classref: Sync with current master branch (dad6c77)

classes/[email protected]

@@ -6677,7 +6677,7 @@ Given a ``seed``, returns a :ref:`PackedInt64Array<class_PackedInt64Array>` of s
 
 :ref:`float<class_float>` **randf**\ (\ )
 
-Returns a random floating point value between ``0.0`` and ``1.0`` (inclusive).
+Returns a random floating-point value between ``0.0`` and ``1.0`` (inclusive).
 
 
 .. tabs::
@@ -6702,7 +6702,7 @@ Returns a random floating point value between ``0.0`` and ``1.0`` (inclusive).
 
 :ref:`float<class_float>` **randf_range**\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`\ )
 
-Returns a random floating point value between ``from`` and ``to`` (inclusive).
+Returns a random floating-point value between ``from`` and ``to`` (inclusive).
 
 
 .. tabs::
@@ -6729,7 +6729,9 @@ Returns a random floating point value between ``from`` and ``to`` (inclusive).
 
 :ref:`float<class_float>` **randfn**\ (\ mean\: :ref:`float<class_float>`, deviation\: :ref:`float<class_float>`\ )
 
-Returns a normally-distributed pseudo-random floating point value using Box-Muller transform with the specified ``mean`` and a standard ``deviation``. This is also called Gaussian distribution.
+Returns a `normally-distributed <https://en.wikipedia.org/wiki/Normal_distribution>`__, pseudo-random floating-point value from the specified ``mean`` and a standard ``deviation``. This is also known as a Gaussian distribution.
+
+\ **Note:** This method uses the `Box-Muller transform <https://en.wikipedia.org/wiki/Box%E2%80%93Muller_transform>`__ algorithm.
 
 .. rst-class:: classref-item-separator
 
@@ -7079,7 +7081,7 @@ Compared to :ref:`ease<class_@GlobalScope_method_ease>` with a curve value of ``
 
 :ref:`Variant<class_Variant>` **snapped**\ (\ x\: :ref:`Variant<class_Variant>`, step\: :ref:`Variant<class_Variant>`\ )
 
-Returns the multiple of ``step`` that is the closest to ``x``. This can also be used to round a floating point number to an arbitrary number of decimals.
+Returns the multiple of ``step`` that is the closest to ``x``. This can also be used to round a floating-point number to an arbitrary number of decimals.
 
 The returned value is the same type of :ref:`Variant<class_Variant>` as ``step``. 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>`.
 
@@ -7104,7 +7106,7 @@ See also :ref:`ceil<class_@GlobalScope_method_ceil>`, :ref:`floor<class_@GlobalS
 
 :ref:`float<class_float>` **snappedf**\ (\ x\: :ref:`float<class_float>`, step\: :ref:`float<class_float>`\ )
 
-Returns the multiple of ``step`` that is the closest to ``x``. This can also be used to round a floating point number to an arbitrary number of decimals.
+Returns the multiple of ``step`` that is the closest to ``x``. This can also be used to round a floating-point number to an arbitrary number of decimals.
 
 A type-safe version of :ref:`snapped<class_@GlobalScope_method_snapped>`, returning a :ref:`float<class_float>`.
 

classes/class_basis.rst

@@ -17,7 +17,7 @@ A 3×3 matrix for representing 3D rotation and scale.
 Description
 -----------
 
-The **Basis** built-in :ref:`Variant<class_Variant>` type is a 3x3 `matrix <https://en.wikipedia.org/wiki/Matrix_(mathematics)>`__ used to represent 3D rotation, scale, and shear. It is frequently used within a :ref:`Transform3D<class_Transform3D>`.
+The **Basis** built-in :ref:`Variant<class_Variant>` type is a 3×3 `matrix <https://en.wikipedia.org/wiki/Matrix_(mathematics)>`__ used to represent 3D rotation, scale, and shear. It is frequently used within a :ref:`Transform3D<class_Transform3D>`.
 
 A **Basis** is composed by 3 axis vectors, each representing a column of the matrix: :ref:`x<class_Basis_property_x>`, :ref:`y<class_Basis_property_y>`, and :ref:`z<class_Basis_property_z>`. The length of each axis (:ref:`Vector3.length<class_Vector3_method_length>`) influences the basis's scale, while the direction of all axes influence the rotation. Usually, these axes are perpendicular to one another. However, when you rotate any axis individually, the basis becomes sheared. Applying a sheared basis to a 3D model will make the model appear distorted.
 

classes/class_canvasitem.rst

@@ -388,7 +388,7 @@ Texture will repeat normally.
 
 :ref:`TextureRepeat<enum_CanvasItem_TextureRepeat>` **TEXTURE_REPEAT_MIRROR** = ``3``
 
-Texture will repeat in a 2x2 tiled mode, where elements at even positions are mirrored.
+Texture will repeat in a 2×2 tiled mode, where elements at even positions are mirrored.
 
 .. _class_CanvasItem_constant_TEXTURE_REPEAT_MAX:
 

classes/class_codeedit.rst

@@ -453,7 +453,7 @@ The option is local to the location of the code completion query - e.g. a local
 
 :ref:`CodeCompletionLocation<enum_CodeEdit_CodeCompletionLocation>` **LOCATION_PARENT_MASK** = ``256``
 
-The option is from the containing class or a parent class, relative to the location of the code completion query. Perform a bitwise OR with the class depth (e.g. 0 for the local class, 1 for the parent, 2 for the grandparent, etc) to store the depth of an option in the class or a parent class.
+The option is from the containing class or a parent class, relative to the location of the code completion query. Perform a bitwise OR with the class depth (e.g. ``0`` for the local class, ``1`` for the parent, ``2`` for the grandparent, etc.) to store the depth of an option in the class or a parent class.
 
 .. _class_CodeEdit_constant_LOCATION_OTHER_USER_CODE:
 
@@ -899,11 +899,9 @@ Submits an item to the queue of potential candidates for the autocomplete menu.
 
 |void| **add_comment_delimiter**\ (\ start_key\: :ref:`String<class_String>`, end_key\: :ref:`String<class_String>`, line_only\: :ref:`bool<class_bool>` = false\ )
 
-Adds a comment delimiter.
+Adds a comment delimiter from ``start_key`` to ``end_key``. Both keys should be symbols, and ``start_key`` must not be shared with other delimiters.
 
-Both the start and end keys must be symbols. Only the start key has to be unique.
-
-\ ``line_only`` denotes if the region should continue until the end of the line or carry over on to the next line. If the end key is blank this is automatically set to ``true``.
+If ``line_only`` is ``true`` or ``end_key`` is an empty :ref:`String<class_String>`, the region does not carry over to the next line.
 
 .. rst-class:: classref-item-separator
 
@@ -915,11 +913,9 @@ Both the start and end keys must be symbols. Only the start key has to be unique
 
 |void| **add_string_delimiter**\ (\ start_key\: :ref:`String<class_String>`, end_key\: :ref:`String<class_String>`, line_only\: :ref:`bool<class_bool>` = false\ )
 
-Adds a string delimiter.
-
-Both the start and end keys must be symbols. Only the start key has to be unique.
+Defines a string delimiter from ``start_key`` to ``end_key``. Both keys should be symbols, and ``start_key`` must not be shared with other delimiters.
 
-\ ``line_only`` denotes if the region should continue until the end of the line or carry over on to the next line. If the end key is blank this is automatically set to ``true``.
+If ``line_only`` is ``true`` or ``end_key`` is an empty :ref:`String<class_String>`, the region does not carry over to the next line.
 
 .. rst-class:: classref-item-separator
 

classes/class_codehighlighter.rst

@@ -222,11 +222,9 @@ Method Descriptions
 
 |void| **add_color_region**\ (\ start_key\: :ref:`String<class_String>`, end_key\: :ref:`String<class_String>`, color\: :ref:`Color<class_Color>`, line_only\: :ref:`bool<class_bool>` = false\ )
 
-Adds a color region such as comments or strings.
+Adds a color region (such as for comments or strings) from ``start_key`` to ``end_key``. Both keys should be symbols, and ``start_key`` must not be shared with other delimiters.
 
-Both the start and end keys must be symbols. Only the start key has to be unique.
-
-\ ``line_only`` denotes if the region should continue until the end of the line or carry over on to the next line. If the end key is blank this is automatically set to ``true``.
+If ``line_only`` is ``true`` or ``end_key`` is an empty :ref:`String<class_String>`, the region does not carry over to the next line.
 
 .. rst-class:: classref-item-separator
 

classes/class_compositor.rst

@@ -14,14 +14,14 @@ Compositor
 
 **Inherits:** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
 
-The compositor resource holds the configuration with which rendering of a viewport can be customised.
+Stores attributes used to customize how a Viewport is rendered.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-The compositor resource holds the configuration with which rendering of a viewport can be customised.
+The compositor resource stores attributes used to customize how a :ref:`Viewport<class_Viewport>` is rendered.
 
 .. rst-class:: classref-reftable-group
 

classes/class_cubemaparray.rst

@@ -19,13 +19,11 @@ An array of :ref:`Cubemap<class_Cubemap>`\ s, stored together and with a single
 Description
 -----------
 
-**CubemapArray**\ s are made of an array of :ref:`Cubemap<class_Cubemap>`\ s. Like :ref:`Cubemap<class_Cubemap>`\ s, they are made of multiple textures, the amount of which must be divisible by 6 (one for each face of the cube). The primary benefit of **CubemapArray**\ s is that they can be accessed in shader code using a single texture reference. In other words, you can pass multiple :ref:`Cubemap<class_Cubemap>`\ s into a shader using a single **CubemapArray**.
+**CubemapArray**\ s are made of an array of :ref:`Cubemap<class_Cubemap>`\ s. Like :ref:`Cubemap<class_Cubemap>`\ s, they are made of multiple textures, the amount of which must be divisible by 6 (one for each face of the cube).
 
-Moreover, :ref:`Cubemap<class_Cubemap>`\ s are allocated in adjacent cache regions on the GPU. This makes **CubemapArray**\ s the most efficient way to store multiple :ref:`Cubemap<class_Cubemap>`\ s.
+The primary benefit of **CubemapArray**\ s is that they can be accessed in shader code using a single texture reference. In other words, you can pass multiple :ref:`Cubemap<class_Cubemap>`\ s into a shader using a single **CubemapArray**. :ref:`Cubemap<class_Cubemap>`\ s are allocated in adjacent cache regions on the GPU, which makes **CubemapArray**\ s the most efficient way to store multiple :ref:`Cubemap<class_Cubemap>`\ s.
 
-Internally, Godot uses **CubemapArray**\ s for many effects, including the :ref:`Sky<class_Sky>` if you set :ref:`ProjectSettings.rendering/reflections/sky_reflections/texture_array_reflections<class_ProjectSettings_property_rendering/reflections/sky_reflections/texture_array_reflections>` to ``true``.
-
-To create such a texture file yourself, reimport your image files using the import presets of the File System dock.
+\ **Note:** Godot uses **CubemapArray**\ s internally for many effects, including the :ref:`Sky<class_Sky>` if you set :ref:`ProjectSettings.rendering/reflections/sky_reflections/texture_array_reflections<class_ProjectSettings_property_rendering/reflections/sky_reflections/texture_array_reflections>` to ``true``. To create such a texture file yourself, reimport your image files using the import presets of the File System dock.
 
 \ **Note:** **CubemapArray** is not supported in the OpenGL 3 rendering backend.
 

classes/class_displayserver.rst

@@ -1582,9 +1582,9 @@ Returns the default mouse cursor shape set by :ref:`cursor_set_shape<class_Displ
 
 |void| **cursor_set_custom_image**\ (\ cursor\: :ref:`Resource<class_Resource>`, shape\: :ref:`CursorShape<enum_DisplayServer_CursorShape>` = 0, hotspot\: :ref:`Vector2<class_Vector2>` = Vector2(0, 0)\ )
 
-Sets a custom mouse cursor image for the defined ``shape``. This means the user's operating system and mouse cursor theme will no longer influence the mouse cursor's appearance. The image must be ``256x256`` or smaller for correct appearance. ``hotspot`` can optionally be set to define the area where the cursor will click. By default, ``hotspot`` is set to ``Vector2(0, 0)``, which is the top-left corner of the image. See also :ref:`cursor_set_shape<class_DisplayServer_method_cursor_set_shape>`.
+Sets a custom mouse cursor image for the given ``shape``. This means the user's operating system and mouse cursor theme will no longer influence the mouse cursor's appearance.
 
-\ ``cursor`` can be either :ref:`Texture2D<class_Texture2D>` or :ref:`Image<class_Image>`.
+\ ``cursor`` can be either a :ref:`Texture2D<class_Texture2D>` or an :ref:`Image<class_Image>`, and it should not be larger than 256×256 to display correctly. Optionally, ``hotspot`` can be set to offset the image's position relative to the click point. By default, ``hotspot`` is set to the top-left corner of the image. See also :ref:`cursor_set_shape<class_DisplayServer_method_cursor_set_shape>`.
 
 .. rst-class:: classref-item-separator
 

classes/class_editorexportplatformweb.rst

@@ -349,9 +349,9 @@ If ``true`` enables :ref:`GDExtension<class_GDExtension>` support for this web b
 
 :ref:`bool<class_bool>` **variant/thread_support**
 
-If enabled, the exported game will support threads. It requires `a "cross-origin isolated" website <https://web.dev/articles/coop-coep>`__, which can be difficult to setup and brings some limitations (e.g. not being able to communicate with third-party websites).
+If ``true``, the exported game will support threads. It requires `a "cross-origin isolated" website <https://web.dev/articles/coop-coep>`__, which may be difficult to set up and is limited for security reasons (such as not being able to communicate with third-party websites).
 
-If disabled, the exported game will not support threads. As a result, it is more prone to performance and audio issues, but will only require to be run on a HTTPS website.
+If ``false``, the exported game will not support threads. As a result, it is more prone to performance and audio issues, but will only require to be run on a HTTPS website.
 
 .. rst-class:: classref-item-separator
 

classes/class_editorplugin.rst

@@ -835,7 +835,7 @@ Override this method in your plugin to return a :ref:`Texture2D<class_Texture2D>
 
 For main screen plugins, this appears at the top of the screen, to the right of the "2D", "3D", "Script", and "AssetLib" buttons.
 
-Ideally, the plugin icon should be white with a transparent background and 16x16 pixels in size.
+Ideally, the plugin icon should be white with a transparent background and 16×16 pixels in size.
 
 
 .. tabs::
@@ -1093,7 +1093,9 @@ Adds a script at ``path`` to the Autoload list as ``name``.
 
 :ref:`Button<class_Button>` **add_control_to_bottom_panel**\ (\ control\: :ref:`Control<class_Control>`, title\: :ref:`String<class_String>`\ )
 
-Adds a control to the bottom panel (together with Output, Debug, Animation, etc). Returns a reference to the button added. It's up to you to hide/show the button when needed. When your plugin is deactivated, make sure to remove your custom control with :ref:`remove_control_from_bottom_panel<class_EditorPlugin_method_remove_control_from_bottom_panel>` and free it with :ref:`Node.queue_free<class_Node_method_queue_free>`.
+Adds a control to the bottom panel (together with **Output**, **Debug**, **Animation**, etc.). Returns the button added to the tab bar. It's up to you to manage the button's visibility as needed.
+
+When your plugin is deactivated, make sure to remove your custom control with :ref:`remove_control_from_bottom_panel<class_EditorPlugin_method_remove_control_from_bottom_panel>` and free it with :ref:`Node.queue_free<class_Node_method_queue_free>`.
 
 .. rst-class:: classref-item-separator
 

classes/class_editorselection.rst

@@ -101,7 +101,7 @@ Clear the selection.
 
 :ref:`Array<class_Array>`\[:ref:`Node<class_Node>`\] **get_selected_nodes**\ (\ )
 
-Gets the list of selected nodes.
+Returns the list of selected nodes.
 
 .. rst-class:: classref-item-separator
 
@@ -113,7 +113,7 @@ Gets the list of selected nodes.
 
 :ref:`Array<class_Array>`\[:ref:`Node<class_Node>`\] **get_transformable_selected_nodes**\ (\ )
 
-Gets the list of selected nodes, optimized for transform operations (i.e. moving them, rotating, etc). This list avoids situations where a node is selected and also child/grandchild.
+Returns the list of selected nodes, optimized for transform operations (i.e. moving them, rotating, etc.). This list can be used to avoid situations where a node is selected and is also a child/grandchild.
 
 .. rst-class:: classref-item-separator
 

classes/class_engine.rst

@@ -123,19 +123,19 @@ Property Descriptions
 - |void| **set_max_fps**\ (\ value\: :ref:`int<class_int>`\ )
 - :ref:`int<class_int>` **get_max_fps**\ (\ )
 
-The maximum number of frames per second (FPS) that can be rendered. A value of ``0`` means the framerate is uncapped.
+The maximum number of frames that can be rendered every second (FPS). A value of ``0`` means the framerate is uncapped.
 
 Limiting the FPS can be useful to reduce the host machine's power consumption, which reduces heat, noise emissions, and improves battery life.
 
-If :ref:`ProjectSettings.display/window/vsync/vsync_mode<class_ProjectSettings_property_display/window/vsync/vsync_mode>` is ``Enabled`` or ``Adaptive``, the setting takes precedence and the max FPS number cannot exceed the monitor's refresh rate.
+If :ref:`ProjectSettings.display/window/vsync/vsync_mode<class_ProjectSettings_property_display/window/vsync/vsync_mode>` is **Enabled** or **Adaptive**, the setting takes precedence and the max FPS number cannot exceed the monitor's refresh rate.
 
-If :ref:`ProjectSettings.display/window/vsync/vsync_mode<class_ProjectSettings_property_display/window/vsync/vsync_mode>` is ``Enabled``, on monitors with variable refresh rate enabled (G-Sync/FreeSync), using a FPS limit a few frames lower than the monitor's refresh rate will `reduce input lag while avoiding tearing <https://blurbusters.com/howto-low-lag-vsync-on/>`__.
+If :ref:`ProjectSettings.display/window/vsync/vsync_mode<class_ProjectSettings_property_display/window/vsync/vsync_mode>` is **Enabled**, on monitors with variable refresh rate enabled (G-Sync/FreeSync), using a FPS limit a few frames lower than the monitor's refresh rate will `reduce input lag while avoiding tearing <https://blurbusters.com/howto-low-lag-vsync-on/>`__.
 
 See also :ref:`physics_ticks_per_second<class_Engine_property_physics_ticks_per_second>` and :ref:`ProjectSettings.application/run/max_fps<class_ProjectSettings_property_application/run/max_fps>`.
 
 \ **Note:** The actual number of frames per second may still be below this value if the CPU or GPU cannot keep up with the project's logic and rendering.
 
-\ **Note:** If :ref:`ProjectSettings.display/window/vsync/vsync_mode<class_ProjectSettings_property_display/window/vsync/vsync_mode>` is ``Disabled``, limiting the FPS to a high value that can be consistently reached on the system can reduce input lag compared to an uncapped framerate. Since this works by ensuring the GPU load is lower than 100%, this latency reduction is only effective in GPU-bottlenecked scenarios, not CPU-bottlenecked scenarios.
+\ **Note:** If :ref:`ProjectSettings.display/window/vsync/vsync_mode<class_ProjectSettings_property_display/window/vsync/vsync_mode>` is **Disabled**, limiting the FPS to a high value that can be consistently reached on the system can reduce input lag compared to an uncapped framerate. Since this works by ensuring the GPU load is lower than 100%, this latency reduction is only effective in GPU-bottlenecked scenarios, not CPU-bottlenecked scenarios.
 
 .. rst-class:: classref-item-separator
 

classes/class_float.rst

@@ -10,7 +10,7 @@
 float
 =====
 
-A built-in type for floating point numbers.
+A built-in type for floating-point numbers.
 
 .. rst-class:: classref-introduction-group
 

classes/class_image.rst

@@ -513,7 +513,7 @@ The `S3TC <https://en.wikipedia.org/wiki/S3_Texture_Compression>`__ texture form
 
 :ref:`Format<enum_Image_Format>` **FORMAT_ASTC_4x4** = ``35``
 
-`Adaptive Scalable Texture Compression <https://en.wikipedia.org/wiki/Adaptive_scalable_texture_compression>`__. This implements the 4x4 (high quality) mode.
+`Adaptive Scalable Texture Compression <https://en.wikipedia.org/wiki/Adaptive_scalable_texture_compression>`__. This implements the 4×4 (high quality) mode.
 
 .. _class_Image_constant_FORMAT_ASTC_4x4_HDR:
 
@@ -529,7 +529,7 @@ Same format as :ref:`FORMAT_ASTC_4x4<class_Image_constant_FORMAT_ASTC_4x4>`, but
 
 :ref:`Format<enum_Image_Format>` **FORMAT_ASTC_8x8** = ``37``
 
-`Adaptive Scalable Texture Compression <https://en.wikipedia.org/wiki/Adaptive_scalable_texture_compression>`__. This implements the 8x8 (low quality) mode.
+`Adaptive Scalable Texture Compression <https://en.wikipedia.org/wiki/Adaptive_scalable_texture_compression>`__. This implements the 8×8 (low quality) mode.
 
 .. _class_Image_constant_FORMAT_ASTC_8x8_HDR:
 
@@ -805,7 +805,7 @@ enum **ASTCFormat**:
 
 :ref:`ASTCFormat<enum_Image_ASTCFormat>` **ASTC_FORMAT_4x4** = ``0``
 
-Hint to indicate that the high quality 4x4 ASTC compression format should be used.
+Hint to indicate that the high quality 4×4 ASTC compression format should be used.
 
 .. _class_Image_constant_ASTC_FORMAT_8x8:
 
@@ -813,7 +813,7 @@ Hint to indicate that the high quality 4x4 ASTC compression format should be use
 
 :ref:`ASTCFormat<enum_Image_ASTCFormat>` **ASTC_FORMAT_8x8** = ``1``
 
-Hint to indicate that the low quality 8x8 ASTC compression format should be used.
+Hint to indicate that the low quality 8×8 ASTC compression format should be used.
 
 .. rst-class:: classref-section-separator
 

classes/class_input.rst

@@ -276,7 +276,7 @@ Cross cursor. Typically appears over regions in which a drawing operation can be
 
 :ref:`CursorShape<enum_Input_CursorShape>` **CURSOR_WAIT** = ``4``
 
-Wait cursor. Indicates that the application is busy performing an operation. This cursor shape denotes that the application isn't usable during the operation (e.g. something is blocking its main thread).
+Wait cursor. Indicates that the application is busy performing an operation, and that it cannot be used during the operation (e.g. something is blocking its main thread).
 
 .. _class_Input_constant_CURSOR_BUSY:
 
@@ -284,7 +284,7 @@ Wait cursor. Indicates that the application is busy performing an operation. Thi
 
 :ref:`CursorShape<enum_Input_CursorShape>` **CURSOR_BUSY** = ``5``
 
-Busy cursor. Indicates that the application is busy performing an operation. This cursor shape denotes that the application is still usable during the operation.
+Busy cursor. Indicates that the application is busy performing an operation, and that it is still usable during the operation.
 
 .. _class_Input_constant_CURSOR_DRAG:
 

classes/class_int.rst

@@ -21,7 +21,7 @@ Signed 64-bit integer type. This means that it can take values from ``-2^63`` to
 
 \ **int**\ s can be automatically converted to :ref:`float<class_float>`\ s when necessary, for example when passing them as arguments in functions. The :ref:`float<class_float>` will be as close to the original integer as possible.
 
-Likewise, :ref:`float<class_float>`\ s can be automatically converted into **int**\ s. This will truncate the :ref:`float<class_float>`, discarding anything after the floating point.
+Likewise, :ref:`float<class_float>`\ s can be automatically converted into **int**\ s. This will truncate the :ref:`float<class_float>`, discarding anything after the floating-point.
 
 \ **Note:** In a boolean context, an **int** will evaluate to ``false`` if it equals ``0``, and to ``true`` otherwise.
 

classes/class_meshconvexdecompositionsettings.rst

@@ -108,7 +108,7 @@ Property Descriptions
 - |void| **set_convex_hull_approximation**\ (\ value\: :ref:`bool<class_bool>`\ )
 - :ref:`bool<class_bool>` **get_convex_hull_approximation**\ (\ )
 
-If enabled uses approximation for computing convex hulls.
+If ``true``, uses approximation for computing convex hulls.
 
 .. rst-class:: classref-item-separator
 
@@ -227,7 +227,7 @@ Mode for the approximate convex decomposition.
 - |void| **set_normalize_mesh**\ (\ value\: :ref:`bool<class_bool>`\ )
 - :ref:`bool<class_bool>` **get_normalize_mesh**\ (\ )
 
-If enabled normalizes the mesh before applying the convex decomposition.
+If ``true``, normalizes the mesh before applying the convex decomposition.
 
 .. rst-class:: classref-item-separator
 
@@ -261,7 +261,7 @@ Controls the granularity of the search for the "best" clipping plane. Ranges fro
 - |void| **set_project_hull_vertices**\ (\ value\: :ref:`bool<class_bool>`\ )
 - :ref:`bool<class_bool>` **get_project_hull_vertices**\ (\ )
 
-If enabled projects output convex hull vertices onto original source mesh to increase floating point accuracy of the results.
+If ``true``, projects output convex hull vertices onto the original source mesh to increase floating-point accuracy of the results.
 
 .. rst-class:: classref-item-separator
 

classes/class_meshdatatool.rst

@@ -351,9 +351,7 @@ Vertex argument must be either 0, 1, or 2 because faces contain three vertices.
 
 :ref:`int<class_int>` **get_format**\ (\ ) |const|
 
-Returns the :ref:`Mesh<class_Mesh>`'s format. Format is an integer made up of :ref:`Mesh<class_Mesh>` format flags combined together. For example, a mesh containing both vertices and normals would return a format of ``3`` because :ref:`Mesh.ARRAY_FORMAT_VERTEX<class_Mesh_constant_ARRAY_FORMAT_VERTEX>` is ``1`` and :ref:`Mesh.ARRAY_FORMAT_NORMAL<class_Mesh_constant_ARRAY_FORMAT_NORMAL>` is ``2``.
-
-See :ref:`ArrayFormat<enum_Mesh_ArrayFormat>` for a list of format flags.
+Returns the :ref:`Mesh<class_Mesh>`'s format as a combination of the :ref:`ArrayFormat<enum_Mesh_ArrayFormat>` flags. For example, a mesh containing both vertices and normals would return a format of ``3`` because :ref:`Mesh.ARRAY_FORMAT_VERTEX<class_Mesh_constant_ARRAY_FORMAT_VERTEX>` is ``1`` and :ref:`Mesh.ARRAY_FORMAT_NORMAL<class_Mesh_constant_ARRAY_FORMAT_NORMAL>` is ``2``.
 
 .. rst-class:: classref-item-separator
 

classes/class_multimesh.rst

@@ -430,7 +430,7 @@ For the color to take effect, ensure that :ref:`use_colors<class_MultiMesh_prope
 
 |void| **set_instance_custom_data**\ (\ instance\: :ref:`int<class_int>`, custom_data\: :ref:`Color<class_Color>`\ )
 
-Sets custom data for a specific instance. Although :ref:`Color<class_Color>` is used, it is just a container for 4 floating point numbers.
+Sets custom data for a specific instance. ``custom_data`` is a :ref:`Color<class_Color>` type only to contain 4 floating-point numbers.
 
 For the custom data to be used, ensure that :ref:`use_custom_data<class_MultiMesh_property_use_custom_data>` is ``true``.
 

classes/class_navigationagent3d.rst

@@ -432,7 +432,7 @@ The height of the avoidance agent. Agents will ignore other agents or obstacles
 - |void| **set_keep_y_velocity**\ (\ value\: :ref:`bool<class_bool>`\ )
 - :ref:`bool<class_bool>` **get_keep_y_velocity**\ (\ )
 
-If ``true``, and the agent uses 2D avoidance, it will remember the set y-axis velocity and reapply it after the avoidance step. While 2D avoidance has no y-axis and simulates on a flat plane this setting can help mitigate the most obvious clipping on uneven 3D geometry.
+If ``true``, and the agent uses 2D avoidance, it will remember the set y-axis velocity and reapply it after the avoidance step. While 2D avoidance has no y-axis and simulates on a flat plane this setting can help to soften the most obvious clipping on uneven 3D geometry.
 
 .. rst-class:: classref-item-separator
 

classes/class_navigationmeshgenerator.rst

@@ -23,7 +23,7 @@ Description
 
 This class is responsible for creating and clearing 3D navigation meshes used as :ref:`NavigationMesh<class_NavigationMesh>` resources inside :ref:`NavigationRegion3D<class_NavigationRegion3D>`. The **NavigationMeshGenerator** has very limited to no use for 2D as the navigation mesh baking process expects 3D node types and 3D source geometry to parse.
 
-The entire navigation mesh baking is best done in a separate thread as the voxelization, collision tests and mesh optimization steps involved are very performance and time hungry operations.
+The entire navigation mesh baking is best done in a separate thread as the voxelization, collision tests and mesh optimization steps involved are very slow and performance-intensive operations.
 
 Navigation mesh baking happens in multiple steps and the result depends on 3D source geometry and properties of the :ref:`NavigationMesh<class_NavigationMesh>` resource. In the first step, starting from a root node and depending on :ref:`NavigationMesh<class_NavigationMesh>` properties all valid 3D source geometry nodes are collected from the :ref:`SceneTree<class_SceneTree>`. Second, all collected nodes are parsed for their relevant 3D geometry data and a combined 3D mesh is build. Due to the many different types of parsable objects, from normal :ref:`MeshInstance3D<class_MeshInstance3D>`\ s to :ref:`CSGShape3D<class_CSGShape3D>`\ s or various :ref:`CollisionObject3D<class_CollisionObject3D>`\ s, some operations to collect geometry data can trigger :ref:`RenderingServer<class_RenderingServer>` and :ref:`PhysicsServer3D<class_PhysicsServer3D>` synchronizations. Server synchronization can have a negative effect on baking time or framerate as it often involves :ref:`Mutex<class_Mutex>` locking for thread security. Many parsable objects and the continuous synchronization with other threaded Servers can increase the baking time significantly. On the other hand only a few but very large and complex objects will take some time to prepare for the Servers which can noticeably stall the next frame render. As a general rule the total number of parsable objects and their individual size and complexity should be balanced to avoid framerate issues or very long baking times. The combined mesh is then passed to the Recast Navigation Object to test the source geometry for walkable terrain suitable to :ref:`NavigationMesh<class_NavigationMesh>` agent properties by creating a voxel world around the meshes bounding area.
 

classes/class_navigationserver2d.rst

@@ -23,7 +23,7 @@ Description
 
 NavigationServer2D is the server that handles navigation maps, regions and agents. It does not handle A\* navigation from :ref:`AStar2D<class_AStar2D>` or :ref:`AStarGrid2D<class_AStarGrid2D>`.
 
-Maps are made up of regions, which are made of navigation polygons. Together, they define the traversable areas in the 2D world.
+Maps are divided into regions, which are composed of navigation polygons. Together, they define the traversable areas in the 2D world.
 
 \ **Note:** Most **NavigationServer2D** changes take effect after the next physics frame and not immediately. This includes all changes made to maps, regions or agents by navigation-related nodes in the scene tree or made through scripts.
 
@@ -600,7 +600,7 @@ Set the agent's ``avoidance_mask`` bitmask.
 
 Set the agent's ``avoidance_priority`` with a ``priority`` between 0.0 (lowest priority) to 1.0 (highest priority).
 
-The specified ``agent`` does not adjust the velocity for other agents that would match the ``avoidance_mask`` but have a lower `` avoidance_priority``. This in turn makes the other agents with lower priority adjust their velocities even more to avoid collision with this agent.
+The specified ``agent`` does not adjust the velocity for other agents that would match the ``avoidance_mask`` but have a lower ``avoidance_priority``. This in turn makes the other agents with lower priority adjust their velocities even more to avoid collision with this agent.
 
 .. rst-class:: classref-item-separator
 

classes/class_navigationserver3d.rst

@@ -23,7 +23,7 @@ Description
 
 NavigationServer3D is the server that handles navigation maps, regions and agents. It does not handle A\* navigation from :ref:`AStar3D<class_AStar3D>`.
 
-Maps are made up of regions, which are made of navigation meshes. Together, they define the navigable areas in the 3D world.
+Maps are divided into regions, which are composed of navigation meshes. Together, they define the navigable areas in the 3D world.
 
 \ **Note:** Most **NavigationServer3D** changes take effect after the next physics frame and not immediately. This includes all changes made to maps, regions or agents by navigation-related nodes in the scene tree or made through scripts.
 
@@ -761,7 +761,7 @@ Set the agent's ``avoidance_mask`` bitmask.
 
 Set the agent's ``avoidance_priority`` with a ``priority`` between 0.0 (lowest priority) to 1.0 (highest priority).
 
-The specified ``agent`` does not adjust the velocity for other agents that would match the ``avoidance_mask`` but have a lower `` avoidance_priority``. This in turn makes the other agents with lower priority adjust their velocities even more to avoid collision with this agent.
+The specified ``agent`` does not adjust the velocity for other agents that would match the ``avoidance_mask`` but have a lower ``avoidance_priority``. This in turn makes the other agents with lower priority adjust their velocities even more to avoid collision with this agent.
 
 .. rst-class:: classref-item-separator
 

classes/class_node3d.rst

@@ -293,7 +293,7 @@ Property Descriptions
 - |void| **set_basis**\ (\ value\: :ref:`Basis<class_Basis>`\ )
 - :ref:`Basis<class_Basis>` **get_basis**\ (\ )
 
-Direct access to the 3x3 basis of the :ref:`transform<class_Node3D_property_transform>` property.
+Basis of the :ref:`transform<class_Node3D_property_transform>` property. Represents the rotation, scale, and shear of this node.
 
 .. rst-class:: classref-item-separator
 

classes/class_openxraction.rst

@@ -19,7 +19,7 @@ An OpenXR action.
 Description
 -----------
 
-This resource defines an OpenXR action. Actions can be used both for inputs (buttons/joystick/trigger/etc) and outputs (haptics).
+This resource defines an OpenXR action. Actions can be used both for inputs (buttons, joysticks, triggers, etc.) and outputs (haptics).
 
 OpenXR performs automatic conversion between action type and input type whenever possible. An analog trigger bound to a boolean action will thus return ``false`` if the trigger is depressed and ``true`` if pressed fully.
 

classes/class_os.rst

@@ -1163,7 +1163,7 @@ Returns a string that is unique to the device.
 
 \ **Note:** This string may change without notice if the user reinstalls their operating system, upgrades it, or modifies their hardware. This means it should generally not be used to encrypt persistent data, as the data saved before an unexpected ID change would become inaccessible. The returned string may also be falsified using external programs, so do not rely on the string returned by this method for security purposes.
 
-\ **Note:** On Web, returns an empty string and generates an error, as this method cannot be implemented for security concerns.
+\ **Note:** On Web, returns an empty string and generates an error, as this method cannot be implemented for security reasons.
 
 .. rst-class:: classref-item-separator
 

classes/class_packedbytearray.rst

@@ -313,7 +313,7 @@ Returns the number of times an element is in the array.
 
 :ref:`float<class_float>` **decode_double**\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const|
 
-Decodes a 64-bit floating point number from the bytes starting at ``byte_offset``. Fails if the byte count is insufficient. Returns ``0.0`` if a valid number can't be decoded.
+Decodes a 64-bit floating-point number from the bytes starting at ``byte_offset``. Fails if the byte count is insufficient. Returns ``0.0`` if a valid number can't be decoded.
 
 .. rst-class:: classref-item-separator
 
@@ -325,7 +325,7 @@ Decodes a 64-bit floating point number from the bytes starting at ``byte_offset`
 
 :ref:`float<class_float>` **decode_float**\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const|
 
-Decodes a 32-bit floating point number from the bytes starting at ``byte_offset``. Fails if the byte count is insufficient. Returns ``0.0`` if a valid number can't be decoded.
+Decodes a 32-bit floating-point number from the bytes starting at ``byte_offset``. Fails if the byte count is insufficient. Returns ``0.0`` if a valid number can't be decoded.
 
 .. rst-class:: classref-item-separator
 
@@ -337,7 +337,7 @@ Decodes a 32-bit floating point number from the bytes starting at ``byte_offset`
 
 :ref:`float<class_float>` **decode_half**\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const|
 
-Decodes a 16-bit floating point number from the bytes starting at ``byte_offset``. Fails if the byte count is insufficient. Returns ``0.0`` if a valid number can't be decoded.
+Decodes a 16-bit floating-point number from the bytes starting at ``byte_offset``. Fails if the byte count is insufficient. Returns ``0.0`` if a valid number can't be decoded.
 
 .. rst-class:: classref-item-separator
 
@@ -513,7 +513,7 @@ Creates a copy of the array, and returns it.
 
 |void| **encode_double**\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`float<class_float>`\ )
 
-Encodes a 64-bit floating point number as bytes at the index of ``byte_offset`` bytes. The array must have at least 8 bytes of allocated space, starting at the offset.
+Encodes a 64-bit floating-point number as bytes at the index of ``byte_offset`` bytes. The array must have at least 8 bytes of allocated space, starting at the offset.
 
 .. rst-class:: classref-item-separator
 
@@ -525,7 +525,7 @@ Encodes a 64-bit floating point number as bytes at the index of ``byte_offset``
 
 |void| **encode_float**\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`float<class_float>`\ )
 
-Encodes a 32-bit floating point number as bytes at the index of ``byte_offset`` bytes. The array must have at least 4 bytes of space, starting at the offset.
+Encodes a 32-bit floating-point number as bytes at the index of ``byte_offset`` bytes. The array must have at least 4 bytes of space, starting at the offset.
 
 .. rst-class:: classref-item-separator
 
@@ -537,7 +537,7 @@ Encodes a 32-bit floating point number as bytes at the index of ``byte_offset``
 
 |void| **encode_half**\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`float<class_float>`\ )
 
-Encodes a 16-bit floating point number as bytes at the index of ``byte_offset`` bytes. The array must have at least 2 bytes of space, starting at the offset.
+Encodes a 16-bit floating-point number as bytes at the index of ``byte_offset`` bytes. The array must have at least 2 bytes of space, starting at the offset.
 
 .. rst-class:: classref-item-separator
 

classes/class_packetpeerudp.rst

@@ -80,7 +80,7 @@ If ``bind_address`` is set to ``"*"`` (default), the peer will be bound on all a
 
 If ``bind_address`` is set to ``"0.0.0.0"`` (for IPv4) or ``"::"`` (for IPv6), the peer will be bound to all available addresses matching that IP type.
 
-If ``bind_address`` is set to any valid address (e.g. ``"192.168.1.101"``, ``"::1"``, etc), the peer will only be bound to the interface with that addresses (or fail if no interface with the given address exists).
+If ``bind_address`` is set to any valid address (e.g. ``"192.168.1.101"``, ``"::1"``, etc.), the peer will only be bound to the interface with that address (or fail if no interface with the given address exists).
 
 .. rst-class:: classref-item-separator
 

classes/class_projection.rst

@@ -17,7 +17,7 @@ A 4×4 matrix for 3D projective transformations.
 Description
 -----------
 
-A 4x4 matrix used for 3D projective transformations. It can represent transformations such as translation, rotation, scaling, shearing, and perspective division. It consists of four :ref:`Vector4<class_Vector4>` columns.
+A 4×4 matrix used for 3D projective transformations. It can represent transformations such as translation, rotation, scaling, shearing, and perspective division. It consists of four :ref:`Vector4<class_Vector4>` columns.
 
 For purely linear transformations (translation, rotation, and scale), it is recommended to use :ref:`Transform3D<class_Transform3D>`, as it is more performant and requires less memory.
 

classes/class_projectsettings.rst

@@ -2770,7 +2770,7 @@ When enabled, using a property, enum, or function that was renamed since Godot 3
 
 :ref:`int<class_int>` **debug/gdscript/warnings/return_value_discarded** = ``0``
 
-When set to ``warn`` or ``error``, produces a warning or an error respectively when calling a function without using its return value (by assigning it to a variable or using it as a function argument). Such return values are sometimes used to denote possible errors using the :ref:`Error<enum_@GlobalScope_Error>` enum.
+When set to ``warn`` or ``error``, produces a warning or an error respectively when calling a function without using its return value (by assigning it to a variable or using it as a function argument). These return values are sometimes used to indicate possible errors using the :ref:`Error<enum_@GlobalScope_Error>` enum.
 
 .. rst-class:: classref-item-separator
 
@@ -3144,7 +3144,7 @@ If ``true``, enables specific shader warnings (see ``debug/shader_language/warni
 
 :ref:`bool<class_bool>` **debug/shader_language/warnings/float_comparison** = ``true``
 
-When set to ``true``, produces a warning when two floating point numbers are compared directly with the ``==`` operator or the ``!=`` operator.
+When set to ``true``, produces a warning when two floating-point numbers are compared directly with the ``==`` operator or the ``!=`` operator.
 
 .. rst-class:: classref-item-separator
 
@@ -6118,7 +6118,7 @@ Root node default layout direction.
 
 Specifies the :ref:`TextServer<class_TextServer>` to use. If left empty, the default will be used.
 
-"ICU / HarfBuzz / Graphite" is the most advanced text driver, supporting right-to-left typesetting and complex scripts (for languages like Arabic, Hebrew, etc). The "Fallback" text driver does not support right-to-left typesetting and complex scripts.
+"ICU / HarfBuzz / Graphite" is the most advanced text driver, supporting right-to-left typesetting and complex scripts (for languages like Arabic, Hebrew, etc.). The "Fallback" text driver does not support right-to-left typesetting and complex scripts.
 
 \ **Note:** The driver in use can be overridden at runtime via the ``--text-driver`` :doc:`command line argument <../tutorials/editor/command_line_tutorial>`.
 
@@ -11340,7 +11340,7 @@ If ``true``, the texture importer will import lossless textures using the PNG fo
 
 :ref:`bool<class_bool>` **rendering/textures/vram_compression/import_etc2_astc** = ``false``
 
-If ``true``, the texture importer will import VRAM-compressed textures using the Ericsson Texture Compression 2 algorithm for lower quality textures and normal maps and Adaptable Scalable Texture Compression algorithm for high quality textures (in 4x4 block size).
+If ``true``, the texture importer will import VRAM-compressed textures using the Ericsson Texture Compression 2 algorithm for lower quality textures and normal maps and Adaptable Scalable Texture Compression algorithm for high quality textures (in 4×4 block size).
 
 \ **Note:** This setting is an override. The texture importer will always import the format the host platform needs, even if this is set to ``false``.
 
@@ -11438,16 +11438,16 @@ The texture *must* use a lossless compression format so that colors can be match
 
 ::
 
-    - 1x1 = rgb(0, 0, 0)     - #000000
-    - 1x2 = rgb(0, 85, 0)    - #005500
-    - 2x1 = rgb(85, 0, 0)    - #550000
-    - 2x2 = rgb(85, 85, 0)   - #555500
-    - 2x4 = rgb(85, 170, 0)  - #55aa00
-    - 4x2 = rgb(170, 85, 0)  - #aa5500
-    - 4x4 = rgb(170, 170, 0) - #aaaa00
-    - 4x8 = rgb(170, 255, 0) - #aaff00 - Not supported on most hardware
-    - 8x4 = rgb(255, 170, 0) - #ffaa00 - Not supported on most hardware
-    - 8x8 = rgb(255, 255, 0) - #ffff00 - Not supported on most hardware
+    - 1×1 = rgb(0, 0, 0)     - #000000
+    - 1×2 = rgb(0, 85, 0)    - #005500
+    - 2×1 = rgb(85, 0, 0)    - #550000
+    - 2×2 = rgb(85, 85, 0)   - #555500
+    - 2×4 = rgb(85, 170, 0)  - #55aa00
+    - 4×2 = rgb(170, 85, 0)  - #aa5500
+    - 4×4 = rgb(170, 170, 0) - #aaaa00
+    - 4×8 = rgb(170, 255, 0) - #aaff00 - Not supported on most hardware
+    - 8×4 = rgb(255, 170, 0) - #ffaa00 - Not supported on most hardware
+    - 8×8 = rgb(255, 255, 0) - #ffff00 - Not supported on most hardware
 
 .. rst-class:: classref-item-separator
 

classes/class_randomnumbergenerator.rst

@@ -207,7 +207,9 @@ Returns a pseudo-random float between ``from`` and ``to`` (inclusive).
 
 :ref:`float<class_float>` **randfn**\ (\ mean\: :ref:`float<class_float>` = 0.0, deviation\: :ref:`float<class_float>` = 1.0\ )
 
-Returns a `normally-distributed <https://en.wikipedia.org/wiki/Normal_distribution>`__ pseudo-random number, using Box-Muller transform with the specified ``mean`` and a standard ``deviation``. This is also called Gaussian distribution.
+Returns a `normally-distributed <https://en.wikipedia.org/wiki/Normal_distribution>`__, pseudo-random floating-point number from the specified ``mean`` and a standard ``deviation``. This is also known as a Gaussian distribution.
+
+\ **Note:** This method uses the `Box-Muller transform <https://en.wikipedia.org/wiki/Box%E2%80%93Muller_transform>`__ algorithm.
 
 .. rst-class:: classref-item-separator
 

classes/class_refcounted.rst

@@ -29,7 +29,7 @@ Unlike other :ref:`Object<class_Object>` types, **RefCounted**\ s keep an intern
 
 In the vast majority of use cases, instantiating and using **RefCounted**-derived types is all you need to do. The methods provided in this class are only for advanced users, and can cause issues if misused.
 
-\ **Note:** In C#, reference-counted objects will not be freed instantly after they are no longer in use. Instead, garbage collection will run periodically and will free reference-counted objects that are no longer in use. This means that unused ones will linger on for a while before being removed.
+\ **Note:** In C#, reference-counted objects will not be freed instantly after they are no longer in use. Instead, garbage collection will run periodically and will free reference-counted objects that are no longer in use. This means that unused ones will remain in memory for a while before being removed.
 
 .. rst-class:: classref-introduction-group
 

classes/class_renderingserver.rst

@@ -9202,7 +9202,7 @@ Calculates and returns the axis-aligned bounding box that encloses all instances
 
 :ref:`PackedFloat32Array<class_PackedFloat32Array>` **multimesh_get_buffer**\ (\ multimesh\: :ref:`RID<class_RID>`\ ) |const|
 
-Returns the MultiMesh data (such as instance transforms, colors, etc). See :ref:`multimesh_set_buffer<class_RenderingServer_method_multimesh_set_buffer>` for a description of the returned data.
+Returns the MultiMesh data (such as instance transforms, colors, etc.). See :ref:`multimesh_set_buffer<class_RenderingServer_method_multimesh_set_buffer>` for details on the returned data.
 
 \ **Note:** If the buffer is in the engine's internal cache, it will have to be fetched from GPU memory and possibly decompressed. This means :ref:`multimesh_get_buffer<class_RenderingServer_method_multimesh_get_buffer>` is potentially a slow operation and should be avoided whenever possible.
 
@@ -11126,7 +11126,7 @@ Returns the viewport's last rendered frame.
 
 |void| **viewport_remove_canvas**\ (\ viewport\: :ref:`RID<class_RID>`, canvas\: :ref:`RID<class_RID>`\ )
 
-Detaches a viewport from a canvas and vice versa.
+Detaches a viewport from a canvas.
 
 .. rst-class:: classref-item-separator
 

classes/class_resource.rst

@@ -27,7 +27,7 @@ In GDScript, resources can loaded from disk by their :ref:`resource_path<class_R
 
 The engine keeps a global cache of all loaded resources, referenced by paths (see :ref:`ResourceLoader.has_cached<class_ResourceLoader_method_has_cached>`). A resource will be cached when loaded for the first time and removed from cache once all references are released. When a resource is cached, subsequent loads using its path will return the cached reference.
 
-\ **Note:** In C#, resources will not be freed instantly after they are no longer in use. Instead, garbage collection will run periodically and will free resources that are no longer in use. This means that unused resources will linger on for a while before being removed.
+\ **Note:** In C#, resources will not be freed instantly after they are no longer in use. Instead, garbage collection will run periodically and will free resources that are no longer in use. This means that unused resources will remain in memory for a while before being removed.
 
 .. rst-class:: classref-introduction-group
 

classes/class_resourceimportertexture.rst

@@ -269,7 +269,7 @@ Unimplemented. This currently has no effect when changed.
 
 :ref:`bool<class_bool>` **process/fix_alpha_border** = ``true``
 
-If ``true``, puts pixels of the same surrounding color in transition from transparent to opaque areas. For textures displayed with bilinear filtering, this helps mitigate the outline effect when exporting images from an image editor.
+If ``true``, puts pixels of the same surrounding color in transition from transparent to opaque areas. For textures displayed with bilinear filtering, this helps to reduce the outline effect when exporting images from an image editor.
 
 It's recommended to leave this enabled (as it is by default), unless this causes issues for a particular image.
 

classes/class_scenetree.rst

@@ -207,7 +207,7 @@ Emitted immediately before :ref:`Node._process<class_Node_private_method__proces
 
 **tree_changed**\ (\ )
 
-Emitted any time the tree's hierarchy changes (nodes being moved, renamed, etc).
+Emitted any time the tree's hierarchy changes (nodes being moved, renamed, etc.).
 
 .. rst-class:: classref-item-separator
 

classes/class_scriptlanguageextension.rst

@@ -299,7 +299,7 @@ The option is local to the location of the code completion query - e.g. a local
 
 :ref:`CodeCompletionLocation<enum_ScriptLanguageExtension_CodeCompletionLocation>` **LOCATION_PARENT_MASK** = ``256``
 
-The option is from the containing class or a parent class, relative to the location of the code completion query. Perform a bitwise OR with the class depth (e.g. 0 for the local class, 1 for the parent, 2 for the grandparent, etc) to store the depth of an option in the class or a parent class.
+The option is from the containing class or a parent class, relative to the location of the code completion query. Perform a bitwise OR with the class depth (e.g. ``0`` for the local class, ``1`` for the parent, ``2`` for the grandparent, etc.) to store the depth of an option in the class or a parent class.
 
 .. _class_ScriptLanguageExtension_constant_LOCATION_OTHER_USER_CODE:
 

classes/class_skeleton3d.rst

@@ -167,7 +167,7 @@ Emitted when the bone at ``bone_idx`` is toggled with :ref:`set_bone_enabled<cla
 
 **bone_pose_changed**\ (\ bone_idx\: :ref:`int<class_int>`\ )
 
-This signal is emitted when one of the bones in the Skeleton3D node have changed their pose. This is used to inform nodes that rely on bone positions that one of the bones in the Skeleton3D have changed their transform/pose.
+Emitted when the bone at ``bone_idx`` changes its transform/pose. This can be used to update other nodes that rely on bone positions.
 
 .. rst-class:: classref-item-separator
 

classes/class_spinbox.rst

@@ -22,7 +22,7 @@ An input field for numbers.
 Description
 -----------
 
-**SpinBox** is a numerical input text field. It allows entering integers and floating point numbers.
+**SpinBox** is a numerical input text field. It allows entering integers and floating-point numbers.
 
 \ **Example:**\ 
 

classes/class_tcpserver.rst

@@ -102,7 +102,7 @@ If ``bind_address`` is set as ``"*"`` (default), the server will listen on all a
 
 If ``bind_address`` is set as ``"0.0.0.0"`` (for IPv4) or ``"::"`` (for IPv6), the server will listen on all available addresses matching that IP type.
 
-If ``bind_address`` is set to any valid address (e.g. ``"192.168.1.101"``, ``"::1"``, etc), the server will only listen on the interface with that addresses (or fail if no interface with the given address exists).
+If ``bind_address`` is set to any valid address (e.g. ``"192.168.1.101"``, ``"::1"``, etc.), the server will only listen on the interface with that address (or fail if no interface with the given address exists).
 
 .. rst-class:: classref-item-separator
 

classes/class_tilemap.rst

@@ -891,7 +891,7 @@ If ``layer`` is negative, the layers are accessed from the last one.
 
 |void| **set_layer_enabled**\ (\ layer\: :ref:`int<class_int>`, enabled\: :ref:`bool<class_bool>`\ )
 
-Enables or disables the layer ``layer``. A disabled layer is not processed at all (no rendering, no physics, etc...).
+Enables or disables the layer ``layer``. A disabled layer is not processed at all (no rendering, no physics, etc.).
 
 If ``layer`` is negative, the layers are accessed from the last one.
 

classes/class_timer.rst

@@ -19,12 +19,21 @@ A countdown timer.
 Description
 -----------
 
-Counts down a specified interval and emits a signal on reaching 0. Can be set to repeat or "one-shot" mode.
+The **Timer** node is a countdown timer and is the simplest way to handle time-based logic in the engine. When a timer reaches the end of its :ref:`wait_time<class_Timer_property_wait_time>`, it will emit the :ref:`timeout<class_Timer_signal_timeout>` signal.
 
-\ **Note:** Timers are affected by :ref:`Engine.time_scale<class_Engine_property_time_scale>`, a higher scale means quicker timeouts, and vice versa.
+After a timer enters the tree, it can be manually started with :ref:`start<class_Timer_method_start>`. A timer node is also started automatically if :ref:`autostart<class_Timer_property_autostart>` is ``true``.
+
+Without requiring much code, a timer node can be added and configured in the editor. The :ref:`timeout<class_Timer_signal_timeout>` signal it emits can also be connected through the Node dock in the editor:
+
+::
+
+    func _on_timer_timeout():
+        print("Time to attack!")
 
 \ **Note:** To create a one-shot timer without instantiating a node, use :ref:`SceneTree.create_timer<class_SceneTree_method_create_timer>`.
 
+\ **Note:** Timers are affected by :ref:`Engine.time_scale<class_Engine_property_time_scale>`. The higher the time scale, the sooner timers will end. How often a timer processes may depend on the framerate or :ref:`Engine.physics_ticks_per_second<class_Engine_property_physics_ticks_per_second>`.
+
 .. rst-class:: classref-introduction-group
 
 Tutorials

classes/class_vector2.rst

@@ -10,7 +10,7 @@
 Vector2
 =======
 
-A 2D vector using floating point coordinates.
+A 2D vector using floating-point coordinates.
 
 .. rst-class:: classref-introduction-group
 

classes/class_vector3.rst

@@ -10,7 +10,7 @@
 Vector3
 =======
 
-A 3D vector using floating point coordinates.
+A 3D vector using floating-point coordinates.
 
 .. rst-class:: classref-introduction-group
 

classes/class_vector4.rst

@@ -10,7 +10,7 @@
 Vector4
 =======
 
-A 4D vector using floating point coordinates.
+A 4D vector using floating-point coordinates.
 
 .. rst-class:: classref-introduction-group
 

classes/class_viewport.rst

@@ -1880,16 +1880,16 @@ The texture *must* use a lossless compression format so that colors can be match
 
 ::
 
-    - 1x1 = rgb(0, 0, 0)     - #000000
-    - 1x2 = rgb(0, 85, 0)    - #005500
-    - 2x1 = rgb(85, 0, 0)    - #550000
-    - 2x2 = rgb(85, 85, 0)   - #555500
-    - 2x4 = rgb(85, 170, 0)  - #55aa00
-    - 4x2 = rgb(170, 85, 0)  - #aa5500
-    - 4x4 = rgb(170, 170, 0) - #aaaa00
-    - 4x8 = rgb(170, 255, 0) - #aaff00 - Not supported on most hardware
-    - 8x4 = rgb(255, 170, 0) - #ffaa00 - Not supported on most hardware
-    - 8x8 = rgb(255, 255, 0) - #ffff00 - Not supported on most hardware
+    - 1×1 = rgb(0, 0, 0)     - #000000
+    - 1×2 = rgb(0, 85, 0)    - #005500
+    - 2×1 = rgb(85, 0, 0)    - #550000
+    - 2×2 = rgb(85, 85, 0)   - #555500
+    - 2×4 = rgb(85, 170, 0)  - #55aa00
+    - 4×2 = rgb(170, 85, 0)  - #aa5500
+    - 4×4 = rgb(170, 170, 0) - #aaaa00
+    - 4×8 = rgb(170, 255, 0) - #aaff00 - Not supported on most hardware
+    - 8×4 = rgb(255, 170, 0) - #ffaa00 - Not supported on most hardware
+    - 8×8 = rgb(255, 255, 0) - #ffff00 - Not supported on most hardware
 
 .. rst-class:: classref-item-separator
 

classes/class_visualshader.rst

@@ -320,7 +320,7 @@ Constants
 
 **NODE_ID_INVALID** = ``-1``
 
-Denotes invalid **VisualShader** node.
+Indicates an invalid **VisualShader** node.
 
 .. _class_VisualShader_constant_NODE_ID_OUTPUT:
 
@@ -328,7 +328,7 @@ Denotes invalid **VisualShader** node.
 
 **NODE_ID_OUTPUT** = ``0``
 
-Denotes output node of **VisualShader**.
+Indicates an output node of **VisualShader**.
 
 .. rst-class:: classref-section-separator
 

classes/class_visualshadernodeif.rst

@@ -12,14 +12,20 @@ VisualShaderNodeIf
 
 **Inherits:** :ref:`VisualShaderNode<class_VisualShaderNode>` **<** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
 
-Outputs a 3D vector based on the result of a floating point comparison within the visual shader graph.
+Outputs a 3D vector based on the result of a floating-point comparison within the visual shader graph.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-This visual shader node has six input ports. Port 1 and 2 provide the two floating point numbers ``a`` and ``b`` that will be compared. Port 3 is the tolerance, which allows similar floating point number to be considered equal. Ports 4 to 6 are the possible outputs, returned if ``a == b``, ``a > b``, or ``a < b`` respectively.
+This visual shader node has six input ports:
+
+- Port **1** and **2** provide the two floating-point numbers ``a`` and ``b`` that will be compared.
+
+- Port **3** is the tolerance, which allows similar floating-point numbers to be considered equal.
+
+- Ports **4**, **5**, and **6** are the possible outputs, returned if ``a == b``, ``a > b``, or ``a < b`` respectively.
 
 .. |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_visualshadernodeis.rst

@@ -62,7 +62,7 @@ Comparison with ``INF`` (Infinity).
 
 :ref:`Function<enum_VisualShaderNodeIs_Function>` **FUNC_IS_NAN** = ``1``
 
-Comparison with ``NaN`` (Not a Number; denotes invalid numeric results, e.g. division by zero).
+Comparison with ``NaN`` (Not a Number; indicates invalid numeric results, such as division by zero).
 
 .. _class_VisualShaderNodeIs_constant_FUNC_MAX:
 

classes/class_visualshadernodetransformcompose.rst

@@ -19,7 +19,7 @@ Composes a :ref:`Transform3D<class_Transform3D>` from four :ref:`Vector3<class_V
 Description
 -----------
 
-Creates a 4x4 transform matrix using four vectors of type ``vec3``. Each vector is one row in the matrix and the last column is a ``vec4(0, 0, 0, 1)``.
+Creates a 4×4 transform matrix using four vectors of type ``vec3``. Each vector is one row in the matrix and the last column is a ``vec4(0, 0, 0, 1)``.
 
 .. |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_visualshadernodetransformdecompose.rst

@@ -19,7 +19,7 @@ Decomposes a :ref:`Transform3D<class_Transform3D>` into four :ref:`Vector3<class
 Description
 -----------
 
-Takes a 4x4 transform matrix and decomposes it into four ``vec3`` values, one from each row of the matrix.
+Takes a 4×4 transform matrix and decomposes it into four ``vec3`` values, one from each row of the matrix.
 
 .. |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_visualshadernodetransformop.rst

@@ -19,7 +19,7 @@ A :ref:`Transform3D<class_Transform3D>` operator to be used within the visual sh
 Description
 -----------
 
-Applies :ref:`operator<class_VisualShaderNodeTransformOp_property_operator>` to two transform (4x4 matrices) inputs.
+Applies :ref:`operator<class_VisualShaderNodeTransformOp_property_operator>` to two transform (4×4 matrices) inputs.
 
 .. rst-class:: classref-reftable-group
 

classes/class_visualshadernodetransformvecmult.rst

@@ -19,7 +19,7 @@ Multiplies a :ref:`Transform3D<class_Transform3D>` and a :ref:`Vector3<class_Vec
 Description
 -----------
 
-A multiplication operation on a transform (4x4 matrix) and a vector, with support for different multiplication operators.
+A multiplication operation on a transform (4×4 matrix) and a vector, with support for different multiplication operators.
 
 .. rst-class:: classref-reftable-group
 

classes/class_xranchor3d.rst

@@ -19,7 +19,7 @@ An anchor point in AR space.
 Description
 -----------
 
-The **XRAnchor3D** point is a spatial node that maps a real world location identified by the AR platform to a position within the game world. For example, as long as plane detection in ARKit is on, ARKit will identify and update the position of planes (tables, floors, etc) and create anchors for them.
+The **XRAnchor3D** point is an :ref:`XRNode3D<class_XRNode3D>` that maps a real world location identified by the AR platform to a position within the game world. For example, as long as plane detection in ARKit is on, ARKit will identify and update the position of planes (tables, floors, etc.) and create anchors for them.
 
 This node is mapped to one of the anchors through its unique ID. When you receive a signal that a new anchor is available, you should add this node to your scene for that anchor. You can predefine nodes and set the ID; the nodes will simply remain on 0,0,0 until a plane is recognized.
 

classes/class_xrinterface.rst

@@ -438,7 +438,7 @@ Returns a combination of :ref:`Capabilities<enum_XRInterface_Capabilities>` flag
 
 :ref:`StringName<class_StringName>` **get_name**\ (\ ) |const|
 
-Returns the name of this interface (OpenXR, OpenVR, OpenHMD, ARKit, etc).
+Returns the name of this interface (``"OpenXR"``, ``"OpenVR"``, ``"OpenHMD"``, ``"ARKit"``, etc.).
 
 .. rst-class:: classref-item-separator
 
@@ -450,7 +450,7 @@ Returns the name of this interface (OpenXR, OpenVR, OpenHMD, ARKit, etc).
 
 :ref:`PackedVector3Array<class_PackedVector3Array>` **get_play_area**\ (\ ) |const|
 
-Returns an array of vectors that denotes the physical play area mapped to the virtual space around the :ref:`XROrigin3D<class_XROrigin3D>` point. The points form a convex polygon that can be used to react to or visualize the play area. This returns an empty array if this feature is not supported or if the information is not yet available.
+Returns an array of vectors that represent the physical play area mapped to the virtual space around the :ref:`XROrigin3D<class_XROrigin3D>` point. The points form a convex polygon that can be used to react to or visualize the play area. This returns an empty array if this feature is not supported or if the information is not yet available.
 
 .. rst-class:: classref-item-separator
 

classes/class_xrinterfaceextension.rst

@@ -221,7 +221,7 @@ Returns the name of this interface.
 
 :ref:`PackedVector3Array<class_PackedVector3Array>` **_get_play_area**\ (\ ) |virtual| |const|
 
-Returns an :ref:`PackedVector3Array<class_PackedVector3Array>` that denotes the play areas boundaries (if applicable).
+Returns a :ref:`PackedVector3Array<class_PackedVector3Array>` that represents the play areas boundaries (if applicable).
 
 .. rst-class:: classref-item-separator
 

classes/class_xrpose.rst

@@ -101,7 +101,7 @@ Tracking information may be inaccurate or estimated. For example, with inside ou
 
 :ref:`TrackingConfidence<enum_XRPose_TrackingConfidence>` **XR_TRACKING_CONFIDENCE_HIGH** = ``2``
 
-Tracking information is deemed accurate and up to date.
+Tracking information is considered accurate and up to date.
 
 .. rst-class:: classref-section-separator