Split C++ (godot-cpp) and GDExtension system info into separate categories, children of Scripting.

Author: Ivorforce

tutorials/scripting/gdextension/index.rst

@@ -1,14 +1,26 @@
 :allow_comments: False
 
-GDExtension
-===========
+.. _doc_gdextension:
+
+The GDExtension system
+======================
+
+**GDExtension** is a Godot-specific technology that lets the engine interact with
+native `shared libraries <https://en.wikipedia.org/wiki/Library_(computing)#Shared_libraries>`__
+at runtime. You can use it to run native code without compiling it with the engine.
+
+.. note:: GDExtension is *not* a scripting language and has no relation to
+          :ref:`GDScript <doc_gdscript>`.
+
+This section describes how GDExtension works, and is generally aimed at people wanting to make a GDExtension from
+scratch, for example to create language bindings. If you want to use existing language bindings, please refer to other
+articles instead, such as the articles about :ref:`C++ (godot-cpp) <doc_godot_cpp>` or one of the
+:ref:`community-made ones <doc_what_is_gdnative_third_party_bindings>`.
 
 .. toctree::
    :maxdepth: 1
-   :name: toc-tutorials-gdnative
+   :name: toc-tutorials-gdextension
 
    what_is_gdextension
-   gdextension_cpp_example
-   gdextension_c_example
    gdextension_file
-   gdextension_docs_system
+   gdextension_c_example

tutorials/scripting/gdextension/what_is_gdextension.rst

@@ -3,129 +3,4 @@
 What is GDExtension?
 ====================
 
-Introduction
-------------
-
-**GDExtension** is a Godot-specific technology that lets the engine interact with
-native `shared libraries <https://en.wikipedia.org/wiki/Library_(computing)#Shared_libraries>`__
-at runtime. You can use it to run native code without compiling it with the engine.
-
-.. note:: GDExtension is *not* a scripting language and has no relation to
-          :ref:`GDScript <doc_gdscript>`.
-
-Differences between GDExtension and C++ modules
------------------------------------------------
-
-You can use both GDExtension and :ref:`C++ modules <doc_custom_modules_in_cpp>` to
-run C or C++ code in a Godot project.
-
-They also both allow you to integrate third-party libraries into Godot. The one
-you should choose depends on your needs.
-
-.. warning::
-
-    GDExtension is currently *experimental*, which means that we may
-    break compatibility in order to fix major bugs or include critical features.
-
-Advantages of GDExtension
-~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Unlike modules, GDExtension doesn't require compiling the engine's source code,
-making it easier to distribute your work. It gives you access to most of the API
-available to GDScript and C#, allowing you to code game logic with full control
-regarding performance. It's ideal if you need high-performance code you'd like
-to distribute as an add-on in the :ref:`asset library <doc_what_is_assetlib>`.
-
-Also:
-
-- GDExtension is not limited to C and C++. Thanks to :ref:`third-party bindings
-  <doc_what_is_gdnative_third_party_bindings>`, you can use it with many other
-  languages.
-- You can use the same compiled GDExtension library in the editor and exported
-  project. With C++ modules, you have to recompile all the export templates you
-  plan to use if you require its functionality at runtime.
-- GDExtension only requires you to compile your library, not the whole engine.
-  That's unlike C++ modules, which are statically compiled into the engine.
-  Every time you change a module, you need to recompile the engine. Even with
-  incremental builds, this process is slower than using GDExtension.
-
-Advantages of C++ modules
-~~~~~~~~~~~~~~~~~~~~~~~~~
-
-We recommend :ref:`C++ modules <doc_custom_modules_in_cpp>` in cases where
-GDExtension isn't enough:
-
-- C++ modules provide deeper integration into the engine. GDExtension's access
-  is not as deep as static modules.
-- You can use C++ modules to provide additional features in a project without
-  carrying native library files around. This extends to exported projects.
-
-.. note::
-
-    If you notice that specific systems are not accessible via GDExtension
-    but are via custom modules, feel free to open an issue on the
-    `godot-cpp repository <https://github.com/godotengine/godot-cpp>`__
-    to discuss implementation options for exposing the missing functionality.
-
-Supported languages
--------------------
-
-The Godot developers officially support the following language bindings for
-GDExtension:
-
-- C++ :ref:`(tutorial) <doc_gdextension_cpp_example>`
-
-.. note::
-
-    There are no plans to support additional languages with GDExtension officially.
-    That said, the community offers several bindings for other languages (see
-    below).
-
-.. _doc_what_is_gdnative_third_party_bindings:
-
-The bindings below are developed and maintained by the community:
-
-.. Binding developers: Feel free to open a pull request to add your binding if it's well-developed enough to be used in a project.
-.. Please keep languages sorted in alphabetical order.
-
-- `D <https://github.com/godot-dlang/godot-dlang>`__
-- `Go <https://github.com/grow-graphics/gd>`__
-- `Nim <https://github.com/godot-nim/gdext-nim>`__
-- `Rust <https://github.com/godot-rust/gdext>`__
-- `Swift <https://github.com/migueldeicaza/SwiftGodot>`__
-
-.. note::
-
-    Not all bindings mentioned here may be production-ready. Make sure to
-    research options thoroughly before starting a project with one of those.
-    Also, double-check whether the binding is compatible with the Godot version
-    you're using.
-
-.. _doc_what_is_gdextension_version_compatibility:
-
-Version compatibility
----------------------
-
-Usually, GDExtensions targeting an earlier version of Godot will work in later
-minor versions, but not vice-versa. For example, a GDExtension targeting Godot 4.2
-should work just fine in Godot 4.3, but one targeting Godot 4.3 won't work in Godot 4.2.
-
-For this reason, when creating GDExtensions, you may want to target the lowest version of
-Godot that has the features you need, *not* the most recent version of Godot. This can
-save you from needing to create multiple builds for different versions of Godot.
-
-However, GDExtension is currently *experimental*, which means that we may
-break compatibility in order to fix major bugs or include critical features.
-For example, GDExtensions created for Godot 4.0 aren't compatible with Godot
-4.1 (see :ref:`updating_your_gdextension_for_godot_4_1`).
-
-GDExtensions are also only compatible with engine builds that use the same
-level of floating-point precision the extension was compiled for. This means
-that if you use an engine build with double-precision floats, the extension must
-also be compiled for double-precision floats and use an ``extension_api.json``
-file generated by your custom engine build. See :ref:`doc_large_world_coordinates`
-for details.
-
-Generally speaking, if you build a custom version of Godot, you should generate an
-``extension_api.json`` from it for your GDExtensions, because it may have some differences
-from official Godot builds.
+Placeholder.

tutorials/scripting/godot_cpp/about_godot_cpp.rst

@@ -0,0 +1,96 @@
+.. _doc_about_godot_cpp:
+
+About godot-cpp
+===============
+
+`godot-cpp <https://github.com/godotengine/godot-cpp>`__ are the official C++ GDExtension bindings, maintained
+as part of the Godot project.
+
+godot-cpp is built with the :ref:`GDExtension system <doc_gdextension>`, which allows access to Godot in almost the
+same way as :ref:`modules <doc_custom_modules_in_cpp>`: A lot of `engine code <https://github.com/godotengine/godot>`__
+can be used in your godot-cpp project almost verbatim.
+
+In particular, godot-cpp has access to all functions that :ref:`GDScript <doc_gdscript>` and :ref:`C# <doc_c_sharp>`
+have, and additional access to a few more which are provided for fast low-level access of data.
+
+Differences between godot-cpp and C++ modules
+-----------------------------------------------
+
+You can use both `godot-cpp <https://github.com/godotengine/godot-cpp>`__
+and :ref:`C++ modules <doc_custom_modules_in_cpp>` to run C or C++ code in a Godot project.
+
+They also both allow you to integrate third-party libraries into Godot. The one
+you should choose depends on your needs.
+
+.. warning::
+
+    godot-cpp is currently *experimental*, which means that we may
+    break compatibility in order to fix major bugs or include critical features.
+
+
+Advantages of godot-cpp
+~~~~~~~~~~~~~~~~~~~~~~~
+
+Unlike modules, godot-cpp (and GDExtension systems in general) don't require
+compiling the engine's source code, making it easier to distribute your work.
+It gives you access to most of the API available to GDScript and C#, allowing
+you to code game logic with full control regarding performance. It's ideal if
+you need high-performance code you'd like to distribute as an add-on in the
+:ref:`asset library <doc_what_is_assetlib>`.
+
+Also:
+
+- You can use the same compiled godot-cpp library in the editor and exported
+  project. With C++ modules, you have to recompile all the export templates you
+  plan to use if you require its functionality at runtime.
+- godot-cpp only requires you to compile your library, not the whole engine.
+  That's unlike C++ modules, which are statically compiled into the engine.
+  Every time you change a module, you need to recompile the engine. Even with
+  incremental builds, this process is slower than using godot-cpp.
+
+Advantages of C++ modules
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+We recommend :ref:`C++ modules <doc_custom_modules_in_cpp>` in cases where
+godot-cpp (or another GDExtension system) isn't enough:
+
+- C++ modules provide deeper integration into the engine. GDExtension's access
+  is not as deep as static modules.
+- You can use C++ modules to provide additional features in a project without
+  carrying native library files around. This extends to exported projects.
+
+.. note::
+
+    If you notice that specific systems are not accessible via GDExtension
+    but are via custom modules, feel free to open an issue on the
+    `godot-cpp repository <https://github.com/godotengine/godot-cpp>`__
+    to discuss implementation options for exposing the missing functionality.
+
+.. _doc_what_is_gdextension_version_compatibility:
+
+Version compatibility
+---------------------
+
+Usually, GDExtensions targeting an earlier version of Godot will work in later
+minor versions, but not vice-versa. For example, a GDExtension targeting Godot 4.2
+should work just fine in Godot 4.3, but one targeting Godot 4.3 won't work in Godot 4.2.
+
+For this reason, when creating GDExtensions, you may want to target the lowest version of
+Godot that has the features you need, *not* the most recent version of Godot. This can
+save you from needing to create multiple builds for different versions of Godot.
+
+However, GDExtension is currently *experimental*, which means that we may
+break compatibility in order to fix major bugs or include critical features.
+For example, GDExtensions created for Godot 4.0 aren't compatible with Godot
+4.1 (see :ref:`updating_your_gdextension_for_godot_4_1`).
+
+GDExtensions are also only compatible with engine builds that use the same
+level of floating-point precision the extension was compiled for. This means
+that if you use an engine build with double-precision floats, the extension must
+also be compiled for double-precision floats and use an ``extension_api.json``
+file generated by your custom engine build. See :ref:`doc_large_world_coordinates`
+for details.
+
+Generally speaking, if you build a custom version of Godot, you should generate an
+``extension_api.json`` from it for your GDExtensions, because it may have some differences
+from official Godot builds.

tutorials/scripting/gdextension/gdextension_docs_system.rst renamed to tutorials/scripting/godot_cpp/docs_system.rst

@@ -1,4 +1,4 @@
-.. _doc_gdextension_docs_system:
+.. _doc_godot_cpp_docs_system:
 
 GDExtension documentation system
 ================================
@@ -15,7 +15,7 @@ XML files (one per class) to document the exposed constructors, properties, meth
 
 .. note::
 
-    We are assuming you are using the project files explained in the :ref:`GDExtension C++ Example <doc_gdextension_cpp_example>`
+    We are assuming you are using the project files explained in the :ref:`GDExtension C++ Example <doc_godot_cpp_getting_started>`
     with the following structure:
 
 .. code-block:: none

tutorials/scripting/gdextension/files/cpp_example/SConstruct renamed to tutorials/scripting/godot_cpp/files/cpp_example/SConstruct

@@ -1,29 +1,38 @@
-.. _doc_gdextension_cpp_example:
+.. _doc_godot_cpp_getting_started:
 
-GDExtension C++ example
-=======================
+Getting Started
+===============
 
-Introduction
-------------
+Workflow Overview
+-----------------
+
+As a GDExtension language binding, godot-cpp is more complicated to use than :ref:`GDScript <doc_gdscript>` and
+:ref:`C# <doc_c_sharp>`. If you decide to work with it, here's what to expect your workflow to look like:
 
-The C++ bindings for GDExtension are built on top of the C GDExtension API
-and provide a nicer way to "extend" nodes and other built-in classes in Godot using C++.
-This new system allows the extension of Godot to nearly the same
-level as statically linked C++ modules.
+* Create a new godot-cpp project (from the `template <https://github.com/godotengine/godot-cpp-template>`__, or from scratch, as explained below)
+* Develop your code with your favorite IDE locally.
+* Build and test your code with the earliest compatible Godot version.
+* Create builds for all platforms you want to support (e.g. using `GitHub Actions <https://github.com/godotengine/godot-cpp-template/blob/main/.github/workflows/builds.yml>`__).
+* Optional: Publish on the `Godot Asset Library <https://godotengine.org/asset-library/asset>`__.
 
-You can download the included example in the test folder of the godot-cpp
-repository `on GitHub <https://github.com/godotengine/godot-cpp>`__.
+Example Project
+---------------
+
+For you first godot-cpp project, we recommend starting with this guide to understand the technology involved with
+godot-cpp. After you're done, you can use the
+`godot-cpp template <https://github.com/godotengine/godot-cpp-template>`__, which is usually more up to date and has
+better coverage of features. However, the template does not explain itself to a high level of detail, which is why
+we recommend going through this guide first.
 
 Setting up the project
-----------------------
+~~~~~~~~~~~~~~~~~~~~~~
 
 There are a few prerequisites you'll need:
 
-- a Godot 4 executable,
-- a C++ compiler,
-- SCons as a build tool,
-- a copy of the `godot-cpp
-  repository <https://github.com/godotengine/godot-cpp>`__.
+- A Godot 4 executable.
+- A C++ compiler.
+- SCons as a build tool.
+- A copy of the `godot-cpp repository <https://github.com/godotengine/godot-cpp>`__.
 
 See also :ref:`Configuring an IDE <toc-devel-configuring_an_ide>`
 and :ref:`Compiling <toc-devel-compiling>` as the build tools are identical
@@ -91,7 +100,7 @@ following commands:
 This will initialize the repository in your project folder.
 
 Building the C++ bindings
--------------------------
+~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Now that we've downloaded our prerequisites, it is time to build the C++
 bindings.
@@ -129,7 +138,7 @@ libraries that can be compiled into your project stored in ``godot-cpp/bin/``.
     You may need to add ``bits=64`` to the command on Windows or Linux.
 
 Creating a simple plugin
-------------------------
+~~~~~~~~~~~~~~~~~~~~~~~~
 
 Now it's time to build an actual plugin. We'll start by creating an empty Godot
 project in which we'll place a few files.
@@ -327,7 +336,7 @@ At last, we need the header file for the ``register_types.cpp`` named
 
 
 Compiling the plugin
---------------------
+~~~~~~~~~~~~~~~~~~~~
 
 To compile the project we need to define how SCons using should compile it
 using a ``SConstruct`` file which references the one in ``godot-cpp``.
@@ -371,7 +380,7 @@ following commands to do so:
     ``target=template_release`` switch.
 
 Using the GDExtension module
-----------------------------
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Before we jump back into Godot, we need to create one more file in
 ``demo/bin/``.
@@ -476,7 +485,7 @@ We're finally ready to run the project:
    :align: default
 
 Adding properties
------------------
+~~~~~~~~~~~~~~~~~
 
 GDScript allows you to add properties to your script using the ``export``
 keyword. In GDExtension you have to register the properties with a getter and
@@ -610,7 +619,7 @@ The first two arguments are the minimum and maximum value and the third is the s
     further configure how properties are displayed and set on the Godot side.
 
 Signals
--------
+~~~~~~~
 
 Last but not least, signals fully work in GDExtension as well. Having your extension
 react to a signal given out by another object requires you to call ``connect``
@@ -717,7 +726,7 @@ our main node and implemented our signal like this:
 Every second, we output our position to the console.
 
 Next steps
-----------
+~~~~~~~~~~
 
 We hope the above example showed you the basics. You can
 build upon this example to create full-fledged scripts to control nodes in Godot