Sync classref with current source

classes/class_area.rst

@@ -74,19 +74,19 @@ Emitted when a :ref:`PhysicsBody<class_physicsbody>` object enters.
 
 - **body_exited** **(** :ref:`Object<class_object>` body **)**
 
-Emitted when a :ref:`PhysicsBody2D<class_physicsbody2d>` object exits.
+Emitted when a :ref:`PhysicsBody<class_physicsbody>` object exits.
 
 .. _class_Area_body_shape_entered:
 
 - **body_shape_entered** **(** :ref:`int<class_int>` body_id, :ref:`Object<class_object>` body, :ref:`int<class_int>` body_shape, :ref:`int<class_int>` area_shape **)**
 
-Emitted when a :ref:`PhysicsBody2D<class_physicsbody2d>` object enters, reporting which shapes overlapped.
+Emitted when a :ref:`PhysicsBody<class_physicsbody>` object enters, reporting which shapes overlapped.
 
 .. _class_Area_body_shape_exited:
 
 - **body_shape_exited** **(** :ref:`int<class_int>` body_id, :ref:`Object<class_object>` body, :ref:`int<class_int>` body_shape, :ref:`int<class_int>` area_shape **)**
 
-Emitted when a :ref:`PhysicsBody2D<class_physicsbody2d>` object exits, reporting which shapes were overlapping.
+Emitted when a :ref:`PhysicsBody<class_physicsbody>` object exits, reporting which shapes were overlapping.
 
 
 Member Variables

classes/class_array.rst

@@ -78,6 +78,8 @@ Member Functions
 +----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`int<class_int>`      | :ref:`rfind<class_Array_rfind>` **(** var what, :ref:`int<class_int>` from=-1 **)**                                                                                             |
 +----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                       | :ref:`shuffle<class_Array_shuffle>` **(** **)**                                                                                                                                 |
++----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`int<class_int>`      | :ref:`size<class_Array_size>` **(** **)**                                                                                                                                       |
 +----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | void                       | :ref:`sort<class_Array_sort>` **(** **)**                                                                                                                                       |
@@ -280,6 +282,12 @@ Resize the array to contain a different number of elements. If the array size is
 
 Searches the array in reverse order. Optionally, a start search index can be passed. If negative, the start index is considered relative to the end of the array.
 
+.. _class_Array_shuffle:
+
+- void **shuffle** **(** **)**
+
+Shuffle the array such that the items will have a random order.
+
 .. _class_Array_size:
 
 - :ref:`int<class_int>` **size** **(** **)**

classes/class_bitmap.rst

@@ -19,21 +19,21 @@ Boolean matrix.
 Member Functions
 ----------------
 
-+--------------------------------+--------------------------------------------------------------------------------------------------------------------------+
-| void                           | :ref:`create<class_BitMap_create>` **(** :ref:`Vector2<class_vector2>` size **)**                                        |
-+--------------------------------+--------------------------------------------------------------------------------------------------------------------------+
-| void                           | :ref:`create_from_image_alpha<class_BitMap_create_from_image_alpha>` **(** :ref:`Image<class_image>` image **)**         |
-+--------------------------------+--------------------------------------------------------------------------------------------------------------------------+
-| :ref:`bool<class_bool>`        | :ref:`get_bit<class_BitMap_get_bit>` **(** :ref:`Vector2<class_vector2>` position **)** const                            |
-+--------------------------------+--------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Vector2<class_vector2>`  | :ref:`get_size<class_BitMap_get_size>` **(** **)** const                                                                 |
-+--------------------------------+--------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`          | :ref:`get_true_bit_count<class_BitMap_get_true_bit_count>` **(** **)** const                                             |
-+--------------------------------+--------------------------------------------------------------------------------------------------------------------------+
-| void                           | :ref:`set_bit<class_BitMap_set_bit>` **(** :ref:`Vector2<class_vector2>` position, :ref:`bool<class_bool>` bit **)**     |
-+--------------------------------+--------------------------------------------------------------------------------------------------------------------------+
-| void                           | :ref:`set_bit_rect<class_BitMap_set_bit_rect>` **(** :ref:`Rect2<class_rect2>` p_rect, :ref:`bool<class_bool>` bit **)** |
-+--------------------------------+--------------------------------------------------------------------------------------------------------------------------+
++--------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                           | :ref:`create<class_BitMap_create>` **(** :ref:`Vector2<class_vector2>` size **)**                                                                         |
++--------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                           | :ref:`create_from_image_alpha<class_BitMap_create_from_image_alpha>` **(** :ref:`Image<class_image>` image, :ref:`float<class_float>` threshold=0.1 **)** |
++--------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`        | :ref:`get_bit<class_BitMap_get_bit>` **(** :ref:`Vector2<class_vector2>` position **)** const                                                             |
++--------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Vector2<class_vector2>`  | :ref:`get_size<class_BitMap_get_size>` **(** **)** const                                                                                                  |
++--------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`          | :ref:`get_true_bit_count<class_BitMap_get_true_bit_count>` **(** **)** const                                                                              |
++--------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                           | :ref:`set_bit<class_BitMap_set_bit>` **(** :ref:`Vector2<class_vector2>` position, :ref:`bool<class_bool>` bit **)**                                      |
++--------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                           | :ref:`set_bit_rect<class_BitMap_set_bit_rect>` **(** :ref:`Rect2<class_rect2>` p_rect, :ref:`bool<class_bool>` bit **)**                                  |
++--------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------+
 
 Description
 -----------
@@ -51,9 +51,9 @@ Creates a bitmap with the specified size, filled with false.
 
 .. _class_BitMap_create_from_image_alpha:
 
-- void **create_from_image_alpha** **(** :ref:`Image<class_image>` image **)**
+- void **create_from_image_alpha** **(** :ref:`Image<class_image>` image, :ref:`float<class_float>` threshold=0.1 **)**
 
-Creates a bitmap that matches the given image dimensions, every element of the bitmap is set to false if the alpha value of the image at that position is 0, and true in other case.
+Creates a bitmap that matches the given image dimensions, every element of the bitmap is set to false if the alpha value of the image at that position is equal to ``threshold`` or less, and true in other case.
 
 .. _class_BitMap_get_bit:
 

classes/class_buttongroup.rst

@@ -28,6 +28,8 @@ Description
 
 Group of :ref:`Button<class_button>`. All direct and indirect children buttons become radios. Only one allows being pressed.
 
+:ref:`BaseButton.toggle_mode<class_BaseButton_toggle_mode>` should be ``true``.
+
 Member Function Description
 ---------------------------
 

classes/class_camera.rst

@@ -74,7 +74,7 @@ Member Variables
 
   .. _class_Camera_h_offset:
 
-- :ref:`float<class_float>` **h_offset** - The horizontal (X) offset of the Camear viewport.
+- :ref:`float<class_float>` **h_offset** - The horizontal (X) offset of the Camera viewport.
 
   .. _class_Camera_keep_aspect:
 
@@ -94,7 +94,7 @@ Member Variables
 
   .. _class_Camera_v_offset:
 
-- :ref:`float<class_float>` **v_offset** - The horizontal (Y) offset of the Camear viewport.
+- :ref:`float<class_float>` **v_offset** - The horizontal (Y) offset of the Camera viewport.
 
 
 Enums

classes/class_canvasitem.rst

@@ -32,10 +32,14 @@ Member Functions
 +----------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | void                                   | :ref:`draw_line<class_CanvasItem_draw_line>` **(** :ref:`Vector2<class_vector2>` from, :ref:`Vector2<class_vector2>` to, :ref:`Color<class_color>` color, :ref:`float<class_float>` width=1.0, :ref:`bool<class_bool>` antialiased=false **)**                                                                                                                                            |
 +----------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                   | :ref:`draw_mesh<class_CanvasItem_draw_mesh>` **(** :ref:`Mesh<class_mesh>` mesh, :ref:`Texture<class_texture>` texture, :ref:`Texture<class_texture>` normal_map=null **)**                                                                                                                                                                                                               |
++----------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | void                                   | :ref:`draw_multiline<class_CanvasItem_draw_multiline>` **(** :ref:`PoolVector2Array<class_poolvector2array>` points, :ref:`Color<class_color>` color, :ref:`float<class_float>` width=1.0, :ref:`bool<class_bool>` antialiased=false **)**                                                                                                                                                |
 +----------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | void                                   | :ref:`draw_multiline_colors<class_CanvasItem_draw_multiline_colors>` **(** :ref:`PoolVector2Array<class_poolvector2array>` points, :ref:`PoolColorArray<class_poolcolorarray>` colors, :ref:`float<class_float>` width=1.0, :ref:`bool<class_bool>` antialiased=false **)**                                                                                                               |
 +----------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                   | :ref:`draw_multimesh<class_CanvasItem_draw_multimesh>` **(** :ref:`Mesh<class_mesh>` mesh, :ref:`Texture<class_texture>` texture, :ref:`Texture<class_texture>` normal_map=null **)**                                                                                                                                                                                                     |
++----------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | void                                   | :ref:`draw_polygon<class_CanvasItem_draw_polygon>` **(** :ref:`PoolVector2Array<class_poolvector2array>` points, :ref:`PoolColorArray<class_poolcolorarray>` colors, :ref:`PoolVector2Array<class_poolvector2array>` uvs=PoolVector2Array(  ), :ref:`Texture<class_texture>` texture=null, :ref:`Texture<class_texture>` normal_map=null, :ref:`bool<class_bool>` antialiased=false **)** |
 +----------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | void                                   | :ref:`draw_polyline<class_CanvasItem_draw_polyline>` **(** :ref:`PoolVector2Array<class_poolvector2array>` points, :ref:`Color<class_color>` color, :ref:`float<class_float>` width=1.0, :ref:`bool<class_bool>` antialiased=false **)**                                                                                                                                                  |
@@ -240,6 +244,10 @@ Draws a colored polygon of any amount of points, convex or concave.
 
 Draws a line from a 2D point to another, with a given color and width. It can be optionally antialiased.
 
+.. _class_CanvasItem_draw_mesh:
+
+- void **draw_mesh** **(** :ref:`Mesh<class_mesh>` mesh, :ref:`Texture<class_texture>` texture, :ref:`Texture<class_texture>` normal_map=null **)**
+
 .. _class_CanvasItem_draw_multiline:
 
 - void **draw_multiline** **(** :ref:`PoolVector2Array<class_poolvector2array>` points, :ref:`Color<class_color>` color, :ref:`float<class_float>` width=1.0, :ref:`bool<class_bool>` antialiased=false **)**
@@ -252,6 +260,10 @@ Draws multiple, parallel lines with a uniform ``color`` and ``width`` and option
 
 Draws multiple, parallel lines with a uniform ``width``, segment-by-segment coloring, and optional antialiasing. Colors assigned to line segments match by index between ``points`` and ``colors``.
 
+.. _class_CanvasItem_draw_multimesh:
+
+- void **draw_multimesh** **(** :ref:`Mesh<class_mesh>` mesh, :ref:`Texture<class_texture>` texture, :ref:`Texture<class_texture>` normal_map=null **)**
+
 .. _class_CanvasItem_draw_polygon:
 
 - void **draw_polygon** **(** :ref:`PoolVector2Array<class_poolvector2array>` points, :ref:`PoolColorArray<class_poolcolorarray>` colors, :ref:`PoolVector2Array<class_poolvector2array>` uvs=PoolVector2Array(  ), :ref:`Texture<class_texture>` texture=null, :ref:`Texture<class_texture>` normal_map=null, :ref:`bool<class_bool>` antialiased=false **)**

classes/class_color.rst

@@ -17,35 +17,37 @@ Color in RGBA format with some support for ARGB format.
 Member Functions
 ----------------
 
-+------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Color<class_color>`    | :ref:`Color<class_Color_Color>` **(** :ref:`float<class_float>` r, :ref:`float<class_float>` g, :ref:`float<class_float>` b, :ref:`float<class_float>` a **)** |
-+------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Color<class_color>`    | :ref:`Color<class_Color_Color>` **(** :ref:`float<class_float>` r, :ref:`float<class_float>` g, :ref:`float<class_float>` b **)**                              |
-+------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Color<class_color>`    | :ref:`Color<class_Color_Color>` **(** :ref:`int<class_int>` from **)**                                                                                         |
-+------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Color<class_color>`    | :ref:`Color<class_Color_Color>` **(** :ref:`String<class_string>` from **)**                                                                                   |
-+------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Color<class_color>`    | :ref:`blend<class_Color_blend>` **(** :ref:`Color<class_color>` over **)**                                                                                     |
-+------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Color<class_color>`    | :ref:`contrasted<class_Color_contrasted>` **(** **)**                                                                                                          |
-+------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Color<class_color>`    | :ref:`darkened<class_Color_darkened>` **(** :ref:`float<class_float>` amount **)**                                                                             |
-+------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`float<class_float>`    | :ref:`gray<class_Color_gray>` **(** **)**                                                                                                                      |
-+------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Color<class_color>`    | :ref:`inverted<class_Color_inverted>` **(** **)**                                                                                                              |
-+------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Color<class_color>`    | :ref:`lightened<class_Color_lightened>` **(** :ref:`float<class_float>` amount **)**                                                                           |
-+------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Color<class_color>`    | :ref:`linear_interpolate<class_Color_linear_interpolate>` **(** :ref:`Color<class_color>` b, :ref:`float<class_float>` t **)**                                 |
-+------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`        | :ref:`to_argb32<class_Color_to_argb32>` **(** **)**                                                                                                            |
-+------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`String<class_string>`  | :ref:`to_html<class_Color_to_html>` **(** :ref:`bool<class_bool>` with_alpha=True **)**                                                                        |
-+------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`        | :ref:`to_rgba32<class_Color_to_rgba32>` **(** **)**                                                                                                            |
-+------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------+
++------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Color<class_color>`    | :ref:`Color<class_Color_Color>` **(** :ref:`float<class_float>` r, :ref:`float<class_float>` g, :ref:`float<class_float>` b, :ref:`float<class_float>` a **)**         |
++------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Color<class_color>`    | :ref:`Color<class_Color_Color>` **(** :ref:`float<class_float>` r, :ref:`float<class_float>` g, :ref:`float<class_float>` b **)**                                      |
++------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Color<class_color>`    | :ref:`Color<class_Color_Color>` **(** :ref:`int<class_int>` from **)**                                                                                                 |
++------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Color<class_color>`    | :ref:`Color<class_Color_Color>` **(** :ref:`String<class_string>` from **)**                                                                                           |
++------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Color<class_color>`    | :ref:`blend<class_Color_blend>` **(** :ref:`Color<class_color>` over **)**                                                                                             |
++------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Color<class_color>`    | :ref:`contrasted<class_Color_contrasted>` **(** **)**                                                                                                                  |
++------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Color<class_color>`    | :ref:`darkened<class_Color_darkened>` **(** :ref:`float<class_float>` amount **)**                                                                                     |
++------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Color<class_color>`    | :ref:`from_hsv<class_Color_from_hsv>` **(** :ref:`float<class_float>` h, :ref:`float<class_float>` s, :ref:`float<class_float>` v, :ref:`float<class_float>` a=1 **)** |
++------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`float<class_float>`    | :ref:`gray<class_Color_gray>` **(** **)**                                                                                                                              |
++------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Color<class_color>`    | :ref:`inverted<class_Color_inverted>` **(** **)**                                                                                                                      |
++------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Color<class_color>`    | :ref:`lightened<class_Color_lightened>` **(** :ref:`float<class_float>` amount **)**                                                                                   |
++------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Color<class_color>`    | :ref:`linear_interpolate<class_Color_linear_interpolate>` **(** :ref:`Color<class_color>` b, :ref:`float<class_float>` t **)**                                         |
++------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`        | :ref:`to_argb32<class_Color_to_argb32>` **(** **)**                                                                                                                    |
++------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`String<class_string>`  | :ref:`to_html<class_Color_to_html>` **(** :ref:`bool<class_bool>` with_alpha=True **)**                                                                                |
++------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`        | :ref:`to_rgba32<class_Color_to_rgba32>` **(** **)**                                                                                                                    |
++------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
 Member Variables
 ----------------
@@ -193,6 +195,16 @@ Returns a new color resulting from making this color darker by the specified per
     var green = Color(0.0, 1.0, 0.0)
     var darkgreen = green.darkened(0.2) # 20% darker than regular green
 
+.. _class_Color_from_hsv:
+
+- :ref:`Color<class_color>` **from_hsv** **(** :ref:`float<class_float>` h, :ref:`float<class_float>` s, :ref:`float<class_float>` v, :ref:`float<class_float>` a=1 **)**
+
+Constructs a color from an HSV profile. ``h`` is a value between 0 and 360. ``s`` and ``v`` are values between 0 and 1.
+
+::
+
+    var c = Color.from_hsv(210, 0.5, 0.79, 0.8) # equivalent to HSV(210, 50, 79, 0.8) or Color8(100, 151, 201, 0.8)
+
 .. _class_Color_gray:
 
 - :ref:`float<class_float>` **gray** **(** **)**

classes/class_configfile.rst

@@ -42,7 +42,7 @@ Member Functions
 Description
 -----------
 
-This helper class can be used to store :ref:`Variant<class_variant>` values on the filesystem using INI-style formatting. The stored values are indentified by a section and a key:
+This helper class can be used to store :ref:`Variant<class_variant>` values on the filesystem using INI-style formatting. The stored values are identified by a section and a key:
 
 ::
 

classes/class_control.rst

@@ -522,14 +522,43 @@ Overrides the ``name`` Stylebox in the theme resource the node uses. If ``styleb
 
 - :ref:`bool<class_bool>` **can_drop_data** **(** :ref:`Vector2<class_vector2>` position, :ref:`Variant<class_variant>` data **)** virtual
 
+Godot calls this method to test if ``data`` from a control's :ref:`get_drag_data<class_Control_get_drag_data>` can be dropped at ``position``. ``position`` is local to this control.
+
+This method should only be used to test the data. Process the data in :ref:`drop_data<class_Control_drop_data>`.
+
+::
+
+    extends Control
+    
+    func can_drop_data(position, data):
+        # check position if it is relevant to you
+        # otherwise just check data
+        return typeof(data) == TYPE_DICTIONARY and data.has('expected')
+
 .. _class_Control_drop_data:
 
 - void **drop_data** **(** :ref:`Vector2<class_vector2>` position, :ref:`Variant<class_variant>` data **)** virtual
 
+Godot calls this method to pass you the ``data`` from a control's :ref:`get_drag_data<class_Control_get_drag_data>` result. Godot first calls :ref:`can_drop_data<class_Control_can_drop_data>` to test if ``data`` is allowed to drop at ``position`` where ``position`` is local to this control.
+
+::
+
+    extends ColorRect
+    
+    func can_drop_data(position, data):
+        return typeof(data) == TYPE_DICTIONARY and data.has('color')
+    
+    func drop_data(position, data):
+        color = data['color']
+
 .. _class_Control_force_drag:
 
 - void **force_drag** **(** :ref:`Variant<class_variant>` data, :ref:`Control<class_control>` preview **)**
 
+Forces drag and bypasses :ref:`get_drag_data<class_Control_get_drag_data>` and :ref:`set_drag_preview<class_Control_set_drag_preview>` by passing ``data`` and ``preview``. Drag will start even if the mouse is neither over nor pressed on this control.
+
+The methods :ref:`can_drop_data<class_Control_can_drop_data>` and :ref:`drop_data<class_Control_drop_data>` must be implemented on controls that want to recieve drop data.
+
 .. _class_Control_get_begin:
 
 - :ref:`Vector2<class_vector2>` **get_begin** **(** **)** const
@@ -556,6 +585,19 @@ Returns the mouse cursor shape the control displays on mouse hover, one of the `
 
 - :ref:`Object<class_object>` **get_drag_data** **(** :ref:`Vector2<class_vector2>` position **)** virtual
 
+Godot calls this method to get data that can be dragged and dropped onto controls that expect drop data. Return null if there is no data to drag. Controls that want to recieve drop data should implement :ref:`can_drop_data<class_Control_can_drop_data>` and :ref:`drop_data<class_Control_drop_data>`. ``position`` is local to this control. Drag may be forced with :ref:`force_drag<class_Control_force_drag>`.
+
+A preview that will follow the mouse that should represent the data can be set with :ref:`set_drag_preview<class_Control_set_drag_preview>`. A good time to set the preview is in this method.
+
+::
+
+    extends Control
+    
+    func get_drag_data(position):
+        var mydata = make_data()
+        set_drag_preview(make_preview(mydata))
+        return mydata
+
 .. _class_Control_get_end:
 
 - :ref:`Vector2<class_vector2>` **get_end** **(** **)** const
@@ -718,10 +760,39 @@ Sets MARGIN_LEFT and MARGIN_TOP at the same time. This is a helper (see :ref:`se
 
 - void **set_drag_forwarding** **(** :ref:`Control<class_control>` target **)**
 
+Forwards the handling of this control's drag and drop to ``target`` control.
+
+Forwarding can be implemented in the target control similar to the methods :ref:`get_drag_data<class_Control_get_drag_data>`, :ref:`can_drop_data<class_Control_can_drop_data>`, and :ref:`drop_data<class_Control_drop_data>` but with two differences:
+
+1. The function name must be suffixed with **_fw**
+
+2. The function must take an extra argument that is the control doing the forwarding
+
+::
+
+    # ThisControl.gd
+    extends Control
+    func _ready():
+        set_drag_forwarding(target_control)
+    
+    # TargetControl.gd
+    extends Control
+    func can_drop_data_fw(position, data, from_control):
+        return true
+    
+    func drop_data_fw(position, data, from_control):
+        my_handle_data(data)
+    
+    func get_drag_data_fw(position, from_control):
+        set_drag_preview(my_preview)
+        return my_data()
+
 .. _class_Control_set_drag_preview:
 
 - 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_get_drag_data>`.
+
 .. _class_Control_set_end:
 
 - void **set_end** **(** :ref:`Vector2<class_vector2>` position **)**

classes/class_dynamicfontdata.rst

@@ -23,6 +23,22 @@ Member Variables
 
 - :ref:`String<class_string>` **font_path** - The path to the vector font file.
 
+  .. _class_DynamicFontData_hinting:
+
+- :ref:`Hinting<enum_dynamicfontdata_hinting>` **hinting** - The font hinting mode used by FreeType.
+
+
+Enums
+-----
+
+  .. _enum_DynamicFontData_Hinting:
+
+enum **Hinting**
+
+- **HINTING_NONE** = **0** --- Disable font hinting (smoother but less crisp).
+- **HINTING_LIGHT** = **1** --- Use the light font hinting mode.
+- **HINTING_NORMAL** = **2** --- Use the default font hinting mode (crisper but less smooth).
+
 
 Description
 -----------

classes/class_editorplugin.rst

@@ -19,6 +19,8 @@ Used by the editor to extend its functionality.
 Member Functions
 ----------------
 
++------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                 | :ref:`add_autoload_singleton<class_EditorPlugin_add_autoload_singleton>` **(** :ref:`String<class_string>` name, :ref:`String<class_string>` path **)**                                                           |
 +------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`ToolButton<class_toolbutton>`                  | :ref:`add_control_to_bottom_panel<class_EditorPlugin_add_control_to_bottom_panel>` **(** :ref:`Control<class_control>` control, :ref:`String<class_string>` title **)**                                           |
 +------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -78,6 +80,8 @@ Member Functions
 +------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | void                                                 | :ref:`queue_save_layout<class_EditorPlugin_queue_save_layout>` **(** **)** const                                                                                                                                  |
 +------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                 | :ref:`remove_autoload_singleton<class_EditorPlugin_remove_autoload_singleton>` **(** :ref:`String<class_string>` name **)**                                                                                       |
++------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | void                                                 | :ref:`remove_control_from_bottom_panel<class_EditorPlugin_remove_control_from_bottom_panel>` **(** :ref:`Control<class_control>` control **)**                                                                    |
 +------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | void                                                 | :ref:`remove_control_from_container<class_EditorPlugin_remove_control_from_container>` **(** :ref:`int<class_int>` container, :ref:`Control<class_control>` control **)**                                         |
@@ -166,6 +170,12 @@ Plugins are used by the editor to extend functionality. The most common types of
 Member Function Description
 ---------------------------
 
+.. _class_EditorPlugin_add_autoload_singleton:
+
+- void **add_autoload_singleton** **(** :ref:`String<class_string>` name, :ref:`String<class_string>` path **)**
+
+Add a script at ``path`` to the Autoload list as ``name``.
+
 .. _class_EditorPlugin_add_control_to_bottom_panel:
 
 - :ref:`ToolButton<class_toolbutton>` **add_control_to_bottom_panel** **(** :ref:`Control<class_control>` control, :ref:`String<class_string>` title **)**
@@ -336,6 +346,12 @@ Remember that you have to manage the visibility of all your editor controls manu
 
 Queue save the project's editor layout.
 
+.. _class_EditorPlugin_remove_autoload_singleton:
+
+- void **remove_autoload_singleton** **(** :ref:`String<class_string>` name **)**
+
+Remove an Autoload ``name`` from the list.
+
 .. _class_EditorPlugin_remove_control_from_bottom_panel:
 
 - void **remove_control_from_bottom_panel** **(** :ref:`Control<class_control>` control **)**

classes/class_environment.rst

@@ -390,9 +390,11 @@ enum **SSAOQuality**
 Description
 -----------
 
-Resource for environment nodes (like :ref:`WorldEnvironment<class_worldenvironment>`) that define multiple environment operations (such as background :ref:`Sky<class_sky>` or :ref:`Color<class_color>`, ambient light, fog, depth-of-field...).	These parameters affect the final render of the scene. The order of these operations is:
+Resource for environment nodes (like :ref:`WorldEnvironment<class_worldenvironment>`) that define multiple environment operations (such as background :ref:`Sky<class_sky>` or :ref:`Color<class_color>`, ambient light, fog, depth-of-field...). These parameters affect the final render of the scene. The order of these operations is:
 
- 		- DOF Blur
+ 		
+
+- DOF Blur
 
 - Motion Blur
 

classes/class_file.rst

@@ -56,6 +56,10 @@ Member Functions
 +------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`String<class_string>`                    | :ref:`get_pascal_string<class_File_get_pascal_string>` **(** **)**                                                                                                                    |
 +------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`String<class_string>`                    | :ref:`get_path<class_File_get_path>` **(** **)**                                                                                                                                      |
++------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`String<class_string>`                    | :ref:`get_path_absolute<class_File_get_path_absolute>` **(** **)**                                                                                                                    |
++------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`int<class_int>`                          | :ref:`get_position<class_File_get_position>` **(** **)** const                                                                                                                        |
 +------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`float<class_float>`                      | :ref:`get_real<class_File_get_real>` **(** **)** const                                                                                                                                |
@@ -110,7 +114,7 @@ Member Variables
 
 - :ref:`bool<class_bool>` **endian_swap** - If ``true`` the file's endianness is swapped. Use this if you're dealing with files written in big endian machines.
 
-Note that this is about the file format, not CPU type. This is always reseted to ``false`` whenever you open the file.
+Note that this is about the file format, not CPU type. This is always reset to ``false`` whenever you open the file.
 
 
 Enums
@@ -268,6 +272,18 @@ Returns the last time the ``file`` was modified in unix timestamp format or retu
 
 Returns a :ref:`String<class_string>` saved in Pascal format from the file.
 
+.. _class_File_get_path:
+
+- :ref:`String<class_string>` **get_path** **(** **)**
+
+Returns the path as a :ref:`String<class_string>` for the current open file.
+
+.. _class_File_get_path_absolute:
+
+- :ref:`String<class_string>` **get_path_absolute** **(** **)**
+
+Returns the absolute path as a :ref:`String<class_string>` for the current open file.
+
 .. _class_File_get_position:
 
 - :ref:`int<class_int>` **get_position** **(** **)** const

classes/class_httpclient.rst

@@ -148,7 +148,7 @@ enum **ResponseCode**
 - **RESPONSE_UPGRADE_REQUIRED** = **426** --- HTTP status code ``426 Upgrade Required``. The server refuses to perform the request using the current protocol but might be willing to do so after the client upgrades to a different protocol.
 - **RESPONSE_PRECONDITION_REQUIRED** = **428** --- HTTP status code ``428 Precondition Required``. The origin server requires the request to be conditional.
 - **RESPONSE_TOO_MANY_REQUESTS** = **429** --- HTTP status code ``429 Too Many Requests``. The user has sent too many requests in a given amount of time (see "rate limiting"). Back off and increase time between requests or try again later.
-- **RESPONSE_REQUEST_HEADER_FIELDS_TOO_LARGE** = **431** --- HTTP status code ``431 Rquest Header Fields Too Large``. The server is unwilling to process the request because its header fields are too large. The request MAY be resubmitted after reducing the size of the request header fields.
+- **RESPONSE_REQUEST_HEADER_FIELDS_TOO_LARGE** = **431** --- HTTP status code ``431 Request Header Fields Too Large``. The server is unwilling to process the request because its header fields are too large. The request MAY be resubmitted after reducing the size of the request header fields.
 - **RESPONSE_UNAVAILABLE_FOR_LEGAL_REASONS** = **451** --- HTTP status code ``451 Response Unavailable For Legal Reasons``. The server is denying access to the resource as a consequence of a legal demand.
 - **RESPONSE_INTERNAL_SERVER_ERROR** = **500** --- HTTP status code ``500 Internal Server Error``. The server encountered an unexpected condition that prevented it from fulfilling the request.
 - **RESPONSE_NOT_IMPLEMENTED** = **501** --- HTTP status code ``501 Not Implemented``. The server does not support the functionality required to fulfill the request.

classes/class_image.rst

@@ -162,41 +162,41 @@ enum **Format**
 
 - **FORMAT_L8** = **0**
 - **FORMAT_LA8** = **1**
-- **FORMAT_R8** = **2**
-- **FORMAT_RG8** = **3**
-- **FORMAT_RGB8** = **4**
-- **FORMAT_RGBA8** = **5**
-- **FORMAT_RGBA4444** = **6**
-- **FORMAT_RGBA5551** = **7**
-- **FORMAT_RF** = **8**
-- **FORMAT_RGF** = **9**
-- **FORMAT_RGBF** = **10**
-- **FORMAT_RGBAF** = **11**
-- **FORMAT_RH** = **12**
-- **FORMAT_RGH** = **13**
-- **FORMAT_RGBH** = **14**
-- **FORMAT_RGBAH** = **15**
-- **FORMAT_RGBE9995** = **16**
-- **FORMAT_DXT1** = **17**
-- **FORMAT_DXT3** = **18**
-- **FORMAT_DXT5** = **19**
-- **FORMAT_RGTC_R** = **20**
-- **FORMAT_RGTC_RG** = **21**
-- **FORMAT_BPTC_RGBA** = **22**
-- **FORMAT_BPTC_RGBF** = **23**
-- **FORMAT_BPTC_RGBFU** = **24**
-- **FORMAT_PVRTC2** = **25**
-- **FORMAT_PVRTC2A** = **26**
-- **FORMAT_PVRTC4** = **27**
-- **FORMAT_PVRTC4A** = **28**
-- **FORMAT_ETC** = **29**
-- **FORMAT_ETC2_R11** = **30**
-- **FORMAT_ETC2_R11S** = **31**
-- **FORMAT_ETC2_RG11** = **32**
-- **FORMAT_ETC2_RG11S** = **33**
-- **FORMAT_ETC2_RGB8** = **34**
-- **FORMAT_ETC2_RGBA8** = **35**
-- **FORMAT_ETC2_RGB8A1** = **36**
+- **FORMAT_R8** = **2** --- OpenGL texture format RED with a single component and a bitdepth of 8.
+- **FORMAT_RG8** = **3** --- OpenGL texture format RG with two components and a bitdepth of 8 for each.
+- **FORMAT_RGB8** = **4** --- OpenGL texture format RGB with three components, each with a bitdepth of 8.
+- **FORMAT_RGBA8** = **5** --- OpenGL texture format RGBA with four components, each with a bitdepth of 8.
+- **FORMAT_RGBA4444** = **6** --- OpenGL texture format RGBA with four components, each with a bitdepth of 4.
+- **FORMAT_RGBA5551** = **7** --- OpenGL texture format GL_RGB5_A1 where 5 bits of depth for each component of RGB and one bit for alpha.
+- **FORMAT_RF** = **8** --- OpenGL texture format GL_R32F where there's one component, a 32-bit floating-point value.
+- **FORMAT_RGF** = **9** --- OpenGL texture format GL_RG32F where there are two components, each a 32-bit floating-point values.
+- **FORMAT_RGBF** = **10** --- OpenGL texture format GL_RGB32F where there are three components, each a 32-bit floating-point values.
+- **FORMAT_RGBAF** = **11** --- OpenGL texture format GL_RGBA32F where there are four components, each a 32-bit floating-point values.
+- **FORMAT_RH** = **12** --- OpenGL texture format GL_R32F where there's one component, a 16-bit "half-precision" floating-point value.
+- **FORMAT_RGH** = **13** --- OpenGL texture format GL_RG32F where there's two components, each a 16-bit "half-precision" floating-point value.
+- **FORMAT_RGBH** = **14** --- OpenGL texture format GL_RGB32F where there's three components, each a 16-bit "half-precision" floating-point value.
+- **FORMAT_RGBAH** = **15** --- OpenGL texture format GL_RGBA32F where there's four components, each a 16-bit "half-precision" floating-point value.
+- **FORMAT_RGBE9995** = **16** --- A special OpenGL texture format where the three color components have 9 bits of precision and all three share a single exponent.
+- **FORMAT_DXT1** = **17** --- The S3TC texture format that uses Block Compression 1, and is the smallest variation of S3TC, only providing 1 bit of alpha and color data being premultiplied with alpha. More information can be found at https://www.khronos.org/opengl/wiki/S3_Texture_Compression.
+- **FORMAT_DXT3** = **18** --- The S3TC texture format that uses Block Compression 2, and color data is interpreted as not having been premultiplied by alpha. Well suited for images with sharp alpha transitions between translucent and opaque areas.
+- **FORMAT_DXT5** = **19** --- The S3TC texture format also known as Block Compression 3 or BC3 that contains 64 bits of alpha channel data followed by 64 bits of DXT1-encoded color data. Color data is not premultiplied by alpha, same as DXT3. DXT5 generally produces superior results for transparency gradients than DXT3.
+- **FORMAT_RGTC_R** = **20** --- Texture format that uses Red Green Texture Compression, normalizing the red channel data using the same compression algorithm that DXT5 uses for the alpha channel. More information can be found here https://www.khronos.org/opengl/wiki/Red_Green_Texture_Compression.
+- **FORMAT_RGTC_RG** = **21** --- Texture format that uses Red Green Texture Compression, normalizing the red and green channel data using the same compression algorithm that DXT5 uses for the alpha channel.
+- **FORMAT_BPTC_RGBA** = **22** --- Texture format that uses BPTC compression with unsigned normalized RGBA components. More information can be found at https://www.khronos.org/opengl/wiki/BPTC_Texture_Compression.
+- **FORMAT_BPTC_RGBF** = **23** --- Texture format that uses BPTC compression with signed floating-point RGB components.
+- **FORMAT_BPTC_RGBFU** = **24** --- Texture format that uses BPTC compression with unsigned floating-point RGB components.
+- **FORMAT_PVRTC2** = **25** --- Texture format used on PowerVR-supported mobile platforms, uses 2 bit color depth with no alpha. More information on PVRTC can be found here https://en.wikipedia.org/wiki/PVRTC.
+- **FORMAT_PVRTC2A** = **26** --- Same as PVRTC2, but with an alpha component.
+- **FORMAT_PVRTC4** = **27** --- Similar to PVRTC2, but with 4 bit color depth and no alpha.
+- **FORMAT_PVRTC4A** = **28** --- Same as PVRTC4, but with an alpha component.
+- **FORMAT_ETC** = **29** --- Ericsson Texture Compression format, also referred to as 'ETC1', and is part of the OpenGL ES graphics standard. An overview of the format is given at https://en.wikipedia.org/wiki/Ericsson_Texture_Compression#ETC1.
+- **FORMAT_ETC2_R11** = **30** --- Ericsson Texture Compression format 2 variant R11_EAC, which provides one channel of unsigned data.
+- **FORMAT_ETC2_R11S** = **31** --- Ericsson Texture Compression format 2 variant SIGNED_R11_EAC, which provides one channel of signed data.
+- **FORMAT_ETC2_RG11** = **32** --- Ericsson Texture Compression format 2 variant RG11_EAC, which provides two channels of unsigned data.
+- **FORMAT_ETC2_RG11S** = **33** --- Ericsson Texture Compression format 2 variant SIGNED_RG11_EAC, which provides two channels of signed data.
+- **FORMAT_ETC2_RGB8** = **34** --- Ericsson Texture Compression format 2 variant RGB8, which is a followup of ETC1 and compresses RGB888 data.
+- **FORMAT_ETC2_RGBA8** = **35** --- Ericsson Texture Compression format 2 variant RGBA8, which compresses RGBA8888 data with full alpha support.
+- **FORMAT_ETC2_RGB8A1** = **36** --- Ericsson Texture Compression format 2 variant RGB8_PUNCHTHROUGH_ALPHA1, which compresses RGBA data to make alpha either fully transparent or fully opaque.
 - **FORMAT_MAX** = **37**
 
 

classes/class_input.rst

@@ -100,7 +100,7 @@ Signals
 
 - **joy_connection_changed** **(** :ref:`int<class_int>` index, :ref:`bool<class_bool>` connected **)**
 
-Emitted when a joypad device has been connected or disconnected
+Emitted when a joypad device has been connected or disconnected.
 
 
 Enums
@@ -113,29 +113,29 @@ enum **MouseMode**
 - **MOUSE_MODE_VISIBLE** = **0** --- Makes the mouse cursor visible if it is hidden.
 - **MOUSE_MODE_HIDDEN** = **1** --- Makes the mouse cursor hidden if it is visible.
 - **MOUSE_MODE_CAPTURED** = **2** --- Captures the mouse. The mouse will be hidden and unable to leave the game window. But it will still register movement and mouse button presses.
-- **MOUSE_MODE_CONFINED** = **3**
+- **MOUSE_MODE_CONFINED** = **3** --- Makes the mouse cursor visible but confines it to the game window.
 
   .. _enum_Input_CursorShape:
 
 enum **CursorShape**
 
-- **CURSOR_ARROW** = **0**
-- **CURSOR_IBEAM** = **1**
-- **CURSOR_POINTING_HAND** = **2**
-- **CURSOR_CROSS** = **3**
-- **CURSOR_WAIT** = **4**
-- **CURSOR_BUSY** = **5**
-- **CURSOR_DRAG** = **6**
-- **CURSOR_CAN_DROP** = **7**
-- **CURSOR_FORBIDDEN** = **8**
-- **CURSOR_VSIZE** = **9**
-- **CURSOR_HSIZE** = **10**
-- **CURSOR_BDIAGSIZE** = **11**
-- **CURSOR_FDIAGSIZE** = **12**
-- **CURSOR_MOVE** = **13**
-- **CURSOR_VSPLIT** = **14**
-- **CURSOR_HSPLIT** = **15**
-- **CURSOR_HELP** = **16**
+- **CURSOR_ARROW** = **0** --- Arrow cursor. Standard, default pointing cursor.
+- **CURSOR_IBEAM** = **1** --- I-beam cursor. Usually used to show where the text cursor will appear when the mouse is clicked.
+- **CURSOR_POINTING_HAND** = **2** --- Pointing hand cursor. Usually used to indicate the pointer is over a link or other interactable item.
+- **CURSOR_CROSS** = **3** --- Cross cursor. Typically appears over regions in which a drawing operation can be performance or for selections.
+- **CURSOR_WAIT** = **4** --- Wait cursor. Indicates that the application is busy performing an operation.
+- **CURSOR_BUSY** = **5** --- Busy cursor. See ``CURSOR_WAIT``.
+- **CURSOR_DRAG** = **6** --- Drag cursor. Usually displayed when dragging something.
+- **CURSOR_CAN_DROP** = **7** --- Can drop cursor. Usually displayed when dragging something to indicate that it can be dropped at the current position.
+- **CURSOR_FORBIDDEN** = **8** --- Forbidden cursor. Indicates that the current action is forbidden (for example, when dragging something) or that the control at a position is disabled.
+- **CURSOR_VSIZE** = **9** --- Vertical resize mouse cursor. A double headed vertical arrow. It tells the user they can resize the window or the panel vertically.
+- **CURSOR_HSIZE** = **10** --- Horizontal resize mouse cursor. A double headed horizontal arrow. It tells the user they can resize the window or the panel horizontally.
+- **CURSOR_BDIAGSIZE** = **11** --- Window resize mouse cursor. The cursor is a double headed arrow that goes from the bottom left to the top right. It tells the user they can resize the window or the panel both horizontally and vertically.
+- **CURSOR_FDIAGSIZE** = **12** --- Window resize mouse cursor. The cursor is a double headed arrow that goes from the top left to the bottom right, the opposite of ``CURSOR_BDIAGSIZE``. It tells the user they can resize the window or the panel both horizontally and vertically.
+- **CURSOR_MOVE** = **13** --- Move cursor. Indicates that something can be moved.
+- **CURSOR_VSPLIT** = **14** --- Vertical split mouse cursor. On Windows, it's the same as ``CURSOR_VSIZE``.
+- **CURSOR_HSPLIT** = **15** --- Horizontal split mouse cursor. On Windows, it's the same as ``CURSOR_HSIZE``.
+- **CURSOR_HELP** = **16** --- Help cursor. Usually a question mark.
 
 
 Description
@@ -168,7 +168,7 @@ Add a new mapping entry (in SDL2 format) to the mapping database. Optionally upd
 
 - :ref:`Vector3<class_vector3>` **get_accelerometer** **(** **)** const
 
-If the device has an accelerometer, this will return the movement.
+If the device has an accelerometer, this will return the acceleration. Otherwise, it returns an empty :ref:`Vector3<class_vector3>`.
 
 .. _class_Input_get_connected_joypads:
 
@@ -180,11 +180,13 @@ Returns an :ref:`Array<class_array>` containing the device IDs of all currently
 
 - :ref:`Vector3<class_vector3>` **get_gravity** **(** **)** const
 
+If the device has an accelerometer, this will return the gravity. Otherwise, it returns an empty :ref:`Vector3<class_vector3>`.
+
 .. _class_Input_get_gyroscope:
 
 - :ref:`Vector3<class_vector3>` **get_gyroscope** **(** **)** const
 
-If the device has a gyroscope, this will return the rate of rotation in rad/s around a device's x, y, and z axis.
+If the device has a gyroscope, this will return the rate of rotation in rad/s around a device's x, y, and z axis. Otherwise, it returns an empty :ref:`Vector3<class_vector3>`.
 
 .. _class_Input_get_joy_axis:
 
@@ -260,13 +262,15 @@ Return the mouse mode. See the constants for more information.
 
 - :ref:`bool<class_bool>` **is_action_just_pressed** **(** :ref:`String<class_string>` action **)** const
 
-Returns ``true`` when you start pressing the action event.
+Returns ``true`` when the user starts pressing the action event, meaning it's true only on the frame that the user pressed down the button.
+
+This is useful for code that needs to run only once when an action is pressed, instead of every frame while it's pressed.
 
 .. _class_Input_is_action_just_released:
 
 - :ref:`bool<class_bool>` **is_action_just_released** **(** :ref:`String<class_string>` action **)** const
 
-Returns ``true`` when you stop pressing the action event.
+Returns ``true`` when the user stops pressing the action event, meaning it's true only on the frame that the user released the button.
 
 .. _class_Input_is_action_pressed:
 
@@ -306,6 +310,8 @@ Returns ``true`` if you are pressing the mouse button. You can pass ``BUTTON_*``
 
 - void **parse_input_event** **(** :ref:`InputEvent<class_inputevent>` event **)**
 
+Feeds an :ref:`InputEvent<class_inputevent>` to the game. Can be used to artificially trigger input events from code.
+
 .. _class_Input_remove_joy_mapping:
 
 - void **remove_joy_mapping** **(** :ref:`String<class_string>` guid **)**

classes/class_instanceplaceholder.rst

@@ -30,7 +30,7 @@ Member Functions
 Description
 -----------
 
-Turning on the option **Load As Placeholder** for an instanced scene in the editor causes it to be replaced by an InstacePlaceholder when running the game. This makes it possible to delay actually loading the scene until calling :ref:`replace_by_instance<class_InstancePlaceholder_replace_by_instance>`. This is useful to avoid loading large scenes all at once by loading parts of it selectively.
+Turning on the option **Load As Placeholder** for an instanced scene in the editor causes it to be replaced by an InstancePlaceholder when running the game. This makes it possible to delay actually loading the scene until calling :ref:`replace_by_instance<class_InstancePlaceholder_replace_by_instance>`. This is useful to avoid loading large scenes all at once by loading parts of it selectively.
 
 The InstancePlaceholder does not have a transform. This causes any child nodes to be positioned relatively to the Viewport from point (0,0), rather than their parent as displayed in the editor. Replacing the placeholder with a scene with a transform will transform children relatively to their parent again.
 

classes/class_kinematicbody.rst

@@ -19,25 +19,25 @@ Kinematic body 3D node.
 Member Functions
 ----------------
 
-+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Vector3<class_vector3>`                        | :ref:`get_floor_velocity<class_KinematicBody_get_floor_velocity>` **(** **)** const                                                                                                                                                                                                                                                |
-+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`KinematicCollision<class_kinematiccollision>`  | :ref:`get_slide_collision<class_KinematicBody_get_slide_collision>` **(** :ref:`int<class_int>` slide_idx **)**                                                                                                                                                                                                                    |
-+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`                                | :ref:`get_slide_count<class_KinematicBody_get_slide_count>` **(** **)** const                                                                                                                                                                                                                                                      |
-+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`bool<class_bool>`                              | :ref:`is_on_ceiling<class_KinematicBody_is_on_ceiling>` **(** **)** const                                                                                                                                                                                                                                                          |
-+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`bool<class_bool>`                              | :ref:`is_on_floor<class_KinematicBody_is_on_floor>` **(** **)** const                                                                                                                                                                                                                                                              |
-+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`bool<class_bool>`                              | :ref:`is_on_wall<class_KinematicBody_is_on_wall>` **(** **)** const                                                                                                                                                                                                                                                                |
-+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`KinematicCollision<class_kinematiccollision>`  | :ref:`move_and_collide<class_KinematicBody_move_and_collide>` **(** :ref:`Vector3<class_vector3>` rel_vec **)**                                                                                                                                                                                                                    |
-+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Vector3<class_vector3>`                        | :ref:`move_and_slide<class_KinematicBody_move_and_slide>` **(** :ref:`Vector3<class_vector3>` linear_velocity, :ref:`Vector3<class_vector3>` floor_normal=Vector3( 0, 0, 0 ), :ref:`float<class_float>` slope_stop_min_velocity=0.05, :ref:`int<class_int>` max_slides=4, :ref:`float<class_float>` floor_max_angle=0.785398 **)** |
-+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`bool<class_bool>`                              | :ref:`test_move<class_KinematicBody_test_move>` **(** :ref:`Transform<class_transform>` from, :ref:`Vector3<class_vector3>` rel_vec **)**                                                                                                                                                                                          |
-+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
++------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Vector3<class_vector3>`                        | :ref:`get_floor_velocity<class_KinematicBody_get_floor_velocity>` **(** **)** const                                                                                                                                                                                                                                                                                               |
++------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`KinematicCollision<class_kinematiccollision>`  | :ref:`get_slide_collision<class_KinematicBody_get_slide_collision>` **(** :ref:`int<class_int>` slide_idx **)**                                                                                                                                                                                                                                                                   |
++------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`                                | :ref:`get_slide_count<class_KinematicBody_get_slide_count>` **(** **)** const                                                                                                                                                                                                                                                                                                     |
++------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`                              | :ref:`is_on_ceiling<class_KinematicBody_is_on_ceiling>` **(** **)** const                                                                                                                                                                                                                                                                                                         |
++------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`                              | :ref:`is_on_floor<class_KinematicBody_is_on_floor>` **(** **)** const                                                                                                                                                                                                                                                                                                             |
++------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`                              | :ref:`is_on_wall<class_KinematicBody_is_on_wall>` **(** **)** const                                                                                                                                                                                                                                                                                                               |
++------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`KinematicCollision<class_kinematiccollision>`  | :ref:`move_and_collide<class_KinematicBody_move_and_collide>` **(** :ref:`Vector3<class_vector3>` rel_vec, :ref:`bool<class_bool>` infinite_inertia=true **)**                                                                                                                                                                                                                    |
++------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Vector3<class_vector3>`                        | :ref:`move_and_slide<class_KinematicBody_move_and_slide>` **(** :ref:`Vector3<class_vector3>` linear_velocity, :ref:`Vector3<class_vector3>` floor_normal=Vector3( 0, 0, 0 ), :ref:`bool<class_bool>` infinite_inertia=true, :ref:`float<class_float>` slope_stop_min_velocity=0.05, :ref:`int<class_int>` max_slides=4, :ref:`float<class_float>` floor_max_angle=0.785398 **)** |
++------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`                              | :ref:`test_move<class_KinematicBody_test_move>` **(** :ref:`Transform<class_transform>` from, :ref:`Vector3<class_vector3>` rel_vec, :ref:`bool<class_bool>` infinite_inertia **)**                                                                                                                                                                                               |
++------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
 Member Variables
 ----------------
@@ -121,13 +121,13 @@ Returns ``true`` if the body is on a wall. Only updates when calling :ref:`move_
 
 .. _class_KinematicBody_move_and_collide:
 
-- :ref:`KinematicCollision<class_kinematiccollision>` **move_and_collide** **(** :ref:`Vector3<class_vector3>` rel_vec **)**
+- :ref:`KinematicCollision<class_kinematiccollision>` **move_and_collide** **(** :ref:`Vector3<class_vector3>` rel_vec, :ref:`bool<class_bool>` infinite_inertia=true **)**
 
 Moves the body along the vector ``rel_vec``. The body will stop if it collides. Returns a :ref:`KinematicCollision<class_kinematiccollision>`, which contains information about the collision.
 
 .. _class_KinematicBody_move_and_slide:
 
-- :ref:`Vector3<class_vector3>` **move_and_slide** **(** :ref:`Vector3<class_vector3>` linear_velocity, :ref:`Vector3<class_vector3>` floor_normal=Vector3( 0, 0, 0 ), :ref:`float<class_float>` slope_stop_min_velocity=0.05, :ref:`int<class_int>` max_slides=4, :ref:`float<class_float>` floor_max_angle=0.785398 **)**
+- :ref:`Vector3<class_vector3>` **move_and_slide** **(** :ref:`Vector3<class_vector3>` linear_velocity, :ref:`Vector3<class_vector3>` floor_normal=Vector3( 0, 0, 0 ), :ref:`bool<class_bool>` infinite_inertia=true, :ref:`float<class_float>` slope_stop_min_velocity=0.05, :ref:`int<class_int>` max_slides=4, :ref:`float<class_float>` floor_max_angle=0.785398 **)**
 
 Moves the body along a vector. If the body collides with another, it will slide along the other body rather than stop immediately. If the other body is a ``KinematicBody`` or :ref:`RigidBody<class_rigidbody>`, it will also be affected by the motion of the other body. You can use this to make moving or rotating platforms, or to make nodes push other nodes.
 
@@ -145,7 +145,7 @@ Returns the movement that remained when the body stopped. To get more detailed i
 
 .. _class_KinematicBody_test_move:
 
-- :ref:`bool<class_bool>` **test_move** **(** :ref:`Transform<class_transform>` from, :ref:`Vector3<class_vector3>` rel_vec **)**
+- :ref:`bool<class_bool>` **test_move** **(** :ref:`Transform<class_transform>` from, :ref:`Vector3<class_vector3>` rel_vec, :ref:`bool<class_bool>` infinite_inertia **)**
 
 Checks for collisions without moving the body. Virtually sets the node's position, scale and rotation to that of the given :ref:`Transform<class_transform>`, then tries to move the body along the vector ``rel_vec``. Returns ``true`` if a collision would occur.
 

classes/class_kinematicbody2d.rst

@@ -19,25 +19,25 @@ Kinematic body 2D node.
 Member Functions
 ----------------
 
-+----------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Vector2<class_vector2>`                            | :ref:`get_floor_velocity<class_KinematicBody2D_get_floor_velocity>` **(** **)** const                                                                                                                                                                                                                                           |
-+----------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`KinematicCollision2D<class_kinematiccollision2d>`  | :ref:`get_slide_collision<class_KinematicBody2D_get_slide_collision>` **(** :ref:`int<class_int>` slide_idx **)**                                                                                                                                                                                                               |
-+----------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`                                    | :ref:`get_slide_count<class_KinematicBody2D_get_slide_count>` **(** **)** const                                                                                                                                                                                                                                                 |
-+----------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`bool<class_bool>`                                  | :ref:`is_on_ceiling<class_KinematicBody2D_is_on_ceiling>` **(** **)** const                                                                                                                                                                                                                                                     |
-+----------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`bool<class_bool>`                                  | :ref:`is_on_floor<class_KinematicBody2D_is_on_floor>` **(** **)** const                                                                                                                                                                                                                                                         |
-+----------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`bool<class_bool>`                                  | :ref:`is_on_wall<class_KinematicBody2D_is_on_wall>` **(** **)** const                                                                                                                                                                                                                                                           |
-+----------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`KinematicCollision2D<class_kinematiccollision2d>`  | :ref:`move_and_collide<class_KinematicBody2D_move_and_collide>` **(** :ref:`Vector2<class_vector2>` rel_vec **)**                                                                                                                                                                                                               |
-+----------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Vector2<class_vector2>`                            | :ref:`move_and_slide<class_KinematicBody2D_move_and_slide>` **(** :ref:`Vector2<class_vector2>` linear_velocity, :ref:`Vector2<class_vector2>` floor_normal=Vector2( 0, 0 ), :ref:`float<class_float>` slope_stop_min_velocity=5, :ref:`int<class_int>` max_bounces=4, :ref:`float<class_float>` floor_max_angle=0.785398 **)** |
-+----------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`bool<class_bool>`                                  | :ref:`test_move<class_KinematicBody2D_test_move>` **(** :ref:`Transform2D<class_transform2d>` from, :ref:`Vector2<class_vector2>` rel_vec **)**                                                                                                                                                                                 |
-+----------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
++----------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Vector2<class_vector2>`                            | :ref:`get_floor_velocity<class_KinematicBody2D_get_floor_velocity>` **(** **)** const                                                                                                                                                                                                                                                                                          |
++----------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`KinematicCollision2D<class_kinematiccollision2d>`  | :ref:`get_slide_collision<class_KinematicBody2D_get_slide_collision>` **(** :ref:`int<class_int>` slide_idx **)**                                                                                                                                                                                                                                                              |
++----------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`                                    | :ref:`get_slide_count<class_KinematicBody2D_get_slide_count>` **(** **)** const                                                                                                                                                                                                                                                                                                |
++----------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`                                  | :ref:`is_on_ceiling<class_KinematicBody2D_is_on_ceiling>` **(** **)** const                                                                                                                                                                                                                                                                                                    |
++----------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`                                  | :ref:`is_on_floor<class_KinematicBody2D_is_on_floor>` **(** **)** const                                                                                                                                                                                                                                                                                                        |
++----------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`                                  | :ref:`is_on_wall<class_KinematicBody2D_is_on_wall>` **(** **)** const                                                                                                                                                                                                                                                                                                          |
++----------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`KinematicCollision2D<class_kinematiccollision2d>`  | :ref:`move_and_collide<class_KinematicBody2D_move_and_collide>` **(** :ref:`Vector2<class_vector2>` rel_vec, :ref:`bool<class_bool>` infinite_inertia=true **)**                                                                                                                                                                                                               |
++----------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Vector2<class_vector2>`                            | :ref:`move_and_slide<class_KinematicBody2D_move_and_slide>` **(** :ref:`Vector2<class_vector2>` linear_velocity, :ref:`Vector2<class_vector2>` floor_normal=Vector2( 0, 0 ), :ref:`bool<class_bool>` infinite_inertia=true, :ref:`float<class_float>` slope_stop_min_velocity=5, :ref:`int<class_int>` max_bounces=4, :ref:`float<class_float>` floor_max_angle=0.785398 **)** |
++----------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`                                  | :ref:`test_move<class_KinematicBody2D_test_move>` **(** :ref:`Transform2D<class_transform2d>` from, :ref:`Vector2<class_vector2>` rel_vec, :ref:`bool<class_bool>` infinite_inertia **)**                                                                                                                                                                                      |
++----------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
 Member Variables
 ----------------
@@ -97,13 +97,13 @@ Returns ``true`` if the body is on a wall. Only updates when calling :ref:`move_
 
 .. _class_KinematicBody2D_move_and_collide:
 
-- :ref:`KinematicCollision2D<class_kinematiccollision2d>` **move_and_collide** **(** :ref:`Vector2<class_vector2>` rel_vec **)**
+- :ref:`KinematicCollision2D<class_kinematiccollision2d>` **move_and_collide** **(** :ref:`Vector2<class_vector2>` rel_vec, :ref:`bool<class_bool>` infinite_inertia=true **)**
 
 Moves the body along the vector ``rel_vec``. The body will stop if it collides. Returns a :ref:`KinematicCollision2D<class_kinematiccollision2d>`, which contains information about the collision.
 
 .. _class_KinematicBody2D_move_and_slide:
 
-- :ref:`Vector2<class_vector2>` **move_and_slide** **(** :ref:`Vector2<class_vector2>` linear_velocity, :ref:`Vector2<class_vector2>` floor_normal=Vector2( 0, 0 ), :ref:`float<class_float>` slope_stop_min_velocity=5, :ref:`int<class_int>` max_bounces=4, :ref:`float<class_float>` floor_max_angle=0.785398 **)**
+- :ref:`Vector2<class_vector2>` **move_and_slide** **(** :ref:`Vector2<class_vector2>` linear_velocity, :ref:`Vector2<class_vector2>` floor_normal=Vector2( 0, 0 ), :ref:`bool<class_bool>` infinite_inertia=true, :ref:`float<class_float>` slope_stop_min_velocity=5, :ref:`int<class_int>` max_bounces=4, :ref:`float<class_float>` floor_max_angle=0.785398 **)**
 
 Moves the body along a vector. If the body collides with another, it will slide along the other body rather than stop immediately. If the other body is a ``KinematicBody2D`` or :ref:`RigidBody2D<class_rigidbody2d>`, it will also be affected by the motion of the other body. You can use this to make moving or rotating platforms, or to make nodes push other nodes.
 
@@ -121,7 +121,7 @@ Returns the movement that remained when the body stopped. To get more detailed i
 
 .. _class_KinematicBody2D_test_move:
 
-- :ref:`bool<class_bool>` **test_move** **(** :ref:`Transform2D<class_transform2d>` from, :ref:`Vector2<class_vector2>` rel_vec **)**
+- :ref:`bool<class_bool>` **test_move** **(** :ref:`Transform2D<class_transform2d>` from, :ref:`Vector2<class_vector2>` rel_vec, :ref:`bool<class_bool>` infinite_inertia **)**
 
 Checks for collisions without moving the body. Virtually sets the node's position, scale and rotation to that of the given :ref:`Transform2D<class_transform2d>`, then tries to move the body along the vector ``rel_vec``. Returns ``true`` if a collision would occur.
 

classes/class_line2d.rst

@@ -142,6 +142,6 @@ Remove the point at index ``i`` from the line.
 
 - void **set_point_position** **(** :ref:`int<class_int>` i, :ref:`Vector2<class_vector2>` position **)**
 
-Overwites the position in point ``i`` with the supplied ``position``.
+Overwrites the position in point ``i`` with the supplied ``position``.
 
 

classes/class_meshinstance2d.rst

@@ -0,0 +1,34 @@
+.. Generated automatically by doc/tools/makerst.py in Godot's source tree.
+.. DO NOT EDIT THIS FILE, but the MeshInstance2D.xml source instead.
+.. The source is found in doc/classes or modules/<name>/doc_classes.
+
+.. _class_MeshInstance2D:
+
+MeshInstance2D
+==============
+
+**Inherits:** :ref:`Node2D<class_node2d>` **<** :ref:`CanvasItem<class_canvasitem>` **<** :ref:`Node<class_node>` **<** :ref:`Object<class_object>`
+
+**Category:** Core
+
+Brief Description
+-----------------
+
+
+
+Member Variables
+----------------
+
+  .. _class_MeshInstance2D_mesh:
+
+- :ref:`Mesh<class_mesh>` **mesh**
+
+  .. _class_MeshInstance2D_normal_map:
+
+- :ref:`Texture<class_texture>` **normal_map**
+
+  .. _class_MeshInstance2D_texture:
+
+- :ref:`Texture<class_texture>` **texture**
+
+

classes/class_navigation2d.rst

@@ -14,7 +14,7 @@ Navigation2D
 Brief Description
 -----------------
 
-
+Class to assist with character navigation and pathfinding.
 
 Member Functions
 ----------------

classes/class_networkedmultiplayerenet.rst

@@ -34,7 +34,7 @@ Member Variables
 
   .. _class_NetworkedMultiplayerENet_compression_mode:
 
-- :ref:`CompressionMode<enum_networkedmultiplayerenet_compressionmode>` **compression_mode**
+- :ref:`CompressionMode<enum_networkedmultiplayerenet_compressionmode>` **compression_mode** - The compression method used for network packets. Default is no compression. These have different tradeoffs of compression speed versus bandwidth, you may need to test which one works best for your use case if you use compression at all.
 
 
 Enums
@@ -44,17 +44,17 @@ Enums
 
 enum **CompressionMode**
 
-- **COMPRESS_NONE** = **0**
-- **COMPRESS_RANGE_CODER** = **1**
-- **COMPRESS_FASTLZ** = **2**
-- **COMPRESS_ZLIB** = **3**
-- **COMPRESS_ZSTD** = **4**
+- **COMPRESS_NONE** = **0** --- No compression.
+- **COMPRESS_RANGE_CODER** = **1** --- ENet's buildin range encoding.
+- **COMPRESS_FASTLZ** = **2** --- FastLZ compression.
+- **COMPRESS_ZLIB** = **3** --- zlib compression.
+- **COMPRESS_ZSTD** = **4** --- ZStandard compression.
 
 
 Description
 -----------
 
-A connection (or a listening server) that should be passed to :ref:`SceneTree.set_network_peer<class_SceneTree_set_network_peer>`. Socket events can be handled by connecting to :ref:`SceneTree<class_scenetree>` signals.
+A PacketPeer implementation that should be passed to :ref:`SceneTree.set_network_peer<class_SceneTree_set_network_peer>` after being initialized as either a client or server. Events can then be handled by connecting to :ref:`SceneTree<class_scenetree>` signals.
 
 Member Function Description
 ---------------------------
@@ -63,20 +63,24 @@ Member Function Description
 
 - void **close_connection** **(** **)**
 
+Closes the connection. Ignored if no connection is currently established. If this is a server it tries to notify all clients before forcibly disconnecting them. If this is a client it simply closes the connection to the server.
+
 .. _class_NetworkedMultiplayerENet_create_client:
 
 - :ref:`int<class_int>` **create_client** **(** :ref:`String<class_string>` ip, :ref:`int<class_int>` port, :ref:`int<class_int>` in_bandwidth=0, :ref:`int<class_int>` out_bandwidth=0 **)**
 
-Create client that connects to a server at address ``ip`` using specified ``port``.
+Create client that connects to a server at address ``ip`` using specified ``port``. The given IP needs to be in IPv4 or IPv6 address format, for example: ``192.168.1.1``. The ``port`` is the port the server is listening on. The ``in_bandwidth`` and ``out_bandwidth`` parameters can be used to limit the incoming and outgoing bandwidth to the given number of bytes per second. The default of 0 means unlimited bandwidth. Note that ENet will strategically drop packets on specific sides of a connection between peers to ensure the peer's bandwidth is not overwhelmed. The bandwidth parameters also determine the window size of a connection which limits the amount of reliable packets that may be in transit at any given time. Returns ``OK`` if a client was created, ``ERR_ALREADY_IN_USE`` if this NetworkedMultiplayerEnet instance already has an open connection (in which case you need to call :ref:`close_connection<class_NetworkedMultiplayerENet_close_connection>` first) or ``ERR_CANT_CREATE`` if the client could not be created.
 
 .. _class_NetworkedMultiplayerENet_create_server:
 
 - :ref:`int<class_int>` **create_server** **(** :ref:`int<class_int>` port, :ref:`int<class_int>` max_clients=32, :ref:`int<class_int>` in_bandwidth=0, :ref:`int<class_int>` out_bandwidth=0 **)**
 
-Create server that listens to connections via ``port``.
+Create server that listens to connections via ``port``. The port needs to be an available, unused port between 0 and 65535. Note that ports below 1024 are privileged and may require elevated permissions depending on the platform. To change the interface the server listens on, use :ref:`set_bind_ip<class_NetworkedMultiplayerENet_set_bind_ip>`. The default IP is the wildcard ``*``, which listens on all available interfaces. ``max_clients`` is the maximum number of clients that are allowed at once, any number up to 4096 may be used, although the achievable number of simultaneous clients may be far lower and depends on the application. For additional details on the bandwidth parameters, see :ref:`create_client<class_NetworkedMultiplayerENet_create_client>`. Returns ``OK`` if a server was created, ``ERR_ALREADY_IN_USE`` if this NetworkedMultiplayerEnet instance already has an open connection (in which case you need to call :ref:`close_connection<class_NetworkedMultiplayerENet_close_connection>` first) or ``ERR_CANT_CREATE`` if the server could not be created.
 
 .. _class_NetworkedMultiplayerENet_set_bind_ip:
 
 - void **set_bind_ip** **(** :ref:`String<class_string>` ip **)**
 
+The IP used when creating a server. This is set to the wildcard ``*`` by default, which binds to all available interfaces. The given IP needs to be in IPv4 or IPv6 address format, for example: ``192.168.1.1``.
+
 

classes/class_node.rst

@@ -204,7 +204,7 @@ Emitted after the node exits the tree and is no longer active.
 
 - **tree_exiting** **(** **)**
 
-Emitted when the node is still active but about to exit the tree. This is the right place for de-initialization.
+Emitted when the node is still active but about to exit the tree. This is the right place for de-initialization (or a "destructor", if you will).
 
 
 Member Variables
@@ -216,9 +216,7 @@ Member Variables
 
   .. _class_Node_name:
 
-- :ref:`String<class_string>` **name** - The name of the node. This name is unique among the siblings (other child nodes from the same parent).
-
-When set to an existing name, the node will be automatically renamed
+- :ref:`String<class_string>` **name** - The name of the node. This name is unique among the siblings (other child nodes from the same parent). When set to an existing name, the node will be automatically renamed
 
   .. _class_Node_owner:
 
@@ -226,7 +224,7 @@ When set to an existing name, the node will be automatically renamed
 
   .. _class_Node_pause_mode:
 
-- :ref:`PauseMode<enum_node_pausemode>` **pause_mode**
+- :ref:`PauseMode<enum_node_pausemode>` **pause_mode** - Pause mode. How the node will behave if the :ref:`SceneTree<class_scenetree>` is paused.
 
 
 Numeric Constants
@@ -246,9 +244,9 @@ Numeric Constants
 - **NOTIFICATION_DRAG_BEGIN** = **21** --- Notification received when a drag begins.
 - **NOTIFICATION_DRAG_END** = **22** --- Notification received when a drag ends.
 - **NOTIFICATION_PATH_CHANGED** = **23** --- Notification received when the node's :ref:`NodePath<class_nodepath>` changed.
-- **NOTIFICATION_TRANSLATION_CHANGED** = **24**
-- **NOTIFICATION_INTERNAL_PROCESS** = **25**
-- **NOTIFICATION_INTERNAL_PHYSICS_PROCESS** = **26**
+- **NOTIFICATION_TRANSLATION_CHANGED** = **24** --- Notification received when translations may have changed. Can be triggered by the user changing the locale. Can be used to respond to language changes, for example to change the UI strings on the fly. Useful when working with the built-in translation support, like :ref:`Object.tr<class_Object_tr>`.
+- **NOTIFICATION_INTERNAL_PROCESS** = **25** --- Notification received every frame when the internal process flag is set (see :ref:`set_process_internal<class_Node_set_process_internal>`).
+- **NOTIFICATION_INTERNAL_PHYSICS_PROCESS** = **26** --- Notification received every frame when the internal physics process flag is set (see :ref:`set_physics_process_internal<class_Node_set_physics_process_internal>`).
 
 Enums
 -----
@@ -257,19 +255,19 @@ Enums
 
 enum **PauseMode**
 
-- **PAUSE_MODE_INHERIT** = **0** --- Inherits pause mode from parent. For root node, it is equivalent to PAUSE_MODE_STOP.
-- **PAUSE_MODE_STOP** = **1** --- Stop processing when SceneTree is paused.
-- **PAUSE_MODE_PROCESS** = **2** --- Continue to process regardless of SceneTree pause state.
+- **PAUSE_MODE_INHERIT** = **0** --- Inherits pause mode from the node's parent. For the root node, it is equivalent to PAUSE_MODE_STOP. Default.
+- **PAUSE_MODE_STOP** = **1** --- Stop processing when the :ref:`SceneTree<class_scenetree>` is paused.
+- **PAUSE_MODE_PROCESS** = **2** --- Continue to process regardless of the :ref:`SceneTree<class_scenetree>` pause state.
 
   .. _enum_Node_RPCMode:
 
 enum **RPCMode**
 
-- **RPC_MODE_DISABLED** = **0**
-- **RPC_MODE_REMOTE** = **1** --- Call a method remotely.
-- **RPC_MODE_SYNC** = **2** --- Call a method both remotely and locally.
-- **RPC_MODE_MASTER** = **3** --- Call a method if the Node is Master.
-- **RPC_MODE_SLAVE** = **4** --- Call a method if the Node is Slave.
+- **RPC_MODE_DISABLED** = **0** --- Used with :ref:`rpc_config<class_Node_rpc_config>` or :ref:`rset_config<class_Node_rset_config>` to disable a method or property for all RPC calls, making it unavailable. Default for all methods.
+- **RPC_MODE_REMOTE** = **1** --- Used with :ref:`rpc_config<class_Node_rpc_config>` or :ref:`rset_config<class_Node_rset_config>` to set a method to be called or a property to be changed only on the remote end, not locally. Analogous to the ``remote`` keyword.
+- **RPC_MODE_SYNC** = **2** --- Used with :ref:`rpc_config<class_Node_rpc_config>` or :ref:`rset_config<class_Node_rset_config>` to set a method to be called or a property to be changed both on the remote end and locally. Analogous to the ``sync`` keyword.
+- **RPC_MODE_MASTER** = **3** --- Used with :ref:`rpc_config<class_Node_rpc_config>` or :ref:`rset_config<class_Node_rset_config>` to set a method to be called or a property to be changed only on the network master for this node. Analogous to the ``master`` keyword. See :ref:`set_network_master<class_Node_set_network_master>`.
+- **RPC_MODE_SLAVE** = **4** --- Used with :ref:`rpc_config<class_Node_rpc_config>` or :ref:`rset_config<class_Node_rset_config>` to set a method to be called or a property to be changed only on slaves for this node. Analogous to the ``slave`` keyword. See :ref:`set_network_master<class_Node_set_network_master>`.
 
   .. _enum_Node_DuplicateFlags:
 
@@ -286,7 +284,7 @@ Description
 
 Nodes are Godot's building blocks. They can be assigned as the child of another node, resulting in a tree arrangement. A given node can contain any number of nodes as children with the requirement that all siblings (direct children of a node) should have unique names.
 
-A tree of nodes is called a *scene*. Scenes can be saved to the disk and then instanced into other scenes. This allows for very high flexibility in the architecture and data model of Godot projects. Nodes can also optionally be added to groups. This makes it possible to access a number of nodes from code (an "enemies" group, for example) to perform grouped actions.
+A tree of nodes is called a *scene*. Scenes can be saved to the disk and then instanced into other scenes. This allows for very high flexibility in the architecture and data model of Godot projects.
 
 **Scene tree:** The :ref:`SceneTree<class_scenetree>` contains the active tree of nodes. When a node is added to the scene tree, it receives the NOTIFICATION_ENTER_TREE notification and its :ref:`_enter_tree<class_Node__enter_tree>` callback is triggered. Child nodes are always added *after* their parent node, i.e. the :ref:`_enter_tree<class_Node__enter_tree>` callback of a parent node will be triggered before its child's.
 
@@ -302,7 +300,9 @@ To keep track of the scene hierarchy (especially when instancing scenes into oth
 
 Finally, when a node is freed with :ref:`free<class_Node_free>` or :ref:`queue_free<class_Node_queue_free>`, it will also free all its children.
 
-**Networking with nodes:** After connecting to a server (or making one, see :ref:`NetworkedMultiplayerENet<class_networkedmultiplayerenet>`) it is possible to use the built-in RPC (remote procedure call) system to communicate over the network. By calling :ref:`rpc<class_Node_rpc>` with a method name, it will be called locally and in all connected peers (peers = clients and the server that accepts connections), with behaviour varying depending on the network mode (:ref:`set_network_mode<class_Node_set_network_mode>`) of the receiving peer. To identify which node receives the RPC call Godot will use its :ref:`NodePath<class_nodepath>` (make sure node names are the same on all peers).
+**Groups:** Nodes can be added to as many groups as you want to be easy to manage, you could create groups like "enemies" or "collectables" for example, depending on your game. See :ref:`add_to_group<class_Node_add_to_group>`, :ref:`is_in_group<class_Node_is_in_group>` and :ref:`remove_from_group<class_Node_remove_from_group>`. You can then retrieve all nodes in these groups, iterate them and even call methods on groups via the methods on :ref:`SceneTree<class_scenetree>`.
+
+**Networking with nodes:** After connecting to a server (or making one, see :ref:`NetworkedMultiplayerENet<class_networkedmultiplayerenet>`) it is possible to use the built-in RPC (remote procedure call) system to communicate over the network. By calling :ref:`rpc<class_Node_rpc>` with a method name, it will be called locally and in all connected peers (peers = clients and the server that accepts connections). To identify which node receives the RPC call Godot will use its :ref:`NodePath<class_nodepath>` (make sure node names are the same on all peers). Also take a look at the high-level networking tutorial and corresponding demos.
 
 Member Function Description
 ---------------------------
@@ -331,6 +331,10 @@ Called when there is an input event. The input event propagates through the node
 
 It is only called if input processing is enabled, which is done automatically if this method is overridden, and can be toggled with :ref:`set_process_input<class_Node_set_process_input>`.
 
+To consume the input event and stop it propagating further to other nodes, :ref:`SceneTree.set_input_as_handled<class_SceneTree_set_input_as_handled>` can be called.
+
+For gameplay input, :ref:`_unhandled_input<class_Node__unhandled_input>` and :ref:`_unhandled_key_input<class_Node__unhandled_key_input>` are usually a better fit as they allow the GUI to intercept the events first.
+
 .. _class_Node__physics_process:
 
 - void **_physics_process** **(** :ref:`float<class_float>` delta **)** virtual
@@ -357,20 +361,34 @@ Corresponds to the NOTIFICATION_PROCESS notification in :ref:`Object._notificati
 
 Called when the node is "ready", i.e. when both the node and its children have entered the scene tree. If the node has children, their :ref:`_ready<class_Node__ready>` callbacks get triggered first, and the parent node will receive the ready notification afterwards.
 
-Corresponds to the NOTIFICATION_READY notification in :ref:`Object._notification<class_Object__notification>`.
+Corresponds to the NOTIFICATION_READY notification in :ref:`Object._notification<class_Object__notification>`. See also the ``onready`` keyword for variables.
+
+Usually used for initialization. For even earlier initialization, :ref:`Object._init<class_Object__init>` may be used. Also see :ref:`_enter_tree<class_Node__enter_tree>`.
 
 .. _class_Node__unhandled_input:
 
 - void **_unhandled_input** **(** :ref:`InputEvent<class_inputevent>` event **)** virtual
 
-Propagated to all nodes when the previous InputEvent is not consumed by any nodes.
+Propagated to all nodes when the previous :ref:`InputEvent<class_inputevent>` is not consumed by any nodes.
 
 It is only called if unhandled input processing is enabled, which is done automatically if this method is overridden, and can be toggled with :ref:`set_process_unhandled_input<class_Node_set_process_unhandled_input>`.
 
+To consume the input event and stop it propagating further to other nodes, :ref:`SceneTree.set_input_as_handled<class_SceneTree_set_input_as_handled>` can be called.
+
+For gameplay input, this and :ref:`_unhandled_key_input<class_Node__unhandled_key_input>` are usually a better fit than :ref:`_input<class_Node__input>` as they allow the GUI to intercept the events first.
+
 .. _class_Node__unhandled_key_input:
 
 - void **_unhandled_key_input** **(** :ref:`InputEventKey<class_inputeventkey>` event **)** virtual
 
+Propagated to all nodes when the previous :ref:`InputEventKey<class_inputeventkey>` is not consumed by any nodes.
+
+It is only called if unhandled key input processing is enabled, which is done automatically if this method is overridden, and can be toggled with :ref:`set_process_unhandled_key_input<class_Node_set_process_unhandled_key_input>`.
+
+To consume the input event and stop it propagating further to other nodes, :ref:`SceneTree.set_input_as_handled<class_SceneTree_set_input_as_handled>` can be called.
+
+For gameplay input, this and :ref:`_unhandled_input<class_Node__unhandled_input>` are usually a better fit than :ref:`_input<class_Node__input>` as they allow the GUI to intercept the events first.
+
 .. _class_Node_add_child:
 
 - void **add_child** **(** :ref:`Node<class_node>` node, :ref:`bool<class_bool>` legible_unique_name=false **)**
@@ -391,7 +409,7 @@ Setting "legible_unique_name" ``true`` creates child nodes with human-readable n
 
 - void **add_to_group** **(** :ref:`String<class_string>` group, :ref:`bool<class_bool>` persistent=false **)**
 
-Adds the node to a group. Groups are helpers to name and organize a subset of nodes, for example "enemies" or "collectables". A node can be in any number of groups. Nodes can be assigned a group at any time, but will not be added until they are inside the scene tree (see :ref:`is_inside_tree<class_Node_is_inside_tree>`).
+Adds the node to a group. Groups are helpers to name and organize a subset of nodes, for example "enemies" or "collectables". A node can be in any number of groups. Nodes can be assigned a group at any time, but will not be added until they are inside the scene tree (see :ref:`is_inside_tree<class_Node_is_inside_tree>`). See notes in the description, and the group methods in :ref:`SceneTree<class_scenetree>`.
 
 .. _class_Node_can_process:
 
@@ -447,7 +465,7 @@ Returns the node's index, i.e. its position among the siblings of its parent.
 
 - :ref:`int<class_int>` **get_network_master** **(** **)** const
 
-Returns the peer ID of the network master for this node.
+Returns the peer ID of the network master for this node. See :ref:`set_network_master<class_Node_set_network_master>`.
 
 .. _class_Node_get_node:
 
@@ -499,7 +517,7 @@ Returns the absolute path of the current node. This only works if the current no
 
 - :ref:`NodePath<class_nodepath>` **get_path_to** **(** :ref:`Node<class_node>` node **)** const
 
-Returns the relative path from the current node to the specified node in "node" argument. Both nodes must be in the same scene, or the function will fail.
+Returns the relative :ref:`NodePath<class_nodepath>` from this node to the specified ``node``. Both nodes must be in the same scene or the function will fail.
 
 .. _class_Node_get_physics_process_delta_time:
 
@@ -523,6 +541,8 @@ Returns the time elapsed (in seconds) since the last process callback. This valu
 
 - :ref:`bool<class_bool>` **get_scene_instance_load_placeholder** **(** **)** const
 
+Returns ``true`` if this is an instance load placeholder. See :ref:`InstancePlaceholder<class_instanceplaceholder>`.
+
 .. _class_Node_get_tree:
 
 - :ref:`SceneTree<class_scenetree>` **get_tree** **(** **)** const
@@ -567,7 +587,7 @@ Returns ``true`` if the given node occurs later in the scene hierarchy than the
 
 - :ref:`bool<class_bool>` **is_in_group** **(** :ref:`String<class_string>` group **)** const
 
-Returns ``true`` if this node is in the specified group.
+Returns ``true`` if this node is in the specified group. See notes in the description, and the group methods in :ref:`SceneTree<class_scenetree>`.
 
 .. _class_Node_is_inside_tree:
 
@@ -579,6 +599,8 @@ Returns ``true`` if this node is currently inside a :ref:`SceneTree<class_scenet
 
 - :ref:`bool<class_bool>` **is_network_master** **(** **)** const
 
+Returns ``true`` if the local system is the master of this node.
+
 .. _class_Node_is_physics_processing:
 
 - :ref:`bool<class_bool>` **is_physics_processing** **(** **)** const
@@ -589,6 +611,8 @@ Returns ``true`` if physics processing is enabled (see :ref:`set_physics_process
 
 - :ref:`bool<class_bool>` **is_physics_processing_internal** **(** **)** const
 
+Returns ``true`` if internal physics processing is enabled (see :ref:`set_physics_process_internal<class_Node_set_physics_process_internal>`).
+
 .. _class_Node_is_processing:
 
 - :ref:`bool<class_bool>` **is_processing** **(** **)** const
@@ -605,6 +629,8 @@ Returns ``true`` if the node is processing input (see :ref:`set_process_input<cl
 
 - :ref:`bool<class_bool>` **is_processing_internal** **(** **)** const
 
+Returns ``true`` if internal processing is enabled (see :ref:`set_process_internal<class_Node_set_process_internal>`).
+
 .. _class_Node_is_processing_unhandled_input:
 
 - :ref:`bool<class_bool>` **is_processing_unhandled_input** **(** **)** const
@@ -627,11 +653,13 @@ Moves a child node to a different position (order) amongst the other children. S
 
 - void **print_stray_nodes** **(** **)**
 
+Prints all stray nodes (nodes outside the :ref:`SceneTree<class_scenetree>`). Used for debugging. Works only in debug builds.
+
 .. _class_Node_print_tree:
 
 - void **print_tree** **(** **)**
 
-Prints the scene to stdout. Used mainly for debugging purposes.
+Prints the scene hierarchy of this node and all it's children to stdout. Used mainly for debugging purposes.
 
 .. _class_Node_propagate_call:
 
@@ -673,7 +701,7 @@ Removes a child node. The node is NOT deleted and must be deleted manually.
 
 - void **remove_from_group** **(** :ref:`String<class_string>` group **)**
 
-Removes a node from a group.
+Removes a node from a group. See notes in the description, and the group methods in :ref:`SceneTree<class_scenetree>`.
 
 .. _class_Node_replace_by:
 
@@ -691,61 +719,61 @@ Requests that ``_ready`` be called again.
 
 - :ref:`Variant<class_variant>` **rpc** **(** :ref:`String<class_string>` method **)** vararg
 
-Sends a remote procedure call request to all peers on the network (and locally), optionally sending additional data as arguments. Call request will be received by nodes with the same :ref:`NodePath<class_nodepath>`.
+Sends a remote procedure call request for the given ``method`` to peers on the network (and locally), optionally sending all additional arguments as arguments to the method called by the RPC. The call request will only be received by nodes with the same :ref:`NodePath<class_nodepath>`, including the exact same node name. Behaviour depends on the RPC configuration for the given method, see :ref:`rpc_config<class_Node_rpc_config>`. Methods are not exposed to RPCs by default. Also see :ref:`rset<class_Node_rset>` and :ref:`rset_config<class_Node_rset_config>` for properties. Returns an empty :ref:`Variant<class_variant>`. Note that you can only safely use RPCs on clients after you received the ``connected_to_server`` signal from the :ref:`SceneTree<class_scenetree>`. You also need to keep track of the connection state, either by the :ref:`SceneTree<class_scenetree>` signals like ``server_disconnected`` or by checking ``SceneTree.network_peer.get_connection_status() == CONNECTION_CONNECTED``.
 
 .. _class_Node_rpc_config:
 
 - void **rpc_config** **(** :ref:`String<class_string>` method, :ref:`int<class_int>` mode **)**
 
-Changes the method's RPC mode (one of RPC_MODE\_\* constants).
+Changes the RPC mode for the given ``method`` to the given ``mode``. See enum RPCMode. An alternative is annotating methods and properties with the corresponding keywords (``remote``, ``sync``, ``master``, ``slave``). By default, methods are not exposed to networking (and RPCs). Also see :ref:`rset<class_Node_rset>` and :ref:`rset_config<class_Node_rset_config>` for properties.
 
 .. _class_Node_rpc_id:
 
 - :ref:`Variant<class_variant>` **rpc_id** **(** :ref:`int<class_int>` peer_id, :ref:`String<class_string>` method **)** vararg
 
-Sends a :ref:`rpc<class_Node_rpc>` to a specific peer identified by *peer_id*.
+Sends a :ref:`rpc<class_Node_rpc>` to a specific peer identified by ``peer_id``. Returns an empty :ref:`Variant<class_variant>`.
 
 .. _class_Node_rpc_unreliable:
 
 - :ref:`Variant<class_variant>` **rpc_unreliable** **(** :ref:`String<class_string>` method **)** vararg
 
-Sends a :ref:`rpc<class_Node_rpc>` using an unreliable protocol.
+Sends a :ref:`rpc<class_Node_rpc>` using an unreliable protocol. Returns an empty :ref:`Variant<class_variant>`.
 
 .. _class_Node_rpc_unreliable_id:
 
 - :ref:`Variant<class_variant>` **rpc_unreliable_id** **(** :ref:`int<class_int>` peer_id, :ref:`String<class_string>` method **)** vararg
 
-Sends a :ref:`rpc<class_Node_rpc>` to a specific peer identified by *peer_id* using an unreliable protocol.
+Sends a :ref:`rpc<class_Node_rpc>` to a specific peer identified by ``peer_id`` using an unreliable protocol. Returns an empty :ref:`Variant<class_variant>`.
 
 .. _class_Node_rset:
 
 - void **rset** **(** :ref:`String<class_string>` property, :ref:`Variant<class_variant>` value **)**
 
-Remotely changes property's value on other peers (and locally).
+Remotely changes a property's value on other peers (and locally). Behaviour depends on the RPC configuration for the given property, see :ref:`rset_config<class_Node_rset_config>`. Also see :ref:`rpc<class_Node_rpc>` for RPCs for methods, most information applies to this method as well.
 
 .. _class_Node_rset_config:
 
 - void **rset_config** **(** :ref:`String<class_string>` property, :ref:`int<class_int>` mode **)**
 
-Changes the property's RPC mode (one of RPC_MODE\_\* constants).
+Changes the RPC mode for the given ``property`` to the given ``mode``. See enum RPCMode. An alternative is annotating methods and properties with the corresponding keywords (``remote``, ``sync``, ``master``, ``slave``). By default, properties are not exposed to networking (and RPCs). Also see :ref:`rpc<class_Node_rpc>` and :ref:`rpc_config<class_Node_rpc_config>` for methods.
 
 .. _class_Node_rset_id:
 
 - void **rset_id** **(** :ref:`int<class_int>` peer_id, :ref:`String<class_string>` property, :ref:`Variant<class_variant>` value **)**
 
-Remotely changes property's value on a specific peer identified by *peer_id*.
+Remotely changes the property's value on a specific peer identified by ``peer_id``.
 
 .. _class_Node_rset_unreliable:
 
 - void **rset_unreliable** **(** :ref:`String<class_string>` property, :ref:`Variant<class_variant>` value **)**
 
-Remotely changes property's value on other peers (and locally) using an unreliable protocol.
+Remotely changes the property's value on other peers (and locally) using an unreliable protocol.
 
 .. _class_Node_rset_unreliable_id:
 
 - void **rset_unreliable_id** **(** :ref:`int<class_int>` peer_id, :ref:`String<class_string>` property, :ref:`Variant<class_variant>` value **)**
 
-Remotely changes property's value on a specific peer identified by *peer_id* using an unreliable protocol.
+Remotely changes property's value on a specific peer identified by ``peer_id`` using an unreliable protocol.
 
 .. _class_Node_set_display_folded:
 
@@ -757,7 +785,7 @@ Sets the folded state of the node in the Scene dock.
 
 - void **set_network_master** **(** :ref:`int<class_int>` id, :ref:`bool<class_bool>` recursive=true **)**
 
-Sets the node network master to the peer with the given peer ID. The network master is the peer that has authority over it on the network. Inherited from the parent node by default, which ultimately defaults to peer ID 1 (the server).
+Sets the node's network master to the peer with the given peer ID. The network master is the peer that has authority over the node on the network. Useful in conjunction with the ``master`` and ``slave`` keywords. Inherited from the parent node by default, which ultimately defaults to peer ID 1 (the server). If ``recursive``, the given peer is recursively set as the master for all children of this node.
 
 .. _class_Node_set_physics_process:
 
@@ -769,6 +797,8 @@ Enables or disables physics (i.e. fixed framerate) processing. When a node is be
 
 - void **set_physics_process_internal** **(** :ref:`bool<class_bool>` enable **)**
 
+Enables or disables internal physics for this node. Internal physics processing happens in isolation from the normal :ref:`method<class_Node_method>`_physics_process`` calls and is used by some nodes internally to guarantee proper functioning even if the node is paused or physics processing is disabled for scripting (:ref:`set_physics_process<class_Node_set_physics_process>`). Only useful for advanced uses to manipulate built-in nodes behaviour.
+
 .. _class_Node_set_process:
 
 - void **set_process** **(** :ref:`bool<class_bool>` enable **)**
@@ -785,6 +815,8 @@ Enables or disables input processing. This is not required for GUI controls! Ena
 
 - void **set_process_internal** **(** :ref:`bool<class_bool>` enable **)**
 
+Enables or disabled internal processing for this node. Internal processing happens in isolation from the normal :ref:`method<class_Node_method>`_process`` calls and is used by some nodes internally to guarantee proper functioning even if the node is paused or processing is disabled for scripting (:ref:`set_process<class_Node_set_process>`). Only useful for advanced uses to manipulate built-in nodes behaviour.
+
 .. _class_Node_set_process_unhandled_input:
 
 - void **set_process_unhandled_input** **(** :ref:`bool<class_bool>` enable **)**
@@ -801,4 +833,6 @@ Enables unhandled key input processing. Enabled automatically if :ref:`_unhandle
 
 - void **set_scene_instance_load_placeholder** **(** :ref:`bool<class_bool>` load_placeholder **)**
 
+Sets whether this is an instance load placeholder. See :ref:`InstancePlaceholder<class_instanceplaceholder>`.
+
 

classes/class_node2d.rst

@@ -9,7 +9,7 @@ Node2D
 
 **Inherits:** :ref:`CanvasItem<class_canvasitem>` **<** :ref:`Node<class_node>` **<** :ref:`Object<class_object>`
 
-**Inherited By:** :ref:`RemoteTransform2D<class_remotetransform2d>`, :ref:`Joint2D<class_joint2d>`, :ref:`VisibilityNotifier2D<class_visibilitynotifier2d>`, :ref:`Navigation2D<class_navigation2d>`, :ref:`CollisionPolygon2D<class_collisionpolygon2d>`, :ref:`TouchScreenButton<class_touchscreenbutton>`, :ref:`Particles2D<class_particles2d>`, :ref:`AnimatedSprite<class_animatedsprite>`, :ref:`RayCast2D<class_raycast2d>`, :ref:`Light2D<class_light2d>`, :ref:`Path2D<class_path2d>`, :ref:`Line2D<class_line2d>`, :ref:`AudioStreamPlayer2D<class_audiostreamplayer2d>`, :ref:`CanvasModulate<class_canvasmodulate>`, :ref:`Sprite<class_sprite>`, :ref:`CollisionShape2D<class_collisionshape2d>`, :ref:`NavigationPolygonInstance<class_navigationpolygoninstance>`, :ref:`PathFollow2D<class_pathfollow2d>`, :ref:`ParallaxLayer<class_parallaxlayer>`, :ref:`Polygon2D<class_polygon2d>`, :ref:`Position2D<class_position2d>`, :ref:`LightOccluder2D<class_lightoccluder2d>`, :ref:`CollisionObject2D<class_collisionobject2d>`, :ref:`BackBufferCopy<class_backbuffercopy>`, :ref:`YSort<class_ysort>`, :ref:`TileMap<class_tilemap>`, :ref:`Camera2D<class_camera2d>`
+**Inherited By:** :ref:`RemoteTransform2D<class_remotetransform2d>`, :ref:`Joint2D<class_joint2d>`, :ref:`VisibilityNotifier2D<class_visibilitynotifier2d>`, :ref:`Navigation2D<class_navigation2d>`, :ref:`CollisionPolygon2D<class_collisionpolygon2d>`, :ref:`TouchScreenButton<class_touchscreenbutton>`, :ref:`Particles2D<class_particles2d>`, :ref:`AnimatedSprite<class_animatedsprite>`, :ref:`RayCast2D<class_raycast2d>`, :ref:`Light2D<class_light2d>`, :ref:`Path2D<class_path2d>`, :ref:`Line2D<class_line2d>`, :ref:`AudioStreamPlayer2D<class_audiostreamplayer2d>`, :ref:`CanvasModulate<class_canvasmodulate>`, :ref:`Sprite<class_sprite>`, :ref:`CollisionShape2D<class_collisionshape2d>`, :ref:`NavigationPolygonInstance<class_navigationpolygoninstance>`, :ref:`PathFollow2D<class_pathfollow2d>`, :ref:`ParallaxLayer<class_parallaxlayer>`, :ref:`Polygon2D<class_polygon2d>`, :ref:`Position2D<class_position2d>`, :ref:`LightOccluder2D<class_lightoccluder2d>`, :ref:`CollisionObject2D<class_collisionobject2d>`, :ref:`BackBufferCopy<class_backbuffercopy>`, :ref:`MeshInstance2D<class_meshinstance2d>`, :ref:`YSort<class_ysort>`, :ref:`TileMap<class_tilemap>`, :ref:`Camera2D<class_camera2d>`
 
 **Category:** Core
 

classes/class_os.rst

@@ -614,6 +614,14 @@ You can pass the output from :ref:`get_datetime_from_unix_time<class_OS_get_date
 
 Returns the absolute directory path where user data is written (``user://``).
 
+On Linux, this is ``~/.local/share/godot/app_userdata/[project_name]``, or ``~/.local/share/[custom_name]`` if ``use_custom_user_dir`` is set.
+
+On macOS, this is ``~/Library/Application Support/Godot/app_userdata/[project_name]``, or ``~/Library/Application Support/[custom_name]`` if ``use_custom_user_dir`` is set.
+
+On Windows, this is ``%APPDATA%/Godot/app_userdata/[project_name]``, or ``%APPDATA%/[custom_name]`` if ``use_custom_user_dir`` is set.
+
+If the project name is empty, ``user://`` falls back to ``res://``.
+
 .. _class_OS_get_virtual_keyboard_height:
 
 - :ref:`int<class_int>` **get_virtual_keyboard_height** **(** **)**

classes/class_particlesmaterial.rst

@@ -185,7 +185,7 @@ Member Variables
 
   .. _class_ParticlesMaterial_radial_accel:
 
-- :ref:`float<class_float>` **radial_accel** - Linear acceleration applied to each particle.
+- :ref:`float<class_float>` **radial_accel** - Radial acceleration applied to each particle.
 
   .. _class_ParticlesMaterial_radial_accel_curve:
 

classes/class_physics2dserver.rst

@@ -21,191 +21,191 @@ Physics 2D Server.
 Member Functions
 ----------------
 
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`area_add_shape<class_Physics2DServer_area_add_shape>` **(** :ref:`RID<class_rid>` area, :ref:`RID<class_rid>` shape, :ref:`Transform2D<class_transform2d>` transform=Transform2D( 1, 0, 0, 1, 0, 0 ) **)**                                                                                               |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`area_attach_object_instance_id<class_Physics2DServer_area_attach_object_instance_id>` **(** :ref:`RID<class_rid>` area, :ref:`int<class_int>` id **)**                                                                                                                                                   |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`area_clear_shapes<class_Physics2DServer_area_clear_shapes>` **(** :ref:`RID<class_rid>` area **)**                                                                                                                                                                                                       |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`RID<class_rid>`                                              | :ref:`area_create<class_Physics2DServer_area_create>` **(** **)**                                                                                                                                                                                                                                              |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`                                              | :ref:`area_get_object_instance_id<class_Physics2DServer_area_get_object_instance_id>` **(** :ref:`RID<class_rid>` area **)** const                                                                                                                                                                             |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Variant<class_variant>`                                      | :ref:`area_get_param<class_Physics2DServer_area_get_param>` **(** :ref:`RID<class_rid>` area, :ref:`int<class_int>` param **)** const                                                                                                                                                                          |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`RID<class_rid>`                                              | :ref:`area_get_shape<class_Physics2DServer_area_get_shape>` **(** :ref:`RID<class_rid>` area, :ref:`int<class_int>` shape_idx **)** const                                                                                                                                                                      |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`                                              | :ref:`area_get_shape_count<class_Physics2DServer_area_get_shape_count>` **(** :ref:`RID<class_rid>` area **)** const                                                                                                                                                                                           |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Transform2D<class_transform2d>`                              | :ref:`area_get_shape_transform<class_Physics2DServer_area_get_shape_transform>` **(** :ref:`RID<class_rid>` area, :ref:`int<class_int>` shape_idx **)** const                                                                                                                                                  |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`RID<class_rid>`                                              | :ref:`area_get_space<class_Physics2DServer_area_get_space>` **(** :ref:`RID<class_rid>` area **)** const                                                                                                                                                                                                       |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`                                              | :ref:`area_get_space_override_mode<class_Physics2DServer_area_get_space_override_mode>` **(** :ref:`RID<class_rid>` area **)** const                                                                                                                                                                           |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Transform2D<class_transform2d>`                              | :ref:`area_get_transform<class_Physics2DServer_area_get_transform>` **(** :ref:`RID<class_rid>` area **)** const                                                                                                                                                                                               |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`area_remove_shape<class_Physics2DServer_area_remove_shape>` **(** :ref:`RID<class_rid>` area, :ref:`int<class_int>` shape_idx **)**                                                                                                                                                                      |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`area_set_collision_layer<class_Physics2DServer_area_set_collision_layer>` **(** :ref:`RID<class_rid>` area, :ref:`int<class_int>` layer **)**                                                                                                                                                            |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`area_set_collision_mask<class_Physics2DServer_area_set_collision_mask>` **(** :ref:`RID<class_rid>` area, :ref:`int<class_int>` mask **)**                                                                                                                                                               |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`area_set_monitor_callback<class_Physics2DServer_area_set_monitor_callback>` **(** :ref:`RID<class_rid>` area, :ref:`Object<class_object>` receiver, :ref:`String<class_string>` method **)**                                                                                                             |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`area_set_param<class_Physics2DServer_area_set_param>` **(** :ref:`RID<class_rid>` area, :ref:`int<class_int>` param, :ref:`Variant<class_variant>` value **)**                                                                                                                                           |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`area_set_shape<class_Physics2DServer_area_set_shape>` **(** :ref:`RID<class_rid>` area, :ref:`int<class_int>` shape_idx, :ref:`RID<class_rid>` shape **)**                                                                                                                                               |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`area_set_shape_disabled<class_Physics2DServer_area_set_shape_disabled>` **(** :ref:`RID<class_rid>` area, :ref:`int<class_int>` shape_idx, :ref:`bool<class_bool>` disable **)**                                                                                                                         |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`area_set_shape_transform<class_Physics2DServer_area_set_shape_transform>` **(** :ref:`RID<class_rid>` area, :ref:`int<class_int>` shape_idx, :ref:`Transform2D<class_transform2d>` transform **)**                                                                                                       |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`area_set_space<class_Physics2DServer_area_set_space>` **(** :ref:`RID<class_rid>` area, :ref:`RID<class_rid>` space **)**                                                                                                                                                                                |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`area_set_space_override_mode<class_Physics2DServer_area_set_space_override_mode>` **(** :ref:`RID<class_rid>` area, :ref:`int<class_int>` mode **)**                                                                                                                                                     |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`area_set_transform<class_Physics2DServer_area_set_transform>` **(** :ref:`RID<class_rid>` area, :ref:`Transform2D<class_transform2d>` transform **)**                                                                                                                                                    |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`body_add_collision_exception<class_Physics2DServer_body_add_collision_exception>` **(** :ref:`RID<class_rid>` body, :ref:`RID<class_rid>` excepted_body **)**                                                                                                                                            |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`body_add_force<class_Physics2DServer_body_add_force>` **(** :ref:`RID<class_rid>` body, :ref:`Vector2<class_vector2>` offset, :ref:`Vector2<class_vector2>` force **)**                                                                                                                                  |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`body_add_shape<class_Physics2DServer_body_add_shape>` **(** :ref:`RID<class_rid>` body, :ref:`RID<class_rid>` shape, :ref:`Transform2D<class_transform2d>` transform=Transform2D( 1, 0, 0, 1, 0, 0 ) **)**                                                                                               |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`body_apply_impulse<class_Physics2DServer_body_apply_impulse>` **(** :ref:`RID<class_rid>` body, :ref:`Vector2<class_vector2>` position, :ref:`Vector2<class_vector2>` impulse **)**                                                                                                                      |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`body_attach_object_instance_id<class_Physics2DServer_body_attach_object_instance_id>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` id **)**                                                                                                                                                   |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`body_clear_shapes<class_Physics2DServer_body_clear_shapes>` **(** :ref:`RID<class_rid>` body **)**                                                                                                                                                                                                       |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`RID<class_rid>`                                              | :ref:`body_create<class_Physics2DServer_body_create>` **(** **)**                                                                                                                                                                                                                                              |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`                                              | :ref:`body_get_collision_layer<class_Physics2DServer_body_get_collision_layer>` **(** :ref:`RID<class_rid>` body **)** const                                                                                                                                                                                   |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`                                              | :ref:`body_get_collision_mask<class_Physics2DServer_body_get_collision_mask>` **(** :ref:`RID<class_rid>` body **)** const                                                                                                                                                                                     |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`                                              | :ref:`body_get_continuous_collision_detection_mode<class_Physics2DServer_body_get_continuous_collision_detection_mode>` **(** :ref:`RID<class_rid>` body **)** const                                                                                                                                           |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Physics2DDirectBodyState<class_physics2ddirectbodystate>`    | :ref:`body_get_direct_state<class_Physics2DServer_body_get_direct_state>` **(** :ref:`RID<class_rid>` body **)**                                                                                                                                                                                               |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`                                              | :ref:`body_get_max_contacts_reported<class_Physics2DServer_body_get_max_contacts_reported>` **(** :ref:`RID<class_rid>` body **)** const                                                                                                                                                                       |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`                                              | :ref:`body_get_mode<class_Physics2DServer_body_get_mode>` **(** :ref:`RID<class_rid>` body **)** const                                                                                                                                                                                                         |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`                                              | :ref:`body_get_object_instance_id<class_Physics2DServer_body_get_object_instance_id>` **(** :ref:`RID<class_rid>` body **)** const                                                                                                                                                                             |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`float<class_float>`                                          | :ref:`body_get_param<class_Physics2DServer_body_get_param>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` param **)** const                                                                                                                                                                          |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`RID<class_rid>`                                              | :ref:`body_get_shape<class_Physics2DServer_body_get_shape>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` shape_idx **)** const                                                                                                                                                                      |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`                                              | :ref:`body_get_shape_count<class_Physics2DServer_body_get_shape_count>` **(** :ref:`RID<class_rid>` body **)** const                                                                                                                                                                                           |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Variant<class_variant>`                                      | :ref:`body_get_shape_metadata<class_Physics2DServer_body_get_shape_metadata>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` shape_idx **)** const                                                                                                                                                    |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Transform2D<class_transform2d>`                              | :ref:`body_get_shape_transform<class_Physics2DServer_body_get_shape_transform>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` shape_idx **)** const                                                                                                                                                  |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`RID<class_rid>`                                              | :ref:`body_get_space<class_Physics2DServer_body_get_space>` **(** :ref:`RID<class_rid>` body **)** const                                                                                                                                                                                                       |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Variant<class_variant>`                                      | :ref:`body_get_state<class_Physics2DServer_body_get_state>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` state **)** const                                                                                                                                                                          |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`bool<class_bool>`                                            | :ref:`body_is_omitting_force_integration<class_Physics2DServer_body_is_omitting_force_integration>` **(** :ref:`RID<class_rid>` body **)** const                                                                                                                                                               |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`body_remove_collision_exception<class_Physics2DServer_body_remove_collision_exception>` **(** :ref:`RID<class_rid>` body, :ref:`RID<class_rid>` excepted_body **)**                                                                                                                                      |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`body_remove_shape<class_Physics2DServer_body_remove_shape>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` shape_idx **)**                                                                                                                                                                      |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`body_set_axis_velocity<class_Physics2DServer_body_set_axis_velocity>` **(** :ref:`RID<class_rid>` body, :ref:`Vector2<class_vector2>` axis_velocity **)**                                                                                                                                                |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`body_set_collision_layer<class_Physics2DServer_body_set_collision_layer>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` layer **)**                                                                                                                                                            |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`body_set_collision_mask<class_Physics2DServer_body_set_collision_mask>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` mask **)**                                                                                                                                                               |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`body_set_continuous_collision_detection_mode<class_Physics2DServer_body_set_continuous_collision_detection_mode>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` mode **)**                                                                                                                     |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`body_set_force_integration_callback<class_Physics2DServer_body_set_force_integration_callback>` **(** :ref:`RID<class_rid>` body, :ref:`Object<class_object>` receiver, :ref:`String<class_string>` method, :ref:`Variant<class_variant>` userdata=null **)**                                            |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`body_set_max_contacts_reported<class_Physics2DServer_body_set_max_contacts_reported>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` amount **)**                                                                                                                                               |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`body_set_mode<class_Physics2DServer_body_set_mode>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` mode **)**                                                                                                                                                                                   |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`body_set_omit_force_integration<class_Physics2DServer_body_set_omit_force_integration>` **(** :ref:`RID<class_rid>` body, :ref:`bool<class_bool>` enable **)**                                                                                                                                           |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`body_set_param<class_Physics2DServer_body_set_param>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` param, :ref:`float<class_float>` value **)**                                                                                                                                               |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`body_set_shape<class_Physics2DServer_body_set_shape>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` shape_idx, :ref:`RID<class_rid>` shape **)**                                                                                                                                               |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`body_set_shape_as_one_way_collision<class_Physics2DServer_body_set_shape_as_one_way_collision>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` shape_idx, :ref:`bool<class_bool>` enable **)**                                                                                                  |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`body_set_shape_disabled<class_Physics2DServer_body_set_shape_disabled>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` shape_idx, :ref:`bool<class_bool>` disable **)**                                                                                                                         |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`body_set_shape_metadata<class_Physics2DServer_body_set_shape_metadata>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` shape_idx, :ref:`Variant<class_variant>` metadata **)**                                                                                                                  |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`body_set_shape_transform<class_Physics2DServer_body_set_shape_transform>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` shape_idx, :ref:`Transform2D<class_transform2d>` transform **)**                                                                                                       |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`body_set_space<class_Physics2DServer_body_set_space>` **(** :ref:`RID<class_rid>` body, :ref:`RID<class_rid>` space **)**                                                                                                                                                                                |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`body_set_state<class_Physics2DServer_body_set_state>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` state, :ref:`Variant<class_variant>` value **)**                                                                                                                                           |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`bool<class_bool>`                                            | :ref:`body_test_motion<class_Physics2DServer_body_test_motion>` **(** :ref:`RID<class_rid>` body, :ref:`Transform2D<class_transform2d>` from, :ref:`Vector2<class_vector2>` motion, :ref:`float<class_float>` margin=0.08, :ref:`Physics2DTestMotionResult<class_physics2dtestmotionresult>` result=null **)** |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`RID<class_rid>`                                              | :ref:`capsule_shape_create<class_Physics2DServer_capsule_shape_create>` **(** **)**                                                                                                                                                                                                                            |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`RID<class_rid>`                                              | :ref:`circle_shape_create<class_Physics2DServer_circle_shape_create>` **(** **)**                                                                                                                                                                                                                              |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`RID<class_rid>`                                              | :ref:`concave_polygon_shape_create<class_Physics2DServer_concave_polygon_shape_create>` **(** **)**                                                                                                                                                                                                            |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`RID<class_rid>`                                              | :ref:`convex_polygon_shape_create<class_Physics2DServer_convex_polygon_shape_create>` **(** **)**                                                                                                                                                                                                              |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`RID<class_rid>`                                              | :ref:`damped_spring_joint_create<class_Physics2DServer_damped_spring_joint_create>` **(** :ref:`Vector2<class_vector2>` anchor_a, :ref:`Vector2<class_vector2>` anchor_b, :ref:`RID<class_rid>` body_a, :ref:`RID<class_rid>` body_b **)**                                                                     |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`float<class_float>`                                          | :ref:`damped_string_joint_get_param<class_Physics2DServer_damped_string_joint_get_param>` **(** :ref:`RID<class_rid>` joint, :ref:`int<class_int>` param **)** const                                                                                                                                           |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`damped_string_joint_set_param<class_Physics2DServer_damped_string_joint_set_param>` **(** :ref:`RID<class_rid>` joint, :ref:`int<class_int>` param, :ref:`float<class_float>` value **)**                                                                                                                |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`free_rid<class_Physics2DServer_free_rid>` **(** :ref:`RID<class_rid>` rid **)**                                                                                                                                                                                                                          |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`                                              | :ref:`get_process_info<class_Physics2DServer_get_process_info>` **(** :ref:`int<class_int>` process_info **)**                                                                                                                                                                                                 |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`RID<class_rid>`                                              | :ref:`groove_joint_create<class_Physics2DServer_groove_joint_create>` **(** :ref:`Vector2<class_vector2>` groove1_a, :ref:`Vector2<class_vector2>` groove2_a, :ref:`Vector2<class_vector2>` anchor_b, :ref:`RID<class_rid>` body_a, :ref:`RID<class_rid>` body_b **)**                                         |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`float<class_float>`                                          | :ref:`joint_get_param<class_Physics2DServer_joint_get_param>` **(** :ref:`RID<class_rid>` joint, :ref:`int<class_int>` param **)** const                                                                                                                                                                       |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`                                              | :ref:`joint_get_type<class_Physics2DServer_joint_get_type>` **(** :ref:`RID<class_rid>` joint **)** const                                                                                                                                                                                                      |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`joint_set_param<class_Physics2DServer_joint_set_param>` **(** :ref:`RID<class_rid>` joint, :ref:`int<class_int>` param, :ref:`float<class_float>` value **)**                                                                                                                                            |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`RID<class_rid>`                                              | :ref:`line_shape_create<class_Physics2DServer_line_shape_create>` **(** **)**                                                                                                                                                                                                                                  |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`RID<class_rid>`                                              | :ref:`pin_joint_create<class_Physics2DServer_pin_joint_create>` **(** :ref:`Vector2<class_vector2>` anchor, :ref:`RID<class_rid>` body_a, :ref:`RID<class_rid>` body_b **)**                                                                                                                                   |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`RID<class_rid>`                                              | :ref:`ray_shape_create<class_Physics2DServer_ray_shape_create>` **(** **)**                                                                                                                                                                                                                                    |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`RID<class_rid>`                                              | :ref:`rectangle_shape_create<class_Physics2DServer_rectangle_shape_create>` **(** **)**                                                                                                                                                                                                                        |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`RID<class_rid>`                                              | :ref:`segment_shape_create<class_Physics2DServer_segment_shape_create>` **(** **)**                                                                                                                                                                                                                            |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`set_active<class_Physics2DServer_set_active>` **(** :ref:`bool<class_bool>` active **)**                                                                                                                                                                                                                 |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Variant<class_variant>`                                      | :ref:`shape_get_data<class_Physics2DServer_shape_get_data>` **(** :ref:`RID<class_rid>` shape **)** const                                                                                                                                                                                                      |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`                                              | :ref:`shape_get_type<class_Physics2DServer_shape_get_type>` **(** :ref:`RID<class_rid>` shape **)** const                                                                                                                                                                                                      |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`shape_set_data<class_Physics2DServer_shape_set_data>` **(** :ref:`RID<class_rid>` shape, :ref:`Variant<class_variant>` data **)**                                                                                                                                                                        |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`RID<class_rid>`                                              | :ref:`space_create<class_Physics2DServer_space_create>` **(** **)**                                                                                                                                                                                                                                            |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Physics2DDirectSpaceState<class_physics2ddirectspacestate>`  | :ref:`space_get_direct_state<class_Physics2DServer_space_get_direct_state>` **(** :ref:`RID<class_rid>` space **)**                                                                                                                                                                                            |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`float<class_float>`                                          | :ref:`space_get_param<class_Physics2DServer_space_get_param>` **(** :ref:`RID<class_rid>` space, :ref:`int<class_int>` param **)** const                                                                                                                                                                       |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`bool<class_bool>`                                            | :ref:`space_is_active<class_Physics2DServer_space_is_active>` **(** :ref:`RID<class_rid>` space **)** const                                                                                                                                                                                                    |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`space_set_active<class_Physics2DServer_space_set_active>` **(** :ref:`RID<class_rid>` space, :ref:`bool<class_bool>` active **)**                                                                                                                                                                        |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                               | :ref:`space_set_param<class_Physics2DServer_space_set_param>` **(** :ref:`RID<class_rid>` space, :ref:`int<class_int>` param, :ref:`float<class_float>` value **)**                                                                                                                                            |
-+--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`area_add_shape<class_Physics2DServer_area_add_shape>` **(** :ref:`RID<class_rid>` area, :ref:`RID<class_rid>` shape, :ref:`Transform2D<class_transform2d>` transform=Transform2D( 1, 0, 0, 1, 0, 0 ) **)**                                                                                                                                         |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`area_attach_object_instance_id<class_Physics2DServer_area_attach_object_instance_id>` **(** :ref:`RID<class_rid>` area, :ref:`int<class_int>` id **)**                                                                                                                                                                                             |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`area_clear_shapes<class_Physics2DServer_area_clear_shapes>` **(** :ref:`RID<class_rid>` area **)**                                                                                                                                                                                                                                                 |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`RID<class_rid>`                                              | :ref:`area_create<class_Physics2DServer_area_create>` **(** **)**                                                                                                                                                                                                                                                                                        |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`                                              | :ref:`area_get_object_instance_id<class_Physics2DServer_area_get_object_instance_id>` **(** :ref:`RID<class_rid>` area **)** const                                                                                                                                                                                                                       |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Variant<class_variant>`                                      | :ref:`area_get_param<class_Physics2DServer_area_get_param>` **(** :ref:`RID<class_rid>` area, :ref:`int<class_int>` param **)** const                                                                                                                                                                                                                    |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`RID<class_rid>`                                              | :ref:`area_get_shape<class_Physics2DServer_area_get_shape>` **(** :ref:`RID<class_rid>` area, :ref:`int<class_int>` shape_idx **)** const                                                                                                                                                                                                                |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`                                              | :ref:`area_get_shape_count<class_Physics2DServer_area_get_shape_count>` **(** :ref:`RID<class_rid>` area **)** const                                                                                                                                                                                                                                     |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Transform2D<class_transform2d>`                              | :ref:`area_get_shape_transform<class_Physics2DServer_area_get_shape_transform>` **(** :ref:`RID<class_rid>` area, :ref:`int<class_int>` shape_idx **)** const                                                                                                                                                                                            |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`RID<class_rid>`                                              | :ref:`area_get_space<class_Physics2DServer_area_get_space>` **(** :ref:`RID<class_rid>` area **)** const                                                                                                                                                                                                                                                 |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`                                              | :ref:`area_get_space_override_mode<class_Physics2DServer_area_get_space_override_mode>` **(** :ref:`RID<class_rid>` area **)** const                                                                                                                                                                                                                     |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Transform2D<class_transform2d>`                              | :ref:`area_get_transform<class_Physics2DServer_area_get_transform>` **(** :ref:`RID<class_rid>` area **)** const                                                                                                                                                                                                                                         |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`area_remove_shape<class_Physics2DServer_area_remove_shape>` **(** :ref:`RID<class_rid>` area, :ref:`int<class_int>` shape_idx **)**                                                                                                                                                                                                                |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`area_set_collision_layer<class_Physics2DServer_area_set_collision_layer>` **(** :ref:`RID<class_rid>` area, :ref:`int<class_int>` layer **)**                                                                                                                                                                                                      |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`area_set_collision_mask<class_Physics2DServer_area_set_collision_mask>` **(** :ref:`RID<class_rid>` area, :ref:`int<class_int>` mask **)**                                                                                                                                                                                                         |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`area_set_monitor_callback<class_Physics2DServer_area_set_monitor_callback>` **(** :ref:`RID<class_rid>` area, :ref:`Object<class_object>` receiver, :ref:`String<class_string>` method **)**                                                                                                                                                       |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`area_set_param<class_Physics2DServer_area_set_param>` **(** :ref:`RID<class_rid>` area, :ref:`int<class_int>` param, :ref:`Variant<class_variant>` value **)**                                                                                                                                                                                     |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`area_set_shape<class_Physics2DServer_area_set_shape>` **(** :ref:`RID<class_rid>` area, :ref:`int<class_int>` shape_idx, :ref:`RID<class_rid>` shape **)**                                                                                                                                                                                         |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`area_set_shape_disabled<class_Physics2DServer_area_set_shape_disabled>` **(** :ref:`RID<class_rid>` area, :ref:`int<class_int>` shape_idx, :ref:`bool<class_bool>` disable **)**                                                                                                                                                                   |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`area_set_shape_transform<class_Physics2DServer_area_set_shape_transform>` **(** :ref:`RID<class_rid>` area, :ref:`int<class_int>` shape_idx, :ref:`Transform2D<class_transform2d>` transform **)**                                                                                                                                                 |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`area_set_space<class_Physics2DServer_area_set_space>` **(** :ref:`RID<class_rid>` area, :ref:`RID<class_rid>` space **)**                                                                                                                                                                                                                          |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`area_set_space_override_mode<class_Physics2DServer_area_set_space_override_mode>` **(** :ref:`RID<class_rid>` area, :ref:`int<class_int>` mode **)**                                                                                                                                                                                               |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`area_set_transform<class_Physics2DServer_area_set_transform>` **(** :ref:`RID<class_rid>` area, :ref:`Transform2D<class_transform2d>` transform **)**                                                                                                                                                                                              |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`body_add_collision_exception<class_Physics2DServer_body_add_collision_exception>` **(** :ref:`RID<class_rid>` body, :ref:`RID<class_rid>` excepted_body **)**                                                                                                                                                                                      |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`body_add_force<class_Physics2DServer_body_add_force>` **(** :ref:`RID<class_rid>` body, :ref:`Vector2<class_vector2>` offset, :ref:`Vector2<class_vector2>` force **)**                                                                                                                                                                            |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`body_add_shape<class_Physics2DServer_body_add_shape>` **(** :ref:`RID<class_rid>` body, :ref:`RID<class_rid>` shape, :ref:`Transform2D<class_transform2d>` transform=Transform2D( 1, 0, 0, 1, 0, 0 ) **)**                                                                                                                                         |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`body_apply_impulse<class_Physics2DServer_body_apply_impulse>` **(** :ref:`RID<class_rid>` body, :ref:`Vector2<class_vector2>` position, :ref:`Vector2<class_vector2>` impulse **)**                                                                                                                                                                |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`body_attach_object_instance_id<class_Physics2DServer_body_attach_object_instance_id>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` id **)**                                                                                                                                                                                             |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`body_clear_shapes<class_Physics2DServer_body_clear_shapes>` **(** :ref:`RID<class_rid>` body **)**                                                                                                                                                                                                                                                 |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`RID<class_rid>`                                              | :ref:`body_create<class_Physics2DServer_body_create>` **(** **)**                                                                                                                                                                                                                                                                                        |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`                                              | :ref:`body_get_collision_layer<class_Physics2DServer_body_get_collision_layer>` **(** :ref:`RID<class_rid>` body **)** const                                                                                                                                                                                                                             |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`                                              | :ref:`body_get_collision_mask<class_Physics2DServer_body_get_collision_mask>` **(** :ref:`RID<class_rid>` body **)** const                                                                                                                                                                                                                               |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`                                              | :ref:`body_get_continuous_collision_detection_mode<class_Physics2DServer_body_get_continuous_collision_detection_mode>` **(** :ref:`RID<class_rid>` body **)** const                                                                                                                                                                                     |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Physics2DDirectBodyState<class_physics2ddirectbodystate>`    | :ref:`body_get_direct_state<class_Physics2DServer_body_get_direct_state>` **(** :ref:`RID<class_rid>` body **)**                                                                                                                                                                                                                                         |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`                                              | :ref:`body_get_max_contacts_reported<class_Physics2DServer_body_get_max_contacts_reported>` **(** :ref:`RID<class_rid>` body **)** const                                                                                                                                                                                                                 |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`                                              | :ref:`body_get_mode<class_Physics2DServer_body_get_mode>` **(** :ref:`RID<class_rid>` body **)** const                                                                                                                                                                                                                                                   |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`                                              | :ref:`body_get_object_instance_id<class_Physics2DServer_body_get_object_instance_id>` **(** :ref:`RID<class_rid>` body **)** const                                                                                                                                                                                                                       |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`float<class_float>`                                          | :ref:`body_get_param<class_Physics2DServer_body_get_param>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` param **)** const                                                                                                                                                                                                                    |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`RID<class_rid>`                                              | :ref:`body_get_shape<class_Physics2DServer_body_get_shape>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` shape_idx **)** const                                                                                                                                                                                                                |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`                                              | :ref:`body_get_shape_count<class_Physics2DServer_body_get_shape_count>` **(** :ref:`RID<class_rid>` body **)** const                                                                                                                                                                                                                                     |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Variant<class_variant>`                                      | :ref:`body_get_shape_metadata<class_Physics2DServer_body_get_shape_metadata>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` shape_idx **)** const                                                                                                                                                                                              |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Transform2D<class_transform2d>`                              | :ref:`body_get_shape_transform<class_Physics2DServer_body_get_shape_transform>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` shape_idx **)** const                                                                                                                                                                                            |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`RID<class_rid>`                                              | :ref:`body_get_space<class_Physics2DServer_body_get_space>` **(** :ref:`RID<class_rid>` body **)** const                                                                                                                                                                                                                                                 |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Variant<class_variant>`                                      | :ref:`body_get_state<class_Physics2DServer_body_get_state>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` state **)** const                                                                                                                                                                                                                    |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`                                            | :ref:`body_is_omitting_force_integration<class_Physics2DServer_body_is_omitting_force_integration>` **(** :ref:`RID<class_rid>` body **)** const                                                                                                                                                                                                         |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`body_remove_collision_exception<class_Physics2DServer_body_remove_collision_exception>` **(** :ref:`RID<class_rid>` body, :ref:`RID<class_rid>` excepted_body **)**                                                                                                                                                                                |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`body_remove_shape<class_Physics2DServer_body_remove_shape>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` shape_idx **)**                                                                                                                                                                                                                |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`body_set_axis_velocity<class_Physics2DServer_body_set_axis_velocity>` **(** :ref:`RID<class_rid>` body, :ref:`Vector2<class_vector2>` axis_velocity **)**                                                                                                                                                                                          |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`body_set_collision_layer<class_Physics2DServer_body_set_collision_layer>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` layer **)**                                                                                                                                                                                                      |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`body_set_collision_mask<class_Physics2DServer_body_set_collision_mask>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` mask **)**                                                                                                                                                                                                         |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`body_set_continuous_collision_detection_mode<class_Physics2DServer_body_set_continuous_collision_detection_mode>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` mode **)**                                                                                                                                                               |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`body_set_force_integration_callback<class_Physics2DServer_body_set_force_integration_callback>` **(** :ref:`RID<class_rid>` body, :ref:`Object<class_object>` receiver, :ref:`String<class_string>` method, :ref:`Variant<class_variant>` userdata=null **)**                                                                                      |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`body_set_max_contacts_reported<class_Physics2DServer_body_set_max_contacts_reported>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` amount **)**                                                                                                                                                                                         |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`body_set_mode<class_Physics2DServer_body_set_mode>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` mode **)**                                                                                                                                                                                                                             |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`body_set_omit_force_integration<class_Physics2DServer_body_set_omit_force_integration>` **(** :ref:`RID<class_rid>` body, :ref:`bool<class_bool>` enable **)**                                                                                                                                                                                     |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`body_set_param<class_Physics2DServer_body_set_param>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` param, :ref:`float<class_float>` value **)**                                                                                                                                                                                         |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`body_set_shape<class_Physics2DServer_body_set_shape>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` shape_idx, :ref:`RID<class_rid>` shape **)**                                                                                                                                                                                         |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`body_set_shape_as_one_way_collision<class_Physics2DServer_body_set_shape_as_one_way_collision>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` shape_idx, :ref:`bool<class_bool>` enable **)**                                                                                                                                            |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`body_set_shape_disabled<class_Physics2DServer_body_set_shape_disabled>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` shape_idx, :ref:`bool<class_bool>` disable **)**                                                                                                                                                                   |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`body_set_shape_metadata<class_Physics2DServer_body_set_shape_metadata>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` shape_idx, :ref:`Variant<class_variant>` metadata **)**                                                                                                                                                            |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`body_set_shape_transform<class_Physics2DServer_body_set_shape_transform>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` shape_idx, :ref:`Transform2D<class_transform2d>` transform **)**                                                                                                                                                 |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`body_set_space<class_Physics2DServer_body_set_space>` **(** :ref:`RID<class_rid>` body, :ref:`RID<class_rid>` space **)**                                                                                                                                                                                                                          |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`body_set_state<class_Physics2DServer_body_set_state>` **(** :ref:`RID<class_rid>` body, :ref:`int<class_int>` state, :ref:`Variant<class_variant>` value **)**                                                                                                                                                                                     |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`                                            | :ref:`body_test_motion<class_Physics2DServer_body_test_motion>` **(** :ref:`RID<class_rid>` body, :ref:`Transform2D<class_transform2d>` from, :ref:`Vector2<class_vector2>` motion, :ref:`bool<class_bool>` infinite_inertia, :ref:`float<class_float>` margin=0.08, :ref:`Physics2DTestMotionResult<class_physics2dtestmotionresult>` result=null **)** |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`RID<class_rid>`                                              | :ref:`capsule_shape_create<class_Physics2DServer_capsule_shape_create>` **(** **)**                                                                                                                                                                                                                                                                      |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`RID<class_rid>`                                              | :ref:`circle_shape_create<class_Physics2DServer_circle_shape_create>` **(** **)**                                                                                                                                                                                                                                                                        |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`RID<class_rid>`                                              | :ref:`concave_polygon_shape_create<class_Physics2DServer_concave_polygon_shape_create>` **(** **)**                                                                                                                                                                                                                                                      |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`RID<class_rid>`                                              | :ref:`convex_polygon_shape_create<class_Physics2DServer_convex_polygon_shape_create>` **(** **)**                                                                                                                                                                                                                                                        |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`RID<class_rid>`                                              | :ref:`damped_spring_joint_create<class_Physics2DServer_damped_spring_joint_create>` **(** :ref:`Vector2<class_vector2>` anchor_a, :ref:`Vector2<class_vector2>` anchor_b, :ref:`RID<class_rid>` body_a, :ref:`RID<class_rid>` body_b **)**                                                                                                               |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`float<class_float>`                                          | :ref:`damped_string_joint_get_param<class_Physics2DServer_damped_string_joint_get_param>` **(** :ref:`RID<class_rid>` joint, :ref:`int<class_int>` param **)** const                                                                                                                                                                                     |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`damped_string_joint_set_param<class_Physics2DServer_damped_string_joint_set_param>` **(** :ref:`RID<class_rid>` joint, :ref:`int<class_int>` param, :ref:`float<class_float>` value **)**                                                                                                                                                          |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`free_rid<class_Physics2DServer_free_rid>` **(** :ref:`RID<class_rid>` rid **)**                                                                                                                                                                                                                                                                    |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`                                              | :ref:`get_process_info<class_Physics2DServer_get_process_info>` **(** :ref:`int<class_int>` process_info **)**                                                                                                                                                                                                                                           |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`RID<class_rid>`                                              | :ref:`groove_joint_create<class_Physics2DServer_groove_joint_create>` **(** :ref:`Vector2<class_vector2>` groove1_a, :ref:`Vector2<class_vector2>` groove2_a, :ref:`Vector2<class_vector2>` anchor_b, :ref:`RID<class_rid>` body_a, :ref:`RID<class_rid>` body_b **)**                                                                                   |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`float<class_float>`                                          | :ref:`joint_get_param<class_Physics2DServer_joint_get_param>` **(** :ref:`RID<class_rid>` joint, :ref:`int<class_int>` param **)** const                                                                                                                                                                                                                 |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`                                              | :ref:`joint_get_type<class_Physics2DServer_joint_get_type>` **(** :ref:`RID<class_rid>` joint **)** const                                                                                                                                                                                                                                                |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`joint_set_param<class_Physics2DServer_joint_set_param>` **(** :ref:`RID<class_rid>` joint, :ref:`int<class_int>` param, :ref:`float<class_float>` value **)**                                                                                                                                                                                      |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`RID<class_rid>`                                              | :ref:`line_shape_create<class_Physics2DServer_line_shape_create>` **(** **)**                                                                                                                                                                                                                                                                            |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`RID<class_rid>`                                              | :ref:`pin_joint_create<class_Physics2DServer_pin_joint_create>` **(** :ref:`Vector2<class_vector2>` anchor, :ref:`RID<class_rid>` body_a, :ref:`RID<class_rid>` body_b **)**                                                                                                                                                                             |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`RID<class_rid>`                                              | :ref:`ray_shape_create<class_Physics2DServer_ray_shape_create>` **(** **)**                                                                                                                                                                                                                                                                              |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`RID<class_rid>`                                              | :ref:`rectangle_shape_create<class_Physics2DServer_rectangle_shape_create>` **(** **)**                                                                                                                                                                                                                                                                  |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`RID<class_rid>`                                              | :ref:`segment_shape_create<class_Physics2DServer_segment_shape_create>` **(** **)**                                                                                                                                                                                                                                                                      |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`set_active<class_Physics2DServer_set_active>` **(** :ref:`bool<class_bool>` active **)**                                                                                                                                                                                                                                                           |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Variant<class_variant>`                                      | :ref:`shape_get_data<class_Physics2DServer_shape_get_data>` **(** :ref:`RID<class_rid>` shape **)** const                                                                                                                                                                                                                                                |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`                                              | :ref:`shape_get_type<class_Physics2DServer_shape_get_type>` **(** :ref:`RID<class_rid>` shape **)** const                                                                                                                                                                                                                                                |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`shape_set_data<class_Physics2DServer_shape_set_data>` **(** :ref:`RID<class_rid>` shape, :ref:`Variant<class_variant>` data **)**                                                                                                                                                                                                                  |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`RID<class_rid>`                                              | :ref:`space_create<class_Physics2DServer_space_create>` **(** **)**                                                                                                                                                                                                                                                                                      |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Physics2DDirectSpaceState<class_physics2ddirectspacestate>`  | :ref:`space_get_direct_state<class_Physics2DServer_space_get_direct_state>` **(** :ref:`RID<class_rid>` space **)**                                                                                                                                                                                                                                      |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`float<class_float>`                                          | :ref:`space_get_param<class_Physics2DServer_space_get_param>` **(** :ref:`RID<class_rid>` space, :ref:`int<class_int>` param **)** const                                                                                                                                                                                                                 |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`                                            | :ref:`space_is_active<class_Physics2DServer_space_is_active>` **(** :ref:`RID<class_rid>` space **)** const                                                                                                                                                                                                                                              |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`space_set_active<class_Physics2DServer_space_set_active>` **(** :ref:`RID<class_rid>` space, :ref:`bool<class_bool>` active **)**                                                                                                                                                                                                                  |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                               | :ref:`space_set_param<class_Physics2DServer_space_set_param>` **(** :ref:`RID<class_rid>` space, :ref:`int<class_int>` param, :ref:`float<class_float>` value **)**                                                                                                                                                                                      |
++--------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
 Enums
 -----
@@ -739,7 +739,7 @@ Sets a body state (see BODY_STATE\* constants).
 
 .. _class_Physics2DServer_body_test_motion:
 
-- :ref:`bool<class_bool>` **body_test_motion** **(** :ref:`RID<class_rid>` body, :ref:`Transform2D<class_transform2d>` from, :ref:`Vector2<class_vector2>` motion, :ref:`float<class_float>` margin=0.08, :ref:`Physics2DTestMotionResult<class_physics2dtestmotionresult>` result=null **)**
+- :ref:`bool<class_bool>` **body_test_motion** **(** :ref:`RID<class_rid>` body, :ref:`Transform2D<class_transform2d>` from, :ref:`Vector2<class_vector2>` motion, :ref:`bool<class_bool>` infinite_inertia, :ref:`float<class_float>` margin=0.08, :ref:`Physics2DTestMotionResult<class_physics2dtestmotionresult>` result=null **)**
 
 Returns whether a body can move from a given point in a given direction. Apart from the boolean return value, a :ref:`Physics2DTestMotionResult<class_physics2dtestmotionresult>` can be passed to return additional information in.
 

classes/class_physicsdirectbodystate.rst

@@ -21,12 +21,16 @@ Brief Description
 Member Functions
 ----------------
 
++----------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                           | :ref:`add_central_force<class_PhysicsDirectBodyState_add_central_force>` **(** :ref:`Vector3<class_vector3>` force **)**                                                     |
 +----------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | void                                                           | :ref:`add_force<class_PhysicsDirectBodyState_add_force>` **(** :ref:`Vector3<class_vector3>` force, :ref:`Vector3<class_vector3>` position **)**                             |
 +----------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                                           | :ref:`add_torque<class_PhysicsDirectBodyState_add_torque>` **(** :ref:`Vector3<class_vector3>` torque **)**                                                                  |
++----------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | void                                                           | :ref:`apply_impulse<class_PhysicsDirectBodyState_apply_impulse>` **(** :ref:`Vector3<class_vector3>` position, :ref:`Vector3<class_vector3>` j **)**                         |
 +----------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                                           | :ref:`apply_torqe_impulse<class_PhysicsDirectBodyState_apply_torqe_impulse>` **(** :ref:`Vector3<class_vector3>` j **)**                                                     |
+| void                                                           | :ref:`apply_torque_impulse<class_PhysicsDirectBodyState_apply_torque_impulse>` **(** :ref:`Vector3<class_vector3>` j **)**                                                   |
 +----------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`RID<class_rid>`                                          | :ref:`get_contact_collider<class_PhysicsDirectBodyState_get_contact_collider>` **(** :ref:`int<class_int>` contact_idx **)** const                                           |
 +----------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -108,17 +112,25 @@ Member Variables
 Member Function Description
 ---------------------------
 
+.. _class_PhysicsDirectBodyState_add_central_force:
+
+- void **add_central_force** **(** :ref:`Vector3<class_vector3>` force **)**
+
 .. _class_PhysicsDirectBodyState_add_force:
 
 - void **add_force** **(** :ref:`Vector3<class_vector3>` force, :ref:`Vector3<class_vector3>` position **)**
 
+.. _class_PhysicsDirectBodyState_add_torque:
+
+- void **add_torque** **(** :ref:`Vector3<class_vector3>` torque **)**
+
 .. _class_PhysicsDirectBodyState_apply_impulse:
 
 - void **apply_impulse** **(** :ref:`Vector3<class_vector3>` position, :ref:`Vector3<class_vector3>` j **)**
 
-.. _class_PhysicsDirectBodyState_apply_torqe_impulse:
+.. _class_PhysicsDirectBodyState_apply_torque_impulse:
 
-- void **apply_torqe_impulse** **(** :ref:`Vector3<class_vector3>` j **)**
+- void **apply_torque_impulse** **(** :ref:`Vector3<class_vector3>` j **)**
 
 .. _class_PhysicsDirectBodyState_get_contact_collider:
 

classes/class_pinjoint2d.rst

@@ -27,5 +27,5 @@ Member Variables
 Description
 -----------
 
-Pin Joint for 2D Rigid Bodies. It pins 2 bodies (rigid or static) together, or a single body to a fixed position in space.
+Pin Joint for 2D Rigid Bodies. It pins two bodies (rigid or static) together.
 

classes/class_polygon2d.rst

@@ -43,6 +43,10 @@ Member Variables
 
 - :ref:`PoolVector2Array<class_poolvector2array>` **polygon** - The polygon's list of vertices. The final point will be connected to the first.
 
+  .. _class_Polygon2D_splits:
+
+- :ref:`PoolIntArray<class_poolintarray>` **splits**
+
   .. _class_Polygon2D_texture:
 
 - :ref:`Texture<class_texture>` **texture** - The polygon's fill texture. Use ``uv`` to set texture coordinates.

classes/class_rayshape.rst

@@ -23,6 +23,10 @@ Member Variables
 
 - :ref:`float<class_float>` **length** - The ray's length.
 
+  .. _class_RayShape_slips_on_slope:
+
+- :ref:`bool<class_bool>` **slips_on_slope** - If ``true`` allow the shape to return the correct normal. Default value: ``false``.
+
 
 Description
 -----------

classes/class_rayshape2d.rst

@@ -23,6 +23,10 @@ Member Variables
 
 - :ref:`float<class_float>` **length** - The ray's length.
 
+  .. _class_RayShape2D_slips_on_slope:
+
+- :ref:`bool<class_bool>` **slips_on_slope** - If ``true`` allow the shape to return the correct normal. Default value: ``false``.
+
 
 Description
 -----------

classes/class_regex.rst

@@ -42,7 +42,7 @@ Member Functions
 Description
 -----------
 
-Regular Expression (or regex) is a compact programming language that can be used to recognise strings that follow a specific pattern, such as URLs, email addresses, complete sentences, etc. For instance, a regex of ``ab[0-9]`` would find any string that is ``ab`` followed by any number from ``0`` to ``9``. For a more in-depth look, you can easily find various tutorials and detailed explainations on the Internet.
+Regular Expression (or regex) is a compact programming language that can be used to recognise strings that follow a specific pattern, such as URLs, email addresses, complete sentences, etc. For instance, a regex of ``ab[0-9]`` would find any string that is ``ab`` followed by any number from ``0`` to ``9``. For a more in-depth look, you can easily find various tutorials and detailed explanations on the Internet.
 
 To begin, the RegEx object needs to be compiled with the search pattern using :ref:`compile<class_RegEx_compile>` before it can be used.
 
@@ -53,7 +53,7 @@ To begin, the RegEx object needs to be compiled with the search pattern using :r
 
 The search pattern must be escaped first for gdscript before it is escaped for the expression. For example, ``compile("\\d+")`` would be read by RegEx as ``\d+``. Similarly, ``compile("\"(?:\\\\.|[^\"])*\"")`` would be read as ``"(?:\\.|[^"])*"``
 
-Using :ref:`search<class_RegEx_search>` you can find the pattern within the given text. If a pattern is found, :ref:`RegExMatch<class_regexmatch>` is returned and you can retrieve details of the results using fuctions such as :ref:`RegExMatch.get_string<class_RegExMatch_get_string>` and :ref:`RegExMatch.get_start<class_RegExMatch_get_start>`.
+Using :ref:`search<class_RegEx_search>` you can find the pattern within the given text. If a pattern is found, :ref:`RegExMatch<class_regexmatch>` is returned and you can retrieve details of the results using functions such as :ref:`RegExMatch.get_string<class_RegExMatch_get_string>` and :ref:`RegExMatch.get_start<class_RegExMatch_get_start>`.
 
 ::
 

classes/class_rigidbody.rst

@@ -26,6 +26,8 @@ Member Functions
 +----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
 | void                       | :ref:`apply_impulse<class_RigidBody_apply_impulse>` **(** :ref:`Vector3<class_vector3>` position, :ref:`Vector3<class_vector3>` impulse **)**     |
 +----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                       | :ref:`apply_torque_impulse<class_RigidBody_apply_torque_impulse>` **(** :ref:`Vector3<class_vector3>` impulse **)**                               |
++----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`Array<class_array>`  | :ref:`get_colliding_bodies<class_RigidBody_get_colliding_bodies>` **(** **)** const                                                               |
 +----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
 | void                       | :ref:`set_axis_velocity<class_RigidBody_set_axis_velocity>` **(** :ref:`Vector3<class_vector3>` axis_velocity **)**                               |
@@ -181,13 +183,11 @@ Description
 
 This is the node that implements full 3D physics. This means that you do not control a RigidBody directly. Instead you can apply forces to it (gravity, impulses, etc.), and the physics simulation will calculate the resulting movement, collision, bouncing, rotating, etc.
 
-This node can use custom force integration, for writing complex physics motion behavior per node.
-
-This node can shift state between regular Rigid body, Kinematic, Character or Static.
+A RigidBody has 4 behavior :ref:`mode<class_RigidBody_mode>`\ s: Rigid, Static, Character, and Kinematic.
 
-Character mode forbids this node from being rotated.
+**Note:** Don't change a RigidBody's position every frame or very often. Sporadic changes work fine, but physics runs at a different granularity (fixed hz) than usual rendering (process callback) and maybe even in a separate thread, so changing this from a process loop will yield strange behavior. If you need to directly affect the body's state, use :ref:`_integrate_forces<class_RigidBody__integrate_forces>`, which allows you to directly access the physics state.
 
-As a warning, don't change RigidBody's position every frame or very often. Sporadic changes work fine, but physics runs at a different granularity (fixed hz) than usual rendering (process callback) and maybe even in a separate thread, so changing this from a process loop will yield strange behavior.
+If you need to override the default physics behavior, you can write a custom force integration. See :ref:`custom_integrator<class_RigidBody_custom_integrator>`.
 
 Member Function Description
 ---------------------------
@@ -204,6 +204,12 @@ Called during physics processing, allowing you to read and safely modify the sim
 
 Apply a positioned impulse (which will be affected by the body mass and shape). This is the equivalent of hitting a billiard ball with a cue: a force that is applied once, and only once. Both the impulse and the position are in global coordinates, and the position is relative to the object's origin.
 
+.. _class_RigidBody_apply_torque_impulse:
+
+- void **apply_torque_impulse** **(** :ref:`Vector3<class_vector3>` impulse **)**
+
+Apply a torque impulse (which will be affected by the body mass and shape). This will rotate the body around the passed in vector.
+
 .. _class_RigidBody_get_colliding_bodies:
 
 - :ref:`Array<class_array>` **get_colliding_bodies** **(** **)** const

classes/class_rigidbody2d.rst

@@ -19,19 +19,19 @@ A body that is controlled by the 2D physics engine.
 Member Functions
 ----------------
 
-+----------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                       | :ref:`_integrate_forces<class_RigidBody2D__integrate_forces>` **(** :ref:`Physics2DDirectBodyState<class_physics2ddirectbodystate>` state **)** virtual                                                                  |
-+----------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                       | :ref:`add_force<class_RigidBody2D_add_force>` **(** :ref:`Vector2<class_vector2>` offset, :ref:`Vector2<class_vector2>` force **)**                                                                                      |
-+----------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                       | :ref:`apply_impulse<class_RigidBody2D_apply_impulse>` **(** :ref:`Vector2<class_vector2>` offset, :ref:`Vector2<class_vector2>` impulse **)**                                                                            |
-+----------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Array<class_array>`  | :ref:`get_colliding_bodies<class_RigidBody2D_get_colliding_bodies>` **(** **)** const                                                                                                                                    |
-+----------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                       | :ref:`set_axis_velocity<class_RigidBody2D_set_axis_velocity>` **(** :ref:`Vector2<class_vector2>` axis_velocity **)**                                                                                                    |
-+----------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`bool<class_bool>`    | :ref:`test_motion<class_RigidBody2D_test_motion>` **(** :ref:`Vector2<class_vector2>` motion, :ref:`float<class_float>` margin=0.08, :ref:`Physics2DTestMotionResult<class_physics2dtestmotionresult>` result=null **)** |
-+----------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
++----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                       | :ref:`_integrate_forces<class_RigidBody2D__integrate_forces>` **(** :ref:`Physics2DDirectBodyState<class_physics2ddirectbodystate>` state **)** virtual                                                                                                                 |
++----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                       | :ref:`add_force<class_RigidBody2D_add_force>` **(** :ref:`Vector2<class_vector2>` offset, :ref:`Vector2<class_vector2>` force **)**                                                                                                                                     |
++----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                       | :ref:`apply_impulse<class_RigidBody2D_apply_impulse>` **(** :ref:`Vector2<class_vector2>` offset, :ref:`Vector2<class_vector2>` impulse **)**                                                                                                                           |
++----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Array<class_array>`  | :ref:`get_colliding_bodies<class_RigidBody2D_get_colliding_bodies>` **(** **)** const                                                                                                                                                                                   |
++----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                       | :ref:`set_axis_velocity<class_RigidBody2D_set_axis_velocity>` **(** :ref:`Vector2<class_vector2>` axis_velocity **)**                                                                                                                                                   |
++----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`    | :ref:`test_motion<class_RigidBody2D_test_motion>` **(** :ref:`Vector2<class_vector2>` motion, :ref:`bool<class_bool>` infinite_inertia=true, :ref:`float<class_float>` margin=0.08, :ref:`Physics2DTestMotionResult<class_physics2dtestmotionresult>` result=null **)** |
++----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
 Signals
 -------
@@ -175,15 +175,7 @@ Description
 
 This node implements simulated 2D physics. You do not control a RigidBody2D directly. Instead you apply forces to it (gravity, impulses, etc.) and the physics simulation calculates the resulting movement based on its mass, friction, and other physical properties.
 
-A RigidBody2D has 4 behavior modes (see :ref:`mode<class_RigidBody2D_mode>`):
-
-- **Rigid**: The body behaves as a physical object. It collides with other bodies and responds to forces applied to it. This is the default mode.
-
-- **Static**: The body behaves like a :ref:`StaticBody2D<class_staticbody2d>` and does not move.
-
-- **Character**: Similar to ``Rigid`` mode, but the body can not rotate.
-
-- **Kinematic**: The body behaves like a :ref:`KinematicBody2D<class_kinematicbody2d>`, and must be moved by code.
+A RigidBody2D has 4 behavior :ref:`mode<class_RigidBody2D_mode>`\ s: Rigid, Static, Character, and Kinematic.
 
 **Note:** You should not change a RigidBody2D's ``position`` or ``linear_velocity`` every frame or even very often. If you need to directly affect the body's state, use :ref:`_integrate_forces<class_RigidBody2D__integrate_forces>`, which allows you to directly access the physics state.
 
@@ -224,7 +216,7 @@ Sets the body's velocity on the given axis. The velocity in the given vector axi
 
 .. _class_RigidBody2D_test_motion:
 
-- :ref:`bool<class_bool>` **test_motion** **(** :ref:`Vector2<class_vector2>` motion, :ref:`float<class_float>` margin=0.08, :ref:`Physics2DTestMotionResult<class_physics2dtestmotionresult>` result=null **)**
+- :ref:`bool<class_bool>` **test_motion** **(** :ref:`Vector2<class_vector2>` motion, :ref:`bool<class_bool>` infinite_inertia=true, :ref:`float<class_float>` margin=0.08, :ref:`Physics2DTestMotionResult<class_physics2dtestmotionresult>` result=null **)**
 
 Returns ``true`` if a collision would result from moving in the given vector. ``margin`` increases the size of the shapes involved in the collision detection, and ``result`` is an object of type :ref:`Physics2DTestMotionResult<class_physics2dtestmotionresult>`, which contains additional information about the collision (should there be one).
 

classes/class_sprite.rst

@@ -16,6 +16,13 @@ Brief Description
 
 General purpose Sprite node.
 
+Member Functions
+----------------
+
++----------------------------+----------------------------------------------------------+
+| :ref:`Rect2<class_rect2>`  | :ref:`get_rect<class_Sprite_get_rect>` **(** **)** const |
++----------------------------+----------------------------------------------------------+
+
 Signals
 -------
 
@@ -53,7 +60,7 @@ Member Variables
 
   .. _class_Sprite_hframes:
 
-- :ref:`int<class_int>` **hframes** - The number of collumns in the sprite sheet.
+- :ref:`int<class_int>` **hframes** - The number of columns in the sprite sheet.
 
   .. _class_Sprite_normal_map:
 
@@ -89,3 +96,13 @@ Description
 
 A node that displays a 2D texture. The texture displayed can be a region from a larger atlas texture, or a frame from a sprite sheet animation.
 
+Member Function Description
+---------------------------
+
+.. _class_Sprite_get_rect:
+
+- :ref:`Rect2<class_rect2>` **get_rect** **(** **)** const
+
+Returns a Rect2 representing the Sprite's boundary relative to its local coordinates.
+
+

classes/class_styleboxtexture.rst

@@ -86,7 +86,7 @@ Member Variables
 
   .. _class_StyleBoxTexture_normal_map:
 
-- :ref:`Resource<class_resource>` **normal_map**
+- :ref:`Texture<class_texture>` **normal_map**
 
   .. _class_StyleBoxTexture_region_rect:
 
@@ -94,7 +94,7 @@ Member Variables
 
   .. _class_StyleBoxTexture_texture:
 
-- :ref:`Resource<class_resource>` **texture**
+- :ref:`Texture<class_texture>` **texture**
 
 
 Enums

classes/class_tilemap.rst

@@ -22,6 +22,8 @@ Member Functions
 +--------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | void                           | :ref:`clear<class_TileMap_clear>` **(** **)**                                                                                                                                                                                                                                                                       |
 +--------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                           | :ref:`fix_invalid_tiles<class_TileMap_fix_invalid_tiles>` **(** **)**                                                                                                                                                                                                                                               |
++--------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`int<class_int>`          | :ref:`get_cell<class_TileMap_get_cell>` **(** :ref:`int<class_int>` x, :ref:`int<class_int>` y **)** const                                                                                                                                                                                                          |
 +--------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`int<class_int>`          | :ref:`get_cellv<class_TileMap_get_cellv>` **(** :ref:`Vector2<class_vector2>` position **)** const                                                                                                                                                                                                                  |
@@ -180,6 +182,12 @@ Member Function Description
 
 Clear all cells.
 
+.. _class_TileMap_fix_invalid_tiles:
+
+- void **fix_invalid_tiles** **(** **)**
+
+Clear cells that does not exist in the tileset.
+
 .. _class_TileMap_get_cell:
 
 - :ref:`int<class_int>` **get_cell** **(** :ref:`int<class_int>` x, :ref:`int<class_int>` y **)** const

classes/class_tree.rst

@@ -104,7 +104,7 @@ Emitted when the right mouse button is pressed if RMB selection is active and th
 
 - **item_activated** **(** **)**
 
-Emitted when an item is activated (double-clicked).
+Emitted when an item's label is double-clicked.
 
 .. _class_Tree_item_collapsed:
 
@@ -120,7 +120,7 @@ Emitted when an item is collapsed by a click on the folding arrow.
 
 - **item_double_clicked** **(** **)**
 
-Emitted when an item is double clicked.
+Emitted when an item's icon is double-clicked.
 
 .. _class_Tree_item_edited:
 

classes/class_vector2.rst

@@ -34,6 +34,8 @@ Member Functions
 +--------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`Vector2<class_vector2>`  | :ref:`clamped<class_Vector2_clamped>` **(** :ref:`float<class_float>` length **)**                                                                                                                            |
 +--------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`float<class_float>`      | :ref:`cross<class_Vector2_cross>` **(** :ref:`Vector2<class_vector2>` b **)**                                                                                                                                 |
++--------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`Vector2<class_vector2>`  | :ref:`cubic_interpolate<class_Vector2_cubic_interpolate>` **(** :ref:`Vector2<class_vector2>` b, :ref:`Vector2<class_vector2>` pre_a, :ref:`Vector2<class_vector2>` post_b, :ref:`float<class_float>` t **)** |
 +--------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`float<class_float>`      | :ref:`distance_squared_to<class_Vector2_distance_squared_to>` **(** :ref:`Vector2<class_vector2>` to **)**                                                                                                    |
@@ -135,6 +137,12 @@ Bounce returns the vector "bounced off" from the given plane, specified by its n
 
 Returns the vector with a maximum length.
 
+.. _class_Vector2_cross:
+
+- :ref:`float<class_float>` **cross** **(** :ref:`Vector2<class_vector2>` b **)**
+
+Returns the 2-dimensional analog of the cross product with ``b``.
+
 .. _class_Vector2_cubic_interpolate:
 
 - :ref:`Vector2<class_vector2>` **cubic_interpolate** **(** :ref:`Vector2<class_vector2>` b, :ref:`Vector2<class_vector2>` pre_a, :ref:`Vector2<class_vector2>` post_b, :ref:`float<class_float>` t **)**

classes/class_vehiclebody.rst

@@ -14,21 +14,30 @@ VehicleBody
 Brief Description
 -----------------
 
-
+Physics body that simulates the behaviour of a car.
 
 Member Variables
 ----------------
 
   .. _class_VehicleBody_brake:
 
-- :ref:`float<class_float>` **brake**
+- :ref:`float<class_float>` **brake** - Slows down the vehicle by applying a braking force. The vehicle is only slowed down if the wheels are in contact with a surface. The force you need to apply to adequately slow down your vehicle depends on the :ref:`RigidBody.mass<class_RigidBody_mass>` of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 30 range for hard braking.
 
   .. _class_VehicleBody_engine_force:
 
-- :ref:`float<class_float>` **engine_force**
+- :ref:`float<class_float>` **engine_force** - Accelerates the vehicle by applying an engine force. The vehicle is only speed up if the wheels that have :ref:`VehicleWheel.set_use_as_traction<class_VehicleWheel_set_use_as_traction>` set to true and are in contact with a surface. The :ref:`RigidBody.mass<class_RigidBody_mass>` of the vehicle has an effect on the acceleration of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 50 range for acceleration. Note that the simulation does not take the effect of gears into account, you will need to add logic for this if you wish to simulate gears.
+
+A negative value will result in the vehicle reversing.
 
   .. _class_VehicleBody_steering:
 
-- :ref:`float<class_float>` **steering**
+- :ref:`float<class_float>` **steering** - The steering angle for the vehicle. Setting this to a non-zero value will result in the vehicle turning when it's moving. Wheels that have :ref:`VehicleWheel.set_use_as_steering<class_VehicleWheel_set_use_as_steering>` set to true will automatically be rotated.
+
+
+Description
+-----------
+
+This nodes implements all the physics logic needed to simulate a car. It is based on the raycast vehicle system commonly found in physics engines. You will need to add a :ref:`CollisionShape<class_collisionshape>` for the main body of your vehicle and add :ref:`VehicleWheel<class_vehiclewheel>` nodes for the wheels. You should also add a :ref:`MeshInstance<class_meshinstance>` to this node for the 3D model of your car but this model should not include meshes for the wheels. You should control the vehicle by using the :ref:`brake<class_VehicleBody_brake>`, :ref:`engine_force<class_VehicleBody_engine_force>`, and :ref:`steering<class_VehicleBody_steering>` properties and not change the position or orientation of this node directly.
 
+Note that the origin point of your VehicleBody will determine the center of gravity of your vehicle so it is better to keep this low and move the :ref:`CollisionShape<class_collisionshape>` and :ref:`MeshInstance<class_meshinstance>` upwards.
 

classes/class_vehiclewheel.rst

@@ -14,7 +14,7 @@ VehicleWheel
 Brief Description
 -----------------
 
-
+Physics object that simulates the behaviour of a wheel.
 
 Member Functions
 ----------------
@@ -30,48 +30,55 @@ Member Variables
 
   .. _class_VehicleWheel_damping_compression:
 
-- :ref:`float<class_float>` **damping_compression**
+- :ref:`float<class_float>` **damping_compression** - The damping applied to the spring when the spring is being compressed. This value should be between 0.0 (no damping) and 1.0. A value of 0.0 means the car will keep bouncing as the spring keeps its energy. A good value for this is around 0.3 for a normal car, 0.5 for a race car.
 
   .. _class_VehicleWheel_damping_relaxation:
 
-- :ref:`float<class_float>` **damping_relaxation**
+- :ref:`float<class_float>` **damping_relaxation** - The damping applied to the spring when relaxing. This value should be between 0.0 (no damping) and 1.0. This value should always be slighly higher then the :ref:`damping_compression<class_VehicleWheel_damping_compression>` property. For a :ref:`damping_compression<class_VehicleWheel_damping_compression>` value of 0.3, try a relaxation value of 0.5
 
   .. _class_VehicleWheel_suspension_max_force:
 
-- :ref:`float<class_float>` **suspension_max_force**
+- :ref:`float<class_float>` **suspension_max_force** - The maximum force the spring can resist. This value should be higher then a quarter of the :ref:`RigidBody.mass<class_RigidBody_mass>` of the :ref:`VehicleBody<class_vehiclebody>` or the spring will not carry the weight of the vehicle. Good results are often obtained by a value that is about 3x to 4x this number.
 
   .. _class_VehicleWheel_suspension_stiffness:
 
-- :ref:`float<class_float>` **suspension_stiffness**
+- :ref:`float<class_float>` **suspension_stiffness** - This value defines the stiffness of the suspension. Use a value lower then 50 for an offroad car, a value between 50 and 100 for a race car and try something around 200 for something like a Formula 1 car.
 
   .. _class_VehicleWheel_suspension_travel:
 
-- :ref:`float<class_float>` **suspension_travel**
+- :ref:`float<class_float>` **suspension_travel** - This is the distance the suspension can travel. As Godots measures are in meters keep this setting relatively low. Try a value between 0.1 and 0.3 depending on the type of car .
 
   .. _class_VehicleWheel_use_as_steering:
 
-- :ref:`bool<class_bool>` **use_as_steering**
+- :ref:`bool<class_bool>` **use_as_steering** - If true this wheel will be turned when the car steers.
 
   .. _class_VehicleWheel_use_as_traction:
 
-- :ref:`bool<class_bool>` **use_as_traction**
+- :ref:`bool<class_bool>` **use_as_traction** - If true this wheel transfers engine force to the ground to propel the vehicle forward.
 
   .. _class_VehicleWheel_wheel_friction_slip:
 
-- :ref:`float<class_float>` **wheel_friction_slip**
+- :ref:`float<class_float>` **wheel_friction_slip** - This determines how much grip this wheel has. It is combined with the friction setting of the surface the wheel is in contact with. 0.0 means no grip, 1.0 is normal grip. For a drift car setup, try setting the grip of the rear wheels slightly lower then the front wheels, or use a lower value to simulate tire wear.
+
+It's best to set this to 1.0 when starting out.
 
   .. _class_VehicleWheel_wheel_radius:
 
-- :ref:`float<class_float>` **wheel_radius**
+- :ref:`float<class_float>` **wheel_radius** - The radius of the wheel in meters.
 
   .. _class_VehicleWheel_wheel_rest_length:
 
-- :ref:`float<class_float>` **wheel_rest_length**
+- :ref:`float<class_float>` **wheel_rest_length** - This is the distance in meters the wheel is lowered from its origin point. Don't set this to 0.0 and move the wheel into position, instead move the origin point of your wheel (the gizmo in Godot) to the position the wheel will take when bottoming out, then use the rest lenght to move the wheel down to the position it should be in when the car is in rest.
 
   .. _class_VehicleWheel_wheel_roll_influence:
 
-- :ref:`float<class_float>` **wheel_roll_influence**
+- :ref:`float<class_float>` **wheel_roll_influence** - This value effects the roll of your vehicle. If set to 0.0 for all wheels your vehicle will be prone to rolling over while a value of 1.0 will resist body roll.
+
 
+Description
+-----------
+
+This node needs to be used as a child node of :ref:`VehicleBody<class_vehiclebody>` and simulates the behaviour of one of its wheels. This node also acts as a collider to detect if the wheel is touching a surface.
 
 Member Function Description
 ---------------------------
@@ -80,8 +87,12 @@ Member Function Description
 
 - :ref:`float<class_float>` **get_skidinfo** **(** **)** const
 
+Returns a value between 0.0 and 1.0 that indicates whether this wheel is skidding. 0.0 is not skidding, 1.0 means the wheel has lost grip.
+
 .. _class_VehicleWheel_is_in_contact:
 
 - :ref:`bool<class_bool>` **is_in_contact** **(** **)** const
 
+Returns true if this wheel is in contact with a surface.
+
 

classes/class_viewport.rst

@@ -359,7 +359,7 @@ Get the enabled status of the size override set with :ref:`set_size_override<cla
 
 - :ref:`bool<class_bool>` **is_size_override_stretch_enabled** **(** **)** const
 
-Get the enabled status of the size strech override set with :ref:`set_size_override_stretch<class_Viewport_set_size_override_stretch>`.
+Get the enabled status of the size stretch override set with :ref:`set_size_override_stretch<class_Viewport_set_size_override_stretch>`.
 
 .. _class_Viewport_set_attach_to_screen_rect:
 

classes/class_visualserver.rst

@@ -46,9 +46,9 @@ Member Functions
 +--------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | void                                       | :ref:`canvas_item_add_line<class_VisualServer_canvas_item_add_line>` **(** :ref:`RID<class_rid>` item, :ref:`Vector2<class_vector2>` from, :ref:`Vector2<class_vector2>` to, :ref:`Color<class_color>` color, :ref:`float<class_float>` width=1.0, :ref:`bool<class_bool>` antialiased=false **)**                                                                                                                                                                                                                       |
 +--------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                       | :ref:`canvas_item_add_mesh<class_VisualServer_canvas_item_add_mesh>` **(** :ref:`RID<class_rid>` item, :ref:`RID<class_rid>` mesh, :ref:`RID<class_rid>` skeleton **)**                                                                                                                                                                                                                                                                                                                                                  |
+| void                                       | :ref:`canvas_item_add_mesh<class_VisualServer_canvas_item_add_mesh>` **(** :ref:`RID<class_rid>` item, :ref:`RID<class_rid>` mesh, :ref:`RID<class_rid>` texture, :ref:`RID<class_rid>` normal_map **)**                                                                                                                                                                                                                                                                                                                 |
 +--------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| void                                       | :ref:`canvas_item_add_multimesh<class_VisualServer_canvas_item_add_multimesh>` **(** :ref:`RID<class_rid>` item, :ref:`RID<class_rid>` mesh, :ref:`RID<class_rid>` skeleton **)**                                                                                                                                                                                                                                                                                                                                        |
+| void                                       | :ref:`canvas_item_add_multimesh<class_VisualServer_canvas_item_add_multimesh>` **(** :ref:`RID<class_rid>` item, :ref:`RID<class_rid>` mesh, :ref:`RID<class_rid>` texture, :ref:`RID<class_rid>` normal_map **)**                                                                                                                                                                                                                                                                                                       |
 +--------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | void                                       | :ref:`canvas_item_add_nine_patch<class_VisualServer_canvas_item_add_nine_patch>` **(** :ref:`RID<class_rid>` item, :ref:`Rect2<class_rect2>` rect, :ref:`Rect2<class_rect2>` source, :ref:`RID<class_rid>` texture, :ref:`Vector2<class_vector2>` topleft, :ref:`Vector2<class_vector2>` bottomright, :ref:`int<class_int>` x_axis_mode=0, :ref:`int<class_int>` y_axis_mode=0, :ref:`bool<class_bool>` draw_center=true, :ref:`Color<class_color>` modulate=Color( 1, 1, 1, 1 ), :ref:`RID<class_rid>` normal_map **)** |
 +--------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -1206,13 +1206,13 @@ Adds a line command to the :ref:`CanvasItem<class_canvasitem>`'s draw commands.
 
 .. _class_VisualServer_canvas_item_add_mesh:
 
-- void **canvas_item_add_mesh** **(** :ref:`RID<class_rid>` item, :ref:`RID<class_rid>` mesh, :ref:`RID<class_rid>` skeleton **)**
+- void **canvas_item_add_mesh** **(** :ref:`RID<class_rid>` item, :ref:`RID<class_rid>` mesh, :ref:`RID<class_rid>` texture, :ref:`RID<class_rid>` normal_map **)**
 
 Adds a :ref:`Mesh<class_mesh>` to the :ref:`CanvasItem<class_canvasitem>`'s draw commands. Only affects its aabb at the moment.
 
 .. _class_VisualServer_canvas_item_add_multimesh:
 
-- void **canvas_item_add_multimesh** **(** :ref:`RID<class_rid>` item, :ref:`RID<class_rid>` mesh, :ref:`RID<class_rid>` skeleton **)**
+- void **canvas_item_add_multimesh** **(** :ref:`RID<class_rid>` item, :ref:`RID<class_rid>` mesh, :ref:`RID<class_rid>` texture, :ref:`RID<class_rid>` normal_map **)**
 
 Adds a :ref:`MultiMesh<class_multimesh>` to the :ref:`CanvasItem<class_canvasitem>`'s draw commands. Only affects its aabb at the moment.
 
@@ -1680,7 +1680,7 @@ Draws a frame. Same as :ref:`draw<class_VisualServer_draw>`.
 
 - void **force_sync** **(** **)**
 
-Syncronizes threads.
+Synchronizes threads.
 
 .. _class_VisualServer_free_rid: