.. _doc_object_class: Object class ============ .. seealso:: This page describes the C++ implementation of objects in Godot. Looking for the Object class reference? :ref:`Have a look here. ` General definition ------------------ :ref:`Object ` is the base class for almost everything. Most classes in Godot inherit directly or indirectly from it. Declaring them is a matter of using a single macro like this: .. code-block:: cpp class CustomObject : public Object { GDCLASS(CustomObject, Object); // This is required to inherit from Object. }; Objects come with a lot of built-in functionality, like reflection and editable properties: .. code-block:: cpp CustomObject *obj = memnew(CustomObject); print_line("Object class: ", obj->get_class()); // print object class OtherClass *obj2 = Object::cast_to(obj); // Converting between classes, similar to dynamic_cast References: ~~~~~~~~~~~ - `core/object/object.h `__ Registering Object classes -------------------------- Most ``Object`` subclasses are registered by calling ``GDREGISTER_CLASS``. .. code-block:: cpp GDREGISTER_CLASS(MyCustomClass) This will register it as a named, public class in the ``ClassDB``, which will allow the class to be instantiated by scripts, code, or by deserialization. Note that classes registered as ``GDREGISTER_CLASS`` should expect to be instantiated or freed automatically, for example by the editor or the documentation system. Besides ``GDREGISTER_CLASS``, there are a few other modes of privateness: .. code-block:: cpp // Registers the class publicly, but prevents automatic instantiation through ClassDB. GDREGISTER_VIRTUAL_CLASS(MyCustomClass); // Registers the class publicly, but prevents all instantiation through ClassDB. GDREGISTER_ABSTRACT_CLASS(MyCustomClass); // Registers the class in ClassDB, but marks it as private, // such that it is not visible to scripts or extensions. // This is the same as not registering the class explicitly at all // - in this case, the class is registered as internal automatically // when it is first constructed. GDREGISTER_INTERNAL_CLASS(MyCustomClass); // Registers the class such that it is only available at runtime (but not in the editor). GDREGISTER_RUNTIME_CLASS(MyCustomClass); It is also possible to use ``GDSOFTCLASS(MyCustomClass, SuperClass)`` instead of ``GDCLASS(MyCustomClass, SuperClass)``. Classes defined this way are not registered in the ``ClassDB`` at all. This is sometimes used for platform-specific subclasses. Registering bindings ~~~~~~~~~~~~~~~~~~~~ Object-derived classes can override the static function ``static void _bind_methods()``. When the class is registered, this static function is called to register all the object methods, properties, constants, etc. It's only called once. Inside ``_bind_methods``, there are a couple of things that can be done. Registering functions is one: .. code-block:: cpp ClassDB::bind_method(D_METHOD("methodname", "arg1name", "arg2name", "arg3name"), &MyCustomType::method); Default values for arguments can be passed as parameters at the end: .. code-block:: cpp ClassDB::bind_method(D_METHOD("methodname", "arg1name", "arg2name", "arg3name"), &MyCustomType::method, DEFVAL(-1), DEFVAL(-2)); // Default values for arg2name (-1) and arg3name (-2). Default values must be provided in the same order as they are declared, skipping required arguments and then providing default values for the optional ones. This matches the syntax for declaring methods in C++. ``D_METHOD`` is a macro that converts "methodname" to a StringName for more efficiency. Argument names are used for introspection, but when compiling on release, the macro ignores them, so the strings are unused and optimized away. Check ``_bind_methods`` of Control or Object for more examples. If just adding modules and functionality that is not expected to be documented as thoroughly, the ``D_METHOD()`` macro can safely be ignored and a string passing the name can be passed for brevity. References: ^^^^^^^^^^^ - `core/object/class_db.h `__ Constants ~~~~~~~~~ Classes often have enums such as: .. code-block:: cpp enum SomeMode { MODE_FIRST, MODE_SECOND }; For these to work when binding to methods, the enum must be declared convertible to int. A macro is provided to help with this: .. code-block:: cpp VARIANT_ENUM_CAST(MyClass::SomeMode); // now functions that take SomeMode can be bound. The constants can also be bound inside ``_bind_methods``, by using: .. code-block:: cpp BIND_CONSTANT(MODE_FIRST); BIND_CONSTANT(MODE_SECOND); Properties (set/get) ~~~~~~~~~~~~~~~~~~~~ Objects export properties, properties are useful for the following: - Serializing and deserializing the object. - Creating a list of editable values for the Object derived class. Properties are usually defined by the PropertyInfo() class and constructed as: .. code-block:: cpp PropertyInfo(type, name, hint, hint_string, usage_flags) For example: .. code-block:: cpp PropertyInfo(Variant::INT, "amount", PROPERTY_HINT_RANGE, "0,49,1", PROPERTY_USAGE_EDITOR) This is an integer property named "amount". The hint is a range, and the range goes from 0 to 49 in steps of 1 (integers). It is only usable for the editor (editing the value visually) but won't be serialized. Another example: .. code-block:: cpp PropertyInfo(Variant::STRING, "modes", PROPERTY_HINT_ENUM, "Enabled,Disabled,Turbo") This is a string property, can take any string but the editor will only allow the defined hint ones. Since no usage flags were specified, the default ones are PROPERTY_USAGE_STORAGE and PROPERTY_USAGE_EDITOR. There are plenty of hints and usage flags available in object.h, give them a check. Properties can also work like C# properties and be accessed from script using indexing, but this usage is generally discouraged, as using functions is preferred for legibility. Many properties are also bound with categories, such as "animation/frame" which also make indexing impossible unless using operator []. From ``_bind_methods()``, properties can be created and bound as long as set/get functions exist. Example: .. code-block:: cpp ADD_PROPERTY(PropertyInfo(Variant::INT, "amount"), "set_amount", "get_amount") This creates the property using the setter and the getter. .. _doc_binding_properties_using_set_get_property_list: Binding properties using ``_set``/``_get``/``_get_property_list`` ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ An additional method of creating properties exists when more flexibility is desired (i.e. adding or removing properties on context). The following functions can be overridden in an Object derived class, they are NOT virtual, DO NOT make them virtual, they are called for every override and the previous ones are not invalidated (multilevel call). .. code-block:: cpp protected: void _get_property_list(List *r_props) const; // return list of properties bool _get(const StringName &p_property, Variant &r_value) const; // return true if property was found bool _set(const StringName &p_property, const Variant &p_value); // return true if property was found This is also a little less efficient since ``p_property`` must be compared against the desired names in serial order. Signals ~~~~~~~ Objects can have a set of signals defined (similar to Delegates in other languages). This example shows how to connect to them: .. code-block:: cpp // This is the function signature: // // Error connect(const StringName &p_signal, const Callable &p_callable, uint32_t p_flags = 0) // // For example: obj->connect("signal_name_here", callable_mp(this, &MyCustomType::method), CONNECT_DEFERRED); ``callable_mp`` is a macro to create a custom callable function pointer to member functions. For the values of ``p_flags``, see :ref:`ConnectFlags `. Adding signals to a class is done in ``_bind_methods``, using the ``ADD_SIGNAL`` macro, for example: .. code-block:: cpp ADD_SIGNAL(MethodInfo("been_killed")) Object ownership and casting ---------------------------- Objects are allocated on the heap. There are two different ownership models: - Objects derived from ``RefCounted`` are reference counted. - All other objects are manually memory managed. The ownership models are fundamentally different. Refer to the section for each respectively to learn how to create, store, and free the object. When you do not know whether an object passed to you (via ``Object *``) is ``RefCounted``, and you need to store it, you should store its ``ObjectID`` rather than a pointer (as explained below, in the manual memory management section). When an object is passed to you via :ref:`Variant`, especially when using deferred callbacks, it is possible that the contained ``Object *`` was already freed by the time your function runs. Instead of converting directly to ``Object *``, you should use ``get_validated_object``: .. code-block:: cpp void do_something(Variant p_variant) { Object *object = p_variant.get_validated_object(); ERR_FAIL_NULL(object); } Manual memory management ~~~~~~~~~~~~~~~~~~~~~~~~ Manually memory managed objects are created using ``memnew`` and freed using ``memdelete``: .. code-block:: cpp Node *node = memnew(Node); // ... memdelete(node); node = nullptr; When you are not the sole owner of an object, storing a pointer to it is dangerous: The object may at any point be freed through other references to it, causing your pointer to become a dangling pointer, which will eventually result in a crash. When storing objects you are not the only owner of, you should store its ``ObjectID`` rather than a pointer: .. code-block:: cpp Node *node = memnew(Node); ObjectID node_id = node.get_instance_id(); // ... Object *maybe_node = ObjectDB::get_instance(node_id); ERR_FAIL_NULL(maybe_node); // The node may have been freed between calls. ``RefCounted`` memory management ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :ref:`RefCounted ` subclasses are memory managed with `reference counting semantics `__. They are constructed using ``memnew``, and should be stored in ``Ref`` instances. When the last ``Ref`` instance is dropped, the object automatically self-destructs. .. code-block:: cpp class MyRefCounted: public RefCounted { GDCLASS(MyReference, RefCounted); }; Ref my_ref = memnew(MyRefCounted); // ... // Ref holds shared ownership over the object, so the object // will not be freed. As long as you have a valid, non-null // Ref, it can be safely assumed the object is still valid. my_ref->get_class_name(); You should never call ``memdelete`` for ``RefCounted`` subclasses, because there may be other owners of it. You should also never store ``RefCounted`` subclasses using raw pointers, for example ``RefCounted *object = memnew(RefCounted)``. This is unsafe because other owners may destruct the object, leaving you with a dangling pointer, which will eventually result in a crash. References: ^^^^^^^^^^^ - `core/object/ref_counted.h `__ Dynamic casting ~~~~~~~~~~~~~~~ Godot provides dynamic casting between Object-derived classes, for example: .. code-block:: cpp void some_func(Object *p_object) { Button *button = Object::cast_to