Merge pull request #9648 from mhilbrunner/4.2-cherrypicks

4.2 cherrypicks

.github/workflows/sync_class_ref.yml

@@ -46,7 +46,7 @@ jobs:
           ./.engine-src/doc/tools/make_rst.py --color -o ./classes -l en ./.engine-src/doc/classes ./.engine-src/modules ./.engine-src/platform
 
       - name: Submit a pull-request
-        uses: peter-evans/create-pull-request@v5
+        uses: peter-evans/create-pull-request@v6
         with:
           commit-message: 'classref: Sync with current ${{ env.engine_rev }} branch (${{ steps.engine.outputs.rev_hash_short }})'
           branch: 'classref/sync-${{ steps.engine.outputs.rev_hash_short }}'

README.md

@@ -6,17 +6,7 @@ They are meant to be parsed with the [Sphinx](https://www.sphinx-doc.org/) docum
 
 ## Download for offline use
 
-To browse the documentation offline, you can use the mirror of the documentation
-hosted on [DevDocs](https://devdocs.io/godot/). To enable offline browsing on
-DevDocs, you need to:
-
-- Click the three dots in the top-left corner, choose **Preferences**.
-- Enable the desired version of the Godot documentation by checking the box
-  next to it in the sidebar.
-- Click the three dots in the top-left corner, choose **Offline data**.
-- Click the **Install** link next to the Godot documentation.
-
-You can also
+To browse the documentation offline, you can
 [download an HTML copy](https://nightly.link/godotengine/godot-docs/workflows/build_offline_docs/master/godot-docs-html-master.zip)
 for offline reading (updated every Monday). Extract the ZIP archive then open
 the top-level `index.html` in a web browser.

_static/css/custom.css

@@ -681,6 +681,7 @@ footer {
 .wy-body-for-nav {
     position: relative;
     background-color: var(--content-wrap-background-color);
+    overflow: visible;
 }
 
 @media only screen and (min-width: 769px) {

_tools/codespell-ignore.txt

@@ -5,3 +5,4 @@ que
 raison
 uint
 implementors
+thirdparty

_tools/redirects/redirects.csv

@@ -30,6 +30,7 @@ source,destination
 /contributing/development/core_and_modules/introduction_to_godot_development.html,/contributing/development/core_and_modules/index.html
 /contributing/doc_and_l10n_guidelines.html,/community/contributing/doc_and_l10n_guidelines.html
 /contributing/updating_the_class_reference.html,/community/contributing/updating_the_class_reference.html
+/contributing/ways_to_contribute.html,/contributing/how_to_contribute.html
 /development/compiling/compiling_for_android.html,/contributing/development/compiling/compiling_for_android.html
 /development/compiling/compiling_for_ios.html,/contributing/development/compiling/compiling_for_ios.html
 /development/compiling/compiling_for_linuxbsd.html,/contributing/development/compiling/compiling_for_linuxbsd.html

about/faq.rst

@@ -9,7 +9,7 @@ Frequently asked questions
 What can I do with Godot? How much does it cost? What are the license terms?
 ----------------------------------------------------------------------------
 
-Godot is `Free and open source Software <https://en.wikipedia.org/wiki/Free_and_open source_software>`_
+Godot is `Free and open source Software <https://en.wikipedia.org/wiki/Free_and_open_source_software>`_
 available under the `OSI-approved <https://opensource.org/licenses/MIT>`_ MIT license. This means it is
 free as in "free speech" as well as in "free beer."
 

about/release_policy.rst

@@ -273,5 +273,4 @@ compatibility-breaking changes of this kind.
       optional parameter), a GDExtension compatibility method must be created.
       This ensures that existing GDExtensions continue to work across patch and
       minor releases, so that users don't have to recompile them.
-      See `pull request #76446 <https://github.com/godotengine/godot/pull/76446>`_
-      for more information.
+      See :ref:`doc_handling_compatibility_breakages` for more information.

community/asset_library/submitting_to_assetlib.rst

@@ -178,6 +178,10 @@ is required in the submission form here as well.
     The **icon** must be square (1:1 aspect ratio). It should have a minimum
     resolution of 128×128 pixels.
 
+.. note::
+
+    For icons hosted on GitHub, URLs must be provided in the form of `https://raw.githubusercontent.com/<user>/<project>/<branch>/Icon.png`.
+
 * **License**:
     The license under which you are distributing the asset. The list
     includes a variety of free and open source software licenses, such as GPL

community/channels.rst

@@ -40,7 +40,7 @@ Social networks and other sites
 - `YouTube <https://www.youtube.com/c/GodotEngineOfficial>`_
 - `Steam <https://steamcommunity.com/app/404790>`_
 - `itch.io <https://godotengine.itch.io/godot>`_
-- `linkin.bio <https://linkin.bio/godot>`_
+- `Links <https://links.godotengine.org>`_
 
 Language-based communities
 --------------------------

community/tutorials.rst

@@ -59,4 +59,3 @@ Resources
 - `awesome-godot: A curated list of free/libre plugins, scripts and add-ons <https://github.com/godotengine/awesome-godot>`_
 - `Godot Asset Library <https://godotengine.org/asset-library/asset>`_
 - `Godot Shaders: A community-driven shader library <https://godotshaders.com/>`_
-- `Zeef Godot Engine: A curated directory of resources by Andre Schmitz <https://godot-engine.zeef.com/andre.antonio.schmitz>`_

conf.py

@@ -315,3 +315,6 @@ rst_epilog = """
     image_locale="-" if language == "en" else language,
     target_locale="" if language == "en" else "/" + language,
 )
+
+# Needed so the table of contents is created for EPUB
+epub_tocscope = 'includehidden'

contributing/development/compiling/compiling_for_linuxbsd.rst

@@ -345,10 +345,14 @@ and named like this (even for \*BSD which is seen as "Linux/X11" by Godot):
 
 ::
 
-    linux_x11_32_debug
-    linux_x11_32_release
-    linux_x11_64_debug
-    linux_x11_64_release
+    linux_debug.arm32
+    linux_debug.arm64
+    linux_debug.x86_32
+    linux_debug.x86_64
+    linux_release.arm32
+    linux_release.arm64
+    linux_release.x86_32
+    linux_release.x86_64
 
 However, if you are writing your custom modules or custom C++ code, you
 might instead want to configure your binaries as custom export templates

contributing/development/compiling/compiling_for_windows.rst

@@ -188,7 +188,7 @@ Cross-compiling for Windows from other operating systems
 --------------------------------------------------------
 
 If you are a Linux or macOS user, you need to install
-`MinGW-w64 <https://mingw-w64.org/doku.php>`__, which typically comes in 32-bit
+`MinGW-w64 <https://www.mingw-w64.org/>`__, which typically comes in 32-bit
 and 64-bit variants. The package names may differ based on your distribution,
 here are some known ones:
 
@@ -281,18 +281,22 @@ with the following flags:
 
 If you plan on replacing the standard export templates, copy these to the
 following location, replacing ``<version>`` with the version identifier
-(such as ``3.1.1.stable`` or ``3.2.dev``):
+(such as ``4.2.1.stable`` or ``4.3.dev``):
 
 .. code-block:: none
 
-    %USERPROFILE%\AppData\Roaming\Godot\templates\<version>\
+    %APPDATA%\Godot\export_templates\<version>\
 
 With the following names::
 
-    windows_32_debug.exe
-    windows_32_release.exe
-    windows_64_debug.exe
-    windows_64_release.exe
+    windows_debug_x86_32_console.exe
+    windows_debug_x86_32.exe
+    windows_debug_x86_64_console.exe
+    windows_debug_x86_64.exe
+    windows_release_x86_32_console.exe
+    windows_release_x86_32.exe
+    windows_release_x86_64_console.exe
+    windows_release_x86_64.exe
 
 However, if you are using custom modules or custom engine code, you
 may instead want to configure your binaries as custom export templates

contributing/development/compiling/cross-compiling_for_ios_on_linux.rst

@@ -24,94 +24,61 @@ described here and cross-compiling the binary.
 Requirements
 ------------
 
-- `XCode with the iOS SDK <https://developer.apple.com/xcode/download>`__
-  (a dmg image, for newer versions a **xip** file is going to be downloaded.)
+- `XCode with the iOS SDK <https://developer.apple.com/download/all/?q=Xcode>`__
+  (you must be logged into an Apple ID to download Xcode).
 - `Clang >= 3.5 <https://clang.llvm.org>`__ for your development
   machine installed and in the ``PATH``. It has to be version >= 3.5
   to target ``arm64`` architecture.
-- `Fuse <https://github.com/libfuse/libfuse>`__ for mounting and unmounting
-  the dmg image.
-- `darling-dmg <https://github.com/darlinghq/darling-dmg>`__, which
-  needs to be built from source. The procedure for that is explained
-  below.
-
-    - For newer versions you should download `xar <https://mackyle.github.io/xar/>`__
-      and `pbzx <https://github.com/NiklasRosenstein/pbzx>`__.
-    - For building darling-dmg, you'll need the development packages of
-      the following libraries: fuse, icu, openssl, zlib, bzip2.
-    - For building xar and pbzx you may want to follow
-      `this guide <https://gist.github.com/phracker/1944ce190e01963c550566b749bd2b54>`__.
+- `xar <https://mackyle.github.io/xar/>`__ and `pbzx <https://github.com/NiklasRosenstein/pbzx>`__
+  (required to extract the ``.xip`` archive Xcode comes in).
+
+  - For building xar and pbzx, you may want to follow
+    `this guide <https://gist.github.com/phracker/1944ce190e01963c550566b749bd2b54>`__.
 
 - `cctools-port <https://github.com/tpoechtrager/cctools-port>`__
   for the needed build tools. The procedure for building is quite
   peculiar and is described below.
 
-    - This also has some extra dependencies: automake, autogen, libtool.
+  - This also has some extra dependencies: automake, autogen, libtool.
 
 Configuring the environment
 ---------------------------
 
-darling-dmg
-~~~~~~~~~~~
-
-Clone the repository on your machine:
-
-::
-
-    $ git clone https://github.com/darlinghq/darling-dmg.git
-
-Build it:
-
-::
-
-    $ cd darling-dmg
-    $ mkdir build
-    $ cd build
-    $ cmake .. -DCMAKE_BUILD_TYPE=Release
-    $ make -j 4  # The number is the amount of cores your processor has, for faster build
-    $ cd ../..
-
 Preparing the SDK
 ~~~~~~~~~~~~~~~~~
 
-Mount the XCode image:
+Extract the Xcode ``.xip`` file you downloaded from Apple's developer website:
 
 ::
 
-    $ mkdir xcode
-    $ ./darling-dmg/build/darling-dmg /path/to/Xcode_7.1.1.dmg xcode
-    [...]
-    Everything looks OK, disk mounted
-
-
-For newer versions you should extract the **xip** file:
-
-::
+    mkdir xcode
+    xar -xf /path/to/Xcode_X.x.xip -C xcode
+    pbzx -n Content | cpio -i
 
-    $ mkdir xcode
-    $ xar -xf /path/to/Xcode_X.x.xip -C xcode
-    $ pbzx -n Content | cpio -i
     [...]
     ######### Blocks
 
-Note that for the commands below, you may need to replace the version (`X.x`) with whatever iOS SDK version you're using.
+Note that for the commands below, you will need to replace the version (``x.x``)
+with whatever iOS SDK version you're using. If you don't know your iPhone SDK
+version, you can see the JSON file inside of
+``Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs``.
 
 Extract the iOS SDK:
 
 ::
 
-    $ # If you don't know your iPhone SDK version you can see the json file inside of Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs
-    $ mkdir -p iPhoneSDK/iPhoneOSX.x.sdk
-    $ cp -r xcode/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/* iPhoneSDK/iPhoneOSX.x.sdk
-    $ cp -r xcode/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include/c++/* iPhoneSDK/iPhoneOSX.x.sdk/usr/include/c++
-    $ fusermount -u xcode  # unmount the image
+    export IOS_SDK_VERSION="x.x"
+    mkdir -p iPhoneSDK/iPhoneOS${IOS_SDK_VERSION}.sdk
+    cp -r xcode/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/* iPhoneSDK/iPhoneOS${IOS_SDK_VERSION}.sdk
+    cp -r xcode/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include/c++/* iPhoneSDK/iPhoneOS${IOS_SDK_VERSION}.sdk/usr/include/c++
+    fusermount -u xcode
 
-Pack the SDK:
+Pack the SDK so that cctools can use it:
 
 ::
 
-    $ cd iPhoneSDK
-    $ tar -cf - * | xz -9 -c - > iPhoneOSX.x.sdk.tar.xz
+    cd iPhoneSDK
+    tar -cf - * | xz -9 -c - > iPhoneOS${IOS_SDK_VERSION}.sdk.tar.xz
 
 Toolchain
 ~~~~~~~~~
@@ -120,9 +87,9 @@ Build cctools:
 
 ::
 
-    $ git clone https://github.com/tpoechtrager/cctools-port.git
-    $ cd cctools-port/usage_examples/ios_toolchain
-    $ ./build.sh /path/iPhoneOSX.x.sdk.tar.xz arm64
+    git clone https://github.com/tpoechtrager/cctools-port.git
+    cd cctools-port/usage_examples/ios_toolchain
+    ./build.sh /path/iPhoneOS${IOS_SDK_VERSION}.sdk.tar.xz arm64
 
 Copy the tools to a nicer place. Note that the SCons scripts for
 building will look under ``usr/bin`` inside the directory you provide
@@ -131,11 +98,11 @@ to the following commands:
 
 ::
 
-    $ mkdir -p /home/user/iostoolchain/usr
-    $ cp -r target/bin /home/user/iostoolchain/usr/
+    mkdir -p "$HOME/iostoolchain/usr"
+    cp -r target/bin "$HOME/iostoolchain/usr/"
 
 Now you should have the iOS toolchain binaries in
-``/home/user/iostoolchain/usr/bin``.
+``$HOME/iostoolchain/usr/bin``.
 
 Compiling Godot for iPhone
 --------------------------
@@ -150,11 +117,11 @@ environment variable defined to anything.
 
 ::
 
-    $ export OSXCROSS_IOS=anything
+    export OSXCROSS_IOS="anything"
 
 Now you can compile for iPhone using SCons like the standard Godot
 way, with some additional arguments to provide the correct paths:
 
 ::
 
-    $ scons -j 4 platform=ios arch=arm64 target=template_release IOS_SDK_PATH="/path/to/iPhoneSDK" IOS_TOOLCHAIN_PATH="/path/to/iostoolchain" ios_triple="arm-apple-darwin11-"
+    scons platform=ios arch=arm64 target=template_release IOS_SDK_PATH="/path/to/iPhoneSDK" IOS_TOOLCHAIN_PATH="/path/to/iostoolchain" ios_triple="arm-apple-darwin11-"

contributing/development/compiling/introduction_to_the_buildsystem.rst

@@ -12,16 +12,16 @@ that compiling Godot from source can be as simple as running::
 
     scons
 
-This produces an *export template* for your current platform, operating system, and architecture.
-An export template is a build of the engine that is used for running exported projects. To build
-the *editor* instead you can run the following command::
+This produces an editor build for your current platform, operating system, and architecture.
+You can change what gets built by specifying a target, a platform, and/or an architecture.
+For example, to build an export template used for running exported games, you can run::
 
-    scons target=editor
+    scons target=template_release
 
-If you plan to debug or develop the engine, then you might want to add another option to the command::
+If you plan to debug or develop the engine, then you might want to enable the ``dev_build``
+option to enable dev-only debugging code::
 
     scons dev_build=yes
-    scons target=editor dev_build=yes
 
 Following sections in the article will explain these and other universal options in more detail. But
 before you can compile Godot, you need to install a few prerequisites. Please refer to the platform
@@ -422,20 +422,34 @@ platform:
 
     android_debug.apk
     android_release.apk
-    web_debug.zip
-    web_release.zip
-    linux_server_32
-    linux_server_64
-    linux_x11_32_debug
-    linux_x11_32_release
-    linux_x11_64_debug
-    linux_x11_64_release
+    android_source.zip
+    ios.zip
+    linux_debug.arm32
+    linux_debug.arm64
+    linux_debug.x86_32
+    linux_debug.x86_64
+    linux_release.arm32
+    linux_release.arm64
+    linux_release.x86_32
+    linux_release.x86_64
     macos.zip
     version.txt
-    windows_32_debug.exe
-    windows_32_release.exe
-    windows_64_debug.exe
-    windows_64_release.exe
+    web_debug.zip
+    web_dlink_debug.zip
+    web_dlink_nothreads_debug.zip
+    web_dlink_nothreads_release.zip
+    web_dlink_release.zip
+    web_nothreads_debug.zip
+    web_nothreads_release.zip
+    web_release.zip
+    windows_debug_x86_32_console.exe
+    windows_debug_x86_32.exe
+    windows_debug_x86_64_console.exe
+    windows_debug_x86_64.exe
+    windows_release_x86_32_console.exe
+    windows_release_x86_32.exe
+    windows_release_x86_64_console.exe
+    windows_release_x86_64.exe
 
 To create those yourself, follow the instructions detailed for each
 platform in this same tutorial section. Each platform explains how to

contributing/development/configuring_an_ide/visual_studio_code.rst

@@ -112,6 +112,10 @@ To run and debug the project you need to create a new configuration in the ``lau
           "description": "Enable pretty-printing for gdb",
           "text": "-enable-pretty-printing",
           "ignoreFailures": true
+        },
+        {
+            "description": "Load custom pretty-printers for Godot types.",
+            "text": "source ${workspaceRoot}/misc/scripts/godot_gdb_pretty_print.py"
         }
       ],
       "preLaunchTask": "build"
@@ -156,6 +160,60 @@ The name under ``program`` depends on your build configuration,
 e.g. ``godot.linuxbsd.editor.dev.x86_64`` for 64-bit LinuxBSD platform with
 ``target=editor`` and ``dev_build=yes``.
 
+Configuring Intellisense
+------------------------
+
+For the C/C++ extension:
+
+To fix include errors you may be having, you need to configure some settings in the ``c_cpp_properties.json`` file.
+
+- First, make sure to build the project since some files need to be generated.
+
+- Edit the C/C++ Configuration file either with the UI or with text:
+
+.. figure:: img/vscode_edit_configurations.webp
+   :align: center
+
+- Add an include path for your platform, for example, ``${workspaceFolder}/platform/windows``.
+
+- Add defines for the editor ``TOOLS_ENABLED``, debug builds ``DEBUG_ENABLED``, and tests ``TESTS_ENABLED``.
+
+- Make sure the compiler path is configured correctly to the compiler you are using. See :ref:`doc_introduction_to_the_buildsystem` for further information on your platform.
+
+- The ``c_cpp_properties.json`` file should look similar to this for Windows:
+
+  .. code-block:: js
+
+    {
+      "configurations": [
+        {
+          "name": "Win32",
+          "includePath": [
+            "${workspaceFolder}/**",
+            "${workspaceFolder}/platform/windows"
+          ],
+          "defines": [
+            "_DEBUG",
+            "UNICODE",
+            "_UNICODE",
+            "TOOLS_ENABLED",
+            "DEBUG_ENABLED",
+            "TESTS_ENABLED"
+          ],
+          "windowsSdkVersion": "10.0.22621.0",
+          "compilerPath": "C:/Program Files/Microsoft Visual Studio/2022/Community/VC/Tools/MSVC/14.39.33519/bin/Hostx64/x64/cl.exe",
+          "cStandard": "c17",
+          "cppStandard": "c++17",
+          "intelliSenseMode": "windows-msvc-x64"
+        }
+      ],
+      "version": 4
+    }
+
+- Alternatively, you can use the scons argument ``compiledb=yes`` and set the compile commands setting ``compileCommands`` to ``compile_commands.json``, found in the advanced section of the C/C++ Configuration UI.
+
+  - This argument can be added to your build task in ``tasks.json`` since it will need to be run whenever files are added or moved.
+
 If you run into any issues, ask for help in one of
 `Godot's community channels <https://godotengine.org/community>`__.
 

contributing/development/core_and_modules/inheritance_class_tree.rst

@@ -4,26 +4,26 @@ Inheritance class tree
 Object
 ------
 
-.. image:: img/Object.png
+.. image:: img/Object.webp
 
 Reference
 ---------
 
-.. image:: img/Reference.png
+.. image:: img/RefCounted.webp
 
 Control
 -------
 
-.. image:: img/Control.png
+.. image:: img/Control.webp
 
 Node2D
 ------
 
-.. image:: img/Node2D.png
+.. image:: img/Node2D.webp
 
 Node3D
 ------
 
-.. image:: img/Spatial.png
+.. image:: img/Node3D.webp
 
 Source files: :download:`class_tree.zip <files/class_tree.zip>`.

contributing/development/handling_compatibility_breakages.rst

@@ -0,0 +1,141 @@
+.. _doc_handling_compatibility_breakages:
+
+Handling compatibility breakages
+================================
+
+.. TODO: Elaborate on types of compatibility and procedure.
+
+So you've added a new parameter to a method, changed the return type,
+changed the type of a parameter, or changed its default value,
+and now the automated testing is complaining about compatibility breakages?
+
+Breaking compatibility should be avoided, but when necessary there are systems in place
+to handle this in a way that makes the transition as smooth as possible.
+
+A practical example
+-------------------
+
+.. TODO: Add example that showcases more details like original default arguments etc.
+
+These changes are taken from `pull request #88047 <https://github.com/godotengine/godot/pull/88047>`_, which added
+new pathing options to ``AStarGrid2D`` and other AStar classes.
+Among other changes, these methods were modified in ``core/math/a_star_grid_2d.h``:
+
+.. code-block:: cpp
+
+    Vector<Vector2> get_point_path(const Vector2i &p_from, const Vector2i &p_to);
+    TypedArray<Vector2i> get_id_path(const Vector2i &p_from, const Vector2i &p_to);
+
+To:
+
+.. code-block:: cpp
+
+    Vector<Vector2> get_point_path(const Vector2i &p_from, const Vector2i &p_to, bool p_allow_partial_path = false);
+    TypedArray<Vector2i> get_id_path(const Vector2i &p_from, const Vector2i &p_to, bool p_allow_partial_path = false);
+
+This meant adding new compatibility method bindings to the file, which should be in the ``protected`` section of
+the code, usually placed next to ``_bind_methods()``:
+
+.. code-block:: cpp
+
+    #ifndef DISABLE_DEPRECATED
+        TypedArray<Vector2i> _get_id_path_bind_compat_88047(const Vector2i &p_from, const Vector2i &p_to);
+        Vector<Vector2> _get_point_path_bind_compat_88047(const Vector2i &p_from, const Vector2i &p_to);
+        static void _bind_compatibility_methods();
+    #endif
+
+They should start with a ``_`` to indicate that they are internal, and end with ``_bind_compat_`` followed by the PR number
+that introduced the change (``88047`` in this example). These compatibility methods need to be implemented in a dedicated file,
+like ``core/math/a_star_grid_2d.compat.inc`` in this case:
+
+.. code-block:: cpp
+
+    /**************************************************************************/
+    /*  a_star_grid_2d.compat.inc                                             */
+    /**************************************************************************/
+    /*                         This file is part of:                          */
+    /*                             GODOT ENGINE                               */
+    /*                        https://godotengine.org                         */
+    /**************************************************************************/
+    /* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+    /* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+    /*                                                                        */
+    /* Permission is hereby granted, free of charge, to any person obtaining  */
+    /* a copy of this software and associated documentation files (the        */
+    /* "Software"), to deal in the Software without restriction, including    */
+    /* without limitation the rights to use, copy, modify, merge, publish,    */
+    /* distribute, sublicense, and/or sell copies of the Software, and to     */
+    /* permit persons to whom the Software is furnished to do so, subject to  */
+    /* the following conditions:                                              */
+    /*                                                                        */
+    /* The above copyright notice and this permission notice shall be         */
+    /* included in all copies or substantial portions of the Software.        */
+    /*                                                                        */
+    /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+    /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+    /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+    /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+    /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+    /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+    /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+    /**************************************************************************/
+
+    #ifndef DISABLE_DEPRECATED
+
+    #include "core/variant/typed_array.h"
+
+    TypedArray<Vector2i> AStarGrid2D::_get_id_path_bind_compat_88047(const Vector2i &p_from_id, const Vector2i &p_to_id) {
+        return get_id_path(p_from_id, p_to_id, false);
+    }
+
+    Vector<Vector2> AStarGrid2D::_get_point_path_bind_compat_88047(const Vector2i &p_from_id, const Vector2i &p_to_id) {
+        return get_point_path(p_from_id, p_to_id, false);
+    }
+
+    void AStarGrid2D::_bind_compatibility_methods() {
+        ClassDB::bind_compatibility_method(D_METHOD("get_id_path", "from_id", "to_id"), &AStarGrid2D::_get_id_path_bind_compat_88047);
+        ClassDB::bind_compatibility_method(D_METHOD("get_point_path", "from_id", "to_id"), &AStarGrid2D::_get_point_path_bind_compat_88047);
+    }
+
+    #endif // DISABLE_DEPRECATED
+
+Unless the change in compatibility is complex, the compatibility method should simply call the modified method directly,
+instead of duplicating that method. Make sure to match the default arguments for that method (in the example above this would be ``false``).
+
+This file should always be placed next to the original file, and have ``.compat.inc`` at the end instead of ``.cpp`` or ``.h``.
+Next, this should be included in the ``.cpp`` file we're adding compatibility methods to, so ``core/math/a_star_grid_2d.cpp``:
+
+.. code-block:: cpp
+
+    #include "a_star_grid_2d.h"
+    #include "a_star_grid_2d.compat.inc"
+
+    #include "core/variant/typed_array.h"
+
+And finally, the changes reported by the API validation step should be added to the relevant validation file. Because this was
+done during the development of 4.3, this would be ``misc/extension_api_validation/4.2-stable.expected`` (including changes not shown in
+this example):
+
+.. code-block:: text
+
+    GH-88047
+    --------
+    Validate extension JSON: Error: Field 'classes/AStar2D/methods/get_id_path/arguments': size changed value in new API, from 2 to 3.
+    Validate extension JSON: Error: Field 'classes/AStar2D/methods/get_point_path/arguments': size changed value in new API, from 2 to 3.
+    Validate extension JSON: Error: Field 'classes/AStar3D/methods/get_id_path/arguments': size changed value in new API, from 2 to 3.
+    Validate extension JSON: Error: Field 'classes/AStar3D/methods/get_point_path/arguments': size changed value in new API, from 2 to 3.
+    Validate extension JSON: Error: Field 'classes/AStarGrid2D/methods/get_id_path/arguments': size changed value in new API, from 2 to 3.
+    Validate extension JSON: Error: Field 'classes/AStarGrid2D/methods/get_point_path/arguments': size changed value in new API, from 2 to 3.
+
+    Added optional "allow_partial_path" argument to get_id_path and get_point_path methods in AStar classes.
+    Compatibility methods registered.
+
+The instructions for how to add to that file are at the top of the file itself.
+
+If you get a "Hash changed" error for a method, it means that the compatibility binding is missing or incorrect.
+Such lines shouldn't be added to the ``.expected`` file, but fixed by binding the proper compatibility method.
+
+And that's it! You might run into a bit more complicated cases, like rearranging arguments,
+changing return types, etc., but this covers the basic on how to use this system.
+
+For more information, see `pull request #76446 <https://github.com/godotengine/godot/pull/76446>`_.

contributing/development/index.rst

@@ -17,6 +17,7 @@ especially if you're new to using Git or GitHub.
    best_practices_for_engine_contributors
    code_style_guidelines
    cpp_usage_guidelines
+   handling_compatibility_breakages
 
 Buildsystem and work environment
 --------------------------------

contributing/documentation/docs_image_guidelines.rst

@@ -64,7 +64,7 @@ have cropping built in it's not always easy to get something precise. And while
 Krita is designed as a painting program the cropping tool gives you pixel precision
 by default. Of course, feel free to use a different program you are familiar with.
 
-If you've never used Krita before download it from the `official Krita website <https://krita.org/en/download/krita-desktop/>`_,
+If you've never used Krita before download it from the `official Krita website <https://krita.org/en/download/>`_,
 on Linux you may also be able to download it from your distributions repository,
 flathub is also an option. Once it's installed on your computer open Krita then
 open the image you want to crop. This button on the left panel is the crop tool.

contributing/documentation/docs_writing_guidelines.rst

@@ -497,11 +497,12 @@ out form (:kbd:`Control`/:kbd:`Command`). For combinations, use the ``+`` symbol
 with a space on either side of the symbol.
 
 Make sure to mention shortcuts that differ on macOS compared to other platforms.
-On macOS, ``Cmd`` often replaces ``Ctrl`` in keyboard shortcuts.
+You can find a list of all shortcuts, including what they are on macOS, on
+:ref:`this page <doc_default_key_mapping>`.
 
 Try to integrate the shortcut into sentences the best you can. Here are some
 examples with the ``:kbd:`` tag left as-is for better visibility:
 
-- Press ``:kbd:`Ctrl + Alt + T``` to toggle the panel (``:kbd:`Cmd + Alt + T``` on macOS).
+- Press ``:kbd:`Ctrl + Alt + T``` to toggle the panel (``:kbd:`Opt + Cmd + T``` on macOS).
 - Press ``:kbd:`Space``` and hold the left mouse button to pan in the 2D editor.
 - Press ``:kbd:`Shift + Up Arrow``` to move the node upwards by 8 pixels.

contributing/documentation/updating_the_class_reference.rst

@@ -110,3 +110,5 @@ Please only include changes that are relevant to your work on the API in your co
 You can discard changes in other XML files using ``git checkout``, but consider reporting
 if you notice unrelated files being updated. Ideally, running this command should only
 bring up the changes that you yourself have made.
+
+You will then need to add descriptions to any newly generated entries.

contributing/how_to_contribute.rst

@@ -0,0 +1,110 @@
+.. _doc_ways_to_contribute:
+
+How to contribute
+=================
+
+The Godot Engine is free and open-source. Like any community-driven project, we rely on volunteer contributions. 
+On this page we want to showcase the various ways you as users can participate - to help you find the right starting place with the skillset you have.
+Because contrary to popular opinion, we need more than just programmers on the project!
+
+
+Fundraising
+-----------
+
+- **Donate**
+
+  We created the non-profit `Godot Foundation <https://godot.foundation/>`_ to be able to support the Godot Engine in both matters of finance and administration. 
+  In practice, this means the Foundation hires people to work part-time or full-time on the project. 
+  These jobs include engine development as well as related tasks like code reviews, production management, community & marketing efforts, and more.
+
+  With as little as 5 EUR per month, you can help us keep going strong. 
+  Currently, we are intending to hire more core developers, as to cover more ground with full-time specialists that supplement and guide volunteer work.
+
+  `Join the Development Fund <fund.godotengine.org>`_
+
+- **Donation Drives**
+  Think about your followers on social media, or other communities you are active in.
+  Use that reach to remind your social environment that even small contributions can make a difference, especially when done by a great number of people at the same time. 
+
+  Are you a content creator? Consider adding a link to the `Godot Development Fund <fund.godotengine.org>`_ to your descriptions. 
+  If you do live streams, perhaps think about organizing a stream with donation incentives.
+
+.. - **Buy Official Merch**
+
+- **Publish Godot Games.**
+  You heard right, simply publishing a game #MadeWithGodot can positively impact the well-being of this project. 
+  Your personal success elevates the engine to a viable alternative for other developers, growing the community further. 
+  Additionally, it opens the doors for us to approach industry contacts about possible cooperations.
+
+
+Technical contributions
+-----------------------
+
+- **Report bugs & other issues**
+  As active users of the engine, you are better equipped to identify bugs and other issues than anyone else.
+  To let us know about your findings, fill out this `bug report form <https://github.com/godotengine/godot/issues/new/choose>`_ on our GitHub.
+  Make sure to include as much information as possible to ensure these issues can easily be reproduced by others.
+
+  If you are interested in helping keep our bug tracker organized, you can even join the `bugsquad <https://chat.godotengine.org/channel/bugsquad>`_!
+
+- **Test Development Versions**
+  While it is recommended to use the stable releases for your projects, you can help us test dev releases, betas, and release candidates
+  by opening a copy of your project in them and checking what problems this introduces or maybe even solves. 
+  Make sure to have a backup ready, since this can produce irreversible changes.
+
+  Find recent `development versions <https://godotengine.org/download/preview/>`_ directly on our download page, or linked in their own blog posts.
+  
+- **Contribute Engine Code (mainly C++)**
+  The engine development is mainly coordinated on our `Contributor RocketChat <https://chat.godotengine.org/>`_, 
+  so if you are serious about making PRs you should join us there!
+
+  Read more about the **technical submission process**: :ref:`doc_first_steps`
+
+  For each subject area of the engine, there is a corresponding team to coordinate the work. 
+  Join the linked chat to get more eyes on your related PR, learn about open todos, or partake in meetings. 
+  For some areas, specialists might even be encouraged to step up as maintainer!
+  `List of teams <https://godotengine.org/teams/>`_
+
+- **Review Code Contributions**
+  All pull requests need to be thoroughly reviewed before they can be merged into the master branch.
+  Help us get a headstart by participating in the code review process.
+  
+  To get started, chose any `open pull request <https://github.com/godotengine/godot/pulls>`_ and reference our **style guide**: :ref:`doc_pr_review_guidelines`
+
+- **Write Plugins (GDScript, C#, & more)**
+  Community addons are not directly included in the core engine download or repository, yet they provide essential quality of life upgrades for your fellow game developers.
+  Upload your plugins to the `Godot Asset Library <https://godotengine.org/asset-library/asset>`_ to make them available to others.
+  .. update to talk about Asset Store later
+
+- **Demo projects (GDScript, C#, and making Assets)**
+  We provide new users with `demo projects <https://github.com/godotengine/godot-demo-projects/>`_ so they can quickly test new features or get familiar with the engine in the first place.
+  At industry events, we might even exhibit these demo projects to showcase what Godot can do! 
+  Help improve existing projects or supply your own to be added to the pool, and join the `demo channel <https://chat.godotengine.org/channel/demo-content>`_ in the Contributor RocketChat to talk about it.
+
+- **Documentation**
+  The documentation is one of the most essential parts of any tech project, yet the need to document new features and substantial changes often gets overlooked. 
+  Join the `documentation team <https://chat.godotengine.org/channel/documentation>`_ to improve the Godot Engine with your technical writing skills.
+
+- **Translations (spoken languages other than English)**
+  Are you interested in making the Godot Engine more accessible to non-English speakers? 
+  Contribute to our `community-translations <https://hosted.weblate.org/projects/godot-engine/godot/>`_.
+
+Community support
+-----------------
+
+- **Call for Moderators**
+  With a community of our size, we need people to step up as volunteer moderators in all kinds of places. 
+  These teams are organized by the Godot Foundation, but would not function without the dedication of active community members like you.
+
+  Have a look around your favorite community platform and you might come across open application calls. 
+
+- **Answer tech-support questions**
+  With many new people discovering the Godot Engine recently, the need for peer-to-peer tech-support has never been greater. 
+  Be it on the `Forum <https://forum.godotengine.org/>`_, our `subreddit <https://www.reddit.com/r/godot/>`_, or on `Discord <https://discord.gg/bdcfAYM4W9>`_, you can always brighten someone's day by helping them get their personal projects back on track.
+
+- **Create tutorials & more**
+  How did you get started with the Godot Engine? 
+  Chances are you looked for learning materials outside of what the documentation provides.
+  Without content creators covering the game development process, there would not be this big of a community today.
+  Therefore it seemed only right to mention them in a page about important contributions to the project.
+  

contributing/ways_to_contribute.rst → contributing/workflow/first_steps.rst

@@ -1,54 +1,4 @@
-.. _doc_ways_to_contribute:
-
-Ways to contribute
-==================
-
-Godot Engine is a non-profit, community-driven free and open source project.
-Almost all (but our lead dev Juan, more on that below) developers are working
-*pro bono* on their free time, out of personal interest and for the love of
-creating a libre engine of exceptional quality.
-
-This means that to thrive, Godot needs as many users as possible to get
-involved by contributing to the engine. There are many ways to contribute to
-such a big project, making it possible for everybody to bring something
-positive to the engine, regardless of their skill set:
-
--  **Be part of the community.** The best way to contribute to Godot and help
-   it become ever better is simply to use the engine and promote it by
-   word-of-mouth, in the credits or splash screen of your games, blog posts, tutorials,
-   videos, demos, gamedev or free software events, support on the Q&A, forums,
-   Contributors Chat, Discord, etc. Participate!
-   Being a user and advocate helps spread the word about our great engine,
-   which has no marketing budget and can therefore only rely on its community
-   to become more mainstream.
-
--  **Make games.** It's no secret that, to convince new users and especially the
-   industry at large that Godot is a relevant market player, we need great games
-   made with Godot. We know that the engine has a lot of potential, both for 2D
-   and 3D games, but given its young age we still lack big releases that will
-   draw attention to Godot. So keep working on your awesome projects, each new
-   game increases our credibility on the gamedev market!
-
--  **Get involved in the engine's development.** This can be by contributing
-   code via pull requests, testing the development snapshots or directly the
-   git *master* branch, report bugs or suggest enhancements on the issue
-   tracker, improve the official documentation (both the class reference and
-   tutorials) and its translations.
-   The following sections will cover each of those "direct" ways
-   of contributing to the engine.
-
--  **Donate.** Godot is a non-profit project, but it can still benefit from
-   user donations for many things. Apart from usual expenses such as hosting
-   costs or promotional material on events, we also use donation money to
-   acquire hardware when necessary (e.g. we used donation money to buy a
-   MacBook Pro to implement Retina/HiDPI support and various other
-   macOS-related features).
-   Most importantly, we also used donation money to hire core developers so they
-   can work full-time on the engine. Even with a low
-   monthly wage, we need a steady donation income to continue doing this, which
-   has been very beneficial to the project so far. So if you want to donate
-   some money to the project, check `our website <https://godotengine.org/donate>`_
-   for details.
+.. _doc_first_steps:
 
 Contributing code
 -----------------

contributing/workflow/index.rst

@@ -12,6 +12,7 @@ approach the project.
    :maxdepth: 1
    :name: toc-contributing-workflow
 
+   first_steps
    bisecting_regressions
    bug_triage_guidelines
    pr_workflow

contributing/workflow/testing_pull_requests.rst

@@ -90,6 +90,9 @@ This approach may be needed for pull requests that were last updated more than
 90 days ago, or to test on platforms and configurations that are not supported
 by Godot's GitHub Actions setup.
 
+Downloading a zipped pull request branch
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 - Open the pull request page. Click the *fork*'s branch name near the top of the page:
 
 .. image:: img/testing_pull_requests_access_fork.png
@@ -101,3 +104,34 @@ by Godot's GitHub Actions setup.
 
 - Extract the ZIP archive and follow the :ref:`compiling <toc-devel-compiling>` instructions
   for your operating system.
+
+Checking out a pull request branch with git
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Alternatively, you can checkout the pull request directly with git:
+
+- Open the pull request page. Note the pull request *number* (``PR_NUMBER``), and the *branch name*
+  (``BRANCH_NAME``), but without the user name.
+
+.. image:: img/testing_pull_requests_command_line_checkout.webp
+
+- Construct the command using this pattern:
+
+::
+
+    $ git fetch upstream pull/PR_NUMBER/head:BRANCH_NAME
+
+So for the pull request above, the actual command will be:
+
+::
+
+    # Fetch PR branch locally
+    $ git fetch upstream pull/48734/head:editor_file_dialog_filter_sort
+
+- Once the pull request finishes downloading, checkout its branch:
+
+::
+
+    $ git checkout editor_file_dialog_filter_sort
+
+- And follow the :ref:`compiling <toc-devel-compiling>` instructions for your operating system.

getting_started/first_2d_game/02.player_scene.rst

@@ -60,7 +60,8 @@ appearance and animations for our player. Notice that there is a warning symbol
 next to the node. An ``AnimatedSprite2D`` requires a :ref:`SpriteFrames
 <class_SpriteFrames>` resource, which is a list of the animations it can
 display. To create one, find the ``Sprite Frames`` property under the ``Animation`` tab in the Inspector and click
-"[empty]" -> "New SpriteFrames". Click again to open the "SpriteFrames" panel:
+"[empty]" -> "New SpriteFrames". Click on the ``SpriteFrames`` you just
+created to open the "SpriteFrames" panel:
 
 .. image:: img/spriteframes_panel.webp
 

getting_started/first_2d_game/03.coding_the_player.rst

@@ -407,6 +407,7 @@ Next, add this code to the function:
 
  .. code-tab:: csharp
 
+    // We also specified this function name in PascalCase in the editor's connection window.
     private void OnBodyEntered(Node2D body)
     {
         Hide(); // Player disappears after being hit.

getting_started/first_2d_game/04.creating_the_enemy.rst

@@ -117,6 +117,7 @@ to the ``Mob`` and add this code:
 
  .. code-tab:: csharp
 
+    // We also specified this function name in PascalCase in the editor's connection window.
     private void OnVisibleOnScreenNotifier2DScreenExited()
     {
         QueueFree();

getting_started/first_2d_game/05.the_main_game_scene.rst

@@ -168,11 +168,13 @@ the other two timers. ``ScoreTimer`` will increment the score by 1.
 
  .. code-tab:: csharp
 
+    // We also specified this function name in PascalCase in the editor's connection window.
     private void OnScoreTimerTimeout()
     {
         _score++;
     }
 
+    // We also specified this function name in PascalCase in the editor's connection window.
     private void OnStartTimerTimeout()
     {
         GetNode<Timer>("MobTimer").Start();
@@ -219,6 +221,7 @@ Note that a new instance must be added to the scene using ``add_child()``.
 
  .. code-tab:: csharp
 
+    // We also specified this function name in PascalCase in the editor's connection window.
     private void OnMobTimerTimeout()
     {
         // Note: Normally it is best to use explicit types rather than the `var`

getting_started/first_2d_game/06.heads_up_display.rst

@@ -185,7 +185,7 @@ Add the code below to ``HUD`` to update the score
     }
 
 Connect the ``pressed()`` signal of ``StartButton`` and the ``timeout()``
-signal of ``MessageTimer``, and add the following code to the new functions:
+signal of ``MessageTimer`` to the ``HUD`` node, and add the following code to the new functions:
 
 .. tabs::
  .. code-tab:: gdscript GDScript
@@ -199,12 +199,14 @@ signal of ``MessageTimer``, and add the following code to the new functions:
 
  .. code-tab:: csharp
 
+    // We also specified this function name in PascalCase in the editor's connection window.
     private void OnStartButtonPressed()
     {
         GetNode<Button>("StartButton").Hide();
         EmitSignal(SignalName.StartGame);
     }
 
+    // We also specified this function name in PascalCase in the editor's connection window.
     private void OnMessageTimerTimeout()
     {
         GetNode<Label>("Message").Hide();

getting_started/first_2d_game/07.finishing-up.rst

@@ -18,7 +18,7 @@ the first node under ``Main`` so that it will be drawn behind the other nodes.
 select "Layout" -> "Anchors Preset" -> "Full Rect" either in the toolbar at the top of the viewport or in the inspector so that it covers the screen.
 
 You could also add a background image, if you have one, by using a
-``TextureRect`` node instead.
+:ref:`TextureRect <class_TextureRect>` node instead.
 
 Sound effects
 ~~~~~~~~~~~~~

getting_started/first_3d_game/02.player_input.rst

@@ -171,7 +171,7 @@ In the next part, we'll code and test the player's movement.
 .. |image5| image:: img/02.player_input/06.toggling_visibility.webp
 .. |image6| image:: img/02.player_input/07.project_settings.png
 .. |image7| image:: img/02.player_input/07.input_map_tab.png
-.. |image8| image:: img/02.player_input/07.adding_action.png
+.. |image8| image:: img/02.player_input/07.adding_action.webp
 .. |image9| image:: img/02.player_input/08.actions_list_empty.png
 .. |image11| image:: img/02.player_input/09.keyboard_key_popup.png
 .. |image12| image:: img/02.player_input/09.keyboard_keys.png

getting_started/first_3d_game/03.player_movement_code.rst

@@ -8,6 +8,17 @@ Moving the player with code
 It's time to code! We're going to use the input actions we created in the last
 part to move the character.
 
+.. note:: For this project, we will be following the Godot naming conventions.
+
+          - **GDScript**: Classes (nodes) use PascalCase, variables and
+            functions use snake_case, and constants use ALL_CAPS (See
+            :ref:`doc_gdscript_styleguide`).
+
+          - **C#**: Classes, export variables and methods use PascalCase,
+            private fields use _camelCase, local variables and parameters use
+            camelCase (See :ref:`doc_c_sharp_styleguide`). Be careful to type
+            the method names precisely when connecting signals.
+
 Right-click the ``Player`` node and select *Attach Script* to add a new script to
 it. In the popup, set the *Template* to *Empty* before pressing the *Create*
 button.

getting_started/first_3d_game/04.mob_scene.rst

@@ -218,6 +218,9 @@ Leaving the screen
 We still have to destroy the mobs when they leave the screen. To do so, we'll
 connect our :ref:`VisibleOnScreenNotifier3D <class_VisibleOnScreenNotifier3D>` node's ``screen_exited`` signal to the ``Mob``.
 
+Head back to the 3D viewport by clicking on the *3D* label at the top of the
+editor. You can also press :kbd:`Ctrl + F2` (:kbd:`Opt + 2` on macOS).
+
 |image8|
 
 Select the :ref:`VisibleOnScreenNotifier3D <class_VisibleOnScreenNotifier3D>` node and on the right side of the interface,
@@ -241,7 +244,7 @@ method. This function destroys the instance it's called on.
 
  .. code-tab:: csharp
 
-    // We also specified this function name in PascalCase in the editor's connection window
+    // We also specified this function name in PascalCase in the editor's connection window.
     private void OnVisibilityNotifierScreenExited()
     {
         QueueFree();
@@ -271,7 +274,7 @@ Here is the complete ``Mob.gd`` script for reference.
         # We position the mob by placing it at start_position
         # and rotate it towards player_position, so it looks at the player.
         look_at_from_position(start_position, player_position, Vector3.UP)
-        # Rotate this mob randomly within range of -90 and +90 degrees,
+        # Rotate this mob randomly within range of -45 and +45 degrees,
         # so that it doesn't move directly towards the player.
         rotate_y(randf_range(-PI / 4, PI / 4))
 
@@ -310,7 +313,7 @@ Here is the complete ``Mob.gd`` script for reference.
             // We position the mob by placing it at startPosition
             // and rotate it towards playerPosition, so it looks at the player.
             LookAtFromPosition(startPosition, playerPosition, Vector3.Up);
-            // Rotate this mob randomly within range of -90 and +90 degrees,
+            // Rotate this mob randomly within range of -45 and +45 degrees,
             // so that it doesn't move directly towards the player.
             RotateY((float)GD.RandRange(-Mathf.Pi / 4.0, Mathf.Pi / 4.0));
 
@@ -323,7 +326,7 @@ Here is the complete ``Mob.gd`` script for reference.
             Velocity = Velocity.Rotated(Vector3.Up, Rotation.Y);
         }
 
-        // We also specified this function name in PascalCase in the editor's connection window
+        // We also specified this function name in PascalCase in the editor's connection window.
         private void OnVisibilityNotifierScreenExited()
         {
             QueueFree();

getting_started/first_3d_game/05.spawning_mobs.rst

@@ -244,7 +244,7 @@ Let's code the mob spawning logic. We're going to:
 
  .. code-tab:: csharp
 
-    // We also specified this function name in PascalCase in the editor's connection window
+    // We also specified this function name in PascalCase in the editor's connection window.
     private void OnMobTimerTimeout()
     {
         // Create a new instance of the Mob scene.

getting_started/first_3d_game/06.jump_and_squash.rst

@@ -288,7 +288,7 @@ With this code, if no collisions occurred on a given frame, the loop won't run.
         }
     }
 
- That's a lot of new functions. Here's some more information about them.
+That's a lot of new functions. Here's some more information about them.
 
 The functions ``get_slide_collision_count()`` and ``get_slide_collision()`` both come from
 the :ref:`CharacterBody3D <class_CharacterBody3D>` class and are related to

getting_started/first_3d_game/07.killing_player.rst

@@ -96,7 +96,7 @@ a ``die()`` function that helps us put a descriptive label on the code.
         QueueFree();
     }
 
-    // We also specified this function name in PascalCase in the editor's connection window
+    // We also specified this function name in PascalCase in the editor's connection window.
     private void OnMobDetectorBodyEntered(Node3D body)
     {
         Die();
@@ -143,7 +143,7 @@ Get the timer, and stop it, in the ``_on_player_hit()`` function.
 
  .. code-tab:: csharp
 
-    // We also specified this function name in PascalCase in the editor's connection window
+    // We also specified this function name in PascalCase in the editor's connection window.
     private void OnPlayerHit()
     {
         GetNode<Timer>("MobTimer").Stop();
@@ -250,7 +250,7 @@ Next is ``Mob.gd``.
         # We position the mob by placing it at start_position
         # and rotate it towards player_position, so it looks at the player.
         look_at_from_position(start_position, player_position, Vector3.UP)
-        # Rotate this mob randomly within range of -90 and +90 degrees,
+        # Rotate this mob randomly within range of -45 and +45 degrees,
         # so that it doesn't move directly towards the player.
         rotate_y(randf_range(-PI / 4, PI / 4))
 
@@ -297,7 +297,7 @@ Next is ``Mob.gd``.
             // We position the mob by placing it at startPosition
             // and rotate it towards playerPosition, so it looks at the player.
             LookAtFromPosition(startPosition, playerPosition, Vector3.Up);
-            // Rotate this mob randomly within range of -90 and +90 degrees,
+            // Rotate this mob randomly within range of -45 and +45 degrees,
             // so that it doesn't move directly towards the player.
             RotateY((float)GD.RandRange(-Mathf.Pi / 4.0, Mathf.Pi / 4.0));
 

getting_started/first_3d_game/09.adding_animations.rst

@@ -102,7 +102,7 @@ position key to ``0.3`` seconds and the rotation key to ``0.1`` seconds.
 Move the time cursor to ``0.5`` seconds by clicking and dragging on the gray
 timeline.
 
-.. image:: img/09.adding_animations/timeline_05_click.webp
+|timeline_05_click|
 
 In the *Inspector*, set the *Position*'s *Y* axis to ``0.65`` meters and the *Rotation*' *X* axis to ``8``.
 
@@ -110,7 +110,7 @@ In the *Inspector*, set the *Position*'s *Y* axis to ``0.65`` meters and the *Ro
 
 Create a keyframe for both properties
 
-.. image:: img/09.adding_animations/second_keys_both.webp
+|second_keys_both|
 
 Now, move the position keyframe to ``0.7``
 seconds by dragging it on the timeline.
@@ -129,7 +129,7 @@ Move the time cursor to the end of the animation, at ``1.2`` seconds. Set the Y
 position to about ``0.35`` and the X rotation to ``-9`` degrees. Once again,
 create a key for both properties.
 
-.. image:: img/09.adding_animations/animation_final_keyframes.webp
+|animation_final_keyframes|
 
 You can preview the result by clicking the play button or pressing :kbd:`Shift + D`.
 Click the stop button or press :kbd:`S` to stop playback.
@@ -529,7 +529,7 @@ And the *Mob*'s script.
         # We position the mob by placing it at start_position
         # and rotate it towards player_position, so it looks at the player.
         look_at_from_position(start_position, player_position, Vector3.UP)
-        # Rotate this mob randomly within range of -90 and +90 degrees,
+        # Rotate this mob randomly within range of -45 and +45 degrees,
         # so that it doesn't move directly towards the player.
         rotate_y(randf_range(-PI / 4, PI / 4))
 
@@ -578,7 +578,7 @@ And the *Mob*'s script.
             // We position the mob by placing it at startPosition
             // and rotate it towards playerPosition, so it looks at the player.
             LookAtFromPosition(startPosition, playerPosition, Vector3.Up);
-            // Rotate this mob randomly within range of -90 and +90 degrees,
+            // Rotate this mob randomly within range of -45 and +45 degrees,
             // so that it doesn't move directly towards the player.
             RotateY((float)GD.RandRange(-Mathf.Pi / 4.0, Mathf.Pi / 4.0));
 
@@ -628,3 +628,6 @@ And the *Mob*'s script.
 .. |image20| image:: img/09.adding_animations/19.ease_in_second_translation_key.png
 .. |image21| image:: img/09.adding_animations/20.float_animation.gif
 .. |image22| image:: img/09.adding_animations/21.script_icon.png
+.. |animation_final_keyframes| image:: img/09.adding_animations/animation_final_keyframes.webp
+.. |second_keys_both| image:: img/09.adding_animations/second_keys_both.webp
+.. |timeline_05_click| image:: img/09.adding_animations/timeline_05_click.webp

getting_started/first_3d_game/going_further.rst

@@ -19,7 +19,7 @@ Where should you begin? Below, you'll find a few pages to start exploring and
 build upon what you've learned so far.
 
 But before that, here's a link to download a completed version of the project:
-`<https://github.com/godotengine/godot-3d-dodge-the-creeps>`_.
+`<https://github.com/godotengine/godot-demo-projects/releases>`_.
 
 Exploring the manual
 --------------------

getting_started/introduction/first_look_at_the_editor.rst

@@ -136,7 +136,7 @@ Godot comes with a built-in class reference.
 You can search for information about a class, method, property, constant, or
 signal by any one of the following methods:
 
-* Pressing :kbd:`F1` (or :kbd:`Alt + Space` on macOS, or :kbd:`fn + F1` for laptops with a :kbd:`fn` key) anywhere in the editor.
+* Pressing :kbd:`F1` (or :kbd:`Opt + Space` on macOS, or :kbd:`fn + F1` for laptops with a :kbd:`fn` key) anywhere in the editor.
 * Clicking the "Search Help" button in the top-right of the Script main screen.
 * Clicking on the Help menu and Search Help.
 * Clicking while pressing the :kbd:`Ctrl` key on a class name, function name,

getting_started/introduction/godot_design_philosophy.rst

@@ -132,7 +132,7 @@ that drive the core updates. New features from the core developers often
 focus on what will benefit the most users first.
 
 That said, although a handful of core developers work on it full-time,
-the project has over 600 contributors at the time of writing. Benevolent
+the project has thousands of contributors at the time of writing. Benevolent
 programmers work on features they may need themselves, so you'll see
 improvements in all corners of the engine at the same time in every
 major release.

getting_started/step_by_step/scripting_languages.rst

@@ -133,6 +133,8 @@ officially supported .NET option.
     Android and iOS platform support is available as of Godot 4.2, but is
     experimental and :ref:`some limitations apply <doc_c_sharp_platforms>`.
 
+.. seealso:: To learn more about C#, head to the :ref:`C# basics <doc_c_sharp>` page.
+
 C++ via GDExtension
 ~~~~~~~~~~~~~~~~~~~
 

getting_started/step_by_step/scripting_player_input.rst

@@ -79,6 +79,24 @@ right arrows on the keyboard or left and right on a gamepad's D-pad.
 Finally, we use the ``direction`` as a multiplier when we update the node's
 ``rotation``: ``rotation += angular_speed * direction * delta``.
 
+Comment out the lines ``var velocity = Vector2.UP.rotated(rotation) * speed`` and ``position += velocity * delta`` like this:
+
+.. tabs::
+
+ .. code-tab:: gdscript GDScript
+
+    #var velocity = Vector2.UP.rotated(rotation) * speed
+	
+    #position += velocity * delta
+
+ .. code-tab:: csharp C#
+
+    //var velocity = Vector2.Up.Rotated(Rotation) * _speed;
+
+    //Position += velocity * (float)delta;
+
+This will ignore the code that moved the icon's position in a circle without user input from the previous exercise.
+
 If you run the scene with this code, the icon should rotate when you press
 :kbd:`Left` and :kbd:`Right`.
 
@@ -86,7 +104,7 @@ Moving when pressing "up"
 -------------------------
 
 To only move when pressing a key, we need to modify the code that calculates the
-velocity. Replace the line starting with ``var velocity`` with the code below.
+velocity. Uncomment the code and replace the line starting with ``var velocity`` with the code below.
 
 .. tabs::
  .. code-tab:: gdscript GDScript

getting_started/step_by_step/signals.rst

@@ -25,14 +25,31 @@ For example, you might have a life bar on the screen that represents the
 player's health. When the player takes damage or uses a healing potion, you want
 the bar to reflect the change. To do so, in Godot, you would use signals.
 
-.. note:: As mentioned in the introduction, signals are Godot's version of the
-          observer pattern. You can learn more about it here:
-          https://gameprogrammingpatterns.com/observer.html
+Like methods (:ref:`class_callable`), signals are a first-class type since Godot
+4.0. This means you can pass them around as method arguments directly without
+having to pass them as strings, which allows for better autocompletion and is
+less error-prone. See the :ref:`class_signal` class reference for a list of
+what you can do with the Signal type directly.
+
+.. seealso::
+
+    As mentioned in the introduction, signals are Godot's version of the
+    observer pattern. You can learn more about it in
+    `Game Programming Patterns <https://gameprogrammingpatterns.com/observer.html>`__.
 
 We will now use a signal to make our Godot icon from the previous lesson
 (:ref:`doc_scripting_player_input`) move and stop by pressing a button.
 
-.. Example
+.. note:: For this project, we will be following the Godot naming conventions.
+
+          - **GDScript**: Classes (nodes) use PascalCase, variables and
+            functions use snake_case, and constants use ALL_CAPS (See
+            :ref:`doc_gdscript_styleguide`).
+
+          - **C#**: Classes, export variables and methods use PascalCase,
+            private fields use _camelCase, local variables and parameters use
+            camelCase (See :ref:`doc_c_sharp_styleguide`). Be careful to type
+            the method names precisely when connecting signals.
 
 Scene setup
 -----------
@@ -128,6 +145,12 @@ methods "_on_node_name_signal_name". Here, it'll be "_on_button_pressed".
    toggle the mode in the window's bottom-right by clicking the Advanced
    button.
 
+.. note::
+
+    If you are using an external editor (such as VS Code) this
+    automatic code generation might not work. In this case you need to to connect
+    the signal via code as explained in the next section.
+
 Click the Connect button to complete the signal connection and jump to the
 Script workspace. You should see the new method with a connection icon in the
 left margin.
@@ -156,6 +179,7 @@ the ``not`` keyword to invert the value.
 
  .. code-tab:: csharp C#
 
+    // We also specified this function name in PascalCase in the editor's connection window.
     private void OnButtonPressed()
     {
         SetProcess(!IsProcessing());
@@ -221,6 +245,7 @@ Your complete ``sprite_2d.gd`` code should look like the following.
             Position += velocity * (float)delta;
         }
 
+        // We also specified this function name in PascalCase in the editor's connection window.
         private void OnButtonPressed()
         {
             SetProcess(!IsProcessing());
@@ -393,6 +418,7 @@ Here is the complete ``sprite_2d.gd`` file for reference.
             Position += velocity * (float)delta;
         }
 
+        // We also specified this function name in PascalCase in the editor's connection window.
         private void OnButtonPressed()
         {
             SetProcess(!IsProcessing());

index.rst

@@ -129,7 +129,7 @@ the ``GodotEngine.epub`` file in an e-book reader application.
    :caption: Contributing
    :name: sec-contributing
 
-   contributing/ways_to_contribute
+   contributing/how_to_contribute
    contributing/workflow/index
    contributing/development/index
    contributing/documentation/index

tutorials/2d/2d_sprite_animation.rst

@@ -101,7 +101,7 @@ released.
 
         public override void _Ready()
         {
-            _animatedSprite = GetNode<AnimatedSprite>("AnimatedSprite");
+            _animatedSprite = GetNode<AnimatedSprite2D>("AnimatedSprite2D");
         }
 
         public override _Process(float _delta)

tutorials/3d/3d_antialiasing.rst

@@ -116,7 +116,7 @@ AMD FidelityFX Super Resolution 2.2 (FSR2)
 ------------------------------------------
 
 Since Godot 4.2, there is built-in support for
-`AMD FidelityFX Super Resolution <https://www.amd.com/en/technologies/fidelityfx-super-resolution>`__
+`AMD FidelityFX Super Resolution <https://www.amd.com/en/products/graphics/technologies/fidelityfx/super-resolution.html>`__
 2.2. This is an :ref:`upscaling method <doc_resolution_scaling>`
 compatible with all recent GPUs from any vendor. FSR2 is normally designed to
 improve performance by lowering the internal 3D rendering resolution,

tutorials/3d/3d_text.rst

@@ -45,7 +45,7 @@ Advantages
 - Label3D can use bitmap fonts and dynamic fonts (with and without
   :abbr:`MSDF (Multi-channel Signed Distance Font)` or mipmaps). This makes it
   more flexible on that aspect compared to TextMesh, especially for rendering
-  fonts with self-intersecting outlines.
+  fonts with self-intersecting outlines or colored fonts (emoji).
 
 .. seealso::
 
@@ -70,6 +70,10 @@ cast shadows, but some transparency sorting issues will remain.
 See :ref:`Transparency sorting <doc_3d_rendering_limitations_transparency_sorting>`
 section in the 3D rendering limitations page for more information.
 
+Text rendering quality can also suffer when the Label3D is viewed at a distance. To improve
+text rendering quality, :ref:`enable mipmaps on the font <doc_using_fonts_mipmaps>` or
+:ref:`switch the font to use MSDF rendering <doc_using_fonts_msdf>`.
+
 TextMesh
 --------
 
@@ -111,6 +115,10 @@ There are some limitations to TextMesh:
   If you notice rendering issues on fonts downloaded from websites such as
   Google Fonts, try downloading the font from the font author's official
   website instead.
+- Antialiasing the text rendering requires a full-scene antialiasing method to
+  be enabled such as MSAA, FXAA and temporal antialiasing (TAA). If no
+  antialiasing method is enabled, text will appear grainy, especially at a
+  distance. See :ref:`doc_3d_antialiasing` for more information.
 
 Projected Label node (or any other Control)
 -------------------------------------------

tutorials/3d/csg_tools.rst

@@ -15,13 +15,14 @@ Interior environments can be created by using inverted primitives.
 
 .. note:: The CSG nodes in Godot are mainly intended for prototyping. There is
           no built-in support for UV mapping or editing 3D polygons (though
-          extruded 2D polygons can be used with the CSGPolygon3D node).
+          extruded 2D polygons can be used with the CSGPolygon3D node). In
+          addition CSG can't reliably create meshes made up of multiple nodes
+          without holes.
 
           If you're looking for an easy to use level design tool for a project,
-          you may want to use `Qodot <https://github.com/QodotPlugin/Qodot>`__
-          instead. It lets you design levels using
-          `TrenchBroom <https://kristianduske.com/trenchbroom/>`__ and import
-          them in Godot.
+          you may want to use `FuncGodot <https://github.com/func-godot/func_godot_plugin>`__
+          or `Cyclops Level Builder <https://github.com/blackears/cyclopsLevelBuilder>`__
+          instead.
 
 .. image:: img/csg.gif
 

tutorials/3d/introduction_to_3d.rst

@@ -24,20 +24,16 @@ Node3D node
 Following this reasoning, the 3D engine uses the :ref:`Node3D <class_Node3D>`
 node for everything 3D.
 
-.. note:: Be aware that "Spatial" Nodes are now called "Node3D"
-   starting with Godot 4. Any Godot 3.x references to "Spatial"
-   Nodes refer to "Node3D" in Godot 4.
-
-.. image:: img/tuto_3d1.png
+.. image:: img/tuto_3d1.webp
 
 Node3Ds have a local transform, which is relative to the parent
 node (as long as the parent node is also of **or inherits from** the type
-Node3D). This transform can be accessed as a 4×3
+Node3D). This transform can be accessed as a 3×4
 :ref:`Transform3D <class_Transform3D>`, or as 3 :ref:`Vector3 <class_Vector3>`
 members representing location, Euler rotation (X, Y and Z angles) and
 scale.
 
-.. image:: img/tuto_3d2.png
+.. image:: img/tuto_3d2.webp
 
 3D content
 ~~~~~~~~~~
@@ -117,14 +113,14 @@ Editing 3D scenes is done in the 3D tab. This tab can be selected
 manually, but it will be automatically enabled when a Node3D node is
 selected.
 
-.. image:: img/tuto_3d3.png
+.. image:: img/tuto_3d3.webp
 
 Default 3D scene navigation controls are similar to Blender (aiming to
 have some sort of consistency in the free software pipeline..), but
 options are included to customize mouse buttons and behavior to be
 similar to other tools in the Editor Settings:
 
-.. image:: img/tuto_3d4.png
+.. image:: img/tuto_3d4.webp
 
 Coordinate system
 -----------------
@@ -167,7 +163,7 @@ respectively. This convention applies to the grid and other gizmos too
 (and also to the shader language, ordering of components for
 Vector3, Color, etc.).
 
-.. image:: img/tuto_3d5.png
+.. image:: img/tuto_3d5.webp
 
 Some useful keybindings:
 
@@ -210,26 +206,37 @@ View menu
 
 The view options are controlled by the "View" menu in the viewport's toolbar.
 
-.. image:: img/tuto_3d6.png
+.. image:: img/tuto_3d6.webp
 
 You can hide the gizmos in the 3D view of the editor through this menu:
 
-.. image:: img/tuto_3d6_1.png
+.. image:: img/tuto_3d6_1.webp
 
 To hide a specific type of gizmos, you can toggle them off in the "View" menu.
 
-.. image:: img/tuto_3d6_2.png
+.. image:: img/tuto_3d6_2.webp
+
+preview environment and light
+-----------------------------
+
+By default, any 3D scene that doesn't have a :ref:`WorldEnvironment <class_WorldEnvironment>`
+node, or a :ref:`DirectionalLight3D <class_DirectionalLight3D>`, will have
+a preview turned on for what it's missing to light the scene.
 
-Default environment
--------------------
+The preview light and environment will only be visible in the scene while
+in the editor. If you run the scene or export the project they will not
+affect the scene.
 
-When created from the Project Manager, the 3D environment has a default sky.
+The preview light and environment can be turned on or off from the top menu
+by clicking on their respective icon, and the 3 dots dropdown menu next to
+those icons can be used to adjust the properties of the preview environment
+and light.
 
-.. image:: img/tuto_3d8.png
+.. image:: img/tuto_3d8.webp
 
-Given how physically-based rendering works, it is advised to always try to
-work with a default environment in order to provide indirect and reflected
-light to your objects.
+The same preview sun and environment is used for every scene in the same project,
+So only make adjustments that would apply to all of the scenes you will need a preview
+light and environment for.
 
 Cameras
 -------
@@ -239,7 +246,7 @@ displayed unless a :ref:`Camera3D <class_Camera3D>` is
 also added to the scene. Cameras can work in either orthogonal or
 perspective projections:
 
-.. image:: img/tuto_3d10.png
+.. image:: img/tuto_3d10.webp
 
 Cameras are associated with (and only display to) a parent or grandparent
 viewport. Since the root of the scene tree is a viewport, cameras will

tutorials/3d/particles/collision.rst

@@ -11,10 +11,6 @@ world. If you need particles to collide with the environment, you have to set up
 There are four of them: :ref:`class_GPUParticlesCollisionBox3D`, :ref:`class_GPUParticlesCollisionSphere3D`,
 :ref:`class_GPUParticlesCollisionSDF3D`, and :ref:`class_GPUParticlesCollisionHeightField3D`.
 
-.. note::
-
-   GPU Particle collision is not yet implemented for 2D particle systems.
-
 Common properties
 ~~~~~~~~~~~~~~~~~
 
@@ -175,3 +171,22 @@ level geometry and instead shoot right through it, try setting this property to
 
 The ``Bake Mask`` property controls which meshes will be considered when the SDF is baked. Only meshes that
 render on the active layers in the bake mask contribute to particle collision.
+
+Troubleshooting
+~~~~~~~~~~~~~~~
+
+For particle collision to work, the particle's :ref:`visibility AABB <doc_3d_particles_properties_draw>`
+must overlap with the collider's AABB. If collisions appear to be not working
+despite colliders being set up, generate an updated visibility AABB by selecting
+the GPUParticles3D node and choosing **GPUParticles3D > Generate Visibility AABB…**
+at the top of the 3D editor viewport.
+
+If the particles move fast and colliders are thin. There are two solutions for this:
+
+- Make the colliders thicker. For instance, if particles cannot get below a
+  solid floor, you could make the collider representing the floor thicker than
+  its actual visual representation. The heightfield collider automatically
+  handles this by design, as heightfields cannot represent "room over room"
+  collision.
+- Increased ``Fixed FPS`` in the GPUParticles3D node, which will perform collision
+  checks more often. This comes at a performance cost, so avoid setting this too high.

tutorials/3d/particles/creating_a_3d_particle_system.rst

@@ -86,7 +86,7 @@ Some of the most notable features that are lost during the conversion include:
 
 You also lose the following properties:
 
-- ``Ammount Ratio``
+- ``Amount Ratio``
 - ``Interp to End``
 - ``Damping as Friction``
 - ``Emission Shape Offset``

tutorials/3d/particles/properties.rst

@@ -16,8 +16,8 @@ want to activate or deactivate particle systems dynamically.
 The ``Amount`` property controls the maximum number of particles visible at any given time. Increase the
 value to spawn more particles at the cost of performance.
 
-The ``Amount Ratio`` property is the radio of particles compared to the ammount that will be emitted.
-If it's less than ``1.0`` the ammount of particles emitted through the lifetime will be the ``Ammount`` *
+The ``Amount Ratio`` property is the ratio of particles compared to the amount that will be emitted.
+If it's less than ``1.0``, the amount of particles emitted through the lifetime will be the ``Amount`` *
 ``Amount Ratio``. Changing this value while emitted doesn't affect already created particles and doesn't
 cause the particle system to restart. It's useful for making effects where the number of emitted particles
 varies over time.
@@ -113,11 +113,22 @@ That's what the ``Interpolate`` property does. It blends particle properties bet
 updates so that even a particle system running at ``10`` FPS appears as smooth as
 running at ``60``.
 
+.. note::
+
+    When using :ref:`particle collision <doc_3d_particles_collision>`, tunneling can occur
+    if the particles move fast and colliders are thin. This can be remedied by increasing
+    ``Fixed FPS`` (at a performance cost).
+
 .. _doc_3d_particles_properties_collision:
 
 Collision properties
 ~~~~~~~~~~~~~~~~~~~~
 
+.. seealso::
+
+    Setting up particle collision requires following further steps described in
+    :ref:`doc_3d_particles_collision`.
+
 The ``Base Size`` property defines each particle's default collision size, which is used
 to check whether a particle is currently colliding with the environment. You would usually want this
 to be about the same size as the particle. It can make sense to increase this value
@@ -141,7 +152,8 @@ box as small as possible.
 
 One thing to keep in mind when you set a size for the ``Visibility AABB`` is that particles
 that are outside of its bounds disappear instantly when it leaves the camera's field of view.
-This, while not technically a bug, can have a negative effect on the visual experience.
+Particle collision will also not occur outside the ``Visibility AABB``.
+While not technically a bug, this can have a negative effect on the visual experience.
 
 When the ``Local Coords`` property is checked, all particle calculations use the local
 coordinate system to determine things like up and down, gravity, and movement direction.

tutorials/3d/procedural_geometry/immediatemesh.rst

@@ -78,7 +78,7 @@ The example code below draws a single triangle in the ``_ready()`` function.
 The ImmediateMesh can also be used across frames. Each time you call
 ``surface_begin()`` and ``surface_end()``, you are adding a new surface to the
 ImmediateMesh. If you want to recreate the mesh from scratch each frame, call
-``surface_clear()`` before calling ``surface_begin()``.
+``clear_surfaces()`` before calling ``surface_begin()``.
 
 .. tabs::
   .. code-tab:: gdscript GDScript

tutorials/3d/using_decals.rst

@@ -192,6 +192,34 @@ Cull Mask
   so you can ensure that dynamic objects don't accidentally receive a Decal
   intended for the terrain under them.
 
+Decal rendering order
+---------------------
+
+By default, decals are ordered based on the size of their :abbr:`AABB
+(Axis-Aligned Bounding Box)` and the distance to the camera. AABBs that are
+closer to the camera are rendered first, which means that decal rendering order
+can sometimes appear to change depending on camera position if some decals are
+positioned at the same location.
+
+To resolve this, you can adjust the **Sorting Offset** property in the
+VisualInstance3D section of the Decal node inspector. This offset is not a
+strict priority order, but a *guideline* that the renderer will use as the AABB
+size still affects how decal sorting works. Therefore, higher values will
+*always* result in the decal being drawn above other decals with a lower sorting
+offset.
+
+If you want to ensure a decal is always rendered on top of other decals,
+you need to set its **Sorting Offset** property to a positive value greater than
+the AABB length of the largest decal that may overlap it. To make this decal
+drawn behind other decals instead, set the **Sorting Offset** to the same
+negative value.
+
+.. figure:: img/decals_sorting_offset.webp
+   :align: center
+   :alt: VisualInstance3D Sorting Offset comparison on Decals
+
+   VisualInstance3D Sorting Offset comparison on Decals
+
 Tweaking performance and quality
 --------------------------------
 

tutorials/assets_pipeline/importing_3d_scenes/model_export_considerations.rst

@@ -39,10 +39,12 @@ Exporting textures separately
 
 While textures can be exported with a model in certain file formats, such as glTF 2.0, you can also export them
 separately. Godot uses PBR (physically based rendering) for its materials, so if a texturing program can export PBR
-textures they can work in Godot. This includes the `Substance suite <https://www.substance3d.com/>`__,
+textures, they can work in Godot. This includes the `Substance suite <https://www.adobe.com/creativecloud/3d-ar.html>`__,
 `ArmorPaint (open source) <https://armorpaint.org/>`__, and `Material Maker (open source) <https://github.com/RodZill4/material-maker>`__.
 
-.. note:: For more information on Godot's materials, see :ref:`doc_standard_material_3d`.
+.. seealso::
+
+    For more information on Godot's materials, see :ref:`doc_standard_material_3d`.
 
 Exporting considerations
 ------------------------

tutorials/assets_pipeline/retargeting_3d_skeletons.rst

@@ -47,8 +47,8 @@ With the Skeleton node selected, first set up a new :ref:`class_bonemap` and :re
 Godot has a preset called :ref:`class_skeletonprofilehumanoid` for humanoid models.
 This tutorial proceeds with the assumption that you are using :ref:`class_skeletonprofilehumanoid`.
 
-.. note:: If you need a profile for a model such as a beast or creature, you can export
-          a :ref:`class_skeletonprofile` from SkeletonEditor with some information converted from Skeleton.
+.. note:: If you need a profile that is different from :ref:`class_skeletonprofilehumanoid`, you can export
+          a :ref:`class_skeletonprofile` from the editor by selecting a Skeleton3D and using the **Skeleton3D** menu in the 3D viewport's toolbar.
 
 When you use :ref:`class_skeletonprofilehumanoid`, auto-mapping will be performed when the
 :ref:`class_skeletonprofile` is set. If the auto-mapping does not work well, you can map bones manually.