classref: Sync with current master branch (8e951fd)

classes/[email protected]

@@ -620,6 +620,24 @@ See also :ref:`@GlobalScope.PROPERTY_HINT_RANGE<class_@GlobalScope_constant_PROP
 
 ----
 
+.. _class_@GDScript_annotation_@export_storage:
+
+.. rst-class:: classref-annotation
+
+**@export_storage**\ (\ )
+
+Export a property with :ref:`@GlobalScope.PROPERTY_USAGE_STORAGE<class_@GlobalScope_constant_PROPERTY_USAGE_STORAGE>` flag. The property is not displayed in the editor, but it is serialized and stored in the scene or resource file. This can be useful for :ref:`@tool<class_@GDScript_annotation_@tool>` scripts. Also the property value is copied when :ref:`Resource.duplicate<class_Resource_method_duplicate>` or :ref:`Node.duplicate<class_Node_method_duplicate>` is called, unlike non-exported variables.
+
+::
+
+    var a # Not stored in the file, not displayed in the editor.
+    @export_storage var b # Stored in the file, not displayed in the editor.
+    @export var c: int # Stored in the file, displayed in the editor.
+
+.. rst-class:: classref-item-separator
+
+----
+
 .. _class_@GDScript_annotation_@export_subgroup:
 
 .. rst-class:: classref-annotation

classes/class_animationnode.rst

@@ -245,7 +245,7 @@ When inheriting from :ref:`AnimationRootNode<class_AnimationRootNode>`, implemen
 
 :ref:`Dictionary<class_Dictionary>` **_get_child_nodes**\ (\ ) |virtual| |const|
 
-When inheriting from :ref:`AnimationRootNode<class_AnimationRootNode>`, implement this virtual method to return all children animation nodes in order as a ``name: node`` dictionary.
+When inheriting from :ref:`AnimationRootNode<class_AnimationRootNode>`, implement this virtual method to return all child animation nodes in order as a ``name: node`` dictionary.
 
 .. rst-class:: classref-item-separator
 
@@ -359,7 +359,7 @@ Blend an input. This is only useful for animation nodes created for an :ref:`Ani
 
 :ref:`float<class_float>` **blend_node**\ (\ name\: :ref:`StringName<class_StringName>`, node\: :ref:`AnimationNode<class_AnimationNode>`, time\: :ref:`float<class_float>`, seek\: :ref:`bool<class_bool>`, is_external_seeking\: :ref:`bool<class_bool>`, blend\: :ref:`float<class_float>`, filter\: :ref:`FilterAction<enum_AnimationNode_FilterAction>` = 0, sync\: :ref:`bool<class_bool>` = true, test_only\: :ref:`bool<class_bool>` = false\ )
 
-Blend another animation node (in case this animation node contains children animation nodes). This function is only useful if you inherit from :ref:`AnimationRootNode<class_AnimationRootNode>` instead, else editors will not display your animation node for addition.
+Blend another animation node (in case this animation node contains child animation nodes). This function is only useful if you inherit from :ref:`AnimationRootNode<class_AnimationRootNode>` instead, otherwise editors will not display your animation node for addition.
 
 .. rst-class:: classref-item-separator
 

classes/class_animationnodetimescale.rst

@@ -19,7 +19,7 @@ A time-scaling animation node used in :ref:`AnimationTree<class_AnimationTree>`.
 Description
 -----------
 
-Allows to scale the speed of the animation (or reverse it) in any children :ref:`AnimationNode<class_AnimationNode>`\ s. Setting it to ``0.0`` will pause the animation.
+Allows to scale the speed of the animation (or reverse it) in any child :ref:`AnimationNode<class_AnimationNode>`\ s. Setting it to ``0.0`` will pause the animation.
 
 .. rst-class:: classref-introduction-group
 

classes/class_button.rst

@@ -122,7 +122,7 @@ Theme Properties
    +-----------------------------------+------------------------------------------------------------------------------------+-------------------------------------+
    | :ref:`Color<class_Color>`         | :ref:`font_hover_pressed_color<class_Button_theme_color_font_hover_pressed_color>` | ``Color(1, 1, 1, 1)``               |
    +-----------------------------------+------------------------------------------------------------------------------------+-------------------------------------+
-   | :ref:`Color<class_Color>`         | :ref:`font_outline_color<class_Button_theme_color_font_outline_color>`             | ``Color(1, 1, 1, 1)``               |
+   | :ref:`Color<class_Color>`         | :ref:`font_outline_color<class_Button_theme_color_font_outline_color>`             | ``Color(0, 0, 0, 1)``               |
    +-----------------------------------+------------------------------------------------------------------------------------+-------------------------------------+
    | :ref:`Color<class_Color>`         | :ref:`font_pressed_color<class_Button_theme_color_font_pressed_color>`             | ``Color(1, 1, 1, 1)``               |
    +-----------------------------------+------------------------------------------------------------------------------------+-------------------------------------+
@@ -457,7 +457,7 @@ Text :ref:`Color<class_Color>` used when the **Button** is being hovered and pre
 
 .. rst-class:: classref-themeproperty
 
-:ref:`Color<class_Color>` **font_outline_color** = ``Color(1, 1, 1, 1)``
+:ref:`Color<class_Color>` **font_outline_color** = ``Color(0, 0, 0, 1)``
 
 The tint of text outline of the **Button**.
 

classes/class_callable.rst

@@ -17,7 +17,7 @@ A built-in type representing a method or a standalone function.
 Description
 -----------
 
-**Callable** is a built-in :ref:`Variant<class_Variant>` type that represents a function. It can either be a method within an :ref:`Object<class_Object>` instance, or a standalone function not related to any object, like a lambda function. Like all :ref:`Variant<class_Variant>` types, it can be stored in variables and passed to other functions. It is most commonly used for signal callbacks.
+**Callable** is a built-in :ref:`Variant<class_Variant>` type that represents a function. It can either be a method within an :ref:`Object<class_Object>` instance, or a custom callable used for different purposes (see :ref:`is_custom<class_Callable_method_is_custom>`). Like all :ref:`Variant<class_Variant>` types, it can be stored in variables and passed to other functions. It is most commonly used for signal callbacks.
 
 \ **Example:**\ 
 
@@ -68,6 +68,26 @@ In GDScript, it's possible to create lambda functions within a method. Lambda fu
         # Prints "Attack!", when the button_pressed signal is emitted.
         button_pressed.connect(func(): print("Attack!"))
 
+In GDScript, you can access methods and global functions as **Callable**\ s:
+
+::
+
+    tween.tween_callback(node.queue_free)  # Object methods.
+    tween.tween_callback(array.clear)  # Methods of built-in types.
+    tween.tween_callback(print.bind("Test"))  # Global functions.
+
+\ **Note:** :ref:`Dictionary<class_Dictionary>` does not support the above due to ambiguity with keys.
+
+::
+
+    var dictionary = {"hello": "world"}
+    
+    # This will not work, `clear` is treated as a key.
+    tween.tween_callback(dictionary.clear)
+    
+    # This will work.
+    tween.tween_callback(Callable.create(dictionary, "clear"))
+
 .. note::
 
 	There are notable differences when using this API with C#. See :ref:`doc_c_sharp_differences` for more information.
@@ -96,43 +116,45 @@ Methods
 .. table::
    :widths: auto
 
-   +-------------------------------------+----------------------------------------------------------------------------------------------------------+
-   | :ref:`Callable<class_Callable>`     | :ref:`bind<class_Callable_method_bind>`\ (\ ...\ ) |vararg| |const|                                      |
-   +-------------------------------------+----------------------------------------------------------------------------------------------------------+
-   | :ref:`Callable<class_Callable>`     | :ref:`bindv<class_Callable_method_bindv>`\ (\ arguments\: :ref:`Array<class_Array>`\ )                   |
-   +-------------------------------------+----------------------------------------------------------------------------------------------------------+
-   | :ref:`Variant<class_Variant>`       | :ref:`call<class_Callable_method_call>`\ (\ ...\ ) |vararg| |const|                                      |
-   +-------------------------------------+----------------------------------------------------------------------------------------------------------+
-   | |void|                              | :ref:`call_deferred<class_Callable_method_call_deferred>`\ (\ ...\ ) |vararg| |const|                    |
-   +-------------------------------------+----------------------------------------------------------------------------------------------------------+
-   | :ref:`Variant<class_Variant>`       | :ref:`callv<class_Callable_method_callv>`\ (\ arguments\: :ref:`Array<class_Array>`\ ) |const|           |
-   +-------------------------------------+----------------------------------------------------------------------------------------------------------+
-   | :ref:`Array<class_Array>`           | :ref:`get_bound_arguments<class_Callable_method_get_bound_arguments>`\ (\ ) |const|                      |
-   +-------------------------------------+----------------------------------------------------------------------------------------------------------+
-   | :ref:`int<class_int>`               | :ref:`get_bound_arguments_count<class_Callable_method_get_bound_arguments_count>`\ (\ ) |const|          |
-   +-------------------------------------+----------------------------------------------------------------------------------------------------------+
-   | :ref:`StringName<class_StringName>` | :ref:`get_method<class_Callable_method_get_method>`\ (\ ) |const|                                        |
-   +-------------------------------------+----------------------------------------------------------------------------------------------------------+
-   | :ref:`Object<class_Object>`         | :ref:`get_object<class_Callable_method_get_object>`\ (\ ) |const|                                        |
-   +-------------------------------------+----------------------------------------------------------------------------------------------------------+
-   | :ref:`int<class_int>`               | :ref:`get_object_id<class_Callable_method_get_object_id>`\ (\ ) |const|                                  |
-   +-------------------------------------+----------------------------------------------------------------------------------------------------------+
-   | :ref:`int<class_int>`               | :ref:`hash<class_Callable_method_hash>`\ (\ ) |const|                                                    |
-   +-------------------------------------+----------------------------------------------------------------------------------------------------------+
-   | :ref:`bool<class_bool>`             | :ref:`is_custom<class_Callable_method_is_custom>`\ (\ ) |const|                                          |
-   +-------------------------------------+----------------------------------------------------------------------------------------------------------+
-   | :ref:`bool<class_bool>`             | :ref:`is_null<class_Callable_method_is_null>`\ (\ ) |const|                                              |
-   +-------------------------------------+----------------------------------------------------------------------------------------------------------+
-   | :ref:`bool<class_bool>`             | :ref:`is_standard<class_Callable_method_is_standard>`\ (\ ) |const|                                      |
-   +-------------------------------------+----------------------------------------------------------------------------------------------------------+
-   | :ref:`bool<class_bool>`             | :ref:`is_valid<class_Callable_method_is_valid>`\ (\ ) |const|                                            |
-   +-------------------------------------+----------------------------------------------------------------------------------------------------------+
-   | |void|                              | :ref:`rpc<class_Callable_method_rpc>`\ (\ ...\ ) |vararg| |const|                                        |
-   +-------------------------------------+----------------------------------------------------------------------------------------------------------+
-   | |void|                              | :ref:`rpc_id<class_Callable_method_rpc_id>`\ (\ peer_id\: :ref:`int<class_int>`, ...\ ) |vararg| |const| |
-   +-------------------------------------+----------------------------------------------------------------------------------------------------------+
-   | :ref:`Callable<class_Callable>`     | :ref:`unbind<class_Callable_method_unbind>`\ (\ argcount\: :ref:`int<class_int>`\ ) |const|              |
-   +-------------------------------------+----------------------------------------------------------------------------------------------------------+
+   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`Callable<class_Callable>`     | :ref:`bind<class_Callable_method_bind>`\ (\ ...\ ) |vararg| |const|                                                                               |
+   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`Callable<class_Callable>`     | :ref:`bindv<class_Callable_method_bindv>`\ (\ arguments\: :ref:`Array<class_Array>`\ )                                                            |
+   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`Variant<class_Variant>`       | :ref:`call<class_Callable_method_call>`\ (\ ...\ ) |vararg| |const|                                                                               |
+   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
+   | |void|                              | :ref:`call_deferred<class_Callable_method_call_deferred>`\ (\ ...\ ) |vararg| |const|                                                             |
+   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`Variant<class_Variant>`       | :ref:`callv<class_Callable_method_callv>`\ (\ arguments\: :ref:`Array<class_Array>`\ ) |const|                                                    |
+   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`Callable<class_Callable>`     | :ref:`create<class_Callable_method_create>`\ (\ variant\: :ref:`Variant<class_Variant>`, method\: :ref:`StringName<class_StringName>`\ ) |static| |
+   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`Array<class_Array>`           | :ref:`get_bound_arguments<class_Callable_method_get_bound_arguments>`\ (\ ) |const|                                                               |
+   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`int<class_int>`               | :ref:`get_bound_arguments_count<class_Callable_method_get_bound_arguments_count>`\ (\ ) |const|                                                   |
+   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`StringName<class_StringName>` | :ref:`get_method<class_Callable_method_get_method>`\ (\ ) |const|                                                                                 |
+   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`Object<class_Object>`         | :ref:`get_object<class_Callable_method_get_object>`\ (\ ) |const|                                                                                 |
+   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`int<class_int>`               | :ref:`get_object_id<class_Callable_method_get_object_id>`\ (\ ) |const|                                                                           |
+   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`int<class_int>`               | :ref:`hash<class_Callable_method_hash>`\ (\ ) |const|                                                                                             |
+   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`bool<class_bool>`             | :ref:`is_custom<class_Callable_method_is_custom>`\ (\ ) |const|                                                                                   |
+   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`bool<class_bool>`             | :ref:`is_null<class_Callable_method_is_null>`\ (\ ) |const|                                                                                       |
+   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`bool<class_bool>`             | :ref:`is_standard<class_Callable_method_is_standard>`\ (\ ) |const|                                                                               |
+   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`bool<class_bool>`             | :ref:`is_valid<class_Callable_method_is_valid>`\ (\ ) |const|                                                                                     |
+   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
+   | |void|                              | :ref:`rpc<class_Callable_method_rpc>`\ (\ ...\ ) |vararg| |const|                                                                                 |
+   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
+   | |void|                              | :ref:`rpc_id<class_Callable_method_rpc_id>`\ (\ peer_id\: :ref:`int<class_int>`, ...\ ) |vararg| |const|                                          |
+   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`Callable<class_Callable>`     | :ref:`unbind<class_Callable_method_unbind>`\ (\ argcount\: :ref:`int<class_int>`\ ) |const|                                                       |
+   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
 
 .. rst-class:: classref-reftable-group
 
@@ -185,6 +207,8 @@ Constructs a **Callable** as a copy of the given **Callable**.
 
 Creates a new **Callable** for the method named ``method`` in the specified ``object``.
 
+\ **Note:** For methods of built-in :ref:`Variant<class_Variant>` types, use :ref:`create<class_Callable_method_create>` instead.
+
 .. rst-class:: classref-section-separator
 
 ----
@@ -259,6 +283,8 @@ Calls the method represented by this **Callable** in deferred mode, i.e. at the
 
 
 
+\ **Note:** Deferred calls are processed at idle time. 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. This means you should not call a method deferred from itself (or from a method called by it), as this causes infinite recursion the same way as if you had called the method directly.
+
 See also :ref:`Object.call_deferred<class_Object_method_call_deferred>`.
 
 .. rst-class:: classref-item-separator
@@ -277,6 +303,20 @@ Calls the method represented by this **Callable**. Unlike :ref:`call<class_Calla
 
 ----
 
+.. _class_Callable_method_create:
+
+.. rst-class:: classref-method
+
+:ref:`Callable<class_Callable>` **create**\ (\ variant\: :ref:`Variant<class_Variant>`, method\: :ref:`StringName<class_StringName>`\ ) |static|
+
+Creates a new **Callable** for the method named ``method`` in the specified ``variant``. To represent a method of a built-in :ref:`Variant<class_Variant>` type, a custom callable is used (see :ref:`is_custom<class_Callable_method_is_custom>`). If ``variant`` is :ref:`Object<class_Object>`, then a standard callable will be created instead.
+
+\ **Note:** This method is always necessary for the :ref:`Dictionary<class_Dictionary>` type, as property syntax is used to access its entries. You may also use this method when ``variant``'s type is not known in advance (for polymorphism).
+
+.. rst-class:: classref-item-separator
+
+----
+
 .. _class_Callable_method_get_bound_arguments:
 
 .. rst-class:: classref-method
@@ -357,7 +397,15 @@ Returns the 32-bit hash value of this **Callable**'s object.
 
 :ref:`bool<class_bool>` **is_custom**\ (\ ) |const|
 
-Returns ``true`` if this **Callable** is a custom callable. Custom callables are created from :ref:`bind<class_Callable_method_bind>` or :ref:`unbind<class_Callable_method_unbind>`. In GDScript, lambda functions are also custom callables.
+Returns ``true`` if this **Callable** is a custom callable. Custom callables are used:
+
+- for binding/unbinding arguments (see :ref:`bind<class_Callable_method_bind>` and :ref:`unbind<class_Callable_method_unbind>`);
+
+- for representing methods of built-in :ref:`Variant<class_Variant>` types (see :ref:`create<class_Callable_method_create>`);
+
+- for representing global, lambda, and RPC functions in GDScript;
+
+- for other purposes in the core, GDExtension, and C#.
 
 .. rst-class:: classref-item-separator
 

classes/class_canvasitem.rst

@@ -525,7 +525,7 @@ Property Descriptions
 - |void| **set_clip_children_mode**\ (\ value\: :ref:`ClipChildrenMode<enum_CanvasItem_ClipChildrenMode>`\ )
 - :ref:`ClipChildrenMode<enum_CanvasItem_ClipChildrenMode>` **get_clip_children_mode**\ (\ )
 
-Allows the current node to clip children nodes, essentially acting as a mask.
+Allows the current node to clip child nodes, essentially acting as a mask.
 
 .. rst-class:: classref-item-separator
 
@@ -1484,7 +1484,7 @@ Transformations issued by ``event``'s inputs are applied in local space instead
 
 Moves this node to display on top of its siblings.
 
-Internally, the node is moved to the bottom of parent's children list. The method has no effect on nodes without a parent.
+Internally, the node is moved to the bottom of parent's child list. The method has no effect on nodes without a parent.
 
 .. rst-class:: classref-item-separator
 

classes/class_displayserver.rst

@@ -1584,6 +1584,8 @@ Returns the default mouse cursor shape set by :ref:`cursor_set_shape<class_Displ
 
 Sets a custom mouse cursor image for the defined ``shape``. This means the user's operating system and mouse cursor theme will no longer influence the mouse cursor's appearance. The image must be ``256x256`` or smaller for correct appearance. ``hotspot`` can optionally be set to define the area where the cursor will click. By default, ``hotspot`` is set to ``Vector2(0, 0)``, which is the top-left corner of the image. See also :ref:`cursor_set_shape<class_DisplayServer_method_cursor_set_shape>`.
 
+\ ``cursor`` can be either :ref:`Texture2D<class_Texture2D>` or :ref:`Image<class_Image>`.
+
 .. rst-class:: classref-item-separator
 
 ----

classes/class_editorsettings.rst

@@ -209,6 +209,8 @@ Properties
    +---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | :ref:`bool<class_bool>`                           | :ref:`editors/panning/warped_mouse_panning<class_EditorSettings_property_editors/panning/warped_mouse_panning>`                                                                     |
    +---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`float<class_float>`                         | :ref:`editors/polygon_editor/auto_bake_delay<class_EditorSettings_property_editors/polygon_editor/auto_bake_delay>`                                                                 |
+   +---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | :ref:`int<class_int>`                             | :ref:`editors/polygon_editor/point_grab_radius<class_EditorSettings_property_editors/polygon_editor/point_grab_radius>`                                                             |
    +---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | :ref:`bool<class_bool>`                           | :ref:`editors/polygon_editor/show_previous_outline<class_EditorSettings_property_editors/polygon_editor/show_previous_outline>`                                                     |
@@ -1695,6 +1697,18 @@ If ``true``, warps the mouse around the 2D viewport while panning in the 2D edit
 
 ----
 
+.. _class_EditorSettings_property_editors/polygon_editor/auto_bake_delay:
+
+.. rst-class:: classref-property
+
+:ref:`float<class_float>` **editors/polygon_editor/auto_bake_delay**
+
+The delay in seconds until more complex and performance costly polygon editors commit their outlines, e.g. the 2D navigation polygon editor rebakes the navigation mesh polygons. A negative value stops the auto bake.
+
+.. rst-class:: classref-item-separator
+
+----
+
 .. _class_EditorSettings_property_editors/polygon_editor/point_grab_radius:
 
 .. rst-class:: classref-property

classes/class_engine.rst

@@ -19,7 +19,7 @@ Provides access to engine properties.
 Description
 -----------
 
-The **Engine** singleton allows you to query and modify the project's run-time parameters, such as frames per second, time scale, and others.
+The **Engine** singleton allows you to query and modify the project's run-time parameters, such as frames per second, time scale, and others. It also stores information about the current build of Godot, such as the current version.
 
 .. rst-class:: classref-reftable-group
 
@@ -123,18 +123,20 @@ Property Descriptions
 - |void| **set_max_fps**\ (\ value\: :ref:`int<class_int>`\ )
 - :ref:`int<class_int>` **get_max_fps**\ (\ )
 
-The maximum number of frames per second that can be rendered. A value of ``0`` means "no limit". The actual number of frames per second may still be below this value if the CPU or GPU cannot keep up with the project logic and rendering.
+The maximum number of frames per second (FPS) that can be rendered. A value of ``0`` means the framerate is uncapped.
 
-Limiting the FPS can be useful to reduce system power consumption, which reduces heat and noise emissions (and improves battery life on mobile devices).
+Limiting the FPS can be useful to reduce the host machine's power consumption, which reduces heat, noise emissions, and improves battery life.
 
-If :ref:`ProjectSettings.display/window/vsync/vsync_mode<class_ProjectSettings_property_display/window/vsync/vsync_mode>` is ``Enabled`` or ``Adaptive``, it takes precedence and the forced FPS number cannot exceed the monitor's refresh rate.
+If :ref:`ProjectSettings.display/window/vsync/vsync_mode<class_ProjectSettings_property_display/window/vsync/vsync_mode>` is ``Enabled`` or ``Adaptive``, the setting takes precedence and the max FPS number cannot exceed the monitor's refresh rate.
 
 If :ref:`ProjectSettings.display/window/vsync/vsync_mode<class_ProjectSettings_property_display/window/vsync/vsync_mode>` is ``Enabled``, on monitors with variable refresh rate enabled (G-Sync/FreeSync), using a FPS limit a few frames lower than the monitor's refresh rate will `reduce input lag while avoiding tearing <https://blurbusters.com/howto-low-lag-vsync-on/>`__.
 
-If :ref:`ProjectSettings.display/window/vsync/vsync_mode<class_ProjectSettings_property_display/window/vsync/vsync_mode>` is ``Disabled``, limiting the FPS to a high value that can be consistently reached on the system can reduce input lag compared to an uncapped framerate. Since this works by ensuring the GPU load is lower than 100%, this latency reduction is only effective in GPU-bottlenecked scenarios, not CPU-bottlenecked scenarios.
-
 See also :ref:`physics_ticks_per_second<class_Engine_property_physics_ticks_per_second>` and :ref:`ProjectSettings.application/run/max_fps<class_ProjectSettings_property_application/run/max_fps>`.
 
+\ **Note:** The actual number of frames per second may still be below this value if the CPU or GPU cannot keep up with the project's logic and rendering.
+
+\ **Note:** If :ref:`ProjectSettings.display/window/vsync/vsync_mode<class_ProjectSettings_property_display/window/vsync/vsync_mode>` is ``Disabled``, limiting the FPS to a high value that can be consistently reached on the system can reduce input lag compared to an uncapped framerate. Since this works by ensuring the GPU load is lower than 100%, this latency reduction is only effective in GPU-bottlenecked scenarios, not CPU-bottlenecked scenarios.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -150,7 +152,9 @@ See also :ref:`physics_ticks_per_second<class_Engine_property_physics_ticks_per_
 - |void| **set_max_physics_steps_per_frame**\ (\ value\: :ref:`int<class_int>`\ )
 - :ref:`int<class_int>` **get_max_physics_steps_per_frame**\ (\ )
 
-Controls the maximum number of physics steps that can be simulated each rendered frame. The default value is tuned to avoid "spiral of death" situations where expensive physics simulations trigger more expensive simulations indefinitely. However, the game will appear to slow down if the rendering FPS is less than ``1 / max_physics_steps_per_frame`` of :ref:`physics_ticks_per_second<class_Engine_property_physics_ticks_per_second>`. This occurs even if ``delta`` is consistently used in physics calculations. To avoid this, increase :ref:`max_physics_steps_per_frame<class_Engine_property_max_physics_steps_per_frame>` if you have increased :ref:`physics_ticks_per_second<class_Engine_property_physics_ticks_per_second>` significantly above its default value.
+The maximum number of physics steps that can be simulated each rendered frame.
+
+\ **Note:** The default value is tuned to prevent expensive physics simulations from triggering even more expensive simulations indefinitely. However, the game will appear to slow down if the rendering FPS is less than ``1 / max_physics_steps_per_frame`` of :ref:`physics_ticks_per_second<class_Engine_property_physics_ticks_per_second>`. This occurs even if ``delta`` is consistently used in physics calculations. To avoid this, increase :ref:`max_physics_steps_per_frame<class_Engine_property_max_physics_steps_per_frame>` if you have increased :ref:`physics_ticks_per_second<class_Engine_property_physics_ticks_per_second>` significantly above its default value.
 
 .. rst-class:: classref-item-separator
 
@@ -167,9 +171,11 @@ Controls the maximum number of physics steps that can be simulated each rendered
 - |void| **set_physics_jitter_fix**\ (\ value\: :ref:`float<class_float>`\ )
 - :ref:`float<class_float>` **get_physics_jitter_fix**\ (\ )
 
-Controls how much physics ticks are synchronized with real time. For 0 or less, the ticks are synchronized. Such values are recommended for network games, where clock synchronization matters. Higher values cause higher deviation of the in-game clock and real clock but smooth out framerate jitters. The default value of 0.5 should be good enough for most; values above 2 could cause the game to react to dropped frames with a noticeable delay and are not recommended.
+How much physics ticks are synchronized with real time. If ``0`` or less, the ticks are fully synchronized. Higher values cause the in-game clock to deviate more from the real clock, but they smooth out framerate jitters.
+
+\ **Note:** The default value of ``0.5`` should be good enough for most cases; values above ``2`` could cause the game to react to dropped frames with a noticeable delay and are not recommended.
 
-\ **Note:** For best results, when using a custom physics interpolation solution, the physics jitter fix should be disabled by setting :ref:`physics_jitter_fix<class_Engine_property_physics_jitter_fix>` to ``0``.
+\ **Note:** When using a custom physics interpolation solution, or within a network game, it's recommended to disable the physics jitter fix by setting this property to ``0``.
 
 .. rst-class:: classref-item-separator
 
@@ -207,10 +213,10 @@ The number of fixed iterations per second. This controls how often physics simul
 
 If ``false``, stops printing error and warning messages to the console and editor Output log. This can be used to hide error and warning messages during unit test suite runs. This property is equivalent to the :ref:`ProjectSettings.application/run/disable_stderr<class_ProjectSettings_property_application/run/disable_stderr>` project setting.
 
-\ **Warning:** If you set this to ``false`` anywhere in the project, important error messages may be hidden even if they are emitted from other scripts. If this is set to ``false`` in a ``@tool`` script, this will also impact the editor itself. Do *not* report bugs before ensuring error messages are enabled (as they are by default).
-
 \ **Note:** This property does not impact the editor's Errors tab when running a project from the editor.
 
+\ **Warning:** If set to ``false`` anywhere in the project, important error messages may be hidden even if they are emitted from other scripts. In a ``@tool`` script, this will also impact the editor itself. Do *not* report bugs before ensuring error messages are enabled (as they are by default).
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -226,11 +232,15 @@ If ``false``, stops printing error and warning messages to the console and edito
 - |void| **set_time_scale**\ (\ value\: :ref:`float<class_float>`\ )
 - :ref:`float<class_float>` **get_time_scale**\ (\ )
 
-Controls how fast or slow the in-game clock ticks versus the real life one. It defaults to 1.0. A value of 2.0 means the game moves twice as fast as real life, whilst a value of 0.5 means the game moves at half the regular speed. This also affects :ref:`Timer<class_Timer>` and :ref:`SceneTreeTimer<class_SceneTreeTimer>` (see :ref:`SceneTree.create_timer<class_SceneTree_method_create_timer>` for how to control this).
+The speed multiplier at which the in-game clock updates, compared to real time. For example, if set to ``2.0`` the game runs twice as fast, and if set to ``0.5`` the game runs half as fast.
+
+This value affects :ref:`Timer<class_Timer>`, :ref:`SceneTreeTimer<class_SceneTreeTimer>`, and all other simulations that make use of ``delta`` time (such as :ref:`Node._process<class_Node_private_method__process>` and :ref:`Node._physics_process<class_Node_private_method__physics_process>`).
+
+\ **Note:** It's recommended to keep this property above ``0.0``, as the game may behave unexpectedly otherwise.
 
 \ **Note:** This does not affect audio playback speed. Use :ref:`AudioServer.playback_speed_scale<class_AudioServer_property_playback_speed_scale>` to adjust audio playback speed independently of :ref:`time_scale<class_Engine_property_time_scale>`.
 
-\ **Note:** This does not automatically adjust :ref:`physics_ticks_per_second<class_Engine_property_physics_ticks_per_second>`, which means that with time scales above 1.0, physics simulation may become less precise (as each physics tick will stretch over a larger period of engine time). If you're using :ref:`time_scale<class_Engine_property_time_scale>` to speed up simulation by a large factor, consider increasing :ref:`physics_ticks_per_second<class_Engine_property_physics_ticks_per_second>` as well to improve physics reliability.
+\ **Note:** This does not automatically adjust :ref:`physics_ticks_per_second<class_Engine_property_physics_ticks_per_second>`. With values above ``1.0`` physics simulation may become less precise, as each physics tick will stretch over a larger period of engine time. If you're modifying :ref:`time_scale<class_Engine_property_time_scale>` to speed up simulation by a large factor, consider also increasing :ref:`physics_ticks_per_second<class_Engine_property_physics_ticks_per_second>` to make the simulation more reliable.
 
 .. rst-class:: classref-section-separator
 
@@ -247,9 +257,9 @@ Method Descriptions
 
 :ref:`String<class_String>` **get_architecture_name**\ (\ ) |const|
 
-Returns the name of the CPU architecture the Godot binary was built for. Possible return values are ``x86_64``, ``x86_32``, ``arm64``, ``arm32``, ``rv64``, ``riscv``, ``ppc64``, ``ppc``, ``wasm64`` and ``wasm32``.
+Returns the name of the CPU architecture the Godot binary was built for. Possible return values include ``"x86_64"``, ``"x86_32"``, ``"arm64"``, ``"arm32"``, ``"rv64"``, ``"riscv"``, ``"ppc64"``, ``"ppc"``, ``"wasm64"``, and ``"wasm32"``.
 
-To detect whether the current CPU architecture is 64-bit, you can use the fact that all 64-bit architecture names have ``64`` in their name:
+To detect whether the current build is 64-bit, you can use the fact that all 64-bit architecture names contain ``64`` in their name:
 
 
 .. tabs::
@@ -270,7 +280,7 @@ To detect whether the current CPU architecture is 64-bit, you can use the fact t
 
 
 
-\ **Note:** :ref:`get_architecture_name<class_Engine_method_get_architecture_name>` does *not* return the name of the host CPU architecture. For example, if running an x86_32 Godot binary on a x86_64 system, the returned value will be ``x86_32``.
+\ **Note:** This method does *not* return the name of the system's CPU architecture (like :ref:`OS.get_processor_name<class_OS_method_get_processor_name>`). For example, when running a ``x86_32`` Godot binary on a ``x86_64`` system, the returned value will still be ``"x86_32"``.
 
 .. rst-class:: classref-item-separator
 
@@ -282,15 +292,7 @@ To detect whether the current CPU architecture is 64-bit, you can use the fact t
 
 :ref:`Dictionary<class_Dictionary>` **get_author_info**\ (\ ) |const|
 
-Returns engine author information in a Dictionary.
-
-\ ``lead_developers``    - Array of Strings, lead developer names
-
-\ ``founders``           - Array of Strings, founder names
-
-\ ``project_managers``   - Array of Strings, project manager names
-
-\ ``developers``         - Array of Strings, developer names
+Returns the engine author information as a :ref:`Dictionary<class_Dictionary>`, where each entry is an :ref:`Array<class_Array>` of strings with the names of notable contributors to the Godot Engine: ``lead_developers``, ``founders``, ``project_managers``, and ``developers``.
 
 .. rst-class:: classref-item-separator
 
@@ -302,11 +304,15 @@ Returns engine author information in a Dictionary.
 
 :ref:`Array<class_Array>`\[:ref:`Dictionary<class_Dictionary>`\] **get_copyright_info**\ (\ ) |const|
 
-Returns an Array of copyright information Dictionaries.
+Returns an :ref:`Array<class_Array>` of dictionaries with copyright information for every component of Godot's source code.
+
+Every :ref:`Dictionary<class_Dictionary>` contains a ``name`` identifier, and a ``parts`` array of dictionaries. It describes the component in detail with the following entries:
+
+- ``files`` - :ref:`Array<class_Array>` of file paths from the source code affected by this component;
 
-\ ``name``    - String, component name
+- ``copyright`` - :ref:`Array<class_Array>` of owners of this component;
 
-\ ``parts``   - Array of Dictionaries {``files``, ``copyright``, ``license``} describing subsections of the component
+- ``license`` - The license applied to this component (such as "`Expat <https://en.wikipedia.org/wiki/MIT_License#Ambiguity_and_variants>`__" or "`CC-BY-4.0 <https://creativecommons.org/licenses/by/4.0/>`__").
 
 .. rst-class:: classref-item-separator
 
@@ -318,7 +324,7 @@ Returns an Array of copyright information Dictionaries.
 
 :ref:`Dictionary<class_Dictionary>` **get_donor_info**\ (\ ) |const|
 
-Returns a Dictionary of Arrays of donor names.
+Returns a :ref:`Dictionary<class_Dictionary>` of categorized donor names. Each entry is an :ref:`Array<class_Array>` of strings:
 
 {``platinum_sponsors``, ``gold_sponsors``, ``silver_sponsors``, ``bronze_sponsors``, ``mini_sponsors``, ``gold_donors``, ``silver_donors``, ``bronze_donors``}
 
@@ -332,7 +338,9 @@ Returns a Dictionary of Arrays of donor names.
 
 :ref:`int<class_int>` **get_frames_drawn**\ (\ )
 
-Returns the total number of frames drawn. On headless platforms, or if the render loop is disabled with ``--disable-render-loop`` via command line, :ref:`get_frames_drawn<class_Engine_method_get_frames_drawn>` always returns ``0``. See :ref:`get_process_frames<class_Engine_method_get_process_frames>`.
+Returns the total number of frames drawn since the engine started.
+
+\ **Note:** On headless platforms, or if rendering is disabled with ``--disable-render-loop`` via command line, this method always returns ``0``. See also :ref:`get_process_frames<class_Engine_method_get_process_frames>`.
 
 .. rst-class:: classref-item-separator
 
@@ -344,7 +352,7 @@ Returns the total number of frames drawn. On headless platforms, or if the rende
 
 :ref:`float<class_float>` **get_frames_per_second**\ (\ ) |const|
 
-Returns the frames per second of the running game.
+Returns the average frames rendered every second (FPS), also known as the framerate.
 
 .. rst-class:: classref-item-separator
 
@@ -356,7 +364,7 @@ Returns the frames per second of the running game.
 
 :ref:`Dictionary<class_Dictionary>` **get_license_info**\ (\ ) |const|
 
-Returns Dictionary of licenses used by Godot and included third party components.
+Returns a :ref:`Dictionary<class_Dictionary>` of licenses used by Godot and included third party components. Each entry is a license name (such as "`Expat <https://en.wikipedia.org/wiki/MIT_License#Ambiguity_and_variants>`__") and its associated text.
 
 .. rst-class:: classref-item-separator
 
@@ -368,7 +376,7 @@ Returns Dictionary of licenses used by Godot and included third party components
 
 :ref:`String<class_String>` **get_license_text**\ (\ ) |const|
 
-Returns Godot license text.
+Returns the full Godot license text.
 
 .. rst-class:: classref-item-separator
 
@@ -380,7 +388,9 @@ Returns Godot license text.
 
 :ref:`MainLoop<class_MainLoop>` **get_main_loop**\ (\ ) |const|
 
-Returns the main loop object (see :ref:`MainLoop<class_MainLoop>` and :ref:`SceneTree<class_SceneTree>`).
+Returns the instance of the :ref:`MainLoop<class_MainLoop>`. This is usually the main :ref:`SceneTree<class_SceneTree>` and is the same as :ref:`Node.get_tree<class_Node_method_get_tree>`.
+
+\ **Note:** The type instantiated as the main loop can changed with :ref:`ProjectSettings.application/run/main_loop_type<class_ProjectSettings_property_application/run/main_loop_type>`.
 
 .. rst-class:: classref-item-separator
 
@@ -392,9 +402,9 @@ Returns the main loop object (see :ref:`MainLoop<class_MainLoop>` and :ref:`Scen
 
 :ref:`int<class_int>` **get_physics_frames**\ (\ ) |const|
 
-Returns the total number of frames passed since engine initialization which is advanced on each **physics frame**. See also :ref:`get_process_frames<class_Engine_method_get_process_frames>`.
+Returns the total number of frames passed since the engine started. This number is increased every **physics frame**. See also :ref:`get_process_frames<class_Engine_method_get_process_frames>`.
 
-\ :ref:`get_physics_frames<class_Engine_method_get_physics_frames>` can be used to run expensive logic less often without relying on a :ref:`Timer<class_Timer>`:
+This method can be used to run expensive logic less often without relying on a :ref:`Timer<class_Timer>`:
 
 
 .. tabs::
@@ -403,7 +413,7 @@ Returns the total number of frames passed since engine initialization which is a
 
     func _physics_process(_delta):
         if Engine.get_physics_frames() % 2 == 0:
-            pass  # Run expensive logic only once every 2 physics frames here.
+            pass # Run expensive logic only once every 2 physics frames here.
 
  .. code-tab:: csharp
 
@@ -441,9 +451,9 @@ Returns the fraction through the current physics tick we are at the time of rend
 
 :ref:`int<class_int>` **get_process_frames**\ (\ ) |const|
 
-Returns the total number of frames passed since engine initialization which is advanced on each **process frame**, regardless of whether the render loop is enabled. See also :ref:`get_frames_drawn<class_Engine_method_get_frames_drawn>` and :ref:`get_physics_frames<class_Engine_method_get_physics_frames>`.
+Returns the total number of frames passed since the engine started. This number is increased every **process frame**, regardless of whether the render loop is enabled. See also :ref:`get_frames_drawn<class_Engine_method_get_frames_drawn>` and :ref:`get_physics_frames<class_Engine_method_get_physics_frames>`.
 
-\ :ref:`get_process_frames<class_Engine_method_get_process_frames>` can be used to run expensive logic less often without relying on a :ref:`Timer<class_Timer>`:
+This method can be used to run expensive logic less often without relying on a :ref:`Timer<class_Timer>`:
 
 
 .. tabs::
@@ -451,8 +461,8 @@ Returns the total number of frames passed since engine initialization which is a
  .. code-tab:: gdscript
 
     func _process(_delta):
-        if Engine.get_process_frames() % 2 == 0:
-            pass  # Run expensive logic only once every 2 process (render) frames here.
+        if Engine.get_process_frames() % 5 == 0:
+            pass # Run expensive logic only once every 5 process (render) frames here.
 
  .. code-tab:: csharp
 
@@ -460,9 +470,9 @@ Returns the total number of frames passed since engine initialization which is a
     {
         base._Process(delta);
     
-        if (Engine.GetProcessFrames() % 2 == 0)
+        if (Engine.GetProcessFrames() % 5 == 0)
         {
-            // Run expensive logic only once every 2 physics frames here.
+            // Run expensive logic only once every 5 process (render) frames here.
         }
     }
 
@@ -478,7 +488,7 @@ Returns the total number of frames passed since engine initialization which is a
 
 :ref:`ScriptLanguage<class_ScriptLanguage>` **get_script_language**\ (\ index\: :ref:`int<class_int>`\ ) |const|
 
-Returns an instance of a :ref:`ScriptLanguage<class_ScriptLanguage>` with the given index.
+Returns an instance of a :ref:`ScriptLanguage<class_ScriptLanguage>` with the given ``index``.
 
 .. rst-class:: classref-item-separator
 
@@ -502,7 +512,9 @@ Returns the number of available script languages. Use with :ref:`get_script_lang
 
 :ref:`Object<class_Object>` **get_singleton**\ (\ name\: :ref:`StringName<class_StringName>`\ ) |const|
 
-Returns a global singleton with given ``name``. Often used for plugins, e.g. GodotPayments.
+Returns the global singleton with the given ``name``, or ``null`` if it does not exist. Often used for plugins. See also :ref:`has_singleton<class_Engine_method_has_singleton>` and :ref:`get_singleton_list<class_Engine_method_get_singleton_list>`.
+
+\ **Note:** Global singletons are not the same as autoloaded nodes, which are configurable in the project settings.
 
 .. rst-class:: classref-item-separator
 
@@ -514,7 +526,7 @@ Returns a global singleton with given ``name``. Often used for plugins, e.g. God
 
 :ref:`PackedStringArray<class_PackedStringArray>` **get_singleton_list**\ (\ ) |const|
 
-Returns a list of available global singletons.
+Returns a list of names of all available global singletons. See also :ref:`get_singleton<class_Engine_method_get_singleton>`.
 
 .. rst-class:: classref-item-separator
 
@@ -526,45 +538,49 @@ Returns a list of available global singletons.
 
 :ref:`Dictionary<class_Dictionary>` **get_version_info**\ (\ ) |const|
 
-Returns the current engine version information in a Dictionary.
+Returns the current engine version information as a :ref:`Dictionary<class_Dictionary>` containing the following entries:
 
-\ ``major``    - Holds the major version number as an int
+- ``major`` - Major version number as an int;
 
-\ ``minor``    - Holds the minor version number as an int
+- ``minor`` - Minor version number as an int;
 
-\ ``patch``    - Holds the patch version number as an int
+- ``patch`` - Patch version number as an int;
 
-\ ``hex``      - Holds the full version number encoded as a hexadecimal int with one byte (2 places) per number (see example below)
+- ``hex`` - Full version encoded as a hexadecimal int with one byte (2 hex digits) per number (see example below);
 
-\ ``status``   - Holds the status (e.g. "beta", "rc1", "rc2", ... "stable") as a String
+- ``status`` - Status (such as "beta", "rc1", "rc2", "stable", etc.) as a String;
 
-\ ``build``    - Holds the build name (e.g. "custom_build") as a String
+- ``build`` - Build name (e.g. "custom_build") as a String;
 
-\ ``hash``     - Holds the full Git commit hash as a String
+- ``hash`` - Full Git commit hash as a String;
 
-\ ``string``   - ``major`` + ``minor`` + ``patch`` + ``status`` + ``build`` in a single String
+- ``timestamp`` - Holds the Git commit date UNIX timestamp in seconds as an int, or ``0`` if unavailable;
 
-The ``hex`` value is encoded as follows, from left to right: one byte for the major, one byte for the minor, one byte for the patch version. For example, "3.1.12" would be ``0x03010C``. **Note:** It's still an int internally, and printing it will give you its decimal representation, which is not particularly meaningful. Use hexadecimal literals for easy version comparisons from code:
+- ``string`` - ``major``, ``minor``, ``patch``, ``status``, and ``build`` in a single String.
+
+The ``hex`` value is encoded as follows, from left to right: one byte for the major, one byte for the minor, one byte for the patch version. For example, "3.1.12" would be ``0x03010C``.
+
+\ **Note:** The ``hex`` value is still an :ref:`int<class_int>` internally, and printing it will give you its decimal representation, which is not particularly meaningful. Use hexadecimal literals for quick version comparisons from code:
 
 
 .. tabs::
 
  .. code-tab:: gdscript
 
-    if Engine.get_version_info().hex >= 0x030200:
-        # Do things specific to version 3.2 or later
+    if Engine.get_version_info().hex >= 0x040100:
+        pass # Do things specific to version 4.1 or later.
     else:
-        # Do things specific to versions before 3.2
+        pass # Do things specific to versions before 4.1.
 
  .. code-tab:: csharp
 
-    if ((int)Engine.GetVersionInfo()["hex"] >= 0x030200)
+    if ((int)Engine.GetVersionInfo()["hex"] >= 0x040100)
     {
-        // Do things specific to version 3.2 or later
+        // Do things specific to version 4.1 or later.
     }
     else
     {
-        // Do things specific to versions before 3.2
+        // Do things specific to versions before 4.1.
     }
 
 
@@ -579,7 +595,7 @@ The ``hex`` value is encoded as follows, from left to right: one byte for the ma
 
 :ref:`String<class_String>` **get_write_movie_path**\ (\ ) |const|
 
-Returns the path to the :ref:`MovieWriter<class_MovieWriter>`'s output file, or an empty string if the engine wasn't started in Movie Maker mode. This path can be absolute or relative depending on how the user specified it.
+Returns the path to the :ref:`MovieWriter<class_MovieWriter>`'s output file, or an empty string if the engine wasn't started in Movie Maker mode. The default path can be changed in :ref:`ProjectSettings.editor/movie_writer/movie_file<class_ProjectSettings_property_editor/movie_writer/movie_file>`.
 
 .. rst-class:: classref-item-separator
 
@@ -591,7 +607,28 @@ Returns the path to the :ref:`MovieWriter<class_MovieWriter>`'s output file, or
 
 :ref:`bool<class_bool>` **has_singleton**\ (\ name\: :ref:`StringName<class_StringName>`\ ) |const|
 
-Returns ``true`` if a singleton with given ``name`` exists in global scope.
+Returns ``true`` if a singleton with the given ``name`` exists in the global scope. See also :ref:`get_singleton<class_Engine_method_get_singleton>`.
+
+
+.. tabs::
+
+ .. code-tab:: gdscript
+
+    print(Engine.has_singleton("OS"))          # Prints true
+    print(Engine.has_singleton("Engine"))      # Prints true
+    print(Engine.has_singleton("AudioServer")) # Prints true
+    print(Engine.has_singleton("Unknown"))     # Prints false
+
+ .. code-tab:: csharp
+
+    GD.Print(Engine.HasSingleton("OS"));          // Prints true
+    GD.Print(Engine.HasSingleton("Engine"));      // Prints true
+    GD.Print(Engine.HasSingleton("AudioServer")); // Prints true
+    GD.Print(Engine.HasSingleton("Unknown"));     // Prints false
+
+
+
+\ **Note:** Global singletons are not the same as autoloaded nodes, which are configurable in the project settings.
 
 .. rst-class:: classref-item-separator
 
@@ -603,7 +640,7 @@ Returns ``true`` if a singleton with given ``name`` exists in global scope.
 
 :ref:`bool<class_bool>` **is_editor_hint**\ (\ ) |const|
 
-Returns ``true`` if the script is currently running inside the editor, ``false`` otherwise. This is useful for ``@tool`` scripts to conditionally draw editor helpers, or prevent accidentally running "game" code that would affect the scene state while in the editor:
+Returns ``true`` if the script is currently running inside the editor, otherwise returns ``false``. This is useful for ``@tool`` scripts to conditionally draw editor helpers, or prevent accidentally running "game" code that would affect the scene state while in the editor:
 
 
 .. tabs::
@@ -626,7 +663,7 @@ Returns ``true`` if the script is currently running inside the editor, ``false``
 
 See :doc:`Running code in the editor <../tutorials/plugins/running_code_in_the_editor>` in the documentation for more information.
 
-\ **Note:** To detect whether the script is run from an editor *build* (e.g. when pressing :kbd:`F5`), use :ref:`OS.has_feature<class_OS_method_has_feature>` with the ``"editor"`` argument instead. ``OS.has_feature("editor")`` will evaluate to ``true`` both when the code is running in the editor and when running the project from the editor, but it will evaluate to ``false`` when the code is run from an exported project.
+\ **Note:** To detect whether the script is running on an editor *build* (such as when pressing :kbd:`F5`), use :ref:`OS.has_feature<class_OS_method_has_feature>` with the ``"editor"`` argument instead. ``OS.has_feature("editor")`` evaluate to ``true`` both when the script is running in the editor and when running the project from the editor, but returns ``false`` when run from an exported project.
 
 .. rst-class:: classref-item-separator
 
@@ -638,7 +675,20 @@ See :doc:`Running code in the editor <../tutorials/plugins/running_code_in_the_e
 
 :ref:`bool<class_bool>` **is_in_physics_frame**\ (\ ) |const|
 
-Returns ``true`` if the game is inside the fixed process and physics phase of the game loop.
+Returns ``true`` if the engine is inside the fixed physics process step of the main loop.
+
+::
+
+    func _enter_tree():
+        # Depending on when the node is added to the tree,
+        # prints either "true" or "false".
+        print(Engine.is_in_physics_frame())
+    
+    func _process(delta):
+        print(Engine.is_in_physics_frame()) # Prints false
+    
+    func _physics_process(delta):
+        print(Engine.is_in_physics_frame()) # Prints true
 
 .. rst-class:: classref-item-separator
 
@@ -654,11 +704,11 @@ Registers a :ref:`ScriptLanguage<class_ScriptLanguage>` instance to be available
 
 Returns:
 
-- :ref:`@GlobalScope.OK<class_@GlobalScope_constant_OK>` on success
+- :ref:`@GlobalScope.OK<class_@GlobalScope_constant_OK>` on success;
 
-- :ref:`@GlobalScope.ERR_UNAVAILABLE<class_@GlobalScope_constant_ERR_UNAVAILABLE>` if ``ScriptServer`` has reached it limit and cannot register any new language
+- :ref:`@GlobalScope.ERR_UNAVAILABLE<class_@GlobalScope_constant_ERR_UNAVAILABLE>` if ``ScriptServer`` has reached the limit and cannot register any new language;
 
-- :ref:`@GlobalScope.ERR_ALREADY_EXISTS<class_@GlobalScope_constant_ERR_ALREADY_EXISTS>` if ``ScriptServer`` already contains a language with similar extension/name/type
+- :ref:`@GlobalScope.ERR_ALREADY_EXISTS<class_@GlobalScope_constant_ERR_ALREADY_EXISTS>` if ``ScriptServer`` already contains a language with similar extension/name/type.
 
 .. rst-class:: classref-item-separator
 
@@ -670,7 +720,7 @@ Returns:
 
 |void| **register_singleton**\ (\ name\: :ref:`StringName<class_StringName>`, instance\: :ref:`Object<class_Object>`\ )
 
-Registers the given object as a singleton, globally available under ``name``.
+Registers the given :ref:`Object<class_Object>` ``instance`` as a singleton, available globally under ``name``. Useful for plugins.
 
 .. rst-class:: classref-item-separator
 
@@ -686,9 +736,9 @@ Unregisters the :ref:`ScriptLanguage<class_ScriptLanguage>` instance from ``Scri
 
 Returns:
 
-- :ref:`@GlobalScope.OK<class_@GlobalScope_constant_OK>` on success
+- :ref:`@GlobalScope.OK<class_@GlobalScope_constant_OK>` on success;
 
-- :ref:`@GlobalScope.ERR_DOES_NOT_EXIST<class_@GlobalScope_constant_ERR_DOES_NOT_EXIST>` if the language is already not registered in ``ScriptServer``
+- :ref:`@GlobalScope.ERR_DOES_NOT_EXIST<class_@GlobalScope_constant_ERR_DOES_NOT_EXIST>` if the language is not registered in ``ScriptServer``.
 
 .. rst-class:: classref-item-separator
 
@@ -700,7 +750,7 @@ Returns:
 
 |void| **unregister_singleton**\ (\ name\: :ref:`StringName<class_StringName>`\ )
 
-Unregisters the singleton registered under ``name``. The singleton object is not freed. Only works with user-defined singletons created with :ref:`register_singleton<class_Engine_method_register_singleton>`.
+Removes the singleton registered under ``name``. The singleton object is *not* freed. Only works with user-defined singletons registered with :ref:`register_singleton<class_Engine_method_register_singleton>`.
 
 .. |virtual| replace:: :abbr:`virtual (This method should typically be overridden by the user to have any effect.)`
 .. |const| replace:: :abbr:`const (This method has no side effects. It doesn't modify any of the instance's member variables.)`

classes/class_filedialog.rst

@@ -112,6 +112,8 @@ Theme Properties
    +-----------------------------------+------------------------------------------------------------------------------+--------------------------+
    | :ref:`Texture2D<class_Texture2D>` | :ref:`back_folder<class_FileDialog_theme_icon_back_folder>`                  |                          |
    +-----------------------------------+------------------------------------------------------------------------------+--------------------------+
+   | :ref:`Texture2D<class_Texture2D>` | :ref:`create_folder<class_FileDialog_theme_icon_create_folder>`              |                          |
+   +-----------------------------------+------------------------------------------------------------------------------+--------------------------+
    | :ref:`Texture2D<class_Texture2D>` | :ref:`file<class_FileDialog_theme_icon_file>`                                |                          |
    +-----------------------------------+------------------------------------------------------------------------------+--------------------------+
    | :ref:`Texture2D<class_Texture2D>` | :ref:`folder<class_FileDialog_theme_icon_folder>`                            |                          |
@@ -689,6 +691,18 @@ Custom icon for the back arrow.
 
 ----
 
+.. _class_FileDialog_theme_icon_create_folder:
+
+.. rst-class:: classref-themeproperty
+
+:ref:`Texture2D<class_Texture2D>` **create_folder**
+
+Custom icon for the create folder button.
+
+.. rst-class:: classref-item-separator
+
+----
+
 .. _class_FileDialog_theme_icon_file:
 
 .. rst-class:: classref-themeproperty

classes/class_flowcontainer.rst

@@ -203,7 +203,7 @@ Theme Property Descriptions
 
 :ref:`int<class_int>` **h_separation** = ``4``
 
-The horizontal separation of children nodes.
+The horizontal separation of child nodes.
 
 .. rst-class:: classref-item-separator
 
@@ -215,7 +215,7 @@ The horizontal separation of children nodes.
 
 :ref:`int<class_int>` **v_separation** = ``4``
 
-The vertical separation of children nodes.
+The vertical separation of child nodes.
 
 .. |virtual| replace:: :abbr:`virtual (This method should typically be overridden by the user to have any effect.)`
 .. |const| replace:: :abbr:`const (This method has no side effects. It doesn't modify any of the instance's member variables.)`

classes/class_gltfnode.rst

@@ -119,7 +119,7 @@ If this GLTF node is a camera, the index of the :ref:`GLTFCamera<class_GLTFCamer
 - |void| **set_children**\ (\ value\: :ref:`PackedInt32Array<class_PackedInt32Array>`\ )
 - :ref:`PackedInt32Array<class_PackedInt32Array>` **get_children**\ (\ )
 
-The indices of the children nodes in the :ref:`GLTFState<class_GLTFState>`. If this GLTF node has no children, this will be an empty array.
+The indices of the child nodes in the :ref:`GLTFState<class_GLTFState>`. If this GLTF node has no children, this will be an empty array.
 
 .. rst-class:: classref-item-separator
 

classes/class_gltfstate.rst

@@ -42,31 +42,33 @@ Properties
 .. table::
    :widths: auto
 
-   +----------------------------------------------------------------------------+----------------------------------------------------------------------------+------------------------+
-   | :ref:`String<class_String>`                                                | :ref:`base_path<class_GLTFState_property_base_path>`                       | ``""``                 |
-   +----------------------------------------------------------------------------+----------------------------------------------------------------------------+------------------------+
-   | :ref:`Array<class_Array>`\[:ref:`PackedByteArray<class_PackedByteArray>`\] | :ref:`buffers<class_GLTFState_property_buffers>`                           | ``[]``                 |
-   +----------------------------------------------------------------------------+----------------------------------------------------------------------------+------------------------+
-   | :ref:`String<class_String>`                                                | :ref:`copyright<class_GLTFState_property_copyright>`                       | ``""``                 |
-   +----------------------------------------------------------------------------+----------------------------------------------------------------------------+------------------------+
-   | :ref:`bool<class_bool>`                                                    | :ref:`create_animations<class_GLTFState_property_create_animations>`       | ``true``               |
-   +----------------------------------------------------------------------------+----------------------------------------------------------------------------+------------------------+
-   | :ref:`String<class_String>`                                                | :ref:`filename<class_GLTFState_property_filename>`                         | ``""``                 |
-   +----------------------------------------------------------------------------+----------------------------------------------------------------------------+------------------------+
-   | :ref:`PackedByteArray<class_PackedByteArray>`                              | :ref:`glb_data<class_GLTFState_property_glb_data>`                         | ``PackedByteArray()``  |
-   +----------------------------------------------------------------------------+----------------------------------------------------------------------------+------------------------+
-   | :ref:`Dictionary<class_Dictionary>`                                        | :ref:`json<class_GLTFState_property_json>`                                 | ``{}``                 |
-   +----------------------------------------------------------------------------+----------------------------------------------------------------------------+------------------------+
-   | :ref:`int<class_int>`                                                      | :ref:`major_version<class_GLTFState_property_major_version>`               | ``0``                  |
-   +----------------------------------------------------------------------------+----------------------------------------------------------------------------+------------------------+
-   | :ref:`int<class_int>`                                                      | :ref:`minor_version<class_GLTFState_property_minor_version>`               | ``0``                  |
-   +----------------------------------------------------------------------------+----------------------------------------------------------------------------+------------------------+
-   | :ref:`PackedInt32Array<class_PackedInt32Array>`                            | :ref:`root_nodes<class_GLTFState_property_root_nodes>`                     | ``PackedInt32Array()`` |
-   +----------------------------------------------------------------------------+----------------------------------------------------------------------------+------------------------+
-   | :ref:`String<class_String>`                                                | :ref:`scene_name<class_GLTFState_property_scene_name>`                     | ``""``                 |
-   +----------------------------------------------------------------------------+----------------------------------------------------------------------------+------------------------+
-   | :ref:`bool<class_bool>`                                                    | :ref:`use_named_skin_binds<class_GLTFState_property_use_named_skin_binds>` | ``false``              |
-   +----------------------------------------------------------------------------+----------------------------------------------------------------------------+------------------------+
+   +----------------------------------------------------------------------------+------------------------------------------------------------------------------------+------------------------+
+   | :ref:`String<class_String>`                                                | :ref:`base_path<class_GLTFState_property_base_path>`                               | ``""``                 |
+   +----------------------------------------------------------------------------+------------------------------------------------------------------------------------+------------------------+
+   | :ref:`Array<class_Array>`\[:ref:`PackedByteArray<class_PackedByteArray>`\] | :ref:`buffers<class_GLTFState_property_buffers>`                                   | ``[]``                 |
+   +----------------------------------------------------------------------------+------------------------------------------------------------------------------------+------------------------+
+   | :ref:`String<class_String>`                                                | :ref:`copyright<class_GLTFState_property_copyright>`                               | ``""``                 |
+   +----------------------------------------------------------------------------+------------------------------------------------------------------------------------+------------------------+
+   | :ref:`bool<class_bool>`                                                    | :ref:`create_animations<class_GLTFState_property_create_animations>`               | ``true``               |
+   +----------------------------------------------------------------------------+------------------------------------------------------------------------------------+------------------------+
+   | :ref:`String<class_String>`                                                | :ref:`filename<class_GLTFState_property_filename>`                                 | ``""``                 |
+   +----------------------------------------------------------------------------+------------------------------------------------------------------------------------+------------------------+
+   | :ref:`PackedByteArray<class_PackedByteArray>`                              | :ref:`glb_data<class_GLTFState_property_glb_data>`                                 | ``PackedByteArray()``  |
+   +----------------------------------------------------------------------------+------------------------------------------------------------------------------------+------------------------+
+   | :ref:`bool<class_bool>`                                                    | :ref:`import_as_skeleton_bones<class_GLTFState_property_import_as_skeleton_bones>` | ``false``              |
+   +----------------------------------------------------------------------------+------------------------------------------------------------------------------------+------------------------+
+   | :ref:`Dictionary<class_Dictionary>`                                        | :ref:`json<class_GLTFState_property_json>`                                         | ``{}``                 |
+   +----------------------------------------------------------------------------+------------------------------------------------------------------------------------+------------------------+
+   | :ref:`int<class_int>`                                                      | :ref:`major_version<class_GLTFState_property_major_version>`                       | ``0``                  |
+   +----------------------------------------------------------------------------+------------------------------------------------------------------------------------+------------------------+
+   | :ref:`int<class_int>`                                                      | :ref:`minor_version<class_GLTFState_property_minor_version>`                       | ``0``                  |
+   +----------------------------------------------------------------------------+------------------------------------------------------------------------------------+------------------------+
+   | :ref:`PackedInt32Array<class_PackedInt32Array>`                            | :ref:`root_nodes<class_GLTFState_property_root_nodes>`                             | ``PackedInt32Array()`` |
+   +----------------------------------------------------------------------------+------------------------------------------------------------------------------------+------------------------+
+   | :ref:`String<class_String>`                                                | :ref:`scene_name<class_GLTFState_property_scene_name>`                             | ``""``                 |
+   +----------------------------------------------------------------------------+------------------------------------------------------------------------------------+------------------------+
+   | :ref:`bool<class_bool>`                                                    | :ref:`use_named_skin_binds<class_GLTFState_property_use_named_skin_binds>`         | ``false``              |
+   +----------------------------------------------------------------------------+------------------------------------------------------------------------------------+------------------------+
 
 .. rst-class:: classref-reftable-group
 
@@ -308,9 +310,24 @@ The file name associated with this GLTF data. If it ends with ``.gltf``, this is
 - |void| **set_glb_data**\ (\ value\: :ref:`PackedByteArray<class_PackedByteArray>`\ )
 - :ref:`PackedByteArray<class_PackedByteArray>` **get_glb_data**\ (\ )
 
-.. container:: contribute
+The binary buffer attached to a .glb file.
 
-	There is currently no description for this property. Please help us by :ref:`contributing one <doc_updating_the_class_reference>`!
+.. rst-class:: classref-item-separator
+
+----
+
+.. _class_GLTFState_property_import_as_skeleton_bones:
+
+.. rst-class:: classref-property
+
+:ref:`bool<class_bool>` **import_as_skeleton_bones** = ``false``
+
+.. rst-class:: classref-property-setget
+
+- |void| **set_import_as_skeleton_bones**\ (\ value\: :ref:`bool<class_bool>`\ )
+- :ref:`bool<class_bool>` **get_import_as_skeleton_bones**\ (\ )
+
+True to force all GLTFNodes in the document to be bones of a single Skeleton3D godot node.
 
 .. rst-class:: classref-item-separator
 
@@ -327,9 +344,7 @@ The file name associated with this GLTF data. If it ends with ``.gltf``, this is
 - |void| **set_json**\ (\ value\: :ref:`Dictionary<class_Dictionary>`\ )
 - :ref:`Dictionary<class_Dictionary>` **get_json**\ (\ )
 
-.. container:: contribute
-
-	There is currently no description for this property. Please help us by :ref:`contributing one <doc_updating_the_class_reference>`!
+The original raw JSON document corresponding to this GLTFState.
 
 .. rst-class:: classref-item-separator
 

classes/class_gridcontainer.rst

@@ -95,7 +95,7 @@ Theme Property Descriptions
 
 :ref:`int<class_int>` **h_separation** = ``4``
 
-The horizontal separation of children nodes.
+The horizontal separation of child nodes.
 
 .. rst-class:: classref-item-separator
 
@@ -107,7 +107,7 @@ The horizontal separation of children nodes.
 
 :ref:`int<class_int>` **v_separation** = ``4``
 
-The vertical separation of children nodes.
+The vertical separation of child nodes.
 
 .. |virtual| replace:: :abbr:`virtual (This method should typically be overridden by the user to have any effect.)`
 .. |const| replace:: :abbr:`const (This method has no side effects. It doesn't modify any of the instance's member variables.)`

classes/class_input.rst

@@ -955,6 +955,8 @@ Feeds an :ref:`InputEvent<class_InputEvent>` to the game. Can be used to artific
 
 
 
+\ **Note:** Calling this function has no influence on the operating system. So for example sending an :ref:`InputEventMouseMotion<class_InputEventMouseMotion>` will not move the OS mouse cursor to the specified position (use :ref:`warp_mouse<class_Input_method_warp_mouse>` instead) and sending :kbd:`Alt/Cmd + Tab` as :ref:`InputEventKey<class_InputEventKey>` won't toggle between active windows.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -993,7 +995,7 @@ Sets the acceleration value of the accelerometer sensor. Can be used for debuggi
 
 Sets a custom mouse cursor image, which is only visible inside the game window. The hotspot can also be specified. Passing ``null`` to the image parameter resets to the system cursor. See :ref:`CursorShape<enum_Input_CursorShape>` for the list of shapes.
 
-\ ``image``'s size must be lower than or equal to 256×256. To avoid rendering issues, sizes lower than or equal to 128×128 are recommended.
+\ ``image`` can be either :ref:`Texture2D<class_Texture2D>` or :ref:`Image<class_Image>` and its size must be lower than or equal to 256×256. To avoid rendering issues, sizes lower than or equal to 128×128 are recommended.
 
 \ ``hotspot`` must be within ``image``'s size.
 

classes/class_itemlist.rst

@@ -184,7 +184,7 @@ Theme Properties
    +---------------------------------+----------------------------------------------------------------------------+--------------------------------+
    | :ref:`Color<class_Color>`       | :ref:`font_hovered_color<class_ItemList_theme_color_font_hovered_color>`   | ``Color(0.95, 0.95, 0.95, 1)`` |
    +---------------------------------+----------------------------------------------------------------------------+--------------------------------+
-   | :ref:`Color<class_Color>`       | :ref:`font_outline_color<class_ItemList_theme_color_font_outline_color>`   | ``Color(1, 1, 1, 1)``          |
+   | :ref:`Color<class_Color>`       | :ref:`font_outline_color<class_ItemList_theme_color_font_outline_color>`   | ``Color(0, 0, 0, 1)``          |
    +---------------------------------+----------------------------------------------------------------------------+--------------------------------+
    | :ref:`Color<class_Color>`       | :ref:`font_selected_color<class_ItemList_theme_color_font_selected_color>` | ``Color(1, 1, 1, 1)``          |
    +---------------------------------+----------------------------------------------------------------------------+--------------------------------+
@@ -198,7 +198,7 @@ Theme Properties
    +---------------------------------+----------------------------------------------------------------------------+--------------------------------+
    | :ref:`int<class_int>`           | :ref:`outline_size<class_ItemList_theme_constant_outline_size>`            | ``0``                          |
    +---------------------------------+----------------------------------------------------------------------------+--------------------------------+
-   | :ref:`int<class_int>`           | :ref:`v_separation<class_ItemList_theme_constant_v_separation>`            | ``2``                          |
+   | :ref:`int<class_int>`           | :ref:`v_separation<class_ItemList_theme_constant_v_separation>`            | ``4``                          |
    +---------------------------------+----------------------------------------------------------------------------+--------------------------------+
    | :ref:`Font<class_Font>`         | :ref:`font<class_ItemList_theme_font_font>`                                |                                |
    +---------------------------------+----------------------------------------------------------------------------+--------------------------------+
@@ -1198,7 +1198,7 @@ Text :ref:`Color<class_Color>` used when the item is hovered and not selected ye
 
 .. rst-class:: classref-themeproperty
 
-:ref:`Color<class_Color>` **font_outline_color** = ``Color(1, 1, 1, 1)``
+:ref:`Color<class_Color>` **font_outline_color** = ``Color(0, 0, 0, 1)``
 
 The tint of text outline of the item.
 
@@ -1284,7 +1284,7 @@ The size of the item text outline.
 
 .. rst-class:: classref-themeproperty
 
-:ref:`int<class_int>` **v_separation** = ``2``
+:ref:`int<class_int>` **v_separation** = ``4``
 
 The vertical spacing between items.
 

classes/class_label.rst

@@ -116,7 +116,7 @@ Theme Properties
    +---------------------------------+----------------------------------------------------------------------------+-----------------------+
    | :ref:`Color<class_Color>`       | :ref:`font_color<class_Label_theme_color_font_color>`                      | ``Color(1, 1, 1, 1)`` |
    +---------------------------------+----------------------------------------------------------------------------+-----------------------+
-   | :ref:`Color<class_Color>`       | :ref:`font_outline_color<class_Label_theme_color_font_outline_color>`      | ``Color(1, 1, 1, 1)`` |
+   | :ref:`Color<class_Color>`       | :ref:`font_outline_color<class_Label_theme_color_font_outline_color>`      | ``Color(0, 0, 0, 1)`` |
    +---------------------------------+----------------------------------------------------------------------------+-----------------------+
    | :ref:`Color<class_Color>`       | :ref:`font_shadow_color<class_Label_theme_color_font_shadow_color>`        | ``Color(0, 0, 0, 0)`` |
    +---------------------------------+----------------------------------------------------------------------------+-----------------------+
@@ -580,7 +580,7 @@ Default text :ref:`Color<class_Color>` of the **Label**.
 
 .. rst-class:: classref-themeproperty
 
-:ref:`Color<class_Color>` **font_outline_color** = ``Color(1, 1, 1, 1)``
+:ref:`Color<class_Color>` **font_outline_color** = ``Color(0, 0, 0, 1)``
 
 The color of text outline.
 

classes/class_lineedit.rst

@@ -197,7 +197,7 @@ Theme Properties
    +-----------------------------------+------------------------------------------------------------------------------------------+-------------------------------------+
    | :ref:`Color<class_Color>`         | :ref:`font_color<class_LineEdit_theme_color_font_color>`                                 | ``Color(0.875, 0.875, 0.875, 1)``   |
    +-----------------------------------+------------------------------------------------------------------------------------------+-------------------------------------+
-   | :ref:`Color<class_Color>`         | :ref:`font_outline_color<class_LineEdit_theme_color_font_outline_color>`                 | ``Color(1, 1, 1, 1)``               |
+   | :ref:`Color<class_Color>`         | :ref:`font_outline_color<class_LineEdit_theme_color_font_outline_color>`                 | ``Color(0, 0, 0, 1)``               |
    +-----------------------------------+------------------------------------------------------------------------------------------+-------------------------------------+
    | :ref:`Color<class_Color>`         | :ref:`font_placeholder_color<class_LineEdit_theme_color_font_placeholder_color>`         | ``Color(0.875, 0.875, 0.875, 0.6)`` |
    +-----------------------------------+------------------------------------------------------------------------------------------+-------------------------------------+
@@ -1470,7 +1470,7 @@ Default font color.
 
 .. rst-class:: classref-themeproperty
 
-:ref:`Color<class_Color>` **font_outline_color** = ``Color(1, 1, 1, 1)``
+:ref:`Color<class_Color>` **font_outline_color** = ``Color(0, 0, 0, 1)``
 
 The tint of text outline of the **LineEdit**.
 

classes/class_linkbutton.rst

@@ -70,7 +70,7 @@ Theme Properties
    +---------------------------------+----------------------------------------------------------------------------------------+-----------------------------------+
    | :ref:`Color<class_Color>`       | :ref:`font_hover_pressed_color<class_LinkButton_theme_color_font_hover_pressed_color>` | ``Color(0, 0, 0, 1)``             |
    +---------------------------------+----------------------------------------------------------------------------------------+-----------------------------------+
-   | :ref:`Color<class_Color>`       | :ref:`font_outline_color<class_LinkButton_theme_color_font_outline_color>`             | ``Color(1, 1, 1, 1)``             |
+   | :ref:`Color<class_Color>`       | :ref:`font_outline_color<class_LinkButton_theme_color_font_outline_color>`             | ``Color(0, 0, 0, 1)``             |
    +---------------------------------+----------------------------------------------------------------------------------------+-----------------------------------+
    | :ref:`Color<class_Color>`       | :ref:`font_pressed_color<class_LinkButton_theme_color_font_pressed_color>`             | ``Color(1, 1, 1, 1)``             |
    +---------------------------------+----------------------------------------------------------------------------------------+-----------------------------------+
@@ -340,7 +340,7 @@ Text :ref:`Color<class_Color>` used when the **LinkButton** is being hovered and
 
 .. rst-class:: classref-themeproperty
 
-:ref:`Color<class_Color>` **font_outline_color** = ``Color(1, 1, 1, 1)``
+:ref:`Color<class_Color>` **font_outline_color** = ``Color(0, 0, 0, 1)``
 
 The tint of text outline of the **LinkButton**.
 

classes/class_menubar.rst

@@ -96,7 +96,7 @@ Theme Properties
    +---------------------------------+-------------------------------------------------------------------------------------+-------------------------------------+
    | :ref:`Color<class_Color>`       | :ref:`font_hover_pressed_color<class_MenuBar_theme_color_font_hover_pressed_color>` | ``Color(1, 1, 1, 1)``               |
    +---------------------------------+-------------------------------------------------------------------------------------+-------------------------------------+
-   | :ref:`Color<class_Color>`       | :ref:`font_outline_color<class_MenuBar_theme_color_font_outline_color>`             | ``Color(1, 1, 1, 1)``               |
+   | :ref:`Color<class_Color>`       | :ref:`font_outline_color<class_MenuBar_theme_color_font_outline_color>`             | ``Color(0, 0, 0, 1)``               |
    +---------------------------------+-------------------------------------------------------------------------------------+-------------------------------------+
    | :ref:`Color<class_Color>`       | :ref:`font_pressed_color<class_MenuBar_theme_color_font_pressed_color>`             | ``Color(1, 1, 1, 1)``               |
    +---------------------------------+-------------------------------------------------------------------------------------+-------------------------------------+
@@ -458,7 +458,7 @@ Text :ref:`Color<class_Color>` used when the menu item is being hovered and pres
 
 .. rst-class:: classref-themeproperty
 
-:ref:`Color<class_Color>` **font_outline_color** = ``Color(1, 1, 1, 1)``
+:ref:`Color<class_Color>` **font_outline_color** = ``Color(0, 0, 0, 1)``
 
 The tint of text outline of the menu item.
 

classes/class_mesh.rst

@@ -229,7 +229,7 @@ enum **ArrayType**:
 
 :ref:`ArrayType<enum_Mesh_ArrayType>` **ARRAY_CUSTOM0** = ``6``
 
-Contains custom color channel 0. :ref:`PackedByteArray<class_PackedByteArray>` if ``(format >> Mesh.ARRAY_FORMAT_CUSTOM0_SHIFT) & Mesh.ARRAY_FORMAT_CUSTOM_MASK`` is :ref:`ARRAY_CUSTOM_RGBA8_UNORM<class_Mesh_constant_ARRAY_CUSTOM_RGBA8_UNORM>`, :ref:`ARRAY_CUSTOM_RGBA8_UNORM<class_Mesh_constant_ARRAY_CUSTOM_RGBA8_UNORM>`, :ref:`ARRAY_CUSTOM_RG_HALF<class_Mesh_constant_ARRAY_CUSTOM_RG_HALF>` or :ref:`ARRAY_CUSTOM_RGBA_HALF<class_Mesh_constant_ARRAY_CUSTOM_RGBA_HALF>`. :ref:`PackedFloat32Array<class_PackedFloat32Array>` otherwise.
+Contains custom color channel 0. :ref:`PackedByteArray<class_PackedByteArray>` if ``(format >> Mesh.ARRAY_FORMAT_CUSTOM0_SHIFT) & Mesh.ARRAY_FORMAT_CUSTOM_MASK`` is :ref:`ARRAY_CUSTOM_RGBA8_UNORM<class_Mesh_constant_ARRAY_CUSTOM_RGBA8_UNORM>`, :ref:`ARRAY_CUSTOM_RGBA8_SNORM<class_Mesh_constant_ARRAY_CUSTOM_RGBA8_SNORM>`, :ref:`ARRAY_CUSTOM_RG_HALF<class_Mesh_constant_ARRAY_CUSTOM_RG_HALF>`, or :ref:`ARRAY_CUSTOM_RGBA_HALF<class_Mesh_constant_ARRAY_CUSTOM_RGBA_HALF>`. :ref:`PackedFloat32Array<class_PackedFloat32Array>` otherwise.
 
 .. _class_Mesh_constant_ARRAY_CUSTOM1:
 
@@ -237,7 +237,7 @@ Contains custom color channel 0. :ref:`PackedByteArray<class_PackedByteArray>` i
 
 :ref:`ArrayType<enum_Mesh_ArrayType>` **ARRAY_CUSTOM1** = ``7``
 
-Contains custom color channel 1. :ref:`PackedByteArray<class_PackedByteArray>` if ``(format >> Mesh.ARRAY_FORMAT_CUSTOM1_SHIFT) & Mesh.ARRAY_FORMAT_CUSTOM_MASK`` is :ref:`ARRAY_CUSTOM_RGBA8_UNORM<class_Mesh_constant_ARRAY_CUSTOM_RGBA8_UNORM>`, :ref:`ARRAY_CUSTOM_RGBA8_UNORM<class_Mesh_constant_ARRAY_CUSTOM_RGBA8_UNORM>`, :ref:`ARRAY_CUSTOM_RG_HALF<class_Mesh_constant_ARRAY_CUSTOM_RG_HALF>` or :ref:`ARRAY_CUSTOM_RGBA_HALF<class_Mesh_constant_ARRAY_CUSTOM_RGBA_HALF>`. :ref:`PackedFloat32Array<class_PackedFloat32Array>` otherwise.
+Contains custom color channel 1. :ref:`PackedByteArray<class_PackedByteArray>` if ``(format >> Mesh.ARRAY_FORMAT_CUSTOM1_SHIFT) & Mesh.ARRAY_FORMAT_CUSTOM_MASK`` is :ref:`ARRAY_CUSTOM_RGBA8_UNORM<class_Mesh_constant_ARRAY_CUSTOM_RGBA8_UNORM>`, :ref:`ARRAY_CUSTOM_RGBA8_SNORM<class_Mesh_constant_ARRAY_CUSTOM_RGBA8_SNORM>`, :ref:`ARRAY_CUSTOM_RG_HALF<class_Mesh_constant_ARRAY_CUSTOM_RG_HALF>`, or :ref:`ARRAY_CUSTOM_RGBA_HALF<class_Mesh_constant_ARRAY_CUSTOM_RGBA_HALF>`. :ref:`PackedFloat32Array<class_PackedFloat32Array>` otherwise.
 
 .. _class_Mesh_constant_ARRAY_CUSTOM2:
 
@@ -245,7 +245,7 @@ Contains custom color channel 1. :ref:`PackedByteArray<class_PackedByteArray>` i
 
 :ref:`ArrayType<enum_Mesh_ArrayType>` **ARRAY_CUSTOM2** = ``8``
 
-Contains custom color channel 2. :ref:`PackedByteArray<class_PackedByteArray>` if ``(format >> Mesh.ARRAY_FORMAT_CUSTOM2_SHIFT) & Mesh.ARRAY_FORMAT_CUSTOM_MASK`` is :ref:`ARRAY_CUSTOM_RGBA8_UNORM<class_Mesh_constant_ARRAY_CUSTOM_RGBA8_UNORM>`, :ref:`ARRAY_CUSTOM_RGBA8_UNORM<class_Mesh_constant_ARRAY_CUSTOM_RGBA8_UNORM>`, :ref:`ARRAY_CUSTOM_RG_HALF<class_Mesh_constant_ARRAY_CUSTOM_RG_HALF>` or :ref:`ARRAY_CUSTOM_RGBA_HALF<class_Mesh_constant_ARRAY_CUSTOM_RGBA_HALF>`. :ref:`PackedFloat32Array<class_PackedFloat32Array>` otherwise.
+Contains custom color channel 2. :ref:`PackedByteArray<class_PackedByteArray>` if ``(format >> Mesh.ARRAY_FORMAT_CUSTOM2_SHIFT) & Mesh.ARRAY_FORMAT_CUSTOM_MASK`` is :ref:`ARRAY_CUSTOM_RGBA8_UNORM<class_Mesh_constant_ARRAY_CUSTOM_RGBA8_UNORM>`, :ref:`ARRAY_CUSTOM_RGBA8_SNORM<class_Mesh_constant_ARRAY_CUSTOM_RGBA8_SNORM>`, :ref:`ARRAY_CUSTOM_RG_HALF<class_Mesh_constant_ARRAY_CUSTOM_RG_HALF>`, or :ref:`ARRAY_CUSTOM_RGBA_HALF<class_Mesh_constant_ARRAY_CUSTOM_RGBA_HALF>`. :ref:`PackedFloat32Array<class_PackedFloat32Array>` otherwise.
 
 .. _class_Mesh_constant_ARRAY_CUSTOM3:
 
@@ -253,7 +253,7 @@ Contains custom color channel 2. :ref:`PackedByteArray<class_PackedByteArray>` i
 
 :ref:`ArrayType<enum_Mesh_ArrayType>` **ARRAY_CUSTOM3** = ``9``
 
-Contains custom color channel 3. :ref:`PackedByteArray<class_PackedByteArray>` if ``(format >> Mesh.ARRAY_FORMAT_CUSTOM3_SHIFT) & Mesh.ARRAY_FORMAT_CUSTOM_MASK`` is :ref:`ARRAY_CUSTOM_RGBA8_UNORM<class_Mesh_constant_ARRAY_CUSTOM_RGBA8_UNORM>`, :ref:`ARRAY_CUSTOM_RGBA8_UNORM<class_Mesh_constant_ARRAY_CUSTOM_RGBA8_UNORM>`, :ref:`ARRAY_CUSTOM_RG_HALF<class_Mesh_constant_ARRAY_CUSTOM_RG_HALF>` or :ref:`ARRAY_CUSTOM_RGBA_HALF<class_Mesh_constant_ARRAY_CUSTOM_RGBA_HALF>`. :ref:`PackedFloat32Array<class_PackedFloat32Array>` otherwise.
+Contains custom color channel 3. :ref:`PackedByteArray<class_PackedByteArray>` if ``(format >> Mesh.ARRAY_FORMAT_CUSTOM3_SHIFT) & Mesh.ARRAY_FORMAT_CUSTOM_MASK`` is :ref:`ARRAY_CUSTOM_RGBA8_UNORM<class_Mesh_constant_ARRAY_CUSTOM_RGBA8_UNORM>`, :ref:`ARRAY_CUSTOM_RGBA8_SNORM<class_Mesh_constant_ARRAY_CUSTOM_RGBA8_SNORM>`, :ref:`ARRAY_CUSTOM_RG_HALF<class_Mesh_constant_ARRAY_CUSTOM_RG_HALF>`, or :ref:`ARRAY_CUSTOM_RGBA_HALF<class_Mesh_constant_ARRAY_CUSTOM_RGBA_HALF>`. :ref:`PackedFloat32Array<class_PackedFloat32Array>` otherwise.
 
 .. _class_Mesh_constant_ARRAY_BONES:
 

classes/class_node.rst

@@ -496,7 +496,7 @@ enum **ProcessThreadGroup**:
 
 :ref:`ProcessThreadGroup<enum_Node_ProcessThreadGroup>` **PROCESS_THREAD_GROUP_INHERIT** = ``0``
 
-If the :ref:`process_thread_group<class_Node_property_process_thread_group>` property is sent to this, the node will belong to any parent (or grandparent) node that has a thread group mode that is not inherit. See :ref:`process_thread_group<class_Node_property_process_thread_group>` for more information.
+Process this node based on the thread group mode of the first parent (or grandparent) node that has a thread group mode that is not inherit. See :ref:`process_thread_group<class_Node_property_process_thread_group>` for more information.
 
 .. _class_Node_constant_PROCESS_THREAD_GROUP_MAIN_THREAD:
 
@@ -504,7 +504,7 @@ If the :ref:`process_thread_group<class_Node_property_process_thread_group>` pro
 
 :ref:`ProcessThreadGroup<enum_Node_ProcessThreadGroup>` **PROCESS_THREAD_GROUP_MAIN_THREAD** = ``1``
 
-Process this node (and children nodes set to inherit) on the main thread. See :ref:`process_thread_group<class_Node_property_process_thread_group>` for more information.
+Process this node (and child nodes set to inherit) on the main thread. See :ref:`process_thread_group<class_Node_property_process_thread_group>` for more information.
 
 .. _class_Node_constant_PROCESS_THREAD_GROUP_SUB_THREAD:
 
@@ -512,7 +512,7 @@ Process this node (and children nodes set to inherit) on the main thread. See :r
 
 :ref:`ProcessThreadGroup<enum_Node_ProcessThreadGroup>` **PROCESS_THREAD_GROUP_SUB_THREAD** = ``2``
 
-Process this node (and children nodes set to inherit) on a sub-thread. See :ref:`process_thread_group<class_Node_property_process_thread_group>` for more information.
+Process this node (and child nodes set to inherit) on a sub-thread. See :ref:`process_thread_group<class_Node_property_process_thread_group>` for more information.
 
 .. rst-class:: classref-item-separator
 
@@ -614,7 +614,7 @@ The node will not be internal.
 
 :ref:`InternalMode<enum_Node_InternalMode>` **INTERNAL_MODE_FRONT** = ``1``
 
-The node will be placed at the beginning of the parent's children list, before any non-internal sibling.
+The node will be placed at the beginning of the parent's children, before any non-internal sibling.
 
 .. _class_Node_constant_INTERNAL_MODE_BACK:
 
@@ -622,7 +622,7 @@ The node will be placed at the beginning of the parent's children list, before a
 
 :ref:`InternalMode<enum_Node_InternalMode>` **INTERNAL_MODE_BACK** = ``2``
 
-The node will be placed at the end of the parent's children list, after any non-internal sibling.
+The node will be placed at the end of the parent's children, after any non-internal sibling.
 
 .. rst-class:: classref-item-separator
 
@@ -1222,7 +1222,7 @@ By default, the thread group is :ref:`PROCESS_THREAD_GROUP_INHERIT<class_Node_co
 
 During processing in a sub-thread, accessing most functions in nodes outside the thread group is forbidden (and it will result in an error in debug mode). Use :ref:`Object.call_deferred<class_Object_method_call_deferred>`, :ref:`call_thread_safe<class_Node_method_call_thread_safe>`, :ref:`call_deferred_thread_group<class_Node_method_call_deferred_thread_group>` and the likes in order to communicate from the thread groups to the main thread (or to other thread groups).
 
-To better understand process thread groups, the idea is that any node set to any other value than :ref:`PROCESS_THREAD_GROUP_INHERIT<class_Node_constant_PROCESS_THREAD_GROUP_INHERIT>` will include any children (and grandchildren) nodes set to inherit into its process thread group. this means that the processing of all the nodes in the group will happen together, at the same time as the node including them.
+To better understand process thread groups, the idea is that any node set to any other value than :ref:`PROCESS_THREAD_GROUP_INHERIT<class_Node_constant_PROCESS_THREAD_GROUP_INHERIT>` will include any child (and grandchild) nodes set to inherit into its process thread group. This means that the processing of all the nodes in the group will happen together, at the same time as the node including them.
 
 .. rst-class:: classref-item-separator
 

classes/class_node3d.rst

@@ -12,7 +12,7 @@ Node3D
 
 **Inherits:** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-**Inherited By:** :ref:`AudioListener3D<class_AudioListener3D>`, :ref:`AudioStreamPlayer3D<class_AudioStreamPlayer3D>`, :ref:`BoneAttachment3D<class_BoneAttachment3D>`, :ref:`Camera3D<class_Camera3D>`, :ref:`CollisionObject3D<class_CollisionObject3D>`, :ref:`CollisionPolygon3D<class_CollisionPolygon3D>`, :ref:`CollisionShape3D<class_CollisionShape3D>`, :ref:`GridMap<class_GridMap>`, :ref:`ImporterMeshInstance3D<class_ImporterMeshInstance3D>`, :ref:`Joint3D<class_Joint3D>`, :ref:`LightmapProbe<class_LightmapProbe>`, :ref:`Marker3D<class_Marker3D>`, :ref:`NavigationLink3D<class_NavigationLink3D>`, :ref:`NavigationObstacle3D<class_NavigationObstacle3D>`, :ref:`NavigationRegion3D<class_NavigationRegion3D>`, :ref:`OccluderInstance3D<class_OccluderInstance3D>`, :ref:`OpenXRHand<class_OpenXRHand>`, :ref:`Path3D<class_Path3D>`, :ref:`PathFollow3D<class_PathFollow3D>`, :ref:`RayCast3D<class_RayCast3D>`, :ref:`RemoteTransform3D<class_RemoteTransform3D>`, :ref:`ShapeCast3D<class_ShapeCast3D>`, :ref:`Skeleton3D<class_Skeleton3D>`, :ref:`SpringArm3D<class_SpringArm3D>`, :ref:`VehicleWheel3D<class_VehicleWheel3D>`, :ref:`VisualInstance3D<class_VisualInstance3D>`, :ref:`XRFaceModifier3D<class_XRFaceModifier3D>`, :ref:`XRHandModifier3D<class_XRHandModifier3D>`, :ref:`XRNode3D<class_XRNode3D>`, :ref:`XROrigin3D<class_XROrigin3D>`
+**Inherited By:** :ref:`AudioListener3D<class_AudioListener3D>`, :ref:`AudioStreamPlayer3D<class_AudioStreamPlayer3D>`, :ref:`BoneAttachment3D<class_BoneAttachment3D>`, :ref:`Camera3D<class_Camera3D>`, :ref:`CollisionObject3D<class_CollisionObject3D>`, :ref:`CollisionPolygon3D<class_CollisionPolygon3D>`, :ref:`CollisionShape3D<class_CollisionShape3D>`, :ref:`GridMap<class_GridMap>`, :ref:`ImporterMeshInstance3D<class_ImporterMeshInstance3D>`, :ref:`Joint3D<class_Joint3D>`, :ref:`LightmapProbe<class_LightmapProbe>`, :ref:`Marker3D<class_Marker3D>`, :ref:`NavigationLink3D<class_NavigationLink3D>`, :ref:`NavigationObstacle3D<class_NavigationObstacle3D>`, :ref:`NavigationRegion3D<class_NavigationRegion3D>`, :ref:`OccluderInstance3D<class_OccluderInstance3D>`, :ref:`OpenXRHand<class_OpenXRHand>`, :ref:`Path3D<class_Path3D>`, :ref:`PathFollow3D<class_PathFollow3D>`, :ref:`RayCast3D<class_RayCast3D>`, :ref:`RemoteTransform3D<class_RemoteTransform3D>`, :ref:`ShapeCast3D<class_ShapeCast3D>`, :ref:`Skeleton3D<class_Skeleton3D>`, :ref:`SpringArm3D<class_SpringArm3D>`, :ref:`VehicleWheel3D<class_VehicleWheel3D>`, :ref:`VisualInstance3D<class_VisualInstance3D>`, :ref:`XRBodyModifier3D<class_XRBodyModifier3D>`, :ref:`XRFaceModifier3D<class_XRFaceModifier3D>`, :ref:`XRHandModifier3D<class_XRHandModifier3D>`, :ref:`XRNode3D<class_XRNode3D>`, :ref:`XROrigin3D<class_XROrigin3D>`
 
 Most basic 3D game object, parent of all 3D-related nodes.
 
@@ -654,7 +654,9 @@ Returns all the gizmos attached to this **Node3D**.
 
 :ref:`Node3D<class_Node3D>` **get_parent_node_3d**\ (\ ) |const|
 
-Returns the parent **Node3D**, or an empty :ref:`Object<class_Object>` if no parent exists or parent is not of type **Node3D**.
+Returns the parent **Node3D**, or ``null`` if no parent exists, the parent is not of type **Node3D**, or :ref:`top_level<class_Node3D_property_top_level>` is ``true``.
+
+\ **Note:** Calling this method is not equivalent to ``get_parent() as Node3D``, which does not take :ref:`top_level<class_Node3D_property_top_level>` into account.
 
 .. rst-class:: classref-item-separator
 

classes/class_nodepath.rst

@@ -92,27 +92,29 @@ Methods
 .. table::
    :widths: auto
 
-   +-------------------------------------+--------------------------------------------------------------------------------------------------+
-   | :ref:`NodePath<class_NodePath>`     | :ref:`get_as_property_path<class_NodePath_method_get_as_property_path>`\ (\ ) |const|            |
-   +-------------------------------------+--------------------------------------------------------------------------------------------------+
-   | :ref:`StringName<class_StringName>` | :ref:`get_concatenated_names<class_NodePath_method_get_concatenated_names>`\ (\ ) |const|        |
-   +-------------------------------------+--------------------------------------------------------------------------------------------------+
-   | :ref:`StringName<class_StringName>` | :ref:`get_concatenated_subnames<class_NodePath_method_get_concatenated_subnames>`\ (\ ) |const|  |
-   +-------------------------------------+--------------------------------------------------------------------------------------------------+
-   | :ref:`StringName<class_StringName>` | :ref:`get_name<class_NodePath_method_get_name>`\ (\ idx\: :ref:`int<class_int>`\ ) |const|       |
-   +-------------------------------------+--------------------------------------------------------------------------------------------------+
-   | :ref:`int<class_int>`               | :ref:`get_name_count<class_NodePath_method_get_name_count>`\ (\ ) |const|                        |
-   +-------------------------------------+--------------------------------------------------------------------------------------------------+
-   | :ref:`StringName<class_StringName>` | :ref:`get_subname<class_NodePath_method_get_subname>`\ (\ idx\: :ref:`int<class_int>`\ ) |const| |
-   +-------------------------------------+--------------------------------------------------------------------------------------------------+
-   | :ref:`int<class_int>`               | :ref:`get_subname_count<class_NodePath_method_get_subname_count>`\ (\ ) |const|                  |
-   +-------------------------------------+--------------------------------------------------------------------------------------------------+
-   | :ref:`int<class_int>`               | :ref:`hash<class_NodePath_method_hash>`\ (\ ) |const|                                            |
-   +-------------------------------------+--------------------------------------------------------------------------------------------------+
-   | :ref:`bool<class_bool>`             | :ref:`is_absolute<class_NodePath_method_is_absolute>`\ (\ ) |const|                              |
-   +-------------------------------------+--------------------------------------------------------------------------------------------------+
-   | :ref:`bool<class_bool>`             | :ref:`is_empty<class_NodePath_method_is_empty>`\ (\ ) |const|                                    |
-   +-------------------------------------+--------------------------------------------------------------------------------------------------+
+   +-------------------------------------+----------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`NodePath<class_NodePath>`     | :ref:`get_as_property_path<class_NodePath_method_get_as_property_path>`\ (\ ) |const|                                            |
+   +-------------------------------------+----------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`StringName<class_StringName>` | :ref:`get_concatenated_names<class_NodePath_method_get_concatenated_names>`\ (\ ) |const|                                        |
+   +-------------------------------------+----------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`StringName<class_StringName>` | :ref:`get_concatenated_subnames<class_NodePath_method_get_concatenated_subnames>`\ (\ ) |const|                                  |
+   +-------------------------------------+----------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`StringName<class_StringName>` | :ref:`get_name<class_NodePath_method_get_name>`\ (\ idx\: :ref:`int<class_int>`\ ) |const|                                       |
+   +-------------------------------------+----------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`int<class_int>`               | :ref:`get_name_count<class_NodePath_method_get_name_count>`\ (\ ) |const|                                                        |
+   +-------------------------------------+----------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`StringName<class_StringName>` | :ref:`get_subname<class_NodePath_method_get_subname>`\ (\ idx\: :ref:`int<class_int>`\ ) |const|                                 |
+   +-------------------------------------+----------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`int<class_int>`               | :ref:`get_subname_count<class_NodePath_method_get_subname_count>`\ (\ ) |const|                                                  |
+   +-------------------------------------+----------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`int<class_int>`               | :ref:`hash<class_NodePath_method_hash>`\ (\ ) |const|                                                                            |
+   +-------------------------------------+----------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`bool<class_bool>`             | :ref:`is_absolute<class_NodePath_method_is_absolute>`\ (\ ) |const|                                                              |
+   +-------------------------------------+----------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`bool<class_bool>`             | :ref:`is_empty<class_NodePath_method_is_empty>`\ (\ ) |const|                                                                    |
+   +-------------------------------------+----------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`NodePath<class_NodePath>`     | :ref:`slice<class_NodePath_method_slice>`\ (\ begin\: :ref:`int<class_int>`, end\: :ref:`int<class_int>` = 2147483647\ ) |const| |
+   +-------------------------------------+----------------------------------------------------------------------------------------------------------------------------------+
 
 .. rst-class:: classref-reftable-group
 
@@ -395,6 +397,22 @@ Returns ``true`` if the node path is absolute. Unlike a relative path, an absolu
 
 Returns ``true`` if the node path has been constructed from an empty :ref:`String<class_String>` (``""``).
 
+.. rst-class:: classref-item-separator
+
+----
+
+.. _class_NodePath_method_slice:
+
+.. rst-class:: classref-method
+
+:ref:`NodePath<class_NodePath>` **slice**\ (\ begin\: :ref:`int<class_int>`, end\: :ref:`int<class_int>` = 2147483647\ ) |const|
+
+Returns the slice of the **NodePath**, from ``begin`` (inclusive) to ``end`` (exclusive), as a new **NodePath**.
+
+The absolute value of ``begin`` and ``end`` will be clamped to the sum of :ref:`get_name_count<class_NodePath_method_get_name_count>` and :ref:`get_subname_count<class_NodePath_method_get_subname_count>`, so the default value for ``end`` makes it slice to the end of the **NodePath** by default (i.e. ``path.slice(1)`` is a shorthand for ``path.slice(1, path.get_name_count() + path.get_subname_count())``).
+
+If either ``begin`` or ``end`` are negative, they will be relative to the end of the **NodePath** (i.e. ``path.slice(0, -2)`` is a shorthand for ``path.slice(0, path.get_name_count() + path.get_subname_count() - 2)``).
+
 .. rst-class:: classref-section-separator
 
 ----

classes/class_object.rst

@@ -782,7 +782,7 @@ Calls the ``method`` on the object and returns the result. This method supports
 
 Calls the ``method`` on the object during idle time. Always returns null, **not** the method's result.
 
-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.
+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. This means you should not call a method deferred from itself (or from a method called by it), as this causes infinite recursion the same way as if you had called the method directly.
 
 This method supports a variable number of arguments, so parameters can be passed as a comma separated list.
 

classes/class_packedscene.rst

@@ -208,7 +208,7 @@ Property Descriptions
 
 A dictionary representation of the scene contents.
 
-Available keys include "rnames" and "variants" for resources, "node_count", "nodes", "node_paths" for nodes, "editable_instances" for base scene children overrides, "conn_count" and "conns" for signal connections, and "version" for the format style of the PackedScene.
+Available keys include "rnames" and "variants" for resources, "node_count", "nodes", "node_paths" for nodes, "editable_instances" for paths to overridden nodes, "conn_count" and "conns" for signal connections, and "version" for the format style of the PackedScene.
 
 .. rst-class:: classref-section-separator
 

classes/class_physicalbone3d.rst

@@ -293,6 +293,8 @@ Sets the body's transform.
 
 The body's bounciness. Values range from ``0`` (no bounce) to ``1`` (full bounciness).
 
+\ **Note:** Even with :ref:`bounce<class_PhysicalBone3D_property_bounce>` set to ``1.0``, some energy will be lost over time due to linear and angular damping. To have a **PhysicalBone3D** that preserves all its energy over time, set :ref:`bounce<class_PhysicalBone3D_property_bounce>` to ``1.0``, :ref:`linear_damp_mode<class_PhysicalBone3D_property_linear_damp_mode>` to :ref:`DAMP_MODE_REPLACE<class_PhysicalBone3D_constant_DAMP_MODE_REPLACE>`, :ref:`linear_damp<class_PhysicalBone3D_property_linear_damp>` to ``0.0``, :ref:`angular_damp_mode<class_PhysicalBone3D_property_angular_damp_mode>` to :ref:`DAMP_MODE_REPLACE<class_PhysicalBone3D_constant_DAMP_MODE_REPLACE>`, and :ref:`angular_damp<class_PhysicalBone3D_property_angular_damp>` to ``0.0``.
+
 .. rst-class:: classref-item-separator
 
 ----

classes/class_physicsmaterial.rst

@@ -78,6 +78,8 @@ If ``true``, subtracts the bounciness from the colliding object's bounciness ins
 
 The body's bounciness. Values range from ``0`` (no bounce) to ``1`` (full bounciness).
 
+\ **Note:** Even with :ref:`bounce<class_PhysicsMaterial_property_bounce>` set to ``1.0``, some energy will be lost over time due to linear and angular damping. To have a :ref:`PhysicsBody3D<class_PhysicsBody3D>` that preserves all its energy over time, set :ref:`bounce<class_PhysicsMaterial_property_bounce>` to ``1.0``, the body's linear damp mode to **Replace** (if applicable), its linear damp to ``0.0``, its angular damp mode to **Replace** (if applicable), and its angular damp to ``0.0``.
+
 .. rst-class:: classref-item-separator
 
 ----

classes/class_popupmenu.rst

@@ -220,11 +220,11 @@ Theme Properties
    +-----------------------------------+-----------------------------------------------------------------------------------------------+-----------------------------------+
    | :ref:`Color<class_Color>`         | :ref:`font_hover_color<class_PopupMenu_theme_color_font_hover_color>`                         | ``Color(0.875, 0.875, 0.875, 1)`` |
    +-----------------------------------+-----------------------------------------------------------------------------------------------+-----------------------------------+
-   | :ref:`Color<class_Color>`         | :ref:`font_outline_color<class_PopupMenu_theme_color_font_outline_color>`                     | ``Color(1, 1, 1, 1)``             |
+   | :ref:`Color<class_Color>`         | :ref:`font_outline_color<class_PopupMenu_theme_color_font_outline_color>`                     | ``Color(0, 0, 0, 1)``             |
    +-----------------------------------+-----------------------------------------------------------------------------------------------+-----------------------------------+
    | :ref:`Color<class_Color>`         | :ref:`font_separator_color<class_PopupMenu_theme_color_font_separator_color>`                 | ``Color(0.875, 0.875, 0.875, 1)`` |
    +-----------------------------------+-----------------------------------------------------------------------------------------------+-----------------------------------+
-   | :ref:`Color<class_Color>`         | :ref:`font_separator_outline_color<class_PopupMenu_theme_color_font_separator_outline_color>` | ``Color(1, 1, 1, 1)``             |
+   | :ref:`Color<class_Color>`         | :ref:`font_separator_outline_color<class_PopupMenu_theme_color_font_separator_outline_color>` | ``Color(0, 0, 0, 1)``             |
    +-----------------------------------+-----------------------------------------------------------------------------------------------+-----------------------------------+
    | :ref:`int<class_int>`             | :ref:`h_separation<class_PopupMenu_theme_constant_h_separation>`                              | ``4``                             |
    +-----------------------------------+-----------------------------------------------------------------------------------------------+-----------------------------------+
@@ -1458,7 +1458,7 @@ The default text :ref:`Color<class_Color>` for menu items' names.
 
 .. rst-class:: classref-themeproperty
 
-:ref:`Color<class_Color>` **font_outline_color** = ``Color(1, 1, 1, 1)``
+:ref:`Color<class_Color>` **font_outline_color** = ``Color(0, 0, 0, 1)``
 
 The tint of text outline of the menu item.
 
@@ -1482,7 +1482,7 @@ The tint of text outline of the menu item.
 
 .. rst-class:: classref-themeproperty
 
-:ref:`Color<class_Color>` **font_separator_outline_color** = ``Color(1, 1, 1, 1)``
+:ref:`Color<class_Color>` **font_separator_outline_color** = ``Color(0, 0, 0, 1)``
 
 The tint of text outline of the labeled separator.
 

classes/class_progressbar.rst

@@ -50,7 +50,7 @@ Theme Properties
    +---------------------------------+-----------------------------------------------------------------------------+--------------------------------+
    | :ref:`Color<class_Color>`       | :ref:`font_color<class_ProgressBar_theme_color_font_color>`                 | ``Color(0.95, 0.95, 0.95, 1)`` |
    +---------------------------------+-----------------------------------------------------------------------------+--------------------------------+
-   | :ref:`Color<class_Color>`       | :ref:`font_outline_color<class_ProgressBar_theme_color_font_outline_color>` | ``Color(1, 1, 1, 1)``          |
+   | :ref:`Color<class_Color>`       | :ref:`font_outline_color<class_ProgressBar_theme_color_font_outline_color>` | ``Color(0, 0, 0, 1)``          |
    +---------------------------------+-----------------------------------------------------------------------------+--------------------------------+
    | :ref:`int<class_int>`           | :ref:`outline_size<class_ProgressBar_theme_constant_outline_size>`          | ``0``                          |
    +---------------------------------+-----------------------------------------------------------------------------+--------------------------------+
@@ -208,7 +208,7 @@ The color of the text.
 
 .. rst-class:: classref-themeproperty
 
-:ref:`Color<class_Color>` **font_outline_color** = ``Color(1, 1, 1, 1)``
+:ref:`Color<class_Color>` **font_outline_color** = ``Color(0, 0, 0, 1)``
 
 The tint of text outline of the **ProgressBar**.
 

classes/class_projectsettings.rst

@@ -9384,12 +9384,14 @@ The size of the 2D shadow atlas in pixels. Higher values result in more precise
 
 :ref:`bool<class_bool>` **rendering/2d/snap/snap_2d_transforms_to_pixel** = ``false``
 
-If ``true``, :ref:`CanvasItem<class_CanvasItem>` nodes will internally snap to full pixels. Useful for low-resolution pixel art games. Their position can still be sub-pixel, but the decimals will not have effect. This can lead to a crisper appearance at the cost of less smooth movement, especially when :ref:`Camera2D<class_Camera2D>` smoothing is enabled.
+If ``true``, :ref:`CanvasItem<class_CanvasItem>` nodes will internally snap to full pixels. Useful for low-resolution pixel art games. Their position can still be sub-pixel, but the decimals will not have effect as the position is rounded. This can lead to a crisper appearance at the cost of less smooth movement, especially when :ref:`Camera2D<class_Camera2D>` smoothing is enabled.
 
 \ **Note:** This property is only read when the project starts. To toggle 2D transform snapping at runtime, use :ref:`RenderingServer.viewport_set_snap_2d_transforms_to_pixel<class_RenderingServer_method_viewport_set_snap_2d_transforms_to_pixel>` on the root :ref:`Viewport<class_Viewport>` instead.
 
 \ **Note:** :ref:`Control<class_Control>` nodes are snapped to the nearest pixel by default. This is controlled by :ref:`gui/common/snap_controls_to_pixels<class_ProjectSettings_property_gui/common/snap_controls_to_pixels>`.
 
+\ **Note:** It is not recommended to use this setting together with :ref:`rendering/2d/snap/snap_2d_vertices_to_pixel<class_ProjectSettings_property_rendering/2d/snap/snap_2d_vertices_to_pixel>`, as movement may appear even less smooth. Prefer only enabling this setting instead.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -9406,6 +9408,8 @@ If ``true``, vertices of :ref:`CanvasItem<class_CanvasItem>` nodes will snap to
 
 \ **Note:** :ref:`Control<class_Control>` nodes are snapped to the nearest pixel by default. This is controlled by :ref:`gui/common/snap_controls_to_pixels<class_ProjectSettings_property_gui/common/snap_controls_to_pixels>`.
 
+\ **Note:** It is not recommended to use this setting together with :ref:`rendering/2d/snap/snap_2d_transforms_to_pixel<class_ProjectSettings_property_rendering/2d/snap/snap_2d_transforms_to_pixel>`, as movement may appear even less smooth. Prefer only enabling that setting instead.
+
 .. rst-class:: classref-item-separator
 
 ----

classes/class_quaternion.rst

@@ -17,11 +17,15 @@ A unit quaternion used for representing 3D rotations.
 Description
 -----------
 
-Quaternions are similar to :ref:`Basis<class_Basis>`, which implements the matrix representation of rotations. Unlike :ref:`Basis<class_Basis>`, which stores rotation, scale, and shearing, quaternions only store rotation.
+The **Quaternion** built-in :ref:`Variant<class_Variant>` type is a 4D data structure that represents rotation in the form of a `Hamilton convention quaternion <https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation>`__. Compared to the :ref:`Basis<class_Basis>` type which can store both rotation and scale, quaternions can *only* store rotation.
 
-Quaternions can be parametrized using both an axis-angle pair or Euler angles. Due to their compactness and the way they are stored in memory, certain operations (obtaining axis-angle and performing SLERP, in particular) are more efficient and robust against floating-point errors.
+A **Quaternion** is composed by 4 floating-point components: :ref:`w<class_Quaternion_property_w>`, :ref:`x<class_Quaternion_property_x>`, :ref:`y<class_Quaternion_property_y>`, and :ref:`z<class_Quaternion_property_z>`. These components are very compact in memory, and because of this some operations are more efficient and less likely to cause floating-point errors. Methods such as :ref:`get_angle<class_Quaternion_method_get_angle>`, :ref:`get_axis<class_Quaternion_method_get_axis>`, and :ref:`slerp<class_Quaternion_method_slerp>` are faster than their :ref:`Basis<class_Basis>` counterparts.
 
-\ **Note:** Quaternions need to be normalized before being used for rotation.
+For a great introduction to quaternions, see `this video by 3Blue1Brown <https://www.youtube.com/watch?v=d4EgbgTm0Bg>`__. You do not need to know the math behind quaternions, as Godot provides several helper methods that handle it for you. These include :ref:`slerp<class_Quaternion_method_slerp>` and :ref:`spherical_cubic_interpolate<class_Quaternion_method_spherical_cubic_interpolate>`, as well as the ``*`` operator.
+
+\ **Note:** Quaternions must be normalized before being used for rotation (see :ref:`normalized<class_Quaternion_method_normalized>`).
+
+\ **Note:** Similarly to :ref:`Vector2<class_Vector2>` and :ref:`Vector3<class_Vector3>`, the components of a quaternion use 32-bit precision by default, unlike :ref:`float<class_float>` which is always 64-bit. If double precision is needed, compile the engine with the option ``precision=double``.
 
 .. note::
 
@@ -32,10 +36,16 @@ Quaternions can be parametrized using both an axis-angle pair or Euler angles. D
 Tutorials
 ---------
 
+- `3Blue1Brown's video on Quaternions <https://www.youtube.com/watch?v=d4EgbgTm0Bg>`__
+
+- `Online Quaternion Visualization <https://quaternions.online/>`__
+
 - `Using 3D transforms <../tutorials/3d/using_transforms.html#interpolating-with-quaternions>`__
 
 - `Third Person Shooter Demo <https://godotengine.org/asset-library/asset/678>`__
 
+- `Advanced Quaternion Visualization <https://iwatake2222.github.io/rotation_master/rotation_master.html>`__
+
 .. rst-class:: classref-reftable-group
 
 Properties
@@ -175,7 +185,9 @@ Constants
 
 **IDENTITY** = ``Quaternion(0, 0, 0, 1)``
 
-The identity quaternion, representing no rotation. Equivalent to an identity :ref:`Basis<class_Basis>` matrix. If a vector is transformed by an identity quaternion, it will not change.
+The identity quaternion, representing no rotation. This has the same rotation as :ref:`Basis.IDENTITY<class_Basis_constant_IDENTITY>`.
+
+If a :ref:`Vector3<class_Vector3>` is rotated (multiplied) by this quaternion, it does not change.
 
 .. rst-class:: classref-section-separator
 
@@ -192,9 +204,9 @@ Property Descriptions
 
 :ref:`float<class_float>` **w** = ``1.0``
 
-W component of the quaternion (real part).
+W component of the quaternion. This is the "real" part.
 
-Quaternion components should usually not be manipulated directly.
+\ **Note:** Quaternion components should usually not be manipulated directly.
 
 .. rst-class:: classref-item-separator
 
@@ -206,9 +218,9 @@ Quaternion components should usually not be manipulated directly.
 
 :ref:`float<class_float>` **x** = ``0.0``
 
-X component of the quaternion (imaginary ``i`` axis part).
+X component of the quaternion. This is the value along the "imaginary" ``i`` axis.
 
-Quaternion components should usually not be manipulated directly.
+\ **Note:** Quaternion components should usually not be manipulated directly.
 
 .. rst-class:: classref-item-separator
 
@@ -220,9 +232,9 @@ Quaternion components should usually not be manipulated directly.
 
 :ref:`float<class_float>` **y** = ``0.0``
 
-Y component of the quaternion (imaginary ``j`` axis part).
+Y component of the quaternion. This is the value along the "imaginary" ``j`` axis.
 
-Quaternion components should usually not be manipulated directly.
+\ **Note:** Quaternion components should usually not be manipulated directly.
 
 .. rst-class:: classref-item-separator
 
@@ -234,9 +246,9 @@ Quaternion components should usually not be manipulated directly.
 
 :ref:`float<class_float>` **z** = ``0.0``
 
-Z component of the quaternion (imaginary ``k`` axis part).
+Z component of the quaternion. This is the value along the "imaginary" ``k`` axis.
 
-Quaternion components should usually not be manipulated directly.
+\ **Note:** Quaternion components should usually not be manipulated directly.
 
 .. rst-class:: classref-section-separator
 
@@ -253,7 +265,7 @@ Constructor Descriptions
 
 :ref:`Quaternion<class_Quaternion>` **Quaternion**\ (\ )
 
-Constructs a default-initialized quaternion with all components set to ``0``.
+Constructs a **Quaternion** identical to the :ref:`IDENTITY<class_Quaternion_constant_IDENTITY>`.
 
 .. rst-class:: classref-item-separator
 
@@ -273,7 +285,7 @@ Constructs a **Quaternion** as a copy of the given **Quaternion**.
 
 :ref:`Quaternion<class_Quaternion>` **Quaternion**\ (\ arc_from\: :ref:`Vector3<class_Vector3>`, arc_to\: :ref:`Vector3<class_Vector3>`\ )
 
-Constructs a quaternion representing the shortest arc between two points on the surface of a sphere with a radius of ``1.0``.
+Constructs a **Quaternion** representing the shortest arc between ``arc_from`` and ``arc_to``. These can be imagined as two points intersecting a sphere's surface, with a radius of ``1.0``.
 
 .. rst-class:: classref-item-separator
 
@@ -283,7 +295,7 @@ Constructs a quaternion representing the shortest arc between two points on the
 
 :ref:`Quaternion<class_Quaternion>` **Quaternion**\ (\ axis\: :ref:`Vector3<class_Vector3>`, angle\: :ref:`float<class_float>`\ )
 
-Constructs a quaternion that will rotate around the given axis by the specified angle. The axis must be a normalized vector.
+Constructs a **Quaternion** representing rotation around the ``axis`` by the given ``angle``, in radians. The axis must be a normalized vector.
 
 .. rst-class:: classref-item-separator
 
@@ -293,7 +305,9 @@ Constructs a quaternion that will rotate around the given axis by the specified
 
 :ref:`Quaternion<class_Quaternion>` **Quaternion**\ (\ from\: :ref:`Basis<class_Basis>`\ )
 
-Constructs a quaternion from the given :ref:`Basis<class_Basis>`.
+Constructs a **Quaternion** from the given rotation :ref:`Basis<class_Basis>`.
+
+This constructor is faster than :ref:`Basis.get_rotation_quaternion<class_Basis_method_get_rotation_quaternion>`, but the given basis must be *orthonormalized* (see :ref:`Basis.orthonormalized<class_Basis_method_orthonormalized>`). Otherwise, the constructor fails and returns :ref:`IDENTITY<class_Quaternion_constant_IDENTITY>`.
 
 .. rst-class:: classref-item-separator
 
@@ -303,7 +317,9 @@ Constructs a quaternion from the given :ref:`Basis<class_Basis>`.
 
 :ref:`Quaternion<class_Quaternion>` **Quaternion**\ (\ x\: :ref:`float<class_float>`, y\: :ref:`float<class_float>`, z\: :ref:`float<class_float>`, w\: :ref:`float<class_float>`\ )
 
-Constructs a quaternion defined by the given values.
+Constructs a **Quaternion** defined by the given values.
+
+\ **Note:** Only normalized quaternions represent rotation; if these values are not normalized, the new **Quaternion** will not be a valid rotation.
 
 .. rst-class:: classref-section-separator
 
@@ -334,7 +350,9 @@ Returns the angle between this quaternion and ``to``. This is the magnitude of t
 
 :ref:`float<class_float>` **dot**\ (\ with\: :ref:`Quaternion<class_Quaternion>`\ ) |const|
 
-Returns the dot product of two quaternions.
+Returns the dot product between this quaternion and ``with``.
+
+This is equivalent to ``(quat.x * with.x) + (quat.y * with.y) + (quat.z * with.z) + (quat.w * with.w)``.
 
 .. rst-class:: classref-item-separator
 
@@ -358,7 +376,7 @@ Returns the exponential of this quaternion. The rotation axis of the result is t
 
 :ref:`Quaternion<class_Quaternion>` **from_euler**\ (\ euler\: :ref:`Vector3<class_Vector3>`\ ) |static|
 
-Constructs a Quaternion from Euler angles in YXZ rotation order.
+Constructs a new **Quaternion** from the given :ref:`Vector3<class_Vector3>` of `Euler angles <https://en.wikipedia.org/wiki/Euler_angles>`__, in radians. This method always uses the YXZ convention (:ref:`@GlobalScope.EULER_ORDER_YXZ<class_@GlobalScope_constant_EULER_ORDER_YXZ>`).
 
 .. rst-class:: classref-item-separator
 
@@ -396,7 +414,9 @@ Returns the rotation axis of the rotation represented by this quaternion.
 
 :ref:`Vector3<class_Vector3>` **get_euler**\ (\ order\: :ref:`int<class_int>` = 2\ ) |const|
 
-Returns the quaternion's rotation in the form of Euler angles. The Euler order depends on the ``order`` parameter, for example using the YXZ convention: since this method decomposes, first Z, then X, and Y last. See the :ref:`EulerOrder<enum_@GlobalScope_EulerOrder>` enum for possible values. The returned vector contains the rotation angles in the format (X angle, Y angle, Z angle).
+Returns this quaternion's rotation as a :ref:`Vector3<class_Vector3>` of `Euler angles <https://en.wikipedia.org/wiki/Euler_angles>`__, in radians.
+
+The order of each consecutive rotation can be changed with ``order`` (see :ref:`EulerOrder<enum_@GlobalScope_EulerOrder>` constants). By default, the YXZ convention is used (:ref:`@GlobalScope.EULER_ORDER_YXZ<class_@GlobalScope_constant_EULER_ORDER_YXZ>`): Z (roll) is calculated first, then X (pitch), and lastly Y (yaw). When using the opposite method :ref:`from_euler<class_Quaternion_method_from_euler>`, this order is reversed.
 
 .. rst-class:: classref-item-separator
 
@@ -408,7 +428,7 @@ Returns the quaternion's rotation in the form of Euler angles. The Euler order d
 
 :ref:`Quaternion<class_Quaternion>` **inverse**\ (\ ) |const|
 
-Returns the inverse of the quaternion.
+Returns the inverse version of this quaternion, inverting the sign of every component except :ref:`w<class_Quaternion_property_w>`.
 
 .. rst-class:: classref-item-separator
 
@@ -444,7 +464,7 @@ Returns ``true`` if this quaternion is finite, by calling :ref:`@GlobalScope.is_
 
 :ref:`bool<class_bool>` **is_normalized**\ (\ ) |const|
 
-Returns whether the quaternion is normalized or not.
+Returns ``true`` if this quaternion is normalized. See also :ref:`normalized<class_Quaternion_method_normalized>`.
 
 .. rst-class:: classref-item-separator
 
@@ -456,7 +476,7 @@ Returns whether the quaternion is normalized or not.
 
 :ref:`float<class_float>` **length**\ (\ ) |const|
 
-Returns the length of the quaternion.
+Returns this quaternion's length, also called magnitude.
 
 .. rst-class:: classref-item-separator
 
@@ -468,7 +488,9 @@ Returns the length of the quaternion.
 
 :ref:`float<class_float>` **length_squared**\ (\ ) |const|
 
-Returns the length of the quaternion, squared.
+Returns this quaternion's length, squared.
+
+\ **Note:** This method is faster than :ref:`length<class_Quaternion_method_length>`, so prefer it if you only need to compare quaternion lengths.
 
 .. rst-class:: classref-item-separator
 
@@ -480,7 +502,7 @@ Returns the length of the quaternion, squared.
 
 :ref:`Quaternion<class_Quaternion>` **log**\ (\ ) |const|
 
-Returns the logarithm of this quaternion. The vector part of the result is the rotation axis of this quaternion multiplied by its rotation angle, the real part of the result is zero.
+Returns the logarithm of this quaternion. Multiplies this quaternion's rotation axis by its rotation angle, and stores the result in the returned quaternion's vector part (:ref:`x<class_Quaternion_property_x>`, :ref:`y<class_Quaternion_property_y>`, and :ref:`z<class_Quaternion_property_z>`). The returned quaternion's real part (:ref:`w<class_Quaternion_property_w>`) is always ``0.0``.
 
 .. rst-class:: classref-item-separator
 
@@ -492,7 +514,7 @@ Returns the logarithm of this quaternion. The vector part of the result is the r
 
 :ref:`Quaternion<class_Quaternion>` **normalized**\ (\ ) |const|
 
-Returns a copy of the quaternion, normalized to unit length.
+Returns a copy of this quaternion, normalized so that its length is ``1.0``. See also :ref:`is_normalized<class_Quaternion_method_is_normalized>`.
 
 .. rst-class:: classref-item-separator
 
@@ -504,9 +526,7 @@ Returns a copy of the quaternion, normalized to unit length.
 
 :ref:`Quaternion<class_Quaternion>` **slerp**\ (\ to\: :ref:`Quaternion<class_Quaternion>`, weight\: :ref:`float<class_float>`\ ) |const|
 
-Returns the result of the spherical linear interpolation between this quaternion and ``to`` by amount ``weight``.
-
-\ **Note:** Both quaternions must be normalized.
+Performs a spherical-linear interpolation with the ``to`` quaternion, given a ``weight`` and returns the result. Both this quaternion and ``to`` must be normalized.
 
 .. rst-class:: classref-item-separator
 
@@ -518,7 +538,7 @@ Returns the result of the spherical linear interpolation between this quaternion
 
 :ref:`Quaternion<class_Quaternion>` **slerpni**\ (\ to\: :ref:`Quaternion<class_Quaternion>`, weight\: :ref:`float<class_float>`\ ) |const|
 
-Returns the result of the spherical linear interpolation between this quaternion and ``to`` by amount ``weight``, but without checking if the rotation path is not bigger than 90 degrees.
+Performs a spherical-linear interpolation with the ``to`` quaternion, given a ``weight`` and returns the result. Unlike :ref:`slerp<class_Quaternion_method_slerp>`, this method does not check if the rotation path is smaller than 90 degrees. Both this quaternion and ``to`` must be normalized.
 
 .. rst-class:: classref-item-separator
 
@@ -561,7 +581,7 @@ Operator Descriptions
 
 :ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`Quaternion<class_Quaternion>`\ )
 
-Returns ``true`` if the quaternions are not equal.
+Returns ``true`` if the components of both quaternions are not exactly equal.
 
 \ **Note:** Due to floating-point precision errors, consider using :ref:`is_equal_approx<class_Quaternion_method_is_equal_approx>` instead, which is more reliable.
 
@@ -575,7 +595,7 @@ Returns ``true`` if the quaternions are not equal.
 
 :ref:`Quaternion<class_Quaternion>` **operator ***\ (\ right\: :ref:`Quaternion<class_Quaternion>`\ )
 
-Composes these two quaternions by multiplying them together. This has the effect of rotating the second quaternion (the child) by the first quaternion (the parent).
+Composes (multiplies) two quaternions. This rotates the ``right`` quaternion (the child) by this quaternion (the parent).
 
 .. rst-class:: classref-item-separator
 
@@ -587,7 +607,7 @@ Composes these two quaternions by multiplying them together. This has the effect
 
 :ref:`Vector3<class_Vector3>` **operator ***\ (\ right\: :ref:`Vector3<class_Vector3>`\ )
 
-Rotates (multiplies) the :ref:`Vector3<class_Vector3>` by the given **Quaternion**.
+Rotates (multiplies) the ``right`` vector by this quaternion, returning a :ref:`Vector3<class_Vector3>`.
 
 .. rst-class:: classref-item-separator
 
@@ -599,7 +619,9 @@ Rotates (multiplies) the :ref:`Vector3<class_Vector3>` by the given **Quaternion
 
 :ref:`Quaternion<class_Quaternion>` **operator ***\ (\ right\: :ref:`float<class_float>`\ )
 
-Multiplies each component of the **Quaternion** by the given value. This operation is not meaningful on its own, but it can be used as a part of a larger expression.
+Multiplies each component of the **Quaternion** by the right :ref:`float<class_float>` value.
+
+This operation is not meaningful on its own, but it can be used as a part of a larger expression.
 
 .. rst-class:: classref-item-separator
 
@@ -611,7 +633,9 @@ Multiplies each component of the **Quaternion** by the given value. This operati
 
 :ref:`Quaternion<class_Quaternion>` **operator ***\ (\ right\: :ref:`int<class_int>`\ )
 
-Multiplies each component of the **Quaternion** by the given value. This operation is not meaningful on its own, but it can be used as a part of a larger expression.
+Multiplies each component of the **Quaternion** by the right :ref:`int<class_int>` value.
+
+This operation is not meaningful on its own, but it can be used as a part of a larger expression.
 
 .. rst-class:: classref-item-separator
 
@@ -623,7 +647,9 @@ Multiplies each component of the **Quaternion** by the given value. This operati
 
 :ref:`Quaternion<class_Quaternion>` **operator +**\ (\ right\: :ref:`Quaternion<class_Quaternion>`\ )
 
-Adds each component of the left **Quaternion** to the right **Quaternion**. This operation is not meaningful on its own, but it can be used as a part of a larger expression, such as approximating an intermediate rotation between two nearby rotations.
+Adds each component of the left **Quaternion** to the right **Quaternion**.
+
+This operation is not meaningful on its own, but it can be used as a part of a larger expression, such as approximating an intermediate rotation between two nearby rotations.
 
 .. rst-class:: classref-item-separator
 
@@ -635,7 +661,9 @@ Adds each component of the left **Quaternion** to the right **Quaternion**. This
 
 :ref:`Quaternion<class_Quaternion>` **operator -**\ (\ right\: :ref:`Quaternion<class_Quaternion>`\ )
 
-Subtracts each component of the left **Quaternion** by the right **Quaternion**. This operation is not meaningful on its own, but it can be used as a part of a larger expression.
+Subtracts each component of the left **Quaternion** by the right **Quaternion**.
+
+This operation is not meaningful on its own, but it can be used as a part of a larger expression.
 
 .. rst-class:: classref-item-separator
 
@@ -647,7 +675,9 @@ Subtracts each component of the left **Quaternion** by the right **Quaternion**.
 
 :ref:`Quaternion<class_Quaternion>` **operator /**\ (\ right\: :ref:`float<class_float>`\ )
 
-Divides each component of the **Quaternion** by the given value. This operation is not meaningful on its own, but it can be used as a part of a larger expression.
+Divides each component of the **Quaternion** by the right :ref:`float<class_float>` value.
+
+This operation is not meaningful on its own, but it can be used as a part of a larger expression.
 
 .. rst-class:: classref-item-separator
 
@@ -659,7 +689,9 @@ Divides each component of the **Quaternion** by the given value. This operation
 
 :ref:`Quaternion<class_Quaternion>` **operator /**\ (\ right\: :ref:`int<class_int>`\ )
 
-Divides each component of the **Quaternion** by the given value. This operation is not meaningful on its own, but it can be used as a part of a larger expression.
+Divides each component of the **Quaternion** by the right :ref:`int<class_int>` value.
+
+This operation is not meaningful on its own, but it can be used as a part of a larger expression.
 
 .. rst-class:: classref-item-separator
 
@@ -671,7 +703,7 @@ Divides each component of the **Quaternion** by the given value. This operation
 
 :ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`Quaternion<class_Quaternion>`\ )
 
-Returns ``true`` if the quaternions are exactly equal.
+Returns ``true`` if the components of both quaternions are exactly equal.
 
 \ **Note:** Due to floating-point precision errors, consider using :ref:`is_equal_approx<class_Quaternion_method_is_equal_approx>` instead, which is more reliable.
 
@@ -685,7 +717,9 @@ Returns ``true`` if the quaternions are exactly equal.
 
 :ref:`float<class_float>` **operator []**\ (\ index\: :ref:`int<class_int>`\ )
 
-Access quaternion components using their index. ``q[0]`` is equivalent to ``q.x``, ``q[1]`` is equivalent to ``q.y``, ``q[2]`` is equivalent to ``q.z``, and ``q[3]`` is equivalent to ``q.w``.
+Accesses each component of this quaternion by their index.
+
+Index ``0`` is the same as :ref:`x<class_Quaternion_property_x>`, index ``1`` is the same as :ref:`y<class_Quaternion_property_y>`, index ``2`` is the same as :ref:`z<class_Quaternion_property_z>`, and index ``3`` is the same as :ref:`w<class_Quaternion_property_w>`.
 
 .. rst-class:: classref-item-separator
 
@@ -709,7 +743,7 @@ Returns the same value as if the ``+`` was not there. Unary ``+`` does nothing,
 
 :ref:`Quaternion<class_Quaternion>` **operator unary-**\ (\ )
 
-Returns the negative value of the **Quaternion**. This is the same as writing ``Quaternion(-q.x, -q.y, -q.z, -q.w)``. This operation results in a quaternion that represents the same rotation.
+Returns the negative value of the **Quaternion**. This is the same as multiplying all components by ``-1``. This operation results in a quaternion that represents the same rotation.
 
 .. |virtual| replace:: :abbr:`virtual (This method should typically be overridden by the user to have any effect.)`
 .. |const| replace:: :abbr:`const (This method has no side effects. It doesn't modify any of the instance's member variables.)`

classes/class_randomnumbergenerator.rst

@@ -60,6 +60,8 @@ Methods
 .. table::
    :widths: auto
 
+   +---------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`int<class_int>`     | :ref:`rand_weighted<class_RandomNumberGenerator_method_rand_weighted>`\ (\ weights\: :ref:`PackedFloat32Array<class_PackedFloat32Array>`\ )         |
    +---------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+
    | :ref:`float<class_float>` | :ref:`randf<class_RandomNumberGenerator_method_randf>`\ (\ )                                                                                        |
    +---------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -147,6 +149,34 @@ The current state of the random number generator. Save and restore this property
 Method Descriptions
 -------------------
 
+.. _class_RandomNumberGenerator_method_rand_weighted:
+
+.. rst-class:: classref-method
+
+:ref:`int<class_int>` **rand_weighted**\ (\ weights\: :ref:`PackedFloat32Array<class_PackedFloat32Array>`\ )
+
+Returns a random index with non-uniform weights. Prints an error and returns ``-1`` if the array is empty.
+
+
+.. tabs::
+
+ .. code-tab:: gdscript
+
+    var rnd = RandomNumberGenerator.new()
+    
+    var my_array = ["one", "two", "three, "four"]
+    var weights = PackedFloat32Array([0.5, 1, 1, 2])
+    
+    # Prints one of the four elements in `my_array`.
+    # It is more likely to print "four", and less likely to print "two".
+    print(my_array[rng.rand_weighted(weights)])
+
+
+
+.. rst-class:: classref-item-separator
+
+----
+
 .. _class_RandomNumberGenerator_method_randf:
 
 .. rst-class:: classref-method

classes/class_resourceformatloader.rst

@@ -78,11 +78,7 @@ enum **CacheMode**:
 
 :ref:`CacheMode<enum_ResourceFormatLoader_CacheMode>` **CACHE_MODE_IGNORE** = ``0``
 
-.. container:: contribute
-
-	There is currently no description for this enum. Please help us by :ref:`contributing one <doc_updating_the_class_reference>`!
-
-
+Neither the main resource (the one requested to be loaded) nor any of its subresources are retrieved from cache nor stored into it. Dependencies (external resources) are loaded with :ref:`CACHE_MODE_REUSE<class_ResourceFormatLoader_constant_CACHE_MODE_REUSE>`.
 
 .. _class_ResourceFormatLoader_constant_CACHE_MODE_REUSE:
 
@@ -90,23 +86,31 @@ enum **CacheMode**:
 
 :ref:`CacheMode<enum_ResourceFormatLoader_CacheMode>` **CACHE_MODE_REUSE** = ``1``
 
-.. container:: contribute
+The main resource (the one requested to be loaded), its subresources, and its dependencies (external resources) are retrieved from cache if present, instead of loaded. Those not cached are loaded and then stored into the cache. The same rules are propagated recursively down the tree of dependencies (external resources).
+
+.. _class_ResourceFormatLoader_constant_CACHE_MODE_REPLACE:
 
-	There is currently no description for this enum. Please help us by :ref:`contributing one <doc_updating_the_class_reference>`!
+.. rst-class:: classref-enumeration-constant
 
+:ref:`CacheMode<enum_ResourceFormatLoader_CacheMode>` **CACHE_MODE_REPLACE** = ``2``
 
+Like :ref:`CACHE_MODE_REUSE<class_ResourceFormatLoader_constant_CACHE_MODE_REUSE>`, but the cache is checked for the main resource (the one requested to be loaded) as well as for each of its subresources. Those already in the cache, as long as the loaded and cached types match, have their data refreshed from storage into the already existing instances. Otherwise, they are recreated as completely new objects.
 
-.. _class_ResourceFormatLoader_constant_CACHE_MODE_REPLACE:
+.. _class_ResourceFormatLoader_constant_CACHE_MODE_IGNORE_DEEP:
 
 .. rst-class:: classref-enumeration-constant
 
-:ref:`CacheMode<enum_ResourceFormatLoader_CacheMode>` **CACHE_MODE_REPLACE** = ``2``
+:ref:`CacheMode<enum_ResourceFormatLoader_CacheMode>` **CACHE_MODE_IGNORE_DEEP** = ``3``
 
-.. container:: contribute
+Like :ref:`CACHE_MODE_IGNORE<class_ResourceFormatLoader_constant_CACHE_MODE_IGNORE>`, but propagated recursively down the tree of dependencies (external resources).
+
+.. _class_ResourceFormatLoader_constant_CACHE_MODE_REPLACE_DEEP:
 
-	There is currently no description for this enum. Please help us by :ref:`contributing one <doc_updating_the_class_reference>`!
+.. rst-class:: classref-enumeration-constant
 
+:ref:`CacheMode<enum_ResourceFormatLoader_CacheMode>` **CACHE_MODE_REPLACE_DEEP** = ``4``
 
+Like :ref:`CACHE_MODE_REPLACE<class_ResourceFormatLoader_constant_CACHE_MODE_REPLACE>`, but propagated recursively down the tree of dependencies (external resources).
 
 .. rst-class:: classref-section-separator
 

classes/class_resourceimporterscene.rst

@@ -67,6 +67,8 @@ Properties
    +-------------------------------------+------------------------------------------------------------------------------------------------------------------+-----------+
    | :ref:`bool<class_bool>`             | :ref:`nodes/apply_root_scale<class_ResourceImporterScene_property_nodes/apply_root_scale>`                       | ``true``  |
    +-------------------------------------+------------------------------------------------------------------------------------------------------------------+-----------+
+   | :ref:`bool<class_bool>`             | :ref:`nodes/import_as_skeleton_bones<class_ResourceImporterScene_property_nodes/import_as_skeleton_bones>`       | ``false`` |
+   +-------------------------------------+------------------------------------------------------------------------------------------------------------------+-----------+
    | :ref:`String<class_String>`         | :ref:`nodes/root_name<class_ResourceImporterScene_property_nodes/root_name>`                                     | ``""``    |
    +-------------------------------------+------------------------------------------------------------------------------------------------------------------+-----------+
    | :ref:`float<class_float>`           | :ref:`nodes/root_scale<class_ResourceImporterScene_property_nodes/root_scale>`                                   | ``1.0``   |
@@ -245,6 +247,18 @@ If ``true``, :ref:`nodes/root_scale<class_ResourceImporterScene_property_nodes/r
 
 ----
 
+.. _class_ResourceImporterScene_property_nodes/import_as_skeleton_bones:
+
+.. rst-class:: classref-property
+
+:ref:`bool<class_bool>` **nodes/import_as_skeleton_bones** = ``false``
+
+Treat all nodes in the imported scene as if they are bones within a single :ref:`Skeleton3D<class_Skeleton3D>`. Can be used to guarantee that imported animations target skeleton bones rather than nodes. May also be used to assign the ``"Root"`` bone in a :ref:`BoneMap<class_BoneMap>`. See :doc:`Retargeting 3D Skeletons <../tutorials/assets_pipeline/retargeting_3d_skeletons>` for more information.
+
+.. rst-class:: classref-item-separator
+
+----
+
 .. _class_ResourceImporterScene_property_nodes/root_name:
 
 .. rst-class:: classref-property

classes/class_resourceloader.rst

@@ -129,7 +129,7 @@ enum **CacheMode**:
 
 :ref:`CacheMode<enum_ResourceLoader_CacheMode>` **CACHE_MODE_IGNORE** = ``0``
 
-The resource is always loaded from disk, even if a cache entry exists for its path, and the newly loaded copy will not be cached. Instances loaded with this mode will exist independently.
+Neither the main resource (the one requested to be loaded) nor any of its subresources are retrieved from cache nor stored into it. Dependencies (external resources) are loaded with :ref:`CACHE_MODE_REUSE<class_ResourceLoader_constant_CACHE_MODE_REUSE>`.
 
 .. _class_ResourceLoader_constant_CACHE_MODE_REUSE:
 
@@ -137,7 +137,7 @@ The resource is always loaded from disk, even if a cache entry exists for its pa
 
 :ref:`CacheMode<enum_ResourceLoader_CacheMode>` **CACHE_MODE_REUSE** = ``1``
 
-If a resource is cached, returns the cached reference. Otherwise it's loaded from disk.
+The main resource (the one requested to be loaded), its subresources, and its dependencies (external resources) are retrieved from cache if present, instead of loaded. Those not cached are loaded and then stored into the cache. The same rules are propagated recursively down the tree of dependencies (external resources).
 
 .. _class_ResourceLoader_constant_CACHE_MODE_REPLACE:
 
@@ -145,7 +145,23 @@ If a resource is cached, returns the cached reference. Otherwise it's loaded fro
 
 :ref:`CacheMode<enum_ResourceLoader_CacheMode>` **CACHE_MODE_REPLACE** = ``2``
 
-The resource is always loaded from disk, even if a cache entry exists for its path. The cached entry will be replaced by the newly loaded copy.
+Like :ref:`CACHE_MODE_REUSE<class_ResourceLoader_constant_CACHE_MODE_REUSE>`, but the cache is checked for the main resource (the one requested to be loaded) as well as for each of its subresources. Those already in the cache, as long as the loaded and cached types match, have their data refreshed from storage into the already existing instances. Otherwise, they are recreated as completely new objects.
+
+.. _class_ResourceLoader_constant_CACHE_MODE_IGNORE_DEEP:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`CacheMode<enum_ResourceLoader_CacheMode>` **CACHE_MODE_IGNORE_DEEP** = ``3``
+
+Like :ref:`CACHE_MODE_IGNORE<class_ResourceLoader_constant_CACHE_MODE_IGNORE>`, but propagated recursively down the tree of dependencies (external resources).
+
+.. _class_ResourceLoader_constant_CACHE_MODE_REPLACE_DEEP:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`CacheMode<enum_ResourceLoader_CacheMode>` **CACHE_MODE_REPLACE_DEEP** = ``4``
+
+Like :ref:`CACHE_MODE_REPLACE<class_ResourceLoader_constant_CACHE_MODE_REPLACE>`, but propagated recursively down the tree of dependencies (external resources).
 
 .. rst-class:: classref-section-separator
 

classes/class_richtextlabel.rst

@@ -205,7 +205,7 @@ Methods
    +-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | |void|                              | :ref:`push_list<class_RichTextLabel_method_push_list>`\ (\ level\: :ref:`int<class_int>`, type\: :ref:`ListType<enum_RichTextLabel_ListType>`, capitalize\: :ref:`bool<class_bool>`, bullet\: :ref:`String<class_String>` = "•"\ )                                                                                                                                                                                                                                                                                                                                                                                                            |
    +-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-   | |void|                              | :ref:`push_meta<class_RichTextLabel_method_push_meta>`\ (\ data\: :ref:`Variant<class_Variant>`\ )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+   | |void|                              | :ref:`push_meta<class_RichTextLabel_method_push_meta>`\ (\ data\: :ref:`Variant<class_Variant>`, underline_mode\: :ref:`MetaUnderline<enum_RichTextLabel_MetaUnderline>` = 1\ )                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
    +-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | |void|                              | :ref:`push_mono<class_RichTextLabel_method_push_mono>`\ (\ )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
    +-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -257,7 +257,7 @@ Theme Properties
    +---------------------------------+----------------------------------------------------------------------------------------------+-----------------------------+
    | :ref:`Color<class_Color>`       | :ref:`default_color<class_RichTextLabel_theme_color_default_color>`                          | ``Color(1, 1, 1, 1)``       |
    +---------------------------------+----------------------------------------------------------------------------------------------+-----------------------------+
-   | :ref:`Color<class_Color>`       | :ref:`font_outline_color<class_RichTextLabel_theme_color_font_outline_color>`                | ``Color(1, 1, 1, 1)``       |
+   | :ref:`Color<class_Color>`       | :ref:`font_outline_color<class_RichTextLabel_theme_color_font_outline_color>`                | ``Color(0, 0, 0, 1)``       |
    +---------------------------------+----------------------------------------------------------------------------------------------+-----------------------------+
    | :ref:`Color<class_Color>`       | :ref:`font_selected_color<class_RichTextLabel_theme_color_font_selected_color>`              | ``Color(0, 0, 0, 0)``       |
    +---------------------------------+----------------------------------------------------------------------------------------------+-----------------------------+
@@ -341,7 +341,22 @@ Triggered when the document is fully loaded.
 
 **meta_clicked**\ (\ meta\: :ref:`Variant<class_Variant>`\ )
 
-Triggered when the user clicks on content between meta tags. If the meta is defined in text, e.g. ``[url={"data"="hi"}]hi[/url]``, then the parameter for this signal will be a :ref:`String<class_String>` type. If a particular type or an object is desired, the :ref:`push_meta<class_RichTextLabel_method_push_meta>` method must be used to manually insert the data into the tag stack.
+Triggered when the user clicks on content between meta (URL) tags. If the meta is defined in BBCode, e.g. ``[url={"key": "value"}]Text[/url]``, then the parameter for this signal will always be a :ref:`String<class_String>` type. If a particular type or an object is desired, the :ref:`push_meta<class_RichTextLabel_method_push_meta>` method must be used to manually insert the data into the tag stack. Alternatively, you can convert the :ref:`String<class_String>` input to the desired type based on its contents (such as calling :ref:`JSON.parse<class_JSON_method_parse>` on it).
+
+For example, the following method can be connected to :ref:`meta_clicked<class_RichTextLabel_signal_meta_clicked>` to open clicked URLs using the user's default web browser:
+
+
+.. tabs::
+
+ .. code-tab:: gdscript
+
+    # This assumes RichTextLabel's `meta_clicked` signal was connected to
+    # the function below using the signal connection dialog.
+    func _richtextlabel_on_meta_clicked(meta):
+        # `meta` is of Variant type, so convert it to a String to avoid script errors at run-time.
+        OS.shell_open(str(meta))
+
+
 
 .. rst-class:: classref-item-separator
 
@@ -452,6 +467,40 @@ Represents the size of the :ref:`MenuItems<enum_RichTextLabel_MenuItems>` enum.
 
 ----
 
+.. _enum_RichTextLabel_MetaUnderline:
+
+.. rst-class:: classref-enumeration
+
+enum **MetaUnderline**:
+
+.. _class_RichTextLabel_constant_META_UNDERLINE_NEVER:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`MetaUnderline<enum_RichTextLabel_MetaUnderline>` **META_UNDERLINE_NEVER** = ``0``
+
+Meta tag does not display an underline, even if :ref:`meta_underlined<class_RichTextLabel_property_meta_underlined>` is ``true``.
+
+.. _class_RichTextLabel_constant_META_UNDERLINE_ALWAYS:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`MetaUnderline<enum_RichTextLabel_MetaUnderline>` **META_UNDERLINE_ALWAYS** = ``1``
+
+If :ref:`meta_underlined<class_RichTextLabel_property_meta_underlined>` is ``true``, meta tag always display an underline.
+
+.. _class_RichTextLabel_constant_META_UNDERLINE_ON_HOVER:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`MetaUnderline<enum_RichTextLabel_MetaUnderline>` **META_UNDERLINE_ON_HOVER** = ``2``
+
+If :ref:`meta_underlined<class_RichTextLabel_property_meta_underlined>` is ``true``, meta tag display an underline when the mouse cursor is over it.
+
+.. rst-class:: classref-item-separator
+
+----
+
 .. _enum_RichTextLabel_ImageUpdateMask:
 
 .. rst-class:: classref-enumeration
@@ -697,7 +746,7 @@ Language code used for line-breaking and text shaping algorithms, if left empty
 - |void| **set_meta_underline**\ (\ value\: :ref:`bool<class_bool>`\ )
 - :ref:`bool<class_bool>` **is_meta_underlined**\ (\ )
 
-If ``true``, the label underlines meta tags such as ``[url]{text}[/url]``.
+If ``true``, the label underlines meta tags such as ``[url]{text}[/url]``. These tags can call a function when clicked if :ref:`meta_clicked<class_RichTextLabel_signal_meta_clicked>` is connected to a function.
 
 .. rst-class:: classref-item-separator
 
@@ -1034,7 +1083,7 @@ Clears the current selection.
 
 :ref:`int<class_int>` **get_character_line**\ (\ character\: :ref:`int<class_int>`\ )
 
-Returns the line number of the character position provided.
+Returns the line number of the character position provided. Line and character numbers are both zero-indexed.
 
 \ **Note:** If :ref:`threaded<class_RichTextLabel_property_threaded>` is enabled, this method returns a value for the loaded part of the document. Use :ref:`is_ready<class_RichTextLabel_method_is_ready>` or :ref:`finished<class_RichTextLabel_signal_finished>` to determine whether document is fully loaded.
 
@@ -1048,7 +1097,7 @@ Returns the line number of the character position provided.
 
 :ref:`int<class_int>` **get_character_paragraph**\ (\ character\: :ref:`int<class_int>`\ )
 
-Returns the paragraph number of the character position provided.
+Returns the paragraph number of the character position provided. Paragraph and character numbers are both zero-indexed.
 
 \ **Note:** If :ref:`threaded<class_RichTextLabel_property_threaded>` is enabled, this method returns a value for the loaded part of the document. Use :ref:`is_ready<class_RichTextLabel_method_is_ready>` or :ref:`finished<class_RichTextLabel_signal_finished>` to determine whether document is fully loaded.
 
@@ -1642,10 +1691,14 @@ Adds ``[ol]`` or ``[ul]`` tag to the tag stack. Multiplies ``level`` by current
 
 .. rst-class:: classref-method
 
-|void| **push_meta**\ (\ data\: :ref:`Variant<class_Variant>`\ )
+|void| **push_meta**\ (\ data\: :ref:`Variant<class_Variant>`, underline_mode\: :ref:`MetaUnderline<enum_RichTextLabel_MetaUnderline>` = 1\ )
 
 Adds a meta tag to the tag stack. Similar to the BBCode ``[url=something]{text}[/url]``, but supports non-:ref:`String<class_String>` metadata types.
 
+If :ref:`meta_underlined<class_RichTextLabel_property_meta_underlined>` is ``true``, meta tags display an underline. This behavior can be customized with ``underline_mode``.
+
+\ **Note:** Meta tags do nothing by default when clicked. To assign behavior when clicked, connect :ref:`meta_clicked<class_RichTextLabel_signal_meta_clicked>` to a function that is called when the meta tag is clicked.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -1907,7 +1960,7 @@ The default text color.
 
 .. rst-class:: classref-themeproperty
 
-:ref:`Color<class_Color>` **font_outline_color** = ``Color(1, 1, 1, 1)``
+:ref:`Color<class_Color>` **font_outline_color** = ``Color(0, 0, 0, 1)``
 
 The default tint of text outline.
 

classes/class_scenetree.rst

@@ -19,11 +19,11 @@ Manages the game loop via a hierarchy of nodes.
 Description
 -----------
 
-As one of the most important classes, the **SceneTree** manages the hierarchy of nodes in a scene as well as scenes themselves. Nodes can be added, retrieved and removed. The whole scene tree (and thus the current scene) can be paused. Scenes can be loaded, switched and reloaded.
+As one of the most important classes, the **SceneTree** manages the hierarchy of nodes in a scene, as well as scenes themselves. Nodes can be added, fetched and removed. The whole scene tree (and thus the current scene) can be paused. Scenes can be loaded, switched and reloaded.
 
-You can also use the **SceneTree** to organize your nodes into groups: every node can be assigned as many groups as you want to create, e.g. an "enemy" group. You can then iterate these groups or even call methods and set properties on all the group's members at once.
+You can also use the **SceneTree** to organize your nodes into **groups**: every node can be added to as many groups as you want to create, e.g. an "enemy" group. You can then iterate these groups or even call methods and set properties on all the nodes belonging to any given group.
 
-\ **SceneTree** is the default :ref:`MainLoop<class_MainLoop>` implementation used by scenes, and is thus in charge of the game loop.
+\ **SceneTree** is the default :ref:`MainLoop<class_MainLoop>` implementation used by the engine, and is thus in charge of the game loop.
 
 .. rst-class:: classref-introduction-group
 
@@ -135,7 +135,7 @@ Signals
 
 **node_added**\ (\ node\: :ref:`Node<class_Node>`\ )
 
-Emitted whenever a node is added to the **SceneTree**.
+Emitted when the ``node`` enters this tree.
 
 .. rst-class:: classref-item-separator
 
@@ -147,7 +147,7 @@ Emitted whenever a node is added to the **SceneTree**.
 
 **node_configuration_warning_changed**\ (\ node\: :ref:`Node<class_Node>`\ )
 
-Emitted when a node's configuration changed. Only emitted in ``tool`` mode.
+Emitted when the ``node``'s :ref:`Node.update_configuration_warnings<class_Node_method_update_configuration_warnings>` is called. Only emitted in the editor.
 
 .. rst-class:: classref-item-separator
 
@@ -159,7 +159,7 @@ Emitted when a node's configuration changed. Only emitted in ``tool`` mode.
 
 **node_removed**\ (\ node\: :ref:`Node<class_Node>`\ )
 
-Emitted whenever a node is removed from the **SceneTree**.
+Emitted when the ``node`` exits this tree.
 
 .. rst-class:: classref-item-separator
 
@@ -171,7 +171,7 @@ Emitted whenever a node is removed from the **SceneTree**.
 
 **node_renamed**\ (\ node\: :ref:`Node<class_Node>`\ )
 
-Emitted whenever a node is renamed.
+Emitted when the ``node``'s :ref:`Node.name<class_Node_property_name>` is changed.
 
 .. rst-class:: classref-item-separator
 
@@ -183,7 +183,7 @@ Emitted whenever a node is renamed.
 
 **physics_frame**\ (\ )
 
-Emitted immediately before :ref:`Node._physics_process<class_Node_private_method__physics_process>` is called on every node in the **SceneTree**.
+Emitted immediately before :ref:`Node._physics_process<class_Node_private_method__physics_process>` is called on every node in this tree.
 
 .. rst-class:: classref-item-separator
 
@@ -195,7 +195,7 @@ Emitted immediately before :ref:`Node._physics_process<class_Node_private_method
 
 **process_frame**\ (\ )
 
-Emitted immediately before :ref:`Node._process<class_Node_private_method__process>` is called on every node in the **SceneTree**.
+Emitted immediately before :ref:`Node._process<class_Node_private_method__process>` is called on every node in this tree.
 
 .. rst-class:: classref-item-separator
 
@@ -207,7 +207,7 @@ Emitted immediately before :ref:`Node._process<class_Node_private_method__proces
 
 **tree_changed**\ (\ )
 
-Emitted whenever the **SceneTree** hierarchy changed (children being moved or renamed, etc.).
+Emitted any time the tree's hierarchy changes (nodes being moved, renamed, etc).
 
 .. rst-class:: classref-item-separator
 
@@ -219,7 +219,7 @@ Emitted whenever the **SceneTree** hierarchy changed (children being moved or re
 
 **tree_process_mode_changed**\ (\ )
 
-This signal is only emitted in the editor, it allows the editor to update the visibility of disabled nodes. Emitted whenever any node's :ref:`Node.process_mode<class_Node_property_process_mode>` is changed.
+Emitted when the :ref:`Node.process_mode<class_Node_property_process_mode>` of any node inside the tree is changed. Only emitted in the editor, to update the visibility of disabled nodes.
 
 .. rst-class:: classref-section-separator
 
@@ -242,7 +242,7 @@ enum **GroupCallFlags**:
 
 :ref:`GroupCallFlags<enum_SceneTree_GroupCallFlags>` **GROUP_CALL_DEFAULT** = ``0``
 
-Call a group with no flags (default).
+Call nodes within a group with no special behavior (default).
 
 .. _class_SceneTree_constant_GROUP_CALL_REVERSE:
 
@@ -250,7 +250,7 @@ Call a group with no flags (default).
 
 :ref:`GroupCallFlags<enum_SceneTree_GroupCallFlags>` **GROUP_CALL_REVERSE** = ``1``
 
-Call a group in reverse scene order.
+Call nodes within a group in reverse tree hierarchy order (all nested children are called before their respective parent nodes).
 
 .. _class_SceneTree_constant_GROUP_CALL_DEFERRED:
 
@@ -258,7 +258,7 @@ Call a group in reverse scene order.
 
 :ref:`GroupCallFlags<enum_SceneTree_GroupCallFlags>` **GROUP_CALL_DEFERRED** = ``2``
 
-Call a group at the end of the current frame (process or physics).
+Call nodes within a group at the end of the current frame (can be either process or physics frame), similar to :ref:`Object.call_deferred<class_Object_method_call_deferred>`.
 
 .. _class_SceneTree_constant_GROUP_CALL_UNIQUE:
 
@@ -266,9 +266,9 @@ Call a group at the end of the current frame (process or physics).
 
 :ref:`GroupCallFlags<enum_SceneTree_GroupCallFlags>` **GROUP_CALL_UNIQUE** = ``4``
 
-Call a group only once even if the call is executed many times.
+Call nodes within a group only once, even if the call is executed many times in the same frame. Must be combined with :ref:`GROUP_CALL_DEFERRED<class_SceneTree_constant_GROUP_CALL_DEFERRED>` to work.
 
-\ **Note:** Arguments are not taken into account when deciding whether the call is unique or not. Therefore when the same method is called with different arguments, only the first call will be performed.
+\ **Note:** Different arguments are not taken into account. Therefore, when the same call is executed with different arguments, only the first call will be performed.
 
 .. rst-class:: classref-section-separator
 
@@ -309,9 +309,9 @@ For mobile platforms, see :ref:`quit_on_go_back<class_SceneTree_property_quit_on
 - |void| **set_current_scene**\ (\ value\: :ref:`Node<class_Node>`\ )
 - :ref:`Node<class_Node>` **get_current_scene**\ (\ )
 
-Returns the root node of the currently running scene, regardless of its structure.
+The root node of the currently loaded main scene, usually as a direct child of :ref:`root<class_SceneTree_property_root>`. See also :ref:`change_scene_to_file<class_SceneTree_method_change_scene_to_file>`, :ref:`change_scene_to_packed<class_SceneTree_method_change_scene_to_packed>`, and :ref:`reload_current_scene<class_SceneTree_method_reload_current_scene>`.
 
-\ **Warning:** Setting this directly might not work as expected, and will *not* add or remove any nodes from the tree, consider using :ref:`change_scene_to_file<class_SceneTree_method_change_scene_to_file>` or :ref:`change_scene_to_packed<class_SceneTree_method_change_scene_to_packed>` instead.
+\ **Warning:** Setting this property directly may not work as expected, as it does *not* add or remove any nodes from this tree.
 
 .. rst-class:: classref-item-separator
 
@@ -385,7 +385,9 @@ If ``true``, curves from :ref:`Path2D<class_Path2D>` and :ref:`Path3D<class_Path
 - |void| **set_edited_scene_root**\ (\ value\: :ref:`Node<class_Node>`\ )
 - :ref:`Node<class_Node>` **get_edited_scene_root**\ (\ )
 
-The root of the edited scene.
+The root of the scene currently being edited in the editor. This is usually a direct child of :ref:`root<class_SceneTree_property_root>`.
+
+\ **Note:** This property does nothing in release builds.
 
 .. rst-class:: classref-item-separator
 
@@ -421,11 +423,11 @@ If ``false``, you need to manually call :ref:`MultiplayerAPI.poll<class_Multipla
 - |void| **set_pause**\ (\ value\: :ref:`bool<class_bool>`\ )
 - :ref:`bool<class_bool>` **is_paused**\ (\ )
 
-If ``true``, the **SceneTree** is paused. Doing so will have the following behavior:
+If ``true``, the scene tree is considered paused. This causes the following behavior:
 
-- 2D and 3D physics will be stopped. This includes signals and collision detection.
+- 2D and 3D physics will be stopped, as well as collision detection and related signals.
 
-- :ref:`Node._process<class_Node_private_method__process>`, :ref:`Node._physics_process<class_Node_private_method__physics_process>` and :ref:`Node._input<class_Node_private_method__input>` will not be called anymore in nodes.
+- Depending on each node's :ref:`Node.process_mode<class_Node_property_process_mode>`, their :ref:`Node._process<class_Node_private_method__process>`, :ref:`Node._physics_process<class_Node_private_method__physics_process>` and :ref:`Node._input<class_Node_private_method__input>` callback methods may not called anymore.
 
 .. rst-class:: classref-item-separator
 
@@ -460,7 +462,9 @@ To handle 'Go Back' button when this option is disabled, use :ref:`DisplayServer
 
 - :ref:`Window<class_Window>` **get_root**\ (\ )
 
-The **SceneTree**'s root :ref:`Window<class_Window>`.
+The tree's root :ref:`Window<class_Window>`. This is top-most :ref:`Node<class_Node>` of the scene tree, and is always present. An absolute :ref:`NodePath<class_NodePath>` always starts from this node. Children of the root node may include the loaded :ref:`current_scene<class_SceneTree_property_current_scene>`, as well as any :doc:`AutoLoad <../tutorials/scripting/singletons_autoload>` configured in the Project Settings.
+
+\ **Warning:** Do not delete this node. This will result in unstable behavior, followed by a crash.
 
 .. rst-class:: classref-section-separator
 
@@ -477,9 +481,11 @@ Method Descriptions
 
 |void| **call_group**\ (\ group\: :ref:`StringName<class_StringName>`, method\: :ref:`StringName<class_StringName>`, ...\ ) |vararg|
 
-Calls ``method`` on each member of the given group. You can pass arguments to ``method`` by specifying them at the end of the method call. If a node doesn't have the given method or the argument list does not match (either in count or in types), it will be skipped.
+Calls ``method`` on each node inside this tree added to the given ``group``. You can pass arguments to ``method`` by specifying them at the end of this method call. Nodes that cannot call ``method`` (either because the method doesn't exist or the arguments do not match) are ignored. See also :ref:`set_group<class_SceneTree_method_set_group>` and :ref:`notify_group<class_SceneTree_method_notify_group>`.
 
-\ **Note:** :ref:`call_group<class_SceneTree_method_call_group>` will call methods immediately on all members at once, which can cause stuttering if an expensive method is called on lots of members.
+\ **Note:** This method acts immediately on all selected nodes at once, which may cause stuttering in some performance-intensive situations.
+
+\ **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.
 
 .. rst-class:: classref-item-separator
 
@@ -491,14 +497,16 @@ Calls ``method`` on each member of the given group. You can pass arguments to ``
 
 |void| **call_group_flags**\ (\ flags\: :ref:`int<class_int>`, group\: :ref:`StringName<class_StringName>`, method\: :ref:`StringName<class_StringName>`, ...\ ) |vararg|
 
-Calls ``method`` on each member of the given group, respecting the given :ref:`GroupCallFlags<enum_SceneTree_GroupCallFlags>`. You can pass arguments to ``method`` by specifying them at the end of the method call. If a node doesn't have the given method or the argument list does not match (either in count or in types), it will be skipped.
+Calls the given ``method`` on each node inside this tree added to the given ``group``. Use ``flags`` to customize this method's behavior (see :ref:`GroupCallFlags<enum_SceneTree_GroupCallFlags>`). Additional arguments for ``method`` can be passed at the end of this method. Nodes that cannot call ``method`` (either because the method doesn't exist or the arguments do not match) are ignored.
 
 ::
 
-    # Call the method in a deferred manner and in reverse order.
-    get_tree().call_group_flags(SceneTree.GROUP_CALL_DEFERRED | SceneTree.GROUP_CALL_REVERSE)
+    # Calls "hide" to all nodes of the "enemies" group, at the end of the frame and in reverse tree order.
+    get_tree().call_group_flags(
+            SceneTree.GROUP_CALL_DEFERRED | SceneTree.GROUP_CALL_REVERSE,
+            "enemies", "hide")
 
-\ **Note:** Group call flags are used to control the method calling behavior. By default, methods will be called immediately in a way similar to :ref:`call_group<class_SceneTree_method_call_group>`. However, if the :ref:`GROUP_CALL_DEFERRED<class_SceneTree_constant_GROUP_CALL_DEFERRED>` flag is present in the ``flags`` argument, methods will be called at the end of the frame in a way similar to :ref:`Object.set_deferred<class_Object_method_set_deferred>`.
+\ **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.
 
 .. rst-class:: classref-item-separator
 
@@ -548,15 +556,15 @@ This ensures that both scenes aren't running at the same time, while still freei
 
 :ref:`SceneTreeTimer<class_SceneTreeTimer>` **create_timer**\ (\ time_sec\: :ref:`float<class_float>`, process_always\: :ref:`bool<class_bool>` = true, process_in_physics\: :ref:`bool<class_bool>` = false, ignore_time_scale\: :ref:`bool<class_bool>` = false\ )
 
-Returns a :ref:`SceneTreeTimer<class_SceneTreeTimer>` which will emit :ref:`SceneTreeTimer.timeout<class_SceneTreeTimer_signal_timeout>` after the given time in seconds elapsed in this **SceneTree**.
+Returns a new :ref:`SceneTreeTimer<class_SceneTreeTimer>`. After ``time_sec`` in seconds have passed, the timer will emit :ref:`SceneTreeTimer.timeout<class_SceneTreeTimer_signal_timeout>` and will be automatically freed.
 
-If ``process_always`` is set to ``false``, pausing the **SceneTree** will also pause the timer.
+If ``process_always`` is ``false``, the timer will be paused when setting :ref:`paused<class_SceneTree_property_paused>` to ``true``.
 
-If ``process_in_physics`` is set to ``true``, will update the :ref:`SceneTreeTimer<class_SceneTreeTimer>` during the physics frame instead of the process frame (fixed framerate processing).
+If ``process_in_physics`` is ``true``, the timer will update at the end of the physics frame, instead of the process frame.
 
-If ``ignore_time_scale`` is set to ``true``, will ignore :ref:`Engine.time_scale<class_Engine_property_time_scale>` and update the :ref:`SceneTreeTimer<class_SceneTreeTimer>` with the actual frame delta.
+If ``ignore_time_scale`` is ``true``, the timer will ignore :ref:`Engine.time_scale<class_Engine_property_time_scale>` and update with the real, elapsed time.
 
-Commonly used to create a one-shot delay timer as in the following example:
+This method is commonly used to create a one-shot delay timer, as in the following example:
 
 
 .. tabs::
@@ -579,9 +587,7 @@ Commonly used to create a one-shot delay timer as in the following example:
 
 
 
-The timer will be automatically freed after its time elapses.
-
-\ **Note:** The timer is processed after all of the nodes in the current frame, i.e. node's :ref:`Node._process<class_Node_private_method__process>` method would be called before the timer (or :ref:`Node._physics_process<class_Node_private_method__physics_process>` if ``process_in_physics`` is set to ``true``).
+\ **Note:** The timer is always updated *after* all of the nodes in the tree. A node's :ref:`Node._process<class_Node_private_method__process>` method would be called before the timer updates (or :ref:`Node._physics_process<class_Node_private_method__physics_process>` if ``process_in_physics`` is set to ``true``).
 
 .. rst-class:: classref-item-separator
 
@@ -593,9 +599,9 @@ The timer will be automatically freed after its time elapses.
 
 :ref:`Tween<class_Tween>` **create_tween**\ (\ )
 
-Creates and returns a new :ref:`Tween<class_Tween>`. The Tween will start automatically on the next process frame or physics frame (depending on :ref:`TweenProcessMode<enum_Tween_TweenProcessMode>`).
+Creates and returns a new :ref:`Tween<class_Tween>` processed in this tree. The Tween will start automatically on the next process frame or physics frame (depending on its :ref:`TweenProcessMode<enum_Tween_TweenProcessMode>`).
 
-\ **Note:** When creating a :ref:`Tween<class_Tween>` using this method, the :ref:`Tween<class_Tween>` will not be tied to the :ref:`Node<class_Node>` that called it. It will continue to animate even if the :ref:`Node<class_Node>` is freed, but it will automatically finish if there's nothing left to animate. If you want the :ref:`Tween<class_Tween>` to be automatically killed when the :ref:`Node<class_Node>` is freed, use :ref:`Node.create_tween<class_Node_method_create_tween>` or :ref:`Tween.bind_node<class_Tween_method_bind_node>`.
+\ **Note:** A :ref:`Tween<class_Tween>` created using this method is not bound to any :ref:`Node<class_Node>`. It may keep working until there is nothing left to animate. If you want the :ref:`Tween<class_Tween>` to be automatically killed when the :ref:`Node<class_Node>` is freed, use :ref:`Node.create_tween<class_Node_method_create_tween>` or :ref:`Tween.bind_node<class_Tween_method_bind_node>`.
 
 .. rst-class:: classref-item-separator
 
@@ -607,7 +613,7 @@ Creates and returns a new :ref:`Tween<class_Tween>`. The Tween will start automa
 
 :ref:`Node<class_Node>` **get_first_node_in_group**\ (\ group\: :ref:`StringName<class_StringName>`\ )
 
-Returns the first node in the specified group, or ``null`` if the group is empty or does not exist.
+Returns the first :ref:`Node<class_Node>` found inside the tree, that has been added to the given ``group``, in scene hierarchy order. Returns ``null`` if no match is found. See also :ref:`get_nodes_in_group<class_SceneTree_method_get_nodes_in_group>`.
 
 .. rst-class:: classref-item-separator
 
@@ -619,7 +625,7 @@ Returns the first node in the specified group, or ``null`` if the group is empty
 
 :ref:`int<class_int>` **get_frame**\ (\ ) |const|
 
-Returns the current frame number, i.e. the total frame count since the application started.
+Returns how many frames have been processed, since the application started. This is *not* a measurement of elapsed time.
 
 .. rst-class:: classref-item-separator
 
@@ -643,7 +649,7 @@ Searches for the :ref:`MultiplayerAPI<class_MultiplayerAPI>` configured for the
 
 :ref:`int<class_int>` **get_node_count**\ (\ ) |const|
 
-Returns the number of nodes in this **SceneTree**.
+Returns the number of nodes inside this tree.
 
 .. rst-class:: classref-item-separator
 
@@ -667,7 +673,7 @@ Returns the number of nodes assigned to the given group.
 
 :ref:`Array<class_Array>`\[:ref:`Node<class_Node>`\] **get_nodes_in_group**\ (\ group\: :ref:`StringName<class_StringName>`\ )
 
-Returns a list of all nodes assigned to the given group.
+Returns an :ref:`Array<class_Array>` containing all nodes inside this tree, that have been added to the given ``group``, in scene hierarchy order.
 
 .. rst-class:: classref-item-separator
 
@@ -679,7 +685,7 @@ Returns a list of all nodes assigned to the given group.
 
 :ref:`Array<class_Array>`\[:ref:`Tween<class_Tween>`\] **get_processed_tweens**\ (\ )
 
-Returns an array of currently existing :ref:`Tween<class_Tween>`\ s in the **SceneTree** (both running and paused).
+Returns an :ref:`Array<class_Array>` of currently existing :ref:`Tween<class_Tween>`\ s in the tree, including paused tweens.
 
 .. rst-class:: classref-item-separator
 
@@ -691,9 +697,7 @@ Returns an array of currently existing :ref:`Tween<class_Tween>`\ s in the **Sce
 
 :ref:`bool<class_bool>` **has_group**\ (\ name\: :ref:`StringName<class_StringName>`\ ) |const|
 
-Returns ``true`` if the given group exists.
-
-A group exists if any :ref:`Node<class_Node>` in the tree belongs to it (see :ref:`Node.add_to_group<class_Node_method_add_to_group>`). Groups without nodes are removed automatically.
+Returns ``true`` if a node added to the given group ``name`` exists in the tree.
 
 .. rst-class:: classref-item-separator
 
@@ -705,9 +709,9 @@ A group exists if any :ref:`Node<class_Node>` in the tree belongs to it (see :re
 
 |void| **notify_group**\ (\ group\: :ref:`StringName<class_StringName>`, notification\: :ref:`int<class_int>`\ )
 
-Sends the given notification to all members of the ``group``.
+Calls :ref:`Object.notification<class_Object_method_notification>` with the given ``notification`` to all nodes inside this tree added to the ``group``. See also :ref:`call_group<class_SceneTree_method_call_group>` and :ref:`set_group<class_SceneTree_method_set_group>`.
 
-\ **Note:** :ref:`notify_group<class_SceneTree_method_notify_group>` will immediately notify all members at once, which can cause stuttering if an expensive method is called as a result of sending the notification to lots of members.
+\ **Note:** This method acts immediately on all selected nodes at once, which may cause stuttering in some performance-intensive situations.
 
 .. rst-class:: classref-item-separator
 
@@ -719,9 +723,7 @@ Sends the given notification to all members of the ``group``.
 
 |void| **notify_group_flags**\ (\ call_flags\: :ref:`int<class_int>`, group\: :ref:`StringName<class_StringName>`, notification\: :ref:`int<class_int>`\ )
 
-Sends the given notification to all members of the ``group``, respecting the given :ref:`GroupCallFlags<enum_SceneTree_GroupCallFlags>`.
-
-\ **Note:** Group call flags are used to control the notification sending behavior. By default, notifications will be sent immediately in a way similar to :ref:`notify_group<class_SceneTree_method_notify_group>`. However, if the :ref:`GROUP_CALL_DEFERRED<class_SceneTree_constant_GROUP_CALL_DEFERRED>` flag is present in the ``call_flags`` argument, notifications will be sent at the end of the current frame in a way similar to using ``Object.call_deferred("notification", ...)``.
+Calls :ref:`Object.notification<class_Object_method_notification>` with the given ``notification`` to all nodes inside this tree added to the ``group``. Use ``call_flags`` to customize this method's behavior (see :ref:`GroupCallFlags<enum_SceneTree_GroupCallFlags>`).
 
 .. rst-class:: classref-item-separator
 
@@ -733,7 +735,7 @@ Sends the given notification to all members of the ``group``, respecting the giv
 
 |void| **queue_delete**\ (\ obj\: :ref:`Object<class_Object>`\ )
 
-Queues the given object for deletion, delaying the call to :ref:`Object.free<class_Object_method_free>` to the end of the current frame.
+Queues the given ``obj`` to be deleted, calling its :ref:`Object.free<class_Object_method_free>` at the end of the current frame. This method is similar to :ref:`Node.queue_free<class_Node_method_queue_free>`.
 
 .. rst-class:: classref-item-separator
 
@@ -745,13 +747,11 @@ Queues the given object for deletion, delaying the call to :ref:`Object.free<cla
 
 |void| **quit**\ (\ exit_code\: :ref:`int<class_int>` = 0\ )
 
-Quits the application at the end of the current iteration. Argument ``exit_code`` can optionally be given (defaulting to 0) to customize the exit status code.
+Quits the application at the end of the current iteration, with the given ``exit_code``.
 
-By convention, an exit code of ``0`` indicates success whereas a non-zero exit code indicates an error.
+By convention, an exit code of ``0`` indicates success, whereas any other exit code indicates an error. For portability reasons, it should be between ``0`` and ``125`` (inclusive).
 
-For portability reasons, the exit code should be set between 0 and 125 (inclusive).
-
-\ **Note:** On iOS this method doesn't work. Instead, as recommended by the iOS Human Interface Guidelines, the user is expected to close apps via the Home button.
+\ **Note:** On iOS this method doesn't work. Instead, as recommended by the `iOS Human Interface Guidelines <https://developer.apple.com/library/archive/qa/qa1561/_index.html>`__, the user is expected to close apps via the Home button.
 
 .. rst-class:: classref-item-separator
 
@@ -763,9 +763,9 @@ For portability reasons, the exit code should be set between 0 and 125 (inclusiv
 
 :ref:`Error<enum_@GlobalScope_Error>` **reload_current_scene**\ (\ )
 
-Reloads the currently active scene.
+Reloads the currently active scene, replacing :ref:`current_scene<class_SceneTree_property_current_scene>` with a new instance of its original :ref:`PackedScene<class_PackedScene>`.
 
-Returns :ref:`@GlobalScope.OK<class_@GlobalScope_constant_OK>` on success, :ref:`@GlobalScope.ERR_UNCONFIGURED<class_@GlobalScope_constant_ERR_UNCONFIGURED>` if no :ref:`current_scene<class_SceneTree_property_current_scene>` was defined yet, :ref:`@GlobalScope.ERR_CANT_OPEN<class_@GlobalScope_constant_ERR_CANT_OPEN>` if :ref:`current_scene<class_SceneTree_property_current_scene>` cannot be loaded into a :ref:`PackedScene<class_PackedScene>`, or :ref:`@GlobalScope.ERR_CANT_CREATE<class_@GlobalScope_constant_ERR_CANT_CREATE>` if the scene cannot be instantiated.
+Returns :ref:`@GlobalScope.OK<class_@GlobalScope_constant_OK>` on success, :ref:`@GlobalScope.ERR_UNCONFIGURED<class_@GlobalScope_constant_ERR_UNCONFIGURED>` if no :ref:`current_scene<class_SceneTree_property_current_scene>` is defined, :ref:`@GlobalScope.ERR_CANT_OPEN<class_@GlobalScope_constant_ERR_CANT_OPEN>` if :ref:`current_scene<class_SceneTree_property_current_scene>` cannot be loaded into a :ref:`PackedScene<class_PackedScene>`, or :ref:`@GlobalScope.ERR_CANT_CREATE<class_@GlobalScope_constant_ERR_CANT_CREATE>` if the scene cannot be instantiated.
 
 .. rst-class:: classref-item-separator
 
@@ -777,9 +777,11 @@ Returns :ref:`@GlobalScope.OK<class_@GlobalScope_constant_OK>` on success, :ref:
 
 |void| **set_group**\ (\ group\: :ref:`StringName<class_StringName>`, property\: :ref:`String<class_String>`, value\: :ref:`Variant<class_Variant>`\ )
 
-Sets the given ``property`` to ``value`` on all members of the given group.
+Sets the given ``property`` to ``value`` on all nodes inside this tree added to the given ``group``. Nodes that do not have the ``property`` are ignored. See also :ref:`call_group<class_SceneTree_method_call_group>` and :ref:`notify_group<class_SceneTree_method_notify_group>`.
+
+\ **Note:** This method acts immediately on all selected nodes at once, which may cause stuttering in some performance-intensive situations.
 
-\ **Note:** :ref:`set_group<class_SceneTree_method_set_group>` will set the property immediately on all members at once, which can cause stuttering if a property with an expensive setter is set on lots of members.
+\ **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.
 
 .. rst-class:: classref-item-separator
 
@@ -791,9 +793,9 @@ Sets the given ``property`` to ``value`` on all members of the given group.
 
 |void| **set_group_flags**\ (\ call_flags\: :ref:`int<class_int>`, group\: :ref:`StringName<class_StringName>`, property\: :ref:`String<class_String>`, value\: :ref:`Variant<class_Variant>`\ )
 
-Sets the given ``property`` to ``value`` on all members of the given group, respecting the given :ref:`GroupCallFlags<enum_SceneTree_GroupCallFlags>`.
+Sets the given ``property`` to ``value`` on all nodes inside this tree added to the given ``group``. Nodes that do not have the ``property`` are ignored. Use ``call_flags`` to customize this method's behavior (see :ref:`GroupCallFlags<enum_SceneTree_GroupCallFlags>`).
 
-\ **Note:** Group call flags are used to control the property setting behavior. By default, properties will be set immediately in a way similar to :ref:`set_group<class_SceneTree_method_set_group>`. However, if the :ref:`GROUP_CALL_DEFERRED<class_SceneTree_constant_GROUP_CALL_DEFERRED>` flag is present in the ``call_flags`` argument, properties will be set at the end of the frame in a way similar to :ref:`Object.call_deferred<class_Object_method_call_deferred>`.
+\ **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.
 
 .. rst-class:: classref-item-separator
 

classes/class_skeleton3d.rst

@@ -59,7 +59,7 @@ Methods
    :widths: auto
 
    +-------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-   | |void|                                          | :ref:`add_bone<class_Skeleton3D_method_add_bone>`\ (\ name\: :ref:`String<class_String>`\ )                                                                                                                                                                         |
+   | :ref:`int<class_int>`                           | :ref:`add_bone<class_Skeleton3D_method_add_bone>`\ (\ name\: :ref:`String<class_String>`\ )                                                                                                                                                                         |
    +-------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | |void|                                          | :ref:`clear_bones<class_Skeleton3D_method_clear_bones>`\ (\ )                                                                                                                                                                                                       |
    +-------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -285,9 +285,11 @@ Method Descriptions
 
 .. rst-class:: classref-method
 
-|void| **add_bone**\ (\ name\: :ref:`String<class_String>`\ )
+:ref:`int<class_int>` **add_bone**\ (\ name\: :ref:`String<class_String>`\ )
 
-Adds a bone, with name ``name``. :ref:`get_bone_count<class_Skeleton3D_method_get_bone_count>` will become the bone index.
+Adds a new bone with the given name. Returns the new bone's index, or ``-1`` if this method fails.
+
+\ **Note:** Bone names should be unique, non empty, and cannot include the ``:`` and ``/`` characters.
 
 .. rst-class:: classref-item-separator
 
@@ -375,7 +377,7 @@ Force updates the bone transform for the bone at ``bone_idx`` and all of its chi
 
 :ref:`PackedInt32Array<class_PackedInt32Array>` **get_bone_children**\ (\ bone_idx\: :ref:`int<class_int>`\ ) |const|
 
-Returns an array containing the bone indexes of all the children node of the passed in bone, ``bone_idx``.
+Returns an array containing the bone indexes of all the child node of the passed in bone, ``bone_idx``.
 
 .. rst-class:: classref-item-separator
 

classes/class_string.rst

@@ -1355,8 +1355,8 @@ Converts the given ``number`` to a string representation, in scientific notation
  .. code-tab:: gdscript
 
     var n = -5.2e8
-    print(n)                       # Prints -520000000
-    print(String.NumScientific(n)) # Prints -5.2e+08
+    print(n)                        # Prints -520000000
+    print(String.num_scientific(n)) # Prints -5.2e+08
 
  .. code-tab:: csharp
 

classes/class_tabbar.rst

@@ -142,7 +142,7 @@ Theme Properties
    +-----------------------------------+------------------------------------------------------------------------------+-------------------------------------+
    | :ref:`Color<class_Color>`         | :ref:`font_hovered_color<class_TabBar_theme_color_font_hovered_color>`       | ``Color(0.95, 0.95, 0.95, 1)``      |
    +-----------------------------------+------------------------------------------------------------------------------+-------------------------------------+
-   | :ref:`Color<class_Color>`         | :ref:`font_outline_color<class_TabBar_theme_color_font_outline_color>`       | ``Color(1, 1, 1, 1)``               |
+   | :ref:`Color<class_Color>`         | :ref:`font_outline_color<class_TabBar_theme_color_font_outline_color>`       | ``Color(0, 0, 0, 1)``               |
    +-----------------------------------+------------------------------------------------------------------------------+-------------------------------------+
    | :ref:`Color<class_Color>`         | :ref:`font_selected_color<class_TabBar_theme_color_font_selected_color>`     | ``Color(0.95, 0.95, 0.95, 1)``      |
    +-----------------------------------+------------------------------------------------------------------------------+-------------------------------------+
@@ -1015,7 +1015,7 @@ Font color of the currently hovered tab. Does not apply to the selected tab.
 
 .. rst-class:: classref-themeproperty
 
-:ref:`Color<class_Color>` **font_outline_color** = ``Color(1, 1, 1, 1)``
+:ref:`Color<class_Color>` **font_outline_color** = ``Color(0, 0, 0, 1)``
 
 The tint of text outline of the tab name.
 

classes/class_tabcontainer.rst

@@ -133,7 +133,7 @@ Theme Properties
    +-----------------------------------+------------------------------------------------------------------------------------+-------------------------------------+
    | :ref:`Color<class_Color>`         | :ref:`font_hovered_color<class_TabContainer_theme_color_font_hovered_color>`       | ``Color(0.95, 0.95, 0.95, 1)``      |
    +-----------------------------------+------------------------------------------------------------------------------------+-------------------------------------+
-   | :ref:`Color<class_Color>`         | :ref:`font_outline_color<class_TabContainer_theme_color_font_outline_color>`       | ``Color(1, 1, 1, 1)``               |
+   | :ref:`Color<class_Color>`         | :ref:`font_outline_color<class_TabContainer_theme_color_font_outline_color>`       | ``Color(0, 0, 0, 1)``               |
    +-----------------------------------+------------------------------------------------------------------------------------+-------------------------------------+
    | :ref:`Color<class_Color>`         | :ref:`font_selected_color<class_TabContainer_theme_color_font_selected_color>`     | ``Color(0.95, 0.95, 0.95, 1)``      |
    +-----------------------------------+------------------------------------------------------------------------------------+-------------------------------------+
@@ -504,7 +504,7 @@ If ``true``, tabs are visible. If ``false``, tabs' content and titles are hidden
 - |void| **set_use_hidden_tabs_for_min_size**\ (\ value\: :ref:`bool<class_bool>`\ )
 - :ref:`bool<class_bool>` **get_use_hidden_tabs_for_min_size**\ (\ )
 
-If ``true``, children :ref:`Control<class_Control>` nodes that are hidden have their minimum size take into account in the total, instead of only the currently visible one.
+If ``true``, child :ref:`Control<class_Control>` nodes that are hidden have their minimum size take into account in the total, instead of only the currently visible one.
 
 .. rst-class:: classref-section-separator
 
@@ -840,7 +840,7 @@ Font color of the currently hovered tab.
 
 .. rst-class:: classref-themeproperty
 
-:ref:`Color<class_Color>` **font_outline_color** = ``Color(1, 1, 1, 1)``
+:ref:`Color<class_Color>` **font_outline_color** = ``Color(0, 0, 0, 1)``
 
 The tint of text outline of the tab name.
 

classes/class_textedit.rst

@@ -429,7 +429,7 @@ Theme Properties
    +-----------------------------------+------------------------------------------------------------------------------------------+-------------------------------------+
    | :ref:`Color<class_Color>`         | :ref:`font_color<class_TextEdit_theme_color_font_color>`                                 | ``Color(0.875, 0.875, 0.875, 1)``   |
    +-----------------------------------+------------------------------------------------------------------------------------------+-------------------------------------+
-   | :ref:`Color<class_Color>`         | :ref:`font_outline_color<class_TextEdit_theme_color_font_outline_color>`                 | ``Color(1, 1, 1, 1)``               |
+   | :ref:`Color<class_Color>`         | :ref:`font_outline_color<class_TextEdit_theme_color_font_outline_color>`                 | ``Color(0, 0, 0, 1)``               |
    +-----------------------------------+------------------------------------------------------------------------------------------+-------------------------------------+
    | :ref:`Color<class_Color>`         | :ref:`font_placeholder_color<class_TextEdit_theme_color_font_placeholder_color>`         | ``Color(0.875, 0.875, 0.875, 0.6)`` |
    +-----------------------------------+------------------------------------------------------------------------------------------+-------------------------------------+
@@ -1014,7 +1014,7 @@ enum **GutterType**:
 
 :ref:`GutterType<enum_TextEdit_GutterType>` **GUTTER_TYPE_STRING** = ``0``
 
-Draw a string.
+When a gutter is set to string using :ref:`set_gutter_type<class_TextEdit_method_set_gutter_type>`, it is used to contain text set via the :ref:`set_line_gutter_text<class_TextEdit_method_set_line_gutter_text>` method.
 
 .. _class_TextEdit_constant_GUTTER_TYPE_ICON:
 
@@ -1022,7 +1022,7 @@ Draw a string.
 
 :ref:`GutterType<enum_TextEdit_GutterType>` **GUTTER_TYPE_ICON** = ``1``
 
-Draw an icon.
+When a gutter is set to icon using :ref:`set_gutter_type<class_TextEdit_method_set_gutter_type>`, it is used to contain an icon set via the :ref:`set_line_gutter_icon<class_TextEdit_method_set_line_gutter_icon>` method.
 
 .. _class_TextEdit_constant_GUTTER_TYPE_CUSTOM:
 
@@ -1030,7 +1030,7 @@ Draw an icon.
 
 :ref:`GutterType<enum_TextEdit_GutterType>` **GUTTER_TYPE_CUSTOM** = ``2``
 
-Custom draw.
+When a gutter is set to custom using :ref:`set_gutter_type<class_TextEdit_method_set_gutter_type>`, it is used to contain custom visuals controlled by a callback method set via the :ref:`set_gutter_custom_draw<class_TextEdit_method_set_gutter_custom_draw>` method.
 
 .. rst-class:: classref-section-separator
 
@@ -2111,7 +2111,7 @@ Returns the name of the gutter at the given index.
 
 :ref:`GutterType<enum_TextEdit_GutterType>` **get_gutter_type**\ (\ gutter\: :ref:`int<class_int>`\ ) |const|
 
-Returns the type of the gutter at the given index.
+Returns the type of the gutter at the given index. Gutters can contain icons, text, or custom visuals. See :ref:`GutterType<enum_TextEdit_GutterType>` for options.
 
 .. rst-class:: classref-item-separator
 
@@ -2243,7 +2243,7 @@ Returns the number of lines in the text.
 
 :ref:`Texture2D<class_Texture2D>` **get_line_gutter_icon**\ (\ line\: :ref:`int<class_int>`, gutter\: :ref:`int<class_int>`\ ) |const|
 
-Returns the icon currently in ``gutter`` at ``line``.
+Returns the icon currently in ``gutter`` at ``line``. This only works when the gutter type is :ref:`GUTTER_TYPE_ICON<class_TextEdit_constant_GUTTER_TYPE_ICON>` (see :ref:`set_gutter_type<class_TextEdit_method_set_gutter_type>`).
 
 .. rst-class:: classref-item-separator
 
@@ -2279,7 +2279,7 @@ Returns the metadata currently in ``gutter`` at ``line``.
 
 :ref:`String<class_String>` **get_line_gutter_text**\ (\ line\: :ref:`int<class_int>`, gutter\: :ref:`int<class_int>`\ ) |const|
 
-Returns the text currently in ``gutter`` at ``line``.
+Returns the text currently in ``gutter`` at ``line``. This only works when the gutter type is :ref:`GUTTER_TYPE_STRING<class_TextEdit_constant_GUTTER_TYPE_STRING>` (see :ref:`set_gutter_type<class_TextEdit_method_set_gutter_type>`).
 
 .. rst-class:: classref-item-separator
 
@@ -3169,7 +3169,7 @@ Sets the gutter as clickable. This will change the mouse cursor to a pointing ha
 
 |void| **set_gutter_custom_draw**\ (\ column\: :ref:`int<class_int>`, draw_callback\: :ref:`Callable<class_Callable>`\ )
 
-Set a custom draw method for the gutter. The callback method must take the following args: ``line: int, gutter: int, Area: Rect2``.
+Set a custom draw method for the gutter. The callback method must take the following args: ``line: int, gutter: int, Area: Rect2``. This only works when the gutter type is :ref:`GUTTER_TYPE_CUSTOM<class_TextEdit_constant_GUTTER_TYPE_CUSTOM>` (see :ref:`set_gutter_type<class_TextEdit_method_set_gutter_type>`).
 
 .. rst-class:: classref-item-separator
 
@@ -3217,7 +3217,7 @@ Sets the gutter to overwritable. See :ref:`merge_gutters<class_TextEdit_method_m
 
 |void| **set_gutter_type**\ (\ gutter\: :ref:`int<class_int>`, type\: :ref:`GutterType<enum_TextEdit_GutterType>`\ )
 
-Sets the type of gutter.
+Sets the type of gutter. Gutters can contain icons, text, or custom visuals. See :ref:`GutterType<enum_TextEdit_GutterType>` for options.
 
 .. rst-class:: classref-item-separator
 
@@ -3313,7 +3313,7 @@ If ``clickable`` is ``true``, makes the ``gutter`` on ``line`` clickable. See :r
 
 |void| **set_line_gutter_icon**\ (\ line\: :ref:`int<class_int>`, gutter\: :ref:`int<class_int>`, icon\: :ref:`Texture2D<class_Texture2D>`\ )
 
-Sets the icon for ``gutter`` on ``line`` to ``icon``.
+Sets the icon for ``gutter`` on ``line`` to ``icon``. This only works when the gutter type is :ref:`GUTTER_TYPE_ICON<class_TextEdit_constant_GUTTER_TYPE_ICON>` (see :ref:`set_gutter_type<class_TextEdit_method_set_gutter_type>`).
 
 .. rst-class:: classref-item-separator
 
@@ -3349,7 +3349,7 @@ Sets the metadata for ``gutter`` on ``line`` to ``metadata``.
 
 |void| **set_line_gutter_text**\ (\ line\: :ref:`int<class_int>`, gutter\: :ref:`int<class_int>`, text\: :ref:`String<class_String>`\ )
 
-Sets the text for ``gutter`` on ``line`` to ``text``.
+Sets the text for ``gutter`` on ``line`` to ``text``. This only works when the gutter type is :ref:`GUTTER_TYPE_STRING<class_TextEdit_constant_GUTTER_TYPE_STRING>` (see :ref:`set_gutter_type<class_TextEdit_method_set_gutter_type>`).
 
 .. rst-class:: classref-item-separator
 
@@ -3546,7 +3546,7 @@ Sets the font :ref:`Color<class_Color>`.
 
 .. rst-class:: classref-themeproperty
 
-:ref:`Color<class_Color>` **font_outline_color** = ``Color(1, 1, 1, 1)``
+:ref:`Color<class_Color>` **font_outline_color** = ``Color(0, 0, 0, 1)``
 
 The tint of text outline of the **TextEdit**.
 

classes/class_tilemap.rst

@@ -24,7 +24,7 @@ Description
 
 Node for 2D tile-based maps. Tilemaps use a :ref:`TileSet<class_TileSet>` which contain a list of tiles which are used to create grid-based maps. A TileMap may have several layers, layouting tiles on top of each other.
 
-For performance reasons, all TileMap updates are batched at the end of a frame. Notably, this means that scene tiles from a :ref:`TileSetScenesCollectionSource<class_TileSetScenesCollectionSource>` may be initialized after their parent.
+For performance reasons, all TileMap updates are batched at the end of a frame. Notably, this means that scene tiles from a :ref:`TileSetScenesCollectionSource<class_TileSetScenesCollectionSource>` may be initialized after their parent. This is only queued when inside the scene tree.
 
 To force an update earlier on, call :ref:`update_internals<class_TileMap_method_update_internals>`.
 

classes/class_tree.rst

@@ -197,7 +197,7 @@ Theme Properties
    +-----------------------------------+------------------------------------------------------------------------------------------+-------------------------------------+
    | :ref:`Color<class_Color>`         | :ref:`font_disabled_color<class_Tree_theme_color_font_disabled_color>`                   | ``Color(0.875, 0.875, 0.875, 0.5)`` |
    +-----------------------------------+------------------------------------------------------------------------------------------+-------------------------------------+
-   | :ref:`Color<class_Color>`         | :ref:`font_outline_color<class_Tree_theme_color_font_outline_color>`                     | ``Color(1, 1, 1, 1)``               |
+   | :ref:`Color<class_Color>`         | :ref:`font_outline_color<class_Tree_theme_color_font_outline_color>`                     | ``Color(0, 0, 0, 1)``               |
    +-----------------------------------+------------------------------------------------------------------------------------------+-------------------------------------+
    | :ref:`Color<class_Color>`         | :ref:`font_selected_color<class_Tree_theme_color_font_selected_color>`                   | ``Color(1, 1, 1, 1)``               |
    +-----------------------------------+------------------------------------------------------------------------------------------+-------------------------------------+
@@ -1368,7 +1368,7 @@ Text :ref:`Color<class_Color>` for a :ref:`TreeItem.CELL_MODE_CHECK<class_TreeIt
 
 .. rst-class:: classref-themeproperty
 
-:ref:`Color<class_Color>` **font_outline_color** = ``Color(1, 1, 1, 1)``
+:ref:`Color<class_Color>` **font_outline_color** = ``Color(0, 0, 0, 1)``
 
 The tint of text outline of the item.
 

classes/class_vector2.rst

@@ -832,7 +832,9 @@ Returns a vector composed of the :ref:`@GlobalScope.fposmod<class_@GlobalScope_m
 
 :ref:`Vector2<class_Vector2>` **project**\ (\ b\: :ref:`Vector2<class_Vector2>`\ ) |const|
 
-Returns the result of projecting the vector onto the given vector ``b``.
+Returns a new vector resulting from projecting this vector onto the given vector ``b``. The resulting new vector is parallel to ``b``. See also :ref:`slide<class_Vector2_method_slide>`.
+
+\ **Note:** If the vector ``b`` is a zero vector, the components of the resulting new vector will be :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>`.
 
 .. rst-class:: classref-item-separator
 
@@ -906,7 +908,9 @@ This method also handles interpolating the lengths if the input vectors have dif
 
 :ref:`Vector2<class_Vector2>` **slide**\ (\ n\: :ref:`Vector2<class_Vector2>`\ ) |const|
 
-Returns the result of sliding the vector along a plane defined by the given normal.
+Returns a new vector resulting from sliding this vector along a line with normal ``n``. The resulting new vector is perpendicular to ``n``, and is equivalent to this vector minus its projection on ``n``. See also :ref:`project<class_Vector2_method_project>`.
+
+\ **Note:** The vector ``n`` must be normalized. See also :ref:`normalized<class_Vector2_method_normalized>`.
 
 .. rst-class:: classref-item-separator
 

classes/class_vector3.rst

@@ -892,7 +892,9 @@ Returns a vector composed of the :ref:`@GlobalScope.fposmod<class_@GlobalScope_m
 
 :ref:`Vector3<class_Vector3>` **project**\ (\ b\: :ref:`Vector3<class_Vector3>`\ ) |const|
 
-Returns the result of projecting the vector onto the given vector ``b``.
+Returns a new vector resulting from projecting this vector onto the given vector ``b``. The resulting new vector is parallel to ``b``. See also :ref:`slide<class_Vector3_method_slide>`.
+
+\ **Note:** If the vector ``b`` is a zero vector, the components of the resulting new vector will be :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>`.
 
 .. rst-class:: classref-item-separator
 
@@ -978,7 +980,9 @@ This method also handles interpolating the lengths if the input vectors have dif
 
 :ref:`Vector3<class_Vector3>` **slide**\ (\ n\: :ref:`Vector3<class_Vector3>`\ ) |const|
 
-Returns a new vector slid along a plane defined by the given normal.
+Returns a new vector resulting from sliding this vector along a plane with normal ``n``. The resulting new vector is perpendicular to ``n``, and is equivalent to this vector minus its projection on ``n``. See also :ref:`project<class_Vector3_method_project>`.
+
+\ **Note:** The vector ``n`` must be normalized. See also :ref:`normalized<class_Vector3_method_normalized>`.
 
 .. rst-class:: classref-item-separator
 

classes/class_viewport.rst

@@ -21,7 +21,7 @@ Abstract base class for viewports. Encapsulates drawing and interaction with a g
 Description
 -----------
 
-A Viewport creates a different view into the screen, or a sub-view inside another viewport. Children 2D Nodes will display on it, and children Camera3D 3D nodes will render on it too.
+A **Viewport** creates a different view into the screen, or a sub-view inside another viewport. Child 2D nodes will display on it, and child Camera3D 3D nodes will render on it too.
 
 Optionally, a viewport can have its own 2D or 3D world, so it doesn't share what it draws with other viewports.
 
@@ -237,6 +237,8 @@ Signals
 
 Emitted when a Control node grabs keyboard focus.
 
+\ **Note:** A Control node losing focus doesn't cause this signal to be emitted.
+
 .. rst-class:: classref-item-separator
 
 ----

classes/class_window.rst

@@ -262,7 +262,7 @@ Theme Properties
    +-----------------------------------+--------------------------------------------------------------------------------------+-----------------------------------+
    | :ref:`Color<class_Color>`         | :ref:`title_color<class_Window_theme_color_title_color>`                             | ``Color(0.875, 0.875, 0.875, 1)`` |
    +-----------------------------------+--------------------------------------------------------------------------------------+-----------------------------------+
-   | :ref:`Color<class_Color>`         | :ref:`title_outline_modulate<class_Window_theme_color_title_outline_modulate>`       | ``Color(1, 1, 1, 1)``             |
+   | :ref:`Color<class_Color>`         | :ref:`title_outline_modulate<class_Window_theme_color_title_outline_modulate>`       | ``Color(0, 0, 0, 1)``             |
    +-----------------------------------+--------------------------------------------------------------------------------------+-----------------------------------+
    | :ref:`int<class_int>`             | :ref:`close_h_offset<class_Window_theme_constant_close_h_offset>`                    | ``18``                            |
    +-----------------------------------+--------------------------------------------------------------------------------------+-----------------------------------+
@@ -1632,7 +1632,7 @@ Ends a bulk theme override update. See :ref:`begin_bulk_theme_override<class_Win
 
 :ref:`Vector2<class_Vector2>` **get_contents_minimum_size**\ (\ ) |const|
 
-Returns the combined minimum size from the child :ref:`Control<class_Control>` nodes of the window. Use :ref:`child_controls_changed<class_Window_method_child_controls_changed>` to update it when children nodes have changed.
+Returns the combined minimum size from the child :ref:`Control<class_Control>` nodes of the window. Use :ref:`child_controls_changed<class_Window_method_child_controls_changed>` to update it when child nodes have changed.
 
 The value returned by this method can be overridden with :ref:`_get_contents_minimum_size<class_Window_private_method__get_contents_minimum_size>`.
 
@@ -2443,7 +2443,7 @@ The color of the title's text.
 
 .. rst-class:: classref-themeproperty
 
-:ref:`Color<class_Color>` **title_outline_modulate** = ``Color(1, 1, 1, 1)``
+:ref:`Color<class_Color>` **title_outline_modulate** = ``Color(0, 0, 0, 1)``
 
 The color of the title's text outline.
 

classes/class_xrbodymodifier3d.rst

@@ -0,0 +1,221 @@
+:github_url: hide
+
+.. DO NOT EDIT THIS FILE!!!
+.. Generated automatically from Godot engine sources.
+.. Generator: https://github.com/godotengine/godot/tree/master/doc/tools/make_rst.py.
+.. XML source: https://github.com/godotengine/godot/tree/master/doc/classes/XRBodyModifier3D.xml.
+
+.. _class_XRBodyModifier3D:
+
+XRBodyModifier3D
+================
+
+**Inherits:** :ref:`Node3D<class_Node3D>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
+
+A node for driving body meshes from :ref:`XRBodyTracker<class_XRBodyTracker>` data.
+
+.. rst-class:: classref-introduction-group
+
+Description
+-----------
+
+This node uses body tracking data from a :ref:`XRBodyTracker<class_XRBodyTracker>` to animate the skeleton of a body mesh.
+
+.. rst-class:: classref-introduction-group
+
+Tutorials
+---------
+
+- :doc:`XR documentation index <../tutorials/xr/index>`
+
+.. rst-class:: classref-reftable-group
+
+Properties
+----------
+
+.. table::
+   :widths: auto
+
+   +-------------------------------------------------------------------+-----------------------------------------------------------------------------+-------------------+
+   | :ref:`StringName<class_StringName>`                               | :ref:`body_tracker<class_XRBodyModifier3D_property_body_tracker>`           | ``&"/user/body"`` |
+   +-------------------------------------------------------------------+-----------------------------------------------------------------------------+-------------------+
+   | |bitfield|\[:ref:`BodyUpdate<enum_XRBodyModifier3D_BodyUpdate>`\] | :ref:`body_update<class_XRBodyModifier3D_property_body_update>`             | ``7``             |
+   +-------------------------------------------------------------------+-----------------------------------------------------------------------------+-------------------+
+   | :ref:`BoneUpdate<enum_XRBodyModifier3D_BoneUpdate>`               | :ref:`bone_update<class_XRBodyModifier3D_property_bone_update>`             | ``0``             |
+   +-------------------------------------------------------------------+-----------------------------------------------------------------------------+-------------------+
+   | :ref:`bool<class_bool>`                                           | :ref:`show_when_tracked<class_XRBodyModifier3D_property_show_when_tracked>` | ``true``          |
+   +-------------------------------------------------------------------+-----------------------------------------------------------------------------+-------------------+
+   | :ref:`NodePath<class_NodePath>`                                   | :ref:`target<class_XRBodyModifier3D_property_target>`                       | ``NodePath("")``  |
+   +-------------------------------------------------------------------+-----------------------------------------------------------------------------+-------------------+
+
+.. rst-class:: classref-section-separator
+
+----
+
+.. rst-class:: classref-descriptions-group
+
+Enumerations
+------------
+
+.. _enum_XRBodyModifier3D_BodyUpdate:
+
+.. rst-class:: classref-enumeration
+
+flags **BodyUpdate**:
+
+.. _class_XRBodyModifier3D_constant_BODY_UPDATE_UPPER_BODY:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`BodyUpdate<enum_XRBodyModifier3D_BodyUpdate>` **BODY_UPDATE_UPPER_BODY** = ``1``
+
+The skeleton's upper body joints are updated.
+
+.. _class_XRBodyModifier3D_constant_BODY_UPDATE_LOWER_BODY:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`BodyUpdate<enum_XRBodyModifier3D_BodyUpdate>` **BODY_UPDATE_LOWER_BODY** = ``2``
+
+The skeleton's lower body joints are updated.
+
+.. _class_XRBodyModifier3D_constant_BODY_UPDATE_HANDS:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`BodyUpdate<enum_XRBodyModifier3D_BodyUpdate>` **BODY_UPDATE_HANDS** = ``4``
+
+The skeleton's hand joints are updated.
+
+.. rst-class:: classref-item-separator
+
+----
+
+.. _enum_XRBodyModifier3D_BoneUpdate:
+
+.. rst-class:: classref-enumeration
+
+enum **BoneUpdate**:
+
+.. _class_XRBodyModifier3D_constant_BONE_UPDATE_FULL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`BoneUpdate<enum_XRBodyModifier3D_BoneUpdate>` **BONE_UPDATE_FULL** = ``0``
+
+The skeleton's bones are fully updated (both position and rotation) to match the tracked bones.
+
+.. _class_XRBodyModifier3D_constant_BONE_UPDATE_ROTATION_ONLY:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`BoneUpdate<enum_XRBodyModifier3D_BoneUpdate>` **BONE_UPDATE_ROTATION_ONLY** = ``1``
+
+The skeleton's bones are only rotated to align with the tracked bones, preserving bone length.
+
+.. _class_XRBodyModifier3D_constant_BONE_UPDATE_MAX:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`BoneUpdate<enum_XRBodyModifier3D_BoneUpdate>` **BONE_UPDATE_MAX** = ``2``
+
+Represents the size of the :ref:`BoneUpdate<enum_XRBodyModifier3D_BoneUpdate>` enum.
+
+.. rst-class:: classref-section-separator
+
+----
+
+.. rst-class:: classref-descriptions-group
+
+Property Descriptions
+---------------------
+
+.. _class_XRBodyModifier3D_property_body_tracker:
+
+.. rst-class:: classref-property
+
+:ref:`StringName<class_StringName>` **body_tracker** = ``&"/user/body"``
+
+.. rst-class:: classref-property-setget
+
+- |void| **set_body_tracker**\ (\ value\: :ref:`StringName<class_StringName>`\ )
+- :ref:`StringName<class_StringName>` **get_body_tracker**\ (\ )
+
+The name of the :ref:`XRBodyTracker<class_XRBodyTracker>` registered with :ref:`XRServer<class_XRServer>` to obtain the body tracking data from.
+
+.. rst-class:: classref-item-separator
+
+----
+
+.. _class_XRBodyModifier3D_property_body_update:
+
+.. rst-class:: classref-property
+
+|bitfield|\[:ref:`BodyUpdate<enum_XRBodyModifier3D_BodyUpdate>`\] **body_update** = ``7``
+
+.. rst-class:: classref-property-setget
+
+- |void| **set_body_update**\ (\ value\: |bitfield|\[:ref:`BodyUpdate<enum_XRBodyModifier3D_BodyUpdate>`\]\ )
+- |bitfield|\[:ref:`BodyUpdate<enum_XRBodyModifier3D_BodyUpdate>`\] **get_body_update**\ (\ )
+
+Specifies the body parts to update.
+
+.. rst-class:: classref-item-separator
+
+----
+
+.. _class_XRBodyModifier3D_property_bone_update:
+
+.. rst-class:: classref-property
+
+:ref:`BoneUpdate<enum_XRBodyModifier3D_BoneUpdate>` **bone_update** = ``0``
+
+.. rst-class:: classref-property-setget
+
+- |void| **set_bone_update**\ (\ value\: :ref:`BoneUpdate<enum_XRBodyModifier3D_BoneUpdate>`\ )
+- :ref:`BoneUpdate<enum_XRBodyModifier3D_BoneUpdate>` **get_bone_update**\ (\ )
+
+Specifies the type of updates to perform on the bones.
+
+.. rst-class:: classref-item-separator
+
+----
+
+.. _class_XRBodyModifier3D_property_show_when_tracked:
+
+.. rst-class:: classref-property
+
+:ref:`bool<class_bool>` **show_when_tracked** = ``true``
+
+.. rst-class:: classref-property-setget
+
+- |void| **set_show_when_tracked**\ (\ value\: :ref:`bool<class_bool>`\ )
+- :ref:`bool<class_bool>` **get_show_when_tracked**\ (\ )
+
+If true then the nodes visibility is determined by whether tracking data is available.
+
+.. rst-class:: classref-item-separator
+
+----
+
+.. _class_XRBodyModifier3D_property_target:
+
+.. rst-class:: classref-property
+
+:ref:`NodePath<class_NodePath>` **target** = ``NodePath("")``
+
+.. rst-class:: classref-property-setget
+
+- |void| **set_target**\ (\ value\: :ref:`NodePath<class_NodePath>`\ )
+- :ref:`NodePath<class_NodePath>` **get_target**\ (\ )
+
+A :ref:`NodePath<class_NodePath>` to a :ref:`Skeleton3D<class_Skeleton3D>` to animate.
+
+.. |virtual| replace:: :abbr:`virtual (This method should typically be overridden by the user to have any effect.)`
+.. |const| replace:: :abbr:`const (This method has no side effects. It doesn't modify any of the instance's member variables.)`
+.. |vararg| replace:: :abbr:`vararg (This method accepts any number of arguments after the ones described here.)`
+.. |constructor| replace:: :abbr:`constructor (This method is used to construct a type.)`
+.. |static| replace:: :abbr:`static (This method doesn't need an instance to be called, so it can be called directly using the class name.)`
+.. |operator| replace:: :abbr:`operator (This method describes a valid operator to use with this type as left-hand operand.)`
+.. |bitfield| replace:: :abbr:`BitField (This value is an integer composed as a bitmask of the following flags.)`
+.. |void| replace:: :abbr:`void (No return value.)`

classes/class_xrbodytracker.rst

@@ -0,0 +1,871 @@
+:github_url: hide
+
+.. DO NOT EDIT THIS FILE!!!
+.. Generated automatically from Godot engine sources.
+.. Generator: https://github.com/godotengine/godot/tree/master/doc/tools/make_rst.py.
+.. XML source: https://github.com/godotengine/godot/tree/master/doc/classes/XRBodyTracker.xml.
+
+.. _class_XRBodyTracker:
+
+XRBodyTracker
+=============
+
+**Inherits:** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
+
+A tracked body in XR.
+
+.. rst-class:: classref-introduction-group
+
+Description
+-----------
+
+A body tracking system will create an instance of this object and add it to the :ref:`XRServer<class_XRServer>`. This tracking system will then obtain skeleton data, convert it to the Godot Humanoid skeleton and store this data on the **XRBodyTracker** object.
+
+Use :ref:`XRBodyModifier3D<class_XRBodyModifier3D>` to animate a body mesh using body tracking data.
+
+.. rst-class:: classref-introduction-group
+
+Tutorials
+---------
+
+- :doc:`XR documentation index <../tutorials/xr/index>`
+
+.. rst-class:: classref-reftable-group
+
+Properties
+----------
+
+.. table::
+   :widths: auto
+
+   +--------------------------------------------------------------+--------------------------------------------------------------------------+-----------+
+   | |bitfield|\[:ref:`BodyFlags<enum_XRBodyTracker_BodyFlags>`\] | :ref:`body_flags<class_XRBodyTracker_property_body_flags>`               | ``0``     |
+   +--------------------------------------------------------------+--------------------------------------------------------------------------+-----------+
+   | :ref:`bool<class_bool>`                                      | :ref:`has_tracking_data<class_XRBodyTracker_property_has_tracking_data>` | ``false`` |
+   +--------------------------------------------------------------+--------------------------------------------------------------------------+-----------+
+
+.. rst-class:: classref-reftable-group
+
+Methods
+-------
+
+.. table::
+   :widths: auto
+
+   +----------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+   | |bitfield|\[:ref:`JointFlags<enum_XRBodyTracker_JointFlags>`\] | :ref:`get_joint_flags<class_XRBodyTracker_method_get_joint_flags>`\ (\ joint\: :ref:`Joint<enum_XRBodyTracker_Joint>`\ ) |const|                                                                 |
+   +----------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`Transform3D<class_Transform3D>`                          | :ref:`get_joint_transform<class_XRBodyTracker_method_get_joint_transform>`\ (\ joint\: :ref:`Joint<enum_XRBodyTracker_Joint>`\ ) |const|                                                         |
+   +----------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+   | |void|                                                         | :ref:`set_joint_flags<class_XRBodyTracker_method_set_joint_flags>`\ (\ joint\: :ref:`Joint<enum_XRBodyTracker_Joint>`, flags\: |bitfield|\[:ref:`JointFlags<enum_XRBodyTracker_JointFlags>`\]\ ) |
+   +----------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+   | |void|                                                         | :ref:`set_joint_transform<class_XRBodyTracker_method_set_joint_transform>`\ (\ joint\: :ref:`Joint<enum_XRBodyTracker_Joint>`, transform\: :ref:`Transform3D<class_Transform3D>`\ )              |
+   +----------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+
+.. rst-class:: classref-section-separator
+
+----
+
+.. rst-class:: classref-descriptions-group
+
+Enumerations
+------------
+
+.. _enum_XRBodyTracker_BodyFlags:
+
+.. rst-class:: classref-enumeration
+
+flags **BodyFlags**:
+
+.. _class_XRBodyTracker_constant_BODY_FLAG_UPPER_BODY_SUPPORTED:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`BodyFlags<enum_XRBodyTracker_BodyFlags>` **BODY_FLAG_UPPER_BODY_SUPPORTED** = ``1``
+
+Upper body tracking supported.
+
+.. _class_XRBodyTracker_constant_BODY_FLAG_LOWER_BODY_SUPPORTED:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`BodyFlags<enum_XRBodyTracker_BodyFlags>` **BODY_FLAG_LOWER_BODY_SUPPORTED** = ``2``
+
+Lower body tracking supported.
+
+.. _class_XRBodyTracker_constant_BODY_FLAG_HANDS_SUPPORTED:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`BodyFlags<enum_XRBodyTracker_BodyFlags>` **BODY_FLAG_HANDS_SUPPORTED** = ``4``
+
+Hand tracking supported.
+
+.. rst-class:: classref-item-separator
+
+----
+
+.. _enum_XRBodyTracker_Joint:
+
+.. rst-class:: classref-enumeration
+
+enum **Joint**:
+
+.. _class_XRBodyTracker_constant_JOINT_ROOT:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_ROOT** = ``0``
+
+Root joint.
+
+.. _class_XRBodyTracker_constant_JOINT_HIPS:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_HIPS** = ``1``
+
+Hips joint.
+
+.. _class_XRBodyTracker_constant_JOINT_SPINE:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_SPINE** = ``2``
+
+Spine joint.
+
+.. _class_XRBodyTracker_constant_JOINT_CHEST:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_CHEST** = ``3``
+
+Chest joint.
+
+.. _class_XRBodyTracker_constant_JOINT_UPPER_CHEST:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_UPPER_CHEST** = ``4``
+
+Upper chest joint.
+
+.. _class_XRBodyTracker_constant_JOINT_NECK:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_NECK** = ``5``
+
+Neck joint.
+
+.. _class_XRBodyTracker_constant_JOINT_HEAD:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_HEAD** = ``6``
+
+Head joint.
+
+.. _class_XRBodyTracker_constant_JOINT_HEAD_TIP:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_HEAD_TIP** = ``7``
+
+Head tip joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_SHOULDER:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_SHOULDER** = ``8``
+
+Left shoulder joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_UPPER_ARM:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_UPPER_ARM** = ``9``
+
+Left upper arm joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_LOWER_ARM:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_LOWER_ARM** = ``10``
+
+Left lower arm joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_SHOULDER:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_SHOULDER** = ``11``
+
+Right shoulder joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_UPPER_ARM:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_UPPER_ARM** = ``12``
+
+Right upper arm joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_LOWER_ARM:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_LOWER_ARM** = ``13``
+
+Right lower arm joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_UPPER_LEG:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_UPPER_LEG** = ``14``
+
+Left upper leg joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_LOWER_LEG:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_LOWER_LEG** = ``15``
+
+Left lower leg joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_FOOT:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_FOOT** = ``16``
+
+Left foot joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_TOES:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_TOES** = ``17``
+
+Left toes joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_UPPER_LEG:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_UPPER_LEG** = ``18``
+
+Right upper leg joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_LOWER_LEG:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_LOWER_LEG** = ``19``
+
+Right lower leg joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_FOOT:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_FOOT** = ``20``
+
+Right foot joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_TOES:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_TOES** = ``21``
+
+Right toes joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_HAND:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_HAND** = ``22``
+
+Left hand joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_PALM:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_PALM** = ``23``
+
+Left palm joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_WRIST:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_WRIST** = ``24``
+
+Left wrist joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_THUMB_METACARPAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_THUMB_METACARPAL** = ``25``
+
+Left thumb metacarpal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_THUMB_PHALANX_PROXIMAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_THUMB_PHALANX_PROXIMAL** = ``26``
+
+Left thumb phalanx proximal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_THUMB_PHALANX_DISTAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_THUMB_PHALANX_DISTAL** = ``27``
+
+Left thumb phalanx distal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_THUMB_TIP:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_THUMB_TIP** = ``28``
+
+Left thumb tip joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_INDEX_FINGER_METACARPAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_INDEX_FINGER_METACARPAL** = ``29``
+
+Left index finger metacarpal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_INDEX_FINGER_PHALANX_PROXIMAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_INDEX_FINGER_PHALANX_PROXIMAL** = ``30``
+
+Left index finger phalanx proximal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_INDEX_FINGER_PHALANX_INTERMEDIATE:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_INDEX_FINGER_PHALANX_INTERMEDIATE** = ``31``
+
+Left index finger phalanx intermediate joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_INDEX_FINGER_PHALANX_DISTAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_INDEX_FINGER_PHALANX_DISTAL** = ``32``
+
+Left index finger phalanx distal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_INDEX_FINGER_TIP:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_INDEX_FINGER_TIP** = ``33``
+
+Left index finger tip joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_MIDDLE_FINGER_METACARPAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_MIDDLE_FINGER_METACARPAL** = ``34``
+
+Left middle finger metacarpal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_MIDDLE_FINGER_PHALANX_PROXIMAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_MIDDLE_FINGER_PHALANX_PROXIMAL** = ``35``
+
+Left middle finger phalanx proximal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_MIDDLE_FINGER_PHALANX_INTERMEDIATE:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_MIDDLE_FINGER_PHALANX_INTERMEDIATE** = ``36``
+
+Left middle finger phalanx intermediate joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_MIDDLE_FINGER_PHALANX_DISTAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_MIDDLE_FINGER_PHALANX_DISTAL** = ``37``
+
+Left middle finger phalanx distal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_MIDDLE_FINGER_TIP:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_MIDDLE_FINGER_TIP** = ``38``
+
+Left middle finger tip joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_RING_FINGER_METACARPAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_RING_FINGER_METACARPAL** = ``39``
+
+Left ring finger metacarpal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_RING_FINGER_PHALANX_PROXIMAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_RING_FINGER_PHALANX_PROXIMAL** = ``40``
+
+Left ring finger phalanx proximal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_RING_FINGER_PHALANX_INTERMEDIATE:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_RING_FINGER_PHALANX_INTERMEDIATE** = ``41``
+
+Left ring finger phalanx intermediate joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_RING_FINGER_PHALANX_DISTAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_RING_FINGER_PHALANX_DISTAL** = ``42``
+
+Left ring finger phalanx distal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_RING_FINGER_TIP:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_RING_FINGER_TIP** = ``43``
+
+Left ring finger tip joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_PINKY_FINGER_METACARPAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_PINKY_FINGER_METACARPAL** = ``44``
+
+Left pinky finger metacarpal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_PINKY_FINGER_PHALANX_PROXIMAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_PINKY_FINGER_PHALANX_PROXIMAL** = ``45``
+
+Left pinky finger phalanx proximal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_PINKY_FINGER_PHALANX_INTERMEDIATE:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_PINKY_FINGER_PHALANX_INTERMEDIATE** = ``46``
+
+Left pinky finger phalanx intermediate joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_PINKY_FINGER_PHALANX_DISTAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_PINKY_FINGER_PHALANX_DISTAL** = ``47``
+
+Left pinky finger phalanx distal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_LEFT_PINKY_FINGER_TIP:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_LEFT_PINKY_FINGER_TIP** = ``48``
+
+Left pinky finger tip joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_HAND:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_HAND** = ``49``
+
+Right hand joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_PALM:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_PALM** = ``50``
+
+Right palm joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_WRIST:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_WRIST** = ``51``
+
+Right wrist joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_THUMB_METACARPAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_THUMB_METACARPAL** = ``52``
+
+Right thumb metacarpal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_THUMB_PHALANX_PROXIMAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_THUMB_PHALANX_PROXIMAL** = ``53``
+
+Right thumb phalanx proximal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_THUMB_PHALANX_DISTAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_THUMB_PHALANX_DISTAL** = ``54``
+
+Right thumb phalanx distal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_THUMB_TIP:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_THUMB_TIP** = ``55``
+
+Right thumb tip joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_INDEX_FINGER_METACARPAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_INDEX_FINGER_METACARPAL** = ``56``
+
+Right index finger metacarpal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_INDEX_FINGER_PHALANX_PROXIMAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_INDEX_FINGER_PHALANX_PROXIMAL** = ``57``
+
+Right index finger phalanx proximal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_INDEX_FINGER_PHALANX_INTERMEDIATE:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_INDEX_FINGER_PHALANX_INTERMEDIATE** = ``58``
+
+Right index finger phalanx intermediate joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_INDEX_FINGER_PHALANX_DISTAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_INDEX_FINGER_PHALANX_DISTAL** = ``59``
+
+Right index finger phalanx distal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_INDEX_FINGER_TIP:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_INDEX_FINGER_TIP** = ``60``
+
+Right index finger tip joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_MIDDLE_FINGER_METACARPAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_MIDDLE_FINGER_METACARPAL** = ``61``
+
+Right middle finger metacarpal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_MIDDLE_FINGER_PHALANX_PROXIMAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_MIDDLE_FINGER_PHALANX_PROXIMAL** = ``62``
+
+Right middle finger phalanx proximal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_MIDDLE_FINGER_PHALANX_INTERMEDIATE:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_MIDDLE_FINGER_PHALANX_INTERMEDIATE** = ``63``
+
+Right middle finger phalanx intermediate joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_MIDDLE_FINGER_PHALANX_DISTAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_MIDDLE_FINGER_PHALANX_DISTAL** = ``64``
+
+Right middle finger phalanx distal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_MIDDLE_FINGER_TIP:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_MIDDLE_FINGER_TIP** = ``65``
+
+Right middle finger tip joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_RING_FINGER_METACARPAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_RING_FINGER_METACARPAL** = ``66``
+
+Right ring finger metacarpal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_RING_FINGER_PHALANX_PROXIMAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_RING_FINGER_PHALANX_PROXIMAL** = ``67``
+
+Right ring finger phalanx proximal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_RING_FINGER_PHALANX_INTERMEDIATE:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_RING_FINGER_PHALANX_INTERMEDIATE** = ``68``
+
+Right ring finger phalanx intermediate joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_RING_FINGER_PHALANX_DISTAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_RING_FINGER_PHALANX_DISTAL** = ``69``
+
+Right ring finger phalanx distal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_RING_FINGER_TIP:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_RING_FINGER_TIP** = ``70``
+
+Right ring finger tip joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_PINKY_FINGER_METACARPAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_PINKY_FINGER_METACARPAL** = ``71``
+
+Right pinky finger metacarpal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_PINKY_FINGER_PHALANX_PROXIMAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_PINKY_FINGER_PHALANX_PROXIMAL** = ``72``
+
+Right pinky finger phalanx proximal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_PINKY_FINGER_PHALANX_INTERMEDIATE:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_PINKY_FINGER_PHALANX_INTERMEDIATE** = ``73``
+
+Right pinky finger phalanx intermediate joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_PINKY_FINGER_PHALANX_DISTAL:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_PINKY_FINGER_PHALANX_DISTAL** = ``74``
+
+Right pinky finger phalanx distal joint.
+
+.. _class_XRBodyTracker_constant_JOINT_RIGHT_PINKY_FINGER_TIP:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_RIGHT_PINKY_FINGER_TIP** = ``75``
+
+Right pinky finger tip joint.
+
+.. _class_XRBodyTracker_constant_JOINT_MAX:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`Joint<enum_XRBodyTracker_Joint>` **JOINT_MAX** = ``76``
+
+Represents the size of the :ref:`Joint<enum_XRBodyTracker_Joint>` enum.
+
+.. rst-class:: classref-item-separator
+
+----
+
+.. _enum_XRBodyTracker_JointFlags:
+
+.. rst-class:: classref-enumeration
+
+flags **JointFlags**:
+
+.. _class_XRBodyTracker_constant_JOINT_FLAG_ORIENTATION_VALID:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`JointFlags<enum_XRBodyTracker_JointFlags>` **JOINT_FLAG_ORIENTATION_VALID** = ``1``
+
+The joint's orientation data is valid.
+
+.. _class_XRBodyTracker_constant_JOINT_FLAG_ORIENTATION_TRACKED:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`JointFlags<enum_XRBodyTracker_JointFlags>` **JOINT_FLAG_ORIENTATION_TRACKED** = ``2``
+
+The joint's orientation is actively tracked. May not be set if tracking has been temporarily lost.
+
+.. _class_XRBodyTracker_constant_JOINT_FLAG_POSITION_VALID:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`JointFlags<enum_XRBodyTracker_JointFlags>` **JOINT_FLAG_POSITION_VALID** = ``4``
+
+The joint's position data is valid.
+
+.. _class_XRBodyTracker_constant_JOINT_FLAG_POSITION_TRACKED:
+
+.. rst-class:: classref-enumeration-constant
+
+:ref:`JointFlags<enum_XRBodyTracker_JointFlags>` **JOINT_FLAG_POSITION_TRACKED** = ``8``
+
+The joint's position is actively tracked. May not be set if tracking has been temporarily lost.
+
+.. rst-class:: classref-section-separator
+
+----
+
+.. rst-class:: classref-descriptions-group
+
+Property Descriptions
+---------------------
+
+.. _class_XRBodyTracker_property_body_flags:
+
+.. rst-class:: classref-property
+
+|bitfield|\[:ref:`BodyFlags<enum_XRBodyTracker_BodyFlags>`\] **body_flags** = ``0``
+
+.. rst-class:: classref-property-setget
+
+- |void| **set_body_flags**\ (\ value\: |bitfield|\[:ref:`BodyFlags<enum_XRBodyTracker_BodyFlags>`\]\ )
+- |bitfield|\[:ref:`BodyFlags<enum_XRBodyTracker_BodyFlags>`\] **get_body_flags**\ (\ )
+
+The type of body tracking data captured.
+
+.. rst-class:: classref-item-separator
+
+----
+
+.. _class_XRBodyTracker_property_has_tracking_data:
+
+.. rst-class:: classref-property
+
+:ref:`bool<class_bool>` **has_tracking_data** = ``false``
+
+.. rst-class:: classref-property-setget
+
+- |void| **set_has_tracking_data**\ (\ value\: :ref:`bool<class_bool>`\ )
+- :ref:`bool<class_bool>` **get_has_tracking_data**\ (\ )
+
+If ``true``, the body tracking data is valid.
+
+.. rst-class:: classref-section-separator
+
+----
+
+.. rst-class:: classref-descriptions-group
+
+Method Descriptions
+-------------------
+
+.. _class_XRBodyTracker_method_get_joint_flags:
+
+.. rst-class:: classref-method
+
+|bitfield|\[:ref:`JointFlags<enum_XRBodyTracker_JointFlags>`\] **get_joint_flags**\ (\ joint\: :ref:`Joint<enum_XRBodyTracker_Joint>`\ ) |const|
+
+Returns flags about the validity of the tracking data for the given body joint (see :ref:`JointFlags<enum_XRBodyTracker_JointFlags>`).
+
+.. rst-class:: classref-item-separator
+
+----
+
+.. _class_XRBodyTracker_method_get_joint_transform:
+
+.. rst-class:: classref-method
+
+:ref:`Transform3D<class_Transform3D>` **get_joint_transform**\ (\ joint\: :ref:`Joint<enum_XRBodyTracker_Joint>`\ ) |const|
+
+Returns the transform for the given body joint.
+
+.. rst-class:: classref-item-separator
+
+----
+
+.. _class_XRBodyTracker_method_set_joint_flags:
+
+.. rst-class:: classref-method
+
+|void| **set_joint_flags**\ (\ joint\: :ref:`Joint<enum_XRBodyTracker_Joint>`, flags\: |bitfield|\[:ref:`JointFlags<enum_XRBodyTracker_JointFlags>`\]\ )
+
+Sets flags about the validity of the tracking data for the given body joint.
+
+.. rst-class:: classref-item-separator
+
+----
+
+.. _class_XRBodyTracker_method_set_joint_transform:
+
+.. rst-class:: classref-method
+
+|void| **set_joint_transform**\ (\ joint\: :ref:`Joint<enum_XRBodyTracker_Joint>`, transform\: :ref:`Transform3D<class_Transform3D>`\ )
+
+Sets the transform for the given body joint.
+
+.. |virtual| replace:: :abbr:`virtual (This method should typically be overridden by the user to have any effect.)`
+.. |const| replace:: :abbr:`const (This method has no side effects. It doesn't modify any of the instance's member variables.)`
+.. |vararg| replace:: :abbr:`vararg (This method accepts any number of arguments after the ones described here.)`
+.. |constructor| replace:: :abbr:`constructor (This method is used to construct a type.)`
+.. |static| replace:: :abbr:`static (This method doesn't need an instance to be called, so it can be called directly using the class name.)`
+.. |operator| replace:: :abbr:`operator (This method describes a valid operator to use with this type as left-hand operand.)`
+.. |bitfield| replace:: :abbr:`BitField (This value is an integer composed as a bitmask of the following flags.)`
+.. |void| replace:: :abbr:`void (No return value.)`

classes/class_xrserver.rst

@@ -52,6 +52,8 @@ Methods
 .. table::
    :widths: auto
 
+   +------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+   | |void|                                                           | :ref:`add_body_tracker<class_XRServer_method_add_body_tracker>`\ (\ tracker_name\: :ref:`StringName<class_StringName>`, body_tracker\: :ref:`XRBodyTracker<class_XRBodyTracker>`\ ) |
    +------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | |void|                                                           | :ref:`add_face_tracker<class_XRServer_method_add_face_tracker>`\ (\ tracker_name\: :ref:`StringName<class_StringName>`, face_tracker\: :ref:`XRFaceTracker<class_XRFaceTracker>`\ ) |
    +------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -67,6 +69,10 @@ Methods
    +------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | :ref:`XRInterface<class_XRInterface>`                            | :ref:`find_interface<class_XRServer_method_find_interface>`\ (\ name\: :ref:`String<class_String>`\ ) |const|                                                                       |
    +------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`XRBodyTracker<class_XRBodyTracker>`                        | :ref:`get_body_tracker<class_XRServer_method_get_body_tracker>`\ (\ tracker_name\: :ref:`StringName<class_StringName>`\ ) |const|                                                   |
+   +------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`Dictionary<class_Dictionary>`                              | :ref:`get_body_trackers<class_XRServer_method_get_body_trackers>`\ (\ ) |const|                                                                                                     |
+   +------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | :ref:`XRFaceTracker<class_XRFaceTracker>`                        | :ref:`get_face_tracker<class_XRServer_method_get_face_tracker>`\ (\ tracker_name\: :ref:`StringName<class_StringName>`\ ) |const|                                                   |
    +------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | :ref:`Dictionary<class_Dictionary>`                              | :ref:`get_face_trackers<class_XRServer_method_get_face_trackers>`\ (\ ) |const|                                                                                                     |
@@ -89,6 +95,8 @@ Methods
    +------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | :ref:`Dictionary<class_Dictionary>`                              | :ref:`get_trackers<class_XRServer_method_get_trackers>`\ (\ tracker_types\: :ref:`int<class_int>`\ )                                                                                |
    +------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+   | |void|                                                           | :ref:`remove_body_tracker<class_XRServer_method_remove_body_tracker>`\ (\ tracker_name\: :ref:`StringName<class_StringName>`\ )                                                     |
+   +------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | |void|                                                           | :ref:`remove_face_tracker<class_XRServer_method_remove_face_tracker>`\ (\ tracker_name\: :ref:`StringName<class_StringName>`\ )                                                     |
    +------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | |void|                                                           | :ref:`remove_hand_tracker<class_XRServer_method_remove_hand_tracker>`\ (\ tracker_name\: :ref:`StringName<class_StringName>`\ )                                                     |
@@ -107,6 +115,42 @@ Methods
 Signals
 -------
 
+.. _class_XRServer_signal_body_tracker_added:
+
+.. rst-class:: classref-signal
+
+**body_tracker_added**\ (\ tracker_name\: :ref:`StringName<class_StringName>`, body_tracker\: :ref:`XRBodyTracker<class_XRBodyTracker>`\ )
+
+Emitted when a new body tracker is added.
+
+.. rst-class:: classref-item-separator
+
+----
+
+.. _class_XRServer_signal_body_tracker_removed:
+
+.. rst-class:: classref-signal
+
+**body_tracker_removed**\ (\ tracker_name\: :ref:`StringName<class_StringName>`\ )
+
+Emitted when a body tracker is removed.
+
+.. rst-class:: classref-item-separator
+
+----
+
+.. _class_XRServer_signal_body_tracker_updated:
+
+.. rst-class:: classref-signal
+
+**body_tracker_updated**\ (\ tracker_name\: :ref:`StringName<class_StringName>`, body_tracker\: :ref:`XRBodyTracker<class_XRBodyTracker>`\ )
+
+Emitted when an existing body tracker is updated.
+
+.. rst-class:: classref-item-separator
+
+----
+
 .. _class_XRServer_signal_face_tracker_added:
 
 .. rst-class:: classref-signal
@@ -407,6 +451,18 @@ The scale of the game world compared to the real world. By default, most AR/VR p
 Method Descriptions
 -------------------
 
+.. _class_XRServer_method_add_body_tracker:
+
+.. rst-class:: classref-method
+
+|void| **add_body_tracker**\ (\ tracker_name\: :ref:`StringName<class_StringName>`, body_tracker\: :ref:`XRBodyTracker<class_XRBodyTracker>`\ )
+
+Registers a new :ref:`XRBodyTracker<class_XRBodyTracker>` that tracks the joints of a body.
+
+.. rst-class:: classref-item-separator
+
+----
+
 .. _class_XRServer_method_add_face_tracker:
 
 .. rst-class:: classref-method
@@ -501,6 +557,30 @@ Finds an interface by its ``name``. For example, if your project uses capabiliti
 
 ----
 
+.. _class_XRServer_method_get_body_tracker:
+
+.. rst-class:: classref-method
+
+:ref:`XRBodyTracker<class_XRBodyTracker>` **get_body_tracker**\ (\ tracker_name\: :ref:`StringName<class_StringName>`\ ) |const|
+
+Returns the :ref:`XRBodyTracker<class_XRBodyTracker>` with the given tracker name.
+
+.. rst-class:: classref-item-separator
+
+----
+
+.. _class_XRServer_method_get_body_trackers:
+
+.. rst-class:: classref-method
+
+:ref:`Dictionary<class_Dictionary>` **get_body_trackers**\ (\ ) |const|
+
+Returns a dictionary of the registered body trackers. Each element of the dictionary is a tracker name mapping to the :ref:`XRBodyTracker<class_XRBodyTracker>` instance.
+
+.. rst-class:: classref-item-separator
+
+----
+
 .. _class_XRServer_method_get_face_tracker:
 
 .. rst-class:: classref-method
@@ -633,6 +713,18 @@ Returns a dictionary of trackers for ``tracker_types``.
 
 ----
 
+.. _class_XRServer_method_remove_body_tracker:
+
+.. rst-class:: classref-method
+
+|void| **remove_body_tracker**\ (\ tracker_name\: :ref:`StringName<class_StringName>`\ )
+
+Removes a registered :ref:`XRBodyTracker<class_XRBodyTracker>`.
+
+.. rst-class:: classref-item-separator
+
+----
+
 .. _class_XRServer_method_remove_face_tracker:
 
 .. rst-class:: classref-method

classes/index.rst

@@ -262,6 +262,7 @@ Nodes
     class_window
     class_worldenvironment
     class_xranchor3d
+    class_xrbodymodifier3d
     class_xrcamera3d
     class_xrcontroller3d
     class_xrfacemodifier3d
@@ -934,6 +935,7 @@ Other objects
     class_webxrinterface
     class_workerthreadpool
     class_xmlparser
+    class_xrbodytracker
     class_xrfacetracker
     class_xrhandtracker
     class_xrinterface