Relintai/pandemonium_engine_docs
1
0
Fork 0
mirror of https://github.com/Relintai/pandemonium_engine_docs.git synced 2025-03-14 18:38:56 +01:00
Code Issues Packages Projects Releases Wiki Activity

More cleanups.

Browse Source
This commit is contained in:
Relintai 2023-01-12 20:39:50 +01:00
parent a0b7fdc7eb
commit 322c693483
235 changed files with 1195 additions and 1195 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@ -54,7 +54,7 @@ To add images, please put them in an `img/` folder next to the .rst file with a
Similarly, you can include attachments (like assets as support material for a tutorial) by placing them into a `files/` folder next to the .rst file, and using this inline markup:
```rst
:download:`myfilename.zip <files/myfilename.zip>`
:download:`myfilename.zip <files/myfilename.zip )`
```
## Building with Sphinx

14
about/complying_with_licenses.md
View File

@ -6,7 +6,7 @@ Complying with licenses
What are licenses?
------------------
Godot is created and distributed under the `MIT License <https://opensource.org/licenses/MIT>`_.
Godot is created and distributed under the `MIT License ( https://opensource.org/licenses/MIT )`_.
It doesn't have a sole owner either, as every contributor that submits code to
the project does it under this same license and keeps ownership of the
contribution.
@ -97,7 +97,7 @@ Third-party licenses
--------------------
Godot itself contains software written by
`third parties <https://github.com/godotengine/godot/blob/master/COPYRIGHT.txt>`_.
`third parties ( https://github.com/godotengine/godot/blob/master/COPYRIGHT.txt )`_.
Most of it does not require license inclusion, but some do.
Make sure to do it if these are compiled in your Godot export template. If
you're using the official export templates, all libraries are enabled. This
@ -108,7 +108,7 @@ Here's a list of libraries requiring attribution:
FreeType
^^^^^^^^
Godot uses `FreeType <https://www.freetype.org/>`_ to render fonts. Its license
Godot uses `FreeType ( https://www.freetype.org/ )`_ to render fonts. Its license
requires attribution, so the following text must be included together with the
Godot license:
@ -124,7 +124,7 @@ Godot license:
ENet
^^^^
Godot includes the `ENet <http://enet.bespin.org/>`_ library to handle
Godot includes the `ENet ( http://enet.bespin.org/ )`_ library to handle
high-level multiplayer. ENet has similar licensing terms as Godot:
@ -139,7 +139,7 @@ high-level multiplayer. ENet has similar licensing terms as Godot:
mbed TLS
^^^^^^^^
If the project is exported with Godot 3.1 or later, it includes `mbed TLS <https://tls.mbed.org>`_.
If the project is exported with Godot 3.1 or later, it includes `mbed TLS ( https://tls.mbed.org )`_.
The Apache license needs to be complied to by including the following text:
Copyright The Mbed TLS Contributors
@ -156,12 +156,12 @@ The Apache license needs to be complied to by including the following text:
See the License for the specific language governing permissions and
limitations under the License.
Keep in mind that Godot 2.x and 3.0 use `OpenSSL <https://www.openssl.org>`_ 1.x
Keep in mind that Godot 2.x and 3.0 use `OpenSSL ( https://www.openssl.org )`_ 1.x
instead. This old OpenSSL version used the OpenSSL license, not the Apache 2 license
as the latest version of OpenSSL currently uses (as of April 2022).
.. note::
If you exported your project using a
`custom build with specific modules disabled <doc_optimizing_for_size>`,
`custom build with specific modules disabled <doc_optimizing_for_size )`,
you don't need to list the disabled modules' licenses in your exported project.

4
about/docs_changelog.md
View File

@ -5,7 +5,7 @@ Documentation changelog
The documentation is continually being improved. The release of version 3.2
includes many new tutorials, many fixes and updates for old tutorials, and many updates
to the `class reference <toc-class-ref>`. Below is a list of new tutorials
to the `class reference <toc-class-ref )`. Below is a list of new tutorials
added since version 3.1.
.. note:: This document only contains new tutorials so not all changes are reflected,
@ -83,7 +83,7 @@ Creating content
^^^^^^^^^^^^^^^^
Procedural geometry series:
- `Procedural geometry <toc-procedural_geometry>`
- `Procedural geometry <toc-procedural_geometry )`
- `doc_arraymesh`
- `doc_surfacetool`
- `doc_meshdatatool`

72
about/faq.md
View File

@ -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>`_ 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."
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."
In short:
@ -17,18 +17,18 @@ In short:
* You are free to modify, distribute, redistribute, and remix Godot to your heart's content, for any reason, both non-commercially and commercially.
All the contents of this accompanying documentation are published under
the permissive Creative Commons Attribution 3.0 (`CC-BY 3.0 <https://creativecommons.org/licenses/by/3.0/>`_) license, with attribution
the permissive Creative Commons Attribution 3.0 (`CC-BY 3.0 ( https://creativecommons.org/licenses/by/3.0/ )`_) license, with attribution
to "Juan Linietsky, Ariel Manzur and the Godot Engine community."
Logos and icons are generally under the same Creative Commons license. Note
that some third-party libraries included with Godot's source code may have
different licenses.
For full details, look at the `COPYRIGHT.txt <https://github.com/godotengine/godot/blob/master/COPYRIGHT.txt>`_ as well
as the `LICENSE.txt <https://github.com/godotengine/godot/blob/master/LICENSE.txt>`_ and `LOGO_LICENSE.txt <https://github.com/godotengine/godot/blob/master/LOGO_LICENSE.md>`_ files
For full details, look at the `COPYRIGHT.txt ( https://github.com/godotengine/godot/blob/master/COPYRIGHT.txt )`_ as well
as the `LICENSE.txt ( https://github.com/godotengine/godot/blob/master/LICENSE.txt )`_ and `LOGO_LICENSE.txt ( https://github.com/godotengine/godot/blob/master/LOGO_LICENSE.md )`_ files
in the Godot repository.
Also, see `the license page on the Godot website <https://godotengine.org/license>`_.
Also, see `the license page on the Godot website ( https://godotengine.org/license )`_.
Which platforms are supported by Godot?
---------------------------------------
@ -38,7 +38,7 @@ Which platforms are supported by Godot?
* Windows
* macOS
* X11 (Linux, \*BSD)
* `Web <doc_using_the_web_editor>`
* `Web <doc_using_the_web_editor )`
* Android (experimental)
**For exporting your games:**
@ -60,15 +60,15 @@ Additionally, there is some unofficial third-party work being done on building
for some consoles. However, none of this is included in the default build
scripts or export templates at this time.
For more on this, see the sections on `exporting <toc-learn-workflow-export>`
and `compiling Godot yourself <toc-devel-compiling>`.
For more on this, see the sections on `exporting <toc-learn-workflow-export )`
and `compiling Godot yourself <toc-devel-compiling )`.
Which programming languages are supported in Godot?
---------------------------------------------------
The officially supported languages for Godot are GDScript, Visual Scripting,
C#, and C++. See the subcategories for each language in the
`scripting <toc-learn-scripting>` section.
`scripting <toc-learn-scripting )` section.
If you are just starting out with either Godot or game development in general,
GDScript is the recommended language to learn and use since it is native to Godot.
@ -81,13 +81,13 @@ Note that C# support is still relatively new, and as such, you may encounter som
issues along the way. Our friendly and hard-working development community is always
ready to tackle new problems as they arise, but since this is an open-source project,
we recommend that you first do some due diligence yourself. Searching through
discussions on `open issues <https://github.com/godotengine/godot/issues>`_ is a
discussions on `open issues ( https://github.com/godotengine/godot/issues )`_ is a
great way to start your troubleshooting.
As for new languages, support is possible via third parties using the GDNative /
NativeScript / PluginScript facilities. (See the question about plugins below.)
Work is currently underway, for example, on unofficial bindings for Godot
to `Python <https://github.com/touilleMan/godot-python>`_ and `Nim <https://github.com/pragmagic/godot-nim>`_.
to `Python ( https://github.com/touilleMan/godot-python )`_ and `Nim ( https://github.com/pragmagic/godot-nim )`_.
.. _doc_faq_what_is_gdscript:
@ -99,7 +99,7 @@ up to maximize Godot's potential in the least amount of code, affording both nov
and expert developers alike to capitalize on Godot's strengths as fast as possible.
If you've ever written anything in a language like Python before then you'll feel
right at home. For examples, history, and a complete overview of the power GDScript
offers you, check out the `GDScript scripting guide <doc_gdscript>`.
offers you, check out the `GDScript scripting guide <doc_gdscript )`.
There are several reasons to use GDScript--especially when you are prototyping, in
alpha/beta stages of your project, or are not creating the next AAA title--but the
@ -128,11 +128,11 @@ languages can be found in the `doc_gdscript_more_efficiently` tutorial.
What were the motivations behind creating GDScript?
---------------------------------------------------
In the early days, the engine used the `Lua <https://www.lua.org>`
In the early days, the engine used the `Lua ( https://www.lua.org )`
scripting language. Lua is fast, but creating bindings to an object
oriented system (by using fallbacks) was complex and slow and took an
enormous amount of code. After some experiments with
`Python <https://www.python.org>`, it also proved difficult to embed.
`Python ( https://www.python.org )`, it also proved difficult to embed.
The main reasons for creating a custom scripting language for Godot were:
@ -157,8 +157,8 @@ GDScript was designed to curtail the issues above, and more.
What type of 3D model formats does Godot support?
-------------------------------------------------
Godot supports Collada via the `OpenCollada <https://github.com/KhronosGroup/OpenCOLLADA/wiki/OpenCOLLADA-Tools>`_ exporter (Maya, 3DSMax).
If you are using Blender, take a look at our own `Better Collada Exporter <https://godotengine.org/download>`_.
Godot supports Collada via the `OpenCollada ( https://github.com/KhronosGroup/OpenCOLLADA/wiki/OpenCOLLADA-Tools )`_ exporter (Maya, 3DSMax).
If you are using Blender, take a look at our own `Better Collada Exporter ( https://godotengine.org/download )`_.
As of Godot 3.0, glTF is supported.
@ -191,9 +191,9 @@ How do I install the Godot editor on my system (for desktop integration)?
Since you don't need to actually install Godot on your system to run it,
this means desktop integration is not performed automatically.
There are two ways to overcome this. You can install Godot from
`Steam <https://store.steampowered.com/app/404790/Godot_Engine/>` (all platforms),
`Scoop <https://scoop.sh/>` (Windows), `Homebrew <https://brew.sh/>` (macOS)
or `Flathub <https://flathub.org/apps/details/org.godotengine.Godot>` (Linux).
`Steam ( https://store.steampowered.com/app/404790/Godot_Engine/ )` (all platforms),
`Scoop ( https://scoop.sh/ )` (Windows), `Homebrew ( https://brew.sh/ )` (macOS)
or `Flathub ( https://flathub.org/apps/details/org.godotengine.Godot )` (Linux).
This will automatically perform the required steps for desktop integration.
Alternatively, you can manually perform the steps that an installer would do for you:
@ -225,14 +225,14 @@ Linux
This is typically `/usr/local/bin/godot` or `/usr/bin/godot`.
Doing this requires administrator privileges,
but this also allows you to
`run the Godot editor from a terminal <doc_command_line_tutorial>` by entering `godot`.
`run the Godot editor from a terminal <doc_command_line_tutorial )` by entering `godot`.
- If you cannot move the Godot editor binary to a protected location, you can
keep the binary somewhere in your home directory, and modify the `Path=`
line in the `.desktop` file linked below to contain the full *absolute* path
to the Godot binary.
- Save `this .desktop file <https://raw.githubusercontent.com/godotengine/godot/3.x/misc/dist/linux/org.godotengine.Godot.desktop>`
- Save `this .desktop file ( https://raw.githubusercontent.com/godotengine/godot/3.x/misc/dist/linux/org.godotengine.Godot.desktop )`
to `$HOME/.local/share/applications/`. If you have administrator privileges,
you can also save the `.desktop` file to `/usr/local/share/applications`
to make the shortcut available for all users.
@ -309,7 +309,7 @@ functionality in Godot. This is why we are aiming to move some core
functionality to officially supported add-ons in future versions of Godot. In
terms of binary size, this also has the advantage of making you pay only for what
you actually use in your project. (In the meantime, you can
`compile custom export templates with unused features disabled <doc_optimizing_for_size>`
`compile custom export templates with unused features disabled <doc_optimizing_for_size )`
to optimize the distribution size of your project.)
How should assets be created to handle multiple resolutions and aspect ratios?
@ -344,7 +344,7 @@ This is mostly needed for 2D, as in 3D it's just a matter of Camera XFov or YFov
if there is one aspect ratio and you want black bars to appear
instead. This is also explained in `doc_multiple_resolutions`.
4. For user interfaces, use the `anchoring <doc_size_and_anchors>`
4. For user interfaces, use the `anchoring <doc_size_and_anchors )`
to determine where controls should stay and move. If UIs are more
complex, consider learning about Containers.
@ -359,16 +359,16 @@ How can I extend Godot?
-----------------------
For extending Godot, like creating Godot Editor plugins or adding support
for additional languages, take a look at `EditorPlugins <doc_making_plugins>`
for additional languages, take a look at `EditorPlugins <doc_making_plugins )`
and tool scripts.
Also, see the official blog posts on these topics:
* `A look at the GDNative architecture <https://godotengine.org/article/look-gdnative-architecture>`_
* `GDNative is here! <https://godotengine.org/article/dlscript-here>`_
* `A look at the GDNative architecture ( https://godotengine.org/article/look-gdnative-architecture )`_
* `GDNative is here! ( https://godotengine.org/article/dlscript-here )`_
You can also take a look at the GDScript implementation, the Godot modules,
as well as the `unofficial Python support <https://github.com/touilleMan/godot-python>`_ for Godot.
as well as the `unofficial Python support ( https://github.com/touilleMan/godot-python )`_ for Godot.
This would be a good starting point to see how another third-party library
integrates with Godot.
@ -384,8 +384,8 @@ I would like to contribute! How can I get started?
Awesome! As an open-source project, Godot thrives off of the innovation and
ambition of developers like you.
The first place to get started is in the `issues <https://github.com/godotengine/godot/issues>`_.
Find an issue that resonates with you, then proceed to the `How to Contribute <https://github.com/godotengine/godot/blob/master/CONTRIBUTING.md#contributing-pull-requests>`_
The first place to get started is in the `issues ( https://github.com/godotengine/godot/issues )`_.
Find an issue that resonates with you, then proceed to the `How to Contribute ( https://github.com/godotengine/godot/blob/master/CONTRIBUTING.md#contributing-pull-requests )`_
guide to learn how to fork, modify, and submit a Pull Request (PR) with your changes.
I have a great idea for Godot. How can I share it?
@ -396,8 +396,8 @@ result in massive core changes, some sort of mimicry of what another
game engine does, or alternative workflows that you'd like built into
the editor. These are great, and we are thankful to have such motivated
people want to contribute, but Godot's focus is and always will be the
core functionality as outlined in the `Roadmap <https://github.com/godotengine/godot-roadmap/blob/master/ROADMAP.md>`_,
`squashing bugs and addressing issues <https://github.com/godotengine/godot/issues>`_,
core functionality as outlined in the `Roadmap ( https://github.com/godotengine/godot-roadmap/blob/master/ROADMAP.md )`_,
`squashing bugs and addressing issues ( https://github.com/godotengine/godot/issues )`_,
and conversations between Godot community members.
Most developers in the Godot community will be more interested to learn
@ -439,8 +439,8 @@ in the Project Settings to decrease CPU and GPU usage.
That said, we wouldn't recommend using Godot to create a *mobile* application
since low-processor mode isn't supported on mobile platforms yet.
Check out `Material Maker <https://github.com/RodZill4/material-maker>` and
`Pixelorama <https://github.com/Orama-Interactive/Pixelorama>` for examples of
Check out `Material Maker ( https://github.com/RodZill4/material-maker )` and
`Pixelorama ( https://github.com/Orama-Interactive/Pixelorama )` for examples of
open source applications made with Godot.
.. _doc_faq_use_godot_as_library:
@ -474,9 +474,9 @@ have to deal with the LGPL licensing caveats that come with GTK or Qt. Lastly,
this means Godot is "eating its own dog food" since the editor itself is one of
the most complex users of Godot's UI system.
This custom UI toolkit `can't be used as a library <doc_faq_use_godot_as_library>`,
This custom UI toolkit `can't be used as a library <doc_faq_use_godot_as_library )`,
but you can still
`use Godot to create non-game applications by using the editor <doc_faq_non_game_applications>`.
`use Godot to create non-game applications by using the editor <doc_faq_non_game_applications )`.
.. _doc_faq_why_not_stl:
@ -540,4 +540,4 @@ See `doc_ways_to_contribute`.
Who is working on Godot? How can I contact you?
-----------------------------------------------
See the corresponding page on the `Godot website <https://godotengine.org/contact>`_.
See the corresponding page on the `Godot website ( https://godotengine.org/contact )`_.

24
about/introduction.md
View File

@ -20,12 +20,12 @@ where to look if you need info on a specific feature.
Before you start
----------------
The `Tutorials and resources <doc_community_tutorials>` page lists
The `Tutorials and resources <doc_community_tutorials )` page lists
video tutorials contributed by the community. If you prefer video to text,
those may be worth a look.
In case you have trouble with one of the tutorials or your project,
you can find help on the various `Community channels <doc_community_channels>`,
you can find help on the various `Community channels <doc_community_channels )`,
especially the Godot Discord community, Q&A, and IRC.
About Godot Engine
@ -47,30 +47,30 @@ if you need a quick writeup about Godot Engine.
theirs, down to the last line of engine code. Godot's development is fully
independent and community-driven, empowering users to help shape their
engine to match their expectations. It is supported by the `Software
Freedom Conservancy <https://sfconservancy.org>`_ not-for-profit.
Freedom Conservancy ( https://sfconservancy.org )`_ not-for-profit.
For a more in-depth view of the engine, you are encouraged to read this
documentation further, especially the `Step by step
<toc-learn-step_by_step>` tutorial.
<toc-learn-step_by_step )` tutorial.
About the documentation
-----------------------
This documentation is continuously written, corrected, edited, and revamped by
members of the Godot Engine community. It is edited via text files in the
`reStructuredText <http://www.sphinx-doc.org/en/stable/rest.html>`_ markup
`reStructuredText ( http://www.sphinx-doc.org/en/stable/rest.html )`_ markup
language and then compiled into a static website/offline document using the
open source `Sphinx <http://www.sphinx-doc.org>`_ and `ReadTheDocs
<https://readthedocs.org/>`_ tools.
open source `Sphinx ( http://www.sphinx-doc.org )`_ and `ReadTheDocs
( https://readthedocs.org/ )`_ tools.
.. note:: You can contribute to Godot's documentation by opening issue tickets
or sending patches via pull requests on its GitHub
`source repository <https://github.com/godotengine/godot-docs>`_, or
`source repository ( https://github.com/godotengine/godot-docs )`_, or
translating it into your language on `Hosted Weblate
<https://hosted.weblate.org/projects/godot-engine/godot-docs/>`_.
( https://hosted.weblate.org/projects/godot-engine/godot-docs/ )`_.
All the contents are under the permissive Creative Commons Attribution 3.0
(`CC-BY 3.0 <https://creativecommons.org/licenses/by/3.0/>`_) license, with
(`CC-BY 3.0 ( https://creativecommons.org/licenses/by/3.0/ )`_) license, with
attribution to "Juan Linietsky, Ariel Manzur and the Godot Engine community".
Organization of the documentation
@ -86,7 +86,7 @@ relatively intuitive:
- The `sec-learn` section is the *raison d'être* of this
documentation, as it contains all the necessary information on using the
engine to make games. It starts with the `Step by step
<toc-learn-step_by_step>` tutorial which should be the entry point for all
<toc-learn-step_by_step )` tutorial which should be the entry point for all
new users.
- The `sec-tutorials` section can be read as needed,
in any order. It contains feature-specific tutorials and documentation.
@ -105,6 +105,6 @@ relatively intuitive:
`doc_updating_the_class_reference` for details.
In addition to this documentation you may also want to take a look at the
various `Godot demo projects <https://github.com/godotengine/godot-demo-projects>`_.
various `Godot demo projects ( https://github.com/godotengine/godot-demo-projects )`_.
Have fun reading and making games with Godot Engine!

82
about/list_of_features.md
View File

@ -8,7 +8,7 @@ This page aims to list all features currently supported by Godot.
.. note::
This page lists features supported by the current stable version of
Godot (3.5). `More features <https://docs.godotengine.org/en/latest/about/list_of_features.html>`
Godot (3.5). `More features ( https://docs.godotengine.org/en/latest/about/list_of_features.html )`
are available in the latest development version (4.0).
Features
@ -33,8 +33,8 @@ Platforms
- Android 4.4 and later.
- iOS 10.0 and later.
- `Consoles <doc_consoles>`.
- `Headless Linux and macOS servers <doc_exporting_for_dedicated_servers>`.
- `Consoles <doc_consoles )`.
- `Headless Linux and macOS servers <doc_exporting_for_dedicated_servers )`.
Godot aims to be as platform-independent as possible and can be ported to new
platforms with relative ease.
@ -46,9 +46,9 @@ Editor
- Scene tree editor.
- Built-in script editor.
- Support for `external script editors <doc_external_editor>` such as
- Support for `external script editors <doc_external_editor )` such as
Visual Studio Code or Vim.
- GDScript `debugger <doc_debugger_panel>`.
- GDScript `debugger <doc_debugger_panel )`.
- No support for debugging in threads yet.
- Performance monitoring tools.
@ -71,10 +71,10 @@ Editor
**Plugins:**
- Editor plugins can be downloaded from the
`asset library <doc_what_is_assetlib>` to extend editor functionality.
- `Create your own plugins <doc_making_plugins>` using GDScript to add new
`asset library <doc_what_is_assetlib )` to extend editor functionality.
- `Create your own plugins <doc_making_plugins )` using GDScript to add new
features or speed up your workflow.
- `Download projects from the asset library <doc_using_assetlib_editor>`
- `Download projects from the asset library <doc_using_assetlib_editor )`
in the project manager and import them directly.
2D graphics
@ -275,7 +275,7 @@ Editor
**Performance:**
- Occlusion culling with `rooms and portals <doc_rooms_and_portals>`.
- Occlusion culling with `rooms and portals <doc_rooms_and_portals )`.
Supports gameplay notifications with primary and secondary visibility to
disable AI/physics processing for nodes that don't need it.
- Real-time occluder shapes (sphere and polygon). Not as effective as rooms and portals
@ -291,8 +291,8 @@ Editor
^^^^^^^^
- Built-in meshes: cube, cylinder/cone, (hemi)sphere, prism, plane, quad.
- Tools for `procedural geometry generation <doc_procedural_geometry>`.
- `Constructive solid geometry <doc_csg_tools>` (intended for prototyping).
- Tools for `procedural geometry generation <doc_procedural_geometry )`.
- `Constructive solid geometry <doc_csg_tools )` (intended for prototyping).
- Path3D node to represent a path in 3D space.
- Can be drawn in the editor or generated procedurally.
@ -326,7 +326,7 @@ Shaders
- *2D:* Custom vertex, fragment, and light shaders.
- *3D:* Custom vertex, fragment, light, and sky shaders.
- Text-based shaders using a `shader language inspired by GLSL <doc_shading_language>`.
- Text-based shaders using a `shader language inspired by GLSL <doc_shading_language )`.
- Visual shader editor.
- Support for visual shader plugins.
@ -338,19 +338,19 @@ Scripting
- Object-oriented design pattern with scripts extending nodes.
- Signals and groups for communicating between scripts.
- Support for `cross-language scripting <doc_cross_language_scripting>`.
- Support for `cross-language scripting <doc_cross_language_scripting )`.
- Many 2D and 3D linear algebra data types such as vectors and transforms.
`GDScript: <toc-learn-scripting-gdscript>`
`GDScript: <toc-learn-scripting-gdscript )`
- `High-level interpreted language <doc_gdscript>` with
`optional static typing <doc_gdscript_static_typing>`.
- `High-level interpreted language <doc_gdscript )` with
`optional static typing <doc_gdscript_static_typing )`.
- Syntax inspired by Python.
- Syntax highlighting is provided on GitHub.
- `Use threads <doc_using_multiple_threads>` to perform asynchronous actions
- `Use threads <doc_using_multiple_threads )` to perform asynchronous actions
or make use of multiple processor cores.
`C#: <toc-learn-scripting-C#>`
`C#: <toc-learn-scripting-C# )`
- Packaged in a separate binary to keep file sizes and dependencies down.
- Uses Mono 6.x.
@ -360,9 +360,9 @@ Scripting
- Supports all platforms.
- Using an external editor is recommended to benefit from IDE functionality.
`VisualScript: <toc-learn-scripting-visual_script>`
`VisualScript: <toc-learn-scripting-visual_script )`
- `Graph-based visual scripting language <doc_what_is_visual_script>`.
- `Graph-based visual scripting language <doc_what_is_visual_script )`.
- Works best when used for specific purposes (such as level-specific logic)
rather than as a language to create entire projects.
@ -381,12 +381,12 @@ Scripting
.. warning::
`Godot 4.0 will remove VisualScript from core entirely. <https://godotengine.org/article/godot-4-will-discontinue-visual-scripting>`
`Godot 4.0 will remove VisualScript from core entirely. ( https://godotengine.org/article/godot-4-will-discontinue-visual-scripting )`
As a result, creating new projects using visual scripting in Godot is not recommended.
Future Godot 4.x releases may have VisualScript reimplemented as an extension.
While Godot 3.x will keep VisualScript supported, we recommend
`trying out GDScript <toc-learn-scripting-gdscript>` instead,
`trying out GDScript <toc-learn-scripting-gdscript )` instead,
especially if you intend to migrate your project to Godot 4.
Audio
@ -399,7 +399,7 @@ Audio
- Optional Doppler effect in 2D and 3D.
- Support for re-routable `audio buses <doc_audio_buses>` and effects
- Support for re-routable `audio buses <doc_audio_buses )` and effects
with dozens of effects included.
- Listener2D and Listener3D nodes to listen from a position different than the camera.
- Audio input to record microphones with real-time access using the AudioEffectCapture class.
@ -416,7 +416,7 @@ Audio
Import
^^^^^^
- Support for `custom import plugins <doc_import_plugins>`.
- Support for `custom import plugins <doc_import_plugins )`.
**Formats:**
@ -430,13 +430,13 @@ Import
- *3D scenes:*
- glTF 2.0 *(recommended)*.
- `ESCN <https://github.com/godotengine/godot-blender-exporter>`
- `ESCN ( https://github.com/godotengine/godot-blender-exporter )`
(direct export from Blender).
- FBX (experimental, static meshes only).
- Collada (.dae).
- Wavefront OBJ (static scenes only, can be loaded directly as a mesh).
- 3D meshes use `Mikktspace <http://www.mikktspace.com/>` to generate tangents
- 3D meshes use `Mikktspace ( http://www.mikktspace.com/ )` to generate tangents
on import, which ensures consistency with other 3D applications such as Blender.
Input
@ -492,8 +492,8 @@ Internationalization
^^^^^^^^^^^^^^^^^^^^
- Full support for Unicode including emoji.
- Store localization strings using `CSV <doc_internationalizing_games>`
or `gettext <doc_localization_using_gettext>`.
- Store localization strings using `CSV <doc_internationalizing_games )`
or `gettext <doc_localization_using_gettext )`.
- Use localized strings in your project automatically in GUI elements or by
using the `tr()` function.
- Support for right-to-left typesetting and text shaping planned in Godot 4.0.
@ -516,10 +516,10 @@ Windowing and OS integration
- Execute commands in a blocking or non-blocking manner.
- Open file paths and URLs using default or custom protocol handlers (if registered on the system).
- Parse custom command line arguments.
- `Headless/server binaries <doc_exporting_for_dedicated_servers>` can be
downloaded for Linux and `compiled for macOS <doc_compiling_for_osx>`.
- `Headless/server binaries <doc_exporting_for_dedicated_servers )` can be
downloaded for Linux and `compiled for macOS <doc_compiling_for_osx )`.
Any binary can be used without a window using the `--no-window`
`command line argument <doc_command_line_tutorial>`.
`command line argument <doc_command_line_tutorial )`.
Mobile
^^^^^^
@ -552,7 +552,7 @@ The editor UI can easily be extended in many ways using add-ons.
- Dropdown menus using PopupMenu and OptionButton.
- Scrollbars.
- Labels.
- RichTextLabel for `text formatted using BBCode <doc_bbcode_in_richtextlabel>`.
- RichTextLabel for `text formatted using BBCode <doc_bbcode_in_richtextlabel )`.
- Trees (can also be used to represent tables).
- Color picker with RGB and HSV modes.
- Containers (horizontal, vertical, grid, flow, center, margin, aspect ratio, draggable splitter, ...).
@ -600,7 +600,7 @@ Animation
File formats
^^^^^^^^^^^^
- Scenes and resources can be saved in `text-based <doc_tscn_file_format>` or binary formats.
- Scenes and resources can be saved in `text-based <doc_tscn_file_format )` or binary formats.
- Text-based formats are human-readable and more friendly to version control.
- Binary formats are faster to save/load for large scenes/resources.
@ -617,25 +617,25 @@ File formats
- Read XML files using `XMLParser`.
- Pack game data into a PCK file (custom format optimized for fast seeking),
into a ZIP archive, or directly into the executable for single-file distribution.
- `Export additional PCK files<doc_exporting_pcks>` that can be read
- `Export additional PCK files<doc_exporting_pcks )` that can be read
by the engine to support mods and DLCs.
Miscellaneous
^^^^^^^^^^^^^
- `Low-level access to servers <doc_using_servers>` which allows bypassing
- `Low-level access to servers <doc_using_servers )` which allows bypassing
the scene tree's overhead when needed.
- `Command line interface <doc_command_line_tutorial>` for automation.
- `Command line interface <doc_command_line_tutorial )` for automation.
- Export and deploy projects using continuous integration platforms.
- `Shell completion scripts <https://github.com/godotengine/godot/tree/master/misc/dist/shell>`
- `Shell completion scripts ( https://github.com/godotengine/godot/tree/master/misc/dist/shell )`
are available for Bash, zsh and fish.
- Support for `C++ modules <doc_custom_modules_in_c++>` statically linked
- Support for `C++ modules <doc_custom_modules_in_c++ )` statically linked
into the engine binary.
- Engine and editor written in C++03.
- Can be `compiled <doc_introduction_to_the_buildsystem>` using GCC,
- Can be `compiled <doc_introduction_to_the_buildsystem )` using GCC,
Clang and MSVC. MinGW is also supported.
- Friendly towards packagers. In most cases, system libraries can be used
instead of the ones provided by Godot. The build system doesn't download anything.
@ -644,10 +644,10 @@ Miscellaneous
- Licensed under the permissive MIT license.
- Open developement process with `contributions welcome <doc_ways_to_contribute>`.
- Open developement process with `contributions welcome <doc_ways_to_contribute )`.
.. seealso::
The `Godot proposals repository <https://github.com/godotengine/godot-proposals>`
The `Godot proposals repository ( https://github.com/godotengine/godot-proposals )`
lists features that have been requested by the community and may be implemented
in future Godot releases.

4
about/release_policy.md
View File

@ -11,7 +11,7 @@ community at a given time.
Godot versioning
----------------
Godot loosely follows `Semantic Versioning <https://semver.org/>` with a
Godot loosely follows `Semantic Versioning ( https://semver.org/ )` with a
`major.minor.patch` versioning system, albeit with an interpretation of each
term adapted to the complexity of a game engine:
@ -146,4 +146,4 @@ the latest bug fixes for their production needs.
As for the upcoming Godot 4.0, as of August 2022, we are aiming for a *beta*
release in Q3 2022, and possibly a stable release by Q4 2022 (but experience
has shown time and time again that such estimates tend to be overly optimistic).
`Follow the Godot blog <https://godotengine.org/news>` for the latest updates.
`Follow the Godot blog ( https://godotengine.org/news )` for the latest updates.

16
about/troubleshooting.md
View File

@ -13,7 +13,7 @@ This page lists common issues encountered when using Godot and possible solution
Everything I do in the editor or project manager appears delayed by one frame.
------------------------------------------------------------------------------
This is a `known bug <https://github.com/godotengine/godot/issues/23069>` on
This is a `known bug ( https://github.com/godotengine/godot/issues/23069 )` on
Intel graphics drivers on Windows. Updating to the latest graphics driver
version *provided by Intel* should fix the issue.
@ -24,7 +24,7 @@ outdated.
The grid disappears and meshes turn black when I rotate the 3D camera in the editor.
------------------------------------------------------------------------------------
This is a `known bug <https://github.com/godotengine/godot/issues/30330>` on
This is a `known bug ( https://github.com/godotengine/godot/issues/30330 )` on
Intel graphics drivers on Windows.
The only workaround, for now, is to switch to the GLES2 renderer. You can switch
@ -36,7 +36,7 @@ Optimus, you can use the dedicated graphics card to run Godot.
The editor or project takes a very long time to start.
------------------------------------------------------
This is a `known bug <https://github.com/godotengine/godot/issues/20566>` on
This is a `known bug ( https://github.com/godotengine/godot/issues/20566 )` on
Windows when you have specific USB peripherals connected. In particular,
Corsair's iCUE software seems to cause the bug. Try updating your USB
peripherals' drivers to their latest version. If the bug persists, you need to
@ -46,7 +46,7 @@ connect the peripheral again.
Editor tooltips in the Inspector and Node docks blink when they're displayed.
-----------------------------------------------------------------------------
This is a `known issue <https://github.com/godotengine/godot/issues/32990>`
This is a `known issue ( https://github.com/godotengine/godot/issues/32990 )`
caused by the third-party Stardock Fences application on Windows.
The only known workaround is to disable Stardock Fences while using Godot.
@ -81,15 +81,15 @@ done to improve performance, especially on integrated graphics, where rendering
To resolve this, open **Project > Project Settings** and enable **Display >
Window > Dpi > Allow Hidpi**. On top of that, make sure your project is
configured to support `multiple resolutions <doc_multiple_resolutions>`.
configured to support `multiple resolutions <doc_multiple_resolutions )`.
The project window doesn't appear centered when I run the project.
------------------------------------------------------------------
This is a `known bug <https://github.com/godotengine/godot/issues/13017>`. To
This is a `known bug ( https://github.com/godotengine/godot/issues/13017 )`. To
resolve this, open **Project > Project Settings** and enable **Display > Window
> Dpi > Allow Hidpi**. On top of that, make sure your project is configured to
support `multiple resolutions <doc_multiple_resolutions>`.
support `multiple resolutions <doc_multiple_resolutions )`.
The project works when run from the editor, but fails to load some files when running from an exported copy.
------------------------------------------------------------------------------------------------------------
@ -102,7 +102,7 @@ project, you need to specify `*.json` in the non-resource export filter. See
`doc_exporting_projects_export_mode` for more information.
On Windows, this can also be due to `case sensitivity
<doc_project_organization_case_sensitivity>` issues. If you reference a resource
<doc_project_organization_case_sensitivity )` issues. If you reference a resource
in your script with a different case than on the filesystem, loading will fail
once you export the project. This is because the virtual PCK filesystem is
case-sensitive, while Windows's filesystem is case-insensitive by default.

16
community/contributing/bisecting_regressions.md
View File

@ -5,7 +5,7 @@ Bisecting regressions
Bisecting is a way to find regressions in software. After reporting a bug on the
`Godot repository on GitHub <https://github.com/godotengine/godot>`, you may
`Godot repository on GitHub ( https://github.com/godotengine/godot )`, you may
be asked by a contributor to *bisect* the issue. Bisecting makes it possible for
contributors to fix bugs faster, as they can know in advance which commit caused
the regression. Your effort will be widely appreciated :)
@ -15,9 +15,9 @@ The guide below explains how to find a regression by bisecting.
What is bisecting?
------------------
Godot developers use the `Git <https://git-scm.com/>` version control system.
Godot developers use the `Git ( https://git-scm.com/ )` version control system.
In the context of Git, bisecting is the process of performing a manual
`binary search <https://en.wikipedia.org/wiki/Binary_search_algorithm>`
`binary search ( https://en.wikipedia.org/wiki/Binary_search_algorithm )`
to determine when a regression appeared. While it's typically used for bugs,
it can also be used to find other kinds of unexpected changes such as
performance regressions.
@ -29,7 +29,7 @@ Before using Git's `bisect` command, we strongly recommend trying to reproduce
the bug with an older (or newer) official release. This greatly reduces the
range of commits that potentially need to be built from source and tested.
You can find binaries of official releases, as well as alphas, betas,
and release candidates `here <https://downloads.tuxfamily.org/godotengine/>`.
and release candidates `here ( https://downloads.tuxfamily.org/godotengine/ )`.
For example, if you've reported a bug against Godot 3.2, you should first try to
reproduce the bug in Godot 3.1 (not a patch release, see below for the reason).
@ -59,7 +59,7 @@ reproduce the bug.
Before bisecting a regression, you need to set up a build environment to
compile Godot from source. To do so, read the
`Compiling <toc-devel-compiling>` page for your target platform.
`Compiling <toc-devel-compiling )` page for your target platform.
(Compiling Godot from source doesn't require C++ programming knowledge.)
Note that compiling Godot can take a while on slow hardware (up an hour for
@ -72,7 +72,7 @@ To start bisecting, you must first determine the commit hashes (identifiers) of
the "bad" and "good" build. "bad" refers to the build that exhibits the bug,
whereas "good" refers to the version that doesn't exhibit the bug. If you're
using a pre-release build as the "good" or "bad" build, browse the `download
mirror <https://downloads.tuxfamily.org/godotengine/>`, go to the folder that
mirror ( https://downloads.tuxfamily.org/godotengine/ )`, go to the folder that
contains the pre-release you downloaded and look for the `README.txt` file.
The commit hash is written inside that file.
@ -88,7 +88,7 @@ following commit hashes depending on the version:
To refer to the latest state of the master branch, you can use `master`
instead of a commit hash.
`Get Godot's source code using Git <doc_getting_source>`. Once this
`Get Godot's source code using Git <doc_getting_source )`. Once this
is done, in the terminal window, use `cd` to reach the Godot repository
folder and enter the following command:
@ -141,4 +141,4 @@ contributing to Godot :)
.. note::
You can read the full documentation on `git bisect`
`here <https://git-scm.com/docs/git-bisect>`.
`here ( https://git-scm.com/docs/git-bisect )`.

12
community/contributing/bug_triage_guidelines.md
View File

@ -5,7 +5,7 @@ Bug triage guidelines
This page describes the typical workflow of the bug triage team aka
bugsquad when handling issues and pull requests on Godot's
`GitHub repository <https://github.com/godotengine/godot>`.
`GitHub repository ( https://github.com/godotengine/godot )`.
It is bound to evolve together with the bugsquad, so do not
hesitate to propose modifications to the following guidelines.
@ -61,15 +61,15 @@ The following labels are currently defined in the Godot repository:
- *Documentation*: issue related to the documentation. Mainly to request
enhancements in the API documentation. Issues related to the ReadTheDocs
documentation should be filed on the
`godot-docs <https://github.com/godotengine/godot-docs>`_ repository.
`godot-docs ( https://github.com/godotengine/godot-docs )`_ repository.
- *Enhancement*: describes a proposed enhancement to an existing
functionality.
- *Feature proposal*: describes a wish for a new feature to be
implemented. Note that the main Godot repository no longer accepts
feature requests. Please use
`godot-proposals <https://github.com/godotengine/godot-proposals>` instead.
`godot-proposals ( https://github.com/godotengine/godot-proposals )` instead.
- *For PR meeting*: the issue needs to be discussed in a pull request meeting.
These meetings are public and are held on the `Godot Contributors Chat <https://chat.godotengine.org/>`_.
These meetings are public and are held on the `Godot Contributors Chat ( https://chat.godotengine.org/ )`_.
- *Good first issue*: the issue is *assumed* to be an easy one to fix, which makes
it a great fit for new contributors who need to become familiar with
the code base.
@ -149,7 +149,7 @@ Android and Linux exclusively, select those two platforms).
Documentation labels
~~~~~~~~~~~~~~~~~~~~
In the `documentation repository <https://github.com/godotengine/godot-docs>`, we
In the `documentation repository ( https://github.com/godotengine/godot-docs )`, we
use the following labels:
- *Bug*: Incorrect information in an existing page. Not to be used for
@ -177,7 +177,7 @@ use the following labels:
Milestones
~~~~~~~~~~
`Milestones <https://github.com/godotengine/godot/milestones>`_ correspond to
`Milestones ( https://github.com/godotengine/godot/milestones )`_ correspond to
planned future versions of Godot for which there is an existing roadmap. Issues
that fit in the said roadmap should be filed under the corresponding milestone;
if they don't correspond to any current roadmap, they should be left without

16
community/contributing/building_the_manual.md
View File

@ -9,20 +9,20 @@ documentation as a PDF, EPUB, or LaTeX file, for example.
To get started, you need to:
1. Clone the `godot-docs repository <https://github.com/godotengine/godot-docs/>`.
2. Install `Sphinx <https://www.sphinx-doc.org/>`
1. Clone the `godot-docs repository ( https://github.com/godotengine/godot-docs/ )`.
2. Install `Sphinx ( https://www.sphinx-doc.org/ )`
3. To build the docs as HTML files, install the `readthedocs.org theme
<https://github.com/snide/sphinx_rtd_theme>`.
( https://github.com/snide/sphinx_rtd_theme )`.
4. Install the Sphinx extensions defined in the `godot-docs repository
<https://github.com/godotengine/godot-docs/>` `requirements.txt` file.
( https://github.com/godotengine/godot-docs/ )` `requirements.txt` file.
We recommend using `pip <https://pip.pypa.io>`, Python’s package manager to
We recommend using `pip ( https://pip.pypa.io )`, Python’s package manager to
install all these tools. It comes pre-installed with `Python
<https://www.python.org/>`. Ensure that you install and use Python 3. Here are
( https://www.python.org/ )`. Ensure that you install and use Python 3. Here are
the commands to clone the repository and then install all requirements.
.. note:: You may need to write `python3 -m pip` (Unix) or `py -m pip` (Windows) instead of `pip3`.
If both approaches fail, `check that you have pip3 installed <https://pip.pypa.io/en/stable/installation/>`.
If both approaches fail, `check that you have pip3 installed ( https://pip.pypa.io/en/stable/installation/ )`.
.. code:: sh
@ -72,7 +72,7 @@ from the final HTML documentation but will keep the rest intact.
.. note:: If you delete the `classes/` folder, do not use `git add .` when
working on a pull request or the whole `classes/` folder will be
removed when you commit. See `#3157
<https://github.com/godotengine/godot-docs/issues/3157>` for more
( https://github.com/godotengine/godot-docs/issues/3157 )` for more
detail.
Alternatively, you can build the documentation by running the sphinx-build

22
community/contributing/class_reference_writing_guidelines.md
View File

@ -70,17 +70,17 @@ member variables, constants, and signals in separate XML nodes.
For each, you want to learn how they work in Godot's source code. Then, fill
their documentation by completing or improving the text in these tags:
- `<brief_description>`
- `<description>`
- `<constant>`
- `<method>` (in its `<description>` tag; return types and arguments don't take separate
- `<brief_description )`
- `<description )`
- `<constant )`
- `<method )` (in its `<description )` tag; return types and arguments don't take separate
documentation strings)
- `<member>`
- `<signal>` (in its `<description>` tag; arguments don't take separate documentation strings)
- `<constant>`
- `<member )`
- `<signal )` (in its `<description )` tag; arguments don't take separate documentation strings)
- `<constant )`
Write in a clear and simple language. Always follow the `writing guidelines
<doc_docs_writing_guidelines>` to keep your descriptions short and easy to read.
<doc_docs_writing_guidelines )` to keep your descriptions short and easy to read.
**Do not leave empty lines** in the descriptions: each line in the XML file will
result in a new paragraph, even if it is empty.
@ -108,7 +108,7 @@ errors if anything's wrong.
Alternatively, you can build Godot and open the modified page in the built-in
code reference. To learn how to compile the engine, read the `compilation
guide <toc-devel-compiling>`.
guide <toc-devel-compiling )`.
We recommend using a code editor that supports XML files like Vim, Atom, Visual Studio Code,
Notepad++, or another to comfortably edit the file. You can also use their
@ -181,7 +181,7 @@ If you need to have different code version in GDScript and C#, use
least one of the language-specific tags, `[gdscript]` and `[csharp]`.
Always write GDScript code examples first! You can use this `experimental code
translation tool <https://github.com/HaSa1002/codetranslator>`_ to speed up your
translation tool ( https://github.com/HaSa1002/codetranslator )`_ to speed up your
workflow.
.. code-block:: none
@ -243,4 +243,4 @@ pull of your changes. Another writer will take care of it.
You can still look at the methods' implementation in Godot's source code on
GitHub. If you have doubts, feel free to ask on the `Q&A website
<https://godotengine.org/qa/>` and `Godot Contributors Chat <https://chat.godotengine.org/>`_.
( https://godotengine.org/qa/ )` and `Godot Contributors Chat ( https://chat.godotengine.org/ )`_.

30
community/contributing/code_style_guidelines.md
View File

@ -14,7 +14,7 @@ C++ and Objective-C
-------------------
There are no written guidelines, but the code style agreed upon by the
developers is enforced via the `clang-format <http://clang.llvm.org/docs/ClangFormat.html>`
developers is enforced via the `clang-format ( http://clang.llvm.org/docs/ClangFormat.html )`
code beautifier, which takes care for you of all our conventions.
To name a few:
@ -25,7 +25,7 @@ To name a few:
- See further down regarding header includes
The rules used by clang-format are outlined in the
`.clang-format <https://github.com/godotengine/godot/blob/master/.clang-format>`
`.clang-format ( https://github.com/godotengine/godot/blob/master/.clang-format )`
file of the Godot repository.
As long as you ensure that your style matches the surrounding code and that you
@ -68,10 +68,10 @@ Here's how to install clang-format:
- Linux: It will usually be available out-of-the-box with the clang toolchain
packaged by your distribution. If your distro version is not the required one,
you can download a pre-compiled version from the
`LLVM website <http://releases.llvm.org/download.html>`, or if you are on
a Debian derivative, use the `upstream repos <http://apt.llvm.org/>`.
`LLVM website ( http://releases.llvm.org/download.html )`, or if you are on
a Debian derivative, use the `upstream repos ( http://apt.llvm.org/ )`.
- macOS and Windows: You can download precompiled binaries from the
`LLVM website <http://releases.llvm.org/download.html>`. You may need to add
`LLVM website ( http://releases.llvm.org/download.html )`. You may need to add
the path to the binary's folder to your system's `PATH` environment
variable to be able to call `clang-format` out of the box.
@ -117,12 +117,12 @@ clang-format automatically, for example each time you save a file.
Here is a non-exhaustive list of beautifier plugins for some IDEs:
- Qt Creator: `Beautifier plugin <http://doc.qt.io/qtcreator/creator-beautifier.html>`
- Visual Studio Code: `Clang-Format <https://marketplace.visualstudio.com/items?itemName=xaver.clang-format>`
- Visual Studio: `ClangFormat <https://marketplace.visualstudio.com/items?itemName=LLVMExtensions.ClangFormat>`
- vim: `vim-clang-format <https://github.com/rhysd/vim-clang-format>`
- Qt Creator: `Beautifier plugin ( http://doc.qt.io/qtcreator/creator-beautifier.html )`
- Visual Studio Code: `Clang-Format ( https://marketplace.visualstudio.com/items?itemName=xaver.clang-format )`
- Visual Studio: `ClangFormat ( https://marketplace.visualstudio.com/items?itemName=LLVMExtensions.ClangFormat )`
- vim: `vim-clang-format ( https://github.com/rhysd/vim-clang-format )`
- CLion: Starting from version `2019.1`, no plugin is required. Instead, enable
`ClangFormat <https://www.jetbrains.com/help/clion/clangformat-as-alternative-formatter.html#clion-support>`
`ClangFormat ( https://www.jetbrains.com/help/clion/clangformat-as-alternative-formatter.html#clion-support )`
(Pull requests welcome to extend this list with tested plugins.)
@ -149,7 +149,7 @@ ones, the following rules should be followed:
separation.
- Finally, third-party headers (either from `thirdparty` or from the system's
include paths) come next and should be included with the < and > symbols, e.g.
`#include <png.h>`. The block of third-party headers should also be followed
`#include <png.h )`. The block of third-party headers should also be followed
by an empty line for separation.
- Godot and third-party headers should be included in the file that requires
them, i.e. in the `.h` header if used in the declarative code or in the `.cpp`
@ -256,8 +256,8 @@ Python
Godot's SCons buildsystem is written in Python, and various scripts included
in the source tree are also using Python.
For those, we follow the `Black style guide <https://github.com/psf/black#the-black-code-style>`.
Blacken your Python changes using `Black <https://pypi.org/project/black/>`.
For those, we follow the `Black style guide ( https://github.com/psf/black#the-black-code-style )`.
Blacken your Python changes using `Black ( https://pypi.org/project/black/ )`.
Using black locally
~~~~~~~~~~~~~~~~~~~
@ -308,7 +308,7 @@ Editor integration
Many IDEs or code editors have beautifier plugins that can be configured to run
black automatically, for example each time you save a file. For details you can
check `Black editor integration <https://github.com/psf/black#editor-integration>`.
check `Black editor integration ( https://github.com/psf/black#editor-integration )`.
Comment style guide
-------------------
@ -344,7 +344,7 @@ Don't repeat what the code says in a comment. Explain the *why* rather than *how
You can use Javadoc-style comments above function or macro definitions. It's
recommended to use Javadoc-style comments *only* for methods which are not
exposed to scripting. This is because exposed methods should be documented in
the `class reference XML <doc_updating_the_class_reference>`
the `class reference XML <doc_updating_the_class_reference )`
instead.
**Example:**

22
community/contributing/contributing_to_the_documentation.md
View File

@ -16,7 +16,7 @@ Getting started
To modify or create pages in the reference manual, you need to edit `.rst`
files in the `godot-docs GitHub repository
<https://github.com/godotengine/godot-docs>`_. Modifying those pages in a pull
( https://github.com/godotengine/godot-docs )`_. Modifying those pages in a pull
request triggers a rebuild of the online documentation upon merging.
.. seealso:: For details on Git usage and the pull request workflow, please
@ -25,8 +25,8 @@ request triggers a rebuild of the online documentation upon merging.
the docs repository.
.. warning:: The class reference's source files are in the `Godot engine
repository <https://github.com/godotengine/godot>`_. We generate
the `Godot API <toc-class-ref>` section of this documentation
repository ( https://github.com/godotengine/godot )`_. We generate
the `Godot API <toc-class-ref )` section of this documentation
from them. If you want to update the description of a class, its
methods, or properties, read
`doc_updating_the_class_reference`.
@ -64,7 +64,7 @@ To edit an existing page, locate its `.rst` source file and open it in your
favorite text editor. You can then commit the changes, push them to your fork,
and make a pull request. **Note that the pages in** `classes/` **should not be
edited here.** They are automatically generated from Godot’s `XML class
reference <https://github.com/godotengine/godot/tree/master/doc/classes>`.
reference ( https://github.com/godotengine/godot/tree/master/doc/classes )`.
See `doc_updating_the_class_reference` for details.
.. seealso:: To build the manual and test changes on your computer, see
@ -104,7 +104,7 @@ Adding new pages
Before adding a new page, please ensure that it fits in the documentation:
1. Look for `existing issues
<https://github.com/godotengine/godot-docs/issues>`_ or open a new one to see
( https://github.com/godotengine/godot-docs/issues )`_ or open a new one to see
if the page is necessary.
2. Ensure there isn't a page that already covers the topic.
3. Read our `doc_content_guidelines`.
@ -145,17 +145,17 @@ first letter capitalized.
Sphinx and reStructuredText syntax
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Check Sphinx’s `reST Primer <https://www.sphinx-doc.org/en/stable/rest.html>`
and the `official reference <http://docutils.sourceforge.net/rst.html>` for
Check Sphinx’s `reST Primer ( https://www.sphinx-doc.org/en/stable/rest.html )`
and the `official reference ( http://docutils.sourceforge.net/rst.html )` for
details on the syntax.
Sphinx uses specific reST comments to do specific operations, like defining the
table of contents (`.. toctree::`) or cross-referencing pages. Check the
`official Sphinx documentation
<https://www.sphinx-doc.org/en/stable/index.html>` for more details. To learn
( https://www.sphinx-doc.org/en/stable/index.html )` for more details. To learn
how to use Sphinx directives like `.. note::` or `.. seealso::`, check out
the `Sphinx directives documentation
<https://www.sphinx-doc.org/en/master/usage/restructuredtext/directives.html>`.
( https://www.sphinx-doc.org/en/master/usage/restructuredtext/directives.html )`.
Adding images and attachments
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -173,7 +173,7 @@ using this inline markup:
.. code:: rst
:download:`myfilename.zip <files/myfilename.zip>`
:download:`myfilename.zip <files/myfilename.zip )`
License
@ -181,7 +181,7 @@ License
This documentation and every page it contains is published under the terms of
the `Creative Commons Attribution 3.0 license (CC-BY-3.0)
<https://tldrlegal.com/license/creative-commons-attribution-(cc)>`_, with
( https://tldrlegal.com/license/creative-commons-attribution-(cc) )`_, with
attribution to "Juan Linietsky, Ariel Manzur and the Godot community".
By contributing to the documentation on the GitHub repository, you agree that

2
community/contributing/cpp_usage_guidelines.md
View File

@ -48,7 +48,7 @@ purpose, such as improving code readability or performance.
Standard Template Library
^^^^^^^^^^^^^^^^^^^^^^^^^
We don't allow using the `STL <https://en.wikipedia.org/wiki/Standard_Template_Library>`
We don't allow using the `STL ( https://en.wikipedia.org/wiki/Standard_Template_Library )`
as Godot provides its own data types (among other things).
See `doc_faq_why_not_stl` for more information.

6
community/contributing/docs_writing_guidelines.md
View File

@ -34,7 +34,7 @@ There are 3 rules to describe classes:
.. seealso::
See the `content guidelines <doc_content_guidelines>` for information
See the `content guidelines <doc_content_guidelines )` for information
on the types of documentation you can write in the official documentation.
7 rules for clear English
@ -530,9 +530,9 @@ for some users.
Before you add or replace any images in the documentation, they should be run
through a PNG compressor to save size. You can use the lossless OxiPNG
compressor included in `Squoosh <https://squoosh.app/>` for this purpose. For
compressor included in `Squoosh ( https://squoosh.app/ )` for this purpose. For
heavier images, consider using a lossy compressor like `pngquant
<https://pngquant.org/>`_. With it, almost no image quality is lost during
( https://pngquant.org/ )`_. With it, almost no image quality is lost during
compression.
.. note::

18
community/contributing/documentation_guidelines.md
View File

@ -6,15 +6,15 @@ Documentation guidelines
This page describes the rules to follow if you want to contribute to Godot
Engine by writing or reviewing documentation, or by translating existing
documentation. Also, have a look at README of the
`godot-docs GitHub repository <https://github.com/godotengine/godot-docs>`_
and the `docs front page <https://docs.godotengine.org>`_
`godot-docs GitHub repository ( https://github.com/godotengine/godot-docs )`_
and the `docs front page ( https://docs.godotengine.org )`_
on what steps to follow and how to contact the docs team.
How to contribute
-----------------
Creating or modifying documentation pages is mainly done via the
`godot-docs GitHub repository <https://github.com/godotengine/godot-docs>`_.
`godot-docs GitHub repository ( https://github.com/godotengine/godot-docs )`_.
The HTML (or PDF and EPUB) documentation is generated from the .rst files
(reStructuredText markup language) in that repository. Modifying those pages
in a pull request and getting it merged will trigger a rebuild of the online
@ -26,8 +26,8 @@ documentation.
also valid for the docs repository.
.. warning:: The class reference's source files are in the `Godot engine repository
<https://github.com/godotengine/godot>`_. We generate the `Godot API
<toc-class-ref>` section of this documentation from them. If you want to update the
( https://github.com/godotengine/godot )`_. We generate the `Godot API
<toc-class-ref )` section of this documentation from them. If you want to update the
description of a class, its methods, or properties, read
`doc_updating_the_class_reference`.
@ -41,7 +41,7 @@ documentation.
The 'Edit on GitHub' link
-------------------------
If you're reading documentation on `docs.godotengine.org <https://docs.godotengine.org>`_,
If you're reading documentation on `docs.godotengine.org ( https://docs.godotengine.org )`_,
you'll see an **Edit on GitHub** hyperlink at the top right of the page.
Once you've created a GitHub account, you can propose changes to a page you're
reading as follows:
@ -118,7 +118,7 @@ letter.
Translating existing pages
--------------------------
You can help to translate the official Godot documentation on our `Hosted Weblate <https://hosted.weblate.org/engage/godot-engine/>`_.
You can help to translate the official Godot documentation on our `Hosted Weblate ( https://hosted.weblate.org/engage/godot-engine/ )`_.
![](https://hosted.weblate.org/widgets/godot-engine/-/godot-docs/287x66-white.png)
:alt: Translation state
@ -128,14 +128,14 @@ You can help to translate the official Godot documentation on our `Hosted Weblat
:height: 66
There also is the official
`Godot i18n repository <https://github.com/godotengine/godot-docs-l10n>`_
`Godot i18n repository ( https://github.com/godotengine/godot-docs-l10n )`_
where you can see when the data was last synchronized.
License
-------
This documentation and every page it contains is published under the terms of
the `Creative Commons Attribution 3.0 license (CC-BY-3.0) <https://tldrlegal.com/license/creative-commons-attribution-(cc)>`_, with attribution to "Juan Linietsky, Ariel Manzur and the Godot community".
the `Creative Commons Attribution 3.0 license (CC-BY-3.0) ( https://tldrlegal.com/license/creative-commons-attribution-(cc) )`_, with attribution to "Juan Linietsky, Ariel Manzur and the Godot community".
By contributing to the documentation on the GitHub repository, you agree that
your changes are distributed under this license.

38
community/contributing/editor_and_docs_localization.md
View File

@ -12,15 +12,15 @@ translation effort of the community.
These resources include:
1. The `Godot editor's interface <https://hosted.weblate.org/projects/godot-engine/godot/>`
1. The `Godot editor's interface ( https://hosted.weblate.org/projects/godot-engine/godot/ )`
(ca. 15,000 words).
2. The `online documentation <https://hosted.weblate.org/projects/godot-engine/godot-docs/>`
2. The `online documentation ( https://hosted.weblate.org/projects/godot-engine/godot-docs/ )`
(editor manual and tutorials, ca. 300,000 words).
3. The `class reference <https://hosted.weblate.org/projects/godot-engine/godot-class-reference/>`,
3. The `class reference ( https://hosted.weblate.org/projects/godot-engine/godot-class-reference/ )`,
available both online and in the editor (ca. 200,000 words).
To manage translations, we use the GNU gettext file format (`PO` files), and
the open source `Weblate <https://weblate.org>` web-based localization
the open source `Weblate ( https://weblate.org )` web-based localization
platform, which allows easy collaboration of many contributors to complete the
translation for the various components, and keep them up to date. Click the bold
links above to access each resource on Weblate.
@ -45,11 +45,11 @@ Weblate, and thus direct pull requests to the Git repositories are not accepted.
Translations are synced manually between Weblate and the Godot repositories by
maintainers.
You should therefore `register on Weblate <https://hosted.weblate.org/accounts/register/>`
You should therefore `register on Weblate ( https://hosted.weblate.org/accounts/register/ )`
to contribute to Godot's translations.
Once signed in, browse to the Godot resource which you want to contribute to (in
this page we will use the `editor translation <https://hosted.weblate.org/projects/godot-engine/godot/>`
this page we will use the `editor translation ( https://hosted.weblate.org/projects/godot-engine/godot/ )`
as an example) to find the list of all languages:
![](img/l10n_01_language_list.png)
@ -57,7 +57,7 @@ as an example) to find the list of all languages:
.. seealso::
Feel free to consult Weblate's own documentation on the `translation
workflow <https://docs.weblate.org/en/latest/user/translating.html>` for
workflow ( https://docs.weblate.org/en/latest/user/translating.html )` for
more details.
Adding a new language
@ -262,7 +262,7 @@ external links, etc. Here are some examples::
# syntax and should be preserved.
Looking for the documentation of the current **development** branch?
`Have a look here <https://docs.godotengine.org/en/latest>`_.
`Have a look here ( https://docs.godotengine.org/en/latest )`_.
# "|supported|" is an inline reference to an image and should stay unchanged.
# "master" uses the markup for inline code, and will be styled as such.
@ -281,7 +281,7 @@ external links, etc. Here are some examples::
# Or it can be used with an optional custom title, which should thus be translated:
See `how to contribute <doc_ways_to_contribute>`.
See `how to contribute <doc_ways_to_contribute )`.
# You may encounter other Sphinx roles, such as :kbd: used for shortcut keys.
# You can translate the content between backticks to match the usual key names,
@ -292,7 +292,7 @@ external links, etc. Here are some examples::
.. seealso::
See Sphinx's `reStructured Text primer <https://www.sphinx-doc.org/en/master/usage/restructuredtext/basics.html>`
See Sphinx's `reStructured Text primer ( https://www.sphinx-doc.org/en/master/usage/restructuredtext/basics.html )`
for a quick overview of the markup language you may find in source strings.
You may encounter especially the inline markup (bold, italics, inline code)
and the internal and external hyperlink markup.
@ -328,7 +328,7 @@ breaks if they are not part of the original translation.
.. seealso::
See our documentation for class reference writers for the `list of
BBCode-like tags <doc_class_reference_writing_guidelines_bbcode>` which are used
BBCode-like tags <doc_class_reference_writing_guidelines_bbcode )` which are used
throughout the class reference.
Offline translation and testing
@ -336,8 +336,8 @@ Offline translation and testing
While we advise using the Weblate interface to write translations, you also have
the possibility to download the PO file locally to translate it with your
preferred PO editing application, such as `Poedit <https://poedit.net/>` or
`Lokalize <https://userbase.kde.org/Lokalize>`.
preferred PO editing application, such as `Poedit ( https://poedit.net/ )` or
`Lokalize ( https://userbase.kde.org/Lokalize )`.
To download the PO file locally, browse to the translation overview for your
language, and select the first item in the "Files" menu:
@ -357,15 +357,15 @@ upload mode.
version.
If you want to test changes locally (especially for the editor translation), you
can use the downloaded PO file and `compile Godot from source <toc-devel-compiling>`.
can use the downloaded PO file and `compile Godot from source <toc-devel-compiling )`.
Rename the editor translation PO file to `<lang>.po` (e.g. `eo.po` for
Esperanto) and place it in the `editor/translations/` folder
(`GitHub <https://github.com/godotengine/godot/tree/master/editor/translations>`).
(`GitHub ( https://github.com/godotengine/godot/tree/master/editor/translations )`).
You can also test class reference changes the same way by renaming the PO file
similarly and placing it in the `doc/translations/` folder
(`GitHub <https://github.com/godotengine/godot/tree/master/doc/translations>`).
(`GitHub ( https://github.com/godotengine/godot/tree/master/doc/translations )`).
Localizing documentation images
-------------------------------
@ -375,7 +375,7 @@ Godot editor, custom-made graphs, of any other kind of visual content. Some of
it includes text and might thus be relevant to localize in your language.
This part is not handled via Weblate, but directly on the `godot-docs-l10n
<https://github.com/godotengine/godot-docs-l10n>`_ Git repository where the
( https://github.com/godotengine/godot-docs-l10n )`_ Git repository where the
documentation translations are synced from Weblate.
.. note::
@ -409,8 +409,8 @@ added before the extension, e.g. `project_manager_first_open.png)` would become
Finally, on godot-docs-l10n_, recreate the same folder structure as for the
original image in the `images` subfolder
(`GitHub <https://github.com/godotengine/godot-docs-l10n/tree/master/images>`_),
(`GitHub ( https://github.com/godotengine/godot-docs-l10n/tree/master/images )`_),
and place your translated image there. In our example, the end result should be
`images/getting_started/step_by_step/img/project_manager_first_open.fr.png)`.
Repeat this for other images and `make a Pull Request <doc_pr_workflow>`.
Repeat this for other images and `make a Pull Request <doc_pr_workflow )`.

4
community/contributing/index.md
View File

@ -9,7 +9,7 @@ can contribute to the project:
reference manual or the code reference.
- Translating the editor or documentation from English to other languages.
- Reporting issues or `writing detailed proposals
<https://github.com/godotengine/godot-proposals/>`.
( https://github.com/godotengine/godot-proposals/ )`.
Getting started
---------------
@ -82,7 +82,7 @@ Class reference guides
The pages below focus on the class reference.
As the reference is included in the Godot editor, its source files are part of
the `godot repository <https://github.com/godotengine/godot>`_. We use XML files
the `godot repository ( https://github.com/godotengine/godot )`_. We use XML files
to write it, so the process to contribute to the class reference differs from
writing the online manual.

30
community/contributing/pr_workflow.md
View File

@ -25,12 +25,12 @@ organization of Godot's Git repository.
Git source repository
---------------------
The `repository on GitHub <https://github.com/godotengine/godot>`_ is a
`Git <https://git-scm.com>`_ code repository together with an embedded
The `repository on GitHub ( https://github.com/godotengine/godot )`_ is a
`Git ( https://git-scm.com )`_ code repository together with an embedded
issue tracker and PR system.
.. note:: If you are contributing to the documentation, its repository can
be found `here <https://github.com/godotengine/godot-docs>`_.
be found `here ( https://github.com/godotengine/godot-docs )`_.
The Git version control system is the tool used to keep track of successive
edits to the source code - to contribute efficiently to Godot, learning the
@ -45,8 +45,8 @@ which quickly leads to PRs with an unreadable Git history (especially after peer
.. seealso:: The first sections of Git's "Book" are a good introduction to
the tool's philosophy and the various commands you need to
master in your daily workflow. You can read them online on the
`Git SCM <https://git-scm.com/book/en/v2>`_ website.
You can also try out `GitHub's interactive guide <https://try.github.io/>`.
`Git SCM ( https://git-scm.com/book/en/v2 )`_ website.
You can also try out `GitHub's interactive guide ( https://try.github.io/ )`.
The branches on the Git repository are organized as follows:
@ -70,7 +70,7 @@ The branches on the Git repository are organized as follows:
Forking and cloning
-------------------
The first step is to *fork* the `godotengine/godot <https://github.com/godotengine/godot>`_
The first step is to *fork* the `godotengine/godot ( https://github.com/godotengine/godot )`_
repository on GitHub. To do so, you will need to have a GitHub account and to
be logged in. In the top right corner of the repository's GitHub page, you
should see the "Fork" button as shown below:
@ -84,7 +84,7 @@ Godot repo, with your GitHub username as namespace:
You can then *clone* your fork, i.e. create a local copy of the online
repository (in Git speak, the *origin remote*). If you haven't already,
download Git from `its website <https://git-scm.com>`_ if you're using Windows or
download Git from `its website ( https://git-scm.com )`_ if you're using Windows or
macOS, or install it through your package manager if you're using Linux.
.. note:: If you are on Windows, open Git Bash to type commands. macOS and Linux users
@ -236,11 +236,11 @@ You will then be back to the original state of your branch before calling
If you have already created a merge commit without using `rebase`, or
have made any other changes that have resulted in undesired history, the best option
is to use an *interactive rebase* on the upstream branch. See the `dedicated
section <doc_pr_workflow_rebase>` for instructions.
section <doc_pr_workflow_rebase )` for instructions.
.. tip:: If at any time you want to *reset* a local branch to a given commit or branch,
you can do so with `git reset --hard <commit ID>` or
`git reset --hard <remote>/<branch>` (e.g. `git reset --hard upstream/master`).
you can do so with `git reset --hard <commit ID )` or
`git reset --hard <remote>/<branch )` (e.g. `git reset --hard upstream/master`).
Be warned that this will remove any changes that you might have committed in
this branch. If you ever lose commits by mistake, use the `git reflog` command
@ -266,12 +266,12 @@ before staging it, while it is staged, and after it has been committed.
- `git diff` will show you the current unstaged changes, i.e. the
differences between your working directory and the staging area.
- `git checkout -- <files>` will undo the unstaged changes to the given
- `git checkout -- <files )` will undo the unstaged changes to the given
files.
- `git add <files>` will *stage* the changes on the listed files.
- `git add <files )` will *stage* the changes on the listed files.
- `git diff --staged` will show the current staged changes, i.e. the
differences between the staging area and the last commit.
- `git reset HEAD <files>` will *unstage* changes to the listed files.
- `git reset HEAD <files )` will *unstage* changes to the listed files.
- `git status` will show you what are the currently staged and unstaged
modifications.
- `git commit` will commit the staged files. It will open a text editor
@ -365,7 +365,7 @@ that will let you issue a pull request on the `godotengine/godot` upstream
repository. It should show you your two commits, and state "Able to merge".
If not (e.g. it has way more commits, or says there are merge conflicts),
don't create the PR yet, something went wrong. Go to our
`Godot Contributors Chat <https://chat.godotengine.org/>`_ and ask for support :)
`Godot Contributors Chat ( https://chat.godotengine.org/ )`_ and ask for support :)
Use an explicit title for the PR and put the necessary details in the comment
area. You can drag and drop screenshots, GIFs or zipped projects if relevant,
@ -470,7 +470,7 @@ upstream `master` branch, which you can do with:
with this little by little).
This will open a text editor (`vi` by default, see
`Git docs <https://git-scm.com/book/en/v2/Customizing-Git-Git-Configuration#_core_editor>`_
`Git docs ( https://git-scm.com/book/en/v2/Customizing-Git-Git-Configuration#_core_editor )`_
to configure your favorite one) with something which may look like this:
.. code-block:: text

14
community/contributing/testing_pull_requests.md
View File

@ -7,7 +7,7 @@ Many people are developing new features or fixing bugs on GitHub.
To help with engine development, you may be asked to test those pull requests
with a Godot build that includes code from the pull request in question.
Thanks to GitHub Actions, all `pull requests <https://github.com/godotengine/godot/pulls>`
Thanks to GitHub Actions, all `pull requests ( https://github.com/godotengine/godot/pulls )`
have continuous builds available. These builds let you try out pull requests
without having to compile anything from source.
@ -23,7 +23,7 @@ depending on whether you have a GitHub account or not.
Due to a GitHub Actions limitation, builds are only available for 90 days
after the pull request was last updated. If you still wish to try a
pull request locally, you can
`compile the pull request branch from source <doc_testing_pull_requests_compile>`
`compile the pull request branch from source <doc_testing_pull_requests_compile )`
instead.
If you have a GitHub account
@ -48,13 +48,13 @@ If you have a GitHub account
Note that Windows and macOS binaries are not code signed.
This means you may have to bypass a security warning before you can run the executable.
If you frequently test pull request builds, it may be better to disable
Windows SmartScreen or `disable macOS Gatekeeper <https://disable-gatekeeper.github.io/>` permanently.
Windows SmartScreen or `disable macOS Gatekeeper ( https://disable-gatekeeper.github.io/ )` permanently.
If you don't have a GitHub account
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
If you don't have a GitHub account and can't sign up for one,
you can use the third-party `nightly.link <https://nightly.link>` service
you can use the third-party `nightly.link ( https://nightly.link )` service
to generate a universal download link.
- Open the pull request page. Click the *fork*'s branch name near the top of the page:
@ -66,7 +66,7 @@ to generate a universal download link.
Click the workflow file for the platform you wish to download artifacts for.
*After* clicking on the file (which opens the file view), copy the page URL from your browser's address bar.
- Open the `nightly.link <https://nightly.link>` website and paste the URL you just copied
- Open the `nightly.link ( https://nightly.link )` website and paste the URL you just copied
into the text field located below the heading **Paste a GitHub link, get a nightly.link!**.
After pasting the URL, click **Get links** on the right.
If the the format of the URL you pasted is correct, you should be presented
@ -80,7 +80,7 @@ to generate a universal download link.
Note that Windows and macOS binaries are not code signed.
This means you may have to bypass a security warning before you can run the executable.
If you frequently test pull request builds, it may be better to disable
Windows SmartScreen or `disable macOS Gatekeeper <https://disable-gatekeeper.github.io/>` permanently.
Windows SmartScreen or `disable macOS Gatekeeper ( https://disable-gatekeeper.github.io/ )` permanently.
.. _doc_testing_pull_requests_compile:
@ -100,5 +100,5 @@ by Godot's GitHub Actions setup.
![](img/testing_pull_requests_fork_zip.png)
- Extract the ZIP archive and follow the `compiling <toc-devel-compiling>` instructions
- Extract the ZIP archive and follow the `compiling <toc-devel-compiling )` instructions
for your operating system.

16
community/contributing/updating_the_class_reference.md
View File

@ -4,7 +4,7 @@ Contributing to the class reference
===================================
The class reference is available online in the `classes <toc-class-ref>`
The class reference is available online in the `classes <toc-class-ref )`
section of the documentation and in the Godot editor, from the help menu.
In the class reference, some methods, variables, and signals lack descriptions.
@ -13,13 +13,13 @@ the entire reference on their own. Godot needs you, and all of us, to
contribute.
**Important:** If you plan to make large changes, you should create an issue on
the `godot-docs repository <https://github.com/godotengine/godot-docs/>`_
the `godot-docs repository ( https://github.com/godotengine/godot-docs/ )`_
or comment on an existing issue. Doing so lets others know you're already
taking care of a given class.
.. seealso::
You can find the writing guidelines for the class reference `here <doc_class_reference_writing_guidelines>`.
You can find the writing guidelines for the class reference `here <doc_class_reference_writing_guidelines )`.
For details on Git usage and the pull request workflow, please
refer to the `doc_pr_workflow` page.
@ -28,24 +28,24 @@ taking care of a given class.
language, see `doc_editor_and_docs_localization`.
This guide is also available as a `video tutorial on YouTube
<https://www.youtube.com/watch?v=5jeHXxeX-JY>`_.
( https://www.youtube.com/watch?v=5jeHXxeX-JY )`_.
.. seealso::
Not sure which class to contribute to? Take a look at the class reference's
completion status `here <https://godotengine.github.io/doc-status/>`_.
completion status `here ( https://godotengine.github.io/doc-status/ )`_.
You can find the source files for the class reference in Godot's GitHub
repository: `doc/classes/
<https://github.com/godotengine/godot/tree/master/doc/classes>`_.
( https://github.com/godotengine/godot/tree/master/doc/classes )`_.
.. note:: For some modules in the engine's source code, you'll find the XML
files in the `modules/<module_name>/doc_classes/` directory instead.
.. warning:: Always edit the API reference through these source XML files. Do
not edit the generated `.rst` files `in the online documentation
<toc-class-ref>`, hosted in the `godot-docs
<https://github.com/godotengine/godot-docs>`_ repository.
<toc-class-ref )`, hosted in the `godot-docs
( https://github.com/godotengine/godot-docs )`_ repository.
.. warning::

22
community/contributing/ways_to_contribute.md
View File

@ -47,7 +47,7 @@ positive to the engine, regardless of their skill set:
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>`_
some money to the project, check `our website ( https://godotengine.org/donate )`_
for details.
Contributing code
@ -55,11 +55,11 @@ Contributing code
The possibility to study, use, modify and redistribute modifications of the
engine's source code are the fundamental rights that
Godot's `MIT <https://tldrlegal.com/license/mit-license>`_ license grants you,
making it `free and open source software <https://en.wikipedia.org/wiki/Free_and_open-source_software>`_.
Godot's `MIT ( https://tldrlegal.com/license/mit-license )`_ license grants you,
making it `free and open source software ( https://en.wikipedia.org/wiki/Free_and_open-source_software )`_.
As such, everyone is entitled to modify
`Godot's source code <https://github.com/godotengine/godot>`_, and send those
`Godot's source code ( https://github.com/godotengine/godot )`_, and send those
modifications back to the upstream project in the form of a patch (a text file
describing the changes in a ready-to-apply manner) or - in the modern workflow
that we use - via a so-called "pull request" (PR), i.e. a proposal to directly
@ -85,7 +85,7 @@ enforce some rules for code contributions, for example regarding the style to
use in the C++ code (indentation, brackets, etc.) or the Git and PR workflow.
A good place to start is by searching for issues tagged as
`good first issue <https://github.com/godotengine/godot/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22>`_
`good first issue ( https://github.com/godotengine/godot/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22 )`_
on GitHub.
.. seealso:: Technical details about the PR workflow are outlined in a
@ -104,9 +104,9 @@ way more contributions than people validating them.
To make sure that your time and efforts aren't wasted, it is recommended to vet the idea
first before implementing it and putting it for a review as a PR. To that end, Godot
has a `proposal system <https://github.com/godotengine/godot-proposals>`_. Its
has a `proposal system ( https://github.com/godotengine/godot-proposals )`_. Its
usage is encouraged to plan changes and discuss them with the community. Implementation
details can also be discussed with other contributors on the `Godot Contributors Chat <https://chat.godotengine.org/>`_.
details can also be discussed with other contributors on the `Godot Contributors Chat ( https://chat.godotengine.org/ )`_.
.. note:: Proposals are only required when working on an enhancement or a new feature.
Bug reports are sufficient for fixing issues.
@ -125,7 +125,7 @@ Testing development versions
To help with the testing, you have several possibilities:
- Compile the engine from source yourself, following the instructions of the
`Compiling <toc-devel-compiling>` page for your platform.
`Compiling <toc-devel-compiling )` page for your platform.
- Test official pre-release binaries when they are announced (usually on the
blog and other community platforms), such as alpha, beta and release candidate (RC) builds.
@ -143,7 +143,7 @@ the developers.
Filing an issue on GitHub
~~~~~~~~~~~~~~~~~~~~~~~~~
Godot uses `GitHub's issue tracker <https://github.com/godotengine/godot/issues>`_
Godot uses `GitHub's issue tracker ( https://github.com/godotengine/godot/issues )`_
for bug reports and enhancement suggestions. You will need a GitHub account to
be able to open a new issue there, and click on the **New issue** button.
@ -197,7 +197,7 @@ There are two separate resources referred to as "documentation" in Godot:
- **The class reference.** This is the documentation for the complete Godot API
as exposed to GDScript and the other scripting languages. It can be consulted
offline, directly in Godot's code editor, or online at `Godot API
<toc-class-ref>`. To contribute to the class reference, you have to edit the
<toc-class-ref )`. To contribute to the class reference, you have to edit the
XML file corresponding to the class and make a pull request.
See `doc_updating_the_class_reference` and
`doc_class_reference_writing_guidelines` for more details.
@ -206,7 +206,7 @@ There are two separate resources referred to as "documentation" in Godot:
This is the part you are reading now, which is distributed in the HTML format.
Its contents are generated from plain text files in the reStructured Text
(rst) format, to which you can contribute via pull requests on the
`godot-docs <https://github.com/godotengine/godot-docs>`_ GitHub repository.
`godot-docs ( https://github.com/godotengine/godot-docs )`_ GitHub repository.
See `doc_contributing_to_the_documentation` for more details.
Contributing translations

72
community/tutorials.md
View File

@ -3,65 +3,65 @@
Tutorials and resources
=======================
This is a list of third-party tutorials and resources created by the Godot community. For resources, remember that there is the official `Godot Asset Library <https://godotengine.org/asset-library/asset>`_ full of official and community resources too! Also, have a look at this `huge list over at Reddit <https://www.reddit.com/r/godot/comments/an0iq5/godot_tutorials_list_of_video_and_written/>`_.
This is a list of third-party tutorials and resources created by the Godot community. For resources, remember that there is the official `Godot Asset Library ( https://godotengine.org/asset-library/asset )`_ full of official and community resources too! Also, have a look at this `huge list over at Reddit ( https://www.reddit.com/r/godot/comments/an0iq5/godot_tutorials_list_of_video_and_written/ )`_.
Think there is something missing here? Feel free to submit a `Pull Request <https://github.com/godotengine/godot-docs/blob/master/community/tutorials.rst>`_ as always.
Think there is something missing here? Feel free to submit a `Pull Request ( https://github.com/godotengine/godot-docs/blob/master/community/tutorials.rst )`_ as always.
Where to start
--------------
The Godot video tutorials by `GDQuest <https://www.youtube.com/channel/UCxboW7x0jZqFdvMdCFKTMsQ/playlists>`_, `Game from Scratch <https://www.youtube.com/watch?v=iDEcP8Mc-7s&list=PLS9MbmO_ssyDk79j9ewONxV88fD5e_o5d>`_ and `KidsCanCode <https://www.youtube.com/channel/UCNaPQ5uLX5iIEHUCLmfAgKg/playlists>`_ are well-regarded in the community and often recommended as a gentle introduction to beginners.
The Godot video tutorials by `GDQuest ( https://www.youtube.com/channel/UCxboW7x0jZqFdvMdCFKTMsQ/playlists )`_, `Game from Scratch ( https://www.youtube.com/watch?v=iDEcP8Mc-7s&list=PLS9MbmO_ssyDk79j9ewONxV88fD5e_o5d )`_ and `KidsCanCode ( https://www.youtube.com/channel/UCNaPQ5uLX5iIEHUCLmfAgKg/playlists )`_ are well-regarded in the community and often recommended as a gentle introduction to beginners.
If you're interested in Visual Scripting, `Emilio's tutorials <https://www.youtube.com/channel/UC9DR22-qohBDtZ74R3FxOZg>`_ may be worth a look.
If you're interested in Visual Scripting, `Emilio's tutorials ( https://www.youtube.com/channel/UC9DR22-qohBDtZ74R3FxOZg )`_ may be worth a look.
If you're interested in a complete introduction to programming using Godot and GDScript, the unofficial `Godot Tutorials <https://www.youtube.com/channel/UCnr9ojBEQGgwbcKsZC-2rIg>`_ YouTube channel is a good place to start.
If you're interested in a complete introduction to programming using Godot and GDScript, the unofficial `Godot Tutorials ( https://www.youtube.com/channel/UCnr9ojBEQGgwbcKsZC-2rIg )`_ YouTube channel is a good place to start.
GDQuest's *Learn GDScript From Zero* is a free and open source interactive tutorial for absolute beginners to learn to program with Godot's GDScript language. It is available as a `desktop application <https://gdquest.itch.io/learn-godot-gdscript>`_ or `in the browser <https://gdquest.github.io/learn-gdscript>`_.
GDQuest's *Learn GDScript From Zero* is a free and open source interactive tutorial for absolute beginners to learn to program with Godot's GDScript language. It is available as a `desktop application ( https://gdquest.itch.io/learn-godot-gdscript )`_ or `in the browser ( https://gdquest.github.io/learn-gdscript )`_.
Some tutorials mentioned below provide more advanced tutorials, e.g. on 3D or shaders.
Video tutorials
---------------
- `Godot Tutorials <https://www.youtube.com/channel/UCnr9ojBEQGgwbcKsZC-2rIg>`_ (2D, GDScript, Programming Basics).
- `Emilio <https://www.youtube.com/channel/UC9DR22-qohBDtZ74R3FxOZg>`_ (2D, GDScript and VisualScript).
- `FinePointCGI <https://www.youtube.com/channel/UCSojAWUnEUTUcdA9iJ6bryQ>`_ (2D, 3D, GDScript and C#).
- `GDQuest <https://www.youtube.com/channel/UCxboW7x0jZqFdvMdCFKTMsQ/playlists>`_ (2D and 3D, GDScript, VisualScript and C#).
- `Game Development Center <https://www.youtube.com/c/GameDevelopmentCenter>`_ (2D, networked multiplayer, GDScript).
- `Game Endeavor <https://www.youtube.com/channel/UCLweX1UtQjRjj7rs_0XQ2Eg/videos>`_ (2D, GDScript).
- `Game from Scratch <https://www.youtube.com/watch?v=iDEcP8Mc-7s&list=PLS9MbmO_ssyDk79j9ewONxV88fD5e_o5d>`_ (2D and 3D, GDScript and C#).
- `HeartBeast <https://www.youtube.com/watch?v=wETY5_9kFtA&list=PL9FzW-m48fn2jlBu_0DRh7PvAt-GULEmd>`_ (2D, GDScript).
- `KidsCanCode <https://www.youtube.com/channel/UCNaPQ5uLX5iIEHUCLmfAgKg/playlists>` (2D and 3D, GDScript and VisualScript).
- `Mister Taft Creates <https://www.youtube.com/playlist?list=PL4vbr3u7UKWqwQlvwvgNcgDL1p_3hcNn2>`_ (2D, GDScript).
- `Miziziziz <https://www.youtube.com/playlist?list=PLmugv6_kd0qN6AyjG245_Pdak4MXKUx88>`_ (2D and 3D, GDScript).
- `P1X / Krzysztof Jankowski <https://www.youtube.com/playlist?list=PLvDk7UKhld4xGPovdB4IFtAHYMYjx_-3K>`_ (3D).
- `Pigdev <https://www.youtube.com/playlist?list=PLPMN4vCRFdordS3E-3zi0Hdh7pAsbWQ6a>`_ (2D, GDScript).
- `Steincodes <https://www.youtube.com/c/steincodes/playlists>` (2D, GDScript and VisualScript).
- `TheBuffED <https://www.youtube.com/watch?v=ygGaN1EOQEA&list=PLvN5Z3tTxXEDfQkt4Frg6ALirespSwZd7>`_ (2D, GDScript).
- `Code with Tom <https://www.youtube.com/playlist?list=PLiUQR4U_J9ec0k91iHPme_qtfS1nrWF3W>`_ (2D and 3D, GDScript).
- `BornCG <https://www.youtube.com/playlist?list=PLda3VoSoc_TSBBOBYwcmlamF1UrjVtccZ>`_ (2D and 3D, GDScript).
- `Gonkee <https://www.youtube.com/channel/UCJqCPFHdbc6443G3Sz6VYDw>`_ (2D and 3D, GDScript, Shaders).
- `TheGuideKnight <https://www.youtube.com/playlist?list=PLYcTJBw32KtX2fvOdtO_fS3Nd6sxM71tn>`_ (2D, GDScript).
- `GDScript Dude <https://www.youtube.com/channel/UCQs0i6vKISElM6mh7OzLouQ>`_ (GDScript).
- `Garbaj <https://www.youtube.com/c/Garbaj/>`_ (3D, GDScript).
- `Kasper Frandsen <https://www.youtube.com/c/KasperFrandsen/>`_ (3D, Shaders).
- `Godot Tutorials ( https://www.youtube.com/channel/UCnr9ojBEQGgwbcKsZC-2rIg )`_ (2D, GDScript, Programming Basics).
- `Emilio ( https://www.youtube.com/channel/UC9DR22-qohBDtZ74R3FxOZg )`_ (2D, GDScript and VisualScript).
- `FinePointCGI ( https://www.youtube.com/channel/UCSojAWUnEUTUcdA9iJ6bryQ )`_ (2D, 3D, GDScript and C#).
- `GDQuest ( https://www.youtube.com/channel/UCxboW7x0jZqFdvMdCFKTMsQ/playlists )`_ (2D and 3D, GDScript, VisualScript and C#).
- `Game Development Center ( https://www.youtube.com/c/GameDevelopmentCenter )`_ (2D, networked multiplayer, GDScript).
- `Game Endeavor ( https://www.youtube.com/channel/UCLweX1UtQjRjj7rs_0XQ2Eg/videos )`_ (2D, GDScript).
- `Game from Scratch ( https://www.youtube.com/watch?v=iDEcP8Mc-7s&list=PLS9MbmO_ssyDk79j9ewONxV88fD5e_o5d )`_ (2D and 3D, GDScript and C#).
- `HeartBeast ( https://www.youtube.com/watch?v=wETY5_9kFtA&list=PL9FzW-m48fn2jlBu_0DRh7PvAt-GULEmd )`_ (2D, GDScript).
- `KidsCanCode ( https://www.youtube.com/channel/UCNaPQ5uLX5iIEHUCLmfAgKg/playlists )` (2D and 3D, GDScript and VisualScript).
- `Mister Taft Creates ( https://www.youtube.com/playlist?list=PL4vbr3u7UKWqwQlvwvgNcgDL1p_3hcNn2 )`_ (2D, GDScript).
- `Miziziziz ( https://www.youtube.com/playlist?list=PLmugv6_kd0qN6AyjG245_Pdak4MXKUx88 )`_ (2D and 3D, GDScript).
- `P1X / Krzysztof Jankowski ( https://www.youtube.com/playlist?list=PLvDk7UKhld4xGPovdB4IFtAHYMYjx_-3K )`_ (3D).
- `Pigdev ( https://www.youtube.com/playlist?list=PLPMN4vCRFdordS3E-3zi0Hdh7pAsbWQ6a )`_ (2D, GDScript).
- `Steincodes ( https://www.youtube.com/c/steincodes/playlists )` (2D, GDScript and VisualScript).
- `TheBuffED ( https://www.youtube.com/watch?v=ygGaN1EOQEA&list=PLvN5Z3tTxXEDfQkt4Frg6ALirespSwZd7 )`_ (2D, GDScript).
- `Code with Tom ( https://www.youtube.com/playlist?list=PLiUQR4U_J9ec0k91iHPme_qtfS1nrWF3W )`_ (2D and 3D, GDScript).
- `BornCG ( https://www.youtube.com/playlist?list=PLda3VoSoc_TSBBOBYwcmlamF1UrjVtccZ )`_ (2D and 3D, GDScript).
- `Gonkee ( https://www.youtube.com/channel/UCJqCPFHdbc6443G3Sz6VYDw )`_ (2D and 3D, GDScript, Shaders).
- `TheGuideKnight ( https://www.youtube.com/playlist?list=PLYcTJBw32KtX2fvOdtO_fS3Nd6sxM71tn )`_ (2D, GDScript).
- `GDScript Dude ( https://www.youtube.com/channel/UCQs0i6vKISElM6mh7OzLouQ )`_ (GDScript).
- `Garbaj ( https://www.youtube.com/c/Garbaj/ )`_ (3D, GDScript).
- `Kasper Frandsen ( https://www.youtube.com/c/KasperFrandsen/ )`_ (3D, Shaders).
Text tutorials
--------------
- `FinepointCGI website by Mitch <http://finepointcgi.io/>`
- `GDScript website by Andrew Wilkes <https://gdscript.com>`
- `Godot Recipes by KidsCanCode <http://godotrecipes.com/>`
- `Steincodes <https://steincodes.tumblr.com>`
- `FinepointCGI website by Mitch ( http://finepointcgi.io/ )`
- `GDScript website by Andrew Wilkes ( https://gdscript.com )`
- `Godot Recipes by KidsCanCode ( http://godotrecipes.com/ )`
- `Steincodes ( https://steincodes.tumblr.com )`
Devlogs
-------
- `Andrea Catania (Physics & AI) <https://www.youtube.com/channel/UCm4RuvYtgpgFDTCgaEUT5uQ/videos>`_
- `Bastiaan Olij (AR & VR) <https://www.youtube.com/channel/UCrbLJYzJjDf2p-vJC011lYw/videos>`_
- `Andrea Catania (Physics & AI) ( https://www.youtube.com/channel/UCm4RuvYtgpgFDTCgaEUT5uQ/videos )`_
- `Bastiaan Olij (AR & VR) ( https://www.youtube.com/channel/UCrbLJYzJjDf2p-vJC011lYw/videos )`_
Resources
---------
- `awesome-godot: A curated list of free/libre plugins, scripts and add-ons <https://github.com/godotengine/awesome-godot>`_
- `Zeef Godot Engine: A curated directory of resources by Andre Schmitz <https://godot-engine.zeef.com/andre.antonio.schmitz>`_
- `awesome-godot: A curated list of free/libre plugins, scripts and add-ons ( https://github.com/godotengine/awesome-godot )`_
- `Zeef Godot Engine: A curated directory of resources by Andre Schmitz ( https://godot-engine.zeef.com/andre.antonio.schmitz )`_

16
development/compiling/compiling_for_android.md
View File

@ -25,9 +25,9 @@ Requirements
For compiling under Windows, Linux or macOS, the following is required:
- `Python 3.5+ <https://www.python.org/downloads/>`_.
- `SCons 3.0+ <https://scons.org/pages/download.html>`_ build system.
- `Android SDK <https://developer.android.com/studio/#command-tools>`_
- `Python 3.5+ ( https://www.python.org/downloads/ )`_.
- `SCons 3.0+ ( https://scons.org/pages/download.html )`_ build system.
- `Android SDK ( https://developer.android.com/studio/#command-tools )`_
(command-line tools are sufficient).
- Required SDK components will be automatically installed.
@ -37,7 +37,7 @@ For compiling under Windows, Linux or macOS, the following is required:
- Gradle (will be downloaded and installed automatically if missing).
- JDK 11 (either OpenJDK or Oracle JDK).
- You can download a build from `ojdkbuild <https://github.com/ojdkbuild/ojdkbuild>`_.
- You can download a build from `ojdkbuild ( https://github.com/ojdkbuild/ojdkbuild )`_.
.. seealso:: To get the Godot source code for compiling, see
`doc_getting_source`.
@ -181,7 +181,7 @@ with their respective names. The templates folder can be located in:
- Linux: `$HOME/.local/share/godot/templates/<version>/`
- macOS: `$HOME/Library/Application Support/Godot/templates/<version>/`
`<version>` is of the form `major.minor[.patch].status` using values from
`<version )` is of the form `major.minor[.patch].status` using values from
`version.py` in your Godot source repository (e.g. `3.0.5.stable` or `3.1.dev`).
You also need to write this same version string to a `version.txt` file located
next to your export templates.
@ -208,7 +208,7 @@ Platform doesn't appear in SCons
Double-check that you've set the `ANDROID_SDK_ROOT`
environment variable. This is required for the platform to appear in SCons'
list of detected platforms.
See `Setting up the buildsystem <doc_android_setting_up_the_buildsystem>`
See `Setting up the buildsystem <doc_android_setting_up_the_buildsystem )`
for more information.
Application not installed
@ -220,7 +220,7 @@ If so:
- Check that the debug keystore is properly generated.
- Check that the jarsigner executable is from JDK 8.
If it still fails, open a command line and run `logcat <https://developer.android.com/studio/command-line/logcat>`_:
If it still fails, open a command line and run `logcat ( https://developer.android.com/studio/command-line/logcat )`_:
::
@ -239,7 +239,7 @@ one of the following reasons:
- Make sure to use export templates that match your editor version; if
you use a new Godot version, you *have* to update the templates too.
- `libgodot_android.so` is not in `libs/<android_arch>/`
where `<android_arch>` is the device's architecture.
where `<android_arch )` is the device's architecture.
- The device's architecture does not match the exported one(s).
Make sure your templates were built for that device's architecture,
and that the export settings included support for that architecture.

4
development/compiling/compiling_for_ios.md
View File

@ -12,8 +12,8 @@ Compiling for iOS
Requirements
------------
- SCons 3.0+ (you can install it via `Homebrew <https://brew.sh/>`_ or
`MacPorts <https://www.macports.org/>`_, you should be able
- SCons 3.0+ (you can install it via `Homebrew ( https://brew.sh/ )`_ or
`MacPorts ( https://www.macports.org/ )`_, you should be able
to run `scons` in a terminal when installed).
- Xcode 10.0 (or later) with the iOS (10.0) SDK and the command line tools.

18
development/compiling/compiling_for_osx.md
View File

@ -14,13 +14,13 @@ Requirements
For compiling under macOS, the following is required:
- `Python 3.5+ <https://www.python.org>`_.
- `SCons 3.0+ <https://www.scons.org>`_ build system.
- `Xcode <https://apps.apple.com/us/app/xcode/id497799835>`_
- `Python 3.5+ ( https://www.python.org )`_.
- `SCons 3.0+ ( https://www.scons.org )`_ build system.
- `Xcode ( https://apps.apple.com/us/app/xcode/id497799835 )`_
(or the more lightweight Command Line Tools for Xcode).
- *Optional* - `yasm <https://yasm.tortall.net/>`_ (for WebM SIMD optimizations).
- *Optional* - `yasm ( https://yasm.tortall.net/ )`_ (for WebM SIMD optimizations).
.. note:: If you have `Homebrew <https://brew.sh/>`_ installed, you can easily
.. note:: If you have `Homebrew ( https://brew.sh/ )`_ installed, you can easily
install SCons and yasm using the following command::
brew install scons yasm
@ -28,7 +28,7 @@ For compiling under macOS, the following is required:
Installing Homebrew will also fetch the Command Line Tools
for Xcode automatically if you don't have them already.
Similarly, if you have `MacPorts <https://www.macports.org/>`_
Similarly, if you have `MacPorts ( https://www.macports.org/ )`_
installed, you can easily install SCons and yasm using the
following command::
@ -85,7 +85,7 @@ projects in an automated manner, use::
scons platform=server tools=yes target=release_debug --jobs=$(sysctl -n hw.logicalcpu)
To compile a debug *server* build which can be used with
`remote debugging tools <doc_command_line_tutorial>`, use::
`remote debugging tools <doc_command_line_tutorial )`, use::
scons platform=server tools=no target=release_debug --jobs=$(sysctl -n hw.logicalcpu)
@ -144,10 +144,10 @@ Cross-compiling for macOS from Linux
It is possible to compile for macOS in a Linux environment (and maybe also in
Windows using the Windows Subsystem for Linux). For that, you'll need to install
`OSXCross <https://github.com/tpoechtrager/osxcross>` to be able to use macOS
`OSXCross ( https://github.com/tpoechtrager/osxcross )` to be able to use macOS
as a target. First, follow the instructions to install it:
Clone the `OSXCross repository <https://github.com/tpoechtrager/osxcross>`
Clone the `OSXCross repository ( https://github.com/tpoechtrager/osxcross )`
somewhere on your machine (or download a ZIP file and extract it somewhere),
e.g.::

4
development/compiling/compiling_for_uwp.md
View File

@ -16,7 +16,7 @@ Requirements
- Visual Studio 2017 or later. See `doc_compiling_for_windows` about the
caveats of installing it and the various prompts.
- Windows 10 SDK (can be selected in Visual Studio installation).
- `ANGLE source <https://github.com/Microsoft/angle>`. Use the
- `ANGLE source ( https://github.com/Microsoft/angle )`. Use the
`ms_master` (default) branch. Keep it in a path without spaces to
avoid problems.
@ -25,7 +25,7 @@ Requirements
As a temporary workaround however, it is still possible to
download an older state of the source code via commit
`c61d048 <https://github.com/microsoft/angle/tree/c61d0488abd9663e0d4d2450db7345baa2c0dfb6>`.
`c61d048 ( https://github.com/microsoft/angle/tree/c61d0488abd9663e0d4d2450db7345baa2c0dfb6 )`.
This page will eventually be updated in the future to reflect
the new build instructions.

12
development/compiling/compiling_for_web.md
View File

@ -14,9 +14,9 @@ Requirements
To compile export templates for the Web, the following is required:
- `Emscripten 1.39.9+ <https://emscripten.org>`.
- `Python 3.5+ <https://www.python.org/>`.
- `SCons 3.0+ <https://www.scons.org>` build system.
- `Emscripten 1.39.9+ ( https://emscripten.org )`.
- `Python 3.5+ ( https://www.python.org/ )`.
- `SCons 3.0+ ( https://www.scons.org )` build system.
.. seealso:: To get the Godot source code for compiling, see
`doc_getting_source`.
@ -38,7 +38,7 @@ either `release` for a release build or `release_debug` for a debug build::
scons platform=javascript tools=no target=release
scons platform=javascript tools=no target=release_debug
By default, the `JavaScript singleton <doc_javascript_eval>` will be built
By default, the `JavaScript singleton <doc_javascript_eval )` will be built
into the engine. Official export templates also have the JavaScript singleton
enabled. Since `eval()` calls can be a security concern, the
`javascript_eval` option can be used to build without the singleton::
@ -65,7 +65,7 @@ Threads and GDNative
The default export templates do not include threads and GDNative support for
performance and compatibility reasons. See the
`export page <doc_javascript_export_options>` for more info.
`export page <doc_javascript_export_options )` for more info.
You can build the export templates using the option `threads_enabled=yes` or
`gdnative_enabled=yes` to enable threads or GDNative support::
@ -104,5 +104,5 @@ Once finished, the resulting file will be placed in the `bin` subdirectory.
Its name will be `godot.javascript.opt.tools.threads.zip`. You can upload the
zip content to your web server and visit it with your browser to use the editor.
Refer to the `export page <doc_javascript_export_options>` for the web
Refer to the `export page <doc_javascript_export_options )` for the web
server requirements.

18
development/compiling/compiling_for_windows.md
View File

@ -14,23 +14,23 @@ Requirements
For compiling under Windows, the following is required:
- `Visual Studio Community <https://www.visualstudio.com/vs/community/>`_,
- `Visual Studio Community ( https://www.visualstudio.com/vs/community/ )`_,
version 2017 or later. VS 2019 is recommended.
**Make sure to read "Installing Visual Studio caveats" below or you
will have to run/download the installer again.**
- `MinGW-w64 <http://mingw-w64.org/>` with GCC can be used as an alternative to
- `MinGW-w64 ( http://mingw-w64.org/ )` with GCC can be used as an alternative to
Visual Studio. Be sure to install/configure it to use the `posix` thread model.
- `Python 3.5+ <https://www.python.org/downloads/windows/>`_.
- `Python 3.5+ ( https://www.python.org/downloads/windows/ )`_.
**Make sure to enable the option to add Python to the `PATH` in the installer.**
- `SCons <https://www.scons.org/>`_ build system. Using the latest release is
- `SCons ( https://www.scons.org/ )`_ build system. Using the latest release is
recommended, especially for proper support of recent Visual Studio releases.
.. note:: If you have `Scoop <https://scoop.sh/>`_ installed, you can easily
.. note:: If you have `Scoop ( https://scoop.sh/ )`_ installed, you can easily
install MinGW and other dependencies using the following command::
scoop install gcc python scons make
.. note:: If you have `MSYS2 <https://www.msys2.org/>`_ installed, you can easily
.. note:: If you have `MSYS2 ( https://www.msys2.org/ )`_ installed, you can easily
install MinGW and other dependencies using the following command::
pacman -S mingw-w64-x86_64-python3-pip mingw-w64-x86_64-gcc \
@ -191,7 +191,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://mingw-w64.org/doku.php )`, which typically comes in 32-bit
and 64-bit variants. The package names may differ based on your distribution,
here are some known ones:
@ -243,7 +243,7 @@ Troubleshooting
~~~~~~~~~~~~~~~
Cross-compiling from some Ubuntu versions may lead to
`this bug <https://github.com/godotengine/godot/issues/9258>`_,
`this bug ( https://github.com/godotengine/godot/issues/9258 )`_,
due to a default configuration lacking support for POSIX threading.
You can change that configuration following those instructions,
@ -273,7 +273,7 @@ with the following flags::
C:\godot> scons platform=windows tools=no target=release bits=64
If you plan on replacing the standard export templates, copy these to the
following location, replacing `<version>` with the version identifier
following location, replacing `<version )` with the version identifier
(such as `3.1.1.stable` or `3.2.dev`)::
%USERPROFILE%\AppData\Roaming\Godot\templates\<version>\

8
development/compiling/compiling_for_x11.md
View File

@ -150,7 +150,7 @@ projects in an automated manner, use::
scons -j8 platform=server tools=yes target=release_debug
To compile a debug *server* build which can be used with
`remote debugging tools <doc_command_line_tutorial>`, use::
`remote debugging tools <doc_command_line_tutorial )`, use::
scons -j8 platform=server tools=no target=release_debug
@ -239,13 +239,13 @@ link-time optimization, making the resulting binaries smaller and faster.
Using Pyston for faster development
-----------------------------------
You can use `Pyston <https://www.pyston.org/>` to run SCons. Pyston is a JIT-enabled
You can use `Pyston ( https://www.pyston.org/ )` to run SCons. Pyston is a JIT-enabled
implementation of the Python language (which SCons is written in). It is currently
only compatible with Linux. Pyston can speed up incremental builds significantly,
often by a factor between 1.5× and 2×. Pyston can be combined with Clang and LLD
to get even faster builds.
- Download the `latest portable Pyston release <https://github.com/pyston/pyston/releases/latest>`.
- Download the `latest portable Pyston release ( https://github.com/pyston/pyston/releases/latest )`.
- Extract the portable `.tar.gz` to a set location, such as `$HOME/.local/opt/pyston/` (create folders as needed).
- Use `cd` to reach the extracted Pyston folder from a terminal,
then run `./pyston -m pip install scons` to install SCons within Pyston.
@ -254,7 +254,7 @@ to get even faster builds.
ln -s ~/.local/opt/pyston/bin/scons ~/.local/bin/pyston-scons
- Instead of running `scons <build arguments>`, run `pyston-scons <build arguments>`
- Instead of running `scons <build arguments )`, run `pyston-scons <build arguments )`
to compile Godot.
If you can't run `pyston-scons` after creating the symbolic link,

24
development/compiling/compiling_with_mono.md
View File

@ -67,7 +67,7 @@ and the C# solution for the editor tools at `modules/mono/glue/GodotSharp/GodotS
Once these files are generated, you can build Godot for all the desired targets
without having to repeat this process.
`<godot_binary>` refers to the tools binary you compiled above with the Mono
`<godot_binary )` refers to the tools binary you compiled above with the Mono
module enabled. Its exact name will differ based on your system and
configuration, but should be of the form
`bin/godot.<platform>.tools.<bits>.mono`, e.g. `bin/godot.x11.tools.64.mono`
@ -117,7 +117,7 @@ the following files in the `bin` directory:
for the editor and for export templates. This directory is important for
proper functioning and must be distributed together with Godot.
More details about this directory in
`Data directory<compiling_with_mono_data_directory>`.
`Data directory<compiling_with_mono_data_directory )`.
Examples
--------
@ -173,13 +173,13 @@ Export templates
The name of the data directory for an export template differs based on the
configuration it was built with. The format is
`data.mono.<platform>.<bits>.<target>`, e.g. `data.mono.x11.32.release_debug` or
`data.mono.<platform>.<bits>.<target )`, e.g. `data.mono.x11.32.release_debug` or
`data.mono.windows.64.release`.
This directory must be placed with its original name next to the Godot export
templates. When exporting a project, Godot will also copy this directory with
the game executable but the name will be changed to `data_<APPNAME>`, where
`<APPNAME>` is the application name as specified in the project setting
the game executable but the name will be changed to `data_<APPNAME )`, where
`<APPNAME )` is the application name as specified in the project setting
`application/config/name`.
In the case of macOS, where the export template is compressed as a ZIP archive,
@ -232,7 +232,7 @@ that is installed on your system. This likely won't be the case when targeting o
platforms like Android, iOS and WebAssembly. You will have to build the Mono runtime
yourself for those platforms.
We recommend using these `build scripts <https://github.com/godotengine/godot-mono-builds>`_.
We recommend using these `build scripts ( https://github.com/godotengine/godot-mono-builds )`_.
They simplify this process but also include some patches needed
for proper functioning with Godot. See the README on the link above
for instructions on how to use the scripts.
@ -248,7 +248,7 @@ to the Gradle project.
Once you've built Mono, you can proceed to build Godot with the instructions
described in this page and the
`Compiling for Android<doc_compiling_for_android>` page.
`Compiling for Android<doc_compiling_for_android )` page.
Make sure to let SCons know about the location of the Mono runtime you've just built, e.g.:
`scons [...] mono_prefix="$HOME/mono-installs/android-armeabi-v7a-release"`
(This path may be different on your system).
@ -258,7 +258,7 @@ Targeting iOS
Once you've built Mono, you can proceed to build Godot with the instructions
described in this page and the
`Compiling for iOS<doc_compiling_for_ios>` page.
`Compiling for iOS<doc_compiling_for_ios )` page.
Make sure to let SCons know about the location of the Mono runtime you've just built, e.g.:
`scons [...] mono_prefix="$HOME/mono-installs/ios-arm64-release"`
(This path may be different on your system).
@ -307,7 +307,7 @@ Building for WebAssembly currently involves the same process regardless of wheth
Once you've built Mono, you can proceed to build Godot with the instructions
described in this page and the
`Compiling for the Web<doc_compiling_for_web>` page.
`Compiling for the Web<doc_compiling_for_web )` page.
Make sure to let SCons know about the location of the Mono runtime you've just built, e.g.:
`scons [...] mono_prefix="$HOME/mono-installs/wasm-runtime-release"`
(This path may be different on your system).
@ -316,8 +316,8 @@ Base Class Library
------------------
The export templates must also include the BCL (Base Class Library) for each target platform.
Godot looks for the BCL folder at `<templates>/bcl/<target_platform>`,
where `<target_platform>` is the same name passed to the SCons `platform` option,
Godot looks for the BCL folder at `<templates>/bcl/<target_platform )`,
where `<target_platform )` is the same name passed to the SCons `platform` option,
e.g.: `<templates>/bcl/windows`, `<templates>/bcl/javascript`.
Alternatively, Godot will look for them in the following locations:
@ -352,7 +352,7 @@ Godot will look for the cross-compiler executable in the AOT compilers folder.
The location of this folder is `<data_folder>/Tools/aot-compilers/`.
In order to build the cross-compilers we recommend using these
`build scripts <https://github.com/godotengine/godot-mono-builds>`_.
`build scripts ( https://github.com/godotengine/godot-mono-builds )`_.
After building them, copy the executable to the Godot AOT compilers directory. The
executable name is `<triple>-mono-sgen`, e.g.: `aarch64-apple-darwin-mono-sgen`.

4
development/compiling/compiling_with_script_encryption_key.md
View File

@ -24,10 +24,10 @@ Step by step
------------
1. Generate a 256-bit AES key in hexadecimal format. You can use the aes-256-cbc variant from
`this service <https://asecuritysite.com/encryption/keygen>`_.
`this service ( https://asecuritysite.com/encryption/keygen )`_.
Alternatively, you can generate it yourself using
`OpenSSL <https://www.openssl.org/>` command-line tools:
`OpenSSL ( https://www.openssl.org/ )` command-line tools:
::

14
development/compiling/cross-compiling_for_ios_on_linux.md
View File

@ -15,9 +15,9 @@ While it is possible to compile for iOS on a Linux environment, Apple is
very restrictive about the tools to be used (especially hardware-wise),
allowing pretty much only their products to be used for development. So
this is **not official**. However, a `statement from Apple in 2010
<http://www.apple.com/pr/library/2010/09/09Statement-by-Apple-on-App-Store-Review-Guidelines.html>`
( http://www.apple.com/pr/library/2010/09/09Statement-by-Apple-on-App-Store-Review-Guidelines.html )`
says they relaxed some of the `App Store review guidelines
<https://developer.apple.com/app-store/review/guidelines/>`
( https://developer.apple.com/app-store/review/guidelines/ )`
to allow any tool to be used, as long as the resulting binary does not
download any code, which means it should be OK to use the procedure
described here and cross-compiling the binary.
@ -25,21 +25,21 @@ described here and cross-compiling the binary.
Requirements
------------
- `XCode with the iOS SDK <https://developer.apple.com/xcode/download>`
- `XCode with the iOS SDK ( https://developer.apple.com/xcode/download )`
(a dmg image)
- `Clang >= 3.5 <http://clang.llvm.org>` for your development
- `Clang >= 3.5 ( http://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 umounting
- `Fuse ( https://github.com/libfuse/libfuse )` for mounting and umounting
the dmg image.
- `darling-dmg <https://github.com/darlinghq/darling-dmg>`, which
- `darling-dmg ( https://github.com/darlinghq/darling-dmg )`, which
needs to be built from source. The procedure for that is explained
below.
- For building darling-dmg, you'll need the development packages of
the following libraries: fuse, icu, openssl, zlib, bzip2.
- `cctools-port <https://github.com/tpoechtrager/cctools-port>`
- `cctools-port ( https://github.com/tpoechtrager/cctools-port )`
for the needed build tools. The procedure for building is quite
peculiar and is described below.

12
development/compiling/getting_source.md
View File

@ -7,18 +7,18 @@ Getting the source
Downloading the Godot source code
---------------------------------
Before `getting into the SCons build system <doc_introduction_to_the_buildsystem>`
Before `getting into the SCons build system <doc_introduction_to_the_buildsystem )`
and compiling Godot, you need to actually download the Godot source code.
The source code is available on `GitHub <https://github.com/godotengine/godot>`
The source code is available on `GitHub ( https://github.com/godotengine/godot )`
and while you can manually download it via the website, in general you want to
do it via the `git` version control system.
If you are compiling in order to make contributions or pull requests, you should
follow the instructions from the `Pull Request workflow <doc_pr_workflow>`.
follow the instructions from the `Pull Request workflow <doc_pr_workflow )`.
If you don't know much about `git` yet, there are a great number of
`tutorials <https://git-scm.com/book>` available on various websites.
`tutorials ( https://git-scm.com/book )` available on various websites.
In general, you need to install `git` and/or one of the various GUI clients.
@ -34,7 +34,7 @@ the following in a terminal:
# You can add the --depth 1 argument to omit the commit history.
# Faster, but not all Git operations (like blame) will work.
For any stable release, visit the `release page <https://github.com/godotengine/godot/releases>`
For any stable release, visit the `release page ( https://github.com/godotengine/godot/releases )`
and click on the link for the release you want.
You can then download and extract the source from the download link on the page.
@ -50,4 +50,4 @@ after the `--branch` (or just `-b`) argument::
There are also generally branches besides `master` for each major version.
After downloading the Godot source code,
you can `continue to compiling Godot <doc_introduction_to_the_buildsystem>`.
you can `continue to compiling Godot <doc_introduction_to_the_buildsystem )`.

14
development/compiling/introduction_to_the_buildsystem.md
View File

@ -7,7 +7,7 @@ Introduction to the buildsystem
SCons
-----
Godot uses `SCons <https://www.scons.org/>` to build. We love it, we are
Godot uses `SCons ( https://www.scons.org/ )` to build. We love it, we are
not changing it for anything else. We are not even sure other build
systems are up to the task of building Godot. We constantly get requests
to move the build system to CMake, or Visual Studio, but this is not
@ -81,7 +81,7 @@ To build for a platform (for example, x11), run with the `platform=` (or
scons platform=x11
This will start the build process, which will take a while. If you want
SCons to build faster, use the `-j <cores>` parameter to specify how many
SCons to build faster, use the `-j <cores )` parameter to specify how many
cores will be used for the build. Or leave it using one core, so you
can use your computer for something else :)
@ -117,7 +117,7 @@ A Windows binary with the same configuration will look like this:
Copy that binary to any location you like, as it contains the project manager,
editor and all means to execute the game. However, it lacks the data to export
it to the different platforms. For that the export templates are needed (which
can be either downloaded from `godotengine.org <https://godotengine.org/>`, or
can be either downloaded from `godotengine.org ( https://godotengine.org/ )`, or
you can build them yourself).
Aside from that, there are a few standard options that can be set in all
@ -215,7 +215,7 @@ Cleaning generated files
------------------------
Sometimes, you may encounter an error due to generated files being present. You
can remove them by using `scons --clean <options>`, where `<options>` is the
can remove them by using `scons --clean <options )`, where `<options )` is the
list of build options you've used to build Godot previously.
Alternatively, you can use `git clean -fixd` which will clean build artifacts
@ -259,7 +259,7 @@ time it takes to build the engine. See `doc_optimizing_for_size` page for more d
.. seealso::
You can use the online
`Godot build options generator <https://godot-build-options-generator.github.io/>`
`Godot build options generator ( https://godot-build-options-generator.github.io/ )`
to generate a `custom.py` file containing SCons options.
You can then save this file and place it at the root of your Godot source directory.
@ -312,7 +312,7 @@ Export templates
----------------
Official export templates are downloaded from the Godot Engine site:
`godotengine.org <https://godotengine.org/>`. However, you might want
`godotengine.org ( https://godotengine.org/ )`. However, you might want
to build them yourself (in case you want newer ones, you are using custom
modules, or simply don't trust your own shadow).
@ -349,7 +349,7 @@ directory to avoid conflicts. For instance, if you are building export templates
for Godot 3.1.1, `version.txt` should contain `3.1.1.stable` on the first
line (and nothing else). This version identifier is based on the `major`,
`minor`, `patch` (if present) and `status` lines of the
`version.py file in the Godot Git repository <https://github.com/godotengine/godot/blob/master/version.py>`.
`version.py file in the Godot Git repository ( https://github.com/godotengine/godot/blob/master/version.py )`.
If you are developing for multiple platforms, macOS is definitely the most
convenient host platform for cross-compilation, since you can cross-compile for

2
development/compiling/optimizing_for_size.md
View File

@ -39,7 +39,7 @@ On Windows, `strip.exe` is included in most MinGW toolchain setups.
This will reduce the size of compiled binaries by a factor between 5× and 10×.
The downside is that crash backtraces will no longer provide accurate information
(which is useful for troubleshooting the cause of a crash).
`C++ profilers <doc_using_cpp_profilers>` will also no longer be able to display
`C++ profilers <doc_using_cpp_profilers )` will also no longer be able to display
function names (this does not affect the built-in GDScript profiler).
.. note::

2
development/cpp/binding_to_external_libraries.md
View File

@ -8,7 +8,7 @@ Modules
The Summator example in `doc_custom_modules_in_c++` is great for small,
custom modules, but what if you want to use a larger, external library?
Let's look at an example using `Festival <http://www.cstr.ed.ac.uk/projects/festival/>`_,
Let's look at an example using `Festival ( http://www.cstr.ed.ac.uk/projects/festival/ )`_,
a speech synthesis (text-to-speech) library written in C++.
To bind to an external library, set up a module directory similar to the Summator example:

4
development/cpp/common_engine_methods_and_macros.md
View File

@ -237,10 +237,10 @@ Godot features many error macros to make error reporting more convenient.
.. seealso::
See `core/error_macros.h <https://github.com/godotengine/godot/blob/3.x/core/error_macros.h>`
See `core/error_macros.h ( https://github.com/godotengine/godot/blob/3.x/core/error_macros.h )`
in Godot's codebase for more information about each error macro.
Some functions return an error code (materialized by a return type of
`Error`). This value can be returned directly from an error macro.
See the list of available error codes in
`core/error_list.h <https://github.com/godotengine/godot/blob/3.x/core/error_list.h>`.
`core/error_list.h ( https://github.com/godotengine/godot/blob/3.x/core/error_list.h )`.

8
development/cpp/configuring_an_ide/android_studio.md
View File

@ -3,8 +3,8 @@
Android Studio
==============
`Android Studio <https://developer.android.com/studio>`_ is a free
`JetBrains <https://www.jetbrains.com/>`_ IDE for Android development.
`Android Studio ( https://developer.android.com/studio )`_ is a free
`JetBrains ( https://www.jetbrains.com/ )`_ IDE for Android development.
It has a feature-rich editor which supports Java and C/C++. It can be used to
work on Godot's core engine as well as the Android platform codebase.
@ -22,7 +22,7 @@ Importing the project
- Navigate to `<Godot root directory>/platform/android/java` and select the `settings.gradle` file.
- Android Studio will import and index the project.
- To build the project, follow the `compiling instructions <toc-devel-compiling>`.
- To build the project, follow the `compiling instructions <toc-devel-compiling )`.
If you run into any issues, ask for help in one of
`Godot's community channels <https://godotengine.org/community>`.
`Godot's community channels ( https://godotengine.org/community )`.

10
development/cpp/configuring_an_ide/clion.md
View File

@ -3,15 +3,15 @@
CLion
=====
`CLion <https://www.jetbrains.com/clion/>`_ is a commercial
`JetBrains <https://www.jetbrains.com/>`_ IDE for C++.
`CLion ( https://www.jetbrains.com/clion/ )`_ is a commercial
`JetBrains ( https://www.jetbrains.com/ )`_ IDE for C++.
Importing the project
---------------------
CLion requires a `CMakeLists.txt` file as a project file, which is problematic
for Godot because it uses the SCons buildsystem instead of CMake. However,
there is a `CMakeLists.txt` configuration for `Android Studio <doc_configuring_an_ide_android_studio>`
there is a `CMakeLists.txt` configuration for `Android Studio <doc_configuring_an_ide_android_studio )`
which can also be used by CLion.
- From the CLion's welcome window choose the option to import an existing
@ -41,13 +41,13 @@ which can also be used by CLion.
work once the project has finished indexing.
If you run into any issues, ask for help in one of
`Godot's community channels <https://godotengine.org/community>`.
`Godot's community channels ( https://godotengine.org/community )`.
Debugging the project
---------------------
Since CLion does not support SCons, you won't be able to compile, launch, and debug Godot from CLion in one step.
You will first need to `compile godot yourself <https://docs.godotengine.org/en/stable/development/compiling/index.html>` and run the binary without CLion. You will then be able to debug Godot by using the `Attach to process <https://www.jetbrains.com/help/clion/attaching-to-local-process.html>` feature.
You will first need to `compile godot yourself ( https://docs.godotengine.org/en/stable/development/compiling/index.html )` and run the binary without CLion. You will then be able to debug Godot by using the `Attach to process ( https://www.jetbrains.com/help/clion/attaching-to-local-process.html )` feature.
- Run the compilation in debug mode by entering `scons`.

4
development/cpp/configuring_an_ide/code_blocks.md
View File

@ -3,7 +3,7 @@
Code::Blocks
============
`Code::Blocks <https://codeblocks.org/>`_ is a free, open source, cross platform IDE.
`Code::Blocks ( https://codeblocks.org/ )`_ is a free, open source, cross platform IDE.
Creating a new project
----------------------
@ -126,4 +126,4 @@ Under **General Settings**, on the **Editor Settings** tab, under **Tab Options*
:figclass: figure-w480
:align: center
That's it. You're ready to start contributing to Godot using the Code::Blocks IDE. Remember to save the project file and the **Workspace**. If you run into any issues, ask for help in one of `Godot's community channels <https://godotengine.org/community>`.
That's it. You're ready to start contributing to Godot using the Code::Blocks IDE. Remember to save the project file and the **Workspace**. If you run into any issues, ask for help in one of `Godot's community channels ( https://godotengine.org/community )`.

4
development/cpp/configuring_an_ide/index.md
View File

@ -1,8 +1,8 @@
Configuring an IDE
==================
We assume that you have already `cloned <https://github.com/godotengine/godot>`_
and `compiled <toc-devel-compiling>` Godot.
We assume that you have already `cloned ( https://github.com/godotengine/godot )`_
and `compiled <toc-devel-compiling )` Godot.
You can easily develop Godot with any text editor and by invoking `scons`
on the command line, but if you want to work with an IDE (Integrated

4
development/cpp/configuring_an_ide/kdevelop.md
View File

@ -3,7 +3,7 @@
KDevelop
========
`KDevelop <https://www.kdevelop.org>`_ is a free, open source IDE for all desktop platforms.
`KDevelop ( https://www.kdevelop.org )`_ is a free, open source IDE for all desktop platforms.
Importing the project
---------------------
@ -84,4 +84,4 @@ Debugging the project
:align: center
If you run into any issues, ask for help in one of
`Godot's community channels <https://godotengine.org/community>`.
`Godot's community channels ( https://godotengine.org/community )`.

8
development/cpp/configuring_an_ide/qt_creator.md
View File

@ -3,7 +3,7 @@
Qt Creator
==========
`Qt Creator <https://doc.qt.io/qtcreator/index.html>`_ is a free, open source IDE for all desktop platforms.
`Qt Creator ( https://doc.qt.io/qtcreator/index.html )`_ is a free, open source IDE for all desktop platforms.
Importing the project
---------------------
@ -85,12 +85,12 @@ Debugging the project
:align: center
To learn more about command line arguments, refer to the
`command line tutorial <doc_command_line_tutorial>`.
`command line tutorial <doc_command_line_tutorial )`.
Code style configuration
------------------------
Developers must follow the project's `code style <doc_code_style_guidelines>`
Developers must follow the project's `code style <doc_code_style_guidelines )`
and the IDE should help them follow it. By default, Qt Creator uses spaces
for indentation which doesn't match the Godot code style guidelines. You can
change this behavior by changing the **Code Style** in **Tools > Options > C++**.
@ -108,4 +108,4 @@ Click on **Edit** to change the current settings, then click on
:align: center
If you run into any issues, ask for help in one of
`Godot's community channels <https://godotengine.org/community>`.
`Godot's community channels ( https://godotengine.org/community )`.

8
development/cpp/configuring_an_ide/visual_studio.md
View File

@ -3,8 +3,8 @@
Visual Studio
=============
`Visual Studio Community <https://visualstudio.microsoft.com>` is a Windows-only IDE
by `Microsoft <https://microsoft.com>`_ that's free for non-commercial use.
`Visual Studio Community ( https://visualstudio.microsoft.com )` is a Windows-only IDE
by `Microsoft ( https://microsoft.com )`_ that's free for non-commercial use.
It has many useful features, such as memory view, performance view, source
control and more.
@ -53,7 +53,7 @@ project manager opens a project, the initial process is terminated and the debug
:align: center
To learn more about command line arguments, refer to the
`command line tutorial <doc_command_line_tutorial>`.
`command line tutorial <doc_command_line_tutorial )`.
Even if you start the project without a debugger attached it can still be connected to the running
process using **Debug > Attach to Process...** menu.
@ -65,4 +65,4 @@ start debugging.
:align: center
If you run into any issues, ask for help in one of
`Godot's community channels <https://godotengine.org/community>`.
`Godot's community channels ( https://godotengine.org/community )`.

12
development/cpp/configuring_an_ide/visual_studio_code.md
View File

@ -3,15 +3,15 @@
Visual Studio Code
==================
`Visual Studio Code <https://code.visualstudio.com>`_ is a free cross-platform code editor
by `Microsoft <https://microsoft.com>`_ (not to be confused with `doc_configuring_an_ide_vs`).
`Visual Studio Code ( https://code.visualstudio.com )`_ is a free cross-platform code editor
by `Microsoft ( https://microsoft.com )`_ (not to be confused with `doc_configuring_an_ide_vs`).
Importing the project
---------------------
- Make sure the C/C++ extension is installed. You can find instructions in
the `official documentation <https://code.visualstudio.com/docs/languages/cpp>`_.
Alternatively, `clangd <https://open-vsx.org/extension/llvm-vs-code-extensions/vscode-clangd>`_
the `official documentation ( https://code.visualstudio.com/docs/languages/cpp )`_.
Alternatively, `clangd ( https://open-vsx.org/extension/llvm-vs-code-extensions/vscode-clangd )`_
can be used instead.
- When using the clangd extension, run `scons compiledb=yes`.
- From the Visual Studio Code's main screen open the Godot root folder with
@ -169,7 +169,7 @@ js Windows
.. note::
Due to sporadic performance issues, it is recommended to use LLDB over GDB on Unix-based systems.
Make sure that the `CodeLLDB extension <https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb>`_
Make sure that the `CodeLLDB extension ( https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb )`_
is installed.
If you encounter issues with lldb, you may consider using gdb (see the X11_gdb configuration).
@ -180,4 +180,4 @@ The name under `program` depends on your build configuration,
e.g. `godot.x11.tools.64` for 64-bit X11 platform with `tools` enabled.
If you run into any issues, ask for help in one of
`Godot's community channels <https://godotengine.org/community>`.
`Godot's community channels ( https://godotengine.org/community )`.

4
development/cpp/configuring_an_ide/xcode.md
View File

@ -3,7 +3,7 @@
Xcode
=====
`Xcode <https://developer.apple.com/xcode>`_ is a free macOS-only IDE. You can
`Xcode ( https://developer.apple.com/xcode )`_ is a free macOS-only IDE. You can
download it from the Mac App Store.
Importing the project
@ -107,4 +107,4 @@ To check that everything is working, put a breakpoint in `platform/osx/godot_mai
run the project.
If you run into any issues, ask for help in one of
`Godot's community channels <https://godotengine.org/community>`.
`Godot's community channels ( https://godotengine.org/community )`.

24
development/cpp/core_types.md
View File

@ -34,7 +34,7 @@ directly to wchar_t.
References:
~~~~~~~~~~~
- `core/typedefs.h <https://github.com/godotengine/godot/blob/3.x/core/typedefs.h>`
- `core/typedefs.h ( https://github.com/godotengine/godot/blob/3.x/core/typedefs.h )`
Memory model
------------
@ -131,8 +131,8 @@ large amount of accesses.
References:
~~~~~~~~~~~
- `core/os/memory.h <https://github.com/godotengine/godot/blob/3.x/core/os/memory.h>`
- `core/pool_vector.h <https://github.com/godotengine/godot/blob/3.x/core/pool_vector.cpp>`
- `core/os/memory.h ( https://github.com/godotengine/godot/blob/3.x/core/os/memory.h )`
- `core/pool_vector.h ( https://github.com/godotengine/godot/blob/3.x/core/pool_vector.cpp )`
Containers
----------
@ -165,10 +165,10 @@ The Vector<> class also has a few nice features:
References:
~~~~~~~~~~~
- `core/vector.h <https://github.com/godotengine/godot/blob/3.x/core/vector.h>`
- `core/list.h <https://github.com/godotengine/godot/blob/3.x/core/list.h>`
- `core/set.h <https://github.com/godotengine/godot/blob/3.x/core/set.h>`
- `core/map.h <https://github.com/godotengine/godot/blob/3.x/core/map.h>`
- `core/vector.h ( https://github.com/godotengine/godot/blob/3.x/core/vector.h )`
- `core/list.h ( https://github.com/godotengine/godot/blob/3.x/core/list.h )`
- `core/set.h ( https://github.com/godotengine/godot/blob/3.x/core/set.h )`
- `core/map.h ( https://github.com/godotengine/godot/blob/3.x/core/map.h )`
String
------
@ -181,7 +181,7 @@ conversion and visualization.
References:
~~~~~~~~~~~
- `core/ustring.h <https://github.com/godotengine/godot/blob/3.x/core/ustring.h>`
- `core/ustring.h ( https://github.com/godotengine/godot/blob/3.x/core/ustring.h )`
StringName
----------
@ -197,7 +197,7 @@ is fast.
References:
~~~~~~~~~~~
- `core/string_name.h <https://github.com/godotengine/godot/blob/3.x/core/string_name.h>`
- `core/string_name.h ( https://github.com/godotengine/godot/blob/3.x/core/string_name.h )`
Math types
----------
@ -208,7 +208,7 @@ directory.
References:
~~~~~~~~~~~
- `core/math <https://github.com/godotengine/godot/tree/3.x/core/math>`
- `core/math ( https://github.com/godotengine/godot/tree/3.x/core/math )`
NodePath
--------
@ -219,7 +219,7 @@ referencing them fast.
References:
~~~~~~~~~~~
- `core/node_path.h <https://github.com/godotengine/godot/blob/3.x/core/node_path.h>`
- `core/node_path.h ( https://github.com/godotengine/godot/blob/3.x/core/node_path.h )`
RID
---
@ -232,4 +232,4 @@ referenced data.
References:
~~~~~~~~~~~
- `core/rid.h <https://github.com/godotengine/godot/blob/3.x/core/rid.h>`
- `core/rid.h ( https://github.com/godotengine/godot/blob/3.x/core/rid.h )`

12
development/cpp/custom_audiostreams.md
View File

@ -22,8 +22,8 @@ This guide assumes the reader knows how to create C++ modules. If not, refer to
References:
~~~~~~~~~~~
- `servers/audio/audio_stream.h <https://github.com/godotengine/godot/blob/master/servers/audio/audio_stream.h>`
- `scene/audio/audioplayer.cpp <https://github.com/godotengine/godot/blob/master/scene/audio/audio_player.cpp>`
- `servers/audio/audio_stream.h ( https://github.com/godotengine/godot/blob/master/servers/audio/audio_stream.h )`
- `scene/audio/audioplayer.cpp ( https://github.com/godotengine/godot/blob/master/scene/audio/audio_player.cpp )`
What for?
---------
@ -116,7 +116,7 @@ Therefore, playback state must be self-contained in AudioStreamPlayback.
References:
~~~~~~~~~~~
- `servers/audio/audio_stream.h <https://github.com/godotengine/godot/blob/master/servers/audio/audio_stream.h>`
- `servers/audio/audio_stream.h ( https://github.com/godotengine/godot/blob/master/servers/audio/audio_stream.h )`
Create an AudioStreamPlayback
@ -346,6 +346,6 @@ query AudioFrames and `get_stream_sampling_rate` to query current mix rate.
References:
~~~~~~~~~~~
- `core/math/audio_frame.h <https://github.com/godotengine/godot/blob/master/core/math/audio_frame.h>`
- `servers/audio/audio_stream.h <https://github.com/godotengine/godot/blob/master/servers/audio/audio_stream.h>`
- `scene/audio/audioplayer.cpp <https://github.com/godotengine/godot/blob/master/scene/audio/audio_player.cpp>`
- `core/math/audio_frame.h ( https://github.com/godotengine/godot/blob/master/core/math/audio_frame.h )`
- `servers/audio/audio_stream.h ( https://github.com/godotengine/godot/blob/master/servers/audio/audio_stream.h )`
- `scene/audio/audioplayer.cpp ( https://github.com/godotengine/godot/blob/master/scene/audio/audio_player.cpp )`

18
development/cpp/custom_godot_servers.md
View File

@ -18,9 +18,9 @@ data types. If not, refer to `doc_custom_modules_in_c++`.
References
~~~~~~~~~~~
- `Why does Godot use servers and RIDs? <https://godotengine.org/article/why-does-godot-use-servers-and-rids>`
- `Singleton pattern <https://en.wikipedia.org/wiki/Singleton_pattern>`
- `Mediator pattern <https://en.wikipedia.org/wiki/Mediator_pattern>`
- `Why does Godot use servers and RIDs? ( https://godotengine.org/article/why-does-godot-use-servers-and-rids )`
- `Singleton pattern ( https://en.wikipedia.org/wiki/Singleton_pattern )`
- `Mediator pattern ( https://en.wikipedia.org/wiki/Mediator_pattern )`
What for?
---------
@ -274,7 +274,7 @@ Custom managed resource data
----------------------------
Godot servers implement a mediator pattern. All data types inherit `RID_Data`.
`RID_Owner<MyRID_Data>` owns the object when `make_rid` is called. During debug mode only,
`RID_Owner<MyRID_Data )` owns the object when `make_rid` is called. During debug mode only,
RID_Owner maintains a list of RIDs. In practice, RIDs are similar to writing
object-oriented C code.
@ -315,8 +315,8 @@ object-oriented C code.
References
~~~~~~~~~~~
- `RID<class_rid>`
- `core/rid.h <https://github.com/godotengine/godot/blob/3.x/core/rid.h>`
- `RID<class_rid )`
- `core/rid.h ( https://github.com/godotengine/godot/blob/3.x/core/rid.h )`
Registering the class in GDScript
---------------------------------
@ -373,7 +373,7 @@ is used to register the dummy class in GDScript.
void register_hilbert_hotel_types();
void unregister_hilbert_hotel_types();
- `servers/register_server_types.cpp <https://github.com/godotengine/godot/blob/master/servers/register_server_types.cpp>`
- `servers/register_server_types.cpp ( https://github.com/godotengine/godot/blob/master/servers/register_server_types.cpp )`
Bind methods
~~~~~~~~~~~~
@ -474,7 +474,7 @@ to execute the desired behavior. The queue will be flushed whenever either
References:
~~~~~~~~~~~
- `core/message_queue.cpp <https://github.com/godotengine/godot/blob/3.x/core/message_queue.cpp>`
- `core/message_queue.cpp ( https://github.com/godotengine/godot/blob/3.x/core/message_queue.cpp )`
Summing it up
-------------
@ -505,5 +505,5 @@ Here is the GDScript sample code:
Notes
~~~~~
- The actual `Hilbert Hotel <https://en.wikipedia.org/wiki/Hilbert%27s_paradox_of_the_Grand_Hotel>` is impossible.
- The actual `Hilbert Hotel ( https://en.wikipedia.org/wiki/Hilbert%27s_paradox_of_the_Grand_Hotel )` is impossible.
- Connecting signal example code is pretty hacky.

14
development/cpp/custom_modules_in_cpp.md
View File

@ -35,7 +35,7 @@ Creating a new module
---------------------
Before creating a module, make sure to `download the source code of Godot
and compile it <toc-devel-compiling>`.
and compile it <toc-devel-compiling )`.
To create a new module, the first step is creating a directory inside
`modules/`. If you want to maintain the module separately, you can checkout
@ -251,7 +251,7 @@ The output will be `60`.
template you plan to use, then specify the path to the custom
template in each export preset. Otherwise, you'll get errors when
running the project as the module isn't compiled in the export
template. See the `Compiling <toc-devel-compiling>` pages
template. See the `Compiling <toc-devel-compiling )` pages
for more information.
Compiling a module externally
@ -303,7 +303,7 @@ and compile them accordingly, including our "summator" module.
.. seealso::
`Introduction to the buildsystem - Custom modules build option <doc_buildsystem_custom_modules>`.
`Introduction to the buildsystem - Custom modules build option <doc_buildsystem_custom_modules )`.
Improving the build system for development
------------------------------------------
@ -312,7 +312,7 @@ Improving the build system for development
This shared library support is not designed to support distributing a module
to other users without recompiling the engine. For that purpose, use
`GDNative <doc_what_is_gdnative>` instead.
`GDNative <doc_what_is_gdnative )` instead.
So far, we defined a clean SCsub that allows us to add the sources
of our new module as part of the Godot binary.
@ -478,8 +478,8 @@ main `doc/classes` directory.
3. Now we can generate the documentation:
We can do this via running Godot's doctool i.e. `godot --doctool <path>`,
which will dump the engine API reference to the given `<path>` in XML format.
We can do this via running Godot's doctool i.e. `godot --doctool <path )`,
which will dump the engine API reference to the given `<path )` in XML format.
In our case we'll point it to the root of the cloned repository. You can point it
to an another folder, and just copy over the files that you need.
@ -507,7 +507,7 @@ the things that you previously added. Of course if you point it to your godot
folder, make sure you don't lose work by extracting older docs from an older engine build
on top of the newer ones.
Note that if you don't have write access rights to your supplied `<path>`,
Note that if you don't have write access rights to your supplied `<path )`,
you might encounter an error similar to the following:
.. code-block:: console

14
development/cpp/custom_resource_format_loaders.md
View File

@ -17,8 +17,8 @@ data types. If not, refer to this guide `doc_custom_modules_in_c++`.
References
~~~~~~~~~~
- `ResourceLoader<class_resourceloader>`
- `core/io/resource_loader.cpp <https://github.com/godotengine/godot/blob/master/core/io/resource_loader.cpp>`_
- `ResourceLoader<class_resourceloader )`
- `core/io/resource_loader.cpp ( https://github.com/godotengine/godot/blob/master/core/io/resource_loader.cpp )`_
What for?
---------
@ -38,7 +38,7 @@ ImageFormatLoader should be used to load images.
References
~~~~~~~~~~
- `core/io/image_loader.h <https://github.com/godotengine/godot/blob/master/core/io/image_loader.h>`_
- `core/io/image_loader.h ( https://github.com/godotengine/godot/blob/master/core/io/image_loader.h )`_
Creating a ResourceFormatLoader
@ -302,9 +302,9 @@ calls into `std::istream`.
References
~~~~~~~~~~
- `istream <http://www.cplusplus.com/reference/istream/istream/>`_
- `streambuf <http://www.cplusplus.com/reference/streambuf/streambuf/?kw=streambuf>`_
- `core/io/fileaccess.h <https://github.com/godotengine/godot/blob/master/core/os/file_access.h>`_
- `istream ( http://www.cplusplus.com/reference/istream/istream/ )`_
- `streambuf ( http://www.cplusplus.com/reference/streambuf/streambuf/?kw=streambuf )`_
- `core/io/fileaccess.h ( https://github.com/godotengine/godot/blob/master/core/os/file_access.h )`_
Registering the new file format
-------------------------------
@ -355,7 +355,7 @@ when `load` is called.
References
~~~~~~~~~~
- `core/io/resource_loader.cpp <https://github.com/godotengine/godot/blob/master/core/io/resource_loader.cpp>`_
- `core/io/resource_loader.cpp ( https://github.com/godotengine/godot/blob/master/core/io/resource_loader.cpp )`_
Loading it on GDScript
----------------------

2
development/cpp/inheritance_class_tree.md
View File

@ -26,4 +26,4 @@ Spatial
![](img/Spatial.png)
Source files: :download:`tree.zip <files/class_tree.zip>`.
Source files: :download:`tree.zip <files/class_tree.zip )`.

12
development/cpp/object_class.md
View File

@ -35,7 +35,7 @@ This makes Objects gain a lot of functionality, like for example
References:
~~~~~~~~~~~
- `core/object.h <https://github.com/godotengine/godot/blob/3.x/core/object.h>`
- `core/object.h ( https://github.com/godotengine/godot/blob/3.x/core/object.h )`
Registering an Object
---------------------
@ -93,7 +93,7 @@ string passing the name can be passed for brevity.
References:
~~~~~~~~~~~
- `core/class_db.h <https://github.com/godotengine/godot/blob/3.x/core/class_db.h>`
- `core/class_db.h ( https://github.com/godotengine/godot/blob/3.x/core/class_db.h )`
Constants
---------
@ -265,7 +265,7 @@ templates point to it.
References:
~~~~~~~~~~~
- `core/reference.h <https://github.com/godotengine/godot/blob/3.x/core/reference.h>`
- `core/reference.h ( https://github.com/godotengine/godot/blob/3.x/core/reference.h )`
Resources:
----------
@ -281,7 +281,7 @@ Resources without a path are fine too.
References:
~~~~~~~~~~~
- `core/resource.h <https://github.com/godotengine/godot/blob/3.x/core/resource.h>`
- `core/resource.h ( https://github.com/godotengine/godot/blob/3.x/core/resource.h )`
Resource loading
----------------
@ -302,7 +302,7 @@ the same time.
References:
~~~~~~~~~~~
- `core/io/resource_loader.h <https://github.com/godotengine/godot/blob/3.x/core/io/resource_loader.h>`
- `core/io/resource_loader.h ( https://github.com/godotengine/godot/blob/3.x/core/io/resource_loader.h )`
Resource saving
---------------
@ -321,4 +321,4 @@ be bundled with the saved resource and assigned sub-IDs, like
References:
~~~~~~~~~~~
- `core/io/resource_saver.h <https://github.com/godotengine/godot/blob/3.x/core/io/resource_saver.h>`
- `core/io/resource_saver.h ( https://github.com/godotengine/godot/blob/3.x/core/io/resource_saver.h )`

8
development/cpp/using_cpp_profilers.md
View File

@ -15,9 +15,9 @@ To this end, profilers are useful tools.
Recommended profilers
---------------------
- `VerySleepy <http://www.codersnotes.com/sleepy/>` (Windows only)
- `HotSpot <https://github.com/KDAB/hotspot>` (Linux only)
- `Xcode Instruments <https://developer.apple.com/xcode/>` (macOS only)
- `VerySleepy ( http://www.codersnotes.com/sleepy/ )` (Windows only)
- `HotSpot ( https://github.com/KDAB/hotspot )` (Linux only)
- `Xcode Instruments ( https://developer.apple.com/xcode/ )` (macOS only)
These profilers may not be the most powerful or flexible options, but their
standalone operation and limited feature set tends to make them easier to use.
@ -53,7 +53,7 @@ If you're looking into optimizing Godot's startup/shutdown performance,
you can tell the profiler to use the `--quit` command line option on the Godot binary.
This will exit Godot just after it finished starting.
The `--quit` option works with `--editor`, `--project-manager` or
`--path <path to project directory>` (which runs a project directly).
`--path <path to project directory )` (which runs a project directly).
.. seealso::

6
development/cpp/variant_class.md
View File

@ -37,7 +37,7 @@ of C++ with little effort. Become a friend of Variant today.
References:
~~~~~~~~~~~
- `core/variant.h <https://github.com/godotengine/godot/blob/3.x/core/variant.h>`
- `core/variant.h ( https://github.com/godotengine/godot/blob/3.x/core/variant.h )`
Containers: Dictionary and Array
--------------------------------
@ -56,5 +56,5 @@ Copy-on-write (COW) mode support for containers was dropped with Godot 3.0.
References:
~~~~~~~~~~~
- `core/dictionary.h <https://github.com/godotengine/godot/blob/3.x/core/dictionary.h>`
- `core/array.h <https://github.com/godotengine/godot/blob/3.x/core/array.h>`
- `core/dictionary.h ( https://github.com/godotengine/godot/blob/3.x/core/dictionary.h )`
- `core/array.h ( https://github.com/godotengine/godot/blob/3.x/core/array.h )`

12
development/editor/creating_icons.md
View File

@ -12,7 +12,7 @@ Creating icons
~~~~~~~~~~~~~~
To create new icons, you first need a vector graphics editor installed.
For instance, you can use the open source `Inkscape <https://inkscape.org/>`_ editor.
For instance, you can use the open source `Inkscape ( https://inkscape.org/ )`_ editor.
Clone the `godot` repository containing all the editor icons:
@ -38,7 +38,7 @@ Color conversion for light editor themes
If the user has configured their editor to use a light theme, Godot will
convert the icon's colors based on a
`set of predefined color mappings <https://github.com/godotengine/godot/blob/b9f2e57d6240346f1833fd0390de195c956299e7/editor/editor_themes.cpp#L122-L184>`.
`set of predefined color mappings ( https://github.com/godotengine/godot/blob/b9f2e57d6240346f1833fd0390de195c956299e7/editor/editor_themes.cpp#L122-L184 )`.
This is to ensure the icon always displays with a sufficient contrast rate.
Try to restrict your icon's color palette to colors found in the list above.
Otherwise, your icon may become difficult to read on a light background.
@ -50,9 +50,9 @@ Because the editor renders SVGs once at load time, they need to be small
in size so they can be efficiently parsed. Editor icons must be first
optimized before being added to the engine, to do so:
1. Install `svgcleaner <https://github.com/RazrFalcon/svgcleaner>`
1. Install `svgcleaner ( https://github.com/RazrFalcon/svgcleaner )`
by downloading a binary from its
`Releases tab <https://github.com/RazrFalcon/svgcleaner/releases/latest>`
`Releases tab ( https://github.com/RazrFalcon/svgcleaner/releases/latest )`
and placing it into a location in your `PATH` environment variable.
2. Run the command below, replacing `svg_source.svg` with the path to your
@ -86,7 +86,7 @@ make a separate pull request for your icons to be available within the editor
as they can be self-contained.
For specific instructions on how to create module icons, refer to
`Creating custom module icons<doc_custom_module_icons>`.
`Creating custom module icons<doc_custom_module_icons )`.
Troubleshooting
~~~~~~~~~~~~~~~
@ -101,4 +101,4 @@ If icons don't appear in the editor, make sure that:
References
~~~~~~~~~~
- `editor/icons <https://github.com/godotengine/godot/tree/master/editor/icons>`
- `editor/icons ( https://github.com/godotengine/godot/tree/master/editor/icons )`

22
development/editor/introduction_to_editor_development.md
View File

@ -22,7 +22,7 @@ Technical choices
-----------------
The Godot editor is drawn using Godot's renderer and
`UI system <toc-gui-basics>`. It does *not* rely on a toolkit
`UI system <toc-gui-basics )`. It does *not* rely on a toolkit
such as GTK or Qt. This is similar in spirit to software like Blender.
While using toolkits makes it easier to achieve a "native" appearance, they are
also quite heavy and their licensing is not compatible with Godot's.
@ -33,26 +33,26 @@ Directory structure
-------------------
The editor's code is fully self-contained in the
`editor/ <https://github.com/godotengine/godot/tree/master/editor>` folder
`editor/ ( https://github.com/godotengine/godot/tree/master/editor )` folder
of the Godot source repository.
Some editor functionality is also implemented via
`modules <doc_custom_modules_in_c++>`. Some of these are only enabled in
`modules <doc_custom_modules_in_c++ )`. Some of these are only enabled in
editor builds to decrease the binary size of export templates. See the
`modules/ <https://github.com/godotengine/godot/tree/master/modules>` folder
`modules/ ( https://github.com/godotengine/godot/tree/master/modules )` folder
in the Godot source repository.
Some important files in the editor are:
- `editor/editor_node.cpp <https://github.com/godotengine/godot/blob/3.x/editor/editor_node.cpp>`:
- `editor/editor_node.cpp ( https://github.com/godotengine/godot/blob/3.x/editor/editor_node.cpp )`:
Main editor initialization file. Effectively the "main scene" of the editor.
- `editor/project_manager.cpp <https://github.com/godotengine/godot/blob/3.x/editor/project_manager.cpp>`:
- `editor/project_manager.cpp ( https://github.com/godotengine/godot/blob/3.x/editor/project_manager.cpp )`:
Main project manager initialization file. Effectively the "main scene" of the project manager.
- `editor/plugins/canvas_item_editor_plugin.cpp <https://github.com/godotengine/godot/blob/3.x/editor/plugins/canvas_item_editor_plugin.cpp>`:
- `editor/plugins/canvas_item_editor_plugin.cpp ( https://github.com/godotengine/godot/blob/3.x/editor/plugins/canvas_item_editor_plugin.cpp )`:
The 2D editor viewport and related functionality (toolbar at the top, editing modes, overlaid helpers/panels, …).
- `editor/plugins/spatial_editor_plugin.cpp <https://github.com/godotengine/godot/blob/3.x/editor/plugins/spatial_editor_plugin.cpp>`:
- `editor/plugins/spatial_editor_plugin.cpp ( https://github.com/godotengine/godot/blob/3.x/editor/plugins/spatial_editor_plugin.cpp )`:
The 3D editor viewport and related functionality (toolbar at the top, editing modes, overlaid panels, …).
- `editor/spatial_editor_gizmos.cpp <https://github.com/godotengine/godot/blob/3.x/editor/spatial_editor_gizmos.cpp>`:
- `editor/spatial_editor_gizmos.cpp ( https://github.com/godotengine/godot/blob/3.x/editor/spatial_editor_gizmos.cpp )`:
Where the 3D editor gizmos are defined and drawn.
This file doesn't have a 2D counterpart as 2D gizmos are drawn by the nodes themselves.
@ -77,12 +77,12 @@ from `servers/` and `core/`, it cannot depend on includes from `editor/`.
Currently, there are some dependencies to `editor/` includes in `scene/`
files, but
`they are in the process of being removed <https://github.com/godotengine/godot/issues/29730>`.
`they are in the process of being removed ( https://github.com/godotengine/godot/issues/29730 )`.
Development tips
----------------
To iterate quickly on the editor, we recommend to set up a test project and
`open it from the command line <doc_command_line_tutorial>` after compiling
`open it from the command line <doc_command_line_tutorial )` after compiling
the editor. This way, you don't have to go through the project manager every
time you start Godot.

2
development/file_formats/tscn.md
View File

@ -16,7 +16,7 @@ This reduces the data size and speeds up loading, as binary formats are faster
to load compared to text-based formats.
For those looking for a complete description, the parsing is handled in the file
`resource_format_text.cpp <https://github.com/godotengine/godot/blob/master/scene/resources/resource_format_text.cpp>`_
`resource_format_text.cpp ( https://github.com/godotengine/godot/blob/master/scene/resources/resource_format_text.cpp )`_
in the `ResourceFormatLoaderText` class.
File structure

2
getting_started/first_2d_game/01.project_setup.md
View File

@ -12,7 +12,7 @@ Launch Godot and create a new project.
GDScript
```
Download :download:`dodge_assets.zip <files/dodge_assets.zip>`.
Download :download:`dodge_assets.zip <files/dodge_assets.zip )`.
The archive contains the images and sounds you'll be using
to make the game. Extract the archive and move the `art/`
and `fonts/` directories to your project's directory.

6
getting_started/first_2d_game/02.player_scene.md
View File

@ -16,7 +16,7 @@ Node structure
To begin, we need to choose a root node for the player object. As a general
rule, a scene's root node should reflect the object's desired functionality -
what the object *is*. Click the "Other Node" button and add an `Area2D
<class_Area2D>` node to the scene.
<class_Area2D )` node to the scene.
![](img/add_node.png)
@ -54,10 +54,10 @@ Sprite animation
~~~~~~~~~~~~~~~~
Click on the `Player` node and add an `AnimatedSprite
<class_AnimatedSprite>` node as a child. The `AnimatedSprite` will handle the
<class_AnimatedSprite )` node as a child. The `AnimatedSprite` will handle the
appearance and animations for our player. Notice that there is a warning symbol
next to the node. An `AnimatedSprite` requires a `SpriteFrames
<class_SpriteFrames>` resource, which is a list of the animations it can
<class_SpriteFrames )` resource, which is a list of the animations it can
display. To create one, find the `Frames` property in the Inspector and click
"[empty]" -> "New SpriteFrames". Click again to open the "SpriteFrames" panel:

2
getting_started/first_2d_game/06.heads_up_display.md
View File

@ -22,7 +22,7 @@ The HUD needs to display the following information:
The basic node for UI elements is `Control`. To create our
UI, we'll use two types of `Control` nodes: `Label
<class_Label>` and `Button`.
<class_Label )` and `Button`.
Create the following as children of the `HUD` node:

6
getting_started/first_2d_game/index.md
View File

@ -45,18 +45,18 @@ Prerequisites
-------------
This step-by-step tutorial is intended for beginners who followed the complete
`Getting Started <toc-learn-step_by_step>`.
`Getting Started <toc-learn-step_by_step )`.
If you're an experienced programmer, you can find the complete demo's source
code here: `Godot demo projects
<https://github.com/godotengine/godot-demo-projects>`.
( https://github.com/godotengine/godot-demo-projects )`.
We prepared some game assets you'll need to download so we can jump straight to
the code.
You can download them by clicking the link below.
:download:`dodge_assets.zip <files/dodge_assets.zip>`.
:download:`dodge_assets.zip <files/dodge_assets.zip )`.
Contents
--------

2
getting_started/first_3d_game/01.game_setup.md
View File

@ -9,7 +9,7 @@ importing the start assets and setting up the game scene.
We've prepared a Godot project with the 3D models and sounds we'll use for this
tutorial, linked in the index page. If you haven't done so yet, you can download
the archive here: `Squash the Creeps assets
<https://github.com/GDQuest/godot-3d-dodge-the-creeps/releases/tag/1.0.0>`.
( https://github.com/GDQuest/godot-3d-dodge-the-creeps/releases/tag/1.0.0 )`.
Once you downloaded it, extract the .zip archive on your computer. Open the
Godot project manager and click the *Import* button.

2
getting_started/first_3d_game/02.player_input.md
View File

@ -45,7 +45,7 @@ This should instantiate the model as a child of *Pivot*. You can rename it to
The `.glb` files contain 3D scene data based on the open-source GLTF 2.0
specification. They're a modern and powerful alternative to a proprietary format
like FBX, which Godot also supports. To produce these files, we designed the
model in `Blender 3D <https://www.blender.org/>` and exported it to GLTF.
model in `Blender 3D ( https://www.blender.org/ )` and exported it to GLTF.
As with all kinds of physics nodes, we need a collision shape for our character
to collide with the environment. Select the *Player* node again and add a

10
getting_started/first_3d_game/06.jump_and_squash.md
View File

@ -8,7 +8,7 @@ lesson, we'll make the player die when a monster hits them on the ground.
First, we have to change a few settings related to physics interactions. Enter
the world of `physics layers
<doc_physics_introduction_collision_layers_and_masks>`.
<doc_physics_introduction_collision_layers_and_masks )`.
Controlling physics interactions
--------------------------------
@ -156,7 +156,7 @@ over monsters and kill them at the same time.
We need to detect collisions with a monster and to differentiate them from
collisions with the floor. To do so, we can use Godot's `group
<doc_groups>` tagging feature.
<doc_groups )` tagging feature.
Open the scene `Mob.tscn` again and select the *Mob* node. Go to the *Node*
dock on the right to see a list of signals. The *Node* dock has two tabs:
@ -224,18 +224,18 @@ gdscript GDScript
That's a lot of new functions. Here's some more information about them.
The functions `get_slide_count()` and `get_slide_collision()` both come from
the `KinematicBody<class_KinematicBody>` class and are related to
the `KinematicBody<class_KinematicBody )` class and are related to
`move_and_slide()`.
`get_slide_collision()` returns a
`KinematicCollision<class_KinematicCollision>` object that holds
`KinematicCollision<class_KinematicCollision )` object that holds
information about where and how the collision occurred. For example, we use its
`collider` property to check if we collided with a "mob" by calling
`is_in_group()` on it: `collision.collider.is_in_group("mob")`.
.. note::
The method `is_in_group()` is available on every `Node<class_Node>`.
The method `is_in_group()` is available on every `Node<class_Node )`.
To check that we are landing on the monster, we use the vector dot product:
`Vector3.UP.dot(collision.normal) > 0.1`. The collision normal is a 3D vector

4
getting_started/first_3d_game/08.score_and_replay.md
View File

@ -262,14 +262,14 @@ gdscript GDScript
```
The function `get_tree()` gives us access to the global `SceneTree
<class_SceneTree>` object, which allows us to reload and restart the current
<class_SceneTree )` object, which allows us to reload and restart the current
scene.
Adding music
------------
To add music that plays continuously in the background, we're going to use
another feature in Godot: `autoloads <doc_singletons_autoload>`.
another feature in Godot: `autoloads <doc_singletons_autoload )`.
To play audio, all you need to do is add an *AudioStreamPlayer* node to your
scene and attach an audio file to it. When you start the scene, it can play

8
getting_started/first_3d_game/going_further.md
View File

@ -17,7 +17,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/GDQuest/godot-3d-dodge-the-creeps>`_.
`( https://github.com/GDQuest/godot-3d-dodge-the-creeps )`_.
Exploring the manual
--------------------
@ -29,11 +29,11 @@ information about 2D, 3D, physics, rendering and performance, and much more.
Here are the sections we recommend you to explore next:
1. Read the `Scripting section <toc-scripting-core-features>` to learn essential programming features you’ll use
1. Read the `Scripting section <toc-scripting-core-features )` to learn essential programming features you’ll use
in every project.
2. The `3D <toc-learn-features-3d>` and `Physics <toc-learn-features-physics>` sections will teach you more about 3D game creation in the
2. The `3D <toc-learn-features-3d )` and `Physics <toc-learn-features-physics )` sections will teach you more about 3D game creation in the
engine.
3. `Inputs <toc-learn-features-inputs>` is another important one for any game project.
3. `Inputs <toc-learn-features-inputs )` is another important one for any game project.
You can start with these or, if you prefer, look at the sidebar menu on the left
and pick your options.

4
getting_started/first_3d_game/index.md
View File

@ -31,7 +31,7 @@ This tutorial is for beginners who followed the complete getting started series.
We'll start slow with detailed instructions and shorten them as we do similar
steps. If you're an experienced programmer, you can browse the complete demo's
source code here: `Squash the Creep source code
<https://github.com/GDQuest/godot-3d-dodge-the-creeps/>`.
( https://github.com/GDQuest/godot-3d-dodge-the-creeps/ )`.
.. note::
@ -42,7 +42,7 @@ source code here: `Squash the Creep source code
We prepared some game assets so we can jump straight to the code. You can
download them here: `Squash the Creeps assets
<https://github.com/GDQuest/godot-3d-dodge-the-creeps/releases/tag/1.1.0>`.
( https://github.com/GDQuest/godot-3d-dodge-the-creeps/releases/tag/1.1.0 )`.
We will first work on a basic prototype for the player's movement. We will then
add the monsters that we'll spawn randomly around the screen. After that, we'll

2
getting_started/introduction/first_look_at_the_editor.md
View File

@ -13,7 +13,7 @@ This page will give you a brief overview of Godot's interface. We're going to
look at the different main screens and docks to help you situate yourself.
.. seealso:: For a comprehensive breakdown of the editor's interface and how to
use it, see the `Editor manual <toc-learn-editor>`.
use it, see the `Editor manual <toc-learn-editor )`.
The Project manager
-------------------

8
getting_started/introduction/godot_design_philosophy.md
View File

@ -17,7 +17,7 @@ your project, you need to try it out for yourself and
understand its design and limitations.
Please watch
`Godot explained in 5 minutes <https://www.youtube.com/watch?v=KjX5llYZ5eQ>`_
`Godot explained in 5 minutes ( https://www.youtube.com/watch?v=KjX5llYZ5eQ )`_
if you're looking for an overview of the engine's features.
Object-oriented design and composition
@ -77,7 +77,7 @@ the ability to hot-reload locally and on remote devices, etc.
The goal is to offer a full package to create games and a continuous
user experience. You can still work with external programs as long as
there is an import plugin for it. Or you can create one, like the `Tiled
Map Importer <https://github.com/vnen/godot-tiled-importer>`.
Map Importer ( https://github.com/vnen/godot-tiled-importer )`.
That is also partly why Godot offers its own programming languages
GDScript and VisualScript, along with C#. They're designed for the needs
@ -111,12 +111,12 @@ manage states and transitions visually.*
.. warning::
`Godot 4.0 will remove VisualScript from core entirely. <https://godotengine.org/article/godot-4-will-discontinue-visual-scripting>`
`Godot 4.0 will remove VisualScript from core entirely. ( https://godotengine.org/article/godot-4-will-discontinue-visual-scripting )`
As a result, creating new projects using visual scripting in Godot is not recommended.
Future Godot 4.x releases may have VisualScript reimplemented as an extension.
While Godot 3.x will keep VisualScript supported, we recommend
`trying out GDScript <toc-learn-scripting-gdscript>` instead,
`trying out GDScript <toc-learn-scripting-gdscript )` instead,
especially if you intend to migrate your project to Godot 4.
Open source

10
getting_started/introduction/introduction_to_godot.md
View File

@ -71,15 +71,15 @@ Programming languages
Let's talk about the available programming languages.
You can code your games using `GDScript <toc-learn-scripting-gdscript>`, a
You can code your games using `GDScript <toc-learn-scripting-gdscript )`, a
Godot-specific and tightly integrated language with a lightweight syntax, or
`C# <toc-learn-scripting-C#>`, which is popular in the games industry.
`C# <toc-learn-scripting-C# )`, which is popular in the games industry.
These are the two main scripting languages we support.
Godot also supports a node-based visual programming language named
`VisualScript <toc-learn-scripting-visual_script>`.
`VisualScript <toc-learn-scripting-visual_script )`.
With the `GDNative <toc-tutorials-gdnative>` technology, you can also write
With the `GDNative <toc-tutorials-gdnative )` technology, you can also write
gameplay or high-performance algorithms in C or C++ without recompiling the
engine. You can use this technology to integrate third-party libraries and other
Software Development Kits (SDK) in the engine.
@ -90,7 +90,7 @@ completely free and open-source.
.. seealso:: These are the five officially supported programming languages. The
community maintains support for many more. For more information,
see `GDNative third-party bindings
<doc_what_is_gdnative_third_party_bindings>`.
<doc_what_is_gdnative_third_party_bindings )`.
What do I need to know to use Godot?
------------------------------------

24
getting_started/introduction/learning_new_features.md
View File

@ -33,7 +33,7 @@ from within the Godot editor. To do so, go to Help -> Search or press
![](img/manual_class_reference_search.png)
To browse it online, head to the manual's `Class Reference <toc-class-ref>`
To browse it online, head to the manual's `Class Reference <toc-class-ref )`
section.
A class reference's page tells you:
@ -53,7 +53,7 @@ A class reference's page tells you:
.. note:: If the manual or class reference is missing or has insufficient
information, please open an Issue in the official `godot-docs
<https://github.com/godotengine/godot-docs/issues>`_ GitHub repository
( https://github.com/godotengine/godot-docs/issues )`_ GitHub repository
to report it.
You can Ctrl-click any underlined text like the name of a class, property,
@ -67,14 +67,14 @@ beyond the scope of Godot's documentation. If you're new to programming, we
recommend two excellent free resources to get you started:
1. Harvard university offers a free courseware to learn to program, `CS50
<https://cs50.harvard.edu/x/>`_. It will teach you programming
( https://cs50.harvard.edu/x/ )`_. It will teach you programming
fundamentals, how code works, and how to think like a programmer. These
skills are essential to become a game developer and learn any game engine
efficiently. You can see this course as an investment that will save you time
and trouble when you learn to create games.
2. If you prefer books, check out the free ebook `Automate The Boring Stuff With
Python <https://automatetheboringstuff.com/>`_ by Al Sweigart.
Python ( https://automatetheboringstuff.com/ )`_ by Al Sweigart.
Learning with the community
---------------------------
@ -82,10 +82,10 @@ Learning with the community
Godot has a growing community of users. If you're stuck on a problem or need
help to better understand how to achieve something, you can ask other users for
help on one of the many `active
communities <https://godotengine.org/community>`_.
communities ( https://godotengine.org/community )`_.
The best place to ask for questions and find already answered ones is the
official `Questions & Answers <https://godotengine.org/qa/>`_ site. These
official `Questions & Answers ( https://godotengine.org/qa/ )`_ site. These
responses show up in search engine results and get saved, allowing other users
to benefit from discussions on the platform. Once you asked a question there,
you can share its link on other social platforms. Before asking a question, be
@ -109,7 +109,7 @@ information:
3. If there is code involved, **share a code sample**. Other users won't be able
to help you fix a problem without seeing your code. Share the code as text
directly. To do so, you can copy and paste a short code snippet in a chat
box, or use a website like `Pastebin <https://pastebin.com/>`_ to share long
box, or use a website like `Pastebin ( https://pastebin.com/ )`_ to share long
files.
4. **Share a screenshot** of your *Scene* dock along with your written code. Most of
@ -123,15 +123,15 @@ information:
should have a built-in tool to take screenshots with the :kbd:`PrtSc` (Print
Screen) key.
Alternatively, you can use a program like `ShareX <https://getsharex.com/>`_
on Windows or `FlameShot <https://flameshot.org/>`_ on Linux.
Alternatively, you can use a program like `ShareX ( https://getsharex.com/ )`_
on Windows or `FlameShot ( https://flameshot.org/ )`_ on Linux.
5. Sharing a video of your running game can also be really **useful to
troubleshoot your game**. You can use programs like `OBS Studio
<https://obsproject.com/>`_ and `Screen to GIF
<https://www.screentogif.com/>`_ to capture your screen.
( https://obsproject.com/ )`_ and `Screen to GIF
( https://www.screentogif.com/ )`_ to capture your screen.
You can then use a service like `streamable <https://streamable.com/>`_ or a
You can then use a service like `streamable ( https://streamable.com/ )`_ or a
cloud provider to upload and share your videos for free.
6. If you're not using the stable version of Godot, please mention the version

2
getting_started/step_by_step/index.md
View File

@ -2,7 +2,7 @@ Step by step
============
This series builds upon the `Introduction to Godot
<toc-learn-introduction>` and will get you started with the editor and the
<toc-learn-introduction )` and will get you started with the editor and the
engine. You will learn more about nodes and scenes, code your first classes with
GDScript, use signals to make nodes communicate with one another, and more.

4
getting_started/step_by_step/instancing.md
View File

@ -14,7 +14,7 @@ the previous lesson was an example. We call those files "Packed Scenes" as they
pack information about your scene's content.
Here's an example of a ball. It's composed of a `RigidBody2D
<class_RigidBody2D>` node as its root named Ball, which allows the ball to fall
<class_RigidBody2D )` node as its root named Ball, which allows the ball to fall
and bounce on walls, a `Sprite` node, and a
`CollisionShape2D`.
@ -40,7 +40,7 @@ In practice
Let's use instancing in practice to see how it works in Godot. We invite
you to download the ball's sample project we prepared for you:
:download:`instancing.zip <files/instancing.zip>`.
:download:`instancing.zip <files/instancing.zip )`.
Extract the archive on your computer. Then, open Godot, and in the project
manager, click the Import button to import the project.

6
getting_started/step_by_step/scripting_first_script.md
View File

@ -20,15 +20,15 @@ Creating your first script
In this lesson, you will code your first script to make the Godot icon turn in
circles using GDScript. As we mentioned `in the introduction
<toc-learn-introduction>`, we assume you have programming foundations.
<toc-learn-introduction )`, we assume you have programming foundations.
The equivalent C# code has been included in another tab for convenience.
![](img/scripting_first_script_rotating_godot.gif)
.. seealso:: To learn more about GDScript, its keywords, and its syntax, head to
the `GDScript reference<doc_gdscript>`.
the `GDScript reference<doc_gdscript )`.
.. seealso:: To learn more about C#, head to the `C# basics <doc_c_sharp>` page.
.. seealso:: To learn more about C#, head to the `C# basics <doc_c_sharp )` page.
Project setup
-------------

32
getting_started/step_by_step/scripting_languages.md
View File

@ -25,7 +25,7 @@ Available scripting languages
Godot offers **five gameplay programming languages**: GDScript, C#,
VisualScript, and, via its GDNative technology, C and C++. There are more
`community-supported languages <doc_what_is_gdnative_third_party_bindings>`,
`community-supported languages <doc_what_is_gdnative_third_party_bindings )`,
but these are the official ones.
You can use multiple languages in a single project. For instance, in a team, you
@ -39,12 +39,12 @@ developers.
.. warning::
`Godot 4.0 will remove VisualScript from core entirely. <https://godotengine.org/article/godot-4-will-discontinue-visual-scripting>`
`Godot 4.0 will remove VisualScript from core entirely. ( https://godotengine.org/article/godot-4-will-discontinue-visual-scripting )`
As a result, creating new projects using visual scripting in Godot is not recommended.
Future Godot 4.x releases may have VisualScript reimplemented as an extension.
While Godot 3.x will keep VisualScript supported, we recommend
`trying out GDScript <toc-learn-scripting-gdscript>` instead,
`trying out GDScript <toc-learn-scripting-gdscript )` instead,
especially if you intend to migrate your project to Godot 4.
Which language should I use?
@ -58,7 +58,7 @@ with Godot.
![](img/scripting_gdscript.png)
For C#, you will need an external code editor like
`VSCode <https://code.visualstudio.com/>`_ or Visual Studio. While C# support is
`VSCode ( https://code.visualstudio.com/ )`_ or Visual Studio. While C# support is
now mature, you will find fewer learning resources for it compared to
GDScript. That's why we recommend C# mainly to users who already have experience
with the language.
@ -68,9 +68,9 @@ Let's look at each language's features, as well as its pros and cons.
GDScript
~~~~~~~~
`GDScript<doc_gdscript>` is an
`object-oriented <https://en.wikipedia.org/wiki/Object-oriented_programming>`_ and
`imperative <https://en.wikipedia.org/wiki/Imperative_programming>`_
`GDScript<doc_gdscript )` is an
`object-oriented ( https://en.wikipedia.org/wiki/Object-oriented_programming )`_ and
`imperative ( https://en.wikipedia.org/wiki/Imperative_programming )`_
programming language built for Godot. It's made by and for game developers
to save you time coding games. Its features include:
@ -82,11 +82,11 @@ to save you time coding games. Its features include:
linear algebra, a must for games.
- Supports multiple threads as efficiently as statically typed languages.
- No `garbage collection
<https://en.wikipedia.org/wiki/Garbage_collection_(computer_science)>`_, as
( https://en.wikipedia.org/wiki/Garbage_collection_(computer_science) )`_, as
this feature eventually gets in the way when creating games. The engine counts
references and manages the memory for you in most cases by default, but you
can also control memory if you need to.
- `Gradual typing <https://en.wikipedia.org/wiki/Gradual_typing>`_. Variables
- `Gradual typing ( https://en.wikipedia.org/wiki/Gradual_typing )`_. Variables
have dynamic types by default, but you also can use type hints for strong type
checks.
@ -111,7 +111,7 @@ languages, including Squirrel, Lua, and Python.
~~~~~~~~~
As Microsoft's `C#
<https://en.wikipedia.org/wiki/C_Sharp_(programming_language)>`_ is a favorite
( https://en.wikipedia.org/wiki/C_Sharp_(programming_language) )`_ is a favorite
amongst game developers, we officially support it. C# is a mature and flexible
language with tons of libraries written for it. We could add support for it
thanks to a generous donation from Microsoft.
@ -123,9 +123,9 @@ should be aware of its garbage collector.
.. note:: You must use the Mono edition of the Godot editor to script in C#. You
can download it on the Godot website's `download
<https://godotengine.org/download/>`_ page.
( https://godotengine.org/download/ )`_ page.
Since Godot uses the `Mono <https://mono-project.com>`_ .NET runtime, in theory,
Since Godot uses the `Mono ( https://mono-project.com )`_ .NET runtime, in theory,
you can use any third-party .NET library or framework in Godot, as well as any
Common Language Infrastructure-compliant programming language, such as F#, Boo,
or ClojureCLR. However, C# is the only officially supported .NET option.
@ -141,15 +141,15 @@ VisualScript
.. warning::
`Godot 4.0 will remove VisualScript from core entirely. <https://godotengine.org/article/godot-4-will-discontinue-visual-scripting>`
`Godot 4.0 will remove VisualScript from core entirely. ( https://godotengine.org/article/godot-4-will-discontinue-visual-scripting )`
As a result, creating new projects using visual scripting in Godot is not recommended.
Future Godot 4.x releases may have VisualScript reimplemented as an extension.
While Godot 3.x will keep VisualScript supported, we recommend
`trying out GDScript <toc-learn-scripting-gdscript>` instead,
`trying out GDScript <toc-learn-scripting-gdscript )` instead,
especially if you intend to migrate your project to Godot 4.
`Visual Scripting<doc_what_is_visual_script>` is a graph-based visual
`Visual Scripting<doc_what_is_visual_script )` is a graph-based visual
programming language where you connect blocks. It can be a great tool for
non-programmers like game designers and artists.
@ -166,7 +166,7 @@ is slow compared to using other programming languages.
.. seealso::
For more information, see
`Getting started with VisualScript <doc_getting_started_visual_script>`.
`Getting started with VisualScript <doc_getting_started_visual_script )`.
C and C++ via GDNative
~~~~~~~~~~~~~~~~~~~~~~

4
getting_started/step_by_step/signals.md
View File

@ -18,7 +18,7 @@ connect to that signal and call a function when the event occurs.
Signals are a delegation mechanism built into Godot that allows one game object to
react to a change in another without them referencing one another. Using signals
limits `coupling
<https://en.wikipedia.org/wiki/Coupling_(computer_programming)>`_ and keeps your
( https://en.wikipedia.org/wiki/Coupling_(computer_programming) )`_ and keeps your
code flexible.
For example, you might have a life bar on the screen that represents the
@ -142,7 +142,7 @@ node's motion.
Our Sprite moves thanks to code in the `_process()` function. Godot provides a
method to toggle processing on and off: `Node.set_process()
<class_Node_method_set_process>`. Another method of the Node class,
<class_Node_method_set_process )`. Another method of the Node class,
`is_processing()`, returns `true` if idle processing is active. We can use
the `not` keyword to invert the value.

20
index.md
View File

@ -9,15 +9,15 @@ Godot Docs – *3.5* branch
.. tip:: This is the documentation for the 3.5 branch.
Looking for the documentation of the current **development** branch?
`Have a look here <https://docs.godotengine.org/en/latest>`_.
`Have a look here ( https://docs.godotengine.org/en/latest )`_.
You can also browse the documentation for the current stable
`3.4 <https://docs.godotengine.org/en/3.4>`_ branch.
`3.4 ( https://docs.godotengine.org/en/3.4 )`_ branch.
.. only:: i18n
.. note:: This documentation is translated from the `original English one
<https://docs.godotengine.org/en/latest>`_ by community members
on `Weblate <https://hosted.weblate.org/projects/godot-engine/godot-docs>`_.
( https://docs.godotengine.org/en/latest )`_ by community members
on `Weblate ( https://hosted.weblate.org/projects/godot-engine/godot-docs )`_.
Depending on the translation effort's completion level, you may
find paragraphs or whole pages which are still in English. You can
@ -28,17 +28,17 @@ Godot Docs – *3.5* branch
the "latest" (development) branch, but should be suitable to learn
how to use stable Godot releases nevertheless.
Welcome to the official documentation of `Godot Engine <https://godotengine.org>`,
Welcome to the official documentation of `Godot Engine ( https://godotengine.org )`,
the free and open source community-driven 2D and 3D game engine! If you are new
to this documentation, we recommend that you read the
`introduction page <doc_about_intro>` to get an overview of what this
`introduction page <doc_about_intro )` to get an overview of what this
documentation has to offer.
The table of contents below and in the sidebar should let you easily access the
documentation for your topic of interest. You can also use the search function
in the top left corner.
You can also `download an HTML copy <https://nightly.link/godotengine/godot-docs/workflows/build_offline_docs/master/godot-docs-html-stable.zip>`
You can also `download an HTML copy ( https://nightly.link/godotengine/godot-docs/workflows/build_offline_docs/master/godot-docs-html-stable.zip )`
for offline reading (updated every Monday). Extract the ZIP archive then open
the top-level `index.html` in a web browser.
@ -50,12 +50,12 @@ the top-level `index.html` in a web browser.
by letting us know!
Submit an issue or pull request on the `GitHub repository
<https://github.com/godotengine/godot-docs/issues>`_,
( https://github.com/godotengine/godot-docs/issues )`_,
help us `translate the documentation
<https://hosted.weblate.org/engage/godot-engine/>`_ into your
( https://hosted.weblate.org/engage/godot-engine/ )`_ into your
language, or talk to us on the
`#documentation` channel on the `Godot Contributors Chat
<https://chat.godotengine.org/>`_!
( https://chat.godotengine.org/ )`_!
.. centered:: |weblate_widget|

18
tutorials/2d/2d_lights_and_shadows.md
View File

@ -7,13 +7,13 @@ Introduction
------------
This tutorial explains how the 2D lighting works in the
`lights and shadows <https://github.com/godotengine/godot-demo-projects/tree/master/2d/lights_and_shadows>`_ demo project.
`lights and shadows ( https://github.com/godotengine/godot-demo-projects/tree/master/2d/lights_and_shadows )`_ demo project.
It begins with a brief description of the resources used in the final demo and then describes how
to make a scene like the demo step by step.
![](img/light_shadow_main.png)
All the resources for this tutorial can be found in the `official demo repository <https://github.com/godotengine/godot-demo-projects>`_
All the resources for this tutorial can be found in the `official demo repository ( https://github.com/godotengine/godot-demo-projects )`_
on GitHub. I suggest you download it before starting. Alternatively,
it can be downloaded from the Project Manager. Launch Godot and in the top
bar select "Templates" and search for "2D Lights and Shadows Demo".
@ -25,19 +25,19 @@ For this demo we use four textures: two for the lights, one for the shadow caste
and one for the background. I've included links to them all here if you want to download them
separately from the demo.
The first is the background image (`background.png) <https://raw.githubusercontent.com/godotengine/godot-demo-projects/master/2d/lights_and_shadows/background.png)>`_)
The first is the background image (`background.png) ( https://raw.githubusercontent.com/godotengine/godot-demo-projects/master/2d/lights_and_shadows/background.png) )`_)
used in the demo. You do not necessarily need a background, but we use one for the demo.
The second is a plain black image (`caster.png) <https://raw.githubusercontent.com/godotengine/godot-demo-projects/master/2d/lights_and_shadows/caster.png)>`_)
The second is a plain black image (`caster.png) ( https://raw.githubusercontent.com/godotengine/godot-demo-projects/master/2d/lights_and_shadows/caster.png) )`_)
to use as our shadow caster object. For a top down game this could be a wall or any
other object that casts a shadow.
Next is the light itself (`light.png) <https://raw.githubusercontent.com/godotengine/godot-demo-projects/master/2d/lights_and_shadows/light.png)>`_).
Next is the light itself (`light.png) ( https://raw.githubusercontent.com/godotengine/godot-demo-projects/master/2d/lights_and_shadows/light.png) )`_).
If you click the link you will notice how large it is. The image you use
for a light should cover the area you want your light to cover. This image is
1024x1024 pixels, so you should use it to cover 1024x1024 pixels in your game.
Lastly, we have the spotlight image (`spot.png) <https://raw.githubusercontent.com/godotengine/godot-demo-projects/master/2d/lights_and_shadows/spot.png)>`_).
Lastly, we have the spotlight image (`spot.png) ( https://raw.githubusercontent.com/godotengine/godot-demo-projects/master/2d/lights_and_shadows/spot.png) )`_).
The demo uses a blob to show where the light is and the larger light
image to show the effect of the light upon the rest of the scene.
@ -51,7 +51,7 @@ The demo uses four different nodes:
* `Light2D`
* `LightOccluder2D`
`CanvasModulate<class_CanvasModulate>` is used to darken the scene.
`CanvasModulate<class_CanvasModulate )` is used to darken the scene.
`Sprites` are used to display the textures for the light blobs, the
background, and for the shadow casters.
@ -150,7 +150,7 @@ This way we can show and hide them all at the same time.
Each shadow caster is made of a `Sprite`
child. For the demo the `Sprite` has a texture
set to the `caster image <https://raw.githubusercontent.com/godotengine/godot-demo-projects/master/2d/lights_and_shadows/caster.png)>`_ and nothing else. The child `LightOccluder2D` is where all the magic happens. In a
set to the `caster image ( https://raw.githubusercontent.com/godotengine/godot-demo-projects/master/2d/lights_and_shadows/caster.png) )`_ and nothing else. The child `LightOccluder2D` is where all the magic happens. In a
game the `Sprite` could be more than a black box; it could be an image of whatever object is casting
the shadow: a wall, a magical chest, or anything else.
@ -194,7 +194,7 @@ section set `Enable` to `on`. This turns on shadows with hard edges like in the
![](img/light_shadow_filter0_pcf0.png)
To give the shadows that nice, soft edge look we set the variables `filter`, `filter smooth`, and
`gradient length`. Godot supports `Percentage Closer Filtering <https://developer.nvidia.com/gpugems/GPUGems/gpugems_ch11.html>`_
`gradient length`. Godot supports `Percentage Closer Filtering ( https://developer.nvidia.com/gpugems/GPUGems/gpugems_ch11.html )`_
(PCF), which takes multiple samples of the shadow map around a pixel and blurs them to create
a smooth shadow effect. The higher the number of samples the smoother the shadow will
look, but the slower it will run. That is why Godot provides 3-13 samples by default and allows you to choose.

4
tutorials/2d/2d_movement.md
View File

@ -23,7 +23,7 @@ children: `Sprite` and `CollisionShape2D`. You can use the Godot icon ("icon.png
for the Sprite's texture or use any other 2D image you have.
Open `Project -> Project Settings` and select the "Input Map" tab. Add the following
input actions (see `InputEvent <doc_inputevent>` for details):
input actions (see `InputEvent <doc_inputevent )` for details):
![](img/movement_inputs.png)
@ -218,4 +218,4 @@ You may find these code samples useful as starting points for your own projects.
Feel free to use them and experiment with them to see what you can make.
You can download this sample project here:
:download:`2D_movement_demo.zip <files/2D_movement_demo.zip>`
:download:`2D_movement_demo.zip <files/2D_movement_demo.zip )`

6
tutorials/2d/2d_sprite_animation.md
View File

@ -29,7 +29,7 @@ animation:
![](img/2d_animation_run_preview.gif)
You can download the images here:
:download:`run_animation.zip <files/run_animation.zip>`
:download:`run_animation.zip <files/run_animation.zip )`
Unzip the images and place them in your project folder. Set up your scene tree
with the following nodes:
@ -40,7 +40,7 @@ with the following nodes:
`RigidBody2D`. The animation will still be
made in the same way. Once the animation is completed, you can
assign a shape to the CollisionShape2D. See
`Physics Introduction <doc_physics_introduction>` for more
`Physics Introduction <doc_physics_introduction )` for more
information.
Now select the `AnimatedSprite` and in its *SpriteFrames* property, select
@ -147,7 +147,7 @@ setting up your scene tree:
`RigidBody2D`. The animation will still be
made in the same way. Once the animation is completed, you can
assign a shape to the CollisionShape2D. See
`Physics Introduction <doc_physics_introduction>` for more
`Physics Introduction <doc_physics_introduction )` for more
information.
Drag the spritesheet into the Sprite's *Texture* property, and you'll see the

2
tutorials/2d/2d_transforms.md
View File

@ -21,7 +21,7 @@ can be accessed as a `Transform2D`.
Also covered in the previous tutorial, nodes are drawn by default in Layer 0,
in the built-in canvas. To put nodes in a different layer, a `CanvasLayer
<class_CanvasLayer>` node can be used.
<class_CanvasLayer )` node can be used.
Global canvas transform
-----------------------

6
tutorials/2d/custom_drawing_in_2d.md
View File

@ -308,14 +308,14 @@ Let's run again! This time, the rotation displays fine!
Antialiased drawing
^^^^^^^^^^^^^^^^^^^
Godot offers method parameters in `draw_line<class_CanvasItem_method_draw_line>`
Godot offers method parameters in `draw_line<class_CanvasItem_method_draw_line )`
to enable antialiasing, but it doesn't work reliably in all situations
(for instance, on mobile/web platforms, or when HDR is enabled).
There is also no `antialiased` parameter available in
`draw_polygon<class_CanvasItem_method_draw_polygon>`.
`draw_polygon<class_CanvasItem_method_draw_polygon )`.
As a workaround, install and use the
`Antialiased Line2D add-on <https://github.com/godot-extended-libraries/godot-antialiased-line2d>`
`Antialiased Line2D add-on ( https://github.com/godot-extended-libraries/godot-antialiased-line2d )`
(which also supports antialiased Polygon2D drawing). Note that this add-on relies
on high-level nodes, rather than low-level `_draw()` functions.

2
tutorials/2d/using_tilemaps.md
View File

@ -21,7 +21,7 @@ Project setup
-------------
This demo will use the following tiles taken from Kenney's "Abstract Platformer"
art pack. You can find the complete set `here <https://kenney.nl/assets/abstract-platformer>`_
art pack. You can find the complete set `here ( https://kenney.nl/assets/abstract-platformer )`_
but for this demo we'll stick to this small set.
![](img/tilesheet.png)

6
tutorials/3d/3d_rendering_limitations.md
View File

@ -21,7 +21,7 @@ Texture size limits
On desktops and laptops, textures larger than 8192×8192 may not be supported on
older devices. You can check your target GPU's limitations on
`GPUinfo.org <https://www.gpuinfo.org/>`.
`GPUinfo.org ( https://www.gpuinfo.org/ )`.
Mobile GPUs are typically limited to 4096×4096 textures. Also, some mobile GPUs
don't support repeating non-power-of-two-sized textures. Therefore, if you want
@ -46,13 +46,13 @@ There are two main ways to alleviate banding:
It also requires HDR to be enabled in the Project Settings (which is the default).
- Alternatively, bake some noise into your textures. This is mainly effective in 2D,
e.g. for vignetting effects. In 3D, you can also use a
`custom debanding shader <https://github.com/fractilegames/godot-gles2-debanding-material>`
`custom debanding shader ( https://github.com/fractilegames/godot-gles2-debanding-material )`
to be applied on your *materials*. This technique works even if your project is
rendered in LDR, which means it will work when using the GLES2 renderer.
.. seealso::
See `Banding in Games: A Noisy Rant <http://loopit.dk/banding_in_games.pdf>`
See `Banding in Games: A Noisy Rant ( http://loopit.dk/banding_in_games.pdf )`
for more details about banding and ways to combat it.
Depth buffer precision

4
tutorials/3d/3d_text.md
View File

@ -12,7 +12,7 @@ methods to do this. The Label3D node and the text mesh for a
MeshInstance node.
This page does **not** cover how to display a GUI scene in a 3D
environment. For information on how to do that see `this <https://github.com/godotengine/godot-demo-projects/tree/master/viewport/2d_in_3d>`
environment. For information on how to do that see `this ( https://github.com/godotengine/godot-demo-projects/tree/master/viewport/2d_in_3d )`
demo project.
Label3D
@ -30,7 +30,7 @@ up and shaded by light sources if the shaded flag is enabled, but it
will not cast a shadow, even with cast shadow turned on under the nodes
GeometryInstance3D settings. This is because the node is a quad mesh
(one glyph per quad) with transparent textures and has the same limitations
as Sprite3D. See `this page <doc_3d_rendering_limitations_transparency_sorting>`
as Sprite3D. See `this page <doc_3d_rendering_limitations_transparency_sorting )`
for more information.
Text mesh

2
tutorials/3d/baked_lightmaps.md
View File

@ -333,7 +333,7 @@ Capture
- **Quality:** The lightmap probe generation quality. Higher values result in
more accurate lighting, but take longer to bake. This setting does not affect
the *density* of the lightmap probes, only their quality.
- **Propagation:** Similar to `GIProbe <doc_gi_probes>`'s Propagation property.
- **Propagation:** Similar to `GIProbe <doc_gi_probes )`'s Propagation property.
Higher values result in brighter and more diffuse indirect lighting for
dynamic objects. Adjust this value depending on your scene to make dynamic
objects better fit with static baked lighting.

8
tutorials/3d/csg_tools.md
View File

@ -16,9 +16,9 @@ Interior environments can be created by using inverted primitives.
extruded 2D polygons can be used with the CSGPolygon node).
If you're looking for an easy to use level design tool for a project,
you may want to use `Qodot <https://github.com/Shfty/qodot-plugin>`
you may want to use `Qodot ( https://github.com/Shfty/qodot-plugin )`
instead. It lets you design levels using
`TrenchBroom <https://kristianduske.com/trenchbroom/>` and import
`TrenchBroom ( https://kristianduske.com/trenchbroom/ )` and import
them in Godot.
![](img/csg.gif)
@ -204,7 +204,7 @@ another CSGCylinder and adjust the dimensions to use it as a pole.
![](img/csg_lamp_pole_stand.png)
We will use a CSGPolygon for the lampshade. Use the **Spin** mode for the
CSGPolygon and draw a `trapezoid <https://en.wikipedia.org/wiki/Trapezoid>`_
CSGPolygon and draw a `trapezoid ( https://en.wikipedia.org/wiki/Trapezoid )`_
while in **Front View** (numeric keypad 1); this shape will extrude around the
origin and form the lampshade.
@ -257,7 +257,7 @@ usage to organic surfaces like terrain. Still, when prototyping, it can be used
to quickly apply textures to CSG-based levels.
.. note:: If you need some textures for prototyping, Kenney made a
`set of CC0-licensed prototype textures <https://kenney.nl/assets/prototype-textures>`.
`set of CC0-licensed prototype textures ( https://kenney.nl/assets/prototype-textures )`.
There are two ways to apply a material to a CSG node:

2
tutorials/3d/introduction_to_3d.md
View File

@ -125,7 +125,7 @@ similar to other tools in the Editor Settings:
Coordinate system
-----------------
Godot uses the `metric <https://en.wikipedia.org/wiki/Metric_system>`
Godot uses the `metric ( https://en.wikipedia.org/wiki/Metric_system )`
system for everything in 3D, with 1 unit being equal to 1 meter.
Physics and other areas are tuned for this scale. Therefore, attempting to use a
different scale is usually a bad idea (unless you know what you are doing).

10
tutorials/3d/portals/advanced_room_and_portal_usage.md
View File

@ -17,7 +17,7 @@ This works because if a monster is in an area that is completely out of view for
How does a monster know whether it is within the gameplay area?
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
This problem is solved because the portal system contains a subsystem called the **Gameplay Monitor** that can be turned on and off from the `RoomManager<class_RoomManager>`. When switched on, any roaming objects that move inside or outside the gameplay area (whether by moving themselves, or the camera moving) will receive callbacks to let them know of this change.
This problem is solved because the portal system contains a subsystem called the **Gameplay Monitor** that can be turned on and off from the `RoomManager<class_RoomManager )`. When switched on, any roaming objects that move inside or outside the gameplay area (whether by moving themselves, or the camera moving) will receive callbacks to let them know of this change.
You can choose to either receive these callbacks as `signals`, or as `notifications`.
@ -41,7 +41,7 @@ VisbilityNotifiers / VisibilityEnablers
Gameplay callbacks have one more useful function. By default in Godot, animation and physics are still processed regardless of whether an object is within view. This can sap performance, especially when using software skinning.
The engine's solution to this problem is the `VisibilityNotifier<class_VisibilityNotifier>` node, and its slightly easier to use variation, the `VisibilityEnabler<class_VisibilityEnabler>` node. VisibilityEnabler can be used to switch off animation and sleep physics when an object is outside the view frustum. You do this by simply placing a VisibilityEnabler node in your subscene (for e.g. a monster). It will do the rest. Consult the `VisibilityEnabler<class_VisibilityEnabler>` documentation for full details.
The engine's solution to this problem is the `VisibilityNotifier<class_VisibilityNotifier )` node, and its slightly easier to use variation, the `VisibilityEnabler<class_VisibilityEnabler )` node. VisibilityEnabler can be used to switch off animation and sleep physics when an object is outside the view frustum. You do this by simply placing a VisibilityEnabler node in your subscene (for e.g. a monster). It will do the rest. Consult the `VisibilityEnabler<class_VisibilityEnabler )` documentation for full details.
![](img/visibility_enabler.png)
@ -52,11 +52,11 @@ What if the VisibilityEnabler could turn off objects when they were occlusion cu
RoomGroups
~~~~~~~~~~
A `RoomGroup<class_RoomGroup>` is a special node which allows you to deal with a group of rooms at once, instead of having write code for them individually. This is especially useful in conjunction with gameplay callbacks. The most important use for RoomGroups is to delineate between "inside" and "outside" areas.
A `RoomGroup<class_RoomGroup )` is a special node which allows you to deal with a group of rooms at once, instead of having write code for them individually. This is especially useful in conjunction with gameplay callbacks. The most important use for RoomGroups is to delineate between "inside" and "outside" areas.
![](img/roomgroups.png)
For instance, when outside you may wish to use a `DirectionalLight<class_DirectionalLight>` to represent the sun. When the outside RoomGroup receives an `enter gameplay` callback, you can turn the light on, and you can turn it off when the RoomGroup exits gameplay. With the light off, performance will increase as there is no need to render it indoors.
For instance, when outside you may wish to use a `DirectionalLight<class_DirectionalLight )` to represent the sun. When the outside RoomGroup receives an `enter gameplay` callback, you can turn the light on, and you can turn it off when the RoomGroup exits gameplay. With the light off, performance will increase as there is no need to render it indoors.
This is an example of a simple RoomGroup script to turn on and off a DirectionalLight. Note that you can also use signals for callbacks (the choice is up to you):
@ -103,7 +103,7 @@ The tent is a simple room inside a terrain room (which contains the ground, the
This is perfect for improving performance in open world games. Often your buildings can be scenes (including the rooms and portals) that can be reused. When viewed from the outside, interiors will mostly be culled, and when viewing from the inside other buildings and most of the outside will be culled. The same goes for other players and objects that are inside and outside the buildings.
*Scene is 'Diorama Eco scene' by Odo, with slight changes for illustration purposes.* `CC Attribution <https://creativecommons.org/licenses/by/4.0/>`_
*Scene is 'Diorama Eco scene' by Odo, with slight changes for illustration purposes.* `CC Attribution ( https://creativecommons.org/licenses/by/4.0/ )`_
Internal room scenes
^^^^^^^^^^^^^^^^^^^^

14
tutorials/3d/portals/editing_rooms_and_portals.md
View File

@ -8,9 +8,9 @@ Putting all the ideas together, here is an example scene tree:
![](img/example_scenetree.png)
- We have used a `RoomGroup<class_RoomGroup>` to denote an outside area.
- The `MeshInstance<class_MeshInstance>`\ s inside the `Room<class_Room>`\ s are either `STATIC` or `DYNAMIC`.
- We have created a `Spatial<class_Spatial>` (I decided to call it 'Freeform', but you could use any name) under which to place `STATIC` and `DYNAMIC` objects that will be autoplaced in rooms
- We have used a `RoomGroup<class_RoomGroup )` to denote an outside area.
- The `MeshInstance<class_MeshInstance )`\ s inside the `Room<class_Room )`\ s are either `STATIC` or `DYNAMIC`.
- We have created a `Spatial<class_Spatial )` (I decided to call it 'Freeform', but you could use any name) under which to place `STATIC` and `DYNAMIC` objects that will be autoplaced in rooms
(Freeform is inside the `roomlist`, but *not* inside a room.)
- The player and the monsters are on branches *OUTSIDE* the `roomlist`.
- The player and monster meshes have portal mode `ROAMING` so they can be in any room.
@ -26,9 +26,9 @@ Although you can create your room system entirely within the editor, you can als
Postfix convention
^^^^^^^^^^^^^^^^^^
- `-room` becomes a `Room<class_Room>`.
- `-roomgroup` becomes a `RoomGroup<class_RoomGroup>`.
- `-portal` becomes a `Portal<class_Portal>`.
- `-room` becomes a `Room<class_Room )`.
- `-roomgroup` becomes a `RoomGroup<class_RoomGroup )`.
- `-portal` becomes a `Portal<class_Portal )`.
- `-bound` becomes a manual bound.
Rooms and RoomGroups should be created as Empties within Blender. Any mesh children of the `-room` Empty will thus be placed in the Room during conversion in Godot.
@ -44,7 +44,7 @@ Portals
Portals are different from Rooms. In Portals, we need to specify the geometry of the Portal in our modelling tool, in addition to just the name. To do this your "portal-to-be" should be created as a Mesh.
Portal meshes have some restrictions to work properly. They must be convex, and the polygon points should be in the same plane. The accuracy to the plane does not have to be exact, as Godot will automatically average the direction of the portal plane. Once converted to a `Portal<class_Portal>` node, the snapping to the portal plane is enforced, and the vertices are specified (and editable) as 2D coordinates in the inspector, rather than 3D points.
Portal meshes have some restrictions to work properly. They must be convex, and the polygon points should be in the same plane. The accuracy to the plane does not have to be exact, as Godot will automatically average the direction of the portal plane. Once converted to a `Portal<class_Portal )` node, the snapping to the portal plane is enforced, and the vertices are specified (and editable) as 2D coordinates in the inspector, rather than 3D points.
The portal's naming is quite important. You can either name the portal `-portal` which will attempt to autolink the Portal in Godot, or you can use the name of the Room you wish to link the Portal to as a prefix.

10
tutorials/3d/portals/first_steps_with_rooms_and_portals.md
View File

@ -4,7 +4,7 @@ First steps with Rooms and Portals
The RoomManager
~~~~~~~~~~~~~~~
Anytime you want to use the portal system, you need to include a special node in your scene tree, called the `RoomManager<class_RoomManager>`. The RoomManager is responsible for the runtime maintenance of the system, especially converting the objects in your rooms into a *room graph* which is used at runtime to perform occlusion culling and other tasks.
Anytime you want to use the portal system, you need to include a special node in your scene tree, called the `RoomManager<class_RoomManager )`. The RoomManager is responsible for the runtime maintenance of the system, especially converting the objects in your rooms into a *room graph* which is used at runtime to perform occlusion culling and other tasks.
Room Conversion
^^^^^^^^^^^^^^^
@ -40,7 +40,7 @@ Rooms
What is a room?
^^^^^^^^^^^^^^^
`Room<class_Room>`\ s are a way of spatially partitioning your level into areas that make sense in terms of level design. Rooms often quite literally *are* rooms (like in a building). Ultimately though, as far as the engine is concerned, a room represents a **non-overlapping** convex volume in which you typically place most of your objects that fall within that area.
`Room<class_Room )`\ s are a way of spatially partitioning your level into areas that make sense in terms of level design. Rooms often quite literally *are* rooms (like in a building). Ultimately though, as far as the engine is concerned, a room represents a **non-overlapping** convex volume in which you typically place most of your objects that fall within that area.
A room doesn't need to correspond to a literal room. It could, for example, also be a canyon in an outdoor area or a smaller part of a concave room. With a little imagination, you can use the system in almost any scenario.
@ -64,12 +64,12 @@ If you accidentally create overlapping rooms, the editor will warn you when you
The system does attempt to cope with overlapping rooms as best as possible by making the current room *"sticky"*. Each object remembers which room it was in during the previous frame and stays within it as long as it does not move outside the convex hull room bound. This can result in some hysteresis in these overlapping zones.
There is one exception, however, for `internal rooms<doc_rooms_and_portals_internal_rooms>`. You do not have to worry about these to start with.
There is one exception, however, for `internal rooms<doc_rooms_and_portals_internal_rooms )`. You do not have to worry about these to start with.
How do I create a room?
^^^^^^^^^^^^^^^^^^^^^^^
A `Room<class_Room>` is a node type that can be added to the scene tree like any other. You can place objects within the room by making them children and grand-children of the Room node.
A `Room<class_Room )` is a node type that can be added to the scene tree like any other. You can place objects within the room by making them children and grand-children of the Room node.
How do I define the shape and position of my room convex hull?
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -93,7 +93,7 @@ Portals
If you create some rooms, place objects within them, then convert the level in the editor, you will see the objects in the rooms appearing and showing as you move between rooms. There is one problem, however! Although you can see the objects within the room that the camera is in, you can't see to any neighbouring rooms! For that we need portals.
`Portal<class_Portal>`\ s are special convex polygons that you position over the openings between rooms in order to allow the system to see between them. You can create a portal node directly in the editor. The default portal has 4 points and behaves much like a `plane` `MeshInstance<class_MeshInstance>`. You can add or remove points using the inspector. A portal requires at least 3 points to work - this is because it needs to form a polygon rather than a point or line.
`Portal<class_Portal )`\ s are special convex polygons that you position over the openings between rooms in order to allow the system to see between them. You can create a portal node directly in the editor. The default portal has 4 points and behaves much like a `plane` `MeshInstance<class_MeshInstance )`. You can add or remove points using the inspector. A portal requires at least 3 points to work - this is because it needs to form a polygon rather than a point or line.
To save editing effort, **only one Portal is required between each pair of Rooms**. You *do not need* to (and indeed should not) create two Portals that overlap in opposite directions. Portals default to being two-way, but you can make them one-way in the Portal inspector.

4
tutorials/3d/portals/introduction_to_rooms_and_portals.md
View File

@ -3,7 +3,7 @@
Introduction to Rooms and Portals
=================================
The rooms and portals system is an optional component of Godot that allows you to partition your 3D game levels into a series of `Room<class_Room>` s (*aka cells*), and `Portal<class_Portal>` s. Portals are openings between the rooms that the `Camera<class_Camera>` (and lights) can see through.
The rooms and portals system is an optional component of Godot that allows you to partition your 3D game levels into a series of `Room<class_Room )` s (*aka cells*), and `Portal<class_Portal )` s. Portals are openings between the rooms that the `Camera<class_Camera )` (and lights) can see through.
This allows several features:
@ -13,7 +13,7 @@ This allows several features:
The trade off for these features is that we have to manually partition our level into rooms, and add portals between them.
.. note:: Godot portals should not be confused with those in the `game of the same name <https://en.wikipedia.org/wiki/Portal_(video_game)>`. They do not warp space, they simply represent a window that the camera (or lights) can see through.
.. note:: Godot portals should not be confused with those in the `game of the same name ( https://en.wikipedia.org/wiki/Portal_(video_game) )`. They do not warp space, they simply represent a window that the camera (or lights) can see through.
Minimizing manual labour
^^^^^^^^^^^^^^^^^^^^^^^^

14
tutorials/3d/portals/rooms_and_portals_example.md
View File

@ -2,7 +2,7 @@ Rooms and Portals example
=========================
Download this tutorial project:
`Simple Portals Example <https://github.com/lawnjelly/godot-demo-projects/tree/portals_simple_demo/3d/portals/room_and_portals_simple_example>`_
`Simple Portals Example ( https://github.com/lawnjelly/godot-demo-projects/tree/portals_simple_demo/3d/portals/room_and_portals_simple_example )`_
.
Introduction
@ -16,13 +16,13 @@ Step 1
![](tutorial_simple/img/tutorial_simple_1.png)
- Create a new project.
- Add a `Spatial<class_Spatial>` as the scene root (on the screenshot, it's called "Root").
- Next add a `RoomManager<class_RoomManager>` node. We will need this later to process the room system.
- Add a `Spatial<class_Spatial )` as the scene root (on the screenshot, it's called "Root").
- Next add a `RoomManager<class_RoomManager )` node. We will need this later to process the room system.
- Next we need to start defining our rooms. We create all our rooms under another Spatial we have called 'RoomList'.
- Add a new `Room<class_Room>` node as a child of the roomlist.
- Add a new `Room<class_Room )` node as a child of the roomlist.
- We have named the room `Kitchen`.
- We will now create the geometry of our room. The names you give to the geometry is up to you.
- Create a `MeshInstance<class_MeshInstance>` for the floor. Create a box by adding a CubeMesh resource to the MeshInstance. Scale and position it to form a floor.
- Create a `MeshInstance<class_MeshInstance )` for the floor. Create a box by adding a CubeMesh resource to the MeshInstance. Scale and position it to form a floor.
- Create MeshInstances for the walls. Create more box meshes for this, then scale and position them. Be sure to leave an opening on one side. You will need to create two wall segments to do this on that side.
Step 2
@ -41,7 +41,7 @@ Step 3
![](tutorial_simple/img/tutorial_simple_3.png)
- Next, we will add a portal between the two rooms.
- Create a new `Portal<class_Portal>` in the kitchen.
- Create a new `Portal<class_Portal )` in the kitchen.
- Scale and position the portal using the node `Transform` in the inspector, so it fits within the opening between the two rooms.
- The portal plane should face *outward* from the source room, i.e. towards the lounge. This direction is indicated by the arrow in the editor gizmo, and portal gizmo's color.
@ -54,7 +54,7 @@ Step 4
- Placing these boxes as children or grandchildren of the room nodes explicitly tells the system which room the objects should be in. However, we can also create these objects *outside* the rooms. Provided they are in the RoomList branch, the system will attempt to automatically place them in the correct room at runtime.
- On the screenshot, the boxes were places as children of a Spatial I have called `Freeform` to keep things tidy.
- Boxes also have a green SpatialMaterial assigned to them to make them stand out more from the rest of the room.
- Let's also create an `OmniLight<class_OmniLight>` so it will be autoplaced in one of the rooms.
- Let's also create an `OmniLight<class_OmniLight )` so it will be autoplaced in one of the rooms.
Step 5
~~~~~~

6
tutorials/3d/portals/using_objects_in_rooms_and_portals.md
View File

@ -1,12 +1,12 @@
Using objects in Rooms and Portals
==================================
Normally, when you use Godot, all objects that you can see (`VisualInstance<class_VisualInstance>`\ s) are treated in the same way by the engine. The portal renderer is slightly different, in that it makes a distinction between the different roles objects will have in your game. It makes this distinction to define the `Room<class_Room>`\ s, and to render and process everything in the most efficient way.
Normally, when you use Godot, all objects that you can see (`VisualInstance<class_VisualInstance )`\ s) are treated in the same way by the engine. The portal renderer is slightly different, in that it makes a distinction between the different roles objects will have in your game. It makes this distinction to define the `Room<class_Room )`\ s, and to render and process everything in the most efficient way.
Portal mode
~~~~~~~~~~~
If you look in the inspector, every VisualInstance in Godot is derived from a `CullInstance<class_CullInstance>`, where you can set a `PortalMode`. This determines how objects will behave in the portal system.
If you look in the inspector, every VisualInstance in Godot is derived from a `CullInstance<class_CullInstance )`, where you can set a `PortalMode`. This determines how objects will behave in the portal system.
![](img/cull_instance.png)
@ -90,6 +90,6 @@ While sprawling works great for large moving objects, it also gives you a lot mo
Lighting
~~~~~~~~
In general lights are handled like any other visual instance. They can be placed in rooms, and they will sprawl to affect neighbouring rooms, following the dimensions and direction of the light. The exception to this is `DirectionalLight<class_DirectionalLight>`\ s. DirectionalLights have no source room as they affect *everywhere*. They should therefore not be placed in a room. As DirectionalLights can be expensive, it is a good idea to turn them off when inside, see the later `doc_rooms_and_portals_roomgroups` section for details on how to do this.
In general lights are handled like any other visual instance. They can be placed in rooms, and they will sprawl to affect neighbouring rooms, following the dimensions and direction of the light. The exception to this is `DirectionalLight<class_DirectionalLight )`\ s. DirectionalLights have no source room as they affect *everywhere*. They should therefore not be placed in a room. As DirectionalLights can be expensive, it is a good idea to turn them off when inside, see the later `doc_rooms_and_portals_roomgroups` section for details on how to do this.
Congratulations! You have now mastered the intermediate techniques required to use rooms and portals. You can use these to make games already, but there are many more features.

4
tutorials/3d/procedural_geometry/arraymesh.md
View File

@ -10,14 +10,14 @@ which takes up to four parameters. The first two are required, while the second
The first parameter is the `PrimitiveType`, an OpenGL concept that instructs the GPU
how to arrange the primitive based on the vertices given, i.e. whether they represent triangles,
lines, points, etc. See `Mesh.PrimitiveType <enum_Mesh_PrimitiveType>` for the options available.
lines, points, etc. See `Mesh.PrimitiveType <enum_Mesh_PrimitiveType )` for the options available.
The second parameter, `arrays`, is the actual Array that stores the mesh information. The array is a
normal Godot array that is constructed with empty brackets `[]`. It stores a `Pool**Array`
(e.g. PoolVector3Array, PoolIntArray, etc.) for each type of information that will be used to build the surface.
The possible elements of `arrays` are listed below, together with the position they must have within `arrays`.
See also `Mesh.ArrayType <enum_Mesh_ArrayType>`.
See also `Mesh.ArrayType <enum_Mesh_ArrayType )`.
.. list-table::

10
tutorials/3d/procedural_geometry/index.md
View File

@ -62,7 +62,7 @@ Surface array
The surface array is an array of length `ArrayMesh.ARRAY_MAX`. Each position in the array is
filled with a sub-array containing per-vertex information. For example, the array located at
`ArrayMesh.ARRAY_NORMAL` is a `PoolVector3Array` of vertex normals.
See `Mesh.ArrayType <enum_Mesh_ArrayType>` for more information.
See `Mesh.ArrayType <enum_Mesh_ArrayType )` for more information.
The surface array can be indexed or non-indexed. Creating a non-indexed array is as easy as not assigning
an array at the index `ArrayMesh.ARRAY_INDEX`. A non-indexed array stores unique vertex information for
@ -84,7 +84,7 @@ ArrayMesh
The ArrayMesh resource extends Mesh to add a few different quality of life functions and, most
importantly, the ability to construct a Mesh surface through scripting.
For more information about the ArrayMesh, please see the `ArrayMesh tutorial <doc_arraymesh>`.
For more information about the ArrayMesh, please see the `ArrayMesh tutorial <doc_arraymesh )`.
MeshDataTool
^^^^^^^^^^^^
@ -92,14 +92,14 @@ MeshDataTool
The MeshDataTool is a resource that converts Mesh data into arrays of vertices, faces, and edges that can
be modified at runtime.
For more information about the MeshDataTool, please see the `MeshDataTool tutorial <doc_meshdatatool>`.
For more information about the MeshDataTool, please see the `MeshDataTool tutorial <doc_meshdatatool )`.
SurfaceTool
^^^^^^^^^^^
The SurfaceTool allows the creation of Meshes using an OpenGL 1.x immediate mode style interface.
For more information about the SurfaceTool, please see the `SurfaceTool tutorial <doc_surfacetool>`.
For more information about the SurfaceTool, please see the `SurfaceTool tutorial <doc_surfacetool )`.
ImmediateGeometry
^^^^^^^^^^^^^^^^^
@ -113,7 +113,7 @@ ImmediateGeometry is useful for prototyping because of its straightforward API,
is rebuilt every frame. It is most useful for adding simple geometry for visual debugging (e.g. by drawing lines to
visualize physics raycasts etc.).
For more information about ImmediateGeometry, please see the `ImmediateGeometry tutorial <doc_immediategeometry>`.
For more information about ImmediateGeometry, please see the `ImmediateGeometry tutorial <doc_immediategeometry )`.
Which one should I use?
-----------------------

4
tutorials/3d/procedural_geometry/meshdatatool.md
View File

@ -16,7 +16,7 @@ for certain mesh algorithms. If you do not need this extra information then it m
We initialize the MeshDataTool from an ArrayMesh by calling `create_from_surface()`. If there is already data initialized in the MeshDataTool,
calling `create_from_surface()` will clear it for you. Alternatively, you can call `clear()` yourself before re-using the MeshDataTool.
In the examples below, assume an ArrayMesh called `mesh` has already been created. See `ArrayMesh tutorial <doc_arraymesh>` for an example of mesh generation.
In the examples below, assume an ArrayMesh called `mesh` has already been created. See `ArrayMesh tutorial <doc_arraymesh )` for an example of mesh generation.
gdscript GDScript
@ -71,7 +71,7 @@ gdscript GDScript
```
Below is a complete example that turns a spherical mesh called `mesh` into a randomly deformed blob complete with updated normals and vertex colors.
See `ArrayMesh tutorial <doc_arraymesh>` for how to generate the base mesh.
See `ArrayMesh tutorial <doc_arraymesh )` for how to generate the base mesh.
gdscript GDScript

Some files were not shown because too many files have changed in this diff Show More