Sync classref with 3.2 branch

classes/[email protected]

@@ -688,11 +688,15 @@ Returns the Object that corresponds to ``instance_id``. All Objects have a uniqu
 
 - :ref:`float<class_float>` **inverse_lerp** **(** :ref:`float<class_float>` from, :ref:`float<class_float>` to, :ref:`float<class_float>` weight **)**
 
-Returns a normalized value considering the given range.
+Returns a normalized value considering the given range. This is the opposite of :ref:`lerp<class_@GDScript_method_lerp>`.
 
 ::
 
-    inverse_lerp(3, 5, 4) # Returns 0.5
+    var middle = lerp(20, 30, 0.75)
+    # `middle` is now 27.5.
+    # Now, we pretend to have forgotten the original ratio and want to get it back.
+    var ratio = inverse_lerp(20, 30, 27.5)
+    # `ratio` is now 0.75.
 
 ----
 
@@ -755,7 +759,7 @@ Returns length of Variant ``var``. Length is the character count of String, elem
 
 - :ref:`Variant<class_Variant>` **lerp** **(** :ref:`Variant<class_Variant>` from, :ref:`Variant<class_Variant>` to, :ref:`float<class_float>` weight **)**
 
-Linearly interpolates between two values by a normalized value.
+Linearly interpolates between two values by a normalized value. This is the opposite of :ref:`inverse_lerp<class_@GDScript_method_inverse_lerp>`.
 
 If the ``from`` and ``to`` arguments are of type :ref:`int<class_int>` or :ref:`float<class_float>`, the return value is a :ref:`float<class_float>`.
 
@@ -774,7 +778,7 @@ If both are of the same vector type (:ref:`Vector2<class_Vector2>`, :ref:`Vector
 
 Linearly interpolates between two angles (in radians) by a normalized value.
 
-Similar to :ref:`lerp<class_@GDScript_method_lerp>` but interpolate correctly when the angles wrap around :ref:`TAU<class_@GDScript_constant_TAU>`.
+Similar to :ref:`lerp<class_@GDScript_method_lerp>`, but interpolates correctly when the angles wrap around :ref:`TAU<class_@GDScript_constant_TAU>`.
 
 ::
 
@@ -792,7 +796,14 @@ Similar to :ref:`lerp<class_@GDScript_method_lerp>` but interpolate correctly wh
 
 - :ref:`float<class_float>` **linear2db** **(** :ref:`float<class_float>` nrg **)**
 
-Converts from linear energy to decibels (audio).
+Converts from linear energy to decibels (audio). This can be used to implement volume sliders that behave as expected (since volume isn't linear). Example:
+
+::
+
+    # "Slider" refers to a node that inherits Range such as HSlider or VSlider.
+    # Its range must be configured to go from 0 to 1.
+    # Change the bus name if you'd like to change the volume of a specific bus only.
+    AudioServer.set_bus_volume_db(AudioServer.get_bus_index("Master"), linear2db($Slider.value))
 
 ----
 

classes/[email protected]

@@ -46,7 +46,7 @@ Properties
 +---------------------------------------------------------------------------+-------------------------------------------------------------------------------------+
 | :ref:`JavaScript<class_JavaScript>`                                       | :ref:`JavaScript<class_@GlobalScope_property_JavaScript>`                           |
 +---------------------------------------------------------------------------+-------------------------------------------------------------------------------------+
-| :ref:`Reference<class_Reference>`                                         | :ref:`Marshalls<class_@GlobalScope_property_Marshalls>`                             |
+| :ref:`Marshalls<class_Marshalls>`                                         | :ref:`Marshalls<class_@GlobalScope_property_Marshalls>`                             |
 +---------------------------------------------------------------------------+-------------------------------------------------------------------------------------+
 | :ref:`EditorNavigationMeshGenerator<class_EditorNavigationMeshGenerator>` | :ref:`NavigationMeshGenerator<class_@GlobalScope_property_NavigationMeshGenerator>` |
 +---------------------------------------------------------------------------+-------------------------------------------------------------------------------------+
@@ -2311,7 +2311,7 @@ The :ref:`JavaScript<class_JavaScript>` singleton.
 
 .. _class_@GlobalScope_property_Marshalls:
 
-- :ref:`Reference<class_Reference>` **Marshalls**
+- :ref:`Marshalls<class_Marshalls>` **Marshalls**
 
 The :ref:`Marshalls<class_Marshalls>` singleton.
 

classes/class_animation.rst

@@ -28,7 +28,7 @@ An Animation resource contains data used to animate everything in the engine. An
     animation.track_insert_key(track_index, 0.0, 0)
     animation.track_insert_key(track_index, 0.5, 100)
 
-Animations are just data containers, and must be added to nodes such as an :ref:`AnimationPlayer<class_AnimationPlayer>` or :ref:`AnimationTreePlayer<class_AnimationTreePlayer>` to be played back.
+Animations are just data containers, and must be added to nodes such as an :ref:`AnimationPlayer<class_AnimationPlayer>` or :ref:`AnimationTreePlayer<class_AnimationTreePlayer>` to be played back. Animation tracks have different types, each with its own set of dedicated methods. Check :ref:`TrackType<enum_Animation_TrackType>` to see available types.
 
 Tutorials
 ---------
@@ -174,6 +174,8 @@ Signals
 
 - **tracks_changed** **(** **)**
 
+Emitted when there's a change in the list of tracks, e.g. tracks are added, moved or have changed paths.
+
 Enumerations
 ------------
 
@@ -199,11 +201,11 @@ enum **TrackType**:
 
 - **TYPE_METHOD** = **2** --- Method tracks call functions with given arguments per key.
 
-- **TYPE_BEZIER** = **3**
+- **TYPE_BEZIER** = **3** --- Bezier tracks are used to interpolate a value using custom curves. They can also be used to animate sub-properties of vectors and colors (e.g. alpha value of a :ref:`Color<class_Color>`).
 
-- **TYPE_AUDIO** = **4**
+- **TYPE_AUDIO** = **4** --- Audio tracks are used to play an audio stream with either type of :ref:`AudioStreamPlayer<class_AudioStreamPlayer>`. The stream can be trimmed and previewed in the animation.
 
-- **TYPE_ANIMATION** = **5**
+- **TYPE_ANIMATION** = **5** --- Animation tracks play animations in other :ref:`AnimationPlayer<class_AnimationPlayer>` nodes.
 
 ----
 
@@ -243,7 +245,7 @@ enum **UpdateMode**:
 
 - **UPDATE_TRIGGER** = **2** --- Update at the keyframes.
 
-- **UPDATE_CAPTURE** = **3**
+- **UPDATE_CAPTURE** = **3** --- Same as linear interpolation, but also interpolates from the current value (i.e. dynamically at runtime) if the first key isn't at 0 seconds.
 
 Property Descriptions
 ---------------------
@@ -311,108 +313,152 @@ Adds a track to the Animation.
 
 - :ref:`String<class_String>` **animation_track_get_key_animation** **(** :ref:`int<class_int>` track_idx, :ref:`int<class_int>` key_idx **)** const
 
+Returns the animation name at the key identified by ``key_idx``. The ``track_idx`` must be the index of an Animation Track.
+
 ----
 
 .. _class_Animation_method_animation_track_insert_key:
 
 - :ref:`int<class_int>` **animation_track_insert_key** **(** :ref:`int<class_int>` track_idx, :ref:`float<class_float>` time, :ref:`String<class_String>` animation **)**
 
+Inserts a key with value ``animation`` at the given ``time`` (in seconds). The ``track_idx`` must be the index of an Animation Track.
+
 ----
 
 .. _class_Animation_method_animation_track_set_key_animation:
 
 - void **animation_track_set_key_animation** **(** :ref:`int<class_int>` track_idx, :ref:`int<class_int>` key_idx, :ref:`String<class_String>` animation **)**
 
+Sets the key identified by ``key_idx`` to value ``animation``. The ``track_idx`` must be the index of an Animation Track.
+
 ----
 
 .. _class_Animation_method_audio_track_get_key_end_offset:
 
 - :ref:`float<class_float>` **audio_track_get_key_end_offset** **(** :ref:`int<class_int>` track_idx, :ref:`int<class_int>` key_idx **)** const
 
+Returns the end offset of the key identified by ``key_idx``. The ``track_idx`` must be the index of an Audio Track.
+
+End offset is the number of seconds cut off at the ending of the audio stream.
+
 ----
 
 .. _class_Animation_method_audio_track_get_key_start_offset:
 
 - :ref:`float<class_float>` **audio_track_get_key_start_offset** **(** :ref:`int<class_int>` track_idx, :ref:`int<class_int>` key_idx **)** const
 
+Returns the start offset of the key identified by ``key_idx``. The ``track_idx`` must be the index of an Audio Track.
+
+Start offset is the number of seconds cut off at the beginning of the audio stream.
+
 ----
 
 .. _class_Animation_method_audio_track_get_key_stream:
 
 - :ref:`Resource<class_Resource>` **audio_track_get_key_stream** **(** :ref:`int<class_int>` track_idx, :ref:`int<class_int>` key_idx **)** const
 
+Returns the audio stream of the key identified by ``key_idx``. The ``track_idx`` must be the index of an Audio Track.
+
 ----
 
 .. _class_Animation_method_audio_track_insert_key:
 
 - :ref:`int<class_int>` **audio_track_insert_key** **(** :ref:`int<class_int>` track_idx, :ref:`float<class_float>` time, :ref:`Resource<class_Resource>` stream, :ref:`float<class_float>` start_offset=0, :ref:`float<class_float>` end_offset=0 **)**
 
+Inserts an Audio Track key at the given ``time`` in seconds. The ``track_idx`` must be the index of an Audio Track.
+
+``stream`` is the :ref:`AudioStream<class_AudioStream>` resource to play. ``start_offset`` is the number of seconds cut off at the beginning of the audio stream, while ``end_offset`` is at the ending.
+
 ----
 
 .. _class_Animation_method_audio_track_set_key_end_offset:
 
 - void **audio_track_set_key_end_offset** **(** :ref:`int<class_int>` track_idx, :ref:`int<class_int>` key_idx, :ref:`float<class_float>` offset **)**
 
+Sets the end offset of the key identified by ``key_idx`` to value ``offset``. The ``track_idx`` must be the index of an Audio Track.
+
 ----
 
 .. _class_Animation_method_audio_track_set_key_start_offset:
 
 - void **audio_track_set_key_start_offset** **(** :ref:`int<class_int>` track_idx, :ref:`int<class_int>` key_idx, :ref:`float<class_float>` offset **)**
 
+Sets the start offset of the key identified by ``key_idx`` to value ``offset``. The ``track_idx`` must be the index of an Audio Track.
+
 ----
 
 .. _class_Animation_method_audio_track_set_key_stream:
 
 - void **audio_track_set_key_stream** **(** :ref:`int<class_int>` track_idx, :ref:`int<class_int>` key_idx, :ref:`Resource<class_Resource>` stream **)**
 
+Sets the stream of the key identified by ``key_idx`` to value ``offset``. The ``track_idx`` must be the index of an Audio Track.
+
 ----
 
 .. _class_Animation_method_bezier_track_get_key_in_handle:
 
 - :ref:`Vector2<class_Vector2>` **bezier_track_get_key_in_handle** **(** :ref:`int<class_int>` track_idx, :ref:`int<class_int>` key_idx **)** const
 
+Returns the in handle of the key identified by ``key_idx``. The ``track_idx`` must be the index of a Bezier Track.
+
 ----
 
 .. _class_Animation_method_bezier_track_get_key_out_handle:
 
 - :ref:`Vector2<class_Vector2>` **bezier_track_get_key_out_handle** **(** :ref:`int<class_int>` track_idx, :ref:`int<class_int>` key_idx **)** const
 
+Returns the out handle of the key identified by ``key_idx``. The ``track_idx`` must be the index of a Bezier Track.
+
 ----
 
 .. _class_Animation_method_bezier_track_get_key_value:
 
 - :ref:`float<class_float>` **bezier_track_get_key_value** **(** :ref:`int<class_int>` track_idx, :ref:`int<class_int>` key_idx **)** const
 
+Returns the value of the key identified by ``key_idx``. The ``track_idx`` must be the index of a Bezier Track.
+
 ----
 
 .. _class_Animation_method_bezier_track_insert_key:
 
 - :ref:`int<class_int>` **bezier_track_insert_key** **(** :ref:`int<class_int>` track_idx, :ref:`float<class_float>` time, :ref:`float<class_float>` value, :ref:`Vector2<class_Vector2>` in_handle=Vector2( 0, 0 ), :ref:`Vector2<class_Vector2>` out_handle=Vector2( 0, 0 ) **)**
 
+Inserts a Bezier Track key at the given ``time`` in seconds. The ``track_idx`` must be the index of a Bezier Track.
+
+``in_handle`` is the left-side weight of the added Bezier curve point, ``out_handle`` is the right-side one, while ``value`` is the actual value at this point.
+
 ----
 
 .. _class_Animation_method_bezier_track_interpolate:
 
 - :ref:`float<class_float>` **bezier_track_interpolate** **(** :ref:`int<class_int>` track_idx, :ref:`float<class_float>` time **)** const
 
+Returns the interpolated value at the given ``time`` (in seconds). The ``track_idx`` must be the index of a Bezier Track.
+
 ----
 
 .. _class_Animation_method_bezier_track_set_key_in_handle:
 
 - void **bezier_track_set_key_in_handle** **(** :ref:`int<class_int>` track_idx, :ref:`int<class_int>` key_idx, :ref:`Vector2<class_Vector2>` in_handle **)**
 
+Sets the in handle of the key identified by ``key_idx`` to value ``in_handle``. The ``track_idx`` must be the index of a Bezier Track.
+
 ----
 
 .. _class_Animation_method_bezier_track_set_key_out_handle:
 
 - void **bezier_track_set_key_out_handle** **(** :ref:`int<class_int>` track_idx, :ref:`int<class_int>` key_idx, :ref:`Vector2<class_Vector2>` out_handle **)**
 
+Sets the out handle of the key identified by ``key_idx`` to value ``out_handle``. The ``track_idx`` must be the index of a Bezier Track.
+
 ----
 
 .. _class_Animation_method_bezier_track_set_key_value:
 
 - void **bezier_track_set_key_value** **(** :ref:`int<class_int>` track_idx, :ref:`int<class_int>` key_idx, :ref:`float<class_float>` value **)**
 
+Sets the value of the key identified by ``key_idx`` to the given value. The ``track_idx`` must be the index of a Bezier Track.
+
 ----
 
 .. _class_Animation_method_clear:

classes/class_animationnodeblendtree.rst

@@ -11,7 +11,12 @@ AnimationNodeBlendTree
 
 **Inherits:** :ref:`AnimationRootNode<class_AnimationRootNode>` **<** :ref:`AnimationNode<class_AnimationNode>` **<** :ref:`Resource<class_Resource>` **<** :ref:`Reference<class_Reference>` **<** :ref:`Object<class_Object>`
 
+:ref:`AnimationTree<class_AnimationTree>` node resource that contains many blend type nodes.
 
+Description
+-----------
+
+This node may contain a sub-tree of any other blend type nodes, such as mix, blend2, blend3, one shot, etc. This is one of the most commonly used roots.
 
 Tutorials
 ---------
@@ -63,17 +68,17 @@ Constants
 
 .. _class_AnimationNodeBlendTree_constant_CONNECTION_ERROR_CONNECTION_EXISTS:
 
-- **CONNECTION_OK** = **0**
+- **CONNECTION_OK** = **0** --- The connection was successful.
 
-- **CONNECTION_ERROR_NO_INPUT** = **1**
+- **CONNECTION_ERROR_NO_INPUT** = **1** --- The input node is ``null``.
 
-- **CONNECTION_ERROR_NO_INPUT_INDEX** = **2**
+- **CONNECTION_ERROR_NO_INPUT_INDEX** = **2** --- The specified input port is out of range.
 
-- **CONNECTION_ERROR_NO_OUTPUT** = **3**
+- **CONNECTION_ERROR_NO_OUTPUT** = **3** --- The output node is ``null``.
 
-- **CONNECTION_ERROR_SAME_NODE** = **4**
+- **CONNECTION_ERROR_SAME_NODE** = **4** --- Input and output nodes are the same.
 
-- **CONNECTION_ERROR_CONNECTION_EXISTS** = **5**
+- **CONNECTION_ERROR_CONNECTION_EXISTS** = **5** --- The specified connection already exists.
 
 Property Descriptions
 ---------------------
@@ -90,6 +95,8 @@ Property Descriptions
 | *Getter*  | get_graph_offset()      |
 +-----------+-------------------------+
 
+The global offset of all sub-nodes.
+
 Method Descriptions
 -------------------
 
@@ -97,51 +104,69 @@ Method Descriptions
 
 - void **add_node** **(** :ref:`String<class_String>` name, :ref:`AnimationNode<class_AnimationNode>` node, :ref:`Vector2<class_Vector2>` position=Vector2( 0, 0 ) **)**
 
+Adds an :ref:`AnimationNode<class_AnimationNode>` at the given ``position``. The ``name`` is used to identify the created sub-node later.
+
 ----
 
 .. _class_AnimationNodeBlendTree_method_connect_node:
 
 - void **connect_node** **(** :ref:`String<class_String>` input_node, :ref:`int<class_int>` input_index, :ref:`String<class_String>` output_node **)**
 
+Connects the output of an :ref:`AnimationNode<class_AnimationNode>` as input for another :ref:`AnimationNode<class_AnimationNode>`, at the input port specified by ``input_index``.
+
 ----
 
 .. _class_AnimationNodeBlendTree_method_disconnect_node:
 
 - void **disconnect_node** **(** :ref:`String<class_String>` input_node, :ref:`int<class_int>` input_index **)**
 
+Disconnects the node connected to the specified input.
+
 ----
 
 .. _class_AnimationNodeBlendTree_method_get_node:
 
 - :ref:`AnimationNode<class_AnimationNode>` **get_node** **(** :ref:`String<class_String>` name **)** const
 
+Returns the sub-node with the specified ``name``.
+
 ----
 
 .. _class_AnimationNodeBlendTree_method_get_node_position:
 
 - :ref:`Vector2<class_Vector2>` **get_node_position** **(** :ref:`String<class_String>` name **)** const
 
+Returns the position of the sub-node with the specified ``name``.
+
 ----
 
 .. _class_AnimationNodeBlendTree_method_has_node:
 
 - :ref:`bool<class_bool>` **has_node** **(** :ref:`String<class_String>` name **)** const
 
+Returns ``true`` if a sub-node with specified ``name`` exists.
+
 ----
 
 .. _class_AnimationNodeBlendTree_method_remove_node:
 
 - void **remove_node** **(** :ref:`String<class_String>` name **)**
 
+Removes a sub-node.
+
 ----
 
 .. _class_AnimationNodeBlendTree_method_rename_node:
 
 - void **rename_node** **(** :ref:`String<class_String>` name, :ref:`String<class_String>` new_name **)**
 
+Changes the name of a sub-node.
+
 ----
 
 .. _class_AnimationNodeBlendTree_method_set_node_position:
 
 - void **set_node_position** **(** :ref:`String<class_String>` name, :ref:`Vector2<class_Vector2>` position **)**
 
+Modifies the position of a sub-node.
+

classes/class_animationnodeoneshot.rst

@@ -11,7 +11,12 @@ AnimationNodeOneShot
 
 **Inherits:** :ref:`AnimationNode<class_AnimationNode>` **<** :ref:`Resource<class_Resource>` **<** :ref:`Reference<class_Reference>` **<** :ref:`Object<class_Object>`
 
+Plays an animation once in :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`.
 
+Description
+-----------
+
+A resource to add to an :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`. This node will execute a sub-animation and return once it finishes. Blend times for fading in and out can be customized, as well as filters.
 
 Tutorials
 ---------
@@ -74,6 +79,8 @@ Property Descriptions
 | *Getter*  | has_autorestart()      |
 +-----------+------------------------+
 
+If ``true``, the sub-animation will restart automatically after finishing.
+
 ----
 
 .. _class_AnimationNodeOneShot_property_autorestart_delay:
@@ -88,6 +95,8 @@ Property Descriptions
 | *Getter*  | get_autorestart_delay()      |
 +-----------+------------------------------+
 
+The delay after which the automatic restart is triggered, in seconds.
+
 ----
 
 .. _class_AnimationNodeOneShot_property_autorestart_random_delay:
@@ -102,6 +111,8 @@ Property Descriptions
 | *Getter*  | get_autorestart_random_delay()      |
 +-----------+-------------------------------------+
 
+If :ref:`autorestart<class_AnimationNodeOneShot_property_autorestart>` is ``true``, a random additional delay (in seconds) between 0 and this value will be added to :ref:`autorestart_delay<class_AnimationNodeOneShot_property_autorestart_delay>`.
+
 ----
 
 .. _class_AnimationNodeOneShot_property_fadein_time:

classes/class_animationnodeoutput.rst

@@ -11,7 +11,7 @@ AnimationNodeOutput
 
 **Inherits:** :ref:`AnimationNode<class_AnimationNode>` **<** :ref:`Resource<class_Resource>` **<** :ref:`Reference<class_Reference>` **<** :ref:`Object<class_Object>`
 
-
+Generic output node to be added to :ref:`AnimationNodeBlendTree<class_AnimationNodeBlendTree>`.
 
 Tutorials
 ---------

classes/class_animationnodetimescale.rst

@@ -11,7 +11,12 @@ AnimationNodeTimeScale
 
 **Inherits:** :ref:`AnimationNode<class_AnimationNode>` **<** :ref:`Resource<class_Resource>` **<** :ref:`Reference<class_Reference>` **<** :ref:`Object<class_Object>`
 
+A time-scaling animation node to be used with :ref:`AnimationTree<class_AnimationTree>`.
 
+Description
+-----------
+
+Allows scaling the speed of the animation (or reversing it) in any children nodes. Setting it to 0 will pause the animation.
 
 Tutorials
 ---------

classes/class_animationnodetimeseek.rst

@@ -11,7 +11,12 @@ AnimationNodeTimeSeek
 
 **Inherits:** :ref:`AnimationNode<class_AnimationNode>` **<** :ref:`Resource<class_Resource>` **<** :ref:`Reference<class_Reference>` **<** :ref:`Object<class_Object>`
 
+A time-seeking animation node to be used with :ref:`AnimationTree<class_AnimationTree>`.
 
+Description
+-----------
+
+This node can be used to cause a seek command to happen to any sub-children of the graph. After setting the time, this value returns to -1.
 
 Tutorials
 ---------

classes/class_animationnodetransition.rst

@@ -11,7 +11,12 @@ AnimationNodeTransition
 
 **Inherits:** :ref:`AnimationNode<class_AnimationNode>` **<** :ref:`Resource<class_Resource>` **<** :ref:`Reference<class_Reference>` **<** :ref:`Object<class_Object>`
 
+A generic animation transition node for :ref:`AnimationTree<class_AnimationTree>`.
 
+Description
+-----------
+
+Simple state machine for cases which don't require a more advanced :ref:`AnimationNodeStateMachine<class_AnimationNodeStateMachine>`. Animations can be connected to the inputs and transition times can be specified.
 
 Tutorials
 ---------
@@ -55,6 +60,8 @@ Property Descriptions
 | *Getter*  | get_enabled_inputs()      |
 +-----------+---------------------------+
 
+The number of available input ports for this node.
+
 ----
 
 .. _class_AnimationNodeTransition_property_xfade_time:
@@ -69,6 +76,8 @@ Property Descriptions
 | *Getter*  | get_cross_fade_time()      |
 +-----------+----------------------------+
 
+Cross-fading time (in seconds) between each animation connected to the inputs.
+
 Method Descriptions
 -------------------
 

classes/class_animationplayer.rst

@@ -18,6 +18,8 @@ Description
 
 An animation player is used for general-purpose playback of :ref:`Animation<class_Animation>` resources. It contains a dictionary of animations (referenced by name) and custom blend times between their transitions. Additionally, animations can be played and blended in different channels.
 
+``AnimationPlayer`` is more suited than :ref:`Tween<class_Tween>` for animations where you know the final values in advance. For example, fading a screen in and out is more easily done with an ``AnimationPlayer`` node thanks to the animation tools provided by the editor. That particular example can also be implemented with a :ref:`Tween<class_Tween>` node, but it requires doing everything by code.
+
 Updating the target properties of animations occurs at process time.
 
 Tutorials

classes/class_animationtree.rst

@@ -11,7 +11,7 @@ AnimationTree
 
 **Inherits:** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-
+A node to be used for advanced animation transitions in an :ref:`AnimationPlayer<class_AnimationPlayer>`.
 
 Tutorials
 ---------
@@ -59,11 +59,11 @@ Enumerations
 
 enum **AnimationProcessMode**:
 
-- **ANIMATION_PROCESS_PHYSICS** = **0**
+- **ANIMATION_PROCESS_PHYSICS** = **0** --- The animations will progress during the physics frame (i.e. :ref:`Node._physics_process<class_Node_method__physics_process>`).
 
-- **ANIMATION_PROCESS_IDLE** = **1**
+- **ANIMATION_PROCESS_IDLE** = **1** --- The animations will progress during the idle frame (i.e. :ref:`Node._process<class_Node_method__process>`).
 
-- **ANIMATION_PROCESS_MANUAL** = **2**
+- **ANIMATION_PROCESS_MANUAL** = **2** --- The animations will only progress manually (see :ref:`advance<class_AnimationTree_method_advance>`).
 
 Property Descriptions
 ---------------------
@@ -80,6 +80,8 @@ Property Descriptions
 | *Getter*  | is_active()       |
 +-----------+-------------------+
 
+If ``true``, the ``AnimationTree`` will be processing.
+
 ----
 
 .. _class_AnimationTree_property_anim_player:
@@ -94,6 +96,8 @@ Property Descriptions
 | *Getter*  | get_animation_player()      |
 +-----------+-----------------------------+
 
+The path to the :ref:`AnimationPlayer<class_AnimationPlayer>` used for animating.
+
 ----
 
 .. _class_AnimationTree_property_process_mode:
@@ -108,6 +112,8 @@ Property Descriptions
 | *Getter*  | get_process_mode()      |
 +-----------+-------------------------+
 
+The process mode of this ``AnimationTree``. See :ref:`AnimationProcessMode<enum_AnimationTree_AnimationProcessMode>` for available modes.
+
 ----
 
 .. _class_AnimationTree_property_root_motion_track:
@@ -134,6 +140,8 @@ Property Descriptions
 | *Getter* | get_tree_root()      |
 +----------+----------------------+
 
+The root animation node of this ``AnimationTree``. See :ref:`AnimationNode<class_AnimationNode>`.
+
 Method Descriptions
 -------------------
 
@@ -141,6 +149,8 @@ Method Descriptions
 
 - void **advance** **(** :ref:`float<class_float>` delta **)**
 
+Manually advance the animations by the specified time (in seconds).
+
 ----
 
 .. _class_AnimationTree_method_get_root_motion_transform:

classes/class_array.rst

@@ -27,6 +27,14 @@ Generic array which can contain several elements of any type, accessible by a nu
     array[2] = "Three"
     print(array[-2]) # Three.
 
+Arrays can be concatenated using the ``+`` operator:
+
+::
+
+    var array1 = ["One", 2]
+    var array2 = [3, "Four"]
+    print(array1 + array2) # ["One", 2, 3, "Four"]
+
 Arrays are always passed by reference.
 
 Methods
@@ -51,15 +59,15 @@ Methods
 +-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`Variant<class_Variant>` | :ref:`back<class_Array_method_back>` **(** **)**                                                                                                                                                                 |
 +-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`         | :ref:`bsearch<class_Array_method_bsearch>` **(** :ref:`Variant<class_Variant>` value, :ref:`bool<class_bool>` before=True **)**                                                                                  |
+| :ref:`int<class_int>`         | :ref:`bsearch<class_Array_method_bsearch>` **(** :ref:`Variant<class_Variant>` value, :ref:`bool<class_bool>` before=true **)**                                                                                  |
 +-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`         | :ref:`bsearch_custom<class_Array_method_bsearch_custom>` **(** :ref:`Variant<class_Variant>` value, :ref:`Object<class_Object>` obj, :ref:`String<class_String>` func, :ref:`bool<class_bool>` before=True **)** |
+| :ref:`int<class_int>`         | :ref:`bsearch_custom<class_Array_method_bsearch_custom>` **(** :ref:`Variant<class_Variant>` value, :ref:`Object<class_Object>` obj, :ref:`String<class_String>` func, :ref:`bool<class_bool>` before=true **)** |
 +-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | void                          | :ref:`clear<class_Array_method_clear>` **(** **)**                                                                                                                                                               |
 +-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`int<class_int>`         | :ref:`count<class_Array_method_count>` **(** :ref:`Variant<class_Variant>` value **)**                                                                                                                           |
 +-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Array<class_Array>`     | :ref:`duplicate<class_Array_method_duplicate>` **(** :ref:`bool<class_bool>` deep=False **)**                                                                                                                    |
+| :ref:`Array<class_Array>`     | :ref:`duplicate<class_Array_method_duplicate>` **(** :ref:`bool<class_bool>` deep=false **)**                                                                                                                    |
 +-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`bool<class_bool>`       | :ref:`empty<class_Array_method_empty>` **(** **)**                                                                                                                                                               |
 +-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -101,7 +109,7 @@ Methods
 +-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`int<class_int>`         | :ref:`size<class_Array_method_size>` **(** **)**                                                                                                                                                                 |
 +-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Array<class_Array>`     | :ref:`slice<class_Array_method_slice>` **(** :ref:`int<class_int>` begin, :ref:`int<class_int>` end, :ref:`int<class_int>` step=1, :ref:`bool<class_bool>` deep=False **)**                                      |
+| :ref:`Array<class_Array>`     | :ref:`slice<class_Array_method_slice>` **(** :ref:`int<class_int>` begin, :ref:`int<class_int>` end, :ref:`int<class_int>` step=1, :ref:`bool<class_bool>` deep=false **)**                                      |
 +-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | void                          | :ref:`sort<class_Array_method_sort>` **(** **)**                                                                                                                                                                 |
 +-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -173,7 +181,7 @@ Returns the last element of the array, or ``null`` if the array is empty.
 
 .. _class_Array_method_bsearch:
 
-- :ref:`int<class_int>` **bsearch** **(** :ref:`Variant<class_Variant>` value, :ref:`bool<class_bool>` before=True **)**
+- :ref:`int<class_int>` **bsearch** **(** :ref:`Variant<class_Variant>` value, :ref:`bool<class_bool>` before=true **)**
 
 Finds the index of an existing value (or the insertion index that maintains sorting order, if the value is not yet present in the array) using binary search. Optionally, a ``before`` specifier can be passed. If ``false``, the returned index comes after all existing entries of the value in the array.
 
@@ -183,7 +191,7 @@ Finds the index of an existing value (or the insertion index that maintains sort
 
 .. _class_Array_method_bsearch_custom:
 
-- :ref:`int<class_int>` **bsearch_custom** **(** :ref:`Variant<class_Variant>` value, :ref:`Object<class_Object>` obj, :ref:`String<class_String>` func, :ref:`bool<class_bool>` before=True **)**
+- :ref:`int<class_int>` **bsearch_custom** **(** :ref:`Variant<class_Variant>` value, :ref:`Object<class_Object>` obj, :ref:`String<class_String>` func, :ref:`bool<class_bool>` before=true **)**
 
 Finds the index of an existing value (or the insertion index that maintains sorting order, if the value is not yet present in the array) using binary search and a custom comparison method. Optionally, a ``before`` specifier can be passed. If ``false``, the returned index comes after all existing entries of the value in the array. The custom method receives two arguments (an element from the array and the value searched for) and must return ``true`` if the first argument is less than the second, and return ``false`` otherwise.
 
@@ -209,7 +217,7 @@ Returns the number of times an element is in the array.
 
 .. _class_Array_method_duplicate:
 
-- :ref:`Array<class_Array>` **duplicate** **(** :ref:`bool<class_bool>` deep=False **)**
+- :ref:`Array<class_Array>` **duplicate** **(** :ref:`bool<class_bool>` deep=false **)**
 
 Returns a copy of the array.
 
@@ -386,7 +394,7 @@ Returns the number of elements in the array.
 
 .. _class_Array_method_slice:
 
-- :ref:`Array<class_Array>` **slice** **(** :ref:`int<class_int>` begin, :ref:`int<class_int>` end, :ref:`int<class_int>` step=1, :ref:`bool<class_bool>` deep=False **)**
+- :ref:`Array<class_Array>` **slice** **(** :ref:`int<class_int>` begin, :ref:`int<class_int>` end, :ref:`int<class_int>` step=1, :ref:`bool<class_bool>` deep=false **)**
 
 Duplicates the subset described in the function and returns it in an array, deeply copying the array if ``deep`` is ``true``. Lower and upper index are inclusive, with the ``step`` describing the change between indices while slicing.
 
@@ -398,7 +406,13 @@ Duplicates the subset described in the function and returns it in an array, deep
 
 Sorts the array.
 
-**Note:** strings are sorted in alphabetical, not natural order.
+**Note:** Strings are sorted in alphabetical order (as opposed to natural order). This may lead to unexpected behavior when sorting an array of strings ending with a sequence of numbers. Consider the following example:
+
+::
+
+    var strings = ["string1", "string2", "string10", "string11"]
+    strings.sort()
+    print(strings) # Prints [string1, string10, string11, string2]
 
 ----
 

classes/class_arvrpositionaltracker.rst

@@ -50,6 +50,8 @@ Methods
 +------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`Vector3<class_Vector3>`                              | :ref:`get_position<class_ARVRPositionalTracker_method_get_position>` **(** **)** const                                                     |
 +------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`                                      | :ref:`get_tracker_id<class_ARVRPositionalTracker_method_get_tracker_id>` **(** **)** const                                                 |
++------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`bool<class_bool>`                                    | :ref:`get_tracks_orientation<class_ARVRPositionalTracker_method_get_tracks_orientation>` **(** **)** const                                 |
 +------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`bool<class_bool>`                                    | :ref:`get_tracks_position<class_ARVRPositionalTracker_method_get_tracks_position>` **(** **)** const                                       |
@@ -146,6 +148,14 @@ Returns the world-space controller position.
 
 ----
 
+.. _class_ARVRPositionalTracker_method_get_tracker_id:
+
+- :ref:`int<class_int>` **get_tracker_id** **(** **)** const
+
+Returns the internal tracker ID. This uniquely identifies the tracker per tracker type and matches the ID you need to specify for nodes such as the :ref:`ARVRController<class_ARVRController>` and :ref:`ARVRAnchor<class_ARVRAnchor>` nodes.
+
+----
+
 .. _class_ARVRPositionalTracker_method_get_tracks_orientation:
 
 - :ref:`bool<class_bool>` **get_tracks_orientation** **(** **)** const

classes/class_audioeffectrecord.rst

@@ -11,7 +11,12 @@ AudioEffectRecord
 
 **Inherits:** :ref:`AudioEffect<class_AudioEffect>` **<** :ref:`Resource<class_Resource>` **<** :ref:`Reference<class_Reference>` **<** :ref:`Object<class_Object>`
 
+Audio effect used for recording sound from a microphone.
 
+Tutorials
+---------
+
+- :doc:`../tutorials/audio/recording_with_microphone`
 
 Properties
 ----------
@@ -46,6 +51,8 @@ Property Descriptions
 | *Getter*  | get_format()      |
 +-----------+-------------------+
 
+Specifies the format in which the sample will be recorded. See :ref:`Format<enum_AudioStreamSample_Format>` for available formats.
+
 Method Descriptions
 -------------------
 
@@ -53,15 +60,21 @@ Method Descriptions
 
 - :ref:`AudioStreamSample<class_AudioStreamSample>` **get_recording** **(** **)** const
 
+Returns the recorded sample.
+
 ----
 
 .. _class_AudioEffectRecord_method_is_recording_active:
 
 - :ref:`bool<class_bool>` **is_recording_active** **(** **)** const
 
+Returns whether the recording is active or not.
+
 ----
 
 .. _class_AudioEffectRecord_method_set_recording_active:
 
 - void **set_recording_active** **(** :ref:`bool<class_bool>` record **)**
 
+If ``true``, the sound will be recorded. Note that restarting the recording will remove the previously recorded sample.
+

classes/class_bakedlightmap.rst

@@ -108,15 +108,15 @@ enum **BakeMode**:
 
 enum **BakeError**:
 
-- **BAKE_ERROR_OK** = **0**
+- **BAKE_ERROR_OK** = **0** --- Baking was successful.
 
-- **BAKE_ERROR_NO_SAVE_PATH** = **1**
+- **BAKE_ERROR_NO_SAVE_PATH** = **1** --- Returns if no viable save path is found. This can happen where an :ref:`image_path<class_BakedLightmap_property_image_path>` is not specified or when the save location is invalid.
 
-- **BAKE_ERROR_NO_MESHES** = **2**
+- **BAKE_ERROR_NO_MESHES** = **2** --- Currently unused.
 
-- **BAKE_ERROR_CANT_CREATE_IMAGE** = **3**
+- **BAKE_ERROR_CANT_CREATE_IMAGE** = **3** --- Returns when the baker cannot save per-mesh textures to file.
 
-- **BAKE_ERROR_USER_ABORTED** = **4**
+- **BAKE_ERROR_USER_ABORTED** = **4** --- Returns if user cancels baking.
 
 Property Descriptions
 ---------------------
@@ -300,7 +300,7 @@ Method Descriptions
 
 - :ref:`BakeError<enum_BakedLightmap_BakeError>` **bake** **(** :ref:`Node<class_Node>` from_node=null, :ref:`bool<class_bool>` create_visual_debug=false **)**
 
-Bakes the lightmaps within the currently edited scene.
+Bakes the lightmaps within the currently edited scene. Returns a :ref:`BakeError<enum_BakedLightmap_BakeError>` to signify if the bake was successful, or if unsuccessful, how the bake failed.
 
 ----
 

classes/class_basis.rst

@@ -58,7 +58,7 @@ Methods
 +-------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`Basis<class_Basis>`     | :ref:`inverse<class_Basis_method_inverse>` **(** **)**                                                                                                              |
 +-------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`bool<class_bool>`       | :ref:`is_equal_approx<class_Basis_method_is_equal_approx>` **(** :ref:`Basis<class_Basis>` b, :ref:`float<class_float>` epsilon=0.00001 **)**                       |
+| :ref:`bool<class_bool>`       | :ref:`is_equal_approx<class_Basis_method_is_equal_approx>` **(** :ref:`Basis<class_Basis>` b, :ref:`float<class_float>` epsilon=1e-05 **)**                         |
 +-------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`Basis<class_Basis>`     | :ref:`orthonormalized<class_Basis_method_orthonormalized>` **(** **)**                                                                                              |
 +-------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -216,7 +216,7 @@ Returns the inverse of the matrix.
 
 .. _class_Basis_method_is_equal_approx:
 
-- :ref:`bool<class_bool>` **is_equal_approx** **(** :ref:`Basis<class_Basis>` b, :ref:`float<class_float>` epsilon=0.00001 **)**
+- :ref:`bool<class_bool>` **is_equal_approx** **(** :ref:`Basis<class_Basis>` b, :ref:`float<class_float>` epsilon=1e-05 **)**
 
 Returns ``true`` if this basis and ``b`` are approximately equal, by calling ``is_equal_approx`` on each component.
 

classes/class_checkbox.rst

@@ -11,12 +11,12 @@ CheckBox
 
 **Inherits:** :ref:`Button<class_Button>` **<** :ref:`BaseButton<class_BaseButton>` **<** :ref:`Control<class_Control>` **<** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-Binary choice user interface widget.
+Binary choice user interface widget. See also :ref:`CheckButton<class_CheckButton>`.
 
 Description
 -----------
 
-A checkbox allows the user to make a binary choice (choosing only one of two possible options).
+A checkbox allows the user to make a binary choice (choosing only one of two possible options). It's similar to :ref:`CheckButton<class_CheckButton>` in functionality, but it has a different apperance. To follow established UX patterns, it's recommended to use CheckBox when toggling it has **no** immediate effect on something. For instance, it should be used when toggling it will only do something once a confirmation button is pressed.
 
 Properties
 ----------

classes/class_checkbutton.rst

@@ -11,12 +11,12 @@ CheckButton
 
 **Inherits:** :ref:`Button<class_Button>` **<** :ref:`BaseButton<class_BaseButton>` **<** :ref:`Control<class_Control>` **<** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-Checkable button.
+Checkable button. See also :ref:`CheckBox<class_CheckBox>`.
 
 Description
 -----------
 
-CheckButton is a toggle button displayed as a check field.
+CheckButton is a toggle button displayed as a check field. It's similar to :ref:`CheckBox<class_CheckBox>` in functionality, but it has a different apperance. To follow established UX patterns, it's recommended to use CheckButton when toggling it has an **immediate** effect on something. For instance, it should be used if toggling it enables/disables a setting without requiring the user to press a confirmation button.
 
 Properties
 ----------

classes/class_collisionpolygon2d.rst

@@ -111,6 +111,8 @@ If ``true``, only edges that face up, relative to ``CollisionPolygon2D``'s rotat
 | *Getter*  | get_one_way_collision_margin()      |
 +-----------+-------------------------------------+
 
+The margin used for one-way collision (in pixels). Higher values will make the shape thicker, and work better for colliders that enter the polygon at a high velocity.
+
 ----
 
 .. _class_CollisionPolygon2D_property_polygon:

classes/class_collisionshape2d.rst

@@ -83,7 +83,7 @@ Sets whether this collision shape should only detect collision on one side (top
 | *Getter*  | get_one_way_collision_margin()      |
 +-----------+-------------------------------------+
 
-The margin used for one-way collision (in pixels).
+The margin used for one-way collision (in pixels). Higher values will make the shape thicker, and work better for colliders that enter the shape at a high velocity.
 
 ----
 

classes/class_color.rst

@@ -48,47 +48,47 @@ Properties
 Methods
 -------
 
-+-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Color<class_Color>`   | :ref:`Color<class_Color_method_Color>` **(** :ref:`String<class_String>` from **)**                                                                                           |
-+-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Color<class_Color>`   | :ref:`Color<class_Color_method_Color>` **(** :ref:`int<class_int>` from **)**                                                                                                 |
-+-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Color<class_Color>`   | :ref:`Color<class_Color_method_Color>` **(** :ref:`float<class_float>` r, :ref:`float<class_float>` g, :ref:`float<class_float>` b **)**                                      |
-+-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Color<class_Color>`   | :ref:`Color<class_Color_method_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:`blend<class_Color_method_blend>` **(** :ref:`Color<class_Color>` over **)**                                                                                             |
-+-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Color<class_Color>`   | :ref:`contrasted<class_Color_method_contrasted>` **(** **)**                                                                                                                  |
-+-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Color<class_Color>`   | :ref:`darkened<class_Color_method_darkened>` **(** :ref:`float<class_float>` amount **)**                                                                                     |
-+-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Color<class_Color>`   | :ref:`from_hsv<class_Color_method_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_method_gray>` **(** **)**                                                                                                                              |
-+-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Color<class_Color>`   | :ref:`inverted<class_Color_method_inverted>` **(** **)**                                                                                                                      |
-+-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`bool<class_bool>`     | :ref:`is_equal_approx<class_Color_method_is_equal_approx>` **(** :ref:`Color<class_Color>` color **)**                                                                        |
-+-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Color<class_Color>`   | :ref:`lightened<class_Color_method_lightened>` **(** :ref:`float<class_float>` amount **)**                                                                                   |
-+-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Color<class_Color>`   | :ref:`linear_interpolate<class_Color_method_linear_interpolate>` **(** :ref:`Color<class_Color>` b, :ref:`float<class_float>` t **)**                                         |
-+-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`       | :ref:`to_abgr32<class_Color_method_to_abgr32>` **(** **)**                                                                                                                    |
-+-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`       | :ref:`to_abgr64<class_Color_method_to_abgr64>` **(** **)**                                                                                                                    |
-+-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`       | :ref:`to_argb32<class_Color_method_to_argb32>` **(** **)**                                                                                                                    |
-+-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`       | :ref:`to_argb64<class_Color_method_to_argb64>` **(** **)**                                                                                                                    |
-+-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`String<class_String>` | :ref:`to_html<class_Color_method_to_html>` **(** :ref:`bool<class_bool>` with_alpha=True **)**                                                                                |
-+-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`       | :ref:`to_rgba32<class_Color_method_to_rgba32>` **(** **)**                                                                                                                    |
-+-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`int<class_int>`       | :ref:`to_rgba64<class_Color_method_to_rgba64>` **(** **)**                                                                                                                    |
-+-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
++-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Color<class_Color>`   | :ref:`Color<class_Color_method_Color>` **(** :ref:`String<class_String>` from **)**                                                                                             |
++-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Color<class_Color>`   | :ref:`Color<class_Color_method_Color>` **(** :ref:`int<class_int>` from **)**                                                                                                   |
++-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Color<class_Color>`   | :ref:`Color<class_Color_method_Color>` **(** :ref:`float<class_float>` r, :ref:`float<class_float>` g, :ref:`float<class_float>` b **)**                                        |
++-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Color<class_Color>`   | :ref:`Color<class_Color_method_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:`blend<class_Color_method_blend>` **(** :ref:`Color<class_Color>` over **)**                                                                                               |
++-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Color<class_Color>`   | :ref:`contrasted<class_Color_method_contrasted>` **(** **)**                                                                                                                    |
++-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Color<class_Color>`   | :ref:`darkened<class_Color_method_darkened>` **(** :ref:`float<class_float>` amount **)**                                                                                       |
++-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Color<class_Color>`   | :ref:`from_hsv<class_Color_method_from_hsv>` **(** :ref:`float<class_float>` h, :ref:`float<class_float>` s, :ref:`float<class_float>` v, :ref:`float<class_float>` a=1.0 **)** |
++-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`float<class_float>`   | :ref:`gray<class_Color_method_gray>` **(** **)**                                                                                                                                |
++-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Color<class_Color>`   | :ref:`inverted<class_Color_method_inverted>` **(** **)**                                                                                                                        |
++-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`     | :ref:`is_equal_approx<class_Color_method_is_equal_approx>` **(** :ref:`Color<class_Color>` color **)**                                                                          |
++-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Color<class_Color>`   | :ref:`lightened<class_Color_method_lightened>` **(** :ref:`float<class_float>` amount **)**                                                                                     |
++-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Color<class_Color>`   | :ref:`linear_interpolate<class_Color_method_linear_interpolate>` **(** :ref:`Color<class_Color>` b, :ref:`float<class_float>` t **)**                                           |
++-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`       | :ref:`to_abgr32<class_Color_method_to_abgr32>` **(** **)**                                                                                                                      |
++-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`       | :ref:`to_abgr64<class_Color_method_to_abgr64>` **(** **)**                                                                                                                      |
++-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`       | :ref:`to_argb32<class_Color_method_to_argb32>` **(** **)**                                                                                                                      |
++-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`       | :ref:`to_argb64<class_Color_method_to_argb64>` **(** **)**                                                                                                                      |
++-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`String<class_String>` | :ref:`to_html<class_Color_method_to_html>` **(** :ref:`bool<class_bool>` with_alpha=true **)**                                                                                  |
++-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`       | :ref:`to_rgba32<class_Color_method_to_rgba32>` **(** **)**                                                                                                                      |
++-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`int<class_int>`       | :ref:`to_rgba64<class_Color_method_to_rgba64>` **(** **)**                                                                                                                      |
++-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
 Constants
 ---------
@@ -901,7 +901,7 @@ Returns a new color resulting from making this color darker by the specified per
 
 .. _class_Color_method_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 **)**
+- :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.0 **)**
 
 Constructs a color from an HSV profile. ``h``, ``s``, and ``v`` are values between 0 and 1.
 
@@ -1028,7 +1028,7 @@ Returns the color's 64-bit integer in ARGB format (each word represents a compon
 
 .. _class_Color_method_to_html:
 
-- :ref:`String<class_String>` **to_html** **(** :ref:`bool<class_bool>` with_alpha=True **)**
+- :ref:`String<class_String>` **to_html** **(** :ref:`bool<class_bool>` with_alpha=true **)**
 
 Returns the color's HTML hexadecimal color string in ARGB format (ex: ``ff34f822``).
 

classes/class_concavepolygonshape.rst

@@ -18,6 +18,8 @@ Description
 
 Concave polygon shape resource, which can be set into a :ref:`PhysicsBody<class_PhysicsBody>` or area. This shape is created by feeding a list of triangles.
 
+Note: when used for collision, ``ConcavePolygonShape`` is intended to work with static :ref:`PhysicsBody<class_PhysicsBody>` nodes like :ref:`StaticBody<class_StaticBody>` and will not work with :ref:`KinematicBody<class_KinematicBody>` or :ref:`RigidBody<class_RigidBody>` with a mode other than Static.
+
 Methods
 -------
 

classes/class_configfile.rst

@@ -68,13 +68,15 @@ Methods
 +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`Error<enum_@GlobalScope_Error>`         | :ref:`load_encrypted<class_ConfigFile_method_load_encrypted>` **(** :ref:`String<class_String>` path, :ref:`PoolByteArray<class_PoolByteArray>` key **)**                              |
 +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Error<enum_@GlobalScope_Error>`         | :ref:`load_encrypted_pass<class_ConfigFile_method_load_encrypted_pass>` **(** :ref:`String<class_String>` path, :ref:`String<class_String>` pass **)**                                 |
+| :ref:`Error<enum_@GlobalScope_Error>`         | :ref:`load_encrypted_pass<class_ConfigFile_method_load_encrypted_pass>` **(** :ref:`String<class_String>` path, :ref:`String<class_String>` password **)**                             |
++-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`Error<enum_@GlobalScope_Error>`         | :ref:`parse<class_ConfigFile_method_parse>` **(** :ref:`String<class_String>` data **)**                                                                                               |
 +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`Error<enum_@GlobalScope_Error>`         | :ref:`save<class_ConfigFile_method_save>` **(** :ref:`String<class_String>` path **)**                                                                                                 |
 +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`Error<enum_@GlobalScope_Error>`         | :ref:`save_encrypted<class_ConfigFile_method_save_encrypted>` **(** :ref:`String<class_String>` path, :ref:`PoolByteArray<class_PoolByteArray>` key **)**                              |
 +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Error<enum_@GlobalScope_Error>`         | :ref:`save_encrypted_pass<class_ConfigFile_method_save_encrypted_pass>` **(** :ref:`String<class_String>` path, :ref:`String<class_String>` pass **)**                                 |
+| :ref:`Error<enum_@GlobalScope_Error>`         | :ref:`save_encrypted_pass<class_ConfigFile_method_save_encrypted_pass>` **(** :ref:`String<class_String>` path, :ref:`String<class_String>` password **)**                             |
 +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | void                                          | :ref:`set_value<class_ConfigFile_method_set_value>` **(** :ref:`String<class_String>` section, :ref:`String<class_String>` key, :ref:`Variant<class_Variant>` value **)**              |
 +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -86,7 +88,7 @@ Method Descriptions
 
 - void **erase_section** **(** :ref:`String<class_String>` section **)**
 
-Deletes the specified section along with all the key-value pairs inside.
+Deletes the specified section along with all the key-value pairs inside. Raises an error if the section does not exist.
 
 ----
 
@@ -94,13 +96,15 @@ Deletes the specified section along with all the key-value pairs inside.
 
 - void **erase_section_key** **(** :ref:`String<class_String>` section, :ref:`String<class_String>` key **)**
 
+Deletes the specified key in a section. Raises an error if either the section or the key do not exist.
+
 ----
 
 .. _class_ConfigFile_method_get_section_keys:
 
 - :ref:`PoolStringArray<class_PoolStringArray>` **get_section_keys** **(** :ref:`String<class_String>` section **)** const
 
-Returns an array of all defined key identifiers in the specified section.
+Returns an array of all defined key identifiers in the specified section. Raises an error and returns an empty array if the section does not exist.
 
 ----
 
@@ -116,7 +120,7 @@ Returns an array of all defined section identifiers.
 
 - :ref:`Variant<class_Variant>` **get_value** **(** :ref:`String<class_String>` section, :ref:`String<class_String>` key, :ref:`Variant<class_Variant>` default=null **)** const
 
-Returns the current value for the specified section and key. If the section and/or the key do not exist, the method returns the value of the optional ``default`` argument, or ``null`` if it is omitted.
+Returns the current value for the specified section and key. If either the section or the key do not exist, the method returns the fallback ``default`` value. If ``default`` is not specified or set to ``null``, an error is also raised.
 
 ----
 
@@ -140,7 +144,7 @@ Returns ``true`` if the specified section-key pair exists.
 
 - :ref:`Error<enum_@GlobalScope_Error>` **load** **(** :ref:`String<class_String>` path **)**
 
-Loads the config file specified as a parameter. The file's contents are parsed and loaded in the ConfigFile object which the method was called on.
+Loads the config file specified as a parameter. The file's contents are parsed and loaded in the ``ConfigFile`` object which the method was called on.
 
 Returns one of the :ref:`Error<enum_@GlobalScope_Error>` code constants (``OK`` on success).
 
@@ -150,11 +154,29 @@ Returns one of the :ref:`Error<enum_@GlobalScope_Error>` code constants (``OK``
 
 - :ref:`Error<enum_@GlobalScope_Error>` **load_encrypted** **(** :ref:`String<class_String>` path, :ref:`PoolByteArray<class_PoolByteArray>` key **)**
 
+Loads the encrypted config file specified as a parameter, using the provided ``key`` to decrypt it. The file's contents are parsed and loaded in the ``ConfigFile`` object which the method was called on.
+
+Returns one of the :ref:`Error<enum_@GlobalScope_Error>` code constants (``OK`` on success).
+
 ----
 
 .. _class_ConfigFile_method_load_encrypted_pass:
 
-- :ref:`Error<enum_@GlobalScope_Error>` **load_encrypted_pass** **(** :ref:`String<class_String>` path, :ref:`String<class_String>` pass **)**
+- :ref:`Error<enum_@GlobalScope_Error>` **load_encrypted_pass** **(** :ref:`String<class_String>` path, :ref:`String<class_String>` password **)**
+
+Loads the encrypted config file specified as a parameter, using the provided ``password`` to decrypt it. The file's contents are parsed and loaded in the ``ConfigFile`` object which the method was called on.
+
+Returns one of the :ref:`Error<enum_@GlobalScope_Error>` code constants (``OK`` on success).
+
+----
+
+.. _class_ConfigFile_method_parse:
+
+- :ref:`Error<enum_@GlobalScope_Error>` **parse** **(** :ref:`String<class_String>` data **)**
+
+Parses the the passed string as the contents of a config file. The string is parsed and loaded in the ConfigFile object which the method was called on.
+
+Returns one of the :ref:`Error<enum_@GlobalScope_Error>` code constants (``OK`` on success).
 
 ----
 
@@ -162,7 +184,7 @@ Returns one of the :ref:`Error<enum_@GlobalScope_Error>` code constants (``OK``
 
 - :ref:`Error<enum_@GlobalScope_Error>` **save** **(** :ref:`String<class_String>` path **)**
 
-Saves the contents of the ConfigFile object to the file specified as a parameter. The output file uses an INI-style structure.
+Saves the contents of the ``ConfigFile`` object to the file specified as a parameter. The output file uses an INI-style structure.
 
 Returns one of the :ref:`Error<enum_@GlobalScope_Error>` code constants (``OK`` on success).
 
@@ -172,11 +194,19 @@ Returns one of the :ref:`Error<enum_@GlobalScope_Error>` code constants (``OK``
 
 - :ref:`Error<enum_@GlobalScope_Error>` **save_encrypted** **(** :ref:`String<class_String>` path, :ref:`PoolByteArray<class_PoolByteArray>` key **)**
 
+Saves the contents of the ``ConfigFile`` object to the AES-256 encrypted file specified as a parameter, using the provided ``key`` to encrypt it. The output file uses an INI-style structure.
+
+Returns one of the :ref:`Error<enum_@GlobalScope_Error>` code constants (``OK`` on success).
+
 ----
 
 .. _class_ConfigFile_method_save_encrypted_pass:
 
-- :ref:`Error<enum_@GlobalScope_Error>` **save_encrypted_pass** **(** :ref:`String<class_String>` path, :ref:`String<class_String>` pass **)**
+- :ref:`Error<enum_@GlobalScope_Error>` **save_encrypted_pass** **(** :ref:`String<class_String>` path, :ref:`String<class_String>` password **)**
+
+Saves the contents of the ``ConfigFile`` object to the AES-256 encrypted file specified as a parameter, using the provided ``password`` to encrypt it. The output file uses an INI-style structure.
+
+Returns one of the :ref:`Error<enum_@GlobalScope_Error>` code constants (``OK`` on success).
 
 ----
 
@@ -184,5 +214,5 @@ Returns one of the :ref:`Error<enum_@GlobalScope_Error>` code constants (``OK``
 
 - void **set_value** **(** :ref:`String<class_String>` section, :ref:`String<class_String>` key, :ref:`Variant<class_Variant>` value **)**
 
-Assigns a value to the specified key of the specified section. If the section and/or the key do not exist, they are created. Passing a ``null`` value deletes the specified key if it exists, and deletes the section if it ends up empty once the key has been removed.
+Assigns a value to the specified key of the specified section. If either the section or the key do not exist, they are created. Passing a ``null`` value deletes the specified key if it exists, and deletes the section if it ends up empty once the key has been removed.
 

classes/class_dictionary.rst

@@ -98,13 +98,13 @@ Methods
 +-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------+
 | void                                | :ref:`clear<class_Dictionary_method_clear>` **(** **)**                                                                           |
 +-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Dictionary<class_Dictionary>` | :ref:`duplicate<class_Dictionary_method_duplicate>` **(** :ref:`bool<class_bool>` deep=False **)**                                |
+| :ref:`Dictionary<class_Dictionary>` | :ref:`duplicate<class_Dictionary_method_duplicate>` **(** :ref:`bool<class_bool>` deep=false **)**                                |
 +-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`bool<class_bool>`             | :ref:`empty<class_Dictionary_method_empty>` **(** **)**                                                                           |
 +-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`bool<class_bool>`             | :ref:`erase<class_Dictionary_method_erase>` **(** :ref:`Variant<class_Variant>` key **)**                                         |
 +-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Variant<class_Variant>`       | :ref:`get<class_Dictionary_method_get>` **(** :ref:`Variant<class_Variant>` key, :ref:`Variant<class_Variant>` default=Null **)** |
+| :ref:`Variant<class_Variant>`       | :ref:`get<class_Dictionary_method_get>` **(** :ref:`Variant<class_Variant>` key, :ref:`Variant<class_Variant>` default=null **)** |
 +-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`bool<class_bool>`             | :ref:`has<class_Dictionary_method_has>` **(** :ref:`Variant<class_Variant>` key **)**                                             |
 +-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------+
@@ -132,7 +132,7 @@ Clear the dictionary, removing all key/value pairs.
 
 .. _class_Dictionary_method_duplicate:
 
-- :ref:`Dictionary<class_Dictionary>` **duplicate** **(** :ref:`bool<class_bool>` deep=False **)**
+- :ref:`Dictionary<class_Dictionary>` **duplicate** **(** :ref:`bool<class_bool>` deep=false **)**
 
 Creates a copy of the dictionary, and returns it.
 
@@ -156,7 +156,7 @@ Erase a dictionary key/value pair by key. Returns ``true`` if the given key was
 
 .. _class_Dictionary_method_get:
 
-- :ref:`Variant<class_Variant>` **get** **(** :ref:`Variant<class_Variant>` key, :ref:`Variant<class_Variant>` default=Null **)**
+- :ref:`Variant<class_Variant>` **get** **(** :ref:`Variant<class_Variant>` key, :ref:`Variant<class_Variant>` default=null **)**
 
 Returns the current value for the specified key in the ``Dictionary``. If the key does not exist, the method returns the value of the optional default argument, or ``null`` if it is omitted.
 

classes/class_editorexportplugin.rst

@@ -11,7 +11,7 @@ EditorExportPlugin
 
 **Inherits:** :ref:`Reference<class_Reference>` **<** :ref:`Object<class_Object>`
 
-
+A script that is executed when exporting projects.
 
 Methods
 -------
@@ -47,12 +47,16 @@ Method Descriptions
 
 - void **_export_begin** **(** :ref:`PoolStringArray<class_PoolStringArray>` features, :ref:`bool<class_bool>` is_debug, :ref:`String<class_String>` path, :ref:`int<class_int>` flags **)** virtual
 
+Virtual method to be overridden by the user. It is called when the export starts and provides all information about the export.
+
 ----
 
 .. _class_EditorExportPlugin_method__export_end:
 
 - void **_export_end** **(** **)** virtual
 
+Virtual method to be overridden by the user. Called when the export is finished.
+
 ----
 
 .. _class_EditorExportPlugin_method__export_file:

classes/class_editorfiledialog.rst

@@ -11,7 +11,7 @@ EditorFileDialog
 
 **Inherits:** :ref:`ConfirmationDialog<class_ConfirmationDialog>` **<** :ref:`AcceptDialog<class_AcceptDialog>` **<** :ref:`WindowDialog<class_WindowDialog>` **<** :ref:`Popup<class_Popup>` **<** :ref:`Control<class_Control>` **<** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-
+A modified version of :ref:`FileDialog<class_FileDialog>` used by the editor.
 
 Properties
 ----------

classes/class_editorfilesystem.rst

@@ -143,3 +143,5 @@ Update a file information. Call this if an external program (not Godot) modified
 
 - void **update_script_classes** **(** **)**
 
+Scans the script files and updates the list of custom class names.
+

classes/class_editorinspector.rst

@@ -11,7 +11,12 @@ EditorInspector
 
 **Inherits:** :ref:`ScrollContainer<class_ScrollContainer>` **<** :ref:`Container<class_Container>` **<** :ref:`Control<class_Control>` **<** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
+A tab used to edit properties of the selected node.
 
+Description
+-----------
+
+The editor inspector is by default located on the right-hand side of the editor. It's used to edit the properties of the selected node. For example, you can select a node such as Sprite2D then edit its transform through the inspector tool. The editor inspector is an essential tool in the game development workflow.
 
 Properties
 ----------

classes/class_editorplugin.rst

@@ -75,7 +75,7 @@ Methods
 +-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`EditorInterface<class_EditorInterface>`       | :ref:`get_editor_interface<class_EditorPlugin_method_get_editor_interface>` **(** **)**                                                                                                                                                |
 +-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`Object<class_Object>`                         | :ref:`get_plugin_icon<class_EditorPlugin_method_get_plugin_icon>` **(** **)** virtual                                                                                                                                                  |
+| :ref:`Texture<class_Texture>`                       | :ref:`get_plugin_icon<class_EditorPlugin_method_get_plugin_icon>` **(** **)** virtual                                                                                                                                                  |
 +-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`String<class_String>`                         | :ref:`get_plugin_name<class_EditorPlugin_method_get_plugin_name>` **(** **)** virtual                                                                                                                                                  |
 +-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -495,7 +495,21 @@ Returns the :ref:`EditorInterface<class_EditorInterface>` object that gives you
 
 .. _class_EditorPlugin_method_get_plugin_icon:
 
-- :ref:`Object<class_Object>` **get_plugin_icon** **(** **)** virtual
+- :ref:`Texture<class_Texture>` **get_plugin_icon** **(** **)** virtual
+
+Override this method in your plugin to return a :ref:`Texture<class_Texture>` in order to give it an icon.
+
+For main screen plugins, this appears at the top of the screen, to the right of the "2D", "3D", "Script", and "AssetLib" buttons.
+
+Ideally, the plugin icon should be white with a transparent background and 16x16 pixels in size.
+
+::
+
+    func get_plugin_icon():
+        # You can use a custom icon:
+        return preload("res://addons/my_plugin/my_plugin_icon.svg")
+        # Or use a built-in icon:
+        return get_editor_interface().get_base_control().get_icon("Node", "EditorIcons")
 
 ----
 
@@ -503,6 +517,10 @@ Returns the :ref:`EditorInterface<class_EditorInterface>` object that gives you
 
 - :ref:`String<class_String>` **get_plugin_name** **(** **)** virtual
 
+Override this method in your plugin to provide the name of the plugin when displayed in the Godot editor.
+
+For main screen plugins, this appears at the top of the screen, to the right of the "2D", "3D", "Script", and "AssetLib" buttons.
+
 ----
 
 .. _class_EditorPlugin_method_get_script_create_dialog:

classes/class_editorsceneimporterassimp.rst

@@ -11,12 +11,12 @@ EditorSceneImporterAssimp
 
 **Inherits:** :ref:`EditorSceneImporter<class_EditorSceneImporter>` **<** :ref:`Reference<class_Reference>` **<** :ref:`Object<class_Object>`
 
-Multi-format 3D asset importer based on `Assimp <http://assimp.org/>`_.
+FBX 3D asset importer based on `Assimp <http://assimp.org/>`_.
 
 Description
 -----------
 
-This is a multi-format 3D asset importer based on `Assimp <http://assimp.org/>`_. See `this page <https://assimp-docs.readthedocs.io/en/latest/about/intoduction.html#installation>`_ for a full list of supported formats.
+This is an FBX 3D asset importer based on `Assimp <http://assimp.org/>`_. It currently has many known limitations and works best with static meshes. Most animated meshes won't import correctly.
 
 If exporting a FBX scene from Autodesk Maya, use these FBX export settings:
 

classes/class_engine.rst

@@ -99,7 +99,7 @@ If ``true``, it is running inside the editor. Useful for tool scripts.
 | *Getter*  | get_iterations_per_second()      |
 +-----------+----------------------------------+
 
-The number of fixed iterations per second (for fixed process and physics).
+The number of fixed iterations per second. This controls how often physics simulation and :ref:`Node._physics_process<class_Node_method__physics_process>` methods are run. This value should generally always be set to ``60`` or above, as Godot doesn't interpolate the physics step. As a result, values lower than ``60`` will look stuttery. This value can be increased to make input more reactive or work around tunneling issues, but keep in mind doing so will increase CPU usage.
 
 ----
 
@@ -115,7 +115,7 @@ The number of fixed iterations per second (for fixed process and physics).
 | *Getter*  | get_physics_jitter_fix()      |
 +-----------+-------------------------------+
 
-Controls how much physic ticks are synchronized  with real time. For 0 or less, the ticks are synchronized. Such values are recommended for network games, where clock synchronization matters. Higher values cause higher deviation of in-game clock and real clock, but allows to smooth out framerate jitters. The default value of 0.5 should be fine for most; values above 2 could cause the game to react to dropped frames with a noticeable delay and are not recommended.
+Controls how much physics ticks are synchronized with real time. For 0 or less, the ticks are synchronized. Such values are recommended for network games, where clock synchronization matters. Higher values cause higher deviation of in-game clock and real clock, but allows to smooth out framerate jitters. The default value of 0.5 should be fine for most; values above 2 could cause the game to react to dropped frames with a noticeable delay and are not recommended.
 
 ----
 

classes/class_font.rst

@@ -100,6 +100,8 @@ Returns the size of a string, taking kerning and advance into account.
 
 - :ref:`Vector2<class_Vector2>` **get_wordwrap_string_size** **(** :ref:`String<class_String>` string, :ref:`float<class_float>` width **)** const
 
+Returns the size that the string would have with word wrapping enabled with a fixed ``width``.
+
 ----
 
 .. _class_Font_method_has_outline:

classes/class_hingejoint.rst

@@ -275,21 +275,29 @@ Method Descriptions
 
 - :ref:`bool<class_bool>` **get_flag** **(** :ref:`Flag<enum_HingeJoint_Flag>` flag **)** const
 
+Returns the value of the specified flag.
+
 ----
 
 .. _class_HingeJoint_method_get_param:
 
 - :ref:`float<class_float>` **get_param** **(** :ref:`Param<enum_HingeJoint_Param>` param **)** const
 
+Returns the value of the specified parameter.
+
 ----
 
 .. _class_HingeJoint_method_set_flag:
 
 - void **set_flag** **(** :ref:`Flag<enum_HingeJoint_Flag>` flag, :ref:`bool<class_bool>` enabled **)**
 
+If ``true``, enables the specified flag.
+
 ----
 
 .. _class_HingeJoint_method_set_param:
 
 - void **set_param** **(** :ref:`Param<enum_HingeJoint_Param>` param, :ref:`float<class_float>` value **)**
 
+Sets the value of the specified parameter.
+

classes/class_inputeventgesture.rst

@@ -13,7 +13,7 @@ InputEventGesture
 
 **Inherited By:** :ref:`InputEventMagnifyGesture<class_InputEventMagnifyGesture>`, :ref:`InputEventPanGesture<class_InputEventPanGesture>`
 
-
+Base class for touch control gestures.
 
 Properties
 ----------
@@ -37,3 +37,5 @@ Property Descriptions
 | *Getter*  | get_position()      |
 +-----------+---------------------+
 
+The local gesture position relative to the :ref:`Viewport<class_Viewport>`. If used in :ref:`Control._gui_input<class_Control_method__gui_input>`, the position is relative to the current :ref:`Control<class_Control>` that received this gesture.
+

classes/class_kinematicbody.rst

@@ -219,7 +219,9 @@ If ``test_only`` is ``true``, the body does not move but the would-be collision
 
 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.
 
-``linear_velocity`` is the velocity vector (typically meters per second). Unlike in :ref:`move_and_collide<class_KinematicBody_method_move_and_collide>`, you should *not* multiply it by ``delta`` — the physics engine handles applying the velocity.
+This method should be used in :ref:`Node._physics_process<class_Node_method__physics_process>` (or in a method called by :ref:`Node._physics_process<class_Node_method__physics_process>`), as it uses the physics step's ``delta`` value automatically in calculations. Otherwise, the simulation will run at an incorrect speed.
+
+``linear_velocity`` is the velocity vector (typically meters per second). Unlike in :ref:`move_and_collide<class_KinematicBody_method_move_and_collide>`, you should *not* multiply it by ``delta`` — the physics engine handles applying the velocity. 
 
 ``up_direction`` is the up direction, used to determine what is a wall and what is a floor or a ceiling. If set to the default value of ``Vector3(0, 0, 0)``, everything is considered a wall.
 

classes/class_kinematicbody2d.rst

@@ -181,7 +181,9 @@ If ``test_only`` is ``true``, the body does not move but the would-be collision
 
 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.
 
-``linear_velocity`` is the velocity vector in pixels per second. Unlike in :ref:`move_and_collide<class_KinematicBody2D_method_move_and_collide>`, you should *not* multiply it by ``delta`` — the physics engine handles applying the velocity.
+This method should be used in :ref:`Node._physics_process<class_Node_method__physics_process>` (or in a method called by :ref:`Node._physics_process<class_Node_method__physics_process>`), as it uses the physics step's ``delta`` value automatically in calculations. Otherwise, the simulation will run at an incorrect speed.
+
+``linear_velocity`` is the velocity vector in pixels per second. Unlike in :ref:`move_and_collide<class_KinematicBody2D_method_move_and_collide>`, you should *not* multiply it by ``delta`` — the physics engine handles applying the velocity. 
 
 ``up_direction`` is the up direction, used to determine what is a wall and what is a floor or a ceiling. If set to the default value of ``Vector2(0, 0)``, everything is considered a wall. This is useful for topdown games.
 

classes/class_linkbutton.rst

@@ -84,6 +84,8 @@ Property Descriptions
 | *Getter*  | get_text()      |
 +-----------+-----------------+
 
+The button's text that will be displayed inside the button's area.
+
 ----
 
 .. _class_LinkButton_property_underline:
@@ -98,3 +100,5 @@ Property Descriptions
 | *Getter*  | get_underline_mode()      |
 +-----------+---------------------------+
 
+Determines when to show the underline. See :ref:`UnderlineMode<enum_LinkButton_UnderlineMode>` for options.
+

classes/class_marshalls.rst

@@ -9,7 +9,7 @@
 Marshalls
 =========
 
-**Inherits:** :ref:`Reference<class_Reference>` **<** :ref:`Object<class_Object>`
+**Inherits:** :ref:`Object<class_Object>`
 
 Data transformation (marshalling) and encoding helpers.
 

classes/class_meshlibrary.rst

@@ -132,9 +132,7 @@ Returns the transform applied to the item's navigation mesh.
 
 - :ref:`Texture<class_Texture>` **get_item_preview** **(** :ref:`int<class_int>` id **)** const
 
-Returns a generated item preview (a 3D rendering in isometric perspective).
-
-**Note:** Since item previews are only generated in an editor context, this function will return an empty :ref:`Texture<class_Texture>` in a running project.
+When running in the editor, returns a generated item preview (a 3D rendering in isometric perspective). When used in a running project, returns the manually-defined item preview which can be set using :ref:`set_item_preview<class_MeshLibrary_method_set_item_preview>`. Returns an empty :ref:`Texture<class_Texture>` if no preview was manually set in a running project.
 
 ----
 

classes/class_node.rst

@@ -904,7 +904,7 @@ Returns the relative :ref:`NodePath<class_NodePath>` from this node to the speci
 
 - :ref:`float<class_float>` **get_physics_process_delta_time** **(** **)** const
 
-Returns the time elapsed since the last physics-bound frame (see :ref:`_physics_process<class_Node_method__physics_process>`). This is always a constant value in physics processing unless the frames per second is changed via :ref:`Engine.target_fps<class_Engine_property_target_fps>`.
+Returns the time elapsed since the last physics-bound frame (see :ref:`_physics_process<class_Node_method__physics_process>`). This is always a constant value in physics processing unless the frames per second is changed via :ref:`Engine.iterations_per_second<class_Engine_property_iterations_per_second>`.
 
 ----
 
@@ -1296,7 +1296,7 @@ Sets the node's network master to the peer with the given peer ID. The network m
 
 - void **set_physics_process** **(** :ref:`bool<class_bool>` enable **)**
 
-Enables or disables physics (i.e. fixed framerate) processing. When a node is being processed, it will receive a :ref:`NOTIFICATION_PHYSICS_PROCESS<class_Node_constant_NOTIFICATION_PHYSICS_PROCESS>` at a fixed (usually 60 FPS, see :ref:`Engine.target_fps<class_Engine_property_target_fps>` to change) interval (and the :ref:`_physics_process<class_Node_method__physics_process>` callback will be called if exists). Enabled automatically if :ref:`_physics_process<class_Node_method__physics_process>` is overridden. Any calls to this before :ref:`_ready<class_Node_method__ready>` will be ignored.
+Enables or disables physics (i.e. fixed framerate) processing. When a node is being processed, it will receive a :ref:`NOTIFICATION_PHYSICS_PROCESS<class_Node_constant_NOTIFICATION_PHYSICS_PROCESS>` at a fixed (usually 60 FPS, see :ref:`Engine.iterations_per_second<class_Engine_property_iterations_per_second>` to change) interval (and the :ref:`_physics_process<class_Node_method__physics_process>` callback will be called if exists). Enabled automatically if :ref:`_physics_process<class_Node_method__physics_process>` is overridden. Any calls to this before :ref:`_ready<class_Node_method__ready>` will be ignored.
 
 ----
 

classes/class_object.rst

@@ -9,7 +9,7 @@
 Object
 ======
 
-**Inherited By:** :ref:`ARVRPositionalTracker<class_ARVRPositionalTracker>`, :ref:`ARVRServer<class_ARVRServer>`, :ref:`AudioServer<class_AudioServer>`, :ref:`CameraServer<class_CameraServer>`, :ref:`ClassDB<class_ClassDB>`, :ref:`EditorFileSystemDirectory<class_EditorFileSystemDirectory>`, :ref:`EditorNavigationMeshGenerator<class_EditorNavigationMeshGenerator>`, :ref:`EditorSelection<class_EditorSelection>`, :ref:`EditorVCSInterface<class_EditorVCSInterface>`, :ref:`Engine<class_Engine>`, :ref:`Geometry<class_Geometry>`, :ref:`GodotSharp<class_GodotSharp>`, :ref:`IP<class_IP>`, :ref:`Input<class_Input>`, :ref:`InputMap<class_InputMap>`, :ref:`JSON<class_JSON>`, :ref:`JSONRPC<class_JSONRPC>`, :ref:`JavaClassWrapper<class_JavaClassWrapper>`, :ref:`JavaScript<class_JavaScript>`, :ref:`MainLoop<class_MainLoop>`, :ref:`Node<class_Node>`, :ref:`OS<class_OS>`, :ref:`Performance<class_Performance>`, :ref:`Physics2DDirectBodyState<class_Physics2DDirectBodyState>`, :ref:`Physics2DDirectSpaceState<class_Physics2DDirectSpaceState>`, :ref:`Physics2DServer<class_Physics2DServer>`, :ref:`PhysicsDirectBodyState<class_PhysicsDirectBodyState>`, :ref:`PhysicsDirectSpaceState<class_PhysicsDirectSpaceState>`, :ref:`PhysicsServer<class_PhysicsServer>`, :ref:`ProjectSettings<class_ProjectSettings>`, :ref:`Reference<class_Reference>`, :ref:`ResourceLoader<class_ResourceLoader>`, :ref:`ResourceSaver<class_ResourceSaver>`, :ref:`TranslationServer<class_TranslationServer>`, :ref:`TreeItem<class_TreeItem>`, :ref:`UndoRedo<class_UndoRedo>`, :ref:`VisualScriptEditor<class_VisualScriptEditor>`, :ref:`VisualServer<class_VisualServer>`
+**Inherited By:** :ref:`ARVRPositionalTracker<class_ARVRPositionalTracker>`, :ref:`ARVRServer<class_ARVRServer>`, :ref:`AudioServer<class_AudioServer>`, :ref:`CameraServer<class_CameraServer>`, :ref:`ClassDB<class_ClassDB>`, :ref:`EditorFileSystemDirectory<class_EditorFileSystemDirectory>`, :ref:`EditorNavigationMeshGenerator<class_EditorNavigationMeshGenerator>`, :ref:`EditorSelection<class_EditorSelection>`, :ref:`EditorVCSInterface<class_EditorVCSInterface>`, :ref:`Engine<class_Engine>`, :ref:`Geometry<class_Geometry>`, :ref:`GodotSharp<class_GodotSharp>`, :ref:`IP<class_IP>`, :ref:`Input<class_Input>`, :ref:`InputMap<class_InputMap>`, :ref:`JSON<class_JSON>`, :ref:`JSONRPC<class_JSONRPC>`, :ref:`JavaClassWrapper<class_JavaClassWrapper>`, :ref:`JavaScript<class_JavaScript>`, :ref:`MainLoop<class_MainLoop>`, :ref:`Marshalls<class_Marshalls>`, :ref:`Node<class_Node>`, :ref:`OS<class_OS>`, :ref:`Performance<class_Performance>`, :ref:`Physics2DDirectBodyState<class_Physics2DDirectBodyState>`, :ref:`Physics2DDirectSpaceState<class_Physics2DDirectSpaceState>`, :ref:`Physics2DServer<class_Physics2DServer>`, :ref:`PhysicsDirectBodyState<class_PhysicsDirectBodyState>`, :ref:`PhysicsDirectSpaceState<class_PhysicsDirectSpaceState>`, :ref:`PhysicsServer<class_PhysicsServer>`, :ref:`ProjectSettings<class_ProjectSettings>`, :ref:`Reference<class_Reference>`, :ref:`ResourceLoader<class_ResourceLoader>`, :ref:`ResourceSaver<class_ResourceSaver>`, :ref:`TranslationServer<class_TranslationServer>`, :ref:`TreeItem<class_TreeItem>`, :ref:`UndoRedo<class_UndoRedo>`, :ref:`VisualScriptEditor<class_VisualScriptEditor>`, :ref:`VisualServer<class_VisualServer>`
 
 Base class for all non built-in types.
 

classes/class_opensimplexnoise.rst

@@ -101,7 +101,9 @@ Difference in period between :ref:`octaves<class_OpenSimplexNoise_property_octav
 | *Getter*  | get_octaves()      |
 +-----------+--------------------+
 
-Number of OpenSimplex noise layers that are sampled to get the fractal noise.
+Number of OpenSimplex noise layers that are sampled to get the fractal noise. Higher values result in more detailed noise but take more time to generate.
+
+**Note:** The maximum allowed value is 9.
 
 ----
 

classes/class_os.rst

@@ -734,7 +734,7 @@ Use ``get_tree().get_root().set_transparent_background(true)`` to disable main v
 
 **Note:** This property has no effect if **Project > Project Settings > Display > Window > Per-pixel transparency > Allowed** setting is disabled.
 
-**Note:** This property is implemented on Linux, macOS and Windows.
+**Note:** This property is implemented on HTML5, Linux, macOS and Windows.
 
 ----
 

classes/class_packeddatacontainerref.rst

@@ -11,7 +11,7 @@ PackedDataContainerRef
 
 **Inherits:** :ref:`Reference<class_Reference>` **<** :ref:`Object<class_Object>`
 
-
+Reference version of :ref:`PackedDataContainer<class_PackedDataContainer>`.
 
 Methods
 -------

classes/class_panoramasky.rst

@@ -18,6 +18,10 @@ Description
 
 A resource referenced in an :ref:`Environment<class_Environment>` that is used to draw a background. The Panorama sky functions similar to skyboxes in other engines, except it uses an equirectangular sky map instead of a cube map.
 
+Using an HDR panorama is strongly recommended for accurate, high-quality reflections. Godot supports the Radiance HDR (``.hdr``) and OpenEXR (``.exr``) image formats for this purpose.
+
+You can use `this tool <https://danilw.github.io/GLSL-howto/cubemap_to_panorama_js/cubemap_to_panorama.html>`_ to convert a cube map to an equirectangular sky map.
+
 Properties
 ----------
 

classes/class_pinjoint.rst

@@ -113,9 +113,13 @@ Method Descriptions
 
 - :ref:`float<class_float>` **get_param** **(** :ref:`Param<enum_PinJoint_Param>` param **)** const
 
+Returns the value of the specified parameter.
+
 ----
 
 .. _class_PinJoint_method_set_param:
 
 - void **set_param** **(** :ref:`Param<enum_PinJoint_Param>` param, :ref:`float<class_float>` value **)**
 
+Sets the value of the specified parameter.
+

classes/class_plane.rst

@@ -52,7 +52,7 @@ Methods
 +-------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`Vector3<class_Vector3>` | :ref:`get_any_point<class_Plane_method_get_any_point>` **(** **)**                                                                                                    |
 +-------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`bool<class_bool>`       | :ref:`has_point<class_Plane_method_has_point>` **(** :ref:`Vector3<class_Vector3>` point, :ref:`float<class_float>` epsilon=0.00001 **)**                             |
+| :ref:`bool<class_bool>`       | :ref:`has_point<class_Plane_method_has_point>` **(** :ref:`Vector3<class_Vector3>` point, :ref:`float<class_float>` epsilon=1e-05 **)**                               |
 +-------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`Vector3<class_Vector3>` | :ref:`intersect_3<class_Plane_method_intersect_3>` **(** :ref:`Plane<class_Plane>` b, :ref:`Plane<class_Plane>` c **)**                                               |
 +-------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -194,7 +194,7 @@ Returns a point on the plane.
 
 .. _class_Plane_method_has_point:
 
-- :ref:`bool<class_bool>` **has_point** **(** :ref:`Vector3<class_Vector3>` point, :ref:`float<class_float>` epsilon=0.00001 **)**
+- :ref:`bool<class_bool>` **has_point** **(** :ref:`Vector3<class_Vector3>` point, :ref:`float<class_float>` epsilon=1e-05 **)**
 
 Returns ``true`` if ``point`` is inside the plane (by a very minimum ``epsilon`` threshold).
 

classes/class_polygon2d.rst

@@ -346,45 +346,61 @@ Method Descriptions
 
 - void **add_bone** **(** :ref:`NodePath<class_NodePath>` path, :ref:`PoolRealArray<class_PoolRealArray>` weights **)**
 
+Adds a bone with the specified ``path`` and ``weights``.
+
 ----
 
 .. _class_Polygon2D_method_clear_bones:
 
 - void **clear_bones** **(** **)**
 
+Removes all bones from this ``Polygon2D``.
+
 ----
 
 .. _class_Polygon2D_method_erase_bone:
 
 - void **erase_bone** **(** :ref:`int<class_int>` index **)**
 
+Removes the specified bone from this ``Polygon2D``.
+
 ----
 
 .. _class_Polygon2D_method_get_bone_count:
 
 - :ref:`int<class_int>` **get_bone_count** **(** **)** const
 
+Returns the number of bones in this ``Polygon2D``.
+
 ----
 
 .. _class_Polygon2D_method_get_bone_path:
 
 - :ref:`NodePath<class_NodePath>` **get_bone_path** **(** :ref:`int<class_int>` index **)** const
 
+Returns the path to the node associated with the specified bone.
+
 ----
 
 .. _class_Polygon2D_method_get_bone_weights:
 
 - :ref:`PoolRealArray<class_PoolRealArray>` **get_bone_weights** **(** :ref:`int<class_int>` index **)** const
 
+Returns the height values of the specified bone.
+
 ----
 
 .. _class_Polygon2D_method_set_bone_path:
 
 - void **set_bone_path** **(** :ref:`int<class_int>` index, :ref:`NodePath<class_NodePath>` path **)**
 
+Sets the path to the node associated with the specified bone.
+
 ----
 
 .. _class_Polygon2D_method_set_bone_weights:
 
 - void **set_bone_weights** **(** :ref:`int<class_int>` index, :ref:`PoolRealArray<class_PoolRealArray>` weights **)**
 
+Sets the weight values for the specified bone.
+

classes/class_projectsettings.rst

@@ -3639,7 +3639,9 @@ Enables :ref:`Viewport.physics_object_picking<class_Viewport_property_physics_ob
 | *Default* | ``60`` |
 +-----------+--------+
 
-Frames per second used in the physics. Physics always needs a fixed amount of frames per second.
+The number of fixed iterations per second. This controls how often physics simulation and :ref:`Node._physics_process<class_Node_method__physics_process>` methods are run.
+
+**Note:** This property is only read when the project starts. To change the physics FPS at runtime, set :ref:`Engine.iterations_per_second<class_Engine_property_iterations_per_second>` instead.
 
 ----
 
@@ -3653,6 +3655,8 @@ Frames per second used in the physics. Physics always needs a fixed amount of fr
 
 Fix to improve physics jitter, specially on monitors where refresh rate is different than the physics FPS.
 
+**Note:** This property is only read when the project starts. To change the physics FPS at runtime, set :ref:`Engine.physics_jitter_fix<class_Engine_property_physics_jitter_fix>` instead.
+
 ----
 
 .. _class_ProjectSettings_property_rendering/environment/default_clear_color:

classes/class_rect2.rst

@@ -60,7 +60,7 @@ Methods
 +---------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`bool<class_bool>`   | :ref:`has_point<class_Rect2_method_has_point>` **(** :ref:`Vector2<class_Vector2>` point **)**                                                                                                           |
 +---------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`bool<class_bool>`   | :ref:`intersects<class_Rect2_method_intersects>` **(** :ref:`Rect2<class_Rect2>` b **)**                                                                                                                 |
+| :ref:`bool<class_bool>`   | :ref:`intersects<class_Rect2_method_intersects>` **(** :ref:`Rect2<class_Rect2>` b, :ref:`bool<class_bool>` include_borders=false **)**                                                                  |
 +---------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`bool<class_bool>`   | :ref:`is_equal_approx<class_Rect2_method_is_equal_approx>` **(** :ref:`Rect2<class_Rect2>` rect **)**                                                                                                    |
 +---------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -203,9 +203,11 @@ Returns ``true`` if the ``Rect2`` contains a point.
 
 .. _class_Rect2_method_intersects:
 
-- :ref:`bool<class_bool>` **intersects** **(** :ref:`Rect2<class_Rect2>` b **)**
+- :ref:`bool<class_bool>` **intersects** **(** :ref:`Rect2<class_Rect2>` b, :ref:`bool<class_bool>` include_borders=false **)**
 
-Returns ``true`` if the ``Rect2`` overlaps with another.
+Returns ``true`` if the ``Rect2`` overlaps with ``b`` (i.e. they have at least one point in common).
+
+If ``include_borders`` is ``true``, they will also be considered overlapping if their borders touch, even without intersection.
 
 ----
 

classes/class_regex.rst

@@ -25,7 +25,7 @@ To begin, the RegEx object needs to be compiled with the search pattern using :r
     var regex = RegEx.new()
     regex.compile("\\w-(\\d+)")
 
-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 ``"(?:\\.|[^"])*"``.
+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_method_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_method_get_string>` and :ref:`RegExMatch.get_start<class_RegExMatch_method_get_start>`.
 
@@ -58,6 +58,10 @@ If you need to process multiple results, :ref:`search_all<class_RegEx_method_sea
     # Would print 01 03 3f 42
     # Note that d0c would not match
 
+**Note:** Godot's regex implementation is based on the `PCRE2 <https://www.pcre.org/>`_ library. You can view the full pattern reference `here <https://www.pcre.org/current/doc/html/pcre2pattern.html>`_.
+
+**Tip:** You can use `Regexr <https://regexr.com/>`_ to test regular expressions online.
+
 Methods
 -------
 

classes/class_script.rst

@@ -111,30 +111,40 @@ Returns the script's base type.
 
 - :ref:`Variant<class_Variant>` **get_property_default_value** **(** :ref:`String<class_String>` property **)**
 
+Returns the default value of the specified property.
+
 ----
 
 .. _class_Script_method_get_script_constant_map:
 
 - :ref:`Dictionary<class_Dictionary>` **get_script_constant_map** **(** **)**
 
+Returns a dictionary containing constant names and their values.
+
 ----
 
 .. _class_Script_method_get_script_method_list:
 
 - :ref:`Array<class_Array>` **get_script_method_list** **(** **)**
 
+Returns the list of methods in this ``Script``.
+
 ----
 
 .. _class_Script_method_get_script_property_list:
 
 - :ref:`Array<class_Array>` **get_script_property_list** **(** **)**
 
+Returns the list of properties in this ``Script``.
+
 ----
 
 .. _class_Script_method_get_script_signal_list:
 
 - :ref:`Array<class_Array>` **get_script_signal_list** **(** **)**
 
+Returns the list of user signals defined in this ``Script``.
+
 ----
 
 .. _class_Script_method_has_script_signal:

classes/class_scripteditor.rst

@@ -11,7 +11,7 @@ ScriptEditor
 
 **Inherits:** :ref:`PanelContainer<class_PanelContainer>` **<** :ref:`Container<class_Container>` **<** :ref:`Control<class_Control>` **<** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-
+Godot editor's script editor.
 
 Methods
 -------

classes/class_skeleton2d.rst

@@ -13,6 +13,11 @@ Skeleton2D
 
 Skeleton for 2D characters and animated objects.
 
+Description
+-----------
+
+Skeleton2D parents a hierarchy of :ref:`Bone2D<class_Bone2D>` objects. It is a requirement of :ref:`Bone2D<class_Bone2D>`. Skeleton2D holds a reference to the rest pose of its children and acts as a single point of access to its bones.
+
 Tutorials
 ---------
 
@@ -43,13 +48,15 @@ Method Descriptions
 
 - :ref:`Bone2D<class_Bone2D>` **get_bone** **(** :ref:`int<class_int>` idx **)**
 
+Returns a :ref:`Bone2D<class_Bone2D>` from the node hierarchy parented by Skeleton2D. The object to return is identified by the parameter ``idx``. Bones are indexed by descending the node hierarchy from top to bottom, adding the children of each branch before moving to the next sibling.
+
 ----
 
 .. _class_Skeleton2D_method_get_bone_count:
 
 - :ref:`int<class_int>` **get_bone_count** **(** **)** const
 
-Returns the amount of bones in the skeleton.
+Returns the number of :ref:`Bone2D<class_Bone2D>` nodes in the node hierarchy parented by Skeleton2D.
 
 ----
 
@@ -57,3 +64,5 @@ Returns the amount of bones in the skeleton.
 
 - :ref:`RID<class_RID>` **get_skeleton** **(** **)** const
 
+Returns the :ref:`RID<class_RID>` of a Skeleton2D instance.
+

classes/class_skin.rst

@@ -25,12 +25,16 @@ Methods
 +-----------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`int<class_int>`             | :ref:`get_bind_count<class_Skin_method_get_bind_count>` **(** **)** const                                                                  |
 +-----------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`String<class_String>`       | :ref:`get_bind_name<class_Skin_method_get_bind_name>` **(** :ref:`int<class_int>` bind_index **)** const                                   |
++-----------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`Transform<class_Transform>` | :ref:`get_bind_pose<class_Skin_method_get_bind_pose>` **(** :ref:`int<class_int>` bind_index **)** const                                   |
 +-----------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------+
 | void                              | :ref:`set_bind_bone<class_Skin_method_set_bind_bone>` **(** :ref:`int<class_int>` bind_index, :ref:`int<class_int>` bone **)**             |
 +-----------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------+
 | void                              | :ref:`set_bind_count<class_Skin_method_set_bind_count>` **(** :ref:`int<class_int>` bind_count **)**                                       |
 +-----------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------+
+| void                              | :ref:`set_bind_name<class_Skin_method_set_bind_name>` **(** :ref:`int<class_int>` bind_index, :ref:`String<class_String>` name **)**       |
++-----------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------+
 | void                              | :ref:`set_bind_pose<class_Skin_method_set_bind_pose>` **(** :ref:`int<class_int>` bind_index, :ref:`Transform<class_Transform>` pose **)** |
 +-----------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------+
 
@@ -61,6 +65,12 @@ Method Descriptions
 
 ----
 
+.. _class_Skin_method_get_bind_name:
+
+- :ref:`String<class_String>` **get_bind_name** **(** :ref:`int<class_int>` bind_index **)** const
+
+----
+
 .. _class_Skin_method_get_bind_pose:
 
 - :ref:`Transform<class_Transform>` **get_bind_pose** **(** :ref:`int<class_int>` bind_index **)** const
@@ -79,6 +89,12 @@ Method Descriptions
 
 ----
 
+.. _class_Skin_method_set_bind_name:
+
+- void **set_bind_name** **(** :ref:`int<class_int>` bind_index, :ref:`String<class_String>` name **)**
+
+----
+
 .. _class_Skin_method_set_bind_pose:
 
 - void **set_bind_pose** **(** :ref:`int<class_int>` bind_index, :ref:`Transform<class_Transform>` pose **)**

classes/class_spatialmaterial.rst

@@ -1423,7 +1423,7 @@ If ``true``, triplanar mapping is calculated in world space rather than object l
 | *Getter*  | get_metallic()      |
 +-----------+---------------------+
 
-The reflectivity of the object's surface. The higher the value, the more light is reflected.
+A high value makes the material appear more like a metal. Non-metals use their albedo as the diffuse color and add diffuse to the specular reflection. With non-metals, the reflection appears on top of the albedo color. Metals use their albedo as a multiplier to the specular reflection and set the diffuse color to black resulting in a tinted reflection. Materials work better when fully metal or fully non-metal, values between ``0`` and ``1`` should only be used for blending between metal and non-metal sections. To alter the amount of reflection use :ref:`roughness<class_SpatialMaterial_property_roughness>`.
 
 ----
 

classes/class_springarm.rst

@@ -128,7 +128,7 @@ Method Descriptions
 
 - void **add_excluded_object** **(** :ref:`RID<class_RID>` RID **)**
 
-Adds the object with the given :ref:`RID<class_RID>` to the list of objects excluded from the collision check.
+Adds the :ref:`PhysicsBody<class_PhysicsBody>` object with the given :ref:`RID<class_RID>` to the list of :ref:`PhysicsBody<class_PhysicsBody>` objects excluded from the collision check.
 
 ----
 
@@ -136,7 +136,7 @@ Adds the object with the given :ref:`RID<class_RID>` to the list of objects excl
 
 - void **clear_excluded_objects** **(** **)**
 
-Clears the list of objects excluded from the collision check.
+Clears the list of :ref:`PhysicsBody<class_PhysicsBody>` objects excluded from the collision check.
 
 ----
 
@@ -152,5 +152,5 @@ Returns the proportion between the current arm length (after checking for collis
 
 - :ref:`bool<class_bool>` **remove_excluded_object** **(** :ref:`RID<class_RID>` RID **)**
 
-Removes the given :ref:`RID<class_RID>` from the list of objects excluded from the collision check.
+Removes the given :ref:`RID<class_RID>` from the list of :ref:`PhysicsBody<class_PhysicsBody>` objects excluded from the collision check.
 

classes/class_spritebase3d.rst

@@ -323,15 +323,21 @@ Method Descriptions
 
 - :ref:`bool<class_bool>` **get_draw_flag** **(** :ref:`DrawFlags<enum_SpriteBase3D_DrawFlags>` flag **)** const
 
+Returns the value of the specified flag.
+
 ----
 
 .. _class_SpriteBase3D_method_get_item_rect:
 
 - :ref:`Rect2<class_Rect2>` **get_item_rect** **(** **)** const
 
+Returns the rectangle representing this sprite.
+
 ----
 
 .. _class_SpriteBase3D_method_set_draw_flag:
 
 - void **set_draw_flag** **(** :ref:`DrawFlags<enum_SpriteBase3D_DrawFlags>` flag, :ref:`bool<class_bool>` enabled **)**
 
+If ``true``, the specified flag will be enabled.
+

classes/class_streampeerssl.rst

@@ -64,11 +64,11 @@ enum **Status**:
 
 - **STATUS_DISCONNECTED** = **0** --- A status representing a ``StreamPeerSSL`` that is disconnected.
 
-- **STATUS_HANDSHAKING** = **1**
+- **STATUS_HANDSHAKING** = **1** --- A status representing a ``StreamPeerSSL`` during handshaking.
 
 - **STATUS_CONNECTED** = **2** --- A status representing a ``StreamPeerSSL`` that is connected to a host.
 
-- **STATUS_ERROR** = **3**
+- **STATUS_ERROR** = **3** --- A status representing a ``StreamPeerSSL`` in error state.
 
 - **STATUS_ERROR_HOSTNAME_MISMATCH** = **4** --- An error status that shows a mismatch in the SSL certificate domain presented by the host and the domain requested for validation.
 

classes/class_streamtexture.rst

@@ -58,3 +58,5 @@ Method Descriptions
 
 - :ref:`Error<enum_@GlobalScope_Error>` **load** **(** :ref:`String<class_String>` path **)**
 
+Loads the texture from the given path.
+

classes/class_string.rst

@@ -103,7 +103,7 @@ Methods
 +-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`int<class_int>`                         | :ref:`findn<class_String_method_findn>` **(** :ref:`String<class_String>` what, :ref:`int<class_int>` from=0 **)**                                                      |
 +-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`String<class_String>`                   | :ref:`format<class_String_method_format>` **(** :ref:`Variant<class_Variant>` values, :ref:`String<class_String>` placeholder={_} **)**                                 |
+| :ref:`String<class_String>`                   | :ref:`format<class_String_method_format>` **(** :ref:`Variant<class_Variant>` values, :ref:`String<class_String>` placeholder="{_}" **)**                               |
 +-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`String<class_String>`                   | :ref:`get_base_dir<class_String_method_get_base_dir>` **(** **)**                                                                                                       |
 +-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -137,7 +137,7 @@ Methods
 +-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`bool<class_bool>`                       | :ref:`is_valid_float<class_String_method_is_valid_float>` **(** **)**                                                                                                   |
 +-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`bool<class_bool>`                       | :ref:`is_valid_hex_number<class_String_method_is_valid_hex_number>` **(** :ref:`bool<class_bool>` with_prefix=False **)**                                               |
+| :ref:`bool<class_bool>`                       | :ref:`is_valid_hex_number<class_String_method_is_valid_hex_number>` **(** :ref:`bool<class_bool>` with_prefix=false **)**                                               |
 +-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`bool<class_bool>`                       | :ref:`is_valid_html_color<class_String_method_is_valid_html_color>` **(** **)**                                                                                         |
 +-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -189,7 +189,7 @@ Methods
 +-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`String<class_String>`                   | :ref:`right<class_String_method_right>` **(** :ref:`int<class_int>` position **)**                                                                                      |
 +-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`PoolStringArray<class_PoolStringArray>` | :ref:`rsplit<class_String_method_rsplit>` **(** :ref:`String<class_String>` delimiter, :ref:`bool<class_bool>` allow_empty=True, :ref:`int<class_int>` maxsplit=0 **)** |
+| :ref:`PoolStringArray<class_PoolStringArray>` | :ref:`rsplit<class_String_method_rsplit>` **(** :ref:`String<class_String>` delimiter, :ref:`bool<class_bool>` allow_empty=true, :ref:`int<class_int>` maxsplit=0 **)** |
 +-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`String<class_String>`                   | :ref:`rstrip<class_String_method_rstrip>` **(** :ref:`String<class_String>` chars **)**                                                                                 |
 +-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -203,11 +203,11 @@ Methods
 +-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`float<class_float>`                     | :ref:`similarity<class_String_method_similarity>` **(** :ref:`String<class_String>` text **)**                                                                          |
 +-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`PoolStringArray<class_PoolStringArray>` | :ref:`split<class_String_method_split>` **(** :ref:`String<class_String>` delimiter, :ref:`bool<class_bool>` allow_empty=True, :ref:`int<class_int>` maxsplit=0 **)**   |
+| :ref:`PoolStringArray<class_PoolStringArray>` | :ref:`split<class_String_method_split>` **(** :ref:`String<class_String>` delimiter, :ref:`bool<class_bool>` allow_empty=true, :ref:`int<class_int>` maxsplit=0 **)**   |
 +-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`PoolRealArray<class_PoolRealArray>`     | :ref:`split_floats<class_String_method_split_floats>` **(** :ref:`String<class_String>` delimiter, :ref:`bool<class_bool>` allow_empty=True **)**                       |
+| :ref:`PoolRealArray<class_PoolRealArray>`     | :ref:`split_floats<class_String_method_split_floats>` **(** :ref:`String<class_String>` delimiter, :ref:`bool<class_bool>` allow_empty=true **)**                       |
 +-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| :ref:`String<class_String>`                   | :ref:`strip_edges<class_String_method_strip_edges>` **(** :ref:`bool<class_bool>` left=True, :ref:`bool<class_bool>` right=True **)**                                   |
+| :ref:`String<class_String>`                   | :ref:`strip_edges<class_String_method_strip_edges>` **(** :ref:`bool<class_bool>` left=true, :ref:`bool<class_bool>` right=true **)**                                   |
 +-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`String<class_String>`                   | :ref:`strip_escapes<class_String_method_strip_escapes>` **(** **)**                                                                                                     |
 +-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -505,7 +505,7 @@ Finds the first occurrence of a substring, ignoring case. Returns the starting p
 
 .. _class_String_method_format:
 
-- :ref:`String<class_String>` **format** **(** :ref:`Variant<class_Variant>` values, :ref:`String<class_String>` placeholder={_} **)**
+- :ref:`String<class_String>` **format** **(** :ref:`Variant<class_Variant>` values, :ref:`String<class_String>` placeholder="{_}" **)**
 
 Formats the string by replacing all occurrences of ``placeholder`` with ``values``.
 
@@ -661,7 +661,7 @@ Returns ``true`` if this string contains a valid float.
 
 .. _class_String_method_is_valid_hex_number:
 
-- :ref:`bool<class_bool>` **is_valid_hex_number** **(** :ref:`bool<class_bool>` with_prefix=False **)**
+- :ref:`bool<class_bool>` **is_valid_hex_number** **(** :ref:`bool<class_bool>` with_prefix=false **)**
 
 Returns ``true`` if this string contains a valid hexadecimal number. If ``with_prefix`` is ``true``, then a validity of the hexadecimal number is determined by ``0x`` prefix, for instance: ``0xDEADC0DE``.
 
@@ -869,7 +869,7 @@ Returns the right side of the string from a given position.
 
 .. _class_String_method_rsplit:
 
-- :ref:`PoolStringArray<class_PoolStringArray>` **rsplit** **(** :ref:`String<class_String>` delimiter, :ref:`bool<class_bool>` allow_empty=True, :ref:`int<class_int>` maxsplit=0 **)**
+- :ref:`PoolStringArray<class_PoolStringArray>` **rsplit** **(** :ref:`String<class_String>` delimiter, :ref:`bool<class_bool>` allow_empty=true, :ref:`int<class_int>` maxsplit=0 **)**
 
 Splits the string by a ``delimiter`` string and returns an array of the substrings, starting from right.
 
@@ -939,7 +939,7 @@ Returns the similarity index of the text compared to this string. 1 means totall
 
 .. _class_String_method_split:
 
-- :ref:`PoolStringArray<class_PoolStringArray>` **split** **(** :ref:`String<class_String>` delimiter, :ref:`bool<class_bool>` allow_empty=True, :ref:`int<class_int>` maxsplit=0 **)**
+- :ref:`PoolStringArray<class_PoolStringArray>` **split** **(** :ref:`String<class_String>` delimiter, :ref:`bool<class_bool>` allow_empty=true, :ref:`int<class_int>` maxsplit=0 **)**
 
 Splits the string by a ``delimiter`` string and returns an array of the substrings.
 
@@ -959,7 +959,7 @@ Example:
 
 .. _class_String_method_split_floats:
 
-- :ref:`PoolRealArray<class_PoolRealArray>` **split_floats** **(** :ref:`String<class_String>` delimiter, :ref:`bool<class_bool>` allow_empty=True **)**
+- :ref:`PoolRealArray<class_PoolRealArray>` **split_floats** **(** :ref:`String<class_String>` delimiter, :ref:`bool<class_bool>` allow_empty=true **)**
 
 Splits the string in floats by using a delimiter string and returns an array of the substrings.
 
@@ -969,7 +969,7 @@ For example, ``"1,2.5,3"`` will return ``[1,2.5,3]`` if split by ``","``.
 
 .. _class_String_method_strip_edges:
 
-- :ref:`String<class_String>` **strip_edges** **(** :ref:`bool<class_bool>` left=True, :ref:`bool<class_bool>` right=True **)**
+- :ref:`String<class_String>` **strip_edges** **(** :ref:`bool<class_bool>` left=true, :ref:`bool<class_bool>` right=true **)**
 
 Returns a copy of the string stripped of any non-printable character (including tabulations, spaces and line breaks) at the beginning and the end. The optional arguments are used to toggle stripping on the left and right edges respectively.
 

classes/class_texturelayered.rst

@@ -18,7 +18,7 @@ Base class for 3D texture types.
 Description
 -----------
 
-Base class for :ref:`Texture3D<class_Texture3D>` and :ref:`TextureArray<class_TextureArray>`. Cannot be used directly.
+Base class for :ref:`Texture3D<class_Texture3D>` and :ref:`TextureArray<class_TextureArray>`. Cannot be used directly, but contains all the functions necessary for accessing and using :ref:`Texture3D<class_Texture3D>` and :ref:`TextureArray<class_TextureArray>`. Data is set on a per-layer basis. For :ref:`Texture3D<class_Texture3D>`\ s, the layer sepcifies the depth or Z-index, they can be treated as a bunch of 2D slices. Similarly, for :ref:`TextureArray<class_TextureArray>`\ s, the layer specifies the array layer.
 
 Properties
 ----------
@@ -65,13 +65,13 @@ Enumerations
 
 enum **Flags**:
 
-- **FLAG_MIPMAPS** = **1**
+- **FLAG_MIPMAPS** = **1** --- Texture will generate mipmaps on creation.
 
-- **FLAG_REPEAT** = **2**
+- **FLAG_REPEAT** = **2** --- Texture will repeat when UV used is outside the 0-1 range.
 
-- **FLAG_FILTER** = **4**
+- **FLAG_FILTER** = **4** --- Use filtering when reading from texture. Filtering smooths out pixels. Turning filtering off is slightly faster and more appropriate when you need access to individual pixels.
 
-- **FLAGS_DEFAULT** = **4**
+- **FLAGS_DEFAULT** = **4** --- Equivalent to :ref:`FLAG_FILTER<class_TextureLayered_constant_FLAG_FILTER>`.
 
 Property Descriptions
 ---------------------
@@ -84,6 +84,8 @@ Property Descriptions
 | *Default* | ``{"depth": 0,"flags": 4,"format": 37,"height": 0,"layers": [  ],"width": 0}`` |
 +-----------+--------------------------------------------------------------------------------+
 
+Returns a dictionary with all the data used by this texture.
+
 ----
 
 .. _class_TextureLayered_property_flags:
@@ -98,6 +100,8 @@ Property Descriptions
 | *Getter*  | get_flags()      |
 +-----------+------------------+
 
+Specifies which :ref:`Flags<enum_TextureLayered_Flags>` apply to this texture.
+
 Method Descriptions
 -------------------
 
@@ -105,45 +109,61 @@ Method Descriptions
 
 - void **create** **(** :ref:`int<class_int>` width, :ref:`int<class_int>` height, :ref:`int<class_int>` depth, :ref:`Format<enum_Image_Format>` format, :ref:`int<class_int>` flags=4 **)**
 
+Creates the :ref:`Texture3D<class_Texture3D>` or :ref:`TextureArray<class_TextureArray>` with specified ``width``, ``height``, and ``depth``. See :ref:`Format<enum_Image_Format>` for ``format`` options. See :ref:`Flags<enum_TextureLayered_Flags>` enumerator for ``flags`` options.
+
 ----
 
 .. _class_TextureLayered_method_get_depth:
 
 - :ref:`int<class_int>` **get_depth** **(** **)** const
 
+Returns the depth of the texture. Depth is the 3rd dimension (typically Z-axis).
+
 ----
 
 .. _class_TextureLayered_method_get_format:
 
 - :ref:`Format<enum_Image_Format>` **get_format** **(** **)** const
 
+Returns the current format being used by this texture. See :ref:`Format<enum_Image_Format>` for details.
+
 ----
 
 .. _class_TextureLayered_method_get_height:
 
 - :ref:`int<class_int>` **get_height** **(** **)** const
 
+Returns the height of the texture. Height is typically represented by the Y-axis.
+
 ----
 
 .. _class_TextureLayered_method_get_layer_data:
 
 - :ref:`Image<class_Image>` **get_layer_data** **(** :ref:`int<class_int>` layer **)** const
 
+Returns an :ref:`Image<class_Image>` resource with the data from specified ``layer``.
+
 ----
 
 .. _class_TextureLayered_method_get_width:
 
 - :ref:`int<class_int>` **get_width** **(** **)** const
 
+Returns the width of the texture. Width is typically represented by the X-axis.
+
 ----
 
 .. _class_TextureLayered_method_set_data_partial:
 
 - void **set_data_partial** **(** :ref:`Image<class_Image>` image, :ref:`int<class_int>` x_offset, :ref:`int<class_int>` y_offset, :ref:`int<class_int>` layer, :ref:`int<class_int>` mipmap=0 **)**
 
+Partially sets the data for a specified ``layer`` by overwriting using the data of the specified ``image``. ``x_offset`` and ``y_offset`` determine where the :ref:`Image<class_Image>` is "stamped" over the texture. The ``image`` must fit within the texture.
+
 ----
 
 .. _class_TextureLayered_method_set_layer_data:
 
 - void **set_layer_data** **(** :ref:`Image<class_Image>` image, :ref:`int<class_int>` layer **)**
 
+Sets the data for the specified layer. Data takes the form of a 2-dimensional :ref:`Image<class_Image>` resource.
+

classes/class_tree.rst

@@ -127,8 +127,6 @@ Theme Properties
 +---------------------------------+------------------------------+------------------------------+
 | :ref:`StyleBox<class_StyleBox>` | cursor                       |                              |
 +---------------------------------+------------------------------+------------------------------+
-| :ref:`Color<class_Color>`       | cursor_color                 | Color( 0, 0, 0, 1 )          |
-+---------------------------------+------------------------------+------------------------------+
 | :ref:`StyleBox<class_StyleBox>` | cursor_unfocused             |                              |
 +---------------------------------+------------------------------+------------------------------+
 | :ref:`StyleBox<class_StyleBox>` | custom_button                |                              |
@@ -169,8 +167,6 @@ Theme Properties
 +---------------------------------+------------------------------+------------------------------+
 | :ref:`StyleBox<class_StyleBox>` | selected_focus               |                              |
 +---------------------------------+------------------------------+------------------------------+
-| :ref:`Color<class_Color>`       | selection_color              | Color( 0.1, 0.1, 1, 0.8 )    |
-+---------------------------------+------------------------------+------------------------------+
 | :ref:`Color<class_Color>`       | title_button_color           | Color( 0.88, 0.88, 0.88, 1 ) |
 +---------------------------------+------------------------------+------------------------------+
 | :ref:`Font<class_Font>`         | title_button_font            |                              |
@@ -259,6 +255,8 @@ Emitted when an item is collapsed by a click on the folding arrow.
 
 - **item_custom_button_pressed** **(** **)**
 
+Emitted when a custom button is pressed (i.e. in a :ref:`TreeItem.CELL_MODE_CUSTOM<class_TreeItem_constant_CELL_MODE_CUSTOM>` mode cell).
+
 ----
 
 .. _class_Tree_signal_item_double_clicked:

classes/class_tween.rst

@@ -18,6 +18,8 @@ Description
 
 Tweens are useful for animations requiring a numerical property to be interpolated over a range of values. The name *tween* comes from *in-betweening*, an animation technique where you specify *keyframes* and the computer interpolates the frames that appear between them.
 
+``Tween`` is more suited than :ref:`AnimationPlayer<class_AnimationPlayer>` for animations where you don't know the final values in advance. For example, interpolating a dynamically-chosen camera zoom value is best done with a ``Tween`` node; it would be difficult to do the same thing with an :ref:`AnimationPlayer<class_AnimationPlayer>` node.
+
 Here is a brief usage example that causes a 2D node to move smoothly between two positions:
 
 ::

classes/class_upnp.rst

@@ -262,7 +262,7 @@ Adds a mapping to forward the external ``port`` (between 1 and 65535) on the def
 
 If ``internal_port`` is ``0`` (the default), the same port number is used for both the external and the internal port (the ``port`` value).
 
-The description (``desc``) is shown in some router UIs and can be used to point out which application added the mapping, and the lifetime of the mapping can be limited by ``duration``. However, some routers are incompatible with one or both of these, so use with caution and add fallback logic in case of errors to retry without them if in doubt.
+The description (``desc``) is shown in some router UIs and can be used to point out which application added the mapping. The mapping's lease duration can be limited by specifying a ``duration`` (in seconds). However, some routers are incompatible with one or both of these, so use with caution and add fallback logic in case of errors to retry without them if in doubt.
 
 See :ref:`UPNPResult<enum_UPNP_UPNPResult>` for possible return values.
 

classes/class_visualshader.rst

@@ -77,11 +77,11 @@ Enumerations
 
 enum **Type**:
 
-- **TYPE_VERTEX** = **0**
+- **TYPE_VERTEX** = **0** --- A vertex shader, operating on vertices.
 
-- **TYPE_FRAGMENT** = **1**
+- **TYPE_FRAGMENT** = **1** --- A fragment shader, operating on fragments (pixels).
 
-- **TYPE_LIGHT** = **2**
+- **TYPE_LIGHT** = **2** --- A shader for light calculations.
 
 - **TYPE_MAX** = **3** --- Represents the size of the :ref:`Type<enum_VisualShader_Type>` enum.
 
@@ -111,6 +111,8 @@ Property Descriptions
 | *Getter*  | get_graph_offset()      |
 +-----------+-------------------------+
 
+The offset vector of the whole graph.
+
 Method Descriptions
 -------------------
 
@@ -118,54 +120,72 @@ Method Descriptions
 
 - void **add_node** **(** :ref:`Type<enum_VisualShader_Type>` type, :ref:`VisualShaderNode<class_VisualShaderNode>` node, :ref:`Vector2<class_Vector2>` position, :ref:`int<class_int>` id **)**
 
+Adds the specified node to the shader.
+
 ----
 
 .. _class_VisualShader_method_can_connect_nodes:
 
 - :ref:`bool<class_bool>` **can_connect_nodes** **(** :ref:`Type<enum_VisualShader_Type>` type, :ref:`int<class_int>` from_node, :ref:`int<class_int>` from_port, :ref:`int<class_int>` to_node, :ref:`int<class_int>` to_port **)** const
 
+Returns ``true`` if the specified nodes and ports can be connected together.
+
 ----
 
 .. _class_VisualShader_method_connect_nodes:
 
 - :ref:`Error<enum_@GlobalScope_Error>` **connect_nodes** **(** :ref:`Type<enum_VisualShader_Type>` type, :ref:`int<class_int>` from_node, :ref:`int<class_int>` from_port, :ref:`int<class_int>` to_node, :ref:`int<class_int>` to_port **)**
 
+Connects the specified nodes and ports.
+
 ----
 
 .. _class_VisualShader_method_connect_nodes_forced:
 
 - void **connect_nodes_forced** **(** :ref:`Type<enum_VisualShader_Type>` type, :ref:`int<class_int>` from_node, :ref:`int<class_int>` from_port, :ref:`int<class_int>` to_node, :ref:`int<class_int>` to_port **)**
 
+Connects the specified nodes and ports, even if they can't be connected. Such connection is invalid and will not function properly.
+
 ----
 
 .. _class_VisualShader_method_disconnect_nodes:
 
 - void **disconnect_nodes** **(** :ref:`Type<enum_VisualShader_Type>` type, :ref:`int<class_int>` from_node, :ref:`int<class_int>` from_port, :ref:`int<class_int>` to_node, :ref:`int<class_int>` to_port **)**
 
+Connects the specified nodes and ports.
+
 ----
 
 .. _class_VisualShader_method_get_node:
 
 - :ref:`VisualShaderNode<class_VisualShaderNode>` **get_node** **(** :ref:`Type<enum_VisualShader_Type>` type, :ref:`int<class_int>` id **)** const
 
+Returns the shader node instance with specified ``type`` and ``id``.
+
 ----
 
 .. _class_VisualShader_method_get_node_connections:
 
 - :ref:`Array<class_Array>` **get_node_connections** **(** :ref:`Type<enum_VisualShader_Type>` type **)** const
 
+Returns the list of connected nodes with the specified type.
+
 ----
 
 .. _class_VisualShader_method_get_node_list:
 
 - :ref:`PoolIntArray<class_PoolIntArray>` **get_node_list** **(** :ref:`Type<enum_VisualShader_Type>` type **)** const
 
+Returns the list of all nodes in the shader with the specified type.
+
 ----
 
 .. _class_VisualShader_method_get_node_position:
 
 - :ref:`Vector2<class_Vector2>` **get_node_position** **(** :ref:`Type<enum_VisualShader_Type>` type, :ref:`int<class_int>` id **)** const
 
+Returns the position of the specified node within the shader graph.
+
 ----
 
 .. _class_VisualShader_method_get_valid_node_id:
@@ -178,21 +198,29 @@ Method Descriptions
 
 - :ref:`bool<class_bool>` **is_node_connection** **(** :ref:`Type<enum_VisualShader_Type>` type, :ref:`int<class_int>` from_node, :ref:`int<class_int>` from_port, :ref:`int<class_int>` to_node, :ref:`int<class_int>` to_port **)** const
 
+Returns ``true`` if the specified node and port connection exist.
+
 ----
 
 .. _class_VisualShader_method_remove_node:
 
 - void **remove_node** **(** :ref:`Type<enum_VisualShader_Type>` type, :ref:`int<class_int>` id **)**
 
+Removes the specified node from the shader.
+
 ----
 
 .. _class_VisualShader_method_set_mode:
 
 - void **set_mode** **(** :ref:`Mode<enum_Shader_Mode>` mode **)**
 
+Sets the mode of this shader.
+
 ----
 
 .. _class_VisualShader_method_set_node_position:
 
 - void **set_node_position** **(** :ref:`Type<enum_VisualShader_Type>` type, :ref:`int<class_int>` id, :ref:`Vector2<class_Vector2>` position **)**
 
+Sets the position of the specified node.
+