Merge pull request #44406 from vnen/variant-ptr-construct

Add PtrConstruct template to use in Variant constructors

core/variant/method_ptrcall.h

@@ -100,6 +100,7 @@ struct PtrToArg {};
 	}
 
 MAKE_PTRARG(bool);
+// Integer types.
 MAKE_PTRARGCONV(uint8_t, int64_t);
 MAKE_PTRARGCONV(int8_t, int64_t);
 MAKE_PTRARGCONV(uint16_t, int64_t);
@@ -108,15 +109,16 @@ MAKE_PTRARGCONV(uint32_t, int64_t);
 MAKE_PTRARGCONV(int32_t, int64_t);
 MAKE_PTRARG(int64_t);
 MAKE_PTRARG(uint64_t);
+// Float types
 MAKE_PTRARGCONV(float, double);
 MAKE_PTRARG(double);
 
 MAKE_PTRARG(String);
 MAKE_PTRARG(Vector2);
-MAKE_PTRARG(Rect2);
-MAKE_PTRARG_BY_REFERENCE(Vector3);
 MAKE_PTRARG(Vector2i);
+MAKE_PTRARG(Rect2);
 MAKE_PTRARG(Rect2i);
+MAKE_PTRARG_BY_REFERENCE(Vector3);
 MAKE_PTRARG_BY_REFERENCE(Vector3i);
 MAKE_PTRARG(Transform2D);
 MAKE_PTRARG_BY_REFERENCE(Plane);
@@ -128,9 +130,10 @@ MAKE_PTRARG_BY_REFERENCE(Color);
 MAKE_PTRARG(StringName);
 MAKE_PTRARG(NodePath);
 MAKE_PTRARG(RID);
-MAKE_PTRARG(Dictionary);
+// Object doesn't need this.
 MAKE_PTRARG(Callable);
 MAKE_PTRARG(Signal);
+MAKE_PTRARG(Dictionary);
 MAKE_PTRARG(Array);
 MAKE_PTRARG(PackedByteArray);
 MAKE_PTRARG(PackedInt32Array);

core/variant/variant_construct.cpp

@@ -39,6 +39,60 @@
 #include "core/templates/local_vector.h"
 #include "core/templates/oa_hash_map.h"
 
+template <class T>
+struct PtrConstruct {};
+
+#define MAKE_PTRCONSTRUCT(m_type)                                                  \
+	template <>                                                                    \
+	struct PtrConstruct<m_type> {                                                  \
+		_FORCE_INLINE_ static void construct(const m_type &p_value, void *p_ptr) { \
+			memnew_placement(p_ptr, m_type(p_value));                              \
+		}                                                                          \
+	};
+
+MAKE_PTRCONSTRUCT(bool);
+MAKE_PTRCONSTRUCT(int64_t);
+MAKE_PTRCONSTRUCT(double);
+MAKE_PTRCONSTRUCT(String);
+MAKE_PTRCONSTRUCT(Vector2);
+MAKE_PTRCONSTRUCT(Vector2i);
+MAKE_PTRCONSTRUCT(Rect2);
+MAKE_PTRCONSTRUCT(Rect2i);
+MAKE_PTRCONSTRUCT(Vector3);
+MAKE_PTRCONSTRUCT(Vector3i);
+MAKE_PTRCONSTRUCT(Transform2D);
+MAKE_PTRCONSTRUCT(Plane);
+MAKE_PTRCONSTRUCT(Quat);
+MAKE_PTRCONSTRUCT(AABB);
+MAKE_PTRCONSTRUCT(Basis);
+MAKE_PTRCONSTRUCT(Transform);
+MAKE_PTRCONSTRUCT(Color);
+MAKE_PTRCONSTRUCT(StringName);
+MAKE_PTRCONSTRUCT(NodePath);
+MAKE_PTRCONSTRUCT(RID);
+
+template <>
+struct PtrConstruct<Object *> {
+	_FORCE_INLINE_ static void construct(Object *p_value, void *p_ptr) {
+		*((Object **)p_ptr) = p_value;
+	}
+};
+
+MAKE_PTRCONSTRUCT(Callable);
+MAKE_PTRCONSTRUCT(Signal);
+MAKE_PTRCONSTRUCT(Dictionary);
+MAKE_PTRCONSTRUCT(Array);
+MAKE_PTRCONSTRUCT(PackedByteArray);
+MAKE_PTRCONSTRUCT(PackedInt32Array);
+MAKE_PTRCONSTRUCT(PackedInt64Array);
+MAKE_PTRCONSTRUCT(PackedFloat32Array);
+MAKE_PTRCONSTRUCT(PackedFloat64Array);
+MAKE_PTRCONSTRUCT(PackedStringArray);
+MAKE_PTRCONSTRUCT(PackedVector2Array);
+MAKE_PTRCONSTRUCT(PackedVector3Array);
+MAKE_PTRCONSTRUCT(PackedColorArray);
+MAKE_PTRCONSTRUCT(Variant);
+
 template <class T, class... P>
 class VariantConstructor {
 	template <size_t... Is>
@@ -59,7 +113,7 @@ class VariantConstructor {
 
 	template <size_t... Is>
 	static _FORCE_INLINE_ void ptr_construct_helper(void *base, const void **p_args, IndexSequence<Is...>) {
-		PtrToArg<T>::encode(T(PtrToArg<P>::convert(p_args[Is])...), base);
+		PtrConstruct<T>::construct(T(PtrToArg<P>::convert(p_args[Is])...), base);
 	}
 
 public:
@@ -112,7 +166,7 @@ public:
 		VariantInternal::object_assign(r_ret, p_args[0]);
 	}
 	static void ptr_construct(void *base, const void **p_args) {
-		PtrToArg<Object *>::encode(PtrToArg<Object *>::convert(p_args[0]), base);
+		PtrConstruct<Object *>::construct(PtrToArg<Object *>::convert(p_args[0]), base);
 	}
 
 	static int get_argument_count() {
@@ -146,7 +200,7 @@ public:
 		VariantInternal::object_assign_null(r_ret);
 	}
 	static void ptr_construct(void *base, const void **p_args) {
-		PtrToArg<Object *>::encode(nullptr, base);
+		PtrConstruct<Object *>::construct(nullptr, base);
 	}
 
 	static int get_argument_count() {
@@ -199,7 +253,7 @@ public:
 		*VariantGetInternalPtr<Callable>::get_ptr(r_ret) = Callable(VariantInternal::get_object_id(p_args[0]), *VariantGetInternalPtr<StringName>::get_ptr(p_args[1]));
 	}
 	static void ptr_construct(void *base, const void **p_args) {
-		PtrToArg<Callable>::encode(Callable(PtrToArg<Object *>::convert(p_args[0]), PtrToArg<StringName>::convert(p_args[1])), base);
+		PtrConstruct<Callable>::construct(Callable(PtrToArg<Object *>::convert(p_args[0]), PtrToArg<StringName>::convert(p_args[1])), base);
 	}
 
 	static int get_argument_count() {
@@ -256,7 +310,7 @@ public:
 		*VariantGetInternalPtr<Signal>::get_ptr(r_ret) = Signal(VariantInternal::get_object_id(p_args[0]), *VariantGetInternalPtr<StringName>::get_ptr(p_args[1]));
 	}
 	static void ptr_construct(void *base, const void **p_args) {
-		PtrToArg<Signal>::encode(Signal(PtrToArg<Object *>::convert(p_args[0]), PtrToArg<StringName>::convert(p_args[1])), base);
+		PtrConstruct<Signal>::construct(Signal(PtrToArg<Object *>::convert(p_args[0]), PtrToArg<StringName>::convert(p_args[1])), base);
 	}
 
 	static int get_argument_count() {
@@ -319,7 +373,7 @@ public:
 			dst_arr[i] = src_arr[i];
 		}
 
-		PtrToArg<Array>::encode(dst_arr, base);
+		PtrConstruct<Array>::construct(dst_arr, base);
 	}
 
 	static int get_argument_count() {
@@ -378,7 +432,7 @@ public:
 			dst_arr.write[i] = src_arr[i];
 		}
 
-		PtrToArg<T>::encode(dst_arr, base);
+		PtrConstruct<T>::construct(dst_arr, base);
 	}
 
 	static int get_argument_count() {
@@ -412,7 +466,7 @@ public:
 		VariantInternal::clear(r_ret);
 	}
 	static void ptr_construct(void *base, const void **p_args) {
-		PtrToArg<Variant>::encode(Variant(), base);
+		PtrConstruct<Variant>::construct(Variant(), base);
 	}
 
 	static int get_argument_count() {
@@ -440,7 +494,7 @@ public:
 		VariantTypeChanger<T>::change_and_reset(r_ret);
 	}
 	static void ptr_construct(void *base, const void **p_args) {
-		PtrToArg<T>::encode(T(), base);
+		PtrConstruct<T>::construct(T(), base);
 	}
 
 	static int get_argument_count() {
@@ -496,7 +550,7 @@ public:
 		VariantInternal::object_assign_null(r_ret);
 	}
 	static void ptr_construct(void *base, const void **p_args) {
-		PtrToArg<Object *>::encode(nullptr, base);
+		PtrConstruct<Object *>::construct(nullptr, base);
 	}
 
 	static int get_argument_count() {