doc: fix typos in engine documentation

copying.md

@@ -169,6 +169,7 @@ _the openage authors_ are:
 |                             | bytegrrrl                   | bytegrrrl à proton dawt me                        |
 | Nicolas Sanchez             | nicolassanchez02            | nicolasjpsanchez à gmail dawt com                 |
 | Manas Pradhan               | manas-maker                 | manasmpradhan5 à gmail dawt com                   |
+| Erwan Billard               | iacker                      | 82095453+iacker à users dawt noreply dawt github dawt com |
 
 If you're a first-time committer, add yourself to the above list. This is not
 just for legal reasons, but also to keep an overview of all those nicknames.

doc/building.md

@@ -168,7 +168,7 @@ The reference package is [created for Gentoo](https://github.com/SFTtech/gentoo-
 - My `Qt`/`Python`/whatever is installed somewhere, but `cmake` can't find it!
   - Run `ccmake` or `cmake-gui` in the build directory to see and change config variables.
   - You can manually tell `cmake` where to look. Try something along the lines of
-    - `./configure -- -DPYTHON_INCLUDE_DIRS=/whereever/python/include/`
+    - `./configure -- -DPYTHON_INCLUDE_DIRS=/wherever/python/include/`
     - `-DPython3_EXECUTABLE=/your/py3/directory/`
 
 - I get compiler errors about missing header files

doc/code/converter/workflow.md

@@ -104,7 +104,7 @@ a Python object type used for storing the attribute.
 or can be skipped (e.g. `SKIP`).
 
 The Reader parses attributes one by one and stores them in a `ValueMember` subclass
-that is associated with a value type. Its output is a list of `ValueMember` intances.
+that is associated with a value type. Its output is a list of `ValueMember` instances.
 
 ## Processor
 

doc/code/curves.md

@@ -61,7 +61,7 @@ The usable types are explained in more detail in the [Curve Types](#curve-types)
 
 Keyframes are implemented as time-value pairs by the `Keyframe` class. `KeyframeContainer`
 is used by all curves to manage their keyframe storage. It also provides functionality to
-efficiently access and insert keyframes as wel as sorting them by time. For the time
+efficiently access and insert keyframes as well as sorting them by time. For the time
 type, the [simulation time type](/doc/code/time.md) from the `openage::time` namespace is
 used.
 
@@ -95,11 +95,11 @@ Primitive curves are intended for members with single value types. These include
 the primitive C++ types (e.g. `int`, `float`, `std::string`), simple structs and data classes,
 and shared pointers.
 
-On contruction of a primitive curve object, a keyframe with time `t = time::time_t::min_value()`
-and the value's type is instanciated with its default constructor. This is done to ensure that for any
+On construction of a primitive curve object, a keyframe with time `t = time::time_t::min_value()`
+and the value's type is instantiated with its default constructor. This is done to ensure that for any
 requested time `t`, there is always a valid value to be returned. This mirrors the expected
 behaviour from declaring primitive values in C++ where members may be auto-initialized without
-explicit assignment to a default value. The default value for curves can also be explicitely
+explicit assignment to a default value. The default value for curves can also be explicitly
 assigned in the constructor. Types that don't have a default constructor require that a
 default value is passed to the curve constructor.
 
@@ -167,7 +167,7 @@ the value of the previous keyframe is used (like on discrete curves).
 Value types on continuous curves need to implement methods for the `operator*(..)` and
 `operator-(..)` operations to support linear interpolation. In particular, `operator*(..)`
 must support multiplication with `time::time_t` and `operator-(..)` must support
-substraction for values of the same type.
+subtraction for values of the same type.
 
 Continuous curves do not allow jumps between keyframe values (hence "continuous").
 Therefore, there cannot be two keyframes inserted for the same time `t`.

doc/code/event_system.md

@@ -35,7 +35,7 @@ earliest to latest invoke time. During execution, events may trigger the resched
 other events if there are dependencies between the events.
 
 Both the creation and execution of events require passing a `State` object that functions
-as a persistant global storage for values that are not linked to a specific event executions.
+as a persistent global storage for values that are not linked to a specific event executions.
 In practice, `State` is primarily used to pass the state of the [game simulation](/doc/code/game_simulation/)
 to the event system via an object of the derived `GameState` class. This object allows
 access to the indexing structures of the current game that can be used to retrieve

doc/code/game_simulation/components.md

@@ -125,6 +125,6 @@ The component stores no runtime data.
 **nyan API object:** [`engine.ability.type.Turn`](/doc/nyan/api_reference/reference_ability.md#abilitytypeturn)
 
 The `Turn` component represents the game entity's ability to change directions in the game world.
-Turning is implicitely required for moving but it also works on its own.
+Turning is implicitly required for moving but it also works on its own.
 
 The component stores no runtime data.

doc/code/game_simulation/game_entity.md

@@ -91,7 +91,7 @@ make the game logic maintanable and extensible.
 For a description of the available systems, check the [system reference](systems.md).
 
 A *system* in openage is basically a function that operates on game entity
-components. They are explicitely separated from game entity and component objects
+components. They are explicitly separated from game entity and component objects
 to allow for more flexible implementation. In practice, systems are implemented as static
 functions inside the `gamestate::system` namespace.
 

doc/code/input/README.md

@@ -1,6 +1,6 @@
 # Input Management
 
-Input managment concerns the handling external input sources that are used to interact with the engine.
+Input management concerns the handling external input sources that are used to interact with the engine.
 The most common example for such input sources are probably **keyboard and mouse**, but other things like the **GUI**,
 **networking** and **scripting** also fall under this umbrella.
 
@@ -154,7 +154,7 @@ of what's going on inside the gamestate than the low-level input manager.
 A controller receives input event data (as an `event_arguments` struct) as well as a `BindingContext`
 from the input manager. It uses the provided information to create a game event that can then be attached
 to the gamestate event loop. To do this, the controller looks up a `binding_action` struct from
-in binding context using the input event signature or class (similiar to how its works in the low level
+in binding context using the input event signature or class (similar to how its works in the low level
 interface).
 
 `binding_action` contains the following information:

doc/code/pathfinding/README.md

@@ -62,7 +62,7 @@ pathfinder to preselect the sectors that flow fields need to be generated for (s
 
 The individual movement cost of each cell in a sector are recorded in a `CostField` object.
 The cost of a cell can range from 1 (minimum cost) to 254 (maximum cost), while a cost of 255
-makes a cell impassible. For Age of Empires, usually only the minimum and impassable cost
+makes a cell impassable. For Age of Empires, usually only the minimum and impassable cost
 values are relevant. The cost field is built when the grid is first initialized and
 individual cost of cells can be altered during gameplay events.
 

doc/code/renderer/demos.md

@@ -14,7 +14,7 @@ This documents describes the purpose of each demo and contains instructions on h
 
 ### Demo 0
 
-This demo shows the creation of a minmal renderer setup and the rendering of a simple mesh.
+This demo shows the creation of a minimal renderer setup and the rendering of a simple mesh.
 
 The demo initializes a GUI application, a window, a renderer object, and a render pass.
 It then loads a shader program and creates a single mesh object which is then rendered to the screen

doc/code/renderer/level1.md

@@ -284,7 +284,7 @@ std::shared_ptr<RenderPass> pass2 = renderer->add_render_pass({ obj2 }, renderer
 
 A color texture is not the only type of texture that can be assigned to a texture
 target. We can also add depth textures or additional (color) textures that the shader
-can write arbritrary values into.
+can write arbitrary values into.
 
 ```c++
 std::shared_ptr<Texture2d> depth_texture = renderer->add_texture(
@@ -414,7 +414,7 @@ resources::VertexInputInfo info{
 As seen above, we have to define 3 parameters.
 
 1. **Vertex Input Layout**: Defines how the vertex data of each vertex is split up in the vertex shader. In this case, a vertex consists of a `vec2` for the position and a `vec2` for the texture coordinates.
-1. **Vertex Buffer Layout**: Defines how the vertex data of all vertices is layed out in the whole buffer. `AOS` is *array of structs* which means that vertex data is interleaved.
+1. **Vertex Buffer Layout**: Defines how the vertex data of all vertices is laid out in the whole buffer. `AOS` is *array of structs* which means that vertex data is interleaved.
 1. **Vertex Primitive**: Type of primitive used for drawing the vertices.
 
 Afterwards, vertices can be copied into a byte array which is then passed
@@ -569,7 +569,7 @@ void main() {
 Placeholders are inserted as comments into the GLSL source. Every placeholder has an ID for
 referencing. For these IDs, *snippets* can be defined to insert code in place of the placeholder
 comment. Placeholders can be placed at any position in the template, so they can be used to insert
-other statements than the control code, including unforms, input/output variables, functions and more.
+other statements than the control code, including uniforms, input/output variables, functions and more.
 
 The snippets for the above example may look like this:
 

doc/code/renderer/level2.md

@@ -37,7 +37,7 @@ There are two render stages that can receive updates from the gamestate: `WorldR
 
 As you can see, the workflow for both render stages is roughly the same and involves these components:
   - **game entity**: Object in the game world managed by the gamestate, e.g. a unit or a building.
-  - **render entity**: Connector object between game entity and the render stage. The game entity sends updates to the render entity to communicate what should be displyed. Furthermore, the render entity transforms said updates into something usable by the renderer, e.g. loading the texture for a texture ID. Render entities also contain the critical path between the gamestate and renderer thread boundaries.
+  - **render entity**: Connector object between game entity and the render stage. The game entity sends updates to the render entity to communicate what should be displayed. Furthermore, the render entity transforms said updates into something usable by the renderer, e.g. loading the texture for a texture ID. Render entities also contain the critical path between the gamestate and renderer thread boundaries.
   - **render object(s)**: Store the current render state for a `Renderable` created for a render entity, e.g. uniforms, meshes or IDs. There can be a variable number of these objects depending on the complexity of the render state. For example, the `TerrainRenderer` stage has separate objects for the mesh (`TerrainMesh`) and model (`TerrainModel`) for its terrain. Render objects poll the render entity for updates every frame and may change the render state when updated.
   - **(sub-)renderer**: Manages all render objects for the render stage, i.e. by polling them for updates and creating level 1 `Renderable`s from their render state which are added to the stage's render pass. New render entities are also registered at the subrenderer. Upon registration, the subrenderer creates the necessary render objects and attaches them to the render entity.
   - **render factory**: Factory in the gamestate for creating and registering new render entities. Game entities can request render entities from the factory, which then also registers the render entity at the corresponding subrenderer. The render factory lives in the gamestate thread, but crosses thread boundaries when registering new render entities. Therefore, it is also part of the critical path.
@@ -61,7 +61,7 @@ Zoom levels can also be adjusted with these methods:
 
 For displaying 3D objects, the `Camera` can also calculate a view matrix (`get_view_matrix()`) and projection matrix (`get_projection_matrix()`) that take current position and zoom level into account.
 
-Camera parameters may be used for raycasting operations, e.g. mouse picking/selection. Since the camera utilizes orthographic projection and a fied angle, the ray direction is exactly the same as the camera direction vector (accessible as `cam_direction`). To find the origin point of a ray for a pixel coordinate in the viewport, the `get_input_pos(..)` method can be used. This method calculates the position of the pixel coordinate on the othographic camera plane that represents the viewport. The result is the absolute position of the pixel coordinate inside the 3D scene. Ray origin point and direction can then be used to perform calculations for line-plane or line sphere intersections.
+Camera parameters may be used for raycasting operations, e.g. mouse picking/selection. Since the camera utilizes orthographic projection and a fixed angle, the ray direction is exactly the same as the camera direction vector (accessible as `cam_direction`). To find the origin point of a ray for a pixel coordinate in the viewport, the `get_input_pos(..)` method can be used. This method calculates the position of the pixel coordinate on the orthographic camera plane that represents the viewport. The result is the absolute position of the pixel coordinate inside the 3D scene. Ray origin point and direction can then be used to perform calculations for line-plane or line sphere intersections.
 
 ### Frustum Culling
 

doc/ide/vscode.md

@@ -5,7 +5,7 @@ vscode can be used to launch build, edit, run and debug C++ code.
 There are two different versions of vscode that you can use:
 
 * The official *vscode* release from Microsoft for which you can get an installer on the the Visual Studio Code website.
-* The inofficial fork *vscodium* that removes all proprietary components and disables telemetry. You can find it [here](https://vscodium.com/).
+* The unofficial fork *vscodium* that removes all proprietary components and disables telemetry. You can find it [here](https://vscodium.com/).
 
 
 ## Setting up vscode for openage

doc/media_convert.md

@@ -10,7 +10,7 @@ Currently we *support* conversion for these games:
 * **SWGB**: Star Wars: Galactic Battlegrounds + Clone Campaigns
 * **HD**: Age of Empires 2 (2013) (formerly: Age of Empires 2: HD Edition)
 * **DE1**: Age of Empires 1: Definitive Edition
-* **DE2**: Age of Empires 2: Definitve Edition
+* **DE2**: Age of Empires 2: Definitive Edition
 
 On Linux, you may have to use additional measures to download DE2 versions from Steam: