Capitalisation quick wins

Author: suearkinunity

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

@@ -19,5 +19,5 @@ Actions also make it simpler to create a system that lets your players [customiz
 > [!NOTE]
 > - Actions are a runtime only feature. You can't use them in [Editor window code](https://docs.unity3d.com/ScriptReference/EditorWindow.html).
 >
-> - You can read input without using Actions and Bindings by directly reading specific device controls. This is less flexible, but can be quicker to implement for certain situations. Read more about [directly reading devices from script](using-direct-workflow.md).
+> - You can read input without using actions and bindings by directly reading specific device controls. This is less flexible, but can be quicker to implement for certain situations. Read more about [directly reading devices from script](using-direct-workflow.md).
 >

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

@@ -19,4 +19,4 @@ Use an input processor to apply processing to input values and return the result
 - [Bindings](bindings.md)
 - [Interactions](Interactions.md)
 - [Configure actions](configure-actions.md)
-- [Configure Bindings from code](configure-bindings-from-code.md)
+- [Configure bs from code](configure-bindings-from-code.md)

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

@@ -51,8 +51,8 @@
     * [Controls schemes](control-schemes.md)
     * [Interactions](Interactions.md)
       * [Introduction to interactions](introduction-interactions.md)
-      * [Apply interactions to Bindings](apply-interactions-bindings.md)
-      * [Apply Interactions to Actions](apply-interactions-actions.md)
+      * [Apply interactions to bindings](apply-interactions-bindings.md)
+      * [Apply Interactions to actions](apply-interactions-actions.md)
       * [Predefined interactions](predefined-interactions.md)
         * [Default Interactions](default-interactions.md)
         * [Built-in Interactions](built-in-interactions.md)
@@ -72,7 +72,7 @@
     * [Declare stand alone actions](declare-standalone-actions.md)
     * [Configure input from JSON](configure-input-from-json.md)
     * [Create actions in code](create-actions-in-code.md)
-    * [Configure Bindings from code](configure-bindings-from-code.md)
+    * [Configure bindings from code](configure-bindings-from-code.md)
 * [Responding to input](respond-to-input.md)
   * [About responding to input](about-responding-to-input.md)
   * [Enabling actions](enable-actions.md)

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

@@ -4,11 +4,11 @@ uid: input-system-workflows
 
 # Input System Workflows
 
-There are multiple ways to use the Input System, however the primary and recommended workflow is to use the **Input Actions** panel in the **Project Settings window** to configure your project-wide Actions and Bindings, get references to those Actions in your code's Start method, then read the values for those actions in your Update method.
+There are multiple ways to use the Input System, however the primary and recommended workflow is to use the **Input Actions** panel in the **Project Settings window** to configure your project-wide actions and bindings, get references to those Actions in your code's Start method, then read the values for those actions in your Update method.
 
-There are other workflows which can suit more unusual situations, for example you can use the **PlayerInput component** together with Actions and Bindings which adds a further layer of abstraction, allowing you to connect actions to your event handlers without requiring any intermediate code, and easily handle multiplayer scenarios.
+There are other workflows which can suit more unusual situations, for example you can use the **PlayerInput component** together with actions and bindings which adds a further layer of abstraction, allowing you to connect actions to your event handlers without requiring any intermediate code, and easily handle multiplayer scenarios.
 
-You can choose to configure Actions and Bindings in the Editor UI, or you can set up everything through scripting. Or you can take a more direct approach by omitting the Actions and Bindings features altogether and instead use script to directly read the state of devices.
+You can choose to configure actions and bindings in the Editor UI, or you can set up everything through scripting. Or you can take a more direct approach by omitting the actions and bindings features altogether and instead use script to directly read the state of devices.
 
 The descriptions below describe these main workflows and link to more detailed description of them.
 
@@ -18,7 +18,7 @@ The descriptions below describe these main workflows and link to more detailed d
 |---|---|
 |[**Using Actions**](Workflow-Actions.md)|This is the **recommended** workflow for most situations. In this workflow, you use the [Actions Editor window](./ActionsEditor.md) to configure sets of actions and bindings, then set up references and read the values for those actions in your code.|
 |[**Using Actions and the PlayerInput Component**](Workflow-PlayerInput.md)|This workflow provides extra features that allow you to connect up **callbacks** directly from Actions to your own callback handler methods, removing the need to deal with Action references in your code. It also provides features that are useful in **local multiplayer** scenarios such as device assignment and split-screen functionality.|
-|[**Directly read device states**](Workflow-Direct.md)|This workflow is a simplified, script-only approach which bypasses the Actions and Bindings features entirely. Instead your script explicitly references specific device controls (such as "left gamepad stick") and reads the values directly. This is suitable for **fast prototyping**, or single fixed platform scenarios. It is a **less flexible** workflow because it bypasses some of the main input system features.|
+|[**Directly read device states**](Workflow-Direct.md)|This workflow is a simplified, script-only approach which bypasses the actions and bindings features entirely. Instead your script explicitly references specific device controls (such as "left gamepad stick") and reads the values directly. This is suitable for **fast prototyping**, or single fixed platform scenarios. It is a **less flexible** workflow because it bypasses some of the main input system features.|
 
 > [!NOTE]
 > Because the Input System has multiple workflows, the code samples used throughout this documentation also vary, often demonstrating techniques using various workflows. For example, some code samples may use Action references, and some may use the workflow of reading input directly from devices.

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

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

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

@@ -6,13 +6,13 @@ uid: input-system-add-processors-bindings-actions
 
 You can add a processor to an action or binding in the Input Actions Editor.
 
-## Processors on Bindings
+## Processors on bindings
 
-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.
+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.
+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.
 3. Choose a Processor type to add a Processor instance of that type. The Processor now appears under the __Processors__ foldout.
 4. (Optional) If the Processor has any parameters, you can edit them in the __Processors__ foldout.
@@ -21,7 +21,7 @@ If you're using Actions defined in the [Input Actions Editor](ActionsEditor.md),
 
 To remove a Processor, click the Remove (-) icon next to it. You can also use the up and down arrows to change the order of Processors. This affects the order in which the system processes values.
 
-If you create your Bindings in code, you can add Processors like this:
+If you create your bindings in code, you can add Processors like this:
 
 ```CSharp
 var action = new InputAction();
@@ -31,9 +31,9 @@ action.AddBinding("<Gamepad>/leftStick")
 
 ## Processors on Actions
 
-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.
+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~/api-overview.md

@@ -21,7 +21,7 @@ using UnityEngine.InputSystem;
 |[`InputSystem.actions`](xref:UnityEngine.InputSystem.InputSystem)|A reference to the set of actions assigned as the [project-wide Actions](./about-project-wide-actions.md).|
 |[`InputAction`](xref:UnityEngine.InputSystem.InputAction)|The class which represents an action. You can use a reference to an action to read the current value of the controls that it is bound to, or to trigger callbacks in response to input. This class corresponds to an entry in the **Actions** column of the [Input Actions editor](actions-editor.md).|
 |[`InputActionMap`](xref:UnityEngine.InputSystem.InputActionMap)|The class which represents an [action map](create-edit-delete-action-maps.md). The API equivalent to an entry in the **Action Maps** column of the [Input Actions editor](actions-editor.md).|
-|[`InputBinding`](xref:UnityEngine.InputSystem.InputBinding)|The relationship between an action and the specific device controls for which it receives input. For more information about Bindings and how to use them, refer to [bindings](bindings.md).|
+|[`InputBinding`](xref:UnityEngine.InputSystem.InputBinding)|The relationship between an action and the specific device controls for which it receives input. For more information about bindings and how to use them, refer to [Bindings](bindings.md).|
 
 ## Actions
 

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

@@ -4,11 +4,11 @@ uid: input-system-apply-interactions-actions
 
 # Apply interactions to actions
 
-Applying Interactions directly to an Action is equivalent to applying them to all Bindings for the Action. You can use this instead of manually adding the same Interaction(s) to multiple Bindings.
+Applying Interactions directly to an Action is equivalent to applying them to all bindings for the Action. You can use this instead of manually adding the same Interaction(s) to multiple bindings.
 
-To apply Interactions to individual Bindings, refer to [Apply Interactions to Bindings](apply-interactions-bindings.md).
+To apply Interactions to individual bindings, refer to [Apply Interactions to bindings](apply-interactions-bindings.md).
 
-If you apply Interactions to both an Action and its Bindings, then the effect is the same as if the Action's Interactions are on the list of Interactions on each of the Bindings. This means that the Input System applies the Binding's Interactions first, and then the Action's Interactions.
+If you apply Interactions to both an Action and its bindings, then the effect is the same as if the Action's Interactions are on the list of Interactions on each of the bindings. This means that the Input System applies the binding's Interactions first, and then the Action's Interactions.
 
 ## Apply Interactions to Actions in the Editor
 

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

@@ -4,15 +4,15 @@ uid: input-system-apply-interactions-bindings
 
 # Apply interactions to bindings
 
-When you create Bindings for your [Actions](actions.md), you can choose to add Interactions to the Bindings via the Editor, or via code.
+When you create bindings for your [Actions](actions.md), you can choose to add Interactions to the bindings with the Editor, or with code.
 
-To apply Interactions to all Bindings on an Action, refer to [Apply Interactions to Actions](apply-interactions-actions.md).
+To apply Interactions to all bindings on an Action, refer to [Apply Interactions to Actions](apply-interactions-actions.md).
 
-## Apply Interactions to Bindings in the Editor
+## 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 via 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. 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. 
 1. Select an Interaction type to add an Interaction instance of that type. The Interaction now appears in the __Interactions__ foldout. 
 1. If the Interaction has any parameters, you can now edit them at this stage.
@@ -21,9 +21,9 @@ If you're using [project-wide actions](actions-editor.md), or [Input Action Asse
 
 To remove an Interaction, select the minus (-) button next to it. To change the [order of Interactions](introduction-interactions.md#multiple-interactions-on-a-binding), select the up and down arrows.
 
-## Apply Interactions to Bindings in code
+## Apply Interactions to bindings in code
 
-To add Interactions to Bindings that you created in code, you can use the following code sample as a template:
+To add Interactions to bindings that you created in code, you can use the following code sample as a template:
 
 ```CSharp
 var Action = new InputAction();

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

@@ -39,14 +39,14 @@ For [composite bindings](./composite-bindings.md), magnitudes of the composite a
 
 Inputs used in combinations with other inputs can also lead to ambiguities. If, for example, the **B** key on the Keyboard is bound both on its own as well as in combination with the **Shift** key, then if you first press **Shift** and then **B**, the latter key press would be a valid input for either of the Actions.
 
-The way the Input System handles this, is that Bindings are processed in the order of decreasing complexity. This metric is derived automatically from the Binding:
+The way the Input System handles this, is that bindings are processed in the order of decreasing complexity. This metric is derived automatically from the binding:
 
 * A binding that is *not* part of a [composite](composite-bindings.md) is assigned a complexity of 1.
 * A binding that *is* part of a [composite](composite-bindings.md) is assigned a complexity equal to the number of part bindings in the composite.
 
-In our example, this means that a **one-modifier composite** binding to **Shift** + **B** has a higher complexity than a Binding to  **B** and gets processed first.
+In our example, this means that a **one-modifier composite** binding to **Shift** + **B** has a higher complexity than a binding to  **B** and gets processed first.
 
-Additionally, if the [Input Consumption](input-settings.md) setting is enabled, the first Binding that results in the Action changing [phase](./set-callbacks-on-actions.md) will consume the input. This results in other Bindings to the same input not being processed. This means in our example, when the **Shift** + **B** binding consumes the **B** input, the Binding to **B** is skipped.
+Additionally, if the [Input Consumption](input-settings.md) setting is enabled, the first binding that results in the Action changing [phase](./set-callbacks-on-actions.md) will consume the input. This results in other bindings to the same input not being processed. This means in our example, when the **Shift** + **B** binding consumes the **B** input, the binding to **B** is skipped.
 
 
 ## Disabling Conflict Resolution