Relintai/pandemonium_engine_docs
1
0
Fork 0
mirror of https://github.com/Relintai/pandemonium_engine_docs.git synced 2025-01-21 15:07:22 +01:00
Code Issues Packages Projects Releases Wiki Activity

More cleanups.

Browse Source
This commit is contained in:
Relintai 2023-01-12 20:35:17 +01:00
parent 2ef52a1698
commit a0b7fdc7eb
102 changed files with 322 additions and 322 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
about/faq.md
View File

@ -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:
@ -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:
@ -232,7 +232,7 @@ Linux
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.
@ -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:

12
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
@ -381,7 +381,7 @@ 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.
@ -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
@ -628,7 +628,7 @@ Miscellaneous
- `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
@ -648,6 +648,6 @@ Miscellaneous
.. 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.

10
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.
@ -86,7 +86,7 @@ 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>`.

12
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).
@ -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.
@ -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>`.

6
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.
@ -67,7 +67,7 @@ The following labels are currently defined in the Godot repository:
- *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/>`_.
- *Good first issue*: the issue is *assumed* to be an easy one to fix, which makes
@ -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

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

2
community/contributing/class_reference_writing_guidelines.md
View File

@ -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/>`_.

26
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.)
@ -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
-------------------

10
community/contributing/contributing_to_the_documentation.md
View File

@ -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
@ -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
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

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.

2
community/contributing/docs_writing_guidelines.md
View File

@ -530,7 +530,7 @@ 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
compression.

24
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
@ -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.
@ -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:
@ -361,11 +361,11 @@ can use the downloaded PO file and `compile Godot from source <toc-devel-compili
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
-------------------------------

2
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
---------------

2
community/contributing/pr_workflow.md
View File

@ -46,7 +46,7 @@ which quickly leads to PRs with an unreadable Git history (especially after peer
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/>`__.
You can also try out `GitHub's interactive guide <https://try.github.io/>`.
The branches on the Git repository are organized as follows:

10
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.
@ -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:

12
community/tutorials.md
View File

@ -31,12 +31,12 @@ Video tutorials
- `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).
- `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).
- `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).
@ -49,10 +49,10 @@ Video tutorials
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
-------

4
development/compiling/compiling_for_osx.md
View File

@ -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.

6
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`.

4
development/compiling/compiling_for_windows.md
View File

@ -18,7 +18,7 @@ For compiling under Windows, the following is required:
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/>`_.
**Make sure to enable the option to add Python to the `PATH` in the installer.**
@ -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:

4
development/compiling/compiling_for_x11.md
View File

@ -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.

2
development/compiling/compiling_with_script_encryption_key.md
View File

@ -27,7 +27,7 @@ Step by step
`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.

6
development/compiling/getting_source.md
View File

@ -10,7 +10,7 @@ Downloading the Godot source code
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.
@ -18,7 +18,7 @@ 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>`.
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.

10
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
@ -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
@ -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

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>`.

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

@ -25,4 +25,4 @@ Importing the project
- 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>`.

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

@ -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`.

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

@ -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>`.

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

@ -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>`.

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

@ -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>`.

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

@ -3,7 +3,7 @@
Visual Studio
=============
`Visual Studio Community <https://visualstudio.microsoft.com>`__ is a Windows-only IDE
`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.
@ -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>`.

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

@ -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>`.

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

@ -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>`

14
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?
---------
@ -316,7 +316,7 @@ References
~~~~~~~~~~~
- `RID<class_rid>`
- `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>`
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.

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>`

6
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.

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>`

8
development/editor/creating_icons.md
View File

@ -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
@ -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>`

16
development/editor/introduction_to_editor_development.md
View File

@ -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
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,7 +77,7 @@ 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
----------------

2
getting_started/first_2d_game/index.md
View File

@ -49,7 +49,7 @@ This step-by-step tutorial is intended for beginners who followed the complete
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.

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

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

4
getting_started/introduction/godot_design_philosophy.md
View File

@ -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,7 +111,7 @@ 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.

4
getting_started/step_by_step/scripting_languages.md
View File

@ -39,7 +39,7 @@ 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.
@ -141,7 +141,7 @@ 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.

4
index.md
View File

@ -28,7 +28,7 @@ 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
@ -38,7 +38,7 @@ 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.

2
tutorials/2d/custom_drawing_in_2d.md
View File

@ -315,7 +315,7 @@ There is also no `antialiased` parameter available in
`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.

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

2
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

6
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)
@ -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).

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

@ -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
^^^^^^^^^^^^^^^^^^^^^^^^

2
tutorials/3d/spatial_material.md
View File

@ -385,7 +385,7 @@ and wider compatibility.
More information about normal maps (including a coordinate order table for
popular engines) can be found
`here <http://wiki.polycount.com/wiki/Normal_Map_Technical_Details>`__.
`here <http://wiki.polycount.com/wiki/Normal_Map_Technical_Details>`.
Rim
~~~

14
tutorials/animation/cutout_animation.md
View File

@ -6,8 +6,8 @@ Cutout animation
What is it?
~~~~~~~~~~~
Traditionally, `cutout animation <https://en.wikipedia.org/wiki/Cutout_animation>`__
is a type of `stop motion animation <https://en.wikipedia.org/wiki/Stop_motion>`__
Traditionally, `cutout animation <https://en.wikipedia.org/wiki/Cutout_animation>`
is a type of `stop motion animation <https://en.wikipedia.org/wiki/Stop_motion>`
in which pieces of paper (or other thin material) are cut into special shapes
and arranged in two-dimensional representations of characters and objects.
Characters' bodies are usually made out of several pieces. The pieces are
@ -16,12 +16,12 @@ and rotates the parts in small increments between each shot to create the
illusion of movement when the images are played back quickly in sequence.
Simulations of cutout animation can now be created using software as seen in
`South Park <https://en.wikipedia.org/wiki/South_Park>`__ and `Jake and the Never
Land Pirates <https://en.wikipedia.org/wiki/Jake_and_the_Never_Land_Pirates>`__.
`South Park <https://en.wikipedia.org/wiki/South_Park>` and `Jake and the Never
Land Pirates <https://en.wikipedia.org/wiki/Jake_and_the_Never_Land_Pirates>`.
In video games, this technique has also become popular. Examples of
this are `Paper Mario <https://en.wikipedia.org/wiki/Super_Paper_Mario>`__ or
`Rayman Origins <https://en.wikipedia.org/wiki/Rayman_Origins>`__ .
this are `Paper Mario <https://en.wikipedia.org/wiki/Super_Paper_Mario>` or
`Rayman Origins <https://en.wikipedia.org/wiki/Rayman_Origins>` .
Cutout animation in Godot
~~~~~~~~~~~~~~~~~~~~~~~~~
@ -54,7 +54,7 @@ Making of GBot
~~~~~~~~~~~~~~
For this tutorial, we will use as demo content the pieces of the
`GBot <https://www.youtube.com/watch?v=S13FrWuBMx4&list=UUckpus81gNin1aV8WSffRKw>`__
`GBot <https://www.youtube.com/watch?v=S13FrWuBMx4&list=UUckpus81gNin1aV8WSffRKw>`
character, created by Andreas Esau.
![](img/tuto_cutout_walk.gif)

8
tutorials/animation/playing_videos.md
View File

@ -113,7 +113,7 @@ This can be done with the following steps:
**Flags > Unshaded** to improve rendering performance.
See `doc_viewports` and the
`GUI in 3D demo <https://github.com/godotengine/godot-demo-projects/tree/master/viewport/gui_in_3d>`__
`GUI in 3D demo <https://github.com/godotengine/godot-demo-projects/tree/master/viewport/gui_in_3d>`
for more information on setting this up.
Video decoding conditions and recommended resolutions
@ -176,8 +176,8 @@ you should use a lossless or uncompressed format as an intermediate format to
maximize the quality of the output Ogg Theora video, but this can require a lot
of disk space.
`HandBrake <https://handbrake.fr/>`__
(GUI) and `FFmpeg <https://ffmpeg.org/>`__ (CLI) are popular open source tools
`HandBrake <https://handbrake.fr/>`
(GUI) and `FFmpeg <https://ffmpeg.org/>` (CLI) are popular open source tools
for this purpose. FFmpeg has a steeper learning curve, but it's more powerful.
Here are example FFmpeg commands to convert a MP4 video to Ogg Theora. Since
@ -206,7 +206,7 @@ video quality, increasing audio quality doesn't increase the output file size
nearly as much. Therefore, if you want the cleanest audio possible, you can
increase this to `9` to get *perceptually lossless* audio. This is especially
valuable if your input file already uses lossy audio compression. See
`this page <https://wiki.hydrogenaud.io/index.php?title=Recommended_Ogg_Vorbis#Recommended_Encoder_Settings>`__
`this page <https://wiki.hydrogenaud.io/index.php?title=Recommended_Ogg_Vorbis#Recommended_Encoder_Settings>`
for a table listing Ogg Vorbis audio quality presets and their respective
variable bitrates.

2
tutorials/assets_pipeline/escn_exporter/mesh.md
View File

@ -19,5 +19,5 @@ it takes a relatively long time.
incorrect shape keys exported, try to disable :code:`Apply Modifiers`
and do the exporting again. Besides, it is worthwhile to report the
incompatible modifier to the `issue list
<https://github.com/godotengine/godot-blender-exporter/issues>`__,
<https://github.com/godotengine/godot-blender-exporter/issues>`,
which helps to develop the exporter to have a more precise check of modifiers.

6
tutorials/assets_pipeline/importing_images.md
View File

@ -23,10 +23,10 @@ Godot can import the following image formats:
- Precision is limited to 8 bits per channel upon importing (no HDR images).
- Truevision Targa (`.tga`)
- SVG (`.svg`, `.svgz`)
- SVGs are rasterized using `NanoSVG <https://github.com/memononen/nanosvg>`__
- SVGs are rasterized using `NanoSVG <https://github.com/memononen/nanosvg>`
when importing them. Support is limited; complex vectors may not render correctly.
For complex vectors, rendering them to PNGs using Inkscape is often a better solution.
This can be automated thanks to its `command-line interface <https://wiki.inkscape.org/wiki/index.php/Using_the_Command_Line#Export_files>`__.
This can be automated thanks to its `command-line interface <https://wiki.inkscape.org/wiki/index.php/Using_the_Command_Line#Export_files>`.
- WebP (`.webp`)
- WebP files support transparency and can be compressed lossily or losslessly.
The precision is limited to 8 bits per channel.
@ -129,7 +129,7 @@ Note that RGTC compression affects the resulting normal map image. You will have
More information about normal maps (including a coordinate order table for
popular engines) can be found
`here <http://wiki.polycount.com/wiki/Normal_Map_Technical_Details>`__.
`here <http://wiki.polycount.com/wiki/Normal_Map_Technical_Details>`.
Flags
-----

12
tutorials/assets_pipeline/importing_scenes.md
View File

@ -31,7 +31,7 @@ Exporting DAE files from Maya and 3DS Max
Autodesk added built-in COLLADA support to Maya and 3DS Max, but it's
broken by default and should not be used. The best way to export this format
is by using the
`OpenCollada <https://github.com/KhronosGroup/OpenCOLLADA/wiki/OpenCOLLADA-Tools>`__
`OpenCollada <https://github.com/KhronosGroup/OpenCOLLADA/wiki/OpenCOLLADA-Tools>`
plugins. They work well, although they are not always up-to date
with the latest version of the software.
@ -83,12 +83,12 @@ Exporting ESCN files from Blender
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The most powerful one, called `godot-blender-exporter
<https://github.com/godotengine/godot-blender-exporter>`__.
<https://github.com/godotengine/godot-blender-exporter>`.
It uses a .escn file, which is kind of another name for a .tscn file (Godot scene file);
it keeps as much information as possible from a Blender scene. However, it is considered
experimental.
The ESCN exporter has a detailed `document <escn_exporter/index.html>`__ describing
The ESCN exporter has a detailed `document <escn_exporter/index.html>` describing
its functionality and usage.
Exporting textures separately
@ -96,8 +96,8 @@ Exporting textures separately
While textures can be exported with a model in certain file formats, such as glTF 2.0, you can also export them
separately. Godot uses PBR (physically based rendering) for its materials, so if a texturing program can export PBR
textures, they can work in Godot. This includes the `Substance suite <https://www.substance3d.com/>`__,
`ArmorPaint (open source) <https://armorpaint.org/>`__, and `Material Maker (open source) <https://github.com/RodZill4/material-maker>`__.
textures, they can work in Godot. This includes the `Substance suite <https://www.substance3d.com/>`,
`ArmorPaint (open source) <https://armorpaint.org/>`, and `Material Maker (open source) <https://github.com/RodZill4/material-maker>`.
.. note:: For more information on Godot's materials, see `doc_spatial_material`.
@ -266,7 +266,7 @@ Ensure Tangents
If textures with normal mapping are to be used, meshes need to have tangent arrays.
This option ensures that these are generated if not present in the source scene.
Godot uses `Mikktspace <http://www.mikktspace.com/>`__ for this,
Godot uses `Mikktspace <http://www.mikktspace.com/>` for this,
but it's always better to have them generated in the exporter.
Storage

6
tutorials/assets_pipeline/importing_translations.md
View File

@ -40,16 +40,16 @@ To complete the picture and allow efficient support for translations,
Godot has a special importer that can read CSV files. Most spreadsheet
editors can export to this format, so the only requirement is that the files
have a special arrangement. The CSV files **must** be saved with UTF-8 encoding
without a `byte order mark <https://en.wikipedia.org/wiki/Byte_order_mark>`__.
without a `byte order mark <https://en.wikipedia.org/wiki/Byte_order_mark>`.
.. warning::
By default, Microsoft Excel will always save CSV files with ANSI encoding
rather than UTF-8. There is no built-in way to do this, but there are
workarounds as described
`here <https://stackoverflow.com/questions/4221176/excel-to-csv-with-utf8-encoding>`__.
`here <https://stackoverflow.com/questions/4221176/excel-to-csv-with-utf8-encoding>`.
We recommend using `LibreOffice <https://www.libreoffice.org/>`__ or Google Sheets instead.
We recommend using `LibreOffice <https://www.libreoffice.org/>` or Google Sheets instead.
CSV files must be formatted as follows:

2
tutorials/audio/audio_buses.md
View File

@ -267,7 +267,7 @@ SpectrumAnalyzer
This effect doesn't alter audio, instead, you add this effect to buses you want
a spectrum analysis of. This would typically be used for audio visualization. A
demo project using this can be found `here <https://github.com/godotengine/godot-demo-projects/tree/master/audio/spectrum>`__.
demo project using this can be found `here <https://github.com/godotengine/godot-demo-projects/tree/master/audio/spectrum>`.
StereoEnhance
~~~~~~~~~~~~~

4
tutorials/best_practices/version_control_systems.md
View File

@ -18,9 +18,9 @@ Official Git plugin
Using Git from inside the editor is supported with an official plugin.
You can find the latest releases
`here <https://github.com/godotengine/godot-git-plugin/releases>`__. Documentation on how to use the Git
`here <https://github.com/godotengine/godot-git-plugin/releases>`. Documentation on how to use the Git
plugin can be found
`here <https://github.com/godotengine/godot-git-plugin/wiki>`__.
`here <https://github.com/godotengine/godot-git-plugin/wiki>`.
Files to exclude from VCS
-------------------------

12
tutorials/editor/using_the_web_editor.md
View File

@ -3,7 +3,7 @@
Using the Web editor
====================
Since Godot 3.3, there is a `Web editor <https://editor.godotengine.org/>`__
Since Godot 3.3, there is a `Web editor <https://editor.godotengine.org/>`
you can use to work on new or existing projects.
.. note::
@ -34,7 +34,7 @@ recommended for better performance and compatibility with old/low-end hardware.
.. note::
If you use Linux, due to
`poor Firefox WebGL performance <https://bugzilla.mozilla.org/show_bug.cgi?id=1010527>`__,
`poor Firefox WebGL performance <https://bugzilla.mozilla.org/show_bug.cgi?id=1010527>`,
it's recommended to use a Chromium-based browser instead of Firefox.
.. _doc_using_the_web_editor_limitations:
@ -52,7 +52,7 @@ are currently missing:
protocol will not work.
- No project exporting. As a workaround, you can download the project source
using **Project > Tools > Download Project Source** and export it using a
`native version of the Godot editor <https://godotengine.org/download>`__.
`native version of the Godot editor <https://godotengine.org/download>`.
- The editor won't warn you when closing the tab with unsaved changes.
- No lightmap baking support. You can still use existing lightmaps if they were
baked with a native version of the Godot editor
@ -67,7 +67,7 @@ of the Web platform:
.. seealso::
See the
`list of open issues on GitHub related to the web editor <https://github.com/godotengine/godot/issues?q=is%3Aopen+is%3Aissue+label%3Aplatform%3Ahtml5+label%3Atopic%3Aeditor>`__ for a list of known bugs.
`list of open issues on GitHub related to the web editor <https://github.com/godotengine/godot/issues?q=is%3Aopen+is%3Aissue+label%3Aplatform%3Ahtml5+label%3Atopic%3Aeditor>` for a list of known bugs.
Importing a project
-------------------
@ -115,10 +115,10 @@ on your machine, but is abstracted away in a database.
You can download the project files as a ZIP archive by using
**Project > Tools > Download Project Source**. This can be used to export the
project using a `native Godot editor <https://godotengine.org/download>`__,
project using a `native Godot editor <https://godotengine.org/download>`,
since exporting from the web editor isn't supported yet.
In the future, it may be possible to use the
`HTML5 FileSystem API <https://developer.mozilla.org/en-US/docs/Web/API/FileSystem>`__
`HTML5 FileSystem API <https://developer.mozilla.org/en-US/docs/Web/API/FileSystem>`
to store the project files on the user's filesystem as the native editor would do.
However, this isn't implemented yet.

2
tutorials/export/android_custom_build.md
View File

@ -41,7 +41,7 @@ When setting up the Android project in the **Project > Export** dialog,
![](img/custom_build_enable.png)
From now on, attempting to export the project or one-click deploy will call the
`Gradle <https://gradle.org/>`__ build system to generate fresh templates (this
`Gradle <https://gradle.org/>` build system to generate fresh templates (this
window will appear every time):
![](img/custom_build_gradle.png)

6
tutorials/export/changing_application_icon_for_windows.md
View File

@ -62,13 +62,13 @@ Changing the file icon
----------------------
In Godot 3.5 and later, you can change the file icon without
external tools using `godoticon <https://github.com/pkowal1982/godoticon>`__.
external tools using `godoticon <https://github.com/pkowal1982/godoticon>`.
Changing the file icon this way should work for executables containing
an embedded PCK.
.. warning::
There are `known issues <https://github.com/godotengine/godot/issues/33466>`__
There are `known issues <https://github.com/godotengine/godot/issues/33466>`
when changing the application icon in executables that embed a PCK file.
It's recommended to avoid using rcedit for now if you choose to enable the
**Embed Pck** option for your Windows export preset in the Export dialog.
@ -108,7 +108,7 @@ the **Application → Icon** field.
If rcedit fails to change the icon, you can instead
`compile your own Windows export templates <doc_compiling_for_windows>`
with the icon changed. To do so, replace
`platform/windows/godot.ico <https://github.com/godotengine/godot/blob/master/platform/windows/godot.ico>`__
`platform/windows/godot.ico <https://github.com/godotengine/godot/blob/master/platform/windows/godot.ico>`
with your own ICO file *before* compiling export templates.
Once this is done, you can specify your export templates as custom export

2
tutorials/export/exporting_basics.md
View File

@ -147,7 +147,7 @@ download them in Godot by clicking on **Editor -> Manage Export Templates**:
.. note::
If you've downloaded Godot from
`Steam <https://store.steampowered.com/app/404790/Godot_Engine/>`__,
`Steam <https://store.steampowered.com/app/404790/Godot_Engine/>`,
export templates are already included. Therefore, you don't need to download
them using the **Manage Export Templates** dialog.

18
tutorials/export/exporting_for_android.md
View File

@ -16,17 +16,17 @@ The following steps detail what is needed to set up the Android SDK and the engi
Install OpenJDK 11
------------------
Download and install `OpenJDK 11 <https://adoptium.net/?variant=openjdk11>`__.
Download and install `OpenJDK 11 <https://adoptium.net/?variant=openjdk11>`.
Download the Android SDK
------------------------
Download and install the Android SDK.
- You can install it using `Android Studio version 4.1 or later <https://developer.android.com/studio/>`__.
- You can install it using `Android Studio version 4.1 or later <https://developer.android.com/studio/>`.
- Run it once to complete the SDK setup using these `instructions <https://developer.android.com/studio/intro/update#sdk-manager>`__.
- Ensure that the `required packages <https://developer.android.com/studio/intro/update#recommended>`__ are installed as well.
- Run it once to complete the SDK setup using these `instructions <https://developer.android.com/studio/intro/update#sdk-manager>`.
- Ensure that the `required packages <https://developer.android.com/studio/intro/update#recommended>` are installed as well.
- Android SDK Platform-Tools version 30.0.5 or later
- Android SDK Build-Tools version 30.0.3
@ -35,9 +35,9 @@ Download and install the Android SDK.
- CMake version 3.10.2.4988404
- NDK version r23c (23.2.8568313)
- You can install it using the `command line tools <https://developer.android.com/studio/#command-tools>`__.
- You can install it using the `command line tools <https://developer.android.com/studio/#command-tools>`.
- Once the command line tools are installed, run the `sdkmanager <https://developer.android.com/studio/command-line/sdkmanager>`__ command to complete the setup process:
- Once the command line tools are installed, run the `sdkmanager <https://developer.android.com/studio/command-line/sdkmanager>` command to complete the setup process:
::
@ -62,7 +62,7 @@ the JDK can be used for this purpose::
keytool -keyalg RSA -genkeypair -alias androiddebugkey -keypass android -keystore debug.keystore -storepass android -dname "CN=Android Debug,O=Android,C=US" -validity 9999 -deststoretype pkcs12
This will create a `debug.keystore` file in your current directory. You should move it to a memorable location such as `%USERPROFILE%\.android\`, because you will need its location in a later step. For more information on `keytool` usage, see `this Q&A article <https://godotengine.org/qa/21349/jdk-android-file-missing>`__.
This will create a `debug.keystore` file in your current directory. You should move it to a memorable location such as `%USERPROFILE%\.android\`, because you will need its location in a later step. For more information on `keytool` usage, see `this Q&A article <https://godotengine.org/qa/21349/jdk-android-file-missing>`.
Setting it up in Godot
----------------------
@ -132,7 +132,7 @@ keystore file; such file can be generated like this:
keytool -v -genkey -keystore mygame.keystore -alias mygame -keyalg RSA -validity 10000
This keystore and key are used to verify your developer identity, remember the password and keep it in a safe place!
Use Google's Android Developer guides to learn more about `APK signing <https://developer.android.com/studio/publish/app-signing>`__.
Use Google's Android Developer guides to learn more about `APK signing <https://developer.android.com/studio/publish/app-signing>`.
Now fill in the following forms in your Android Export Presets:
@ -163,7 +163,7 @@ ARMv8 devices, but the opposite is not true.
Since August 2019, Google Play requires all applications to be available in
64-bit form. This means you cannot upload an APK that contains *just* an ARMv7
library. To solve this, you can upload several APKs to Google Play using its
`Multiple APK support <https://developer.android.com/google/play/publishing/multiple-apks>`__.
`Multiple APK support <https://developer.android.com/google/play/publishing/multiple-apks>`.
Each APK should target a single architecture; creating an APK for ARMv7
and ARMv8 is usually sufficient to cover most devices in use today.

8
tutorials/export/exporting_for_dedicated_servers.md
View File

@ -9,7 +9,7 @@ have a GPU or display server available, you'll need to use a server build of God
Platform support
----------------
- **Linux:** `Download an official Linux server binary <https://godotengine.org/download/server>`__.
- **Linux:** `Download an official Linux server binary <https://godotengine.org/download/server>`.
To compile a server binary from source, follow instructions in
`doc_compiling_for_x11`.
- **macOS:** `Compile a server binary from source for macOS <doc_compiling_for_osx>`.
@ -23,7 +23,7 @@ If your project uses C#, you'll have to use a Mono-enabled server binary.
"Headless" versus "server" binaries
-----------------------------------
The `server download page <https://godotengine.org/download/server>`__
The `server download page <https://godotengine.org/download/server>`
offers two kinds of binaries with several differences.
- **Server:** Use this one for running dedicated servers. It does not contain
@ -115,11 +115,11 @@ Next steps
On Linux, to make your dedicated server restart after a crash or system reboot,
you can
`create a systemd service <https://medium.com/@benmorel/creating-a-linux-service-with-systemd-611b5c8b91d6>`__.
`create a systemd service <https://medium.com/@benmorel/creating-a-linux-service-with-systemd-611b5c8b91d6>`.
This also lets you view server logs in a more convenient fashion, with automatic
log rotation provided by systemd.
If you have experience with containers, you could also look into wrapping your
dedicated server in a `Docker <https://www.docker.com/>`__ container. This way,
dedicated server in a `Docker <https://www.docker.com/>` container. This way,
it can be used more easily in an automatic scaling setup (which is outside the
scope of this tutorial).

14
tutorials/export/exporting_for_macos.md
View File

@ -29,7 +29,7 @@ Code signing and notarization
By default, macOS will run only applications that are signed and notarized. If you use any other signing configuration, see `Running Godot apps on macOS <doc_running_on_macos>` for workarounds.
To notarize an app, you **must** have a valid `Apple Developer ID Certificate <https://developer.apple.com/>`__.
To notarize an app, you **must** have a valid `Apple Developer ID Certificate <https://developer.apple.com/>`.
If you have an Apple Developer ID Certificate
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -42,9 +42,9 @@ If `Notarization` is enabled, Godot will automatically upload the exported proje
You can use the `xcrun notarytool history` command to check notarization status and use the `xcrun notarytool log {ID}` command to download the notarization log.
If you encounter notarization issues, see `Resolving common notarization issues <https://developer.apple.com/documentation/security/notarizing_macos_software_before_distribution/resolving_common_notarization_issues>`__ for more info.
If you encounter notarization issues, see `Resolving common notarization issues <https://developer.apple.com/documentation/security/notarizing_macos_software_before_distribution/resolving_common_notarization_issues>` for more info.
After notarization is completed, `staple the ticket <https://developer.apple.com/documentation/security/notarizing_macos_software_before_distribution/customizing_the_notarization_workflow>`__ to the exported project.
After notarization is completed, `staple the ticket <https://developer.apple.com/documentation/security/notarizing_macos_software_before_distribution/customizing_the_notarization_workflow>` to the exported project.
If you do not have an Apple Developer ID Certificate
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -88,12 +88,12 @@ Notarization Options
+--------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Apple ID Name | Apple ID account name (email address) |
+--------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Apple ID Password | Apple ID app-specific password. See `Using app-specific passwords <https://support.apple.com/en-us/HT204397>`__ to enable two-factor authentication and create app password. |
| Apple ID Password | Apple ID app-specific password. See `Using app-specific passwords <https://support.apple.com/en-us/HT204397>` to enable two-factor authentication and create app password. |
+--------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Apple Team ID | Team ID, if your Apple ID belongs to multiple teams |
+--------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
See `Notarizing macOS Software Before Distribution <https://developer.apple.com/documentation/security/notarizing_macos_software_before_distribution?language=objc>`__ for more info.
See `Notarizing macOS Software Before Distribution <https://developer.apple.com/documentation/security/notarizing_macos_software_before_distribution?language=objc>` for more info.
.. note::
@ -106,7 +106,7 @@ Hardened Runtime Entitlements
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Hardened Runtime entitlements manage security options and resource access policy.
See `Hardened Runtime <https://developer.apple.com/documentation/security/hardened_runtime?language=objc>`__ for more info.
See `Hardened Runtime <https://developer.apple.com/documentation/security/hardened_runtime?language=objc>` for more info.
+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Entitlement | Description |
@ -145,7 +145,7 @@ App Sandbox Entitlement
The App Sandbox restricts access to user data, networking and devices.
Sandboxed apps can't access most of the file system, can't use custom file dialogs and execute binaries (using `OS.execute` and `OS.create_process`) outside the `.app` bundle.
See `App Sandbox <https://developer.apple.com/documentation/security/app_sandbox?language=objc>`__ for more info.
See `App Sandbox <https://developer.apple.com/documentation/security/app_sandbox?language=objc>` for more info.
.. note::

6
tutorials/export/exporting_for_uwp.md
View File

@ -23,14 +23,14 @@ the name used on the certificate.
Limitations on Xbox One
-----------------------
As described in the `UWP documentation <https://docs.microsoft.com/en-us/windows/uwp/xbox-apps/system-resource-allocation>`__:
As described in the `UWP documentation <https://docs.microsoft.com/en-us/windows/uwp/xbox-apps/system-resource-allocation>`:
- Submitted as an "App"
- available memory is 1GB
- share of 2-4 CPU cores
- shared access of GPU power (45%)
- Submitted as a "Game" (through `Xbox Live Creators Program <https://www.xbox.com/en-US/developers/creators-program>`__)
- Submitted as a "Game" (through `Xbox Live Creators Program <https://www.xbox.com/en-US/developers/creators-program>`)
- available memory is 5GB
- 4 exclusive CPU cores and 2 shared CPU cores
- exclusive access to GPU power (100%)
@ -45,7 +45,7 @@ the Windows SDK. If you use Visual Studio, you can open one of its Developer
Prompts, since it comes with these tools and they can be located in the path.
You can get more detailed instructions from `Microsoft's documentation
<https://msdn.microsoft.com/en-us/library/windows/desktop/jj835832(v=vs.85).aspx>`__.
<https://msdn.microsoft.com/en-us/library/windows/desktop/jj835832(v=vs.85).aspx>`.
First, run `MakeCert` to create a private key::

24
tutorials/export/exporting_for_web.md
View File

@ -11,7 +11,7 @@ Exporting for the Web
HTML5 export allows publishing games made in Godot Engine to the browser.
This requires support for `WebAssembly
<https://webassembly.org/>`__ and `WebGL <https://www.khronos.org/webgl/>`__
<https://webassembly.org/>` and `WebGL <https://www.khronos.org/webgl/>`
in the user's browser.
.. important:: Use the browser-integrated developer console, usually opened
@ -19,7 +19,7 @@ in the user's browser.
engine, and WebGL errors.
.. attention:: `There are significant bugs when running HTML5 projects on iOS
<https://github.com/godotengine/godot/issues?q=is:issue+is:open+label:platform:html5+ios>`__
<https://github.com/godotengine/godot/issues?q=is:issue+is:open+label:platform:html5+ios>`
(regardless of the browser). We recommend using
`iOS' native export functionality <doc_exporting_for_ios>`
instead, as it will also result in better performance.
@ -40,7 +40,7 @@ specifically.
Additionally, while most browsers support WebGL 2.0, this is not yet the case
for **Safari**. WebGL 2.0 support is coming in Safari 15 for macOS, and is not
available yet for any **iOS** browser (all WebKit-based like Safari).
See `Can I use WebGL 2.0 <https://caniuse.com/webgl2>`__ for details.
See `Can I use WebGL 2.0 <https://caniuse.com/webgl2>` for details.
.. _doc_javascript_export_options:
@ -56,8 +56,8 @@ You can choose the **Export Type** to select which features will be available:
- *Regular*: is the most compatible across browsers, will not support threads,
nor GDNative.
- *Threads*: will require the browser to support `SharedArrayBuffer
<https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer>`__.
See `Can I use SharedArrayBuffer <https://caniuse.com/sharedarraybuffer>`__
<https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer>`.
See `Can I use SharedArrayBuffer <https://caniuse.com/sharedarraybuffer>`
for details.
- *GDNative*: enables GDNative support but makes the binary bigger and slower
to load.
@ -100,7 +100,7 @@ of limitations you should be aware of when porting a Godot game to the web.
usually exempt from such requirement).
.. tip:: Check the `list of open HTML5 issues on GitHub
<https://github.com/godotengine/godot/issues?q=is:open+is:issue+label:platform:html5>`__
<https://github.com/godotengine/godot/issues?q=is:open+is:issue+label:platform:html5>`
to see if the functionality you're interested in has an issue yet. If
not, open one to communicate your interest.
@ -138,7 +138,7 @@ across browsers is still limited.
.. warning:: Requires a `secure context <doc_javascript_secure_contexts>`.
Browsers also require that the web page is served with specific
`cross-origin isolation headers <https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cross-Origin-Embedder-Policy>`__.
`cross-origin isolation headers <https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cross-Origin-Embedder-Policy>`.
GDNative
~~~~~~~~
@ -170,7 +170,7 @@ Chrome restricts how websites may play audio. It may be necessary for the
player to click or tap or press a key to enable audio.
.. seealso:: Google offers additional information about their `Web Audio autoplay
policies <https://sites.google.com/a/chromium.org/dev/audio-video/autoplay>`__.
policies <https://sites.google.com/a/chromium.org/dev/audio-video/autoplay>`.
.. warning:: Access to microphone requires a
`secure context <doc_javascript_secure_contexts>`.
@ -192,13 +192,13 @@ The HTTP classes also have several restrictions on the HTML5 platform:
- Cannot progress more than once per frame, so polling in a loop will freeze
- No chunked responses
- Host verification cannot be disabled
- Subject to `same-origin policy <https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy>`__
- Subject to `same-origin policy <https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy>`
Clipboard
~~~~~~~~~
Clipboard synchronization between engine and the operating system requires a
browser supporting the `Clipboard API <https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API>`__,
browser supporting the `Clipboard API <https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API>`,
additionally, due to the API asynchronous nature might not be reliable when
accessed from GDScript.
@ -209,7 +209,7 @@ Gamepads
Gamepads will not be detected until one of their button is pressed. Gamepads
might have the wrong mapping depending on the browser/OS/gamepad combination,
sadly the `Gamepad API <https://developer.mozilla.org/en-US/docs/Web/API/Gamepad_API/Using_the_Gamepad_API>`__
sadly the `Gamepad API <https://developer.mozilla.org/en-US/docs/Web/API/Gamepad_API/Using_the_Gamepad_API>`
does not provide a reliable way to detect the gamepad information necessary
to remap them based on model/vendor/OS due to privacy considerations.
@ -267,7 +267,7 @@ of its original size with gzip compression.
**Hosts that provide on-the-fly compression:** GitHub Pages (gzip)
**Hosts that don't provide on-the-fly compression:** itch.io, GitLab Pages
(`supports manual gzip precompression <https://webd97.de/post/gitlab-pages-compression/>`__)
(`supports manual gzip precompression <https://webd97.de/post/gitlab-pages-compression/>`)
.. _doc_javascript_eval:

2
tutorials/export/exporting_for_windows.md
View File

@ -21,7 +21,7 @@ binary that is smaller, faster and does not contain the editor and debugger.
Requirements
------------
- To enable code signing, you must have the `Windows 10 SDK` (on Windows) or `osslsigncode <https://github.com/mtrojnar/osslsigncode>`__ (on any other OS) installed.
- To enable code signing, you must have the `Windows 10 SDK` (on Windows) or `osslsigncode <https://github.com/mtrojnar/osslsigncode>` (on any other OS) installed.
- Download the Godot export templates. Use the Godot menu: `Editor > Manage Export Templates`.
.. warning::

4
tutorials/export/exporting_projects.md
View File

@ -194,7 +194,7 @@ depending on your needs.
- Uncompressed format. Larger file size, but faster to read/write.
- Not readable and writable using tools normally present on the user's
operating system, even though there are
`third-party tools <https://github.com/hhyyrylainen/GodotPckTool>`__
`third-party tools <https://github.com/hhyyrylainen/GodotPckTool>`
to extract and create PCK files.
**ZIP format:**
@ -205,7 +205,7 @@ depending on your needs.
.. warning::
Due to a `known bug <https://github.com/godotengine/godot/pull/42123>`__,
Due to a `known bug <https://github.com/godotengine/godot/pull/42123>`,
when using a ZIP file as a pack file, the exported binary will not try to use
it automatically. Therefore, you have to create a *launcher script* that
the player can double-click or run from a terminal to launch the project::

4
tutorials/export/one-click_deploy.md
View File

@ -73,10 +73,10 @@ To resolve this:
Try unlocking your device and accepting the authorization prompt if you see any.
If you can't see this prompt, running `adb devices` on your PC should make
the authorization prompt appear on the device.
- Try `revoking the debugging authorization <https://stackoverflow.com/questions/23081263/adb-android-device-unauthorized>`__
- Try `revoking the debugging authorization <https://stackoverflow.com/questions/23081263/adb-android-device-unauthorized>`
in the device's developer settings, then follow the steps again.
- Try using USB debugging instead of wireless debugging or vice versa.
Sometimes, one of those can work better than the other.
- On Linux, you may be missing the required
`udev rules <https://github.com/M0Rf30/android-udev-rules>`__
`udev rules <https://github.com/M0Rf30/android-udev-rules>`
for your device to be recognized.

16
tutorials/inputs/controllers_gamepads_joysticks.md
View File

@ -4,16 +4,16 @@ Controllers, gamepads, and joysticks
====================================
Godot supports hundreds of controller models thanks to the community-sourced
`SDL game controller database <https://github.com/gabomdq/SDL_GameControllerDB>`__.
`SDL game controller database <https://github.com/gabomdq/SDL_GameControllerDB>`.
Controllers are supported on Windows, macOS, Linux, Android, iOS, and HTML5.
Note that more specialized devices such as steering wheels, rudder pedals and
`HOTAS <https://en.wikipedia.org/wiki/HOTAS>`__ are less tested and may not
`HOTAS <https://en.wikipedia.org/wiki/HOTAS>` are less tested and may not
always work as expected. Overriding force feedback for those devices is also not
implemented yet. If you have access to one of those devices, don't hesitate to
`report bugs on GitHub
<https://github.com/godotengine/godot/blob/master/CONTRIBUTING.md#reporting-bugs>`__.
<https://github.com/godotengine/godot/blob/master/CONTRIBUTING.md#reporting-bugs>`.
In this guide, you will learn:
@ -154,26 +154,26 @@ Troubleshooting
.. seealso::
You can view a list of
`known issues with controller support <https://github.com/godotengine/godot/issues?q=is%3Aopen+is%3Aissue+label%3Atopic%3Ainput+gamepad>`__
`known issues with controller support <https://github.com/godotengine/godot/issues?q=is%3Aopen+is%3Aissue+label%3Atopic%3Ainput+gamepad>`
on GitHub.
My controller isn't recognized by Godot.
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
First, check that your controller is recognized by other applications. You can
use the `Gamepad Tester <https://gamepad-tester.com/>`__ website to confirm that
use the `Gamepad Tester <https://gamepad-tester.com/>` website to confirm that
your controller is recognized.
My controller has incorrectly mapped buttons or axes.
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
If buttons are incorrectly mapped, this may be due to an erroneous mapping from
the `SDL game controller database <https://github.com/gabomdq/SDL_GameControllerDB>`__.
the `SDL game controller database <https://github.com/gabomdq/SDL_GameControllerDB>`.
You can contribute an updated mapping to be included in the next Godot version
by opening a pull request on the linked repository.
There are many ways to create mappings. One option is to use the mapping wizard
in the `official Joypads demo <https://godotengine.org/asset-library/asset/140>`__.
in the `official Joypads demo <https://godotengine.org/asset-library/asset/140>`.
Once you have a working mapping for your controller, you can test it by defining
the `SDL_GAMECONTROLLERCONFIG` environment variable before running Godot:
@ -223,5 +223,5 @@ result, you may have to instruct your players to use a different browser if they
can't get their controller to work.
Also, note that
`controller support was significantly improved <https://github.com/godotengine/godot/pull/45078>`__
`controller support was significantly improved <https://github.com/godotengine/godot/pull/45078>`
in Godot 3.3 and later.

2
tutorials/inputs/input_examples.md
View File

@ -163,7 +163,7 @@ gdscript GDScript
As a result, it's recommended to use a default keyboard layout that is designed to work well
on a keyboard without antighosting. See
`this Gamedev Stack Exchange question <https://gamedev.stackexchange.com/a/109002>`__
`this Gamedev Stack Exchange question <https://gamedev.stackexchange.com/a/109002>`
for more information.
Keyboard modifiers

2
tutorials/io/background_loading.md
View File

@ -304,4 +304,4 @@ Example:
**Note**: this code, in its current form, is not tested in real world
scenarios. 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>`.

6
tutorials/io/data_paths.md
View File

@ -141,12 +141,12 @@ depending on the platform. By default, these paths are:
It can safely be removed when Godot is closed.
Godot complies with the `XDG Base Directory Specification
<https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html>`__
<https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html>`
on all platforms. You can override environment variables following the
specification to change the editor and project data paths.
.. note:: If you use `Godot packaged as a Flatpak
<https://flathub.org/apps/details/org.godotengine.Godot>`__, the
<https://flathub.org/apps/details/org.godotengine.Godot>`, the
editor data paths will be located in subfolders in
`~/.var/app/org.godotengine.Godot/`.
@ -162,7 +162,7 @@ This mode makes Godot write all editor data, settings, and cache to a directory
named `editor_data/` in the same directory as the editor binary.
You can use it to create a portable installation of the editor.
The `Steam release of Godot <https://store.steampowered.com/app/404790/>`__ uses
The `Steam release of Godot <https://store.steampowered.com/app/404790/>` uses
self-contained mode by default.
.. note::

4
tutorials/math/random_number_generation.md
View File

@ -15,7 +15,7 @@ and how to use a noise generator in GDScript.
Computers cannot generate "true" random numbers. Instead, they rely on
`pseudorandom number generators
<https://en.wikipedia.org/wiki/Pseudorandom_number_generator>`__ (PRNGs).
<https://en.wikipedia.org/wiki/Pseudorandom_number_generator>` (PRNGs).
Global scope versus RandomNumberGenerator class
-----------------------------------------------
@ -104,7 +104,7 @@ other things.
`randfn()` returns a random
floating-point number following a `normal distribution
<https://en.wikipedia.org/wiki/Normal_distribution>`__. This means the returned
<https://en.wikipedia.org/wiki/Normal_distribution>`. This means the returned
value is more likely to be around the mean (0.0 by default),
varying by the deviation (1.0 by default):

2
tutorials/math/vectors_advanced.md
View File

@ -184,7 +184,7 @@ Some examples of planes
-----------------------
Here is a simple example of what planes are useful for. Imagine you have
a `convex <https://www.mathsisfun.com/definitions/convex.html>`__
a `convex <https://www.mathsisfun.com/definitions/convex.html>`
polygon. For example, a rectangle, a trapezoid, a triangle, or just any
polygon where no faces bend inwards.

4
tutorials/networking/high_level_multiplayer.md
View File

@ -35,8 +35,8 @@ In summary, you can use the low-level networking API for maximum control and imp
https://gafferongames.com/post/udp_vs_tcp/
Gaffer On Games has a lot of useful articles about networking in Games
(`here <https://gafferongames.com/categories/game-networking/>`__), including the comprehensive
`introduction to networking models in games <https://gafferongames.com/post/what_every_programmer_needs_to_know_about_game_networking/>`__.
(`here <https://gafferongames.com/categories/game-networking/>`), including the comprehensive
`introduction to networking models in games <https://gafferongames.com/post/what_every_programmer_needs_to_know_about_game_networking/>`.
If you want to use your low-level networking library of choice instead of Godot's built-in networking,
see here for an example:

4
tutorials/networking/ssl_certificates.md
View File

@ -19,7 +19,7 @@ with a .crt file in the project settings:
![](img/ssl_certs.png)
This file should contain any number of public certificates in
`PEM format <https://en.wikipedia.org/wiki/Privacy-enhanced_Electronic_Mail>`__.
`PEM format <https://en.wikipedia.org/wiki/Privacy-enhanced_Electronic_Mail>`.
Of course, remember to add .crt as filter so the exporter recognizes
this when exporting your project.
@ -36,7 +36,7 @@ key pair and add the public key (in PEM format) to the .crt file.
The private key should go to your server.
OpenSSL has `some
documentation <https://raw.githubusercontent.com/openssl/openssl/master/doc/HOWTO/keys.txt>`__ about
documentation <https://raw.githubusercontent.com/openssl/openssl/master/doc/HOWTO/keys.txt>` about
this. This approach also **does not require domain validation** nor
requires you to spend a considerable amount of money in purchasing
certificates from a CA.

2
tutorials/networking/webrtc.md
View File

@ -35,7 +35,7 @@ Using WebRTC in Godot
WebRTC is implemented in Godot via two main classes `WebRTCPeerConnection` for more details.
.. note:: These classes are available automatically in HTML5, but **require an external GDNative plugin on native (non-HTML5) platforms**. Check out the `webrtc-native plugin repository <https://github.com/godotengine/webrtc-native>`__ for instructions and to get the latest `release <https://github.com/godotengine/webrtc-native/releases>`__.
.. note:: These classes are available automatically in HTML5, but **require an external GDNative plugin on native (non-HTML5) platforms**. Check out the `webrtc-native plugin repository <https://github.com/godotengine/webrtc-native>` for instructions and to get the latest `release <https://github.com/godotengine/webrtc-native/releases>`.
.. warning::

12
tutorials/performance/cpu_optimization.md
View File

@ -55,11 +55,11 @@ Although the Godot IDE profiler is very convenient and useful, sometimes you
need more power, and the ability to profile the Godot engine source code itself.
You can use a number of third party profilers to do this including
`Valgrind <https://www.valgrind.org/>`__,
`VerySleepy <http://www.codersnotes.com/sleepy/>`__,
`HotSpot <https://github.com/KDAB/hotspot>`__,
`Visual Studio <https://visualstudio.microsoft.com/>`__ and
`Intel VTune <https://software.intel.com/content/www/us/en/develop/tools/vtune-profiler.html>`__.
`Valgrind <https://www.valgrind.org/>`,
`VerySleepy <http://www.codersnotes.com/sleepy/>`,
`HotSpot <https://github.com/KDAB/hotspot>`,
`Visual Studio <https://visualstudio.microsoft.com/>` and
`Intel VTune <https://software.intel.com/content/www/us/en/develop/tools/vtune-profiler.html>`.
.. note:: You will need to compile Godot from source to use a third-party profiler.
This is required to obtain debugging symbols. You can also use a debug
@ -271,7 +271,7 @@ that feature real-time player movement.
The solution to jitter is to use *fixed timestep interpolation*, which involves
smoothing the rendered positions and rotations over multiple frames to match the
physics. You can either implement this yourself or use a
`third-party addon <https://github.com/lawnjelly/smoothing-addon>`__.
`third-party addon <https://github.com/lawnjelly/smoothing-addon>`.
Performance-wise, interpolation is a very cheap operation compared to running a
physics tick. It's orders of magnitude faster, so this can be a significant
performance win while also reducing jitter.

6
tutorials/performance/general_optimization.md
View File

@ -58,8 +58,8 @@ There are several methods of measuring performance, including:
- Using the Godot profiler.
- Using external third-party CPU profilers.
- Using GPU profilers/debuggers such as
`NVIDIA Nsight Graphics <https://developer.nvidia.com/nsight-graphics>`__
or `apitrace <https://apitrace.github.io/>`__.
`NVIDIA Nsight Graphics <https://developer.nvidia.com/nsight-graphics>`
or `apitrace <https://apitrace.github.io/>`.
- Checking the frame rate (with V-Sync disabled).
Be very aware that the relative performance of different areas can vary on
@ -133,7 +133,7 @@ For more info about using Godot's built-in profiler, see `doc_debugger_panel`.
Principles
==========
`Donald Knuth <https://en.wikipedia.org/wiki/Donald_Knuth>`__ said:
`Donald Knuth <https://en.wikipedia.org/wiki/Donald_Knuth>` said:
*Programmers waste enormous amounts of time thinking about, or worrying
about, the speed of noncritical parts of their programs, and these attempts

8
tutorials/platform/android/android_in_app_purchases.md
View File

@ -4,11 +4,11 @@ Android in-app purchases
========================
Godot offers a first-party `GodotGooglePlayBilling` Android plugin since Godot 3.2.2.
The new plugin uses the `Google Play Billing library <https://developer.android.com/google/play/billing>`__
The new plugin uses the `Google Play Billing library <https://developer.android.com/google/play/billing>`
instead of the now deprecated AIDL IAP implementation.
If you learn better by looking at an example, you can find the demo project
`here <https://github.com/godotengine/godot-demo-projects/tree/master/mobile/android_iap>`__.
`here <https://github.com/godotengine/godot-demo-projects/tree/master/mobile/android_iap>`.
Migrating from Godot 3.2.1 and lower (GodotPaymentsV3)
@ -22,7 +22,7 @@ Changes
- You need to enable the Custom Build option in your Android export settings and install
the `GodotGooglePlayBilling` plugin manually (see below for details)
- All purchases have to be acknowledged by your app. This is a
`requirement from Google <https://developer.android.com/google/play/billing/integrate#process>`__.
`requirement from Google <https://developer.android.com/google/play/billing/integrate#process>`.
Purchases that are not acknowledged by your app will be refunded.
- Support for subscriptions
- Signals (no polling or callback objects)
@ -35,7 +35,7 @@ Getting started
***************
If not already done, make sure you have enabled and successfully set up `Android Custom Builds <doc_android_custom_build>`.
Grab the`GodotGooglePlayBilling` plugin binary and config from the `releases page <https://github.com/godotengine/godot-google-play-billing/releases>`__
Grab the`GodotGooglePlayBilling` plugin binary and config from the `releases page <https://github.com/godotengine/godot-google-play-billing/releases>`
and put both into `res://android/plugins`.
The plugin should now show up in the Android export settings, where you can enable it.

4
tutorials/platform/android/android_plugin.md
View File

@ -52,12 +52,12 @@ Building an Android plugin
**Prerequisite:** `Android Studio <https://developer.android.com/studio>`_ is strongly recommended as the IDE to use to create Android plugins.
The instructions below assumes that you're using Android Studio.
1. Follow `these instructions <https://developer.android.com/studio/projects/android-library>`__ to create an Android library module for your plugin.
1. Follow `these instructions <https://developer.android.com/studio/projects/android-library>` to create an Android library module for your plugin.
2. Add the Godot engine library as a dependency to your plugin module:
- Download the Godot engine library (`godot-lib.<version>.<status>.aar`) from the `Godot download page <https://godotengine.org/download>`_ (e.g.: `godot-lib.3.4.2.stable.release.aar`).
- Follow `these instructions <https://developer.android.com/studio/projects/android-library#AddDependency>`__ to add
- Follow `these instructions <https://developer.android.com/studio/projects/android-library#AddDependency>` to add
the Godot engine library as a dependency for your plugin.
- In the plugin module's `build.gradle` file, replace `implementation` with `compileOnly` for the dependency line for the Godot engine library.

4
tutorials/platform/consoles.md
View File

@ -20,9 +20,9 @@ to a console platform is as follows:
developers (*devkit*). The cost of those devkits is confidential.
- Port the engine to the console platform or pay a company to do it.
- To be published, your game needs to be rated in the regions you'd like to sell
it in. For example, in North America, the `ESRB <https://www.esrb.org/>`__
it in. For example, in North America, the `ESRB <https://www.esrb.org/>`
handles game ratings. In Europe, this is done by
`PEGI <https://pegi.info/>`__. Indie developers can generally get a rating
`PEGI <https://pegi.info/>`. Indie developers can generally get a rating
for cheaper compared to more established developers.
Due to the complexity of the process, the budget to publish a game by yourself on a

2
tutorials/platform/customizing_html5_shell.md
View File

@ -19,7 +19,7 @@ Some use-cases where customizing the default page is useful include:
- Passing custom command line arguments, e.g. `-s` to start a `MainLoop` script.
The default HTML page is available in the Godot Engine repository at
`/misc/dist/html/full-size.html <https://github.com/godotengine/godot/blob/master/misc/dist/html/full-size.html>`__
`/misc/dist/html/full-size.html <https://github.com/godotengine/godot/blob/master/misc/dist/html/full-size.html>`
but the following template can be used as a much simpler example:
.. code-block:: html

2
tutorials/platform/html5_shell_classref.md
View File

@ -7,7 +7,7 @@ Projects exported for the Web expose the :js:class:`Engine` class to the JavaScr
fine control over the engine's start-up process.
This API is built in an asynchronous manner and requires basic understanding
of `Promises <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Using_promises>`__.
of `Promises <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Using_promises>`.
Engine
------

2
tutorials/rendering/jitter_stutter.md
View File

@ -43,7 +43,7 @@ frame timer.
.. note::
You can use physics interpolation to mitigate physics-related jittering.
See `lawnjelly's smoothing-addon <https://github.com/lawnjelly/smoothing-addon>`__
See `lawnjelly's smoothing-addon <https://github.com/lawnjelly/smoothing-addon>`
for an add-on that can be dropped into any project to enable physics interpolation.
Stutter

4
tutorials/rendering/multiple_resolutions.md
View File

@ -302,7 +302,7 @@ Desktop game
Godot currently doesn't have a way to enforce integer scaling when using the
`2d` or `viewport` stretch mode, which means pixel art may look bad if the
final window size is not a multiple of the base window size.
To fix this, use an add-on such as the `Integer Resolution Handler <https://github.com/Yukitty/godot-addon-integer_resolution_handler>`__.
To fix this, use an add-on such as the `Integer Resolution Handler <https://github.com/Yukitty/godot-addon-integer_resolution_handler>`.
Mobile game in landscape mode
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -439,5 +439,5 @@ that it allows enable linear filtering. This makes scaled 3D viewports look
better in many cases.
See the
`3D viewport scaling demo <https://github.com/godotengine/godot-demo-projects/tree/master/viewport/3d_scaling>`__
`3D viewport scaling demo <https://github.com/godotengine/godot-demo-projects/tree/master/viewport/3d_scaling>`
for examples.

2
tutorials/scripting/cross_language_scripting.md
View File

@ -177,5 +177,5 @@ Inheritance
A GDScript file may not inherit from a C# script. Likewise, a C# script may not
inherit from a GDScript file. Due to how complex this would be to implement,
this limitation is unlikely to be lifted in the future. See
`this GitHub issue <https://github.com/godotengine/godot/issues/38352>`__
`this GitHub issue <https://github.com/godotengine/godot/issues/38352>`
for more information.

2
tutorials/scripting/debug/debugger_panel.md
View File

@ -16,7 +16,7 @@ Debugger
The Debugger tab opens automatically when the GDScript compiler reaches
a breakpoint in your code.
It gives you a `stack trace <https://en.wikipedia.org/wiki/Stack_trace>`__,
It gives you a `stack trace <https://en.wikipedia.org/wiki/Stack_trace>`,
information about the state of the object, and buttons to control
the program's execution.

2
tutorials/scripting/evaluating_expressions.md
View File

@ -48,7 +48,7 @@ The following operators are available:
+------------------------+-------------------------------------------------------------------------------------+
Spaces around operators are optional. Also, keep in mind the usual
`order of operations <https://en.wikipedia.org/wiki/Order_of_operations>`__
`order of operations <https://en.wikipedia.org/wiki/Order_of_operations>`
applies. Use parentheses to override the order of operations if needed.
All the Variant types supported in Godot can be used: integers, floating-point

2
tutorials/scripting/gdscript/gdscript_styleguide.md
View File

@ -9,7 +9,7 @@ discussions, and tutorials. Hopefully, this will also support the development of
auto-formatting tools.
Since GDScript is close to Python, this guide is inspired by Python's
`PEP 8 <https://www.python.org/dev/peps/pep-0008/>`__ programming
`PEP 8 <https://www.python.org/dev/peps/pep-0008/>` programming
style guide.
Style guides aren't meant as hard rulebooks. At times, you may not be able to

2
tutorials/scripting/gdscript/static_typing.md
View File

@ -191,7 +191,7 @@ an error or not at runtime.
This happens when you get a child node. Let's take a timer for example:
with dynamic code, you can get the node with `$Timer`. GDScript
supports `duck-typing <https://stackoverflow.com/a/4205163/8125343>`__,
supports `duck-typing <https://stackoverflow.com/a/4205163/8125343>`,
so even if your timer is of type `Timer`, it is also a `Node` and an
`Object`, two classes it extends. With dynamic GDScript, you also
don't care about the node's type as long as it has the methods you need

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