classref: Sync with current master branch (543750a)

classes/[email protected]

@@ -10,7 +10,7 @@
 @GDScript
 =========
 
-Built-in GDScript functions.
+Built-in GDScript constants, functions, and annotations.
 
 .. rst-class:: classref-introduction-group
 
@@ -109,7 +109,7 @@ Positive floating-point infinity. This is the result of floating-point division
 
 **NAN** = ``nan``
 
-"Not a Number", an invalid floating-point value. :ref:`NAN<class_@GDScript_constant_NAN>` has special properties, including that it is not equal to itself (``NAN == NAN`` returns ``false``). It is output by some invalid operations, such as dividing floating-point ``0.0`` by ``0.0``.
+"Not a Number", an invalid floating-point value. :ref:`NAN<class_@GDScript_constant_NAN>` has special properties, including that ``!=`` always returns ``true``, while other comparison operators always return ``false``. This is true even when comparing with itself (``NAN == NAN`` returns ``false`` and ``NAN != NAN`` returns ``true``). It is returned by some invalid operations, such as dividing floating-point ``0.0`` by ``0.0``.
 
 \ **Warning:** "Not a Number" is only a concept with floating-point numbers, and has no equivalent for integers. Dividing an integer ``0`` by ``0`` will not result in :ref:`NAN<class_@GDScript_constant_NAN>` and will result in a run-time error instead.
 

classes/[email protected]

@@ -5303,7 +5303,7 @@ A type-safe version of :ref:`ceil<class_@GlobalScope_method_ceil>`, returning an
 
 :ref:`Variant<class_Variant>` **clamp** **(** :ref:`Variant<class_Variant>` value, :ref:`Variant<class_Variant>` min, :ref:`Variant<class_Variant>` max **)**
 
-Clamps the ``value``, returning a :ref:`Variant<class_Variant>` not less than ``min`` and not more than ``max``. Supported types: :ref:`int<class_int>`, :ref:`float<class_float>`, :ref:`Vector2<class_Vector2>`, :ref:`Vector2i<class_Vector2i>`, :ref:`Vector3<class_Vector3>`, :ref:`Vector3i<class_Vector3i>`, :ref:`Vector4<class_Vector4>`, :ref:`Vector4i<class_Vector4i>`.
+Clamps the ``value``, returning a :ref:`Variant<class_Variant>` not less than ``min`` and not more than ``max``. Any values that can be compared with the less than and greater than operators will work.
 
 ::
 
@@ -5325,7 +5325,7 @@ Clamps the ``value``, returning a :ref:`Variant<class_Variant>` not less than ``
     var f = clamp(Vector3i(-7, -8, -9), Vector3i(-1, 2, 3), Vector3i(-4, -5, -6))
     # f is (-4, -5, -6)
 
-\ **Note:** For better type safety, use :ref:`clampf<class_@GlobalScope_method_clampf>`, :ref:`clampi<class_@GlobalScope_method_clampi>`, :ref:`Vector2.clamp<class_Vector2_method_clamp>`, :ref:`Vector2i.clamp<class_Vector2i_method_clamp>`, :ref:`Vector3.clamp<class_Vector3_method_clamp>`, :ref:`Vector3i.clamp<class_Vector3i_method_clamp>`, :ref:`Vector4.clamp<class_Vector4_method_clamp>`, or :ref:`Vector4i.clamp<class_Vector4i_method_clamp>`.
+\ **Note:** For better type safety, use :ref:`clampf<class_@GlobalScope_method_clampf>`, :ref:`clampi<class_@GlobalScope_method_clampi>`, :ref:`Vector2.clamp<class_Vector2_method_clamp>`, :ref:`Vector2i.clamp<class_Vector2i_method_clamp>`, :ref:`Vector3.clamp<class_Vector3_method_clamp>`, :ref:`Vector3i.clamp<class_Vector3i_method_clamp>`, :ref:`Vector4.clamp<class_Vector4_method_clamp>`, :ref:`Vector4i.clamp<class_Vector4i_method_clamp>`, or :ref:`Color.clamp<class_Color_method_clamp>`.
 
 .. rst-class:: classref-item-separator
 
@@ -6230,7 +6230,7 @@ The following BBCode tags are supported: ``b``, ``i``, ``u``, ``s``, ``indent``,
 
 Color tags only support the following named colors: ``black``, ``red``, ``green``, ``yellow``, ``blue``, ``magenta``, ``pink``, ``purple``, ``cyan``, ``white``, ``orange``, ``gray``. Hexadecimal color codes are not supported.
 
-URL tags only support URLs wrapped by an URL tag, not URLs with a different title.
+URL tags only support URLs wrapped by a URL tag, not URLs with a different title.
 
 When printing to standard output, the supported subset of BBCode is converted to ANSI escape codes for the terminal emulator to display. Support for ANSI escape codes varies across terminal emulators, especially for italic and strikethrough. In standard output, ``code`` is represented with faint text but without any font change. Unsupported tags are left as-is in standard output.
 

classes/class_aabb.rst

@@ -10,7 +10,7 @@
 AABB
 ====
 
-Axis-Aligned Bounding Box.
+A 3D axis-aligned bounding box.
 
 .. rst-class:: classref-introduction-group
 

classes/class_acceptdialog.rst

@@ -14,14 +14,14 @@ AcceptDialog
 
 **Inherited By:** :ref:`ConfirmationDialog<class_ConfirmationDialog>`
 
-Base dialog for user notification.
+A base dialog used for user notification.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-This dialog is useful for small notifications to the user about an event. It can only be accepted or closed, with the same result.
+The default use of **AcceptDialog** is to allow it to only be accepted or closed, with the same result. However, the :ref:`confirmed<class_AcceptDialog_signal_confirmed>` and :ref:`canceled<class_AcceptDialog_signal_canceled>` signals allow to make the two actions different, and the :ref:`add_button<class_AcceptDialog_method_add_button>` method allows to add custom buttons and actions.
 
 .. rst-class:: classref-reftable-group
 

classes/class_aescontext.rst

@@ -12,14 +12,14 @@ AESContext
 
 **Inherits:** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
 
-Interface to low level AES encryption features.
+Provides access to AES encryption/decryption of raw data.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-This class provides access to AES encryption/decryption of raw data. Both AES-ECB and AES-CBC mode are supported.
+This class holds the context information required for encryption and decryption operations with AES (Advanced Encryption Standard). Both AES-ECB and AES-CBC modes are supported.
 
 
 .. tabs::

classes/class_animatablebody2d.rst

@@ -12,18 +12,16 @@ AnimatableBody2D
 
 **Inherits:** :ref:`StaticBody2D<class_StaticBody2D>` **<** :ref:`PhysicsBody2D<class_PhysicsBody2D>` **<** :ref:`CollisionObject2D<class_CollisionObject2D>` **<** :ref:`Node2D<class_Node2D>` **<** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-Physics body for 2D physics which moves only by script or animation (while affecting other bodies on its path). Useful for moving platforms and doors.
+A 2D physics body that can't be moved by external forces. When moved manually, it affects other bodies in its path.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Animatable body for 2D physics.
+An animatable 2D physics body. It can't be moved by external forces or contacts, but can be moved manually by other means such as code, :ref:`AnimationPlayer<class_AnimationPlayer>`\ s (with :ref:`AnimationPlayer.playback_process_mode<class_AnimationPlayer_property_playback_process_mode>` set to ``ANIMATION_PROCESS_PHYSICS``), and :ref:`RemoteTransform2D<class_RemoteTransform2D>`.
 
-An animatable body can't be moved by external forces or contacts, but can be moved by script or animation to affect other bodies in its path. It is ideal for implementing moving objects in the environment, such as moving platforms or doors.
-
-When the body is moved manually, either from code or from an :ref:`AnimationPlayer<class_AnimationPlayer>` (with :ref:`AnimationPlayer.playback_process_mode<class_AnimationPlayer_property_playback_process_mode>` set to ``physics``), the physics will automatically compute an estimate of their linear and angular velocity. This makes them very useful for moving platforms or other AnimationPlayer-controlled objects (like a door, a bridge that opens, etc).
+When **AnimatableBody2D** is moved, its linear and angular velocity are estimated and used to affect other physics bodies in its path. This makes it useful for moving platforms, doors, and other moving objects.
 
 .. rst-class:: classref-reftable-group
 

classes/class_animatablebody3d.rst

@@ -12,20 +12,16 @@ AnimatableBody3D
 
 **Inherits:** :ref:`StaticBody3D<class_StaticBody3D>` **<** :ref:`PhysicsBody3D<class_PhysicsBody3D>` **<** :ref:`CollisionObject3D<class_CollisionObject3D>` **<** :ref:`Node3D<class_Node3D>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-Physics body for 3D physics which moves only by script or animation (while affecting other bodies on its path). Useful for moving platforms and doors.
+A 3D physics body that can't be moved by external forces. When moved manually, it affects other bodies in its path.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Animatable body for 3D physics.
+An animatable 3D physics body. It can't be moved by external forces or contacts, but can be moved manually by other means such as code, :ref:`AnimationPlayer<class_AnimationPlayer>`\ s (with :ref:`AnimationPlayer.playback_process_mode<class_AnimationPlayer_property_playback_process_mode>` set to ``ANIMATION_PROCESS_PHYSICS``), and :ref:`RemoteTransform3D<class_RemoteTransform3D>`.
 
-An animatable body can't be moved by external forces or contacts, but can be moved by script or animation to affect other bodies in its path. It is ideal for implementing moving objects in the environment, such as moving platforms or doors.
-
-When the body is moved manually, either from code or from an :ref:`AnimationPlayer<class_AnimationPlayer>` (with :ref:`AnimationPlayer.playback_process_mode<class_AnimationPlayer_property_playback_process_mode>` set to ``physics``), the physics will automatically compute an estimate of their linear and angular velocity. This makes them very useful for moving platforms or other AnimationPlayer-controlled objects (like a door, a bridge that opens, etc).
-
-\ **Warning:** With a non-uniform scale this node will probably not function as expected. Please make sure to keep its scale uniform (i.e. the same on all axes), and change the size(s) of its collision shape(s) instead.
+When **AnimatableBody3D** is moved, its linear and angular velocity are estimated and used to affect other physics bodies in its path. This makes it useful for moving platforms, doors, and other moving objects.
 
 .. rst-class:: classref-introduction-group
 

classes/class_animationnode.rst

@@ -23,7 +23,7 @@ Description
 
 Base resource for :ref:`AnimationTree<class_AnimationTree>` nodes. In general, it's not used directly, but you can create custom ones with custom blending formulas.
 
-Inherit this when creating nodes mainly for use in :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`, otherwise :ref:`AnimationRootNode<class_AnimationRootNode>` should be used instead.
+Inherit this when creating animation nodes mainly for use in :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`, otherwise :ref:`AnimationRootNode<class_AnimationRootNode>` should be used instead.
 
 .. rst-class:: classref-introduction-group
 
@@ -111,7 +111,7 @@ Signals
 
 **animation_node_removed** **(** :ref:`int<class_int>` object_id, :ref:`String<class_String>` name **)**
 
-Emitted by nodes that inherit from this class and that have an internal tree when one of their nodes removes. The nodes that emit this signal are :ref:`AnimationNodeBlendSpace1D<class_AnimationNodeBlendSpace1D>`, :ref:`AnimationNodeBlendSpace2D<class_AnimationNodeBlendSpace2D>`, :ref:`AnimationNodeStateMachine<class_AnimationNodeStateMachine>`, and :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`.
+Emitted by nodes that inherit from this class and that have an internal tree when one of their animation nodes removes. The animation nodes that emit this signal are :ref:`AnimationNodeBlendSpace1D<class_AnimationNodeBlendSpace1D>`, :ref:`AnimationNodeBlendSpace2D<class_AnimationNodeBlendSpace2D>`, :ref:`AnimationNodeStateMachine<class_AnimationNodeStateMachine>`, and :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`.
 
 .. rst-class:: classref-item-separator
 
@@ -123,7 +123,7 @@ Emitted by nodes that inherit from this class and that have an internal tree whe
 
 **animation_node_renamed** **(** :ref:`int<class_int>` object_id, :ref:`String<class_String>` old_name, :ref:`String<class_String>` new_name **)**
 
-Emitted by nodes that inherit from this class and that have an internal tree when one of their node names changes. The nodes that emit this signal are :ref:`AnimationNodeBlendSpace1D<class_AnimationNodeBlendSpace1D>`, :ref:`AnimationNodeBlendSpace2D<class_AnimationNodeBlendSpace2D>`, :ref:`AnimationNodeStateMachine<class_AnimationNodeStateMachine>`, and :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`.
+Emitted by nodes that inherit from this class and that have an internal tree when one of their animation node names changes. The animation nodes that emit this signal are :ref:`AnimationNodeBlendSpace1D<class_AnimationNodeBlendSpace1D>`, :ref:`AnimationNodeBlendSpace2D<class_AnimationNodeBlendSpace2D>`, :ref:`AnimationNodeStateMachine<class_AnimationNodeStateMachine>`, and :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`.
 
 .. rst-class:: classref-item-separator
 
@@ -135,7 +135,7 @@ Emitted by nodes that inherit from this class and that have an internal tree whe
 
 **tree_changed** **(** **)**
 
-Emitted by nodes that inherit from this class and that have an internal tree when one of their nodes changes. The nodes that emit this signal are :ref:`AnimationNodeBlendSpace1D<class_AnimationNodeBlendSpace1D>`, :ref:`AnimationNodeBlendSpace2D<class_AnimationNodeBlendSpace2D>`, :ref:`AnimationNodeStateMachine<class_AnimationNodeStateMachine>`, :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>` and :ref:`AnimationNodeTransition<class_AnimationNodeTransition>`.
+Emitted by nodes that inherit from this class and that have an internal tree when one of their animation nodes changes. The animation nodes that emit this signal are :ref:`AnimationNodeBlendSpace1D<class_AnimationNodeBlendSpace1D>`, :ref:`AnimationNodeBlendSpace2D<class_AnimationNodeBlendSpace2D>`, :ref:`AnimationNodeStateMachine<class_AnimationNodeStateMachine>`, :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>` and :ref:`AnimationNodeTransition<class_AnimationNodeTransition>`.
 
 .. rst-class:: classref-section-separator
 
@@ -221,7 +221,7 @@ Method Descriptions
 
 :ref:`String<class_String>` **_get_caption** **(** **)** |virtual| |const|
 
-When inheriting from :ref:`AnimationRootNode<class_AnimationRootNode>`, implement this virtual method to override the text caption for this node.
+When inheriting from :ref:`AnimationRootNode<class_AnimationRootNode>`, implement this virtual method to override the text caption for this animation node.
 
 .. rst-class:: classref-item-separator
 
@@ -233,7 +233,7 @@ When inheriting from :ref:`AnimationRootNode<class_AnimationRootNode>`, implemen
 
 :ref:`AnimationNode<class_AnimationNode>` **_get_child_by_name** **(** :ref:`StringName<class_StringName>` name **)** |virtual| |const|
 
-When inheriting from :ref:`AnimationRootNode<class_AnimationRootNode>`, implement this virtual method to return a child node by its ``name``.
+When inheriting from :ref:`AnimationRootNode<class_AnimationRootNode>`, implement this virtual method to return a child animation node by its ``name``.
 
 .. rst-class:: classref-item-separator
 
@@ -245,7 +245,7 @@ When inheriting from :ref:`AnimationRootNode<class_AnimationRootNode>`, implemen
 
 :ref:`Dictionary<class_Dictionary>` **_get_child_nodes** **(** **)** |virtual| |const|
 
-When inheriting from :ref:`AnimationRootNode<class_AnimationRootNode>`, implement this virtual method to return all children nodes in order as a ``name: node`` dictionary.
+When inheriting from :ref:`AnimationRootNode<class_AnimationRootNode>`, implement this virtual method to return all children animation nodes in order as a ``name: node`` dictionary.
 
 .. rst-class:: classref-item-separator
 
@@ -257,7 +257,7 @@ When inheriting from :ref:`AnimationRootNode<class_AnimationRootNode>`, implemen
 
 :ref:`Variant<class_Variant>` **_get_parameter_default_value** **(** :ref:`StringName<class_StringName>` parameter **)** |virtual| |const|
 
-When inheriting from :ref:`AnimationRootNode<class_AnimationRootNode>`, implement this virtual method to return the default value of a ``parameter``. Parameters are custom local memory used for your nodes, given a resource can be reused in multiple trees.
+When inheriting from :ref:`AnimationRootNode<class_AnimationRootNode>`, implement this virtual method to return the default value of a ``parameter``. Parameters are custom local memory used for your animation nodes, given a resource can be reused in multiple trees.
 
 .. rst-class:: classref-item-separator
 
@@ -269,7 +269,7 @@ When inheriting from :ref:`AnimationRootNode<class_AnimationRootNode>`, implemen
 
 :ref:`Array<class_Array>` **_get_parameter_list** **(** **)** |virtual| |const|
 
-When inheriting from :ref:`AnimationRootNode<class_AnimationRootNode>`, implement this virtual method to return a list of the properties on this node. Parameters are custom local memory used for your nodes, given a resource can be reused in multiple trees. Format is similar to :ref:`Object.get_property_list<class_Object_method_get_property_list>`.
+When inheriting from :ref:`AnimationRootNode<class_AnimationRootNode>`, implement this virtual method to return a list of the properties on this animation node. Parameters are custom local memory used for your animation nodes, given a resource can be reused in multiple trees. Format is similar to :ref:`Object.get_property_list<class_Object_method_get_property_list>`.
 
 .. rst-class:: classref-item-separator
 
@@ -281,7 +281,7 @@ When inheriting from :ref:`AnimationRootNode<class_AnimationRootNode>`, implemen
 
 :ref:`bool<class_bool>` **_has_filter** **(** **)** |virtual| |const|
 
-When inheriting from :ref:`AnimationRootNode<class_AnimationRootNode>`, implement this virtual method to return whether the blend tree editor should display filter editing on this node.
+When inheriting from :ref:`AnimationRootNode<class_AnimationRootNode>`, implement this virtual method to return whether the blend tree editor should display filter editing on this animation node.
 
 .. rst-class:: classref-item-separator
 
@@ -293,7 +293,7 @@ When inheriting from :ref:`AnimationRootNode<class_AnimationRootNode>`, implemen
 
 :ref:`bool<class_bool>` **_is_parameter_read_only** **(** :ref:`StringName<class_StringName>` parameter **)** |virtual| |const|
 
-When inheriting from :ref:`AnimationRootNode<class_AnimationRootNode>`, implement this virtual method to return whether the ``parameter`` is read-only. Parameters are custom local memory used for your nodes, given a resource can be reused in multiple trees.
+When inheriting from :ref:`AnimationRootNode<class_AnimationRootNode>`, implement this virtual method to return whether the ``parameter`` is read-only. Parameters are custom local memory used for your animation nodes, given a resource can be reused in multiple trees.
 
 .. rst-class:: classref-item-separator
 
@@ -305,7 +305,7 @@ When inheriting from :ref:`AnimationRootNode<class_AnimationRootNode>`, implemen
 
 :ref:`float<class_float>` **_process** **(** :ref:`float<class_float>` time, :ref:`bool<class_bool>` seek, :ref:`bool<class_bool>` is_external_seeking, :ref:`bool<class_bool>` test_only **)** |virtual| |const|
 
-When inheriting from :ref:`AnimationRootNode<class_AnimationRootNode>`, implement this virtual method to run some code when this node is processed. The ``time`` parameter is a relative delta, unless ``seek`` is ``true``, in which case it is absolute.
+When inheriting from :ref:`AnimationRootNode<class_AnimationRootNode>`, implement this virtual method to run some code when this animation node is processed. The ``time`` parameter is a relative delta, unless ``seek`` is ``true``, in which case it is absolute.
 
 Here, call the :ref:`blend_input<class_AnimationNode_method_blend_input>`, :ref:`blend_node<class_AnimationNode_method_blend_node>` or :ref:`blend_animation<class_AnimationNode_method_blend_animation>` functions. You can also use :ref:`get_parameter<class_AnimationNode_method_get_parameter>` and :ref:`set_parameter<class_AnimationNode_method_set_parameter>` to modify local memory.
 
@@ -321,7 +321,7 @@ This function should return the time left for the current animation to finish (i
 
 :ref:`bool<class_bool>` **add_input** **(** :ref:`String<class_String>` name **)**
 
-Adds an input to the node. This is only useful for nodes created for use in an :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`. If the addition fails, returns ``false``.
+Adds an input to the animation node. This is only useful for animation nodes created for use in an :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`. If the addition fails, returns ``false``.
 
 .. rst-class:: classref-item-separator
 
@@ -347,7 +347,7 @@ A ``looped_flag`` is used by internal processing immediately after the loop. See
 
 :ref:`float<class_float>` **blend_input** **(** :ref:`int<class_int>` input_index, :ref:`float<class_float>` time, :ref:`bool<class_bool>` seek, :ref:`bool<class_bool>` is_external_seeking, :ref:`float<class_float>` blend, :ref:`FilterAction<enum_AnimationNode_FilterAction>` filter=0, :ref:`bool<class_bool>` sync=true, :ref:`bool<class_bool>` test_only=false **)**
 
-Blend an input. This is only useful for nodes created for an :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`. The ``time`` parameter is a relative delta, unless ``seek`` is ``true``, in which case it is absolute. A filter mode may be optionally passed (see :ref:`FilterAction<enum_AnimationNode_FilterAction>` for options).
+Blend an input. This is only useful for animation nodes created for an :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`. The ``time`` parameter is a relative delta, unless ``seek`` is ``true``, in which case it is absolute. A filter mode may be optionally passed (see :ref:`FilterAction<enum_AnimationNode_FilterAction>` for options).
 
 .. rst-class:: classref-item-separator
 
@@ -359,7 +359,7 @@ Blend an input. This is only useful for nodes created for an :ref:`AnimationNode
 
 :ref:`float<class_float>` **blend_node** **(** :ref:`StringName<class_StringName>` name, :ref:`AnimationNode<class_AnimationNode>` node, :ref:`float<class_float>` time, :ref:`bool<class_bool>` seek, :ref:`bool<class_bool>` is_external_seeking, :ref:`float<class_float>` blend, :ref:`FilterAction<enum_AnimationNode_FilterAction>` filter=0, :ref:`bool<class_bool>` sync=true, :ref:`bool<class_bool>` test_only=false **)**
 
-Blend another animation node (in case this node contains children animation nodes). This function is only useful if you inherit from :ref:`AnimationRootNode<class_AnimationRootNode>` instead, else editors will not display your node for addition.
+Blend another animation node (in case this animation node contains children animation nodes). This function is only useful if you inherit from :ref:`AnimationRootNode<class_AnimationRootNode>` instead, else editors will not display your animation node for addition.
 
 .. rst-class:: classref-item-separator
 
@@ -383,7 +383,7 @@ Returns the input index which corresponds to ``name``. If not found, returns ``-
 
 :ref:`int<class_int>` **get_input_count** **(** **)** |const|
 
-Amount of inputs in this node, only useful for nodes that go into :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`.
+Amount of inputs in this animation node, only useful for animation nodes that go into :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`.
 
 .. rst-class:: classref-item-separator
 
@@ -407,7 +407,7 @@ Gets the name of an input by index.
 
 :ref:`Variant<class_Variant>` **get_parameter** **(** :ref:`StringName<class_StringName>` name **)** |const|
 
-Gets the value of a parameter. Parameters are custom local memory used for your nodes, given a resource can be reused in multiple trees.
+Gets the value of a parameter. Parameters are custom local memory used for your animation nodes, given a resource can be reused in multiple trees.
 
 .. rst-class:: classref-item-separator
 

classes/class_animationnodeadd2.rst

@@ -19,7 +19,11 @@ Blends two animations additively inside of an :ref:`AnimationNodeBlendTree<class
 Description
 -----------
 
-A resource to add to an :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`. Blends two animations additively based on an amount value in the ``[0.0, 1.0]`` range.
+A resource to add to an :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`. Blends two animations additively based on the amount value.
+
+If the amount is greater than ``1.0``, the animation connected to "in" port is blended with the amplified animation connected to "add" port.
+
+If the amount is less than ``0.0``, the animation connected to "in" port is blended with the inverted animation connected to "add" port.
 
 .. rst-class:: classref-introduction-group
 

classes/class_animationnodeadd3.rst

@@ -19,15 +19,17 @@ Blends two of three animations additively inside of an :ref:`AnimationNodeBlendT
 Description
 -----------
 
-A resource to add to an :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`. Blends two animations together additively out of three based on a value in the ``[-1.0, 1.0]`` range.
+A resource to add to an :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`. Blends two animations out of three additively out of three based on the amounmt value.
 
-This node has three inputs:
+This animation node has three inputs:
 
 - The base animation to add to
 
-- A -add animation to blend with when the blend amount is in the ``[-1.0, 0.0]`` range.
+- A "-add" animation to blend with when the blend amount is negative
 
-- A +add animation to blend with when the blend amount is in the ``[0.0, 1.0]`` range
+- A "+add" animation to blend with when the blend amount is positive
+
+If the absolute value of the amount is greater than ``1.0``, the animation connected to "in" port is blended with the amplified animation connected to "-add"/"+add" port.
 
 .. rst-class:: classref-introduction-group
 

classes/class_animationnodeblend2.rst

@@ -19,7 +19,9 @@ Blends two animations linearly inside of an :ref:`AnimationNodeBlendTree<class_A
 Description
 -----------
 
-A resource to add to an :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`. Blends two animations linearly based on an amount value in the ``[0.0, 1.0]`` range.
+A resource to add to an :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`. Blends two animations linearly based on the amount value.
+
+In general, the blend value should be in the ``[0.0, 1.0]`` range. Values outside of this range can blend amplified or inverted animations, however, :ref:`AnimationNodeAdd2<class_AnimationNodeAdd2>` works better for this purpose.
 
 .. rst-class:: classref-introduction-group
 

classes/class_animationnodeblend3.rst

@@ -19,15 +19,17 @@ Blends two of three animations linearly inside of an :ref:`AnimationNodeBlendTre
 Description
 -----------
 
-A resource to add to an :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`. Blends two animations together linearly out of three based on a value in the ``[-1.0, 1.0]`` range.
+A resource to add to an :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`. Blends two animations out of three linearly out of three based on the amounmt value.
 
-This node has three inputs:
+This animation node has three inputs:
 
-- The base animation
+- The base animation to blend with
 
-- A -blend animation to blend with when the blend amount is in the ``[-1.0, 0.0]`` range.
+- A "-blend" animation to blend with when the blend amount is negative value
 
-- A +blend animation to blend with when the blend amount is in the ``[0.0, 1.0]`` range
+- A "+blend" animation to blend with when the blend amount is positive value
+
+In general, the blend value should be in the ``[-1.0, 1.0]`` range. Values outside of this range can blend amplified animations, however, :ref:`AnimationNodeAdd3<class_AnimationNodeAdd3>` works better for this purpose.
 
 .. rst-class:: classref-introduction-group
 

classes/class_animationnodeblendspace1d.rst

@@ -107,7 +107,7 @@ The interpolation between animations is linear.
 
 :ref:`BlendMode<enum_AnimationNodeBlendSpace1D_BlendMode>` **BLEND_MODE_DISCRETE** = ``1``
 
-The blend space plays the animation of the node the blending position is closest to. Useful for frame-by-frame 2D animations.
+The blend space plays the animation of the animation node which blending position is closest to. Useful for frame-by-frame 2D animations.
 
 .. _class_AnimationNodeBlendSpace1D_constant_BLEND_MODE_DISCRETE_CARRY:
 

classes/class_animationnodeblendspace2d.rst

@@ -138,7 +138,7 @@ The interpolation between animations is linear.
 
 :ref:`BlendMode<enum_AnimationNodeBlendSpace2D_BlendMode>` **BLEND_MODE_DISCRETE** = ``1``
 
-The blend space plays the animation of the node the blending position is closest to. Useful for frame-by-frame 2D animations.
+The blend space plays the animation of the animation node which blending position is closest to. Useful for frame-by-frame 2D animations.
 
 .. _class_AnimationNodeBlendSpace2D_constant_BLEND_MODE_DISCRETE_CARRY:
 

classes/class_animationnodeblendtree.rst

@@ -12,14 +12,14 @@ AnimationNodeBlendTree
 
 **Inherits:** :ref:`AnimationRootNode<class_AnimationRootNode>` **<** :ref:`AnimationNode<class_AnimationNode>` **<** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
 
-A sub-tree of blend type :ref:`AnimationNode<class_AnimationNode>`\ s used for complex animations. Used by :ref:`AnimationTree<class_AnimationTree>`.
+A sub-tree of many type :ref:`AnimationNode<class_AnimationNode>`\ s used for complex animations. Used by :ref:`AnimationTree<class_AnimationTree>`.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-This node may contain a sub-tree of any other blend type nodes, such as :ref:`AnimationNodeTransition<class_AnimationNodeTransition>`, :ref:`AnimationNodeBlend2<class_AnimationNodeBlend2>`, :ref:`AnimationNodeBlend3<class_AnimationNodeBlend3>`, :ref:`AnimationNodeOneShot<class_AnimationNodeOneShot>`, etc. This is one of the most commonly used animation node roots.
+This animation node may contain a sub-tree of any other type animation nodes, such as :ref:`AnimationNodeTransition<class_AnimationNodeTransition>`, :ref:`AnimationNodeBlend2<class_AnimationNodeBlend2>`, :ref:`AnimationNodeBlend3<class_AnimationNodeBlend3>`, :ref:`AnimationNodeOneShot<class_AnimationNodeOneShot>`, etc. This is one of the most commonly used animation node roots.
 
 An :ref:`AnimationNodeOutput<class_AnimationNodeOutput>` node named ``output`` is created by default.
 
@@ -164,7 +164,7 @@ Property Descriptions
 - void **set_graph_offset** **(** :ref:`Vector2<class_Vector2>` value **)**
 - :ref:`Vector2<class_Vector2>` **get_graph_offset** **(** **)**
 
-The global offset of all sub-nodes.
+The global offset of all sub animation nodes.
 
 .. rst-class:: classref-section-separator
 
@@ -181,7 +181,7 @@ Method Descriptions
 
 void **add_node** **(** :ref:`StringName<class_StringName>` name, :ref:`AnimationNode<class_AnimationNode>` node, :ref:`Vector2<class_Vector2>` position=Vector2(0, 0) **)**
 
-Adds an :ref:`AnimationNode<class_AnimationNode>` at the given ``position``. The ``name`` is used to identify the created sub-node later.
+Adds an :ref:`AnimationNode<class_AnimationNode>` at the given ``position``. The ``name`` is used to identify the created sub animation node later.
 
 .. rst-class:: classref-item-separator
 
@@ -205,7 +205,7 @@ Connects the output of an :ref:`AnimationNode<class_AnimationNode>` as input for
 
 void **disconnect_node** **(** :ref:`StringName<class_StringName>` input_node, :ref:`int<class_int>` input_index **)**
 
-Disconnects the node connected to the specified input.
+Disconnects the animation node connected to the specified input.
 
 .. rst-class:: classref-item-separator
 
@@ -217,7 +217,7 @@ Disconnects the node connected to the specified input.
 
 :ref:`AnimationNode<class_AnimationNode>` **get_node** **(** :ref:`StringName<class_StringName>` name **)** |const|
 
-Returns the sub-node with the specified ``name``.
+Returns the sub animation node with the specified ``name``.
 
 .. rst-class:: classref-item-separator
 
@@ -229,7 +229,7 @@ Returns the sub-node with the specified ``name``.
 
 :ref:`Vector2<class_Vector2>` **get_node_position** **(** :ref:`StringName<class_StringName>` name **)** |const|
 
-Returns the position of the sub-node with the specified ``name``.
+Returns the position of the sub animation node with the specified ``name``.
 
 .. rst-class:: classref-item-separator
 
@@ -241,7 +241,7 @@ Returns the position of the sub-node with the specified ``name``.
 
 :ref:`bool<class_bool>` **has_node** **(** :ref:`StringName<class_StringName>` name **)** |const|
 
-Returns ``true`` if a sub-node with specified ``name`` exists.
+Returns ``true`` if a sub animation node with specified ``name`` exists.
 
 .. rst-class:: classref-item-separator
 
@@ -253,7 +253,7 @@ Returns ``true`` if a sub-node with specified ``name`` exists.
 
 void **remove_node** **(** :ref:`StringName<class_StringName>` name **)**
 
-Removes a sub-node.
+Removes a sub animation node.
 
 .. rst-class:: classref-item-separator
 
@@ -265,7 +265,7 @@ Removes a sub-node.
 
 void **rename_node** **(** :ref:`StringName<class_StringName>` name, :ref:`StringName<class_StringName>` new_name **)**
 
-Changes the name of a sub-node.
+Changes the name of a sub animation node.
 
 .. rst-class:: classref-item-separator
 
@@ -277,7 +277,7 @@ Changes the name of a sub-node.
 
 void **set_node_position** **(** :ref:`StringName<class_StringName>` name, :ref:`Vector2<class_Vector2>` position **)**
 
-Modifies the position of a sub-node.
+Modifies the position of a sub animation node.
 
 .. |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_animationnodeoneshot.rst

@@ -19,7 +19,7 @@ Plays an animation once in an :ref:`AnimationNodeBlendTree<class_AnimationNodeBl
 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.
+A resource to add to an :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`. This animation 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>`.
 
@@ -56,13 +56,13 @@ After setting the request and changing the animation playback, the one-shot node
  .. code-tab:: csharp
 
     // Play child animation connected to "shot" port.
-    animationTree.Set("parameters/OneShot/request", AnimationNodeOneShot.ONE_SHOT_REQUEST_FIRE);
+    animationTree.Set("parameters/OneShot/request", (int)AnimationNodeOneShot.OneShotRequest.Fire);
     
     // Abort child animation connected to "shot" port.
-    animationTree.Set("parameters/OneShot/request", AnimationNodeOneShot.ONE_SHOT_REQUEST_ABORT);
+    animationTree.Set("parameters/OneShot/request", (int)AnimationNodeOneShot.OneShotRequest.Abort);
     
     // Abort child animation with fading out connected to "shot" port.
-    animationTree.Set("parameters/OneShot/request", AnimationNodeOneShot.ONE_SHOT_REQUEST_FADE_OUT);
+    animationTree.Set("parameters/OneShot/request", (int)AnimationNodeOneShot.OneShotRequest.FadeOut);
     
     // Get current state (read-only).
     animationTree.Get("parameters/OneShot/active");

classes/class_animationnodestatemachine.rst

@@ -19,7 +19,7 @@ A state machine with multiple :ref:`AnimationRootNode<class_AnimationRootNode>`\
 Description
 -----------
 
-Contains multiple :ref:`AnimationRootNode<class_AnimationRootNode>`\ s representing animation states, connected in a graph. Node transitions can be configured to happen automatically or via code, using a shortest-path algorithm. Retrieve the :ref:`AnimationNodeStateMachinePlayback<class_AnimationNodeStateMachinePlayback>` object from the :ref:`AnimationTree<class_AnimationTree>` node to control it programmatically.
+Contains multiple :ref:`AnimationRootNode<class_AnimationRootNode>`\ s representing animation states, connected in a graph. State transitions can be configured to happen automatically or via code, using a shortest-path algorithm. Retrieve the :ref:`AnimationNodeStateMachinePlayback<class_AnimationNodeStateMachinePlayback>` object from the :ref:`AnimationTree<class_AnimationTree>` node to control it programmatically.
 
 \ **Example:**\ 
 
@@ -221,7 +221,7 @@ Method Descriptions
 
 void **add_node** **(** :ref:`StringName<class_StringName>` name, :ref:`AnimationNode<class_AnimationNode>` node, :ref:`Vector2<class_Vector2>` position=Vector2(0, 0) **)**
 
-Adds a new node to the graph. The ``position`` is used for display in the editor.
+Adds a new animation node to the graph. The ``position`` is used for display in the editor.
 
 .. rst-class:: classref-item-separator
 
@@ -233,7 +233,7 @@ Adds a new node to the graph. The ``position`` is used for display in the editor
 
 void **add_transition** **(** :ref:`StringName<class_StringName>` from, :ref:`StringName<class_StringName>` to, :ref:`AnimationNodeStateMachineTransition<class_AnimationNodeStateMachineTransition>` transition **)**
 
-Adds a transition between the given nodes.
+Adds a transition between the given animation nodes.
 
 .. rst-class:: classref-item-separator
 
@@ -281,7 +281,7 @@ Returns the given animation node's name.
 
 :ref:`Vector2<class_Vector2>` **get_node_position** **(** :ref:`StringName<class_StringName>` name **)** |const|
 
-Returns the given node's coordinates. Used for display in the editor.
+Returns the given animation node's coordinates. Used for display in the editor.
 
 .. rst-class:: classref-item-separator
 
@@ -341,7 +341,7 @@ Returns the given transition's end node.
 
 :ref:`bool<class_bool>` **has_node** **(** :ref:`StringName<class_StringName>` name **)** |const|
 
-Returns ``true`` if the graph contains the given node.
+Returns ``true`` if the graph contains the given animation node.
 
 .. rst-class:: classref-item-separator
 
@@ -353,7 +353,7 @@ Returns ``true`` if the graph contains the given node.
 
 :ref:`bool<class_bool>` **has_transition** **(** :ref:`StringName<class_StringName>` from, :ref:`StringName<class_StringName>` to **)** |const|
 
-Returns ``true`` if there is a transition between the given nodes.
+Returns ``true`` if there is a transition between the given animation nodes.
 
 .. rst-class:: classref-item-separator
 
@@ -365,7 +365,7 @@ Returns ``true`` if there is a transition between the given nodes.
 
 void **remove_node** **(** :ref:`StringName<class_StringName>` name **)**
 
-Deletes the given node from the graph.
+Deletes the given animation node from the graph.
 
 .. rst-class:: classref-item-separator
 
@@ -377,7 +377,7 @@ Deletes the given node from the graph.
 
 void **remove_transition** **(** :ref:`StringName<class_StringName>` from, :ref:`StringName<class_StringName>` to **)**
 
-Deletes the transition between the two specified nodes.
+Deletes the transition between the two specified animation nodes.
 
 .. rst-class:: classref-item-separator
 
@@ -401,7 +401,7 @@ Deletes the given transition by index.
 
 void **rename_node** **(** :ref:`StringName<class_StringName>` name, :ref:`StringName<class_StringName>` new_name **)**
 
-Renames the given node.
+Renames the given animation node.
 
 .. rst-class:: classref-item-separator
 
@@ -439,7 +439,7 @@ Sets the draw offset of the graph. Used for display in the editor.
 
 void **set_node_position** **(** :ref:`StringName<class_StringName>` name, :ref:`Vector2<class_Vector2>` position **)**
 
-Sets the node's coordinates. Used for display in the editor.
+Sets the animation node's coordinates. Used for display in the editor.
 
 .. |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

@@ -33,7 +33,7 @@ Allows control of :ref:`AnimationTree<class_AnimationTree>` state machines creat
 
  .. code-tab:: csharp
 
-    var stateMachine = GetNode<AnimationTree>("AnimationTree").Get("parameters/playback") as AnimationNodeStateMachinePlayback;
+    var stateMachine = GetNode<AnimationTree>("AnimationTree").Get("parameters/playback").As<AnimationNodeStateMachinePlayback>();
     stateMachine.Travel("some_state");
 
 

classes/class_animationnodesub2.rst

@@ -0,0 +1,42 @@
+:github_url: hide
+
+.. DO NOT EDIT THIS FILE!!!
+.. Generated automatically from Godot engine sources.
+.. Generator: https://github.com/godotengine/godot/tree/master/doc/tools/make_rst.py.
+.. XML source: https://github.com/godotengine/godot/tree/master/doc/classes/AnimationNodeSub2.xml.
+
+.. _class_AnimationNodeSub2:
+
+AnimationNodeSub2
+=================
+
+**Inherits:** :ref:`AnimationNodeSync<class_AnimationNodeSync>` **<** :ref:`AnimationNode<class_AnimationNode>` **<** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
+
+Blends two animations subtractively inside of an :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`.
+
+.. rst-class:: classref-introduction-group
+
+Description
+-----------
+
+A resource to add to an :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`. Blends two animations subtractively based on the amount value.
+
+This animation node is usually used for pre-calculation to cancel out any extra poses from the animation for the "add" animation source in :ref:`AnimationNodeAdd2<class_AnimationNodeAdd2>` or :ref:`AnimationNodeAdd3<class_AnimationNodeAdd3>`.
+
+In general, the blend value should be in the ``[0.0, 1.0]`` range, but values outside of this range can be used for amplified or inverted animations.
+
+\ **Note:** This calculation is different from using a negative value in :ref:`AnimationNodeAdd2<class_AnimationNodeAdd2>`, since the transformation matrices do not satisfy the commutative law. **AnimationNodeSub2** multiplies the transformation matrix of the inverted animation from the left side, while negative :ref:`AnimationNodeAdd2<class_AnimationNodeAdd2>` multiplies it from the right side.
+
+.. rst-class:: classref-introduction-group
+
+Tutorials
+---------
+
+- :doc:`AnimationTree <../tutorials/animation/animation_tree>`
+
+.. |virtual| replace:: :abbr:`virtual (This method should typically be overridden by the user to have any effect.)`
+.. |const| replace:: :abbr:`const (This method has no side effects. It doesn't modify any of the instance's member variables.)`
+.. |vararg| replace:: :abbr:`vararg (This method accepts any number of arguments after the ones described here.)`
+.. |constructor| replace:: :abbr:`constructor (This method is used to construct a type.)`
+.. |static| replace:: :abbr:`static (This method doesn't need an instance to be called, so it can be called directly using the class name.)`
+.. |operator| replace:: :abbr:`operator (This method describes a valid operator to use with this type as left-hand operand.)`

classes/class_animationnodesync.rst

@@ -12,7 +12,7 @@ AnimationNodeSync
 
 **Inherits:** :ref:`AnimationNode<class_AnimationNode>` **<** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
 
-**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>`
+**Inherited By:** :ref:`AnimationNodeAdd2<class_AnimationNodeAdd2>`, :ref:`AnimationNodeAdd3<class_AnimationNodeAdd3>`, :ref:`AnimationNodeBlend2<class_AnimationNodeBlend2>`, :ref:`AnimationNodeBlend3<class_AnimationNodeBlend3>`, :ref:`AnimationNodeOneShot<class_AnimationNodeOneShot>`, :ref:`AnimationNodeSub2<class_AnimationNodeSub2>`, :ref:`AnimationNodeTransition<class_AnimationNodeTransition>`
 
 Base class for :ref:`AnimationNode<class_AnimationNode>`\ s with more than two input ports that must be synchronized.
 

classes/class_animationnodetimeseek.rst

@@ -19,7 +19,7 @@ A time-seeking animation node used in :ref:`AnimationTree<class_AnimationTree>`.
 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>`.
+This animation node can be used to cause a seek command to happen to any sub-children of the animation graph. Use 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``.
 

classes/class_animationnodetransition.rst

@@ -41,7 +41,7 @@ After setting the request and changing the animation playback, the transition no
     animation_tree["parameters/Transition/current_state"]
     
     # Get current state index (read-only).
-    animation_tree.get("parameters/Transition/current_index"))
+    animation_tree.get("parameters/Transition/current_index")
     # Alternative syntax (same result as above).
     animation_tree["parameters/Transition/current_index"]
 
@@ -142,7 +142,7 @@ If ``true``, allows transition to the self state. When the reset option is enabl
 - void **set_input_count** **(** :ref:`int<class_int>` value **)**
 - :ref:`int<class_int>` **get_input_count** **(** **)**
 
-The number of enabled input ports for this node.
+The number of enabled input ports for this animation node.
 
 .. rst-class:: classref-item-separator
 

classes/class_animationplayer.rst

@@ -676,6 +676,8 @@ Returns the :ref:`Animation<class_Animation>` with the key ``name``. If the anim
 
 Returns the first :ref:`AnimationLibrary<class_AnimationLibrary>` with key ``name`` or ``null`` if not found.
 
+To get the **AnimationPlayer**'s global animation library, use ``get_animation_library("")``.
+
 .. rst-class:: classref-item-separator
 
 ----

classes/class_animationrootnode.rst

@@ -23,6 +23,8 @@ Description
 
 **AnimationRootNode** is a base class for :ref:`AnimationNode<class_AnimationNode>`\ s that hold a complete animation. A complete animation refers to the output of an :ref:`AnimationNodeOutput<class_AnimationNodeOutput>` in an :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>` or the output of another **AnimationRootNode**. Used for :ref:`AnimationTree.tree_root<class_AnimationTree_property_tree_root>` or in other **AnimationRootNode**\ s.
 
+Examples of built-in root nodes include :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>` (allows blending nodes between each other using various modes), :ref:`AnimationNodeStateMachine<class_AnimationNodeStateMachine>` (allows to configure blending and transitions between nodes using a state machine pattern), :ref:`AnimationNodeBlendSpace2D<class_AnimationNodeBlendSpace2D>` (allows linear blending between **three** :ref:`AnimationNode<class_AnimationNode>`\ s), :ref:`AnimationNodeBlendSpace1D<class_AnimationNodeBlendSpace1D>` (allows linear blending only between **two** :ref:`AnimationNode<class_AnimationNode>`\ s).
+
 .. rst-class:: classref-introduction-group
 
 Tutorials

classes/class_area2d.rst

@@ -12,18 +12,16 @@ 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, as well as physics and audio influence.
+A region of 2D space that detects other :ref:`CollisionObject2D<class_CollisionObject2D>`\ s entering or exiting it.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-2D area that detects :ref:`CollisionObject2D<class_CollisionObject2D>` nodes overlapping, entering, or exiting. Can also alter or override local physics parameters (gravity, damping) and route audio to custom audio buses.
+**Area2D** is a region of 2D space defined by one or multiple :ref:`CollisionShape2D<class_CollisionShape2D>` or :ref:`CollisionPolygon2D<class_CollisionPolygon2D>` child nodes. It detects when other :ref:`CollisionObject2D<class_CollisionObject2D>`\ s enter or exit it, and it also keeps track of which collision objects haven't exited it yet (i.e. which one are overlapping it).
 
-To give the area its shape, add a :ref:`CollisionShape2D<class_CollisionShape2D>` or a :ref:`CollisionPolygon2D<class_CollisionPolygon2D>` node as a *direct* child (or add multiple such nodes as direct children) of the area.
-
-\ **Warning:** See :ref:`ConcavePolygonShape2D<class_ConcavePolygonShape2D>` for a warning about possibly unexpected behavior when using that shape for an area.
+This node can also locally alter or override physics parameters (gravity, damping) and route audio to custom audio buses.
 
 .. rst-class:: classref-introduction-group
 

classes/class_area3d.rst

@@ -12,26 +12,26 @@ Area3D
 
 **Inherits:** :ref:`CollisionObject3D<class_CollisionObject3D>` **<** :ref:`Node3D<class_Node3D>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-3D area for detection, as well as physics and audio influence.
+A region of 3D space that detects other :ref:`CollisionObject3D<class_CollisionObject3D>`\ s entering or exiting it.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-3D area that detects :ref:`CollisionObject3D<class_CollisionObject3D>` nodes overlapping, entering, or exiting. Can also alter or override local physics parameters (gravity, damping) and route audio to custom audio buses.
+**Area3D** is a region of 3D space defined by one or multiple :ref:`CollisionShape3D<class_CollisionShape3D>` or :ref:`CollisionPolygon3D<class_CollisionPolygon3D>` child nodes. It detects when other :ref:`CollisionObject3D<class_CollisionObject3D>`\ s enter or exit it, and it also keeps track of which collision objects haven't exited it yet (i.e. which one are overlapping it).
 
-To give the area its shape, add a :ref:`CollisionShape3D<class_CollisionShape3D>` or a :ref:`CollisionPolygon3D<class_CollisionPolygon3D>` node as a *direct* child (or add multiple such nodes as direct children) of the area.
+This node can also locally alter or override physics parameters (gravity, damping) and route audio to custom audio buses.
 
-\ **Warning:** See :ref:`ConcavePolygonShape3D<class_ConcavePolygonShape3D>` (also called "trimesh") for a warning about possibly unexpected behavior when using that shape for an area.
-
-\ **Warning:** With a non-uniform scale this node will probably not function as expected. Please make sure to keep its scale uniform (i.e. the same on all axes), and change the size(s) of its collision shape(s) instead.
+\ **Warning:** Using a :ref:`ConcavePolygonShape3D<class_ConcavePolygonShape3D>` inside a :ref:`CollisionShape3D<class_CollisionShape3D>` child of this node (created e.g. by using the *Create Trimesh Collision Sibling* option in the *Mesh* menu that appears when selecting a :ref:`MeshInstance3D<class_MeshInstance3D>` node) may give unexpected results, since this collision shape is hollow. If this is not desired, it has to be split into multiple :ref:`ConvexPolygonShape3D<class_ConvexPolygonShape3D>`\ s or primitive shapes like :ref:`BoxShape3D<class_BoxShape3D>`, or in some cases it may be replaceable by a :ref:`CollisionPolygon3D<class_CollisionPolygon3D>`.
 
 .. rst-class:: classref-introduction-group
 
 Tutorials
 ---------
 
+- :doc:`Using Area2D <../tutorials/physics/using_area_2d>`
+
 - `3D Platformer Demo <https://godotengine.org/asset-library/asset/125>`__
 
 - `GUI in 3D Demo <https://godotengine.org/asset-library/asset/127>`__

classes/class_array.rst

@@ -10,14 +10,14 @@
 Array
 =====
 
-A generic array datatype.
+A built-in data structure that holds a sequence of elements.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-A generic array that can contain several elements of any type, accessible by a numerical index starting at 0. Negative indices can be used to count from the back, like in Python (-1 is the last element, -2 is the second to last, etc.).
+An array data structure that can contain a sequence of elements of any type. Elements are accessed by a numerical index starting at 0. Negative indices are used to count from the back (-1 is the last element, -2 is the second to last, etc.).
 
 \ **Example:**\ 
 
@@ -64,8 +64,6 @@ Arrays can be concatenated using the ``+`` operator:
 
 
 
-\ **Note:** Concatenating with the ``+=`` operator will create a new array, which has a cost. If you want to append another array to an existing array, :ref:`append_array<class_Array_method_append_array>` is more efficient.
-
 \ **Note:** Arrays are always passed by reference. To get a copy of an array that can be modified independently of the original array, use :ref:`duplicate<class_Array_method_duplicate>`.
 
 \ **Note:** Erasing elements while iterating over arrays is **not** supported and will result in unpredictable behavior.

classes/class_arrayoccluder3d.rst

@@ -69,9 +69,9 @@ Property Descriptions
 - void **set_indices** **(** :ref:`PackedInt32Array<class_PackedInt32Array>` value **)**
 - :ref:`PackedInt32Array<class_PackedInt32Array>` **get_indices** **(** **)**
 
-.. container:: contribute
+The occluder's index position. Indices determine which points from the :ref:`vertices<class_ArrayOccluder3D_property_vertices>` array should be drawn, and in which order.
 
-	There is currently no description for this property. Please help us by :ref:`contributing one <doc_updating_the_class_reference>`!
+\ **Note:** The occluder is always updated after setting this value. If creating occluders procedurally, consider using :ref:`set_arrays<class_ArrayOccluder3D_method_set_arrays>` instead to avoid updating the occluder twice when it's created.
 
 .. rst-class:: classref-item-separator
 
@@ -88,9 +88,9 @@ Property Descriptions
 - void **set_vertices** **(** :ref:`PackedVector3Array<class_PackedVector3Array>` value **)**
 - :ref:`PackedVector3Array<class_PackedVector3Array>` **get_vertices** **(** **)**
 
-.. container:: contribute
+The occluder's vertex positions in local 3D coordinates.
 
-	There is currently no description for this property. Please help us by :ref:`contributing one <doc_updating_the_class_reference>`!
+\ **Note:** The occluder is always updated after setting this value. If creating occluders procedurally, consider using :ref:`set_arrays<class_ArrayOccluder3D_method_set_arrays>` instead to avoid updating the occluder twice when it's created.
 
 .. rst-class:: classref-section-separator
 
@@ -107,9 +107,7 @@ Method Descriptions
 
 void **set_arrays** **(** :ref:`PackedVector3Array<class_PackedVector3Array>` vertices, :ref:`PackedInt32Array<class_PackedInt32Array>` indices **)**
 
-.. container:: contribute
-
-	There is currently no description for this method. Please help us by :ref:`contributing one <doc_updating_the_class_reference>`!
+Sets :ref:`indices<class_ArrayOccluder3D_property_indices>` and :ref:`vertices<class_ArrayOccluder3D_property_vertices>`, while updating the final occluder only once after both values are set.
 
 .. |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_aspectratiocontainer.rst

@@ -12,21 +12,21 @@ AspectRatioContainer
 
 **Inherits:** :ref:`Container<class_Container>` **<** :ref:`Control<class_Control>` **<** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-Container that preserves its child controls' aspect ratio.
+A container that preserves the proportions of its child controls.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Arranges child controls in a way to preserve their aspect ratio automatically whenever the container is resized. Solves the problem where the container size is dynamic and the contents' size needs to adjust accordingly without losing proportions.
+A container type that arranges its child controls in a way that preserves their proportions automatically when the container is resized. Useful when a container has a dynamic size and the child nodes must adjust their sizes accordingly without losing their aspect ratios.
 
 .. rst-class:: classref-introduction-group
 
 Tutorials
 ---------
 
-- :doc:`GUI containers <../tutorials/ui/gui_containers>`
+- :doc:`Using Containers <../tutorials/ui/gui_containers>`
 
 .. rst-class:: classref-reftable-group
 

classes/class_astar2d.rst

@@ -12,14 +12,16 @@ AStar2D
 
 **Inherits:** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
 
-AStar class representation that uses 2D vectors as edges.
+An implementation of A\* for finding the shortest path between two vertices on a connected graph in 2D space.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-This is a wrapper for the :ref:`AStar3D<class_AStar3D>` class which uses 2D vectors instead of 3D vectors.
+An implementation of the A\* algorithm, used to find the shortest path between two vertices on a connected graph in 2D space.
+
+See :ref:`AStar3D<class_AStar3D>` for a more thorough explanation on how to use this class. **AStar2D** is a wrapper for :ref:`AStar3D<class_AStar3D>` that enforces 2D coordinates.
 
 .. rst-class:: classref-reftable-group
 
@@ -98,7 +100,7 @@ Method Descriptions
 
 Called when computing the cost between two connected points.
 
-Note that this function is hidden in the default ``AStar2D`` class.
+Note that this function is hidden in the default **AStar2D** class.
 
 .. rst-class:: classref-item-separator
 
@@ -112,7 +114,7 @@ Note that this function is hidden in the default ``AStar2D`` class.
 
 Called when estimating the cost between a point and the path's ending point.
 
-Note that this function is hidden in the default ``AStar2D`` class.
+Note that this function is hidden in the default **AStar2D** class.
 
 .. rst-class:: classref-item-separator
 

classes/class_astar3d.rst

@@ -12,16 +12,16 @@ AStar3D
 
 **Inherits:** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
 
-An implementation of A\* to find the shortest paths among connected points in space.
+An implementation of A\* for finding the shortest path between two vertices on a connected graph in 3D space.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-A\* (A star) is a computer algorithm that is widely used in pathfinding and graph traversal, the process of plotting short paths among vertices (points), passing through a given set of edges (segments). It enjoys widespread use due to its performance and accuracy. Godot's A\* implementation uses points in three-dimensional space and Euclidean distances by default.
+A\* (A star) is a computer algorithm used in pathfinding and graph traversal, the process of plotting short paths among vertices (points), passing through a given set of edges (segments). It enjoys widespread use due to its performance and accuracy. Godot's A\* implementation uses points in 3D space and Euclidean distances by default.
 
-You must add points manually with :ref:`add_point<class_AStar3D_method_add_point>` and create segments manually with :ref:`connect_points<class_AStar3D_method_connect_points>`. Then you can test if there is a path between two points with the :ref:`are_points_connected<class_AStar3D_method_are_points_connected>` function, get a path containing indices by :ref:`get_id_path<class_AStar3D_method_get_id_path>`, or one containing actual coordinates with :ref:`get_point_path<class_AStar3D_method_get_point_path>`.
+You must add points manually with :ref:`add_point<class_AStar3D_method_add_point>` and create segments manually with :ref:`connect_points<class_AStar3D_method_connect_points>`. Once done, you can test if there is a path between two points with the :ref:`are_points_connected<class_AStar3D_method_are_points_connected>` function, get a path containing indices by :ref:`get_id_path<class_AStar3D_method_get_id_path>`, or one containing actual coordinates with :ref:`get_point_path<class_AStar3D_method_get_point_path>`.
 
 It is also possible to use non-Euclidean distances. To do so, create a class that extends ``AStar3D`` and override methods :ref:`_compute_cost<class_AStar3D_method__compute_cost>` and :ref:`_estimate_cost<class_AStar3D_method__estimate_cost>`. Both take two indices and return a length, as is shown in the following example.
 

classes/class_astargrid2d.rst

@@ -12,16 +12,16 @@ AStarGrid2D
 
 **Inherits:** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
 
-A\* (or "A-Star") pathfinding tailored to find the shortest paths on 2D grids.
+An implementation of A\* for finding the shortest path between two points on a partial 2D grid.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Compared to :ref:`AStar2D<class_AStar2D>` you don't need to manually create points or connect them together. It also supports multiple type of heuristics and modes for diagonal movement. This class also provides a jumping mode which is faster to calculate than without it in the :ref:`AStar2D<class_AStar2D>` class.
+**AStarGrid2D** is a variant of :ref:`AStar2D<class_AStar2D>` that is specialized for partial 2D grids. It is simpler to use because it doesn't require you to manually create points and connect them together. This class also supports multiple types of heuristics, modes for diagonal movement, and a jumping mode to speed up calculations.
 
-In contrast to :ref:`AStar2D<class_AStar2D>`, you only need set the :ref:`region<class_AStarGrid2D_property_region>` of the grid, optionally set the :ref:`cell_size<class_AStarGrid2D_property_cell_size>` and then call the :ref:`update<class_AStarGrid2D_method_update>` method:
+To use **AStarGrid2D**, you only need to set the :ref:`region<class_AStarGrid2D_property_region>` of the grid, optionally set the :ref:`cell_size<class_AStarGrid2D_property_cell_size>`, and then call the :ref:`update<class_AStarGrid2D_method_update>` method:
 
 
 .. tabs::
@@ -46,6 +46,8 @@ In contrast to :ref:`AStar2D<class_AStar2D>`, you only need set the :ref:`region
 
 
 
+To remove a point from the pathfinding grid, it must be set as "solid" with :ref:`set_point_solid<class_AStarGrid2D_method_set_point_solid>`.
+
 .. rst-class:: classref-reftable-group
 
 Properties

classes/class_audiostreamplaybackpolyphonic.rst

@@ -87,7 +87,7 @@ Return true whether the stream associated with an integer ID is still playing. C
 
 Play an :ref:`AudioStream<class_AudioStream>` at a given offset, volume and pitch scale. Playback starts immediately.
 
-The return value is an unique integer ID that is associated to this playback stream and which can be used to control it.
+The return value is a unique integer ID that is associated to this playback stream and which can be used to control it.
 
 This ID becomes invalid when the stream ends (if it does not loop), when the **AudioStreamPlaybackPolyphonic** is stopped, or when :ref:`stop_stream<class_AudioStreamPlaybackPolyphonic_method_stop_stream>` is called.
 

classes/class_basebutton.rst

@@ -14,14 +14,14 @@ BaseButton
 
 **Inherited By:** :ref:`Button<class_Button>`, :ref:`LinkButton<class_LinkButton>`, :ref:`TextureButton<class_TextureButton>`
 
-Base class for different kinds of buttons.
+Abstract base class for GUI buttons.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-BaseButton is the abstract base class for buttons, so it shouldn't be used directly (it doesn't display anything). Other types of buttons inherit from it.
+**BaseButton** is an abstract base class for GUI buttons. It doesn't display anything by itself.
 
 .. rst-class:: classref-reftable-group
 

classes/class_basis.rst

@@ -10,18 +10,18 @@
 Basis
 =====
 
-3×3 matrix datatype.
+A 3×3 matrix for representing 3D rotation and scale.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-3×3 matrix used for 3D rotation and scale. Almost always used as an orthogonal basis for a :ref:`Transform3D<class_Transform3D>`.
+A 3×3 matrix used for representing 3D rotation and scale. Usually used as an orthogonal basis for a :ref:`Transform3D<class_Transform3D>`.
 
 Contains 3 vector fields X, Y and Z as its columns, which are typically interpreted as the local basis vectors of a transformation. For such use, it is composed of a scaling and a rotation matrix, in that order (M = R.S).
 
-Can also be accessed as array of 3D vectors. These vectors are normally orthogonal to each other, but are not necessarily normalized (due to scaling).
+Basis can also be accessed as an array of 3D vectors. These vectors are usually orthogonal to each other, but are not necessarily normalized (due to scaling).
 
 For more information, read the "Matrices and transforms" documentation article.
 
@@ -394,7 +394,7 @@ Returns the inverse of the matrix.
 
 :ref:`bool<class_bool>` **is_equal_approx** **(** :ref:`Basis<class_Basis>` b **)** |const|
 
-Returns ``true`` if this basis and ``b`` are approximately equal, by calling ``is_equal_approx`` on each component.
+Returns ``true`` if this basis and ``b`` are approximately equal, by calling :ref:`@GlobalScope.is_equal_approx<class_@GlobalScope_method_is_equal_approx>` on all vector components.
 
 .. rst-class:: classref-item-separator
 
@@ -406,7 +406,7 @@ Returns ``true`` if this basis and ``b`` are approximately equal, by calling ``i
 
 :ref:`bool<class_bool>` **is_finite** **(** **)** |const|
 
-Returns ``true`` if this basis is finite, by calling :ref:`@GlobalScope.is_finite<class_@GlobalScope_method_is_finite>` on each component.
+Returns ``true`` if this basis is finite, by calling :ref:`@GlobalScope.is_finite<class_@GlobalScope_method_is_finite>` on all vector components.
 
 .. rst-class:: classref-item-separator
 

classes/class_bool.rst

@@ -10,113 +10,59 @@
 bool
 ====
 
-Boolean built-in type.
+A built-in boolean type.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Boolean is a built-in type. There are two boolean values: ``true`` and ``false``. You can think of it as a switch with on or off (1 or 0) setting. Booleans are used in programming for logic in condition statements, like ``if`` statements.
+A **bool** is always one of two values: ``true`` or ``false``, similar to a switch that is either on or off. Booleans are used in programming for logic in condition statements.
 
-Booleans can be directly used in ``if`` statements. The code below demonstrates this on the ``if can_shoot:`` line. You don't need to use ``== true``, you only need ``if can_shoot:``. Similarly, use ``if not can_shoot:`` rather than ``== false``.
+Booleans can be directly used in ``if`` and ``elif`` statements. You don't need to add ``== true`` or ``== false``:
 
 
 .. tabs::
 
  .. code-tab:: gdscript
 
-    var _can_shoot = true
-    
-    func shoot():
-        if _can_shoot:
-            pass # Perform shooting actions here.
+    if can_shoot:
+        launch_bullet()
 
  .. code-tab:: csharp
 
-    private bool _canShoot = true;
-    
-    public void Shoot()
+    if (canShoot)
     {
-        if (_canShoot)
-        {
-            // Perform shooting actions here.
-        }
+        launchBullet();
     }
 
 
 
-The following code will only create a bullet if both conditions are met: action "shoot" is pressed and if ``can_shoot`` is ``true``.
+Many common methods and operations return **bool**\ s, for example, ``shooting_cooldown <= 0.0`` may evaluate to ``true`` or ``false`` depending on the number's value.
 
-\ **Note:** ``Input.is_action_pressed("shoot")`` is also a boolean that is ``true`` when "shoot" is pressed and ``false`` when "shoot" isn't pressed.
+\ **bool**\ s are usually used with the logical operators ``and``, ``or``, and ``not`` to create complex conditions:
 
 
 .. tabs::
 
  .. code-tab:: gdscript
 
-    var _can_shoot = true
+    if bullets > 0 and not is_reloading:
+        launch_bullet()
     
-    func shoot():
-        if _can_shoot and Input.is_action_pressed("shoot"):
-            create_bullet()
+    if bullets == 0 or is_reloading:
+        play_clack_sound()
 
  .. code-tab:: csharp
 
-    private bool _canShoot = true;
-    
-    public void Shoot()
-    {
-        if (_canShoot && Input.IsActionPressed("shoot"))
-        {
-            CreateBullet();
-        }
-    }
-
-
-
-The following code will set ``can_shoot`` to ``false`` and start a timer. This will prevent player from shooting until the timer runs out. Next ``can_shoot`` will be set to ``true`` again allowing player to shoot once again.
-
-
-.. tabs::
-
- .. code-tab:: gdscript
-
-    var _can_shoot = true
-    @onready var _cool_down = $CoolDownTimer
-    
-    func shoot():
-        if _can_shoot and Input.is_action_pressed("shoot"):
-            create_bullet()
-            _can_shoot = false
-            _cool_down.start()
-    
-    func _on_cool_down_timer_timeout():
-        _can_shoot = true
-
- .. code-tab:: csharp
-
-    private bool _canShoot = true;
-    private Timer _coolDown;
-    
-    public override void _Ready()
-    {
-        _coolDown = GetNode<Timer>("CoolDownTimer");
-    }
-    
-    public void Shoot()
+    if (bullets > 0 && !isReloading)
     {
-        if (_canShoot && Input.IsActionPressed("shoot"))
-        {
-            CreateBullet();
-            _canShoot = false;
-            _coolDown.Start();
-        }
+        launchBullet();
     }
     
-    public void OnCoolDownTimerTimeout()
+    if (bullets == 0 || isReloading)
     {
-        _canShoot = true;
+        playClackSound();
     }
 
 
@@ -192,7 +138,7 @@ Constructs a **bool** as a copy of the given **bool**.
 
 :ref:`bool<class_bool>` **bool** **(** :ref:`float<class_float>` from **)**
 
-Cast a :ref:`float<class_float>` value to a boolean value, this method will return ``false`` if ``0.0`` is passed in, and ``true`` for all other floats.
+Cast a :ref:`float<class_float>` value to a boolean value. This method will return ``false`` if ``0.0`` is passed in, and ``true`` for all other values.
 
 .. rst-class:: classref-item-separator
 
@@ -202,7 +148,7 @@ Cast a :ref:`float<class_float>` value to a boolean value, this method will retu
 
 :ref:`bool<class_bool>` **bool** **(** :ref:`int<class_int>` from **)**
 
-Cast an :ref:`int<class_int>` value to a boolean value, this method will return ``false`` if ``0`` is passed in, and ``true`` for all other ints.
+Cast an :ref:`int<class_int>` value to a boolean value. This method will return ``false`` if ``0`` is passed in, and ``true`` for all other values.
 
 .. rst-class:: classref-section-separator
 

classes/class_boxcontainer.rst

@@ -14,21 +14,21 @@ BoxContainer
 
 **Inherited By:** :ref:`HBoxContainer<class_HBoxContainer>`, :ref:`VBoxContainer<class_VBoxContainer>`
 
-Base class for box containers.
+A container that arranges its child controls horizontally or vertically.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Arranges child :ref:`Control<class_Control>` nodes vertically or horizontally, and rearranges them automatically when their minimum size changes.
+A container that arranges its child controls horizontally or vertically, rearranging them automatically when their minimum size changes.
 
 .. rst-class:: classref-introduction-group
 
 Tutorials
 ---------
 
-- :doc:`GUI containers <../tutorials/ui/gui_containers>`
+- :doc:`Using Containers <../tutorials/ui/gui_containers>`
 
 .. rst-class:: classref-reftable-group
 

classes/class_boxshape3d.rst

@@ -12,16 +12,16 @@ BoxShape3D
 
 **Inherits:** :ref:`Shape3D<class_Shape3D>` **<** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
 
-Box shape resource for 3D collisions.
+A 3D box shape used for physics collision.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-3D box shape to be added as a *direct* child of a :ref:`PhysicsBody3D<class_PhysicsBody3D>` or :ref:`Area3D<class_Area3D>` using a :ref:`CollisionShape3D<class_CollisionShape3D>` node.
+A 3D box shape, intended for use in physics. Usually used to provide a shape for a :ref:`CollisionShape3D<class_CollisionShape3D>`.
 
-\ **Performance:** Being a primitive collision shape, **BoxShape3D** is fast to check collisions against (though not as fast as :ref:`SphereShape3D<class_SphereShape3D>`).
+\ **Performance:** **BoxShape3D** is fast to check collisions against. It is faster than :ref:`CapsuleShape3D<class_CapsuleShape3D>` and :ref:`CylinderShape3D<class_CylinderShape3D>`, but slower than :ref:`SphereShape3D<class_SphereShape3D>`.
 
 .. rst-class:: classref-introduction-group
 

classes/class_button.rst

@@ -14,14 +14,14 @@ Button
 
 **Inherited By:** :ref:`CheckBox<class_CheckBox>`, :ref:`CheckButton<class_CheckButton>`, :ref:`ColorPickerButton<class_ColorPickerButton>`, :ref:`MenuButton<class_MenuButton>`, :ref:`OptionButton<class_OptionButton>`
 
-Standard themed Button.
+A themed button that can contain text and an icon.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Button is the standard themed button. It can contain text and an icon, and will display them according to the current :ref:`Theme<class_Theme>`.
+**Button** is the standard themed button. It can contain text and an icon, and it will display them according to the current :ref:`Theme<class_Theme>`.
 
 \ **Example of creating a button and assigning an action when pressed by code:**\ 
 
@@ -56,11 +56,9 @@ Button is the standard themed button. It can contain text and an icon, and will
 
 
 
-Buttons (like all Control nodes) can also be created in the editor, but some situations may require creating them from code.
-
 See also :ref:`BaseButton<class_BaseButton>` which contains common properties and methods associated with this node.
 
-\ **Note:** Buttons do not interpret touch input and therefore don't support multitouch, since mouse emulation can only press one button at a given time. Use :ref:`TouchScreenButton<class_TouchScreenButton>` for buttons that trigger gameplay movement or actions, as :ref:`TouchScreenButton<class_TouchScreenButton>` supports multitouch.
+\ **Note:** Buttons do not interpret touch input and therefore don't support multitouch, since mouse emulation can only press one button at a given time. Use :ref:`TouchScreenButton<class_TouchScreenButton>` for buttons that trigger gameplay movement or actions.
 
 .. rst-class:: classref-introduction-group
 

classes/class_buttongroup.rst

@@ -12,16 +12,16 @@ ButtonGroup
 
 **Inherits:** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
 
-Group of Buttons.
+A group of buttons that doesn't allow more than one button to be pressed at a time.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Group of :ref:`BaseButton<class_BaseButton>`. The members of this group are treated like radio buttons in the sense that only one button can be pressed at the same time. Some types of buttons (such as :ref:`CheckBox<class_CheckBox>`) may have a special appearance for this state.
+A group of :ref:`BaseButton<class_BaseButton>`-derived buttons. The buttons in a **ButtonGroup** are treated like radio buttons: No more than one button can be pressed at a time. Some types of buttons (such as :ref:`CheckBox<class_CheckBox>`) may have a special appearance in this state.
 
-Every member of the ButtonGroup should have :ref:`BaseButton.toggle_mode<class_BaseButton_property_toggle_mode>` set to ``true``.
+Every member of a **ButtonGroup** should have :ref:`BaseButton.toggle_mode<class_BaseButton_property_toggle_mode>` set to ``true``.
 
 .. rst-class:: classref-reftable-group
 

classes/class_callable.rst

@@ -10,7 +10,7 @@
 Callable
 ========
 
-Built-in type representing a method in an object instance or a standalone function.
+A built-in type representing a method or a standalone function.
 
 .. rst-class:: classref-introduction-group
 

classes/class_camera3d.rst

@@ -250,7 +250,13 @@ The :ref:`CameraAttributes<class_CameraAttributes>` to use for this camera.
 - void **set_cull_mask** **(** :ref:`int<class_int>` value **)**
 - :ref:`int<class_int>` **get_cull_mask** **(** **)**
 
-The culling mask that describes which 3D render layers are rendered by this camera.
+The culling mask that describes which :ref:`VisualInstance3D.layers<class_VisualInstance3D_property_layers>` are rendered by this camera. By default, all 20 user-visible layers are rendered.
+
+\ **Note:** Since the :ref:`cull_mask<class_Camera3D_property_cull_mask>` allows for 32 layers to be stored in total, there are an additional 12 layers that are only used internally by the engine and aren't exposed in the editor. Setting :ref:`cull_mask<class_Camera3D_property_cull_mask>` using a script allows you to toggle those reserved layers, which can be useful for editor plugins.
+
+To adjust :ref:`cull_mask<class_Camera3D_property_cull_mask>` more easily using a script, use :ref:`get_cull_mask_value<class_Camera3D_method_get_cull_mask_value>` and :ref:`set_cull_mask_value<class_Camera3D_method_set_cull_mask_value>`.
+
+\ **Note:** :ref:`VoxelGI<class_VoxelGI>`, SDFGI and :ref:`LightmapGI<class_LightmapGI>` will always take all layers into account to determine what contributes to global illumination. If this is an issue, set :ref:`GeometryInstance3D.gi_mode<class_GeometryInstance3D_property_gi_mode>` to :ref:`GeometryInstance3D.GI_MODE_DISABLED<class_GeometryInstance3D_constant_GI_MODE_DISABLED>` for meshes and :ref:`Light3D.light_bake_mode<class_Light3D_property_light_bake_mode>` to :ref:`Light3D.BAKE_DISABLED<class_Light3D_constant_BAKE_DISABLED>` for lights to exclude them from global illumination.
 
 .. rst-class:: classref-item-separator
 
@@ -320,7 +326,7 @@ The :ref:`Environment<class_Environment>` to use for this camera.
 - void **set_far** **(** :ref:`float<class_float>` value **)**
 - :ref:`float<class_float>` **get_far** **(** **)**
 
-The distance to the far culling boundary for this camera relative to its local Z axis.
+The distance to the far culling boundary for this camera relative to its local Z axis. Higher values allow the camera to see further away, while decreasing :ref:`far<class_Camera3D_property_far>` can improve performance if it results in objects being partially or fully culled.
 
 .. rst-class:: classref-item-separator
 
@@ -417,7 +423,7 @@ The axis to lock during :ref:`fov<class_Camera3D_property_fov>`/:ref:`size<class
 - void **set_near** **(** :ref:`float<class_float>` value **)**
 - :ref:`float<class_float>` **get_near** **(** **)**
 
-The distance to the near culling boundary for this camera relative to its local Z axis.
+The distance to the near culling boundary for this camera relative to its local Z axis. Lower values allow the camera to see objects more up close to its origin, at the cost of lower precision across the *entire* range. Values lower than the default can lead to increased Z-fighting.
 
 .. rst-class:: classref-item-separator
 

classes/class_canvasitem.rst

@@ -14,24 +14,20 @@ CanvasItem
 
 **Inherited By:** :ref:`Control<class_Control>`, :ref:`Node2D<class_Node2D>`
 
-Base class of anything 2D.
+Abstract base class for everything in 2D space.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Base class of anything 2D. Canvas items are laid out in a tree; children inherit and extend their parent's transform. **CanvasItem** is extended by :ref:`Control<class_Control>` for anything GUI-related, and by :ref:`Node2D<class_Node2D>` for anything related to the 2D engine.
+Abstract base class for everything in 2D space. Canvas items are laid out in a tree; children inherit and extend their parent's transform. **CanvasItem** is extended by :ref:`Control<class_Control>` for GUI-related nodes, and by :ref:`Node2D<class_Node2D>` for 2D game objects.
 
-Any **CanvasItem** can draw. For this, :ref:`queue_redraw<class_CanvasItem_method_queue_redraw>` is called by the engine, then :ref:`NOTIFICATION_DRAW<class_CanvasItem_constant_NOTIFICATION_DRAW>` will be received on idle time to request redraw. Because of this, canvas items don't need to be redrawn on every frame, improving the performance significantly. Several functions for drawing on the **CanvasItem** are provided (see ``draw_*`` functions). However, they can only be used inside :ref:`_draw<class_CanvasItem_method__draw>`, its corresponding :ref:`Object._notification<class_Object_method__notification>` or methods connected to the :ref:`draw<class_CanvasItem_signal_draw>` signal.
+Any **CanvasItem** can draw. For this, :ref:`queue_redraw<class_CanvasItem_method_queue_redraw>` is called by the engine, then :ref:`NOTIFICATION_DRAW<class_CanvasItem_constant_NOTIFICATION_DRAW>` will be received on idle time to request a redraw. Because of this, canvas items don't need to be redrawn on every frame, improving the performance significantly. Several functions for drawing on the **CanvasItem** are provided (see ``draw_*`` functions). However, they can only be used inside :ref:`_draw<class_CanvasItem_method__draw>`, its corresponding :ref:`Object._notification<class_Object_method__notification>` or methods connected to the :ref:`draw<class_CanvasItem_signal_draw>` signal.
 
-Canvas items are drawn in tree order. By default, children are on top of their parents so a root **CanvasItem** will be drawn behind everything. This behavior can be changed on a per-item basis.
+Canvas items are drawn in tree order. By default, children are on top of their parents, so a root **CanvasItem** will be drawn behind everything. This behavior can be changed on a per-item basis.
 
-A **CanvasItem** can also be hidden, which will also hide its children. It provides many ways to change parameters such as modulation (for itself and its children) and self modulation (only for itself), as well as its blend mode.
-
-Ultimately, a transform notification can be requested, which will notify the node that its global position changed in case the parent tree changed.
-
-\ **Note:** Unless otherwise specified, all methods that have angle parameters must have angles specified as *radians*. To convert degrees to radians, use :ref:`@GlobalScope.deg_to_rad<class_@GlobalScope_method_deg_to_rad>`.
+A **CanvasItem** can be hidden, which will also hide its children. By adjusting various other properties of a **CanvasItem**, you can also modulate its color (via :ref:`modulate<class_CanvasItem_property_modulate>` or :ref:`self_modulate<class_CanvasItem_property_self_modulate>`), change its Z-index, blend mode, and more.
 
 .. rst-class:: classref-introduction-group
 

classes/class_canvaslayer.rst

@@ -14,16 +14,20 @@ CanvasLayer
 
 **Inherited By:** :ref:`ParallaxBackground<class_ParallaxBackground>`
 
-Canvas drawing layer.
+A node used for independent rendering of objects within a 2D scene.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Canvas drawing layer. :ref:`CanvasItem<class_CanvasItem>` nodes that are direct or indirect children of a **CanvasLayer** will be drawn in that layer. The layer is a numeric index that defines the draw order. The default 2D scene renders with index 0, so a **CanvasLayer** with index -1 will be drawn below, and one with index 1 will be drawn above. This is very useful for HUDs (in layer 1+ or above), or backgrounds (in layer -1 or below).
+:ref:`CanvasItem<class_CanvasItem>`-derived nodes that are direct or indirect children of a **CanvasLayer** will be drawn in that layer. The layer is a numeric index that defines the draw order. The default 2D scene renders with index ``0``, so a **CanvasLayer** with index ``-1`` will be drawn below, and a **CanvasLayer** with index ``1`` will be drawn above. This order will hold regardless of the :ref:`CanvasItem.z_index<class_CanvasItem_property_z_index>` of the nodes within each layer.
 
-Embedded :ref:`Window<class_Window>`\ s are placed in layer 1024. CanvasItems in layer 1025 or above appear in front of embedded windows, CanvasItems in layer 1023 or below appear behind embedded windows.
+\ **CanvasLayer**\ s can be hidden and they can also optionally follow the viewport. This makes them useful for HUDs like health bar overlays (on layers ``1`` and higher) or backgrounds (on layers ``-1`` and lower).
+
+\ **Note:** Embedded :ref:`Window<class_Window>`\ s are placed on layer ``1024``. :ref:`CanvasItem<class_CanvasItem>`\ s on layers ``1025`` and higher appear in front of embedded windows.
+
+\ **Note:** Each **CanvasLayer** is drawn on one specific :ref:`Viewport<class_Viewport>` and cannot be shared between multiple :ref:`Viewport<class_Viewport>`\ s, see :ref:`custom_viewport<class_CanvasLayer_property_custom_viewport>`. When using multiple :ref:`Viewport<class_Viewport>`\ s, for example in a split-screen game, you need create an individual **CanvasLayer** for each :ref:`Viewport<class_Viewport>` you want it to be drawn on.
 
 .. rst-class:: classref-introduction-group
 

classes/class_canvasmodulate.rst

@@ -12,14 +12,14 @@ CanvasModulate
 
 **Inherits:** :ref:`Node2D<class_Node2D>` **<** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-Tint the entire canvas.
+A node that applies a color tint to a canvas.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-**CanvasModulate** tints the canvas elements using its assigned :ref:`color<class_CanvasModulate_property_color>`.
+**CanvasModulate** applies a color tint to all nodes on a canvas. Only one can be used to tint a canvas, but :ref:`CanvasLayer<class_CanvasLayer>`\ s can be used to render things independently.
 
 .. rst-class:: classref-reftable-group
 

classes/class_capsuleshape2d.rst

@@ -12,16 +12,16 @@ CapsuleShape2D
 
 **Inherits:** :ref:`Shape2D<class_Shape2D>` **<** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
 
-Capsule shape resource for 2D physics.
+A 2D capsule shape used for physics collision.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-2D capsule shape to be added as a *direct* child of a :ref:`PhysicsBody2D<class_PhysicsBody2D>` or :ref:`Area2D<class_Area2D>` using a :ref:`CollisionShape2D<class_CollisionShape2D>` node. In 2D, a capsule is a rectangle shape with half-circles at both ends.
+A 2D capsule shape, intended for use in physics. Usually used to provide a shape for a :ref:`CollisionShape2D<class_CollisionShape2D>`.
 
-\ **Performance:** Being a primitive collision shape, **CapsuleShape2D** is fast to check collisions against (though not as fast as :ref:`CircleShape2D<class_CircleShape2D>`).
+\ **Performance:** **CapsuleShape2D** is fast to check collisions against, but it is slower than :ref:`RectangleShape2D<class_RectangleShape2D>` and :ref:`CircleShape2D<class_CircleShape2D>`.
 
 .. rst-class:: classref-reftable-group
 

classes/class_capsuleshape3d.rst

@@ -12,16 +12,16 @@ CapsuleShape3D
 
 **Inherits:** :ref:`Shape3D<class_Shape3D>` **<** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
 
-Capsule shape resource for 3D collisions.
+A 3D capsule shape used for physics collision.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-3D capsule shape to be added as a *direct* child of a :ref:`PhysicsBody3D<class_PhysicsBody3D>` or :ref:`Area3D<class_Area3D>` using a :ref:`CollisionShape3D<class_CollisionShape3D>` node. In 3D, a capsule is a cylinder shape with hemispheres at both ends.
+A 3D capsule shape, intended for use in physics. Usually used to provide a shape for a :ref:`CollisionShape3D<class_CollisionShape3D>`.
 
-\ **Performance:** Being a primitive collision shape, **CapsuleShape3D** is fast to check collisions against (though not as fast as :ref:`SphereShape3D<class_SphereShape3D>`). **CapsuleShape3D** is cheaper to check collisions against compared to :ref:`CylinderShape3D<class_CylinderShape3D>`.
+\ **Performance:** **CapsuleShape3D** is fast to check collisions against. It is faster than :ref:`CylinderShape3D<class_CylinderShape3D>`, but slower than :ref:`SphereShape3D<class_SphereShape3D>` and :ref:`BoxShape3D<class_BoxShape3D>`.
 
 .. rst-class:: classref-introduction-group
 

classes/class_centercontainer.rst

@@ -12,21 +12,21 @@ CenterContainer
 
 **Inherits:** :ref:`Container<class_Container>` **<** :ref:`Control<class_Control>` **<** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-Keeps children controls centered.
+A container that keeps child controls in its center.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-CenterContainer keeps children controls centered. This container keeps all children to their minimum size, in the center.
+**CenterContainer** is a container that keeps all of its child controls in its center at their minimum size.
 
 .. rst-class:: classref-introduction-group
 
 Tutorials
 ---------
 
-- :doc:`GUI containers <../tutorials/ui/gui_containers>`
+- :doc:`Using Containers <../tutorials/ui/gui_containers>`
 
 .. rst-class:: classref-reftable-group
 

classes/class_characterbody2d.rst

@@ -12,18 +12,16 @@ CharacterBody2D
 
 **Inherits:** :ref:`PhysicsBody2D<class_PhysicsBody2D>` **<** :ref:`CollisionObject2D<class_CollisionObject2D>` **<** :ref:`Node2D<class_Node2D>` **<** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-Specialized 2D physics body node for characters moved by script.
+A 2D physics body specialized for characters moved by script.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Character bodies are special types of bodies that are meant to be user-controlled. They are not affected by physics at all; to other types of bodies, such as a rigid body, these are the same as a :ref:`AnimatableBody2D<class_AnimatableBody2D>`. However, they have two main uses:
+**CharacterBody2D** is a specialized class for physics bodies that are meant to be user-controlled. They are not affected by physics at all, but they affect other physics bodies in their path. They are mainly used to provide high-level API to move objects with wall and slope detection (:ref:`move_and_slide<class_CharacterBody2D_method_move_and_slide>` method) in addition to the general collision detection provided by :ref:`PhysicsBody2D.move_and_collide<class_PhysicsBody2D_method_move_and_collide>`. This makes it useful for highly configurable physics bodies that must move in specific ways and collide with the world, as is often the case with user-controlled characters.
 
-\ **Kinematic characters:** Character bodies have an API for moving objects with walls and slopes detection (:ref:`move_and_slide<class_CharacterBody2D_method_move_and_slide>` method), in addition to collision detection (also done with :ref:`PhysicsBody2D.move_and_collide<class_PhysicsBody2D_method_move_and_collide>`). This makes them really useful to implement characters that move in specific ways and collide with the world, but don't require advanced physics.
-
-\ **Kinematic motion:** Character bodies can also be used for kinematic motion (same functionality as :ref:`AnimatableBody2D<class_AnimatableBody2D>`), which allows them to be moved by code and push other bodies on their path.
+For game objects that don't require complex movement or collision detection, such as moving platforms, :ref:`AnimatableBody2D<class_AnimatableBody2D>` is simpler to configure.
 
 .. rst-class:: classref-introduction-group
 

classes/class_characterbody3d.rst

@@ -12,20 +12,16 @@ CharacterBody3D
 
 **Inherits:** :ref:`PhysicsBody3D<class_PhysicsBody3D>` **<** :ref:`CollisionObject3D<class_CollisionObject3D>` **<** :ref:`Node3D<class_Node3D>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-Specialized 3D physics body node for characters moved by script.
+A 3D physics body specialized for characters moved by script.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Character bodies are special types of bodies that are meant to be user-controlled. They are not affected by physics at all; to other types of bodies, such as a rigid body, these are the same as a :ref:`AnimatableBody3D<class_AnimatableBody3D>`. However, they have two main uses:
+**CharacterBody3D** is a specialized class for physics bodies that are meant to be user-controlled. They are not affected by physics at all, but they affect other physics bodies in their path. They are mainly used to provide high-level API to move objects with wall and slope detection (:ref:`move_and_slide<class_CharacterBody3D_method_move_and_slide>` method) in addition to the general collision detection provided by :ref:`PhysicsBody3D.move_and_collide<class_PhysicsBody3D_method_move_and_collide>`. This makes it useful for highly configurable physics bodies that must move in specific ways and collide with the world, as is often the case with user-controlled characters.
 
-\ *Kinematic characters:* Character bodies have an API for moving objects with walls and slopes detection (:ref:`move_and_slide<class_CharacterBody3D_method_move_and_slide>` method), in addition to collision detection (also done with :ref:`PhysicsBody3D.move_and_collide<class_PhysicsBody3D_method_move_and_collide>`). This makes them really useful to implement characters that move in specific ways and collide with the world, but don't require advanced physics.
-
-\ *Kinematic motion:* Character bodies can also be used for kinematic motion (same functionality as :ref:`AnimatableBody3D<class_AnimatableBody3D>`), which allows them to be moved by code and push other bodies on their path.
-
-\ **Warning:** With a non-uniform scale this node will probably not function as expected. Please make sure to keep its scale uniform (i.e. the same on all axes), and change the size(s) of its collision shape(s) instead.
+For game objects that don't require complex movement or collision detection, such as moving platforms, :ref:`AnimatableBody3D<class_AnimatableBody3D>` is simpler to configure.
 
 .. rst-class:: classref-introduction-group
 

classes/class_checkbox.rst

@@ -12,18 +12,18 @@ CheckBox
 
 **Inherits:** :ref:`Button<class_Button>` **<** :ref:`BaseButton<class_BaseButton>` **<** :ref:`Control<class_Control>` **<** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-Binary choice user interface widget. See also :ref:`CheckButton<class_CheckButton>`.
+A button that represents a binary choice.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-A checkbox allows the user to make a binary choice (choosing only one of two possible options). It's similar to :ref:`CheckButton<class_CheckButton>` in functionality, but it has a different appearance. To follow established UX patterns, it's recommended to use CheckBox when toggling it has **no** immediate effect on something. For example, it could be used when toggling it will only do something once a confirmation button is pressed.
+**CheckBox** allows the user to choose one of only two possible options. It's similar to :ref:`CheckButton<class_CheckButton>` in functionality, but it has a different appearance. To follow established UX patterns, it's recommended to use **CheckBox** when toggling it has **no** immediate effect on something. For example, it could be used when toggling it will only do something once a confirmation button is pressed.
 
 See also :ref:`BaseButton<class_BaseButton>` which contains common properties and methods associated with this node.
 
-\ **Note:** CheckBox changes its appearance when it's configured as a radio button. See various ``radio_*`` theme properties. To configure CheckBox to act as a radio button, use :ref:`BaseButton.button_group<class_BaseButton_property_button_group>` and :ref:`ButtonGroup<class_ButtonGroup>`.
+When :ref:`BaseButton.button_group<class_BaseButton_property_button_group>` specifies a :ref:`ButtonGroup<class_ButtonGroup>`, **CheckBox** changes its appearance to that of a radio button and uses the various ``radio_*`` theme properties.
 
 .. rst-class:: classref-reftable-group
 

classes/class_checkbutton.rst

@@ -12,14 +12,14 @@ CheckButton
 
 **Inherits:** :ref:`Button<class_Button>` **<** :ref:`BaseButton<class_BaseButton>` **<** :ref:`Control<class_Control>` **<** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-Checkable button. See also :ref:`CheckBox<class_CheckBox>`.
+A button that represents a binary choice.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-CheckButton is a toggle button displayed as a check field. It's similar to :ref:`CheckBox<class_CheckBox>` in functionality, but it has a different appearance. To follow established UX patterns, it's recommended to use CheckButton when toggling it has an **immediate** effect on something. For example, it could be used if toggling it enables/disables a setting without requiring the user to press a confirmation button.
+**CheckButton** is a toggle button displayed as a check field. It's similar to :ref:`CheckBox<class_CheckBox>` in functionality, but it has a different appearance. To follow established UX patterns, it's recommended to use **CheckButton** when toggling it has an **immediate** effect on something. For example, it can be used when pressing it shows or hides advanced settings, without asking the user to confirm this action.
 
 See also :ref:`BaseButton<class_BaseButton>` which contains common properties and methods associated with this node.
 

classes/class_circleshape2d.rst

@@ -12,16 +12,16 @@ CircleShape2D
 
 **Inherits:** :ref:`Shape2D<class_Shape2D>` **<** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
 
-Circular shape resource for 2D physics.
+A 2D circle shape used for physics collision.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-2D circular shape to be added as a *direct* child of a :ref:`PhysicsBody2D<class_PhysicsBody2D>` or :ref:`Area2D<class_Area2D>` using a :ref:`CollisionShape2D<class_CollisionShape2D>` node. This shape is useful for modeling balls or small characters and its collision detection with everything else is very fast.
+A 2D circle shape, intended for use in physics. Usually used to provide a shape for a :ref:`CollisionShape2D<class_CollisionShape2D>`.
 
-\ **Performance:** Being a primitive collision shape, **CircleShape2D** is the fastest collision shape to check collisions against, as it only requires a distance check with the shape's origin.
+\ **Performance:** **CircleShape2D** is fast to check collisions against. It is faster than :ref:`RectangleShape2D<class_RectangleShape2D>` and :ref:`CapsuleShape2D<class_CapsuleShape2D>`.
 
 .. rst-class:: classref-reftable-group
 

classes/class_classdb.rst

@@ -12,7 +12,7 @@ ClassDB
 
 **Inherits:** :ref:`Object<class_Object>`
 
-Class information repository.
+A class information repository.
 
 .. rst-class:: classref-introduction-group
 

classes/class_codeedit.rst

@@ -12,16 +12,16 @@ CodeEdit
 
 **Inherits:** :ref:`TextEdit<class_TextEdit>` **<** :ref:`Control<class_Control>` **<** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-Multiline text control intended for editing code.
+A multiline text editor designed for editing code.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-CodeEdit is a specialized :ref:`TextEdit<class_TextEdit>` designed for editing plain text code files. It contains a bunch of features commonly found in code editors such as line numbers, line folding, code completion, indent management and string / comment management.
+CodeEdit is a specialized :ref:`TextEdit<class_TextEdit>` designed for editing plain text code files. It has many features commonly found in code editors such as line numbers, line folding, code completion, indent management, and string/comment management.
 
-\ **Note:** By default **CodeEdit** always use left-to-right text direction to correctly display source code.
+\ **Note:** Regardless of locale, **CodeEdit** will by default always use left-to-right text direction to correctly display source code.
 
 .. rst-class:: classref-reftable-group
 

classes/class_codehighlighter.rst

@@ -12,14 +12,14 @@ CodeHighlighter
 
 **Inherits:** :ref:`SyntaxHighlighter<class_SyntaxHighlighter>` **<** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
 
-A syntax highlighter for code.
+A syntax highlighter intended for code.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-A syntax highlighter for code.
+By adjusting various properties of this resource, you can change the colors of strings, comments, numbers, and other text patterns inside a :ref:`TextEdit<class_TextEdit>` control.
 
 .. rst-class:: classref-reftable-group
 

classes/class_collisionobject2d.rst

@@ -14,14 +14,14 @@ CollisionObject2D
 
 **Inherited By:** :ref:`Area2D<class_Area2D>`, :ref:`PhysicsBody2D<class_PhysicsBody2D>`
 
-Base node for 2D collision objects.
+Abstract base class for 2D physics objects.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-CollisionObject2D is the base class for 2D physics objects. It can hold any number of 2D collision :ref:`Shape2D<class_Shape2D>`\ s. Each shape must be assigned to a *shape owner*. The CollisionObject2D can have any number of shape owners. Shape owners are not nodes and do not appear in the editor, but are accessible through code using the ``shape_owner_*`` methods.
+Abstract base class for 2D physics objects. **CollisionObject2D** can hold any number of :ref:`Shape2D<class_Shape2D>`\ s for collision. Each shape must be assigned to a *shape owner*. Shape owners are not nodes and do not appear in the editor, but are accessible through code using the ``shape_owner_*`` methods.
 
 \ **Note:** Only collisions between objects within the same canvas (:ref:`Viewport<class_Viewport>` canvas or :ref:`CanvasLayer<class_CanvasLayer>`) are supported. The behavior of collisions between objects in different canvases is undefined.
 

classes/class_collisionobject3d.rst

@@ -14,16 +14,16 @@ CollisionObject3D
 
 **Inherited By:** :ref:`Area3D<class_Area3D>`, :ref:`PhysicsBody3D<class_PhysicsBody3D>`
 
-Base node for collision objects.
+Abstract base class for 3D physics objects.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-CollisionObject3D is the base class for physics objects. It can hold any number of collision :ref:`Shape3D<class_Shape3D>`\ s. Each shape must be assigned to a *shape owner*. The CollisionObject3D can have any number of shape owners. Shape owners are not nodes and do not appear in the editor, but are accessible through code using the ``shape_owner_*`` methods.
+Abstract base class for 3D physics objects. **CollisionObject3D** can hold any number of :ref:`Shape3D<class_Shape3D>`\ s for collision. Each shape must be assigned to a *shape owner*. Shape owners are not nodes and do not appear in the editor, but are accessible through code using the ``shape_owner_*`` methods.
 
-\ **Warning:** With a non-uniform scale this node will probably not function as expected. Please make sure to keep its scale uniform (i.e. the same on all axes), and change the size(s) of its collision shape(s) instead.
+\ **Warning:** With a non-uniform scale, this node will likely not behave as expected. It is advised to keep its scale the same on all axes and adjust its collision shape(s) instead.
 
 .. rst-class:: classref-reftable-group
 

classes/class_collisionpolygon2d.rst

@@ -12,18 +12,16 @@ CollisionPolygon2D
 
 **Inherits:** :ref:`Node2D<class_Node2D>` **<** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-Node that represents a 2D collision polygon.
+A node that provides a polygon shape to a :ref:`CollisionObject2D<class_CollisionObject2D>` parent.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Provides a 2D collision polygon to a :ref:`CollisionObject2D<class_CollisionObject2D>` parent. Polygons can be drawn in the editor or specified by a list of vertices.
+A node that provides a thickened polygon shape (a prism) to a :ref:`CollisionObject2D<class_CollisionObject2D>` parent and allows to edit it. The polygon can be concave or convex. This can give a detection shape to an :ref:`Area2D<class_Area2D>` or turn :ref:`PhysicsBody2D<class_PhysicsBody2D>` into a solid object.
 
-Depending on the build mode, this node effectively provides several convex shapes (by convex decomposition of the polygon) or a single concave shape made of the polygon's segments.
-
-In the editor, a **CollisionPolygon2D** can be generated from a :ref:`Sprite2D<class_Sprite2D>`'s outline by selecting a :ref:`Sprite2D<class_Sprite2D>` node, going to the **Sprite2D** menu at the top of the 2D editor viewport then choosing **Create CollisionPolygon2D Sibling**.
+\ **Warning:** A non-uniformly scaled :ref:`CollisionShape3D<class_CollisionShape3D>` will likely not behave as expected. Make sure to keep its scale the same on all axes and adjust its shape resource instead.
 
 .. rst-class:: classref-reftable-group
 

classes/class_collisionpolygon3d.rst

@@ -12,18 +12,16 @@ CollisionPolygon3D
 
 **Inherits:** :ref:`Node3D<class_Node3D>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-Node that represents a 3D collision polygon, given by the thickening of a 2D polygon in the local XY plane along the local Z axis.
+A node that provides a thickened polygon shape (a prism) to a :ref:`CollisionObject3D<class_CollisionObject3D>` parent.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Provides a 3D collision polygon to a :ref:`CollisionObject3D<class_CollisionObject3D>` parent, by thickening a 2D (convex or concave) polygon in the local XY plane along the local Z axis. The 2D polygon in the local XY plane can be drawn in the editor or specified by a list of vertices. That 2D polygon is thickened evenly in the local Z and -Z directions.
+A node that provides a thickened polygon shape (a prism) to a :ref:`CollisionObject3D<class_CollisionObject3D>` parent and allows to edit it. The polygon can be concave or convex. This can give a detection shape to an :ref:`Area3D<class_Area3D>` or turn :ref:`PhysicsBody3D<class_PhysicsBody3D>` into a solid object.
 
-This node has the same effect as several :ref:`ConvexPolygonShape3D<class_ConvexPolygonShape3D>` nodes, created by thickening the 2D convex polygons in the convex decomposition of the given 2D polygon (but without the overhead of multiple nodes).
-
-\ **Warning:** A non-uniformly scaled CollisionPolygon3D node will probably not function as expected. Please make sure to keep its scale uniform (i.e. the same on all axes), and change its :ref:`polygon<class_CollisionPolygon3D_property_polygon>`'s vertices instead.
+\ **Warning:** A non-uniformly scaled :ref:`CollisionShape3D<class_CollisionShape3D>` will likely not behave as expected. Make sure to keep its scale the same on all axes and adjust its shape resource instead.
 
 .. rst-class:: classref-reftable-group
 

classes/class_collisionshape2d.rst

@@ -12,16 +12,14 @@ CollisionShape2D
 
 **Inherits:** :ref:`Node2D<class_Node2D>` **<** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-Node that represents collision shape data in 2D space.
+A node that provides a :ref:`Shape2D<class_Shape2D>` to a :ref:`CollisionObject2D<class_CollisionObject2D>` parent.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Editor facility for creating and editing collision shapes in 2D space. Set the :ref:`shape<class_CollisionShape2D_property_shape>` property to configure the shape.
-
-You can use this node to represent all sorts of collision shapes, for example, add this to an :ref:`Area2D<class_Area2D>` to give it a detection shape, or add it to a :ref:`PhysicsBody2D<class_PhysicsBody2D>` to create a solid object.
+A node that provides a :ref:`Shape2D<class_Shape2D>` to a :ref:`CollisionObject2D<class_CollisionObject2D>` parent and allows to edit it. This can give a detection shape to an :ref:`Area2D<class_Area2D>` or turn a :ref:`PhysicsBody2D<class_PhysicsBody2D>` into a solid object.
 
 .. rst-class:: classref-introduction-group
 

classes/class_collisionshape3d.rst

@@ -12,18 +12,16 @@ CollisionShape3D
 
 **Inherits:** :ref:`Node3D<class_Node3D>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-Node that represents collision shape data in 3D space.
+A node that provides a :ref:`Shape3D<class_Shape3D>` to a :ref:`CollisionObject3D<class_CollisionObject3D>` parent.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Editor facility for creating and editing collision shapes in 3D space. Set the :ref:`shape<class_CollisionShape3D_property_shape>` property to configure the shape.
+A node that provides a :ref:`Shape3D<class_Shape3D>` to a :ref:`CollisionObject3D<class_CollisionObject3D>` parent and allows to edit it. This can give a detection shape to an :ref:`Area3D<class_Area3D>` or turn a :ref:`PhysicsBody3D<class_PhysicsBody3D>` into a solid object.
 
-You can use this node to represent all sorts of collision shapes, for example, add this to an :ref:`Area3D<class_Area3D>` to give it a detection shape, or add it to a :ref:`PhysicsBody3D<class_PhysicsBody3D>` to create a solid object.
-
-\ **Warning:** A non-uniformly scaled CollisionShape3D node will probably not function as expected. Please make sure to keep its scale uniform (i.e. the same on all axes), and change the size of its :ref:`shape<class_CollisionShape3D_property_shape>` resource instead.
+\ **Warning:** A non-uniformly scaled **CollisionShape3D** will likely not behave as expected. Make sure to keep its scale the same on all axes and adjust its :ref:`shape<class_CollisionShape3D_property_shape>` resource instead.
 
 .. rst-class:: classref-introduction-group
 

classes/class_color.rst

@@ -10,18 +10,18 @@
 Color
 =====
 
-Color built-in type, in RGBA format.
+A color represented in RGBA format.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-A color represented in RGBA format by red (:ref:`r<class_Color_property_r>`), green (:ref:`g<class_Color_property_g>`), blue (:ref:`b<class_Color_property_b>`), and alpha (:ref:`a<class_Color_property_a>`) components. Each component is a 16-bit floating-point value, usually ranging from 0 to 1. Some properties (such as :ref:`CanvasItem.modulate<class_CanvasItem_property_modulate>`) may support values greater than 1, for overbright or High Dynamic Range colors. If you want to supply values in a range of 0 to 255, you should use :ref:`@GDScript.Color8<class_@GDScript_method_Color8>`.
+A color represented in RGBA format by a red (:ref:`r<class_Color_property_r>`), green (:ref:`g<class_Color_property_g>`), blue (:ref:`b<class_Color_property_b>`), and alpha (:ref:`a<class_Color_property_a>`) component. Each component is a 16-bit floating-point value, usually ranging from ``0.0`` to ``1.0``. Some properties (such as :ref:`CanvasItem.modulate<class_CanvasItem_property_modulate>`) may support values greater than ``1.0``, for overbright or HDR (High Dynamic Range) colors.
 
-Colors can also be created by name from a set of standardized colors, through the :ref:`String<class_String>` constructor, :ref:`from_string<class_Color_method_from_string>`, or by directly fetching the color constants documented here. The standardized color set is based on the `X11 color names <https://en.wikipedia.org/wiki/X11_color_names>`__, with the addition of :ref:`TRANSPARENT<class_Color_constant_TRANSPARENT>`.
+Colors can be created in various ways: By the various **Color** constructors, by static methods such as :ref:`from_hsv<class_Color_method_from_hsv>`, and by using a name from the set of standardized colors based on `X11 color names <https://en.wikipedia.org/wiki/X11_color_names>`__ with the addition of :ref:`TRANSPARENT<class_Color_constant_TRANSPARENT>`. GDScript also provides :ref:`@GDScript.Color8<class_@GDScript_method_Color8>`, which uses integers from ``0`` to ``255`` and doesn't support overbright colors.
 
-\ **Note:** In a boolean context, a Color will evaluate to ``false`` if it's equal to ``Color(0, 0, 0, 1)`` (opaque black). Otherwise, a Color will always evaluate to ``true``.
+\ **Note:** In a boolean context, a Color will evaluate to ``false`` if it is equal to ``Color(0, 0, 0, 1)`` (opaque black). Otherwise, a Color will always evaluate to ``true``.
 
 \ `Color constants cheatsheet <https://raw.githubusercontent.com/godotengine/godot-docs/master/img/color_constants.png>`__
 
@@ -1791,9 +1791,9 @@ 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 RGBA 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).
 
-In GDScript and C#, the :ref:`int<class_int>` is best visualized with hexadecimal notation (``"0x"`` prefix).
+In GDScript and C#, the :ref:`int<class_int>` is best visualized with hexadecimal notation (``"0x"`` prefix, making it ``"0xRRGGBBAA"``).
 
 
 .. tabs::
@@ -1822,9 +1822,9 @@ 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 RGBA 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).
 
-In GDScript and C#, the :ref:`int<class_int>` is best visualized with hexadecimal notation (``"0x"`` prefix).
+In GDScript and C#, the :ref:`int<class_int>` is best visualized with hexadecimal notation (``"0x"`` prefix, making it ``"0xRRRRGGGGBBBBAAAA"``).
 
 .. rst-class:: classref-item-separator
 

classes/class_colorpicker.rst

@@ -12,16 +12,16 @@ ColorPicker
 
 **Inherits:** :ref:`VBoxContainer<class_VBoxContainer>` **<** :ref:`BoxContainer<class_BoxContainer>` **<** :ref:`Container<class_Container>` **<** :ref:`Control<class_Control>` **<** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-Color picker control.
+A widget that provides an interface for selecting or modifying a color.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Displays a color picker widget. Useful for selecting a color from an RGB/RGBA colorspace.
+A widget that provides an interface for selecting or modifying a color. It can optionally provide functionalities like a color sampler (eyedropper), color modes, and presets.
 
-\ **Note:** This control is the color picker widget itself. You can use a :ref:`ColorPickerButton<class_ColorPickerButton>` instead if you need a button that brings up a **ColorPicker** in a pop-up.
+\ **Note:** This control is the color picker widget itself. You can use a :ref:`ColorPickerButton<class_ColorPickerButton>` instead if you need a button that brings up a **ColorPicker** in a popup.
 
 .. rst-class:: classref-introduction-group
 

classes/class_colorpickerbutton.rst

@@ -12,14 +12,14 @@ ColorPickerButton
 
 **Inherits:** :ref:`Button<class_Button>` **<** :ref:`BaseButton<class_BaseButton>` **<** :ref:`Control<class_Control>` **<** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-Button that pops out a :ref:`ColorPicker<class_ColorPicker>`.
+A button that brings up a :ref:`ColorPicker<class_ColorPicker>` when pressed.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Encapsulates a :ref:`ColorPicker<class_ColorPicker>` making it accessible by pressing a button. Pressing the button will toggle the :ref:`ColorPicker<class_ColorPicker>` visibility.
+Encapsulates a :ref:`ColorPicker<class_ColorPicker>`, making it accessible by pressing a button. Pressing the button will toggle the :ref:`ColorPicker<class_ColorPicker>`'s visibility.
 
 See also :ref:`BaseButton<class_BaseButton>` which contains common properties and methods associated with this node.
 

classes/class_colorrect.rst

@@ -12,14 +12,14 @@ ColorRect
 
 **Inherits:** :ref:`Control<class_Control>` **<** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-Colored rectangle.
+A control that displays a solid color rectangle.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Displays a rectangle filled with a solid :ref:`color<class_ColorRect_property_color>`. If you need to display the border alone, consider using :ref:`ReferenceRect<class_ReferenceRect>` instead.
+Displays a rectangle filled with a solid :ref:`color<class_ColorRect_property_color>`. If you need to display the border alone, consider using a :ref:`Panel<class_Panel>` instead.
 
 .. rst-class:: classref-introduction-group
 
@@ -60,20 +60,7 @@ Property Descriptions
 - void **set_color** **(** :ref:`Color<class_Color>` value **)**
 - :ref:`Color<class_Color>` **get_color** **(** **)**
 
-The fill color.
-
-
-.. tabs::
-
- .. code-tab:: gdscript
-
-    $ColorRect.color = Color(1, 0, 0, 1) # Set ColorRect's color to red.
-
- .. code-tab:: csharp
-
-    GetNode<ColorRect>("ColorRect").Color = new Color(1, 0, 0, 1); // Set ColorRect's color to red.
-
-
+The fill color of the rectangle.
 
 .. |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_concavepolygonshape2d.rst

@@ -12,26 +12,22 @@ ConcavePolygonShape2D
 
 **Inherits:** :ref:`Shape2D<class_Shape2D>` **<** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
 
-Concave polygon shape resource for 2D physics.
+A 2D polyline shape used for physics collision.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-2D concave polygon shape to be added as a *direct* child of a :ref:`PhysicsBody2D<class_PhysicsBody2D>` or :ref:`Area2D<class_Area2D>` using a :ref:`CollisionShape2D<class_CollisionShape2D>` node.
+A 2D polyline shape, intended for use in physics. Used internally in :ref:`CollisionPolygon2D<class_CollisionPolygon2D>` when it's in ``BUILD_SEGMENTS`` mode.
 
-The shape consists of a collection of line segments, and as such it does not include any "inside" that the segments might be enclosing. If the segments do enclose anything, then the shape is *hollow*, as opposed to a :ref:`ConvexPolygonShape2D<class_ConvexPolygonShape2D>` which is solid. See also :ref:`CollisionPolygon2D<class_CollisionPolygon2D>`.
+Being just a collection of interconnected line segments, **ConcavePolygonShape2D** is the most freely configurable single 2D shape. It can be used to form polygons of any nature, or even shapes that don't enclose an area. However, :ref:`ConvexPolygonShape2D<class_ConvexPolygonShape2D>` is *hollow* even if the interconnected line segments do enclose an area, which often makes it unsuitable for physics or detection.
 
-Being made out of line segments, this shape is the most freely configurable single 2D shape. It can be used to form (hollow) polygons of any nature, convex or concave.
+\ **Note:** When used for collision, **ConcavePolygonShape2D** is intended to work with static :ref:`CollisionShape2D<class_CollisionShape2D>` nodes like :ref:`StaticBody2D<class_StaticBody2D>` and will likely not behave well for :ref:`CharacterBody2D<class_CharacterBody2D>`\ s or :ref:`RigidBody2D<class_RigidBody2D>`\ s in a mode other than Static.
 
-\ **Note:** When used for collision, **ConcavePolygonShape2D** is intended to work with static :ref:`PhysicsBody2D<class_PhysicsBody2D>` nodes like :ref:`StaticBody2D<class_StaticBody2D>` and is not recommended to use with :ref:`RigidBody2D<class_RigidBody2D>` nodes in a mode other than Static. A :ref:`CollisionPolygon2D<class_CollisionPolygon2D>` in convex decomposition mode (solids) or several convex objects are advised for that instead. Otherwise, a concave polygon 2D shape is better suited for static bodies.
+\ **Warning:** Physics bodies that are small have a chance to clip through this shape when moving fast. This happens because on one frame, the physics body may be on the "outside" of the shape, and on the next frame it may be "inside" it. **ConcavePolygonShape2D** is hollow, so it won't detect a collision.
 
-\ **Warning:** The nature of this shape makes it extra prone to being tunneled through by (small) fast physics bodies. For example, consider a (small) rigid body *Ball* traveling toward a static body *Box* at high speed. If the box uses a **ConcavePolygonShape2D** consisting of four segments, then the ball might end up inside the box or tunnel all the way through the box, if it goes fast enough. This is (partly) because the ball can only collide against the individual segments of the hollow box. In interactions with rigid bodies tunneling can be avoided by enabling continuous collision detection on the rigid body.
-
-\ **Warning:** Using this shape for an :ref:`Area2D<class_Area2D>` (via a :ref:`CollisionShape2D<class_CollisionShape2D>` node) may give unexpected results: the area will only detect collisions with the segments in the **ConcavePolygonShape2D** (and not with any "inside" of the shape, for example).
-
-\ **Performance:** Due to its complexity, **ConcavePolygonShape2D** is the slowest collision shape to check collisions against. Its use should generally be limited to level geometry. For convex geometry, using :ref:`ConvexPolygonShape2D<class_ConvexPolygonShape2D>` will perform better. For dynamic physics bodies that need concave collision, several :ref:`ConvexPolygonShape2D<class_ConvexPolygonShape2D>`\ s can be used to represent its collision by using convex decomposition; see :ref:`ConvexPolygonShape2D<class_ConvexPolygonShape2D>`'s documentation for instructions. However, consider using primitive collision shapes such as :ref:`CircleShape2D<class_CircleShape2D>` or :ref:`RectangleShape2D<class_RectangleShape2D>` first.
+\ **Performance:** Due to its complexity, **ConcavePolygonShape2D** is the slowest 2D collision shape to check collisions against. Its use should generally be limited to level geometry. If the polyline is closed, :ref:`CollisionPolygon2D<class_CollisionPolygon2D>`'s ``BUILD_SOLIDS`` mode can be used, which decomposes the polygon into convex ones; see :ref:`ConvexPolygonShape2D<class_ConvexPolygonShape2D>`'s documentation for instructions.
 
 .. rst-class:: classref-reftable-group
 

classes/class_concavepolygonshape3d.rst

@@ -12,26 +12,22 @@ ConcavePolygonShape3D
 
 **Inherits:** :ref:`Shape3D<class_Shape3D>` **<** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
 
-Concave polygon shape resource (also called "trimesh") for 3D physics.
+A 3D trimesh shape used for physics collision.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-3D concave polygon shape resource (also called "trimesh") to be added as a *direct* child of a :ref:`PhysicsBody3D<class_PhysicsBody3D>` or :ref:`Area3D<class_Area3D>` using a :ref:`CollisionShape3D<class_CollisionShape3D>` node.
+A 3D trimesh shape, intended for use in physics. Usually used to provide a shape for a :ref:`CollisionShape3D<class_CollisionShape3D>`.
 
-The shape consists of a collection of triangle faces, and as such it does not include any "inside" that the faces might be enclosing. If the faces enclose anything, then the shape is *hollow*, as opposed to a :ref:`ConvexPolygonShape3D<class_ConvexPolygonShape3D>` which is solid. See also :ref:`CollisionPolygon3D<class_CollisionPolygon3D>`.
+Being just a collection of interconnected triangles, **ConcavePolygonShape3D** is the most freely configurable single 3D shape. It can be used to form polyhedra of any nature, or even shapes that don't enclose a volume. However, :ref:`ConvexPolygonShape3D<class_ConvexPolygonShape3D>` is *hollow* even if the interconnected triangles do enclose a volume, which often makes it unsuitable for physics or detection.
 
-Being made out of triangle faces, this shape is the most freely configurable single 3D shape. Despite its name, it can be used to form (hollow) polyhedra of any nature, convex or concave.
+\ **Note:** When used for collision, **ConcavePolygonShape3D** is intended to work with static :ref:`CollisionShape3D<class_CollisionShape3D>` nodes like :ref:`StaticBody3D<class_StaticBody3D>` and will likely not behave well for :ref:`CharacterBody3D<class_CharacterBody3D>`\ s or :ref:`RigidBody3D<class_RigidBody3D>`\ s in a mode other than Static.
 
-\ **Note:** When used for collision, **ConcavePolygonShape3D** is intended to work with static :ref:`PhysicsBody3D<class_PhysicsBody3D>` nodes like :ref:`StaticBody3D<class_StaticBody3D>` and will not work with :ref:`CharacterBody3D<class_CharacterBody3D>` or :ref:`RigidBody3D<class_RigidBody3D>` in a mode other than Static.
+\ **Warning:** Physics bodies that are small have a chance to clip through this shape when moving fast. This happens because on one frame, the physics body may be on the "outside" of the shape, and on the next frame it may be "inside" it. **ConcavePolygonShape3D** is hollow, so it won't detect a collision.
 
-\ **Warning:** The nature of this shape makes it extra prone to being tunneled through by (small) fast physics bodies. For example, consider a (small) rigid body *Ball* traveling toward a static body *Box* at high speed. If the box uses a **ConcavePolygonShape3D** consisting of twelve triangle faces (two triangle faces for each of the six sides of the box), then the ball might end up inside the box or tunnel all the way through the box, if it goes fast enough. This is (partly) because the ball can only collide against the individual faces of the hollow box. In interactions with rigid bodies tunneling can be avoided by enabling continuous collision detection on the rigid body.
-
-\ **Warning:** Using this shape for an :ref:`Area3D<class_Area3D>` (via a :ref:`CollisionShape3D<class_CollisionShape3D>` node, created e.g. by using the *Create Trimesh Collision Sibling* option in the *Mesh* menu that appears when selecting a :ref:`MeshInstance3D<class_MeshInstance3D>` node) may give unexpected results: the area will only detect collisions with the triangle faces in the **ConcavePolygonShape3D** (and not with any "inside" of the shape, for example); moreover it will only detect all such collisions if :ref:`backface_collision<class_ConcavePolygonShape3D_property_backface_collision>` is ``true``.
-
-\ **Performance:** Due to its complexity, **ConcavePolygonShape3D** is the slowest collision shape to check collisions against. Its use should generally be limited to level geometry. For convex geometry, using :ref:`ConvexPolygonShape3D<class_ConvexPolygonShape3D>` will perform better. For dynamic physics bodies that need concave collision, several :ref:`ConvexPolygonShape3D<class_ConvexPolygonShape3D>`\ s can be used to represent its collision by using convex decomposition; see :ref:`ConvexPolygonShape3D<class_ConvexPolygonShape3D>`'s documentation for instructions. However, consider using primitive collision shapes such as :ref:`SphereShape3D<class_SphereShape3D>` or :ref:`BoxShape3D<class_BoxShape3D>` first.
+\ **Performance:** Due to its complexity, **ConcavePolygonShape3D** is the slowest 3D collision shape to check collisions against. Its use should generally be limited to level geometry. For convex geometry, :ref:`ConvexPolygonShape3D<class_ConvexPolygonShape3D>` should be used. For dynamic physics bodies that need concave collision, several :ref:`ConvexPolygonShape3D<class_ConvexPolygonShape3D>`\ s can be used to represent its collision by using convex decomposition; see :ref:`ConvexPolygonShape3D<class_ConvexPolygonShape3D>`'s documentation for instructions.
 
 .. rst-class:: classref-introduction-group
 

classes/class_conetwistjoint3d.rst

@@ -12,18 +12,14 @@ ConeTwistJoint3D
 
 **Inherits:** :ref:`Joint3D<class_Joint3D>` **<** :ref:`Node3D<class_Node3D>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-A twist joint between two 3D PhysicsBodies.
+A physics joint that connects two 3D physics bodies in a way that simulates a ball-and-socket joint.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-The joint can rotate the bodies across an axis defined by the local x-axes of the :ref:`Joint3D<class_Joint3D>`.
-
-The twist axis is initiated as the X axis of the :ref:`Joint3D<class_Joint3D>`.
-
-Once the Bodies swing, the twist axis is calculated as the middle of the x-axes of the Joint3D in the local space of the two Bodies. See also :ref:`Generic6DOFJoint3D<class_Generic6DOFJoint3D>`.
+A physics joint that connects two 3D physics bodies in a way that simulates a ball-and-socket joint. The twist axis is initiated as the X axis of the **ConeTwistJoint3D**. Once the physics bodies swing, the twist axis is calculated as the middle of the X axes of the joint in the local space of the two physics bodies. Useful for limbs like shoulders and hips, lamps hanging off a ceiling, etc.
 
 .. rst-class:: classref-reftable-group
 

classes/class_confirmationdialog.rst

@@ -14,14 +14,14 @@ ConfirmationDialog
 
 **Inherited By:** :ref:`EditorCommandPalette<class_EditorCommandPalette>`, :ref:`EditorFileDialog<class_EditorFileDialog>`, :ref:`FileDialog<class_FileDialog>`, :ref:`ScriptCreateDialog<class_ScriptCreateDialog>`
 
-Dialog for confirmation of actions.
+A dialog used for confirmation of actions.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Dialog for confirmation of actions. This dialog inherits from :ref:`AcceptDialog<class_AcceptDialog>`, but has by default an OK and Cancel button (in host OS order).
+A dialog used for confirmation of actions. This window is similar to :ref:`AcceptDialog<class_AcceptDialog>`, but pressing its Cancel button can have a different outcome from pressing the OK button. The order of the two buttons varies depending on the host OS.
 
 To get cancel action, you can use:
 

classes/class_container.rst

@@ -14,23 +14,21 @@ Container
 
 **Inherited By:** :ref:`AspectRatioContainer<class_AspectRatioContainer>`, :ref:`BoxContainer<class_BoxContainer>`, :ref:`CenterContainer<class_CenterContainer>`, :ref:`EditorProperty<class_EditorProperty>`, :ref:`FlowContainer<class_FlowContainer>`, :ref:`GraphNode<class_GraphNode>`, :ref:`GridContainer<class_GridContainer>`, :ref:`MarginContainer<class_MarginContainer>`, :ref:`PanelContainer<class_PanelContainer>`, :ref:`ScrollContainer<class_ScrollContainer>`, :ref:`SplitContainer<class_SplitContainer>`, :ref:`SubViewportContainer<class_SubViewportContainer>`, :ref:`TabContainer<class_TabContainer>`
 
-Base node for containers.
+Base class for all GUI containers.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Base node for containers. A **Container** contains other controls and automatically arranges them in a certain way.
-
-A Control can inherit this to create custom container classes.
+Base class for all GUI containers. A **Container** automatically arranges its child controls in a certain way. This class can be inherited to make custom container types.
 
 .. rst-class:: classref-introduction-group
 
 Tutorials
 ---------
 
-- :doc:`GUI containers <../tutorials/ui/gui_containers>`
+- :doc:`Using Containers <../tutorials/ui/gui_containers>`
 
 .. rst-class:: classref-reftable-group
 

classes/class_control.rst

@@ -14,7 +14,7 @@ Control
 
 **Inherited By:** :ref:`BaseButton<class_BaseButton>`, :ref:`ColorRect<class_ColorRect>`, :ref:`Container<class_Container>`, :ref:`GraphEdit<class_GraphEdit>`, :ref:`ItemList<class_ItemList>`, :ref:`Label<class_Label>`, :ref:`LineEdit<class_LineEdit>`, :ref:`MenuBar<class_MenuBar>`, :ref:`NinePatchRect<class_NinePatchRect>`, :ref:`Panel<class_Panel>`, :ref:`Range<class_Range>`, :ref:`ReferenceRect<class_ReferenceRect>`, :ref:`RichTextLabel<class_RichTextLabel>`, :ref:`Separator<class_Separator>`, :ref:`TabBar<class_TabBar>`, :ref:`TextEdit<class_TextEdit>`, :ref:`TextureRect<class_TextureRect>`, :ref:`Tree<class_Tree>`, :ref:`VideoStreamPlayer<class_VideoStreamPlayer>`
 
-All user interface nodes inherit from Control. A control's anchors and offsets adapt its position and size relative to its parent.
+Base class for all GUI controls. Adapts its position and size based on its parent control.
 
 .. rst-class:: classref-introduction-group
 
@@ -1898,7 +1898,7 @@ This method should only be used to test the data. Process the data in :ref:`_dro
     {
         // Check position if it is relevant to you
         // Otherwise, just check data
-        return data.VariantType == Variant.Type.Dictionary && data.AsGodotDictionary().Contains("expected");
+        return data.VariantType == Variant.Type.Dictionary && data.AsGodotDictionary().ContainsKey("expected");
     }
 
 
@@ -1930,7 +1930,7 @@ Godot calls this method to pass you the ``data`` from a control's :ref:`_get_dra
 
     public override bool _CanDropData(Vector2 atPosition, Variant data)
     {
-        return data.VariantType == Variant.Type.Dictionary && dict.AsGodotDictionary().Contains("color");
+        return data.VariantType == Variant.Type.Dictionary && dict.AsGodotDictionary().ContainsKey("color");
     }
     
     public override void _DropData(Vector2 atPosition, Variant data)

classes/class_convexpolygonshape2d.rst

@@ -12,22 +12,20 @@ ConvexPolygonShape2D
 
 **Inherits:** :ref:`Shape2D<class_Shape2D>` **<** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
 
-Convex polygon shape resource for 2D physics.
+A 2D convex polygon shape used for physics collision.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-2D convex polygon shape to be added as a *direct* child of a :ref:`PhysicsBody2D<class_PhysicsBody2D>` or :ref:`Area2D<class_Area2D>` using a :ref:`CollisionShape2D<class_CollisionShape2D>` node.
+A 2D convex polygon shape, intended for use in physics. Used internally in :ref:`CollisionPolygon2D<class_CollisionPolygon2D>` when it's in ``BUILD_SOLIDS`` mode.
 
-The shape is a *solid* that includes all the points that it encloses, as opposed to :ref:`ConcavePolygonShape2D<class_ConcavePolygonShape2D>` which is hollow if it encloses anything. See also :ref:`CollisionPolygon2D<class_CollisionPolygon2D>`.
+\ **ConvexPolygonShape2D** is *solid*, which means it detects collisions from objects that are fully inside it, unlike :ref:`ConcavePolygonShape2D<class_ConcavePolygonShape2D>` which is hollow. This makes it more suitable for both detection and physics.
 
-The solid nature of the shape makes it well-suited for both detection and physics; in physics body interactions this allows depenetrating even those shapes which end up (e.g. due to high speed) fully inside the convex shape (similarly to primitive shapes, but unlike :ref:`ConcavePolygonShape2D<class_ConcavePolygonShape2D>`). The convexity limits the possible geometric shape of a single **ConvexPolygonShape2D**: it cannot be concave.
+\ **Convex decomposition:** A concave polygon can be split up into several convex polygons. This allows dynamic physics bodies to have complex concave collisions (at a performance cost) and can be achieved by using several :ref:`ConvexPolygonShape3D<class_ConvexPolygonShape3D>` nodes or by using the :ref:`CollisionPolygon2D<class_CollisionPolygon2D>` node in ``BUILD_SOLIDS`` mode. To generate a collision polygon from a sprite, select the :ref:`Sprite2D<class_Sprite2D>` node, go to the **Sprite2D** menu that appears above the viewport, and choose **Create Polygon2D Sibling**.
 
-\ **Convex decomposition:** Concave objects' collisions can be represented accurately using *several* convex shapes. This allows dynamic physics bodies to have complex concave collisions (at a performance cost). It can be achieved using several **ConvexPolygonShape2D** nodes or by using the :ref:`CollisionPolygon2D<class_CollisionPolygon2D>` node in Solids build mode. To generate a collision polygon from a sprite, select the :ref:`Sprite2D<class_Sprite2D>` node, go to the **Sprite2D** menu that appears above the viewport, and choose **Create Polygon2D Sibling**.
-
-\ **Performance:** **ConvexPolygonShape2D** is faster to check collisions against compared to :ref:`ConcavePolygonShape2D<class_ConcavePolygonShape2D>`, but it is slower than primitive collision shapes such as :ref:`CircleShape2D<class_CircleShape2D>` or :ref:`RectangleShape2D<class_RectangleShape2D>`. Its use should generally be limited to medium-sized objects that cannot have their collision accurately represented by primitive shapes.
+\ **Performance:** **ConvexPolygonShape2D** is faster to check collisions against compared to :ref:`ConcavePolygonShape2D<class_ConcavePolygonShape2D>`, but it is slower than primitive collision shapes such as :ref:`CircleShape2D<class_CircleShape2D>` and :ref:`RectangleShape2D<class_RectangleShape2D>`. Its use should generally be limited to medium-sized objects that cannot have their collision accurately represented by primitive shapes.
 
 .. rst-class:: classref-reftable-group
 

classes/class_convexpolygonshape3d.rst

@@ -12,22 +12,20 @@ ConvexPolygonShape3D
 
 **Inherits:** :ref:`Shape3D<class_Shape3D>` **<** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
 
-Convex polygon shape resource for 3D physics.
+A 3D convex polyhedron shape used for physics collision.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-3D convex polygon shape resource to be added as a *direct* child of a :ref:`PhysicsBody3D<class_PhysicsBody3D>` or :ref:`Area3D<class_Area3D>` using a :ref:`CollisionShape3D<class_CollisionShape3D>` node.
+A 3D convex polyhedron shape, intended for use in physics. Usually used to provide a shape for a :ref:`CollisionShape3D<class_CollisionShape3D>`.
 
-The shape is a *solid* that includes all the points that it encloses, as opposed to :ref:`ConcavePolygonShape3D<class_ConcavePolygonShape3D>` which is hollow if it encloses anything. See also :ref:`CollisionPolygon3D<class_CollisionPolygon3D>`.
+\ **ConvexPolygonShape3D** is *solid*, which means it detects collisions from objects that are fully inside it, unlike :ref:`ConcavePolygonShape3D<class_ConcavePolygonShape3D>` which is hollow. This makes it more suitable for both detection and physics.
 
-The solid nature of the shape makes it well-suited for both detection and physics; in physics body interactions this allows depenetrating even those shapes which end up (e.g. due to high speed) fully inside the convex shape (similarly to primitive shapes, but unlike :ref:`ConcavePolygonShape3D<class_ConcavePolygonShape3D>` and :ref:`HeightMapShape3D<class_HeightMapShape3D>`). The convexity restricts the possible geometric shape of a single **ConvexPolygonShape3D**: it cannot be concave.
+\ **Convex decomposition:** A concave polyhedron can be split up into several convex polyhedra. This allows dynamic physics bodies to have complex concave collisions (at a performance cost) and can be achieved by using several **ConvexPolygonShape3D** nodes. To generate a convex decomposition from a mesh, select the :ref:`MeshInstance3D<class_MeshInstance3D>` node, go to the **Mesh** menu that appears above the viewport, and choose **Create Multiple Convex Collision Siblings**. Alternatively, :ref:`MeshInstance3D.create_multiple_convex_collisions<class_MeshInstance3D_method_create_multiple_convex_collisions>` can be called in a script to perform this decomposition at run-time.
 
-\ **Convex decomposition:** Concave objects' collisions can be represented accurately using *several* convex shapes. This allows dynamic physics bodies to have complex concave collisions (at a performance cost). It can be achieved by using several **ConvexPolygonShape3D** nodes or by using the :ref:`CollisionPolygon3D<class_CollisionPolygon3D>` node. To generate a collision polygon from a mesh, select the :ref:`MeshInstance3D<class_MeshInstance3D>` node, go to the **Mesh** menu that appears above the viewport and choose **Create Multiple Convex Collision Siblings**. Alternatively, :ref:`MeshInstance3D.create_multiple_convex_collisions<class_MeshInstance3D_method_create_multiple_convex_collisions>` can be called in a script to perform this decomposition at run-time.
-
-\ **Performance:** **ConvexPolygonShape3D** is faster to check collisions against compared to :ref:`ConcavePolygonShape3D<class_ConcavePolygonShape3D>`, but it is slower than primitive collision shapes such as :ref:`SphereShape3D<class_SphereShape3D>` or :ref:`BoxShape3D<class_BoxShape3D>`. Its use should generally be limited to medium-sized objects that cannot have their collision accurately represented by primitive shapes.
+\ **Performance:** **ConvexPolygonShape3D** is faster to check collisions against compared to :ref:`ConcavePolygonShape3D<class_ConcavePolygonShape3D>`, but it is slower than primitive collision shapes such as :ref:`SphereShape3D<class_SphereShape3D>` and :ref:`BoxShape3D<class_BoxShape3D>`. Its use should generally be limited to medium-sized objects that cannot have their collision accurately represented by primitive shapes.
 
 .. rst-class:: classref-introduction-group
 

classes/class_crypto.rst

@@ -12,16 +12,16 @@ Crypto
 
 **Inherits:** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
 
-Access to advanced cryptographic functionalities.
+Provides access to advanced cryptographic functionalities.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-The Crypto class allows you to access some more advanced cryptographic functionalities in Godot.
+The Crypto class provides access to advanced cryptographic functionalities.
 
-For now, this includes generating cryptographically secure random bytes, RSA keys and self-signed X509 certificates generation, asymmetric key encryption/decryption, and signing/verification.
+Currently, this includes asymmetric key encryption/decryption, signing/verification, and generating cryptographically secure random bytes, RSA keys, HMAC digests, and self-signed :ref:`X509Certificate<class_X509Certificate>`\ s.
 
 
 .. tabs::

classes/class_cylindershape3d.rst

@@ -12,18 +12,18 @@ CylinderShape3D
 
 **Inherits:** :ref:`Shape3D<class_Shape3D>` **<** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
 
-Cylinder shape for 3D collisions.
+A 3D cylinder shape used for physics collision.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Cylinder shape for collisions. Like :ref:`CapsuleShape3D<class_CapsuleShape3D>`, but without hemispheres at the cylinder's ends.
+A 2D capsule shape, intended for use in physics. Usually used to provide a shape for a :ref:`CollisionShape3D<class_CollisionShape3D>`.
 
 \ **Note:** There are several known bugs with cylinder collision shapes. Using :ref:`CapsuleShape3D<class_CapsuleShape3D>` or :ref:`BoxShape3D<class_BoxShape3D>` instead is recommended.
 
-\ **Performance:** Being a primitive collision shape, **CylinderShape3D** is fast to check collisions against (though not as fast as :ref:`SphereShape3D<class_SphereShape3D>`). **CylinderShape3D** is also more demanding compared to :ref:`CapsuleShape3D<class_CapsuleShape3D>`.
+\ **Performance:** **CylinderShape3D** is fast to check collisions against, but it is slower than :ref:`CapsuleShape3D<class_CapsuleShape3D>`, :ref:`BoxShape3D<class_BoxShape3D>`, and **CylinderShape3D**.
 
 .. rst-class:: classref-introduction-group
 

classes/class_dampedspringjoint2d.rst

@@ -12,14 +12,14 @@ DampedSpringJoint2D
 
 **Inherits:** :ref:`Joint2D<class_Joint2D>` **<** :ref:`Node2D<class_Node2D>` **<** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-Damped spring constraint for 2D physics.
+A physics joint that connects two 2D physics bodies with a spring-like force.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Damped spring constraint for 2D physics. This resembles a spring joint that always wants to go back to a given length.
+A physics joint that connects two 2D physics bodies with a spring-like force. This resembles a spring that always wants to stretch to a given length.
 
 .. rst-class:: classref-reftable-group
 

classes/class_dictionary.rst

@@ -10,18 +10,16 @@
 Dictionary
 ==========
 
-Dictionary type.
+A built-in data structure that holds key-value pairs.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Dictionary type. Associative container, which contains values referenced by unique keys. Dictionaries are composed of pairs of keys (which must be unique) and values. Dictionaries will preserve the insertion order when adding new entries. In other programming languages, this data structure is sometimes referred to as a hash map or associative array.
+Dictionaries are associative containers that contain values referenced by unique keys. Dictionaries will preserve the insertion order when adding new entries. In other programming languages, this data structure is often referred to as a hash map or an associative array.
 
-You can define a dictionary by placing a comma-separated list of ``key: value`` pairs in curly braces ``{}``.
-
-\ **Note:** Dictionaries are always passed by reference. To get a copy of a dictionary which can be modified independently of the original dictionary, use :ref:`duplicate<class_Dictionary_method_duplicate>`.
+You can define a dictionary by placing a comma-separated list of ``key: value`` pairs inside curly braces ``{}``.
 
 Creating a dictionary:
 
@@ -187,6 +185,8 @@ The keys of a dictionary can be iterated with the ``for`` keyword:
 
 
 
+\ **Note:** Dictionaries are always passed by reference. To get a copy of a dictionary which can be modified independently of the original dictionary, use :ref:`duplicate<class_Dictionary_method_duplicate>`.
+
 \ **Note:** Erasing elements while iterating over dictionaries is **not** supported and will result in unpredictable behavior.
 
 .. rst-class:: classref-introduction-group
@@ -400,9 +400,9 @@ Returns ``true`` if the dictionary contains an entry with the given ``key``.
         { 210, default },
     };
     
-    GD.Print(myDict.Contains("Godot")); // Prints true
-    GD.Print(myDict.Contains(210));     // Prints true
-    GD.Print(myDict.Contains(4));       // Prints false
+    GD.Print(myDict.ContainsKey("Godot")); // Prints true
+    GD.Print(myDict.ContainsKey(210));     // Prints true
+    GD.Print(myDict.ContainsKey(4));       // Prints false
 
 
 

classes/class_diraccess.rst

@@ -12,14 +12,14 @@ DirAccess
 
 **Inherits:** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
 
-Type used to handle the filesystem.
+Provides methods for managing directories and their content.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Directory type. It is used to manage directories and their content (not restricted to the project folder).
+This class is used to manage directories and their content, even outside of the project folder.
 
 \ **DirAccess** can't be instantiated directly. Instead it is created with a static method that takes a path for which it will be opened.
 
@@ -417,7 +417,7 @@ Returns a :ref:`PackedStringArray<class_PackedStringArray>` containing filenames
 
 Affected by :ref:`include_hidden<class_DirAccess_property_include_hidden>`.
 
-\ **Note:** When used on a ``res://`` path in an exported project, only the files actually included in the PCK at the given folder level are returned. In practice, this means that since imported resources are stored in a top-level ``.godot/`` folder, only paths to ``*.gd`` and ``*.import`` files are returned (plus a few files such as ``project.godot`` or ``project.binary[code] and the project icon). In an exported project, the list of returned files will also vary depending on whether [member ProjectSettings.editor/export/convert_text_resources_to_binary] is [code]true``.
+\ **Note:** When used on a ``res://`` path in an exported project, only the files actually included in the PCK at the given folder level are returned. In practice, this means that since imported resources are stored in a top-level ``.godot/`` folder, only paths to ``*.gd`` and ``*.import`` files are returned (plus a few files such as ``project.godot`` or ``project.binary`` and the project icon). In an exported project, the list of returned files will also vary depending on whether :ref:`ProjectSettings.editor/export/convert_text_resources_to_binary<class_ProjectSettings_property_editor/export/convert_text_resources_to_binary>` is ``true``.
 
 .. rst-class:: classref-item-separator
 

classes/class_displayserver.rst

@@ -12,14 +12,14 @@ DisplayServer
 
 **Inherits:** :ref:`Object<class_Object>`
 
-Singleton for window management functions.
+A server interface for low-level window management.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-**DisplayServer** handles everything related to window management. This is separated from :ref:`OS<class_OS>` as a single operating system may support multiple display servers.
+**DisplayServer** handles everything related to window management. It is separated from :ref:`OS<class_OS>` as a single operating system may support multiple display servers.
 
 \ **Headless mode:** Starting the engine with the ``--headless`` :doc:`command line argument <../tutorials/editor/command_line_tutorial>` disables all rendering and window management functions. Most functions from **DisplayServer** will return dummy values in this case.
 
@@ -758,7 +758,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 a URL tag in a :ref:`RichTextLabel<class_RichTextLabel>`.
 
 .. _class_DisplayServer_constant_CURSOR_CROSS:
 
@@ -1018,7 +1018,7 @@ Use :ref:`window_set_window_buttons_offset<class_DisplayServer_method_window_set
 
 Use :ref:`window_get_safe_title_margins<class_DisplayServer_method_window_get_safe_title_margins>` to determine area under the title bar that is not covered by decorations.
 
-\ **Note:** This flag is implemented on macOS.
+\ **Note:** This flag is implemented only on macOS.
 
 .. _class_DisplayServer_constant_WINDOW_FLAG_MOUSE_PASSTHROUGH:
 
@@ -1094,7 +1094,7 @@ Sent when the user has attempted to close the window (e.g. close button is press
 
 Sent when the device "Back" button is pressed, see :ref:`window_set_window_event_callback<class_DisplayServer_method_window_set_window_event_callback>`.
 
-\ **Note:** This event is implemented on Android.
+\ **Note:** This event is implemented only on Android.
 
 .. _class_DisplayServer_constant_WINDOW_EVENT_DPI_CHANGE:
 
@@ -1104,7 +1104,7 @@ Sent when the device "Back" button is pressed, see :ref:`window_set_window_event
 
 Sent when the window is moved to the display with different DPI, or display DPI is changed, see :ref:`window_set_window_event_callback<class_DisplayServer_method_window_set_window_event_callback>`.
 
-\ **Note:** This flag is implemented on macOS.
+\ **Note:** This flag is implemented only on macOS.
 
 .. _class_DisplayServer_constant_WINDOW_EVENT_TITLEBAR_CHANGE:
 
@@ -1114,7 +1114,7 @@ Sent when the window is moved to the display with different DPI, or display DPI
 
 Sent when the window title bar decoration is changed (e.g. :ref:`WINDOW_FLAG_EXTEND_TO_TITLE<class_DisplayServer_constant_WINDOW_FLAG_EXTEND_TO_TITLE>` is set or window entered/exited full screen mode), see :ref:`window_set_window_event_callback<class_DisplayServer_method_window_set_window_event_callback>`.
 
-\ **Note:** This flag is implemented on macOS.
+\ **Note:** This flag is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -1446,7 +1446,7 @@ Sets the default mouse cursor shape. The cursor's appearance will vary depending
 
 Shows a text input dialog which uses the operating system's native look-and-feel. ``callback`` will be called with a :ref:`String<class_String>` argument equal to the text field's contents when the dialog is closed for any reason.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -1460,7 +1460,7 @@ Shows a text input dialog which uses the operating system's native look-and-feel
 
 Shows a text dialog which uses the operating system's native look-and-feel. ``callback`` will be called when the dialog is closed for any reason.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -1474,7 +1474,7 @@ void **enable_for_stealing_focus** **(** :ref:`int<class_int>` process_id **)**
 
 Allows the ``process_id`` PID to steal focus from this window. In other words, this disables the operating system's focus stealing protection for the specified PID.
 
-\ **Note:** This method is implemented on Windows.
+\ **Note:** This method is implemented only on Windows.
 
 .. rst-class:: classref-item-separator
 
@@ -1659,7 +1659,7 @@ An ``accelerator`` can optionally be defined, which is a keyboard shortcut that
 
 \ **Note:** The ``callback`` and ``key_callback`` Callables need to accept exactly one Variant parameter, the parameter passed to the Callables will be the value passed to ``tag``.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 \ **Supported system menu IDs:**\ 
 
@@ -1686,7 +1686,7 @@ An ``accelerator`` can optionally be defined, which is a keyboard shortcut that
 
 \ **Note:** The ``callback`` and ``key_callback`` Callables need to accept exactly one Variant parameter, the parameter passed to the Callables will be the value passed to ``tag``.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 \ **Supported system menu IDs:**\ 
 
@@ -1713,7 +1713,7 @@ An ``accelerator`` can optionally be defined, which is a keyboard shortcut that
 
 \ **Note:** The ``callback`` and ``key_callback`` Callables need to accept exactly one Variant parameter, the parameter passed to the Callables will be the value passed to ``tag``.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 \ **Supported system menu IDs:**\ 
 
@@ -1742,7 +1742,7 @@ An ``accelerator`` can optionally be defined, which is a keyboard shortcut that
 
 \ **Note:** The ``callback`` and ``key_callback`` Callables need to accept exactly one Variant parameter, the parameter passed to the Callables will be the value passed to ``tag``.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 \ **Supported system menu IDs:**\ 
 
@@ -1769,7 +1769,7 @@ An ``accelerator`` can optionally be defined, which is a keyboard shortcut that
 
 \ **Note:** The ``callback`` and ``key_callback`` Callables need to accept exactly one Variant parameter, the parameter passed to the Callables will be the value passed to ``tag``.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 \ **Supported system menu IDs:**\ 
 
@@ -1800,7 +1800,7 @@ An ``accelerator`` can optionally be defined, which is a keyboard shortcut that
 
 \ **Note:** The ``callback`` and ``key_callback`` Callables need to accept exactly one Variant parameter, the parameter passed to the Callables will be the value passed to ``tag``.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 \ **Supported system menu IDs:**\ 
 
@@ -1829,7 +1829,7 @@ An ``accelerator`` can optionally be defined, which is a keyboard shortcut that
 
 \ **Note:** The ``callback`` and ``key_callback`` Callables need to accept exactly one Variant parameter, the parameter passed to the Callables will be the value passed to ``tag``.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 \ **Supported system menu IDs:**\ 
 
@@ -1852,7 +1852,7 @@ Adds a separator between items to the global menu with ID ``menu_root``. Separat
 
 Returns index of the inserted item, it's not guaranteed to be the same as ``index`` value.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 \ **Supported system menu IDs:**\ 
 
@@ -1875,7 +1875,7 @@ Adds an item that will act as a submenu of the global menu ``menu_root``. The ``
 
 Returns index of the inserted item, it's not guaranteed to be the same as ``index`` value.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 \ **Supported system menu IDs:**\ 
 
@@ -1896,7 +1896,7 @@ void **global_menu_clear** **(** :ref:`String<class_String>` menu_root **)**
 
 Removes all items from the global menu with ID ``menu_root``.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 \ **Supported system menu IDs:**\ 
 
@@ -1917,7 +1917,7 @@ Removes all items from the global menu with ID ``menu_root``.
 
 Returns the accelerator of the item at index ``idx``. Accelerators are special combinations of keys that activate the item, no matter which control is focused.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -1931,7 +1931,7 @@ Returns the accelerator of the item at index ``idx``. Accelerators are special c
 
 Returns the callback of the item at index ``idx``.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -1945,7 +1945,7 @@ Returns the callback of the item at index ``idx``.
 
 Returns number of items in the global menu with ID ``menu_root``.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -1959,7 +1959,7 @@ Returns number of items in the global menu with ID ``menu_root``.
 
 Returns the icon of the item at index ``idx``.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -1973,7 +1973,7 @@ Returns the icon of the item at index ``idx``.
 
 Returns the horizontal offset of the item at the given ``idx``.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -1987,7 +1987,7 @@ Returns the horizontal offset of the item at the given ``idx``.
 
 Returns the index of the item with the specified ``tag``. Index is automatically assigned to each item by the engine. Index can not be set manually.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2001,7 +2001,7 @@ Returns the index of the item with the specified ``tag``. Index is automatically
 
 Returns the index of the item with the specified ``text``. Index is automatically assigned to each item by the engine. Index can not be set manually.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2015,7 +2015,7 @@ Returns the index of the item with the specified ``text``. Index is automaticall
 
 Returns the callback of the item accelerator at index ``idx``.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2029,7 +2029,7 @@ Returns the callback of the item accelerator at index ``idx``.
 
 Returns number of states of a multistate item. See :ref:`global_menu_add_multistate_item<class_DisplayServer_method_global_menu_add_multistate_item>` for details.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2043,7 +2043,7 @@ Returns number of states of a multistate item. See :ref:`global_menu_add_multist
 
 Returns the state of a multistate item. See :ref:`global_menu_add_multistate_item<class_DisplayServer_method_global_menu_add_multistate_item>` for details.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2057,7 +2057,7 @@ Returns the state of a multistate item. See :ref:`global_menu_add_multistate_ite
 
 Returns the submenu ID of the item at index ``idx``. See :ref:`global_menu_add_submenu_item<class_DisplayServer_method_global_menu_add_submenu_item>` for more info on how to add a submenu.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2071,7 +2071,7 @@ Returns the submenu ID of the item at index ``idx``. See :ref:`global_menu_add_s
 
 Returns the metadata of the specified item, which might be of any type. You can set it with :ref:`global_menu_set_item_tag<class_DisplayServer_method_global_menu_set_item_tag>`, which provides a simple way of assigning context data to items.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2085,7 +2085,7 @@ Returns the metadata of the specified item, which might be of any type. You can
 
 Returns the text of the item at index ``idx``.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2099,7 +2099,7 @@ Returns the text of the item at index ``idx``.
 
 Returns the tooltip associated with the specified index ``idx``.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2113,7 +2113,7 @@ Returns the tooltip associated with the specified index ``idx``.
 
 Returns ``true`` if the item at index ``idx`` is checkable in some way, i.e. if it has a checkbox or radio button.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2127,7 +2127,7 @@ Returns ``true`` if the item at index ``idx`` is checkable in some way, i.e. if
 
 Returns ``true`` if the item at index ``idx`` is checked.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2143,7 +2143,7 @@ Returns ``true`` if the item at index ``idx`` is disabled. When it is disabled i
 
 See :ref:`global_menu_set_item_disabled<class_DisplayServer_method_global_menu_set_item_disabled>` for more info on how to disable an item.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2159,7 +2159,7 @@ Returns ``true`` if the item at index ``idx`` has radio button-style checkabilit
 
 \ **Note:** This is purely cosmetic; you must add the logic for checking/unchecking items in radio groups.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2175,7 +2175,7 @@ Removes the item at index ``idx`` from the global menu ``menu_root``.
 
 \ **Note:** The indices of items after the removed item will be shifted by one.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2189,7 +2189,7 @@ void **global_menu_set_item_accelerator** **(** :ref:`String<class_String>` menu
 
 Sets the accelerator of the item at index ``idx``. ``keycode`` can be a single :ref:`Key<enum_@GlobalScope_Key>`, or a combination of :ref:`KeyModifierMask<enum_@GlobalScope_KeyModifierMask>`\ s and :ref:`Key<enum_@GlobalScope_Key>`\ s using bitwise OR such as ``KEY_MASK_CTRL | KEY_A`` (:kbd:`Ctrl + A`).
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2205,7 +2205,7 @@ Sets the callback of the item at index ``idx``. Callback is emitted when an item
 
 \ **Note:** The ``callback`` Callable needs to accept exactly one Variant parameter, the parameter passed to the Callable will be the value passed to the ``tag`` parameter when the menu item was created.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2219,7 +2219,7 @@ void **global_menu_set_item_checkable** **(** :ref:`String<class_String>` menu_r
 
 Sets whether the item at index ``idx`` has a checkbox. If ``false``, sets the type of the item to plain text.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2233,7 +2233,7 @@ void **global_menu_set_item_checked** **(** :ref:`String<class_String>` menu_roo
 
 Sets the checkstate status of the item at index ``idx``.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2247,7 +2247,7 @@ void **global_menu_set_item_disabled** **(** :ref:`String<class_String>` menu_ro
 
 Enables/disables the item at index ``idx``. When it is disabled, it can't be selected and its action can't be invoked.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2261,7 +2261,7 @@ void **global_menu_set_item_icon** **(** :ref:`String<class_String>` menu_root,
 
 Replaces the :ref:`Texture2D<class_Texture2D>` icon of the specified ``idx``.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 \ **Note:** This method is not supported by macOS "_dock" menu items.
 
@@ -2277,7 +2277,7 @@ void **global_menu_set_item_indentation_level** **(** :ref:`String<class_String>
 
 Sets the horizontal offset of the item at the given ``idx``.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2293,7 +2293,7 @@ Sets the callback of the item at index ``idx``. Callback is emitted when its acc
 
 \ **Note:** The ``key_callback`` Callable needs to accept exactly one Variant parameter, the parameter passed to the Callable will be the value passed to the ``tag`` parameter when the menu item was created.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2307,7 +2307,7 @@ void **global_menu_set_item_max_states** **(** :ref:`String<class_String>` menu_
 
 Sets number of state of a multistate item. See :ref:`global_menu_add_multistate_item<class_DisplayServer_method_global_menu_add_multistate_item>` for details.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2323,7 +2323,7 @@ Sets the type of the item at the specified index ``idx`` to radio button. If ``f
 
 \ **Note:** This is purely cosmetic; you must add the logic for checking/unchecking items in radio groups.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2337,7 +2337,7 @@ void **global_menu_set_item_state** **(** :ref:`String<class_String>` menu_root,
 
 Sets the state of a multistate item. See :ref:`global_menu_add_multistate_item<class_DisplayServer_method_global_menu_add_multistate_item>` for details.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2351,7 +2351,7 @@ void **global_menu_set_item_submenu** **(** :ref:`String<class_String>` menu_roo
 
 Sets the submenu of the item at index ``idx``. The submenu is the ID of a global menu root that would be shown when the item is clicked.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2365,7 +2365,7 @@ void **global_menu_set_item_tag** **(** :ref:`String<class_String>` menu_root, :
 
 Sets the metadata of an item, which may be of any type. You can later get it with :ref:`global_menu_get_item_tag<class_DisplayServer_method_global_menu_get_item_tag>`, which provides a simple way of assigning context data to items.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2379,7 +2379,7 @@ void **global_menu_set_item_text** **(** :ref:`String<class_String>` menu_root,
 
 Sets the text of the item at index ``idx``.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2393,7 +2393,7 @@ void **global_menu_set_item_tooltip** **(** :ref:`String<class_String>` menu_roo
 
 Sets the :ref:`String<class_String>` tooltip of the item at the specified index ``idx``.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2419,7 +2419,7 @@ Returns ``true`` if the specified ``feature`` is supported by the current **Disp
 
 Returns the text selection in the `Input Method Editor <https://en.wikipedia.org/wiki/Input_method>`__ composition string, with the :ref:`Vector2i<class_Vector2i>`'s ``x`` component being the caret position and ``y`` being the length of the selection.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2433,7 +2433,7 @@ Returns the text selection in the `Input Method Editor <https://en.wikipedia.org
 
 Returns the composition string contained within the `Input Method Editor <https://en.wikipedia.org/wiki/Input_method>`__ window.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2676,7 +2676,7 @@ Returns the greatest scale factor of all screens.
 
 \ **Note:** On macOS returned value is ``2.0`` if there is at least one hiDPI (Retina) screen in the system, and ``1.0`` in all other cases.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2767,7 +2767,7 @@ Returns the scale factor of the specified screen by index.
 
 \ **Note:** On macOS returned value is ``2.0`` for hiDPI (Retina) screen, and ``1.0`` for all other cases.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -2865,7 +2865,7 @@ Sets the window icon (usually displayed in the top-left corner) in the operating
 
 Returns current active tablet driver name.
 
-\ **Note:** This method is implemented on Windows.
+\ **Note:** This method is implemented only on Windows.
 
 .. rst-class:: classref-item-separator
 
@@ -2879,7 +2879,7 @@ Returns current active tablet driver name.
 
 Returns the total number of available tablet drivers.
 
-\ **Note:** This method is implemented on Windows.
+\ **Note:** This method is implemented only on Windows.
 
 .. rst-class:: classref-item-separator
 
@@ -2893,7 +2893,7 @@ Returns the total number of available tablet drivers.
 
 Returns the tablet driver name for the given index.
 
-\ **Note:** This method is implemented on Windows.
+\ **Note:** This method is implemented only on Windows.
 
 .. rst-class:: classref-item-separator
 
@@ -2907,7 +2907,7 @@ void **tablet_set_current_driver** **(** :ref:`String<class_String>` name **)**
 
 Set active tablet driver name.
 
-\ **Note:** This method is implemented on Windows.
+\ **Note:** This method is implemented only on Windows.
 
 .. rst-class:: classref-item-separator
 
@@ -3181,7 +3181,7 @@ Returns ID of the active popup window, or :ref:`INVALID_WINDOW_ID<class_DisplayS
 
 :ref:`int<class_int>` **window_get_attached_instance_id** **(** :ref:`int<class_int>` window_id=0 **)** |const|
 
-Returns the :ref:`Object.get_instance_id<class_Object_method_get_instance_id>` of the :ref:`Window<class_Window>` the ``window_id`` is attached to. also :ref:`window_get_attached_instance_id<class_DisplayServer_method_window_get_attached_instance_id>`.
+Returns the :ref:`Object.get_instance_id<class_Object_method_get_instance_id>` of the :ref:`Window<class_Window>` the ``window_id`` is attached to.
 
 .. rst-class:: classref-item-separator
 
@@ -3365,7 +3365,7 @@ Returns ``true`` if the given window can be maximized (the maximize button is en
 
 Returns ``true``, if double-click on a window title should maximize it.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -3379,7 +3379,7 @@ Returns ``true``, if double-click on a window title should maximize it.
 
 Returns ``true``, if double-click on a window title should minimize it.
 
-\ **Note:** This method is implemented on macOS.
+\ **Note:** This method is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 
@@ -3725,7 +3725,7 @@ void **window_set_window_buttons_offset** **(** :ref:`Vector2i<class_Vector2i>`
 
 When :ref:`WINDOW_FLAG_EXTEND_TO_TITLE<class_DisplayServer_constant_WINDOW_FLAG_EXTEND_TO_TITLE>` flag is set, set offset to the center of the first titlebar button.
 
-\ **Note:** This flag is implemented on macOS.
+\ **Note:** This flag is implemented only on macOS.
 
 .. rst-class:: classref-item-separator
 

classes/class_editorfiledialog.rst

@@ -19,7 +19,7 @@ A modified version of :ref:`FileDialog<class_FileDialog>` used by the editor.
 Description
 -----------
 
-**EditorFileDialog** is an enhanced version of :ref:`FileDialog<class_FileDialog>` available only to editor plugins. Additional features include list of favorited/recent files and ability to see files as thumbnails grid instead of list.
+**EditorFileDialog** is an enhanced version of :ref:`FileDialog<class_FileDialog>` available only to editor plugins. Additional features include list of favorited/recent files and the ability to see files as thumbnails grid instead of list.
 
 .. rst-class:: classref-reftable-group
 

classes/class_editorimportplugin.rst

@@ -115,7 +115,7 @@ Below is an example EditorImportPlugin that imports a :ref:`Mesh<class_Mesh>` fr
                 new Godot.Collections.Dictionary
                 {
                     { "name", "myOption" },
-                    { "defaultValue", false },
+                    { "default_value", false },
                 }
             };
         }
@@ -249,12 +249,12 @@ This method can be overridden to hide specific import options if conditions are
 
  .. code-tab:: csharp
 
-    public void GetOptionVisibility(string option, Godot.Collections.Dictionary options)
+    public void _GetOptionVisibility(string option, Godot.Collections.Dictionary options)
     {
         // Only show the lossy quality setting if the compression mode is set to "Lossy".
-        if (option == "compress/lossyQuality" && options.Contains("compress/mode"))
+        if (option == "compress/lossy_quality" && options.ContainsKey("compress/mode"))
         {
-            return (int)options["compress/mode"] == COMPRESS_LOSSY; // This is a constant you set
+            return (int)options["compress/mode"] == CompressLossy; // This is a constant you set
         }
     
         return true;

classes/class_editorinterface.rst

@@ -19,7 +19,7 @@ Godot editor's interface.
 Description
 -----------
 
-EditorInterface gives you control over Godot editor's window. It allows customizing the window, saving and (re-)loading scenes, rendering mesh previews, inspecting and editing resources and objects, and provides access to :ref:`EditorSettings<class_EditorSettings>`, :ref:`EditorFileSystem<class_EditorFileSystem>`, :ref:`EditorResourcePreview<class_EditorResourcePreview>`, :ref:`ScriptEditor<class_ScriptEditor>`, the editor viewport, and information about scenes.
+**EditorInterface** gives you control over Godot editor's window. It allows customizing the window, saving and (re-)loading scenes, rendering mesh previews, inspecting and editing resources and objects, and provides access to :ref:`EditorSettings<class_EditorSettings>`, :ref:`EditorFileSystem<class_EditorFileSystem>`, :ref:`EditorResourcePreview<class_EditorResourcePreview>`, :ref:`ScriptEditor<class_ScriptEditor>`, the editor viewport, and information about scenes.
 
 \ **Note:** This class shouldn't be instantiated directly. Instead, access the singleton using :ref:`EditorPlugin.get_editor_interface<class_EditorPlugin_method_get_editor_interface>`.
 

classes/class_editornode3dgizmoplugin.rst

@@ -12,7 +12,7 @@ EditorNode3DGizmoPlugin
 
 **Inherits:** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
 
-Used by the editor to define Node3D gizmo types.
+A class used by the editor to define Node3D gizmo types.
 
 .. rst-class:: classref-introduction-group
 

classes/class_editorproperty.rst

@@ -12,14 +12,14 @@ EditorProperty
 
 **Inherits:** :ref:`Container<class_Container>` **<** :ref:`Control<class_Control>` **<** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-Custom control to edit properties for adding into the inspector.
+Custom control for editing properties that can be added to the :ref:`EditorInspector<class_EditorInspector>`.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-This control allows property editing for one or multiple properties into :ref:`EditorInspector<class_EditorInspector>`. It is added via :ref:`EditorInspectorPlugin<class_EditorInspectorPlugin>`.
+A custom control for editing properties that can be added to the :ref:`EditorInspector<class_EditorInspector>`. It is added via :ref:`EditorInspectorPlugin<class_EditorInspectorPlugin>`.
 
 .. rst-class:: classref-reftable-group
 

classes/class_editorresourcepreview.rst

@@ -12,14 +12,14 @@ EditorResourcePreview
 
 **Inherits:** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-Helper to generate previews of resources or files.
+A node used to generate previews of resources or files.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-This object is used to generate previews for resources of files.
+This node is used to generate previews for resources of files.
 
 \ **Note:** This class shouldn't be instantiated directly. Instead, access the singleton using :ref:`EditorInterface.get_resource_previewer<class_EditorInterface_method_get_resource_previewer>`.
 

classes/class_editorresourcetooltipplugin.rst

@@ -31,15 +31,13 @@ Methods
 .. table::
    :widths: auto
 
-   +-------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-   | :ref:`bool<class_bool>`                   | :ref:`_handles<class_EditorResourceTooltipPlugin_method__handles>` **(** :ref:`String<class_String>` type **)** |virtual| |const|                                                                           |
-   +-------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-   | :ref:`Object<class_Object>`               | :ref:`_make_tooltip_for_path<class_EditorResourceTooltipPlugin_method__make_tooltip_for_path>` **(** :ref:`String<class_String>` path, :ref:`Dictionary<class_Dictionary>` metadata **)** |virtual| |const| |
-   +-------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-   | :ref:`VBoxContainer<class_VBoxContainer>` | :ref:`make_default_tooltip<class_EditorResourceTooltipPlugin_method_make_default_tooltip>` **(** :ref:`String<class_String>` path **)** |static|                                                            |
-   +-------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-   | void                                      | :ref:`request_thumbnail<class_EditorResourceTooltipPlugin_method_request_thumbnail>` **(** :ref:`String<class_String>` path, :ref:`TextureRect<class_TextureRect>` control **)** |const|                    |
-   +-------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+   +-------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`bool<class_bool>`       | :ref:`_handles<class_EditorResourceTooltipPlugin_method__handles>` **(** :ref:`String<class_String>` type **)** |virtual| |const|                                                                                                               |
+   +-------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`Control<class_Control>` | :ref:`_make_tooltip_for_path<class_EditorResourceTooltipPlugin_method__make_tooltip_for_path>` **(** :ref:`String<class_String>` path, :ref:`Dictionary<class_Dictionary>` metadata, :ref:`Control<class_Control>` base **)** |virtual| |const| |
+   +-------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+   | void                          | :ref:`request_thumbnail<class_EditorResourceTooltipPlugin_method_request_thumbnail>` **(** :ref:`String<class_String>` path, :ref:`TextureRect<class_TextureRect>` control **)** |const|                                                        |
+   +-------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
 .. rst-class:: classref-section-separator
 
@@ -66,25 +64,25 @@ Return ``true`` if the plugin is going to handle the given :ref:`Resource<class_
 
 .. rst-class:: classref-method
 
-:ref:`Object<class_Object>` **_make_tooltip_for_path** **(** :ref:`String<class_String>` path, :ref:`Dictionary<class_Dictionary>` metadata **)** |virtual| |const|
+:ref:`Control<class_Control>` **_make_tooltip_for_path** **(** :ref:`String<class_String>` path, :ref:`Dictionary<class_Dictionary>` metadata, :ref:`Control<class_Control>` base **)** |virtual| |const|
 
-Create and return a tooltip that will be displayed when the user hovers resource under given ``path`` in filesystem dock. For best results, use :ref:`make_default_tooltip<class_EditorResourceTooltipPlugin_method_make_default_tooltip>` as a base. 
+Create and return a tooltip that will be displayed when the user hovers a resource under the given ``path`` in filesystem dock.
 
 The ``metadata`` dictionary is provided by preview generator (see method EditorResourcePreviewGenerator._generate]).
 
-\ **Note:** It's unadvised to use :ref:`ResourceLoader.load<class_ResourceLoader_method_load>`, especially with heavy resources like models or textures, because it will make the editor unresponsive when creating the tooltip. You can use :ref:`request_thumbnail<class_EditorResourceTooltipPlugin_method_request_thumbnail>` if you want to display a preview in your tooltip.
-
-.. rst-class:: classref-item-separator
+\ ``base`` is the base default tooltip, which is a :ref:`VBoxContainer<class_VBoxContainer>` with a file name, type and size labels. If another plugin handled the same file type, ``base`` will be output from the previous plugin. For best result, make sure the base tooltip is part of the returned :ref:`Control<class_Control>`.
 
-----
-
-.. _class_EditorResourceTooltipPlugin_method_make_default_tooltip:
+\ **Note:** It's unadvised to use :ref:`ResourceLoader.load<class_ResourceLoader_method_load>`, especially with heavy resources like models or textures, because it will make the editor unresponsive when creating the tooltip. You can use :ref:`request_thumbnail<class_EditorResourceTooltipPlugin_method_request_thumbnail>` if you want to display a preview in your tooltip.
 
-.. rst-class:: classref-method
+\ **Note:** If you decide to discard the ``base``, make sure to call :ref:`Node.queue_free<class_Node_method_queue_free>`, because it's not freed automatically.
 
-:ref:`VBoxContainer<class_VBoxContainer>` **make_default_tooltip** **(** :ref:`String<class_String>` path **)** |static|
+::
 
-Creates a default file tooltip. The tooltip includes file name, file size and :ref:`Resource<class_Resource>` type if available.
+    func _make_tooltip_for_path(path, metadata, base):
+        var t_rect = TextureRect.new()
+        request_thumbnail(path, t_rect)
+        base.add_child(t_rect) # The TextureRect will appear at the bottom of the tooltip.
+        return base
 
 .. rst-class:: classref-item-separator
 

classes/class_editorsettings.rst

@@ -89,8 +89,6 @@ Properties
    +-------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | :ref:`int<class_int>`         | :ref:`editors/2d/bone_width<class_EditorSettings_property_editors/2d/bone_width>`                                                                                                   |
    +-------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-   | :ref:`bool<class_bool>`       | :ref:`editors/2d/constrain_editor_view<class_EditorSettings_property_editors/2d/constrain_editor_view>`                                                                             |
-   +-------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | :ref:`Color<class_Color>`     | :ref:`editors/2d/grid_color<class_EditorSettings_property_editors/2d/grid_color>`                                                                                                   |
    +-------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | :ref:`Color<class_Color>`     | :ref:`editors/2d/guides_color<class_EditorSettings_property_editors/2d/guides_color>`                                                                                               |
@@ -395,8 +393,6 @@ Properties
    +-------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | :ref:`bool<class_bool>`       | :ref:`text_editor/appearance/gutters/line_numbers_zero_padded<class_EditorSettings_property_text_editor/appearance/gutters/line_numbers_zero_padded>`                               |
    +-------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-   | :ref:`bool<class_bool>`       | :ref:`text_editor/appearance/gutters/show_bookmark_gutter<class_EditorSettings_property_text_editor/appearance/gutters/show_bookmark_gutter>`                                       |
-   +-------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | :ref:`bool<class_bool>`       | :ref:`text_editor/appearance/gutters/show_info_gutter<class_EditorSettings_property_text_editor/appearance/gutters/show_info_gutter>`                                               |
    +-------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | :ref:`bool<class_bool>`       | :ref:`text_editor/appearance/gutters/show_line_numbers<class_EditorSettings_property_text_editor/appearance/gutters/show_line_numbers>`                                             |
@@ -813,18 +809,6 @@ The bone width in the 2D skeleton editor (in pixels). See also :ref:`editors/2d/
 
 ----
 
-.. _class_EditorSettings_property_editors/2d/constrain_editor_view:
-
-.. rst-class:: classref-property
-
-:ref:`bool<class_bool>` **editors/2d/constrain_editor_view**
-
-If ``true``, prevents the 2D editor viewport from leaving the scene. Limits are calculated dynamically based on nodes present in the current scene. If ``false``, the 2D editor viewport will be able to move freely, but you risk getting lost when zooming out too far. You can refocus on the scene by selecting a node then pressing :kbd:`F`.
-
-.. rst-class:: classref-item-separator
-
-----
-
 .. _class_EditorSettings_property_editors/2d/grid_color:
 
 .. rst-class:: classref-property
@@ -2753,25 +2737,13 @@ If ``true``, displays line numbers with zero padding (e.g. ``007`` instead of ``
 
 ----
 
-.. _class_EditorSettings_property_text_editor/appearance/gutters/show_bookmark_gutter:
-
-.. rst-class:: classref-property
-
-:ref:`bool<class_bool>` **text_editor/appearance/gutters/show_bookmark_gutter**
-
-If ``true``, displays icons for bookmarks in a gutter at the left. Bookmarks remain functional when this setting is disabled.
-
-.. rst-class:: classref-item-separator
-
-----
-
 .. _class_EditorSettings_property_text_editor/appearance/gutters/show_info_gutter:
 
 .. rst-class:: classref-property
 
 :ref:`bool<class_bool>` **text_editor/appearance/gutters/show_info_gutter**
 
-If ``true``, displays a gutter at the left containing icons for methods with signal connections.
+If ``true``, displays a gutter at the left containing icons for methods with signal connections and for overridden methods.
 
 .. rst-class:: classref-item-separator
 

classes/class_editorsyntaxhighlighter.rst

@@ -12,14 +12,14 @@ EditorSyntaxHighlighter
 
 **Inherits:** :ref:`SyntaxHighlighter<class_SyntaxHighlighter>` **<** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
 
-Base Syntax highlighter resource for the :ref:`ScriptEditor<class_ScriptEditor>`.
+Base class for :ref:`SyntaxHighlighter<class_SyntaxHighlighter>` used by the :ref:`ScriptEditor<class_ScriptEditor>`.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Base syntax highlighter resource all editor syntax highlighters extend from, it is used in the :ref:`ScriptEditor<class_ScriptEditor>`.
+Base class that all :ref:`SyntaxHighlighter<class_SyntaxHighlighter>`\ s used by the :ref:`ScriptEditor<class_ScriptEditor>` extend from.
 
 Add a syntax highlighter to an individual script by calling :ref:`ScriptEditorBase.add_syntax_highlighter<class_ScriptEditorBase_method_add_syntax_highlighter>`. To apply to all scripts on open, call :ref:`ScriptEditor.register_syntax_highlighter<class_ScriptEditor_method_register_syntax_highlighter>`
 

classes/class_engine.rst

@@ -12,7 +12,7 @@ Engine
 
 **Inherits:** :ref:`Object<class_Object>`
 
-Access to engine properties.
+Provides access to engine properties.
 
 .. rst-class:: classref-introduction-group
 

classes/class_fileaccess.rst

@@ -12,14 +12,14 @@ FileAccess
 
 **Inherits:** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
 
-Type to handle file reading and writing operations.
+Provides methods for file reading and writing operations.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-File type. This is used to permanently store data into the user device's file system and to read from it. This can be used to store game save data or player configuration files, for example.
+This class can be used to permanently store data in the user device's file system and to read from it. This is useful for store game save data or player configuration files.
 
 Here's a sample on how to write and read from a file:
 
@@ -56,24 +56,9 @@ Here's a sample on how to write and read from a file:
 
 In the example above, the file will be saved in the user data folder as specified in the :doc:`Data paths <../tutorials/io/data_paths>` documentation.
 
-\ **FileAccess** will close when it's freed, which happens when it goes out of scope or when it gets assigned with ``null``. In C# the reference must be disposed after we are done using it, this can be done with the ``using`` statement or calling the ``Dispose`` method directly.
+\ **FileAccess** will close when it's freed, which happens when it goes out of scope or when it gets assigned with ``null``. :ref:`close<class_FileAccess_method_close>` can be used to close it before then explicitly. In C# the reference must be disposed manually, which can be done with the ``using`` statement or by calling the ``Dispose`` method directly.
 
-
-.. tabs::
-
- .. code-tab:: gdscript
-
-    var file = FileAccess.open("res://something") # File is opened and locked for use.
-    file = null # File is closed.
-
- .. code-tab:: csharp
-
-    using var file = FileAccess.Open("res://something"); // File is opened and locked for use.
-    // The using statement calls Dispose when going out of scope.
-
-
-
-\ **Note:** To access project resources once exported, it is recommended to use :ref:`ResourceLoader<class_ResourceLoader>` instead of the **FileAccess** API, as some files are converted to engine-specific formats and their original source files might not be present in the exported PCK package.
+\ **Note:** To access project resources once exported, it is recommended to use :ref:`ResourceLoader<class_ResourceLoader>` instead of **FileAccess**, as some files are converted to engine-specific formats and their original source files might not be present in the exported PCK package.
 
 \ **Note:** Files are automatically closed only if the process exits "normally" (such as by clicking the window manager's close button or pressing **Alt + F4**). If you stop the project execution by pressing **F8** while the project is running, the file won't be closed as the game process will be killed. You can work around this by calling :ref:`flush<class_FileAccess_method_flush>` at regular intervals.
 

classes/class_filedialog.rst

@@ -12,14 +12,14 @@ FileDialog
 
 **Inherits:** :ref:`ConfirmationDialog<class_ConfirmationDialog>` **<** :ref:`AcceptDialog<class_AcceptDialog>` **<** :ref:`Window<class_Window>` **<** :ref:`Viewport<class_Viewport>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-Dialog for selecting files or directories in the filesystem.
+A dialog for selecting files or directories in the filesystem.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-FileDialog is a preset dialog used to choose files and directories in the filesystem. It supports filter masks. The FileDialog automatically sets its window title according to the :ref:`file_mode<class_FileDialog_property_file_mode>`. If you want to use a custom title, disable this by setting :ref:`mode_overrides_title<class_FileDialog_property_mode_overrides_title>` to ``false``.
+**FileDialog** is a preset dialog used to choose files and directories in the filesystem. It supports filter masks. **FileDialog** automatically sets its window title according to the :ref:`file_mode<class_FileDialog_property_file_mode>`. If you want to use a custom title, disable this by setting :ref:`mode_overrides_title<class_FileDialog_property_mode_overrides_title>` to ``false``.
 
 .. rst-class:: classref-reftable-group
 

classes/class_filesystemdock.rst

@@ -12,7 +12,7 @@ FileSystemDock
 
 **Inherits:** :ref:`VBoxContainer<class_VBoxContainer>` **<** :ref:`BoxContainer<class_BoxContainer>` **<** :ref:`Container<class_Container>` **<** :ref:`Control<class_Control>` **<** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-Editor dock for managing files in the project.
+Godot editor's dock for managing files in the project.
 
 .. rst-class:: classref-introduction-group
 
@@ -21,7 +21,7 @@ Description
 
 This class is available only in :ref:`EditorPlugin<class_EditorPlugin>`\ s and can't be instantiated. You can access it using :ref:`EditorInterface.get_file_system_dock<class_EditorInterface_method_get_file_system_dock>`.
 
-While FileSystemDock doesn't expose any methods for file manipulation, you can listen for various file-related signals.
+While **FileSystemDock** doesn't expose any methods for file manipulation, it can listen for various file-related signals.
 
 .. rst-class:: classref-reftable-group
 

classes/class_float.rst

@@ -10,18 +10,18 @@
 float
 =====
 
-Float built-in type.
+A built-in type for floating point numbers.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-The **float** built-in type is a 64-bit double-precision floating-point number, equivalent to ``double`` in C++. This type has 14 reliable decimal digits of precision. The **float** type can be stored in :ref:`Variant<class_Variant>`, which is the generic type used by the engine. The maximum value of **float** is approximately ``1.79769e308``, and the minimum is approximately ``-1.79769e308``.
+The **float** built-in type is a 64-bit double-precision floating-point number, equivalent to ``double`` in C++. This type has 14 reliable decimal digits of precision. The maximum value of **float** is approximately ``1.79769e308``, and the minimum is approximately ``-1.79769e308``.
 
 Many methods and properties in the engine use 32-bit single-precision floating-point numbers instead, equivalent to ``float`` in C++, which have 6 reliable decimal digits of precision. For data structures such as :ref:`Vector2<class_Vector2>` and :ref:`Vector3<class_Vector3>`, Godot uses 32-bit floating-point numbers by default, but it can be changed to use 64-bit doubles if Godot is compiled with the ``precision=double`` option.
 
-Math done using the **float** type is not guaranteed to be exact or deterministic, and will often result in small errors. You should usually use the :ref:`@GlobalScope.is_equal_approx<class_@GlobalScope_method_is_equal_approx>` and :ref:`@GlobalScope.is_zero_approx<class_@GlobalScope_method_is_zero_approx>` methods instead of ``==`` to compare **float** values for equality.
+Math done using the **float** type is not guaranteed to be exact and will often result in small errors. You should usually use the :ref:`@GlobalScope.is_equal_approx<class_@GlobalScope_method_is_equal_approx>` and :ref:`@GlobalScope.is_zero_approx<class_@GlobalScope_method_is_zero_approx>` methods instead of ``==`` to compare **float** values for equality.
 
 .. rst-class:: classref-introduction-group
 
@@ -200,6 +200,8 @@ Operator Descriptions
 
 Returns ``true`` if two floats are different from each other.
 
+\ **Note:** :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` doesn't behave the same as other numbers. Therefore, the results from this operator may not be accurate if NaNs are included.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -222,7 +224,7 @@ Returns ``true`` if the integer has different value than the float.
 
 :ref:`Color<class_Color>` **operator *** **(** :ref:`Color<class_Color>` right **)**
 
-Multiplies each component of the :ref:`Color<class_Color>` by the given **float**.
+Multiplies each component of the :ref:`Color<class_Color>`, including the alpha, by the given **float**.
 
 ::
 
@@ -468,6 +470,8 @@ Divides a **float** by an :ref:`int<class_int>`. The result is a **float**.
 
 Returns ``true`` if the left float is less than the right one.
 
+\ **Note:** :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` doesn't behave the same as other numbers. Therefore, the results from this operator may not be accurate if NaNs are included.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -492,6 +496,8 @@ Returns ``true`` if this **float** is less than the given :ref:`int<class_int>`.
 
 Returns ``true`` if the left float is less than or equal to the right one.
 
+\ **Note:** :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` doesn't behave the same as other numbers. Therefore, the results from this operator may not be accurate if NaNs are included.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -518,6 +524,8 @@ Returns ``true`` if both floats are exactly equal.
 
 \ **Note:** Due to floating-point precision errors, consider using :ref:`@GlobalScope.is_equal_approx<class_@GlobalScope_method_is_equal_approx>` or :ref:`@GlobalScope.is_zero_approx<class_@GlobalScope_method_is_zero_approx>` instead, which are more reliable.
 
+\ **Note:** :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` doesn't behave the same as other numbers. Therefore, the results from this operator may not be accurate if NaNs are included.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -542,6 +550,8 @@ Returns ``true`` if the **float** and the given :ref:`int<class_int>` are equal.
 
 Returns ``true`` if the left float is greater than the right one.
 
+\ **Note:** :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` doesn't behave the same as other numbers. Therefore, the results from this operator may not be accurate if NaNs are included.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -566,6 +576,8 @@ Returns ``true`` if this **float** is greater than the given :ref:`int<class_int
 
 Returns ``true`` if the left float is greater than or equal to the right one.
 
+\ **Note:** :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` doesn't behave the same as other numbers. Therefore, the results from this operator may not be accurate if NaNs are included.
+
 .. rst-class:: classref-item-separator
 
 ----

classes/class_flowcontainer.rst

@@ -14,16 +14,21 @@ FlowContainer
 
 **Inherited By:** :ref:`HFlowContainer<class_HFlowContainer>`, :ref:`VFlowContainer<class_VFlowContainer>`
 
-Base class for flow containers.
+A container that arranges its child controls horizontally or vertically and wraps them around at the borders.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Arranges child :ref:`Control<class_Control>` nodes vertically or horizontally in a left-to-right or top-to-bottom flow.
+A container that arranges its child controls horizontally or vertically and wraps them around at the borders. This is similar to how text in a book wraps around when no more words can fit on a line.
 
-A line is filled with :ref:`Control<class_Control>` nodes until no more fit on the same line, similar to text in an autowrapped label.
+.. rst-class:: classref-introduction-group
+
+Tutorials
+---------
+
+- :doc:`Using Containers <../tutorials/ui/gui_containers>`
 
 .. rst-class:: classref-reftable-group
 

classes/class_font.rst

@@ -14,14 +14,14 @@ Font
 
 **Inherited By:** :ref:`FontFile<class_FontFile>`, :ref:`FontVariation<class_FontVariation>`, :ref:`SystemFont<class_SystemFont>`
 
-Base class for fonts and font variations.
+Abstract base class for fonts and font variations.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Font is the abstract base class for font, so it shouldn't be used directly. Other types of fonts inherit from it.
+Abstract base class for different font types. It has methods for drawing text and font character introspection.
 
 .. rst-class:: classref-reftable-group
 

classes/class_fontfile.rst

@@ -12,7 +12,7 @@ FontFile
 
 **Inherits:** :ref:`Font<class_Font>` **<** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
 
-Font source data and prerendered glyph cache, imported from dynamic or bitmap font.
+Holds font source data and prerendered glyph cache, imported from a dynamic or a bitmap font.
 
 .. rst-class:: classref-introduction-group
 
@@ -35,9 +35,9 @@ Supported font formats:
 
 \ **Note:** A character is a symbol that represents an item (letter, digit etc.) in an abstract way.
 
-\ **Note:** A glyph is a bitmap or shape used to draw one or more characters in a context-dependent manner. Glyph indices are bound to the specific font data source.
+\ **Note:** A glyph is a bitmap or a shape used to draw one or more characters in a context-dependent manner. Glyph indices are bound to the specific font data source.
 
-\ **Note:** If a none of the font data sources contain glyphs for a character used in a string, the character in question will be replaced with a box displaying its hexadecimal code.
+\ **Note:** If none of the font data sources contain glyphs for a character used in a string, the character in question will be replaced with a box displaying its hexadecimal code.
 
 
 .. tabs::

classes/class_fontvariation.rst

@@ -12,14 +12,14 @@ FontVariation
 
 **Inherits:** :ref:`Font<class_Font>` **<** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
 
-Variation of the :ref:`Font<class_Font>`.
+A variation of a font with additional settings.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-OpenType variations, simulated bold / slant, and additional font settings like OpenType features and extra spacing.
+Provides OpenType variations, simulated bold / slant, and additional font settings like OpenType features and extra spacing.
 
 To use simulated bold font variant:
 

classes/class_generic6dofjoint3d.rst

@@ -12,14 +12,16 @@ Generic6DOFJoint3D
 
 **Inherits:** :ref:`Joint3D<class_Joint3D>` **<** :ref:`Node3D<class_Node3D>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-The generic 6-degrees-of-freedom joint can implement a variety of joint types by locking certain axes' rotation or translation.
+A physics joint that allows for complex movement and rotation between two 3D physics bodies.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-The first 3 DOF axes are linear axes, which represent translation of Bodies, and the latter 3 DOF axes represent the angular motion. Each axis can be either locked, or limited.
+The **Generic6DOFJoint3D** (6 Degrees Of Freedom) joint allows for implementing custom types of joints by locking the rotation and translation of certain axes.
+
+The first 3 DOF represent the linear motion of the physics bodies and the last 3 DOF represent the angular motion of the physics bodies. Each axis can be either locked, or limited.
 
 .. rst-class:: classref-reftable-group
 

classes/class_geometry2d.rst

@@ -12,14 +12,14 @@ Geometry2D
 
 **Inherits:** :ref:`Object<class_Object>`
 
-Helper node to calculate generic geometry operations in 2D space.
+Provides methods for some common 2D geometric operations.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-Geometry2D provides users with a set of helper functions to create geometric shapes, compute intersections between shapes, and process various other geometric operations.
+Provides a set of helper functions to create geometric shapes, compute intersections between shapes, and process various other geometric operations in 2D.
 
 .. rst-class:: classref-reftable-group