class_db.hpp 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244
  1. /*************************************************************************/
  2. /* class_db.hpp */
  3. /*************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* https://godotengine.org */
  7. /*************************************************************************/
  8. /* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
  9. /* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
  10. /* */
  11. /* Permission is hereby granted, free of charge, to any person obtaining */
  12. /* a copy of this software and associated documentation files (the */
  13. /* "Software"), to deal in the Software without restriction, including */
  14. /* without limitation the rights to use, copy, modify, merge, publish, */
  15. /* distribute, sublicense, and/or sell copies of the Software, and to */
  16. /* permit persons to whom the Software is furnished to do so, subject to */
  17. /* the following conditions: */
  18. /* */
  19. /* The above copyright notice and this permission notice shall be */
  20. /* included in all copies or substantial portions of the Software. */
  21. /* */
  22. /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
  23. /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
  24. /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
  25. /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
  26. /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
  27. /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
  28. /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
  29. /*************************************************************************/
  30. #ifndef CLASS_DB_HPP
  31. #define CLASS_DB_HPP
  32. #include <godot/gdnative_interface.h>
  33. #include <godot_cpp/core/defs.hpp>
  34. #include <godot_cpp/core/error_macros.hpp>
  35. #include <godot_cpp/core/method_bind.hpp>
  36. #include <godot_cpp/core/object.hpp>
  37. #include <list>
  38. #include <set>
  39. #include <string>
  40. #include <unordered_map>
  41. #include <vector>
  42. namespace godot {
  43. #define DEFVAL(m_defval) (m_defval)
  44. struct MethodDefinition {
  45. const char *name = nullptr;
  46. std::list<std::string> args;
  47. MethodDefinition() {}
  48. MethodDefinition(const char *p_name) :
  49. name(p_name) {}
  50. };
  51. MethodDefinition D_METHOD(const char *p_name);
  52. MethodDefinition D_METHOD(const char *p_name, const char *p_arg1);
  53. template <typename... Args>
  54. MethodDefinition D_METHOD(const char *p_name, const char *p_arg1, Args... args) {
  55. MethodDefinition md = D_METHOD(p_name, args...);
  56. md.args.push_front(p_arg1);
  57. return md;
  58. }
  59. class ClassDB {
  60. static GDNativeInitializationLevel current_level;
  61. friend class godot::GDExtensionBinding;
  62. public:
  63. struct PropertySetGet {
  64. int index;
  65. const char *setter;
  66. const char *getter;
  67. MethodBind *_setptr;
  68. MethodBind *_getptr;
  69. Variant::Type type;
  70. };
  71. struct ClassInfo {
  72. const char *name = nullptr;
  73. const char *parent_name = nullptr;
  74. GDNativeInitializationLevel level = GDNATIVE_INITIALIZATION_SCENE;
  75. std::unordered_map<std::string, MethodBind *> method_map;
  76. std::set<std::string> signal_names;
  77. std::unordered_map<std::string, GDNativeExtensionClassCallVirtual> virtual_methods;
  78. std::set<std::string> property_names;
  79. std::set<std::string> constant_names;
  80. ClassInfo *parent_ptr = nullptr;
  81. };
  82. private:
  83. static std::unordered_map<std::string, ClassInfo> classes;
  84. static MethodBind *bind_methodfi(uint32_t p_flags, MethodBind *p_bind, const MethodDefinition &method_name, const void **p_defs, int p_defcount);
  85. static void initialize_class(const ClassInfo &cl);
  86. static void bind_method_godot(const char *p_class_name, MethodBind *p_method);
  87. public:
  88. template <class T>
  89. static void register_class();
  90. template <class N, class M, typename... VarArgs>
  91. static MethodBind *bind_method(N p_method_name, M p_method, VarArgs... p_args);
  92. template <class N, class M, typename... VarArgs>
  93. static MethodBind *bind_static_method(const char *p_class, N p_method_name, M p_method, VarArgs... p_args);
  94. template <class M>
  95. static MethodBind *bind_vararg_method(uint32_t p_flags, const char *p_name, M p_method, const MethodInfo &p_info = MethodInfo(), const std::vector<Variant> &p_default_args = std::vector<Variant>{}, bool p_return_nil_is_variant = true);
  96. static void add_property_group(const char *p_class, const char *p_name, const char *p_prefix);
  97. static void add_property_subgroup(const char *p_class, const char *p_name, const char *p_prefix);
  98. static void add_property(const char *p_class, const PropertyInfo &p_pinfo, const char *p_setter, const char *p_getter, int p_index = -1);
  99. static void add_signal(const char *p_class, const MethodInfo &p_signal);
  100. static void bind_integer_constant(const char *p_class_name, const char *p_enum_name, const char *p_constant_name, GDNativeInt p_constant_value, bool p_is_bitfield = false);
  101. static void bind_virtual_method(const char *p_class, const char *p_method, GDNativeExtensionClassCallVirtual p_call);
  102. static MethodBind *get_method(const char *p_class, const char *p_method);
  103. static GDNativeExtensionClassCallVirtual get_virtual_func(void *p_userdata, const char *p_name);
  104. static void initialize(GDNativeInitializationLevel p_level);
  105. static void deinitialize(GDNativeInitializationLevel p_level);
  106. };
  107. #define BIND_CONSTANT(m_constant) \
  108. godot::ClassDB::bind_integer_constant(get_class_static(), "", #m_constant, m_constant);
  109. #define BIND_ENUM_CONSTANT(m_constant) \
  110. godot::ClassDB::bind_integer_constant(get_class_static(), godot::__constant_get_enum_name(m_constant, #m_constant), #m_constant, m_constant);
  111. #define BIND_BITFIELD_FLAG(m_constant) \
  112. godot::ClassDB::bind_integer_constant(get_class_static(), godot::__constant_get_bitfield_name(m_constant, #m_constant), #m_constant, m_constant, true);
  113. #define BIND_VIRTUAL_METHOD(m_class, m_method) \
  114. { \
  115. auto ___call##m_method = [](GDNativeObjectPtr p_instance, const GDNativeTypePtr *p_args, GDNativeTypePtr p_ret) -> void { \
  116. call_with_ptr_args(reinterpret_cast<m_class *>(p_instance), &m_class::m_method, p_args, p_ret); \
  117. }; \
  118. godot::ClassDB::bind_virtual_method(m_class::get_class_static(), #m_method, ___call##m_method); \
  119. }
  120. template <class T>
  121. void ClassDB::register_class() {
  122. // Register this class within our plugin
  123. ClassInfo cl;
  124. cl.name = T::get_class_static();
  125. cl.parent_name = T::get_parent_class_static();
  126. cl.level = current_level;
  127. classes[cl.name] = cl;
  128. if (classes.find(cl.parent_name) != classes.end()) {
  129. cl.parent_ptr = &classes[cl.parent_name];
  130. }
  131. // Register this class with Godot
  132. GDNativeExtensionClassCreationInfo class_info = {
  133. nullptr, // GDNativeExtensionClassSet set_func;
  134. nullptr, // GDNativeExtensionClassGet get_func;
  135. nullptr, // GDNativeExtensionClassGetPropertyList get_property_list_func;
  136. nullptr, // GDNativeExtensionClassFreePropertyList free_property_list_func;
  137. nullptr, // GDNativeExtensionClassNotification notification_func;
  138. nullptr, // GDNativeExtensionClassToString to_string_func;
  139. nullptr, // GDNativeExtensionClassReference reference_func;
  140. nullptr, // GDNativeExtensionClassUnreference unreference_func;
  141. T::create, // GDNativeExtensionClassCreateInstance create_instance_func; /* this one is mandatory */
  142. T::free, // GDNativeExtensionClassFreeInstance free_instance_func; /* this one is mandatory */
  143. &ClassDB::get_virtual_func, // GDNativeExtensionClassGetVirtual get_virtual_func;
  144. nullptr, // GDNativeExtensionClassGetRID get_rid;
  145. (void *)cl.name, // void *class_userdata;
  146. };
  147. internal::gdn_interface->classdb_register_extension_class(internal::library, cl.name, cl.parent_name, &class_info);
  148. // call bind_methods etc. to register all members of the class
  149. T::initialize_class();
  150. // now register our class within ClassDB within Godot
  151. initialize_class(classes[cl.name]);
  152. }
  153. template <class N, class M, typename... VarArgs>
  154. MethodBind *ClassDB::bind_method(N p_method_name, M p_method, VarArgs... p_args) {
  155. Variant args[sizeof...(p_args) + 1] = { p_args..., Variant() }; // +1 makes sure zero sized arrays are also supported.
  156. const Variant *argptrs[sizeof...(p_args) + 1];
  157. for (uint32_t i = 0; i < sizeof...(p_args); i++) {
  158. argptrs[i] = &args[i];
  159. }
  160. MethodBind *bind = create_method_bind(p_method);
  161. return bind_methodfi(METHOD_FLAGS_DEFAULT, bind, p_method_name, sizeof...(p_args) == 0 ? nullptr : (const void **)argptrs, sizeof...(p_args));
  162. }
  163. template <class N, class M, typename... VarArgs>
  164. MethodBind *ClassDB::bind_static_method(const char *p_class, N p_method_name, M p_method, VarArgs... p_args) {
  165. Variant args[sizeof...(p_args) + 1] = { p_args..., Variant() }; // +1 makes sure zero sized arrays are also supported.
  166. const Variant *argptrs[sizeof...(p_args) + 1];
  167. for (uint32_t i = 0; i < sizeof...(p_args); i++) {
  168. argptrs[i] = &args[i];
  169. }
  170. MethodBind *bind = create_static_method_bind(p_method);
  171. bind->set_instance_class(p_class);
  172. return bind_methodfi(0, bind, p_method_name, sizeof...(p_args) == 0 ? nullptr : (const void **)argptrs, sizeof...(p_args));
  173. }
  174. template <class M>
  175. MethodBind *ClassDB::bind_vararg_method(uint32_t p_flags, const char *p_name, M p_method, const MethodInfo &p_info, const std::vector<Variant> &p_default_args, bool p_return_nil_is_variant) {
  176. MethodBind *bind = create_vararg_method_bind(p_method, p_info, p_return_nil_is_variant);
  177. ERR_FAIL_COND_V(!bind, nullptr);
  178. bind->set_name(p_name);
  179. bind->set_default_arguments(p_default_args);
  180. const char *instance_type = bind->get_instance_class();
  181. std::unordered_map<std::string, ClassInfo>::iterator type_it = classes.find(instance_type);
  182. if (type_it == classes.end()) {
  183. memdelete(bind);
  184. ERR_FAIL_V_MSG(nullptr, "Class doesn't exist.");
  185. }
  186. ClassInfo &type = type_it->second;
  187. if (type.method_map.find(p_name) != type.method_map.end()) {
  188. memdelete(bind);
  189. ERR_FAIL_V_MSG(nullptr, "Binding duplicate method.");
  190. }
  191. // register our method bind within our plugin
  192. type.method_map[p_name] = bind;
  193. // and register with godot
  194. bind_method_godot(type.name, bind);
  195. return bind;
  196. }
  197. #define GDREGISTER_CLASS(m_class) ClassDB::register_class<m_class>();
  198. } // namespace godot
  199. #endif // ! CLASS_DB_HPP