wip

Author: bmalrat

Assets/Tests/InputSystem/CorePerformanceTests.cs

@@ -123,8 +123,14 @@ public void Performance_ReadEveryKey()
 
         Measure.Method(() =>
         {
+            int keyIndex = 0;
             foreach (var key in keyboard.allKeys)
+            {
+                if (++keyIndex == (int) KeyEx.IMESelected) // Skip IMESelected as it's not a real key.
+                    continue;
                 key.ReadValue();
+                
+            }
         })
             .MeasurementCount(100)
             .WarmupCount(5)

Assets/Tests/InputSystem/CoreTests_Devices.cs

@@ -2674,7 +2674,7 @@ public void Devices_AnyKeyOnKeyboard_DoesNotReactToIMESelected()
     {
         var keyboard = InputSystem.AddDevice<Keyboard>();
 
-        InputSystem.QueueStateEvent(keyboard, new KeyboardState(Key.IMESelected));
+        InputSystem.QueueStateEvent(keyboard, new KeyboardState(IMESelected: true));
         InputSystem.Update();
 
         Assert.That(keyboard.anyKey.isPressed, Is.False);

Packages/com.unity.inputsystem/InputSystem/Devices/Keyboard.cs

@@ -38,10 +38,10 @@ public unsafe struct KeyboardState : IInputStateTypeInfo
         /// <seealso cref="InputStateBlock.format"/>
         public static FourCC Format => new FourCC('K', 'E', 'Y', 'S');
 
-        private const int kSizeInBits = Keyboard.KeyCount;
+        private const int kSizeInBits = Keyboard.KeyCount + 1; // +1 for IMESelected.
         internal const int kSizeInBytes = (kSizeInBits + 7) / 8;
 
-        [InputControl(name = "anyKey", displayName = "Any Key", layout = "AnyKey", sizeInBits = kSizeInBits - 1, synthetic = true)] // Exclude IMESelected.
+        [InputControl(name = "anyKey", displayName = "Any Key", layout = "AnyKey", offset = 1, sizeInBits = (int)Key.F24, synthetic = true)]
         [InputControl(name = "escape", displayName = "Escape", layout = "Key", usages = new[] {"Back", "Cancel"}, bit = (int)Key.Escape)]
         [InputControl(name = "space", displayName = "Space", layout = "Key", bit = (int)Key.Space)]
         [InputControl(name = "enter", displayName = "Enter", layout = "Key", usage = "Submit", bit = (int)Key.Enter)]
@@ -155,17 +155,42 @@ public unsafe struct KeyboardState : IInputStateTypeInfo
         [InputControl(name = "OEM3", layout = "Key", bit = (int)Key.OEM3)]
         [InputControl(name = "OEM4", layout = "Key", bit = (int)Key.OEM4)]
         [InputControl(name = "OEM5", layout = "Key", bit = (int)Key.OEM5)]
-        [InputControl(name = "IMESelected", layout = "Button", bit = (int)Key.IMESelected, synthetic = true)]
+        [InputControl(name = "f13", displayName = "F13", layout = "Key", bit = (int)Key.F13)]
+        [InputControl(name = "f14", displayName = "F14", layout = "Key", bit = (int)Key.F14)]
+        [InputControl(name = "f15", displayName = "F15", layout = "Key", bit = (int)Key.F15)]
+        [InputControl(name = "f16", displayName = "F16", layout = "Key", bit = (int)Key.F16)]
+        [InputControl(name = "f17", displayName = "F17", layout = "Key", bit = (int)Key.F17)]
+        [InputControl(name = "f18", displayName = "F18", layout = "Key", bit = (int)Key.F18)]
+        [InputControl(name = "f19", displayName = "F19", layout = "Key", bit = (int)Key.F19)]
+        [InputControl(name = "f20", displayName = "F20", layout = "Key", bit = (int)Key.F20)]
+        [InputControl(name = "f21", displayName = "F21", layout = "Key", bit = (int)Key.F21)]
+        [InputControl(name = "f22", displayName = "F22", layout = "Key", bit = (int)Key.F22)]
+        [InputControl(name = "f23", displayName = "F23", layout = "Key", bit = (int)Key.F23)]
+        [InputControl(name = "f24", displayName = "F24", layout = "Key", bit = (int)Key.F24)]
+        [InputControl(name = "IMESelected", layout = "Button", bit = (int)KeyEx.RemapedIMESelected, synthetic = true)] // Use the last bit to hold IME selected state.
         public fixed byte keys[kSizeInBytes];
 
-        public KeyboardState(params Key[] pressedKeys)
+        // will be the default in new editor [InputControl(name = "IMESelected", layout = "Button", bit = 0, sizeInBits = 1, synthetic = true)]
+        //public byte modifiers;
+
+        public KeyboardState(params Key[] pressedKeys) : this(false, pressedKeys)
+        {
+
+        }
+
+        public KeyboardState(bool IMESelected, params Key[] pressedKeys)
         {
             if (pressedKeys == null)
                 throw new ArgumentNullException(nameof(pressedKeys));
-
-            fixed(byte* keysPtr = keys)
+            fixed (byte* keysPtr = keys)
             {
                 UnsafeUtility.MemClear(keysPtr, kSizeInBytes);
+
+                if (IMESelected)
+                {
+                    MemoryHelpers.WriteSingleBit(keysPtr, (uint)KeyEx.IMESelected, true);
+                }
+
                 for (var i = 0; i < pressedKeys.Length; ++i)
                     MemoryHelpers.WriteSingleBit(keysPtr, (uint)pressedKeys[i], true);
             }
@@ -177,6 +202,14 @@ public void Set(Key key, bool state)
             MemoryHelpers.WriteSingleBit(keysPtr, (uint)key, state);
         }
 
+        internal bool Get(Key key)
+        {
+            fixed (byte* keysPtr = keys)
+            {
+                return MemoryHelpers.ReadSingleBit(keysPtr, (uint)key);
+            }
+        }
+
         public void Press(Key key)
         {
             Set(key, true);
@@ -842,9 +875,86 @@ public enum Key
         /// </summary>
         OEM5,
 
-        ////FIXME: This should never have been a Key but rather just an extra button or state on keyboard
-        // Not exactly a key, but binary data sent by the Keyboard to say if IME is being used.
-        IMESelected
+        /// <summary>
+        /// Don't use this. This is a dummy key that is only used internally to represent the IME selected state.
+        /// Will be removed in the future.
+        /// </summary>
+        [Obsolete("Don't use this. This is a dummy key that is only used internally to represent the IME selected state. Will be removed in the future.", true)]
+        IMESelected,
+
+        /// <summary>
+        /// The <see cref="Keyboard.f13Key"/>.
+        /// </summary>
+        F13,
+
+        /// <summary>
+        /// The <see cref="Keyboard.f14Key"/>.
+        /// </summary>
+        F14,
+
+        /// <summary>
+        /// The <see cref="Keyboard.f15Key"/>.
+        /// </summary>
+        F15,
+
+        /// <summary>
+        /// The <see cref="Keyboard.f16Key"/>.
+        /// </summary>
+        F16,
+
+        /// <summary>
+        /// The <see cref="Keyboard.f17Key"/>.
+        /// </summary>
+        F17,
+
+        /// <summary>
+        /// The <see cref="Keyboard.f18Key"/>.
+        /// </summary>
+        F18,
+
+        /// <summary>
+        /// The <see cref="Keyboard.f19Key"/>.
+        /// </summary>
+        F19,
+
+        /// <summary>
+        /// The <see cref="Keyboard.f20Key"/>.
+        /// </summary>
+        F20,
+
+        /// <summary>
+        /// The <see cref="Keyboard.f21Key"/>.
+        /// </summary>
+        F21,
+
+        /// <summary>
+        /// The <see cref="Keyboard.f22Key"/>.
+        /// </summary>
+        F22,
+
+        /// <summary>
+        /// The <see cref="Keyboard.f23Key"/>.
+        /// </summary>
+        F23,
+
+        /// <summary>
+        /// The <see cref="Keyboard.f24Key"/>.
+        /// </summary>
+        F24,
+
+        /// <summary>
+        /// Don't use this. This is a dummy key that is only used internally to represent the IME selected state.
+        /// Will be removed in the future.
+        /// FIXME: This should never have been a Key but rather just an extra button or state on keyboard
+        /// Not exactly a key, but binary data sent by the Keyboard to say if IME is being used.
+        /// </summary>
+        //InternalForIMESelected = 127,
+    }
+
+    internal static class KeyEx
+    {
+        internal const Key IMESelected = (Key)111; //IMESelected value
+        internal const Key RemapedIMESelected = (Key)127; //IMESelected value
     }
 
     /// <summary>
@@ -877,14 +987,15 @@ public enum Key
     /// keyboard has certain keys or not.
     /// </remarks>
     [InputControlLayout(stateType = typeof(KeyboardState), isGenericTypeOfDevice = true)]
-    public class Keyboard : InputDevice, ITextInputReceiver
+    public class Keyboard : InputDevice, ITextInputReceiver, IEventPreProcessor
     {
         /// <summary>
         /// Total number of key controls on a keyboard, i.e. the number of controls
         /// in <see cref="allKeys"/>.
         /// </summary>
         /// <value>Total number of key controls.</value>
-        public const int KeyCount = (int)Key.OEM5;
+        public const int KeyCount = (int)Key.F24 - 1; // without IMESelected
+        // without IMESelected
 
         /// <summary>
         /// Event that is fired for every single character entered on the keyboard.
@@ -1862,6 +1973,7 @@ public string keyboardLayout
         /// <value>Control representing the F12 key.</value>
         public KeyControl f12Key => this[Key.F12];
 
+
         /// <summary>
         /// First additional key on the keyboard.
         /// </summary>
@@ -2149,17 +2261,32 @@ protected override void FinishSetup()
                 "oem3",
                 "oem4",
                 "oem5",
+                null, // IMESelected
+                "f13",
+                "f14",
+                "f15",
+                "f16",
+                "f17",
+                "f18",
+                "f19",
+                "f20",
+                "f21",
+                "f22",
+                "f23",
+                "f24",
             };
             m_Keys = new KeyControl[keyStrings.Length];
             for (var i = 0; i < keyStrings.Length; ++i)
             {
+                if (string.IsNullOrEmpty(keyStrings[i]))
+                    continue;
                 m_Keys[i] = GetChildControl<KeyControl>(keyStrings[i]);
 
                 ////REVIEW: Ideally, we'd have a way to do this through layouts; this way nested key controls could work, too,
                 ////        and it just seems somewhat dirty to jam the data into the control here
                 m_Keys[i].keyCode = (Key)(i + 1);
             }
-            Debug.Assert(keyStrings[(int)Key.OEM5 - 1] == "oem5",
+            Debug.Assert(keyStrings[(int)Key.F24 - 1] == "f24",
                 "keyString array layout doe not match Key enum layout");
             anyKey = GetChildControl<AnyKeyControl>("anyKey");
             shiftKey = GetChildControl<ButtonControl>("shift");
@@ -2228,6 +2355,44 @@ public void OnIMECompositionChanged(IMECompositionString compositionString)
             }
         }
 
+        public unsafe bool PreProcessEvent(InputEventPtr currentEventPtr)
+        {
+            if (currentEventPtr.type == StateEvent.Type)
+            {
+                var stateEvent = StateEvent.FromUnchecked(currentEventPtr);
+                if (stateEvent->stateFormat == KeyboardState.Format)
+                {
+                    var keyboardState = ((KeyboardState*)(stateEvent->stateData));
+                    if(keyboardState->Get(KeyEx.IMESelected))
+                    {
+                        keyboardState->Set(KeyEx.IMESelected, false);
+                        keyboardState->Set(KeyEx.RemapedIMESelected, true);
+                    }
+
+                    //stateEvent->stateSizeInBytes = KeyboardState.kSizeInBytes;
+
+                    //keyboardState->
+                    //if (stateEvent->)
+                    //var imeSelected = ((KeyboardState*)(stateEvent))->Get(Key.InternalForIMESelected);
+
+                    //((KeyboardState*)(stateEvent))->Set(Key.IMESelected, ((KeyboardState*)(stateEvent))->Get(Key.DiscardedIMESelected));
+                    ////((KeyboardState*)(stateEvent))->keys[]
+                    //if (stateEvent->stateSizeInBytes != KeyboardState.kSizeInBytes)
+                    //{
+                    //    //imeSelected
+                    //    ((KeyboardState*)(stateEvent))->Set(Key.IMESelected, ((KeyboardState*)(stateEvent))->Get(Key.DiscardedIMESelected));
+                    //    ((KeyboardState*)(stateEvent))->Set(Key.DiscardedIMESelected, false);
+                    //    Debug.Log($"FastKeyboard: StateEvent size mismatch {stateEvent->stateSizeInBytes} {KeyboardState.kSizeInBytes}");
+                    //}
+
+                }
+
+
+            }
+
+            return true;
+        }
+
         private InlinedArray<Action<char>> m_TextInputListeners;
         private string m_KeyboardLayoutName;
         private KeyControl[] m_Keys;