Implement Structs in GDScript

core/extension/extension_api_dump.cpp

@@ -40,6 +40,9 @@
 #include "core/templates/pair.h"
 #include "core/version.h"
 
+// Forward declaration for struct type
+class GDScriptStructInstance;
+
 #ifdef TOOLS_ENABLED
 #include "editor/doc/editor_help.h"
 
@@ -210,6 +213,7 @@ Dictionary GDExtensionAPIDump::generate_extension_api(bool p_include_docs) {
 			{ Variant::NODE_PATH, ptrsize_32, ptrsize_64, ptrsize_32, ptrsize_64 },
 			{ Variant::RID, sizeof(uint64_t), sizeof(uint64_t), sizeof(uint64_t), sizeof(uint64_t) },
 			{ Variant::OBJECT, ptrsize_32, ptrsize_64, ptrsize_32, ptrsize_64 },
+			{ Variant::STRUCT, ptrsize_32, ptrsize_64, ptrsize_32, ptrsize_64 },
 			{ Variant::CALLABLE, sizeof(Callable), sizeof(Callable), sizeof(Callable), sizeof(Callable) }, // Hardcoded align.
 			{ Variant::SIGNAL, sizeof(Signal), sizeof(Signal), sizeof(Signal), sizeof(Signal) }, // Hardcoded align.
 			{ Variant::DICTIONARY, ptrsize_32, ptrsize_64, ptrsize_32, ptrsize_64 },
@@ -252,6 +256,7 @@ Dictionary GDExtensionAPIDump::generate_extension_api(bool p_include_docs) {
 		static_assert(type_size_array[Variant::NODE_PATH][sizeof(void *)] == sizeof(NodePath), "Size of NodePath mismatch");
 		static_assert(type_size_array[Variant::RID][sizeof(void *)] == sizeof(RID), "Size of RID mismatch");
 		static_assert(type_size_array[Variant::OBJECT][sizeof(void *)] == sizeof(Object *), "Size of Object mismatch");
+		static_assert(type_size_array[Variant::STRUCT][sizeof(void *)] == sizeof(GDScriptStructInstance *), "Size of Struct mismatch");
 		static_assert(type_size_array[Variant::CALLABLE][sizeof(void *)] == sizeof(Callable), "Size of Callable mismatch");
 		static_assert(type_size_array[Variant::SIGNAL][sizeof(void *)] == sizeof(Signal), "Size of Signal mismatch");
 		static_assert(type_size_array[Variant::DICTIONARY][sizeof(void *)] == sizeof(Dictionary), "Size of Dictionary mismatch");

core/extension/gdextension_interface.cpp

@@ -817,6 +817,11 @@ static GDExtensionPtrOperatorEvaluator gdextension_variant_get_ptr_operator_eval
 	return (GDExtensionPtrOperatorEvaluator)Variant::get_ptr_operator_evaluator(Variant::Operator(p_operator), Variant::Type(p_type_a), Variant::Type(p_type_b));
 }
 static GDExtensionPtrBuiltInMethod gdextension_variant_get_ptr_builtin_method(GDExtensionVariantType p_type, GDExtensionConstStringNamePtr p_method, GDExtensionInt p_hash) {
+	// STRUCT type doesn't support built-in methods
+	if (p_type == (int)Variant::STRUCT) {
+		return nullptr;
+	}
+
 	const StringName method = *reinterpret_cast<const StringName *>(p_method);
 	uint32_t hash = Variant::get_builtin_method_hash(Variant::Type(p_type), method);
 	if (hash != p_hash) {
@@ -827,6 +832,11 @@ static GDExtensionPtrBuiltInMethod gdextension_variant_get_ptr_builtin_method(GD
 	return (GDExtensionPtrBuiltInMethod)Variant::get_ptr_builtin_method(Variant::Type(p_type), method);
 }
 static GDExtensionPtrConstructor gdextension_variant_get_ptr_constructor(GDExtensionVariantType p_type, int32_t p_constructor) {
+	// STRUCT type doesn't support constructors (yet)
+	if (p_type == (int)Variant::STRUCT) {
+		return nullptr;
+	}
+
 	return (GDExtensionPtrConstructor)Variant::get_ptr_constructor(Variant::Type(p_type), p_constructor);
 }
 static GDExtensionPtrDestructor gdextension_variant_get_ptr_destructor(GDExtensionVariantType p_type) {

core/io/json.cpp

@@ -824,6 +824,11 @@ Variant JSON::_from_native(const Variant &p_variant, bool p_full_objects, int p_
 			return ret;
 		} break;
 
+		case Variant::STRUCT: {
+			// TODO: Implement struct serialization
+			ERR_FAIL_V_MSG(Variant(), vformat("Struct serialization not yet implemented."));
+		} break;
+
 		case Variant::DICTIONARY: {
 			const Dictionary dict = p_variant;
 
@@ -1297,6 +1302,11 @@ Variant JSON::_to_native(const Variant &p_json, bool p_allow_objects, int p_dept
 					// Nothing to do at this stage. `Object` should be treated as a class, not as a built-in type.
 				} break;
 
+				case Variant::STRUCT: {
+					// TODO: Implement struct deserialization
+					ERR_FAIL_V_MSG(Variant(), vformat("Struct deserialization not yet implemented."));
+				} break;
+
 				case Variant::DICTIONARY: {
 					LOAD_ARGS_CHECK_FACTOR(2);
 

core/variant/variant.cpp

@@ -37,6 +37,7 @@
 #include "core/io/resource.h"
 #include "core/math/math_funcs.h"
 #include "core/variant/variant_parser.h"
+#include "modules/gdscript/gdscript_struct.h"
 
 PagedAllocator<Variant::Pools::BucketSmall, true> Variant::Pools::_bucket_small;
 PagedAllocator<Variant::Pools::BucketMedium, true> Variant::Pools::_bucket_medium;
@@ -119,6 +120,9 @@ String Variant::get_type_name(Variant::Type p_type) {
 		case OBJECT: {
 			return "Object";
 		}
+		case STRUCT: {
+			return "Struct";
+		}
 		case CALLABLE: {
 			return "Callable";
 		}
@@ -1311,6 +1315,15 @@ void Variant::reference(const Variant &p_variant) {
 				_data.packed_array = PackedArrayRef<Vector4>::create();
 			}
 		} break;
+		case STRUCT: {
+			// Reference the struct instance
+			GDScriptStructInstance *struct_instance = const_cast<GDScriptStructInstance *>(reinterpret_cast<const GDScriptStructInstance *>(p_variant._data._mem));
+			if (struct_instance) {
+				struct_instance->reference();
+			}
+			// Copy the pointer - only copy pointer size, not entire _mem
+			memcpy(_data._mem, p_variant._data._mem, sizeof(void *));
+		} break;
 		default: {
 		}
 	}
@@ -1480,6 +1493,18 @@ void Variant::_clear_internal() {
 		case PACKED_VECTOR4_ARRAY: {
 			PackedArrayRefBase::destroy(_data.packed_array);
 		} break;
+		case STRUCT: {
+			// Unreference the struct instance
+			GDScriptStructInstance *struct_instance = reinterpret_cast<GDScriptStructInstance *>(_data._mem);
+			if (struct_instance) {
+				struct_instance->unreference();
+				if (struct_instance->get_reference_count() == 0) {
+					memdelete(struct_instance);
+				}
+			}
+			// Clear the pointer
+			memset(_data._mem, 0, sizeof(_data._mem));
+		} break;
 		default: {
 			// Not needed, there is no point. The following do not allocate memory:
 			// VECTOR2, VECTOR3, VECTOR4, RECT2, PLANE, QUATERNION, COLOR.
@@ -3490,7 +3515,7 @@ void Variant::construct_from_string(const String &p_string, Variant &r_value, Ob
 
 String Variant::get_construct_string() const {
 	String vars;
-	VariantWriter::write_to_string(*this, vars, nullptr, nullptr, true, true);
+	VariantWriter::write_to_string(*this, vars);
 
 	return vars;
 }

core/variant/variant.h

@@ -67,6 +67,7 @@
 
 class Object;
 class RefCounted;
+class GDScriptStructInstance;
 
 template <typename T>
 class Ref;
@@ -123,6 +124,7 @@ class Variant {
 		NODE_PATH,
 		RID,
 		OBJECT,
+		STRUCT,
 		CALLABLE,
 		SIGNAL,
 		DICTIONARY,
@@ -175,6 +177,7 @@ class Variant {
 
 	friend struct _VariantCall;
 	friend class VariantInternal;
+	friend class GDScriptStructClass; // Needed for proper struct construction
 	// 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),
@@ -310,6 +313,7 @@ class Variant {
 		true, //NODE_PATH,
 		false, //RID,
 		true, //OBJECT,
+		true, //STRUCT,
 		true, //CALLABLE,
 		true, //SIGNAL,
 		true, //DICTIONARY,