All other updated PRs

suearkinunity · suearkinunity · commit 5ca23d098626 · 2026-06-30T11:25:58.000+01:00
diff --git a/Packages/com.unity.inputsystem/Documentation~/KnownLimitations.md b/Packages/com.unity.inputsystem/Documentation~/KnownLimitations.md
@@ -33,5 +33,4 @@ The following is a list of known limitations that the Input System currently has
 
 ## Features Supported by Old Input Manager
 
-* `MonoBehaviour` mouse methods (`OnMouseEnter`, `OnMouseDrag`, etc) will not be called by the Input System.
 * Unity Remote doesn't currently support the Input System. This is being worked on.
diff --git a/Packages/com.unity.inputsystem/Documentation~/Processors.md b/Packages/com.unity.inputsystem/Documentation~/Processors.md
@@ -11,7 +11,7 @@ Use an input processor to apply processing to input values and return the result
 | [**Introduction to processors**](introduction-to-processors.md) | Learn what processors can do to alter input values, and how they interact with bindings, actions, and controls. |
 | [**Built-in processors**](built-in-processors.md) | Explore the processors that come built into the Input System. |
 | [**Write custom processors**](write-custom-processors.md) | Create and register your own processors for use with bindings, actions, and controls. |
-| [**Add processors to bindings and actions**](add-processors-bindings-actions.md) | Add processors to individual bindings, or to all bindings on an action, via the Editor or via code. |
+| [**Add processors to bindings and actions**](add-processors-bindings-actions.md) | Add processors to individual bindings, or to all bindings on an action, with the Editor or with code. |
 | [**Add processors to controls**](add-processors-controls.md) | Add processors to specific control inputs, including custom controls. |
 
 ## Additional resources
diff --git a/Packages/com.unity.inputsystem/Documentation~/TableOfContents.md b/Packages/com.unity.inputsystem/Documentation~/TableOfContents.md
@@ -6,6 +6,7 @@
     * [Using the Actions Workflow](using-actions-workflow.md)
     * [Using the PlayerInput Workflow](using-playerinput-workflow.md)
     * [Using the Direct Workflow](using-direct-workflow.md)
+  * [Video resources](videos.md)
 * [Setting up input](setting-up-input.md)
   * [Actions](actions.md)
   * [Input action assets](action-assets.md)
diff --git a/Packages/com.unity.inputsystem/Documentation~/binding-conflicts.md b/Packages/com.unity.inputsystem/Documentation~/binding-conflicts.md
@@ -37,6 +37,9 @@ For [composite bindings](./composite-bindings.md), magnitudes of the composite a
 > [!NOTE]
 > The mechanism described here only applies to Actions that are part of the same [action map](./input-actions-editor-window-reference.md#action-maps-panel-reference) or [action assets](./action-assets.md).
 
+> [!NOTE]
+> To use automatic composite complexity as described below, in **Project Settings** > **Input System Package**, enable __Complexity-Based Shortcut Resolution__ ([`InputSettings.shortcutKeysConsumeInput`](xref:UnityEngine.InputSystem.InputSettings.shortcutKeysConsumeInput)) and leave __Action Priority Shortcut Resolution__ ([`InputSettings.shortcutKeysUseActionPriority`](xref:UnityEngine.InputSystem.InputSettings.shortcutKeysUseActionPriority)) disabled. If __Action Priority Shortcut Resolution__ is enabled, overlaps are resolved using each action's [`InputAction.Priority`](xref:UnityEngine.InputSystem.InputAction.Priority) instead. Refer to [Input settings](xref:input-system-settings#improved-shortcut-support) for details.
+
 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:
diff --git a/Packages/com.unity.inputsystem/Documentation~/corresponding-old-new-api.md b/Packages/com.unity.inputsystem/Documentation~/corresponding-old-new-api.md
@@ -69,6 +69,8 @@ Directly reading hardware controls bypasses the new Input System's action-based
 
 ## Mouse
 
+`MonoBehaviour.OnMouse` events, such as [MonoBehaviour.OnMouseDown](https://docs.unity3d.com/ScriptReference/MonoBehaviour.OnMouseDown.html), are supported in Unity 6.4 and later.
+
 |Input Manager (Old)|Input System (New)|
 |--|--|
 [`Input.GetMouseButton`](https://docs.unity3d.com/ScriptReference/Input.GetMouseButton.html)<br/>Example: `Input.GetMouseButton(0)`|Use [`isPressed`](xref:UnityEngine.InputSystem.Controls.ButtonControl) on the corresponding mouse button.<br/>Example: `InputSystem.Mouse.current.leftButton.isPressed`
diff --git a/Packages/com.unity.inputsystem/Documentation~/display-bindings.md b/Packages/com.unity.inputsystem/Documentation~/display-bindings.md
@@ -64,6 +64,6 @@ You can also use this method to replace the text string with images.
     }
 ```
 
-Additionally, each Binding has a [`ToDisplayString`](xref:UnityEngine.InputSystem.InputBinding) method, which you can use to turn individual Bindings into display strings. There is also a generic formatting method for Control paths, [`InputControlPath.ToHumanReadableString`](xref:UnityEngine.InputSystem.InputControlPath), which you can use with arbitrary Control path strings.
+Additionally, each binding has a [`ToDisplayString`](xref:UnityEngine.InputSystem.InputBinding) method, which you can use to turn individual bindings into display strings. There is also a generic formatting method for Control paths, [`InputControlPath.ToHumanReadableString`](xref:UnityEngine.InputSystem.InputControlPath), which you can use with arbitrary Control path strings.
 
-Note that the Controls a Binding resolves to can change at any time, and the display strings for controls might change dynamically. For example, if the user switches the currently active keyboard layout, the display string for each individual key on the [`Keyboard`](xref:UnityEngine.InputSystem.Keyboard) might change.
+Note that the Controls a binding resolves to can change at any time, and the display strings for controls might change dynamically. For example, if the user switches the currently active keyboard layout, the display string for each individual key on the [`Keyboard`](xref:UnityEngine.InputSystem.Keyboard) might change.
diff --git a/Packages/com.unity.inputsystem/Documentation~/enable-actions.md b/Packages/com.unity.inputsystem/Documentation~/enable-actions.md
@@ -32,6 +32,28 @@ You can't change certain aspects of the configuration, such as an action's bindi
 
 While enabled, the action actively monitors the [control(s)](controls.md) it is bound to. If a bound control changes state, the action processes the change. If the control's change represents an [interaction](Interactions.md) change, the action creates a response. All of this happens during the Input System update logic. Depending on the [update mode](update-mode.md) selected in the input settings, this happens once every frame, once every fixed update, or manually if the update mode setting is set to manual.
 
+## Overlapping bindings and action priority
 
+When several enabled actions share the same physical control (for example a plain **B** key action and a **Shift**+**B** composite), the Input System can resolve which action should respond first using either complexity-based or priority-based resolution. Both modes are configured in **Project Settings** > **Input System Package** under [Improved Shortcut Support](xref:input-system-settings#improved-shortcut-support).
 
+Each action has a [`Priority`](xref:UnityEngine.InputSystem.InputAction.Priority) property. The range is from `0` to `65535`, and is clamped when set. A higher value means a higher priority, notified first.
 
+The `Priority` value applies to all bindings on that action. Serialized priority is always stored on the asset; at runtime it's used only when **Action Priority Shortcut Resolution** is enabled. In that case, the **Priority** field is also shown in the [Input Actions Editor](xref:input-system-configuring-input).
+
+When action priority resolution is active:
+
+- Higher priority actions are notified before lower-priority actions on the same control.
+- When an action reaches the Performed phase, priority `0` doesn't mark the input event as handled, so lower-priority actions in the same overlap group can still respond on that event.
+- Any priority greater than zero can mark the event as handled and suppress strictly lower-priority actions in the same group for that event.
+- Actions with the same priority are not suppressed relative to each other; both can perform in the same update if their bindings fire.
+
+To set priority in code, use `.Priority`:
+
+```CSharp
+fireAction.Priority = 10;
+reloadAction.Priority = 5;
+```
+
+You can also edit the **Priority** field on an action in the Input Actions Editor when **Action Priority Shortcut Resolution** is enabled.
+
+For information about composite shortcuts and complexity ordering, refer to [Multiple input sequences (such as keyboard shortcuts)](xref:input-system-action-bindings#multiple-input-sequences-such-as-keyboard-shortcuts).
diff --git a/Packages/com.unity.inputsystem/Documentation~/gamepad-haptics.md b/Packages/com.unity.inputsystem/Documentation~/gamepad-haptics.md
@@ -14,11 +14,21 @@ Gamepad.current.SetMotorSpeeds(0.25f, 0.75f);
 
 ```
 
-Only the following platforms support rumble:
+Only the following combinations of devices/OSes currently support rumble:
 
-* PlayStation, Xbox, and Switch controllers on their respective consoles.   
-* PlayStation controllers on macOS, Windows or Universal Windows Platform.  
+* PS4, Xbox, and Nintendo Switch controllers, when connected to their respective consoles. Only supported if you install console-specific input packages in your Project.
+* PS4 controllers, when connected to Mac or Windows/UWP computers.
 * Xbox controllers on Windows.
+* Gamepads on Android. Rumble support varies with Android OS version and requires Unity 6000.6 or later.
+    * Rumble automatically stops about 10 seconds after the last. [`SetMotorSpeeds`](xref:UnityEngine.InputSystem.Haptics.IDualMotorRumble) call unless you explicitly stop it.
+    * Android 12 or later:
+        * Supports most Bluetooth-connected gamepads with rumble support including PS4, PS5, and Xbox controllers.
+        *  If the gamepad is connected with a USB cable, rumble support might vary.
+        *  If the gamepad supports more than one motor, you can control the speed of each motor individually.
+    * Android 11 or earlier:
+        * Rumble support is limited.
+        * Only one motor is supported. If the gamepad has more than one motor, the higher value of the left and right motor speed applies to both.
+        * On some devices, motor speed control is limited. You can only set the left and right motor speed to either `1.0` (maximum speed) or `0.0` (turned off).
 
 ## Pausing, resuming, and stopping haptics
 
diff --git a/Packages/com.unity.inputsystem/Documentation~/polling-actions.md b/Packages/com.unity.inputsystem/Documentation~/polling-actions.md
@@ -143,7 +143,7 @@ public class Example : MonoBehaviour
             // teleport occurs on the first frame that the action is pressed, and not again until the button is released
         }
 
-        if (submit.WasReleasedThisFrame())
+            if (submitAction.WasReleasedThisFrame())
         {
             // submit occurs on the frame that the action is released, a common technique for buttons relating to UI controls.
         }
diff --git a/Packages/com.unity.inputsystem/Documentation~/projectMetadata.json b/Packages/com.unity.inputsystem/Documentation~/projectMetadata.json
@@ -1,3 +1,7 @@
 {
-    "hideGlobalNamespace": true
+    "hideGlobalNamespace": true,
+    "xref": [
+        "com.unity.xr.openxr",
+        "com.unity.xr.interaction.toolkit"
+    ]
 }
diff --git a/Packages/com.unity.inputsystem/Documentation~/record-events.md b/Packages/com.unity.inputsystem/Documentation~/record-events.md
@@ -32,6 +32,9 @@ trace.Dispose();
 
 Dispose event traces after use, so that they do not leak memory on the unmanaged (C++) memory heap.
 
+> [!NOTE]
+> **Keyboard text input is not replayed to UI text fields.** Keyboard state (key presses) is captured and replayed correctly and remains accessible via `Keyboard.current`. However, there is a known limitation with character delivery to UI Framework components (uGUI `InputField` or UI Toolkit `TextField`). These components receive text through a separate native pipeline that is not fed by event replay. As a result, text typed into UI text fields during recording will not appear during playback.
+
 You can also write event traces out to files/streams, load them back in, and replay recorded streams.
 
 ```CSharp
diff --git a/Packages/com.unity.inputsystem/Documentation~/supported-devices.md b/Packages/com.unity.inputsystem/Documentation~/supported-devices.md
@@ -26,4 +26,17 @@ To force the Editor to add all locally available Devices, even if they're not in
 ![Add Devices Not Listed In Supported Devices](Images/AddDevicesNotListedInSupportedDevices.png)
 
 > [!NOTE]
-> This setting is stored as a user setting, not a project setting. This means other users who open the project in their own Editor do not share the setting.
+> This setting is stored as a user setting, not a project setting. This means other users who open the project in their own Editor do not share the setting.
+
+## Improved Shortcut Support
+
+Under **Improved Shortcut Support**, two independent options control how the Input System resolves overlapping bindings on the same control (for example, a plain **B** key action as opposed to **Shift**+**B**):
+
+| UI / API | Description |
+| -------- | ----------- |
+| __Complexity-Based Shortcut Resolution__ ([`shortcutKeysConsumeInput`](xref:UnityEngine.InputSystem.InputSettings.shortcutKeysConsumeInput)) | When enabled and Action Priority Shortcut Resolution is off, composite bindings are ordered by automatic **complexity** (depth of the composite). The first action that performs can consume the input so simpler bindings on the same control are skipped. Modifier composites use **ordered** modifier evaluation while this mode is active. |
+| __Action Priority Shortcut Resolution__ ([`shortcutKeysUseActionPriority`](xref:UnityEngine.InputSystem.InputSettings.shortcutKeysUseActionPriority)) | When enabled, resolution uses each action's [`InputAction.Priority`](xref:UnityEngine.InputSystem.InputAction.Priority). Higher priority is handled first and can consume input for lower-priority actions. A performed action with priority 0 does not mark the input event as handled for suppressing lower-priority overlaps; any priority above zero can. The **Priority** field appears in the Input Actions editor when this is on. Serialized priority values are always kept on the asset even when this option is off. |
+
+Both options default to **off**. If **Action Priority Shortcut Resolution** is on, it **takes precedence** over complexity-based resolution even if **Complexity-Based Shortcut Resolution** is also enabled.
+
+For more detail on complexity ordering, see [Multiple input sequences (such as keyboard shortcuts)](xref:input-system-action-bindings#multiple-input-sequences-such-as-keyboard-shortcuts).
diff --git a/Packages/com.unity.inputsystem/Documentation~/videos.md b/Packages/com.unity.inputsystem/Documentation~/videos.md
@@ -0,0 +1,83 @@
+---
+uid: input-system-videos
+---
+
+# Video resources
+
+This page provides a collection of video resources to introduce the Input System in Unity 6. Follow the videos in the order provided, since many of the tutorials provide a foundation for understanding the more advanced tutorials.
+
+The Input System supports several different workflows, each with its own advantages. These videos walk you through the most commonly used workflows and offer practical guidance to help you begin using the Input System right away.
+
+## Introduction to the Unity Input System
+
+**Description**: This is the first video in a 7-part series that demonstrates how to get started with Unity’s Input System and introduces some of its core concepts. It covers the following lessons:
+
+- Learn how to install the Input System in your Unity project.
+- Understand the concept of input actions.
+- Learn how to use the **Input Actions Editor** to bind input actions to various inputs, such as keys, gamepad buttons, and mouse axes.
+- Explore how to define interactions when an input action is triggered (for example, press, hold, or release).
+- Learn how processors can modify or transform raw input data before it’s used (for example, normalizing, inverting, or clamping values).
+
+**Link**: [Watch video 1/7](https://www.youtube.com/watch?v=TiTKAseu17A) (YouTube)
+
+## Input System scripting
+
+**Description**: The second video in the series introduces scripting with the Input System to control a third-person character:
+
+- Learn how to write code to move and jump the third-person character using an Input System asset, with support for both gamepad and mouse-and-keyboard inputs.
+- Add a simple pause menu.
+- Learn how to dynamically switch action maps to handle different input contexts.
+
+**Link**: [Watch video 2/7](https://www.youtube.com/watch?v=Cd2Erk_bsRY) (YouTube)
+
+
+## Mobile controls
+
+**Description**: The third video in the series demonstrates how to add mobile touch controls to your game using Unity’s Input System:
+
+- Use the On-Screen Stick and On-Screen Button components to set up on-screen controls for mobile devices.
+- Enable touch-based input for third-person character movement.
+
+**Link**: [Watch Video 3/7](https://www.youtube.com/watch?v=aI-r7ILNDug) (YouTube)
+
+
+## UI toolkit with the Input System
+
+**Description**: The fourth video in the series demonstrates how to integrate the Input System with UI Toolkit:
+
+- Learn how to navigate and interact with a series of buttons.
+- Use gamepad controls to toggle between different button collections, enabling seamless switching on and off.
+
+**Link**: [Watch Video 4/7](https://www.youtube.com/watch?v=GdjP5pggaHw) (YouTube)
+
+## Rebind Input System controls
+
+**Description**: The fifth video in the series explores in-game rebinding:
+
+- Learn how to use rebinding to enable players to customize their input controls during gameplay.
+- Save these custom bindings using PlayerPrefs, to ensure your settings persist between game sessions.
+
+**Link**: [Watch Video 5/7](https://www.youtube.com/watch?v=JfuqMaOiNPs) (YouTube)
+
+
+## Player Input Component
+
+**Description**: The sixth video in the series explores preparing a local multiplayer scene, where two or more players share the same computer and screen but use separate controllers:
+
+- Configure the Player Input component.
+- Set up scripts to interact with the Player Input component.
+- Set up behaviors for communicating with your scripts.
+
+**Link**: [Watch Video 6/7](https://www.youtube.com/watch?v=beDfIBLfx4c) (YouTube)
+
+## Player Input Manager and local multiplayer games
+
+**Description**: The seventh video in the series focuses on local multiplayer games, where two or more players share the same computer and screen while using separate controllers. Learn how to use the Player Input Manager component to enable multiple players to control different characters in a local multiplayer setup.
+
+This includes examples that demonstrate the following:
+
+- A local co-op setup
+- A split-screen configuration
+- A two-player scenario
+
+**Link**: [Watch Video 7/7](https://www.youtube.com/watch?v=lGxXQzE5Vu8) (YouTube)

Original file line number	Diff line number	Diff line change
`@@ -33,5 +33,4 @@ The following is a list of known limitations that the Input System currently has`
`33`	`33`
`34`	`34`	`## Features Supported by Old Input Manager`
`35`	`35`
`36`		-* `MonoBehaviour` mouse methods (`OnMouseEnter`, `OnMouseDrag`, etc) will not be called by the Input System.
`37`	`36`	`* Unity Remote doesn't currently support the Input System. This is being worked on.`
Original file line number	Diff line number	Diff line change
`@@ -64,6 +64,6 @@ You can also use this method to replace the text string with images.`
`64`	`64`	`}`
`65`	`65`	```
`66`	`66`
`67`		-Additionally, each Binding has a [`ToDisplayString`](xref:UnityEngine.InputSystem.InputBinding) method, which you can use to turn individual Bindings into display strings. There is also a generic formatting method for Control paths, [`InputControlPath.ToHumanReadableString`](xref:UnityEngine.InputSystem.InputControlPath), which you can use with arbitrary Control path strings.
	`67`	+Additionally, each binding has a [`ToDisplayString`](xref:UnityEngine.InputSystem.InputBinding) method, which you can use to turn individual bindings into display strings. There is also a generic formatting method for Control paths, [`InputControlPath.ToHumanReadableString`](xref:UnityEngine.InputSystem.InputControlPath), which you can use with arbitrary Control path strings.
`68`	`68`
`69`		-Note that the Controls a Binding resolves to can change at any time, and the display strings for controls might change dynamically. For example, if the user switches the currently active keyboard layout, the display string for each individual key on the [`Keyboard`](xref:UnityEngine.InputSystem.Keyboard) might change.
	`69`	+Note that the Controls a binding resolves to can change at any time, and the display strings for controls might change dynamically. For example, if the user switches the currently active keyboard layout, the display string for each individual key on the [`Keyboard`](xref:UnityEngine.InputSystem.Keyboard) might change.
Original file line number	Diff line number	Diff line change
`@@ -143,7 +143,7 @@ public class Example : MonoBehaviour`
`143`	`143`	`// teleport occurs on the first frame that the action is pressed, and not again until the button is released`
`144`	`144`	`}`
`145`	`145`
`146`		`- if (submit.WasReleasedThisFrame())`
	`146`	`+ if (submitAction.WasReleasedThisFrame())`
`147`	`147`	`{`
`148`	`148`	`// submit occurs on the frame that the action is released, a common technique for buttons relating to UI controls.`
`149`	`149`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,7 @@`
`1`	`1`	`{`
`2`		`- "hideGlobalNamespace": true`
	`2`	`+ "hideGlobalNamespace": true,`
	`3`	`+ "xref": [`
	`4`	`+ "com.unity.xr.openxr",`
	`5`	`+ "com.unity.xr.interaction.toolkit"`
	`6`	`+ ]`
`3`	`7`	`}`