Still working on 2253

Author: suearkinunity

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

@@ -11,7 +11,7 @@ The association between an Action and the device controls which perform that inp
 
 To use actions in your code, you must use the [Input Actions editor](actions-editor.md) to configure the mapping between the Action and one or more device controls. For example in this screenshot, the "Move" action is displayed, showing its bindings the left gamepad stick, and the keyboard's arrow keys.
 
-![Actions Bindings](Images/ActionsBinding.png)<br/>
+![The Actions panel of the Input Actions Editor in Project Settings](Images/ActionsBinding.png)<br/>
 *The Actions panel of the Input Actions Editor in Project Settings*
 
 You can then get a reference to this action in your code, and check its value, or attach a callback method to be notified when it is performed. See the [Actions Workflow page](using-actions-workflow.md) for a simple example script demonstrating this.

Packages/com.unity.inputsystem/Documentation~/composite-bindings.md

@@ -4,9 +4,11 @@ uid: input-system-composite-bindings
 
 # Composite Bindings
 
-Sometimes, you might want to have several Controls act in unison to mimic a different type of Control. The most common example of this is using the W, A, S, and D keys on the keyboard to form a 2D vector Control equivalent to mouse deltas or gamepad sticks. Another example is to use two keys to form a 1D axis equivalent to a mouse scroll axis.
+You might want to have several controls act in unison to mimic a different type of control. The most common example of this is using the W, A, S, and D keys on the keyboard to form a 2D vector control equivalent to mouse deltas or gamepad sticks. Another example is to use two keys to form a 1D axis equivalent to a mouse scroll axis.
 
-Composite Bindings, made up of multiple **sub-bindings** solve this problem. Composites themselves don't bind directly to Controls; instead, they take values from their **sub-bindings** that do, and then synthesize input from those values together into a single virtual control binding.
+This is difficult to implement with normal bindings. You can bind a  [`ButtonControl`](xref:UnityEngine.InputSystem.Controls.ButtonControl) to an action expecting a `Vector2`, but doing so results in an exception at runtime when the Input System tries to read a `Vector2` from a control that can deliver only a `float`.
+
+Composite bindings (that is, bindings that are made up of other bindings) solve this problem. Composites themselves don't bind directly to controls; instead, they source values from other bindings that do, and then synthesize input on the fly from those values.
 
 To create a composite binding, select the appropriate [composite type](binding-types.md) for your action while [adding a binding in the actions editor](./add-duplicate-delete-binding.md). The types of composite bindings available are as follows:
 

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

@@ -22,12 +22,12 @@ The asset is created in your project, and automatically assigned as the **projec
 
 The Action Asset appears in your Project view, and is named "InputSystem_Actions". This is where your new configuration of actions is saved, including any changes you make to it.
 
-![](images/InputSystemActionsAsset.png)<br/>
+![The new Actions Asset in your Project window](images/InputSystemActionsAsset.png)<br/>
 *The new Actions Asset in your Project window*
 
 When you create an action asset this way, the new asset contains a set of default actions that are useful in many common scenarios. You can [configure them](./configure-actions.md) or [add new actions](./create-edit-delete-actions.md) to suit your project.
 
-![image alt text](./Images/ProjectSettingsInputActionsSimpleShot.png)
+![The Input System Package Project Settings after creating and assigning the default actions](./Images/ProjectSettingsInputActionsSimpleShot.png)
 *The Input System Package Project Settings after creating and assigning the default actions*
 
 Once you have created and assigned project-wide actions, the Input System Package page in Project Settings displays the **Actions Editor** interface. Read more about how to use the [Actions Editor](actions-editor.md) to configure your actions.

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

@@ -15,7 +15,19 @@ These default actions mean that in many cases, you can start scripting with the
 
 ### The legacy default Actions Asset
 
-The Input System Package also comes with an asset called `DefaultInputActions.inputactions` containing a default set of Actions. This default actions asset is older than, and entirely separate from the default project-wide actions described above. 
-
-This is a legacy asset that remains included in the package for backward compatibility only, and not recommended for use in new projects. It should not be confused with the default project-wide actions described above.
-
+> [!NOTE]
+> The default actions asset is entirely separate from the [default project-wide actions](xref:project-wide-actions). It is a legacy asset that is included in the package for backwards compatibility.
+
+The Input System package provides an asset called `DefaultInputActions.inputactions` which you can reference directly in your projects like any other Unity asset. The asset is also available in code form through the [`DefaultInputActions`](xref:UnityEngine.InputSystem.DefaultInputActions) class.
+
+
+```CSharp
+void Start()
+{
+    // Create an instance of the default actions.
+    var actions = new DefaultInputActions();
+    actions.Player.Look.performed += OnLook;
+    actions.Player.Move.performed += OnMove;
+    actions.Enable();
+}
+```

Packages/com.unity.inputsystem/Documentation~/default-actions.md

@@ -28,8 +28,11 @@ Once applied, the Input System creates a C# script containing API that matches t
 using UnityEngine;
 using UnityEngine.InputSystem;
 
-// IGameplayActions is an interface generated from the "gameplay" action map.
-// Your interface name will match the name you chose for your action map.
+// IGameplayActions is an interface generated from the newly added "gameplay"
+// action map, triggered by the "Generate Interfaces" checkbox. Note that if
+// you change the default values for the action map, the name of the interface
+// will be different.
+
 public class MyPlayerScript : MonoBehaviour, IGameplayActions
 {
     // MyPlayerControls is the C# class that Unity generated.
@@ -42,8 +45,8 @@ public class MyPlayerScript : MonoBehaviour, IGameplayActions
         if (controls == null)
         {
             controls = new MyPlayerControls();
-            // Tell the "gameplay" action map that we want to get told about
-            // when actions get triggered.
+            // Tell the "gameplay" action map that we want to be
+            // notified when actions get triggered.
             controls.gameplay.SetCallbacks(this);
         }
         controls.gameplay.Enable();
@@ -68,4 +71,4 @@ public class MyPlayerScript : MonoBehaviour, IGameplayActions
 ```
 
 > [!NOTE]
-> To regenerate the .cs file, right-click the .inputactions asset in the Project Browser and choose "Reimport".
+> To regenerate the .cs file, right-click the .inputactions asset in the Project Browser and select **Reimpor**.

Packages/com.unity.inputsystem/Documentation~/generate-cs-api-from-actions.md

@@ -6,12 +6,13 @@ uid: input-system-bindings-intro
 
 ![A flowchart showing the general workflow of the Input System, with icons representing the different concepts. It starts with the User icon, which then leads into the Input Device and its Controls icon. This then leads into the Action Map and Actions concept. The Input Device and Action Map and Actions icons are collectively grouped under the Binding header. This leads into the final icon representing your action code.](Images/ConceptsOverview.png)
 
-A **binding** represents a connection between an [Action](actions.md) and one or more [Controls](controls.md) identified by a [Control path](./control-paths.md). For example, the right trigger of a gamepad (a control) might be bound to an an action named `accelerate`, so that pulling the right trigger causes a car to accelerate in your game.
+A **binding** represents a connection between an [Action](actions.md) and one or more [Controls](controls.md) identified by a [Control path](./control-paths.md). For example, the right trigger of a gamepad (a control) might be bound to an an action named "accelerate", so that pulling the right trigger causes a car to accelerate in your game.
 
-You can add multiple bindings to an action, which is generally useful for supporting multiple types of input device. For example, in the default set of actions, the "Move" action has a binding to the left gamepad stick and the WSAD keys, which means input through any of these bindings will perform the action.
+You can add multiple bindings to an action, which is generally useful for supporting multiple types of input device. For example, in the default set of actions, the "Move" action has a binding to the left gamepad stick and the WASD keys, which means input through any of these bindings will perform the action.
 
 You can also bind multiple controls from the same device to an action. For example, both the left and right trigger of a gamepad could be mapped to the same action, so that pulling either trigger has the same result in your game.
 
 ![The default "move" action with its multiple bindings highlighted](./Images/ActionWithMultipleBindings.png)<br/>
 _The default "Move" action in the Actions Editor window, displaying the multiple bindings associated with it._
 
+You can also set up [Composite](composite-bindings) bindings, which don't bind to the controls themselves, but receive their input from **Part Bindings** and then return a value representing a composition of those inputs. For example, the right trigger on the gamepad can act as a strength multiplier on the value of the left stick.