Sync classref with current source

classes/[email protected]

@@ -240,7 +240,7 @@ Method Descriptions
 
 - :ref:`Color<class_Color>` **Color8** **(** :ref:`int<class_int>` r8, :ref:`int<class_int>` g8, :ref:`int<class_int>` b8, :ref:`int<class_int>` a8=255 **)**
 
-Returns a 32 bit color with red, green, blue and alpha channels. Each channel has 8 bits of information ranging from 0 to 255.
+Returns a color constructed from integer red, green, blue, and alpha channels. Each channel should have 8 bits of information ranging from 0 to 255.
 
 ``r8`` red channel
 
@@ -1032,6 +1032,8 @@ Prints one or more arguments to strings in the best way possible to console. No
     printraw("B")
     # Prints AB
 
+**Note:** Due to limitations with Godot's built-in console, this only prints to the terminal. If you need to print in the editor, use another method, such as :ref:`print<class_@GDScript_method_print>`.
+
 ----
 
 .. _class_@GDScript_method_prints:

classes/class_aabb.rst

@@ -71,6 +71,8 @@ Methods
 +-------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`bool<class_bool>`       | :ref:`intersects_segment<class_AABB_method_intersects_segment>` **(** :ref:`Vector3<class_Vector3>` from, :ref:`Vector3<class_Vector3>` to **)** |
 +-------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`       | :ref:`is_equal_approx<class_AABB_method_is_equal_approx>` **(** :ref:`AABB<class_AABB>` aabb **)**                                               |
++-------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`AABB<class_AABB>`       | :ref:`merge<class_AABB_method_merge>` **(** :ref:`AABB<class_AABB>` with **)**                                                                   |
 +-------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------+
 
@@ -284,6 +286,12 @@ Returns ``true`` if the ``AABB`` intersects the line segment between ``from`` an
 
 ----
 
+.. _class_AABB_method_is_equal_approx:
+
+- :ref:`bool<class_bool>` **is_equal_approx** **(** :ref:`AABB<class_AABB>` aabb **)**
+
+----
+
 .. _class_AABB_method_merge:
 
 - :ref:`AABB<class_AABB>` **merge** **(** :ref:`AABB<class_AABB>` with **)**

classes/class_animationnodeblendspace2d.rst

@@ -116,7 +116,7 @@ Property Descriptions
 | *Getter*  | get_auto_triangles()      |
 +-----------+---------------------------+
 
-If true, the blend space is triangulated automatically. The mesh updates every time you add or remove points with :ref:`add_blend_point<class_AnimationNodeBlendSpace2D_method_add_blend_point>` and :ref:`remove_blend_point<class_AnimationNodeBlendSpace2D_method_remove_blend_point>`.
+If ``true``, the blend space is triangulated automatically. The mesh updates every time you add or remove points with :ref:`add_blend_point<class_AnimationNodeBlendSpace2D_method_add_blend_point>` and :ref:`remove_blend_point<class_AnimationNodeBlendSpace2D_method_remove_blend_point>`.
 
 ----
 

classes/class_area2d.rst

@@ -177,6 +177,11 @@ Description
 
 2D area that detects :ref:`CollisionObject2D<class_CollisionObject2D>` nodes overlapping, entering, or exiting. Can also alter or override local physics parameters (gravity, damping).
 
+Tutorials
+---------
+
+- :doc:`../tutorials/physics/using_area_2d`
+
 Property Descriptions
 ---------------------
 

classes/class_array.rst

@@ -393,7 +393,7 @@ Returns the number of elements in the array.
 
 - :ref:`Array<class_Array>` **slice** **(** :ref:`int<class_int>` begin, :ref:`int<class_int>` end, :ref:`int<class_int>` step=1, :ref:`bool<class_bool>` deep=False **)**
 
-Duplicates the subset described in the function and returns it in an array, deeply copying the array if ``deep`` is true. Lower and upper index are inclusive, with the ``step`` describing the change between indices while slicing.
+Duplicates the subset described in the function and returns it in an array, deeply copying the array if ``deep`` is ``true``. Lower and upper index are inclusive, with the ``step`` describing the change between indices while slicing.
 
 ----
 

classes/class_astar.rst

@@ -16,69 +16,84 @@ AStar
 Brief Description
 -----------------
 
-AStar class representation that uses 3d-vectors as edges.
+An implementation of A\* to find shortest paths among connected points in space.
 
 Methods
 -------
 
-+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`float<class_float>`                       | :ref:`_compute_cost<class_AStar_method__compute_cost>` **(** :ref:`int<class_int>` from_id, :ref:`int<class_int>` to_id **)** virtual                                      |
-+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`float<class_float>`                       | :ref:`_estimate_cost<class_AStar_method__estimate_cost>` **(** :ref:`int<class_int>` from_id, :ref:`int<class_int>` to_id **)** virtual                                    |
-+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                            | :ref:`add_point<class_AStar_method_add_point>` **(** :ref:`int<class_int>` id, :ref:`Vector3<class_Vector3>` position, :ref:`float<class_float>` weight_scale=1.0 **)**    |
-+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`bool<class_bool>`                         | :ref:`are_points_connected<class_AStar_method_are_points_connected>` **(** :ref:`int<class_int>` id, :ref:`int<class_int>` to_id **)** const                               |
-+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                            | :ref:`clear<class_AStar_method_clear>` **(** **)**                                                                                                                         |
-+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                            | :ref:`connect_points<class_AStar_method_connect_points>` **(** :ref:`int<class_int>` id, :ref:`int<class_int>` to_id, :ref:`bool<class_bool>` bidirectional=true **)**     |
-+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                            | :ref:`disconnect_points<class_AStar_method_disconnect_points>` **(** :ref:`int<class_int>` id, :ref:`int<class_int>` to_id **)**                                           |
-+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`                           | :ref:`get_available_point_id<class_AStar_method_get_available_point_id>` **(** **)** const                                                                                 |
-+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`                           | :ref:`get_closest_point<class_AStar_method_get_closest_point>` **(** :ref:`Vector3<class_Vector3>` to_position, :ref:`bool<class_bool>` include_disabled=false **)** const |
-+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Vector3<class_Vector3>`                   | :ref:`get_closest_position_in_segment<class_AStar_method_get_closest_position_in_segment>` **(** :ref:`Vector3<class_Vector3>` to_position **)** const                     |
-+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`PoolIntArray<class_PoolIntArray>`         | :ref:`get_id_path<class_AStar_method_get_id_path>` **(** :ref:`int<class_int>` from_id, :ref:`int<class_int>` to_id **)**                                                  |
-+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`                           | :ref:`get_point_capacity<class_AStar_method_get_point_capacity>` **(** **)** const                                                                                         |
-+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`PoolIntArray<class_PoolIntArray>`         | :ref:`get_point_connections<class_AStar_method_get_point_connections>` **(** :ref:`int<class_int>` id **)**                                                                |
-+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`                           | :ref:`get_point_count<class_AStar_method_get_point_count>` **(** **)** const                                                                                               |
-+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`PoolVector3Array<class_PoolVector3Array>` | :ref:`get_point_path<class_AStar_method_get_point_path>` **(** :ref:`int<class_int>` from_id, :ref:`int<class_int>` to_id **)**                                            |
-+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Vector3<class_Vector3>`                   | :ref:`get_point_position<class_AStar_method_get_point_position>` **(** :ref:`int<class_int>` id **)** const                                                                |
-+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`float<class_float>`                       | :ref:`get_point_weight_scale<class_AStar_method_get_point_weight_scale>` **(** :ref:`int<class_int>` id **)** const                                                        |
-+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Array<class_Array>`                       | :ref:`get_points<class_AStar_method_get_points>` **(** **)**                                                                                                               |
-+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`bool<class_bool>`                         | :ref:`has_point<class_AStar_method_has_point>` **(** :ref:`int<class_int>` id **)** const                                                                                  |
-+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`bool<class_bool>`                         | :ref:`is_point_disabled<class_AStar_method_is_point_disabled>` **(** :ref:`int<class_int>` id **)** const                                                                  |
-+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                            | :ref:`remove_point<class_AStar_method_remove_point>` **(** :ref:`int<class_int>` id **)**                                                                                  |
-+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                            | :ref:`reserve_space<class_AStar_method_reserve_space>` **(** :ref:`int<class_int>` num_nodes **)**                                                                         |
-+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                            | :ref:`set_point_disabled<class_AStar_method_set_point_disabled>` **(** :ref:`int<class_int>` id, :ref:`bool<class_bool>` disabled=true **)**                               |
-+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                            | :ref:`set_point_position<class_AStar_method_set_point_position>` **(** :ref:`int<class_int>` id, :ref:`Vector3<class_Vector3>` position **)**                              |
-+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                            | :ref:`set_point_weight_scale<class_AStar_method_set_point_weight_scale>` **(** :ref:`int<class_int>` id, :ref:`float<class_float>` weight_scale **)**                      |
-+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
++-------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`float<class_float>`                       | :ref:`_compute_cost<class_AStar_method__compute_cost>` **(** :ref:`int<class_int>` from_id, :ref:`int<class_int>` to_id **)** virtual                                                    |
++-------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`float<class_float>`                       | :ref:`_estimate_cost<class_AStar_method__estimate_cost>` **(** :ref:`int<class_int>` from_id, :ref:`int<class_int>` to_id **)** virtual                                                  |
++-------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                            | :ref:`add_point<class_AStar_method_add_point>` **(** :ref:`int<class_int>` id, :ref:`Vector3<class_Vector3>` position, :ref:`float<class_float>` weight_scale=1.0 **)**                  |
++-------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`                         | :ref:`are_points_connected<class_AStar_method_are_points_connected>` **(** :ref:`int<class_int>` id, :ref:`int<class_int>` to_id, :ref:`bool<class_bool>` bidirectional=true **)** const |
++-------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                            | :ref:`clear<class_AStar_method_clear>` **(** **)**                                                                                                                                       |
++-------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                            | :ref:`connect_points<class_AStar_method_connect_points>` **(** :ref:`int<class_int>` id, :ref:`int<class_int>` to_id, :ref:`bool<class_bool>` bidirectional=true **)**                   |
++-------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                            | :ref:`disconnect_points<class_AStar_method_disconnect_points>` **(** :ref:`int<class_int>` id, :ref:`int<class_int>` to_id, :ref:`bool<class_bool>` bidirectional=true **)**             |
++-------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`                           | :ref:`get_available_point_id<class_AStar_method_get_available_point_id>` **(** **)** const                                                                                               |
++-------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`                           | :ref:`get_closest_point<class_AStar_method_get_closest_point>` **(** :ref:`Vector3<class_Vector3>` to_position, :ref:`bool<class_bool>` include_disabled=false **)** const               |
++-------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Vector3<class_Vector3>`                   | :ref:`get_closest_position_in_segment<class_AStar_method_get_closest_position_in_segment>` **(** :ref:`Vector3<class_Vector3>` to_position **)** const                                   |
++-------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`PoolIntArray<class_PoolIntArray>`         | :ref:`get_id_path<class_AStar_method_get_id_path>` **(** :ref:`int<class_int>` from_id, :ref:`int<class_int>` to_id **)**                                                                |
++-------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`                           | :ref:`get_point_capacity<class_AStar_method_get_point_capacity>` **(** **)** const                                                                                                       |
++-------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`PoolIntArray<class_PoolIntArray>`         | :ref:`get_point_connections<class_AStar_method_get_point_connections>` **(** :ref:`int<class_int>` id **)**                                                                              |
++-------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`                           | :ref:`get_point_count<class_AStar_method_get_point_count>` **(** **)** const                                                                                                             |
++-------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`PoolVector3Array<class_PoolVector3Array>` | :ref:`get_point_path<class_AStar_method_get_point_path>` **(** :ref:`int<class_int>` from_id, :ref:`int<class_int>` to_id **)**                                                          |
++-------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Vector3<class_Vector3>`                   | :ref:`get_point_position<class_AStar_method_get_point_position>` **(** :ref:`int<class_int>` id **)** const                                                                              |
++-------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`float<class_float>`                       | :ref:`get_point_weight_scale<class_AStar_method_get_point_weight_scale>` **(** :ref:`int<class_int>` id **)** const                                                                      |
++-------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Array<class_Array>`                       | :ref:`get_points<class_AStar_method_get_points>` **(** **)**                                                                                                                             |
++-------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`                         | :ref:`has_point<class_AStar_method_has_point>` **(** :ref:`int<class_int>` id **)** const                                                                                                |
++-------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`                         | :ref:`is_point_disabled<class_AStar_method_is_point_disabled>` **(** :ref:`int<class_int>` id **)** const                                                                                |
++-------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                            | :ref:`remove_point<class_AStar_method_remove_point>` **(** :ref:`int<class_int>` id **)**                                                                                                |
++-------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                            | :ref:`reserve_space<class_AStar_method_reserve_space>` **(** :ref:`int<class_int>` num_nodes **)**                                                                                       |
++-------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                            | :ref:`set_point_disabled<class_AStar_method_set_point_disabled>` **(** :ref:`int<class_int>` id, :ref:`bool<class_bool>` disabled=true **)**                                             |
++-------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                            | :ref:`set_point_position<class_AStar_method_set_point_position>` **(** :ref:`int<class_int>` id, :ref:`Vector3<class_Vector3>` position **)**                                            |
++-------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                            | :ref:`set_point_weight_scale<class_AStar_method_set_point_weight_scale>` **(** :ref:`int<class_int>` id, :ref:`float<class_float>` weight_scale **)**                                    |
++-------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
 Description
 -----------
 
-A\* (A star) is a computer algorithm that is widely used in pathfinding and graph traversal, the process of plotting an efficiently directed path between multiple points. It enjoys widespread use due to its performance and accuracy. Godot's A\* implementation make use of vectors as points.
+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.
 
-You must add points manually with :ref:`add_point<class_AStar_method_add_point>` and create segments manually with :ref:`connect_points<class_AStar_method_connect_points>`. So you can test if there is a path between two points with the :ref:`are_points_connected<class_AStar_method_are_points_connected>` function, get the list of existing ids in the found path with :ref:`get_id_path<class_AStar_method_get_id_path>`, or the points list with :ref:`get_point_path<class_AStar_method_get_point_path>`.
+You must add points manually with :ref:`add_point<class_AStar_method_add_point>` and create segments manually with :ref:`connect_points<class_AStar_method_connect_points>`. Then you can test if there is a path between two points with the :ref:`are_points_connected<class_AStar_method_are_points_connected>` function, get a path containing indices by :ref:`get_id_path<class_AStar_method_get_id_path>`, or one containing actual coordinates with :ref:`get_point_path<class_AStar_method_get_point_path>`.
+
+It is also possible to use non-Euclidean distances. To do so, create a class that extends ``AStar`` and override methods :ref:`_compute_cost<class_AStar_method__compute_cost>` and :ref:`_estimate_cost<class_AStar_method__estimate_cost>`. Both take two indices and return a length, as is shown in the following example.
+
+::
+
+    class MyAStar:
+        extends AStar
+    
+        func _compute_cost(u, v):
+            return abs(u - v)
+    
+        func _estimate_cost(u, v):
+            return min(0, abs(u - v) - 1)
+
+:ref:`_estimate_cost<class_AStar_method__estimate_cost>` should return a lower bound of the distance, i.e. ``_estimate_cost(u, v) <= _compute_cost(u, v)``. This serves as a hint to the algorithm because the custom ``_compute_cost`` might be computation-heavy. If this is not the case, make :ref:`_estimate_cost<class_AStar_method__estimate_cost>` return the same value as :ref:`_compute_cost<class_AStar_method__compute_cost>` to provide the algorithm with the most accurate information.
 
 Method Descriptions
 -------------------
@@ -89,6 +104,8 @@ Method Descriptions
 
 Called when computing the cost between two connected points.
 
+Note that this function is hidden in the default ``AStar`` class.
+
 ----
 
 .. _class_AStar_method__estimate_cost:
@@ -97,6 +114,8 @@ Called when computing the cost between two connected points.
 
 Called when estimating the cost between a point and the path's ending point.
 
+Note that this function is hidden in the default ``AStar`` class.
+
 ----
 
 .. _class_AStar_method_add_point:
@@ -116,9 +135,9 @@ If there already exists a point for the given ``id``, its position and weight sc
 
 .. _class_AStar_method_are_points_connected:
 
-- :ref:`bool<class_bool>` **are_points_connected** **(** :ref:`int<class_int>` id, :ref:`int<class_int>` to_id **)** const
+- :ref:`bool<class_bool>` **are_points_connected** **(** :ref:`int<class_int>` id, :ref:`int<class_int>` to_id, :ref:`bool<class_bool>` bidirectional=true **)** const
 
-Returns whether there is a connection/segment between the given points.
+Returns whether the two given points are directly connected by a segment. If ``bidirectional`` is ``false``, returns whether movement from ``id`` to ``to_id`` is possible through this segment.
 
 ----
 
@@ -147,9 +166,9 @@ Creates a segment between the given points. If ``bidirectional`` is ``false``, o
 
 .. _class_AStar_method_disconnect_points:
 
-- void **disconnect_points** **(** :ref:`int<class_int>` id, :ref:`int<class_int>` to_id **)**
+- void **disconnect_points** **(** :ref:`int<class_int>` id, :ref:`int<class_int>` to_id, :ref:`bool<class_bool>` bidirectional=true **)**
 
-Deletes the segment between the given points.
+Deletes the segment between the given points. If ``bidirectional`` is ``false``, only movement from ``id`` to ``to_id`` is prevented, and a unidirectional segment possibly remains.
 
 ----
 

classes/class_backbuffercopy.rst

@@ -16,7 +16,7 @@ BackBufferCopy
 Brief Description
 -----------------
 
-Copies a region of the screen (or the whole screen) to a buffer so it can be accessed with ``SCREEN_TEXTURE`` in the ``texture()`` function.
+Copies a region of the screen (or the whole screen) to a buffer so it can be accessed in your shader scripts through the ``texture(SCREEN_TEXTURE, ...)`` function.
 
 Properties
 ----------
@@ -49,7 +49,7 @@ enum **CopyMode**:
 Description
 -----------
 
-Node for back-buffering the currently-displayed screen. The region defined in the BackBufferCopy node is bufferized with the content of the screen it covers, or the entire screen according to the copy mode set. Use ``SCREEN_TEXTURE`` in the ``texture()`` function to access the buffer.
+Node for back-buffering the currently-displayed screen. The region defined in the BackBufferCopy node is bufferized with the content of the screen it covers, or the entire screen according to the copy mode set. Use the ``texture(SCREEN_TEXTURE, ...)`` function in your shader scripts to access the buffer.
 
 Property Descriptions
 ---------------------

classes/class_canvasitem.rst

@@ -543,6 +543,8 @@ Draws a textured rectangle region at a given position, optionally modulated by a
 
 - void **force_update_transform** **(** **)**
 
+Forces the transform to update. Transform changes in physics are not instant for performance reasons. Transforms are accumulated and then set. Use this if you need an up-to-date transform when doing physics operations.
+
 ----
 
 .. _class_CanvasItem_method_get_canvas:

classes/class_color.rst

@@ -67,6 +67,8 @@ Methods
 +-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`Color<class_Color>`   | :ref:`inverted<class_Color_method_inverted>` **(** **)**                                                                                                                      |
 +-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`     | :ref:`is_equal_approx<class_Color_method_is_equal_approx>` **(** :ref:`Color<class_Color>` color **)**                                                                        |
++-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`Color<class_Color>`   | :ref:`lightened<class_Color_method_lightened>` **(** :ref:`float<class_float>` amount **)**                                                                                   |
 +-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`Color<class_Color>`   | :ref:`linear_interpolate<class_Color_method_linear_interpolate>` **(** :ref:`Color<class_Color>` b, :ref:`float<class_float>` t **)**                                         |
@@ -942,6 +944,12 @@ Returns the inverted color ``(1 - r, 1 - g, 1 - b, a)``.
 
 ----
 
+.. _class_Color_method_is_equal_approx:
+
+- :ref:`bool<class_bool>` **is_equal_approx** **(** :ref:`Color<class_Color>` color **)**
+
+----
+
 .. _class_Color_method_lightened:
 
 - :ref:`Color<class_Color>` **lightened** **(** :ref:`float<class_float>` amount **)**

classes/class_control.rst

@@ -1194,7 +1194,7 @@ The event won't trigger if:
 
 Virtual method to be implemented by the user. Returns a ``Control`` node that should be used as a tooltip instead of the default one. Use ``for_text`` parameter to determine what text the tooltip should contain (likely the contents of :ref:`hint_tooltip<class_Control_property_hint_tooltip>`).
 
-The returned node must be of type ``Control`` or Control-derieved. It can have child nodes of any type. It is freed when the tooltip disappears, so make sure you always provide a new instance, not e.g. a node from scene. When null or non-Control node is returned, the default tooltip will be used instead.
+The returned node must be of type ``Control`` or Control-derieved. It can have child nodes of any type. It is freed when the tooltip disappears, so make sure you always provide a new instance, not e.g. a node from scene. When ``null`` or non-Control node is returned, the default tooltip will be used instead.
 
 **Note:** The tooltip is shrunk to minimal size. If you want to ensure it's fully visible, you might want to set its :ref:`rect_min_size<class_Control_property_rect_min_size>` to some non-zero value.
 
@@ -1727,7 +1727,19 @@ Forwarding can be implemented in the target control similar to the methods :ref:
 
 - void **set_drag_preview** **(** :ref:`Control<class_Control>` control **)**
 
-Shows the given control at the mouse pointer. A good time to call this method is in :ref:`get_drag_data<class_Control_method_get_drag_data>`.
+Shows the given control at the mouse pointer. A good time to call this method is in :ref:`get_drag_data<class_Control_method_get_drag_data>`. The control must not be in the scene tree.
+
+::
+
+    export (Color, RGBA) var color = Color(1, 0, 0, 1)
+    
+    func get_drag_data(position):
+        # Use a control that is not in the tree
+        var cpb = ColorPickerButton.new()
+        cpb.color = color
+        cpb.rect_size = Vector2(50, 50)
+        set_drag_preview(cpb)
+        return color
 
 ----
 

classes/class_editorinspectorplugin.rst

@@ -46,7 +46,7 @@ This plugins allows adding custom property editors to :ref:`EditorInspector<clas
 
 Plugins are registered via :ref:`EditorPlugin.add_inspector_plugin<class_EditorPlugin_method_add_inspector_plugin>`.
 
-When an object is edited, the :ref:`can_handle<class_EditorInspectorPlugin_method_can_handle>` function is called and must return true if the object type is supported.
+When an object is edited, the :ref:`can_handle<class_EditorInspectorPlugin_method_can_handle>` function is called and must return ``true`` if the object type is supported.
 
 If supported, the function :ref:`parse_begin<class_EditorInspectorPlugin_method_parse_begin>` will be called, allowing to place custom controls at the beginning of the class.
 
@@ -87,7 +87,7 @@ Adds an editor that allows modifying multiple properties, this must inherit :ref
 
 - :ref:`bool<class_bool>` **can_handle** **(** :ref:`Object<class_Object>` object **)** virtual
 
-Returns true if this object can be handled by this plugin.
+Returns ``true`` if this object can be handled by this plugin.
 
 ----
 

classes/class_httprequest.rst

@@ -16,7 +16,7 @@ HTTPRequest
 Brief Description
 -----------------
 
-A node with the ability to send HTTP requests.
+A node with the ability to send HTTP(S) requests.
 
 Properties
 ----------
@@ -123,9 +123,42 @@ A node with the ability to send HTTP requests. Uses :ref:`HTTPClient<class_HTTPC
 
 Can be used to make HTTP requests, i.e. download or upload files or web content via HTTP.
 
+**Example of loading and displaying an image using HTTPRequest:**
+
+::
+
+    func _ready():
+        # Create an HTTP request node and connect its completion signal.
+        var http_request = HTTPRequest.new()
+        add_child(http_request)
+        http_request.connect("request_completed", self, "_http_request_completed")
+    
+        # Perform the HTTP request. The URL below returns a PNG image as of writing.
+        var error = http_request.request("https://via.placeholder.com/512")
+        if error != OK:
+            push_error("An error occurred in the HTTP request.")
+    
+    
+    # Called when the HTTP request is completed.
+    func _http_request_completed(result, response_code, headers, body):
+        var image = Image.new()
+        var error = image.load_png_from_buffer(body)
+        if error != OK:
+            push_error("Couldn't load the image.")
+    
+        var texture = ImageTexture.new()
+        texture.create_from_image(image)
+    
+        # Display the image in a TextureRect node.
+        var texture_rect = TextureRect.new()
+        add_child(texture_rect)
+        texture_rect.texture = texture
+
 Tutorials
 ---------
 
+- :doc:`../tutorials/networking/http_request_class`
+
 - :doc:`../tutorials/networking/ssl_certificates`
 
 Property Descriptions

classes/class_image.rst

@@ -791,7 +791,7 @@ Resizes the image to the nearest power of 2 for the width and height. If ``squar
 
 - :ref:`Error<enum_@GlobalScope_Error>` **save_exr** **(** :ref:`String<class_String>` path, :ref:`bool<class_bool>` grayscale=false **)** const
 
-Saves the image as an EXR file to ``path``. If grayscale is true and the image has only one channel, it will be saved explicitly as monochrome rather than one red channel. This function will return :ref:`@GlobalScope.ERR_UNAVAILABLE<class_@GlobalScope_constant_ERR_UNAVAILABLE>`  if Godot was compiled without the TinyEXR module.
+Saves the image as an EXR file to ``path``. If grayscale is ``true`` and the image has only one channel, it will be saved explicitly as monochrome rather than one red channel. This function will return :ref:`@GlobalScope.ERR_UNAVAILABLE<class_@GlobalScope_constant_ERR_UNAVAILABLE>` if Godot was compiled without the TinyEXR module.
 
 ----
 
@@ -824,6 +824,17 @@ Sets the :ref:`Color<class_Color>` of the pixel at ``(x, y)`` if the image is lo
 
 - void **set_pixelv** **(** :ref:`Vector2<class_Vector2>` dst, :ref:`Color<class_Color>` color **)**
 
+Sets the :ref:`Color<class_Color>` of the pixel at ``(dst.x, dst.y)`` if the image is locked. Note that the ``dst`` values must be integers. Example:
+
+::
+
+    var img = Image.new()
+    img.create(img_width, img_height, false, Image.FORMAT_RGBA8)
+    img.lock()
+    img.set_pixelv(Vector2(x, y), color) # Works
+    img.unlock()
+    img.set_pixelv(Vector2(x, y), color) # Does not have an effect
+
 ----
 
 .. _class_Image_method_shrink_x2:

classes/class_inputevent.rst

@@ -39,7 +39,7 @@ Methods
 +-------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`bool<class_bool>`             | :ref:`is_action<class_InputEvent_method_is_action>` **(** :ref:`String<class_String>` action **)** const                                                                     |
 +-------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`bool<class_bool>`             | :ref:`is_action_pressed<class_InputEvent_method_is_action_pressed>` **(** :ref:`String<class_String>` action **)** const                                                     |
+| :ref:`bool<class_bool>`             | :ref:`is_action_pressed<class_InputEvent_method_is_action_pressed>` **(** :ref:`String<class_String>` action, :ref:`bool<class_bool>` allow_echo=false **)** const           |
 +-------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`bool<class_bool>`             | :ref:`is_action_released<class_InputEvent_method_is_action_released>` **(** :ref:`String<class_String>` action **)** const                                                   |
 +-------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -122,9 +122,9 @@ Returns ``true`` if this input event matches a pre-defined action of any type.
 
 .. _class_InputEvent_method_is_action_pressed:
 
-- :ref:`bool<class_bool>` **is_action_pressed** **(** :ref:`String<class_String>` action **)** const
+- :ref:`bool<class_bool>` **is_action_pressed** **(** :ref:`String<class_String>` action, :ref:`bool<class_bool>` allow_echo=false **)** const
 
-Returns ``true`` if the given action is being pressed (and is not an echo event for :ref:`InputEventKey<class_InputEventKey>` events). Not relevant for events of type :ref:`InputEventMouseMotion<class_InputEventMouseMotion>` or :ref:`InputEventScreenDrag<class_InputEventScreenDrag>`.
+Returns ``true`` if the given action is being pressed (and is not an echo event for :ref:`InputEventKey<class_InputEventKey>` events, unless ``allow_echo`` is ``true``). Not relevant for events of type :ref:`InputEventMouseMotion<class_InputEventMouseMotion>` or :ref:`InputEventScreenDrag<class_InputEventScreenDrag>`.
 
 ----
 

classes/class_inputeventmousemotion.rst

@@ -21,16 +21,20 @@ Input event type for mouse motion events.
 Properties
 ----------
 
++-------------------------------+----------------------------------------------------------------+-----------------+
+| :ref:`float<class_float>`     | :ref:`pressure<class_InputEventMouseMotion_property_pressure>` | 0.0             |
 +-------------------------------+----------------------------------------------------------------+-----------------+
 | :ref:`Vector2<class_Vector2>` | :ref:`relative<class_InputEventMouseMotion_property_relative>` | Vector2( 0, 0 ) |
 +-------------------------------+----------------------------------------------------------------+-----------------+
 | :ref:`Vector2<class_Vector2>` | :ref:`speed<class_InputEventMouseMotion_property_speed>`       | Vector2( 0, 0 ) |
 +-------------------------------+----------------------------------------------------------------+-----------------+
+| :ref:`Vector2<class_Vector2>` | :ref:`tilt<class_InputEventMouseMotion_property_tilt>`         | Vector2( 0, 0 ) |
++-------------------------------+----------------------------------------------------------------+-----------------+
 
 Description
 -----------
 
-Contains mouse motion information. Supports relative, absolute positions and speed. See :ref:`Node._input<class_Node_method__input>`.
+Contains mouse and pen motion information. Supports relative, absolute positions and speed. See :ref:`Node._input<class_Node_method__input>`.
 
 Tutorials
 ---------
@@ -40,6 +44,22 @@ Tutorials
 Property Descriptions
 ---------------------
 
+.. _class_InputEventMouseMotion_property_pressure:
+
+- :ref:`float<class_float>` **pressure**
+
++-----------+---------------------+
+| *Default* | 0.0                 |
++-----------+---------------------+
+| *Setter*  | set_pressure(value) |
++-----------+---------------------+
+| *Getter*  | get_pressure()      |
++-----------+---------------------+
+
+Represents the pressure the user puts on the pen. Ranges from ``0.0`` to ``1.0``.
+
+----
+
 .. _class_InputEventMouseMotion_property_relative:
 
 - :ref:`Vector2<class_Vector2>` **relative**
@@ -70,3 +90,19 @@ The mouse position relative to the previous position (position at the last frame
 
 The mouse speed in pixels per second.
 
+----
+
+.. _class_InputEventMouseMotion_property_tilt:
+
+- :ref:`Vector2<class_Vector2>` **tilt**
+
++-----------+-----------------+
+| *Default* | Vector2( 0, 0 ) |
++-----------+-----------------+
+| *Setter*  | set_tilt(value) |
++-----------+-----------------+
+| *Getter*  | get_tilt()      |
++-----------+-----------------+
+
+Represents the angles of tilt of the pen. Positive X-coordinate value indicates a tilt to the right. Positive Y-coordinate value indicates a tilt toward the user. Ranges from ``-1.0`` to ``1.0`` for both axes.
+

classes/class_os.rst

@@ -895,6 +895,10 @@ Returns the command line arguments passed to the engine.
 
 - :ref:`PoolStringArray<class_PoolStringArray>` **get_connected_midi_inputs** **(** **)**
 
+Returns an array of MIDI device names.
+
+The returned array will be empty if the system MIDI driver has not previously been initialised with :ref:`open_midi_inputs<class_OS_method_open_midi_inputs>`.
+
 ----
 
 .. _class_OS_method_get_current_video_driver:
@@ -1464,6 +1468,8 @@ Resumes native video playback.
 
 - void **open_midi_inputs** **(** **)**
 
+Initialises the singleton for the system MIDI driver.
+
 ----
 
 .. _class_OS_method_print_all_resources:

classes/class_particles.rst

@@ -422,6 +422,8 @@ Returns the axis-aligned bounding box that contains all the particles that are a
 
 - :ref:`Mesh<class_Mesh>` **get_draw_pass_mesh** **(** :ref:`int<class_int>` pass **)** const
 
+Returns the :ref:`Mesh<class_Mesh>` that is drawn at index ``pass``.
+
 ----
 
 .. _class_Particles_method_restart:
@@ -436,3 +438,5 @@ Restarts the particle emission, clearing existing particles.
 
 - void **set_draw_pass_mesh** **(** :ref:`int<class_int>` pass, :ref:`Mesh<class_Mesh>` mesh **)**
 
+Sets the :ref:`Mesh<class_Mesh>` that is drawn at index ``pass``.
+

classes/class_plane.rst

@@ -55,6 +55,8 @@ Methods
 +-------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`Vector3<class_Vector3>` | :ref:`intersects_segment<class_Plane_method_intersects_segment>` **(** :ref:`Vector3<class_Vector3>` begin, :ref:`Vector3<class_Vector3>` end **)**                   |
 +-------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`       | :ref:`is_equal_approx<class_Plane_method_is_equal_approx>` **(** :ref:`Plane<class_Plane>` plane **)**                                                                |
++-------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`bool<class_bool>`       | :ref:`is_point_over<class_Plane_method_is_point_over>` **(** :ref:`Vector3<class_Vector3>` point **)**                                                                |
 +-------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`Plane<class_Plane>`     | :ref:`normalized<class_Plane_method_normalized>` **(** **)**                                                                                                          |
@@ -217,6 +219,12 @@ Returns the intersection point of a segment from position ``begin`` to position
 
 ----
 
+.. _class_Plane_method_is_equal_approx:
+
+- :ref:`bool<class_bool>` **is_equal_approx** **(** :ref:`Plane<class_Plane>` plane **)**
+
+----
+
 .. _class_Plane_method_is_point_over:
 
 - :ref:`bool<class_bool>` **is_point_over** **(** :ref:`Vector3<class_Vector3>` point **)**

classes/class_poolbytearray.rst

@@ -30,6 +30,8 @@ Methods
 +-------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`PoolByteArray<class_PoolByteArray>` | :ref:`decompress<class_PoolByteArray_method_decompress>` **(** :ref:`int<class_int>` buffer_size, :ref:`int<class_int>` compression_mode=0 **)** |
 +-------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`                   | :ref:`empty<class_PoolByteArray_method_empty>` **(** **)**                                                                                       |
++-------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`String<class_String>`               | :ref:`get_string_from_ascii<class_PoolByteArray_method_get_string_from_ascii>` **(** **)**                                                       |
 +-------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`String<class_String>`               | :ref:`get_string_from_utf8<class_PoolByteArray_method_get_string_from_utf8>` **(** **)**                                                         |
@@ -103,6 +105,14 @@ Returns a new ``PoolByteArray`` with the data decompressed. Set ``buffer_size``
 
 ----
 
+.. _class_PoolByteArray_method_empty:
+
+- :ref:`bool<class_bool>` **empty** **(** **)**
+
+Returns ``true`` if the array is empty.
+
+----
+
 .. _class_PoolByteArray_method_get_string_from_ascii:
 
 - :ref:`String<class_String>` **get_string_from_ascii** **(** **)**

classes/class_poolcolorarray.rst

@@ -26,6 +26,8 @@ Methods
 +---------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------+
 | void                                        | :ref:`append_array<class_PoolColorArray_method_append_array>` **(** :ref:`PoolColorArray<class_PoolColorArray>` array **)** |
 +---------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`                     | :ref:`empty<class_PoolColorArray_method_empty>` **(** **)**                                                                 |
++---------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------+
 | :ref:`int<class_int>`                       | :ref:`insert<class_PoolColorArray_method_insert>` **(** :ref:`int<class_int>` idx, :ref:`Color<class_Color>` color **)**    |
 +---------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------+
 | void                                        | :ref:`invert<class_PoolColorArray_method_invert>` **(** **)**                                                               |
@@ -75,6 +77,14 @@ Appends a ``PoolColorArray`` at the end of this array.
 
 ----
 
+.. _class_PoolColorArray_method_empty:
+
+- :ref:`bool<class_bool>` **empty** **(** **)**
+
+Returns ``true`` if the array is empty.
+
+----
+
 .. _class_PoolColorArray_method_insert:
 
 - :ref:`int<class_int>` **insert** **(** :ref:`int<class_int>` idx, :ref:`Color<class_Color>` color **)**

classes/class_poolintarray.rst

@@ -26,6 +26,8 @@ Methods
 +-----------------------------------------+-----------------------------------------------------------------------------------------------------------------------+
 | void                                    | :ref:`append_array<class_PoolIntArray_method_append_array>` **(** :ref:`PoolIntArray<class_PoolIntArray>` array **)** |
 +-----------------------------------------+-----------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`                 | :ref:`empty<class_PoolIntArray_method_empty>` **(** **)**                                                             |
++-----------------------------------------+-----------------------------------------------------------------------------------------------------------------------+
 | :ref:`int<class_int>`                   | :ref:`insert<class_PoolIntArray_method_insert>` **(** :ref:`int<class_int>` idx, :ref:`int<class_int>` integer **)**  |
 +-----------------------------------------+-----------------------------------------------------------------------------------------------------------------------+
 | void                                    | :ref:`invert<class_PoolIntArray_method_invert>` **(** **)**                                                           |
@@ -77,6 +79,14 @@ Appends a ``PoolIntArray`` at the end of this array.
 
 ----
 
+.. _class_PoolIntArray_method_empty:
+
+- :ref:`bool<class_bool>` **empty** **(** **)**
+
+Returns ``true`` if the array is empty.
+
+----
+
 .. _class_PoolIntArray_method_insert:
 
 - :ref:`int<class_int>` **insert** **(** :ref:`int<class_int>` idx, :ref:`int<class_int>` integer **)**

classes/class_poolrealarray.rst

@@ -26,6 +26,8 @@ Methods
 +-------------------------------------------+--------------------------------------------------------------------------------------------------------------------------+
 | void                                      | :ref:`append_array<class_PoolRealArray_method_append_array>` **(** :ref:`PoolRealArray<class_PoolRealArray>` array **)** |
 +-------------------------------------------+--------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`                   | :ref:`empty<class_PoolRealArray_method_empty>` **(** **)**                                                               |
++-------------------------------------------+--------------------------------------------------------------------------------------------------------------------------+
 | :ref:`int<class_int>`                     | :ref:`insert<class_PoolRealArray_method_insert>` **(** :ref:`int<class_int>` idx, :ref:`float<class_float>` value **)**  |
 +-------------------------------------------+--------------------------------------------------------------------------------------------------------------------------+
 | void                                      | :ref:`invert<class_PoolRealArray_method_invert>` **(** **)**                                                             |
@@ -75,6 +77,14 @@ Appends a ``PoolRealArray`` at the end of this array.
 
 ----
 
+.. _class_PoolRealArray_method_empty:
+
+- :ref:`bool<class_bool>` **empty** **(** **)**
+
+Returns ``true`` if the array is empty.
+
+----
+
 .. _class_PoolRealArray_method_insert:
 
 - :ref:`int<class_int>` **insert** **(** :ref:`int<class_int>` idx, :ref:`float<class_float>` value **)**

classes/class_poolstringarray.rst

@@ -26,6 +26,8 @@ Methods
 +-----------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------+
 | void                                          | :ref:`append_array<class_PoolStringArray_method_append_array>` **(** :ref:`PoolStringArray<class_PoolStringArray>` array **)** |
 +-----------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`                       | :ref:`empty<class_PoolStringArray_method_empty>` **(** **)**                                                                   |
++-----------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`int<class_int>`                         | :ref:`insert<class_PoolStringArray_method_insert>` **(** :ref:`int<class_int>` idx, :ref:`String<class_String>` string **)**   |
 +-----------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------+
 | void                                          | :ref:`invert<class_PoolStringArray_method_invert>` **(** **)**                                                                 |
@@ -77,6 +79,14 @@ Appends a ``PoolStringArray`` at the end of this array.
 
 ----
 
+.. _class_PoolStringArray_method_empty:
+
+- :ref:`bool<class_bool>` **empty** **(** **)**
+
+Returns ``true`` if the array is empty.
+
+----
+
 .. _class_PoolStringArray_method_insert:
 
 - :ref:`int<class_int>` **insert** **(** :ref:`int<class_int>` idx, :ref:`String<class_String>` string **)**

classes/class_poolvector2array.rst

@@ -26,6 +26,8 @@ Methods
 +-------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------+
 | void                                            | :ref:`append_array<class_PoolVector2Array_method_append_array>` **(** :ref:`PoolVector2Array<class_PoolVector2Array>` array **)** |
 +-------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`                         | :ref:`empty<class_PoolVector2Array_method_empty>` **(** **)**                                                                     |
++-------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`int<class_int>`                           | :ref:`insert<class_PoolVector2Array_method_insert>` **(** :ref:`int<class_int>` idx, :ref:`Vector2<class_Vector2>` vector2 **)**  |
 +-------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------+
 | void                                            | :ref:`invert<class_PoolVector2Array_method_invert>` **(** **)**                                                                   |
@@ -75,6 +77,14 @@ Appends a ``PoolVector2Array`` at the end of this array.
 
 ----
 
+.. _class_PoolVector2Array_method_empty:
+
+- :ref:`bool<class_bool>` **empty** **(** **)**
+
+Returns ``true`` if the array is empty.
+
+----
+
 .. _class_PoolVector2Array_method_insert:
 
 - :ref:`int<class_int>` **insert** **(** :ref:`int<class_int>` idx, :ref:`Vector2<class_Vector2>` vector2 **)**

classes/class_poolvector3array.rst

@@ -26,6 +26,8 @@ Methods
 +-------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------+
 | void                                            | :ref:`append_array<class_PoolVector3Array_method_append_array>` **(** :ref:`PoolVector3Array<class_PoolVector3Array>` array **)** |
 +-------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`                         | :ref:`empty<class_PoolVector3Array_method_empty>` **(** **)**                                                                     |
++-------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`int<class_int>`                           | :ref:`insert<class_PoolVector3Array_method_insert>` **(** :ref:`int<class_int>` idx, :ref:`Vector3<class_Vector3>` vector3 **)**  |
 +-------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------+
 | void                                            | :ref:`invert<class_PoolVector3Array_method_invert>` **(** **)**                                                                   |
@@ -75,6 +77,14 @@ Appends a ``PoolVector3Array`` at the end of this array.
 
 ----
 
+.. _class_PoolVector3Array_method_empty:
+
+- :ref:`bool<class_bool>` **empty** **(** **)**
+
+Returns ``true`` if the array is empty.
+
+----
+
 .. _class_PoolVector3Array_method_insert:
 
 - :ref:`int<class_int>` **insert** **(** :ref:`int<class_int>` idx, :ref:`Vector3<class_Vector3>` vector3 **)**

classes/class_popupmenu.rst

@@ -647,7 +647,7 @@ Sets whether the item at index ``idx`` has a checkbox. If ``false``, sets the ty
 
 - void **set_item_as_radio_checkable** **(** :ref:`int<class_int>` idx, :ref:`bool<class_bool>` enable **)**
 
-Sets the type of the item at the specified index ``idx`` to radio button. If false, sets the type of the item to plain text.
+Sets the type of the item at the specified index ``idx`` to radio button. If ``false``, sets the type of the item to plain text.
 
 ----
 

classes/class_projectsettings.rst

@@ -94,6 +94,8 @@ Properties
 +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`bool<class_bool>`                       | :ref:`debug/gdscript/warnings/enable<class_ProjectSettings_property_debug/gdscript/warnings/enable>`                                                                 | true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
 +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`                       | :ref:`debug/gdscript/warnings/exclude_addons<class_ProjectSettings_property_debug/gdscript/warnings/exclude_addons>`                                                 | true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
++-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`bool<class_bool>`                       | :ref:`debug/gdscript/warnings/function_conflicts_constant<class_ProjectSettings_property_debug/gdscript/warnings/function_conflicts_constant>`                       | true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
 +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`bool<class_bool>`                       | :ref:`debug/gdscript/warnings/function_conflicts_variable<class_ProjectSettings_property_debug/gdscript/warnings/function_conflicts_variable>`                       | true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
@@ -192,8 +194,6 @@ Properties
 +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`bool<class_bool>`                       | :ref:`display/window/vsync/use_vsync<class_ProjectSettings_property_display/window/vsync/use_vsync>`                                                                 | true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
 +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`bool<class_bool>`                       | :ref:`editor/active<class_ProjectSettings_property_editor/active>`                                                                                                   | false                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-+-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`String<class_String>`                   | :ref:`editor/script_templates_search_path<class_ProjectSettings_property_editor/script_templates_search_path>`                                                       | "res://script_templates"                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`PoolStringArray<class_PoolStringArray>` | :ref:`editor/search_in_file_extensions<class_ProjectSettings_property_editor/search_in_file_extensions>`                                                             | PoolStringArray( "gd", "shader" )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
@@ -1050,6 +1050,18 @@ If ``true``, enables specific GDScript warnings (see ``debug/gdscript/warnings/*
 
 ----
 
+.. _class_ProjectSettings_property_debug/gdscript/warnings/exclude_addons:
+
+- :ref:`bool<class_bool>` **debug/gdscript/warnings/exclude_addons**
+
++-----------+------+
+| *Default* | true |
++-----------+------+
+
+If ``true``, scripts in the ``res://addons`` folder will not generate warnings.
+
+----
+
 .. _class_ProjectSettings_property_debug/gdscript/warnings/function_conflicts_constant:
 
 - :ref:`bool<class_bool>` **debug/gdscript/warnings/function_conflicts_constant**
@@ -1636,18 +1648,6 @@ If ``true``, enables vertical synchronization. This eliminates tearing that may
 
 ----
 
-.. _class_ProjectSettings_property_editor/active:
-
-- :ref:`bool<class_bool>` **editor/active**
-
-+-----------+-------+
-| *Default* | false |
-+-----------+-------+
-
-Internal editor setting, don't touch.
-
-----
-
 .. _class_ProjectSettings_property_editor/script_templates_search_path:
 
 - :ref:`String<class_String>` **editor/script_templates_search_path**
@@ -3810,6 +3810,8 @@ Saves the configuration to a custom file.
 
 - void **set_initial_value** **(** :ref:`String<class_String>` name, :ref:`Variant<class_Variant>` value **)**
 
+Sets the specified property's initial value. This is the value the property reverts to.
+
 ----
 
 .. _class_ProjectSettings_method_set_order:
@@ -3824,3 +3826,11 @@ Sets the order of a configuration value (influences when saved to the config fil
 
 - void **set_setting** **(** :ref:`String<class_String>` name, :ref:`Variant<class_Variant>` value **)**
 
+Sets the value of a setting.
+
+**Example:**
+
+::
+
+    ProjectSettings.set_setting("application/config/name", "Example")
+

classes/class_quat.rst

@@ -49,6 +49,8 @@ Methods
 +-------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`Quat<class_Quat>`       | :ref:`inverse<class_Quat_method_inverse>` **(** **)**                                                                                                                               |
 +-------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`       | :ref:`is_equal_approx<class_Quat_method_is_equal_approx>` **(** :ref:`Quat<class_Quat>` quat **)**                                                                                  |
++-------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`bool<class_bool>`       | :ref:`is_normalized<class_Quat_method_is_normalized>` **(** **)**                                                                                                                   |
 +-------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`float<class_float>`     | :ref:`length<class_Quat_method_length>` **(** **)**                                                                                                                                 |
@@ -199,6 +201,12 @@ Returns the inverse of the quaternion.
 
 ----
 
+.. _class_Quat_method_is_equal_approx:
+
+- :ref:`bool<class_bool>` **is_equal_approx** **(** :ref:`Quat<class_Quat>` quat **)**
+
+----
+
 .. _class_Quat_method_is_normalized:
 
 - :ref:`bool<class_bool>` **is_normalized** **(** **)**

classes/class_raycast.rst

@@ -79,6 +79,11 @@ Only enabled raycasts will be able to query the space and report collisions.
 
 RayCast calculates intersection every physics frame (see :ref:`Node<class_Node>`), and the result is cached so it can be used later until the next frame. If multiple queries are required between physics frames (or during the same frame), use :ref:`force_raycast_update<class_RayCast_method_force_raycast_update>` after adjusting the raycast.
 
+Tutorials
+---------
+
+- :doc:`../tutorials/physics/ray-casting`
+
 Property Descriptions
 ---------------------
 

classes/class_raycast2d.rst

@@ -79,6 +79,11 @@ Only enabled raycasts will be able to query the space and report collisions.
 
 RayCast2D calculates intersection every physics frame (see :ref:`Node<class_Node>`), and the result is cached so it can be used later until the next frame. If multiple queries are required between physics frames (or during the same frame) use :ref:`force_raycast_update<class_RayCast2D_method_force_raycast_update>` after adjusting the raycast.
 
+Tutorials
+---------
+
+- :doc:`../tutorials/physics/ray-casting`
+
 Property Descriptions
 ---------------------
 

classes/class_rect2.rst

@@ -57,6 +57,8 @@ Methods
 +---------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`bool<class_bool>`   | :ref:`intersects<class_Rect2_method_intersects>` **(** :ref:`Rect2<class_Rect2>` b **)**                                                                                                                 |
 +---------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`   | :ref:`is_equal_approx<class_Rect2_method_is_equal_approx>` **(** :ref:`Rect2<class_Rect2>` rect **)**                                                                                                    |
++---------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`Rect2<class_Rect2>` | :ref:`merge<class_Rect2_method_merge>` **(** :ref:`Rect2<class_Rect2>` b **)**                                                                                                                           |
 +---------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
@@ -212,6 +214,12 @@ Returns ``true`` if the ``Rect2`` overlaps with another.
 
 ----
 
+.. _class_Rect2_method_is_equal_approx:
+
+- :ref:`bool<class_bool>` **is_equal_approx** **(** :ref:`Rect2<class_Rect2>` rect **)**
+
+----
+
 .. _class_Rect2_method_merge:
 
 - :ref:`Rect2<class_Rect2>` **merge** **(** :ref:`Rect2<class_Rect2>` b **)**

classes/class_softbody.rst

@@ -40,6 +40,8 @@ Properties
 +---------------------------------+-------------------------------------------------------------------------------------+--------------+
 | :ref:`float<class_float>`       | :ref:`pressure_coefficient<class_SoftBody_property_pressure_coefficient>`           | 0.0          |
 +---------------------------------+-------------------------------------------------------------------------------------+--------------+
+| :ref:`bool<class_bool>`         | :ref:`ray_pickable<class_SoftBody_property_ray_pickable>`                           | true         |
++---------------------------------+-------------------------------------------------------------------------------------+--------------+
 | :ref:`int<class_int>`           | :ref:`simulation_precision<class_SoftBody_property_simulation_precision>`           | 5            |
 +---------------------------------+-------------------------------------------------------------------------------------+--------------+
 | :ref:`float<class_float>`       | :ref:`total_mass<class_SoftBody_property_total_mass>`                               | 1.0          |
@@ -59,22 +61,23 @@ Methods
 +---------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`bool<class_bool>`   | :ref:`get_collision_mask_bit<class_SoftBody_method_get_collision_mask_bit>` **(** :ref:`int<class_int>` bit **)** const                            |
 +---------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`bool<class_bool>`   | :ref:`is_ray_pickable<class_SoftBody_method_is_ray_pickable>` **(** **)** const                                                                    |
-+---------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+
 | void                      | :ref:`remove_collision_exception_with<class_SoftBody_method_remove_collision_exception_with>` **(** :ref:`Node<class_Node>` body **)**             |
 +---------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+
 | void                      | :ref:`set_collision_layer_bit<class_SoftBody_method_set_collision_layer_bit>` **(** :ref:`int<class_int>` bit, :ref:`bool<class_bool>` value **)** |
 +---------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+
 | void                      | :ref:`set_collision_mask_bit<class_SoftBody_method_set_collision_mask_bit>` **(** :ref:`int<class_int>` bit, :ref:`bool<class_bool>` value **)**   |
 +---------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                      | :ref:`set_ray_pickable<class_SoftBody_method_set_ray_pickable>` **(** :ref:`bool<class_bool>` ray_pickable **)**                                   |
-+---------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+
 
 Description
 -----------
 
 A deformable physics body. Used to create elastic or deformable objects such as cloth, rubber, or other flexible materials.
 
+Tutorials
+---------
+
+- :doc:`../tutorials/physics/soft_body`
+
 Property Descriptions
 ---------------------
 
@@ -104,7 +107,7 @@ Property Descriptions
 | *Getter*  | get_collision_layer()      |
 +-----------+----------------------------+
 
-The physics layers this area is in.
+The physics layers this SoftBody is in.
 
 Collidable objects can exist in any of 32 different layers. These layers work like a tagging system, and are not visual. A collidable can use these layers to select with which objects it can collide, using the collision_mask property.
 
@@ -124,7 +127,7 @@ A contact is detected if object A is in any of the layers that object B scans, o
 | *Getter*  | get_collision_mask()      |
 +-----------+---------------------------+
 
-The physics layers this area scans for collisions.
+The physics layers this SoftBody scans for collisions.
 
 ----
 
@@ -182,6 +185,8 @@ The physics layers this area scans for collisions.
 | *Getter*  | get_parent_collision_ignore()      |
 +-----------+------------------------------------+
 
+:ref:`NodePath<class_NodePath>` to a :ref:`CollisionObject<class_CollisionObject>` this SoftBody should avoid clipping.
+
 ----
 
 .. _class_SoftBody_property_pose_matching_coefficient:
@@ -212,6 +217,22 @@ The physics layers this area scans for collisions.
 
 ----
 
+.. _class_SoftBody_property_ray_pickable:
+
+- :ref:`bool<class_bool>` **ray_pickable**
+
++-----------+-------------------------+
+| *Default* | true                    |
++-----------+-------------------------+
+| *Setter*  | set_ray_pickable(value) |
++-----------+-------------------------+
+| *Getter*  | is_ray_pickable()       |
++-----------+-------------------------+
+
+If ``true``, the ``SoftBody`` will respond to :ref:`RayCast<class_RayCast>`\ s.
+
+----
+
 .. _class_SoftBody_property_simulation_precision:
 
 - :ref:`int<class_int>` **simulation_precision**
@@ -240,6 +261,8 @@ Increasing this value will improve the resulting simulation, but can affect perf
 | *Getter*  | get_total_mass()      |
 +-----------+-----------------------+
 
+The SoftBody's mass.
+
 ----
 
 .. _class_SoftBody_property_volume_stiffness:
@@ -289,12 +312,6 @@ Returns an individual bit on the collision mask.
 
 ----
 
-.. _class_SoftBody_method_is_ray_pickable:
-
-- :ref:`bool<class_bool>` **is_ray_pickable** **(** **)** const
-
-----
-
 .. _class_SoftBody_method_remove_collision_exception_with:
 
 - void **remove_collision_exception_with** **(** :ref:`Node<class_Node>` body **)**
@@ -317,9 +334,3 @@ Sets individual bits on the layer mask. Use this if you only need to change one
 
 Sets individual bits on the collision mask. Use this if you only need to change one layer's value.
 
-----
-
-.. _class_SoftBody_method_set_ray_pickable:
-
-- void **set_ray_pickable** **(** :ref:`bool<class_bool>` ray_pickable **)**
-

classes/class_spatial.rst

@@ -286,6 +286,8 @@ Method Descriptions
 
 - void **force_update_transform** **(** **)**
 
+Forces the transform to update. Transform changes in physics are not instant for performance reasons. Transforms are accumulated and then set. Use this if you need an up-to-date transform when doing physics operations.
+
 ----
 
 .. _class_Spatial_method_get_parent_spatial:
@@ -316,6 +318,8 @@ Rotates the global (world) transformation around axis, a unit :ref:`Vector3<clas
 
 - void **global_scale** **(** :ref:`Vector3<class_Vector3>` scale **)**
 
+Scales the global (world) transformation by the given :ref:`Vector3<class_Vector3>` scale factors.
+
 ----
 
 .. _class_Spatial_method_global_translate:
@@ -346,6 +350,8 @@ Returns whether node notifies about its local transformation changes. ``Spatial`
 
 - :ref:`bool<class_bool>` **is_scale_disabled** **(** **)** const
 
+Returns whether this node uses a scale of ``(1, 1, 1)`` or its local transformation scale.
+
 ----
 
 .. _class_Spatial_method_is_set_as_toplevel:
@@ -460,6 +466,8 @@ Makes the node ignore its parents transformations. Node transformations are only
 
 - void **set_disable_scale** **(** :ref:`bool<class_bool>` disable **)**
 
+Sets whether the node uses a scale of ``(1, 1, 1)`` or its local transformation scale. Changes to the local transformation scale are preserved.
+
 ----
 
 .. _class_Spatial_method_set_identity:

classes/class_string.rst

@@ -610,7 +610,7 @@ Converts ``size`` represented as number of bytes to human-readable format using
 
 - :ref:`String<class_String>` **insert** **(** :ref:`int<class_int>` position, :ref:`String<class_String>` what **)**
 
-Inserts a substring at a given position.
+Returns a copy of the string with the substring ``what`` inserted at the given position.
 
 ----
 

classes/class_textedit.rst

@@ -315,6 +315,20 @@ enum **SearchFlags**:
 
 ----
 
+.. _enum_TextEdit_SearchResult:
+
+.. _class_TextEdit_constant_SEARCH_RESULT_COLUMN:
+
+.. _class_TextEdit_constant_SEARCH_RESULT_LINE:
+
+enum **SearchResult**:
+
+- **SEARCH_RESULT_COLUMN** = **0** --- Used to access the result column from :ref:`search<class_TextEdit_method_search>`.
+
+- **SEARCH_RESULT_LINE** = **1** --- Used to access the result line from :ref:`search<class_TextEdit_method_search>`.
+
+----
+
 .. _enum_TextEdit_MenuItems:
 
 .. _class_TextEdit_constant_MENU_CUT:
@@ -335,7 +349,7 @@ enum **SearchFlags**:
 
 enum **MenuItems**:
 
-- **MENU_CUT** = **0** --- Cuts (Copies and clears) the selected text.
+- **MENU_CUT** = **0** --- Cuts (copies and clears) the selected text.
 
 - **MENU_COPY** = **1** --- Copies the selected text.
 
@@ -814,7 +828,7 @@ Returns the line the editing cursor is at.
 
 Moves the cursor at the specified ``column`` index.
 
-If ``adjust_viewport`` is set to true, the viewport will center at the cursor position after the move occurs.
+If ``adjust_viewport`` is set to ``true``, the viewport will center at the cursor position after the move occurs.
 
 ----
 
@@ -824,9 +838,9 @@ If ``adjust_viewport`` is set to true, the viewport will center at the cursor po
 
 Moves the cursor at the specified ``line`` index.
 
-If ``adjust_viewport`` is set to true, the viewport will center at the cursor position after the move occurs.
+If ``adjust_viewport`` is set to ``true``, the viewport will center at the cursor position after the move occurs.
 
-If ``can_be_hidden`` is set to true, the specified ``line`` can be hidden using :ref:`set_line_as_hidden<class_TextEdit_method_set_line_as_hidden>`.
+If ``can_be_hidden`` is set to ``true``, the specified ``line`` can be hidden using :ref:`set_line_as_hidden<class_TextEdit_method_set_line_as_hidden>`.
 
 ----
 
@@ -1026,7 +1040,17 @@ Removes all the breakpoints. This will not fire the :ref:`breakpoint_toggled<cla
 
 - :ref:`PoolIntArray<class_PoolIntArray>` **search** **(** :ref:`String<class_String>` key, :ref:`int<class_int>` flags, :ref:`int<class_int>` from_line, :ref:`int<class_int>` from_column **)** const
 
-Perform a search inside the text. Search flags can be specified in the``SEARCH_*`` enum.
+Perform a search inside the text. Search flags can be specified in the :ref:`SearchFlags<enum_TextEdit_SearchFlags>` enum.
+
+Returns an empty ``PoolIntArray`` if no result was found. Otherwise, the result line and column can be accessed at indices specified in the :ref:`SearchResult<enum_TextEdit_SearchResult>` enum, e.g:
+
+::
+
+    var result = search(key, flags, line, column)
+    if result.size() > 0:
+        # result found
+        var res_line = result[TextEdit.SEARCH_RESULT_LINE]
+        var res_column = result[TextEdit.SEARCH_RESULT_COLUMN]
 
 ----
 

classes/class_theme.rst

@@ -124,6 +124,8 @@ Method Descriptions
 
 - void **clear** **(** **)**
 
+Clears all values on the theme.
+
 ----
 
 .. _class_Theme_method_clear_color:
@@ -178,6 +180,8 @@ Sets the Theme's values to a copy of the default theme values.
 
 - void **copy_theme** **(** :ref:`Theme<class_Theme>` other **)**
 
+Sets the Theme's values to a copy of a given theme.
+
 ----
 
 .. _class_Theme_method_get_color:

classes/class_tilemap.rst

@@ -212,6 +212,8 @@ Property Descriptions
 | *Getter*  | get_clip_uv()      |
 +-----------+--------------------+
 
+If ``true``, the cell's UVs will be clipped.
+
 ----
 
 .. _class_TileMap_property_cell_custom_transform:
@@ -420,6 +422,8 @@ If ``true``, TileMap collisions will be handled as a kinematic body. If ``false`
 | *Getter*  | get_collision_use_parent()      |
 +-----------+---------------------------------+
 
+If ``true``, this tilemap's collision shape will be added to the collision shape of the parent. The parent has to be a :ref:`CollisionObject2D<class_CollisionObject2D>`.
+
 ----
 
 .. _class_TileMap_property_compatibility_mode:
@@ -517,6 +521,8 @@ Returns the tile index of the given cell. If no tile exists in the cell, returns
 
 - :ref:`Vector2<class_Vector2>` **get_cell_autotile_coord** **(** :ref:`int<class_int>` x, :ref:`int<class_int>` y **)** const
 
+Returns the coordinate of the autotile variation in the tileset. Returns a zero vector if the cell doesn't have autotiling.
+
 ----
 
 .. _class_TileMap_method_get_cellv:

classes/class_touchscreenbutton.rst

@@ -188,7 +188,7 @@ The button's shape.
 | *Getter*  | is_shape_centered()       |
 +-----------+---------------------------+
 
-If ``true``, the button's shape is centered.
+If ``true``, the button's shape is centered in the provided texture. If no texture is used, this property has no effect.
 
 ----
 

classes/class_transform.rst

@@ -45,6 +45,8 @@ Methods
 +-----------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`Transform<class_Transform>` | :ref:`inverse<class_Transform_method_inverse>` **(** **)**                                                                                                                                                            |
 +-----------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`           | :ref:`is_equal_approx<class_Transform_method_is_equal_approx>` **(** :ref:`Transform<class_Transform>` transform **)**                                                                                                |
++-----------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`Transform<class_Transform>` | :ref:`looking_at<class_Transform_method_looking_at>` **(** :ref:`Vector3<class_Vector3>` target, :ref:`Vector3<class_Vector3>` up **)**                                                                               |
 +-----------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`Transform<class_Transform>` | :ref:`orthonormalized<class_Transform_method_orthonormalized>` **(** **)**                                                                                                                                            |
@@ -175,6 +177,12 @@ Returns the inverse of the transform, under the assumption that the transformati
 
 ----
 
+.. _class_Transform_method_is_equal_approx:
+
+- :ref:`bool<class_bool>` **is_equal_approx** **(** :ref:`Transform<class_Transform>` transform **)**
+
+----
+
 .. _class_Transform_method_looking_at:
 
 - :ref:`Transform<class_Transform>` **looking_at** **(** :ref:`Vector3<class_Vector3>` target, :ref:`Vector3<class_Vector3>` up **)**

classes/class_transform2d.rst

@@ -53,6 +53,8 @@ Methods
 +---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`Transform2D<class_Transform2D>` | :ref:`inverse<class_Transform2D_method_inverse>` **(** **)**                                                                                                                          |
 +---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`               | :ref:`is_equal_approx<class_Transform2D_method_is_equal_approx>` **(** :ref:`Transform2D<class_Transform2D>` transform **)**                                                          |
++---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`Transform2D<class_Transform2D>` | :ref:`orthonormalized<class_Transform2D_method_orthonormalized>` **(** **)**                                                                                                          |
 +---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`Transform2D<class_Transform2D>` | :ref:`rotated<class_Transform2D_method_rotated>` **(** :ref:`float<class_float>` phi **)**                                                                                            |
@@ -210,6 +212,12 @@ Returns the inverse of the transform, under the assumption that the transformati
 
 ----
 
+.. _class_Transform2D_method_is_equal_approx:
+
+- :ref:`bool<class_bool>` **is_equal_approx** **(** :ref:`Transform2D<class_Transform2D>` transform **)**
+
+----
+
 .. _class_Transform2D_method_orthonormalized:
 
 - :ref:`Transform2D<class_Transform2D>` **orthonormalized** **(** **)**

classes/class_variant.rst

@@ -19,8 +19,48 @@ The most important data type in Godot.
 Description
 -----------
 
+In computer programming, a Variant class is a class that is designed to store a variety of other types. Dynamic programming languages like PHP, Lua, JavaScript and GDScript like to use them to store variables' data on the backend. With these Variants, properties are able to change value types freely.
+
+::
+
+    var foo = 2 # foo is dynamically an integer
+    foo = "Now foo is a string!"
+    foo = Reference.new() # foo is an Object
+    var bar: int = 2 # bar is a statically typed integer.
+    # bar = "Uh oh! I can't make static variables become a different type!"
+
+Godot tracks all scripting API variables within Variants. Without even realizing it, you use Variants all the time. When a particular language enforces its own rules for keeping data typed, then that language is applying its own custom logic over the base Variant scripting API.
+
+- GDScript automatically wrap values in them. It keeps all data in plain Variants by default and then optionally enforces custom static typing rules on variable types.
+
+- VisualScript tracks properties inside Variants as well, but it also uses static typing. The GUI interface enforces that properties have a particular type that doesn't change over time.
+
+- C# is statically typed, but uses the Mono ``object`` type in place of Godot's Variant class when it needs to represent a dynamic value. ``object`` is the Mono runtime's equivalent of the same concept.
+
+- The statically-typed language NativeScript C++ does not define a built-in Variant-like class. Godot's GDNative bindings provide their own godot::Variant class for users; Any point at which the C++ code starts interacting with the Godot runtime is a place where you might have to start wrapping data inside Variant objects.
+
+The global :ref:`@GDScript.typeof<class_@GDScript_method_typeof>` function returns the enumerated value of the Variant type stored in the current variable. These correspond to ``TYPE_*`` constants in the :ref:`@GlobalScope<class_@GlobalScope>` docs.
+
+::
+
+    var foo = 2
+    match typeof(foo):
+        TYPE_NIL:
+            print("foo is null")
+        TYPE_INTEGER:
+            print("foo is an integer")
+        TYPE_OBJECT:
+            # Note that Objects are their own special category.
+            # To get the name of the underlying Object type, you need the `get_class()` method.
+            print("foo is a(n) %s" % foo.get_class()) # inject the class name into a formatted string.
+            # Note also that there is not yet any way to get a script's `class_name` string easily.
+            # To fetch that value, you need to dig deeply into a hidden ProjectSettings setting: an Array of Dictionaries called "_global_script_classes".
+            # Open your project.godot file to see it up close.
+
 A Variant takes up only 20 bytes and can store almost any engine datatype inside of it. Variants are rarely used to hold information for long periods of time. Instead, they are used mainly for communication, editing, serialization and moving data around.
 
+Godot has specifically invested in making its Variant class as flexible as possible; so much so that it is used for a multitude of operations to facilitate communication between all of Godot's systems.
+
 A Variant:
 
 - Can store almost any datatype.
@@ -43,7 +83,12 @@ A Variant:
 
 - Can be used for dictionaries, arrays, parsers, etc.
 
-**Containers (:ref:`Array<class_Array>` and :ref:`Dictionary<class_Dictionary>`):** Both are implemented using variants. A :ref:`Dictionary<class_Dictionary>` can match any datatype used as key to any other datatype. An :ref:`Array<class_Array>` just holds an array of Variants. Of course, a Variant can also hold a :ref:`Dictionary<class_Dictionary>` and an :ref:`Array<class_Array>` inside, making it even more flexible.
+**Containers (Array and Dictionary):** Both are implemented using variants. A :ref:`Dictionary<class_Dictionary>` can match any datatype used as key to any other datatype. An :ref:`Array<class_Array>` just holds an array of Variants. Of course, a Variant can also hold a :ref:`Dictionary<class_Dictionary>` and an :ref:`Array<class_Array>` inside, making it even more flexible.
 
 Modifications to a container will modify all references to it. A :ref:`Mutex<class_Mutex>` should be created to lock it if multi-threaded access is desired.
 
+Tutorials
+---------
+
+- :doc:`../development/cpp/variant_class`
+

classes/class_vector2.rst

@@ -61,6 +61,8 @@ Methods
 +-------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`Vector2<class_Vector2>` | :ref:`floor<class_Vector2_method_floor>` **(** **)**                                                                                                                                                                 |
 +-------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`       | :ref:`is_equal_approx<class_Vector2_method_is_equal_approx>` **(** :ref:`Vector2<class_Vector2>` v **)**                                                                                                             |
++-------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`bool<class_bool>`       | :ref:`is_normalized<class_Vector2_method_is_normalized>` **(** **)**                                                                                                                                                 |
 +-------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`float<class_float>`     | :ref:`length<class_Vector2_method_length>` **(** **)**                                                                                                                                                               |
@@ -303,6 +305,12 @@ Returns the vector with all components rounded down.
 
 ----
 
+.. _class_Vector2_method_is_equal_approx:
+
+- :ref:`bool<class_bool>` **is_equal_approx** **(** :ref:`Vector2<class_Vector2>` v **)**
+
+----
+
 .. _class_Vector2_method_is_normalized:
 
 - :ref:`bool<class_bool>` **is_normalized** **(** **)**

classes/class_vector3.rst

@@ -57,6 +57,8 @@ Methods
 +-------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`Vector3<class_Vector3>` | :ref:`inverse<class_Vector3_method_inverse>` **(** **)**                                                                                                                                                             |
 +-------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`       | :ref:`is_equal_approx<class_Vector3_method_is_equal_approx>` **(** :ref:`Vector3<class_Vector3>` v **)**                                                                                                             |
++-------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`bool<class_bool>`       | :ref:`is_normalized<class_Vector3_method_is_normalized>` **(** **)**                                                                                                                                                 |
 +-------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`float<class_float>`     | :ref:`length<class_Vector3_method_length>` **(** **)**                                                                                                                                                               |
@@ -303,6 +305,12 @@ Returns the inverse of the vector. This is the same as ``Vector3( 1.0 / v.x, 1.0
 
 ----
 
+.. _class_Vector3_method_is_equal_approx:
+
+- :ref:`bool<class_bool>` **is_equal_approx** **(** :ref:`Vector3<class_Vector3>` v **)**
+
+----
+
 .. _class_Vector3_method_is_normalized:
 
 - :ref:`bool<class_bool>` **is_normalized** **(** **)**

classes/class_visualshadernodeinput.rst

@@ -27,6 +27,13 @@ Properties
 | :ref:`String<class_String>` | :ref:`input_name<class_VisualShaderNodeInput_property_input_name>` | "[None]"    |
 +-----------------------------+--------------------------------------------------------------------+-------------+
 
+Methods
+-------
+
++-----------------------------+------------------------------------------------------------------------------------------------------+
+| :ref:`String<class_String>` | :ref:`get_input_real_name<class_VisualShaderNodeInput_method_get_input_real_name>` **(** **)** const |
++-----------------------------+------------------------------------------------------------------------------------------------------+
+
 Signals
 -------
 
@@ -49,3 +56,10 @@ Property Descriptions
 | *Getter*  | get_input_name()      |
 +-----------+-----------------------+
 
+Method Descriptions
+-------------------
+
+.. _class_VisualShaderNodeInput_method_get_input_real_name:
+
+- :ref:`String<class_String>` **get_input_real_name** **(** **)** const
+