classref: Sync with current master branch (97b8ad1)

classes/class_animation.rst

@@ -1347,7 +1347,7 @@ Sets the value of an existing key.
 
 |void| **track_set_path**\ (\ track_idx\: :ref:`int<class_int>`, path\: :ref:`NodePath<class_NodePath>`\ ) :ref:`🔗<class_Animation_method_track_set_path>`
 
-Sets the path of a track. Paths must be valid scene-tree paths to a node and must be specified starting from the parent node of the node that will reproduce the animation. Tracks that control properties or bones must append their name after the path, separated by ``":"``.
+Sets the path of a track. Paths must be valid scene-tree paths to a node and must be specified starting from the :ref:`AnimationMixer.root_node<class_AnimationMixer_property_root_node>` that will reproduce the animation. Tracks that control properties or bones must append their name after the path, separated by ``":"``.
 
 For example, ``"character/skeleton:ankle"`` or ``"character/mesh:transform/local"``.
 

classes/class_animationmixer.rst

@@ -454,9 +454,9 @@ This makes it more convenient to preview and edit animations in the editor, as c
 - |void| **set_root_motion_track**\ (\ value\: :ref:`NodePath<class_NodePath>`\ )
 - :ref:`NodePath<class_NodePath>` **get_root_motion_track**\ (\ )
 
-The path to the Animation track used for root motion. Paths must be valid scene-tree paths to a node, and must be specified starting from the parent node of the node that will reproduce the animation. To specify a track that controls properties or bones, append its name after the path, separated by ``":"``. For example, ``"character/skeleton:ankle"`` or ``"character/mesh:transform/local"``.
+The path to the Animation track used for root motion. Paths must be valid scene-tree paths to a node, and must be specified starting from the parent node of the node that will reproduce the animation. The :ref:`root_motion_track<class_AnimationMixer_property_root_motion_track>` uses the same format as :ref:`Animation.track_set_path<class_Animation_method_track_set_path>`, but note that a bone must be specified.
 
-If the track has type :ref:`Animation.TYPE_POSITION_3D<class_Animation_constant_TYPE_POSITION_3D>`, :ref:`Animation.TYPE_ROTATION_3D<class_Animation_constant_TYPE_ROTATION_3D>` or :ref:`Animation.TYPE_SCALE_3D<class_Animation_constant_TYPE_SCALE_3D>` the transformation will be canceled visually, and the animation will appear to stay in place. See also :ref:`get_root_motion_position<class_AnimationMixer_method_get_root_motion_position>`, :ref:`get_root_motion_rotation<class_AnimationMixer_method_get_root_motion_rotation>`, :ref:`get_root_motion_scale<class_AnimationMixer_method_get_root_motion_scale>` and :ref:`RootMotionView<class_RootMotionView>`.
+If the track has type :ref:`Animation.TYPE_POSITION_3D<class_Animation_constant_TYPE_POSITION_3D>`, :ref:`Animation.TYPE_ROTATION_3D<class_Animation_constant_TYPE_ROTATION_3D>`, or :ref:`Animation.TYPE_SCALE_3D<class_Animation_constant_TYPE_SCALE_3D>` the transformation will be canceled visually, and the animation will appear to stay in place. See also :ref:`get_root_motion_position<class_AnimationMixer_method_get_root_motion_position>`, :ref:`get_root_motion_rotation<class_AnimationMixer_method_get_root_motion_rotation>`, :ref:`get_root_motion_scale<class_AnimationMixer_method_get_root_motion_scale>`, and :ref:`RootMotionView<class_RootMotionView>`.
 
 .. rst-class:: classref-item-separator
 

classes/class_editorexportplatformwindows.rst

@@ -187,7 +187,7 @@ If set to ``1``, ANGLE libraries are exported with the exported application. If
 
 :ref:`int<class_int>` **application/export_d3d12** :ref:`🔗<class_EditorExportPlatformWindows_property_application/export_d3d12>`
 
-If set to ``1``, Direct3D 12 runtime (DXIL, Agility SDK, PIX) libraries are exported with the exported application. If set to ``0``, Direct3D 12 libraries are exported only if :ref:`ProjectSettings.rendering/rendering_device/driver<class_ProjectSettings_property_rendering/rendering_device/driver>` is set to ``"d3d12"``.
+If set to ``1``, the Direct3D 12 runtime libraries (Agility SDK, PIX) are exported with the exported application. If set to ``0``, Direct3D 12 libraries are exported only if :ref:`ProjectSettings.rendering/rendering_device/driver<class_ProjectSettings_property_rendering/rendering_device/driver>` is set to ``"d3d12"``.
 
 .. rst-class:: classref-item-separator
 

classes/class_os.rst

@@ -829,7 +829,7 @@ Returns the value of the given environment variable, or an empty string if ``var
 
 Returns the file path to the current engine executable.
 
-\ **Note:** On macOS, always use :ref:`create_instance<class_OS_method_create_instance>` instead of relying on executable path.
+\ **Note:** On macOS, if you want to launch another instance of Godot, always use :ref:`create_instance<class_OS_method_create_instance>` instead of relying on the executable path.
 
 .. rst-class:: classref-item-separator
 

classes/class_physicspointqueryparameters2d.rst

@@ -135,6 +135,8 @@ The physics layers the query will detect (as a bitmask). By default, all collisi
 
 The list of object :ref:`RID<class_RID>`\ s that will be excluded from collisions. Use :ref:`CollisionObject2D.get_rid<class_CollisionObject2D_method_get_rid>` to get the :ref:`RID<class_RID>` associated with a :ref:`CollisionObject2D<class_CollisionObject2D>`-derived node.
 
+\ **Note:** The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then assign it to the property again.
+
 .. rst-class:: classref-item-separator
 
 ----

classes/class_physicspointqueryparameters3d.rst

@@ -114,6 +114,8 @@ The physics layers the query will detect (as a bitmask). By default, all collisi
 
 The list of object :ref:`RID<class_RID>`\ s that will be excluded from collisions. Use :ref:`CollisionObject3D.get_rid<class_CollisionObject3D_method_get_rid>` to get the :ref:`RID<class_RID>` associated with a :ref:`CollisionObject3D<class_CollisionObject3D>`-derived node.
 
+\ **Note:** The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then assign it to the property again.
+
 .. rst-class:: classref-item-separator
 
 ----

classes/class_physicsrayqueryparameters2d.rst

@@ -130,6 +130,8 @@ The physics layers the query will detect (as a bitmask). By default, all collisi
 
 The list of object :ref:`RID<class_RID>`\ s that will be excluded from collisions. Use :ref:`CollisionObject2D.get_rid<class_CollisionObject2D_method_get_rid>` to get the :ref:`RID<class_RID>` associated with a :ref:`CollisionObject2D<class_CollisionObject2D>`-derived node.
 
+\ **Note:** The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then assign it to the property again.
+
 .. rst-class:: classref-item-separator
 
 ----

classes/class_physicsrayqueryparameters3d.rst

@@ -132,6 +132,8 @@ The physics layers the query will detect (as a bitmask). By default, all collisi
 
 The list of object :ref:`RID<class_RID>`\ s that will be excluded from collisions. Use :ref:`CollisionObject3D.get_rid<class_CollisionObject3D_method_get_rid>` to get the :ref:`RID<class_RID>` associated with a :ref:`CollisionObject3D<class_CollisionObject3D>`-derived node.
 
+\ **Note:** The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then assign it to the property again.
+
 .. rst-class:: classref-item-separator
 
 ----

classes/class_physicsshapequeryparameters2d.rst

@@ -122,6 +122,8 @@ The physics layers the query will detect (as a bitmask). By default, all collisi
 
 The list of object :ref:`RID<class_RID>`\ s that will be excluded from collisions. Use :ref:`CollisionObject2D.get_rid<class_CollisionObject2D_method_get_rid>` to get the :ref:`RID<class_RID>` associated with a :ref:`CollisionObject2D<class_CollisionObject2D>`-derived node.
 
+\ **Note:** The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then assign it to the property again.
+
 .. rst-class:: classref-item-separator
 
 ----

classes/class_physicsshapequeryparameters3d.rst

@@ -122,6 +122,8 @@ The physics layers the query will detect (as a bitmask). By default, all collisi
 
 The list of object :ref:`RID<class_RID>`\ s that will be excluded from collisions. Use :ref:`CollisionObject3D.get_rid<class_CollisionObject3D_method_get_rid>` to get the :ref:`RID<class_RID>` associated with a :ref:`CollisionObject3D<class_CollisionObject3D>`-derived node.
 
+\ **Note:** The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then assign it to the property again.
+
 .. rst-class:: classref-item-separator
 
 ----

classes/class_popupmenu.rst

@@ -148,6 +148,8 @@ Methods
    +--------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | :ref:`bool<class_bool>`                          | :ref:`is_item_shortcut_disabled<class_PopupMenu_method_is_item_shortcut_disabled>`\ (\ index\: :ref:`int<class_int>`\ ) |const|                                                                                                                                                            |
    +--------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+   | :ref:`bool<class_bool>`                          | :ref:`is_native_menu<class_PopupMenu_method_is_native_menu>`\ (\ ) |const|                                                                                                                                                                                                                 |
+   +--------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | :ref:`bool<class_bool>`                          | :ref:`is_system_menu<class_PopupMenu_method_is_system_menu>`\ (\ ) |const|                                                                                                                                                                                                                 |
    +--------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
    | |void|                                           | :ref:`remove_item<class_PopupMenu_method_remove_item>`\ (\ index\: :ref:`int<class_int>`\ )                                                                                                                                                                                                |
@@ -445,6 +447,8 @@ The number of items currently in the list.
 
 If ``true``, :ref:`MenuBar<class_MenuBar>` will use native menu when supported.
 
+\ **Note:** If **PopupMenu** is linked to :ref:`StatusIndicator<class_StatusIndicator>`, :ref:`MenuBar<class_MenuBar>`, or another **PopupMenu** item it can use native menu regardless of this property, use :ref:`is_native_menu<class_PopupMenu_method_is_native_menu>` to check it.
+
 .. rst-class:: classref-item-separator
 
 ----
@@ -1076,6 +1080,18 @@ Returns ``true`` if the specified item's shortcut is disabled.
 
 ----
 
+.. _class_PopupMenu_method_is_native_menu:
+
+.. rst-class:: classref-method
+
+:ref:`bool<class_bool>` **is_native_menu**\ (\ ) |const| :ref:`🔗<class_PopupMenu_method_is_native_menu>`
+
+Returns ``true`` if the system native menu is supported and currently used by this **PopupMenu**.
+
+.. rst-class:: classref-item-separator
+
+----
+
 .. _class_PopupMenu_method_is_system_menu:
 
 .. rst-class:: classref-method

classes/class_projectsettings.rst

@@ -279,6 +279,8 @@ Properties
    +---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+
    | :ref:`int<class_int>`                             | :ref:`debug/settings/profiler/max_functions<class_ProjectSettings_property_debug/settings/profiler/max_functions>`                                                                                         | ``16384``                                                                                        |
    +---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+
+   | :ref:`int<class_int>`                             | :ref:`debug/settings/profiler/max_timestamp_query_elements<class_ProjectSettings_property_debug/settings/profiler/max_timestamp_query_elements>`                                                           | ``256``                                                                                          |
+   +---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+
    | :ref:`bool<class_bool>`                           | :ref:`debug/settings/stdout/print_fps<class_ProjectSettings_property_debug/settings/stdout/print_fps>`                                                                                                     | ``false``                                                                                        |
    +---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+
    | :ref:`bool<class_bool>`                           | :ref:`debug/settings/stdout/print_gpu_profile<class_ProjectSettings_property_debug/settings/stdout/print_gpu_profile>`                                                                                     | ``false``                                                                                        |
@@ -3198,6 +3200,18 @@ Maximum number of functions per frame allowed when profiling.
 
 ----
 
+.. _class_ProjectSettings_property_debug/settings/profiler/max_timestamp_query_elements:
+
+.. rst-class:: classref-property
+
+:ref:`int<class_int>` **debug/settings/profiler/max_timestamp_query_elements** = ``256`` :ref:`🔗<class_ProjectSettings_property_debug/settings/profiler/max_timestamp_query_elements>`
+
+Maximum number of timestamp query elements allowed per frame for visual profiling.
+
+.. rst-class:: classref-item-separator
+
+----
+
 .. _class_ProjectSettings_property_debug/settings/stdout/print_fps:
 
 .. rst-class:: classref-property
@@ -4220,9 +4234,9 @@ Defines how the base size is stretched to fit the resolution of the window or sc
 
 \ **"disabled"**: No stretching happens. One unit in the scene corresponds to one pixel on the screen. In this mode, :ref:`display/window/stretch/aspect<class_ProjectSettings_property_display/window/stretch/aspect>` has no effect. Recommended for non-game applications.
 
-\ **"canvas_items"**: The base size specified in width and height in the project settings is stretched to cover the whole screen (taking :ref:`display/window/stretch/aspect<class_ProjectSettings_property_display/window/stretch/aspect>` into account). This means that everything is rendered directly at the target resolution. 3D is unaffected, while in 2D, there is no longer a 1:1 correspondence between sprite pixels and screen pixels, which may result in scaling artifacts. Recommended for most games that don't use a pixel art esthetic, although it is possible to use this stretch mode for pixel art games too (especially in 3D).
+\ **"canvas_items"**: The base size specified in width and height in the project settings is stretched to cover the whole screen (taking :ref:`display/window/stretch/aspect<class_ProjectSettings_property_display/window/stretch/aspect>` into account). This means that everything is rendered directly at the target resolution. 3D is unaffected, while in 2D, there is no longer a 1:1 correspondence between sprite pixels and screen pixels, which may result in scaling artifacts. Recommended for most games that don't use a pixel art aesthetic, although it is possible to use this stretch mode for pixel art games too (especially in 3D).
 
-\ **"viewport"**: The size of the root :ref:`Viewport<class_Viewport>` is set precisely to the base size specified in the Project Settings' Display section. The scene is rendered to this viewport first. Finally, this viewport is scaled to fit the screen (taking :ref:`display/window/stretch/aspect<class_ProjectSettings_property_display/window/stretch/aspect>` into account). Recommended for games that use a pixel art esthetic.
+\ **"viewport"**: The size of the root :ref:`Viewport<class_Viewport>` is set precisely to the base size specified in the Project Settings' Display section. The scene is rendered to this viewport first. Finally, this viewport is scaled to fit the screen (taking :ref:`display/window/stretch/aspect<class_ProjectSettings_property_display/window/stretch/aspect>` into account). Recommended for games that use a pixel art aesthetic.
 
 .. rst-class:: classref-item-separator
 
@@ -4336,9 +4350,11 @@ Changing this value allows setting up a multi-project scenario where there are m
 
 :ref:`bool<class_bool>` **editor/export/convert_text_resources_to_binary** = ``true`` :ref:`🔗<class_ProjectSettings_property_editor/export/convert_text_resources_to_binary>`
 
-If ``true``, text resources are converted to a binary format on export. This decreases file sizes and speeds up loading slightly.
+If ``true``, text resource (``tres``) and text scene (``tscn``) files are converted to their corresponding binary format on export. This decreases file sizes and speeds up loading slightly.
+
+\ **Note:** Because a resource's file extension may change in an exported project, it is heavily recommended to use :ref:`@GDScript.load<class_@GDScript_method_load>` or :ref:`ResourceLoader<class_ResourceLoader>` instead of :ref:`FileAccess<class_FileAccess>` to load resources dynamically.
 
-\ **Note:** If :ref:`editor/export/convert_text_resources_to_binary<class_ProjectSettings_property_editor/export/convert_text_resources_to_binary>` is ``true``, :ref:`@GDScript.load<class_@GDScript_method_load>` will not be able to return the converted files in an exported project. Some file paths within the exported PCK will also change, such as ``project.godot`` becoming ``project.binary``. If you rely on run-time loading of files present within the PCK, set :ref:`editor/export/convert_text_resources_to_binary<class_ProjectSettings_property_editor/export/convert_text_resources_to_binary>` to ``false``.
+\ **Note:** The project settings file (``project.godot``) will always be converted to binary on export, regardless of this setting.
 
 .. rst-class:: classref-item-separator
 

classes/class_renderdataextension.rst

@@ -54,7 +54,7 @@ Method Descriptions
 
 :ref:`RID<class_RID>` **_get_camera_attributes**\ (\ ) |virtual| |const| :ref:`🔗<class_RenderDataExtension_private_method__get_camera_attributes>`
 
-Implement this in GDExtension to return the :ref:`RID<class_RID>` for the implementations camera attributes object.
+Implement this in GDExtension to return the :ref:`RID<class_RID>` for the implementation's camera attributes object.
 
 .. rst-class:: classref-item-separator
 
@@ -66,9 +66,7 @@ Implement this in GDExtension to return the :ref:`RID<class_RID>` for the implem
 
 :ref:`RID<class_RID>` **_get_environment**\ (\ ) |virtual| |const| :ref:`🔗<class_RenderDataExtension_private_method__get_environment>`
 
-.. container:: contribute
-
-	There is currently no description for this method. Please help us by :ref:`contributing one <doc_updating_the_class_reference>`!
+Implement this in GDExtension to return the :ref:`RID<class_RID>` of the implementation's environment object.
 
 .. rst-class:: classref-item-separator
 
@@ -80,7 +78,7 @@ Implement this in GDExtension to return the :ref:`RID<class_RID>` for the implem
 
 :ref:`RenderSceneBuffers<class_RenderSceneBuffers>` **_get_render_scene_buffers**\ (\ ) |virtual| |const| :ref:`🔗<class_RenderDataExtension_private_method__get_render_scene_buffers>`
 
-Implement this in GDExtension to return the :ref:`RID<class_RID>` of the implementations environment object.
+Implement this in GDExtension to return the implementation's :ref:`RenderSceneBuffers<class_RenderSceneBuffers>` object.
 
 .. rst-class:: classref-item-separator
 
@@ -92,7 +90,7 @@ Implement this in GDExtension to return the :ref:`RID<class_RID>` of the impleme
 
 :ref:`RenderSceneData<class_RenderSceneData>` **_get_render_scene_data**\ (\ ) |virtual| |const| :ref:`🔗<class_RenderDataExtension_private_method__get_render_scene_data>`
 
-Implement this in GDExtension to return the implementations :ref:`RenderSceneDataExtension<class_RenderSceneDataExtension>` object.
+Implement this in GDExtension to return the implementation's :ref:`RenderSceneDataExtension<class_RenderSceneDataExtension>` object.
 
 .. |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_scripteditorbase.rst

@@ -144,7 +144,7 @@ Emitted when the user contextual goto and the item is in the same script.
 
 .. rst-class:: classref-signal
 
-**request_save_previous_state**\ (\ line\: :ref:`int<class_int>`\ ) :ref:`🔗<class_ScriptEditorBase_signal_request_save_previous_state>`
+**request_save_previous_state**\ (\ state\: :ref:`Dictionary<class_Dictionary>`\ ) :ref:`🔗<class_ScriptEditorBase_signal_request_save_previous_state>`
 
 Emitted when the user changes current script or moves caret by 10 or more columns within the same script.
 

classes/class_transform2d.rst

@@ -17,10 +17,14 @@ A 2×3 matrix representing a 2D transformation.
 Description
 -----------
 
-A 2×3 matrix (2 rows, 3 columns) used for 2D linear transformations. It can represent transformations such as translation, rotation, and scaling. It consists of three :ref:`Vector2<class_Vector2>` values: :ref:`x<class_Transform2D_property_x>`, :ref:`y<class_Transform2D_property_y>`, and the :ref:`origin<class_Transform2D_property_origin>`.
+The **Transform2D** built-in :ref:`Variant<class_Variant>` type is a 2×3 `matrix <https://en.wikipedia.org/wiki/Matrix_(mathematics)>`__ representing a transformation in 2D space. It contains three :ref:`Vector2<class_Vector2>` values: :ref:`x<class_Transform2D_property_x>`, :ref:`y<class_Transform2D_property_y>`, and :ref:`origin<class_Transform2D_property_origin>`. Together, they can represent translation, rotation, scale, and skew.
+
+The :ref:`x<class_Transform2D_property_x>` and :ref:`y<class_Transform2D_property_y>` axes form a 2×2 matrix, known as the transform's **basis**. The length of each axis (:ref:`Vector2.length<class_Vector2_method_length>`) influences the transform's scale, while the direction of all axes influence the rotation. Usually, both axes are perpendicular to one another. However, when you rotate one axis individually, the transform becomes skewed. Applying a skewed transform to a 2D sprite will make the sprite appear distorted.
 
 For a general introduction, see the :doc:`Matrices and transforms <../tutorials/math/matrices_and_transforms>` tutorial.
 
+\ **Note:** Unlike :ref:`Transform3D<class_Transform3D>`, there is no 2D equivalent to the :ref:`Basis<class_Basis>` type. All mentions of "basis" refer to the :ref:`x<class_Transform2D_property_x>` and :ref:`y<class_Transform2D_property_y>` components of **Transform2D**.
+
 .. note::
 
 	There are notable differences when using this API with C#. See :ref:`doc_c_sharp_differences` for more information.
@@ -173,7 +177,24 @@ Constants
 
 **IDENTITY** = ``Transform2D(1, 0, 0, 1, 0, 0)`` :ref:`🔗<class_Transform2D_constant_IDENTITY>`
 
-The identity **Transform2D** with no translation, rotation or scaling applied. When applied to other data structures, :ref:`IDENTITY<class_Transform2D_constant_IDENTITY>` performs no transformation.
+The identity **Transform2D**. A transform with no translation, no rotation, and its scale being ``1``. When multiplied by another :ref:`Variant<class_Variant>` such as :ref:`Rect2<class_Rect2>` or another **Transform2D**, no transformation occurs. This means that:
+
+- The :ref:`x<class_Transform2D_property_x>` points right (:ref:`Vector2.RIGHT<class_Vector2_constant_RIGHT>`);
+
+- The :ref:`y<class_Transform2D_property_y>` points up (:ref:`Vector2.UP<class_Vector2_constant_UP>`).
+
+::
+
+    var transform = Transform2D.IDENTITY
+    print("| X | Y | Origin")
+    print("| %s | %s | %s" % [transform.x.x, transform.y.x, transform.origin.x])
+    print("| %s | %s | %s" % [transform.x.y, transform.y.y, transform.origin.y])
+    # Prints:
+    # | X | Y | Origin
+    # | 1 | 0 | 0
+    # | 0 | 1 | 0
+
+This is identical to creating :ref:`Transform2D<class_Transform2D_constructor_Transform2D>` without any parameters. This constant can be used to make your code clearer, and for consistency with C#.
 
 .. _class_Transform2D_constant_FLIP_X:
 
@@ -181,7 +202,9 @@ The identity **Transform2D** with no translation, rotation or scaling applied. W
 
 **FLIP_X** = ``Transform2D(-1, 0, 0, 1, 0, 0)`` :ref:`🔗<class_Transform2D_constant_FLIP_X>`
 
-The **Transform2D** that will flip something along the X axis.
+When any transform is multiplied by :ref:`FLIP_X<class_Transform2D_constant_FLIP_X>`, it negates all components of the :ref:`x<class_Transform2D_property_x>` axis (the X column).
+
+When :ref:`FLIP_X<class_Transform2D_constant_FLIP_X>` is multiplied by any basis, it negates the :ref:`Vector2.x<class_Vector2_property_x>` component of all axes (the X row).
 
 .. _class_Transform2D_constant_FLIP_Y:
 
@@ -189,7 +212,9 @@ The **Transform2D** that will flip something along the X axis.
 
 **FLIP_Y** = ``Transform2D(1, 0, 0, -1, 0, 0)`` :ref:`🔗<class_Transform2D_constant_FLIP_Y>`
 
-The **Transform2D** that will flip something along the Y axis.
+When any transform is multiplied by :ref:`FLIP_Y<class_Transform2D_constant_FLIP_Y>`, it negates all components of the :ref:`y<class_Transform2D_property_y>` axis (the Y column).
+
+When :ref:`FLIP_Y<class_Transform2D_constant_FLIP_Y>` is multiplied by any basis, it negates the :ref:`Vector2.y<class_Vector2_property_y>` component of all axes (the Y row).
 
 .. rst-class:: classref-section-separator
 
@@ -206,7 +231,7 @@ Property Descriptions
 
 :ref:`Vector2<class_Vector2>` **origin** = ``Vector2(0, 0)`` :ref:`🔗<class_Transform2D_property_origin>`
 
-The origin vector (column 2, the third column). Equivalent to array index ``2``. The origin vector represents translation.
+The translation offset of this transform, and the column ``2`` of the matrix. In 2D space, this can be seen as the position.
 
 .. rst-class:: classref-item-separator
 
@@ -218,7 +243,9 @@ The origin vector (column 2, the third column). Equivalent to array index ``2``.
 
 :ref:`Vector2<class_Vector2>` **x** = ``Vector2(1, 0)`` :ref:`🔗<class_Transform2D_property_x>`
 
-The basis matrix's X vector (column 0). Equivalent to array index ``0``.
+The transform basis's X axis, and the column ``0`` of the matrix. Combined with :ref:`y<class_Transform2D_property_y>`, this represents the transform's rotation, scale, and skew.
+
+On the identity transform, this vector points right (:ref:`Vector2.RIGHT<class_Vector2_constant_RIGHT>`).
 
 .. rst-class:: classref-item-separator
 
@@ -230,7 +257,9 @@ The basis matrix's X vector (column 0). Equivalent to array index ``0``.
 
 :ref:`Vector2<class_Vector2>` **y** = ``Vector2(0, 1)`` :ref:`🔗<class_Transform2D_property_y>`
 
-The basis matrix's Y vector (column 1). Equivalent to array index ``1``.
+The transform basis's Y axis, and the column ``1`` of the matrix. Combined with :ref:`x<class_Transform2D_property_x>`, this represents the transform's rotation, scale, and skew.
+
+On the identity transform, this vector points up (:ref:`Vector2.UP<class_Vector2_constant_UP>`).
 
 .. rst-class:: classref-section-separator
 
@@ -247,7 +276,7 @@ Constructor Descriptions
 
 :ref:`Transform2D<class_Transform2D>` **Transform2D**\ (\ ) :ref:`🔗<class_Transform2D_constructor_Transform2D>`
 
-Constructs a default-initialized **Transform2D** set to :ref:`IDENTITY<class_Transform2D_constant_IDENTITY>`.
+Constructs a **Transform2D** identical to :ref:`IDENTITY<class_Transform2D_constant_IDENTITY>`.
 
 .. rst-class:: classref-item-separator
 
@@ -267,7 +296,7 @@ Constructs a **Transform2D** as a copy of the given **Transform2D**.
 
 :ref:`Transform2D<class_Transform2D>` **Transform2D**\ (\ rotation\: :ref:`float<class_float>`, position\: :ref:`Vector2<class_Vector2>`\ )
 
-Constructs the transform from a given angle (in radians) and position.
+Constructs a **Transform2D** from a given angle (in radians) and position.
 
 .. rst-class:: classref-item-separator
 
@@ -277,7 +306,7 @@ Constructs the transform from a given angle (in radians) and position.
 
 :ref:`Transform2D<class_Transform2D>` **Transform2D**\ (\ rotation\: :ref:`float<class_float>`, scale\: :ref:`Vector2<class_Vector2>`, skew\: :ref:`float<class_float>`, position\: :ref:`Vector2<class_Vector2>`\ )
 
-Constructs the transform from a given angle (in radians), scale, skew (in radians) and position.
+Constructs a **Transform2D** from a given angle (in radians), scale, skew (in radians), and position.
 
 .. rst-class:: classref-item-separator
 
@@ -287,7 +316,7 @@ Constructs the transform from a given angle (in radians), scale, skew (in radian
 
 :ref:`Transform2D<class_Transform2D>` **Transform2D**\ (\ x_axis\: :ref:`Vector2<class_Vector2>`, y_axis\: :ref:`Vector2<class_Vector2>`, origin\: :ref:`Vector2<class_Vector2>`\ )
 
-Constructs the transform from 3 :ref:`Vector2<class_Vector2>` values representing :ref:`x<class_Transform2D_property_x>`, :ref:`y<class_Transform2D_property_y>`, and the :ref:`origin<class_Transform2D_property_origin>` (the three column vectors).
+Constructs a **Transform2D** from 3 :ref:`Vector2<class_Vector2>` values representing :ref:`x<class_Transform2D_property_x>`, :ref:`y<class_Transform2D_property_y>`, and the :ref:`origin<class_Transform2D_property_origin>` (the three matrix columns).
 
 .. rst-class:: classref-section-separator
 
@@ -304,7 +333,9 @@ Method Descriptions
 
 :ref:`Transform2D<class_Transform2D>` **affine_inverse**\ (\ ) |const| :ref:`🔗<class_Transform2D_method_affine_inverse>`
 
-Returns the inverse of the transform, under the assumption that the basis is invertible (must have non-zero determinant).
+Returns the inverted version of this transform. Unlike :ref:`inverse<class_Transform2D_method_inverse>`, this method works with almost any basis, including non-uniform ones, but is slower. See also :ref:`inverse<class_Transform2D_method_inverse>`.
+
+\ **Note:** For this method to return correctly, the transform's basis needs to have a determinant that is not exactly ``0`` (see :ref:`determinant<class_Transform2D_method_determinant>`).
 
 .. rst-class:: classref-item-separator
 
@@ -316,9 +347,7 @@ Returns the inverse of the transform, under the assumption that the basis is inv
 
 :ref:`Vector2<class_Vector2>` **basis_xform**\ (\ v\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Transform2D_method_basis_xform>`
 
-Returns a vector transformed (multiplied) by the basis matrix.
-
-This method does not account for translation (the :ref:`origin<class_Transform2D_property_origin>` vector).
+Returns a copy of the ``v`` vector, transformed (multiplied) by the transform basis's matrix. Unlike the multiplication operator (``*``), this method ignores the :ref:`origin<class_Transform2D_property_origin>`.
 
 .. rst-class:: classref-item-separator
 
@@ -330,13 +359,9 @@ This method does not account for translation (the :ref:`origin<class_Transform2D
 
 :ref:`Vector2<class_Vector2>` **basis_xform_inv**\ (\ v\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Transform2D_method_basis_xform_inv>`
 
-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 :ref:`origin<class_Transform2D_property_origin>` vector).
+Returns a copy of the ``v`` vector, transformed (multiplied) by the inverse transform basis's matrix (see :ref:`inverse<class_Transform2D_method_inverse>`). This method ignores the :ref:`origin<class_Transform2D_property_origin>`.
 
-\ ``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>`.
+\ **Note:** This method assumes that this transform's basis is *orthonormal* (see :ref:`orthonormalized<class_Transform2D_method_orthonormalized>`). If the basis is not orthonormal, ``transform.affine_inverse().basis_xform(vector)`` should be used instead (see :ref:`affine_inverse<class_Transform2D_method_affine_inverse>`).
 
 .. rst-class:: classref-item-separator
 
@@ -348,9 +373,13 @@ For non-orthonormal transforms (e.g. with scaling) ``transform.affine_inverse().
 
 :ref:`float<class_float>` **determinant**\ (\ ) |const| :ref:`🔗<class_Transform2D_method_determinant>`
 
-Returns the determinant of the basis matrix. If the basis is uniformly scaled, then its determinant equals the square of the scale factor.
+Returns the `determinant <https://en.wikipedia.org/wiki/Determinant>`__ of this transform basis's matrix. For advanced math, this number can be used to determine a few attributes:
+
+- If the determinant is exactly ``0``, the basis is not invertible (see :ref:`inverse<class_Transform2D_method_inverse>`).
 
-A negative determinant means the basis was flipped, so one part of the scale is negative. A zero determinant means the basis isn't invertible, and is usually considered invalid.
+- If the determinant is a negative number, the basis represents a negative scale.
+
+\ **Note:** If the basis's scale is the same for every axis, its determinant is always that scale by the power of 2.
 
 .. rst-class:: classref-item-separator
 
@@ -362,7 +391,7 @@ A negative determinant means the basis was flipped, so one part of the scale is
 
 :ref:`Vector2<class_Vector2>` **get_origin**\ (\ ) |const| :ref:`🔗<class_Transform2D_method_get_origin>`
 
-Returns the transform's origin (translation).
+Returns this transform's translation. Equivalent to :ref:`origin<class_Transform2D_property_origin>`.
 
 .. rst-class:: classref-item-separator
 
@@ -374,7 +403,7 @@ Returns the transform's origin (translation).
 
 :ref:`float<class_float>` **get_rotation**\ (\ ) |const| :ref:`🔗<class_Transform2D_method_get_rotation>`
 
-Returns the transform's rotation (in radians).
+Returns this transform's rotation (in radians). This is equivalent to :ref:`x<class_Transform2D_property_x>`'s angle (see :ref:`Vector2.angle<class_Vector2_method_angle>`).
 
 .. rst-class:: classref-item-separator
 
@@ -386,7 +415,38 @@ Returns the transform's rotation (in radians).
 
 :ref:`Vector2<class_Vector2>` **get_scale**\ (\ ) |const| :ref:`🔗<class_Transform2D_method_get_scale>`
 
-Returns the scale.
+Returns the length of both :ref:`x<class_Transform2D_property_x>` and :ref:`y<class_Transform2D_property_y>`, as a :ref:`Vector2<class_Vector2>`. If this transform's basis is not skewed, this value is the scaling factor. It is not affected by rotation.
+
+
+.. tabs::
+
+ .. code-tab:: gdscript
+
+    var my_transform = Transform2D(
+        Vector2(2, 0),
+        Vector2(0, 4),
+        Vector2(0, 0)
+    )
+    # Rotating the Transform2D in any way preserves its scale.
+    my_transform = my_transform.rotated(TAU / 2)
+    
+    print(my_transform.get_scale()) # Prints (2, 4).
+
+ .. code-tab:: csharp
+
+    var myTransform = new Transform2D(
+        Vector3(2.0f, 0.0f),
+        Vector3(0.0f, 4.0f),
+        Vector3(0.0f, 0.0f)
+    );
+    // Rotating the Transform2D in any way preserves its scale.
+    myTransform = myTransform.Rotated(Mathf.Tau / 2.0f);
+    
+    GD.Print(myTransform.GetScale()); // Prints (2, 4, 8).
+
+
+
+\ **Note:** If the value returned by :ref:`determinant<class_Transform2D_method_determinant>` is negative, the scale is also negative.
 
 .. rst-class:: classref-item-separator
 
@@ -398,7 +458,7 @@ Returns the scale.
 
 :ref:`float<class_float>` **get_skew**\ (\ ) |const| :ref:`🔗<class_Transform2D_method_get_skew>`
 
-Returns the transform's skew (in radians).
+Returns this transform's skew (in radians).
 
 .. rst-class:: classref-item-separator
 
@@ -410,7 +470,9 @@ Returns the transform's skew (in radians).
 
 :ref:`Transform2D<class_Transform2D>` **interpolate_with**\ (\ xform\: :ref:`Transform2D<class_Transform2D>`, weight\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Transform2D_method_interpolate_with>`
 
-Returns a transform interpolated between this transform and another by a given ``weight`` (on the range of 0.0 to 1.0).
+Returns the result of the linear interpolation between this transform and ``xform`` by the given ``weight``.
+
+The ``weight`` should be between ``0.0`` and ``1.0`` (inclusive). Values outside this range are allowed and can be used to perform *extrapolation* instead.
 
 .. rst-class:: classref-item-separator
 
@@ -422,7 +484,9 @@ Returns a transform interpolated between this transform and another by a given `
 
 :ref:`Transform2D<class_Transform2D>` **inverse**\ (\ ) |const| :ref:`🔗<class_Transform2D_method_inverse>`
 
-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).
+Returns the `inverted version of this transform <https://en.wikipedia.org/wiki/Invertible_matrix>`__.
+
+\ **Note:** For this method to return correctly, the transform's basis needs to be *orthonormal* (see :ref:`orthonormalized<class_Transform2D_method_orthonormalized>`). That means, the basis should only represent a rotation. If it does not, use :ref:`affine_inverse<class_Transform2D_method_affine_inverse>` instead.
 
 .. rst-class:: classref-item-separator
 
@@ -434,7 +498,7 @@ Returns the inverse of the transform, under the assumption that the transformati
 
 :ref:`bool<class_bool>` **is_conformal**\ (\ ) |const| :ref:`🔗<class_Transform2D_method_is_conformal>`
 
-Returns ``true`` if the transform's basis is conformal, meaning it preserves angles and distance ratios, and may only be composed of rotation and uniform scale. Returns ``false`` if the transform's basis has non-uniform scale or shear/skew. This can be used to validate if the transform is non-distorted, which is important for physics and other use cases.
+Returns ``true`` if this transform's basis is conformal. A conformal basis is both *orthogonal* (the axes are perpendicular to each other) and *uniform* (the axes share the same length). This method can be especially useful during physics calculations.
 
 .. rst-class:: classref-item-separator
 
@@ -470,9 +534,7 @@ Returns ``true`` if this transform is finite, by calling :ref:`@GlobalScope.is_f
 
 :ref:`Transform2D<class_Transform2D>` **looking_at**\ (\ target\: :ref:`Vector2<class_Vector2>` = Vector2(0, 0)\ ) |const| :ref:`🔗<class_Transform2D_method_looking_at>`
 
-Returns a copy of the transform rotated such that the rotated X-axis points towards the ``target`` position.
-
-Operations take place in global space.
+Returns a copy of the transform rotated such that the rotated X-axis points towards the ``target`` position, in global space.
 
 .. rst-class:: classref-item-separator
 
@@ -484,7 +546,7 @@ Operations take place in global space.
 
 :ref:`Transform2D<class_Transform2D>` **orthonormalized**\ (\ ) |const| :ref:`🔗<class_Transform2D_method_orthonormalized>`
 
-Returns the transform with the basis orthogonal (90 degrees), and normalized axis vectors (scale of 1 or -1).
+Returns a copy of this transform with its basis orthonormalized. An orthonormal basis is both *orthogonal* (the axes are perpendicular to each other) and *normalized* (the axes have a length of ``1``), which also means it can only represent rotation.
 
 .. rst-class:: classref-item-separator
 
@@ -597,7 +659,7 @@ Operator Descriptions
 
 :ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`Transform2D<class_Transform2D>`\ ) :ref:`🔗<class_Transform2D_operator_neq_Transform2D>`
 
-Returns ``true`` if the transforms are not equal.
+Returns ``true`` if the components of both transforms are not equal.
 
 \ **Note:** Due to floating-point precision errors, consider using :ref:`is_equal_approx<class_Transform2D_method_is_equal_approx>` instead, which is more reliable.
 
@@ -611,7 +673,9 @@ Returns ``true`` if the transforms are not equal.
 
 :ref:`PackedVector2Array<class_PackedVector2Array>` **operator ***\ (\ right\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) :ref:`🔗<class_Transform2D_operator_mul_PackedVector2Array>`
 
-Transforms (multiplies) each element of the :ref:`Vector2<class_Vector2>` array by the given **Transform2D** matrix.
+Transforms (multiplies) every :ref:`Vector2<class_Vector2>` element of the given :ref:`PackedVector2Array<class_PackedVector2Array>` by this transformation matrix.
+
+On larger arrays, this operation is much faster than transforming each :ref:`Vector2<class_Vector2>` individually.
 
 .. rst-class:: classref-item-separator
 
@@ -623,7 +687,7 @@ Transforms (multiplies) each element of the :ref:`Vector2<class_Vector2>` array
 
 :ref:`Rect2<class_Rect2>` **operator ***\ (\ right\: :ref:`Rect2<class_Rect2>`\ ) :ref:`🔗<class_Transform2D_operator_mul_Rect2>`
 
-Transforms (multiplies) the :ref:`Rect2<class_Rect2>` by the given **Transform2D** matrix.
+Transforms (multiplies) the :ref:`Rect2<class_Rect2>` by this transformation matrix.
 
 .. rst-class:: classref-item-separator
 
@@ -635,7 +699,17 @@ Transforms (multiplies) the :ref:`Rect2<class_Rect2>` by the given **Transform2D
 
 :ref:`Transform2D<class_Transform2D>` **operator ***\ (\ right\: :ref:`Transform2D<class_Transform2D>`\ ) :ref:`🔗<class_Transform2D_operator_mul_Transform2D>`
 
-Composes these two transformation matrices by multiplying them together. This has the effect of transforming the second transform (the child) by the first transform (the parent).
+Transforms (multiplies) this transform by the ``right`` transform.
+
+This is the operation performed between parent and child :ref:`CanvasItem<class_CanvasItem>` nodes.
+
+\ **Note:** If you need to only modify one attribute of this transform, consider using one of the following methods, instead:
+
+- For translation, see :ref:`translated<class_Transform2D_method_translated>` or :ref:`translated_local<class_Transform2D_method_translated_local>`.
+
+- For rotation, see :ref:`rotated<class_Transform2D_method_rotated>` or :ref:`rotated_local<class_Transform2D_method_rotated_local>`.
+
+- For scale, see :ref:`scaled<class_Transform2D_method_scaled>` or :ref:`scaled_local<class_Transform2D_method_scaled_local>`.
 
 .. rst-class:: classref-item-separator
 
@@ -647,7 +721,7 @@ Composes these two transformation matrices by multiplying them together. This ha
 
 :ref:`Vector2<class_Vector2>` **operator ***\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Transform2D_operator_mul_Vector2>`
 
-Transforms (multiplies) the :ref:`Vector2<class_Vector2>` by the given **Transform2D** matrix.
+Transforms (multiplies) the :ref:`Vector2<class_Vector2>` by this transformation matrix.
 
 .. rst-class:: classref-item-separator
 
@@ -659,7 +733,7 @@ Transforms (multiplies) the :ref:`Vector2<class_Vector2>` by the given **Transfo
 
 :ref:`Transform2D<class_Transform2D>` **operator ***\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_Transform2D_operator_mul_float>`
 
-This operator multiplies all components of the **Transform2D**, including the :ref:`origin<class_Transform2D_property_origin>` vector, which scales it uniformly.
+Multiplies all components of the **Transform2D** by the given :ref:`float<class_float>`, including the :ref:`origin<class_Transform2D_property_origin>`. This affects the transform's scale uniformly.
 
 .. rst-class:: classref-item-separator
 
@@ -671,7 +745,7 @@ This operator multiplies all components of the **Transform2D**, including the :r
 
 :ref:`Transform2D<class_Transform2D>` **operator ***\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Transform2D_operator_mul_int>`
 
-This operator multiplies all components of the **Transform2D**, including the :ref:`origin<class_Transform2D_property_origin>` vector, which scales it uniformly.
+Multiplies all components of the **Transform2D** by the given :ref:`int<class_int>`, including the :ref:`origin<class_Transform2D_property_origin>`. This affects the transform's scale uniformly.
 
 .. rst-class:: classref-item-separator
 
@@ -683,7 +757,7 @@ This operator multiplies all components of the **Transform2D**, including the :r
 
 :ref:`Transform2D<class_Transform2D>` **operator /**\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_Transform2D_operator_div_float>`
 
-This operator divides all components of the **Transform2D**, including the :ref:`origin<class_Transform2D_property_origin>` vector, which inversely scales it uniformly.
+Divides all components of the **Transform2D** by the given :ref:`float<class_float>`, including the :ref:`origin<class_Transform2D_property_origin>`. This affects the transform's scale uniformly.
 
 .. rst-class:: classref-item-separator
 
@@ -695,7 +769,7 @@ This operator divides all components of the **Transform2D**, including the :ref:
 
 :ref:`Transform2D<class_Transform2D>` **operator /**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Transform2D_operator_div_int>`
 
-This operator divides all components of the **Transform2D**, including the :ref:`origin<class_Transform2D_property_origin>` vector, which inversely scales it uniformly.
+Divides all components of the **Transform2D** by the given :ref:`int<class_int>`, including the :ref:`origin<class_Transform2D_property_origin>`. This affects the transform's scale uniformly.
 
 .. rst-class:: classref-item-separator
 
@@ -707,7 +781,7 @@ This operator divides all components of the **Transform2D**, including the :ref:
 
 :ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`Transform2D<class_Transform2D>`\ ) :ref:`🔗<class_Transform2D_operator_eq_Transform2D>`
 
-Returns ``true`` if the transforms are exactly equal.
+Returns ``true`` if the components of both transforms are exactly equal.
 
 \ **Note:** Due to floating-point precision errors, consider using :ref:`is_equal_approx<class_Transform2D_method_is_equal_approx>` instead, which is more reliable.
 
@@ -721,7 +795,7 @@ Returns ``true`` if the transforms are exactly equal.
 
 :ref:`Vector2<class_Vector2>` **operator []**\ (\ index\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Transform2D_operator_idx_int>`
 
-Access transform components using their index. ``t[0]`` is equivalent to ``t.x``, ``t[1]`` is equivalent to ``t.y``, and ``t[2]`` is equivalent to ``t.origin``.
+Accesses each axis (column) of this transform by their index. Index ``0`` is the same as :ref:`x<class_Transform2D_property_x>`, index ``1`` is the same as :ref:`y<class_Transform2D_property_y>`, and index ``2`` is the same as :ref:`origin<class_Transform2D_property_origin>`.
 
 .. |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_xrinterface.rst

@@ -704,6 +704,14 @@ Triggers a haptic pulse on a device associated with this interface.
 
 \ ``tracker_name`` is optional and can be used to direct the pulse to a specific device provided that device is bound to this haptic.
 
+\ ``frequency`` is the frequency of the pulse, set to ``0.0`` to have the system use a default frequency.
+
+\ ``amplitude`` is the amplitude of the pulse between ``0.0`` and ``1.0``.
+
+\ ``duration_sec`` is the duration of the pulse in seconds.
+
+\ ``delay_sec`` is a delay in seconds before the pulse is given.
+
 .. rst-class:: classref-item-separator
 
 ----

classes/class_xrnode3d.rst

@@ -196,6 +196,14 @@ Triggers a haptic pulse on a device associated with this interface.
 
 \ ``action_name`` is the name of the action for this pulse.
 
+\ ``frequency`` is the frequency of the pulse, set to ``0.0`` to have the system use a default frequency.
+
+\ ``amplitude`` is the amplitude of the pulse between ``0.0`` and ``1.0``.
+
+\ ``duration_sec`` is the duration of the pulse in seconds.
+
+\ ``delay_sec`` is a delay in seconds before the pulse is given.
+
 .. |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.)`
 .. |vararg| replace:: :abbr:`vararg (This method accepts any number of arguments after the ones described here.)`