godotengine/godot-docs
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs.git synced 2026-01-04 14:11:02 +03:00
Code Issues Packages Projects Releases Wiki Activity

Replace British spelling and fix various typos

Browse Source
This commit is contained in:
Yuri Sizov
2020-04-01 12:23:23 +03:00
parent e4237e2948
commit 135b33b768
25 changed files with 45 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
about/introduction.rst
View File

@@ -76,7 +76,7 @@ attribution to "Juan Linietsky, Ariel Manzur and the Godot Engine community".
Organization of the documentation
---------------------------------
This documentation is organised in five sections with an impressively
This documentation is organized in five sections with an impressively
unbalanced distribution of contents – but the way it is split up should be
relatively intuitive:

2
community/channels.rst
View File

@@ -47,7 +47,7 @@ Social networks
- `Facebook group <https://www.facebook.com/groups/godotengine/>`_
- `Twitter (also, #godotengine) <https://twitter.com/godotengine>`_
- `Reddit <https://www.reddit.com/r/godot>`_
- `Youtube <https://www.youtube.com/c/GodotEngineOfficial>`_
- `YouTube <https://www.youtube.com/c/GodotEngineOfficial>`_
- `Steam <https://steamcommunity.com/app/404790>`_
Forum

14
community/contributing/code_style_guidelines.rst
View File

@@ -34,16 +34,16 @@ not introducing trailing whitespace or space-based indentation, you should be
fine. If you plan to contribute regularly however, we strongly advise that you
setup clang-format locally to check and automatically fix all your commits.
.. warning:: Godot's code style should *not* be applied to thirdparty code,
.. warning:: Godot's code style should *not* be applied to third-party code,
i.e. that is included in Godot's source tree but was not written
specifically for our project. Such code usually come from
different upstream projects with their own style guides (or lack
thereof), and don't want to introduce differences that would make
syncing with upstream repositories harder.
Thirdparty code is usually included in the ``thirdparty/`` folder
Third-party code is usually included in the ``thirdparty/`` folder
and can thus easily be excluded from formatting scripts. For the
rare cases where a thirdparty code snippet needs to be included
rare cases where a third-party code snippet needs to be included
directly within a Godot file, you can use
``/* clang-format off */`` and ``/* clang-format on */`` to tell
clang-format to ignore a chunk of code.
@@ -139,11 +139,11 @@ ones, the following rules should be followed:
includes should be done with quotes, e.g. ``#include "core/object.h"``. The
block of Godot header includes should then be followed by an empty line for
separation.
- Finally, thirdparty headers (either from ``thirdparty`` or from the system's
- Finally, third-party headers (either from ``thirdparty`` or from the system's
include paths) come next and should be included with the < and > symbols, e.g.
``#include <png.h>``. The block of thirdparty headers should also be followed
``#include <png.h>``. The block of third-party headers should also be followed
by an empty line for separation.
- Godot and thirdparty headers should be included in the file that requires
- Godot and third-party headers should be included in the file that requires
them, i.e. in the `.h` header if used in the declarative code or in the `.cpp`
if used only in the imperative code.
@@ -240,7 +240,7 @@ Java
Godot's Java code (mostly in ``platform/android``) is also enforced via
``clang-format``, so see the instructions above to set it up. Keep in mind that
this style guide only applies to code written and maintained by Godot, not
thirdparty code such as the ``java/src/com/google`` subfolder.
third-party code such as the ``java/src/com/google`` subfolder.
Python
------

2
community/contributing/documentation_guidelines.rst
View File

@@ -52,7 +52,7 @@ reading as follows:
3. Complete all the edits you want to make for that page.
4. Summarise the changes you made in the form at the bottom of the page and
4. Summarize the changes you made in the form at the bottom of the page and
click the button labelled **Propose file change** when done.
5. On the following screens, click the **Create pull request** button until you

4
community/contributing/pr_workflow.rst
View File

@@ -21,7 +21,7 @@ the *master* branch).
We will go together through an example to show the typical workflow and
associated Git commands. But first, let's have a quick look at the
organisation of Godot's Git repository.
organization of Godot's Git repository.
Git source repository
---------------------
@@ -442,7 +442,7 @@ will raise an error:
hint: Updates were rejected because the tip of your current branch is behind
hint: its remote counterpart.
This is a sane behaviour, Git will not let you push changes that would
This is a sane behavior, Git will not let you push changes that would
override remote content. But that's actually what we want to do here, so we
will have to *force* it:

4
community/contributing/updating_the_class_reference.rst
View File

@@ -79,7 +79,7 @@ You can check the list of all remote servers with:
git remote -v
You should have two: ``origin``, your fork on github, that git adds by default, and ``upstream``, that you just added:
You should have two: ``origin``, your fork on GitHub, that git adds by default, and ``upstream``, that you just added:
::
@@ -162,7 +162,7 @@ How to edit class XML
Edit the file for your chosen class in ``doc/classes/`` to update the class reference. The folder contains an XML file for each class. The XML lists the constants and methods you'll find in the class reference. Godot generates and updates the XML automatically.
Edit it using your favourite text editor. If you use a code editor, make sure that it doesn't change the indent style: tabs for the XML, and 4 spaces inside BBcode-style blocks. More on that below.
Edit it using your favorite text editor. If you use a code editor, make sure that it doesn't change the indent style: tabs for the XML, and 4 spaces inside BBcode-style blocks. More on that below.
If you need to check that the modifications you've made are correct in the generated documentation, build Godot as described :ref:`here <toc-devel-compiling>`, run the editor and open the help for the page you modified.

2
community/contributing/ways_to_contribute.rst
View File

@@ -41,7 +41,7 @@ positive to the engine, regardless of their skill set:
user donations for many things. Apart from usual expenses such as hosting
costs or promotional material on events, we also use donation money to
acquire hardware when necessary (e.g. we used donation money to buy a
Macbook Pro to implement Retina/HiDPI support and various other
MacBook Pro to implement Retina/HiDPI support and various other
macOS-related features).
Most importantly, we also used donation money to hire core developers so they
can work full-time on the engine. Even with a low

12
getting_started/editor/unity_to_godot.rst
View File

@@ -12,7 +12,7 @@ and aims to help you migrate your existing Unity experience into the world of Go
.. note::
This article talks about older versions of Unity. Nestable prefabs ('Nested prefabs') were added to Unity 2018.3. Nestable prefabs are analogous to Godot's scenes, and allow a more Godot-like approach to scene organisation.
This article talks about older versions of Unity. Nestable prefabs ('Nested prefabs') were added to Unity 2018.3. Nestable prefabs are analogous to Godot's scenes, and allow a more Godot-like approach to scene organization.
Differences
-----------
@@ -28,7 +28,7 @@ Differences
| | * **Mobile:** Android, iOS, Windows Phone, Tizen | * **Mobile:** Android, iOS |
| | * **Web:** WebAssembly or asm.js | * **Web:** WebAssembly |
| | * **Consoles:** PS4, PS Vita, Xbox One, Xbox 360, Wii U, Nintendo 3DS | * **Console:** See :ref:`doc_consoles` |
| | * **VR:** Oculus Rift, SteamVR, Google Cardboard, Playstation VR, Gear VR, HoloLens| * **VR:** Oculus Rift, SteamVR |
| | * **VR:** Oculus Rift, SteamVR, Google Cardboard, PlayStation VR, Gear VR, HoloLens| * **VR:** Oculus Rift, SteamVR |
| | * **TV:** Android TV, Samsung SMART TV, tvOS | |
+-------------------+------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+
| Scene system | * Component/Scene (GameObject > Component) | :ref:`Scene tree and nodes <doc_scenes_and_nodes>`, allowing scenes to be nested and/or inherit other scenes |
@@ -87,7 +87,7 @@ and debugging/live editing on it after the game is exported.
The scene system
----------------
This is the most important difference between Unity and Godot and the favourite feature of most Godot users.
This is the most important difference between Unity and Godot and the favorite feature of most Godot users.
Working on a 'level' in Unity usually means embedding all the required assets in a scene
and linking them together with components and scripts.
@@ -116,14 +116,14 @@ Consider the player as an element we'd like to use in different parent scenes (f
2. **A scene for the Enemy.**
An enemy is also an element we'd like to use in several scenes. It's almost the same
as the Player node. The only differences are the script (it needs 'AI' routines to generate the enemy's behaviour)
as the Player node. The only differences are the script (it needs 'AI' routines to generate the enemy's behavior)
and the sprite textures used by the AnimatedSprite node.
3. **A Level scene.**
A Level scene is composed of Bricks (for platforms), Coins (for the player to collect) and a
number of instances of the Enemy scene. Each instance is a node in the Level scene tree. These instances are separate enemies,
which initially have shared behaviour and appearance as defined in the Enemy scene. You can set different properties for each Enemy node (to change its color, for example).
which initially have shared behavior and appearance as defined in the Enemy scene. You can set different properties for each Enemy node (to change its color, for example).
4. **A Main scene.**
The Main scene would be composed of one root node with 2 children: a Player instance node, and a Level instance node.
@@ -202,7 +202,7 @@ please read the :ref:`doc_gdscript` and :ref:`doc_faq` pages. GDScript is strong
and doesn't take long to learn: Between one evening for an experienced programmer and a week for a complete beginner.
Unity allows you to attach as many scripts as you want to a GameObject.
Each script adds a behaviour to the GameObject: For example, you can attach a script so that it reacts to the player's controls,
Each script adds a behavior to the GameObject: For example, you can attach a script so that it reacts to the player's controls,
and another that controls its specific game logic.
In Godot, you can only attach one script per node. You can use either an external GDScript file

2
getting_started/scripting/c_sharp/c_sharp_basics.rst
View File

@@ -35,7 +35,7 @@ page in the Mono documentation.
Setting up C# for Godot
-----------------------
Windows (Visaul Studio)
Windows (Visual Studio)
~~~~~~~~~~~~~~~~~~~~~~~
Download and install the latest version of

2
getting_started/step_by_step/ui_code_a_life_bar.rst
View File

@@ -110,7 +110,7 @@ scene:
.. note::
The project uses a simple organisation that works for game jams and tiny games.
The project uses a simple organization that works for game jams and tiny games.
At the root of the project, in the `res://` folder, you will find the `LevelMockup`. That's the main game scene and the one we will work with. All the components that make up the game are in the `scenes/` folder. The `assets/` folder contains the game sprites and the font for the HP counter. In the `scripts/` folder you will find the enemy, the player, and the GUI controller scripts.

2
getting_started/step_by_step/ui_game_user_interface.rst
View File

@@ -22,7 +22,7 @@ Download the project files: :download:`ui_gui_design.zip <files/ui_gui_design.zi
.. note::
You can watch this tutorial as a `video on Youtube <https://www.youtube.com/watch?v=y1E_y9AIqow>`_.
You can watch this tutorial as a `video on YouTube <https://www.youtube.com/watch?v=y1E_y9AIqow>`_.
Breaking down the UI
--------------------

4
getting_started/step_by_step/ui_main_menu.rst
View File

@@ -191,8 +191,8 @@ containers split the area into two: a left and a right side or a top and
a bottom side. They also allow the user to resize the left and right
areas using an interactive bar. On the other hand, ``HBoxContainer``
just splits itself into as many columns as it has children. Although you
can deactivate the split container's resize behaviour, I recommend to
favour box containers.
can deactivate the split container's resize behavior, I recommend to
favor box containers.
Select the ``MarginContainer`` and add an ``HBoxContainer``. Then, we
need two containers as children of our ``HBoxContainer``: a

2
getting_started/workflow/assets/escn_exporter/animation.rst
View File

@@ -81,7 +81,7 @@ are placed in just one AnimationPlayer in the scene root.
**Mode 'Animation as Action with Squash'**
This mode has very similar behaviour of mode 'Animation as Action', but it
This mode has very similar behavior of mode 'Animation as Action', but it
can generate fewer AnimationPlayers; objects in parent-children relationship would
share their AnimationPlayer. It is useful when you have several rigs, and each
Skeleton and Mesh has actions; then one rig would have just one AnimationPlayer.

4
getting_started/workflow/export/exporting_for_web.rst
View File

@@ -116,10 +116,10 @@ The following functionality is currently unavailable on the HTML5 platform:
- Threads
- GDNative
- C#
- Clipboard synchronisation between engine and operating system
- Clipboard synchronization between engine and operating system
- Networking other than :ref:`class_HTTPClient` and :ref:`class_WebSocketClient`
.. tip:: Check the `list of open HTML5 issues on Github
.. tip:: Check the `list of open HTML5 issues on GitHub
<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.

2
tutorials/2d/2d_lights_and_shadows.rst
View File

@@ -14,7 +14,7 @@ to make a scene like the demo step by step.
.. image:: img/light_shadow_main.png
All the resources for this tutorial can be found in the `official demo repository <https://github.com/godotengine/godot-demo-projects>`_
on github. I suggest you download it before starting. Alternatively,
on GitHub. I suggest you download it before starting. Alternatively,
it can be downloaded from the Project Manager. Launch Godot and in the top
bar select "Templates" and search for "2D Lights and Shadows Demo".

4
tutorials/3d/fps_tutorial/part_four.rst
View File

@@ -118,7 +118,7 @@ If there is a joypad connected, we then get its left stick axes for right/left a
Because a wired Xbox 360 controller has different joystick axis mapping based on OS, we will use different axes based on
the OS.
.. warning:: This tutorial assumes you are using a XBox 360 or a Playstation wired controller.
.. warning:: This tutorial assumes you are using a XBox 360 or a PlayStation wired controller.
Also, I do not (currently) have access to a Mac computer, so the joystick axes may need changing.
If they do, please open a GitHub issue on the Godot documentation repository! Thanks!
@@ -178,7 +178,7 @@ Make a new function called ``process_view_input`` and add the following:
rotation_helper.rotation_degrees = camera_rot
# ----------------------------------
.. code-tab:: gdscript Playstation Controller
.. code-tab:: gdscript PlayStation Controller
func process_view_input(delta):

4
tutorials/3d/fps_tutorial/part_six.rst
View File

@@ -1014,9 +1014,9 @@ At this point, you have a good base to build more complicated FPS games.
Other than that, the source is exactly the same, just with helpful comments explaining what
each part does.
.. tip:: The finished project source is hosted on Github as well: https://github.com/TwistedTwigleg/Godot_FPS_Tutorial
.. tip:: The finished project source is hosted on GitHub as well: https://github.com/TwistedTwigleg/Godot_FPS_Tutorial
**Please note that the code in Github may or may not be in sync with the tutorial in the documentation**.
**Please note that the code in GitHub may or may not be in sync with the tutorial in the documentation**.
The code in the documentation is likely better managed and/or more up to date.
If you are unsure of which to use, use the project(s) provided in the documentation, as they are maintained by the Godot community.

2
tutorials/animation/animation_tree.rst
View File

@@ -212,7 +212,7 @@ Check the "Parameters" section of the ``AnimationTree`` node to see all the para
.. image:: img/animtree16.png
This is handy because it makes it possible to animate them from an ``AnimationPlayer``, or even the ``AnimationTree`` itself,
allowing the realisation of very complex animation logic.
allowing the realization of very complex animation logic.
To modify these values from code, the property path must be obtained. This is done easily by hovering the mouse over any of the parameters:

2
tutorials/animation/introduction_2d.rst
View File

@@ -212,7 +212,7 @@ the end.
Animation loop
If you set the animation length to 4 seconds now, the animation moves
back and forth. You can change this behaviour if you change the track's
back and forth. You can change this behavior if you change the track's
loop mode. This is covered in the next chapter.
Track settings

6
tutorials/inputs/inputevent.rst
View File

@@ -115,7 +115,7 @@ specific Controls, only direct ancestors of the targeted Control node receive th
In accordance with Godot's node-based design, this enables
specialized child nodes to handle and consume particular events, while
their ancestors, and ultimately the scene root, can provide more
generalized behaviour if needed.
generalized behavior if needed.
Anatomy of an InputEvent
------------------------
@@ -124,14 +124,14 @@ Anatomy of an InputEvent
anything and only contains some basic information, such as event ID
(which is increased for each event), device index, etc.
There are several specialised types of InputEvent, described in the table below:
There are several specialized types of InputEvent, described in the table below:
+-------------------------------------------------------------------+--------------------+-----------------------------------------+
| Event | Type Index | Description |
+-------------------------------------------------------------------+--------------------+-----------------------------------------+
| :ref:`InputEvent <class_InputEvent>` | NONE | Empty Input Event. |
+-------------------------------------------------------------------+--------------------+-----------------------------------------+
| :ref:`InputEventKey <class_InputEventKey>` | KEY | Contains a scancode and unicode value, |
| :ref:`InputEventKey <class_InputEventKey>` | KEY | Contains a scancode and Unicode value, |
| | | as well as modifiers. |
+-------------------------------------------------------------------+--------------------+-----------------------------------------+
| :ref:`InputEventMouseButton <class_InputEventMouseButton>` | MOUSE_BUTTON | Contains click information, such as |

2
tutorials/networking/high_level_multiplayer.rst
View File

@@ -65,7 +65,7 @@ This class interface can abstract most types of network layers, topologies and l
provides an implementation based on ENet (:ref:`NetworkedMultiplayerEnet <class_NetworkedMultiplayerENet>`),
one based on WebRTC (:ref:`WebRTCMultiplayer <class_WebRTCMultiplayer>`), and one based on WebSocket
(:ref:`WebSocketMultiplayerPeer <class_WebSocketMultiplayerPeer>`), but this could be used to implement
mobile APIs (for adhoc WiFi, Bluetooth) or custom device/console-specific networking APIs.
mobile APIs (for ad hoc WiFi, Bluetooth) or custom device/console-specific networking APIs.
For most common cases, using this object directly is discouraged, as Godot provides even higher level networking facilities.
Yet it is made available in case a game has specific needs for a lower level API.

4
tutorials/shading/advanced_postprocessing.rst
View File

@@ -91,8 +91,8 @@ When displaying depth directly from the ``DEPTH_TEXTURE``, everything will look
white unless it is very close. This is because the depth buffer stores objects closer
to the camera using more bits than those further, so most of the detail in depth
buffer is found close to the camera. In order to make the depth value align with world or
model coordinates, we need to linearise the value. When we apply the projection matrix to the
vertex position, the z value is made nonlinear, so to linearise it, we multiply it by the
model coordinates, we need to linearize the value. When we apply the projection matrix to the
vertex position, the z value is made nonlinear, so to linearize it, we multiply it by the
inverse of the projection matrix, which in Godot, is accessible with the variable
``INV_PROJECTION_MATRIX``.

2
tutorials/shading/shading_reference/canvas_item_shader.rst
View File

@@ -143,7 +143,7 @@ the texture color for such nodes, use:
COLOR = texture(TEXTURE, UV);
This differs from the behaviour of the built-in normal map. If a normal map is attached, Godot uses
This differs from the behavior of the built-in normal map. If a normal map is attached, Godot uses
it by default and assigns its value to the built-in ``NORMAL`` variable. If you are using a normal
map meant for use in 3D, it will appear inverted. In order to use it in your shader, you must assign
it to the ``NORMALMAP`` property. Godot will handle converting it for use in 2D and overwriting ``NORMAL``.

2
tutorials/shading/shading_reference/shading_language.rst
View File

@@ -625,7 +625,7 @@ to shaders, Godot converts the type automatically. Below is a table of the corre
+-----------------+-----------+
.. note:: Be careful when setting shader uniforms from GDScript, no error will be thrown if the
type does not match. Your shader will just exhibit undefined behaviour.
type does not match. Your shader will just exhibit undefined behavior.
Uniforms can also be assigned default values:

2
tutorials/vr/vr_primer.rst
View File

@@ -74,7 +74,7 @@ The first are our units. In normal 3D games, you don't have to think a lot about
In AR and VR, this changes because things in your virtual world are mapped to things in the real world. If you step 1 meter forward in the real world, but you only move 1 cm forward in your virtual world, you have a problem. The same with the position of your controllers; if they don't appear in the right relative space, it breaks the immersion for the player.
Most VR platforms, including our AR/VR Server, assume that 1 unit = 1 meter. The AR/VR server, however, has a property that, for convenience, is also exposed on the ARVROrigin node called world scale. For instance, setting this to a value of 10 changes our coordinate system so 10 units = 1 meter.
Performance is another thing that needs to be carefully considered. Especially VR taxes your game a lot more than most people realise. For mobile VR, you have to be extra careful here, but even for desktop games, there are three factors that make life extra difficult:
Performance is another thing that needs to be carefully considered. Especially VR taxes your game a lot more than most people realize. For mobile VR, you have to be extra careful here, but even for desktop games, there are three factors that make life extra difficult:
* You are rendering stereoscopic, two for the price of one. While not exactly doubling the work load and with things in the pipeline such as supporting the new MultiView OpenGL extension in mind, there still is an extra workload in rendering images for both eyes
* A normal game will run acceptably on 30fps and ideally manages 60fps. That gives you a big range to play with between lower end and higher end hardware. For any HMD application of AR or VR, however, 60fps is the absolute minimum and you should target your games to run at a stable 90fps to ensure your users don't get motion sickness right off the bat.