Adding exporting of structs

voylin · voylin · commit 00abe9e85f53 · 2026-03-16T12:25:00.000+09:00
diff --git a/core/object/object.h b/core/object/object.h
@@ -94,6 +94,7 @@ enum PropertyHint {
 	PROPERTY_HINT_INPUT_NAME,
 	PROPERTY_HINT_FILE_PATH,
 	PROPERTY_HINT_MAX,
+	PROPERTY_HINT_STRUCT, // The hint string would be like "script_path::struct_name"
 };
 
 enum PropertyUsageFlags {
diff --git a/core/variant/array.cpp b/core/variant/array.cpp
@@ -994,13 +994,16 @@ void Array::set_named(const StringName &p_member, const Variant &p_value) {
 
 void Array::set_as_struct(const Vector<StringName> &p_names, const Vector<Variant> &p_default_values) {
 	ERR_FAIL_COND_MSG(_p->read_only, "Array is in read-only state.");
-	ERR_FAIL_COND_MSG(_p->array.size() > 0, "Type can only be set when array is empty.");
+	//ERR_FAIL_COND_MSG(_p->array.size() > 0, "Type can only be set when array is empty.");
 	ERR_FAIL_COND_MSG(_p->refcount.get() > 1, "Type can only be set when array has no more than one user.");
 	ERR_FAIL_COND_MSG(_p->typed.type != Variant::NIL || is_struct(), "Type can only be set once.");
 
 	uint32_t p_member_count = p_names.size();
 	ERR_FAIL_COND_MSG(p_default_values.size() != p_member_count, "Struct member vectors must have the same size.");
 
+	// Added this, and commented out the line above as a temporary fix for the exporting.
+	_p->array.clear();
+
 	_p->struct_size = p_member_count;
 	if (p_member_count > 0) {
 		_p->struct_member_names = memnew_arr(StringName, p_member_count);
diff --git a/editor/inspector/editor_properties.cpp b/editor/inspector/editor_properties.cpp
@@ -4253,6 +4253,11 @@ EditorProperty *EditorInspectorDefaultPlugin::get_editor_for_property(Object *p_
 			}
 		} break;
 		case Variant::ARRAY: {
+			if (p_hint == PROPERTY_HINT_STRUCT) {
+				EditorPropertyStruct *editor = memnew(EditorPropertyStruct);
+				editor->setup(p_hint_text);
+				return editor;
+			}
 			EditorPropertyArray *editor = memnew(EditorPropertyArray);
 			editor->setup(Variant::ARRAY, p_hint_text);
 			return editor;
diff --git a/editor/inspector/editor_properties_array_dict.cpp b/editor/inspector/editor_properties_array_dict.cpp
@@ -234,6 +234,226 @@ String EditorPropertyDictionaryObject::get_label_for_index(int p_index) {
 	}
 }
 
+///////////////////// STRUCT ///////////////////////////
+
+bool EditorPropertyStructObject::_set(const StringName &p_name, const Variant &p_value) {
+	String name = p_name;
+	if (!name.begins_with("indices/")) {
+		return false;
+	}
+	int index = name.get_slicec('/', 1).to_int();
+	array.set(index, p_value);
+	return true;
+}
+
+bool EditorPropertyStructObject::_get(const StringName &p_name, Variant &r_ret) const {
+	String name = p_name;
+	if (!name.begins_with("indices/")) {
+		return false;
+	}
+	int index = name.get_slicec('/', 1).to_int();
+	bool valid;
+	r_ret = array.get(index, &valid);
+	if (r_ret.get_type() == Variant::OBJECT && Object::cast_to<EncodedObjectAsID>(r_ret)) {
+		r_ret = Object::cast_to<EncodedObjectAsID>(r_ret)->get_object_id();
+	}
+	return valid;
+}
+
+void EditorPropertyStructObject::set_array(const Variant &p_array) {
+	array = p_array;
+}
+
+Variant EditorPropertyStructObject::get_array() {
+	return array;
+}
+
+void EditorPropertyStruct::_property_changed(const String &p_property, Variant p_value, const String &p_name, bool p_changing) {
+	if (!p_property.begins_with("indices/")) {
+		return;
+	}
+	if (p_value.get_type() == Variant::OBJECT && p_value.is_null()) {
+		p_value = Variant();
+	}
+	int index = p_property.get_slicec('/', 1).to_int();
+	Variant array = object->get_array().duplicate();
+	array.set(index, p_value);
+	emit_changed(get_edited_property(), array, p_name, p_changing);
+	if (p_changing) {
+		object->set_array(array);
+	}
+}
+
+void EditorPropertyStruct::_edit_pressed() {
+	Variant array = get_edited_property_value();
+	if (!array.is_array() && edit->is_pressed()) {
+		Array arr;
+		arr.resize(fields.size());
+		Vector<StringName> names;
+		Vector<Variant> default_values;
+		for (int i = 0; i < fields.size(); i++) {
+			Dictionary d = fields[i];
+			arr[i] = d["default_value"];
+			names.push_back(d["name"]);
+			default_values.push_back(d["default_value"]);
+		}
+		arr.set_as_struct(names, default_values);
+		array = arr;
+		emit_changed(get_edited_property(), array);
+	}
+
+	get_edited_object()->editor_set_section_unfold(get_edited_property(), edit->is_pressed());
+	update_property();
+}
+
+void EditorPropertyStruct::update_property() {
+	Variant array = get_edited_property_value();
+
+	if (!array.is_array()) {
+		edit->set_text_alignment(HORIZONTAL_ALIGNMENT_CENTER);
+		edit->set_button_icon(Ref<Texture2D>());
+		edit->set_text(vformat(TTR("(Nil) %s"), struct_name));
+		edit->set_pressed(false);
+		if (container) {
+			set_bottom_editor(nullptr);
+			memdelete(container);
+			container = nullptr;
+			slots.clear();
+		}
+		return;
+	}
+
+	object->set_array(array);
+
+	edit->set_text_alignment(HORIZONTAL_ALIGNMENT_CENTER);
+	edit->set_button_icon(Ref<Texture2D>());
+	edit->set_text(struct_name);
+
+	bool unfolded = get_edited_object()->editor_is_section_unfolded(get_edited_property());
+	if (edit->is_pressed() != unfolded) {
+		edit->set_pressed(unfolded);
+	}
+
+	if (unfolded) {
+		updating = true;
+
+		if (!container) {
+			container = memnew(PanelContainer);
+			add_child(container);
+			set_bottom_editor(container);
+
+			VBoxContainer *vbox = memnew(VBoxContainer);
+			vbox->set_theme_type_variation(SNAME("EditorPropertyContainer"));
+			container->add_child(vbox);
+
+			property_vbox = memnew(VBoxContainer);
+			property_vbox->set_theme_type_variation(SNAME("EditorPropertyContainer"));
+			property_vbox->set_h_size_flags(SIZE_EXPAND_FILL);
+			vbox->add_child(property_vbox);
+
+			for (int i = 0; i < fields.size(); i++) {
+				Dictionary d = fields[i];
+				StringName field_name = d["name"];
+				Variant::Type field_type = (Variant::Type)(int)d["type"];
+				PropertyHint field_hint = (PropertyHint)(int)d["hint"];
+				String field_hint_string = d["hint_string"];
+				uint32_t field_usage = d["usage"];
+
+				HBoxContainer *hbox = memnew(HBoxContainer);
+				property_vbox->add_child(hbox);
+
+				EditorProperty *prop = EditorInspector::instantiate_property_editor(this, field_type, "", field_hint, field_hint_string, field_usage);
+				if (!prop) {
+					prop = memnew(EditorPropertyNil);
+				}
+				prop->set_h_size_flags(SIZE_EXPAND_FILL);
+				hbox->add_child(prop);
+
+				String prop_name = "indices/" + itos(i);
+				prop->set_object_and_property(object.ptr(), prop_name);
+				prop->set_label(field_name);
+				prop->set_selectable(false);
+				prop->set_use_folding(is_using_folding());
+				prop->connect(SNAME("property_changed"), callable_mp(this, &EditorPropertyStruct::_property_changed));
+				prop->connect(SNAME("object_id_selected"), callable_mp(this, &EditorPropertyStruct::_object_id_selected));
+				if (field_type == Variant::OBJECT) {
+					prop->connect("resource_selected", callable_mp(this, &EditorPropertyStruct::_resource_selected), CONNECT_DEFERRED);
+				}
+				prop->set_read_only(is_read_only());
+
+				Slot slot;
+				slot.prop = prop;
+				slot.prop_name = prop_name;
+				slot.index = i;
+				slots.push_back(slot);
+			}
+		}
+
+		for (Slot &slot : slots) {
+			slot.prop->update_property();
+		}
+
+		updating = false;
+	} else {
+		if (container) {
+			set_bottom_editor(nullptr);
+			memdelete(container);
+			container = nullptr;
+			slots.clear();
+		}
+	}
+}
+
+void EditorPropertyStruct::_object_id_selected(const StringName &p_property, ObjectID p_id) {
+	emit_signal(SNAME("object_id_selected"), p_property, p_id);
+}
+
+void EditorPropertyStruct::_resource_selected(const String &p_path, Ref<Resource> p_resource) {
+	emit_signal(SNAME("resource_selected"), get_edited_property(), p_resource);
+}
+
+bool EditorPropertyStruct::is_colored(ColorationMode p_mode) {
+	return p_mode == COLORATION_CONTAINER_RESOURCE;
+}
+
+void EditorPropertyStruct::_notification(int p_what) {
+}
+
+void EditorPropertyStruct::setup(const String &p_hint_string) {
+	int sep = p_hint_string.find("::");
+	if (sep != -1) {
+		struct_path = p_hint_string.substr(0, sep);
+		struct_name = p_hint_string.substr(sep + 2);
+		Ref<Script> scr = ResourceLoader::load(struct_path);
+		if (scr.is_valid()) {
+			HashMap<StringName, Variant> constants;
+			scr->get_constants(&constants);
+			if (constants.has(struct_name)) {
+				Variant struct_def = constants[struct_name];
+				if (struct_def.get_type() == Variant::OBJECT) {
+					fields = struct_def.call("get_fields");
+				}
+			}
+		}
+	}
+}
+
+EditorPropertyStruct::EditorPropertyStruct() {
+	object.instantiate();
+	edit = memnew(Button);
+	edit->set_accessibility_name(TTRC("Edit"));
+	edit->set_h_size_flags(SIZE_EXPAND_FILL);
+	edit->set_clip_text(true);
+	edit->set_theme_type_variation(SNAME("EditorInspectorButton"));
+	edit->connect(SceneStringName(pressed), callable_mp(this, &EditorPropertyStruct::_edit_pressed));
+	edit->set_toggle_mode(true);
+	add_child(edit);
+	add_focusable(edit);
+
+	container = nullptr;
+	has_borders = true;
+}
+
 ///////////////////// ARRAY ///////////////////////////
 
 void EditorPropertyArray::initialize_array(Variant &p_array) {
diff --git a/editor/inspector/editor_properties_array_dict.h b/editor/inspector/editor_properties_array_dict.h
@@ -89,6 +89,56 @@ class EditorPropertyDictionaryObject : public RefCounted {
 	String get_key_name_for_index(int p_index);
 };
 
+class EditorPropertyStructObject : public RefCounted {
+	GDCLASS(EditorPropertyStructObject, RefCounted);
+
+	Variant array;
+
+protected:
+	bool _set(const StringName &p_name, const Variant &p_value);
+	bool _get(const StringName &p_name, Variant &r_ret) const;
+
+public:
+	void set_array(const Variant &p_array);
+	Variant get_array();
+};
+
+class EditorPropertyStruct : public EditorProperty {
+	GDCLASS(EditorPropertyStruct, EditorProperty);
+
+	struct Slot {
+		EditorProperty *prop = nullptr;
+		String prop_name;
+		int index = -1;
+	};
+
+	Ref<EditorPropertyStructObject> object;
+	VBoxContainer *property_vbox = nullptr;
+	Button *edit = nullptr;
+	PanelContainer *container = nullptr;
+	bool updating = false;
+
+	String struct_path;
+	String struct_name;
+
+	LocalVector<Slot> slots;
+	Array fields;
+
+	void _edit_pressed();
+	void _property_changed(const String &p_property, Variant p_value, const String &p_name = "", bool p_changing = false);
+	void _object_id_selected(const StringName &p_property, ObjectID p_id);
+	void _resource_selected(const String &p_path, Ref<Resource> p_resource);
+
+protected:
+	void _notification(int p_what);
+
+public:
+	void setup(const String &p_hint_string);
+	virtual void update_property() override;
+	virtual bool is_colored(ColorationMode p_mode) override;
+	EditorPropertyStruct();
+};
+
 class EditorPropertyArray : public EditorProperty {
 	GDCLASS(EditorPropertyArray, EditorProperty);
 
diff --git a/modules/gdscript/gdscript.cpp b/modules/gdscript/gdscript.cpp
@@ -63,6 +63,29 @@
 
 ///////////////////////////
 
+void GDScriptStruct::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("get_fields"), &GDScriptStruct::get_fields);
+}
+
+Array GDScriptStruct::get_fields() const {
+	Array arr;
+	for (int i = 0; i < fields.size(); i++) {
+		PropertyInfo prop_info = fields[i].property_info;
+		Dictionary dic;
+		dic["name"] = fields[i].name;
+		dic["type"] = prop_info.type;
+		dic["hint"] = prop_info.hint;
+		dic["hint_string"] = prop_info.hint_string;
+		dic["usage"] = prop_info.usage;
+		dic["class_name"] = prop_info.class_name;
+		dic["default_value"] = fields[i].default_value;
+		arr.push_back(dic);
+	}
+	return arr;
+}
+
+///////////////////////////
+
 GDScriptNativeClass::GDScriptNativeClass(const StringName &p_name) {
 	name = p_name;
 }
diff --git a/modules/gdscript/gdscript.h b/modules/gdscript/gdscript.h
@@ -61,19 +61,22 @@ class GDScriptStruct : public RefCounted {
 	GDCLASS(GDScriptStruct, RefCounted);
 
 protected:
-	static void _bind_methods() {}
+	static void _bind_methods();
 
 public:
 	StringName name;
 
 	struct Field {
 		StringName name;
 		GDScriptDataType data_type;
+		PropertyInfo property_info;
 		Variant default_value;
 	};
 
 	Vector<Field> fields;
 	GDScriptStruct() {}
+
+	Array get_fields() const;
 };
 
 class GDScript : public Script {
diff --git a/modules/gdscript/gdscript_compiler.cpp b/modules/gdscript/gdscript_compiler.cpp
@@ -3032,6 +3032,7 @@ Error GDScriptCompiler::_prepare_compilation(GDScript *p_script, const GDScriptP
 					GDScriptStruct::Field field;
 					field.name = var_node->identifier->name;
 					field.data_type = _gdtype_from_datatype(var_node->get_datatype(), p_script);
+					field.property_info = var_node->get_datatype().to_property_info(field.name);
 
 					if (var_node->initializer != nullptr && var_node->initializer->is_constant) {
 						field.default_value = var_node->initializer->reduced_value;
diff --git a/modules/gdscript/gdscript_parser.cpp b/modules/gdscript/gdscript_parser.cpp
