Merge pull request #3458 from pycbouh/replace-be-with-ae

Replace British spelling and fix various typos

about/introduction.rst

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

community/channels.rst

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

community/contributing/code_style_guidelines.rst

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

community/contributing/documentation_guidelines.rst

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

community/contributing/pr_workflow.rst

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

community/contributing/updating_the_class_reference.rst

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

community/contributing/ways_to_contribute.rst

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

getting_started/editor/unity_to_godot.rst

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

getting_started/scripting/c_sharp/c_sharp_basics.rst

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

getting_started/step_by_step/ui_code_a_life_bar.rst

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

getting_started/step_by_step/ui_game_user_interface.rst

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

getting_started/step_by_step/ui_main_menu.rst

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

getting_started/workflow/assets/escn_exporter/animation.rst

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

getting_started/workflow/export/exporting_for_web.rst

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

tutorials/2d/2d_lights_and_shadows.rst

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

tutorials/3d/fps_tutorial/part_four.rst

@@ -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):
 

tutorials/3d/fps_tutorial/part_six.rst

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

tutorials/animation/animation_tree.rst

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

tutorials/animation/introduction_2d.rst

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

tutorials/inputs/inputevent.rst

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

tutorials/networking/high_level_multiplayer.rst

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

tutorials/shading/advanced_postprocessing.rst

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

tutorials/shading/shading_reference/canvas_item_shader.rst

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

tutorials/shading/shading_reference/shading_language.rst

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

tutorials/vr/vr_primer.rst

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