Latin quick wins

Author: suearkinunity

Packages/com.unity.inputsystem/Documentation~/KnownLimitations.md

@@ -7,7 +7,7 @@ The following is a list of known limitations that the Input System currently has
 
 ## Compatibility with other Unity features
 
-* Input processing in the background is tied to `Application.runInBackground` (i.e. the "Run In Background" setting in "Player Preferences") which, however, Unity always forces to `true` in __development__ players. This means that in development players, input will always be processed, even if the app is in the background. Of course, this only pertains to platforms where the player can actually run in the background (iOS and Android are thus unaffected).
+* Input processing in the background is tied to `Application.runInBackground` (That is, the "Run In Background" setting in "Player Preferences") which, however, Unity always forces to `true` in __development__ players. This means that in development players, input will always be processed, even if the app is in the background. Of course, this only pertains to platforms where the player can actually run in the background (iOS and Android are thus unaffected).
 * `PlayerInput` split-screen support does not work with Cinemachine virtual cameras.
 * The Input System cannot generate input for IMGUI.
 * UI Toolkit can be used with `InputSystemUIInputModule` but only pointer (mouse, pen, touch) and gamepad input is supported at the moment. XR support is coming.

Packages/com.unity.inputsystem/Documentation~/about-action-assets.md

@@ -4,13 +4,13 @@ uid: input-system-about-action-assets
 
 # About action assets
 
-The Input System stores your configuration of [Input Actions](actions.md) and their associated [bindings](bindings.md), [action maps](create-edit-delete-action-maps.md) and [Control Schemes](control-schemes.md) in an [Action Asset](action-assets.md) file. These Assets have the `.inputactions` file extension and are stored in a plain JSON format.
+The Input System stores your configuration of [Input Actions](actions.md) and their associated [bindings](bindings.md), [action maps](create-edit-delete-action-maps.md) and [Control Schemes](control-schemes.md) in an [action asset](action-assets.md) file. These Assets have the `.inputactions` file extension and are stored in a plain JSON format.
 
 ## Project-wide action assets
 
-The Input System creates an Action Asset when you set up the [default project-wide actions](about-project-wide-actions.md), which is the most common and recommended workflow, but you can also [create new empty Action Assets](./create-empty-action-asset.md) directly in the Project window.
+The Input System creates an action asset when you set up the [default project-wide actions](about-project-wide-actions.md), which is the most common and recommended workflow, but you can also [create new empty action assets](./create-empty-action-asset.md) directly in the Project window.
 
 ## Action maps
 
-Actions assets allow you to group sets of related actions into [action maps](./create-edit-delete-action-maps.md). For example, in an open-world city game, you might create separate action maps for different situations such as exploring on foot, driving a car, flying an aircraft, or navigating UI interfaces. This means, for most common scenarios, you don't need to use more than one Input Action Asset. 
+Actions assets allow you to group sets of related actions into [action maps](./create-edit-delete-action-maps.md). For example, in an open-world city game, you might create separate action maps for different situations such as exploring on foot, driving a car, flying an aircraft, or navigating UI interfaces. This means, for most common scenarios, you don't need to use more than one Input action asset. 
 

Packages/com.unity.inputsystem/Documentation~/about-project-wide-actions.md

@@ -3,11 +3,11 @@ uid: input-system-project-wide-actions
 ---
 # About project-wide actions
 
-You can assign an individual Action Asset to be available "project-wide", which means the actions within that asset are available more conveniently through the Input System API without needing to set up references to the asset.
+You can assign an individual action asset to be available "project-wide", which means the actions within that asset are available more conveniently through the Input System API without needing to set up references to the asset.
 
-When you [assign an Action Asset as project-wide](assign-project-wide-actions.md), it also becomes automatically [preloaded](https://docs.unity3d.com/ScriptReference/PlayerSettings.GetPreloadedAssets.html) when your app starts up, and is kept available until it terminates.
+When you [assign an action asset as project-wide](assign-project-wide-actions.md), it also becomes automatically [preloaded](https://docs.unity3d.com/ScriptReference/PlayerSettings.GetPreloadedAssets.html) when your app starts up, and is kept available until it terminates.
 
-Unless you have specific project requirements that require more than one Action Asset, the recommended workflow is to use a single Action Asset assigned as the project-wide actions.
+Unless you have specific project requirements that require more than one action asset, the recommended workflow is to use a single action asset assigned as the project-wide actions.
 
 
 ## Edit project-wide actions
@@ -20,7 +20,7 @@ Once you have created and assigned project-wide actions, the Input System Packag
 
 ## Using project-wide actions in code
 
-The benefit of assign an Action Asset as the project-wide actions is that you can access the actions directly through the [`InputSystem.actions`](xref:UnityEngine.InputSystem.InputSystem) property directly, rather than needing to set up a reference to your Action Asset first.
+The benefit of assign an action asset as the project-wide actions is that you can access the actions directly through the [`InputSystem.actions`](xref:UnityEngine.InputSystem.InputSystem) property directly, rather than needing to set up a reference to your action asset first.
 
 For example, you can get a reference to an action named "Move" in your project-wide actions using a line of code like this:
 

Packages/com.unity.inputsystem/Documentation~/add-processors-bindings-actions.md

@@ -10,7 +10,7 @@ You can add a processor to an action or binding in the Input Actions Editor.
 
 When you create bindings for your [actions](Actions.md), you can choose to add Processors to the bindings. These process the values from the controls they bind to, before the system applies them to the Action value. For instance, you might want to invert the `Vector2` values from the controls along the Y-axis before passing these values to the Action that drives the input logic for your application. To do this, you can add an [Invert Vector2](ProcessorTypes.md#invert-vector-2) Processor to your binding.
 
-If you're using Actions defined in the [Input Actions Editor](ActionsEditor.md), or in an [Action Asset](ActionAssets.md), you can add any Processor to your bindings in the Input Action editor:
+If you're using Actions defined in the [Input Actions Editor](ActionsEditor.md), or in an [action asset](ActionAssets.md), you can add any Processor to your bindings in the Input Action editor:
 
 1. Select the binding you want to add Processors to so that the Binding Properties panel shows up on the right side.
 2. Select the **Add (+)** icon on the __Processors__ foldout to open a list of all available Processors that match your control type.
@@ -33,7 +33,7 @@ action.AddBinding("<Gamepad>/leftStick")
 
 Processors on Actions work in the same way as Processors on bindings, but they affect all controls bound to an Action, rather than just the controls from a specific binding. If there are Processors on both the binding and the Action, the system processes the ones from the binding first.
 
-You can add and edit Processors on Actions in the [Input Actions Editor](ActionsEditor.md), or in an  [Action Asset](ActionAssets.md) the [same way](#processors-on-bindings) as you would for bindings: select an Action to edit, then add one or more Processors in the right window pane.
+You can add and edit Processors on Actions in the [Input Actions Editor](ActionsEditor.md), or in an  [action asset](ActionAssets.md) the [same way](#processors-on-bindings) as you would for bindings: select an Action to edit, then add one or more Processors in the right window pane.
 
 If you create your Actions in code, you can add Processors like this:
 

Packages/com.unity.inputsystem/Documentation~/add-processors-controls.md

@@ -8,7 +8,7 @@ You can have any number of Processors directly on an [`InputControl`](xref:Unity
 
 The Input System adds Processors to a Control during device creation, if they're specified in the Control's [layout](Layouts.md). You can't add Processors to existing Controls after they've been created, so you can only add Processors to Controls when you're [creating custom devices](Devices.md#creating-custom-devices). The devices that the Input System supports out of the box already have some useful Processors added on their Controls. For instance, sticks on gamepads have a [Stick Deadzone](ProcessorTypes.md#stick-deadzone) Processor.
 
-If you're using a layout generated by the Input System from a [state struct](Devices.md#step-1-the-state-struct) using [`InputControlAttributes`](xref:UnityEngine.InputSystem.Layouts.InputControlAttribute), you can specify the Processors you want to use via the [`processors`](xref:UnityEngine.InputSystem.Layouts.InputControlAttribute) property of the attribute, like this:
+If you're using a layout generated by the Input System from a [state struct](Devices.md#step-1-the-state-struct) using [`InputControlAttributes`](xref:UnityEngine.InputSystem.Layouts.InputControlAttribute), you can specify the Processors you want to use with the [`processors`](xref:UnityEngine.InputSystem.Layouts.InputControlAttribute) property of the attribute, like this:
 
 ```CSharp
 public struct MyDeviceState : IInputStateTypeInfo

Packages/com.unity.inputsystem/Documentation~/apply-interactions-bindings.md

@@ -10,7 +10,7 @@ To apply Interactions to all bindings on an Action, refer to [Apply Interactions
 
 ## Apply Interactions to bindings in the Editor
 
-If you're using [project-wide actions](actions-editor.md), or [Input Action Assets](action-assets.md), you can add any Interaction to your bindings via the Input Action editor. 
+If you're using [project-wide actions](actions-editor.md), or [Input action assets](action-assets.md), you can add any Interaction to your bindings with the Input Action editor. 
 
 1. Once you have [created some bindings](actions-editor.md#bindings), select the binding you want to add Interactions to, so that the right pane of the window displays the properties for that binding. 
 1. Select the plus icon on the __Interactions__ foldout to open a list of all available Interactions types. 

Packages/com.unity.inputsystem/Documentation~/assign-project-wide-actions.md

@@ -9,8 +9,8 @@ To assign an existing Actions Asset as project-wide, do one of the following:
 1. Go to **Edit** > **Project Settings** > **Input System Package**
 2. Drag the asset from your Project window into the **Project-wide Actions** field.
 
-![Screenshot of the Project Settings window, with Input System Package selected. Its settings are displayed on the right of the window. The Project-wide Actions field is empty, and an information box explaining you can assign an Action Asset as project-wide by selecting it in this field or creating it in this window is shown. A button to automatically create and assign the default project-wide Action Asset is displayed under the information box](./Images/InputSettingsNoProjectWideAsset.png)</br>
-*The Input System Package Project Settings with no project-wide actions assigned displays a button to create and assign a default project-wide Action Asset*
+![Screenshot of the Project Settings window, with Input System Package selected. Its settings are displayed on the right of the window. The Project-wide Actions field is empty, and an information box explaining you can assign an action asset as project-wide by selecting it in this field or creating it in this window is shown. A button to automatically create and assign the default project-wide action asset is displayed under the information box](./Images/InputSettingsNoProjectWideAsset.png)</br>
+*The Input System Package Project Settings with no project-wide actions assigned displays a button to create and assign a default project-wide action asset*
 
 or:
 

Packages/com.unity.inputsystem/Documentation~/binding-conflicts.md

@@ -86,7 +86,7 @@ Press(Keyboard.current.leftShiftKey);
 // bAction as well as shiftbAction.
 //
 // What will happen now is that shiftbAction will do its processing first. In response,
-// it will *perform* the action (i.e. we see the `performed` callback being invoked) and
+// it will *perform* the action (That is, we see the `performed` callback being invoked) and
 // thus "consume" the input. bAction will stay silent as it will in turn be skipped over.
 Press(keyboard.bKey);
 ```

Packages/com.unity.inputsystem/Documentation~/configure-bindings-from-code.md

@@ -276,7 +276,7 @@ In addition, you can set these parameters on a 2D Vector Composite:
 
 |Parameter|Description|
 |---------|-----------|
-|[`mode`](xref:UnityEngine.InputSystem.Composites.Vector2Composite)|Whether to treat the inputs as digital or as analog controls.<br><br>If this is set to [`Mode.DigitalNormalized`](xref:UnityEngine.InputSystem.Composites.Vector2Composite.Mode), inputs are treated as buttons (off if below [`defaultButtonPressPoint`](xref:UnityEngine.InputSystem.InputSettings) and on if equal to or greater). Each input is 0 or 1 depending on whether the button is pressed or not. The vector resulting from the up/down/left/right parts is normalized. The result is a diamond-shaped 2D input range.<br><br>If this is set to [`Mode.Digital`](xref:UnityEngine.InputSystem.Composites.Vector2Composite.Mode), the behavior is essentially the same as [`Mode.DigitalNormalized`](xref:UnityEngine.InputSystem.Composites.Vector2Composite.Mode) except that the resulting vector is not normalized.<br><br>Finally, if this is set to [`Mode.Analog`](xref:UnityEngine.InputSystem.Composites.Vector2Composite.Mode), inputs are treated as analog (i.e. full floating-point values) and, other than [`down`](xref:UnityEngine.InputSystem.Composites.Vector2Composite) and [`left`](xref:UnityEngine.InputSystem.Composites.Vector2Composite) being inverted, values will be passed through as is.<br><br>The default is [`Mode.DigitalNormalized`](xref:UnityEngine.InputSystem.Composites.Vector2Composite.Mode).|
+|[`mode`](xref:UnityEngine.InputSystem.Composites.Vector2Composite)|Whether to treat the inputs as digital or as analog controls.<br><br>If this is set to [`Mode.DigitalNormalized`](xref:UnityEngine.InputSystem.Composites.Vector2Composite.Mode), inputs are treated as buttons (off if below [`defaultButtonPressPoint`](xref:UnityEngine.InputSystem.InputSettings) and on if equal to or greater). Each input is 0 or 1 depending on whether the button is pressed or not. The vector resulting from the up/down/left/right parts is normalized. The result is a diamond-shaped 2D input range.<br><br>If this is set to [`Mode.Digital`](xref:UnityEngine.InputSystem.Composites.Vector2Composite.Mode), the behavior is essentially the same as [`Mode.DigitalNormalized`](xref:UnityEngine.InputSystem.Composites.Vector2Composite.Mode) except that the resulting vector is not normalized.<br><br>Finally, if this is set to [`Mode.Analog`](xref:UnityEngine.InputSystem.Composites.Vector2Composite.Mode), inputs are treated as analog (That is, full floating-point values) and, other than [`down`](xref:UnityEngine.InputSystem.Composites.Vector2Composite) and [`left`](xref:UnityEngine.InputSystem.Composites.Vector2Composite) being inverted, values will be passed through as is.<br><br>The default is [`Mode.DigitalNormalized`](xref:UnityEngine.InputSystem.Composites.Vector2Composite.Mode).|
 
 > [!NOTE]
 > There is no support yet for interpolating between the up/down/left/right over time.
@@ -407,7 +407,7 @@ public class CustomComposite : InputBindingComposite<float>
 
     // Any public field that is not annotated with InputControlAttribute is considered
     // a parameter of the composite. This can be set graphically in the UI and also
-    // in the data (e.g. "custom(floatParameter=2.0)").
+    // in the data (For example, "custom(floatParameter=2.0)").
     public float floatParameter;
     public bool boolParameter;
 
@@ -473,7 +473,7 @@ public class CustomParameterEditor : InputParameterEditor<CustomComposite>
 
 ## Changing bindings
 
-In general, you can change existing bindings via the [`InputActionSetupExtensions.ChangeBinding`](xref:UnityEngine.InputSystem.InputActionSetupExtensions) method. This returns an accessor that can be used to modify the properties of the targeted [`InputBinding`](xref:UnityEngine.InputSystem.InputBinding). Note that most of the write operations of the accessor are destructive. For non-destructive changes to bindings, refer to [Applying Overrides](#applying-overrides).
+In general, you can change existing bindings with the [`InputActionSetupExtensions.ChangeBinding`](xref:UnityEngine.InputSystem.InputActionSetupExtensions) method. This returns an accessor that can be used to modify the properties of the targeted [`InputBinding`](xref:UnityEngine.InputSystem.InputBinding). Note that most of the write operations of the accessor are destructive. For non-destructive changes to bindings, refer to [Applying Overrides](#applying-overrides).
 
 ```CSharp
 // Get write access to the second binding of the 'fire' action.

Packages/com.unity.inputsystem/Documentation~/configure-player-input-manager-component.md

@@ -11,7 +11,7 @@ uid: input-system-configure-player-input-manager
 |[`Notification Behavior`](xref:UnityEngine.InputSystem.PlayerInputManager)|How the [`PlayerInputManager`](xref:UnityEngine.InputSystem.PlayerInput) component notifies game code about changes to the connected players. [This works the same way as for the `PlayerInput` component](player-input-component.md#notification-behaviors).|
 |[`Join Behavior`](xref:UnityEngine.InputSystem.PlayerInputManager)|Determines the mechanism by which players can join when joining is enabled. See documentation on [join behaviors](#join-behaviors).|
 |[`Player Prefab`](xref:UnityEngine.InputSystem.PlayerInputManager)|A prefab that represents a player in the game. The [`PlayerInputManager`](xref:UnityEngine.InputSystem.PlayerInputManager) component creates an instance of this prefab whenever a new player joins. This prefab must have one [`PlayerInput`](player-input-component.md) component in its hierarchy.|
-|[`Joining Enabled By Default`](xref:UnityEngine.InputSystem.PlayerInputManager)|While this is enabled, new players can join via the mechanism determined by [`Join Behavior`](xref:UnityEngine.InputSystem.PlayerInputManager).|
+|[`Joining Enabled By Default`](xref:UnityEngine.InputSystem.PlayerInputManager)|While this is enabled, new players can join with the mechanism determined by [`Join Behavior`](xref:UnityEngine.InputSystem.PlayerInputManager).|
 |[`Limit Number of Players`](xref:UnityEngine.InputSystem.PlayerInputManager)|Enable this if you want to limit the number of players who can join the game.|
 |[`Max Player Count`](xref:UnityEngine.InputSystem.PlayerInputManager)(Only shown when `Limit number of Players` is enabled.)|The maximum number of players allowed to join the game.|
 |[`Enable Split-Screen`](xref:UnityEngine.InputSystem.PlayerInputManager)|If enabled, each player is automatically assigned a portion of the available screen area. See documentation on [split-screen](#split-screen) multiplayer.|