Merge pull request #105254 from Ivorforce/no-get-internal-ptr

Delete `VariantGetInternalPtr` and `VariantImplicitConvert`, replace with `VariantInternalAccessor`

core/variant/binder_common.h

@@ -531,27 +531,27 @@ void call_with_ptr_args_static_method(void (*p_method)(P...), const void **p_arg
 
 template <typename T, typename... P>
 void call_with_validated_variant_args(Variant *base, void (T::*p_method)(P...), const Variant **p_args) {
-	call_with_validated_variant_args_helper<T, P...>(VariantGetInternalPtr<T>::get_ptr(base), p_method, p_args, BuildIndexSequence<sizeof...(P)>{});
+	call_with_validated_variant_args_helper<T, P...>(&VariantInternalAccessor<T>::get(base), p_method, p_args, BuildIndexSequence<sizeof...(P)>{});
 }
 
 template <typename T, typename R, typename... P>
 void call_with_validated_variant_args_ret(Variant *base, R (T::*p_method)(P...), const Variant **p_args, Variant *r_ret) {
-	call_with_validated_variant_args_ret_helper<T, R, P...>(VariantGetInternalPtr<T>::get_ptr(base), p_method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
+	call_with_validated_variant_args_ret_helper<T, R, P...>(&VariantInternalAccessor<T>::get(base), p_method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
 }
 
 template <typename T, typename R, typename... P>
 void call_with_validated_variant_args_retc(Variant *base, R (T::*p_method)(P...) const, const Variant **p_args, Variant *r_ret) {
-	call_with_validated_variant_args_retc_helper<T, R, P...>(VariantGetInternalPtr<T>::get_ptr(base), p_method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
+	call_with_validated_variant_args_retc_helper<T, R, P...>(&VariantInternalAccessor<T>::get(base), p_method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
 }
 
 template <typename T, typename... P>
 void call_with_validated_variant_args_static(Variant *base, void (*p_method)(T *, P...), const Variant **p_args) {
-	call_with_validated_variant_args_static_helper<T, P...>(VariantGetInternalPtr<T>::get_ptr(base), p_method, p_args, BuildIndexSequence<sizeof...(P)>{});
+	call_with_validated_variant_args_static_helper<T, P...>(&VariantInternalAccessor<T>::get(base), p_method, p_args, BuildIndexSequence<sizeof...(P)>{});
 }
 
 template <typename T, typename R, typename... P>
 void call_with_validated_variant_args_static_retc(Variant *base, R (*p_method)(T *, P...), const Variant **p_args, Variant *r_ret) {
-	call_with_validated_variant_args_static_retc_helper<T, R, P...>(VariantGetInternalPtr<T>::get_ptr(base), p_method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
+	call_with_validated_variant_args_static_retc_helper<T, R, P...>(&VariantInternalAccessor<T>::get(base), p_method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
 }
 
 template <typename... P>

core/variant/variant.h

@@ -173,6 +173,12 @@ private:
 
 	friend struct _VariantCall;
 	friend class VariantInternal;
+	template <typename>
+	friend struct _VariantInternalAccessorLocal;
+	template <typename>
+	friend struct _VariantInternalAccessorElsewhere;
+	template <typename>
+	friend struct _VariantInternalAccessorPackedArrayRef;
 	// Variant takes 24 bytes when real_t is float, and 40 bytes if double.
 	// It only allocates extra memory for AABB/Transform2D (24, 48 if double),
 	// Basis/Transform3D (48, 96 if double), Projection (64, 128 if double),

core/variant/variant_call.cpp

@@ -54,58 +54,58 @@ static _FORCE_INLINE_ void vc_static_method_call(void (*method)(P...), const Var
 
 template <typename R, typename T, typename... P>
 static _FORCE_INLINE_ void vc_method_call(R (T::*method)(P...), Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
-	call_with_variant_args_ret_dv(VariantGetInternalPtr<T>::get_ptr(base), method, p_args, p_argcount, r_ret, r_error, p_defvals);
+	call_with_variant_args_ret_dv(&VariantInternalAccessor<T>::get(base), method, p_args, p_argcount, r_ret, r_error, p_defvals);
 }
 
 template <typename R, typename T, typename... P>
 static _FORCE_INLINE_ void vc_method_call(R (T::*method)(P...) const, Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
-	call_with_variant_args_retc_dv(VariantGetInternalPtr<T>::get_ptr(base), method, p_args, p_argcount, r_ret, r_error, p_defvals);
+	call_with_variant_args_retc_dv(&VariantInternalAccessor<T>::get(base), method, p_args, p_argcount, r_ret, r_error, p_defvals);
 }
 
 template <typename T, typename... P>
 static _FORCE_INLINE_ void vc_method_call(void (T::*method)(P...), Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
 	VariantInternal::clear(&r_ret);
-	call_with_variant_args_dv(VariantGetInternalPtr<T>::get_ptr(base), method, p_args, p_argcount, r_error, p_defvals);
+	call_with_variant_args_dv(&VariantInternalAccessor<T>::get(base), method, p_args, p_argcount, r_error, p_defvals);
 }
 
 template <typename T, typename... P>
 static _FORCE_INLINE_ void vc_method_call(void (T::*method)(P...) const, Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
 	VariantInternal::clear(&r_ret);
-	call_with_variant_argsc_dv(VariantGetInternalPtr<T>::get_ptr(base), method, p_args, p_argcount, r_error, p_defvals);
+	call_with_variant_argsc_dv(&VariantInternalAccessor<T>::get(base), method, p_args, p_argcount, r_error, p_defvals);
 }
 
 template <typename From, typename R, typename T, typename... P>
 static _FORCE_INLINE_ void vc_convert_method_call(R (T::*method)(P...), Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
-	T converted(static_cast<T>(*VariantGetInternalPtr<From>::get_ptr(base)));
+	T converted(static_cast<T>(VariantInternalAccessor<From>::get(base)));
 	call_with_variant_args_ret_dv(&converted, method, p_args, p_argcount, r_ret, r_error, p_defvals);
 }
 
 template <typename From, typename R, typename T, typename... P>
 static _FORCE_INLINE_ void vc_convert_method_call(R (T::*method)(P...) const, Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
-	T converted(static_cast<T>(*VariantGetInternalPtr<From>::get_ptr(base)));
+	T converted(static_cast<T>(VariantInternalAccessor<From>::get(base)));
 	call_with_variant_args_retc_dv(&converted, method, p_args, p_argcount, r_ret, r_error, p_defvals);
 }
 
 template <typename From, typename T, typename... P>
 static _FORCE_INLINE_ void vc_convert_method_call(void (T::*method)(P...), Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
-	T converted(static_cast<T>(*VariantGetInternalPtr<From>::get_ptr(base)));
+	T converted(static_cast<T>(VariantInternalAccessor<From>::get(base)));
 	call_with_variant_args_dv(&converted, method, p_args, p_argcount, r_error, p_defvals);
 }
 
 template <typename From, typename T, typename... P>
 static _FORCE_INLINE_ void vc_convert_method_call(void (T::*method)(P...) const, Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
-	T converted(static_cast<T>(*VariantGetInternalPtr<From>::get_ptr(base)));
+	T converted(static_cast<T>(VariantInternalAccessor<From>::get(base)));
 	call_with_variant_argsc_dv(&converted, method, p_args, p_argcount, r_error, p_defvals);
 }
 
 template <typename R, typename T, typename... P>
 static _FORCE_INLINE_ void vc_method_call_static(R (*method)(T *, P...), Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
-	call_with_variant_args_retc_static_helper_dv(VariantGetInternalPtr<T>::get_ptr(base), method, p_args, p_argcount, r_ret, p_defvals, r_error);
+	call_with_variant_args_retc_static_helper_dv(&VariantInternalAccessor<T>::get(base), method, p_args, p_argcount, r_ret, p_defvals, r_error);
 }
 
 template <typename T, typename... P>
 static _FORCE_INLINE_ void vc_method_call_static(void (*method)(T *, P...), Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
-	call_with_variant_args_static_helper_dv(VariantGetInternalPtr<T>::get_ptr(base), method, p_args, p_argcount, p_defvals, r_error);
+	call_with_variant_args_static_helper_dv(&VariantInternalAccessor<T>::get(base), method, p_args, p_argcount, p_defvals, r_error);
 }
 
 template <typename R, typename T, typename... P>
@@ -129,24 +129,24 @@ static _FORCE_INLINE_ void vc_validated_call(void (T::*method)(P...) const, Vari
 
 template <typename From, typename R, typename T, typename... P>
 static _FORCE_INLINE_ void vc_convert_validated_call(R (T::*method)(P...), Variant *base, const Variant **p_args, Variant *r_ret) {
-	T converted(static_cast<T>(*VariantGetInternalPtr<From>::get_ptr(base)));
+	T converted(static_cast<T>(VariantInternalAccessor<From>::get(base)));
 	call_with_validated_variant_args_ret_helper<T, R, P...>(&converted, method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
 }
 
 template <typename From, typename R, typename T, typename... P>
 static _FORCE_INLINE_ void vc_convert_validated_call(R (T::*method)(P...) const, Variant *base, const Variant **p_args, Variant *r_ret) {
-	T converted(static_cast<T>(*VariantGetInternalPtr<From>::get_ptr(base)));
+	T converted(static_cast<T>(VariantInternalAccessor<From>::get(base)));
 	call_with_validated_variant_args_retc_helper<T, R, P...>(&converted, method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
 }
 template <typename From, typename T, typename... P>
 static _FORCE_INLINE_ void vc_convert_validated_call(void (T::*method)(P...), Variant *base, const Variant **p_args, Variant *r_ret) {
-	T converted(static_cast<T>(*VariantGetInternalPtr<From>::get_ptr(base)));
+	T converted(static_cast<T>(VariantInternalAccessor<From>::get(base)));
 	call_with_validated_variant_args_helper<T, P...>(&converted, method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
 }
 
 template <typename From, typename T, typename... P>
 static _FORCE_INLINE_ void vc_convert_validated_call(void (T::*method)(P...) const, Variant *base, const Variant **p_args, Variant *r_ret) {
-	T converted(static_cast<T>(*VariantGetInternalPtr<From>::get_ptr(base)));
+	T converted(static_cast<T>(VariantInternalAccessor<From>::get(base)));
 	call_with_validated_variant_argsc_helper<T, P...>(&converted, method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
 }
 
@@ -1168,17 +1168,17 @@ struct _VariantCall {
 	}
 
 	static void func_Callable_call(Variant *v, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) {
-		Callable *callable = VariantGetInternalPtr<Callable>::get_ptr(v);
+		Callable *callable = &VariantInternalAccessor<Callable>::get(v);
 		callable->callp(p_args, p_argcount, r_ret, r_error);
 	}
 
 	static void func_Callable_call_deferred(Variant *v, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) {
-		Callable *callable = VariantGetInternalPtr<Callable>::get_ptr(v);
+		Callable *callable = &VariantInternalAccessor<Callable>::get(v);
 		callable->call_deferredp(p_args, p_argcount);
 	}
 
 	static void func_Callable_rpc(Variant *v, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) {
-		Callable *callable = VariantGetInternalPtr<Callable>::get_ptr(v);
+		Callable *callable = &VariantInternalAccessor<Callable>::get(v);
 		callable->rpcp(0, p_args, p_argcount, r_error);
 	}
 
@@ -1191,13 +1191,13 @@ struct _VariantCall {
 			r_error.argument = 0;
 			r_error.expected = Variant::INT;
 		} else {
-			Callable *callable = VariantGetInternalPtr<Callable>::get_ptr(v);
+			Callable *callable = &VariantInternalAccessor<Callable>::get(v);
 			callable->rpcp(*p_args[0], &p_args[1], p_argcount - 1, r_error);
 		}
 	}
 
 	static void func_Callable_bind(Variant *v, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) {
-		Callable *callable = VariantGetInternalPtr<Callable>::get_ptr(v);
+		Callable *callable = &VariantInternalAccessor<Callable>::get(v);
 		r_ret = callable->bindp(p_args, p_argcount);
 	}
 
@@ -1206,7 +1206,7 @@ struct _VariantCall {
 	}
 
 	static void func_Signal_emit(Variant *v, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) {
-		Signal *signal = VariantGetInternalPtr<Signal>::get_ptr(v);
+		Signal *signal = &VariantInternalAccessor<Signal>::get(v);
 		signal->emit(p_args, p_argcount);
 	}
 

core/variant/variant_construct.cpp

@@ -125,8 +125,8 @@ void Variant::_register_variant_constructors() {
 
 	add_constructor<VariantConstructNoArgs<Transform2D>>(sarray());
 	add_constructor<VariantConstructor<Transform2D, Transform2D>>(sarray("from"));
-	add_constructor<VariantConstructor<Transform2D, float, Vector2>>(sarray("rotation", "position"));
-	add_constructor<VariantConstructor<Transform2D, float, Size2, float, Vector2>>(sarray("rotation", "scale", "skew", "position"));
+	add_constructor<VariantConstructor<Transform2D, double, Vector2>>(sarray("rotation", "position"));
+	add_constructor<VariantConstructor<Transform2D, double, Size2, double, Vector2>>(sarray("rotation", "scale", "skew", "position"));
 	add_constructor<VariantConstructor<Transform2D, Vector2, Vector2, Vector2>>(sarray("x_axis", "y_axis", "origin"));
 
 	add_constructor<VariantConstructNoArgs<Plane>>(sarray());

core/variant/variant_construct.h

@@ -113,7 +113,7 @@ class VariantConstructor {
 
 	template <size_t... Is>
 	static _FORCE_INLINE_ void validated_construct_helper(T &base, const Variant **p_args, IndexSequence<Is...>) {
-		base = T((*VariantGetInternalPtr<P>::get_ptr(p_args[Is]))...);
+		base = T((VariantInternalAccessor<P>::get(p_args[Is]))...);
 	}
 
 	template <size_t... Is>
@@ -125,12 +125,12 @@ public:
 	static void construct(Variant &r_ret, const Variant **p_args, Callable::CallError &r_error) {
 		r_error.error = Callable::CallError::CALL_OK;
 		VariantTypeChanger<T>::change(&r_ret);
-		construct_helper(*VariantGetInternalPtr<T>::get_ptr(&r_ret), p_args, r_error, BuildIndexSequence<sizeof...(P)>{});
+		construct_helper(VariantInternalAccessor<T>::get(&r_ret), p_args, r_error, BuildIndexSequence<sizeof...(P)>{});
 	}
 
 	static inline void validated_construct(Variant *r_ret, const Variant **p_args) {
 		VariantTypeChanger<T>::change(r_ret);
-		validated_construct_helper(*VariantGetInternalPtr<T>::get_ptr(r_ret), p_args, BuildIndexSequence<sizeof...(P)>{});
+		validated_construct_helper(VariantInternalAccessor<T>::get(r_ret), p_args, BuildIndexSequence<sizeof...(P)>{});
 	}
 	static void ptr_construct(void *base, const void **p_args) {
 		ptr_construct_helper(base, p_args, BuildIndexSequence<sizeof...(P)>{});
@@ -249,7 +249,7 @@ public:
 
 	static inline void validated_construct(Variant *r_ret, const Variant **p_args) {
 		VariantTypeChanger<T>::change(r_ret);
-		const String &src_str = *VariantGetInternalPtr<String>::get_ptr(p_args[0]);
+		const String &src_str = VariantInternalAccessor<String>::get(p_args[0]);
 		T ret = Variant();
 		if (r_ret->get_type() == Variant::Type::INT) {
 			ret = src_str.to_int();
@@ -302,9 +302,9 @@ public:
 		}
 
 		if (p_args[1]->get_type() == Variant::STRING_NAME) {
-			method = *VariantGetInternalPtr<StringName>::get_ptr(p_args[1]);
+			method = VariantInternalAccessor<StringName>::get(p_args[1]);
 		} else if (p_args[1]->get_type() == Variant::STRING) {
-			method = *VariantGetInternalPtr<String>::get_ptr(p_args[1]);
+			method = VariantInternalAccessor<String>::get(p_args[1]);
 		} else {
 			r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
 			r_error.argument = 1;
@@ -313,12 +313,12 @@ public:
 		}
 
 		VariantTypeChanger<Callable>::change(&r_ret);
-		*VariantGetInternalPtr<Callable>::get_ptr(&r_ret) = Callable(object_id, method);
+		VariantInternalAccessor<Callable>::get(&r_ret) = Callable(object_id, method);
 	}
 
 	static inline void validated_construct(Variant *r_ret, const Variant **p_args) {
 		VariantTypeChanger<Callable>::change(r_ret);
-		*VariantGetInternalPtr<Callable>::get_ptr(r_ret) = Callable(VariantInternal::get_object_id(p_args[0]), *VariantGetInternalPtr<StringName>::get_ptr(p_args[1]));
+		VariantInternalAccessor<Callable>::get(r_ret) = Callable(VariantInternal::get_object_id(p_args[0]), VariantInternalAccessor<StringName>::get(p_args[1]));
 	}
 	static void ptr_construct(void *base, const void **p_args) {
 		PtrConstruct<Callable>::construct(Callable(PtrToArg<Object *>::convert(p_args[0]), PtrToArg<StringName>::convert(p_args[1])), base);
@@ -359,9 +359,9 @@ public:
 		}
 
 		if (p_args[1]->get_type() == Variant::STRING_NAME) {
-			method = *VariantGetInternalPtr<StringName>::get_ptr(p_args[1]);
+			method = VariantInternalAccessor<StringName>::get(p_args[1]);
 		} else if (p_args[1]->get_type() == Variant::STRING) {
-			method = *VariantGetInternalPtr<String>::get_ptr(p_args[1]);
+			method = VariantInternalAccessor<String>::get(p_args[1]);
 		} else {
 			r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
 			r_error.argument = 1;
@@ -370,12 +370,12 @@ public:
 		}
 
 		VariantTypeChanger<Signal>::change(&r_ret);
-		*VariantGetInternalPtr<Signal>::get_ptr(&r_ret) = Signal(object_id, method);
+		VariantInternalAccessor<Signal>::get(&r_ret) = Signal(object_id, method);
 	}
 
 	static inline void validated_construct(Variant *r_ret, const Variant **p_args) {
 		VariantTypeChanger<Signal>::change(r_ret);
-		*VariantGetInternalPtr<Signal>::get_ptr(r_ret) = Signal(VariantInternal::get_object_id(p_args[0]), *VariantGetInternalPtr<StringName>::get_ptr(p_args[1]));
+		VariantInternalAccessor<Signal>::get(r_ret) = Signal(VariantInternal::get_object_id(p_args[0]), VariantInternalAccessor<StringName>::get(p_args[1]));
 	}
 	static void ptr_construct(void *base, const void **p_args) {
 		PtrConstruct<Signal>::construct(Signal(PtrToArg<Object *>::convert(p_args[0]), PtrToArg<StringName>::convert(p_args[1])), base);
@@ -436,20 +436,20 @@ public:
 			return;
 		}
 
-		const Dictionary &base_dict = *VariantGetInternalPtr<Dictionary>::get_ptr(p_args[0]);
+		const Dictionary &base_dict = VariantInternalAccessor<Dictionary>::get(p_args[0]);
 		const uint32_t key_type = p_args[1]->operator uint32_t();
-		const StringName &key_class_name = *VariantGetInternalPtr<StringName>::get_ptr(p_args[2]);
+		const StringName &key_class_name = VariantInternalAccessor<StringName>::get(p_args[2]);
 		const uint32_t value_type = p_args[4]->operator uint32_t();
-		const StringName &value_class_name = *VariantGetInternalPtr<StringName>::get_ptr(p_args[5]);
+		const StringName &value_class_name = VariantInternalAccessor<StringName>::get(p_args[5]);
 		r_ret = Dictionary(base_dict, key_type, key_class_name, *p_args[3], value_type, value_class_name, *p_args[6]);
 	}
 
 	static inline void validated_construct(Variant *r_ret, const Variant **p_args) {
-		const Dictionary &base_dict = *VariantGetInternalPtr<Dictionary>::get_ptr(p_args[0]);
+		const Dictionary &base_dict = VariantInternalAccessor<Dictionary>::get(p_args[0]);
 		const uint32_t key_type = p_args[1]->operator uint32_t();
-		const StringName &key_class_name = *VariantGetInternalPtr<StringName>::get_ptr(p_args[2]);
+		const StringName &key_class_name = VariantInternalAccessor<StringName>::get(p_args[2]);
 		const uint32_t value_type = p_args[4]->operator uint32_t();
-		const StringName &value_class_name = *VariantGetInternalPtr<StringName>::get_ptr(p_args[5]);
+		const StringName &value_class_name = VariantInternalAccessor<StringName>::get(p_args[5]);
 		*r_ret = Dictionary(base_dict, key_type, key_class_name, *p_args[3], value_type, value_class_name, *p_args[6]);
 	}
 
@@ -528,15 +528,15 @@ public:
 			return;
 		}
 
-		const Array &base_arr = *VariantGetInternalPtr<Array>::get_ptr(p_args[0]);
+		const Array &base_arr = VariantInternalAccessor<Array>::get(p_args[0]);
 		const uint32_t type = p_args[1]->operator uint32_t();
 		r_ret = Array(base_arr, type, *p_args[2], *p_args[3]);
 	}
 
 	static inline void validated_construct(Variant *r_ret, const Variant **p_args) {
-		const Array &base_arr = *VariantGetInternalPtr<Array>::get_ptr(p_args[0]);
+		const Array &base_arr = VariantInternalAccessor<Array>::get(p_args[0]);
 		const uint32_t type = p_args[1]->operator uint32_t();
-		const StringName &class_name = *VariantGetInternalPtr<StringName>::get_ptr(p_args[2]);
+		const StringName &class_name = VariantInternalAccessor<StringName>::get(p_args[2]);
 		*r_ret = Array(base_arr, type, class_name, *p_args[3]);
 	}
 
@@ -591,8 +591,8 @@ public:
 		}
 
 		r_ret = Array();
-		Array &dst_arr = *VariantGetInternalPtr<Array>::get_ptr(&r_ret);
-		const T &src_arr = *VariantGetInternalPtr<T>::get_ptr(p_args[0]);
+		Array &dst_arr = VariantInternalAccessor<Array>::get(&r_ret);
+		const T &src_arr = VariantInternalAccessor<T>::get(p_args[0]);
 
 		int size = src_arr.size();
 		dst_arr.resize(size);
@@ -603,8 +603,8 @@ public:
 
 	static inline void validated_construct(Variant *r_ret, const Variant **p_args) {
 		*r_ret = Array();
-		Array &dst_arr = *VariantGetInternalPtr<Array>::get_ptr(r_ret);
-		const T &src_arr = *VariantGetInternalPtr<T>::get_ptr(p_args[0]);
+		Array &dst_arr = VariantInternalAccessor<Array>::get(r_ret);
+		const T &src_arr = VariantInternalAccessor<T>::get(p_args[0]);
 
 		int size = src_arr.size();
 		dst_arr.resize(size);
@@ -650,8 +650,8 @@ public:
 		}
 
 		VariantTypeChanger<T>::change(&r_ret);
-		const Array &src_arr = *VariantGetInternalPtr<Array>::get_ptr(p_args[0]);
-		T &dst_arr = *VariantGetInternalPtr<T>::get_ptr(&r_ret);
+		const Array &src_arr = VariantInternalAccessor<Array>::get(p_args[0]);
+		T &dst_arr = VariantInternalAccessor<T>::get(&r_ret);
 
 		int size = src_arr.size();
 		dst_arr.resize(size);
@@ -662,8 +662,8 @@ public:
 
 	static inline void validated_construct(Variant *r_ret, const Variant **p_args) {
 		VariantTypeChanger<T>::change(r_ret);
-		const Array &src_arr = *VariantGetInternalPtr<Array>::get_ptr(p_args[0]);
-		T &dst_arr = *VariantGetInternalPtr<T>::get_ptr(r_ret);
+		const Array &src_arr = VariantInternalAccessor<Array>::get(p_args[0]);
+		T &dst_arr = VariantInternalAccessor<T>::get(r_ret);
 
 		int size = src_arr.size();
 		dst_arr.resize(size);

core/variant/variant_internal.h

@@ -30,6 +30,7 @@
 
 #pragma once
 
+#include "type_info.h"
 #include "variant.h"
 
 #include "core/templates/simple_type.h"
@@ -44,6 +45,10 @@ class VariantInternal {
 
 public:
 	// Set type.
+	_FORCE_INLINE_ static void set_type(Variant &v, Variant::Type p_type) {
+		v.type = p_type;
+	}
+
 	_FORCE_INLINE_ static void initialize(Variant *v, Variant::Type p_type) {
 		v->clear();
 		v->type = p_type;
@@ -529,281 +534,35 @@ public:
 	}
 };
 
-template <typename T, typename = void>
-struct VariantGetInternalPtr;
-
-template <typename T>
-struct VariantGetInternalPtr<T, std::enable_if_t<!std::is_same_v<T, GetSimpleTypeT<T>>>> : VariantGetInternalPtr<GetSimpleTypeT<T>> {};
-
-template <>
-struct VariantGetInternalPtr<bool> {
-	static bool *get_ptr(Variant *v) { return VariantInternal::get_bool(v); }
-	static const bool *get_ptr(const Variant *v) { return VariantInternal::get_bool(v); }
-};
-
-template <typename T>
-struct VariantGetInternalPtr<T, std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>>> {
-	static int64_t *get_ptr(Variant *v) { return VariantInternal::get_int(v); }
-	static const int64_t *get_ptr(const Variant *v) { return VariantInternal::get_int(v); }
-};
-
-template <typename T>
-struct VariantGetInternalPtr<BitField<T>, std::enable_if_t<std::is_enum_v<T>>> {
-	static int64_t *get_ptr(Variant *v) { return VariantInternal::get_int(v); }
-	static const int64_t *get_ptr(const Variant *v) { return VariantInternal::get_int(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<ObjectID> {
-	static int64_t *get_ptr(Variant *v) { return VariantInternal::get_int(v); }
-	static const int64_t *get_ptr(const Variant *v) { return VariantInternal::get_int(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<float> {
-	static double *get_ptr(Variant *v) { return VariantInternal::get_float(v); }
-	static const double *get_ptr(const Variant *v) { return VariantInternal::get_float(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<double> {
-	static double *get_ptr(Variant *v) { return VariantInternal::get_float(v); }
-	static const double *get_ptr(const Variant *v) { return VariantInternal::get_float(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<String> {
-	static String *get_ptr(Variant *v) { return VariantInternal::get_string(v); }
-	static const String *get_ptr(const Variant *v) { return VariantInternal::get_string(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<Vector2> {
-	static Vector2 *get_ptr(Variant *v) { return VariantInternal::get_vector2(v); }
-	static const Vector2 *get_ptr(const Variant *v) { return VariantInternal::get_vector2(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<Vector2i> {
-	static Vector2i *get_ptr(Variant *v) { return VariantInternal::get_vector2i(v); }
-	static const Vector2i *get_ptr(const Variant *v) { return VariantInternal::get_vector2i(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<Rect2> {
-	static Rect2 *get_ptr(Variant *v) { return VariantInternal::get_rect2(v); }
-	static const Rect2 *get_ptr(const Variant *v) { return VariantInternal::get_rect2(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<Rect2i> {
-	static Rect2i *get_ptr(Variant *v) { return VariantInternal::get_rect2i(v); }
-	static const Rect2i *get_ptr(const Variant *v) { return VariantInternal::get_rect2i(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<Vector3> {
-	static Vector3 *get_ptr(Variant *v) { return VariantInternal::get_vector3(v); }
-	static const Vector3 *get_ptr(const Variant *v) { return VariantInternal::get_vector3(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<Vector3i> {
-	static Vector3i *get_ptr(Variant *v) { return VariantInternal::get_vector3i(v); }
-	static const Vector3i *get_ptr(const Variant *v) { return VariantInternal::get_vector3i(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<Vector4> {
-	static Vector4 *get_ptr(Variant *v) { return VariantInternal::get_vector4(v); }
-	static const Vector4 *get_ptr(const Variant *v) { return VariantInternal::get_vector4(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<Vector4i> {
-	static Vector4i *get_ptr(Variant *v) { return VariantInternal::get_vector4i(v); }
-	static const Vector4i *get_ptr(const Variant *v) { return VariantInternal::get_vector4i(v); }
-};
-template <>
-struct VariantGetInternalPtr<Transform2D> {
-	static Transform2D *get_ptr(Variant *v) { return VariantInternal::get_transform2d(v); }
-	static const Transform2D *get_ptr(const Variant *v) { return VariantInternal::get_transform2d(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<Transform3D> {
-	static Transform3D *get_ptr(Variant *v) { return VariantInternal::get_transform(v); }
-	static const Transform3D *get_ptr(const Variant *v) { return VariantInternal::get_transform(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<Projection> {
-	static Projection *get_ptr(Variant *v) { return VariantInternal::get_projection(v); }
-	static const Projection *get_ptr(const Variant *v) { return VariantInternal::get_projection(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<Plane> {
-	static Plane *get_ptr(Variant *v) { return VariantInternal::get_plane(v); }
-	static const Plane *get_ptr(const Variant *v) { return VariantInternal::get_plane(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<Quaternion> {
-	static Quaternion *get_ptr(Variant *v) { return VariantInternal::get_quaternion(v); }
-	static const Quaternion *get_ptr(const Variant *v) { return VariantInternal::get_quaternion(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<::AABB> {
-	static ::AABB *get_ptr(Variant *v) { return VariantInternal::get_aabb(v); }
-	static const ::AABB *get_ptr(const Variant *v) { return VariantInternal::get_aabb(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<Basis> {
-	static Basis *get_ptr(Variant *v) { return VariantInternal::get_basis(v); }
-	static const Basis *get_ptr(const Variant *v) { return VariantInternal::get_basis(v); }
-};
-
-//
-
-template <>
-struct VariantGetInternalPtr<Color> {
-	static Color *get_ptr(Variant *v) { return VariantInternal::get_color(v); }
-	static const Color *get_ptr(const Variant *v) { return VariantInternal::get_color(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<StringName> {
-	static StringName *get_ptr(Variant *v) { return VariantInternal::get_string_name(v); }
-	static const StringName *get_ptr(const Variant *v) { return VariantInternal::get_string_name(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<NodePath> {
-	static NodePath *get_ptr(Variant *v) { return VariantInternal::get_node_path(v); }
-	static const NodePath *get_ptr(const Variant *v) { return VariantInternal::get_node_path(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<::RID> {
-	static ::RID *get_ptr(Variant *v) { return VariantInternal::get_rid(v); }
-	static const ::RID *get_ptr(const Variant *v) { return VariantInternal::get_rid(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<Callable> {
-	static Callable *get_ptr(Variant *v) { return VariantInternal::get_callable(v); }
-	static const Callable *get_ptr(const Variant *v) { return VariantInternal::get_callable(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<Signal> {
-	static Signal *get_ptr(Variant *v) { return VariantInternal::get_signal(v); }
-	static const Signal *get_ptr(const Variant *v) { return VariantInternal::get_signal(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<Dictionary> {
-	static Dictionary *get_ptr(Variant *v) { return VariantInternal::get_dictionary(v); }
-	static const Dictionary *get_ptr(const Variant *v) { return VariantInternal::get_dictionary(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<Array> {
-	static Array *get_ptr(Variant *v) { return VariantInternal::get_array(v); }
-	static const Array *get_ptr(const Variant *v) { return VariantInternal::get_array(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<PackedByteArray> {
-	static PackedByteArray *get_ptr(Variant *v) { return VariantInternal::get_byte_array(v); }
-	static const PackedByteArray *get_ptr(const Variant *v) { return VariantInternal::get_byte_array(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<PackedInt32Array> {
-	static PackedInt32Array *get_ptr(Variant *v) { return VariantInternal::get_int32_array(v); }
-	static const PackedInt32Array *get_ptr(const Variant *v) { return VariantInternal::get_int32_array(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<PackedInt64Array> {
-	static PackedInt64Array *get_ptr(Variant *v) { return VariantInternal::get_int64_array(v); }
-	static const PackedInt64Array *get_ptr(const Variant *v) { return VariantInternal::get_int64_array(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<PackedFloat32Array> {
-	static PackedFloat32Array *get_ptr(Variant *v) { return VariantInternal::get_float32_array(v); }
-	static const PackedFloat32Array *get_ptr(const Variant *v) { return VariantInternal::get_float32_array(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<PackedFloat64Array> {
-	static PackedFloat64Array *get_ptr(Variant *v) { return VariantInternal::get_float64_array(v); }
-	static const PackedFloat64Array *get_ptr(const Variant *v) { return VariantInternal::get_float64_array(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<PackedStringArray> {
-	static PackedStringArray *get_ptr(Variant *v) { return VariantInternal::get_string_array(v); }
-	static const PackedStringArray *get_ptr(const Variant *v) { return VariantInternal::get_string_array(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<PackedVector2Array> {
-	static PackedVector2Array *get_ptr(Variant *v) { return VariantInternal::get_vector2_array(v); }
-	static const PackedVector2Array *get_ptr(const Variant *v) { return VariantInternal::get_vector2_array(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<PackedVector3Array> {
-	static PackedVector3Array *get_ptr(Variant *v) { return VariantInternal::get_vector3_array(v); }
-	static const PackedVector3Array *get_ptr(const Variant *v) { return VariantInternal::get_vector3_array(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<PackedColorArray> {
-	static PackedColorArray *get_ptr(Variant *v) { return VariantInternal::get_color_array(v); }
-	static const PackedColorArray *get_ptr(const Variant *v) { return VariantInternal::get_color_array(v); }
-};
-
-template <>
-struct VariantGetInternalPtr<PackedVector4Array> {
-	static PackedVector4Array *get_ptr(Variant *v) { return VariantInternal::get_vector4_array(v); }
-	static const PackedVector4Array *get_ptr(const Variant *v) { return VariantInternal::get_vector4_array(v); }
-};
-
 template <typename T, typename = void>
 struct VariantInternalAccessor;
 
 template <typename T>
 struct VariantInternalAccessor<T, std::enable_if_t<!std::is_same_v<T, GetSimpleTypeT<T>>>> : VariantInternalAccessor<GetSimpleTypeT<T>> {};
 
-template <>
-struct VariantInternalAccessor<bool> {
-	static _FORCE_INLINE_ bool get(const Variant *v) { return *VariantInternal::get_bool(v); }
-	static _FORCE_INLINE_ void set(Variant *v, bool p_value) { *VariantInternal::get_bool(v) = p_value; }
-};
-
 template <typename T>
-struct VariantInternalAccessor<T, std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>>> {
-	static _FORCE_INLINE_ T get(const Variant *v) { return static_cast<T>(*VariantInternal::get_int(v)); }
-	static _FORCE_INLINE_ void set(Variant *v, T p_value) { *VariantInternal::get_int(v) = static_cast<int64_t>(p_value); }
+struct _VariantInternalAccessorLocal {
+	using declared_when_native_type = void;
+	static constexpr bool is_local = true;
+	static _FORCE_INLINE_ T &get(Variant *v) { return *reinterpret_cast<T *>(v->_data._mem); }
+	static _FORCE_INLINE_ const T &get(const Variant *v) { return *reinterpret_cast<const T *>(v->_data._mem); }
+	static _FORCE_INLINE_ void set(Variant *v, T p_value) { *reinterpret_cast<T *>(v->_data._mem) = std::move(p_value); }
 };
 
 template <typename T>
-struct VariantInternalAccessor<BitField<T>, std::enable_if_t<std::is_enum_v<T>>> {
-	static _FORCE_INLINE_ BitField<T> get(const Variant *v) { return BitField<T>(static_cast<T>(*VariantInternal::get_int(v))); }
-	static _FORCE_INLINE_ void set(Variant *v, BitField<T> p_value) { *VariantInternal::get_int(v) = static_cast<int64_t>(p_value); }
+struct _VariantInternalAccessorElsewhere {
+	using declared_when_native_type = void;
+	static _FORCE_INLINE_ T &get(Variant *v) { return *reinterpret_cast<T *>(v->_data._ptr); }
+	static _FORCE_INLINE_ const T &get(const Variant *v) { return *reinterpret_cast<const T *>(v->_data._ptr); }
+	static _FORCE_INLINE_ void set(Variant *v, T p_value) { *reinterpret_cast<T *>(v->_data._ptr) = std::move(p_value); }
 };
 
-template <>
-struct VariantInternalAccessor<ObjectID> {
-	static _FORCE_INLINE_ ObjectID get(const Variant *v) { return ObjectID(*VariantInternal::get_int(v)); }
-	static _FORCE_INLINE_ void set(Variant *v, ObjectID p_value) { *VariantInternal::get_int(v) = p_value; }
+template <typename T>
+struct _VariantInternalAccessorPackedArrayRef {
+	using declared_when_native_type = void;
+	static _FORCE_INLINE_ Vector<T> &get(Variant *v) { return static_cast<Variant::PackedArrayRef<T> *>(v->_data.packed_array)->array; }
+	static _FORCE_INLINE_ const Vector<T> &get(const Variant *v) { return static_cast<const Variant::PackedArrayRef<T> *>(v->_data.packed_array)->array; }
+	static _FORCE_INLINE_ void set(Variant *v, Vector<T> p_value) { static_cast<Variant::PackedArrayRef<T> *>(v->_data.packed_array)->array = std::move(p_value); }
 };
 
 template <typename T>
@@ -825,262 +584,198 @@ struct VariantInternalAccessor<IPAddress> {
 };
 
 template <>
-struct VariantInternalAccessor<float> {
-	static _FORCE_INLINE_ float get(const Variant *v) { return *VariantInternal::get_float(v); }
-	static _FORCE_INLINE_ void set(Variant *v, float p_value) { *VariantInternal::get_float(v) = p_value; }
+struct VariantInternalAccessor<Object *> {
+	static _FORCE_INLINE_ Object *get(const Variant *v) { return const_cast<Object *>(*VariantInternal::get_object(v)); }
+	static _FORCE_INLINE_ void set(Variant *v, const Object *p_value) { VariantInternal::object_assign(v, p_value); }
 };
 
 template <>
-struct VariantInternalAccessor<double> {
-	static _FORCE_INLINE_ double get(const Variant *v) { return *VariantInternal::get_float(v); }
-	static _FORCE_INLINE_ void set(Variant *v, double p_value) { *VariantInternal::get_float(v) = p_value; }
+struct VariantInternalAccessor<Variant> {
+	static _FORCE_INLINE_ Variant &get(Variant *v) { return *v; }
+	static _FORCE_INLINE_ const Variant &get(const Variant *v) { return *v; }
+	static _FORCE_INLINE_ void set(Variant *v, const Variant &p_value) { *v = p_value; }
 };
 
 template <>
-struct VariantInternalAccessor<String> {
-	static _FORCE_INLINE_ const String &get(const Variant *v) { return *VariantInternal::get_string(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const String &p_value) { *VariantInternal::get_string(v) = p_value; }
+struct VariantInternalAccessor<Vector<Variant>> {
+	static _FORCE_INLINE_ Vector<Variant> get(const Variant *v) {
+		Vector<Variant> ret;
+		int s = VariantInternal::get_array(v)->size();
+		ret.resize(s);
+		for (int i = 0; i < s; i++) {
+			ret.write[i] = VariantInternal::get_array(v)->get(i);
+		}
+
+		return ret;
+	}
+	static _FORCE_INLINE_ void set(Variant *v, const Vector<Variant> &p_value) {
+		int s = p_value.size();
+		VariantInternal::get_array(v)->resize(s);
+		for (int i = 0; i < s; i++) {
+			VariantInternal::get_array(v)->set(i, p_value[i]);
+		}
+	}
 };
 
 template <>
-struct VariantInternalAccessor<Vector2> {
-	static _FORCE_INLINE_ const Vector2 &get(const Variant *v) { return *VariantInternal::get_vector2(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const Vector2 &p_value) { *VariantInternal::get_vector2(v) = p_value; }
-};
+struct VariantInternalAccessor<bool> : _VariantInternalAccessorLocal<bool> {};
 
 template <>
-struct VariantInternalAccessor<Vector2i> {
-	static _FORCE_INLINE_ const Vector2i &get(const Variant *v) { return *VariantInternal::get_vector2i(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const Vector2i &p_value) { *VariantInternal::get_vector2i(v) = p_value; }
-};
+struct VariantInternalAccessor<int64_t> : _VariantInternalAccessorLocal<int64_t> {};
 
 template <>
-struct VariantInternalAccessor<Rect2> {
-	static _FORCE_INLINE_ const Rect2 &get(const Variant *v) { return *VariantInternal::get_rect2(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const Rect2 &p_value) { *VariantInternal::get_rect2(v) = p_value; }
-};
+struct VariantInternalAccessor<double> : _VariantInternalAccessorLocal<double> {};
 
 template <>
-struct VariantInternalAccessor<Rect2i> {
-	static _FORCE_INLINE_ const Rect2i &get(const Variant *v) { return *VariantInternal::get_rect2i(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const Rect2i &p_value) { *VariantInternal::get_rect2i(v) = p_value; }
-};
+struct VariantInternalAccessor<String> : _VariantInternalAccessorLocal<String> {};
 
 template <>
-struct VariantInternalAccessor<Vector3> {
-	static _FORCE_INLINE_ const Vector3 &get(const Variant *v) { return *VariantInternal::get_vector3(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const Vector3 &p_value) { *VariantInternal::get_vector3(v) = p_value; }
-};
+struct VariantInternalAccessor<Vector2> : _VariantInternalAccessorLocal<Vector2> {};
 
 template <>
-struct VariantInternalAccessor<Vector3i> {
-	static _FORCE_INLINE_ const Vector3i &get(const Variant *v) { return *VariantInternal::get_vector3i(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const Vector3i &p_value) { *VariantInternal::get_vector3i(v) = p_value; }
-};
+struct VariantInternalAccessor<Vector2i> : _VariantInternalAccessorLocal<Vector2i> {};
 
 template <>
-struct VariantInternalAccessor<Vector4> {
-	static _FORCE_INLINE_ const Vector4 &get(const Variant *v) { return *VariantInternal::get_vector4(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const Vector4 &p_value) { *VariantInternal::get_vector4(v) = p_value; }
-};
+struct VariantInternalAccessor<Rect2> : _VariantInternalAccessorLocal<Rect2> {};
 
 template <>
-struct VariantInternalAccessor<Vector4i> {
-	static _FORCE_INLINE_ const Vector4i &get(const Variant *v) { return *VariantInternal::get_vector4i(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const Vector4i &p_value) { *VariantInternal::get_vector4i(v) = p_value; }
-};
+struct VariantInternalAccessor<Rect2i> : _VariantInternalAccessorLocal<Rect2i> {};
+
 template <>
-struct VariantInternalAccessor<Transform2D> {
-	static _FORCE_INLINE_ const Transform2D &get(const Variant *v) { return *VariantInternal::get_transform2d(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const Transform2D &p_value) { *VariantInternal::get_transform2d(v) = p_value; }
-};
+struct VariantInternalAccessor<Vector3> : _VariantInternalAccessorLocal<Vector3> {};
 
 template <>
-struct VariantInternalAccessor<Transform3D> {
-	static _FORCE_INLINE_ const Transform3D &get(const Variant *v) { return *VariantInternal::get_transform(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const Transform3D &p_value) { *VariantInternal::get_transform(v) = p_value; }
-};
+struct VariantInternalAccessor<Vector3i> : _VariantInternalAccessorLocal<Vector3i> {};
 
 template <>
-struct VariantInternalAccessor<Projection> {
-	static _FORCE_INLINE_ const Projection &get(const Variant *v) { return *VariantInternal::get_projection(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const Projection &p_value) { *VariantInternal::get_projection(v) = p_value; }
-};
+struct VariantInternalAccessor<Vector4> : _VariantInternalAccessorLocal<Vector4> {};
 
 template <>
-struct VariantInternalAccessor<Plane> {
-	static _FORCE_INLINE_ const Plane &get(const Variant *v) { return *VariantInternal::get_plane(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const Plane &p_value) { *VariantInternal::get_plane(v) = p_value; }
-};
+struct VariantInternalAccessor<Vector4i> : _VariantInternalAccessorLocal<Vector4i> {};
 
 template <>
-struct VariantInternalAccessor<Quaternion> {
-	static _FORCE_INLINE_ const Quaternion &get(const Variant *v) { return *VariantInternal::get_quaternion(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const Quaternion &p_value) { *VariantInternal::get_quaternion(v) = p_value; }
-};
+struct VariantInternalAccessor<Transform2D> : _VariantInternalAccessorElsewhere<Transform2D> {};
 
 template <>
-struct VariantInternalAccessor<AABB> {
-	static _FORCE_INLINE_ const AABB &get(const Variant *v) { return *VariantInternal::get_aabb(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const AABB &p_value) { *VariantInternal::get_aabb(v) = p_value; }
-};
+struct VariantInternalAccessor<Transform3D> : _VariantInternalAccessorElsewhere<Transform3D> {};
 
 template <>
-struct VariantInternalAccessor<Basis> {
-	static _FORCE_INLINE_ const Basis &get(const Variant *v) { return *VariantInternal::get_basis(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const Basis &p_value) { *VariantInternal::get_basis(v) = p_value; }
-};
+struct VariantInternalAccessor<Projection> : _VariantInternalAccessorElsewhere<Projection> {};
 
 template <>
-struct VariantInternalAccessor<Color> {
-	static _FORCE_INLINE_ const Color &get(const Variant *v) { return *VariantInternal::get_color(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const Color &p_value) { *VariantInternal::get_color(v) = p_value; }
-};
+struct VariantInternalAccessor<Plane> : _VariantInternalAccessorLocal<Plane> {};
 
 template <>
-struct VariantInternalAccessor<StringName> {
-	static _FORCE_INLINE_ const StringName &get(const Variant *v) { return *VariantInternal::get_string_name(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const StringName &p_value) { *VariantInternal::get_string_name(v) = p_value; }
-};
+struct VariantInternalAccessor<Quaternion> : _VariantInternalAccessorLocal<Quaternion> {};
 
 template <>
-struct VariantInternalAccessor<NodePath> {
-	static _FORCE_INLINE_ const NodePath &get(const Variant *v) { return *VariantInternal::get_node_path(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const NodePath &p_value) { *VariantInternal::get_node_path(v) = p_value; }
-};
+struct VariantInternalAccessor<::AABB> : _VariantInternalAccessorElsewhere<::AABB> {};
 
 template <>
-struct VariantInternalAccessor<::RID> {
-	static _FORCE_INLINE_ const ::RID &get(const Variant *v) { return *VariantInternal::get_rid(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const ::RID &p_value) { *VariantInternal::get_rid(v) = p_value; }
-};
+struct VariantInternalAccessor<Basis> : _VariantInternalAccessorElsewhere<Basis> {};
 
 template <>
-struct VariantInternalAccessor<Callable> {
-	static _FORCE_INLINE_ const Callable &get(const Variant *v) { return *VariantInternal::get_callable(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const Callable &p_value) { *VariantInternal::get_callable(v) = p_value; }
-};
+struct VariantInternalAccessor<Color> : _VariantInternalAccessorLocal<Color> {};
 
 template <>
-struct VariantInternalAccessor<Signal> {
-	static _FORCE_INLINE_ const Signal &get(const Variant *v) { return *VariantInternal::get_signal(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const Signal &p_value) { *VariantInternal::get_signal(v) = p_value; }
-};
+struct VariantInternalAccessor<StringName> : _VariantInternalAccessorLocal<StringName> {};
 
 template <>
-struct VariantInternalAccessor<Dictionary> {
-	static _FORCE_INLINE_ const Dictionary &get(const Variant *v) { return *VariantInternal::get_dictionary(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const Dictionary &p_value) { *VariantInternal::get_dictionary(v) = p_value; }
-};
+struct VariantInternalAccessor<NodePath> : _VariantInternalAccessorLocal<NodePath> {};
 
 template <>
-struct VariantInternalAccessor<Array> {
-	static _FORCE_INLINE_ const Array &get(const Variant *v) { return *VariantInternal::get_array(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const Array &p_value) { *VariantInternal::get_array(v) = p_value; }
-};
+struct VariantInternalAccessor<::RID> : _VariantInternalAccessorLocal<::RID> {};
+
+// template <>
+// struct VariantInternalAccessor<Variant::ObjData> : _VariantInternalAccessorLocal<Variant::ObjData> {};
 
 template <>
-struct VariantInternalAccessor<PackedByteArray> {
-	static _FORCE_INLINE_ const PackedByteArray &get(const Variant *v) { return *VariantInternal::get_byte_array(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const PackedByteArray &p_value) { *VariantInternal::get_byte_array(v) = p_value; }
-};
+struct VariantInternalAccessor<Callable> : _VariantInternalAccessorLocal<Callable> {};
 
 template <>
-struct VariantInternalAccessor<PackedInt32Array> {
-	static _FORCE_INLINE_ const PackedInt32Array &get(const Variant *v) { return *VariantInternal::get_int32_array(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const PackedInt32Array &p_value) { *VariantInternal::get_int32_array(v) = p_value; }
-};
+struct VariantInternalAccessor<Signal> : _VariantInternalAccessorLocal<Signal> {};
 
 template <>
-struct VariantInternalAccessor<PackedInt64Array> {
-	static _FORCE_INLINE_ const PackedInt64Array &get(const Variant *v) { return *VariantInternal::get_int64_array(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const PackedInt64Array &p_value) { *VariantInternal::get_int64_array(v) = p_value; }
-};
+struct VariantInternalAccessor<Dictionary> : _VariantInternalAccessorLocal<Dictionary> {};
 
 template <>
-struct VariantInternalAccessor<PackedFloat32Array> {
-	static _FORCE_INLINE_ const PackedFloat32Array &get(const Variant *v) { return *VariantInternal::get_float32_array(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const PackedFloat32Array &p_value) { *VariantInternal::get_float32_array(v) = p_value; }
-};
+struct VariantInternalAccessor<Array> : _VariantInternalAccessorLocal<Array> {};
 
 template <>
-struct VariantInternalAccessor<PackedFloat64Array> {
-	static _FORCE_INLINE_ const PackedFloat64Array &get(const Variant *v) { return *VariantInternal::get_float64_array(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const PackedFloat64Array &p_value) { *VariantInternal::get_float64_array(v) = p_value; }
-};
+struct VariantInternalAccessor<PackedByteArray> : _VariantInternalAccessorPackedArrayRef<uint8_t> {};
 
 template <>
-struct VariantInternalAccessor<PackedStringArray> {
-	static _FORCE_INLINE_ const PackedStringArray &get(const Variant *v) { return *VariantInternal::get_string_array(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const PackedStringArray &p_value) { *VariantInternal::get_string_array(v) = p_value; }
-};
+struct VariantInternalAccessor<PackedInt32Array> : _VariantInternalAccessorPackedArrayRef<int32_t> {};
 
 template <>
-struct VariantInternalAccessor<PackedVector2Array> {
-	static _FORCE_INLINE_ const PackedVector2Array &get(const Variant *v) { return *VariantInternal::get_vector2_array(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const PackedVector2Array &p_value) { *VariantInternal::get_vector2_array(v) = p_value; }
-};
+struct VariantInternalAccessor<PackedInt64Array> : _VariantInternalAccessorPackedArrayRef<int64_t> {};
 
 template <>
-struct VariantInternalAccessor<PackedVector3Array> {
-	static _FORCE_INLINE_ const PackedVector3Array &get(const Variant *v) { return *VariantInternal::get_vector3_array(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const PackedVector3Array &p_value) { *VariantInternal::get_vector3_array(v) = p_value; }
-};
+struct VariantInternalAccessor<PackedFloat32Array> : _VariantInternalAccessorPackedArrayRef<float> {};
 
 template <>
-struct VariantInternalAccessor<PackedColorArray> {
-	static _FORCE_INLINE_ const PackedColorArray &get(const Variant *v) { return *VariantInternal::get_color_array(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const PackedColorArray &p_value) { *VariantInternal::get_color_array(v) = p_value; }
-};
+struct VariantInternalAccessor<PackedFloat64Array> : _VariantInternalAccessorPackedArrayRef<double> {};
 
 template <>
-struct VariantInternalAccessor<PackedVector4Array> {
-	static _FORCE_INLINE_ const PackedVector4Array &get(const Variant *v) { return *VariantInternal::get_vector4_array(v); }
-	static _FORCE_INLINE_ void set(Variant *v, const PackedVector4Array &p_value) { *VariantInternal::get_vector4_array(v) = p_value; }
-};
+struct VariantInternalAccessor<PackedStringArray> : _VariantInternalAccessorPackedArrayRef<String> {};
 
 template <>
-struct VariantInternalAccessor<Object *> {
-	static _FORCE_INLINE_ Object *get(const Variant *v) { return const_cast<Object *>(*VariantInternal::get_object(v)); }
-	static _FORCE_INLINE_ void set(Variant *v, const Object *p_value) { VariantInternal::object_assign(v, p_value); }
-};
+struct VariantInternalAccessor<PackedVector2Array> : _VariantInternalAccessorPackedArrayRef<Vector2> {};
 
 template <>
-struct VariantInternalAccessor<Variant> {
-	static _FORCE_INLINE_ Variant &get(Variant *v) { return *v; }
-	static _FORCE_INLINE_ const Variant &get(const Variant *v) { return *v; }
-	static _FORCE_INLINE_ void set(Variant *v, const Variant &p_value) { *v = p_value; }
-};
+struct VariantInternalAccessor<PackedVector3Array> : _VariantInternalAccessorPackedArrayRef<Vector3> {};
 
 template <>
-struct VariantInternalAccessor<Vector<Variant>> {
-	static _FORCE_INLINE_ Vector<Variant> get(const Variant *v) {
-		Vector<Variant> ret;
-		int s = VariantInternal::get_array(v)->size();
-		ret.resize(s);
-		for (int i = 0; i < s; i++) {
-			ret.write[i] = VariantInternal::get_array(v)->get(i);
-		}
+struct VariantInternalAccessor<PackedColorArray> : _VariantInternalAccessorPackedArrayRef<Color> {};
 
-		return ret;
+template <>
+struct VariantInternalAccessor<PackedVector4Array> : _VariantInternalAccessorPackedArrayRef<Vector4> {};
+
+template <typename T, typename = std::void_t<>>
+struct IsVariantType : std::false_type {};
+
+template <typename T>
+struct IsVariantType<T, std::void_t<typename VariantInternalAccessor<T>::declared_when_native_type>> : std::true_type {};
+
+template <typename T>
+constexpr bool IsVariantTypeT = IsVariantType<T>::value;
+
+template <typename T, typename S>
+struct _VariantInternalAccessorConvert {
+	static _FORCE_INLINE_ T get(const Variant *v) {
+		return T(VariantInternalAccessor<S>::get(v));
 	}
-	static _FORCE_INLINE_ void set(Variant *v, const Vector<Variant> &p_value) {
-		int s = p_value.size();
-		VariantInternal::get_array(v)->resize(s);
-		for (int i = 0; i < s; i++) {
-			VariantInternal::get_array(v)->set(i, p_value[i]);
-		}
+	static _FORCE_INLINE_ void set(Variant *v, const T p_value) {
+		VariantInternalAccessor<S>::get(v) = S(std::move(p_value));
 	}
 };
 
+// Integer types.
 template <typename T>
+struct VariantInternalAccessor<T, std::enable_if_t<std::is_integral_v<T> && !std::is_same_v<T, bool> && !std::is_same_v<T, int64_t>>> : _VariantInternalAccessorConvert<T, int64_t> {};
+template <typename T>
+struct VariantInternalAccessor<T, std::enable_if_t<std::is_enum_v<T>>> : _VariantInternalAccessorConvert<T, int64_t> {};
+template <typename T>
+struct VariantInternalAccessor<BitField<T>, std::enable_if_t<std::is_enum_v<T>>> : _VariantInternalAccessorConvert<BitField<T>, int64_t> {};
+
+template <>
+struct VariantInternalAccessor<ObjectID> : _VariantInternalAccessorConvert<ObjectID, int64_t> {};
+
+// Float types.
+template <>
+struct VariantInternalAccessor<float> : _VariantInternalAccessorConvert<float, double> {};
+
+template <typename T, typename = void>
 struct VariantInitializer {
 	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_generic<T>(v); }
 };
 
-template <>
-struct VariantInitializer<String> {
-	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_string(v); }
+template <typename T>
+struct VariantInitializer<T, std::enable_if_t<VariantInternalAccessor<T>::is_local>> {
+	static _FORCE_INLINE_ void init(Variant *v) {
+		memnew_placement(&VariantInternalAccessor<T>::get(v), T);
+		VariantInternal::set_type(*v, GetTypeInfo<T>::VARIANT_TYPE);
+	}
 };
 
 template <>
@@ -1108,36 +803,6 @@ struct VariantInitializer<Projection> {
 	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_projection(v); }
 };
 
-template <>
-struct VariantInitializer<StringName> {
-	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_string_name(v); }
-};
-
-template <>
-struct VariantInitializer<NodePath> {
-	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_node_path(v); }
-};
-
-template <>
-struct VariantInitializer<Callable> {
-	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_callable(v); }
-};
-
-template <>
-struct VariantInitializer<Signal> {
-	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_signal(v); }
-};
-
-template <>
-struct VariantInitializer<Dictionary> {
-	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_dictionary(v); }
-};
-
-template <>
-struct VariantInitializer<Array> {
-	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_array(v); }
-};
-
 template <>
 struct VariantInitializer<PackedByteArray> {
 	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_byte_array(v); }
@@ -1193,205 +858,15 @@ struct VariantInitializer<Object *> {
 	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_object(v); }
 };
 
+/// Note: This struct assumes that the argument type is already of the correct type.
 template <typename T, typename = void>
 struct VariantDefaultInitializer;
 
 template <typename T>
-struct VariantDefaultInitializer<T, std::enable_if_t<!std::is_same_v<T, GetSimpleTypeT<T>>>> : VariantDefaultInitializer<GetSimpleTypeT<T>> {};
-
-template <>
-struct VariantDefaultInitializer<bool> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_bool(v) = false; }
-};
-
-template <typename T>
-struct VariantDefaultInitializer<T, std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>>> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_int(v) = 0; }
-};
-
-template <typename T>
-struct VariantDefaultInitializer<BitField<T>, std::enable_if_t<std::is_enum_v<T>>> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_int(v) = 0; }
-};
-
-template <>
-struct VariantDefaultInitializer<double> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_float(v) = 0.0; }
-};
-
-template <>
-struct VariantDefaultInitializer<float> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_float(v) = 0.0; }
-};
-
-template <>
-struct VariantDefaultInitializer<String> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_string(v) = String(); }
-};
-
-template <>
-struct VariantDefaultInitializer<Vector2> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_vector2(v) = Vector2(); }
-};
-
-template <>
-struct VariantDefaultInitializer<Vector2i> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_vector2i(v) = Vector2i(); }
-};
-
-template <>
-struct VariantDefaultInitializer<Rect2> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_rect2(v) = Rect2(); }
-};
-
-template <>
-struct VariantDefaultInitializer<Rect2i> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_rect2i(v) = Rect2i(); }
-};
-
-template <>
-struct VariantDefaultInitializer<Vector3> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_vector3(v) = Vector3(); }
-};
-
-template <>
-struct VariantDefaultInitializer<Vector3i> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_vector3i(v) = Vector3i(); }
-};
-
-template <>
-struct VariantDefaultInitializer<Vector4> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_vector4(v) = Vector4(); }
-};
-
-template <>
-struct VariantDefaultInitializer<Vector4i> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_vector4i(v) = Vector4i(); }
-};
-
-template <>
-struct VariantDefaultInitializer<Transform2D> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_transform2d(v) = Transform2D(); }
-};
-
-template <>
-struct VariantDefaultInitializer<Plane> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_plane(v) = Plane(); }
-};
-
-template <>
-struct VariantDefaultInitializer<Quaternion> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_quaternion(v) = Quaternion(); }
-};
-
-template <>
-struct VariantDefaultInitializer<AABB> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_aabb(v) = AABB(); }
-};
-
-template <>
-struct VariantDefaultInitializer<Basis> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_basis(v) = Basis(); }
-};
-
-template <>
-struct VariantDefaultInitializer<Transform3D> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_transform(v) = Transform3D(); }
-};
-
-template <>
-struct VariantDefaultInitializer<Projection> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_projection(v) = Projection(); }
-};
-
-template <>
-struct VariantDefaultInitializer<Color> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_color(v) = Color(); }
-};
-
-template <>
-struct VariantDefaultInitializer<StringName> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_string_name(v) = StringName(); }
-};
-
-template <>
-struct VariantDefaultInitializer<NodePath> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_node_path(v) = NodePath(); }
-};
-
-template <>
-struct VariantDefaultInitializer<::RID> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_rid(v) = RID(); }
-};
-
-template <>
-struct VariantDefaultInitializer<Callable> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_callable(v) = Callable(); }
-};
-
-template <>
-struct VariantDefaultInitializer<Signal> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_signal(v) = Signal(); }
-};
-
-template <>
-struct VariantDefaultInitializer<Dictionary> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_dictionary(v) = Dictionary(); }
-};
-
-template <>
-struct VariantDefaultInitializer<Array> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_array(v) = Array(); }
-};
-
-template <>
-struct VariantDefaultInitializer<PackedByteArray> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_byte_array(v) = PackedByteArray(); }
-};
-
-template <>
-struct VariantDefaultInitializer<PackedInt32Array> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_int32_array(v) = PackedInt32Array(); }
-};
-
-template <>
-struct VariantDefaultInitializer<PackedInt64Array> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_int64_array(v) = PackedInt64Array(); }
-};
-
-template <>
-struct VariantDefaultInitializer<PackedFloat32Array> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_float32_array(v) = PackedFloat32Array(); }
-};
-
-template <>
-struct VariantDefaultInitializer<PackedFloat64Array> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_float64_array(v) = PackedFloat64Array(); }
-};
-
-template <>
-struct VariantDefaultInitializer<PackedStringArray> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_string_array(v) = PackedStringArray(); }
-};
-
-template <>
-struct VariantDefaultInitializer<PackedVector2Array> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_vector2_array(v) = PackedVector2Array(); }
-};
-
-template <>
-struct VariantDefaultInitializer<PackedVector3Array> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_vector3_array(v) = PackedVector3Array(); }
-};
-
-template <>
-struct VariantDefaultInitializer<PackedColorArray> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_color_array(v) = PackedColorArray(); }
-};
-
-template <>
-struct VariantDefaultInitializer<PackedVector4Array> {
-	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_vector4_array(v) = PackedVector4Array(); }
+struct VariantDefaultInitializer<T, std::enable_if_t<IsVariantTypeT<T>>> {
+	static _FORCE_INLINE_ void init(Variant *v) {
+		VariantInternalAccessor<T>::get(v) = T();
+	}
 };
 
 template <typename T>

core/variant/variant_op.cpp

@@ -51,13 +51,13 @@ template <>
 class OperatorEvaluatorMul<Vector2, Vector2i, double> {
 public:
 	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
-		const Vector2i &a = *VariantGetInternalPtr<Vector2i>::get_ptr(&p_left);
-		const double &b = *VariantGetInternalPtr<double>::get_ptr(&p_right);
+		const Vector2i &a = VariantInternalAccessor<Vector2i>::get(&p_left);
+		const double &b = VariantInternalAccessor<double>::get(&p_right);
 		*r_ret = Vector2(a.x, a.y) * b;
 		r_valid = true;
 	}
 	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
-		*VariantGetInternalPtr<Vector2>::get_ptr(r_ret) = Vector2(VariantGetInternalPtr<Vector2i>::get_ptr(left)->x, VariantGetInternalPtr<Vector2i>::get_ptr(left)->y) * *VariantGetInternalPtr<double>::get_ptr(right);
+		VariantInternalAccessor<Vector2>::get(r_ret) = Vector2(VariantInternalAccessor<Vector2i>::get(left).x, VariantInternalAccessor<Vector2i>::get(left).y) * VariantInternalAccessor<double>::get(right);
 	}
 	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
 		PtrToArg<Vector2>::encode(Vector2(PtrToArg<Vector2i>::convert(left).x, PtrToArg<Vector2i>::convert(left).y) * PtrToArg<double>::convert(right), r_ret);
@@ -69,13 +69,13 @@ template <>
 class OperatorEvaluatorMul<Vector2, double, Vector2i> {
 public:
 	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
-		const Vector2i &a = *VariantGetInternalPtr<Vector2i>::get_ptr(&p_right);
-		const double &b = *VariantGetInternalPtr<double>::get_ptr(&p_left);
+		const Vector2i &a = VariantInternalAccessor<Vector2i>::get(&p_right);
+		const double &b = VariantInternalAccessor<double>::get(&p_left);
 		*r_ret = Vector2(a.x, a.y) * b;
 		r_valid = true;
 	}
 	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
-		*VariantGetInternalPtr<Vector2>::get_ptr(r_ret) = Vector2(VariantGetInternalPtr<Vector2i>::get_ptr(right)->x, VariantGetInternalPtr<Vector2i>::get_ptr(right)->y) * *VariantGetInternalPtr<double>::get_ptr(left);
+		VariantInternalAccessor<Vector2>::get(r_ret) = Vector2(VariantInternalAccessor<Vector2i>::get(right).x, VariantInternalAccessor<Vector2i>::get(right).y) * VariantInternalAccessor<double>::get(left);
 	}
 	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
 		PtrToArg<Vector2>::encode(Vector2(PtrToArg<Vector2i>::convert(right).x, PtrToArg<Vector2i>::convert(right).y) * PtrToArg<double>::convert(left), r_ret);
@@ -87,8 +87,8 @@ template <>
 class OperatorEvaluatorDivNZ<Vector2, Vector2i, double> {
 public:
 	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
-		const Vector2i &a = *VariantGetInternalPtr<Vector2i>::get_ptr(&p_left);
-		const double &b = *VariantGetInternalPtr<double>::get_ptr(&p_right);
+		const Vector2i &a = VariantInternalAccessor<Vector2i>::get(&p_left);
+		const double &b = VariantInternalAccessor<double>::get(&p_right);
 		if (unlikely(b == 0)) {
 			r_valid = false;
 			*r_ret = "Division by zero error";
@@ -98,7 +98,7 @@ public:
 		r_valid = true;
 	}
 	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
-		*VariantGetInternalPtr<Vector2>::get_ptr(r_ret) = Vector2(VariantGetInternalPtr<Vector2i>::get_ptr(left)->x, VariantGetInternalPtr<Vector2i>::get_ptr(left)->y) / *VariantGetInternalPtr<double>::get_ptr(right);
+		VariantInternalAccessor<Vector2>::get(r_ret) = Vector2(VariantInternalAccessor<Vector2i>::get(left).x, VariantInternalAccessor<Vector2i>::get(left).y) / VariantInternalAccessor<double>::get(right);
 	}
 	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
 		PtrToArg<Vector2>::encode(Vector2(PtrToArg<Vector2i>::convert(left).x, PtrToArg<Vector2i>::convert(left).y) / PtrToArg<double>::convert(right), r_ret);
@@ -110,13 +110,13 @@ template <>
 class OperatorEvaluatorMul<Vector3, Vector3i, double> {
 public:
 	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
-		const Vector3i &a = *VariantGetInternalPtr<Vector3i>::get_ptr(&p_left);
-		const double &b = *VariantGetInternalPtr<double>::get_ptr(&p_right);
+		const Vector3i &a = VariantInternalAccessor<Vector3i>::get(&p_left);
+		const double &b = VariantInternalAccessor<double>::get(&p_right);
 		*r_ret = Vector3(a.x, a.y, a.z) * b;
 		r_valid = true;
 	}
 	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
-		*VariantGetInternalPtr<Vector3>::get_ptr(r_ret) = Vector3(VariantGetInternalPtr<Vector3i>::get_ptr(left)->x, VariantGetInternalPtr<Vector3i>::get_ptr(left)->y, VariantGetInternalPtr<Vector3i>::get_ptr(left)->z) * *VariantGetInternalPtr<double>::get_ptr(right);
+		VariantInternalAccessor<Vector3>::get(r_ret) = Vector3(VariantInternalAccessor<Vector3i>::get(left).x, VariantInternalAccessor<Vector3i>::get(left).y, VariantInternalAccessor<Vector3i>::get(left).z) * VariantInternalAccessor<double>::get(right);
 	}
 	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
 		PtrToArg<Vector3>::encode(Vector3(PtrToArg<Vector3i>::convert(left).x, PtrToArg<Vector3i>::convert(left).y, PtrToArg<Vector3i>::convert(left).z) * PtrToArg<double>::convert(right), r_ret);
@@ -128,13 +128,13 @@ template <>
 class OperatorEvaluatorMul<Vector3, double, Vector3i> {
 public:
 	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
-		const Vector3i &a = *VariantGetInternalPtr<Vector3i>::get_ptr(&p_right);
-		const double &b = *VariantGetInternalPtr<double>::get_ptr(&p_left);
+		const Vector3i &a = VariantInternalAccessor<Vector3i>::get(&p_right);
+		const double &b = VariantInternalAccessor<double>::get(&p_left);
 		*r_ret = Vector3(a.x, a.y, a.z) * b;
 		r_valid = true;
 	}
 	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
-		*VariantGetInternalPtr<Vector3>::get_ptr(r_ret) = Vector3(VariantGetInternalPtr<Vector3i>::get_ptr(right)->x, VariantGetInternalPtr<Vector3i>::get_ptr(right)->y, VariantGetInternalPtr<Vector3i>::get_ptr(right)->z) * *VariantGetInternalPtr<double>::get_ptr(left);
+		VariantInternalAccessor<Vector3>::get(r_ret) = Vector3(VariantInternalAccessor<Vector3i>::get(right).x, VariantInternalAccessor<Vector3i>::get(right).y, VariantInternalAccessor<Vector3i>::get(right).z) * VariantInternalAccessor<double>::get(left);
 	}
 	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
 		PtrToArg<Vector3>::encode(Vector3(PtrToArg<Vector3i>::convert(right).x, PtrToArg<Vector3i>::convert(right).y, PtrToArg<Vector3i>::convert(right).z) * PtrToArg<double>::convert(left), r_ret);
@@ -146,8 +146,8 @@ template <>
 class OperatorEvaluatorDivNZ<Vector3, Vector3i, double> {
 public:
 	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
-		const Vector3i &a = *VariantGetInternalPtr<Vector3i>::get_ptr(&p_left);
-		const double &b = *VariantGetInternalPtr<double>::get_ptr(&p_right);
+		const Vector3i &a = VariantInternalAccessor<Vector3i>::get(&p_left);
+		const double &b = VariantInternalAccessor<double>::get(&p_right);
 		if (unlikely(b == 0)) {
 			r_valid = false;
 			*r_ret = "Division by zero error";
@@ -157,7 +157,7 @@ public:
 		r_valid = true;
 	}
 	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
-		*VariantGetInternalPtr<Vector3>::get_ptr(r_ret) = Vector3(VariantGetInternalPtr<Vector3i>::get_ptr(left)->x, VariantGetInternalPtr<Vector3i>::get_ptr(left)->y, VariantGetInternalPtr<Vector3i>::get_ptr(left)->z) / *VariantGetInternalPtr<double>::get_ptr(right);
+		VariantInternalAccessor<Vector3>::get(r_ret) = Vector3(VariantInternalAccessor<Vector3i>::get(left).x, VariantInternalAccessor<Vector3i>::get(left).y, VariantInternalAccessor<Vector3i>::get(left).z) / VariantInternalAccessor<double>::get(right);
 	}
 	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
 		PtrToArg<Vector3>::encode(Vector3(PtrToArg<Vector3i>::convert(left).x, PtrToArg<Vector3i>::convert(left).y, PtrToArg<Vector3i>::convert(left).z) / PtrToArg<double>::convert(right), r_ret);
@@ -171,13 +171,13 @@ template <>
 class OperatorEvaluatorMul<Vector4, Vector4i, double> {
 public:
 	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
-		const Vector4i &a = *VariantGetInternalPtr<Vector4i>::get_ptr(&p_left);
-		const double &b = *VariantGetInternalPtr<double>::get_ptr(&p_right);
+		const Vector4i &a = VariantInternalAccessor<Vector4i>::get(&p_left);
+		const double &b = VariantInternalAccessor<double>::get(&p_right);
 		*r_ret = Vector4(a.x, a.y, a.z, a.w) * b;
 		r_valid = true;
 	}
 	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
-		*VariantGetInternalPtr<Vector4>::get_ptr(r_ret) = Vector4(VariantGetInternalPtr<Vector4i>::get_ptr(left)->x, VariantGetInternalPtr<Vector4i>::get_ptr(left)->y, VariantGetInternalPtr<Vector4i>::get_ptr(left)->z, VariantGetInternalPtr<Vector4i>::get_ptr(left)->w) * *VariantGetInternalPtr<double>::get_ptr(right);
+		VariantInternalAccessor<Vector4>::get(r_ret) = Vector4(VariantInternalAccessor<Vector4i>::get(left).x, VariantInternalAccessor<Vector4i>::get(left).y, VariantInternalAccessor<Vector4i>::get(left).z, VariantInternalAccessor<Vector4i>::get(left).w) * VariantInternalAccessor<double>::get(right);
 	}
 	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
 		PtrToArg<Vector4>::encode(Vector4(PtrToArg<Vector4i>::convert(left).x, PtrToArg<Vector4i>::convert(left).y, PtrToArg<Vector4i>::convert(left).z, PtrToArg<Vector4i>::convert(left).w) * PtrToArg<double>::convert(right), r_ret);
@@ -189,13 +189,13 @@ template <>
 class OperatorEvaluatorMul<Vector4, double, Vector4i> {
 public:
 	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
-		const Vector4i &a = *VariantGetInternalPtr<Vector4i>::get_ptr(&p_right);
-		const double &b = *VariantGetInternalPtr<double>::get_ptr(&p_left);
+		const Vector4i &a = VariantInternalAccessor<Vector4i>::get(&p_right);
+		const double &b = VariantInternalAccessor<double>::get(&p_left);
 		*r_ret = Vector4(a.x, a.y, a.z, a.w) * b;
 		r_valid = true;
 	}
 	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
-		*VariantGetInternalPtr<Vector4>::get_ptr(r_ret) = Vector4(VariantGetInternalPtr<Vector4i>::get_ptr(right)->x, VariantGetInternalPtr<Vector4i>::get_ptr(right)->y, VariantGetInternalPtr<Vector4i>::get_ptr(right)->z, VariantGetInternalPtr<Vector4i>::get_ptr(right)->w) * *VariantGetInternalPtr<double>::get_ptr(left);
+		VariantInternalAccessor<Vector4>::get(r_ret) = Vector4(VariantInternalAccessor<Vector4i>::get(right).x, VariantInternalAccessor<Vector4i>::get(right).y, VariantInternalAccessor<Vector4i>::get(right).z, VariantInternalAccessor<Vector4i>::get(right).w) * VariantInternalAccessor<double>::get(left);
 	}
 	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
 		PtrToArg<Vector4>::encode(Vector4(PtrToArg<Vector4i>::convert(right).x, PtrToArg<Vector4i>::convert(right).y, PtrToArg<Vector4i>::convert(right).z, PtrToArg<Vector4i>::convert(right).w) * PtrToArg<double>::convert(left), r_ret);
@@ -207,8 +207,8 @@ template <>
 class OperatorEvaluatorDivNZ<Vector4, Vector4i, double> {
 public:
 	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
-		const Vector4i &a = *VariantGetInternalPtr<Vector4i>::get_ptr(&p_left);
-		const double &b = *VariantGetInternalPtr<double>::get_ptr(&p_right);
+		const Vector4i &a = VariantInternalAccessor<Vector4i>::get(&p_left);
+		const double &b = VariantInternalAccessor<double>::get(&p_right);
 		if (unlikely(b == 0)) {
 			r_valid = false;
 			*r_ret = "Division by zero error";
@@ -219,7 +219,7 @@ public:
 	}
 
 	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
-		*VariantGetInternalPtr<Vector4>::get_ptr(r_ret) = Vector4(VariantGetInternalPtr<Vector4i>::get_ptr(left)->x, VariantGetInternalPtr<Vector4i>::get_ptr(left)->y, VariantGetInternalPtr<Vector4i>::get_ptr(left)->z, VariantGetInternalPtr<Vector4i>::get_ptr(left)->w) / *VariantGetInternalPtr<double>::get_ptr(right);
+		VariantInternalAccessor<Vector4>::get(r_ret) = Vector4(VariantInternalAccessor<Vector4i>::get(left).x, VariantInternalAccessor<Vector4i>::get(left).y, VariantInternalAccessor<Vector4i>::get(left).z, VariantInternalAccessor<Vector4i>::get(left).w) / VariantInternalAccessor<double>::get(right);
 	}
 
 	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
@@ -1166,7 +1166,7 @@ bool Variant::in(const Variant &p_index, bool *r_valid) const {
 	}
 	if (valid) {
 		ERR_FAIL_COND_V(ret.type != BOOL, false);
-		return *VariantGetInternalPtr<bool>::get_ptr(&ret);
+		return VariantInternalAccessor<bool>::get(&ret);
 	} else {
 		return false;
 	}

core/variant/variant_setget.cpp

@@ -256,7 +256,7 @@ void Variant::set_named(const StringName &p_member, const Variant &p_value, bool
 			return;
 		}
 	} else if (type == Variant::DICTIONARY) {
-		Dictionary &dict = *VariantGetInternalPtr<Dictionary>::get_ptr(this);
+		Dictionary &dict = VariantInternalAccessor<Dictionary>::get(this);
 		r_valid = dict.set(p_member, p_value);
 	} else {
 		r_valid = false;
@@ -287,7 +287,7 @@ Variant Variant::get_named(const StringName &p_member, bool &r_valid) const {
 			}
 		} break;
 		case Variant::DICTIONARY: {
-			const Variant *v = VariantGetInternalPtr<Dictionary>::get_ptr(this)->getptr(p_member);
+			const Variant *v = VariantInternalAccessor<Dictionary>::get(this).getptr(p_member);
 			if (v) {
 				r_valid = true;
 				return *v;
@@ -329,207 +329,145 @@ Variant Variant::get_named(const StringName &p_member, bool &r_valid) const {
 
 #endif
 
-#define INDEXED_SETGET_STRUCT_TYPED(m_base_type, m_elem_type)                                                                        \
-	struct VariantIndexedSetGet_##m_base_type {                                                                                      \
-		static void get(const Variant *base, int64_t index, Variant *value, bool *oob) {                                             \
-			int64_t size = VariantGetInternalPtr<m_base_type>::get_ptr(base)->size();                                                \
-			if (index < 0) {                                                                                                         \
-				index += size;                                                                                                       \
-			}                                                                                                                        \
-			if (index < 0 || index >= size) {                                                                                        \
-				*oob = true;                                                                                                         \
-				return;                                                                                                              \
-			}                                                                                                                        \
-			VariantTypeAdjust<m_elem_type>::adjust(value);                                                                           \
-			*VariantGetInternalPtr<m_elem_type>::get_ptr(value) = (*VariantGetInternalPtr<m_base_type>::get_ptr(base))[index];       \
-			*oob = false;                                                                                                            \
-		}                                                                                                                            \
-		static void ptr_get(const void *base, int64_t index, void *member) {                                                         \
-			/* avoid ptrconvert for performance*/                                                                                    \
-			const m_base_type &v = *reinterpret_cast<const m_base_type *>(base);                                                     \
-			if (index < 0)                                                                                                           \
-				index += v.size();                                                                                                   \
-			OOB_TEST(index, v.size());                                                                                               \
-			PtrToArg<m_elem_type>::encode(v[index], member);                                                                         \
-		}                                                                                                                            \
-		static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) {                                \
-			if (value->get_type() != GetTypeInfo<m_elem_type>::VARIANT_TYPE) {                                                       \
-				*oob = false;                                                                                                        \
-				*valid = false;                                                                                                      \
-				return;                                                                                                              \
-			}                                                                                                                        \
-			int64_t size = VariantGetInternalPtr<m_base_type>::get_ptr(base)->size();                                                \
-			if (index < 0) {                                                                                                         \
-				index += size;                                                                                                       \
-			}                                                                                                                        \
-			if (index < 0 || index >= size) {                                                                                        \
-				*oob = true;                                                                                                         \
-				*valid = false;                                                                                                      \
-				return;                                                                                                              \
-			}                                                                                                                        \
-			(*VariantGetInternalPtr<m_base_type>::get_ptr(base)).write[index] = *VariantGetInternalPtr<m_elem_type>::get_ptr(value); \
-			*oob = false;                                                                                                            \
-			*valid = true;                                                                                                           \
-		}                                                                                                                            \
-		static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) {                                   \
-			int64_t size = VariantGetInternalPtr<m_base_type>::get_ptr(base)->size();                                                \
-			if (index < 0) {                                                                                                         \
-				index += size;                                                                                                       \
-			}                                                                                                                        \
-			if (index < 0 || index >= size) {                                                                                        \
-				*oob = true;                                                                                                         \
-				return;                                                                                                              \
-			}                                                                                                                        \
-			(*VariantGetInternalPtr<m_base_type>::get_ptr(base)).write[index] = *VariantGetInternalPtr<m_elem_type>::get_ptr(value); \
-			*oob = false;                                                                                                            \
-		}                                                                                                                            \
-		static void ptr_set(void *base, int64_t index, const void *member) {                                                         \
-			/* avoid ptrconvert for performance*/                                                                                    \
-			m_base_type &v = *reinterpret_cast<m_base_type *>(base);                                                                 \
-			if (index < 0)                                                                                                           \
-				index += v.size();                                                                                                   \
-			OOB_TEST(index, v.size());                                                                                               \
-			v.write[index] = PtrToArg<m_elem_type>::convert(member);                                                                 \
-		}                                                                                                                            \
-		static Variant::Type get_index_type() {                                                                                      \
-			return GetTypeInfo<m_elem_type>::VARIANT_TYPE;                                                                           \
-		}                                                                                                                            \
-		static uint32_t get_index_usage() {                                                                                          \
-			return GetTypeInfo<m_elem_type>::get_class_info().usage;                                                                 \
-		}                                                                                                                            \
-		static uint64_t get_indexed_size(const Variant *base) {                                                                      \
-			return VariantGetInternalPtr<m_base_type>::get_ptr(base)->size();                                                        \
-		}                                                                                                                            \
-	};
-
-#define INDEXED_SETGET_STRUCT_TYPED_NUMERIC(m_base_type, m_elem_type, m_assign_type)                                                 \
-	struct VariantIndexedSetGet_##m_base_type {                                                                                      \
-		static void get(const Variant *base, int64_t index, Variant *value, bool *oob) {                                             \
-			int64_t size = VariantGetInternalPtr<m_base_type>::get_ptr(base)->size();                                                \
-			if (index < 0) {                                                                                                         \
-				index += size;                                                                                                       \
-			}                                                                                                                        \
-			if (index < 0 || index >= size) {                                                                                        \
-				*oob = true;                                                                                                         \
-				return;                                                                                                              \
-			}                                                                                                                        \
-			VariantTypeAdjust<m_elem_type>::adjust(value);                                                                           \
-			*VariantGetInternalPtr<m_elem_type>::get_ptr(value) = (*VariantGetInternalPtr<m_base_type>::get_ptr(base))[index];       \
-			*oob = false;                                                                                                            \
-		}                                                                                                                            \
-		static void ptr_get(const void *base, int64_t index, void *member) {                                                         \
-			/* avoid ptrconvert for performance*/                                                                                    \
-			const m_base_type &v = *reinterpret_cast<const m_base_type *>(base);                                                     \
-			if (index < 0)                                                                                                           \
-				index += v.size();                                                                                                   \
-			OOB_TEST(index, v.size());                                                                                               \
-			PtrToArg<m_elem_type>::encode(v[index], member);                                                                         \
-		}                                                                                                                            \
-		static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) {                                \
-			int64_t size = VariantGetInternalPtr<m_base_type>::get_ptr(base)->size();                                                \
-			if (index < 0) {                                                                                                         \
-				index += size;                                                                                                       \
-			}                                                                                                                        \
-			if (index < 0 || index >= size) {                                                                                        \
-				*oob = true;                                                                                                         \
-				*valid = false;                                                                                                      \
-				return;                                                                                                              \
-			}                                                                                                                        \
-			m_assign_type num;                                                                                                       \
-			if (value->get_type() == Variant::INT) {                                                                                 \
-				num = (m_assign_type) * VariantGetInternalPtr<int64_t>::get_ptr(value);                                              \
-			} else if (value->get_type() == Variant::FLOAT) {                                                                        \
-				num = (m_assign_type) * VariantGetInternalPtr<double>::get_ptr(value);                                               \
-			} else {                                                                                                                 \
-				*oob = false;                                                                                                        \
-				*valid = false;                                                                                                      \
-				return;                                                                                                              \
-			}                                                                                                                        \
-			(*VariantGetInternalPtr<m_base_type>::get_ptr(base)).write[index] = num;                                                 \
-			*oob = false;                                                                                                            \
-			*valid = true;                                                                                                           \
-		}                                                                                                                            \
-		static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) {                                   \
-			int64_t size = VariantGetInternalPtr<m_base_type>::get_ptr(base)->size();                                                \
-			if (index < 0) {                                                                                                         \
-				index += size;                                                                                                       \
-			}                                                                                                                        \
-			if (index < 0 || index >= size) {                                                                                        \
-				*oob = true;                                                                                                         \
-				return;                                                                                                              \
-			}                                                                                                                        \
-			(*VariantGetInternalPtr<m_base_type>::get_ptr(base)).write[index] = *VariantGetInternalPtr<m_elem_type>::get_ptr(value); \
-			*oob = false;                                                                                                            \
-		}                                                                                                                            \
-		static void ptr_set(void *base, int64_t index, const void *member) {                                                         \
-			/* avoid ptrconvert for performance*/                                                                                    \
-			m_base_type &v = *reinterpret_cast<m_base_type *>(base);                                                                 \
-			if (index < 0)                                                                                                           \
-				index += v.size();                                                                                                   \
-			OOB_TEST(index, v.size());                                                                                               \
-			v.write[index] = PtrToArg<m_elem_type>::convert(member);                                                                 \
-		}                                                                                                                            \
-		static Variant::Type get_index_type() {                                                                                      \
-			return GetTypeInfo<m_elem_type>::VARIANT_TYPE;                                                                           \
-		}                                                                                                                            \
-		static uint32_t get_index_usage() {                                                                                          \
-			return GetTypeInfo<m_elem_type>::get_class_info().usage;                                                                 \
-		}                                                                                                                            \
-		static uint64_t get_indexed_size(const Variant *base) {                                                                      \
-			return VariantGetInternalPtr<m_base_type>::get_ptr(base)->size();                                                        \
-		}                                                                                                                            \
+#define INDEXED_SETGET_STRUCT_TYPED(m_base_type, m_elem_type)                                                                  \
+	struct VariantIndexedSetGet_##m_base_type {                                                                                \
+		static void get(const Variant *base, int64_t index, Variant *value, bool *oob) {                                       \
+			int64_t size = VariantInternalAccessor<m_base_type>::get(base).size();                                             \
+			if (index < 0) {                                                                                                   \
+				index += size;                                                                                                 \
+			}                                                                                                                  \
+			if (index < 0 || index >= size) {                                                                                  \
+				*oob = true;                                                                                                   \
+				return;                                                                                                        \
+			}                                                                                                                  \
+			VariantTypeAdjust<m_elem_type>::adjust(value);                                                                     \
+			VariantInternalAccessor<m_elem_type>::get(value) = (VariantInternalAccessor<m_base_type>::get(base))[index];       \
+			*oob = false;                                                                                                      \
+		}                                                                                                                      \
+		static void ptr_get(const void *base, int64_t index, void *member) {                                                   \
+			/* avoid ptrconvert for performance*/                                                                              \
+			const m_base_type &v = *reinterpret_cast<const m_base_type *>(base);                                               \
+			if (index < 0)                                                                                                     \
+				index += v.size();                                                                                             \
+			OOB_TEST(index, v.size());                                                                                         \
+			PtrToArg<m_elem_type>::encode(v[index], member);                                                                   \
+		}                                                                                                                      \
+		static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) {                          \
+			if (value->get_type() != GetTypeInfo<m_elem_type>::VARIANT_TYPE) {                                                 \
+				*oob = false;                                                                                                  \
+				*valid = false;                                                                                                \
+				return;                                                                                                        \
+			}                                                                                                                  \
+			int64_t size = VariantInternalAccessor<m_base_type>::get(base).size();                                             \
+			if (index < 0) {                                                                                                   \
+				index += size;                                                                                                 \
+			}                                                                                                                  \
+			if (index < 0 || index >= size) {                                                                                  \
+				*oob = true;                                                                                                   \
+				*valid = false;                                                                                                \
+				return;                                                                                                        \
+			}                                                                                                                  \
+			(VariantInternalAccessor<m_base_type>::get(base)).write[index] = VariantInternalAccessor<m_elem_type>::get(value); \
+			*oob = false;                                                                                                      \
+			*valid = true;                                                                                                     \
+		}                                                                                                                      \
+		static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) {                             \
+			int64_t size = VariantInternalAccessor<m_base_type>::get(base).size();                                             \
+			if (index < 0) {                                                                                                   \
+				index += size;                                                                                                 \
+			}                                                                                                                  \
+			if (index < 0 || index >= size) {                                                                                  \
+				*oob = true;                                                                                                   \
+				return;                                                                                                        \
+			}                                                                                                                  \
+			(VariantInternalAccessor<m_base_type>::get(base)).write[index] = VariantInternalAccessor<m_elem_type>::get(value); \
+			*oob = false;                                                                                                      \
+		}                                                                                                                      \
+		static void ptr_set(void *base, int64_t index, const void *member) {                                                   \
+			/* avoid ptrconvert for performance*/                                                                              \
+			m_base_type &v = *reinterpret_cast<m_base_type *>(base);                                                           \
+			if (index < 0)                                                                                                     \
+				index += v.size();                                                                                             \
+			OOB_TEST(index, v.size());                                                                                         \
+			v.write[index] = PtrToArg<m_elem_type>::convert(member);                                                           \
+		}                                                                                                                      \
+		static Variant::Type get_index_type() {                                                                                \
+			return GetTypeInfo<m_elem_type>::VARIANT_TYPE;                                                                     \
+		}                                                                                                                      \
+		static uint32_t get_index_usage() {                                                                                    \
+			return GetTypeInfo<m_elem_type>::get_class_info().usage;                                                           \
+		}                                                                                                                      \
+		static uint64_t get_indexed_size(const Variant *base) {                                                                \
+			return VariantInternalAccessor<m_base_type>::get(base).size();                                                     \
+		}                                                                                                                      \
 	};
 
-#define INDEXED_SETGET_STRUCT_BUILTIN_NUMERIC(m_base_type, m_elem_type, m_assign_type, m_max)                                  \
+#define INDEXED_SETGET_STRUCT_TYPED_NUMERIC(m_base_type, m_elem_type, m_assign_type)                                           \
 	struct VariantIndexedSetGet_##m_base_type {                                                                                \
 		static void get(const Variant *base, int64_t index, Variant *value, bool *oob) {                                       \
-			if (index < 0 || index >= m_max) {                                                                                 \
+			int64_t size = VariantInternalAccessor<m_base_type>::get(base).size();                                             \
+			if (index < 0) {                                                                                                   \
+				index += size;                                                                                                 \
+			}                                                                                                                  \
+			if (index < 0 || index >= size) {                                                                                  \
 				*oob = true;                                                                                                   \
 				return;                                                                                                        \
 			}                                                                                                                  \
 			VariantTypeAdjust<m_elem_type>::adjust(value);                                                                     \
-			*VariantGetInternalPtr<m_elem_type>::get_ptr(value) = (*VariantGetInternalPtr<m_base_type>::get_ptr(base))[index]; \
+			VariantInternalAccessor<m_elem_type>::get(value) = (VariantInternalAccessor<m_base_type>::get(base))[index];       \
 			*oob = false;                                                                                                      \
 		}                                                                                                                      \
 		static void ptr_get(const void *base, int64_t index, void *member) {                                                   \
 			/* avoid ptrconvert for performance*/                                                                              \
 			const m_base_type &v = *reinterpret_cast<const m_base_type *>(base);                                               \
-			OOB_TEST(index, m_max);                                                                                            \
+			if (index < 0)                                                                                                     \
+				index += v.size();                                                                                             \
+			OOB_TEST(index, v.size());                                                                                         \
 			PtrToArg<m_elem_type>::encode(v[index], member);                                                                   \
 		}                                                                                                                      \
 		static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) {                          \
-			if (index < 0 || index >= m_max) {                                                                                 \
+			int64_t size = VariantInternalAccessor<m_base_type>::get(base).size();                                             \
+			if (index < 0) {                                                                                                   \
+				index += size;                                                                                                 \
+			}                                                                                                                  \
+			if (index < 0 || index >= size) {                                                                                  \
 				*oob = true;                                                                                                   \
 				*valid = false;                                                                                                \
 				return;                                                                                                        \
 			}                                                                                                                  \
 			m_assign_type num;                                                                                                 \
 			if (value->get_type() == Variant::INT) {                                                                           \
-				num = (m_assign_type) * VariantGetInternalPtr<int64_t>::get_ptr(value);                                        \
+				num = (m_assign_type) * &VariantInternalAccessor<int64_t>::get(value);                                         \
 			} else if (value->get_type() == Variant::FLOAT) {                                                                  \
-				num = (m_assign_type) * VariantGetInternalPtr<double>::get_ptr(value);                                         \
+				num = (m_assign_type) * &VariantInternalAccessor<double>::get(value);                                          \
 			} else {                                                                                                           \
 				*oob = false;                                                                                                  \
 				*valid = false;                                                                                                \
 				return;                                                                                                        \
 			}                                                                                                                  \
-			(*VariantGetInternalPtr<m_base_type>::get_ptr(base))[index] = num;                                                 \
+			(VariantInternalAccessor<m_base_type>::get(base)).write[index] = num;                                              \
 			*oob = false;                                                                                                      \
 			*valid = true;                                                                                                     \
 		}                                                                                                                      \
 		static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) {                             \
-			if (index < 0 || index >= m_max) {                                                                                 \
+			int64_t size = VariantInternalAccessor<m_base_type>::get(base).size();                                             \
+			if (index < 0) {                                                                                                   \
+				index += size;                                                                                                 \
+			}                                                                                                                  \
+			if (index < 0 || index >= size) {                                                                                  \
 				*oob = true;                                                                                                   \
 				return;                                                                                                        \
 			}                                                                                                                  \
-			(*VariantGetInternalPtr<m_base_type>::get_ptr(base))[index] = *VariantGetInternalPtr<m_elem_type>::get_ptr(value); \
+			(VariantInternalAccessor<m_base_type>::get(base)).write[index] = VariantInternalAccessor<m_elem_type>::get(value); \
 			*oob = false;                                                                                                      \
 		}                                                                                                                      \
 		static void ptr_set(void *base, int64_t index, const void *member) {                                                   \
 			/* avoid ptrconvert for performance*/                                                                              \
 			m_base_type &v = *reinterpret_cast<m_base_type *>(base);                                                           \
-			OOB_TEST(index, m_max);                                                                                            \
-			v[index] = PtrToArg<m_elem_type>::convert(member);                                                                 \
+			if (index < 0)                                                                                                     \
+				index += v.size();                                                                                             \
+			OOB_TEST(index, v.size());                                                                                         \
+			v.write[index] = PtrToArg<m_elem_type>::convert(member);                                                           \
 		}                                                                                                                      \
 		static Variant::Type get_index_type() {                                                                                \
 			return GetTypeInfo<m_elem_type>::VARIANT_TYPE;                                                                     \
@@ -538,125 +476,187 @@ Variant Variant::get_named(const StringName &p_member, bool &r_valid) const {
 			return GetTypeInfo<m_elem_type>::get_class_info().usage;                                                           \
 		}                                                                                                                      \
 		static uint64_t get_indexed_size(const Variant *base) {                                                                \
-			return m_max;                                                                                                      \
+			return VariantInternalAccessor<m_base_type>::get(base).size();                                                     \
 		}                                                                                                                      \
 	};
 
-#define INDEXED_SETGET_STRUCT_BUILTIN_ACCESSOR(m_base_type, m_elem_type, m_accessor, m_max)                                               \
-	struct VariantIndexedSetGet_##m_base_type {                                                                                           \
-		static void get(const Variant *base, int64_t index, Variant *value, bool *oob) {                                                  \
-			if (index < 0 || index >= m_max) {                                                                                            \
-				*oob = true;                                                                                                              \
-				return;                                                                                                                   \
-			}                                                                                                                             \
-			VariantTypeAdjust<m_elem_type>::adjust(value);                                                                                \
-			*VariantGetInternalPtr<m_elem_type>::get_ptr(value) = (*VariantGetInternalPtr<m_base_type>::get_ptr(base))m_accessor[index];  \
-			*oob = false;                                                                                                                 \
-		}                                                                                                                                 \
-		static void ptr_get(const void *base, int64_t index, void *member) {                                                              \
-			/* avoid ptrconvert for performance*/                                                                                         \
-			const m_base_type &v = *reinterpret_cast<const m_base_type *>(base);                                                          \
-			OOB_TEST(index, m_max);                                                                                                       \
-			PtrToArg<m_elem_type>::encode(v m_accessor[index], member);                                                                   \
-		}                                                                                                                                 \
-		static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) {                                     \
-			if (value->get_type() != GetTypeInfo<m_elem_type>::VARIANT_TYPE) {                                                            \
-				*oob = false;                                                                                                             \
-				*valid = false;                                                                                                           \
-			}                                                                                                                             \
-			if (index < 0 || index >= m_max) {                                                                                            \
-				*oob = true;                                                                                                              \
-				*valid = false;                                                                                                           \
-				return;                                                                                                                   \
-			}                                                                                                                             \
-			(*VariantGetInternalPtr<m_base_type>::get_ptr(base)) m_accessor[index] = *VariantGetInternalPtr<m_elem_type>::get_ptr(value); \
-			*oob = false;                                                                                                                 \
-			*valid = true;                                                                                                                \
-		}                                                                                                                                 \
-		static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) {                                        \
-			if (index < 0 || index >= m_max) {                                                                                            \
-				*oob = true;                                                                                                              \
-				return;                                                                                                                   \
-			}                                                                                                                             \
-			(*VariantGetInternalPtr<m_base_type>::get_ptr(base)) m_accessor[index] = *VariantGetInternalPtr<m_elem_type>::get_ptr(value); \
-			*oob = false;                                                                                                                 \
-		}                                                                                                                                 \
-		static void ptr_set(void *base, int64_t index, const void *member) {                                                              \
-			/* avoid ptrconvert for performance*/                                                                                         \
-			m_base_type &v = *reinterpret_cast<m_base_type *>(base);                                                                      \
-			OOB_TEST(index, m_max);                                                                                                       \
-			v m_accessor[index] = PtrToArg<m_elem_type>::convert(member);                                                                 \
-		}                                                                                                                                 \
-		static Variant::Type get_index_type() {                                                                                           \
-			return GetTypeInfo<m_elem_type>::VARIANT_TYPE;                                                                                \
-		}                                                                                                                                 \
-		static uint32_t get_index_usage() {                                                                                               \
-			return GetTypeInfo<m_elem_type>::get_class_info().usage;                                                                      \
-		}                                                                                                                                 \
-		static uint64_t get_indexed_size(const Variant *base) {                                                                           \
-			return m_max;                                                                                                                 \
-		}                                                                                                                                 \
+#define INDEXED_SETGET_STRUCT_BUILTIN_NUMERIC(m_base_type, m_elem_type, m_assign_type, m_max)                            \
+	struct VariantIndexedSetGet_##m_base_type {                                                                          \
+		static void get(const Variant *base, int64_t index, Variant *value, bool *oob) {                                 \
+			if (index < 0 || index >= m_max) {                                                                           \
+				*oob = true;                                                                                             \
+				return;                                                                                                  \
+			}                                                                                                            \
+			VariantTypeAdjust<m_elem_type>::adjust(value);                                                               \
+			VariantInternalAccessor<m_elem_type>::get(value) = (VariantInternalAccessor<m_base_type>::get(base))[index]; \
+			*oob = false;                                                                                                \
+		}                                                                                                                \
+		static void ptr_get(const void *base, int64_t index, void *member) {                                             \
+			/* avoid ptrconvert for performance*/                                                                        \
+			const m_base_type &v = *reinterpret_cast<const m_base_type *>(base);                                         \
+			OOB_TEST(index, m_max);                                                                                      \
+			PtrToArg<m_elem_type>::encode(v[index], member);                                                             \
+		}                                                                                                                \
+		static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) {                    \
+			if (index < 0 || index >= m_max) {                                                                           \
+				*oob = true;                                                                                             \
+				*valid = false;                                                                                          \
+				return;                                                                                                  \
+			}                                                                                                            \
+			m_assign_type num;                                                                                           \
+			if (value->get_type() == Variant::INT) {                                                                     \
+				num = (m_assign_type) * &VariantInternalAccessor<int64_t>::get(value);                                   \
+			} else if (value->get_type() == Variant::FLOAT) {                                                            \
+				num = (m_assign_type) * &VariantInternalAccessor<double>::get(value);                                    \
+			} else {                                                                                                     \
+				*oob = false;                                                                                            \
+				*valid = false;                                                                                          \
+				return;                                                                                                  \
+			}                                                                                                            \
+			(VariantInternalAccessor<m_base_type>::get(base))[index] = num;                                              \
+			*oob = false;                                                                                                \
+			*valid = true;                                                                                               \
+		}                                                                                                                \
+		static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) {                       \
+			if (index < 0 || index >= m_max) {                                                                           \
+				*oob = true;                                                                                             \
+				return;                                                                                                  \
+			}                                                                                                            \
+			(VariantInternalAccessor<m_base_type>::get(base))[index] = VariantInternalAccessor<m_elem_type>::get(value); \
+			*oob = false;                                                                                                \
+		}                                                                                                                \
+		static void ptr_set(void *base, int64_t index, const void *member) {                                             \
+			/* avoid ptrconvert for performance*/                                                                        \
+			m_base_type &v = *reinterpret_cast<m_base_type *>(base);                                                     \
+			OOB_TEST(index, m_max);                                                                                      \
+			v[index] = PtrToArg<m_elem_type>::convert(member);                                                           \
+		}                                                                                                                \
+		static Variant::Type get_index_type() {                                                                          \
+			return GetTypeInfo<m_elem_type>::VARIANT_TYPE;                                                               \
+		}                                                                                                                \
+		static uint32_t get_index_usage() {                                                                              \
+			return GetTypeInfo<m_elem_type>::get_class_info().usage;                                                     \
+		}                                                                                                                \
+		static uint64_t get_indexed_size(const Variant *base) {                                                          \
+			return m_max;                                                                                                \
+		}                                                                                                                \
+	};
+
+#define INDEXED_SETGET_STRUCT_BUILTIN_ACCESSOR(m_base_type, m_elem_type, m_accessor, m_max)                                         \
+	struct VariantIndexedSetGet_##m_base_type {                                                                                     \
+		static void get(const Variant *base, int64_t index, Variant *value, bool *oob) {                                            \
+			if (index < 0 || index >= m_max) {                                                                                      \
+				*oob = true;                                                                                                        \
+				return;                                                                                                             \
+			}                                                                                                                       \
+			VariantTypeAdjust<m_elem_type>::adjust(value);                                                                          \
+			VariantInternalAccessor<m_elem_type>::get(value) = (VariantInternalAccessor<m_base_type>::get(base))m_accessor[index];  \
+			*oob = false;                                                                                                           \
+		}                                                                                                                           \
+		static void ptr_get(const void *base, int64_t index, void *member) {                                                        \
+			/* avoid ptrconvert for performance*/                                                                                   \
+			const m_base_type &v = *reinterpret_cast<const m_base_type *>(base);                                                    \
+			OOB_TEST(index, m_max);                                                                                                 \
+			PtrToArg<m_elem_type>::encode(v m_accessor[index], member);                                                             \
+		}                                                                                                                           \
+		static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) {                               \
+			if (value->get_type() != GetTypeInfo<m_elem_type>::VARIANT_TYPE) {                                                      \
+				*oob = false;                                                                                                       \
+				*valid = false;                                                                                                     \
+			}                                                                                                                       \
+			if (index < 0 || index >= m_max) {                                                                                      \
+				*oob = true;                                                                                                        \
+				*valid = false;                                                                                                     \
+				return;                                                                                                             \
+			}                                                                                                                       \
+			(VariantInternalAccessor<m_base_type>::get(base)) m_accessor[index] = VariantInternalAccessor<m_elem_type>::get(value); \
+			*oob = false;                                                                                                           \
+			*valid = true;                                                                                                          \
+		}                                                                                                                           \
+		static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) {                                  \
+			if (index < 0 || index >= m_max) {                                                                                      \
+				*oob = true;                                                                                                        \
+				return;                                                                                                             \
+			}                                                                                                                       \
+			(VariantInternalAccessor<m_base_type>::get(base)) m_accessor[index] = VariantInternalAccessor<m_elem_type>::get(value); \
+			*oob = false;                                                                                                           \
+		}                                                                                                                           \
+		static void ptr_set(void *base, int64_t index, const void *member) {                                                        \
+			/* avoid ptrconvert for performance*/                                                                                   \
+			m_base_type &v = *reinterpret_cast<m_base_type *>(base);                                                                \
+			OOB_TEST(index, m_max);                                                                                                 \
+			v m_accessor[index] = PtrToArg<m_elem_type>::convert(member);                                                           \
+		}                                                                                                                           \
+		static Variant::Type get_index_type() {                                                                                     \
+			return GetTypeInfo<m_elem_type>::VARIANT_TYPE;                                                                          \
+		}                                                                                                                           \
+		static uint32_t get_index_usage() {                                                                                         \
+			return GetTypeInfo<m_elem_type>::get_class_info().usage;                                                                \
+		}                                                                                                                           \
+		static uint64_t get_indexed_size(const Variant *base) {                                                                     \
+			return m_max;                                                                                                           \
+		}                                                                                                                           \
 	};
 
-#define INDEXED_SETGET_STRUCT_BUILTIN_FUNC(m_base_type, m_elem_type, m_set, m_get, m_max)                                          \
-	struct VariantIndexedSetGet_##m_base_type {                                                                                    \
-		static void get(const Variant *base, int64_t index, Variant *value, bool *oob) {                                           \
-			if (index < 0 || index >= m_max) {                                                                                     \
-				*oob = true;                                                                                                       \
-				return;                                                                                                            \
-			}                                                                                                                      \
-			VariantTypeAdjust<m_elem_type>::adjust(value);                                                                         \
-			*VariantGetInternalPtr<m_elem_type>::get_ptr(value) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_get(index); \
-			*oob = false;                                                                                                          \
-		}                                                                                                                          \
-		static void ptr_get(const void *base, int64_t index, void *member) {                                                       \
-			/* avoid ptrconvert for performance*/                                                                                  \
-			const m_base_type &v = *reinterpret_cast<const m_base_type *>(base);                                                   \
-			OOB_TEST(index, m_max);                                                                                                \
-			PtrToArg<m_elem_type>::encode(v.m_get(index), member);                                                                 \
-		}                                                                                                                          \
-		static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) {                              \
-			if (value->get_type() != GetTypeInfo<m_elem_type>::VARIANT_TYPE) {                                                     \
-				*oob = false;                                                                                                      \
-				*valid = false;                                                                                                    \
-			}                                                                                                                      \
-			if (index < 0 || index >= m_max) {                                                                                     \
-				*oob = true;                                                                                                       \
-				*valid = false;                                                                                                    \
-				return;                                                                                                            \
-			}                                                                                                                      \
-			VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_set(index, *VariantGetInternalPtr<m_elem_type>::get_ptr(value));  \
-			*oob = false;                                                                                                          \
-			*valid = true;                                                                                                         \
-		}                                                                                                                          \
-		static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) {                                 \
-			if (index < 0 || index >= m_max) {                                                                                     \
-				*oob = true;                                                                                                       \
-				return;                                                                                                            \
-			}                                                                                                                      \
-			VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_set(index, *VariantGetInternalPtr<m_elem_type>::get_ptr(value));  \
-			*oob = false;                                                                                                          \
-		}                                                                                                                          \
-		static void ptr_set(void *base, int64_t index, const void *member) {                                                       \
-			/* avoid ptrconvert for performance*/                                                                                  \
-			m_base_type &v = *reinterpret_cast<m_base_type *>(base);                                                               \
-			OOB_TEST(index, m_max);                                                                                                \
-			v.m_set(index, PtrToArg<m_elem_type>::convert(member));                                                                \
-		}                                                                                                                          \
-		static Variant::Type get_index_type() {                                                                                    \
-			return GetTypeInfo<m_elem_type>::VARIANT_TYPE;                                                                         \
-		}                                                                                                                          \
-		static uint32_t get_index_usage() {                                                                                        \
-			return GetTypeInfo<m_elem_type>::get_class_info().usage;                                                               \
-		}                                                                                                                          \
-		static uint64_t get_indexed_size(const Variant *base) {                                                                    \
-			return m_max;                                                                                                          \
-		}                                                                                                                          \
+#define INDEXED_SETGET_STRUCT_BUILTIN_FUNC(m_base_type, m_elem_type, m_set, m_get, m_max)                                    \
+	struct VariantIndexedSetGet_##m_base_type {                                                                              \
+		static void get(const Variant *base, int64_t index, Variant *value, bool *oob) {                                     \
+			if (index < 0 || index >= m_max) {                                                                               \
+				*oob = true;                                                                                                 \
+				return;                                                                                                      \
+			}                                                                                                                \
+			VariantTypeAdjust<m_elem_type>::adjust(value);                                                                   \
+			VariantInternalAccessor<m_elem_type>::get(value) = VariantInternalAccessor<m_base_type>::get(base).m_get(index); \
+			*oob = false;                                                                                                    \
+		}                                                                                                                    \
+		static void ptr_get(const void *base, int64_t index, void *member) {                                                 \
+			/* avoid ptrconvert for performance*/                                                                            \
+			const m_base_type &v = *reinterpret_cast<const m_base_type *>(base);                                             \
+			OOB_TEST(index, m_max);                                                                                          \
+			PtrToArg<m_elem_type>::encode(v.m_get(index), member);                                                           \
+		}                                                                                                                    \
+		static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) {                        \
+			if (value->get_type() != GetTypeInfo<m_elem_type>::VARIANT_TYPE) {                                               \
+				*oob = false;                                                                                                \
+				*valid = false;                                                                                              \
+			}                                                                                                                \
+			if (index < 0 || index >= m_max) {                                                                               \
+				*oob = true;                                                                                                 \
+				*valid = false;                                                                                              \
+				return;                                                                                                      \
+			}                                                                                                                \
+			VariantInternalAccessor<m_base_type>::get(base).m_set(index, VariantInternalAccessor<m_elem_type>::get(value));  \
+			*oob = false;                                                                                                    \
+			*valid = true;                                                                                                   \
+		}                                                                                                                    \
+		static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) {                           \
+			if (index < 0 || index >= m_max) {                                                                               \
+				*oob = true;                                                                                                 \
+				return;                                                                                                      \
+			}                                                                                                                \
+			VariantInternalAccessor<m_base_type>::get(base).m_set(index, VariantInternalAccessor<m_elem_type>::get(value));  \
+			*oob = false;                                                                                                    \
+		}                                                                                                                    \
+		static void ptr_set(void *base, int64_t index, const void *member) {                                                 \
+			/* avoid ptrconvert for performance*/                                                                            \
+			m_base_type &v = *reinterpret_cast<m_base_type *>(base);                                                         \
+			OOB_TEST(index, m_max);                                                                                          \
+			v.m_set(index, PtrToArg<m_elem_type>::convert(member));                                                          \
+		}                                                                                                                    \
+		static Variant::Type get_index_type() {                                                                              \
+			return GetTypeInfo<m_elem_type>::VARIANT_TYPE;                                                                   \
+		}                                                                                                                    \
+		static uint32_t get_index_usage() {                                                                                  \
+			return GetTypeInfo<m_elem_type>::get_class_info().usage;                                                         \
+		}                                                                                                                    \
+		static uint64_t get_indexed_size(const Variant *base) {                                                              \
+			return m_max;                                                                                                    \
+		}                                                                                                                    \
 	};
 
 struct VariantIndexedSetGet_Array {
 	static void get(const Variant *base, int64_t index, Variant *value, bool *oob) {
-		int64_t size = VariantGetInternalPtr<Array>::get_ptr(base)->size();
+		int64_t size = VariantInternalAccessor<Array>::get(base).size();
 		if (index < 0) {
 			index += size;
 		}
@@ -664,7 +664,7 @@ struct VariantIndexedSetGet_Array {
 			*oob = true;
 			return;
 		}
-		*value = (*VariantGetInternalPtr<Array>::get_ptr(base))[index];
+		*value = (VariantInternalAccessor<Array>::get(base))[index];
 		*oob = false;
 	}
 	static void ptr_get(const void *base, int64_t index, void *member) {
@@ -677,12 +677,12 @@ struct VariantIndexedSetGet_Array {
 		PtrToArg<Variant>::encode(v[index], member);
 	}
 	static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) {
-		if (VariantGetInternalPtr<Array>::get_ptr(base)->is_read_only()) {
+		if (VariantInternalAccessor<Array>::get(base).is_read_only()) {
 			*valid = false;
 			*oob = true;
 			return;
 		}
-		int64_t size = VariantGetInternalPtr<Array>::get_ptr(base)->size();
+		int64_t size = VariantInternalAccessor<Array>::get(base).size();
 		if (index < 0) {
 			index += size;
 		}
@@ -691,16 +691,16 @@ struct VariantIndexedSetGet_Array {
 			*valid = false;
 			return;
 		}
-		VariantGetInternalPtr<Array>::get_ptr(base)->set(index, *value);
+		VariantInternalAccessor<Array>::get(base).set(index, *value);
 		*oob = false;
 		*valid = true;
 	}
 	static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) {
-		if (VariantGetInternalPtr<Array>::get_ptr(base)->is_read_only()) {
+		if (VariantInternalAccessor<Array>::get(base).is_read_only()) {
 			*oob = true;
 			return;
 		}
-		int64_t size = VariantGetInternalPtr<Array>::get_ptr(base)->size();
+		int64_t size = VariantInternalAccessor<Array>::get(base).size();
 		if (index < 0) {
 			index += size;
 		}
@@ -708,7 +708,7 @@ struct VariantIndexedSetGet_Array {
 			*oob = true;
 			return;
 		}
-		VariantGetInternalPtr<Array>::get_ptr(base)->set(index, *value);
+		VariantInternalAccessor<Array>::get(base).set(index, *value);
 		*oob = false;
 	}
 	static void ptr_set(void *base, int64_t index, const void *member) {
@@ -727,7 +727,7 @@ struct VariantIndexedSetGet_Array {
 
 struct VariantIndexedSetGet_Dictionary {
 	static void get(const Variant *base, int64_t index, Variant *value, bool *oob) {
-		const Variant *ptr = VariantGetInternalPtr<Dictionary>::get_ptr(base)->getptr(index);
+		const Variant *ptr = VariantInternalAccessor<Dictionary>::get(base).getptr(index);
 		if (!ptr) {
 			*oob = true;
 			return;
@@ -743,12 +743,12 @@ struct VariantIndexedSetGet_Dictionary {
 		PtrToArg<Variant>::encode(*ptr, member);
 	}
 	static void set(Variant *base, int64_t index, const Variant *value, bool *valid, bool *oob) {
-		*valid = VariantGetInternalPtr<Dictionary>::get_ptr(base)->set(index, *value);
-		*oob = VariantGetInternalPtr<Dictionary>::get_ptr(base)->is_read_only();
+		*valid = VariantInternalAccessor<Dictionary>::get(base).set(index, *value);
+		*oob = VariantInternalAccessor<Dictionary>::get(base).is_read_only();
 	}
 	static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) {
-		VariantGetInternalPtr<Dictionary>::get_ptr(base)->set(index, *value);
-		*oob = VariantGetInternalPtr<Dictionary>::get_ptr(base)->is_read_only();
+		VariantInternalAccessor<Dictionary>::get(base).set(index, *value);
+		*oob = VariantInternalAccessor<Dictionary>::get(base).is_read_only();
 	}
 	static void ptr_set(void *base, int64_t index, const void *member) {
 		Dictionary &v = *reinterpret_cast<Dictionary *>(base);
@@ -756,12 +756,12 @@ struct VariantIndexedSetGet_Dictionary {
 	}
 	static Variant::Type get_index_type() { return Variant::NIL; }
 	static uint32_t get_index_usage() { return PROPERTY_USAGE_DEFAULT; }
-	static uint64_t get_indexed_size(const Variant *base) { return VariantGetInternalPtr<Dictionary>::get_ptr(base)->size(); }
+	static uint64_t get_indexed_size(const Variant *base) { return VariantInternalAccessor<Dictionary>::get(base).size(); }
 };
 
 struct VariantIndexedSetGet_String {
 	static void get(const Variant *base, int64_t index, Variant *value, bool *oob) {
-		int64_t length = VariantGetInternalPtr<String>::get_ptr(base)->length();
+		int64_t length = VariantInternalAccessor<String>::get(base).length();
 		if (index < 0) {
 			index += length;
 		}
@@ -769,7 +769,7 @@ struct VariantIndexedSetGet_String {
 			*oob = true;
 			return;
 		}
-		*value = String::chr((*VariantGetInternalPtr<String>::get_ptr(base))[index]);
+		*value = String::chr((VariantInternalAccessor<String>::get(base))[index]);
 		*oob = false;
 	}
 	static void ptr_get(const void *base, int64_t index, void *member) {
@@ -787,7 +787,7 @@ struct VariantIndexedSetGet_String {
 			*valid = false;
 			return;
 		}
-		int64_t length = VariantGetInternalPtr<String>::get_ptr(base)->length();
+		int64_t length = VariantInternalAccessor<String>::get(base).length();
 		if (index < 0) {
 			index += length;
 		}
@@ -796,7 +796,7 @@ struct VariantIndexedSetGet_String {
 			*valid = false;
 			return;
 		}
-		String *b = VariantGetInternalPtr<String>::get_ptr(base);
+		String *b = &VariantInternalAccessor<String>::get(base);
 		const String *v = VariantInternal::get_string(value);
 		if (v->length() == 0) {
 			b->remove_at(index);
@@ -807,7 +807,7 @@ struct VariantIndexedSetGet_String {
 		*valid = true;
 	}
 	static void validated_set(Variant *base, int64_t index, const Variant *value, bool *oob) {
-		int64_t length = VariantGetInternalPtr<String>::get_ptr(base)->length();
+		int64_t length = VariantInternalAccessor<String>::get(base).length();
 		if (index < 0) {
 			index += length;
 		}
@@ -815,7 +815,7 @@ struct VariantIndexedSetGet_String {
 			*oob = true;
 			return;
 		}
-		String *b = VariantGetInternalPtr<String>::get_ptr(base);
+		String *b = &VariantInternalAccessor<String>::get(base);
 		const String *v = VariantInternal::get_string(value);
 		if (v->length() == 0) {
 			b->remove_at(index);
@@ -1004,7 +1004,7 @@ uint64_t Variant::get_indexed_size() const {
 
 struct VariantKeyedSetGetDictionary {
 	static void get(const Variant *base, const Variant *key, Variant *value, bool *r_valid) {
-		const Variant *ptr = VariantGetInternalPtr<Dictionary>::get_ptr(base)->getptr(*key);
+		const Variant *ptr = VariantInternalAccessor<Dictionary>::get(base).getptr(*key);
 		if (!ptr) {
 			*r_valid = false;
 			return;
@@ -1020,7 +1020,7 @@ struct VariantKeyedSetGetDictionary {
 		PtrToArg<Variant>::encode(*ptr, value);
 	}
 	static void set(Variant *base, const Variant *key, const Variant *value, bool *r_valid) {
-		*r_valid = VariantGetInternalPtr<Dictionary>::get_ptr(base)->set(*key, *value);
+		*r_valid = VariantInternalAccessor<Dictionary>::get(base).set(*key, *value);
 	}
 	static void ptr_set(void *base, const void *key, const void *value) {
 		Dictionary &v = *reinterpret_cast<Dictionary *>(base);
@@ -1029,7 +1029,7 @@ struct VariantKeyedSetGetDictionary {
 
 	static bool has(const Variant *base, const Variant *key, bool *r_valid) {
 		*r_valid = true;
-		return VariantGetInternalPtr<Dictionary>::get_ptr(base)->has(*key);
+		return VariantInternalAccessor<Dictionary>::get(base).has(*key);
 	}
 	static uint32_t ptr_has(const void *base, const void *key) {
 		/* avoid ptrconvert for performance*/
@@ -1197,13 +1197,13 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid,
 	} else {
 		bool valid = false;
 		if (p_index.get_type() == STRING_NAME) {
-			set_named(*VariantGetInternalPtr<StringName>::get_ptr(&p_index), p_value, valid);
+			set_named(VariantInternalAccessor<StringName>::get(&p_index), p_value, valid);
 			if (!valid && err_code) {
 				*err_code = VariantSetError::SET_NAMED_ERR;
 			}
 		} else if (p_index.get_type() == INT) {
 			bool obb;
-			set_indexed(*VariantGetInternalPtr<int64_t>::get_ptr(&p_index), p_value, valid, obb);
+			set_indexed(VariantInternalAccessor<int64_t>::get(&p_index), p_value, valid, obb);
 			if (obb) {
 				valid = false;
 				if (err_code) {
@@ -1211,13 +1211,13 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid,
 				}
 			}
 		} else if (p_index.get_type() == STRING) { // less efficient version of named
-			set_named(*VariantGetInternalPtr<String>::get_ptr(&p_index), p_value, valid);
+			set_named(VariantInternalAccessor<String>::get(&p_index), p_value, valid);
 			if (!valid && err_code) {
 				*err_code = VariantSetError::SET_NAMED_ERR;
 			}
 		} else if (p_index.get_type() == FLOAT) { // less efficient version of indexed
 			bool obb;
-			set_indexed(*VariantGetInternalPtr<double>::get_ptr(&p_index), p_value, valid, obb);
+			set_indexed(VariantInternalAccessor<double>::get(&p_index), p_value, valid, obb);
 			if (obb) {
 				valid = false;
 				if (err_code) {
@@ -1248,13 +1248,13 @@ Variant Variant::get(const Variant &p_index, bool *r_valid, VariantGetError *err
 	} else {
 		bool valid = false;
 		if (p_index.get_type() == STRING_NAME) {
-			ret = get_named(*VariantGetInternalPtr<StringName>::get_ptr(&p_index), valid);
+			ret = get_named(VariantInternalAccessor<StringName>::get(&p_index), valid);
 			if (!valid && err_code) {
 				*err_code = VariantGetError::GET_NAMED_ERR;
 			}
 		} else if (p_index.get_type() == INT) {
 			bool obb;
-			ret = get_indexed(*VariantGetInternalPtr<int64_t>::get_ptr(&p_index), valid, obb);
+			ret = get_indexed(VariantInternalAccessor<int64_t>::get(&p_index), valid, obb);
 			if (obb) {
 				valid = false;
 				if (err_code) {
@@ -1262,13 +1262,13 @@ Variant Variant::get(const Variant &p_index, bool *r_valid, VariantGetError *err
 				}
 			}
 		} else if (p_index.get_type() == STRING) { // less efficient version of named
-			ret = get_named(*VariantGetInternalPtr<String>::get_ptr(&p_index), valid);
+			ret = get_named(VariantInternalAccessor<String>::get(&p_index), valid);
 			if (!valid && err_code) {
 				*err_code = VariantGetError::GET_NAMED_ERR;
 			}
 		} else if (p_index.get_type() == FLOAT) { // less efficient version of indexed
 			bool obb;
-			ret = get_indexed(*VariantGetInternalPtr<double>::get_ptr(&p_index), valid, obb);
+			ret = get_indexed(VariantInternalAccessor<double>::get(&p_index), valid, obb);
 			if (obb) {
 				valid = false;
 				if (err_code) {

core/variant/variant_setget.h

@@ -38,244 +38,244 @@
 
 /**** NAMED SETTERS AND GETTERS ****/
 
-#define SETGET_STRUCT(m_base_type, m_member_type, m_member)                                                                          \
-	struct VariantSetGet_##m_base_type##_##m_member {                                                                                \
-		static void get(const Variant *base, Variant *member) {                                                                      \
-			VariantTypeAdjust<m_member_type>::adjust(member);                                                                        \
-			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member;    \
-		}                                                                                                                            \
-		static inline void validated_get(const Variant *base, Variant *member) {                                                     \
-			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member;    \
-		}                                                                                                                            \
-		static void ptr_get(const void *base, void *member) {                                                                        \
-			PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_member, member);                                  \
-		}                                                                                                                            \
-		static void set(Variant *base, const Variant *value, bool &valid) {                                                          \
-			if (value->get_type() == GetTypeInfo<m_member_type>::VARIANT_TYPE) {                                                     \
-				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member = *VariantGetInternalPtr<m_member_type>::get_ptr(value); \
-				valid = true;                                                                                                        \
-			} else {                                                                                                                 \
-				valid = false;                                                                                                       \
-			}                                                                                                                        \
-		}                                                                                                                            \
-		static inline void validated_set(Variant *base, const Variant *value) {                                                      \
-			VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member = *VariantGetInternalPtr<m_member_type>::get_ptr(value);     \
-		}                                                                                                                            \
-		static void ptr_set(void *base, const void *member) {                                                                        \
-			m_base_type b = PtrToArg<m_base_type>::convert(base);                                                                    \
-			b.m_member = PtrToArg<m_member_type>::convert(member);                                                                   \
-			PtrToArg<m_base_type>::encode(b, base);                                                                                  \
-		}                                                                                                                            \
-		static Variant::Type get_type() {                                                                                            \
-			return GetTypeInfo<m_member_type>::VARIANT_TYPE;                                                                         \
-		}                                                                                                                            \
+#define SETGET_STRUCT(m_base_type, m_member_type, m_member)                                                                    \
+	struct VariantSetGet_##m_base_type##_##m_member {                                                                          \
+		static void get(const Variant *base, Variant *member) {                                                                \
+			VariantTypeAdjust<m_member_type>::adjust(member);                                                                  \
+			VariantInternalAccessor<m_member_type>::get(member) = VariantInternalAccessor<m_base_type>::get(base).m_member;    \
+		}                                                                                                                      \
+		static inline void validated_get(const Variant *base, Variant *member) {                                               \
+			VariantInternalAccessor<m_member_type>::get(member) = VariantInternalAccessor<m_base_type>::get(base).m_member;    \
+		}                                                                                                                      \
+		static void ptr_get(const void *base, void *member) {                                                                  \
+			PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_member, member);                            \
+		}                                                                                                                      \
+		static void set(Variant *base, const Variant *value, bool &valid) {                                                    \
+			if (value->get_type() == GetTypeInfo<m_member_type>::VARIANT_TYPE) {                                               \
+				VariantInternalAccessor<m_base_type>::get(base).m_member = VariantInternalAccessor<m_member_type>::get(value); \
+				valid = true;                                                                                                  \
+			} else {                                                                                                           \
+				valid = false;                                                                                                 \
+			}                                                                                                                  \
+		}                                                                                                                      \
+		static inline void validated_set(Variant *base, const Variant *value) {                                                \
+			VariantInternalAccessor<m_base_type>::get(base).m_member = VariantInternalAccessor<m_member_type>::get(value);     \
+		}                                                                                                                      \
+		static void ptr_set(void *base, const void *member) {                                                                  \
+			m_base_type b = PtrToArg<m_base_type>::convert(base);                                                              \
+			b.m_member = PtrToArg<m_member_type>::convert(member);                                                             \
+			PtrToArg<m_base_type>::encode(b, base);                                                                            \
+		}                                                                                                                      \
+		static Variant::Type get_type() {                                                                                      \
+			return GetTypeInfo<m_member_type>::VARIANT_TYPE;                                                                   \
+		}                                                                                                                      \
 	};
 
-#define SETGET_NUMBER_STRUCT(m_base_type, m_member_type, m_member)                                                                \
-	struct VariantSetGet_##m_base_type##_##m_member {                                                                             \
-		static void get(const Variant *base, Variant *member) {                                                                   \
-			VariantTypeAdjust<m_member_type>::adjust(member);                                                                     \
-			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member; \
-		}                                                                                                                         \
-		static inline void validated_get(const Variant *base, Variant *member) {                                                  \
-			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member; \
-		}                                                                                                                         \
-		static void ptr_get(const void *base, void *member) {                                                                     \
-			PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_member, member);                               \
-		}                                                                                                                         \
-		static void set(Variant *base, const Variant *value, bool &valid) {                                                       \
-			if (value->get_type() == Variant::FLOAT) {                                                                            \
-				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member = *VariantGetInternalPtr<double>::get_ptr(value);     \
-				valid = true;                                                                                                     \
-			} else if (value->get_type() == Variant::INT) {                                                                       \
-				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member = *VariantGetInternalPtr<int64_t>::get_ptr(value);    \
-				valid = true;                                                                                                     \
-			} else {                                                                                                              \
-				valid = false;                                                                                                    \
-			}                                                                                                                     \
-		}                                                                                                                         \
-		static inline void validated_set(Variant *base, const Variant *value) {                                                   \
-			VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member = *VariantGetInternalPtr<m_member_type>::get_ptr(value);  \
-		}                                                                                                                         \
-		static void ptr_set(void *base, const void *member) {                                                                     \
-			m_base_type b = PtrToArg<m_base_type>::convert(base);                                                                 \
-			b.m_member = PtrToArg<m_member_type>::convert(member);                                                                \
-			PtrToArg<m_base_type>::encode(b, base);                                                                               \
-		}                                                                                                                         \
-		static Variant::Type get_type() {                                                                                         \
-			return GetTypeInfo<m_member_type>::VARIANT_TYPE;                                                                      \
-		}                                                                                                                         \
+#define SETGET_NUMBER_STRUCT(m_base_type, m_member_type, m_member)                                                          \
+	struct VariantSetGet_##m_base_type##_##m_member {                                                                       \
+		static void get(const Variant *base, Variant *member) {                                                             \
+			VariantTypeAdjust<m_member_type>::adjust(member);                                                               \
+			VariantInternalAccessor<m_member_type>::get(member) = VariantInternalAccessor<m_base_type>::get(base).m_member; \
+		}                                                                                                                   \
+		static inline void validated_get(const Variant *base, Variant *member) {                                            \
+			VariantInternalAccessor<m_member_type>::get(member) = VariantInternalAccessor<m_base_type>::get(base).m_member; \
+		}                                                                                                                   \
+		static void ptr_get(const void *base, void *member) {                                                               \
+			PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_member, member);                         \
+		}                                                                                                                   \
+		static void set(Variant *base, const Variant *value, bool &valid) {                                                 \
+			if (value->get_type() == Variant::FLOAT) {                                                                      \
+				VariantInternalAccessor<m_base_type>::get(base).m_member = VariantInternalAccessor<double>::get(value);     \
+				valid = true;                                                                                               \
+			} else if (value->get_type() == Variant::INT) {                                                                 \
+				VariantInternalAccessor<m_base_type>::get(base).m_member = VariantInternalAccessor<int64_t>::get(value);    \
+				valid = true;                                                                                               \
+			} else {                                                                                                        \
+				valid = false;                                                                                              \
+			}                                                                                                               \
+		}                                                                                                                   \
+		static inline void validated_set(Variant *base, const Variant *value) {                                             \
+			VariantInternalAccessor<m_base_type>::get(base).m_member = VariantInternalAccessor<m_member_type>::get(value);  \
+		}                                                                                                                   \
+		static void ptr_set(void *base, const void *member) {                                                               \
+			m_base_type b = PtrToArg<m_base_type>::convert(base);                                                           \
+			b.m_member = PtrToArg<m_member_type>::convert(member);                                                          \
+			PtrToArg<m_base_type>::encode(b, base);                                                                         \
+		}                                                                                                                   \
+		static Variant::Type get_type() {                                                                                   \
+			return GetTypeInfo<m_member_type>::VARIANT_TYPE;                                                                \
+		}                                                                                                                   \
 	};
 
-#define SETGET_STRUCT_CUSTOM(m_base_type, m_member_type, m_member, m_custom)                                                         \
-	struct VariantSetGet_##m_base_type##_##m_member {                                                                                \
-		static void get(const Variant *base, Variant *member) {                                                                      \
-			VariantTypeAdjust<m_member_type>::adjust(member);                                                                        \
-			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom;    \
-		}                                                                                                                            \
-		static inline void validated_get(const Variant *base, Variant *member) {                                                     \
-			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom;    \
-		}                                                                                                                            \
-		static void ptr_get(const void *base, void *member) {                                                                        \
-			PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_custom, member);                                  \
-		}                                                                                                                            \
-		static void set(Variant *base, const Variant *value, bool &valid) {                                                          \
-			if (value->get_type() == GetTypeInfo<m_member_type>::VARIANT_TYPE) {                                                     \
-				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom = *VariantGetInternalPtr<m_member_type>::get_ptr(value); \
-				valid = true;                                                                                                        \
-			} else {                                                                                                                 \
-				valid = false;                                                                                                       \
-			}                                                                                                                        \
-		}                                                                                                                            \
-		static inline void validated_set(Variant *base, const Variant *value) {                                                      \
-			VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom = *VariantGetInternalPtr<m_member_type>::get_ptr(value);     \
-		}                                                                                                                            \
-		static void ptr_set(void *base, const void *member) {                                                                        \
-			m_base_type b = PtrToArg<m_base_type>::convert(base);                                                                    \
-			b.m_custom = PtrToArg<m_member_type>::convert(member);                                                                   \
-			PtrToArg<m_base_type>::encode(b, base);                                                                                  \
-		}                                                                                                                            \
-		static Variant::Type get_type() {                                                                                            \
-			return GetTypeInfo<m_member_type>::VARIANT_TYPE;                                                                         \
-		}                                                                                                                            \
+#define SETGET_STRUCT_CUSTOM(m_base_type, m_member_type, m_member, m_custom)                                                   \
+	struct VariantSetGet_##m_base_type##_##m_member {                                                                          \
+		static void get(const Variant *base, Variant *member) {                                                                \
+			VariantTypeAdjust<m_member_type>::adjust(member);                                                                  \
+			VariantInternalAccessor<m_member_type>::get(member) = VariantInternalAccessor<m_base_type>::get(base).m_custom;    \
+		}                                                                                                                      \
+		static inline void validated_get(const Variant *base, Variant *member) {                                               \
+			VariantInternalAccessor<m_member_type>::get(member) = VariantInternalAccessor<m_base_type>::get(base).m_custom;    \
+		}                                                                                                                      \
+		static void ptr_get(const void *base, void *member) {                                                                  \
+			PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_custom, member);                            \
+		}                                                                                                                      \
+		static void set(Variant *base, const Variant *value, bool &valid) {                                                    \
+			if (value->get_type() == GetTypeInfo<m_member_type>::VARIANT_TYPE) {                                               \
+				VariantInternalAccessor<m_base_type>::get(base).m_custom = VariantInternalAccessor<m_member_type>::get(value); \
+				valid = true;                                                                                                  \
+			} else {                                                                                                           \
+				valid = false;                                                                                                 \
+			}                                                                                                                  \
+		}                                                                                                                      \
+		static inline void validated_set(Variant *base, const Variant *value) {                                                \
+			VariantInternalAccessor<m_base_type>::get(base).m_custom = VariantInternalAccessor<m_member_type>::get(value);     \
+		}                                                                                                                      \
+		static void ptr_set(void *base, const void *member) {                                                                  \
+			m_base_type b = PtrToArg<m_base_type>::convert(base);                                                              \
+			b.m_custom = PtrToArg<m_member_type>::convert(member);                                                             \
+			PtrToArg<m_base_type>::encode(b, base);                                                                            \
+		}                                                                                                                      \
+		static Variant::Type get_type() {                                                                                      \
+			return GetTypeInfo<m_member_type>::VARIANT_TYPE;                                                                   \
+		}                                                                                                                      \
 	};
 
-#define SETGET_NUMBER_STRUCT_CUSTOM(m_base_type, m_member_type, m_member, m_custom)                                               \
-	struct VariantSetGet_##m_base_type##_##m_member {                                                                             \
-		static void get(const Variant *base, Variant *member) {                                                                   \
-			VariantTypeAdjust<m_member_type>::adjust(member);                                                                     \
-			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom; \
-		}                                                                                                                         \
-		static inline void validated_get(const Variant *base, Variant *member) {                                                  \
-			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom; \
-		}                                                                                                                         \
-		static void ptr_get(const void *base, void *member) {                                                                     \
-			PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_custom, member);                               \
-		}                                                                                                                         \
-		static void set(Variant *base, const Variant *value, bool &valid) {                                                       \
-			if (value->get_type() == Variant::FLOAT) {                                                                            \
-				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom = *VariantGetInternalPtr<double>::get_ptr(value);     \
-				valid = true;                                                                                                     \
-			} else if (value->get_type() == Variant::INT) {                                                                       \
-				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom = *VariantGetInternalPtr<int64_t>::get_ptr(value);    \
-				valid = true;                                                                                                     \
-			} else {                                                                                                              \
-				valid = false;                                                                                                    \
-			}                                                                                                                     \
-		}                                                                                                                         \
-		static inline void validated_set(Variant *base, const Variant *value) {                                                   \
-			VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom = *VariantGetInternalPtr<m_member_type>::get_ptr(value);  \
-		}                                                                                                                         \
-		static void ptr_set(void *base, const void *member) {                                                                     \
-			m_base_type b = PtrToArg<m_base_type>::convert(base);                                                                 \
-			b.m_custom = PtrToArg<m_member_type>::convert(member);                                                                \
-			PtrToArg<m_base_type>::encode(b, base);                                                                               \
-		}                                                                                                                         \
-		static Variant::Type get_type() {                                                                                         \
-			return GetTypeInfo<m_member_type>::VARIANT_TYPE;                                                                      \
-		}                                                                                                                         \
+#define SETGET_NUMBER_STRUCT_CUSTOM(m_base_type, m_member_type, m_member, m_custom)                                         \
+	struct VariantSetGet_##m_base_type##_##m_member {                                                                       \
+		static void get(const Variant *base, Variant *member) {                                                             \
+			VariantTypeAdjust<m_member_type>::adjust(member);                                                               \
+			VariantInternalAccessor<m_member_type>::get(member) = VariantInternalAccessor<m_base_type>::get(base).m_custom; \
+		}                                                                                                                   \
+		static inline void validated_get(const Variant *base, Variant *member) {                                            \
+			VariantInternalAccessor<m_member_type>::get(member) = VariantInternalAccessor<m_base_type>::get(base).m_custom; \
+		}                                                                                                                   \
+		static void ptr_get(const void *base, void *member) {                                                               \
+			PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_custom, member);                         \
+		}                                                                                                                   \
+		static void set(Variant *base, const Variant *value, bool &valid) {                                                 \
+			if (value->get_type() == Variant::FLOAT) {                                                                      \
+				VariantInternalAccessor<m_base_type>::get(base).m_custom = VariantInternalAccessor<double>::get(value);     \
+				valid = true;                                                                                               \
+			} else if (value->get_type() == Variant::INT) {                                                                 \
+				VariantInternalAccessor<m_base_type>::get(base).m_custom = VariantInternalAccessor<int64_t>::get(value);    \
+				valid = true;                                                                                               \
+			} else {                                                                                                        \
+				valid = false;                                                                                              \
+			}                                                                                                               \
+		}                                                                                                                   \
+		static inline void validated_set(Variant *base, const Variant *value) {                                             \
+			VariantInternalAccessor<m_base_type>::get(base).m_custom = VariantInternalAccessor<m_member_type>::get(value);  \
+		}                                                                                                                   \
+		static void ptr_set(void *base, const void *member) {                                                               \
+			m_base_type b = PtrToArg<m_base_type>::convert(base);                                                           \
+			b.m_custom = PtrToArg<m_member_type>::convert(member);                                                          \
+			PtrToArg<m_base_type>::encode(b, base);                                                                         \
+		}                                                                                                                   \
+		static Variant::Type get_type() {                                                                                   \
+			return GetTypeInfo<m_member_type>::VARIANT_TYPE;                                                                \
+		}                                                                                                                   \
 	};
 
-#define SETGET_STRUCT_FUNC(m_base_type, m_member_type, m_member, m_setter, m_getter)                                                \
-	struct VariantSetGet_##m_base_type##_##m_member {                                                                               \
-		static void get(const Variant *base, Variant *member) {                                                                     \
-			VariantTypeAdjust<m_member_type>::adjust(member);                                                                       \
-			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_getter(); \
-		}                                                                                                                           \
-		static inline void validated_get(const Variant *base, Variant *member) {                                                    \
-			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_getter(); \
-		}                                                                                                                           \
-		static void ptr_get(const void *base, void *member) {                                                                       \
-			PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_getter(), member);                               \
-		}                                                                                                                           \
-		static void set(Variant *base, const Variant *value, bool &valid) {                                                         \
-			if (value->get_type() == GetTypeInfo<m_member_type>::VARIANT_TYPE) {                                                    \
-				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_setter(*VariantGetInternalPtr<m_member_type>::get_ptr(value)); \
-				valid = true;                                                                                                       \
-			} else {                                                                                                                \
-				valid = false;                                                                                                      \
-			}                                                                                                                       \
-		}                                                                                                                           \
-		static inline void validated_set(Variant *base, const Variant *value) {                                                     \
-			VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_setter(*VariantGetInternalPtr<m_member_type>::get_ptr(value));     \
-		}                                                                                                                           \
-		static void ptr_set(void *base, const void *member) {                                                                       \
-			m_base_type b = PtrToArg<m_base_type>::convert(base);                                                                   \
-			b.m_setter(PtrToArg<m_member_type>::convert(member));                                                                   \
-			PtrToArg<m_base_type>::encode(b, base);                                                                                 \
-		}                                                                                                                           \
-		static Variant::Type get_type() {                                                                                           \
-			return GetTypeInfo<m_member_type>::VARIANT_TYPE;                                                                        \
-		}                                                                                                                           \
+#define SETGET_STRUCT_FUNC(m_base_type, m_member_type, m_member, m_setter, m_getter)                                          \
+	struct VariantSetGet_##m_base_type##_##m_member {                                                                         \
+		static void get(const Variant *base, Variant *member) {                                                               \
+			VariantTypeAdjust<m_member_type>::adjust(member);                                                                 \
+			VariantInternalAccessor<m_member_type>::get(member) = VariantInternalAccessor<m_base_type>::get(base).m_getter(); \
+		}                                                                                                                     \
+		static inline void validated_get(const Variant *base, Variant *member) {                                              \
+			VariantInternalAccessor<m_member_type>::get(member) = VariantInternalAccessor<m_base_type>::get(base).m_getter(); \
+		}                                                                                                                     \
+		static void ptr_get(const void *base, void *member) {                                                                 \
+			PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_getter(), member);                         \
+		}                                                                                                                     \
+		static void set(Variant *base, const Variant *value, bool &valid) {                                                   \
+			if (value->get_type() == GetTypeInfo<m_member_type>::VARIANT_TYPE) {                                              \
+				VariantInternalAccessor<m_base_type>::get(base).m_setter(VariantInternalAccessor<m_member_type>::get(value)); \
+				valid = true;                                                                                                 \
+			} else {                                                                                                          \
+				valid = false;                                                                                                \
+			}                                                                                                                 \
+		}                                                                                                                     \
+		static inline void validated_set(Variant *base, const Variant *value) {                                               \
+			VariantInternalAccessor<m_base_type>::get(base).m_setter(VariantInternalAccessor<m_member_type>::get(value));     \
+		}                                                                                                                     \
+		static void ptr_set(void *base, const void *member) {                                                                 \
+			m_base_type b = PtrToArg<m_base_type>::convert(base);                                                             \
+			b.m_setter(PtrToArg<m_member_type>::convert(member));                                                             \
+			PtrToArg<m_base_type>::encode(b, base);                                                                           \
+		}                                                                                                                     \
+		static Variant::Type get_type() {                                                                                     \
+			return GetTypeInfo<m_member_type>::VARIANT_TYPE;                                                                  \
+		}                                                                                                                     \
 	};
 
-#define SETGET_NUMBER_STRUCT_FUNC(m_base_type, m_member_type, m_member, m_setter, m_getter)                                         \
-	struct VariantSetGet_##m_base_type##_##m_member {                                                                               \
-		static void get(const Variant *base, Variant *member) {                                                                     \
-			VariantTypeAdjust<m_member_type>::adjust(member);                                                                       \
-			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_getter(); \
-		}                                                                                                                           \
-		static inline void validated_get(const Variant *base, Variant *member) {                                                    \
-			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_getter(); \
-		}                                                                                                                           \
-		static void ptr_get(const void *base, void *member) {                                                                       \
-			PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_getter(), member);                               \
-		}                                                                                                                           \
-		static void set(Variant *base, const Variant *value, bool &valid) {                                                         \
-			if (value->get_type() == Variant::FLOAT) {                                                                              \
-				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_setter(*VariantGetInternalPtr<double>::get_ptr(value));        \
-				valid = true;                                                                                                       \
-			} else if (value->get_type() == Variant::INT) {                                                                         \
-				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_setter(*VariantGetInternalPtr<int64_t>::get_ptr(value));       \
-				valid = true;                                                                                                       \
-			} else {                                                                                                                \
-				valid = false;                                                                                                      \
-			}                                                                                                                       \
-		}                                                                                                                           \
-		static inline void validated_set(Variant *base, const Variant *value) {                                                     \
-			VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_setter(*VariantGetInternalPtr<m_member_type>::get_ptr(value));     \
-		}                                                                                                                           \
-		static void ptr_set(void *base, const void *member) {                                                                       \
-			m_base_type b = PtrToArg<m_base_type>::convert(base);                                                                   \
-			b.m_setter(PtrToArg<m_member_type>::convert(member));                                                                   \
-			PtrToArg<m_base_type>::encode(b, base);                                                                                 \
-		}                                                                                                                           \
-		static Variant::Type get_type() {                                                                                           \
-			return GetTypeInfo<m_member_type>::VARIANT_TYPE;                                                                        \
-		}                                                                                                                           \
+#define SETGET_NUMBER_STRUCT_FUNC(m_base_type, m_member_type, m_member, m_setter, m_getter)                                   \
+	struct VariantSetGet_##m_base_type##_##m_member {                                                                         \
+		static void get(const Variant *base, Variant *member) {                                                               \
+			VariantTypeAdjust<m_member_type>::adjust(member);                                                                 \
+			VariantInternalAccessor<m_member_type>::get(member) = VariantInternalAccessor<m_base_type>::get(base).m_getter(); \
+		}                                                                                                                     \
+		static inline void validated_get(const Variant *base, Variant *member) {                                              \
+			VariantInternalAccessor<m_member_type>::get(member) = VariantInternalAccessor<m_base_type>::get(base).m_getter(); \
+		}                                                                                                                     \
+		static void ptr_get(const void *base, void *member) {                                                                 \
+			PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_getter(), member);                         \
+		}                                                                                                                     \
+		static void set(Variant *base, const Variant *value, bool &valid) {                                                   \
+			if (value->get_type() == Variant::FLOAT) {                                                                        \
+				VariantInternalAccessor<m_base_type>::get(base).m_setter(VariantInternalAccessor<double>::get(value));        \
+				valid = true;                                                                                                 \
+			} else if (value->get_type() == Variant::INT) {                                                                   \
+				VariantInternalAccessor<m_base_type>::get(base).m_setter(VariantInternalAccessor<int64_t>::get(value));       \
+				valid = true;                                                                                                 \
+			} else {                                                                                                          \
+				valid = false;                                                                                                \
+			}                                                                                                                 \
+		}                                                                                                                     \
+		static inline void validated_set(Variant *base, const Variant *value) {                                               \
+			VariantInternalAccessor<m_base_type>::get(base).m_setter(VariantInternalAccessor<m_member_type>::get(value));     \
+		}                                                                                                                     \
+		static void ptr_set(void *base, const void *member) {                                                                 \
+			m_base_type b = PtrToArg<m_base_type>::convert(base);                                                             \
+			b.m_setter(PtrToArg<m_member_type>::convert(member));                                                             \
+			PtrToArg<m_base_type>::encode(b, base);                                                                           \
+		}                                                                                                                     \
+		static Variant::Type get_type() {                                                                                     \
+			return GetTypeInfo<m_member_type>::VARIANT_TYPE;                                                                  \
+		}                                                                                                                     \
 	};
 
-#define SETGET_STRUCT_FUNC_INDEX(m_base_type, m_member_type, m_member, m_setter, m_getter, m_index)                                          \
-	struct VariantSetGet_##m_base_type##_##m_member {                                                                                        \
-		static void get(const Variant *base, Variant *member) {                                                                              \
-			VariantTypeAdjust<m_member_type>::adjust(member);                                                                                \
-			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_getter(m_index);   \
-		}                                                                                                                                    \
-		static inline void validated_get(const Variant *base, Variant *member) {                                                             \
-			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_getter(m_index);   \
-		}                                                                                                                                    \
-		static void ptr_get(const void *base, void *member) {                                                                                \
-			PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_getter(m_index), member);                                 \
-		}                                                                                                                                    \
-		static void set(Variant *base, const Variant *value, bool &valid) {                                                                  \
-			if (value->get_type() == GetTypeInfo<m_member_type>::VARIANT_TYPE) {                                                             \
-				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_setter(m_index, *VariantGetInternalPtr<m_member_type>::get_ptr(value)); \
-				valid = true;                                                                                                                \
-			} else {                                                                                                                         \
-				valid = false;                                                                                                               \
-			}                                                                                                                                \
-		}                                                                                                                                    \
-		static inline void validated_set(Variant *base, const Variant *value) {                                                              \
-			VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_setter(m_index, *VariantGetInternalPtr<m_member_type>::get_ptr(value));     \
-		}                                                                                                                                    \
-		static void ptr_set(void *base, const void *member) {                                                                                \
-			m_base_type b = PtrToArg<m_base_type>::convert(base);                                                                            \
-			b.m_setter(m_index, PtrToArg<m_member_type>::convert(member));                                                                   \
-			PtrToArg<m_base_type>::encode(b, base);                                                                                          \
-		}                                                                                                                                    \
-		static Variant::Type get_type() {                                                                                                    \
-			return GetTypeInfo<m_member_type>::VARIANT_TYPE;                                                                                 \
-		}                                                                                                                                    \
+#define SETGET_STRUCT_FUNC_INDEX(m_base_type, m_member_type, m_member, m_setter, m_getter, m_index)                                    \
+	struct VariantSetGet_##m_base_type##_##m_member {                                                                                  \
+		static void get(const Variant *base, Variant *member) {                                                                        \
+			VariantTypeAdjust<m_member_type>::adjust(member);                                                                          \
+			VariantInternalAccessor<m_member_type>::get(member) = VariantInternalAccessor<m_base_type>::get(base).m_getter(m_index);   \
+		}                                                                                                                              \
+		static inline void validated_get(const Variant *base, Variant *member) {                                                       \
+			VariantInternalAccessor<m_member_type>::get(member) = VariantInternalAccessor<m_base_type>::get(base).m_getter(m_index);   \
+		}                                                                                                                              \
+		static void ptr_get(const void *base, void *member) {                                                                          \
+			PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_getter(m_index), member);                           \
+		}                                                                                                                              \
+		static void set(Variant *base, const Variant *value, bool &valid) {                                                            \
+			if (value->get_type() == GetTypeInfo<m_member_type>::VARIANT_TYPE) {                                                       \
+				VariantInternalAccessor<m_base_type>::get(base).m_setter(m_index, VariantInternalAccessor<m_member_type>::get(value)); \
+				valid = true;                                                                                                          \
+			} else {                                                                                                                   \
+				valid = false;                                                                                                         \
+			}                                                                                                                          \
+		}                                                                                                                              \
+		static inline void validated_set(Variant *base, const Variant *value) {                                                        \
+			VariantInternalAccessor<m_base_type>::get(base).m_setter(m_index, VariantInternalAccessor<m_member_type>::get(value));     \
+		}                                                                                                                              \
+		static void ptr_set(void *base, const void *member) {                                                                          \
+			m_base_type b = PtrToArg<m_base_type>::convert(base);                                                                      \
+			b.m_setter(m_index, PtrToArg<m_member_type>::convert(member));                                                             \
+			PtrToArg<m_base_type>::encode(b, base);                                                                                    \
+		}                                                                                                                              \
+		static Variant::Type get_type() {                                                                                              \
+			return GetTypeInfo<m_member_type>::VARIANT_TYPE;                                                                           \
+		}                                                                                                                              \
 	};
 
 SETGET_NUMBER_STRUCT(Vector2, double, x)

servers/rendering/shader_language.cpp

@@ -4726,8 +4726,8 @@ Variant ShaderLanguage::get_default_datatype_value(DataType p_type, int p_array_
 				}
 				value = Variant(array);
 			} else {
-				VariantInitializer<float>::init(&value);
-				VariantDefaultInitializer<float>::init(&value);
+				VariantInitializer<double>::init(&value);
+				VariantDefaultInitializer<double>::init(&value);
 			}
 			break;
 		case ShaderLanguage::TYPE_VEC2: