NEW: Pen.isSupported, Mouse.isSupported and Touchscreen.isPressureSupported [ISX-2046]

Legacy UnityEngine.Input conflates "is X supported on this platform" with
"is an X present right now", and the Input System had no equivalent for the
first question at all. Input.stylusTouchSupported reports true on any iPad new
enough to pair an Apple Pencil, whether or not one is paired.
Input.mousePresent is genuine detection on Windows and the consoles but a
hardcoded true on macOS and Linux.

These three properties answer the capability question. Presence keeps its
existing answer, Device.current != null.

The queries go to the engine's system endpoint, which is addressed by a
reserved device id that is never registered, so it never appears in the device
list and no device can answer a question about the platform. That endpoint
lands separately in the engine repository under the same ticket.

Touch pressure is answered at platform scope rather than per touchscreen
because that is the scope at which the answer exists: every platform sources it
from a device model or an OS API property rather than by enumerating
digitizers. A per-instance property can be added later, preferring a per-device
answer over this one, without changing what is here.

The commands and the InputCapabilitySupport tristate are internal rather than
public, unlike the rest of the Commands folder. They target the system
endpoint, so there is no custom device for a user to answer them for, and
keeping them internal avoids freezing a capability model that the low level
input API is expected to revisit. The engine answers with a tristate whose
Unknown is zero, so an unimplemented query reads as "we do not know" rather
than a confident false; the public properties collapse anything other than
Supported to false.

Both the properties and the plumbing are gated on
UNITY_INPUTSYSTEM_SUPPORTS_CAPABILITY_QUERIES, so the API is absent rather than
present-and-always-false on engine versions that cannot answer. The version
expression is currently the local development engine and must be updated to
whichever version the engine side actually ships in.

ExecuteGlobalCommand is replaced by ExecuteSystemCommand. The former had no
callers, having been orphaned when UseWindowsGamingInputCommand was removed by
ISXB-927, and its premise was wrong: it addressed device id 0 on the assumption
that the engine routes such commands by FourCC alone, but InputDeviceIOCTL
resolves the id against the device registry and 0 is the invalid-device
sentinel, so nothing sent there could ever be answered.

Capabilities cannot change while the process runs, so each is queried at most
once. The cache lives on InputManager rather than in a static, so a domain
reload or a test installing a different runtime discards it without needing an
explicit reset hook.

Tests cover each state including Unknown, that the properties answer with no
device added, that a query is never delivered to a real device, that repeated
reads issue one command, that nothing answering reports false rather than
throwing, and that the enum values, the FourCC codes and the payload size all
agree with the engine's own constants.

Author: ekcoh

Assets/Tests/InputSystem/CoreTests_Devices.cs

@@ -5895,4 +5895,167 @@ public unsafe void Devices_DoesntErrorOutOnMaxTouchCount()
                 BeginTouch(i, new Vector2(i * 1.0f, i * 2.0f), time: 0);
         }, Throws.Nothing);
     }
+
+#if UNITY_INPUTSYSTEM_SUPPORTS_CAPABILITY_QUERIES
+    // Platform capability queries. These are addressed to the engine's system endpoint rather than
+    // to a device, because they answer "can this platform do X" rather than "is an X connected".
+    // What a given platform actually answers is asserted natively in the engine repository, from
+    // PlatformDependent, where the file location gates the test to that platform.
+
+    private unsafe void AnswerCapabilityQuery(FourCC type, InputCapabilitySupport answer)
+    {
+        runtime.SetDeviceCommandCallback(NativeInputCapabilities.systemDeviceId,
+            (id, command) =>
+            {
+                if (command->type != type)
+                    return InputDeviceCommand.GenericFailure;
+
+                *(InputCapabilitySupport*)((byte*)command + InputDeviceCommand.kBaseCommandSize) = answer;
+                return InputDeviceCommand.GenericSuccess;
+            });
+    }
+
+    [Test]
+    [Category("Devices")]
+    [TestCase(InputCapabilitySupport.Supported, true)]
+    [TestCase(InputCapabilitySupport.NotSupported, false)]
+    // Unknown collapses to false: the platform has not answered, and a maybe is not something a
+    // bool property can express.
+    [TestCase(InputCapabilitySupport.Unknown, false)]
+    public void Devices_PenIsSupported_ReflectsWhatThePlatformAnswers(InputCapabilitySupport answer, bool expected)
+    {
+        AnswerCapabilityQuery(QueryPenSupportedCommand.Type, answer);
+
+        Assert.That(Pen.isSupported, Is.EqualTo(expected));
+    }
+
+    [Test]
+    [Category("Devices")]
+    [TestCase(InputCapabilitySupport.Supported, true)]
+    [TestCase(InputCapabilitySupport.NotSupported, false)]
+    [TestCase(InputCapabilitySupport.Unknown, false)]
+    public void Devices_MouseIsSupported_ReflectsWhatThePlatformAnswers(InputCapabilitySupport answer, bool expected)
+    {
+        AnswerCapabilityQuery(QueryMouseSupportedCommand.Type, answer);
+
+        Assert.That(Mouse.isSupported, Is.EqualTo(expected));
+    }
+
+    [Test]
+    [Category("Devices")]
+    [TestCase(InputCapabilitySupport.Supported, true)]
+    [TestCase(InputCapabilitySupport.NotSupported, false)]
+    [TestCase(InputCapabilitySupport.Unknown, false)]
+    public void Devices_TouchscreenIsPressureSupported_ReflectsWhatThePlatformAnswers(InputCapabilitySupport answer, bool expected)
+    {
+        AnswerCapabilityQuery(QueryTouchPressureSupportedCommand.Type, answer);
+
+        Assert.That(Touchscreen.isPressureSupported, Is.EqualTo(expected));
+    }
+
+    // The properties describe the platform, not a device, so they must answer without one. This is
+    // the case that separates them from Device.current != null.
+    [Test]
+    [Category("Devices")]
+    public void Devices_CapabilityQueries_AreAnsweredWithNoDeviceAdded()
+    {
+        AnswerCapabilityQuery(QueryPenSupportedCommand.Type, InputCapabilitySupport.Supported);
+
+        Assert.That(InputSystem.devices, Is.Empty);
+        Assert.That(Pen.isSupported, Is.True);
+        Assert.That(Pen.current, Is.Null);
+    }
+
+    // The endpoint is addressed by a reserved id. A capability query must not be delivered to a
+    // real device, which would let a device answer a question about the platform.
+    [Test]
+    [Category("Devices")]
+    public unsafe void Devices_CapabilityQueries_AreNotDeliveredToDevices()
+    {
+        var pen = InputSystem.AddDevice<Pen>();
+        var receivedByDevice = 0;
+        runtime.SetDeviceCommandCallback(pen,
+            (id, command) =>
+            {
+                if (command->type == QueryPenSupportedCommand.Type)
+                    ++receivedByDevice;
+                return InputDeviceCommand.GenericFailure;
+            });
+        AnswerCapabilityQuery(QueryPenSupportedCommand.Type, InputCapabilitySupport.Supported);
+
+        Assert.That(Pen.isSupported, Is.True);
+        Assert.That(receivedByDevice, Is.Zero);
+    }
+
+    // A platform capability cannot change while the application runs, so reading the property
+    // repeatedly must not keep issuing commands.
+    [Test]
+    [Category("Devices")]
+    public unsafe void Devices_CapabilityQueries_AreOnlyIssuedOnce()
+    {
+        var queryCount = 0;
+        runtime.SetDeviceCommandCallback(NativeInputCapabilities.systemDeviceId,
+            (id, command) =>
+            {
+                if (command->type != QueryPenSupportedCommand.Type)
+                    return InputDeviceCommand.GenericFailure;
+
+                ++queryCount;
+                *(InputCapabilitySupport*)((byte*)command + InputDeviceCommand.kBaseCommandSize) =
+                    InputCapabilitySupport.Supported;
+                return InputDeviceCommand.GenericSuccess;
+            });
+
+        Assert.That(Pen.isSupported, Is.True);
+        Assert.That(Pen.isSupported, Is.True);
+        Assert.That(Pen.isSupported, Is.True);
+
+        Assert.That(queryCount, Is.EqualTo(1));
+    }
+
+    // Nothing answers, which is what an engine without the endpoint looks like. The property must
+    // report false rather than throwing, and must not retry on every read.
+    [Test]
+    [Category("Devices")]
+    public void Devices_CapabilityQueries_ReportFalseWhenNothingAnswers()
+    {
+        Assert.That(Pen.isSupported, Is.False);
+        Assert.That(Mouse.isSupported, Is.False);
+        Assert.That(Touchscreen.isPressureSupported, Is.False);
+    }
+
+    // Nothing generates the mirror of the engine's enum, and a reordering would silently invert
+    // Supported and NotSupported across the boundary. The engine pins the same values from its side.
+    [Test]
+    [Category("Devices")]
+    public void Devices_CapabilitySupport_MatchesTheEngineWireValues()
+    {
+        Assert.That((byte)InputCapabilitySupport.Unknown, Is.EqualTo((byte)CapabilityState.Unknown));
+        Assert.That((byte)InputCapabilitySupport.NotSupported, Is.EqualTo((byte)CapabilityState.False));
+        Assert.That((byte)InputCapabilitySupport.Supported, Is.EqualTo((byte)CapabilityState.True));
+    }
+
+    // Same reasoning for the codes: the package spells them as FourCC characters, matching every
+    // other command in the Commands folder, while the engine declares them as integer constants.
+    [Test]
+    [Category("Devices")]
+    public void Devices_CapabilityQueryCodes_MatchTheEngineCodes()
+    {
+        Assert.That((int)QueryPenSupportedCommand.Type, Is.EqualTo(NativeInputCapabilities.queryPenSupported));
+        Assert.That((int)QueryMouseSupportedCommand.Type, Is.EqualTo(NativeInputCapabilities.queryMouseSupported));
+        Assert.That((int)QueryTouchPressureSupportedCommand.Type,
+            Is.EqualTo(NativeInputCapabilities.queryTouchPressureSupported));
+    }
+
+    // The payload the package sends must be exactly the one byte the engine's payload validation
+    // accepts. The base command header is stripped before it reaches native.
+    [Test]
+    [Category("Devices")]
+    public void Devices_CapabilityQueryPayload_IsOneByteAfterTheCommandHeader()
+    {
+        Assert.That(QueryPenSupportedCommand.kSize - InputDeviceCommand.kBaseCommandSize, Is.EqualTo(1));
+        Assert.That(QueryMouseSupportedCommand.kSize - InputDeviceCommand.kBaseCommandSize, Is.EqualTo(1));
+        Assert.That(QueryTouchPressureSupportedCommand.kSize - InputDeviceCommand.kBaseCommandSize, Is.EqualTo(1));
+    }
+#endif // UNITY_INPUTSYSTEM_SUPPORTS_CAPABILITY_QUERIES
 }

Assets/Tests/InputSystem/Unity.InputSystem.Tests.asmdef

@@ -81,6 +81,11 @@
             "name": "Unity",
             "expression": "6000.5.0a8",
             "define": "UNITY_INPUTSYSTEM_SUPPORTS_FOCUS_EVENTS"
+        },
+        {
+            "name": "Unity",
+            "expression": "6000.7.0a6",
+            "define": "UNITY_INPUTSYSTEM_SUPPORTS_CAPABILITY_QUERIES"
         }
     ],
     "noEngineReferences": false

Packages/com.unity.inputsystem/CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## [Unreleased] - yyyy-mm-dd
 
+### Added
+
+- Added `Pen.isSupported`, `Mouse.isSupported` and `Touchscreen.isPressureSupported`, which report what the current platform is capable of rather than what is connected right now. Use them to decide whether to offer device-specific functionality, and keep using `Device.current != null` to ask whether a device is available to read from. This replaces the legacy `UnityEngine.Input.stylusTouchSupported` and `Input.mousePresent`, which conflated the two questions. The properties require an Editor version that can answer the query and are not compiled in on older versions [ISX-2046](https://jira.unity3d.com/browse/ISX-2046)
+
 ### Fixed
 
 - Fixed the Inspector help button for a selected `.inputactions` asset ("Open Reference for Input Action Importer") opening a missing documentation page; it now links to the Action Assets manual page [UUM-149518](https://issuetracker.unity3d.com/product/unity/issues/guid/UUM-149518)

Packages/com.unity.inputsystem/InputSystem/Runtime/Devices/Commands/InputCapabilitySupport.cs

@@ -0,0 +1,36 @@
+#if UNITY_INPUTSYSTEM_SUPPORTS_CAPABILITY_QUERIES
+namespace UnityEngine.InputSystem.LowLevel
+{
+    /// <summary>
+    /// Answer to a platform capability query, meaning what the platform can deliver rather than
+    /// what is currently connected.
+    /// </summary>
+    /// <remarks>
+    /// Mirrors <c>CapabilityState</c> in the engine's <c>Modules/Input/InputDeviceIOCTL.h</c>, whose
+    /// wire values are pinned by tests on both sides. <see cref="Unknown"/> is zero so that an
+    /// unwritten payload, or a platform that has not implemented a query, reads as "we do not know"
+    /// rather than as a confident <see cref="NotSupported"/>.
+    ///
+    /// The value space is open. Treat anything other than <see cref="Supported"/> as not supported
+    /// rather than rejecting it, because a newer engine may answer with a value this version of the
+    /// package does not know about.
+    /// </remarks>
+    internal enum InputCapabilitySupport : byte
+    {
+        /// <summary>
+        /// The platform has no answer, typically because it has not implemented the query yet.
+        /// </summary>
+        Unknown = 0,
+
+        /// <summary>
+        /// The platform definitively cannot deliver it.
+        /// </summary>
+        NotSupported = 1,
+
+        /// <summary>
+        /// The platform definitively can deliver it.
+        /// </summary>
+        Supported = 2
+    }
+}
+#endif // UNITY_INPUTSYSTEM_SUPPORTS_CAPABILITY_QUERIES

Packages/com.unity.inputsystem/InputSystem/Runtime/Devices/Commands/InputCapabilitySupport.cs.meta

@@ -0,0 +1,45 @@
+#if UNITY_INPUTSYSTEM_SUPPORTS_CAPABILITY_QUERIES
+using System.Runtime.InteropServices;
+using UnityEngine.InputSystem.Utilities;
+
+namespace UnityEngine.InputSystem.LowLevel
+{
+    /// <summary>
+    /// Queries whether the platform can deliver mouse input at all, as opposed to whether a mouse is
+    /// connected right now.
+    /// </summary>
+    /// <remarks>
+    /// Addressed to the engine's system endpoint rather than to a device, so it is sent through
+    /// <see cref="InputManager.ExecuteSystemCommand{TCommand}"/> rather than
+    /// <see cref="InputDevice.ExecuteCommand{TCommand}"/>. Presence is answered by the device list.
+    ///
+    /// The FourCC must match <c>kInputFourCCIOCTLQueryMouseSupported</c> in the engine's
+    /// <c>Modules/Input/InputFourCC.h</c>.
+    /// </remarks>
+    /// <seealso cref="Mouse.isSupported"/>
+    [StructLayout(LayoutKind.Explicit, Size = kSize)]
+    internal struct QueryMouseSupportedCommand : IInputDeviceCommandInfo
+    {
+        public static FourCC Type => new FourCC('Q', 'M', 'O', 'U');
+
+        internal const int kSize = InputDeviceCommand.kBaseCommandSize + sizeof(byte);
+
+        [FieldOffset(0)]
+        public InputDeviceCommand baseCommand;
+
+        [FieldOffset(InputDeviceCommand.kBaseCommandSize)]
+        public InputCapabilitySupport isSupported;
+
+        public FourCC typeStatic => Type;
+
+        public static QueryMouseSupportedCommand Create()
+        {
+            return new QueryMouseSupportedCommand
+            {
+                baseCommand = new InputDeviceCommand(Type, kSize),
+                isSupported = InputCapabilitySupport.Unknown
+            };
+        }
+    }
+}
+#endif // UNITY_INPUTSYSTEM_SUPPORTS_CAPABILITY_QUERIES

Packages/com.unity.inputsystem/InputSystem/Runtime/Devices/Commands/QueryMouseSupportedCommand.cs

@@ -0,0 +1,45 @@
+#if UNITY_INPUTSYSTEM_SUPPORTS_CAPABILITY_QUERIES
+using System.Runtime.InteropServices;
+using UnityEngine.InputSystem.Utilities;
+
+namespace UnityEngine.InputSystem.LowLevel
+{
+    /// <summary>
+    /// Queries whether the platform can deliver pen input at all, as opposed to whether a pen is
+    /// connected right now.
+    /// </summary>
+    /// <remarks>
+    /// Addressed to the engine's system endpoint rather than to a device, so it is sent through
+    /// <see cref="InputManager.ExecuteSystemCommand{TCommand}"/> rather than
+    /// <see cref="InputDevice.ExecuteCommand{TCommand}"/>. Presence is answered by the device list.
+    ///
+    /// The FourCC must match <c>kInputFourCCIOCTLQueryPenSupported</c> in the engine's
+    /// <c>Modules/Input/InputFourCC.h</c>.
+    /// </remarks>
+    /// <seealso cref="Pen.isSupported"/>
+    [StructLayout(LayoutKind.Explicit, Size = kSize)]
+    internal struct QueryPenSupportedCommand : IInputDeviceCommandInfo
+    {
+        public static FourCC Type => new FourCC('Q', 'P', 'E', 'N');
+
+        internal const int kSize = InputDeviceCommand.kBaseCommandSize + sizeof(byte);
+
+        [FieldOffset(0)]
+        public InputDeviceCommand baseCommand;
+
+        [FieldOffset(InputDeviceCommand.kBaseCommandSize)]
+        public InputCapabilitySupport isSupported;
+
+        public FourCC typeStatic => Type;
+
+        public static QueryPenSupportedCommand Create()
+        {
+            return new QueryPenSupportedCommand
+            {
+                baseCommand = new InputDeviceCommand(Type, kSize),
+                isSupported = InputCapabilitySupport.Unknown
+            };
+        }
+    }
+}
+#endif // UNITY_INPUTSYSTEM_SUPPORTS_CAPABILITY_QUERIES