classref: Sync with current master branch (8c7b98d45)

classes/[email protected]

@@ -17,7 +17,7 @@ Built-in GDScript functions.
 Description
 -----------
 
-A list of GDScript-specific utility functions accessed in any script.
+A list of GDScript-specific utility functions and annotations accessible from any script.
 
 For the list of the global functions and constants see :ref:`@GlobalScope<class_@GlobalScope>`.
 
@@ -124,12 +124,14 @@ Annotations
 
 **@export** **(** **)**
 
-Mark the following property as exported (editable in the Inspector dock and saved to disk). To control the type of the exported property use the type hint notation.
+Mark the following property as exported (editable in the Inspector dock and saved to disk). To control the type of the exported property, use the type hint notation.
 
 ::
 
+    @export var string = ""
     @export var int_number = 5
     @export var float_number: float = 5
+    @export var image : Image
 
 .. rst-class:: classref-item-separator
 
@@ -147,11 +149,11 @@ See also :ref:`@GlobalScope.PROPERTY_USAGE_CATEGORY<class_@GlobalScope_constant_
 
 ::
 
-    @export_category("My Properties")
-    @export var number = 3
-    @export var string = ""
+    @export_category("Statistics")
+    @export var hp = 30
+    @export var speed = 1.25
 
-\ **Note:** Categories in the property list are supposed to indicate different base types, so the use of this annotation is not encouraged. See :ref:`@export_group<class_@GDScript_annotation_@export_group>` and :ref:`@export_subgroup<class_@GDScript_annotation_@export_subgroup>` instead.
+\ **Note:** Categories in the Inspector dock's list usually divide properties coming from different classes (Node, Node2D, Sprite, etc.). For better clarity, it's recommended to use :ref:`@export_group<class_@GDScript_annotation_@export_group>` and :ref:`@export_subgroup<class_@GDScript_annotation_@export_subgroup>`, instead.
 
 .. rst-class:: classref-item-separator
 
@@ -163,13 +165,13 @@ See also :ref:`@GlobalScope.PROPERTY_USAGE_CATEGORY<class_@GlobalScope_constant_
 
 **@export_color_no_alpha** **(** **)**
 
-Export a :ref:`Color<class_Color>` property without transparency (its alpha fixed as ``1.0``).
+Export a :ref:`Color<class_Color>` property without allowing its transparency (:ref:`Color.a<class_Color_property_a>`) to be edited.
 
 See also :ref:`@GlobalScope.PROPERTY_HINT_COLOR_NO_ALPHA<class_@GlobalScope_constant_PROPERTY_HINT_COLOR_NO_ALPHA>`.
 
 ::
 
-    @export_color_no_alpha var modulate_color: Color
+    @export_color_no_alpha var dye_color : Color
 
 .. rst-class:: classref-item-separator
 
@@ -187,7 +189,7 @@ See also :ref:`@GlobalScope.PROPERTY_HINT_DIR<class_@GlobalScope_constant_PROPER
 
 ::
 
-    @export_dir var sprite_folder: String
+    @export_dir var sprite_folder_path: String
 
 .. rst-class:: classref-item-separator
 
@@ -260,8 +262,8 @@ See also :ref:`@GlobalScope.PROPERTY_HINT_FILE<class_@GlobalScope_constant_PROPE
 
 ::
 
-    @export_file var sound_effect_file: String
-    @export_file("*.txt") var notes_file: String
+    @export_file var sound_effect_path: String
+    @export_file("*.txt") var notes_path: String
 
 .. rst-class:: classref-item-separator
 
@@ -420,13 +422,13 @@ See also :ref:`@GlobalScope.PROPERTY_HINT_LAYERS_3D_RENDER<class_@GlobalScope_co
 
 **@export_global_dir** **(** **)**
 
-Export a :ref:`String<class_String>` property as a path to a directory. The path can be picked from the entire filesystem. See :ref:`@export_dir<class_@GDScript_annotation_@export_dir>` to limit it to the project folder and its subfolders.
+Export a :ref:`String<class_String>` property as an absolute path to a directory. The path can be picked from the entire filesystem. See :ref:`@export_dir<class_@GDScript_annotation_@export_dir>` to limit it to the project folder and its subfolders.
 
 See also :ref:`@GlobalScope.PROPERTY_HINT_GLOBAL_DIR<class_@GlobalScope_constant_PROPERTY_HINT_GLOBAL_DIR>`.
 
 ::
 
-    @export_global_dir var sprite_folder: String
+    @export_global_dir var sprite_folder_path: String
 
 .. rst-class:: classref-item-separator
 
@@ -438,7 +440,7 @@ See also :ref:`@GlobalScope.PROPERTY_HINT_GLOBAL_DIR<class_@GlobalScope_constant
 
 **@export_global_file** **(** :ref:`String<class_String>` filter="", ... **)** |vararg|
 
-Export a :ref:`String<class_String>` property as a path to a file. The path can be picked from the entire filesystem. See :ref:`@export_file<class_@GDScript_annotation_@export_file>` to limit it to the project folder and its subfolders.
+Export a :ref:`String<class_String>` property as an absolute path to a file. The path can be picked from the entire filesystem. See :ref:`@export_file<class_@GDScript_annotation_@export_file>` to limit it to the project folder and its subfolders.
 
 If ``filter`` is provided, only matching files will be available for picking.
 
@@ -446,8 +448,8 @@ See also :ref:`@GlobalScope.PROPERTY_HINT_GLOBAL_FILE<class_@GlobalScope_constan
 
 ::
 
-    @export_global_file var sound_effect_file: String
-    @export_global_file("*.txt") var notes_file: String
+    @export_global_file var sound_effect_path: String
+    @export_global_file("*.txt") var notes_path: String
 
 .. rst-class:: classref-item-separator
 
@@ -469,13 +471,13 @@ See also :ref:`@GlobalScope.PROPERTY_USAGE_GROUP<class_@GlobalScope_constant_PRO
 
 ::
 
-    @export_group("My Properties")
-    @export var number = 3
-    @export var string = ""
+    @export_group("Racer Properties")
+    @export var nickname = "Nick"
+    @export var age = 26
     
-    @export_group("Prefixed Properties", "prefix_")
-    @export var prefix_number = 3
-    @export var prefix_string = ""
+    @export_group("Car Properties", "car_")
+    @export var car_label = "Speedy"
+    @export var car_number = 3
     
     @export_group("", "")
     @export var ungrouped_number = 3
@@ -581,13 +583,13 @@ See also :ref:`@GlobalScope.PROPERTY_USAGE_SUBGROUP<class_@GlobalScope_constant_
 
 ::
 
-    @export_group("My Properties")
-    @export var number = 3
-    @export var string = ""
+    @export_group("Racer Properties")
+    @export var nickname = "Nick"
+    @export var age = 26
     
-    @export_subgroup("My Prefixed Properties", "prefix_")
-    @export var prefix_number = 3
-    @export var prefix_string = ""
+    @export_subgroup("Car Properties", "car_")
+    @export var car_label = "Speedy"
+    @export var car_number = 3
 
 \ **Note:** Subgroups cannot be nested, they only provide one extra level of depth. Just like the next group ends the previous group, so do the subsequent subgroups.
 
@@ -623,7 +625,7 @@ Add a custom icon to the current script. The script must be registered as a glob
 
 **@onready** **(** **)**
 
-Mark the following property as assigned on :ref:`Node<class_Node>`'s ready state change. Values for these properties are not assigned immediately upon the node's creation, and instead are computed and stored right before :ref:`Node._ready<class_Node_method__ready>`.
+Mark the following property as assigned when the :ref:`Node<class_Node>` is ready. Values for these properties are not assigned immediately when the node is initialized (:ref:`Object._init<class_Object_method__init>`), and instead are computed and stored right before :ref:`Node._ready<class_Node_method__ready>`.
 
 ::
 
@@ -712,7 +714,7 @@ Returns a :ref:`Color<class_Color>` constructed from red (``r8``), green (``g8``
 
 ::
 
-    var red = Color8(255, 0, 0)             # Same as Color(1, 0, 0)
+    var red = Color8(255, 0, 0)             # Same as Color(1, 0, 0).
     var dark_blue = Color8(0, 0, 51)        # Same as Color(0, 0, 0.2).
     var my_color = Color8(306, 255, 0, 102) # Same as Color(1.2, 1, 0, 0.4).
 
@@ -736,10 +738,10 @@ An optional ``message`` can be shown in addition to the generic "Assertion faile
 
     # Imagine we always want speed to be between 0 and 20.
     var speed = -10
-    assert(speed < 20) # True, the program will continue
-    assert(speed >= 0) # False, the program will stop
-    assert(speed >= 0 and speed < 20) # You can also combine the two conditional statements in one check
-    assert(speed < 20, "the speed limit is 20") # Show a message
+    assert(speed < 20) # True, the program will continue.
+    assert(speed >= 0) # False, the program will stop.
+    assert(speed >= 0 and speed < 20) # You can also combine the two conditional statements in one check.
+    assert(speed < 20, "the speed limit is 20") # Show a message.
 
 .. rst-class:: classref-item-separator
 
@@ -886,7 +888,7 @@ Returns the length of the given Variant ``var``. The length can be the character
 
 Returns a :ref:`Resource<class_Resource>` from the filesystem located at the absolute ``path``. Unless it's already referenced elsewhere (such as in another script or in the scene), the resource is loaded from disk on function call, which might cause a slight delay, especially when loading large scenes. To avoid unnecessary delays when loading something multiple times, either store the resource in a variable or use :ref:`preload<class_@GDScript_method_preload>`.
 
-\ **Note:** Resource paths can be obtained by right-clicking on a resource in the FileSystem dock and choosing "Copy Path" or by dragging the file from the FileSystem dock into the script.
+\ **Note:** Resource paths can be obtained by right-clicking on a resource in the FileSystem dock and choosing "Copy Path", or by dragging the file from the FileSystem dock into the current script.
 
 ::
 
@@ -911,7 +913,7 @@ This function is a simplified version of :ref:`ResourceLoader.load<class_Resourc
 
 Returns a :ref:`Resource<class_Resource>` from the filesystem located at ``path``. During run-time, the resource is loaded when the script is being parsed. This function effectively acts as a reference to that resource. Note that this function requires ``path`` to be a constant :ref:`String<class_String>`. If you want to load a resource from a dynamic/variable path, use :ref:`load<class_@GDScript_method_load>`.
 
-\ **Note:** Resource paths can be obtained by right clicking on a resource in the Assets Panel and choosing "Copy Path" or by dragging the file from the FileSystem dock into the script.
+\ **Note:** Resource paths can be obtained by right-clicking on a resource in the Assets Panel and choosing "Copy Path", or by dragging the file from the FileSystem dock into the current script.
 
 ::
 

classes/[email protected]

@@ -2351,7 +2351,7 @@ Command (on macOS) or Meta/Windows key mask.
 
 :ref:`KeyModifierMask<enum_@GlobalScope_KeyModifierMask>` **KEY_MASK_CTRL** = ``268435456``
 
-Ctrl key mask.
+Control key mask.
 
 .. _class_@GlobalScope_constant_KEY_MASK_KPAD:
 
@@ -2417,7 +2417,7 @@ Middle mouse button.
 
 :ref:`MouseButton<enum_@GlobalScope_MouseButton>` **MOUSE_BUTTON_WHEEL_UP** = ``4``
 
-Mouse wheel up.
+Mouse wheel scrolling up.
 
 .. _class_@GlobalScope_constant_MOUSE_BUTTON_WHEEL_DOWN:
 
@@ -2425,7 +2425,7 @@ Mouse wheel up.
 
 :ref:`MouseButton<enum_@GlobalScope_MouseButton>` **MOUSE_BUTTON_WHEEL_DOWN** = ``5``
 
-Mouse wheel down.
+Mouse wheel scrolling down.
 
 .. _class_@GlobalScope_constant_MOUSE_BUTTON_WHEEL_LEFT:
 
@@ -3716,7 +3716,7 @@ Hints that a string property is a password, and every character is replaced with
 
 :ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_MAX** = ``37``
 
-
+Represents the size of the :ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` enum.
 
 .. rst-class:: classref-item-separator
 
@@ -3902,7 +3902,7 @@ When duplicating a resource with :ref:`Resource.duplicate<class_Resource_method_
 
 :ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_HIGH_END_GFX** = ``2097152``
 
-The property is only shown in the editor if modern renderers are supported (GLES3 is excluded).
+The property is only shown in the editor if modern renderers are supported (the Compatibility rendering method is excluded).
 
 .. _class_@GlobalScope_constant_PROPERTY_USAGE_NODE_PATH_FROM_SCENE_ROOT:
 
@@ -6166,7 +6166,8 @@ In GDScript, this is the equivalent of the ``**`` operator.
 
 ::
 
-    pow(2, 5) # Returns 32
+    pow(2, 5)   # Returns 32.0
+    pow(4, 1.5) # Returns 8.0
 
 .. rst-class:: classref-item-separator
 
@@ -6954,15 +6955,15 @@ Converts a formatted ``string`` that was returned by :ref:`var_to_str<class_@Glo
 
  .. code-tab:: gdscript
 
-    var a = '{ "a": 1, "b": 2 }' # a is a String
-    var b = str_to_var(a)        # b is a Dictionary
-    print(b["a"])                # Prints 1
+    var data = '{ "a": 1, "b": 2 }' # data is a String
+    var dict = str_to_var(data)     # dict is a Dictionary
+    print(dict["a"])                # Prints 1
 
  .. code-tab:: csharp
 
-    string a = "{ \"a\": 1, \"b\": 2 }";        // a is a string
-    var b = GD.StrToVar(a).AsGodotDictionary(); // b is a Dictionary
-    GD.Print(b["a"]);                           // Prints 1
+    string data = "{ \"a\": 1, \"b\": 2 }";           // data is a string
+    var dict = GD.StrToVar(data).AsGodotDictionary(); // dict is a Dictionary
+    GD.Print(dict["a"]);                              // Prints 1
 
 
 

classes/class_animationnodeanimation.rst

@@ -67,7 +67,7 @@ enum **PlayMode**:
 
 :ref:`PlayMode<enum_AnimationNodeAnimation_PlayMode>` **PLAY_MODE_FORWARD** = ``0``
 
-
+Plays animation in forward direction.
 
 .. _class_AnimationNodeAnimation_constant_PLAY_MODE_BACKWARD:
 
@@ -75,7 +75,7 @@ enum **PlayMode**:
 
 :ref:`PlayMode<enum_AnimationNodeAnimation_PlayMode>` **PLAY_MODE_BACKWARD** = ``1``
 
-
+Plays animation in backward direction.
 
 .. rst-class:: classref-section-separator
 

classes/class_animationnodeoneshot.rst

@@ -21,6 +21,41 @@ Description
 
 A resource to add to an :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`. This node will execute a sub-animation and return once it finishes. Blend times for fading in and out can be customized, as well as filters.
 
+After setting the request and changing the animation playback, the one-shot node automatically clears the request on the next process frame by setting its ``request`` value to :ref:`ONE_SHOT_REQUEST_NONE<class_AnimationNodeOneShot_constant_ONE_SHOT_REQUEST_NONE>`.
+
+
+.. tabs::
+
+ .. code-tab:: gdscript
+
+    # Play child animation connected to "shot" port.
+    animation_tree.set("parameters/OneShot/request", AnimationNodeOneShot.ONE_SHOT_REQUEST_FIRE)
+    # Alternative syntax (same result as above).
+    animation_tree["parameters/OneShot/request"] = AnimationNodeOneShot.ONE_SHOT_REQUEST_FIRE
+    
+    # Abort child animation connected to "shot" port.
+    animation_tree.set("parameters/OneShot/request", AnimationNodeOneShot.ONE_SHOT_REQUEST_ABORT)
+    # Alternative syntax (same result as above).
+    animation_tree["parameters/OneShot/request"] = AnimationNodeOneShot.ONE_SHOT_REQUEST_ABORT
+    
+    # Get current state (read-only).
+    animation_tree.get("parameters/OneShot/active"))
+    # Alternative syntax (same result as above).
+    animation_tree["parameters/OneShot/active"]
+
+ .. code-tab:: csharp
+
+    // Play child animation connected to "shot" port.
+    animationTree.Set("parameters/OneShot/request", AnimationNodeOneShot.ONE_SHOT_REQUEST_FIRE);
+    
+    // Abort child animation connected to "shot" port.
+    animationTree.Set("parameters/OneShot/request", AnimationNodeOneShot.ONE_SHOT_REQUEST_ABORT);
+    
+    // Get current state (read-only).
+    animationTree.Get("parameters/OneShot/active");
+
+
+
 .. rst-class:: classref-introduction-group
 
 Tutorials
@@ -73,7 +108,7 @@ enum **OneShotRequest**:
 
 :ref:`OneShotRequest<enum_AnimationNodeOneShot_OneShotRequest>` **ONE_SHOT_REQUEST_NONE** = ``0``
 
-
+The default state of the request. Nothing is done.
 
 .. _class_AnimationNodeOneShot_constant_ONE_SHOT_REQUEST_FIRE:
 
@@ -81,7 +116,7 @@ enum **OneShotRequest**:
 
 :ref:`OneShotRequest<enum_AnimationNodeOneShot_OneShotRequest>` **ONE_SHOT_REQUEST_FIRE** = ``1``
 
-
+The request to play the animation connected to "shot" port.
 
 .. _class_AnimationNodeOneShot_constant_ONE_SHOT_REQUEST_ABORT:
 
@@ -89,7 +124,7 @@ enum **OneShotRequest**:
 
 :ref:`OneShotRequest<enum_AnimationNodeOneShot_OneShotRequest>` **ONE_SHOT_REQUEST_ABORT** = ``2``
 
-
+The request to stop the animation connected to "shot" port.
 
 .. rst-class:: classref-item-separator
 
@@ -107,7 +142,7 @@ enum **MixMode**:
 
 :ref:`MixMode<enum_AnimationNodeOneShot_MixMode>` **MIX_MODE_BLEND** = ``0``
 
-
+Blends two animations. See also :ref:`AnimationNodeBlend2<class_AnimationNodeBlend2>`.
 
 .. _class_AnimationNodeOneShot_constant_MIX_MODE_ADD:
 
@@ -115,7 +150,7 @@ enum **MixMode**:
 
 :ref:`MixMode<enum_AnimationNodeOneShot_MixMode>` **MIX_MODE_ADD** = ``1``
 
-
+Blends two animations additively. See also :ref:`AnimationNodeAdd2<class_AnimationNodeAdd2>`.
 
 .. rst-class:: classref-section-separator
 
@@ -139,6 +174,8 @@ Property Descriptions
 
 If ``true``, the sub-animation will restart automatically after finishing.
 
+In other words, to start auto restarting, the animation must be played once with the :ref:`ONE_SHOT_REQUEST_FIRE<class_AnimationNodeOneShot_constant_ONE_SHOT_REQUEST_FIRE>` request. The :ref:`ONE_SHOT_REQUEST_ABORT<class_AnimationNodeOneShot_constant_ONE_SHOT_REQUEST_ABORT>` request stops the auto restarting, but it does not disable the :ref:`autorestart<class_AnimationNodeOneShot_property_autorestart>` itself. So, the :ref:`ONE_SHOT_REQUEST_FIRE<class_AnimationNodeOneShot_constant_ONE_SHOT_REQUEST_FIRE>` request will start auto restarting again.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -188,9 +225,7 @@ If :ref:`autorestart<class_AnimationNodeOneShot_property_autorestart>` is ``true
 - void **set_fadein_time** **(** :ref:`float<class_float>` value **)**
 - :ref:`float<class_float>` **get_fadein_time** **(** **)**
 
-.. container:: contribute
-
-	There is currently no description for this property. Please help us by :ref:`contributing one <doc_updating_the_class_reference>`!
+The fade-in duration. For example, setting this to ``1.0`` for a 5 second length animation will produce a crossfade that starts at 0 second and ends at 1 second during the animation.
 
 .. rst-class:: classref-item-separator
 
@@ -207,9 +242,7 @@ If :ref:`autorestart<class_AnimationNodeOneShot_property_autorestart>` is ``true
 - void **set_fadeout_time** **(** :ref:`float<class_float>` value **)**
 - :ref:`float<class_float>` **get_fadeout_time** **(** **)**
 
-.. container:: contribute
-
-	There is currently no description for this property. Please help us by :ref:`contributing one <doc_updating_the_class_reference>`!
+The fade-out duration. For example, setting this to ``1.0`` for a 5 second length animation will produce a crossfade that starts at 4 second and ends at 5 second during the animation.
 
 .. rst-class:: classref-item-separator
 
@@ -226,9 +259,7 @@ If :ref:`autorestart<class_AnimationNodeOneShot_property_autorestart>` is ``true
 - void **set_mix_mode** **(** :ref:`MixMode<enum_AnimationNodeOneShot_MixMode>` value **)**
 - :ref:`MixMode<enum_AnimationNodeOneShot_MixMode>` **get_mix_mode** **(** **)**
 
-.. container:: contribute
-
-	There is currently no description for this property. Please help us by :ref:`contributing one <doc_updating_the_class_reference>`!
+The blend type.
 
 .. |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_animationnodestatemachineplayback.rst

@@ -102,9 +102,9 @@ Method Descriptions
 
 :ref:`float<class_float>` **get_current_length** **(** **)** |const|
 
-.. container:: contribute
+Returns the current state length.
 
-	There is currently no description for this method. Please help us by :ref:`contributing one <doc_updating_the_class_reference>`!
+\ **Note:** It is possible that any :ref:`AnimationRootNode<class_AnimationRootNode>` can be nodes as well as animations. This means that there can be multiple animations within a single state. Which animation length has priority depends on the nodes connected inside it. Also, if a transition does not reset, the remaining length at that point will be returned.
 
 .. rst-class:: classref-item-separator
 
@@ -118,6 +118,8 @@ Method Descriptions
 
 Returns the currently playing animation state.
 
+\ **Note:** When using a cross-fade, the current state changes to the next state immediately after the cross-fade begins.
+
 .. rst-class:: classref-item-separator
 
 ----

classes/class_animationnodestatemachinetransition.rst

@@ -12,9 +12,16 @@ AnimationNodeStateMachineTransition
 
 **Inherits:** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
 
-.. container:: contribute
+A resource to connect each node to make a path for :ref:`AnimationNodeStateMachine<class_AnimationNodeStateMachine>`.
 
-	There is currently no description for this class. Please help us by :ref:`contributing one <doc_updating_the_class_reference>`!
+.. rst-class:: classref-introduction-group
+
+Description
+-----------
+
+The path generated when using :ref:`AnimationNodeStateMachinePlayback.travel<class_AnimationNodeStateMachinePlayback_method_travel>` is limited to the nodes connected by **AnimationNodeStateMachineTransition**.
+
+You can set the timing and conditions of the transition in detail.
 
 .. rst-class:: classref-introduction-group
 

classes/class_animationnodesync.rst

@@ -14,9 +14,7 @@ AnimationNodeSync
 
 **Inherited By:** :ref:`AnimationNodeAdd2<class_AnimationNodeAdd2>`, :ref:`AnimationNodeAdd3<class_AnimationNodeAdd3>`, :ref:`AnimationNodeBlend2<class_AnimationNodeBlend2>`, :ref:`AnimationNodeBlend3<class_AnimationNodeBlend3>`, :ref:`AnimationNodeOneShot<class_AnimationNodeOneShot>`, :ref:`AnimationNodeTransition<class_AnimationNodeTransition>`
 
-.. container:: contribute
-
-	There is currently no description for this class. Please help us by :ref:`contributing one <doc_updating_the_class_reference>`!
+The base class for :ref:`AnimationNode<class_AnimationNode>` which has more than two input ports and needs to synchronize them.
 
 .. rst-class:: classref-reftable-group
 

classes/class_animationnodetimeseek.rst

@@ -19,7 +19,9 @@ A time-seeking animation node to be used with :ref:`AnimationTree<class_Animatio
 Description
 -----------
 
-This node can be used to cause a seek command to happen to any sub-children of the animation graph. Use this node type to play an :ref:`Animation<class_Animation>` from the start or a certain playback position inside the :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`. After setting the time and changing the animation playback, the seek node automatically goes into sleep mode on the next process frame by setting its ``seek_position`` value to ``-1.0``.
+This node can be used to cause a seek command to happen to any sub-children of the animation graph. Use this node type to play an :ref:`Animation<class_Animation>` from the start or a certain playback position inside the :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`.
+
+After setting the time and changing the animation playback, the time seek node automatically goes into sleep mode on the next process frame by setting its ``seek_request`` value to ``-1.0``.
 
 
 .. tabs::
@@ -27,22 +29,22 @@ This node can be used to cause a seek command to happen to any sub-children of t
  .. code-tab:: gdscript
 
     # Play child animation from the start.
-    animation_tree.set("parameters/Seek/seek_position", 0.0)
+    animation_tree.set("parameters/TimeSeek/seek_request", 0.0)
     # Alternative syntax (same result as above).
-    animation_tree["parameters/Seek/seek_position"] = 0.0
+    animation_tree["parameters/TimeSeek/seek_request"] = 0.0
     
     # Play child animation from 12 second timestamp.
-    animation_tree.set("parameters/Seek/seek_position", 12.0)
+    animation_tree.set("parameters/TimeSeek/seek_request", 12.0)
     # Alternative syntax (same result as above).
-    animation_tree["parameters/Seek/seek_position"] = 12.0
+    animation_tree["parameters/TimeSeek/seek_request"] = 12.0
 
  .. code-tab:: csharp
 
     // Play child animation from the start.
-    animationTree.Set("parameters/Seek/seek_position", 0.0);
+    animationTree.Set("parameters/TimeSeek/seek_request", 0.0);
     
     // Play child animation from 12 second timestamp.
-    animationTree.Set("parameters/Seek/seek_position", 12.0);
+    animationTree.Set("parameters/TimeSeek/seek_request", 12.0);
 
 
 

classes/class_animationnodetransition.rst

@@ -21,6 +21,43 @@ Description
 
 Simple state machine for cases which don't require a more advanced :ref:`AnimationNodeStateMachine<class_AnimationNodeStateMachine>`. Animations can be connected to the inputs and transition times can be specified.
 
+After setting the request and changing the animation playback, the transition node automatically clears the request on the next process frame by setting its ``transition_request`` value to empty.
+
+\ **Note:** When using a cross-fade, ``current_state`` and ``current_index`` change to the next state immediately after the cross-fade begins.
+
+
+.. tabs::
+
+ .. code-tab:: gdscript
+
+    # Play child animation connected to "state_2" port.
+    animation_tree.set("parameters/Transition/transition_request", "state_2")
+    # Alternative syntax (same result as above).
+    animation_tree["parameters/Transition/transition_request"] = "state_2"
+    
+    # Get current state name (read-only).
+    animation_tree.get("parameters/Transition/current_state")
+    # Alternative syntax (same result as above).
+    animation_tree["parameters/Transition/current_state"]
+    
+    # Get current state index (read-only).
+    animation_tree.get("parameters/Transition/current_index"))
+    # Alternative syntax (same result as above).
+    animation_tree["parameters/Transition/current_index"]
+
+ .. code-tab:: csharp
+
+    // Play child animation connected to "state_2" port.
+    animationTree.Set("parameters/Transition/transition_request", "state_2");
+    
+    // Get current state name (read-only).
+    animationTree.Get("parameters/Transition/current_state");
+    
+    // Get current state index (read-only).
+    animationTree.Get("parameters/Transition/current_index");
+
+
+
 .. rst-class:: classref-introduction-group
 
 Tutorials

classes/class_animationrootnode.rst

@@ -14,9 +14,7 @@ AnimationRootNode
 
 **Inherited By:** :ref:`AnimationNodeAnimation<class_AnimationNodeAnimation>`, :ref:`AnimationNodeBlendSpace1D<class_AnimationNodeBlendSpace1D>`, :ref:`AnimationNodeBlendSpace2D<class_AnimationNodeBlendSpace2D>`, :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`, :ref:`AnimationNodeStateMachine<class_AnimationNodeStateMachine>`
 
-.. container:: contribute
-
-	There is currently no description for this class. Please help us by :ref:`contributing one <doc_updating_the_class_reference>`!
+The :ref:`AnimationNode<class_AnimationNode>` which can be set as the root of an :ref:`AnimationTree<class_AnimationTree>`.
 
 .. |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_animationtree.rst

@@ -71,10 +71,16 @@ Methods
    +-------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | :ref:`Vector3<class_Vector3>`       | :ref:`get_root_motion_position<class_AnimationTree_method_get_root_motion_position>` **(** **)** |const|                                                                                                                                                                                             |
    +-------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`Vector3<class_Vector3>`       | :ref:`get_root_motion_position_accumulator<class_AnimationTree_method_get_root_motion_position_accumulator>` **(** **)** |const|                                                                                                                                                                     |
+   +-------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | :ref:`Quaternion<class_Quaternion>` | :ref:`get_root_motion_rotation<class_AnimationTree_method_get_root_motion_rotation>` **(** **)** |const|                                                                                                                                                                                             |
    +-------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`Quaternion<class_Quaternion>` | :ref:`get_root_motion_rotation_accumulator<class_AnimationTree_method_get_root_motion_rotation_accumulator>` **(** **)** |const|                                                                                                                                                                     |
+   +-------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | :ref:`Vector3<class_Vector3>`       | :ref:`get_root_motion_scale<class_AnimationTree_method_get_root_motion_scale>` **(** **)** |const|                                                                                                                                                                                                   |
    +-------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`Vector3<class_Vector3>`       | :ref:`get_root_motion_scale_accumulator<class_AnimationTree_method_get_root_motion_scale_accumulator>` **(** **)** |const|                                                                                                                                                                           |
+   +-------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
 .. rst-class:: classref-section-separator
 
@@ -327,7 +333,7 @@ Manually advance the animations by the specified time (in seconds).
 
 :ref:`Vector3<class_Vector3>` **get_root_motion_position** **(** **)** |const|
 
-Retrieve the motion of position with the :ref:`root_motion_track<class_AnimationTree_property_root_motion_track>` as a :ref:`Vector3<class_Vector3>` that can be used elsewhere.
+Retrieve the motion delta of position with the :ref:`root_motion_track<class_AnimationTree_property_root_motion_track>` as a :ref:`Vector3<class_Vector3>` that can be used elsewhere.
 
 If :ref:`root_motion_track<class_AnimationTree_property_root_motion_track>` is not a path to a track of type :ref:`Animation.TYPE_POSITION_3D<class_Animation_constant_TYPE_POSITION_3D>`, returns ``Vector3(0, 0, 0)``.
 
@@ -352,6 +358,58 @@ The most basic example is applying position to :ref:`CharacterBody3D<class_Chara
 
 
 
+By using this in combination with :ref:`get_root_motion_position_accumulator<class_AnimationTree_method_get_root_motion_position_accumulator>`, you can apply the root motion position more correctly to account for the rotation of the node.
+
+
+.. tabs::
+
+ .. code-tab:: gdscript
+
+    func _process(delta):
+        if Input.is_action_just_pressed("animate"):
+            state_machine.travel("Animate")
+        set_quaternion(get_quaternion() * animation_tree.get_root_motion_rotation())
+        var velocity: Vector3 = (animation_tree.get_root_motion_rotation_accumulator().inverse() * get_quaternion()) * animation_tree.get_root_motion_position() / delta
+        set_velocity(velocity)
+        move_and_slide()
+
+
+
+.. rst-class:: classref-item-separator
+
+----
+
+.. _class_AnimationTree_method_get_root_motion_position_accumulator:
+
+.. rst-class:: classref-method
+
+:ref:`Vector3<class_Vector3>` **get_root_motion_position_accumulator** **(** **)** |const|
+
+Retrieve the blended value of the position tracks with the :ref:`root_motion_track<class_AnimationTree_property_root_motion_track>` as a :ref:`Vector3<class_Vector3>` that can be used elsewhere.
+
+This is useful in cases where you want to respect the initial key values of the animation.
+
+For example, if an animation with only one key ``Vector3(0, 0, 0)`` is played in the previous frame and then an animation with only one key ``Vector3(1, 0, 1)`` is played in the next frame, the difference can be calculated as follows:
+
+
+.. tabs::
+
+ .. code-tab:: gdscript
+
+    var prev_root_motion_position_accumulator: Vector3
+    
+    func _process(delta):
+        if Input.is_action_just_pressed("animate"):
+            state_machine.travel("Animate")
+        var current_root_motion_position_accumulator: Vector3 = animation_tree.get_root_motion_position_accumulator()
+        var difference: Vector3 = current_root_motion_position_accumulator - prev_root_motion_position_accumulator
+        prev_root_motion_position_accumulator = current_root_motion_position_accumulator
+        transform.origin += difference
+
+
+
+However, if the animation loops, an unintended discrete change may occur, so this is only useful for some simple use cases.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -362,7 +420,7 @@ The most basic example is applying position to :ref:`CharacterBody3D<class_Chara
 
 :ref:`Quaternion<class_Quaternion>` **get_root_motion_rotation** **(** **)** |const|
 
-Retrieve the motion of rotation with the :ref:`root_motion_track<class_AnimationTree_property_root_motion_track>` as a :ref:`Quaternion<class_Quaternion>` that can be used elsewhere.
+Retrieve the motion delta of rotation with the :ref:`root_motion_track<class_AnimationTree_property_root_motion_track>` as a :ref:`Quaternion<class_Quaternion>` that can be used elsewhere.
 
 If :ref:`root_motion_track<class_AnimationTree_property_root_motion_track>` is not a path to a track of type :ref:`Animation.TYPE_ROTATION_3D<class_Animation_constant_TYPE_ROTATION_3D>`, returns ``Quaternion(0, 0, 0, 1)``.
 
@@ -382,6 +440,43 @@ The most basic example is applying rotation to :ref:`CharacterBody3D<class_Chara
 
 
 
+.. rst-class:: classref-item-separator
+
+----
+
+.. _class_AnimationTree_method_get_root_motion_rotation_accumulator:
+
+.. rst-class:: classref-method
+
+:ref:`Quaternion<class_Quaternion>` **get_root_motion_rotation_accumulator** **(** **)** |const|
+
+Retrieve the blended value of the rotation tracks with the :ref:`root_motion_track<class_AnimationTree_property_root_motion_track>` as a :ref:`Quaternion<class_Quaternion>` that can be used elsewhere.
+
+This is necessary to apply the root motion position correctly, taking rotation into account. See also :ref:`get_root_motion_position<class_AnimationTree_method_get_root_motion_position>`.
+
+Also, this is useful in cases where you want to respect the initial key values of the animation.
+
+For example, if an animation with only one key ``Quaternion(0, 0, 0, 1)`` is played in the previous frame and then an animation with only one key ``Quaternion(0, 0.707, 0, 0.707)`` is played in the next frame, the difference can be calculated as follows:
+
+
+.. tabs::
+
+ .. code-tab:: gdscript
+
+    var prev_root_motion_rotation_accumulator: Quaternion
+    
+    func _process(delta):
+        if Input.is_action_just_pressed("animate"):
+            state_machine.travel("Animate")
+        var current_root_motion_rotation_accumulator: Quaternion = animation_tree.get_root_motion_Quaternion_accumulator()
+        var difference: Quaternion = prev_root_motion_rotation_accumulator.inverse() * current_root_motion_rotation_accumulator
+        prev_root_motion_rotation_accumulator = current_root_motion_rotation_accumulator
+        transform.basis *= difference
+
+
+
+However, if the animation loops, an unintended discrete change may occur, so this is only useful for some simple use cases.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -392,7 +487,7 @@ The most basic example is applying rotation to :ref:`CharacterBody3D<class_Chara
 
 :ref:`Vector3<class_Vector3>` **get_root_motion_scale** **(** **)** |const|
 
-Retrieve the motion of scale with the :ref:`root_motion_track<class_AnimationTree_property_root_motion_track>` as a :ref:`Vector3<class_Vector3>` that can be used elsewhere.
+Retrieve the motion delta of scale with the :ref:`root_motion_track<class_AnimationTree_property_root_motion_track>` as a :ref:`Vector3<class_Vector3>` that can be used elsewhere.
 
 If :ref:`root_motion_track<class_AnimationTree_property_root_motion_track>` is not a path to a track of type :ref:`Animation.TYPE_SCALE_3D<class_Animation_constant_TYPE_SCALE_3D>`, returns ``Vector3(0, 0, 0)``.
 
@@ -418,6 +513,39 @@ The most basic example is applying scale to :ref:`CharacterBody3D<class_Characte
 
 
 
+.. rst-class:: classref-item-separator
+
+----
+
+.. _class_AnimationTree_method_get_root_motion_scale_accumulator:
+
+.. rst-class:: classref-method
+
+:ref:`Vector3<class_Vector3>` **get_root_motion_scale_accumulator** **(** **)** |const|
+
+Retrieve the blended value of the scale tracks with the :ref:`root_motion_track<class_AnimationTree_property_root_motion_track>` as a :ref:`Vector3<class_Vector3>` that can be used elsewhere.
+
+For example, if an animation with only one key ``Vector3(1, 1, 1)`` is played in the previous frame and then an animation with only one key ``Vector3(2, 2, 2)`` is played in the next frame, the difference can be calculated as follows:
+
+
+.. tabs::
+
+ .. code-tab:: gdscript
+
+    var prev_root_motion_scale_accumulator: Vector3
+    
+    func _process(delta):
+        if Input.is_action_just_pressed("animate"):
+            state_machine.travel("Animate")
+        var current_root_motion_scale_accumulator: Vector3 = animation_tree.get_root_motion_scale_accumulator()
+        var difference: Vector3 = current_root_motion_scale_accumulator - prev_root_motion_scale_accumulator
+        prev_root_motion_scale_accumulator = current_root_motion_scale_accumulator
+        transform.basis = transform.basis.scaled(difference)
+
+
+
+However, if the animation loops, an unintended discrete change may occur, so this is only useful for some simple use cases.
+
 .. |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.)`

classes/class_area2d.rst

@@ -12,7 +12,7 @@ Area2D
 
 **Inherits:** :ref:`CollisionObject2D<class_CollisionObject2D>` **<** :ref:`Node2D<class_Node2D>` **<** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-2D area for detection and physics and audio influence.
+2D area for detection, as well as physics and audio influence.
 
 .. rst-class:: classref-introduction-group
 

classes/class_area3d.rst

@@ -12,7 +12,7 @@ Area3D
 
 **Inherits:** :ref:`CollisionObject3D<class_CollisionObject3D>` **<** :ref:`Node3D<class_Node3D>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-3D area for detection and physics and audio influence.
+3D area for detection, as well as physics and audio influence.
 
 .. rst-class:: classref-introduction-group
 

classes/class_basematerial3d.rst

@@ -569,7 +569,7 @@ enum **Transparency**:
 
 :ref:`Transparency<enum_BaseMaterial3D_Transparency>` **TRANSPARENCY_DISABLED** = ``0``
 
-The material will not use transparency.
+The material will not use transparency. This is the fastest to render.
 
 .. _class_BaseMaterial3D_constant_TRANSPARENCY_ALPHA:
 
@@ -577,7 +577,7 @@ The material will not use transparency.
 
 :ref:`Transparency<enum_BaseMaterial3D_Transparency>` **TRANSPARENCY_ALPHA** = ``1``
 
-The material will use the texture's alpha values for transparency.
+The material will use the texture's alpha values for transparency. This is the slowest to render, and disables shadow casting.
 
 .. _class_BaseMaterial3D_constant_TRANSPARENCY_ALPHA_SCISSOR:
 
@@ -585,7 +585,7 @@ The material will use the texture's alpha values for transparency.
 
 :ref:`Transparency<enum_BaseMaterial3D_Transparency>` **TRANSPARENCY_ALPHA_SCISSOR** = ``2``
 
-The material will cut off all values below a threshold, the rest will remain opaque. The opaque portions will be rendered in the depth prepass.
+The material will cut off all values below a threshold, the rest will remain opaque. The opaque portions will be rendered in the depth prepass. This is faster to render than alpha blending, but slower than opaque rendering. This also supports casting shadows.
 
 .. _class_BaseMaterial3D_constant_TRANSPARENCY_ALPHA_HASH:
 
@@ -593,7 +593,7 @@ The material will cut off all values below a threshold, the rest will remain opa
 
 :ref:`Transparency<enum_BaseMaterial3D_Transparency>` **TRANSPARENCY_ALPHA_HASH** = ``3``
 
-The material will cut off all values below a spatially-deterministic threshold, the rest will remain opaque.
+The material will cut off all values below a spatially-deterministic threshold, the rest will remain opaque. This is faster to render than alpha blending, but slower than opaque rendering. This also supports casting shadows. Alpha hashing is suited for hair rendering.
 
 .. _class_BaseMaterial3D_constant_TRANSPARENCY_ALPHA_DEPTH_PRE_PASS:
 
@@ -601,7 +601,7 @@ The material will cut off all values below a spatially-deterministic threshold,
 
 :ref:`Transparency<enum_BaseMaterial3D_Transparency>` **TRANSPARENCY_ALPHA_DEPTH_PRE_PASS** = ``4``
 
-The material will use the texture's alpha value for transparency, but will discard fragments with an alpha of less than 0.99 during the depth prepass and fragments with an alpha less than 0.1 during the shadow pass.
+The material will use the texture's alpha value for transparency, but will discard fragments with an alpha of less than 0.99 during the depth prepass and fragments with an alpha less than 0.1 during the shadow pass. This also supports casting shadows.
 
 .. _class_BaseMaterial3D_constant_TRANSPARENCY_MAX:
 
@@ -627,7 +627,7 @@ enum **ShadingMode**:
 
 :ref:`ShadingMode<enum_BaseMaterial3D_ShadingMode>` **SHADING_MODE_UNSHADED** = ``0``
 
-The object will not receive shadows.
+The object will not receive shadows. This is the fastest to render, but it disables all interactions with lights.
 
 .. _class_BaseMaterial3D_constant_SHADING_MODE_PER_PIXEL:
 
@@ -635,7 +635,7 @@ The object will not receive shadows.
 
 :ref:`ShadingMode<enum_BaseMaterial3D_ShadingMode>` **SHADING_MODE_PER_PIXEL** = ``1``
 
-The object will be shaded per pixel. Useful for realistic shading effect.
+The object will be shaded per pixel. Useful for realistic shading effects.
 
 .. _class_BaseMaterial3D_constant_SHADING_MODE_PER_VERTEX:
 
@@ -643,7 +643,7 @@ The object will be shaded per pixel. Useful for realistic shading effect.
 
 :ref:`ShadingMode<enum_BaseMaterial3D_ShadingMode>` **SHADING_MODE_PER_VERTEX** = ``2``
 
-The object will be shaded per vertex. Useful when you want cheaper shaders and do not care about visual quality.
+The object will be shaded per vertex. Useful when you want cheaper shaders and do not care about visual quality. Not implemented yet (this mode will act like :ref:`SHADING_MODE_PER_PIXEL<class_BaseMaterial3D_constant_SHADING_MODE_PER_PIXEL>`).
 
 .. _class_BaseMaterial3D_constant_SHADING_MODE_MAX:
 
@@ -895,7 +895,7 @@ enum **CullMode**:
 
 :ref:`CullMode<enum_BaseMaterial3D_CullMode>` **CULL_BACK** = ``0``
 
-Default cull mode. The back of the object is culled when not visible. Back face triangles will be culled when facing the camera. This results in only the front side of triangles being drawn. For closed-surface meshes this means that only the exterior of the mesh will be visible.
+Default cull mode. The back of the object is culled when not visible. Back face triangles will be culled when facing the camera. This results in only the front side of triangles being drawn. For closed-surface meshes, this means that only the exterior of the mesh will be visible.
 
 .. _class_BaseMaterial3D_constant_CULL_FRONT:
 
@@ -903,7 +903,7 @@ Default cull mode. The back of the object is culled when not visible. Back face
 
 :ref:`CullMode<enum_BaseMaterial3D_CullMode>` **CULL_FRONT** = ``1``
 
-Front face triangles will be culled when facing the camera. This results in only the back side of triangles being drawn. For closed-surface meshes this means that the interior of the mesh will be drawn instead of the exterior.
+Front face triangles will be culled when facing the camera. This results in only the back side of triangles being drawn. For closed-surface meshes, this means that the interior of the mesh will be drawn instead of the exterior.
 
 .. _class_BaseMaterial3D_constant_CULL_DISABLED:
 
@@ -911,7 +911,7 @@ Front face triangles will be culled when facing the camera. This results in only
 
 :ref:`CullMode<enum_BaseMaterial3D_CullMode>` **CULL_DISABLED** = ``2``
 
-No culling is performed.
+No face culling is performed; both the front face and back face will be visible.
 
 .. rst-class:: classref-item-separator
 
@@ -947,7 +947,7 @@ Set ``ALBEDO`` to the per-vertex color specified in the mesh.
 
 Vertex colors are considered to be stored in sRGB color space and are converted to linear color space during rendering. See also :ref:`vertex_color_is_srgb<class_BaseMaterial3D_property_vertex_color_is_srgb>`.
 
-\ **Note:** Only effective when using the Vulkan Clustered or Vulkan Mobile backends.
+\ **Note:** Only effective when using the Forward+ and Mobile rendering methods.
 
 .. _class_BaseMaterial3D_constant_FLAG_USE_POINT_SIZE:
 
@@ -1175,7 +1175,7 @@ Toon blob which changes size based on roughness.
 
 :ref:`SpecularMode<enum_BaseMaterial3D_SpecularMode>` **SPECULAR_DISABLED** = ``2``
 
-No specular blob.
+No specular blob. This is slightly faster to render than other specular modes.
 
 .. rst-class:: classref-item-separator
 
@@ -1329,7 +1329,7 @@ Smoothly fades the object out based on each pixel's distance from the camera usi
 
 :ref:`DistanceFadeMode<enum_BaseMaterial3D_DistanceFadeMode>` **DISTANCE_FADE_PIXEL_DITHER** = ``2``
 
-Smoothly fades the object out based on each pixel's distance from the camera using a dither approach. Dithering discards pixels based on a set pattern to smoothly fade without enabling transparency. On certain hardware this can be faster than :ref:`DISTANCE_FADE_PIXEL_ALPHA<class_BaseMaterial3D_constant_DISTANCE_FADE_PIXEL_ALPHA>`.
+Smoothly fades the object out based on each pixel's distance from the camera using a dithering approach. Dithering discards pixels based on a set pattern to smoothly fade without enabling transparency. On certain hardware, this can be faster than :ref:`DISTANCE_FADE_PIXEL_ALPHA<class_BaseMaterial3D_constant_DISTANCE_FADE_PIXEL_ALPHA>`.
 
 .. _class_BaseMaterial3D_constant_DISTANCE_FADE_OBJECT_DITHER:
 
@@ -1337,7 +1337,7 @@ Smoothly fades the object out based on each pixel's distance from the camera usi
 
 :ref:`DistanceFadeMode<enum_BaseMaterial3D_DistanceFadeMode>` **DISTANCE_FADE_OBJECT_DITHER** = ``3``
 
-Smoothly fades the object out based on the object's distance from the camera using a dither approach. Dithering discards pixels based on a set pattern to smoothly fade without enabling transparency. On certain hardware this can be faster than :ref:`DISTANCE_FADE_PIXEL_ALPHA<class_BaseMaterial3D_constant_DISTANCE_FADE_PIXEL_ALPHA>`.
+Smoothly fades the object out based on the object's distance from the camera using a dithering approach. Dithering discards pixels based on a set pattern to smoothly fade without enabling transparency. On certain hardware, this can be faster than :ref:`DISTANCE_FADE_PIXEL_ALPHA<class_BaseMaterial3D_constant_DISTANCE_FADE_PIXEL_ALPHA>` and :ref:`DISTANCE_FADE_PIXEL_DITHER<class_BaseMaterial3D_constant_DISTANCE_FADE_PIXEL_DITHER>`.
 
 .. rst-class:: classref-section-separator
 
@@ -2201,7 +2201,9 @@ If ``true``, the object is rendered at the same size regardless of distance.
 - void **set_grow_enabled** **(** :ref:`bool<class_bool>` value **)**
 - :ref:`bool<class_bool>` **is_grow_enabled** **(** **)**
 
-If ``true``, enables the vertex grow setting. See :ref:`grow_amount<class_BaseMaterial3D_property_grow_amount>`.
+If ``true``, enables the vertex grow setting. This can be used to create mesh-based outlines using a second material pass and its :ref:`cull_mode<class_BaseMaterial3D_property_cull_mode>` set to :ref:`CULL_FRONT<class_BaseMaterial3D_constant_CULL_FRONT>`. See also :ref:`grow_amount<class_BaseMaterial3D_property_grow_amount>`.
+
+\ **Note:** Vertex growth cannot create new vertices, which means that visible gaps may occur in sharp corners. This can be alleviated by designing the mesh to use smooth normals exclusively using `face weighted normals <https://wiki.polycount.com/wiki/Face_weighted_normals>`__ in the 3D authoring software. In this case, grow will be able to join every outline together, just like in the original mesh.
 
 .. rst-class:: classref-item-separator
 
@@ -2218,7 +2220,7 @@ If ``true``, enables the vertex grow setting. See :ref:`grow_amount<class_BaseMa
 - void **set_grow** **(** :ref:`float<class_float>` value **)**
 - :ref:`float<class_float>` **get_grow** **(** **)**
 
-Grows object vertices in the direction of their normals.
+Grows object vertices in the direction of their normals. Only effective if :ref:`grow<class_BaseMaterial3D_property_grow>` is ``true``.
 
 .. rst-class:: classref-item-separator
 
@@ -2523,7 +2525,7 @@ If ``true``, depth testing is disabled and the object will be drawn in render or
 - void **set_feature** **(** :ref:`Feature<enum_BaseMaterial3D_Feature>` feature, :ref:`bool<class_bool>` enable **)**
 - :ref:`bool<class_bool>` **get_feature** **(** :ref:`Feature<enum_BaseMaterial3D_Feature>` feature **)** |const|
 
-If ``true``, normal mapping is enabled.
+If ``true``, normal mapping is enabled. This has a slight performance cost, especially on mobile GPUs.
 
 .. rst-class:: classref-item-separator
 
@@ -2888,7 +2890,9 @@ Specifies the channel of the :ref:`roughness_texture<class_BaseMaterial3D_proper
 - void **set_shading_mode** **(** :ref:`ShadingMode<enum_BaseMaterial3D_ShadingMode>` value **)**
 - :ref:`ShadingMode<enum_BaseMaterial3D_ShadingMode>` **get_shading_mode** **(** **)**
 
-Sets whether the shading takes place per-pixel or per-vertex. Per-vertex lighting is faster, making it the best choice for mobile applications, however it looks considerably worse than per-pixel.
+Sets whether the shading takes place, per-pixel, per-vertex or unshaded. Per-vertex lighting is faster, making it the best choice for mobile applications, however it looks considerably worse than per-pixel. Unshaded rendering is the fastest, but disables all interactions with lights.
+
+\ **Note:** Setting the shading mode vertex shading currently has no effect, as vertex shading is not implemented yet.
 
 .. rst-class:: classref-item-separator
 
@@ -3130,7 +3134,7 @@ Repeat flags for the texture. See :ref:`TextureFilter<enum_BaseMaterial3D_Textur
 - void **set_transparency** **(** :ref:`Transparency<enum_BaseMaterial3D_Transparency>` value **)**
 - :ref:`Transparency<enum_BaseMaterial3D_Transparency>` **get_transparency** **(** **)**
 
-If ``true``, transparency is enabled on the body. See also :ref:`blend_mode<class_BaseMaterial3D_property_blend_mode>`.
+If ``true``, transparency is enabled on the body. Some transparency modes will disable shadow casting. Any transparency mode other than Disabled has a greater performance impact compared to opaque rendering. See also :ref:`blend_mode<class_BaseMaterial3D_property_blend_mode>`.
 
 .. rst-class:: classref-item-separator
 
@@ -3359,7 +3363,7 @@ If ``true``, triplanar mapping for ``UV2`` is calculated in world space rather t
 
 If ``true``, vertex colors are considered to be stored in sRGB color space and are converted to linear color space during rendering. If ``false``, vertex colors are considered to be stored in linear color space and are rendered as-is. See also :ref:`albedo_texture_force_srgb<class_BaseMaterial3D_property_albedo_texture_force_srgb>`.
 
-\ **Note:** Only effective when using the Vulkan Clustered or Vulkan Mobile backends.
+\ **Note:** Only effective when using the Forward+ and Mobile rendering methods, not Compatibility.
 
 .. rst-class:: classref-item-separator
 

classes/class_camera2d.rst

@@ -667,6 +667,8 @@ The angular, asymptotic speed of the camera's rotation smoothing effect when :re
 
 The camera's zoom. A zoom of ``Vector(2, 2)`` doubles the size seen in the viewport. A zoom of ``Vector(0.5, 0.5)`` halves the size seen in the viewport.
 
+\ **Note:** :ref:`FontFile.oversampling<class_FontFile_property_oversampling>` does *not* take **Camera2D** zoom into account. This means that zooming in/out will cause bitmap fonts and rasterized (non-MSDF) dynamic fonts to appear blurry or pixelated unless the font is part of a :ref:`CanvasLayer<class_CanvasLayer>` that makes it ignore camera zoom. To ensure text remains crisp regardless of zoom, you can enable MSDF font rendering by enabling :ref:`ProjectSettings.gui/theme/default_font_multichannel_signed_distance_field<class_ProjectSettings_property_gui/theme/default_font_multichannel_signed_distance_field>` (applies to the default project font only), or enabling **Multichannel Signed Distance Field** in the import options of a DynamicFont for custom fonts. On system fonts, :ref:`SystemFont.multichannel_signed_distance_field<class_SystemFont_property_multichannel_signed_distance_field>` can be enabled in the inspector.
+
 .. rst-class:: classref-section-separator
 
 ----

classes/class_cameraattributesphysical.rst

@@ -25,6 +25,8 @@ When used in a :ref:`WorldEnvironment<class_WorldEnvironment>` it provides defau
 
 The default settings are intended for use in an outdoor environment, tips for settings for use in an indoor environment can be found in each setting's documentation.
 
+\ **Note:** Depth of field blur is only supported in the Forward+ and Mobile rendering methods, not Compatibility.
+
 .. rst-class:: classref-reftable-group
 
 Properties

classes/class_cameraattributespractical.rst

@@ -141,6 +141,8 @@ Objects further from the :ref:`Camera3D<class_Camera3D>` by this amount will be
 
 Enables depth of field blur for objects further than :ref:`dof_blur_far_distance<class_CameraAttributesPractical_property_dof_blur_far_distance>`. Strength of blur is controlled by :ref:`dof_blur_amount<class_CameraAttributesPractical_property_dof_blur_amount>` and modulated by :ref:`dof_blur_far_transition<class_CameraAttributesPractical_property_dof_blur_far_transition>`.
 
+\ **Note:** Depth of field blur is only supported in the Forward+ and Mobile rendering methods, not Compatibility.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -192,6 +194,8 @@ Objects closer from the :ref:`Camera3D<class_Camera3D>` by this amount will be b
 
 Enables depth of field blur for objects closer than :ref:`dof_blur_near_distance<class_CameraAttributesPractical_property_dof_blur_near_distance>`. Strength of blur is controlled by :ref:`dof_blur_amount<class_CameraAttributesPractical_property_dof_blur_amount>` and modulated by :ref:`dof_blur_near_transition<class_CameraAttributesPractical_property_dof_blur_near_transition>`.
 
+\ **Note:** Depth of field blur is only supported in the Forward+ and Mobile rendering methods, not Compatibility.
+
 .. rst-class:: classref-item-separator
 
 ----

classes/class_canvasitem.rst

@@ -1091,6 +1091,8 @@ void **draw_set_transform** **(** :ref:`Vector2<class_Vector2>` position, :ref:`
 
 Sets a custom transform for drawing via components. Anything drawn afterwards will be transformed by this.
 
+\ **Note:** :ref:`FontFile.oversampling<class_FontFile_property_oversampling>` does *not* take ``scale`` into account. This means that scaling up/down will cause bitmap fonts and rasterized (non-MSDF) dynamic fonts to appear blurry or pixelated. To ensure text remains crisp regardless of scale, you can enable MSDF font rendering by enabling :ref:`ProjectSettings.gui/theme/default_font_multichannel_signed_distance_field<class_ProjectSettings_property_gui/theme/default_font_multichannel_signed_distance_field>` (applies to the default project font only), or enabling **Multichannel Signed Distance Field** in the import options of a DynamicFont for custom fonts. On system fonts, :ref:`SystemFont.multichannel_signed_distance_field<class_SystemFont_property_multichannel_signed_distance_field>` can be enabled in the inspector.
+
 .. rst-class:: classref-item-separator
 
 ----

classes/class_canvaslayer.rst

@@ -172,7 +172,7 @@ Scales the layer when using :ref:`follow_viewport_enabled<class_CanvasLayer_prop
 - void **set_layer** **(** :ref:`int<class_int>` value **)**
 - :ref:`int<class_int>` **get_layer** **(** **)**
 
-Layer index for draw order. Lower values are drawn first.
+Layer index for draw order. Lower values are drawn behind higher values.
 
 .. rst-class:: classref-item-separator
 

classes/class_characterbody2d.rst

@@ -573,10 +573,10 @@ Returns a :ref:`KinematicCollision2D<class_KinematicCollision2D>`, which contain
 
  .. code-tab:: csharp
 
-    for (int i = 0; i < GetSlideCount(); i++)
+    for (int i = 0; i < GetSlideCollisionCount(); i++)
     {
         KinematicCollision2D collision = GetSlideCollision(i);
-        GD.Print("Collided with: ", (collision.Collider as Node).Name);
+        GD.Print("Collided with: ", (collision.GetCollider() as Node).Name);
     }
 
 

classes/class_codeedit.rst

@@ -777,7 +777,7 @@ Sets whether line folding is allowed.
 - void **set_line_length_guidelines** **(** :ref:`int[]<class_int>` value **)**
 - :ref:`int[]<class_int>` **get_line_length_guidelines** **(** **)**
 
-Draws vertical lines at the provided columns. The first entry is considered a main hard guideline and is draw more prominently
+Draws vertical lines at the provided columns. The first entry is considered a main hard guideline and is draw more prominently.
 
 .. rst-class:: classref-item-separator
 

classes/class_color.rst

@@ -1791,7 +1791,7 @@ Returns the light intensity of the color, as a value between 0.0 and 1.0 (inclus
 
 :ref:`Color<class_Color>` **hex** **(** :ref:`int<class_int>` hex **)** |static|
 
-Returns the **Color** associated with the provided ``hex`` integer in 32-bit ARGB format (8 bits per channel, alpha channel first).
+Returns the **Color** associated with the provided ``hex`` integer in 32-bit RGBA format (8 bits per channel, alpha channel first).
 
 In GDScript and C#, the :ref:`int<class_int>` is best visualized with hexadecimal notation (``"0x"`` prefix).
 
@@ -1800,15 +1800,15 @@ In GDScript and C#, the :ref:`int<class_int>` is best visualized with hexadecima
 
  .. code-tab:: gdscript
 
-    var red = Color.hex(0xffff0000)
-    var dark_cyan = Color.hex(0xff008b8b)
-    var my_color = Color.hex(0xa4bbefd2)
+    var red = Color.hex(0xff0000ff)
+    var dark_cyan = Color.hex(0x008b8bff)
+    var my_color = Color.hex(0xbbefd2a4)
 
  .. code-tab:: csharp
 
-    var red = new Color(0xffff0000);
-    var dark_cyan = new Color(0xff008b8b);
-    var my_color = new Color(0xa4bbefd2);
+    var red = new Color(0xff0000ff);
+    var dark_cyan = new Color(0x008b8bff);
+    var my_color = new Color(0xbbefd2a4);
 
 
 
@@ -1822,7 +1822,7 @@ In GDScript and C#, the :ref:`int<class_int>` is best visualized with hexadecima
 
 :ref:`Color<class_Color>` **hex64** **(** :ref:`int<class_int>` hex **)** |static|
 
-Returns the **Color** associated with the provided ``hex`` integer in 64-bit ARGB format (16 bits per channel, alpha channel first).
+Returns the **Color** associated with the provided ``hex`` integer in 64-bit RGBA format (16 bits per channel, alpha channel first).
 
 In GDScript and C#, the :ref:`int<class_int>` is best visualized with hexadecimal notation (``"0x"`` prefix).
 

classes/class_control.rst

@@ -1685,7 +1685,9 @@ Helper property to access :ref:`rotation<class_Control_property_rotation>` in de
 
 The node's scale, relative to its :ref:`size<class_Control_property_size>`. Change this property to scale the node around its :ref:`pivot_offset<class_Control_property_pivot_offset>`. The Control's :ref:`tooltip_text<class_Control_property_tooltip_text>` will also scale according to this value.
 
-\ **Note:** This property is mainly intended to be used for animation purposes. Text inside the Control will look pixelated or blurry when the Control is scaled. To support multiple resolutions in your project, use an appropriate viewport stretch mode as described in the :doc:`documentation <../tutorials/rendering/multiple_resolutions>` instead of scaling Controls individually.
+\ **Note:** This property is mainly intended to be used for animation purposes. To support multiple resolutions in your project, use an appropriate viewport stretch mode as described in the :doc:`documentation <../tutorials/rendering/multiple_resolutions>` instead of scaling Controls individually.
+
+\ **Note:** :ref:`FontFile.oversampling<class_FontFile_property_oversampling>` does *not* take **Control** :ref:`scale<class_Control_property_scale>` into account. This means that scaling up/down will cause bitmap fonts and rasterized (non-MSDF) dynamic fonts to appear blurry or pixelated. To ensure text remains crisp regardless of scale, you can enable MSDF font rendering by enabling :ref:`ProjectSettings.gui/theme/default_font_multichannel_signed_distance_field<class_ProjectSettings_property_gui/theme/default_font_multichannel_signed_distance_field>` (applies to the default project font only), or enabling **Multichannel Signed Distance Field** in the import options of a DynamicFont for custom fonts. On system fonts, :ref:`SystemFont.multichannel_signed_distance_field<class_SystemFont_property_multichannel_signed_distance_field>` can be enabled in the inspector.
 
 \ **Note:** If the Control node is a child of a :ref:`Container<class_Container>` node, the scale will be reset to ``Vector2(1, 1)`` when the scene is instantiated. To set the Control's scale when it's instantiated, wait for one frame using ``await get_tree().process_frame`` then set its :ref:`scale<class_Control_property_scale>` property.
 
@@ -2726,7 +2728,7 @@ void **grab_focus** **(** **)**
 
 Steal the focus from another control and become the focused control (see :ref:`focus_mode<class_Control_property_focus_mode>`).
 
-\ **Note**: Using this method together with :ref:`Callable.call_deferred<class_Callable_method_call_deferred>` makes it more reliable, especially when called inside :ref:`Node._ready<class_Node_method__ready>`.
+\ **Note:** Using this method together with :ref:`Callable.call_deferred<class_Callable_method_call_deferred>` makes it more reliable, especially when called inside :ref:`Node._ready<class_Node_method__ready>`.
 
 .. rst-class:: classref-item-separator
 

classes/class_cpuparticles3d.rst

@@ -810,7 +810,7 @@ Maximum damping.
 - void **set_param_min** **(** :ref:`Parameter<enum_CPUParticles3D_Parameter>` param, :ref:`float<class_float>` value **)**
 - :ref:`float<class_float>` **get_param_min** **(** :ref:`Parameter<enum_CPUParticles3D_Parameter>` param **)** |const|
 
-Minimum damping
+Minimum damping.
 
 .. rst-class:: classref-item-separator
 

classes/class_decal.rst

@@ -27,6 +27,8 @@ The :ref:`Texture2D<class_Texture2D>`\ s associated with the Decal are automatic
 
 \ **Note:** Decals cannot affect an underlying material's transparency, regardless of its transparency mode (alpha blend, alpha scissor, alpha hash, opaque pre-pass). This means translucent or transparent areas of a material will remain translucent or transparent even if an opaque decal is applied on them.
 
+\ **Note:** Decals are only supported in the Forward+ and Mobile rendering methods, not Compatibility. When using the Mobile rendering method, only 8 decals can be displayed on each mesh resource. Attempting to display more than 8 decals on a single mesh resource will result in decals flickering in and out as the camera moves.
+
 \ **Note:** When using the Mobile rendering method, decals will only correctly affect meshes whose visibility AABB intersects with the decal's AABB. If using a shader to deform the mesh in a way that makes it go outside its AABB, :ref:`GeometryInstance3D.extra_cull_margin<class_GeometryInstance3D_property_extra_cull_margin>` must be increased on the mesh. Otherwise, the decal may not be visible on the mesh.
 
 .. rst-class:: classref-reftable-group
@@ -313,7 +315,9 @@ Fades the Decal if the angle between the Decal's :ref:`AABB<class_AABB>` and the
 - void **set_size** **(** :ref:`Vector3<class_Vector3>` value **)**
 - :ref:`Vector3<class_Vector3>` **get_size** **(** **)**
 
-Sets the size of the :ref:`AABB<class_AABB>` used by the decal. The AABB goes from ``-size/2`` to ``size/2``.
+Sets the size of the :ref:`AABB<class_AABB>` used by the decal. All dimensions must be set to a value greater than zero (they will be clamped to ``0.001`` if this is not the case). The AABB goes from ``-size/2`` to ``size/2``.
+
+\ **Note:** To improve culling efficiency of "hard surface" decals, set their :ref:`upper_fade<class_Decal_property_upper_fade>` and :ref:`lower_fade<class_Decal_property_lower_fade>` to ``0.0`` and set the Y component of the :ref:`size<class_Decal_property_size>` as low as possible. This will reduce the decals' AABB size without affecting their appearance.
 
 .. rst-class:: classref-item-separator
 

classes/class_directionallight2d.rst

@@ -21,6 +21,8 @@ Description
 
 A directional light is a type of :ref:`Light2D<class_Light2D>` node that models an infinite number of parallel rays covering the entire scene. It is used for lights with strong intensity that are located far away from the scene (for example: to model sunlight or moonlight).
 
+\ **Note:** **DirectionalLight2D** does not support light cull masks (but it supports shadow cull masks). It will always light up 2D nodes, regardless of the 2D node's :ref:`CanvasItem.light_mask<class_CanvasItem_property_light_mask>`.
+
 .. rst-class:: classref-introduction-group
 
 Tutorials

classes/class_displayserver.rst

@@ -744,7 +744,7 @@ I-beam cursor shape. This is used by default when hovering a control that accept
 
 :ref:`CursorShape<enum_DisplayServer_CursorShape>` **CURSOR_POINTING_HAND** = ``2``
 
-Pointing hand cursor shape. This is used by default when hovering a :ref:`LinkButton<class_LinkButton>` or an URL tag in a :ref:`RichTextLabel<class_RichTextLabel>`.⋅
+Pointing hand cursor shape. This is used by default when hovering a :ref:`LinkButton<class_LinkButton>` or an URL tag in a :ref:`RichTextLabel<class_RichTextLabel>`.
 
 .. _class_DisplayServer_constant_CURSOR_CROSS:
 
@@ -1118,7 +1118,7 @@ enum **VSyncMode**:
 
 :ref:`VSyncMode<enum_DisplayServer_VSyncMode>` **VSYNC_DISABLED** = ``0``
 
-No vertical synchronization, which means the engine will display frames as fast as possible (tearing may be visible). Framerate is unlimited (nonwithstanding :ref:`Engine.max_fps<class_Engine_property_max_fps>`).
+No vertical synchronization, which means the engine will display frames as fast as possible (tearing may be visible). Framerate is unlimited (nonwithstanding :ref:`Engine.max_fps<class_Engine_property_max_fps>`). Not supported when using the Compatibility rendering method.
 
 .. _class_DisplayServer_constant_VSYNC_ENABLED:
 
@@ -1134,7 +1134,7 @@ Default vertical synchronization mode, the image is displayed only on vertical b
 
 :ref:`VSyncMode<enum_DisplayServer_VSyncMode>` **VSYNC_ADAPTIVE** = ``2``
 
-Behaves like :ref:`VSYNC_DISABLED<class_DisplayServer_constant_VSYNC_DISABLED>` when the framerate drops below the screen's refresh rate to reduce stuttering (tearing may be visible). Otherwise, vertical synchronization is enabled to avoid tearing. Framerate is limited by the monitor refresh rate (nonwithstanding :ref:`Engine.max_fps<class_Engine_property_max_fps>`).
+Behaves like :ref:`VSYNC_DISABLED<class_DisplayServer_constant_VSYNC_DISABLED>` when the framerate drops below the screen's refresh rate to reduce stuttering (tearing may be visible). Otherwise, vertical synchronization is enabled to avoid tearing. Framerate is limited by the monitor refresh rate (nonwithstanding :ref:`Engine.max_fps<class_Engine_property_max_fps>`). Not supported when using the Compatibility rendering method.
 
 .. _class_DisplayServer_constant_VSYNC_MAILBOX:
 
@@ -1144,7 +1144,7 @@ Behaves like :ref:`VSYNC_DISABLED<class_DisplayServer_constant_VSYNC_DISABLED>`
 
 Displays the most recent image in the queue on vertical blanking intervals, while rendering to the other images (no tearing is visible). Framerate is unlimited (nonwithstanding :ref:`Engine.max_fps<class_Engine_property_max_fps>`).
 
-Although not guaranteed, the images can be rendered as fast as possible, which may reduce input lag (also called "Fast" V-Sync mode). :ref:`VSYNC_MAILBOX<class_DisplayServer_constant_VSYNC_MAILBOX>` works best when at least twice as many frames as the display refresh rate are rendered.
+Although not guaranteed, the images can be rendered as fast as possible, which may reduce input lag (also called "Fast" V-Sync mode). :ref:`VSYNC_MAILBOX<class_DisplayServer_constant_VSYNC_MAILBOX>` works best when at least twice as many frames as the display refresh rate are rendered. Not supported when using the Compatibility rendering method.
 
 .. rst-class:: classref-item-separator
 
@@ -2263,7 +2263,7 @@ Sets number of state of an multistate item. See :ref:`global_menu_add_multistate
 
 void **global_menu_set_item_radio_checkable** **(** :ref:`String<class_String>` menu_root, :ref:`int<class_int>` idx, :ref:`bool<class_bool>` checkable **)**
 
-Sets the type of the item at the specified index ``idx`` to radio button. If ``false``, sets the type of the item to plain text
+Sets the type of the item at the specified index ``idx`` to radio button. If ``false``, sets the type of the item to plain text.
 
 \ **Note:** This is purely cosmetic; you must add the logic for checking/unchecking items in radio groups.
 
@@ -3603,6 +3603,8 @@ See :ref:`VSyncMode<enum_DisplayServer_VSyncMode>` for possible values and how t
 
 Depending on the platform and used renderer, the engine will fall back to :ref:`VSYNC_ENABLED<class_DisplayServer_constant_VSYNC_ENABLED>` if the desired mode is not supported.
 
+\ **Note:** V-Sync modes other than :ref:`VSYNC_ENABLED<class_DisplayServer_constant_VSYNC_ENABLED>` are only supported in the Forward+ and Mobile rendering methods, not Compatibility.
+
 .. rst-class:: classref-item-separator
 
 ----

classes/class_engine.rst

@@ -94,10 +94,12 @@ Methods
    +---------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | :ref:`bool<class_bool>`                           | :ref:`is_in_physics_frame<class_Engine_method_is_in_physics_frame>` **(** **)** |const|                                                                      |
    +---------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
-   | void                                              | :ref:`register_script_language<class_Engine_method_register_script_language>` **(** :ref:`ScriptLanguage<class_ScriptLanguage>` language **)**               |
+   | :ref:`Error<enum_@GlobalScope_Error>`             | :ref:`register_script_language<class_Engine_method_register_script_language>` **(** :ref:`ScriptLanguage<class_ScriptLanguage>` language **)**               |
    +---------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | void                                              | :ref:`register_singleton<class_Engine_method_register_singleton>` **(** :ref:`StringName<class_StringName>` name, :ref:`Object<class_Object>` instance **)** |
    +---------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`Error<enum_@GlobalScope_Error>`             | :ref:`unregister_script_language<class_Engine_method_unregister_script_language>` **(** :ref:`ScriptLanguage<class_ScriptLanguage>` language **)**           |
+   +---------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | void                                              | :ref:`unregister_singleton<class_Engine_method_unregister_singleton>` **(** :ref:`StringName<class_StringName>` name **)**                                   |
    +---------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
@@ -644,10 +646,18 @@ Returns ``true`` if the game is inside the fixed process and physics phase of th
 
 .. rst-class:: classref-method
 
-void **register_script_language** **(** :ref:`ScriptLanguage<class_ScriptLanguage>` language **)**
+:ref:`Error<enum_@GlobalScope_Error>` **register_script_language** **(** :ref:`ScriptLanguage<class_ScriptLanguage>` language **)**
 
 Registers a :ref:`ScriptLanguage<class_ScriptLanguage>` instance to be available with ``ScriptServer``.
 
+Returns:
+
+- :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_ALREADY_EXISTS<class_@GlobalScope_constant_ERR_ALREADY_EXISTS>` if ``ScriptServer`` already contains a language with similar extension/name/type
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -664,6 +674,24 @@ Registers the given object as a singleton, globally available under ``name``.
 
 ----
 
+.. _class_Engine_method_unregister_script_language:
+
+.. rst-class:: classref-method
+
+:ref:`Error<enum_@GlobalScope_Error>` **unregister_script_language** **(** :ref:`ScriptLanguage<class_ScriptLanguage>` language **)**
+
+Unregisters the :ref:`ScriptLanguage<class_ScriptLanguage>` instance from ``ScriptServer``.
+
+Returns:
+
+- :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``
+
+.. rst-class:: classref-item-separator
+
+----
+
 .. _class_Engine_method_unregister_singleton:
 
 .. rst-class:: classref-method

classes/class_environment.rst

@@ -604,6 +604,8 @@ The global contrast value of the rendered scene (default value is 1). Effective
 
 If ``true``, enables the ``adjustment_*`` properties provided by this resource. If ``false``, modifications to the ``adjustment_*`` properties will have no effect on the rendered scene.
 
+\ **Note:** Adjustments are only supported in the Forward+ and Mobile rendering methods, not Compatibility.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -1001,6 +1003,8 @@ The bloom's intensity. If set to a value higher than ``0``, this will make glow
 
 If ``true``, the glow effect is enabled.
 
+\ **Note:** Glow is only supported in the Forward+ and Mobile rendering methods, not Compatibility. When using the Mobile rendering method, glow will look different due to the lower dynamic range available in the Mobile rendering method.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -1050,7 +1054,7 @@ The bleed scale of the HDR glow.
 - void **set_glow_hdr_bleed_threshold** **(** :ref:`float<class_float>` value **)**
 - :ref:`float<class_float>` **get_glow_hdr_bleed_threshold** **(** **)**
 
-The lower threshold of the HDR glow. When using the OpenGL renderer (which doesn't support HDR), this needs to be below ``1.0`` for glow to be visible. A value of ``0.9`` works well in this case.
+The lower threshold of the HDR glow. When using the Mobile rendering method (which only supports a lower dynamic range up to ``2.0``), this may need to be below ``1.0`` for glow to be visible. A value of ``0.9`` works well in this case. This value also needs to be decreased below ``1.0`` when using glow in 2D, as 2D rendering is performed in SDR.
 
 .. rst-class:: classref-item-separator
 
@@ -1067,7 +1071,7 @@ The lower threshold of the HDR glow. When using the OpenGL renderer (which doesn
 - void **set_glow_intensity** **(** :ref:`float<class_float>` value **)**
 - :ref:`float<class_float>` **get_glow_intensity** **(** **)**
 
-The overall brightness multiplier of the glow effect. When using the OpenGL renderer, this should be increased to ``1.5`` to compensate for the lack of HDR rendering.
+The overall brightness multiplier of the glow effect. When using the Mobile rendering method (which only supports a lower dynamic range up to ``2.0``), this should be increased to ``1.5`` to compensate.
 
 .. rst-class:: classref-item-separator
 
@@ -1273,7 +1277,7 @@ If ``true``, glow levels will be normalized so that summed together their intens
 - void **set_glow_strength** **(** :ref:`float<class_float>` value **)**
 - :ref:`float<class_float>` **get_glow_strength** **(** **)**
 
-The strength of the glow effect. This applies as the glow is blurred across the screen and increases the distance and intensity of the blur. When using the OpenGL renderer, this should be increased to 1.3 to compensate for the lack of HDR rendering.
+The strength of the glow effect. This applies as the glow is blurred across the screen and increases the distance and intensity of the blur. When using the Mobile rendering method, this should be increased to compensate for the lower dynamic range.
 
 .. rst-class:: classref-item-separator
 
@@ -1364,6 +1368,8 @@ The number of cascades to use for SDFGI (between 1 and 8). A higher number of ca
 
 If ``true``, enables signed distance field global illumination for meshes that have their :ref:`GeometryInstance3D.gi_mode<class_GeometryInstance3D_property_gi_mode>` set to :ref:`GeometryInstance3D.GI_MODE_STATIC<class_GeometryInstance3D_constant_GI_MODE_STATIC>`. SDFGI is a real-time global illumination technique that works well with procedurally generated and user-built levels, including in situations where geometry is created during gameplay. The signed distance field is automatically generated around the camera as it moves. Dynamic lights are supported, but dynamic occluders and emissive surfaces are not.
 
+\ **Note:** SDFGI is only supported in the Forward+ rendering method, not Mobile or Compatibility.
+
 \ **Performance:** SDFGI is relatively demanding on the GPU and is not suited to low-end hardware such as integrated graphics (consider :ref:`LightmapGI<class_LightmapGI>` instead). To improve SDFGI performance, enable :ref:`ProjectSettings.rendering/global_illumination/gi/use_half_resolution<class_ProjectSettings_property_rendering/global_illumination/gi/use_half_resolution>` in the Project Settings.
 
 \ **Note:** Meshes should have sufficiently thick walls to avoid light leaks (avoid one-sided walls). For interior levels, enclose your level geometry in a sufficiently large box and bridge the loops to close the mesh.
@@ -1610,6 +1616,8 @@ Sets the strength of the additional level of detail for the screen-space ambient
 
 If ``true``, the screen-space ambient occlusion effect is enabled. This darkens objects' corners and cavities to simulate ambient light not reaching the entire object as in real life. This works well for small, dynamic objects, but baked lighting or ambient occlusion textures will do a better job at displaying ambient occlusion on large static objects. Godot uses a form of SSAO called Adaptive Screen Space Ambient Occlusion which is itself a form of Horizon Based Ambient Occlusion.
 
+\ **Note:** SSAO is only supported in the Forward+ rendering method, not Mobile or Compatibility.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -1729,6 +1737,8 @@ The amount that the screen-space ambient occlusion effect is allowed to blur ove
 
 If ``true``, the screen-space indirect lighting effect is enabled. Screen space indirect lighting is a form of indirect lighting that allows diffuse light to bounce between nearby objects. Screen-space indirect lighting works very similarly to screen-space ambient occlusion, in that it only affects a limited range. It is intended to be used along with a form of proper global illumination like SDFGI or :ref:`VoxelGI<class_VoxelGI>`. Screen-space indirect lighting is not affected by individual light's :ref:`Light3D.light_indirect_energy<class_Light3D_property_light_indirect_energy>`.
 
+\ **Note:** SSIL is only supported in the Forward+ rendering method, not Mobile or Compatibility.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -1831,6 +1841,8 @@ The depth tolerance for screen-space reflections.
 
 If ``true``, screen-space reflections are enabled. Screen-space reflections are more accurate than reflections from :ref:`VoxelGI<class_VoxelGI>`\ s or :ref:`ReflectionProbe<class_ReflectionProbe>`\ s, but are slower and can't reflect surfaces occluded by others.
 
+\ **Note:** SSR is only supported in the Forward+ rendering method, not Mobile or Compatibility.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -2075,7 +2087,7 @@ The brightness of the emitted light from the volumetric fog.
 
 Enables the volumetric fog effect. Volumetric fog uses a screen-aligned froxel buffer to calculate accurate volumetric scattering in the short to medium range. Volumetric fog interacts with :ref:`FogVolume<class_FogVolume>`\ s and lights to calculate localized and global fog. Volumetric fog uses a PBR single-scattering model based on extinction, scattering, and emission which it exposes to users as density, albedo, and emission.
 
-\ **Note:** Volumetric fog is only available in the forward plus renderer. It is not available in the mobile renderer or the compatibility renderer.
+\ **Note:** Volumetric fog is only supported in the Forward+ rendering method, not Mobile or Compatibility.
 
 .. rst-class:: classref-item-separator
 

classes/class_fileaccess.rst

@@ -689,6 +689,8 @@ Returns a SHA-256 :ref:`String<class_String>` representing the file at the given
 
 Returns the next :ref:`Variant<class_Variant>` value from the file. If ``allow_objects`` is ``true``, decoding objects is allowed.
 
+Internally, this uses the same decoding mechanism as the :ref:`@GlobalScope.bytes_to_var<class_@GlobalScope_method_bytes_to_var>` method.
+
 \ **Warning:** Deserialized objects can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats such as remote code execution.
 
 .. rst-class:: classref-item-separator
@@ -1002,6 +1004,8 @@ void **store_var** **(** :ref:`Variant<class_Variant>` value, :ref:`bool<class_b
 
 Stores any Variant value in the file. If ``full_objects`` is ``true``, encoding objects is allowed (and can potentially include code).
 
+Internally, this uses the same encoding mechanism as the :ref:`@GlobalScope.var_to_bytes<class_@GlobalScope_method_var_to_bytes>` method.
+
 \ **Note:** Not all properties are included. Only properties that are configured with the :ref:`@GlobalScope.PROPERTY_USAGE_STORAGE<class_@GlobalScope_constant_PROPERTY_USAGE_STORAGE>` flag set will be serialized. You can add a new usage flag to a property by overriding the :ref:`Object._get_property_list<class_Object_method__get_property_list>` method in your class. You can also check how property usage is configured by calling :ref:`Object._get_property_list<class_Object_method__get_property_list>`. See :ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` for the possible usage flags.
 
 .. |virtual| replace:: :abbr:`virtual (This method should typically be overridden by the user to have any effect.)`

classes/class_font.rst

@@ -400,7 +400,7 @@ Returns the spacing for the given ``type`` (see :ref:`SpacingType<enum_TextServe
 
 :ref:`Vector2<class_Vector2>` **get_string_size** **(** :ref:`String<class_String>` text, :ref:`HorizontalAlignment<enum_@GlobalScope_HorizontalAlignment>` alignment=0, :ref:`float<class_float>` width=-1, :ref:`int<class_int>` font_size=16, :ref:`JustificationFlag<enum_TextServer_JustificationFlag>` jst_flags=3, :ref:`Direction<enum_TextServer_Direction>` direction=0, :ref:`Orientation<enum_TextServer_Orientation>` orientation=0 **)** |const|
 
-Returns the size of a bounding box of a single-line string, taking kerning and advance into account. See also :ref:`get_multiline_string_size<class_Font_method_get_multiline_string_size>` and :ref:`draw_string<class_Font_method_draw_string>`.
+Returns the size of a bounding box of a single-line string, taking kerning, advance and subpixel positioning into account. See also :ref:`get_multiline_string_size<class_Font_method_get_multiline_string_size>` and :ref:`draw_string<class_Font_method_draw_string>`.
 
 For example, to get the string size as displayed by a single-line Label, use:
 
@@ -418,6 +418,8 @@ For example, to get the string size as displayed by a single-line Label, use:
 
 
 
+\ **Note:** Since kerning, advance and subpixel positioning are taken into account by :ref:`get_string_size<class_Font_method_get_string_size>`, using separate :ref:`get_string_size<class_Font_method_get_string_size>` calls on substrings of a string then adding the results together will return a different result compared to using a single :ref:`get_string_size<class_Font_method_get_string_size>` call on the full string.
+
 \ **Note:** Real height of the string is context-dependent and can be significantly different from the value returned by :ref:`get_height<class_Font_method_get_height>`.
 
 .. rst-class:: classref-item-separator

classes/class_fontvariation.rst

@@ -176,7 +176,7 @@ Extra spacing at the bottom of the line in pixels.
 - void **set_spacing** **(** :ref:`SpacingType<enum_TextServer_SpacingType>` spacing, :ref:`int<class_int>` value **)**
 - :ref:`int<class_int>` **get_spacing** **(** **)**
 
-Extra spacing between graphical glyphs
+Extra spacing between graphical glyphs.
 
 .. rst-class:: classref-item-separator
 

classes/class_graphedit.rst

@@ -19,6 +19,8 @@ GraphEdit is a control responsible for displaying and manipulating graph-like da
 Description
 -----------
 
+**Note:** Please be aware that this node will undergo extensive refactoring in a future 4.x version involving compatibility-breaking API changes.
+
 GraphEdit provides tools for creation, manipulation, and display of various graphs. Its main purpose in the engine is to power the visual programming systems, such as visual shaders, but it is also available for use in user projects.
 
 GraphEdit by itself is only an empty container, representing an infinite grid where :ref:`GraphNode<class_GraphNode>`\ s can be placed. Each :ref:`GraphNode<class_GraphNode>` represent a node in the graph, a single unit of data in the connected scheme. GraphEdit, in turn, helps to control various interactions with nodes and between nodes. When the user attempts to connect, disconnect, or close a :ref:`GraphNode<class_GraphNode>`, a signal is emitted in the GraphEdit, but no action is taken by default. It is the responsibility of the programmer utilizing this control to implement the necessary logic to determine how each request should be handled.

classes/class_graphnode.rst

@@ -19,6 +19,8 @@ GraphNode is a :ref:`Container<class_Container>` control that represents a singl
 Description
 -----------
 
+**Note:** Please be aware that this node will undergo extensive refactoring in a future 4.x version involving compatibility-breaking API changes.
+
 GraphNode allows to create nodes for a :ref:`GraphEdit<class_GraphEdit>` graph with customizable content based on its child :ref:`Control<class_Control>`\ s. GraphNode is a :ref:`Container<class_Container>` and is responsible for placing its children on screen. This works similar to :ref:`VBoxContainer<class_VBoxContainer>`. Children, in turn, provide GraphNode with so-called slots, each of which can have a connection port on either side. This is similar to how :ref:`TabContainer<class_TabContainer>` uses children to create the tabs.
 
 Each GraphNode slot is defined by its index and can provide the node with up to two ports: one on the left, and one on the right. By convention the left port is also referred to as the input port and the right port is referred to as the output port. Each port can be enabled and configured individually, using different type and color. The type is an arbitrary value that you can define using your own considerations. The parent :ref:`GraphEdit<class_GraphEdit>` will receive this information on each connect and disconnect request.

classes/class_httprequest.rst

@@ -171,8 +171,7 @@ Can be used to make HTTP requests, i.e. download or upload files or web content
             GD.PushError("Couldn't load the image.");
         }
     
-        var texture = new ImageTexture();
-        texture.CreateFromImage(image);
+        var texture = ImageTexture.CreateFromImage(image);
     
         // Display the image in a TextureRect node.
         var textureRect = new TextureRect();

classes/class_image.rst

@@ -1623,8 +1623,7 @@ Sets the :ref:`Color<class_Color>` of the pixel at ``(x, y)`` to ``color``.
 
     var img_width = 10
     var img_height = 5
-    var img = Image.new()
-    img.create(img_width, img_height, false, Image.FORMAT_RGBA8)
+    var img = Image.create(img_width, img_height, false, Image.FORMAT_RGBA8)
     
     img.set_pixel(1, 2, Color.RED) # Sets the color at (1, 2) to red.
 
@@ -1632,8 +1631,7 @@ Sets the :ref:`Color<class_Color>` of the pixel at ``(x, y)`` to ``color``.
 
     int imgWidth = 10;
     int imgHeight = 5;
-    var img = new Image();
-    img.Create(imgWidth, imgHeight, false, Image.Format.Rgba8);
+    var img = Image.Create(imgWidth, imgHeight, false, Image.Format.Rgba8);
     
     img.SetPixel(1, 2, Colors.Red); // Sets the color at (1, 2) to red.
 
@@ -1662,8 +1660,7 @@ Sets the :ref:`Color<class_Color>` of the pixel at ``point`` to ``color``.
 
     var img_width = 10
     var img_height = 5
-    var img = Image.new()
-    img.create(img_width, img_height, false, Image.FORMAT_RGBA8)
+    var img = Image.create(img_width, img_height, false, Image.FORMAT_RGBA8)
     
     img.set_pixelv(Vector2i(1, 2), Color.RED) # Sets the color at (1, 2) to red.
 
@@ -1671,8 +1668,7 @@ Sets the :ref:`Color<class_Color>` of the pixel at ``point`` to ``color``.
 
     int imgWidth = 10;
     int imgHeight = 5;
-    var img = new Image();
-    img.Create(imgWidth, imgHeight, false, Image.Format.Rgba8);
+    var img = Image.Create(imgWidth, imgHeight, false, Image.Format.Rgba8);
     
     img.SetPixelv(new Vector2I(1, 2), Colors.Red); // Sets the color at (1, 2) to red.
 

classes/class_light2d.rst

@@ -262,7 +262,9 @@ The Light2D's energy value. The larger the value, the stronger the light.
 - void **set_item_cull_mask** **(** :ref:`int<class_int>` value **)**
 - :ref:`int<class_int>` **get_item_cull_mask** **(** **)**
 
-The layer mask. Only objects with a matching mask will be affected by the Light2D.
+The layer mask. Only objects with a matching :ref:`CanvasItem.light_mask<class_CanvasItem_property_light_mask>` will be affected by the Light2D. See also :ref:`shadow_item_cull_mask<class_Light2D_property_shadow_item_cull_mask>`, which affects which objects can cast shadows.
+
+\ **Note:** :ref:`range_item_cull_mask<class_Light2D_property_range_item_cull_mask>` is ignored by :ref:`DirectionalLight2D<class_DirectionalLight2D>`, which will always light a 2D node regardless of the 2D node's :ref:`CanvasItem.light_mask<class_CanvasItem_property_light_mask>`.
 
 .. rst-class:: classref-item-separator
 
@@ -415,7 +417,7 @@ Smoothing value for shadows. Higher values will result in softer shadows, at the
 - void **set_item_shadow_cull_mask** **(** :ref:`int<class_int>` value **)**
 - :ref:`int<class_int>` **get_item_shadow_cull_mask** **(** **)**
 
-The shadow mask. Used with :ref:`LightOccluder2D<class_LightOccluder2D>` to cast shadows. Only occluders with a matching light mask will cast shadows.
+The shadow mask. Used with :ref:`LightOccluder2D<class_LightOccluder2D>` to cast shadows. Only occluders with a matching :ref:`CanvasItem.light_mask<class_CanvasItem_property_light_mask>` will cast shadows. See also :ref:`range_item_cull_mask<class_Light2D_property_range_item_cull_mask>`, which affects which objects can *receive* the light.
 
 .. rst-class:: classref-section-separator
 

classes/class_light3d.rst

@@ -450,10 +450,12 @@ If ``true``, the light only appears in the editor and will not be visible at run
 - void **set_param** **(** :ref:`Param<enum_Light3D_Param>` param, :ref:`float<class_float>` value **)**
 - :ref:`float<class_float>` **get_param** **(** :ref:`Param<enum_Light3D_Param>` param **)** |const|
 
-The light's angular size in degrees. Increasing this will make shadows softer at greater distances. Only available for :ref:`DirectionalLight3D<class_DirectionalLight3D>`\ s. For reference, the Sun from the Earth is approximately ``0.5``.
+The light's angular size in degrees. Increasing this will make shadows softer at greater distances (also called percentage-closer soft shadows, or PCSS). Only available for :ref:`DirectionalLight3D<class_DirectionalLight3D>`\ s. For reference, the Sun from the Earth is approximately ``0.5``. Increasing this value above ``0.0`` for lights with shadows enabled will have a noticeable performance cost due to PCSS.
 
 \ **Note:** :ref:`light_angular_distance<class_Light3D_property_light_angular_distance>` is not affected by :ref:`Node3D.scale<class_Node3D_property_scale>` (the light's scale or its parent's scale).
 
+\ **Note:** PCSS for directional lights is only supported in the Forward+ rendering method, not Mobile or Compatibility.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -619,6 +621,8 @@ If ``true``, the light's effect is reversed, darkening areas and casting bright
 
 \ **Note:** Unlike :ref:`BaseMaterial3D<class_BaseMaterial3D>` whose filter mode can be adjusted on a per-material basis, the filter mode for light projector textures is set globally with :ref:`ProjectSettings.rendering/textures/light_projectors/filter<class_ProjectSettings_property_rendering/textures/light_projectors/filter>`.
 
+\ **Note:** Light projector textures are only supported in the Forward+ and Mobile rendering methods, not Compatibility.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -634,10 +638,12 @@ If ``true``, the light's effect is reversed, darkening areas and casting bright
 - void **set_param** **(** :ref:`Param<enum_Light3D_Param>` param, :ref:`float<class_float>` value **)**
 - :ref:`float<class_float>` **get_param** **(** :ref:`Param<enum_Light3D_Param>` param **)** |const|
 
-The size of the light in Godot units. Only available for :ref:`OmniLight3D<class_OmniLight3D>`\ s and :ref:`SpotLight3D<class_SpotLight3D>`\ s. Increasing this value will make the light fade out slower and shadows appear blurrier. This can be used to simulate area lights to an extent.
+The size of the light in Godot units. Only available for :ref:`OmniLight3D<class_OmniLight3D>`\ s and :ref:`SpotLight3D<class_SpotLight3D>`\ s. Increasing this value will make the light fade out slower and shadows appear blurrier (also called percentage-closer soft shadows, or PCSS). This can be used to simulate area lights to an extent. Increasing this value above ``0.0`` for lights with shadows enabled will have a noticeable performance cost due to PCSS.
 
 \ **Note:** :ref:`light_size<class_Light3D_property_light_size>` is not affected by :ref:`Node3D.scale<class_Node3D_property_scale>` (the light's scale or its parent's scale).
 
+\ **Note:** PCSS for positional lights is only supported in the Forward+ and Mobile rendering methods, not Compatibility.
+
 .. rst-class:: classref-item-separator
 
 ----

classes/class_marshalls.rst

@@ -84,6 +84,8 @@ Returns a decoded string corresponding to the Base64-encoded string ``base64_str
 
 Returns a decoded :ref:`Variant<class_Variant>` corresponding to the Base64-encoded string ``base64_str``. If ``allow_objects`` is ``true``, decoding objects is allowed.
 
+Internally, this uses the same decoding mechanism as the :ref:`@GlobalScope.bytes_to_var<class_@GlobalScope_method_bytes_to_var>` method.
+
 \ **Warning:** Deserialized objects can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats such as remote code execution.
 
 .. rst-class:: classref-item-separator
@@ -122,6 +124,8 @@ Returns a Base64-encoded string of the UTF-8 string ``utf8_str``.
 
 Returns a Base64-encoded string of the :ref:`Variant<class_Variant>` ``variant``. If ``full_objects`` is ``true``, encoding objects is allowed (and can potentially include code).
 
+Internally, this uses the same encoding mechanism as the :ref:`@GlobalScope.var_to_bytes<class_@GlobalScope_method_var_to_bytes>` method.
+
 .. |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.)`

classes/class_navigationserver2d.rst

@@ -12,7 +12,7 @@ NavigationServer2D
 
 **Inherits:** :ref:`Object<class_Object>`
 
-Server interface for low-level 2D navigation access
+Server interface for low-level 2D navigation access.
 
 .. rst-class:: classref-introduction-group
 

classes/class_navigationserver3d.rst

@@ -12,7 +12,7 @@ NavigationServer3D
 
 **Inherits:** :ref:`Object<class_Object>`
 
-Server interface for low-level 3D navigation access
+Server interface for low-level 3D navigation access.
 
 .. rst-class:: classref-introduction-group
 

classes/class_ninepatchrect.rst

@@ -113,8 +113,6 @@ Stretches the center texture across the NinePatchRect. This may cause the textur
 
 Repeats the center texture across the NinePatchRect. This won't cause any visible distortion. The texture must be seamless for this to work without displaying artifacts between edges.
 
-\ **Note:** Only supported when using the Vulkan renderer. When using the OpenGL renderer, this will behave like :ref:`AXIS_STRETCH_MODE_STRETCH<class_NinePatchRect_constant_AXIS_STRETCH_MODE_STRETCH>`.
-
 .. _class_NinePatchRect_constant_AXIS_STRETCH_MODE_TILE_FIT:
 
 .. rst-class:: classref-enumeration-constant
@@ -123,8 +121,6 @@ Repeats the center texture across the NinePatchRect. This won't cause any visibl
 
 Repeats the center texture across the NinePatchRect, but will also stretch the texture to make sure each tile is visible in full. This may cause the texture to be distorted, but less than :ref:`AXIS_STRETCH_MODE_STRETCH<class_NinePatchRect_constant_AXIS_STRETCH_MODE_STRETCH>`. The texture must be seamless for this to work without displaying artifacts between edges.
 
-\ **Note:** Only supported when using the Vulkan renderer. When using the OpenGL renderer, this will behave like :ref:`AXIS_STRETCH_MODE_STRETCH<class_NinePatchRect_constant_AXIS_STRETCH_MODE_STRETCH>`.
-
 .. rst-class:: classref-section-separator
 
 ----

classes/class_object.rst

@@ -713,7 +713,7 @@ Calls the ``method`` on the object and returns the result. Unlike :ref:`call<cla
 
 
 
-\ **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
+\ **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
 

classes/class_omnilight3d.rst

@@ -21,6 +21,8 @@ Description
 
 An Omnidirectional light is a type of :ref:`Light3D<class_Light3D>` that emits light in all directions. The light is attenuated by distance and this attenuation can be configured by changing its energy, radius, and attenuation parameters.
 
+\ **Note:** When using the Mobile rendering method, only 8 omni lights can be displayed on each mesh resource. Attempting to display more than 8 omni lights on a single mesh resource will result in omni lights flickering in and out as the camera moves. When using the Compatibility rendering method, only 8 omni lights can be displayed on each mesh resource by default, but this can be increased by adjusting :ref:`ProjectSettings.rendering/limits/opengl/max_lights_per_object<class_ProjectSettings_property_rendering/limits/opengl/max_lights_per_object>`.
+
 \ **Note:** When using the Mobile or Compatibility rendering methods, omni lights will only correctly affect meshes whose visibility AABB intersects with the light's AABB. If using a shader to deform the mesh in a way that makes it go outside its AABB, :ref:`GeometryInstance3D.extra_cull_margin<class_GeometryInstance3D_property_extra_cull_margin>` must be increased on the mesh. Otherwise, the light may not be visible on the mesh.
 
 .. rst-class:: classref-introduction-group

classes/class_packetpeer.rst

@@ -136,6 +136,8 @@ Returns the error state of the last packet received (via :ref:`get_packet<class_
 
 Gets a Variant. If ``allow_objects`` is ``true``, decoding objects is allowed.
 
+Internally, this uses the same decoding mechanism as the :ref:`@GlobalScope.bytes_to_var<class_@GlobalScope_method_bytes_to_var>` method.
+
 \ **Warning:** Deserialized objects can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats such as remote code execution.
 
 .. rst-class:: classref-item-separator
@@ -162,6 +164,8 @@ Sends a raw packet.
 
 Sends a :ref:`Variant<class_Variant>` as a packet. If ``full_objects`` is ``true``, encoding objects is allowed (and can potentially include code).
 
+Internally, this uses the same encoding mechanism as the :ref:`@GlobalScope.var_to_bytes<class_@GlobalScope_method_var_to_bytes>` method.
+
 .. |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.)`

classes/class_physicsdirectspacestate3d.rst

@@ -43,7 +43,7 @@ Methods
    +-------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | :ref:`PackedFloat32Array<class_PackedFloat32Array>`   | :ref:`cast_motion<class_PhysicsDirectSpaceState3D_method_cast_motion>` **(** :ref:`PhysicsShapeQueryParameters3D<class_PhysicsShapeQueryParameters3D>` parameters **)**                                               |
    +-------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-   | :ref:`PackedVector2Array[]<class_PackedVector2Array>` | :ref:`collide_shape<class_PhysicsDirectSpaceState3D_method_collide_shape>` **(** :ref:`PhysicsShapeQueryParameters3D<class_PhysicsShapeQueryParameters3D>` parameters, :ref:`int<class_int>` max_results=32 **)**     |
+   | :ref:`PackedVector3Array[]<class_PackedVector3Array>` | :ref:`collide_shape<class_PhysicsDirectSpaceState3D_method_collide_shape>` **(** :ref:`PhysicsShapeQueryParameters3D<class_PhysicsShapeQueryParameters3D>` parameters, :ref:`int<class_int>` max_results=32 **)**     |
    +-------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | :ref:`Dictionary<class_Dictionary>`                   | :ref:`get_rest_info<class_PhysicsDirectSpaceState3D_method_get_rest_info>` **(** :ref:`PhysicsShapeQueryParameters3D<class_PhysicsShapeQueryParameters3D>` parameters **)**                                           |
    +-------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -83,7 +83,7 @@ Returns an array with the safe and unsafe proportions (between 0 and 1) of the m
 
 .. rst-class:: classref-method
 
-:ref:`PackedVector2Array[]<class_PackedVector2Array>` **collide_shape** **(** :ref:`PhysicsShapeQueryParameters3D<class_PhysicsShapeQueryParameters3D>` parameters, :ref:`int<class_int>` max_results=32 **)**
+:ref:`PackedVector3Array[]<class_PackedVector3Array>` **collide_shape** **(** :ref:`PhysicsShapeQueryParameters3D<class_PhysicsShapeQueryParameters3D>` parameters, :ref:`int<class_int>` max_results=32 **)**
 
 Checks the intersections of a shape, given through a :ref:`PhysicsShapeQueryParameters3D<class_PhysicsShapeQueryParameters3D>` object, against the space. The resulting array contains a list of points where the shape intersects another. Like with :ref:`intersect_shape<class_PhysicsDirectSpaceState3D_method_intersect_shape>`, the number of returned results can be limited to save processing time.
 

classes/class_pointlight2d.rst

@@ -19,7 +19,7 @@ Positional 2D light source.
 Description
 -----------
 
-Casts light in a 2D environment. This light's shape is defined by a (usually grayscale) texture
+Casts light in a 2D environment. This light's shape is defined by a (usually grayscale) texture.
 
 .. rst-class:: classref-introduction-group
 

classes/class_projectsettings.rst

@@ -197,8 +197,6 @@ Properties
    +---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+
    | :ref:`int<class_int>`                             | :ref:`debug/gdscript/warnings/static_called_on_instance<class_ProjectSettings_property_debug/gdscript/warnings/static_called_on_instance>`                                                                 | ``1``                                                                                            |
    +---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+
-   | :ref:`bool<class_bool>`                           | :ref:`debug/gdscript/warnings/treat_warnings_as_errors<class_ProjectSettings_property_debug/gdscript/warnings/treat_warnings_as_errors>`                                                                   | ``false``                                                                                        |
-   +---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+
    | :ref:`int<class_int>`                             | :ref:`debug/gdscript/warnings/unassigned_variable<class_ProjectSettings_property_debug/gdscript/warnings/unassigned_variable>`                                                                             | ``1``                                                                                            |
    +---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+
    | :ref:`int<class_int>`                             | :ref:`debug/gdscript/warnings/unassigned_variable_op_assign<class_ProjectSettings_property_debug/gdscript/warnings/unassigned_variable_op_assign>`                                                         | ``1``                                                                                            |
@@ -2361,18 +2359,6 @@ When set to ``warn`` or ``error``, produces a warning or an error respectively w
 
 ----
 
-.. _class_ProjectSettings_property_debug/gdscript/warnings/treat_warnings_as_errors:
-
-.. rst-class:: classref-property
-
-:ref:`bool<class_bool>` **debug/gdscript/warnings/treat_warnings_as_errors** = ``false``
-
-If ``true``, all warnings will be reported as if they are errors.
-
-.. rst-class:: classref-item-separator
-
-----
-
 .. _class_ProjectSettings_property_debug/gdscript/warnings/unassigned_variable:
 
 .. rst-class:: classref-property
@@ -3263,7 +3249,9 @@ Sets the V-Sync mode for the main game window.
 
 See :ref:`VSyncMode<enum_DisplayServer_VSyncMode>` for possible values and how they affect the behavior of your application.
 
-Depending on the platform and used renderer, the engine will fall back to ``Enabled`` if the desired mode is not supported.
+Depending on the platform and used renderer, the engine will fall back to **Enabled** if the desired mode is not supported.
+
+\ **Note:** V-Sync modes other than **Enabled** are only supported in the Forward+ and Mobile rendering methods, not Compatibility.
 
 \ **Note:** This property is only read when the project starts. To change the V-Sync mode at runtime, call :ref:`DisplayServer.window_set_vsync_mode<class_DisplayServer_method_window_set_vsync_mode>` instead.
 
@@ -3621,7 +3609,7 @@ Path to a custom :ref:`Font<class_Font>` resource to use as default for all GUI
 
 :ref:`int<class_int>` **gui/theme/default_font_antialiasing** = ``1``
 
-Font anti-aliasing mode. See :ref:`FontFile.antialiasing<class_FontFile_property_antialiasing>`,
+Font anti-aliasing mode. See :ref:`FontFile.antialiasing<class_FontFile_property_antialiasing>`.
 
 .. rst-class:: classref-item-separator
 
@@ -4169,7 +4157,7 @@ macOS specific override for the shortcut to delete a word.
 
 :ref:`Dictionary<class_Dictionary>` **input/ui_text_caret_add_above**
 
-Default :ref:`InputEventAction<class_InputEventAction>` to add an additional caret above every caret of a text
+Default :ref:`InputEventAction<class_InputEventAction>` to add an additional caret above every caret of a text.
 
 .. rst-class:: classref-item-separator
 
@@ -4181,7 +4169,7 @@ Default :ref:`InputEventAction<class_InputEventAction>` to add an additional car
 
 :ref:`Dictionary<class_Dictionary>` **input/ui_text_caret_add_above.macos**
 
-macOS specific override for the shortcut to add a caret above every caret
+macOS specific override for the shortcut to add a caret above every caret.
 
 .. rst-class:: classref-item-separator
 
@@ -4193,7 +4181,7 @@ macOS specific override for the shortcut to add a caret above every caret
 
 :ref:`Dictionary<class_Dictionary>` **input/ui_text_caret_add_below**
 
-Default :ref:`InputEventAction<class_InputEventAction>` to add an additional caret below every caret of a text
+Default :ref:`InputEventAction<class_InputEventAction>` to add an additional caret below every caret of a text.
 
 .. rst-class:: classref-item-separator
 
@@ -4205,7 +4193,7 @@ Default :ref:`InputEventAction<class_InputEventAction>` to add an additional car
 
 :ref:`Dictionary<class_Dictionary>` **input/ui_text_caret_add_below.macos**
 
-macOS specific override for the shortcut to add a caret below every caret
+macOS specific override for the shortcut to add a caret below every caret.
 
 .. rst-class:: classref-item-separator
 
@@ -6907,7 +6895,7 @@ Optional name for the 3D render layer 13. If left empty, the layer will display
 
 :ref:`String<class_String>` **layer_names/3d_render/layer_14** = ``""``
 
-Optional name for the 3D render layer 14. If left empty, the layer will display as "Layer 14"
+Optional name for the 3D render layer 14. If left empty, the layer will display as "Layer 14".
 
 .. rst-class:: classref-item-separator
 
@@ -7869,6 +7857,8 @@ The number of fixed iterations per second. This controls how often physics simul
 
 Sets the number of MSAA samples to use for 2D/Canvas rendering (as a power of two). MSAA is used to reduce aliasing around the edges of polygons. A higher MSAA value results in smoother edges but can be significantly slower on some hardware. This has no effect on shader-induced aliasing or texture aliasing.
 
+\ **Note:** MSAA is only supported in the Forward+ and Mobile rendering methods, not Compatibility.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -7881,6 +7871,8 @@ Sets the number of MSAA samples to use for 2D/Canvas rendering (as a power of tw
 
 Sets the number of MSAA samples to use for 3D rendering (as a power of two). MSAA is used to reduce aliasing around the edges of polygons. A higher MSAA value results in smoother edges but can be significantly slower on some hardware. See also bilinear scaling 3d :ref:`rendering/scaling_3d/mode<class_ProjectSettings_property_rendering/scaling_3d/mode>` for supersampling, which provides higher quality but is much more expensive. This has no effect on shader-induced aliasing or texture aliasing.
 
+\ **Note:** MSAA is only supported in the Forward+ and Mobile rendering methods, not Compatibility.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -7895,6 +7887,8 @@ Sets the screen-space antialiasing mode for the default screen :ref:`Viewport<cl
 
 Another way to combat specular aliasing is to enable :ref:`rendering/anti_aliasing/screen_space_roughness_limiter/enabled<class_ProjectSettings_property_rendering/anti_aliasing/screen_space_roughness_limiter/enabled>`.
 
+\ **Note:** Screen-space antialiasing is only supported in the Forward+ and Mobile rendering methods, not Compatibility.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -7923,7 +7917,9 @@ In some cases, debanding may introduce a slightly noticeable dithering pattern.
 
 Enables Temporal Anti-Aliasing for the default screen :ref:`Viewport<class_Viewport>`. TAA works by jittering the camera and accumulating the images of the last rendered frames, motion vector rendering is used to account for camera and object motion. Enabling TAA can make the image blurrier, which is partially counteracted by automatically using a negative mipmap LOD bias (see :ref:`rendering/textures/default_filters/texture_mipmap_bias<class_ProjectSettings_property_rendering/textures/default_filters/texture_mipmap_bias>`).
 
-\ **Note:** The implementation is not complete yet, some visual instances such as particles and skinned meshes may show artifacts.
+\ **Note:** The implementation is not complete yet. Some visual instances such as particles and skinned meshes may show ghosting artifacts in motion.
+
+\ **Note:** TAA is only supported in the Forward+ rendering method, not Mobile or Compatibility.
 
 .. rst-class:: classref-item-separator
 
@@ -7949,9 +7945,9 @@ Enables Temporal Anti-Aliasing for the default screen :ref:`Viewport<class_Viewp
 
 :ref:`bool<class_bool>` **rendering/anti_aliasing/screen_space_roughness_limiter/enabled** = ``true``
 
-.. container:: contribute
+If ``true``, enables a spatial filter to limit roughness in areas with high-frequency detail. This can help reduce specular aliasing to an extent, though not as much as enabling :ref:`rendering/anti_aliasing/quality/use_taa<class_ProjectSettings_property_rendering/anti_aliasing/quality/use_taa>`. This filter has a small performance cost, so consider disabling it if it doesn't benefit your scene noticeably.
 
-	There is currently no description for this property. Please help us by :ref:`contributing one <doc_updating_the_class_reference>`!
+\ **Note:** TAA is only supported in the Forward+ and Mobile rendering methods, not Compatibility.
 
 .. rst-class:: classref-item-separator
 
@@ -8027,7 +8023,7 @@ Disables :ref:`rendering/driver/depth_prepass/enable<class_ProjectSettings_prope
 
 If ``true``, performs a previous depth pass before rendering 3D materials. This increases performance significantly in scenes with high overdraw, when complex materials and lighting are used. However, in scenes with few occluded surfaces, the depth prepass may reduce performance. If your game is viewed from a fixed angle that makes it easy to avoid overdraw (such as top-down or side-scrolling perspective), consider disabling the depth prepass to improve performance. This setting can be changed at run-time to optimize performance depending on the scene currently being viewed.
 
-\ **Note:** Only supported when using the Vulkan Clustered backend or the OpenGL backend. When using Vulkan Mobile there is no depth prepass performed.
+\ **Note:** Depth prepass is only supported when using the Forward+ or Compatibility rendering method. When using the Mobile rendering method, there is no depth prepass performed.
 
 .. rst-class:: classref-item-separator
 
@@ -8881,6 +8877,8 @@ Enables the use of physically based units for light sources. Physically based un
 
 Max number of omnilights and spotlights renderable per object. At the default value of 8, this means that each surface can be affected by up to 8 omnilights and 8 spotlights. This is further limited by hardware support and :ref:`rendering/limits/opengl/max_renderable_lights<class_ProjectSettings_property_rendering/limits/opengl/max_renderable_lights>`. Setting this low will slightly reduce memory usage, may decrease shader compile times, and may result in faster rendering on low-end, mobile, or web devices.
 
+\ **Note:** This setting is only effective when using the Compatibility rendering method, not Forward+ and Mobile.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -8893,6 +8891,8 @@ Max number of omnilights and spotlights renderable per object. At the default va
 
 Max number of elements renderable in a frame. If more elements than this are visible per frame, they will not be drawn. Keep in mind elements refer to mesh surfaces and not meshes themselves. Setting this low will slightly reduce memory usage and may decrease shader compile times, particularly on web. For most uses, the default value is suitable, but consider lowering as much as possible on web export.
 
+\ **Note:** This setting is only effective when using the Compatibility rendering method, not Forward+ and Mobile.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -8905,6 +8905,8 @@ Max number of elements renderable in a frame. If more elements than this are vis
 
 Max number of positional lights renderable in a frame. If more lights than this number are used, they will be ignored. Setting this low will slightly reduce memory usage and may decrease shader compile times, particularly on web. For most uses, the default value is suitable, but consider lowering as much as possible on web export.
 
+\ **Note:** This setting is only effective when using the Compatibility rendering method, not Forward+ and Mobile.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -9301,7 +9303,9 @@ Determines how sharp the upscaled image will be when using the FSR upscaling mod
 
 :ref:`int<class_int>` **rendering/scaling_3d/mode** = ``0``
 
-Sets the scaling 3D mode. Bilinear scaling renders at different resolution to either undersample or supersample the viewport. FidelityFX Super Resolution 1.0, abbreviated to FSR, is an upscaling technology that produces high quality images at fast framerates by using a spatially aware upscaling algorithm. FSR is slightly more expensive than bilinear, but it produces significantly higher image quality. FSR should be used where possible.
+Sets the scaling 3D mode. Bilinear scaling renders at different resolution to either undersample or supersample the viewport. FidelityFX Super Resolution 1.0, abbreviated to FSR, is an upscaling technology that produces high quality images at fast framerates by using a spatially-aware upscaling algorithm. FSR is slightly more expensive than bilinear, but it produces significantly higher image quality. On particularly low-end GPUs, the added cost of FSR may not be worth it (compared to using bilinear scaling with a slightly higher resolution scale to match performance).
+
+\ **Note:** FSR is only effective when using the Forward+ rendering method, not Mobile or Compatibility. If using an incompatible rendering method, FSR will fall back to bilinear scaling.
 
 .. rst-class:: classref-item-separator
 
@@ -9419,6 +9423,8 @@ Lower-end override for :ref:`rendering/shading/overrides/force_lambert_over_burl
 
 If ``true``, forces vertex shading for all rendering. This can increase performance a lot, but also reduces quality immensely. Can be used to optimize performance on low-end mobile devices.
 
+\ **Note:** This setting currently has no effect, as vertex shading is not implemented yet.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -9431,6 +9437,8 @@ If ``true``, forces vertex shading for all rendering. This can increase performa
 
 Lower-end override for :ref:`rendering/shading/overrides/force_vertex_shading<class_ProjectSettings_property_rendering/shading/overrides/force_vertex_shading>` on mobile devices, due to performance concerns or driver support.
 
+\ **Note:** This setting currently has no effect, as vertex shading is not implemented yet.
+
 .. rst-class:: classref-item-separator
 
 ----

classes/class_reflectionprobe.rst

@@ -25,6 +25,8 @@ The **ReflectionProbe** is used to create high-quality reflections at a low perf
 
 \ **Note:** Unlike :ref:`VoxelGI<class_VoxelGI>` and SDFGI, **ReflectionProbe**\ s only source their environment from a :ref:`WorldEnvironment<class_WorldEnvironment>` node. If you specify an :ref:`Environment<class_Environment>` resource within a :ref:`Camera3D<class_Camera3D>` node, it will be ignored by the **ReflectionProbe**. This can lead to incorrect lighting within the **ReflectionProbe**.
 
+\ **Note:** Reflection probes are only supported in the Forward+ and Mobile rendering methods, not Compatibility. When using the Mobile rendering method, only 8 reflection probes can be displayed on each mesh resource. Attempting to display more than 8 reflection probes on a single mesh resource will result in reflection probes flickering in and out as the camera moves.
+
 \ **Note:** When using the Mobile rendering method, reflection probes will only correctly affect meshes whose visibility AABB intersects with the reflection probe's AABB. If using a shader to deform the mesh in a way that makes it go outside its AABB, :ref:`GeometryInstance3D.extra_cull_margin<class_GeometryInstance3D_property_extra_cull_margin>` must be increased on the mesh. Otherwise, the reflection probe may not be visible on the mesh.
 
 .. rst-class:: classref-introduction-group

classes/class_renderingdevice.rst

@@ -27,7 +27,7 @@ Internally, **RenderingDevice** is used in Godot to provide support for several
 
 \ **Local RenderingDevices:** Using :ref:`RenderingServer.create_local_rendering_device<class_RenderingServer_method_create_local_rendering_device>`, you can create "secondary" rendering devices to perform drawing and GPU compute operations on separate threads.
 
-\ **Note:** **RenderingDevice** is not available when running in headless mode or when using the OpenGL renderer.
+\ **Note:** **RenderingDevice** is not available when running in headless mode or when using the Compatibility rendering method.
 
 .. rst-class:: classref-reftable-group
 
@@ -42,7 +42,7 @@ Methods
    +------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | :ref:`Error<enum_@GlobalScope_Error>`                      | :ref:`buffer_clear<class_RenderingDevice_method_buffer_clear>` **(** :ref:`RID<class_RID>` buffer, :ref:`int<class_int>` offset, :ref:`int<class_int>` size_bytes, :ref:`BarrierMask<enum_RenderingDevice_BarrierMask>` post_barrier=7 **)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
    +------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-   | :ref:`PackedByteArray<class_PackedByteArray>`              | :ref:`buffer_get_data<class_RenderingDevice_method_buffer_get_data>` **(** :ref:`RID<class_RID>` buffer **)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+   | :ref:`PackedByteArray<class_PackedByteArray>`              | :ref:`buffer_get_data<class_RenderingDevice_method_buffer_get_data>` **(** :ref:`RID<class_RID>` buffer, :ref:`int<class_int>` offset_bytes=0, :ref:`int<class_int>` size_bytes=0 **)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
    +------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | :ref:`Error<enum_@GlobalScope_Error>`                      | :ref:`buffer_update<class_RenderingDevice_method_buffer_update>` **(** :ref:`RID<class_RID>` buffer, :ref:`int<class_int>` offset, :ref:`int<class_int>` size_bytes, :ref:`PackedByteArray<class_PackedByteArray>` data, :ref:`BarrierMask<enum_RenderingDevice_BarrierMask>` post_barrier=7 **)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
    +------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -4316,11 +4316,9 @@ void **barrier** **(** :ref:`BarrierMask<enum_RenderingDevice_BarrierMask>` from
 
 .. rst-class:: classref-method
 
-:ref:`PackedByteArray<class_PackedByteArray>` **buffer_get_data** **(** :ref:`RID<class_RID>` buffer **)**
+:ref:`PackedByteArray<class_PackedByteArray>` **buffer_get_data** **(** :ref:`RID<class_RID>` buffer, :ref:`int<class_int>` offset_bytes=0, :ref:`int<class_int>` size_bytes=0 **)**
 
-.. container:: contribute
-
-	There is currently no description for this method. Please help us by :ref:`contributing one <doc_updating_the_class_reference>`!
+Returns a copy of the data of the specified ``buffer``, optionally ``offset_bytes`` and ``size_bytes`` can be set to copy only a portion of the buffer.
 
 .. rst-class:: classref-item-separator
 

classes/class_rigidbody2d.rst

@@ -616,6 +616,34 @@ The body's moment of inertia. This is like mass, but for rotation: it determines
 
 If set to ``0``, inertia is automatically computed (default value).
 
+\ **Note:** This value does not change when inertia is automatically computed. Use :ref:`PhysicsServer2D<class_PhysicsServer2D>` to get the computed inertia.
+
+
+.. tabs::
+
+ .. code-tab:: gdscript
+
+    @onready var ball = $Ball
+    
+    func get_ball_inertia():
+        return 1.0 / PhysicsServer2D.body_get_direct_state(ball.get_rid()).inverse_inertia
+
+ .. code-tab:: csharp
+
+    private RigidBody2D _ball;
+    
+    public override void _Ready()
+    {
+        _ball = GetNode<RigidBody2D>("Ball");
+    }
+    
+    private float GetBallInertia()
+    {
+        return 1.0f / PhysicsServer2D.BodyGetDirectState(_ball.GetRid()).InverseInertia;
+    }
+
+
+
 .. rst-class:: classref-item-separator
 
 ----

classes/class_rigidbody3d.rst

@@ -586,6 +586,34 @@ The body's moment of inertia. This is like mass, but for rotation: it determines
 
 If set to ``Vector3.ZERO``, inertia is automatically computed (default value).
 
+\ **Note:** This value does not change when inertia is automatically computed. Use :ref:`PhysicsServer3D<class_PhysicsServer3D>` to get the computed inertia.
+
+
+.. tabs::
+
+ .. code-tab:: gdscript
+
+    @onready var ball = $Ball
+    
+    func get_ball_inertia():
+        return PhysicsServer3D.body_get_direct_state(ball.get_rid()).inverse_inertia.inverse()
+
+ .. code-tab:: csharp
+
+    private RigidBody3D _ball;
+    
+    public override void _Ready()
+    {
+        _ball = GetNode<RigidBody3D>("Ball");
+    }
+    
+    private Vector3 GetBallInertia()
+    {
+        return PhysicsServer3D.BodyGetDirectState(_ball.GetRid()).InverseInertia.Inverse();
+    }
+
+
+
 .. rst-class:: classref-item-separator
 
 ----

classes/class_skeleton3d.rst

@@ -703,7 +703,7 @@ Sets the global pose transform, ``pose``, for the bone at ``bone_idx``.
 
 \ ``amount`` is the interpolation strength that will be used when applying the pose, and ``persistent`` determines if the applied pose will remain.
 
-\ **Note:** The pose transform needs to be a global pose! To convert a world transform from a :ref:`Node3D<class_Node3D>` to a global bone pose, multiply the :ref:`Transform3D.affine_inverse<class_Transform3D_method_affine_inverse>` of the node's :ref:`Node3D.global_transform<class_Node3D_property_global_transform>` by the desired world transform
+\ **Note:** The pose transform needs to be a global pose! To convert a world transform from a :ref:`Node3D<class_Node3D>` to a global bone pose, multiply the :ref:`Transform3D.affine_inverse<class_Transform3D_method_affine_inverse>` of the node's :ref:`Node3D.global_transform<class_Node3D_property_global_transform>` by the desired world transform.
 
 .. rst-class:: classref-item-separator
 

classes/class_spotlight3d.rst

@@ -21,6 +21,8 @@ Description
 
 A Spotlight is a type of :ref:`Light3D<class_Light3D>` node that emits lights in a specific direction, in the shape of a cone. The light is attenuated through the distance. This attenuation can be configured by changing the energy, radius and attenuation parameters of :ref:`Light3D<class_Light3D>`.
 
+\ **Note:** When using the Mobile rendering method, only 8 spot lights can be displayed on each mesh resource. Attempting to display more than 8 spot lights on a single mesh resource will result in spot lights flickering in and out as the camera moves. When using the Compatibility rendering method, only 8 spot lights can be displayed on each mesh resource by default, but this can be increased by adjusting :ref:`ProjectSettings.rendering/limits/opengl/max_lights_per_object<class_ProjectSettings_property_rendering/limits/opengl/max_lights_per_object>`.
+
 \ **Note:** When using the Mobile or Compatibility rendering methods, spot lights will only correctly affect meshes whose visibility AABB intersects with the light's AABB. If using a shader to deform the mesh in a way that makes it go outside its AABB, :ref:`GeometryInstance3D.extra_cull_margin<class_GeometryInstance3D_property_extra_cull_margin>` must be increased on the mesh. Otherwise, the light may not be visible on the mesh.
 
 .. rst-class:: classref-introduction-group

classes/class_streampeer.rst

@@ -328,6 +328,8 @@ Gets an UTF-8 string with byte-length ``bytes`` from the stream (this decodes th
 
 Gets a Variant from the stream. If ``allow_objects`` is ``true``, decoding objects is allowed.
 
+Internally, this uses the same decoding mechanism as the :ref:`@GlobalScope.bytes_to_var<class_@GlobalScope_method_bytes_to_var>` method.
+
 \ **Warning:** Deserialized objects can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats such as remote code execution.
 
 .. rst-class:: classref-item-separator
@@ -540,6 +542,8 @@ void **put_var** **(** :ref:`Variant<class_Variant>` value, :ref:`bool<class_boo
 
 Puts a Variant into the stream. If ``full_objects`` is ``true`` encoding objects is allowed (and can potentially include code).
 
+Internally, this uses the same encoding mechanism as the :ref:`@GlobalScope.var_to_bytes<class_@GlobalScope_method_var_to_bytes>` method.
+
 .. |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.)`

classes/class_string.rst

@@ -593,8 +593,8 @@ Returns the index of the **first** occurrence of ``what`` in this string, or ``-
     GD.Print("Team".Find("I")); // Prints -1
     
     GD.Print("Potato".Find("t"));    // Prints 2
-    GD.print("Potato".Find("t", 3)); // Prints 4
-    GD.print("Potato".Find("t", 5)); // Prints -1
+    GD.Print("Potato".Find("t", 3)); // Prints 4
+    GD.Print("Potato".Find("t", 5)); // Prints -1
 
 
 
@@ -645,6 +645,8 @@ Some additional handling is performed when ``values`` is an :ref:`Array<class_Ar
 
 See also the :doc:`GDScript format string <../tutorials/scripting/gdscript/gdscript_format_string>` tutorial.
 
+\ **Note:** In C#, it's recommended to `interpolate strings with "$" <https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/interpolated>`__, instead.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -1060,7 +1062,7 @@ Returns the concatenation of ``parts``' elements, with each element separated by
     var fruits = new string[] {"Apple", "Orange", "Pear", "Kiwi"};
     
     // In C#, this method is static.
-    GD.Print(string.Join(", ", fruits);   // Prints "Apple, Orange, Pear, Kiwi"
+    GD.Print(string.Join(", ", fruits));  // Prints "Apple, Orange, Pear, Kiwi"
     GD.Print(string.Join("---", fruits)); // Prints "Apple---Orange---Pear---Kiwi"
 
 
@@ -2001,9 +2003,7 @@ Returns ``true`` if this **String** is not equivalent to the given :ref:`StringN
 
 :ref:`String<class_String>` **operator %** **(** :ref:`Variant<class_Variant>` right **)**
 
-Formats the **String**, replacing the placeholders with one or more parameters.
-
-To pass multiple parameters, ``right`` needs to be an :ref:`Array<class_Array>`.
+Formats the **String**, replacing the placeholders with one or more parameters. To pass multiple parameters, ``right`` needs to be an :ref:`Array<class_Array>`.
 
 ::
 
@@ -2014,10 +2014,10 @@ To pass multiple parameters, ``right`` needs to be an :ref:`Array<class_Array>`.
     var speed = 40.3485
     print(my_message % [location, speed]) # Prints "Travelling to Deep Valley, at 40.35 km/h."
 
-In C#, there is no direct equivalent to this operator. Use the :ref:`format<class_String_method_format>` method, instead.
-
 For more information, see the :doc:`GDScript format strings <../tutorials/scripting/gdscript/gdscript_format_string>` tutorial.
 
+\ **Note:** In C#, this operator is not available. Instead, see `how to interpolate strings with "$" <https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/interpolated>`__.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -2040,9 +2040,7 @@ Appends ``right`` at the end of this **String**, also known as a string concaten
 
 :ref:`String<class_String>` **operator +** **(** :ref:`StringName<class_StringName>` right **)**
 
-.. container:: contribute
-
-	There is currently no description for this operator. Please help us by :ref:`contributing one <doc_updating_the_class_reference>`!
+Appends ``right`` at the end of this **String**, returning a **String**. This is also known as a string concatenation.
 
 .. rst-class:: classref-item-separator
 

classes/class_stringname.rst

@@ -19,7 +19,7 @@ Description
 
 **StringName**\ s are immutable strings designed for general-purpose representation of unique names (also called "string interning"). **StringName** ensures that only one instance of a given name exists (so two **StringName**\ s with the same value are the same object). Comparing them is much faster than with regular :ref:`String<class_String>`\ s, because only the pointers are compared, not the whole strings.
 
-You will usually just pass a :ref:`String<class_String>` to methods expecting a **StringName** and it will be automatically converted, but you may occasionally want to construct a **StringName** ahead of time with **StringName** or, in GDScript, the literal syntax ``&"example"``.
+You will usually just pass a :ref:`String<class_String>` to methods expecting a **StringName** and it will be automatically converted, but you may occasionally want to construct a **StringName** ahead of time with the **StringName** constructor or, in GDScript, the literal syntax ``&"example"``.
 
 See also :ref:`NodePath<class_NodePath>`, which is a similar concept specifically designed to store pre-parsed node paths.
 
@@ -547,8 +547,8 @@ Returns the index of the **first** occurrence of ``what`` in this string, or ``-
     GD.Print("Team".Find("I")); // Prints -1
     
     GD.Print("Potato".Find("t"));    // Prints 2
-    GD.print("Potato".Find("t", 3)); // Prints 4
-    GD.print("Potato".Find("t", 5)); // Prints -1
+    GD.Print("Potato".Find("t", 3)); // Prints 4
+    GD.Print("Potato".Find("t", 5)); // Prints -1
 
 
 
@@ -599,6 +599,8 @@ Some additional handling is performed when ``values`` is an :ref:`Array<class_Ar
 
 See also the :doc:`GDScript format string <../tutorials/scripting/gdscript/gdscript_format_string>` tutorial.
 
+\ **Note:** In C#, it's recommended to `interpolate strings with "$" <https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/interpolated>`__, instead.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -1000,7 +1002,7 @@ Returns the concatenation of ``parts``' elements, with each element separated by
     var fruits = new string[] {"Apple", "Orange", "Pear", "Kiwi"};
     
     // In C#, this method is static.
-    GD.Print(string.Join(", ", fruits);   // Prints "Apple, Orange, Pear, Kiwi"
+    GD.Print(string.Join(", ", fruits));  // Prints "Apple, Orange, Pear, Kiwi"
     GD.Print(string.Join("---", fruits)); // Prints "Apple---Orange---Pear---Kiwi"
 
 
@@ -1844,9 +1846,11 @@ Returns ``true`` if the **StringName** and ``right`` do not refer to the same na
 
 :ref:`String<class_String>` **operator %** **(** :ref:`Variant<class_Variant>` right **)**
 
-.. container:: contribute
+Formats the **StringName**, replacing the placeholders with one or more parameters, returning a :ref:`String<class_String>`. To pass multiple parameters, ``right`` needs to be an :ref:`Array<class_Array>`.
+
+For more information, see the :doc:`GDScript format strings <../tutorials/scripting/gdscript/gdscript_format_string>` tutorial.
 
-	There is currently no description for this operator. Please help us by :ref:`contributing one <doc_updating_the_class_reference>`!
+\ **Note:** In C#, this operator is not available. Instead, see `how to interpolate strings with "$" <https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/interpolated>`__.
 
 .. rst-class:: classref-item-separator
 
@@ -1858,9 +1862,7 @@ Returns ``true`` if the **StringName** and ``right`` do not refer to the same na
 
 :ref:`String<class_String>` **operator +** **(** :ref:`String<class_String>` right **)**
 
-.. container:: contribute
-
-	There is currently no description for this operator. Please help us by :ref:`contributing one <doc_updating_the_class_reference>`!
+Appends ``right`` at the end of this **StringName**, returning a :ref:`String<class_String>`. This is also known as a string concatenation.
 
 .. rst-class:: classref-item-separator
 
@@ -1872,9 +1874,7 @@ Returns ``true`` if the **StringName** and ``right`` do not refer to the same na
 
 :ref:`String<class_String>` **operator +** **(** :ref:`StringName<class_StringName>` right **)**
 
-.. container:: contribute
-
-	There is currently no description for this operator. Please help us by :ref:`contributing one <doc_updating_the_class_reference>`!
+Appends ``right`` at the end of this **StringName**, returning a :ref:`String<class_String>`. This is also known as a string concatenation.
 
 .. rst-class:: classref-item-separator
 

classes/class_textedit.rst

@@ -2353,7 +2353,7 @@ You can add custom menu items or remove standard ones. Make sure your IDs don't
 
 :ref:`int<class_int>` **get_minimap_line_at_pos** **(** :ref:`Vector2i<class_Vector2i>` position **)** |const|
 
-Returns the equivalent minimap line at ``position``
+Returns the equivalent minimap line at ``position``.
 
 .. rst-class:: classref-item-separator
 
@@ -2429,7 +2429,7 @@ Returns the local position and size for the grapheme at the given ``line`` and `
 
 :ref:`int<class_int>` **get_saved_version** **(** **)** |const|
 
-Returns the last tagged saved version from :ref:`tag_saved_version<class_TextEdit_method_tag_saved_version>`
+Returns the last tagged saved version from :ref:`tag_saved_version<class_TextEdit_method_tag_saved_version>`.
 
 .. rst-class:: classref-item-separator
 
@@ -3350,7 +3350,7 @@ Sets the tab size for the **TextEdit** to use.
 
 void **set_tooltip_request_func** **(** :ref:`Callable<class_Callable>` callback **)**
 
-Provide custom tooltip text. The callback method must take the following args: ``hovered_word: String``
+Provide custom tooltip text. The callback method must take the following args: ``hovered_word: String``.
 
 .. rst-class:: classref-item-separator
 

classes/class_texturelayered.rst

@@ -29,7 +29,7 @@ All images need to have the same width, height and number of mipmap levels.
 
 A **TextureLayered** can be loaded with :ref:`ResourceLoader.load<class_ResourceLoader_method_load>`.
 
-Internally, Godot maps these files to their respective counterparts in the target rendering driver (Vulkan, GLES3).
+Internally, Godot maps these files to their respective counterparts in the target rendering driver (Vulkan, OpenGL3).
 
 .. rst-class:: classref-reftable-group
 

classes/class_tilemap.rst

@@ -105,6 +105,8 @@ Methods
    +---------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | :ref:`int<class_int>`                       | :ref:`get_layers_count<class_TileMap_method_get_layers_count>` **(** **)** |const|                                                                                                                                                                                                      |
    +---------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`RID<class_RID>`                       | :ref:`get_navigation_map<class_TileMap_method_get_navigation_map>` **(** :ref:`int<class_int>` layer **)** |const|                                                                                                                                                                      |
+   +---------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | :ref:`Vector2i<class_Vector2i>`             | :ref:`get_neighbor_cell<class_TileMap_method_get_neighbor_cell>` **(** :ref:`Vector2i<class_Vector2i>` coords, :ref:`CellNeighbor<enum_TileSet_CellNeighbor>` neighbor **)** |const|                                                                                                    |
    +---------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | :ref:`TileMapPattern<class_TileMapPattern>` | :ref:`get_pattern<class_TileMap_method_get_pattern>` **(** :ref:`int<class_int>` layer, :ref:`Vector2i[]<class_Vector2i>` coords_array **)**                                                                                                                                            |
@@ -149,6 +151,8 @@ Methods
    +---------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | void                                        | :ref:`set_layer_z_index<class_TileMap_method_set_layer_z_index>` **(** :ref:`int<class_int>` layer, :ref:`int<class_int>` z_index **)**                                                                                                                                                 |
    +---------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+   | void                                        | :ref:`set_navigation_map<class_TileMap_method_set_navigation_map>` **(** :ref:`int<class_int>` layer, :ref:`RID<class_RID>` map **)**                                                                                                                                                   |
+   +---------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | void                                        | :ref:`set_pattern<class_TileMap_method_set_pattern>` **(** :ref:`int<class_int>` layer, :ref:`Vector2i<class_Vector2i>` position, :ref:`TileMapPattern<class_TileMapPattern>` pattern **)**                                                                                             |
    +---------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
@@ -551,6 +555,22 @@ Returns the number of layers in the TileMap.
 
 ----
 
+.. _class_TileMap_method_get_navigation_map:
+
+.. rst-class:: classref-method
+
+:ref:`RID<class_RID>` **get_navigation_map** **(** :ref:`int<class_int>` layer **)** |const|
+
+Returns the :ref:`NavigationServer2D<class_NavigationServer2D>` navigation map :ref:`RID<class_RID>` currently assigned to the specified TileMap ``layer``.
+
+By default the TileMap uses the default :ref:`World2D<class_World2D>` navigation map for the first TileMap layer. For each additional TileMap layer a new navigation map is created for the additional layer.
+
+In order to make :ref:`NavigationAgent2D<class_NavigationAgent2D>` switch between TileMap layer navigation maps use :ref:`NavigationAgent2D.set_navigation_map<class_NavigationAgent2D_method_set_navigation_map>` with the navigation map received from :ref:`get_navigation_map<class_TileMap_method_get_navigation_map>`.
+
+.. rst-class:: classref-item-separator
+
+----
+
 .. _class_TileMap_method_get_neighbor_cell:
 
 .. rst-class:: classref-method
@@ -581,7 +601,7 @@ Creates a new :ref:`TileMapPattern<class_TileMapPattern>` from the given layer a
 
 :ref:`Vector2i[]<class_Vector2i>` **get_surrounding_cells** **(** :ref:`Vector2i<class_Vector2i>` coords **)**
 
-Returns the list of all neighbourings cells to the one at ``coords``
+Returns the list of all neighbourings cells to the one at ``coords``.
 
 .. rst-class:: classref-item-separator
 
@@ -669,7 +689,7 @@ Returns the map coordinates of the cell containing the given ``local_position``.
 
 :ref:`Vector2i<class_Vector2i>` **map_pattern** **(** :ref:`Vector2i<class_Vector2i>` position_in_tilemap, :ref:`Vector2i<class_Vector2i>` coords_in_pattern, :ref:`TileMapPattern<class_TileMapPattern>` pattern **)**
 
-Returns for the given coordinate ``coords_in_pattern`` in a :ref:`TileMapPattern<class_TileMapPattern>` the corresponding cell coordinates if the pattern was pasted at the ``position_in_tilemap`` coordinates (see :ref:`set_pattern<class_TileMap_method_set_pattern>`). This mapping is required as in half-offset tile shapes, the mapping might not work by calculating ``position_in_tile_map + coords_in_pattern``
+Returns for the given coordinate ``coords_in_pattern`` in a :ref:`TileMapPattern<class_TileMapPattern>` the corresponding cell coordinates if the pattern was pasted at the ``position_in_tilemap`` coordinates (see :ref:`set_pattern<class_TileMap_method_set_pattern>`). This mapping is required as in half-offset tile shapes, the mapping might not work by calculating ``position_in_tile_map + coords_in_pattern``.
 
 .. rst-class:: classref-item-separator
 
@@ -853,6 +873,22 @@ If ``layer`` is negative, the layers are accessed from the last one.
 
 ----
 
+.. _class_TileMap_method_set_navigation_map:
+
+.. rst-class:: classref-method
+
+void **set_navigation_map** **(** :ref:`int<class_int>` layer, :ref:`RID<class_RID>` map **)**
+
+Assigns a :ref:`NavigationServer2D<class_NavigationServer2D>` navigation map :ref:`RID<class_RID>` to the specified TileMap ``layer``.
+
+By default the TileMap uses the default :ref:`World2D<class_World2D>` navigation map for the first TileMap layer. For each additional TileMap layer a new navigation map is created for the additional layer.
+
+In order to make :ref:`NavigationAgent2D<class_NavigationAgent2D>` switch between TileMap layer navigation maps use :ref:`NavigationAgent2D.set_navigation_map<class_NavigationAgent2D_method_set_navigation_map>` with the navigation map received from :ref:`get_navigation_map<class_TileMap_method_get_navigation_map>`.
+
+.. rst-class:: classref-item-separator
+
+----
+
 .. _class_TileMap_method_set_pattern:
 
 .. rst-class:: classref-method

classes/class_visibleonscreennotifier2d.rst

@@ -25,6 +25,8 @@ The VisibleOnScreenNotifier2D detects when it is visible on the screen. It also
 
 If you want nodes to be disabled automatically when they exit the screen, use :ref:`VisibleOnScreenEnabler2D<class_VisibleOnScreenEnabler2D>` instead.
 
+\ **Note:** VisibleOnScreenNotifier2D uses the render culling code to determine whether it's visible on screen, which also means that its :ref:`CanvasItem.visible<class_CanvasItem_property_visible>` must be ``true`` to work correctly.
+
 .. rst-class:: classref-introduction-group
 
 Tutorials

classes/class_visibleonscreennotifier3d.rst

@@ -25,7 +25,7 @@ The VisibleOnScreenNotifier3D detects when it is visible on the screen. It also
 
 If you want nodes to be disabled automatically when they exit the screen, use :ref:`VisibleOnScreenEnabler3D<class_VisibleOnScreenEnabler3D>` instead.
 
-\ **Note:** VisibleOnScreenNotifier3D uses an approximate heuristic for performance reasons. It doesn't take walls and other occlusion into account. The heuristic is an implementation detail and may change in future versions. If you need precise visibility checking, use another method such as adding an :ref:`Area3D<class_Area3D>` node as a child of a :ref:`Camera3D<class_Camera3D>` node and/or :ref:`Vector3.dot<class_Vector3_method_dot>`.
+\ **Note:** VisibleOnScreenNotifier3D uses the render culling code to determine whether it's visible on screen, which also means that its :ref:`Node3D.visible<class_Node3D_property_visible>` must be ``true`` to work correctly.
 
 .. rst-class:: classref-reftable-group
 

classes/class_voxelgi.rst

@@ -21,6 +21,8 @@ Description
 
 **VoxelGI**\ s are used to provide high-quality real-time indirect light and reflections to scenes. They precompute the effect of objects that emit light and the effect of static geometry to simulate the behavior of complex light in real-time. **VoxelGI**\ s need to be baked before having a visible effect. However, once baked, dynamic objects will receive light from them. Furthermore, lights can be fully dynamic or baked.
 
+\ **Note:** **VoxelGI** is only supported in the Forward+ rendering method, not Mobile or Compatibility.
+
 \ **Procedural generation:** **VoxelGI** can be baked in an exported project, which makes it suitable for procedurally generated or user-built levels as long as all the geometry is generated in advance. For games where geometry is generated at any time during gameplay, SDFGI is more suitable (see :ref:`Environment.sdfgi_enabled<class_Environment_property_sdfgi_enabled>`).
 
 \ **Performance:** **VoxelGI** is relatively demanding on the GPU and is not suited to low-end hardware such as integrated graphics (consider :ref:`LightmapGI<class_LightmapGI>` instead). To improve performance, adjust :ref:`ProjectSettings.rendering/global_illumination/voxel_gi/quality<class_ProjectSettings_property_rendering/global_illumination/voxel_gi/quality>` and enable :ref:`ProjectSettings.rendering/global_illumination/gi/use_half_resolution<class_ProjectSettings_property_rendering/global_illumination/gi/use_half_resolution>` in the Project Settings. To provide a fallback for low-end hardware, consider adding an option to disable **VoxelGI** in your project's options menus. A **VoxelGI** node can be disabled by hiding it.

classes/class_websocketmultiplayerpeer.rst

@@ -189,7 +189,7 @@ Method Descriptions
 
 Starts a new multiplayer client connecting to the given ``url``. TLS certificates will be verified against the hostname when connecting using the ``wss://`` protocol. You can pass the optional ``tls_client_options`` parameter to customize the trusted certification authorities, or disable the common name verification. See :ref:`TLSOptions.client<class_TLSOptions_method_client>` and :ref:`TLSOptions.client_unsafe<class_TLSOptions_method_client_unsafe>`.
 
-\ **Note**: It is recommended to specify the scheme part of the URL, i.e. the ``url`` should start with either ``ws://`` or ``wss://``.
+\ **Note:** It is recommended to specify the scheme part of the URL, i.e. the ``url`` should start with either ``ws://`` or ``wss://``.
 
 .. rst-class:: classref-item-separator
 

classes/class_window.rst

@@ -1939,6 +1939,8 @@ Popups the **Window** at the center of the current screen, with optionally given
 
 If the **Window** is embedded, it will be centered in the parent :ref:`Viewport<class_Viewport>` instead.
 
+\ **Note:** Calling it with the default value of ``minsize`` is equivalent to calling it with :ref:`size<class_Window_property_size>`.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -1953,6 +1955,8 @@ Popups the **Window** centered inside its parent **Window**.
 
 \ ``fallback_ratio`` determines the maximum size of the **Window**, in relation to its parent.
 
+\ **Note:** Calling it with the default value of ``minsize`` is equivalent to calling it with :ref:`size<class_Window_property_size>`.
+
 .. rst-class:: classref-item-separator
 
 ----