mirror/godot
2
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2024-11-21 03:18:37 +08:00
Code Issues Packages Projects Releases Wiki Activity
410893ad0f
godot/core/object/class_db.h

425 lines
19 KiB
C++
Raw Normal View History

GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
/*************************************************************************/
Style: Cleanups, added headers, renamed files Made sure files in core/ and tools/ have a proper Godot license header when written by us. Also renamed aabb.{cpp,h} and object_type_db.{cpp,h} to rect3.{cpp,h} and class_db.{cpp,h} respectively. Also added a proper header to core/io/base64.{c,h} after clarifying the licensing with the original author (public domain).
2017-01-16 15:04:19 +08:00
/* class_db.h */
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
Use HTTPS URL for Godot's website in the headers
2017-08-27 20:16:55 +08:00
/* https://godotengine.org */
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
/*************************************************************************/
Update copyright statements to 2022 Happy new year to the wonderful Godot community!
2022-01-04 04:27:34 +08:00
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
Add missing copyright headers and fix formatting Using `misc/scripts/fix_headers.py` on all Godot files. Some missing header guards were added, and the header inclusion order was fixed in the Bullet module.
2018-01-05 07:50:27 +08:00
Style: Cleanups, added headers, renamed files Made sure files in core/ and tools/ have a proper Godot license header when written by us. Also renamed aabb.{cpp,h} and object_type_db.{cpp,h} to rect3.{cpp,h} and class_db.{cpp,h} respectively. Also added a proper header to core/io/base64.{c,h} after clarifying the licensing with the original author (public domain).
2017-01-16 15:04:19 +08:00
#ifndef CLASS_DB_H
#define CLASS_DB_H
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Reorganized core/ directory, it was too fatty already -Removed FuncRef, since Callable makes it obsolete -Removed int_types.h as its obsolete in c++11+ -Changed color names code
2020-11-08 06:33:38 +08:00
#include "core/object/method_bind.h"
#include "core/object/object.h"
#include "core/string/print_string.h"
Style: Cleanups, added headers, renamed files Made sure files in core/ and tools/ have a proper Godot license header when written by us. Also renamed aabb.{cpp,h} and object_type_db.{cpp,h} to rect3.{cpp,h} and class_db.{cpp,h} respectively. Also added a proper header to core/io/base64.{c,h} after clarifying the licensing with the original author (public domain).
2017-01-16 15:04:19 +08:00
Created the callable_mp macro, for signals to call method pointers directly.
2020-02-21 02:32:36 +08:00
// Makes callable_mp readily available in all classes connecting signals.
// Needs to come after method_bind and object have been included.
Reorganized core/ directory, it was too fatty already -Removed FuncRef, since Callable makes it obsolete -Removed int_types.h as its obsolete in c++11+ -Changed color names code
2020-11-08 06:33:38 +08:00
#include "core/object/callable_method_pointer.h"
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Created the callable_mp macro, for signals to call method pointers directly.
2020-02-21 02:32:36 +08:00
#define DEFVAL(m_defval) (m_defval)
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Remove argument name strings from release builds They are not needed in release, so we can remove them to reduce the binary size.
2022-04-06 07:40:07 +08:00
#ifdef DEBUG_METHODS_ENABLED
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
struct MethodDefinition {
StringName name;
Vector<StringName> args;
remove trailing whitespace
2016-03-09 07:00:52 +08:00
MethodDefinition() {}
Style: Apply new clang-format 5.0 style to all files
2017-12-07 04:36:34 +08:00
MethodDefinition(const char *p_name) :
name(p_name) {}
MethodDefinition(const StringName &p_name) :
name(p_name) {}
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
};
Change D_METHOD to variadic template
2022-04-27 18:52:18 +08:00
MethodDefinition D_METHODP(const char *p_name, const char *const **p_args, uint32_t p_argcount);
template <typename... VarArgs>
MethodDefinition D_METHOD(const char *p_name, const VarArgs... p_args) {
const char *args[sizeof...(p_args) + 1] = { p_args..., nullptr }; // +1 makes sure zero sized arrays are also supported.
const char *const *argptrs[sizeof...(p_args) + 1];
for (uint32_t i = 0; i < sizeof...(p_args); i++) {
argptrs[i] = &args[i];
}
return D_METHODP(p_name, sizeof...(p_args) == 0 ? nullptr : (const char *const **)argptrs, sizeof...(p_args));
}
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Remove argument name strings from release builds They are not needed in release, so we can remove them to reduce the binary size.
2022-04-06 07:40:07 +08:00
#else
// When DEBUG_METHODS_ENABLED is set this will let the engine know
// the argument names for easier debugging.
#define D_METHOD(m_c, ...) m_c
#endif
ObjectTypeDB was renamed to ClassDB. Types are meant to be more generic to Variant. All usages of "type" to refer to classes were renamed to "class" ClassDB has been exposed to GDScript. OBJ_TYPE() macro is now GDCLASS()
2017-01-03 10:03:46 +08:00
class ClassDB {
Added API version and hashing to ObjectTypeDB
2016-09-15 06:37:37 +08:00
public:
enum APIType {
API_CORE,
API_EDITOR,
Add API for registering native extensions * First step for GDNative to behave more like modules * Only Object and ClassDB, the rest needs to happen on the GDNative side.
2021-06-05 01:33:48 +08:00
API_EXTENSION,
API_EDITOR_EXTENSION,
Added API version and hashing to ObjectTypeDB
2016-09-15 06:37:37 +08:00
API_NONE
};
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
Added API version and hashing to ObjectTypeDB
2016-09-15 06:37:37 +08:00
public:
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
struct PropertySetGet {
int index;
StringName setter;
StringName getter;
Zero initialize all pointer class and struct members This prevents the pitfall of UB when checking if they have been assigned something valid by comparing to nullptr.
2022-04-04 21:06:57 +08:00
MethodBind *_setptr = nullptr;
MethodBind *_getptr = nullptr;
-Display on animation editor which keys are invalid and which tracks are unresolved -Added a tool to clean up unresolved tracks and unused keys
2015-12-06 01:18:22 +08:00
Variant::Type type;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
};
ObjectTypeDB was renamed to ClassDB. Types are meant to be more generic to Variant. All usages of "type" to refer to classes were renamed to "class" ClassDB has been exposed to GDScript. OBJ_TYPE() macro is now GDCLASS()
2017-01-03 10:03:46 +08:00
struct ClassInfo {
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 23:01:17 +08:00
APIType api = API_NONE;
ClassInfo *inherits_ptr = nullptr;
void *class_ptr = nullptr;
Add API for registering native extensions * First step for GDNative to behave more like modules * Only Object and ClassDB, the rest needs to happen on the GDNative side.
2021-06-05 01:33:48 +08:00
ObjectNativeExtension *native_extension = nullptr;
-Fixes to how hashing happened, now StringName and NodePath use default hasher, this was leading to some severe slowdown in scenarios -Fixes to some duplication scenarios for instanced scenes
2018-07-03 02:08:35 +08:00
HashMap<StringName, MethodBind *> method_map;
HashMap<StringName, int> constant_map;
Style: Set clang-format Standard to Cpp11 For us, it practically only changes the fact that `A<A<int>>` is now used instead of the C++03 compatible `A<A<int> >`. Note: clang-format 10+ changed the `Standard` arguments to fully specified `c++11`, `c++14`, etc. versions, but we can't use `c++17` now if we want to preserve compatibility with clang-format 8 and 9. `Cpp11` is still supported as deprecated alias for `Latest`.
2020-03-17 14:33:00 +08:00
HashMap<StringName, List<StringName>> enum_map;
-Fixes to how hashing happened, now StringName and NodePath use default hasher, this was leading to some severe slowdown in scenarios -Fixes to some duplication scenarios for instanced scenes
2018-07-03 02:08:35 +08:00
HashMap<StringName, MethodInfo> signal_map;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
List<PropertyInfo> property_list;
Add methods in ClassDB to get property/method/constant/enum info Without the need to iterate the whole list.
2020-06-11 05:13:25 +08:00
HashMap<StringName, PropertyInfo> property_map;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
#ifdef DEBUG_METHODS_ENABLED
List<StringName> constant_order;
List<StringName> method_order;
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 21:04:37 +08:00
RBSet<StringName> methods_in_properties;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
List<MethodInfo> virtual_methods;
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 21:04:37 +08:00
HashMap<StringName, MethodInfo> virtual_methods_map;
HashMap<StringName, Vector<Error>> method_error_values;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
#endif
-Fixes to how hashing happened, now StringName and NodePath use default hasher, this was leading to some severe slowdown in scenarios -Fixes to some duplication scenarios for instanced scenes
2018-07-03 02:08:35 +08:00
HashMap<StringName, PropertySetGet> property_setget;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
StringName inherits;
StringName name;
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 23:01:17 +08:00
bool disabled = false;
bool exposed = false;
Discern between virtual and abstract class bindings * Previous "virtual" classes (which can't be instantiated) are not corretly named "abstract". * Added a new "virtual" category for classes, they can't be instantiated from the editor, but can be inherited from script and extensions. * Converted a large amount of classes from "abstract" to "virtual" where it makes sense. Most classes that make sense have been converted. Missing: * Physics servers * VideoStream * Script* classes. which will go in a separate PR due to the complexity involved.
2022-03-10 15:17:38 +08:00
bool is_virtual = false;
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 23:01:17 +08:00
Object *(*creation_func)() = nullptr;
ClassInfo() {}
~ClassInfo() {}
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
};
remove trailing whitespace
2016-03-09 07:00:52 +08:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
template <class T>
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
static Object *creator() {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
return memnew(T);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
}
remove trailing whitespace
2016-03-09 07:00:52 +08:00
Modernize RWLock - Based on C++14's `shared_time_mutex` - No more need to allocate-deallocate or check for null - No pointer anymore, just a member variable - Platform-specific implementations no longer needed - Simpler for `NO_THREADS`
2021-01-18 21:01:38 +08:00
static RWLock lock;
-Fixes to how hashing happened, now StringName and NodePath use default hasher, this was leading to some severe slowdown in scenarios -Fixes to some duplication scenarios for instanced scenes
2018-07-03 02:08:35 +08:00
static HashMap<StringName, ClassInfo> classes;
static HashMap<StringName, StringName> resource_base_extensions;
static HashMap<StringName, StringName> compat_classes;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Remove argument name strings from release builds They are not needed in release, so we can remove them to reduce the binary size.
2022-04-06 07:40:07 +08:00
#ifdef DEBUG_METHODS_ENABLED
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
static MethodBind *bind_methodfi(uint32_t p_flags, MethodBind *p_bind, const MethodDefinition &method_name, const Variant **p_defs, int p_defcount);
Remove argument name strings from release builds They are not needed in release, so we can remove them to reduce the binary size.
2022-04-06 07:40:07 +08:00
#else
static MethodBind *bind_methodfi(uint32_t p_flags, MethodBind *p_bind, const char *method_name, const Variant **p_defs, int p_defcount);
#endif
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Added API version and hashing to ObjectTypeDB
2016-09-15 06:37:37 +08:00
static APIType current_api;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
static void _add_class2(const StringName &p_class, const StringName &p_inherits);
remove trailing whitespace
2016-03-09 07:00:52 +08:00
Style: Set clang-format Standard to Cpp11 For us, it practically only changes the fact that `A<A<int>>` is now used instead of the C++03 compatible `A<A<int> >`. Note: clang-format 10+ changed the `Standard` arguments to fully specified `c++11`, `c++14`, etc. versions, but we can't use `c++17` now if we want to preserve compatibility with clang-format 8 and 9. `Cpp11` is still supported as deprecated alias for `Latest`.
2020-03-17 14:33:00 +08:00
static HashMap<StringName, HashMap<StringName, Variant>> default_values;
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 21:04:37 +08:00
static RBSet<StringName> default_values_cached;
-Moved EditorDefaultValue to ClassDB, made it core -Removed one and zero hints for properties, replaced by default value
2018-11-08 22:30:02 +08:00
Create GDExtension clases for PhysicsServer3D * Allows creating a GDExtension based 3D Physics Server (for Bullet, PhysX, etc. support) * Some changes on native struct binding for PhysicsServer This allows a 3D Physics server created entirely from GDExtension. Once it works, the idea is to port the 2D one to it.
2022-03-14 22:52:03 +08:00
// Native structs, used by binder
struct NativeStruct {
String ccode; // C code to create the native struct, fields separated by ; Arrays accepted (even containing other structs), also function pointers. All types must be Godot types.
uint64_t struct_size; // local size of struct, for comparison
};
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 21:04:37 +08:00
static HashMap<StringName, NativeStruct> native_structs;
Create GDExtension clases for PhysicsServer3D * Allows creating a GDExtension based 3D Physics Server (for Bullet, PhysX, etc. support) * Some changes on native struct binding for PhysicsServer This allows a 3D Physics server created entirely from GDExtension. Once it works, the idea is to port the 2D one to it.
2022-03-14 22:52:03 +08:00
Avoid reentrant OBJTYPE_RLOCK in ClassDB Fixes #43020 when a thread uses ClassDB while main thread calls is_parent_class().
2020-11-01 15:44:15 +08:00
private:
// Non-locking variants of get_parent_class and is_parent_class.
static StringName _get_parent_class(const StringName &p_class);
static bool _is_parent_class(const StringName &p_class, const StringName &p_inherits);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
public:
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
// DO NOT USE THIS!!!!!! NEEDS TO BE PUBLIC BUT DO NOT USE NO MATTER WHAT!!!
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
template <class T>
ObjectTypeDB was renamed to ClassDB. Types are meant to be more generic to Variant. All usages of "type" to refer to classes were renamed to "class" ClassDB has been exposed to GDScript. OBJ_TYPE() macro is now GDCLASS()
2017-01-03 10:03:46 +08:00
static void _add_class() {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
_add_class2(T::get_class_static(), T::get_parent_class_static());
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
template <class T>
Discern between virtual and abstract class bindings * Previous "virtual" classes (which can't be instantiated) are not corretly named "abstract". * Added a new "virtual" category for classes, they can't be instantiated from the editor, but can be inherited from script and extensions. * Converted a large amount of classes from "abstract" to "virtual" where it makes sense. Most classes that make sense have been converted. Missing: * Physics servers * VideoStream * Script* classes. which will go in a separate PR due to the complexity involved.
2022-03-10 15:17:38 +08:00
static void register_class(bool p_virtual = false) {
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
GLOBAL_LOCK_FUNCTION;
ObjectTypeDB was renamed to ClassDB. Types are meant to be more generic to Variant. All usages of "type" to refer to classes were renamed to "class" ClassDB has been exposed to GDScript. OBJ_TYPE() macro is now GDCLASS()
2017-01-03 10:03:46 +08:00
T::initialize_class();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
ClassInfo *t = classes.getptr(T::get_class_static());
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
ERR_FAIL_COND(!t);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
t->creation_func = &creator<T>;
Adds 'exposed' field to ClassInfo This field represents if the class is exposed to the scripting API. The value is 'true' if the class was registered manually ('ClassDB::register_*class()'), otherwise it's false (registered on '_post_initialize'). - Added missing registration of classes that are meant to be exposed.
2017-10-10 05:49:17 +08:00
t->exposed = true;
Discern between virtual and abstract class bindings * Previous "virtual" classes (which can't be instantiated) are not corretly named "abstract". * Added a new "virtual" category for classes, they can't be instantiated from the editor, but can be inherited from script and extensions. * Converted a large amount of classes from "abstract" to "virtual" where it makes sense. Most classes that make sense have been converted. Missing: * Physics servers * VideoStream * Script* classes. which will go in a separate PR due to the complexity involved.
2022-03-10 15:17:38 +08:00
t->is_virtual = p_virtual;
Expose cast_to to GDNative for dynamic casts
2019-10-21 23:44:56 +08:00
t->class_ptr = T::get_class_ptr_static();
Fix ClassDB API type mismatch bug between --editor and player There are two ways a class can be added to ClassDB: - `A`: When an instance of the class is created for the first time. When this happends the class is not registered/exposed to scripts. - `B`: When calling `GDREGISTER_CLASS(ClassName)` or similar. When this happens the class is registered/exposed to scripts. ClassDB has an API type property to differentiate between the core and editor APIs. Up until now the API type was determined whenever the class is added to ClassDB (either `A` or `B`). The problem comes when a class is instantiated (`A`) before being registered (`B`). If at this point the current defined API is not the same as when the class is later registered, this will result in a mismatch between `--editor` and non-editor apps. This is specially bad for C# as it makes the editor player abort. This was happening with `EditorPaths` which, while being registered during the editor API classes registrations, it was also being instantiated earlier when running the editor or the project manager, via a call to `EditorPaths::create()`. This regression was introduced in 1074017f043ec9155b12ea97cd00cf11361ccdf0. This commit fixes this simply by re-assigning the class API type when the class is registered (`B`). This is correct because API type describes registered/exposed classes. It shouldn't cause any regressions as the API type should not be accessed of classes that are not (or not yet) registered/exposed. Code locations for reference: - Method to add a class to ClassDB: `ClassDB::_add_class2` - Code that adds classes to ClassDB post first initialization (`A`): `memnew` macros -> `Object::_postinitialize` -> `Object::initialize_class` -> `ClassDB::_add_class2`. - Code adds class to ClassDB and registers/exposes it to scripts: `GDREGISTER_CLASS` macros -> `ClassDB::register_class<T>` -> `Object::initialize_class` -> `ClassDB::_add_class2`.
2021-09-01 03:45:21 +08:00
t->api = current_api;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
T::register_custom_data_to_otdb();
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
template <class T>
Discern between virtual and abstract class bindings * Previous "virtual" classes (which can't be instantiated) are not corretly named "abstract". * Added a new "virtual" category for classes, they can't be instantiated from the editor, but can be inherited from script and extensions. * Converted a large amount of classes from "abstract" to "virtual" where it makes sense. Most classes that make sense have been converted. Missing: * Physics servers * VideoStream * Script* classes. which will go in a separate PR due to the complexity involved.
2022-03-10 15:17:38 +08:00
static void register_abstract_class() {
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
GLOBAL_LOCK_FUNCTION;
ObjectTypeDB was renamed to ClassDB. Types are meant to be more generic to Variant. All usages of "type" to refer to classes were renamed to "class" ClassDB has been exposed to GDScript. OBJ_TYPE() macro is now GDCLASS()
2017-01-03 10:03:46 +08:00
T::initialize_class();
Adds 'exposed' field to ClassInfo This field represents if the class is exposed to the scripting API. The value is 'true' if the class was registered manually ('ClassDB::register_*class()'), otherwise it's false (registered on '_post_initialize'). - Added missing registration of classes that are meant to be exposed.
2017-10-10 05:49:17 +08:00
ClassInfo *t = classes.getptr(T::get_class_static());
ERR_FAIL_COND(!t);
t->exposed = true;
Expose cast_to to GDNative for dynamic casts
2019-10-21 23:44:56 +08:00
t->class_ptr = T::get_class_ptr_static();
Fix ClassDB API type mismatch bug between --editor and player There are two ways a class can be added to ClassDB: - `A`: When an instance of the class is created for the first time. When this happends the class is not registered/exposed to scripts. - `B`: When calling `GDREGISTER_CLASS(ClassName)` or similar. When this happens the class is registered/exposed to scripts. ClassDB has an API type property to differentiate between the core and editor APIs. Up until now the API type was determined whenever the class is added to ClassDB (either `A` or `B`). The problem comes when a class is instantiated (`A`) before being registered (`B`). If at this point the current defined API is not the same as when the class is later registered, this will result in a mismatch between `--editor` and non-editor apps. This is specially bad for C# as it makes the editor player abort. This was happening with `EditorPaths` which, while being registered during the editor API classes registrations, it was also being instantiated earlier when running the editor or the project manager, via a call to `EditorPaths::create()`. This regression was introduced in 1074017f043ec9155b12ea97cd00cf11361ccdf0. This commit fixes this simply by re-assigning the class API type when the class is registered (`B`). This is correct because API type describes registered/exposed classes. It shouldn't cause any regressions as the API type should not be accessed of classes that are not (or not yet) registered/exposed. Code locations for reference: - Method to add a class to ClassDB: `ClassDB::_add_class2` - Code that adds classes to ClassDB post first initialization (`A`): `memnew` macros -> `Object::_postinitialize` -> `Object::initialize_class` -> `ClassDB::_add_class2`. - Code adds class to ClassDB and registers/exposes it to scripts: `GDREGISTER_CLASS` macros -> `ClassDB::register_class<T>` -> `Object::initialize_class` -> `ClassDB::_add_class2`.
2021-09-01 03:45:21 +08:00
t->api = current_api;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
//nothing
}
Add API for registering native extensions * First step for GDNative to behave more like modules * Only Object and ClassDB, the rest needs to happen on the GDNative side.
2021-06-05 01:33:48 +08:00
static void register_extension_class(ObjectNativeExtension *p_extension);
Implement native extension system * Deprecates GDNative in favor of a simpler, lower level interface. * New extension system allows registering core engine classes. * Simple header interface in gdnative_interace.h
2021-06-19 23:58:49 +08:00
static void unregister_extension_class(const StringName &p_class);
Add API for registering native extensions * First step for GDNative to behave more like modules * Only Object and ClassDB, the rest needs to happen on the GDNative side.
2021-06-05 01:33:48 +08:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
template <class T>
static Object *_create_ptr_func() {
-fixed export templates not loading/exporting on Windows -fixed TouchScreenButton with stretch2d -fixed(?) OSX crash on startup (test!!) -compilation fixes on windows -CollisionPolygon editor works again -find buttons en find dialog -TileMap editor cleanup (removed "error", made nicer) -viewport flicker fixed -make .scn default extension for saving scenes -export the rest of the network classes to gdscript
2014-02-14 05:03:28 +08:00
return T::create();
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
template <class T>
ObjectTypeDB was renamed to ClassDB. Types are meant to be more generic to Variant. All usages of "type" to refer to classes were renamed to "class" ClassDB has been exposed to GDScript. OBJ_TYPE() macro is now GDCLASS()
2017-01-03 10:03:46 +08:00
static void register_custom_instance_class() {
-fixed export templates not loading/exporting on Windows -fixed TouchScreenButton with stretch2d -fixed(?) OSX crash on startup (test!!) -compilation fixes on windows -CollisionPolygon editor works again -find buttons en find dialog -TileMap editor cleanup (removed "error", made nicer) -viewport flicker fixed -make .scn default extension for saving scenes -export the rest of the network classes to gdscript
2014-02-14 05:03:28 +08:00
GLOBAL_LOCK_FUNCTION;
ObjectTypeDB was renamed to ClassDB. Types are meant to be more generic to Variant. All usages of "type" to refer to classes were renamed to "class" ClassDB has been exposed to GDScript. OBJ_TYPE() macro is now GDCLASS()
2017-01-03 10:03:46 +08:00
T::initialize_class();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
ClassInfo *t = classes.getptr(T::get_class_static());
-fixed export templates not loading/exporting on Windows -fixed TouchScreenButton with stretch2d -fixed(?) OSX crash on startup (test!!) -compilation fixes on windows -CollisionPolygon editor works again -find buttons en find dialog -TileMap editor cleanup (removed "error", made nicer) -viewport flicker fixed -make .scn default extension for saving scenes -export the rest of the network classes to gdscript
2014-02-14 05:03:28 +08:00
ERR_FAIL_COND(!t);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
t->creation_func = &_create_ptr_func<T>;
Adds 'exposed' field to ClassInfo This field represents if the class is exposed to the scripting API. The value is 'true' if the class was registered manually ('ClassDB::register_*class()'), otherwise it's false (registered on '_post_initialize'). - Added missing registration of classes that are meant to be exposed.
2017-10-10 05:49:17 +08:00
t->exposed = true;
Expose cast_to to GDNative for dynamic casts
2019-10-21 23:44:56 +08:00
t->class_ptr = T::get_class_ptr_static();
Fix ClassDB API type mismatch bug between --editor and player There are two ways a class can be added to ClassDB: - `A`: When an instance of the class is created for the first time. When this happends the class is not registered/exposed to scripts. - `B`: When calling `GDREGISTER_CLASS(ClassName)` or similar. When this happens the class is registered/exposed to scripts. ClassDB has an API type property to differentiate between the core and editor APIs. Up until now the API type was determined whenever the class is added to ClassDB (either `A` or `B`). The problem comes when a class is instantiated (`A`) before being registered (`B`). If at this point the current defined API is not the same as when the class is later registered, this will result in a mismatch between `--editor` and non-editor apps. This is specially bad for C# as it makes the editor player abort. This was happening with `EditorPaths` which, while being registered during the editor API classes registrations, it was also being instantiated earlier when running the editor or the project manager, via a call to `EditorPaths::create()`. This regression was introduced in 1074017f043ec9155b12ea97cd00cf11361ccdf0. This commit fixes this simply by re-assigning the class API type when the class is registered (`B`). This is correct because API type describes registered/exposed classes. It shouldn't cause any regressions as the API type should not be accessed of classes that are not (or not yet) registered/exposed. Code locations for reference: - Method to add a class to ClassDB: `ClassDB::_add_class2` - Code that adds classes to ClassDB post first initialization (`A`): `memnew` macros -> `Object::_postinitialize` -> `Object::initialize_class` -> `ClassDB::_add_class2`. - Code adds class to ClassDB and registers/exposes it to scripts: `GDREGISTER_CLASS` macros -> `ClassDB::register_class<T>` -> `Object::initialize_class` -> `ClassDB::_add_class2`.
2021-09-01 03:45:21 +08:00
t->api = current_api;
-fixed export templates not loading/exporting on Windows -fixed TouchScreenButton with stretch2d -fixed(?) OSX crash on startup (test!!) -compilation fixes on windows -CollisionPolygon editor works again -find buttons en find dialog -TileMap editor cleanup (removed "error", made nicer) -viewport flicker fixed -make .scn default extension for saving scenes -export the rest of the network classes to gdscript
2014-02-14 05:03:28 +08:00
T::register_custom_data_to_otdb();
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
static void get_class_list(List<StringName> *p_classes);
static void get_inheriters_from_class(const StringName &p_class, List<StringName> *p_classes);
Add ability to edit editor feature profiles Allows enabling/disabling parts of the editor and storing/loading profiles for that.
2019-04-09 06:18:03 +08:00
static void get_direct_inheriters_from_class(const StringName &p_class, List<StringName> *p_classes);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
static StringName get_parent_class_nocheck(const StringName &p_class);
static StringName get_parent_class(const StringName &p_class);
GIProbes working.
2019-10-04 04:39:08 +08:00
static StringName get_compatibility_remapped_class(const StringName &p_class);
ObjectTypeDB was renamed to ClassDB. Types are meant to be more generic to Variant. All usages of "type" to refer to classes were renamed to "class" ClassDB has been exposed to GDScript. OBJ_TYPE() macro is now GDCLASS()
2017-01-03 10:03:46 +08:00
static bool class_exists(const StringName &p_class);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
static bool is_parent_class(const StringName &p_class, const StringName &p_inherits);
Rename `instance()`->`instantiate()` when it's a verb
2021-06-18 06:03:09 +08:00
static bool can_instantiate(const StringName &p_class);
Discern between virtual and abstract class bindings * Previous "virtual" classes (which can't be instantiated) are not corretly named "abstract". * Added a new "virtual" category for classes, they can't be instantiated from the editor, but can be inherited from script and extensions. * Converted a large amount of classes from "abstract" to "virtual" where it makes sense. Most classes that make sense have been converted. Missing: * Physics servers * VideoStream * Script* classes. which will go in a separate PR due to the complexity involved.
2022-03-10 15:17:38 +08:00
static bool is_virtual(const StringName &p_class);
Rename `instance()`->`instantiate()` when it's a verb
2021-06-18 06:03:09 +08:00
static Object *instantiate(const StringName &p_class);
Change gdnative interface so that Godot object initialization should be triggered from the extension side
2021-11-24 17:22:12 +08:00
static void set_object_extension_instance(Object *p_object, const StringName &p_class, GDExtensionClassInstancePtr p_instance);
Implement native extension system * Deprecates GDNative in favor of a simpler, lower level interface. * New extension system allows registering core engine classes. * Simple header interface in gdnative_interace.h
2021-06-19 23:58:49 +08:00
ObjectTypeDB was renamed to ClassDB. Types are meant to be more generic to Variant. All usages of "type" to refer to classes were renamed to "class" ClassDB has been exposed to GDScript. OBJ_TYPE() macro is now GDCLASS()
2017-01-03 10:03:46 +08:00
static APIType get_api_type(const StringName &p_class);
Added API version and hashing to ObjectTypeDB
2016-09-15 06:37:37 +08:00
static uint64_t get_api_hash(APIType p_api);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Add static method support to ClassDB * Based on the work done for Variant in the past. * Added `ClassDB::bind_static_method` * Cleaned up ClassDB::bind_method to use variadic templates. This adds support for having static methods in Object derived classes. Note that this does not make it work yet in GDScript or Mono and, while it works for GDExtension, GodotCPP needs to be updated.
2022-03-19 20:18:52 +08:00
template <class N, class M, typename... VarArgs>
static MethodBind *bind_method(N p_method_name, M p_method, VarArgs... p_args) {
Variant args[sizeof...(p_args) + 1] = { p_args..., Variant() }; // +1 makes sure zero sized arrays are also supported.
const Variant *argptrs[sizeof...(p_args) + 1];
for (uint32_t i = 0; i < sizeof...(p_args); i++) {
argptrs[i] = &args[i];
}
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
MethodBind *bind = create_method_bind(p_method);
Add static method support to ClassDB * Based on the work done for Variant in the past. * Added `ClassDB::bind_static_method` * Cleaned up ClassDB::bind_method to use variadic templates. This adds support for having static methods in Object derived classes. Note that this does not make it work yet in GDScript or Mono and, while it works for GDExtension, GodotCPP needs to be updated.
2022-03-19 20:18:52 +08:00
return bind_methodfi(METHOD_FLAGS_DEFAULT, bind, p_method_name, sizeof...(p_args) == 0 ? nullptr : (const Variant **)argptrs, sizeof...(p_args));
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
}
Add static method support to ClassDB * Based on the work done for Variant in the past. * Added `ClassDB::bind_static_method` * Cleaned up ClassDB::bind_method to use variadic templates. This adds support for having static methods in Object derived classes. Note that this does not make it work yet in GDScript or Mono and, while it works for GDExtension, GodotCPP needs to be updated.
2022-03-19 20:18:52 +08:00
template <class N, class M, typename... VarArgs>
static MethodBind *bind_static_method(const StringName &p_class, N p_method_name, M p_method, VarArgs... p_args) {
Variant args[sizeof...(p_args) + 1] = { p_args..., Variant() }; // +1 makes sure zero sized arrays are also supported.
const Variant *argptrs[sizeof...(p_args) + 1];
for (uint32_t i = 0; i < sizeof...(p_args); i++) {
argptrs[i] = &args[i];
}
MethodBind *bind = create_static_method_bind(p_method);
bind->set_instance_class(p_class);
return bind_methodfi(METHOD_FLAGS_DEFAULT, bind, p_method_name, sizeof...(p_args) == 0 ? nullptr : (const Variant **)argptrs, sizeof...(p_args));
Fixed antialiasing option for Polygon2D Some cases were not handled properly for Polygon2D after making changes in common code to fix Line2D antialiasing. Added an option for drawing polygons to differentiate the two use cases. Fixes #34568
2020-01-01 18:39:07 +08:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
template <class M>
Editor StringName and Viewport optimizations * Added explicit return type to the SNAME macro. * Add some extra SNAME usages. * Change some ClassDB methods to use const StringName & arguments. * Cache the Window parent in Control because it's used in is_layout_rtl(), which is called often. * Only enable internal processing for viewports that need it. * Change CanvasItem::group to be a StringName because it's only used as that.
2021-07-20 01:25:15 +08:00
static MethodBind *bind_vararg_method(uint32_t p_flags, const StringName &p_name, M p_method, const MethodInfo &p_info = MethodInfo(), const Vector<Variant> &p_default_args = Vector<Variant>(), bool p_return_nil_is_variant = true) {
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
GLOBAL_LOCK_FUNCTION;
Allows to doc vararg method return type as void
2020-01-02 16:31:43 +08:00
MethodBind *bind = create_vararg_method_bind(p_method, p_info, p_return_nil_is_variant);
Replace NULL with nullptr
2020-04-02 07:20:12 +08:00
ERR_FAIL_COND_V(!bind, nullptr);
Allow documenting unexposed return types in bind_native_method Document return type of `Object.call` and `GDScript.new`
2016-08-06 08:20:59 +08:00
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
bind->set_name(p_name);
bind->set_default_arguments(p_default_args);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
String instance_type = bind->get_instance_class();
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
ClassInfo *type = classes.getptr(instance_type);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
if (!type) {
memdelete(bind);
Replace NULL with nullptr
2020-04-02 07:20:12 +08:00
ERR_FAIL_COND_V(!type, nullptr);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
}
if (type->method_map.has(p_name)) {
memdelete(bind);
Namespaces instead of underscore prefix for binds Thanks to neikeq for the initial work. Co-authored-by: Ignacio Roldán Etcheverry <neikeq@users.noreply.github.com>
2021-08-13 22:46:14 +08:00
// Overloading not supported
Replace NULL with nullptr
2020-04-02 07:20:12 +08:00
ERR_FAIL_V_MSG(nullptr, "Method already bound: " + instance_type + "::" + p_name + ".");
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
type->method_map[p_name] = bind;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
#ifdef DEBUG_METHODS_ENABLED
Re-apply clang-format to all files Some badly formatted code has managed to pass through our CI...
2017-08-27 20:16:32 +08:00
// FIXME: <reduz> set_return_type is no longer in MethodBind, so I guess it should be moved to vararg method bind
//bind->set_return_type("Variant");
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
type->method_order.push_back(p_name);
#endif
return bind;
}
Add API for registering native extensions * First step for GDNative to behave more like modules * Only Object and ClassDB, the rest needs to happen on the GDNative side.
2021-06-05 01:33:48 +08:00
static void bind_method_custom(const StringName &p_class, MethodBind *p_method);
Editor StringName and Viewport optimizations * Added explicit return type to the SNAME macro. * Add some extra SNAME usages. * Change some ClassDB methods to use const StringName & arguments. * Cache the Window parent in Control because it's used in is_layout_rtl(), which is called often. * Only enable internal processing for viewports that need it. * Change CanvasItem::group to be a StringName because it's only used as that.
2021-07-20 01:25:15 +08:00
static void add_signal(const StringName &p_class, const MethodInfo &p_signal);
static bool has_signal(const StringName &p_class, const StringName &p_signal, bool p_no_inheritance = false);
static bool get_signal(const StringName &p_class, const StringName &p_signal, MethodInfo *r_signal);
static void get_signal_list(const StringName &p_class, List<MethodInfo> *p_signals, bool p_no_inheritance = false);
Reorganize inspector layout workflow for Control nodes
2021-11-09 04:53:41 +08:00
static void add_property_group(const StringName &p_class, const String &p_name, const String &p_prefix = "", int p_indent_depth = 0);
static void add_property_subgroup(const StringName &p_class, const String &p_name, const String &p_prefix = "", int p_indent_depth = 0);
Remove ItemList editor and replace it by a property array
2021-10-28 00:29:44 +08:00
static void add_property_array_count(const StringName &p_class, const String &p_label, const StringName &p_count_property, const StringName &p_count_setter, const StringName &p_count_getter, const String &p_array_element_prefix, uint32_t p_count_usage = PROPERTY_USAGE_DEFAULT);
Implement properties arrays in the Inspector.
2021-08-31 16:48:45 +08:00
static void add_property_array(const StringName &p_class, const StringName &p_path, const String &p_array_element_prefix);
Editor StringName and Viewport optimizations * Added explicit return type to the SNAME macro. * Add some extra SNAME usages. * Change some ClassDB methods to use const StringName & arguments. * Cache the Window parent in Control because it's used in is_layout_rtl(), which is called often. * Only enable internal processing for viewports that need it. * Change CanvasItem::group to be a StringName because it's only used as that.
2021-07-20 01:25:15 +08:00
static void add_property(const StringName &p_class, const PropertyInfo &p_pinfo, const StringName &p_setter, const StringName &p_getter, int p_index = -1);
static void set_property_default_value(const StringName &p_class, const StringName &p_name, const Variant &p_default);
Fix capsule height/radius setters with linked properties Capsule height and radius setters can modify each other, rather than using clamping, to avoid cases where values are not set correctly when loading a scene (depending on the order of properties). Inspector undo/redo: Added the possibility to link properties together in the editor, so they can be undone together, for cases where a property can modify another one. Gizmo undo/redo: Capsule handles pass both radius and height values so they can be undone together.
2021-08-13 02:26:47 +08:00
static void add_linked_property(const StringName &p_class, const String &p_property, const String &p_linked_property);
Editor StringName and Viewport optimizations * Added explicit return type to the SNAME macro. * Add some extra SNAME usages. * Change some ClassDB methods to use const StringName & arguments. * Cache the Window parent in Control because it's used in is_layout_rtl(), which is called often. * Only enable internal processing for viewports that need it. * Change CanvasItem::group to be a StringName because it's only used as that.
2021-07-20 01:25:15 +08:00
static void get_property_list(const StringName &p_class, List<PropertyInfo> *p_list, bool p_no_inheritance = false, const Object *p_validator = nullptr);
static bool get_property_info(const StringName &p_class, const StringName &p_property, PropertyInfo *r_info, bool p_no_inheritance = false, const Object *p_validator = nullptr);
Replace NULL with nullptr
2020-04-02 07:20:12 +08:00
static bool set_property(Object *p_object, const StringName &p_property, const Variant &p_value, bool *r_valid = nullptr);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
static bool get_property(Object *p_object, const StringName &p_property, Variant &r_value);
static bool has_property(const StringName &p_class, const StringName &p_property, bool p_no_inheritance = false);
Replace NULL with nullptr
2020-04-02 07:20:12 +08:00
static int get_property_index(const StringName &p_class, const StringName &p_property, bool *r_is_valid = nullptr);
static Variant::Type get_property_type(const StringName &p_class, const StringName &p_property, bool *r_is_valid = nullptr);
Editor StringName and Viewport optimizations * Added explicit return type to the SNAME macro. * Add some extra SNAME usages. * Change some ClassDB methods to use const StringName & arguments. * Cache the Window parent in Control because it's used in is_layout_rtl(), which is called often. * Only enable internal processing for viewports that need it. * Change CanvasItem::group to be a StringName because it's only used as that.
2021-07-20 01:25:15 +08:00
static StringName get_property_setter(const StringName &p_class, const StringName &p_property);
static StringName get_property_getter(const StringName &p_class, const StringName &p_property);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
Editor StringName and Viewport optimizations * Added explicit return type to the SNAME macro. * Add some extra SNAME usages. * Change some ClassDB methods to use const StringName & arguments. * Cache the Window parent in Control because it's used in is_layout_rtl(), which is called often. * Only enable internal processing for viewports that need it. * Change CanvasItem::group to be a StringName because it's only used as that.
2021-07-20 01:25:15 +08:00
static bool has_method(const StringName &p_class, const StringName &p_method, bool p_no_inheritance = false);
static void set_method_flags(const StringName &p_class, const StringName &p_method, int p_flags);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
Editor StringName and Viewport optimizations * Added explicit return type to the SNAME macro. * Add some extra SNAME usages. * Change some ClassDB methods to use const StringName & arguments. * Cache the Window parent in Control because it's used in is_layout_rtl(), which is called often. * Only enable internal processing for viewports that need it. * Change CanvasItem::group to be a StringName because it's only used as that.
2021-07-20 01:25:15 +08:00
static void get_method_list(const StringName &p_class, List<MethodInfo> *p_methods, bool p_no_inheritance = false, bool p_exclude_from_properties = false);
static bool get_method_info(const StringName &p_class, const StringName &p_method, MethodInfo *r_info, bool p_no_inheritance = false, bool p_exclude_from_properties = false);
static MethodBind *get_method(const StringName &p_class, const StringName &p_name);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Replace BIND_VMETHOD by new GDVIRTUAL syntax * New syntax is type safe. * New syntax allows for type safe virtuals in native extensions. * New syntax permits extremely fast calling. Note: Everything was replaced where possible except for `_gui_input` `_input` and `_unhandled_input`. These will require API rework on a separate PR as they work different than the rest of the functions. Added a new method flag METHOD_FLAG_OBJECT_CORE, used internally. Allows to not dump the core virtuals like `_notification` to the json API, since each language will implement those as it is best fits.
2021-08-22 09:52:44 +08:00
static void add_virtual_method(const StringName &p_class, const MethodInfo &p_method, bool p_virtual = true, const Vector<String> &p_arg_names = Vector<String>(), bool p_object_core = false);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
static void get_virtual_methods(const StringName &p_class, List<MethodInfo> *p_methods, bool p_no_inheritance = false);
remove trailing whitespace
2016-03-09 07:00:52 +08:00
ClassDB: Provide the enum name of integer constants
2017-08-20 23:45:01 +08:00
static void bind_integer_constant(const StringName &p_class, const StringName &p_enum, const StringName &p_name, int p_constant);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
static void get_integer_constant_list(const StringName &p_class, List<String> *p_constants, bool p_no_inheritance = false);
Replace NULL with nullptr
2020-04-02 07:20:12 +08:00
static int get_integer_constant(const StringName &p_class, const StringName &p_name, bool *p_success = nullptr);
Add methods in ClassDB to get property/method/constant/enum info Without the need to iterate the whole list.
2020-06-11 05:13:25 +08:00
static bool has_integer_constant(const StringName &p_class, const StringName &p_name, bool p_no_inheritance = false);
ClassDB: Provide the enum name of integer constants
2017-08-20 23:45:01 +08:00
static StringName get_integer_constant_enum(const StringName &p_class, const StringName &p_name, bool p_no_inheritance = false);
static void get_enum_list(const StringName &p_class, List<StringName> *p_enums, bool p_no_inheritance = false);
static void get_enum_constants(const StringName &p_class, const StringName &p_enum, List<StringName> *p_constants, bool p_no_inheritance = false);
Add methods in ClassDB to get property/method/constant/enum info Without the need to iterate the whole list.
2020-06-11 05:13:25 +08:00
static bool has_enum(const StringName &p_class, const StringName &p_name, bool p_no_inheritance = false);
ClassDB: Provide the enum name of integer constants
2017-08-20 23:45:01 +08:00
Implement error return documetation Adds ability to add error return documetation to the binder and class reference. Usage example: ```C++ void MyClass::_bind_method() { [..] BIND_METHOD_ERR_RETURN_DOC("load", ERR_FILE_CANT_OPEN, ERR_FILE_UNRECOGNIZED); } ``` One function of ConfigFile was changed as example.
2021-08-25 02:16:25 +08:00
static void set_method_error_return_values(const StringName &p_class, const StringName &p_method, const Vector<Error> &p_values);
static Vector<Error> get_method_error_return_values(const StringName &p_class, const StringName &p_method);
Replace NULL with nullptr
2020-04-02 07:20:12 +08:00
static Variant class_get_default_property_value(const StringName &p_class, const StringName &p_property, bool *r_valid = nullptr);
-Moved EditorDefaultValue to ClassDB, made it core -Removed one and zero hints for properties, replaced by default value
2018-11-08 22:30:02 +08:00
Editor StringName and Viewport optimizations * Added explicit return type to the SNAME macro. * Add some extra SNAME usages. * Change some ClassDB methods to use const StringName & arguments. * Cache the Window parent in Control because it's used in is_layout_rtl(), which is called often. * Only enable internal processing for viewports that need it. * Change CanvasItem::group to be a StringName because it's only used as that.
2021-07-20 01:25:15 +08:00
static void set_class_enabled(const StringName &p_class, bool p_enable);
static bool is_class_enabled(const StringName &p_class);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Editor StringName and Viewport optimizations * Added explicit return type to the SNAME macro. * Add some extra SNAME usages. * Change some ClassDB methods to use const StringName & arguments. * Cache the Window parent in Control because it's used in is_layout_rtl(), which is called often. * Only enable internal processing for viewports that need it. * Change CanvasItem::group to be a StringName because it's only used as that.
2021-07-20 01:25:15 +08:00
static bool is_class_exposed(const StringName &p_class);
Adds 'exposed' field to ClassInfo This field represents if the class is exposed to the scripting API. The value is 'true' if the class was registered manually ('ClassDB::register_*class()'), otherwise it's false (registered on '_post_initialize'). - Added missing registration of classes that are meant to be exposed.
2017-10-10 05:49:17 +08:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
static void add_resource_base_extension(const StringName &p_extension, const StringName &p_class);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
static void get_resource_base_extensions(List<String> *p_extensions);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
static void get_extensions_for_type(const StringName &p_class, List<String> *p_extensions);
Implement Resource UIDs * Most resource types now have unique identifiers. * Applies to text, binary and imported resources. * File formats reference both by text and UID (when available). UID always has priority. * Resource UIDs are 64 bits for better compatibility with the engine. * Can be represented and used textually, example `uuid://dapwmgsmnl28u`. * A special binary cache file is used and exported, containing the mappings. Example of how it looks: ```GDScript [gd_scene load_steps=2 format=3 uid="uid://dw86wq31afig2"] [ext_resource type="PackedScene" uid="uid://bt36ojelx8q6c" path="res://subscene.scn" id="1_t56hs"] ``` GDScript, shaders and other special resource files can't currently provide UIDs, but this should be doable with special keywords on the files. This will be reserved for future PRs.
2021-07-24 03:01:18 +08:00
static bool is_resource_extension(const StringName &p_extension);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
static void add_compatibility_class(const StringName &p_class, const StringName &p_fallback);
Added API version and hashing to ObjectTypeDB
2016-09-15 06:37:37 +08:00
static void set_current_api(APIType p_api);
Fix wrong method binds and registered class
2019-04-06 22:12:59 +08:00
static APIType get_current_api();
Add default values to the editor help, docs, and generated RST Also, make spacing of "=" in the editor help a bit more consistent. Closes #16086
2019-06-01 21:42:22 +08:00
static void cleanup_defaults();
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
static void cleanup();
Create GDExtension clases for PhysicsServer3D * Allows creating a GDExtension based 3D Physics Server (for Bullet, PhysX, etc. support) * Some changes on native struct binding for PhysicsServer This allows a 3D Physics server created entirely from GDExtension. Once it works, the idea is to port the 2D one to it.
2022-03-14 22:52:03 +08:00
static void register_native_struct(const StringName &p_name, const String &p_code, uint64_t p_current_size);
static void get_native_struct_list(List<StringName> *r_names);
static String get_native_struct_code(const StringName &p_name);
static uint64_t get_native_struct_size(const StringName &p_name); // Used for asserting
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
};
ClassDB: Provide the enum name of integer constants
2017-08-20 23:45:01 +08:00
#ifdef DEBUG_METHODS_ENABLED
#define BIND_CONSTANT(m_constant) \
Namespaces instead of underscore prefix for binds Thanks to neikeq for the initial work. Co-authored-by: Ignacio Roldán Etcheverry <neikeq@users.noreply.github.com>
2021-08-13 22:46:14 +08:00
::ClassDB::bind_integer_constant(get_class_static(), StringName(), #m_constant, m_constant);
ClassDB: Provide the enum name of integer constants
2017-08-20 23:45:01 +08:00
#define BIND_ENUM_CONSTANT(m_constant) \
Namespaces instead of underscore prefix for binds Thanks to neikeq for the initial work. Co-authored-by: Ignacio Roldán Etcheverry <neikeq@users.noreply.github.com>
2021-08-13 22:46:14 +08:00
::ClassDB::bind_integer_constant(get_class_static(), __constant_get_enum_name(m_constant, #m_constant), #m_constant, m_constant);
ClassDB: Provide the enum name of integer constants
2017-08-20 23:45:01 +08:00
Implement error return documetation Adds ability to add error return documetation to the binder and class reference. Usage example: ```C++ void MyClass::_bind_method() { [..] BIND_METHOD_ERR_RETURN_DOC("load", ERR_FILE_CANT_OPEN, ERR_FILE_UNRECOGNIZED); } ``` One function of ConfigFile was changed as example.
2021-08-25 02:16:25 +08:00
_FORCE_INLINE_ void errarray_add_str(Vector<Error> &arr) {
}
_FORCE_INLINE_ void errarray_add_str(Vector<Error> &arr, const Error &p_err) {
arr.push_back(p_err);
}
template <class... P>
_FORCE_INLINE_ void errarray_add_str(Vector<Error> &arr, const Error &p_err, P... p_args) {
arr.push_back(p_err);
errarray_add_str(arr, p_args...);
}
template <class... P>
_FORCE_INLINE_ Vector<Error> errarray(P... p_args) {
Vector<Error> arr;
errarray_add_str(arr, p_args...);
return arr;
}
#define BIND_METHOD_ERR_RETURN_DOC(m_method, ...) \
::ClassDB::set_method_error_return_values(get_class_static(), m_method, errarray(__VA_ARGS__));
ClassDB: Provide the enum name of integer constants
2017-08-20 23:45:01 +08:00
#else
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
#define BIND_CONSTANT(m_constant) \
Namespaces instead of underscore prefix for binds Thanks to neikeq for the initial work. Co-authored-by: Ignacio Roldán Etcheverry <neikeq@users.noreply.github.com>
2021-08-13 22:46:14 +08:00
::ClassDB::bind_integer_constant(get_class_static(), StringName(), #m_constant, m_constant);
ClassDB: Provide the enum name of integer constants
2017-08-20 23:45:01 +08:00
#define BIND_ENUM_CONSTANT(m_constant) \
Namespaces instead of underscore prefix for binds Thanks to neikeq for the initial work. Co-authored-by: Ignacio Roldán Etcheverry <neikeq@users.noreply.github.com>
2021-08-13 22:46:14 +08:00
::ClassDB::bind_integer_constant(get_class_static(), StringName(), #m_constant, m_constant);
ClassDB: Provide the enum name of integer constants
2017-08-20 23:45:01 +08:00
Implement error return documetation Adds ability to add error return documetation to the binder and class reference. Usage example: ```C++ void MyClass::_bind_method() { [..] BIND_METHOD_ERR_RETURN_DOC("load", ERR_FILE_CANT_OPEN, ERR_FILE_UNRECOGNIZED); } ``` One function of ConfigFile was changed as example.
2021-08-25 02:16:25 +08:00
#define BIND_METHOD_ERR_RETURN_DOC(m_method, ...)
ClassDB: Provide the enum name of integer constants
2017-08-20 23:45:01 +08:00
#endif
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Implement the ability to disable classes * This PR adds the ability to disable classes when building. * For now it's only possible to do this via command like: `scons disable_classes=RayCast2D,Area3D` * Eventually, a proper UI will be implemented to create a build config file to do this at large scale, as well as detect what is used in the project.
2021-07-12 06:30:33 +08:00
#define GDREGISTER_CLASS(m_class) \
if (!GD_IS_DEFINED(ClassDB_Disable_##m_class)) { \
Namespaces instead of underscore prefix for binds Thanks to neikeq for the initial work. Co-authored-by: Ignacio Roldán Etcheverry <neikeq@users.noreply.github.com>
2021-08-13 22:46:14 +08:00
::ClassDB::register_class<m_class>(); \
Implement the ability to disable classes * This PR adds the ability to disable classes when building. * For now it's only possible to do this via command like: `scons disable_classes=RayCast2D,Area3D` * Eventually, a proper UI will be implemented to create a build config file to do this at large scale, as well as detect what is used in the project.
2021-07-12 06:30:33 +08:00
}
Discern between virtual and abstract class bindings * Previous "virtual" classes (which can't be instantiated) are not corretly named "abstract". * Added a new "virtual" category for classes, they can't be instantiated from the editor, but can be inherited from script and extensions. * Converted a large amount of classes from "abstract" to "virtual" where it makes sense. Most classes that make sense have been converted. Missing: * Physics servers * VideoStream * Script* classes. which will go in a separate PR due to the complexity involved.
2022-03-10 15:17:38 +08:00
#define GDREGISTER_VIRTUAL_CLASS(m_class) \
if (!GD_IS_DEFINED(ClassDB_Disable_##m_class)) { \
::ClassDB::register_class<m_class>(true); \
}
#define GDREGISTER_ABSTRACT_CLASS(m_class) \
if (!GD_IS_DEFINED(ClassDB_Disable_##m_class)) { \
::ClassDB::register_abstract_class<m_class>(); \
Implement the ability to disable classes * This PR adds the ability to disable classes when building. * For now it's only possible to do this via command like: `scons disable_classes=RayCast2D,Area3D` * Eventually, a proper UI will be implemented to create a build config file to do this at large scale, as well as detect what is used in the project.
2021-07-12 06:30:33 +08:00
}
Create GDExtension clases for PhysicsServer3D * Allows creating a GDExtension based 3D Physics Server (for Bullet, PhysX, etc. support) * Some changes on native struct binding for PhysicsServer This allows a 3D Physics server created entirely from GDExtension. Once it works, the idea is to port the 2D one to it.
2022-03-14 22:52:03 +08:00
#define GDREGISTER_NATIVE_STRUCT(m_class, m_code) ClassDB::register_native_struct(#m_class, m_code, sizeof(m_class))
Implement the ability to disable classes * This PR adds the ability to disable classes when building. * For now it's only possible to do this via command like: `scons disable_classes=RayCast2D,Area3D` * Eventually, a proper UI will be implemented to create a build config file to do this at large scale, as well as detect what is used in the project.
2021-07-12 06:30:33 +08:00
#include "core/disabled_classes.gen.h"
Style: Cleanups, added headers, renamed files Made sure files in core/ and tools/ have a proper Godot license header when written by us. Also renamed aabb.{cpp,h} and object_type_db.{cpp,h} to rect3.{cpp,h} and class_db.{cpp,h} respectively. Also added a proper header to core/io/base64.{c,h} after clarifying the licensing with the original author (public domain).
2017-01-16 15:04:19 +08:00
#endif // CLASS_DB_H
Reference in New Issue Copy Permalink