Implement a struct-like type that can be exposed to scripting. #82198

nlupugla · 2023-09-23T16:11:53Z

I am in the process of implementing the proposal godotengine/godot-proposals#7329 of @reduz on adding structs to GDScript. This work is still very much in it's early stages and many features still have yet to be implemented. Nevertheless, I'm making the draft public now so I can get continual feedback on this highly requested feature.

Edit 2023-Oct-18 22:50: Added list of structable methods

I've gone through Godot's API and made a list of about 130 methods that might benefit from structification: https://gist.github.com/nlupugla/01d59094d5fa31230e15bd991b63d33f.

core/object/object.h

core/object/object.cpp

core/variant/array.cpp

core/variant/struct.h

reduz · 2023-09-24T09:03:42Z

core/variant/array.cpp

+	/// structs
+
+	uint32_t struct_size = 0;
+	const StructMember *struct_members = nullptr;


I know you are trying to simplify the code, but this should work like the proposal for performance reasons. With separate arrays, this means less cache lines loaded for the lookup, hence faster performance.

reduz · 2023-09-24T09:04:27Z

core/variant/struct.h

+#define STRUCT_MEMBER(m_name, m_type) StructMember(SNAME(m_name), m_type)
+#define STRUCT_CLASS_MEMBER(m_name, m_class) StructMember(SNAME(m_name), Variant::OBJECT, m_class)
+// TODO: is there a way to define this so that the member count doesn't have to be passed?
+#define STRUCT_LAYOUT(m_name, m_member_count, ...)                               \


I think passing member count is unnecesary, you can add some macro magic to guess the number of `VA_ARGS.

I couldn't figure out the proper way to guess the number of args. One method I saw worked using sizeof, but I don't think that will work here because sizeof StructMember won't be known yet? Another method involved explicitly enumerating all possible number of arguments up to some finite number (like 16, or 39, or whatever you have the patience to write). That method seemed pretty clunky to me, and would also limit the number of members a struct can have. That said, it would be great if the user didn't have to pass in the length somehow.

You could check Boost.preprocessor for inspiration, there the macro would probably look more like (note lack of delimiting semicolons)

STRUCT_LAYOUT(PropertyInfoLayout, ("name", Variant::STRING) ("type", Variant::INT) ("hint", Variant::INT) ("hint_string", Variant::STRING) ("class_name", Variant::STRING_NAME) );

At which point BOOST_PP_SEQ_SIZE would give you the size. (and it's more generic in general, in case you ever needed a macro iterate over the member list more than once, for example to generate get/set_hint_string etc instead of having C++ call get/set_named). I've seen a macro that did a very similar struct declaration exactly this way (not in public code though).
Or instead of getting size via a macro, you could put the field types into a tuple type and get tuple size at compile time via templates.

Thanks for the tip! We won't to avoid unnecessary packages and libraries though, so tuple is off limits. A quick search on how BOOST_PP_SEQ_SIZE works suggests it falls in to the camp of explicitly enumerating sequence lengths up to some finite number. Maybe that's the way to go in the end, but it feels a little odd to restrict the number of members in a struct to a smallish number (like 64 or 256).

We won't to avoid unnecessary packages and libraries though, so tuple is off limits.

Sure, but even without an std::tuple, it still can be done about the same, with the sizeof... operator. So as long as you can get the macro to generate SomeTemplate<Variant::STRING, Variant::INT, Variant::INT, etc>, that should be enough. (...though at that point there are probably even simpler ways)

I apologise if I'm missing something, but if you moved up the static const StructMember members[member_count] = line, couldn't you get the member count with the classic sizeof(members)/sizeof(members[0])?

Uh, if you changed it from static const StructMember members[member_count] = to static const StructMember members[] =, that is.

For some reason I thought that wouldn't work because StructMember isn't a primitive type (like int or something). I can try it out though, it would certainly be much simpler :)

Oh sorry, when I try it I get an error about “in-class initialization of static data member 'const StructMember PropertyInfoLayout::members []' of incomplete type” (https://godbolt.org/z/vG8csqqjd). I'm not sure why C++ cares about that. It does work however if it is made a static variable (outside the class) rather than a static property. To namespace it you could use token concatenation like: const StructMember m_name##_members[] = { (https://godbolt.org/z/9P5aGGcfs) but I appreciate that might not be to everyone's taste.

Actually, your idea seems to be working for me :)

nlupugla · 2023-09-25T14:44:13Z