classref: Sync with current master branch (6543495)

classes/[email protected]

@@ -5416,7 +5416,7 @@ Decodes a byte array back to a :ref:`Variant<class_Variant>` value. Decoding obj
 
 :ref:`Variant<class_Variant>` **ceil** **(** :ref:`Variant<class_Variant>` x **)**
 
-Rounds ``x`` upward (towards positive infinity), returning the smallest whole number that is not less than ``x``. Supported types: :ref:`int<class_int>`, :ref:`float<class_float>`, :ref:`Vector2<class_Vector2>`, :ref:`Vector3<class_Vector3>`, :ref:`Vector4<class_Vector4>`.
+Rounds ``x`` upward (towards positive infinity), returning the smallest whole number that is not less than ``x``. Supported types: :ref:`int<class_int>`, :ref:`float<class_float>`, :ref:`Vector2<class_Vector2>`, :ref:`Vector2i<class_Vector2i>`, :ref:`Vector3<class_Vector3>`, :ref:`Vector3i<class_Vector3i>`, :ref:`Vector4<class_Vector4>`, :ref:`Vector4i<class_Vector4i>`.
 
 ::
 
@@ -5718,7 +5718,7 @@ For exponents to other bases use the method :ref:`pow<class_@GlobalScope_method_
 
 :ref:`Variant<class_Variant>` **floor** **(** :ref:`Variant<class_Variant>` x **)**
 
-Rounds ``x`` downward (towards negative infinity), returning the largest whole number that is not more than ``x``. Supported types: :ref:`int<class_int>`, :ref:`float<class_float>`, :ref:`Vector2<class_Vector2>`, :ref:`Vector3<class_Vector3>`, :ref:`Vector4<class_Vector4>`.
+Rounds ``x`` downward (towards negative infinity), returning the largest whole number that is not more than ``x``. Supported types: :ref:`int<class_int>`, :ref:`float<class_float>`, :ref:`Vector2<class_Vector2>`, :ref:`Vector2i<class_Vector2i>`, :ref:`Vector3<class_Vector3>`, :ref:`Vector3i<class_Vector3i>`, :ref:`Vector4<class_Vector4>`, :ref:`Vector4i<class_Vector4i>`.
 
 ::
 
@@ -6825,7 +6825,7 @@ If ``delta`` is negative, this function will rotate away from ``to``, toward the
 
 :ref:`Variant<class_Variant>` **round** **(** :ref:`Variant<class_Variant>` x **)**
 
-Rounds ``x`` to the nearest whole number, with halfway cases rounded away from 0. Supported types: :ref:`int<class_int>`, :ref:`float<class_float>`, :ref:`Vector2<class_Vector2>`, :ref:`Vector3<class_Vector3>`, :ref:`Vector4<class_Vector4>`.
+Rounds ``x`` to the nearest whole number, with halfway cases rounded away from 0. Supported types: :ref:`int<class_int>`, :ref:`float<class_float>`, :ref:`Vector2<class_Vector2>`, :ref:`Vector2i<class_Vector2i>`, :ref:`Vector3<class_Vector3>`, :ref:`Vector3i<class_Vector3i>`, :ref:`Vector4<class_Vector4>`, :ref:`Vector4i<class_Vector4i>`.
 
 ::
 

classes/class_aabb.rst

@@ -585,7 +585,11 @@ Returns ``true`` if the AABBs are not equal.
 
 :ref:`AABB<class_AABB>` **operator *** **(** :ref:`Transform3D<class_Transform3D>` right **)**
 
-Inversely transforms (multiplies) the **AABB** by the given :ref:`Transform3D<class_Transform3D>` transformation matrix.
+Inversely transforms (multiplies) the **AABB** by the given :ref:`Transform3D<class_Transform3D>` transformation matrix, under the assumption that the transformation basis is orthonormal (i.e. rotation/reflection is fine, scaling/skew is not).
+
+\ ``aabb * transform`` is equivalent to ``transform.inverse() * aabb``. See :ref:`Transform3D.inverse<class_Transform3D_method_inverse>`.
+
+For transforming by inverse of an affine transformation (e.g. with scaling) ``transform.affine_inverse() * aabb`` can be used instead. See :ref:`Transform3D.affine_inverse<class_Transform3D_method_affine_inverse>`.
 
 .. rst-class:: classref-item-separator
 

classes/class_button.rst

@@ -598,9 +598,7 @@ Font size of the **Button**'s text.
 
 :ref:`Texture2D<class_Texture2D>` **icon**
 
-.. container:: contribute
-
-	There is currently no description for this theme property. Please help us by :ref:`contributing one <doc_updating_the_class_reference>`!
+Default icon for the **Button**. Appears only if :ref:`icon<class_Button_property_icon>` is not assigned.
 
 .. rst-class:: classref-item-separator
 

classes/class_graphedit.rst

@@ -1100,7 +1100,7 @@ Disallows to disconnect nodes when dragging from the right port of the :ref:`Gra
 
 void **set_connection_activity** **(** :ref:`StringName<class_StringName>` from_node, :ref:`int<class_int>` from_port, :ref:`StringName<class_StringName>` to_node, :ref:`int<class_int>` to_port, :ref:`float<class_float>` amount **)**
 
-Sets the coloration of the connection between ``from_node``'s ``from_port`` and ``to_node``'s ``to_port`` with the color provided in the :ref:`activity<class_GraphEdit_theme_color_activity>` theme property.
+Sets the coloration of the connection between ``from_node``'s ``from_port`` and ``to_node``'s ``to_port`` with the color provided in the :ref:`activity<class_GraphEdit_theme_color_activity>` theme property. The color is linearly interpolated between the connection color and the activity color using ``amount`` as weight.
 
 .. rst-class:: classref-item-separator
 
@@ -1129,9 +1129,7 @@ Theme Property Descriptions
 
 :ref:`Color<class_Color>` **activity** = ``Color(1, 1, 1, 1)``
 
-.. container:: contribute
-
-	There is currently no description for this theme property. Please help us by :ref:`contributing one <doc_updating_the_class_reference>`!
+Color of the connection's activity (see :ref:`set_connection_activity<class_GraphEdit_method_set_connection_activity>`).
 
 .. rst-class:: classref-item-separator
 

classes/class_lineedit.rst

@@ -998,7 +998,7 @@ If ``true``, every character is replaced with the secret character (see :ref:`se
 - void **set_secret_character** **(** :ref:`String<class_String>` value **)**
 - :ref:`String<class_String>` **get_secret_character** **(** **)**
 
-The character to use to mask secret input (defaults to "•"). Only a single character can be used as the secret character.
+The character to use to mask secret input. Only a single character can be used as the secret character. If it is longer than one character, only the first one will be used. If it is empty, a space will be used instead.
 
 .. rst-class:: classref-item-separator
 

classes/class_object.rst

@@ -21,7 +21,7 @@ Description
 
 An advanced :ref:`Variant<class_Variant>` type. All classes in the engine inherit from Object. Each class may define new properties, methods or signals, which are available to all inheriting classes. For example, a :ref:`Sprite2D<class_Sprite2D>` instance is able to call :ref:`Node.add_child<class_Node_method_add_child>` because it inherits from :ref:`Node<class_Node>`.
 
-You can create new instances, using ``Object.new()`` in GDScript, or ``new Object`` in C#.
+You can create new instances, using ``Object.new()`` in GDScript, or ``new GodotObject`` in C#.
 
 To delete an Object instance, call :ref:`free<class_Object_method_free>`. This is necessary for most classes inheriting Object, because they do not manage memory on their own, and will otherwise cause memory leaks when no longer in use. There are a few classes that perform memory management. For example, :ref:`RefCounted<class_RefCounted>` (and by extension :ref:`Resource<class_Resource>`) deletes itself when no longer referenced, and :ref:`Node<class_Node>` deletes its children when freed.
 
@@ -449,7 +449,7 @@ The example below displays ``hammer_type`` in the Inspector dock, only if ``hold
 
 void **_init** **(** **)** |virtual|
 
-Called when the object's script is instantiated, oftentimes after the object is initialized in memory (through ``Object.new()`` in GDScript, or ``new Object`` in C#). It can be also defined to take in parameters. This method is similar to a constructor in most programming languages.
+Called when the object's script is instantiated, oftentimes after the object is initialized in memory (through ``Object.new()`` in GDScript, or ``new GodotObject`` in C#). It can be also defined to take in parameters. This method is similar to a constructor in most programming languages.
 
 \ **Note:** If :ref:`_init<class_Object_method__init>` is defined with *required* parameters, the Object with script may only be created directly. If any other means (such as :ref:`PackedScene.instantiate<class_PackedScene_method_instantiate>` or :ref:`Node.duplicate<class_Node_method_duplicate>`) are used, the script's initialization will fail.
 
@@ -542,6 +542,7 @@ Combined with :ref:`_get<class_Object_method__get>` and :ref:`_get_property_list
             # Storing the value in the fake property.
             internal_data["fake_property"] = value
             return true
+        return false
     
     func _get_property_list():
         return [
@@ -552,7 +553,7 @@ Combined with :ref:`_get<class_Object_method__get>` and :ref:`_get_property_list
 
     private Godot.Collections.Dictionary _internalData = new Godot.Collections.Dictionary();
     
-    public override void _Set(StringName property, Variant value)
+    public override bool _Set(StringName property, Variant value)
     {
         if (property == "FakeProperty")
         {

classes/class_packedvector2array.rst

@@ -463,7 +463,11 @@ Returns ``true`` if contents of the arrays differ.
 
 :ref:`PackedVector2Array<class_PackedVector2Array>` **operator *** **(** :ref:`Transform2D<class_Transform2D>` right **)**
 
-Transforms (multiplies) all vectors in the array by the :ref:`Transform2D<class_Transform2D>` matrix.
+Returns a new **PackedVector2Array** with all vectors in this array inversely transformed (multiplied) by the given :ref:`Transform2D<class_Transform2D>` transformation matrix, under the assumption that the transformation basis is orthonormal (i.e. rotation/reflection is fine, scaling/skew is not).
+
+\ ``array * transform`` is equivalent to ``transform.inverse() * array``. See :ref:`Transform2D.inverse<class_Transform2D_method_inverse>`.
+
+For transforming by inverse of an affine transformation (e.g. with scaling) ``transform.affine_inverse() * array`` can be used instead. See :ref:`Transform2D.affine_inverse<class_Transform2D_method_affine_inverse>`.
 
 .. rst-class:: classref-item-separator
 

classes/class_packedvector3array.rst

@@ -456,7 +456,11 @@ Returns ``true`` if contents of the arrays differ.
 
 :ref:`PackedVector3Array<class_PackedVector3Array>` **operator *** **(** :ref:`Transform3D<class_Transform3D>` right **)**
 
-Transforms (multiplies) all vectors in the array by the :ref:`Transform3D<class_Transform3D>` matrix.
+Returns a new **PackedVector3Array** with all vectors in this array inversely transformed (multiplied) by the given :ref:`Transform3D<class_Transform3D>` transformation matrix, under the assumption that the transformation basis is orthonormal (i.e. rotation/reflection is fine, scaling/skew is not).
+
+\ ``array * transform`` is equivalent to ``transform.inverse() * array``. See :ref:`Transform3D.inverse<class_Transform3D_method_inverse>`.
+
+For transforming by inverse of an affine transformation (e.g. with scaling) ``transform.affine_inverse() * array`` can be used instead. See :ref:`Transform3D.affine_inverse<class_Transform3D_method_affine_inverse>`.
 
 .. rst-class:: classref-item-separator
 

classes/class_plane.rst

@@ -475,6 +475,8 @@ Returns ``true`` if the planes are not equal.
 
 Inversely transforms (multiplies) the **Plane** by the given :ref:`Transform3D<class_Transform3D>` transformation matrix.
 
+\ ``plane * transform`` is equivalent to ``transform.affine_inverse() * plane``. See :ref:`Transform3D.affine_inverse<class_Transform3D_method_affine_inverse>`.
+
 .. rst-class:: classref-item-separator
 
 ----

classes/class_projectsettings.rst

@@ -129,6 +129,10 @@ Properties
    +---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+
    | :ref:`float<class_float>`                         | :ref:`audio/general/3d_panning_strength<class_ProjectSettings_property_audio/general/3d_panning_strength>`                                                                                                 | ``0.5``                                                                                          |
    +---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+
+   | :ref:`bool<class_bool>`                           | :ref:`audio/general/ios/mix_with_others<class_ProjectSettings_property_audio/general/ios/mix_with_others>`                                                                                                 | ``false``                                                                                        |
+   +---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+
+   | :ref:`int<class_int>`                             | :ref:`audio/general/ios/session_category<class_ProjectSettings_property_audio/general/ios/session_category>`                                                                                               | ``0``                                                                                            |
+   +---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+
    | :ref:`bool<class_bool>`                           | :ref:`audio/general/text_to_speech<class_ProjectSettings_property_audio/general/text_to_speech>`                                                                                                           | ``false``                                                                                        |
    +---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+
    | :ref:`int<class_int>`                             | :ref:`audio/video/video_delay_compensation_ms<class_ProjectSettings_property_audio/video/video_delay_compensation_ms>`                                                                                     | ``0``                                                                                            |
@@ -2184,6 +2188,32 @@ The default value of ``0.5`` is tuned for headphones. When using speakers, you m
 
 ----
 
+.. _class_ProjectSettings_property_audio/general/ios/mix_with_others:
+
+.. rst-class:: classref-property
+
+:ref:`bool<class_bool>` **audio/general/ios/mix_with_others** = ``false``
+
+Sets the `mixWithOthers <https://developer.apple.com/documentation/avfaudio/avaudiosession/categoryoptions/1616611-mixwithothers>`__ option for the AVAudioSession on iOS. This will override the mix behavior, if the category is set to ``Play and Record``, ``Playback``, or ``Multi Route``.
+
+\ ``Ambient`` always has this set per default.
+
+.. rst-class:: classref-item-separator
+
+----
+
+.. _class_ProjectSettings_property_audio/general/ios/session_category:
+
+.. rst-class:: classref-property
+
+:ref:`int<class_int>` **audio/general/ios/session_category** = ``0``
+
+Sets the `AVAudioSessionCategory <https://developer.apple.com/documentation/avfaudio/avaudiosessioncategory>`__ on iOS. Use the ``Playback`` category to get sound output, even if the phone is in silent mode.
+
+.. rst-class:: classref-item-separator
+
+----
+
 .. _class_ProjectSettings_property_audio/general/text_to_speech:
 
 .. rst-class:: classref-property

classes/class_rect2.rst

@@ -520,7 +520,11 @@ Returns ``true`` if the :ref:`position<class_Rect2_property_position>` or :ref:`
 
 :ref:`Rect2<class_Rect2>` **operator *** **(** :ref:`Transform2D<class_Transform2D>` right **)**
 
-Inversely transforms (multiplies) the **Rect2** by the given :ref:`Transform2D<class_Transform2D>` transformation matrix.
+Inversely transforms (multiplies) the **Rect2** by the given :ref:`Transform2D<class_Transform2D>` transformation matrix, under the assumption that the transformation basis is orthonormal (i.e. rotation/reflection is fine, scaling/skew is not).
+
+\ ``rect * transform`` is equivalent to ``transform.inverse() * rect``. See :ref:`Transform2D.inverse<class_Transform2D_method_inverse>`.
+
+For transforming by inverse of an affine transformation (e.g. with scaling) ``transform.affine_inverse() * rect`` can be used instead. See :ref:`Transform2D.affine_inverse<class_Transform2D_method_affine_inverse>`.
 
 .. rst-class:: classref-item-separator
 

classes/class_scrollbar.rst

@@ -64,8 +64,6 @@ Theme Properties
    +-----------------------------------+----------------------------------------------------------------------------+
    | :ref:`StyleBox<class_StyleBox>`   | :ref:`grabber_pressed<class_ScrollBar_theme_style_grabber_pressed>`        |
    +-----------------------------------+----------------------------------------------------------------------------+
-   | :ref:`StyleBox<class_StyleBox>`   | :ref:`hscroll<class_ScrollBar_theme_style_hscroll>`                        |
-   +-----------------------------------+----------------------------------------------------------------------------+
    | :ref:`StyleBox<class_StyleBox>`   | :ref:`scroll<class_ScrollBar_theme_style_scroll>`                          |
    +-----------------------------------+----------------------------------------------------------------------------+
    | :ref:`StyleBox<class_StyleBox>`   | :ref:`scroll_focus<class_ScrollBar_theme_style_scroll_focus>`              |
@@ -227,20 +225,6 @@ Used when the grabber is being dragged.
 
 ----
 
-.. _class_ScrollBar_theme_style_hscroll:
-
-.. rst-class:: classref-themeproperty
-
-:ref:`StyleBox<class_StyleBox>` **hscroll**
-
-.. container:: contribute
-
-	There is currently no description for this theme property. Please help us by :ref:`contributing one <doc_updating_the_class_reference>`!
-
-.. rst-class:: classref-item-separator
-
-----
-
 .. _class_ScrollBar_theme_style_scroll:
 
 .. rst-class:: classref-themeproperty

classes/class_transform2d.rst

@@ -300,7 +300,7 @@ Method Descriptions
 
 :ref:`Transform2D<class_Transform2D>` **affine_inverse** **(** **)** |const|
 
-Returns the inverse of the transform, under the assumption that the transformation is composed of rotation, scaling and translation.
+Returns the inverse of the transform, under the assumption that the basis is invertible (must have non-zero determinant).
 
 .. rst-class:: classref-item-separator
 
@@ -314,7 +314,7 @@ Returns the inverse of the transform, under the assumption that the transformati
 
 Returns a vector transformed (multiplied) by the basis matrix.
 
-This method does not account for translation (the origin vector).
+This method does not account for translation (the :ref:`origin<class_Transform2D_property_origin>` vector).
 
 .. rst-class:: classref-item-separator
 
@@ -326,9 +326,13 @@ This method does not account for translation (the origin vector).
 
 :ref:`Vector2<class_Vector2>` **basis_xform_inv** **(** :ref:`Vector2<class_Vector2>` v **)** |const|
 
-Returns a vector transformed (multiplied) by the inverse basis matrix.
+Returns a vector transformed (multiplied) by the inverse basis matrix, under the assumption that the basis is orthonormal (i.e. rotation/reflection is fine, scaling/skew is not).
 
-This method does not account for translation (the origin vector).
+This method does not account for translation (the :ref:`origin<class_Transform2D_property_origin>` vector).
+
+\ ``transform.basis_xform_inv(vector)`` is equivalent to ``transform.inverse().basis_xform(vector)``. See :ref:`inverse<class_Transform2D_method_inverse>`.
+
+For non-orthonormal transforms (e.g. with scaling) ``transform.affine_inverse().basis_xform(vector)`` can be used instead. See :ref:`affine_inverse<class_Transform2D_method_affine_inverse>`.
 
 .. rst-class:: classref-item-separator
 
@@ -414,7 +418,7 @@ Returns a transform interpolated between this transform and another by a given `
 
 :ref:`Transform2D<class_Transform2D>` **inverse** **(** **)** |const|
 
-Returns the inverse of the transform, under the assumption that the transformation is composed of rotation and translation (no scaling, use :ref:`affine_inverse<class_Transform2D_method_affine_inverse>` for transforms with scaling).
+Returns the inverse of the transform, under the assumption that the transformation basis is orthonormal (i.e. rotation/reflection is fine, scaling/skew is not). Use :ref:`affine_inverse<class_Transform2D_method_affine_inverse>` for non-orthonormal transforms (e.g. with scaling).
 
 .. rst-class:: classref-item-separator
 
@@ -651,7 +655,7 @@ Transforms (multiplies) the :ref:`Vector2<class_Vector2>` by the given **Transfo
 
 :ref:`Transform2D<class_Transform2D>` **operator *** **(** :ref:`float<class_float>` right **)**
 
-This operator multiplies all components of the **Transform2D**, including the origin vector, which scales it uniformly.
+This operator multiplies all components of the **Transform2D**, including the :ref:`origin<class_Transform2D_property_origin>` vector, which scales it uniformly.
 
 .. rst-class:: classref-item-separator
 
@@ -663,7 +667,7 @@ This operator multiplies all components of the **Transform2D**, including the or
 
 :ref:`Transform2D<class_Transform2D>` **operator *** **(** :ref:`int<class_int>` right **)**
 
-This operator multiplies all components of the **Transform2D**, including the origin vector, which scales it uniformly.
+This operator multiplies all components of the **Transform2D**, including the :ref:`origin<class_Transform2D_property_origin>` vector, which scales it uniformly.
 
 .. rst-class:: classref-item-separator
 

classes/class_transform3d.rst

@@ -282,7 +282,7 @@ Method Descriptions
 
 :ref:`Transform3D<class_Transform3D>` **affine_inverse** **(** **)** |const|
 
-Returns the inverse of the transform, under the assumption that the transformation is composed of rotation, scaling and translation.
+Returns the inverse of the transform, under the assumption that the basis is invertible (must have non-zero determinant).
 
 .. rst-class:: classref-item-separator
 
@@ -306,7 +306,7 @@ Returns a transform interpolated between this transform and another by a given `
 
 :ref:`Transform3D<class_Transform3D>` **inverse** **(** **)** |const|
 
-Returns the inverse of the transform, under the assumption that the transformation is composed of rotation and translation (no scaling, use :ref:`affine_inverse<class_Transform3D_method_affine_inverse>` for transforms with scaling).
+Returns the inverse of the transform, under the assumption that the transformation basis is orthonormal (i.e. rotation/reflection is fine, scaling/skew is not). Use :ref:`affine_inverse<class_Transform3D_method_affine_inverse>` for non-orthonormal transforms (e.g. with scaling).
 
 .. rst-class:: classref-item-separator
 
@@ -549,7 +549,7 @@ Transforms (multiplies) the :ref:`Vector3<class_Vector3>` by the given **Transfo
 
 :ref:`Transform3D<class_Transform3D>` **operator *** **(** :ref:`float<class_float>` right **)**
 
-This operator multiplies all components of the **Transform3D**, including the origin vector, which scales it uniformly.
+This operator multiplies all components of the **Transform3D**, including the :ref:`origin<class_Transform3D_property_origin>` vector, which scales it uniformly.
 
 .. rst-class:: classref-item-separator
 
@@ -561,7 +561,7 @@ This operator multiplies all components of the **Transform3D**, including the or
 
 :ref:`Transform3D<class_Transform3D>` **operator *** **(** :ref:`int<class_int>` right **)**
 
-This operator multiplies all components of the **Transform3D**, including the origin vector, which scales it uniformly.
+This operator multiplies all components of the **Transform3D**, including the :ref:`origin<class_Transform3D_property_origin>` vector, which scales it uniformly.
 
 .. rst-class:: classref-item-separator
 

classes/class_vector2.rst

@@ -951,7 +951,11 @@ Returns ``true`` if the vectors are not equal.
 
 :ref:`Vector2<class_Vector2>` **operator *** **(** :ref:`Transform2D<class_Transform2D>` right **)**
 
-Inversely transforms (multiplies) the **Vector2** by the given :ref:`Transform2D<class_Transform2D>` transformation matrix.
+Inversely transforms (multiplies) the **Vector2** by the given :ref:`Transform2D<class_Transform2D>` transformation matrix, under the assumption that the transformation basis is orthonormal (i.e. rotation/reflection is fine, scaling/skew is not).
+
+\ ``vector * transform`` is equivalent to ``transform.inverse() * vector``. See :ref:`Transform2D.inverse<class_Transform2D_method_inverse>`.
+
+For transforming by inverse of an affine transformation (e.g. with scaling) ``transform.affine_inverse() * vector`` can be used instead. See :ref:`Transform2D.affine_inverse<class_Transform2D_method_affine_inverse>`.
 
 .. rst-class:: classref-item-separator
 

classes/class_vector3.rst

@@ -1023,7 +1023,11 @@ Returns ``true`` if the vectors are not equal.
 
 :ref:`Vector3<class_Vector3>` **operator *** **(** :ref:`Basis<class_Basis>` right **)**
 
-Inversely transforms (multiplies) the **Vector3** by the given :ref:`Basis<class_Basis>` matrix.
+Inversely transforms (multiplies) the **Vector3** by the given :ref:`Basis<class_Basis>` matrix, under the assumption that the basis is orthonormal (i.e. rotation/reflection is fine, scaling/skew is not).
+
+\ ``vector * basis`` is equivalent to ``basis.transposed() * vector``. See :ref:`Basis.transposed<class_Basis_method_transposed>`.
+
+For transforming by inverse of a non-orthonormal basis (e.g. with scaling) ``basis.inverse() * vector`` can be used instead. See :ref:`Basis.inverse<class_Basis_method_inverse>`.
 
 .. rst-class:: classref-item-separator
 
@@ -1037,6 +1041,8 @@ Inversely transforms (multiplies) the **Vector3** by the given :ref:`Basis<class
 
 Inversely transforms (multiplies) the **Vector3** by the given :ref:`Quaternion<class_Quaternion>`.
 
+\ ``vector * quaternion`` is equivalent to ``quaternion.inverse() * vector``. See :ref:`Quaternion.inverse<class_Quaternion_method_inverse>`.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -1047,7 +1053,11 @@ Inversely transforms (multiplies) the **Vector3** by the given :ref:`Quaternion<
 
 :ref:`Vector3<class_Vector3>` **operator *** **(** :ref:`Transform3D<class_Transform3D>` right **)**
 
-Inversely transforms (multiplies) the **Vector3** by the given :ref:`Transform3D<class_Transform3D>` transformation matrix.
+Inversely transforms (multiplies) the **Vector3** by the given :ref:`Transform3D<class_Transform3D>` transformation matrix, under the assumption that the transformation basis is orthonormal (i.e. rotation/reflection is fine, scaling/skew is not).
+
+\ ``vector * transform`` is equivalent to ``transform.inverse() * vector``. See :ref:`Transform3D.inverse<class_Transform3D_method_inverse>`.
+
+For transforming by inverse of an affine transformation (e.g. with scaling) ``transform.affine_inverse() * vector`` can be used instead. See :ref:`Transform3D.affine_inverse<class_Transform3D_method_affine_inverse>`.
 
 .. rst-class:: classref-item-separator
 

classes/class_vector4.rst

@@ -692,7 +692,9 @@ Returns ``true`` if the vectors are not equal.
 
 :ref:`Vector4<class_Vector4>` **operator *** **(** :ref:`Projection<class_Projection>` right **)**
 
-Inversely transforms (multiplies) the **Vector4** by the given :ref:`Projection<class_Projection>` matrix.
+Transforms (multiplies) the **Vector4** by the transpose of the given :ref:`Projection<class_Projection>` matrix.
+
+For transforming by inverse of a projection ``projection.inverse() * vector`` can be used instead. See :ref:`Projection.inverse<class_Projection_method_inverse>`.
 
 .. rst-class:: classref-item-separator
 

classes/class_visibleonscreenenabler2d.rst

@@ -12,14 +12,18 @@ VisibleOnScreenEnabler2D
 
 **Inherits:** :ref:`VisibleOnScreenNotifier2D<class_VisibleOnScreenNotifier2D>` **<** :ref:`Node2D<class_Node2D>` **<** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-Automatically disables another node if not visible on screen.
+A rectangular region of 2D space that, when visible on screen, enables a target node.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-VisibleOnScreenEnabler2D detects when it is visible on screen (just like :ref:`VisibleOnScreenNotifier2D<class_VisibleOnScreenNotifier2D>`) and automatically enables or disables the target node. The target node is disabled when **VisibleOnScreenEnabler2D** is not visible on screen (including when :ref:`CanvasItem.visible<class_CanvasItem_property_visible>` is ``false``), and enabled when the enabler is visible. The disabling is achieved by changing :ref:`Node.process_mode<class_Node_property_process_mode>`.
+**VisibleOnScreenEnabler2D** contains a rectangular region of 2D space and a target node. The target node will be automatically enabled (via its :ref:`Node.process_mode<class_Node_property_process_mode>` property) when any part of this region becomes visible on the screen, and automatically disabled otherwise. This can for example be used to activate enemies only when the player approaches them.
+
+See :ref:`VisibleOnScreenNotifier2D<class_VisibleOnScreenNotifier2D>` if you only want to be notified when the region is visible on screen.
+
+\ **Note:** **VisibleOnScreenEnabler2D** uses the render culling code to determine whether it's visible on screen, so it won't function unless :ref:`CanvasItem.visible<class_CanvasItem_property_visible>` is set to ``true``.
 
 .. rst-class:: classref-reftable-group
 
@@ -94,7 +98,7 @@ Property Descriptions
 - void **set_enable_mode** **(** :ref:`EnableMode<enum_VisibleOnScreenEnabler2D_EnableMode>` value **)**
 - :ref:`EnableMode<enum_VisibleOnScreenEnabler2D_EnableMode>` **get_enable_mode** **(** **)**
 
-Determines how the node is enabled. Corresponds to :ref:`ProcessMode<enum_Node_ProcessMode>`. Disabled node uses :ref:`Node.PROCESS_MODE_DISABLED<class_Node_constant_PROCESS_MODE_DISABLED>`.
+Determines how the target node is enabled. Corresponds to :ref:`ProcessMode<enum_Node_ProcessMode>`. When the node is disabled, it always uses :ref:`Node.PROCESS_MODE_DISABLED<class_Node_constant_PROCESS_MODE_DISABLED>`.
 
 .. rst-class:: classref-item-separator
 
@@ -111,7 +115,7 @@ Determines how the node is enabled. Corresponds to :ref:`ProcessMode<enum_Node_P
 - void **set_enable_node_path** **(** :ref:`NodePath<class_NodePath>` value **)**
 - :ref:`NodePath<class_NodePath>` **get_enable_node_path** **(** **)**
 
-The path to the target node, relative to the **VisibleOnScreenEnabler2D**. The target node is cached; it's only assigned when setting this property (if the **VisibleOnScreenEnabler2D** is inside scene tree) and every time the **VisibleOnScreenEnabler2D** enters the scene tree. If the path is invalid, nothing will happen.
+The path to the target node, relative to the **VisibleOnScreenEnabler2D**. The target node is cached; it's only assigned when setting this property (if the **VisibleOnScreenEnabler2D** is inside the scene tree) and every time the **VisibleOnScreenEnabler2D** enters the scene tree. If the path is invalid, an error will be printed in the editor and no node will be affected.
 
 .. |virtual| replace:: :abbr:`virtual (This method should typically be overridden by the user to have any effect.)`
 .. |const| replace:: :abbr:`const (This method has no side effects. It doesn't modify any of the instance's member variables.)`

classes/class_visibleonscreenenabler3d.rst

@@ -12,20 +12,18 @@ VisibleOnScreenEnabler3D
 
 **Inherits:** :ref:`VisibleOnScreenNotifier3D<class_VisibleOnScreenNotifier3D>` **<** :ref:`VisualInstance3D<class_VisualInstance3D>` **<** :ref:`Node3D<class_Node3D>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
 
-Enables certain nodes only when approximately visible.
+A box-shaped region of 3D space that, when visible on screen, enables a target node.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-The VisibleOnScreenEnabler3D will disable :ref:`RigidBody3D<class_RigidBody3D>` and :ref:`AnimationPlayer<class_AnimationPlayer>` nodes when they are not visible. It will only affect other nodes within the same scene as the VisibleOnScreenEnabler3D itself.
+**VisibleOnScreenEnabler3D** contains a box-shaped region of 3D space and a target node. The target node will be automatically enabled (via its :ref:`Node.process_mode<class_Node_property_process_mode>` property) when any part of this region becomes visible on the screen, and automatically disabled otherwise. This can for example be used to activate enemies only when the player approaches them.
 
-If you just want to receive notifications, use :ref:`VisibleOnScreenNotifier3D<class_VisibleOnScreenNotifier3D>` instead.
+See :ref:`VisibleOnScreenNotifier3D<class_VisibleOnScreenNotifier3D>` if you only want to be notified when the region is visible on screen.
 
-\ **Note:** VisibleOnScreenEnabler3D uses an approximate heuristic for performance reasons. It doesn't take walls and other occlusion into account. The heuristic is an implementation detail and may change in future versions. If you need precise visibility checking, use another method such as adding an :ref:`Area3D<class_Area3D>` node as a child of a :ref:`Camera3D<class_Camera3D>` node and/or :ref:`Vector3.dot<class_Vector3_method_dot>`.
-
-\ **Note:** VisibleOnScreenEnabler3D will not affect nodes added after scene initialization.
+\ **Note:** **VisibleOnScreenEnabler3D** uses an approximate heuristic that doesn't take walls and other occlusion into account, unless occlusion culling is used. It also won't function unless :ref:`Node3D.visible<class_Node3D_property_visible>` is set to ``true``.
 
 .. rst-class:: classref-reftable-group
 
@@ -62,7 +60,7 @@ enum **EnableMode**:
 
 :ref:`EnableMode<enum_VisibleOnScreenEnabler3D_EnableMode>` **ENABLE_MODE_INHERIT** = ``0``
 
-
+Corresponds to :ref:`Node.PROCESS_MODE_INHERIT<class_Node_constant_PROCESS_MODE_INHERIT>`.
 
 .. _class_VisibleOnScreenEnabler3D_constant_ENABLE_MODE_ALWAYS:
 
@@ -70,7 +68,7 @@ enum **EnableMode**:
 
 :ref:`EnableMode<enum_VisibleOnScreenEnabler3D_EnableMode>` **ENABLE_MODE_ALWAYS** = ``1``
 
-
+Corresponds to :ref:`Node.PROCESS_MODE_ALWAYS<class_Node_constant_PROCESS_MODE_ALWAYS>`.
 
 .. _class_VisibleOnScreenEnabler3D_constant_ENABLE_MODE_WHEN_PAUSED:
 
@@ -78,7 +76,7 @@ enum **EnableMode**:
 
 :ref:`EnableMode<enum_VisibleOnScreenEnabler3D_EnableMode>` **ENABLE_MODE_WHEN_PAUSED** = ``2``
 
-
+Corresponds to :ref:`Node.PROCESS_MODE_WHEN_PAUSED<class_Node_constant_PROCESS_MODE_WHEN_PAUSED>`.
 
 .. rst-class:: classref-section-separator
 
@@ -100,9 +98,7 @@ Property Descriptions
 - void **set_enable_mode** **(** :ref:`EnableMode<enum_VisibleOnScreenEnabler3D_EnableMode>` value **)**
 - :ref:`EnableMode<enum_VisibleOnScreenEnabler3D_EnableMode>` **get_enable_mode** **(** **)**
 
-.. container:: contribute
-
-	There is currently no description for this property. Please help us by :ref:`contributing one <doc_updating_the_class_reference>`!
+Determines how the target node is enabled. Corresponds to :ref:`ProcessMode<enum_Node_ProcessMode>`. When the node is disabled, it always uses :ref:`Node.PROCESS_MODE_DISABLED<class_Node_constant_PROCESS_MODE_DISABLED>`.
 
 .. rst-class:: classref-item-separator
 
@@ -119,9 +115,7 @@ Property Descriptions
 - void **set_enable_node_path** **(** :ref:`NodePath<class_NodePath>` value **)**
 - :ref:`NodePath<class_NodePath>` **get_enable_node_path** **(** **)**
 
-.. container:: contribute
-
-	There is currently no description for this property. Please help us by :ref:`contributing one <doc_updating_the_class_reference>`!
+The path to the target node, relative to the **VisibleOnScreenEnabler3D**. The target node is cached; it's only assigned when setting this property (if the **VisibleOnScreenEnabler3D** is inside the scene tree) and every time the **VisibleOnScreenEnabler3D** enters the scene tree. If the path is invalid, an error will be printed in the editor and no node will be affected.
 
 .. |virtual| replace:: :abbr:`virtual (This method should typically be overridden by the user to have any effect.)`
 .. |const| replace:: :abbr:`const (This method has no side effects. It doesn't modify any of the instance's member variables.)`

classes/class_visibleonscreennotifier2d.rst

@@ -14,18 +14,18 @@ VisibleOnScreenNotifier2D
 
 **Inherited By:** :ref:`VisibleOnScreenEnabler2D<class_VisibleOnScreenEnabler2D>`
 
-Detects when the node extents are visible on screen.
+A rectangular region of 2D space that detects whether it is visible on screen.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-The VisibleOnScreenNotifier2D detects when it is visible on the screen. It also notifies when its bounding rectangle enters or exits the screen or a viewport.
+:ref:`VisibleOnScreenEnabler2D<class_VisibleOnScreenEnabler2D>` represents a rectangular region of 2D space. When any part of this region becomes visible on screen or in a viewport, it will emit a :ref:`screen_entered<class_VisibleOnScreenNotifier2D_signal_screen_entered>` signal, and likewise it will emit a :ref:`screen_exited<class_VisibleOnScreenNotifier2D_signal_screen_exited>` signal when no part of it remains visible.
 
-If you want nodes to be disabled automatically when they exit the screen, use :ref:`VisibleOnScreenEnabler2D<class_VisibleOnScreenEnabler2D>` instead.
+If you want a node to be enabled automatically when this region is visible on screen, use :ref:`VisibleOnScreenEnabler2D<class_VisibleOnScreenEnabler2D>`.
 
-\ **Note:** VisibleOnScreenNotifier2D uses the render culling code to determine whether it's visible on screen, which also means that its :ref:`CanvasItem.visible<class_CanvasItem_property_visible>` must be ``true`` to work correctly.
+\ **Note:** **VisibleOnScreenNotifier2D** uses the render culling code to determine whether it's visible on screen, so it won't function unless :ref:`CanvasItem.visible<class_CanvasItem_property_visible>` is set to ``true``.
 
 .. rst-class:: classref-introduction-group
 
@@ -126,7 +126,7 @@ Method Descriptions
 
 If ``true``, the bounding rectangle is on the screen.
 
-\ **Note:** It takes one frame for the node's visibility to be assessed once added to the scene tree, so this method will return ``false`` right after it is instantiated, even if it will be on screen in the draw pass.
+\ **Note:** It takes one frame for the **VisibleOnScreenNotifier2D**'s visibility to be determined once added to the scene tree, so this method will always return ``false`` right after it is instantiated, before the draw pass.
 
 .. |virtual| replace:: :abbr:`virtual (This method should typically be overridden by the user to have any effect.)`
 .. |const| replace:: :abbr:`const (This method has no side effects. It doesn't modify any of the instance's member variables.)`

classes/class_visibleonscreennotifier3d.rst

@@ -14,18 +14,18 @@ VisibleOnScreenNotifier3D
 
 **Inherited By:** :ref:`VisibleOnScreenEnabler3D<class_VisibleOnScreenEnabler3D>`
 
-Detects approximately when the node is visible on screen.
+A box-shaped region of 3D space that detects whether it is visible on screen.
 
 .. rst-class:: classref-introduction-group
 
 Description
 -----------
 
-The VisibleOnScreenNotifier3D detects when it is visible on the screen. It also notifies when its bounding rectangle enters or exits the screen or a :ref:`Camera3D<class_Camera3D>`'s view.
+:ref:`VisibleOnScreenEnabler3D<class_VisibleOnScreenEnabler3D>` represents a box-shaped region of 3D space. When any part of this region becomes visible on screen or in a :ref:`Camera3D<class_Camera3D>`'s view, it will emit a :ref:`screen_entered<class_VisibleOnScreenNotifier3D_signal_screen_entered>` signal, and likewise it will emit a :ref:`screen_exited<class_VisibleOnScreenNotifier3D_signal_screen_exited>` signal when no part of it remains visible.
 
-If you want nodes to be disabled automatically when they exit the screen, use :ref:`VisibleOnScreenEnabler3D<class_VisibleOnScreenEnabler3D>` instead.
+If you want a node to be enabled automatically when this region is visible on screen, use :ref:`VisibleOnScreenEnabler3D<class_VisibleOnScreenEnabler3D>`.
 
-\ **Note:** VisibleOnScreenNotifier3D uses the render culling code to determine whether it's visible on screen, which also means that its :ref:`Node3D.visible<class_Node3D_property_visible>` must be ``true`` to work correctly.
+\ **Note:** **VisibleOnScreenNotifier3D** uses an approximate heuristic that doesn't take walls and other occlusion into account, unless occlusion culling is used. It also won't function unless :ref:`Node3D.visible<class_Node3D_property_visible>` is set to ``true``.
 
 .. rst-class:: classref-reftable-group
 
@@ -66,7 +66,7 @@ Signals
 
 **screen_entered** **(** **)**
 
-Emitted when the VisibleOnScreenNotifier3D enters the screen.
+Emitted when the **VisibleOnScreenNotifier3D** enters the screen.
 
 .. rst-class:: classref-item-separator
 
@@ -78,7 +78,7 @@ Emitted when the VisibleOnScreenNotifier3D enters the screen.
 
 **screen_exited** **(** **)**
 
-Emitted when the VisibleOnScreenNotifier3D exits the screen.
+Emitted when the **VisibleOnScreenNotifier3D** exits the screen.
 
 .. rst-class:: classref-section-separator
 
@@ -100,7 +100,7 @@ Property Descriptions
 - void **set_aabb** **(** :ref:`AABB<class_AABB>` value **)**
 - :ref:`AABB<class_AABB>` **get_aabb** **(** **)**
 
-The VisibleOnScreenNotifier3D's bounding box.
+The **VisibleOnScreenNotifier3D**'s bounding box.
 
 .. rst-class:: classref-section-separator
 
@@ -117,9 +117,9 @@ Method Descriptions
 
 :ref:`bool<class_bool>` **is_on_screen** **(** **)** |const|
 
-If ``true``, the bounding box is on the screen.
+Returns ``true`` if the bounding box is on the screen.
 
-\ **Note:** It takes one frame for the node's visibility to be assessed once added to the scene tree, so this method will return ``false`` right after it is instantiated, even if it will be on screen in the draw pass.
+\ **Note:** It takes one frame for the **VisibleOnScreenNotifier3D**'s visibility to be assessed once added to the scene tree, so this method will always return ``false`` right after it is instantiated.
 
 .. |virtual| replace:: :abbr:`virtual (This method should typically be overridden by the user to have any effect.)`
 .. |const| replace:: :abbr:`const (This method has no side effects. It doesn't modify any of the instance's member variables.)`