class_object.rst 92 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725
  1. :github_url: hide
  2. .. DO NOT EDIT THIS FILE!!!
  3. .. Generated automatically from Godot engine sources.
  4. .. Generator: https://github.com/godotengine/godot/tree/master/doc/tools/make_rst.py.
  5. .. XML source: https://github.com/godotengine/godot/tree/master/doc/classes/Object.xml.
  6. .. _class_Object:
  7. Object
  8. ======
  9. **Inherited By:** :ref:`AudioServer<class_AudioServer>`, :ref:`CameraServer<class_CameraServer>`, :ref:`ClassDB<class_ClassDB>`, :ref:`DisplayServer<class_DisplayServer>`, :ref:`EditorFileSystemDirectory<class_EditorFileSystemDirectory>`, :ref:`EditorInterface<class_EditorInterface>`, :ref:`EditorPaths<class_EditorPaths>`, :ref:`EditorSelection<class_EditorSelection>`, :ref:`EditorUndoRedoManager<class_EditorUndoRedoManager>`, :ref:`EditorVCSInterface<class_EditorVCSInterface>`, :ref:`Engine<class_Engine>`, :ref:`EngineDebugger<class_EngineDebugger>`, :ref:`GDExtensionManager<class_GDExtensionManager>`, :ref:`Geometry2D<class_Geometry2D>`, :ref:`Geometry3D<class_Geometry3D>`, :ref:`GodotSharp<class_GodotSharp>`, :ref:`Input<class_Input>`, :ref:`InputMap<class_InputMap>`, :ref:`IP<class_IP>`, :ref:`JavaClassWrapper<class_JavaClassWrapper>`, :ref:`JavaScriptBridge<class_JavaScriptBridge>`, :ref:`JNISingleton<class_JNISingleton>`, :ref:`JSONRPC<class_JSONRPC>`, :ref:`MainLoop<class_MainLoop>`, :ref:`Marshalls<class_Marshalls>`, :ref:`MovieWriter<class_MovieWriter>`, :ref:`NavigationMeshGenerator<class_NavigationMeshGenerator>`, :ref:`NavigationServer2D<class_NavigationServer2D>`, :ref:`NavigationServer3D<class_NavigationServer3D>`, :ref:`Node<class_Node>`, :ref:`OpenXRExtensionWrapperExtension<class_OpenXRExtensionWrapperExtension>`, :ref:`OpenXRInteractionProfileMetadata<class_OpenXRInteractionProfileMetadata>`, :ref:`OS<class_OS>`, :ref:`Performance<class_Performance>`, :ref:`PhysicsDirectBodyState2D<class_PhysicsDirectBodyState2D>`, :ref:`PhysicsDirectBodyState3D<class_PhysicsDirectBodyState3D>`, :ref:`PhysicsDirectSpaceState2D<class_PhysicsDirectSpaceState2D>`, :ref:`PhysicsDirectSpaceState3D<class_PhysicsDirectSpaceState3D>`, :ref:`PhysicsServer2D<class_PhysicsServer2D>`, :ref:`PhysicsServer2DManager<class_PhysicsServer2DManager>`, :ref:`PhysicsServer3D<class_PhysicsServer3D>`, :ref:`PhysicsServer3DManager<class_PhysicsServer3DManager>`, :ref:`PhysicsServer3DRenderingServerHandler<class_PhysicsServer3DRenderingServerHandler>`, :ref:`ProjectSettings<class_ProjectSettings>`, :ref:`RefCounted<class_RefCounted>`, :ref:`RenderingDevice<class_RenderingDevice>`, :ref:`RenderingServer<class_RenderingServer>`, :ref:`ResourceLoader<class_ResourceLoader>`, :ref:`ResourceSaver<class_ResourceSaver>`, :ref:`ResourceUID<class_ResourceUID>`, :ref:`ScriptLanguage<class_ScriptLanguage>`, :ref:`TextServerManager<class_TextServerManager>`, :ref:`ThemeDB<class_ThemeDB>`, :ref:`TileData<class_TileData>`, :ref:`Time<class_Time>`, :ref:`TranslationServer<class_TranslationServer>`, :ref:`TreeItem<class_TreeItem>`, :ref:`UndoRedo<class_UndoRedo>`, :ref:`WorkerThreadPool<class_WorkerThreadPool>`, :ref:`XRServer<class_XRServer>`
  10. Base class for all other classes in the engine.
  11. .. rst-class:: classref-introduction-group
  12. Description
  13. -----------
  14. An advanced :ref:`Variant<class_Variant>` type. All classes in the engine inherit from Object. Each class may define new properties, methods or signals, which are available to all inheriting classes. For example, a :ref:`Sprite2D<class_Sprite2D>` instance is able to call :ref:`Node.add_child<class_Node_method_add_child>` because it inherits from :ref:`Node<class_Node>`.
  15. You can create new instances, using ``Object.new()`` in GDScript, or ``new Object`` in C#.
  16. To delete an Object instance, call :ref:`free<class_Object_method_free>`. This is necessary for most classes inheriting Object, because they do not manage memory on their own, and will otherwise cause memory leaks when no longer in use. There are a few classes that perform memory management. For example, :ref:`RefCounted<class_RefCounted>` (and by extension :ref:`Resource<class_Resource>`) deletes itself when no longer referenced, and :ref:`Node<class_Node>` deletes its children when freed.
  17. Objects can have a :ref:`Script<class_Script>` attached to them. Once the :ref:`Script<class_Script>` is instantiated, it effectively acts as an extension to the base class, allowing it to define and inherit new properties, methods and signals.
  18. Inside a :ref:`Script<class_Script>`, :ref:`_get_property_list<class_Object_method__get_property_list>` may be overridden to customize properties in several ways. This allows them to be available to the editor, display as lists of options, sub-divide into groups, save on disk, etc. Scripting languages offer easier ways to customize properties, such as with the :ref:`@GDScript.@export<class_@GDScript_annotation_@export>` annotation.
  19. Godot is very dynamic. An object's script, and therefore its properties, methods and signals, can be changed at run-time. Because of this, there can be occasions where, for example, a property required by a method may not exist. To prevent run-time errors, see methods such as :ref:`set<class_Object_method_set>`, :ref:`get<class_Object_method_get>`, :ref:`call<class_Object_method_call>`, :ref:`has_method<class_Object_method_has_method>`, :ref:`has_signal<class_Object_method_has_signal>`, etc. Note that these methods are **much** slower than direct references.
  20. In GDScript, you can also check if a given property, method, or signal name exists in an object with the ``in`` operator:
  21. ::
  22. var node = Node.new()
  23. print("name" in node) # Prints true
  24. print("get_parent" in node) # Prints true
  25. print("tree_entered" in node) # Prints true
  26. print("unknown" in node) # Prints false
  27. Notifications are :ref:`int<class_int>` constants commonly sent and received by objects. For example, on every rendered frame, the :ref:`SceneTree<class_SceneTree>` notifies nodes inside the tree with a :ref:`Node.NOTIFICATION_PROCESS<class_Node_constant_NOTIFICATION_PROCESS>`. The nodes receive it and may call :ref:`Node._process<class_Node_method__process>` to update. To make use of notifications, see :ref:`notification<class_Object_method_notification>` and :ref:`_notification<class_Object_method__notification>`.
  28. Lastly, every object can also contain metadata (data about data). :ref:`set_meta<class_Object_method_set_meta>` can be useful to store information that the object itself does not depend on. To keep your code clean, making excessive use of metadata is discouraged.
  29. \ **Note:** Unlike references to a :ref:`RefCounted<class_RefCounted>`, references to an object stored in a variable can become invalid without being set to ``null``. To check if an object has been deleted, do *not* compare it against ``null``. Instead, use :ref:`@GlobalScope.is_instance_valid<class_@GlobalScope_method_is_instance_valid>`. It's also recommended to inherit from :ref:`RefCounted<class_RefCounted>` for classes storing data instead of **Object**.
  30. \ **Note:** The ``script`` is not exposed like most properties. To set or get an object's :ref:`Script<class_Script>` in code, use :ref:`set_script<class_Object_method_set_script>` and :ref:`get_script<class_Object_method_get_script>`, respectively.
  31. .. rst-class:: classref-introduction-group
  32. Tutorials
  33. ---------
  34. - :doc:`Object class introduction <../contributing/development/core_and_modules/object_class>`
  35. - :doc:`When and how to avoid using nodes for everything <../tutorials/best_practices/node_alternatives>`
  36. - :doc:`Object notifications <../tutorials/best_practices/godot_notifications>`
  37. .. rst-class:: classref-reftable-group
  38. Methods
  39. -------
  40. .. table::
  41. :widths: auto
  42. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  43. | :ref:`Variant<class_Variant>` | :ref:`_get<class_Object_method__get>` **(** :ref:`StringName<class_StringName>` property **)** |virtual| |
  44. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  45. | :ref:`Dictionary[]<class_Dictionary>` | :ref:`_get_property_list<class_Object_method__get_property_list>` **(** **)** |virtual| |
  46. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  47. | void | :ref:`_init<class_Object_method__init>` **(** **)** |virtual| |
  48. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  49. | void | :ref:`_notification<class_Object_method__notification>` **(** :ref:`int<class_int>` what **)** |virtual| |
  50. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  51. | :ref:`bool<class_bool>` | :ref:`_property_can_revert<class_Object_method__property_can_revert>` **(** :ref:`StringName<class_StringName>` property **)** |virtual| |
  52. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  53. | :ref:`Variant<class_Variant>` | :ref:`_property_get_revert<class_Object_method__property_get_revert>` **(** :ref:`StringName<class_StringName>` property **)** |virtual| |
  54. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  55. | :ref:`bool<class_bool>` | :ref:`_set<class_Object_method__set>` **(** :ref:`StringName<class_StringName>` property, :ref:`Variant<class_Variant>` value **)** |virtual| |
  56. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  57. | :ref:`String<class_String>` | :ref:`_to_string<class_Object_method__to_string>` **(** **)** |virtual| |
  58. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  59. | void | :ref:`_validate_property<class_Object_method__validate_property>` **(** :ref:`Dictionary<class_Dictionary>` property **)** |virtual| |
  60. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  61. | void | :ref:`add_user_signal<class_Object_method_add_user_signal>` **(** :ref:`String<class_String>` signal, :ref:`Array<class_Array>` arguments=[] **)** |
  62. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  63. | :ref:`Variant<class_Variant>` | :ref:`call<class_Object_method_call>` **(** :ref:`StringName<class_StringName>` method, ... **)** |vararg| |
  64. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  65. | :ref:`Variant<class_Variant>` | :ref:`call_deferred<class_Object_method_call_deferred>` **(** :ref:`StringName<class_StringName>` method, ... **)** |vararg| |
  66. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  67. | :ref:`Variant<class_Variant>` | :ref:`callv<class_Object_method_callv>` **(** :ref:`StringName<class_StringName>` method, :ref:`Array<class_Array>` arg_array **)** |
  68. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  69. | :ref:`bool<class_bool>` | :ref:`can_translate_messages<class_Object_method_can_translate_messages>` **(** **)** |const| |
  70. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  71. | void | :ref:`cancel_free<class_Object_method_cancel_free>` **(** **)** |
  72. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  73. | :ref:`Error<enum_@GlobalScope_Error>` | :ref:`connect<class_Object_method_connect>` **(** :ref:`StringName<class_StringName>` signal, :ref:`Callable<class_Callable>` callable, :ref:`int<class_int>` flags=0 **)** |
  74. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  75. | void | :ref:`disconnect<class_Object_method_disconnect>` **(** :ref:`StringName<class_StringName>` signal, :ref:`Callable<class_Callable>` callable **)** |
  76. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  77. | :ref:`Error<enum_@GlobalScope_Error>` | :ref:`emit_signal<class_Object_method_emit_signal>` **(** :ref:`StringName<class_StringName>` signal, ... **)** |vararg| |
  78. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  79. | void | :ref:`free<class_Object_method_free>` **(** **)** |
  80. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  81. | :ref:`Variant<class_Variant>` | :ref:`get<class_Object_method_get>` **(** :ref:`StringName<class_StringName>` property **)** |const| |
  82. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  83. | :ref:`String<class_String>` | :ref:`get_class<class_Object_method_get_class>` **(** **)** |const| |
  84. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  85. | :ref:`Dictionary[]<class_Dictionary>` | :ref:`get_incoming_connections<class_Object_method_get_incoming_connections>` **(** **)** |const| |
  86. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  87. | :ref:`Variant<class_Variant>` | :ref:`get_indexed<class_Object_method_get_indexed>` **(** :ref:`NodePath<class_NodePath>` property_path **)** |const| |
  88. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  89. | :ref:`int<class_int>` | :ref:`get_instance_id<class_Object_method_get_instance_id>` **(** **)** |const| |
  90. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  91. | :ref:`Variant<class_Variant>` | :ref:`get_meta<class_Object_method_get_meta>` **(** :ref:`StringName<class_StringName>` name, :ref:`Variant<class_Variant>` default=null **)** |const| |
  92. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  93. | :ref:`StringName[]<class_StringName>` | :ref:`get_meta_list<class_Object_method_get_meta_list>` **(** **)** |const| |
  94. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  95. | :ref:`Dictionary[]<class_Dictionary>` | :ref:`get_method_list<class_Object_method_get_method_list>` **(** **)** |const| |
  96. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  97. | :ref:`Dictionary[]<class_Dictionary>` | :ref:`get_property_list<class_Object_method_get_property_list>` **(** **)** |const| |
  98. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  99. | :ref:`Variant<class_Variant>` | :ref:`get_script<class_Object_method_get_script>` **(** **)** |const| |
  100. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  101. | :ref:`Dictionary[]<class_Dictionary>` | :ref:`get_signal_connection_list<class_Object_method_get_signal_connection_list>` **(** :ref:`StringName<class_StringName>` signal **)** |const| |
  102. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  103. | :ref:`Dictionary[]<class_Dictionary>` | :ref:`get_signal_list<class_Object_method_get_signal_list>` **(** **)** |const| |
  104. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  105. | :ref:`bool<class_bool>` | :ref:`has_meta<class_Object_method_has_meta>` **(** :ref:`StringName<class_StringName>` name **)** |const| |
  106. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  107. | :ref:`bool<class_bool>` | :ref:`has_method<class_Object_method_has_method>` **(** :ref:`StringName<class_StringName>` method **)** |const| |
  108. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  109. | :ref:`bool<class_bool>` | :ref:`has_signal<class_Object_method_has_signal>` **(** :ref:`StringName<class_StringName>` signal **)** |const| |
  110. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  111. | :ref:`bool<class_bool>` | :ref:`has_user_signal<class_Object_method_has_user_signal>` **(** :ref:`StringName<class_StringName>` signal **)** |const| |
  112. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  113. | :ref:`bool<class_bool>` | :ref:`is_blocking_signals<class_Object_method_is_blocking_signals>` **(** **)** |const| |
  114. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  115. | :ref:`bool<class_bool>` | :ref:`is_class<class_Object_method_is_class>` **(** :ref:`String<class_String>` class **)** |const| |
  116. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  117. | :ref:`bool<class_bool>` | :ref:`is_connected<class_Object_method_is_connected>` **(** :ref:`StringName<class_StringName>` signal, :ref:`Callable<class_Callable>` callable **)** |const| |
  118. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  119. | :ref:`bool<class_bool>` | :ref:`is_queued_for_deletion<class_Object_method_is_queued_for_deletion>` **(** **)** |const| |
  120. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  121. | void | :ref:`notification<class_Object_method_notification>` **(** :ref:`int<class_int>` what, :ref:`bool<class_bool>` reversed=false **)** |
  122. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  123. | void | :ref:`notify_property_list_changed<class_Object_method_notify_property_list_changed>` **(** **)** |
  124. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  125. | :ref:`bool<class_bool>` | :ref:`property_can_revert<class_Object_method_property_can_revert>` **(** :ref:`StringName<class_StringName>` property **)** |const| |
  126. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  127. | :ref:`Variant<class_Variant>` | :ref:`property_get_revert<class_Object_method_property_get_revert>` **(** :ref:`StringName<class_StringName>` property **)** |const| |
  128. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  129. | void | :ref:`remove_meta<class_Object_method_remove_meta>` **(** :ref:`StringName<class_StringName>` name **)** |
  130. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  131. | void | :ref:`set<class_Object_method_set>` **(** :ref:`StringName<class_StringName>` property, :ref:`Variant<class_Variant>` value **)** |
  132. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  133. | void | :ref:`set_block_signals<class_Object_method_set_block_signals>` **(** :ref:`bool<class_bool>` enable **)** |
  134. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  135. | void | :ref:`set_deferred<class_Object_method_set_deferred>` **(** :ref:`StringName<class_StringName>` property, :ref:`Variant<class_Variant>` value **)** |
  136. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  137. | void | :ref:`set_indexed<class_Object_method_set_indexed>` **(** :ref:`NodePath<class_NodePath>` property_path, :ref:`Variant<class_Variant>` value **)** |
  138. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  139. | void | :ref:`set_message_translation<class_Object_method_set_message_translation>` **(** :ref:`bool<class_bool>` enable **)** |
  140. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  141. | void | :ref:`set_meta<class_Object_method_set_meta>` **(** :ref:`StringName<class_StringName>` name, :ref:`Variant<class_Variant>` value **)** |
  142. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  143. | void | :ref:`set_script<class_Object_method_set_script>` **(** :ref:`Variant<class_Variant>` script **)** |
  144. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  145. | :ref:`String<class_String>` | :ref:`to_string<class_Object_method_to_string>` **(** **)** |
  146. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  147. | :ref:`String<class_String>` | :ref:`tr<class_Object_method_tr>` **(** :ref:`StringName<class_StringName>` message, :ref:`StringName<class_StringName>` context="" **)** |const| |
  148. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  149. | :ref:`String<class_String>` | :ref:`tr_n<class_Object_method_tr_n>` **(** :ref:`StringName<class_StringName>` message, :ref:`StringName<class_StringName>` plural_message, :ref:`int<class_int>` n, :ref:`StringName<class_StringName>` context="" **)** |const| |
  150. +---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  151. .. rst-class:: classref-section-separator
  152. ----
  153. .. rst-class:: classref-descriptions-group
  154. Signals
  155. -------
  156. .. _class_Object_signal_property_list_changed:
  157. .. rst-class:: classref-signal
  158. **property_list_changed** **(** **)**
  159. Emitted when :ref:`notify_property_list_changed<class_Object_method_notify_property_list_changed>` is called.
  160. .. rst-class:: classref-item-separator
  161. ----
  162. .. _class_Object_signal_script_changed:
  163. .. rst-class:: classref-signal
  164. **script_changed** **(** **)**
  165. Emitted when the object's script is changed.
  166. \ **Note:** When this signal is emitted, the new script is not initialized yet. If you need to access the new script, defer connections to this signal with :ref:`CONNECT_DEFERRED<class_Object_constant_CONNECT_DEFERRED>`.
  167. .. rst-class:: classref-section-separator
  168. ----
  169. .. rst-class:: classref-descriptions-group
  170. Enumerations
  171. ------------
  172. .. _enum_Object_ConnectFlags:
  173. .. rst-class:: classref-enumeration
  174. enum **ConnectFlags**:
  175. .. _class_Object_constant_CONNECT_DEFERRED:
  176. .. rst-class:: classref-enumeration-constant
  177. :ref:`ConnectFlags<enum_Object_ConnectFlags>` **CONNECT_DEFERRED** = ``1``
  178. Deferred connections trigger their :ref:`Callable<class_Callable>`\ s on idle time (at the end of the frame), rather than instantly.
  179. .. _class_Object_constant_CONNECT_PERSIST:
  180. .. rst-class:: classref-enumeration-constant
  181. :ref:`ConnectFlags<enum_Object_ConnectFlags>` **CONNECT_PERSIST** = ``2``
  182. Persisting connections are stored when the object is serialized (such as when using :ref:`PackedScene.pack<class_PackedScene_method_pack>`). In the editor, connections created through the Node dock are always persisting.
  183. .. _class_Object_constant_CONNECT_ONE_SHOT:
  184. .. rst-class:: classref-enumeration-constant
  185. :ref:`ConnectFlags<enum_Object_ConnectFlags>` **CONNECT_ONE_SHOT** = ``4``
  186. One-shot connections disconnect themselves after emission.
  187. .. _class_Object_constant_CONNECT_REFERENCE_COUNTED:
  188. .. rst-class:: classref-enumeration-constant
  189. :ref:`ConnectFlags<enum_Object_ConnectFlags>` **CONNECT_REFERENCE_COUNTED** = ``8``
  190. Reference-counted connections can be assigned to the same :ref:`Callable<class_Callable>` multiple times. Each disconnection decreases the internal counter. The signal fully disconnects only when the counter reaches 0.
  191. .. rst-class:: classref-section-separator
  192. ----
  193. .. rst-class:: classref-descriptions-group
  194. Constants
  195. ---------
  196. .. _class_Object_constant_NOTIFICATION_POSTINITIALIZE:
  197. .. rst-class:: classref-constant
  198. **NOTIFICATION_POSTINITIALIZE** = ``0``
  199. Notification received when the object is initialized, before its script is attached. Used internally.
  200. .. _class_Object_constant_NOTIFICATION_PREDELETE:
  201. .. rst-class:: classref-constant
  202. **NOTIFICATION_PREDELETE** = ``1``
  203. Notification received when the object is about to be deleted. Can act as the deconstructor of some programming languages.
  204. .. rst-class:: classref-section-separator
  205. ----
  206. .. rst-class:: classref-descriptions-group
  207. Method Descriptions
  208. -------------------
  209. .. _class_Object_method__get:
  210. .. rst-class:: classref-method
  211. :ref:`Variant<class_Variant>` **_get** **(** :ref:`StringName<class_StringName>` property **)** |virtual|
  212. Override this method to customize the behavior of :ref:`get<class_Object_method_get>`. Should return the given ``property``'s value, or ``null`` if the ``property`` should be handled normally.
  213. Combined with :ref:`_set<class_Object_method__set>` and :ref:`_get_property_list<class_Object_method__get_property_list>`, this method allows defining custom properties, which is particularly useful for editor plugins. Note that a property must be present in :ref:`get_property_list<class_Object_method_get_property_list>`, otherwise this method will not be called.
  214. .. tabs::
  215. .. code-tab:: gdscript
  216. func _get(property):
  217. if property == "fake_property":
  218. print("Getting my property!")
  219. return 4
  220. func _get_property_list():
  221. return [
  222. { "name": "fake_property", "type": TYPE_INT }
  223. ]
  224. .. code-tab:: csharp
  225. public override Variant _Get(StringName property)
  226. {
  227. if (property == "FakeProperty")
  228. {
  229. GD.Print("Getting my property!");
  230. return 4;
  231. }
  232. return default;
  233. }
  234. public override Godot.Collections.Array<Godot.Collections.Dictionary> _GetPropertyList()
  235. {
  236. return new Godot.Collections.Array<Godot.Collections.Dictionary>()
  237. {
  238. new Godot.Collections.Dictionary()
  239. {
  240. { "name", "FakeProperty" },
  241. { "type", (int)Variant.Type.Int }
  242. }
  243. };
  244. }
  245. .. rst-class:: classref-item-separator
  246. ----
  247. .. _class_Object_method__get_property_list:
  248. .. rst-class:: classref-method
  249. :ref:`Dictionary[]<class_Dictionary>` **_get_property_list** **(** **)** |virtual|
  250. Override this method to customize how script properties should be handled by the engine.
  251. Should return a property list, as an :ref:`Array<class_Array>` of dictionaries. The result is added to the array of :ref:`get_property_list<class_Object_method_get_property_list>`, and should be formatted in the same way. Each :ref:`Dictionary<class_Dictionary>` must at least contain the ``name`` and ``type`` entries.
  252. The example below displays ``hammer_type`` in the Inspector dock, only if ``holding_hammer`` is ``true``:
  253. .. tabs::
  254. .. code-tab:: gdscript
  255. @tool
  256. extends Node2D
  257. @export var holding_hammer = false:
  258. set(value):
  259. holding_hammer = value
  260. notify_property_list_changed()
  261. var hammer_type = 0
  262. func _get_property_list():
  263. # By default, `hammer_type` is not visible in the editor.
  264. var property_usage = PROPERTY_USAGE_NO_EDITOR
  265. if holding_hammer:
  266. property_usage = PROPERTY_USAGE_DEFAULT
  267. var properties = []
  268. properties.append({
  269. "name": "hammer_type",
  270. "type": TYPE_INT,
  271. "usage": property_usage, # See above assignment.
  272. "hint": PROPERTY_HINT_ENUM,
  273. "hint_string": "Wooden,Iron,Golden,Enchanted"
  274. })
  275. return properties
  276. .. code-tab:: csharp
  277. [Tool]
  278. public partial class MyNode2D : Node2D
  279. {
  280. private bool _holdingHammer;
  281. [Export]
  282. public bool HoldingHammer
  283. {
  284. get => _holdingHammer;
  285. set
  286. {
  287. _holdingHammer = value;
  288. NotifyPropertyListChanged();
  289. }
  290. }
  291. public int HammerType { get; set; }
  292. public override Godot.Collections.Array<Godot.Collections.Dictionary> _GetPropertyList()
  293. {
  294. // By default, `HammerType` is not visible in the editor.
  295. var propertyUsage = PropertyUsageFlags.NoEditor;
  296. if (HoldingHammer)
  297. {
  298. propertyUsage = PropertyUsageFlags.Default;
  299. }
  300. var properties = new Godot.Collections.Array<Godot.Collections.Dictionary>();
  301. properties.Add(new Godot.Collections.Dictionary()
  302. {
  303. { "name", "HammerType" },
  304. { "type", (int)Variant.Type.Int },
  305. { "usage", (int)propertyUsage }, // See above assignment.
  306. { "hint", (int)PropertyHint.Enum },
  307. { "hint_string", "Wooden,Iron,Golden,Enchanted" }
  308. });
  309. return properties;
  310. }
  311. }
  312. \ **Note:** This method is intended for advanced purposes. For most common use cases, the scripting languages offer easier ways to handle properties. See :ref:`@GDScript.@export<class_@GDScript_annotation_@export>`, :ref:`@GDScript.@export_enum<class_@GDScript_annotation_@export_enum>`, :ref:`@GDScript.@export_group<class_@GDScript_annotation_@export_group>`, etc.
  313. \ **Note:** If the object's script is not :ref:`@GDScript.@tool<class_@GDScript_annotation_@tool>`, this method will not be called in the editor.
  314. .. rst-class:: classref-item-separator
  315. ----
  316. .. _class_Object_method__init:
  317. .. rst-class:: classref-method
  318. void **_init** **(** **)** |virtual|
  319. Called when the object's script is instantiated, oftentimes after the object is initialized in memory (through ``Object.new()`` in GDScript, or ``new Object`` in C#). It can be also defined to take in parameters. This method is similar to a constructor in most programming languages.
  320. \ **Note:** If :ref:`_init<class_Object_method__init>` is defined with *required* parameters, the Object with script may only be created directly. If any other means (such as :ref:`PackedScene.instantiate<class_PackedScene_method_instantiate>` or :ref:`Node.duplicate<class_Node_method_duplicate>`) are used, the script's initialization will fail.
  321. .. rst-class:: classref-item-separator
  322. ----
  323. .. _class_Object_method__notification:
  324. .. rst-class:: classref-method
  325. void **_notification** **(** :ref:`int<class_int>` what **)** |virtual|
  326. Called when the object receives a notification, which can be identified in ``what`` by comparing it with a constant. See also :ref:`notification<class_Object_method_notification>`.
  327. .. tabs::
  328. .. code-tab:: gdscript
  329. func _notification(what):
  330. if what == NOTIFICATION_PREDELETE:
  331. print("Goodbye!")
  332. .. code-tab:: csharp
  333. public override void _Notification(int what)
  334. {
  335. if (what == NotificationPredelete)
  336. {
  337. GD.Print("Goodbye!");
  338. }
  339. }
  340. \ **Note:** The base **Object** defines a few notifications (:ref:`NOTIFICATION_POSTINITIALIZE<class_Object_constant_NOTIFICATION_POSTINITIALIZE>` and :ref:`NOTIFICATION_PREDELETE<class_Object_constant_NOTIFICATION_PREDELETE>`). Inheriting classes such as :ref:`Node<class_Node>` define a lot more notifications, which are also received by this method.
  341. .. rst-class:: classref-item-separator
  342. ----
  343. .. _class_Object_method__property_can_revert:
  344. .. rst-class:: classref-method
  345. :ref:`bool<class_bool>` **_property_can_revert** **(** :ref:`StringName<class_StringName>` property **)** |virtual|
  346. Override this method to customize the given ``property``'s revert behavior. Should return ``true`` if the ``property`` can be reverted in the Inspector dock. Use :ref:`_property_get_revert<class_Object_method__property_get_revert>` to specify the ``property``'s default value.
  347. \ **Note:** This method must return consistently, regardless of the current value of the ``property``.
  348. .. rst-class:: classref-item-separator
  349. ----
  350. .. _class_Object_method__property_get_revert:
  351. .. rst-class:: classref-method
  352. :ref:`Variant<class_Variant>` **_property_get_revert** **(** :ref:`StringName<class_StringName>` property **)** |virtual|
  353. Override this method to customize the given ``property``'s revert behavior. Should return the default value for the ``property``. If the default value differs from the ``property``'s current value, a revert icon is displayed in the Inspector dock.
  354. \ **Note:** :ref:`_property_can_revert<class_Object_method__property_can_revert>` must also be overridden for this method to be called.
  355. .. rst-class:: classref-item-separator
  356. ----
  357. .. _class_Object_method__set:
  358. .. rst-class:: classref-method
  359. :ref:`bool<class_bool>` **_set** **(** :ref:`StringName<class_StringName>` property, :ref:`Variant<class_Variant>` value **)** |virtual|
  360. Override this method to customize the behavior of :ref:`set<class_Object_method_set>`. Should set the ``property`` to ``value`` and return ``true``, or ``false`` if the ``property`` should be handled normally. The *exact* way to set the ``property`` is up to this method's implementation.
  361. Combined with :ref:`_get<class_Object_method__get>` and :ref:`_get_property_list<class_Object_method__get_property_list>`, this method allows defining custom properties, which is particularly useful for editor plugins. Note that a property *must* be present in :ref:`get_property_list<class_Object_method_get_property_list>`, otherwise this method will not be called.
  362. .. tabs::
  363. .. code-tab:: gdscript
  364. var internal_data = {}
  365. func _set(property, value):
  366. if property == "fake_property":
  367. # Storing the value in the fake property.
  368. internal_data["fake_property"] = value
  369. return true
  370. func _get_property_list():
  371. return [
  372. { "name": "fake_property", "type": TYPE_INT }
  373. ]
  374. .. code-tab:: csharp
  375. private Godot.Collections.Dictionary _internalData = new Godot.Collections.Dictionary();
  376. public override void _Set(StringName property, Variant value)
  377. {
  378. if (property == "FakeProperty")
  379. {
  380. // Storing the value in the fake property.
  381. _internalData["FakeProperty"] = value;
  382. return true;
  383. }
  384. return false;
  385. }
  386. public override Godot.Collections.Array<Godot.Collections.Dictionary> _GetPropertyList()
  387. {
  388. return new Godot.Collections.Array<Godot.Collections.Dictionary>()
  389. {
  390. new Godot.Collections.Dictionary()
  391. {
  392. { "name", "FakeProperty" },
  393. { "type", (int)Variant.Type.Int }
  394. }
  395. };
  396. }
  397. .. rst-class:: classref-item-separator
  398. ----
  399. .. _class_Object_method__to_string:
  400. .. rst-class:: classref-method
  401. :ref:`String<class_String>` **_to_string** **(** **)** |virtual|
  402. Override this method to customize the return value of :ref:`to_string<class_Object_method_to_string>`, and therefore the object's representation as a :ref:`String<class_String>`.
  403. ::
  404. func _to_string():
  405. return "Welcome to Godot 4!"
  406. func _init():
  407. print(self) # Prints Welcome to Godot 4!"
  408. var a = str(self) # a is "Welcome to Godot 4!"
  409. .. rst-class:: classref-item-separator
  410. ----
  411. .. _class_Object_method__validate_property:
  412. .. rst-class:: classref-method
  413. void **_validate_property** **(** :ref:`Dictionary<class_Dictionary>` property **)** |virtual|
  414. Override this method to customize existing properties. Every property info goes through this method. The dictionary contents is the same as in :ref:`_get_property_list<class_Object_method__get_property_list>`.
  415. .. tabs::
  416. .. code-tab:: gdscript
  417. @tool
  418. extends Node
  419. @export var is_number_editable: bool:
  420. set(value):
  421. is_number_editable = value
  422. notify_property_list_changed()
  423. @export var number: int
  424. func _validate_property(property: Dictionary):
  425. if property.name == "number" and not is_number_editable:
  426. property.usage |= PROPERTY_USAGE_READ_ONLY
  427. .. code-tab:: csharp
  428. [Tool]
  429. public partial class MyNode : Node
  430. {
  431. private bool _isNumberEditable;
  432. [Export]
  433. public bool IsNumberEditable
  434. {
  435. get => _isNumberEditable;
  436. set
  437. {
  438. _isNumberEditable = value;
  439. NotifyPropertyListChanged();
  440. }
  441. }
  442. [Export]
  443. public int Number { get; set; }
  444. public override void _ValidateProperty(Godot.Collections.Dictionary property)
  445. {
  446. if (property["name"].AsStringName() == PropertyName.Number && IsNumberEditable)
  447. {
  448. var usage = property["usage"].As>PropertyUsageFlags<() | PropertyUsageFlags.ReadOnly;
  449. property["usage"] = (int)usage;
  450. }
  451. }
  452. }
  453. .. rst-class:: classref-item-separator
  454. ----
  455. .. _class_Object_method_add_user_signal:
  456. .. rst-class:: classref-method
  457. void **add_user_signal** **(** :ref:`String<class_String>` signal, :ref:`Array<class_Array>` arguments=[] **)**
  458. Adds a user-defined ``signal``. Optional arguments for the signal can be added as an :ref:`Array<class_Array>` of dictionaries, each defining a ``name`` :ref:`String<class_String>` and a ``type`` :ref:`int<class_int>` (see :ref:`Variant.Type<enum_@GlobalScope_Variant.Type>`). See also :ref:`has_user_signal<class_Object_method_has_user_signal>`.
  459. .. tabs::
  460. .. code-tab:: gdscript
  461. add_user_signal("hurt", [
  462. { "name": "damage", "type": TYPE_INT },
  463. { "name": "source", "type": TYPE_OBJECT }
  464. ])
  465. .. code-tab:: csharp
  466. AddUserSignal("Hurt", new Godot.Collections.Array()
  467. {
  468. new Godot.Collections.Dictionary()
  469. {
  470. { "name", "damage" },
  471. { "type", (int)Variant.Type.Int }
  472. },
  473. new Godot.Collections.Dictionary()
  474. {
  475. { "name", "source" },
  476. { "type", (int)Variant.Type.Object }
  477. }
  478. });
  479. .. rst-class:: classref-item-separator
  480. ----
  481. .. _class_Object_method_call:
  482. .. rst-class:: classref-method
  483. :ref:`Variant<class_Variant>` **call** **(** :ref:`StringName<class_StringName>` method, ... **)** |vararg|
  484. Calls the ``method`` on the object and returns the result. This method supports a variable number of arguments, so parameters can be passed as a comma separated list.
  485. .. tabs::
  486. .. code-tab:: gdscript
  487. var node = Node3D.new()
  488. node.call("rotate", Vector3(1.0, 0.0, 0.0), 1.571)
  489. .. code-tab:: csharp
  490. var node = new Node3D();
  491. node.Call(Node3D.MethodName.Rotate, new Vector3(1f, 0f, 0f), 1.571f);
  492. \ **Note:** In C#, ``method`` must be in snake_case when referring to built-in Godot methods. Prefer using the names exposed in the ``MethodName`` class to avoid allocating a new :ref:`StringName<class_StringName>` on each call.
  493. .. rst-class:: classref-item-separator
  494. ----
  495. .. _class_Object_method_call_deferred:
  496. .. rst-class:: classref-method
  497. :ref:`Variant<class_Variant>` **call_deferred** **(** :ref:`StringName<class_StringName>` method, ... **)** |vararg|
  498. Calls the ``method`` on the object during idle time. Always returns null, **not** the method's result.
  499. Idle time happens mainly at the end of process and physics frames. In it, deferred calls will be run until there are none left, which means you can defer calls from other deferred calls and they'll still be run in the current idle time cycle. If not done carefully, this can result in infinite recursion without causing a stack overflow, which will hang the game similarly to an infinite loop.
  500. This method supports a variable number of arguments, so parameters can be passed as a comma separated list.
  501. .. tabs::
  502. .. code-tab:: gdscript
  503. var node = Node3D.new()
  504. node.call_deferred("rotate", Vector3(1.0, 0.0, 0.0), 1.571)
  505. .. code-tab:: csharp
  506. var node = new Node3D();
  507. node.CallDeferred(Node3D.MethodName.Rotate, new Vector3(1f, 0f, 0f), 1.571f);
  508. See also :ref:`Callable.call_deferred<class_Callable_method_call_deferred>`.
  509. \ **Note:** In C#, ``method`` must be in snake_case when referring to built-in Godot methods. Prefer using the names exposed in the ``MethodName`` class to avoid allocating a new :ref:`StringName<class_StringName>` on each call.
  510. \ **Note:** If you're looking to delay the function call by a frame, refer to the :ref:`SceneTree.process_frame<class_SceneTree_signal_process_frame>` and :ref:`SceneTree.physics_frame<class_SceneTree_signal_physics_frame>` signals.
  511. ::
  512. var node = Node3D.new()
  513. # Make a Callable and bind the arguments to the node's rotate() call.
  514. var callable = node.rotate.bind(Vector3(1.0, 0.0, 0.0), 1.571)
  515. # Connect the callable to the process_frame signal, so it gets called in the next process frame.
  516. # CONNECT_ONE_SHOT makes sure it only gets called once instead of every frame.
  517. get_tree().process_frame.connect(callable, CONNECT_ONE_SHOT)
  518. .. rst-class:: classref-item-separator
  519. ----
  520. .. _class_Object_method_callv:
  521. .. rst-class:: classref-method
  522. :ref:`Variant<class_Variant>` **callv** **(** :ref:`StringName<class_StringName>` method, :ref:`Array<class_Array>` arg_array **)**
  523. Calls the ``method`` on the object and returns the result. Unlike :ref:`call<class_Object_method_call>`, this method expects all parameters to be contained inside ``arg_array``.
  524. .. tabs::
  525. .. code-tab:: gdscript
  526. var node = Node3D.new()
  527. node.callv("rotate", [Vector3(1.0, 0.0, 0.0), 1.571])
  528. .. code-tab:: csharp
  529. var node = new Node3D();
  530. node.Callv(Node3D.MethodName.Rotate, new Godot.Collections.Array { new Vector3(1f, 0f, 0f), 1.571f });
  531. \ **Note:** In C#, ``method`` must be in snake_case when referring to built-in Godot methods. Prefer using the names exposed in the ``MethodName`` class to avoid allocating a new :ref:`StringName<class_StringName>` on each call.
  532. .. rst-class:: classref-item-separator
  533. ----
  534. .. _class_Object_method_can_translate_messages:
  535. .. rst-class:: classref-method
  536. :ref:`bool<class_bool>` **can_translate_messages** **(** **)** |const|
  537. Returns ``true`` if the object is allowed to translate messages with :ref:`tr<class_Object_method_tr>` and :ref:`tr_n<class_Object_method_tr_n>`. See also :ref:`set_message_translation<class_Object_method_set_message_translation>`.
  538. .. rst-class:: classref-item-separator
  539. ----
  540. .. _class_Object_method_cancel_free:
  541. .. rst-class:: classref-method
  542. void **cancel_free** **(** **)**
  543. If this method is called during :ref:`NOTIFICATION_PREDELETE<class_Object_constant_NOTIFICATION_PREDELETE>`, this object will reject being freed and will remain allocated. This is mostly an internal function used for error handling to avoid the user from freeing objects when they are not intended to.
  544. .. rst-class:: classref-item-separator
  545. ----
  546. .. _class_Object_method_connect:
  547. .. rst-class:: classref-method
  548. :ref:`Error<enum_@GlobalScope_Error>` **connect** **(** :ref:`StringName<class_StringName>` signal, :ref:`Callable<class_Callable>` callable, :ref:`int<class_int>` flags=0 **)**
  549. Connects a ``signal`` by name to a ``callable``. Optional ``flags`` can be also added to configure the connection's behavior (see :ref:`ConnectFlags<enum_Object_ConnectFlags>` constants).
  550. A signal can only be connected once to the same :ref:`Callable<class_Callable>`. If the signal is already connected, this method returns :ref:`@GlobalScope.ERR_INVALID_PARAMETER<class_@GlobalScope_constant_ERR_INVALID_PARAMETER>` and pushes an error message, unless the signal is connected with :ref:`CONNECT_REFERENCE_COUNTED<class_Object_constant_CONNECT_REFERENCE_COUNTED>`. To prevent this, use :ref:`is_connected<class_Object_method_is_connected>` first to check for existing connections.
  551. If the ``callable``'s object is freed, the connection will be lost.
  552. \ **Examples with recommended syntax:**\
  553. Connecting signals is one of the most common operations in Godot and the API gives many options to do so, which are described further down. The code block below shows the recommended approach.
  554. .. tabs::
  555. .. code-tab:: gdscript
  556. func _ready():
  557. var button = Button.new()
  558. # `button_down` here is a Signal variant type, and we thus call the Signal.connect() method, not Object.connect().
  559. # See discussion below for a more in-depth overview of the API.
  560. button.button_down.connect(_on_button_down)
  561. # This assumes that a `Player` class exists, which defines a `hit` signal.
  562. var player = Player.new()
  563. # We use Signal.connect() again, and we also use the Callable.bind() method,
  564. # which returns a new Callable with the parameter binds.
  565. player.hit.connect(_on_player_hit.bind("sword", 100))
  566. func _on_button_down():
  567. print("Button down!")
  568. func _on_player_hit(weapon_type, damage):
  569. print("Hit with weapon %s for %d damage." % [weapon_type, damage])
  570. .. code-tab:: csharp
  571. public override void _Ready()
  572. {
  573. var button = new Button();
  574. // C# supports passing signals as events, so we can use this idiomatic construct:
  575. button.ButtonDown += OnButtonDown;
  576. // This assumes that a `Player` class exists, which defines a `Hit` signal.
  577. var player = new Player();
  578. // We can use lambdas when we need to bind additional parameters.
  579. player.Hit += () => OnPlayerHit("sword", 100);
  580. }
  581. private void OnButtonDown()
  582. {
  583. GD.Print("Button down!");
  584. }
  585. private void OnPlayerHit(string weaponType, int damage)
  586. {
  587. GD.Print($"Hit with weapon {weaponType} for {damage} damage.");
  588. }
  589. \ **\ ``Object.connect()`` or ``Signal.connect()``?**\
  590. As seen above, the recommended method to connect signals is not :ref:`connect<class_Object_method_connect>`. The code block below shows the four options for connecting signals, using either this legacy method or the recommended :ref:`Signal.connect<class_Signal_method_connect>`, and using either an implicit :ref:`Callable<class_Callable>` or a manually defined one.
  591. .. tabs::
  592. .. code-tab:: gdscript
  593. func _ready():
  594. var button = Button.new()
  595. # Option 1: Object.connect() with an implicit Callable for the defined function.
  596. button.connect("button_down", _on_button_down)
  597. # Option 2: Object.connect() with a constructed Callable using a target object and method name.
  598. button.connect("button_down", Callable(self, "_on_button_down"))
  599. # Option 3: Signal.connect() with an implicit Callable for the defined function.
  600. button.button_down.connect(_on_button_down)
  601. # Option 4: Signal.connect() with a constructed Callable using a target object and method name.
  602. button.button_down.connect(Callable(self, "_on_button_down"))
  603. func _on_button_down():
  604. print("Button down!")
  605. .. code-tab:: csharp
  606. public override void _Ready()
  607. {
  608. var button = new Button();
  609. // Option 1: In C#, we can use signals as events and connect with this idiomatic syntax:
  610. button.ButtonDown += OnButtonDown;
  611. // Option 2: GodotObject.Connect() with a constructed Callable from a method group.
  612. button.Connect(Button.SignalName.ButtonDown, Callable.From(OnButtonDown));
  613. // Option 3: GodotObject.Connect() with a constructed Callable using a target object and method name.
  614. button.Connect(Button.SignalName.ButtonDown, new Callable(this, MethodName.OnButtonDown));
  615. }
  616. private void OnButtonDown()
  617. {
  618. GD.Print("Button down!");
  619. }
  620. While all options have the same outcome (``button``'s :ref:`BaseButton.button_down<class_BaseButton_signal_button_down>` signal will be connected to ``_on_button_down``), **option 3** offers the best validation: it will print a compile-time error if either the ``button_down`` :ref:`Signal<class_Signal>` or the ``_on_button_down`` :ref:`Callable<class_Callable>` are not defined. On the other hand, **option 2** only relies on string names and will only be able to validate either names at runtime: it will print a runtime error if ``"button_down"`` doesn't correspond to a signal, or if ``"_on_button_down"`` is not a registered method in the object ``self``. The main reason for using options 1, 2, or 4 would be if you actually need to use strings (e.g. to connect signals programmatically based on strings read from a configuration file). Otherwise, option 3 is the recommended (and fastest) method.
  621. \ **Binding and passing parameters:**\
  622. The syntax to bind parameters is through :ref:`Callable.bind<class_Callable_method_bind>`, which returns a copy of the :ref:`Callable<class_Callable>` with its parameters bound.
  623. When calling :ref:`emit_signal<class_Object_method_emit_signal>`, the signal parameters can be also passed. The examples below show the relationship between these signal parameters and bound parameters.
  624. .. tabs::
  625. .. code-tab:: gdscript
  626. func _ready():
  627. # This assumes that a `Player` class exists, which defines a `hit` signal.
  628. var player = Player.new()
  629. # Using Callable.bind().
  630. player.hit.connect(_on_player_hit.bind("sword", 100))
  631. # Parameters added when emitting the signal are passed first.
  632. player.emit_signal("hit", "Dark lord", 5)
  633. # We pass two arguments when emitting (`hit_by`, `level`),
  634. # and bind two more arguments when connecting (`weapon_type`, `damage`).
  635. func _on_player_hit(hit_by, level, weapon_type, damage):
  636. print("Hit by %s (level %d) with weapon %s for %d damage." % [hit_by, level, weapon_type, damage])
  637. .. code-tab:: csharp
  638. public override void _Ready()
  639. {
  640. // This assumes that a `Player` class exists, which defines a `Hit` signal.
  641. var player = new Player();
  642. // Using lambda expressions that create a closure that captures the additional parameters.
  643. // The lambda only receives the parameters defined by the signal's delegate.
  644. player.Hit += (hitBy, level) => OnPlayerHit(hitBy, level, "sword", 100);
  645. // Parameters added when emitting the signal are passed first.
  646. player.EmitSignal(SignalName.Hit, "Dark lord", 5);
  647. }
  648. // We pass two arguments when emitting (`hit_by`, `level`),
  649. // and bind two more arguments when connecting (`weapon_type`, `damage`).
  650. private void OnPlayerHit(string hitBy, int level, string weaponType, int damage)
  651. {
  652. GD.Print($"Hit by {hitBy} (level {level}) with weapon {weaponType} for {damage} damage.");
  653. }
  654. .. rst-class:: classref-item-separator
  655. ----
  656. .. _class_Object_method_disconnect:
  657. .. rst-class:: classref-method
  658. void **disconnect** **(** :ref:`StringName<class_StringName>` signal, :ref:`Callable<class_Callable>` callable **)**
  659. Disconnects a ``signal`` by name from a given ``callable``. If the connection does not exist, generates an error. Use :ref:`is_connected<class_Object_method_is_connected>` to make sure that the connection exists.
  660. .. rst-class:: classref-item-separator
  661. ----
  662. .. _class_Object_method_emit_signal:
  663. .. rst-class:: classref-method
  664. :ref:`Error<enum_@GlobalScope_Error>` **emit_signal** **(** :ref:`StringName<class_StringName>` signal, ... **)** |vararg|
  665. Emits the given ``signal`` by name. The signal must exist, so it should be a built-in signal of this class or one of its inherited classes, or a user-defined signal (see :ref:`add_user_signal<class_Object_method_add_user_signal>`). This method supports a variable number of arguments, so parameters can be passed as a comma separated list.
  666. Returns :ref:`@GlobalScope.ERR_UNAVAILABLE<class_@GlobalScope_constant_ERR_UNAVAILABLE>` if ``signal`` does not exist or the parameters are invalid.
  667. .. tabs::
  668. .. code-tab:: gdscript
  669. emit_signal("hit", "sword", 100)
  670. emit_signal("game_over")
  671. .. code-tab:: csharp
  672. EmitSignal(SignalName.Hit, "sword", 100);
  673. EmitSignal(SignalName.GameOver);
  674. \ **Note:** In C#, ``signal`` must be in snake_case when referring to built-in Godot signals. Prefer using the names exposed in the ``SignalName`` class to avoid allocating a new :ref:`StringName<class_StringName>` on each call.
  675. .. rst-class:: classref-item-separator
  676. ----
  677. .. _class_Object_method_free:
  678. .. rst-class:: classref-method
  679. void **free** **(** **)**
  680. Deletes the object from memory. Pre-existing references to the object become invalid, and any attempt to access them will result in a run-time error. Checking the references with :ref:`@GlobalScope.is_instance_valid<class_@GlobalScope_method_is_instance_valid>` will return ``false``.
  681. .. rst-class:: classref-item-separator
  682. ----
  683. .. _class_Object_method_get:
  684. .. rst-class:: classref-method
  685. :ref:`Variant<class_Variant>` **get** **(** :ref:`StringName<class_StringName>` property **)** |const|
  686. Returns the :ref:`Variant<class_Variant>` value of the given ``property``. If the ``property`` does not exist, this method returns ``null``.
  687. .. tabs::
  688. .. code-tab:: gdscript
  689. var node = Node2D.new()
  690. node.rotation = 1.5
  691. var a = node.get("rotation") # a is 1.5
  692. .. code-tab:: csharp
  693. var node = new Node2D();
  694. node.Rotation = 1.5f;
  695. var a = node.Get("rotation"); // a is 1.5
  696. \ **Note:** In C#, ``property`` must be in snake_case when referring to built-in Godot properties. Prefer using the names exposed in the ``PropertyName`` class to avoid allocating a new :ref:`StringName<class_StringName>` on each call.
  697. .. rst-class:: classref-item-separator
  698. ----
  699. .. _class_Object_method_get_class:
  700. .. rst-class:: classref-method
  701. :ref:`String<class_String>` **get_class** **(** **)** |const|
  702. Returns the object's built-in class name, as a :ref:`String<class_String>`. See also :ref:`is_class<class_Object_method_is_class>`.
  703. \ **Note:** This method ignores ``class_name`` declarations. If this object's script has defined a ``class_name``, the base, built-in class name is returned instead.
  704. .. rst-class:: classref-item-separator
  705. ----
  706. .. _class_Object_method_get_incoming_connections:
  707. .. rst-class:: classref-method
  708. :ref:`Dictionary[]<class_Dictionary>` **get_incoming_connections** **(** **)** |const|
  709. Returns an :ref:`Array<class_Array>` of signal connections received by this object. Each connection is represented as a :ref:`Dictionary<class_Dictionary>` that contains three entries:
  710. - ``signal`` is a reference to the :ref:`Signal<class_Signal>`;
  711. - ``callable`` is a reference to the :ref:`Callable<class_Callable>`;
  712. - ``flags`` is a combination of :ref:`ConnectFlags<enum_Object_ConnectFlags>`.
  713. .. rst-class:: classref-item-separator
  714. ----
  715. .. _class_Object_method_get_indexed:
  716. .. rst-class:: classref-method
  717. :ref:`Variant<class_Variant>` **get_indexed** **(** :ref:`NodePath<class_NodePath>` property_path **)** |const|
  718. Gets the object's property indexed by the given ``property_path``. The path should be a :ref:`NodePath<class_NodePath>` relative to the current object and can use the colon character (``:``) to access nested properties.
  719. \ **Examples:** ``"position:x"`` or ``"material:next_pass:blend_mode"``.
  720. .. tabs::
  721. .. code-tab:: gdscript
  722. var node = Node2D.new()
  723. node.position = Vector2(5, -10)
  724. var a = node.get_indexed("position") # a is Vector2(5, -10)
  725. var b = node.get_indexed("position:y") # b is -10
  726. .. code-tab:: csharp
  727. var node = new Node2D();
  728. node.Position = new Vector2(5, -10);
  729. var a = node.GetIndexed("position"); // a is Vector2(5, -10)
  730. var b = node.GetIndexed("position:y"); // b is -10
  731. \ **Note:** In C#, ``property_path`` must be in snake_case when referring to built-in Godot properties. Prefer using the names exposed in the ``PropertyName`` class to avoid allocating a new :ref:`StringName<class_StringName>` on each call.
  732. \ **Note:** This method does not support actual paths to nodes in the :ref:`SceneTree<class_SceneTree>`, only sub-property paths. In the context of nodes, use :ref:`Node.get_node_and_resource<class_Node_method_get_node_and_resource>` instead.
  733. .. rst-class:: classref-item-separator
  734. ----
  735. .. _class_Object_method_get_instance_id:
  736. .. rst-class:: classref-method
  737. :ref:`int<class_int>` **get_instance_id** **(** **)** |const|
  738. Returns the object's unique instance ID. This ID can be saved in :ref:`EncodedObjectAsID<class_EncodedObjectAsID>`, and can be used to retrieve this object instance with :ref:`@GlobalScope.instance_from_id<class_@GlobalScope_method_instance_from_id>`.
  739. .. rst-class:: classref-item-separator
  740. ----
  741. .. _class_Object_method_get_meta:
  742. .. rst-class:: classref-method
  743. :ref:`Variant<class_Variant>` **get_meta** **(** :ref:`StringName<class_StringName>` name, :ref:`Variant<class_Variant>` default=null **)** |const|
  744. Returns the object's metadata value for the given entry ``name``. If the entry does not exist, returns ``default``. If ``default`` is ``null``, an error is also generated.
  745. \ **Note:** A metadata's name must be a valid identifier as per :ref:`StringName.is_valid_identifier<class_StringName_method_is_valid_identifier>` method.
  746. \ **Note:** Metadata that has a name starting with an underscore (``_``) is considered editor-only. Editor-only metadata is not displayed in the Inspector and should not be edited, although it can still be found by this method.
  747. .. rst-class:: classref-item-separator
  748. ----
  749. .. _class_Object_method_get_meta_list:
  750. .. rst-class:: classref-method
  751. :ref:`StringName[]<class_StringName>` **get_meta_list** **(** **)** |const|
  752. Returns the object's metadata entry names as a :ref:`PackedStringArray<class_PackedStringArray>`.
  753. .. rst-class:: classref-item-separator
  754. ----
  755. .. _class_Object_method_get_method_list:
  756. .. rst-class:: classref-method
  757. :ref:`Dictionary[]<class_Dictionary>` **get_method_list** **(** **)** |const|
  758. Returns this object's methods and their signatures as an :ref:`Array<class_Array>` of dictionaries. Each :ref:`Dictionary<class_Dictionary>` contains the following entries:
  759. - ``name`` is the name of the method, as a :ref:`String<class_String>`;
  760. - ``args`` is an :ref:`Array<class_Array>` of dictionaries representing the arguments;
  761. - ``default_args`` is the default arguments as an :ref:`Array<class_Array>` of variants;
  762. - ``flags`` is a combination of :ref:`MethodFlags<enum_@GlobalScope_MethodFlags>`;
  763. - ``id`` is the method's internal identifier :ref:`int<class_int>`;
  764. - ``return`` is the returned value, as a :ref:`Dictionary<class_Dictionary>`;
  765. \ **Note:** The dictionaries of ``args`` and ``return`` are formatted identically to the results of :ref:`get_property_list<class_Object_method_get_property_list>`, although not all entries are used.
  766. .. rst-class:: classref-item-separator
  767. ----
  768. .. _class_Object_method_get_property_list:
  769. .. rst-class:: classref-method
  770. :ref:`Dictionary[]<class_Dictionary>` **get_property_list** **(** **)** |const|
  771. Returns the object's property list as an :ref:`Array<class_Array>` of dictionaries. Each :ref:`Dictionary<class_Dictionary>` contains the following entries:
  772. - ``name`` is the property's name, as a :ref:`String<class_String>`;
  773. - ``class_name`` is an empty :ref:`StringName<class_StringName>`, unless the property is :ref:`@GlobalScope.TYPE_OBJECT<class_@GlobalScope_constant_TYPE_OBJECT>` and it inherits from a class;
  774. - ``type`` is the property's type, as an :ref:`int<class_int>` (see :ref:`Variant.Type<enum_@GlobalScope_Variant.Type>`);
  775. - ``hint`` is *how* the property is meant to be edited (see :ref:`PropertyHint<enum_@GlobalScope_PropertyHint>`);
  776. - ``hint_string`` depends on the hint (see :ref:`PropertyHint<enum_@GlobalScope_PropertyHint>`);
  777. - ``usage`` is a combination of :ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>`.
  778. \ **Note:** In GDScript, all class members are treated as properties. In C# and GDExtension, it may be necessary to explicitly mark class members as Godot properties using decorators or attributes.
  779. .. rst-class:: classref-item-separator
  780. ----
  781. .. _class_Object_method_get_script:
  782. .. rst-class:: classref-method
  783. :ref:`Variant<class_Variant>` **get_script** **(** **)** |const|
  784. Returns the object's :ref:`Script<class_Script>` instance, or ``null`` if no script is attached.
  785. .. rst-class:: classref-item-separator
  786. ----
  787. .. _class_Object_method_get_signal_connection_list:
  788. .. rst-class:: classref-method
  789. :ref:`Dictionary[]<class_Dictionary>` **get_signal_connection_list** **(** :ref:`StringName<class_StringName>` signal **)** |const|
  790. Returns an :ref:`Array<class_Array>` of connections for the given ``signal`` name. Each connection is represented as a :ref:`Dictionary<class_Dictionary>` that contains three entries:
  791. - ``signal`` is a reference to the :ref:`Signal<class_Signal>`;
  792. - ``callable`` is a reference to the connected :ref:`Callable<class_Callable>`;
  793. - ``flags`` is a combination of :ref:`ConnectFlags<enum_Object_ConnectFlags>`.
  794. .. rst-class:: classref-item-separator
  795. ----
  796. .. _class_Object_method_get_signal_list:
  797. .. rst-class:: classref-method
  798. :ref:`Dictionary[]<class_Dictionary>` **get_signal_list** **(** **)** |const|
  799. Returns the list of existing signals as an :ref:`Array<class_Array>` of dictionaries.
  800. \ **Note:** Due of the implementation, each :ref:`Dictionary<class_Dictionary>` is formatted very similarly to the returned values of :ref:`get_method_list<class_Object_method_get_method_list>`.
  801. .. rst-class:: classref-item-separator
  802. ----
  803. .. _class_Object_method_has_meta:
  804. .. rst-class:: classref-method
  805. :ref:`bool<class_bool>` **has_meta** **(** :ref:`StringName<class_StringName>` name **)** |const|
  806. Returns ``true`` if a metadata entry is found with the given ``name``. See also :ref:`get_meta<class_Object_method_get_meta>`, :ref:`set_meta<class_Object_method_set_meta>` and :ref:`remove_meta<class_Object_method_remove_meta>`.
  807. \ **Note:** A metadata's name must be a valid identifier as per :ref:`StringName.is_valid_identifier<class_StringName_method_is_valid_identifier>` method.
  808. \ **Note:** Metadata that has a name starting with an underscore (``_``) is considered editor-only. Editor-only metadata is not displayed in the Inspector and should not be edited, although it can still be found by this method.
  809. .. rst-class:: classref-item-separator
  810. ----
  811. .. _class_Object_method_has_method:
  812. .. rst-class:: classref-method
  813. :ref:`bool<class_bool>` **has_method** **(** :ref:`StringName<class_StringName>` method **)** |const|
  814. Returns ``true`` if the given ``method`` name exists in the object.
  815. \ **Note:** In C#, ``method`` must be in snake_case when referring to built-in Godot methods. Prefer using the names exposed in the ``MethodName`` class to avoid allocating a new :ref:`StringName<class_StringName>` on each call.
  816. .. rst-class:: classref-item-separator
  817. ----
  818. .. _class_Object_method_has_signal:
  819. .. rst-class:: classref-method
  820. :ref:`bool<class_bool>` **has_signal** **(** :ref:`StringName<class_StringName>` signal **)** |const|
  821. Returns ``true`` if the given ``signal`` name exists in the object.
  822. \ **Note:** In C#, ``signal`` must be in snake_case when referring to built-in Godot methods. Prefer using the names exposed in the ``SignalName`` class to avoid allocating a new :ref:`StringName<class_StringName>` on each call.
  823. .. rst-class:: classref-item-separator
  824. ----
  825. .. _class_Object_method_has_user_signal:
  826. .. rst-class:: classref-method
  827. :ref:`bool<class_bool>` **has_user_signal** **(** :ref:`StringName<class_StringName>` signal **)** |const|
  828. Returns ``true`` if the given user-defined ``signal`` name exists. Only signals added with :ref:`add_user_signal<class_Object_method_add_user_signal>` are included.
  829. .. rst-class:: classref-item-separator
  830. ----
  831. .. _class_Object_method_is_blocking_signals:
  832. .. rst-class:: classref-method
  833. :ref:`bool<class_bool>` **is_blocking_signals** **(** **)** |const|
  834. Returns ``true`` if the object is blocking its signals from being emitted. See :ref:`set_block_signals<class_Object_method_set_block_signals>`.
  835. .. rst-class:: classref-item-separator
  836. ----
  837. .. _class_Object_method_is_class:
  838. .. rst-class:: classref-method
  839. :ref:`bool<class_bool>` **is_class** **(** :ref:`String<class_String>` class **)** |const|
  840. Returns ``true`` if the object inherits from the given ``class``. See also :ref:`get_class<class_Object_method_get_class>`.
  841. .. tabs::
  842. .. code-tab:: gdscript
  843. var sprite2d = Sprite2D.new()
  844. sprite2d.is_class("Sprite2D") # Returns true
  845. sprite2d.is_class("Node") # Returns true
  846. sprite2d.is_class("Node3D") # Returns false
  847. .. code-tab:: csharp
  848. var sprite2D = new Sprite2D();
  849. sprite2D.IsClass("Sprite2D"); // Returns true
  850. sprite2D.IsClass("Node"); // Returns true
  851. sprite2D.IsClass("Node3D"); // Returns false
  852. \ **Note:** This method ignores ``class_name`` declarations in the object's script.
  853. .. rst-class:: classref-item-separator
  854. ----
  855. .. _class_Object_method_is_connected:
  856. .. rst-class:: classref-method
  857. :ref:`bool<class_bool>` **is_connected** **(** :ref:`StringName<class_StringName>` signal, :ref:`Callable<class_Callable>` callable **)** |const|
  858. Returns ``true`` if a connection exists between the given ``signal`` name and ``callable``.
  859. \ **Note:** In C#, ``signal`` must be in snake_case when referring to built-in Godot methods. Prefer using the names exposed in the ``SignalName`` class to avoid allocating a new :ref:`StringName<class_StringName>` on each call.
  860. .. rst-class:: classref-item-separator
  861. ----
  862. .. _class_Object_method_is_queued_for_deletion:
  863. .. rst-class:: classref-method
  864. :ref:`bool<class_bool>` **is_queued_for_deletion** **(** **)** |const|
  865. Returns ``true`` if the :ref:`Node.queue_free<class_Node_method_queue_free>` method was called for the object.
  866. .. rst-class:: classref-item-separator
  867. ----
  868. .. _class_Object_method_notification:
  869. .. rst-class:: classref-method
  870. void **notification** **(** :ref:`int<class_int>` what, :ref:`bool<class_bool>` reversed=false **)**
  871. Sends the given ``what`` notification to all classes inherited by the object, triggering calls to :ref:`_notification<class_Object_method__notification>`, starting from the highest ancestor (the **Object** class) and going down to the object's script.
  872. If ``reversed`` is ``true``, the call order is reversed.
  873. .. tabs::
  874. .. code-tab:: gdscript
  875. var player = Node2D.new()
  876. player.set_script(load("res://player.gd"))
  877. player.notification(NOTIFICATION_ENTER_TREE)
  878. # The call order is Object -> Node -> Node2D -> player.gd.
  879. player.notification(NOTIFICATION_ENTER_TREE, true)
  880. # The call order is player.gd -> Node2D -> Node -> Object.
  881. .. code-tab:: csharp
  882. var player = new Node2D();
  883. player.SetScript(GD.Load("res://player.gd"));
  884. player.Notification(NotificationEnterTree);
  885. // The call order is GodotObject -> Node -> Node2D -> player.gd.
  886. player.Notification(NotificationEnterTree, true);
  887. // The call order is player.gd -> Node2D -> Node -> GodotObject.
  888. .. rst-class:: classref-item-separator
  889. ----
  890. .. _class_Object_method_notify_property_list_changed:
  891. .. rst-class:: classref-method
  892. void **notify_property_list_changed** **(** **)**
  893. Emits the :ref:`property_list_changed<class_Object_signal_property_list_changed>` signal. This is mainly used to refresh the editor, so that the Inspector and editor plugins are properly updated.
  894. .. rst-class:: classref-item-separator
  895. ----
  896. .. _class_Object_method_property_can_revert:
  897. .. rst-class:: classref-method
  898. :ref:`bool<class_bool>` **property_can_revert** **(** :ref:`StringName<class_StringName>` property **)** |const|
  899. Returns ``true`` if the given ``property`` has a custom default value. Use :ref:`property_get_revert<class_Object_method_property_get_revert>` to get the ``property``'s default value.
  900. \ **Note:** This method is used by the Inspector dock to display a revert icon. The object must implement :ref:`_property_can_revert<class_Object_method__property_can_revert>` to customize the default value. If :ref:`_property_can_revert<class_Object_method__property_can_revert>` is not implemented, this method returns ``false``.
  901. .. rst-class:: classref-item-separator
  902. ----
  903. .. _class_Object_method_property_get_revert:
  904. .. rst-class:: classref-method
  905. :ref:`Variant<class_Variant>` **property_get_revert** **(** :ref:`StringName<class_StringName>` property **)** |const|
  906. Returns the custom default value of the given ``property``. Use :ref:`property_can_revert<class_Object_method_property_can_revert>` to check if the ``property`` has a custom default value.
  907. \ **Note:** This method is used by the Inspector dock to display a revert icon. The object must implement :ref:`_property_get_revert<class_Object_method__property_get_revert>` to customize the default value. If :ref:`_property_get_revert<class_Object_method__property_get_revert>` is not implemented, this method returns ``null``.
  908. .. rst-class:: classref-item-separator
  909. ----
  910. .. _class_Object_method_remove_meta:
  911. .. rst-class:: classref-method
  912. void **remove_meta** **(** :ref:`StringName<class_StringName>` name **)**
  913. Removes the given entry ``name`` from the object's metadata. See also :ref:`has_meta<class_Object_method_has_meta>`, :ref:`get_meta<class_Object_method_get_meta>` and :ref:`set_meta<class_Object_method_set_meta>`.
  914. \ **Note:** A metadata's name must be a valid identifier as per :ref:`StringName.is_valid_identifier<class_StringName_method_is_valid_identifier>` method.
  915. \ **Note:** Metadata that has a name starting with an underscore (``_``) is considered editor-only. Editor-only metadata is not displayed in the Inspector and should not be edited, although it can still be found by this method.
  916. .. rst-class:: classref-item-separator
  917. ----
  918. .. _class_Object_method_set:
  919. .. rst-class:: classref-method
  920. void **set** **(** :ref:`StringName<class_StringName>` property, :ref:`Variant<class_Variant>` value **)**
  921. Assigns ``value`` to the given ``property``. If the property does not exist or the given ``value``'s type doesn't match, nothing happens.
  922. .. tabs::
  923. .. code-tab:: gdscript
  924. var node = Node2D.new()
  925. node.set("global_scale", Vector2(8, 2.5))
  926. print(node.global_scale) # Prints (8, 2.5)
  927. .. code-tab:: csharp
  928. var node = new Node2D();
  929. node.Set("global_scale", new Vector2(8, 2.5));
  930. GD.Print(node.GlobalScale); // Prints Vector2(8, 2.5)
  931. \ **Note:** In C#, ``property`` must be in snake_case when referring to built-in Godot properties. Prefer using the names exposed in the ``PropertyName`` class to avoid allocating a new :ref:`StringName<class_StringName>` on each call.
  932. .. rst-class:: classref-item-separator
  933. ----
  934. .. _class_Object_method_set_block_signals:
  935. .. rst-class:: classref-method
  936. void **set_block_signals** **(** :ref:`bool<class_bool>` enable **)**
  937. If set to ``true``, the object becomes unable to emit signals. As such, :ref:`emit_signal<class_Object_method_emit_signal>` and signal connections will not work, until it is set to ``false``.
  938. .. rst-class:: classref-item-separator
  939. ----
  940. .. _class_Object_method_set_deferred:
  941. .. rst-class:: classref-method
  942. void **set_deferred** **(** :ref:`StringName<class_StringName>` property, :ref:`Variant<class_Variant>` value **)**
  943. Assigns ``value`` to the given ``property``, at the end of the current frame. This is equivalent to calling :ref:`set<class_Object_method_set>` through :ref:`call_deferred<class_Object_method_call_deferred>`.
  944. .. tabs::
  945. .. code-tab:: gdscript
  946. var node = Node2D.new()
  947. add_child(node)
  948. node.rotation = 45.0
  949. node.set_deferred("rotation", 90.0)
  950. print(node.rotation) # Prints 45.0
  951. await get_tree().process_frame
  952. print(node.rotation) # Prints 90.0
  953. .. code-tab:: csharp
  954. var node = new Node2D();
  955. node.Rotation = 45f;
  956. node.SetDeferred("rotation", 90f);
  957. GD.Print(node.Rotation); // Prints 45.0
  958. await ToSignal(GetTree(), SceneTree.SignalName.ProcessFrame);
  959. GD.Print(node.Rotation); // Prints 90.0
  960. \ **Note:** In C#, ``property`` must be in snake_case when referring to built-in Godot properties. Prefer using the names exposed in the ``PropertyName`` class to avoid allocating a new :ref:`StringName<class_StringName>` on each call.
  961. .. rst-class:: classref-item-separator
  962. ----
  963. .. _class_Object_method_set_indexed:
  964. .. rst-class:: classref-method
  965. void **set_indexed** **(** :ref:`NodePath<class_NodePath>` property_path, :ref:`Variant<class_Variant>` value **)**
  966. Assigns a new ``value`` to the property identified by the ``property_path``. The path should be a :ref:`NodePath<class_NodePath>` relative to this object, and can use the colon character (``:``) to access nested properties.
  967. .. tabs::
  968. .. code-tab:: gdscript
  969. var node = Node2D.new()
  970. node.set_indexed("position", Vector2(42, 0))
  971. node.set_indexed("position:y", -10)
  972. print(node.position) # Prints (42, -10)
  973. .. code-tab:: csharp
  974. var node = new Node2D();
  975. node.SetIndexed("position", new Vector2(42, 0));
  976. node.SetIndexed("position:y", -10);
  977. GD.Print(node.Position); // Prints (42, -10)
  978. \ **Note:** In C#, ``property_path`` must be in snake_case when referring to built-in Godot properties. Prefer using the names exposed in the ``PropertyName`` class to avoid allocating a new :ref:`StringName<class_StringName>` on each call.
  979. .. rst-class:: classref-item-separator
  980. ----
  981. .. _class_Object_method_set_message_translation:
  982. .. rst-class:: classref-method
  983. void **set_message_translation** **(** :ref:`bool<class_bool>` enable **)**
  984. If set to ``true``, allows the object to translate messages with :ref:`tr<class_Object_method_tr>` and :ref:`tr_n<class_Object_method_tr_n>`. Enabled by default. See also :ref:`can_translate_messages<class_Object_method_can_translate_messages>`.
  985. .. rst-class:: classref-item-separator
  986. ----
  987. .. _class_Object_method_set_meta:
  988. .. rst-class:: classref-method
  989. void **set_meta** **(** :ref:`StringName<class_StringName>` name, :ref:`Variant<class_Variant>` value **)**
  990. Adds or changes the entry ``name`` inside the object's metadata. The metadata ``value`` can be any :ref:`Variant<class_Variant>`, although some types cannot be serialized correctly.
  991. If ``value`` is ``null``, the entry is removed. This is the equivalent of using :ref:`remove_meta<class_Object_method_remove_meta>`. See also :ref:`has_meta<class_Object_method_has_meta>` and :ref:`get_meta<class_Object_method_get_meta>`.
  992. \ **Note:** A metadata's name must be a valid identifier as per :ref:`StringName.is_valid_identifier<class_StringName_method_is_valid_identifier>` method.
  993. \ **Note:** Metadata that has a name starting with an underscore (``_``) is considered editor-only. Editor-only metadata is not displayed in the Inspector and should not be edited, although it can still be found by this method.
  994. .. rst-class:: classref-item-separator
  995. ----
  996. .. _class_Object_method_set_script:
  997. .. rst-class:: classref-method
  998. void **set_script** **(** :ref:`Variant<class_Variant>` script **)**
  999. Attaches ``script`` to the object, and instantiates it. As a result, the script's :ref:`_init<class_Object_method__init>` is called. A :ref:`Script<class_Script>` is used to extend the object's functionality.
  1000. If a script already exists, its instance is detached, and its property values and state are lost. Built-in property values are still kept.
  1001. .. rst-class:: classref-item-separator
  1002. ----
  1003. .. _class_Object_method_to_string:
  1004. .. rst-class:: classref-method
  1005. :ref:`String<class_String>` **to_string** **(** **)**
  1006. Returns a :ref:`String<class_String>` representing the object. Defaults to ``"<ClassName#RID>"``. Override :ref:`_to_string<class_Object_method__to_string>` to customize the string representation of the object.
  1007. .. rst-class:: classref-item-separator
  1008. ----
  1009. .. _class_Object_method_tr:
  1010. .. rst-class:: classref-method
  1011. :ref:`String<class_String>` **tr** **(** :ref:`StringName<class_StringName>` message, :ref:`StringName<class_StringName>` context="" **)** |const|
  1012. Translates a ``message``, using the translation catalogs configured in the Project Settings. Further ``context`` can be specified to help with the translation.
  1013. If :ref:`can_translate_messages<class_Object_method_can_translate_messages>` is ``false``, or no translation is available, this method returns the ``message`` without changes. See :ref:`set_message_translation<class_Object_method_set_message_translation>`.
  1014. For detailed examples, see :doc:`Internationalizing games <../tutorials/i18n/internationalizing_games>`.
  1015. .. rst-class:: classref-item-separator
  1016. ----
  1017. .. _class_Object_method_tr_n:
  1018. .. rst-class:: classref-method
  1019. :ref:`String<class_String>` **tr_n** **(** :ref:`StringName<class_StringName>` message, :ref:`StringName<class_StringName>` plural_message, :ref:`int<class_int>` n, :ref:`StringName<class_StringName>` context="" **)** |const|
  1020. Translates a ``message`` or ``plural_message``, using the translation catalogs configured in the Project Settings. Further ``context`` can be specified to help with the translation.
  1021. If :ref:`can_translate_messages<class_Object_method_can_translate_messages>` is ``false``, or no translation is available, this method returns ``message`` or ``plural_message``, without changes. See :ref:`set_message_translation<class_Object_method_set_message_translation>`.
  1022. The ``n`` is the number, or amount, of the message's subject. It is used by the translation system to fetch the correct plural form for the current language.
  1023. For detailed examples, see :doc:`Localization using gettext <../tutorials/i18n/localization_using_gettext>`.
  1024. \ **Note:** Negative and :ref:`float<class_float>` numbers may not properly apply to some countable subjects. It's recommended handling these cases with :ref:`tr<class_Object_method_tr>`.
  1025. .. |virtual| replace:: :abbr:`virtual (This method should typically be overridden by the user to have any effect.)`
  1026. .. |const| replace:: :abbr:`const (This method has no side effects. It doesn't modify any of the instance's member variables.)`
  1027. .. |vararg| replace:: :abbr:`vararg (This method accepts any number of arguments after the ones described here.)`
  1028. .. |constructor| replace:: :abbr:`constructor (This method is used to construct a type.)`
  1029. .. |static| replace:: :abbr:`static (This method doesn't need an instance to be called, so it can be called directly using the class name.)`
  1030. .. |operator| replace:: :abbr:`operator (This method describes a valid operator to use with this type as left-hand operand.)`
  1031. .. |bitfield| replace:: :abbr:`BitField (This value is an integer composed as a bitmask of the following flags.)`