pass both logical key & physical key to input handler on keyboard keypress

examples/dart/js_wasm/web/web_input_handler.dart

@@ -88,17 +88,19 @@ class WebInputHandler {
   }
 
   void _onKeyDown(web.KeyboardEvent event) {
-    PhysicalKey? key = _getPhysicalKeyFromEvent(event);
+    PhysicalKey? physicalKey = _getPhysicalKeyFromEvent(event);
-    if (key != null) {
+    LogicalKey? logicalKey = _getLogicalKeyFromEvent(event);
-      inputHandler.handle(KeyEvent(KeyEventType.down, key));
+    if (physicalKey != null && logicalKey != null) {
+      inputHandler.handle(KeyEvent(KeyEventType.down, logicalKey, physicalKey));
     }
     event.preventDefault();
   }
 
   void _onKeyUp(web.KeyboardEvent event) {
-    PhysicalKey? key = _getPhysicalKeyFromEvent(event);
+    LogicalKey? logicalKey = _getLogicalKeyFromEvent(event);
-    if (key != null) {
+    PhysicalKey? physicalKey = _getPhysicalKeyFromEvent(event);
-      inputHandler.handle(KeyEvent(KeyEventType.up, key));
+    if (physicalKey != null && logicalKey != null) {
+      inputHandler.handle(KeyEvent(KeyEventType.up, logicalKey, physicalKey));
     }
     event.preventDefault();
   }
@@ -210,16 +212,31 @@ class WebInputHandler {
     return null;
   }
 
-  PhysicalKey? _getPhysicalKeyFromEvent(web.KeyboardEvent event) {
+    PhysicalKey? _getPhysicalKeyFromEvent(web.KeyboardEvent event) {
     switch (event.code) {
       case 'KeyW':
-        return PhysicalKey.W;
+        return PhysicalKey.w;
       case 'KeyA':
-        return PhysicalKey.A;
+        return PhysicalKey.a;
       case 'KeyS':
-        return PhysicalKey.S;
+        return PhysicalKey.s;
       case 'KeyD':
-        return PhysicalKey.D;
+        return PhysicalKey.d;
+      default:
+        return null;
+    }
+  }
+
+  LogicalKey? _getLogicalKeyFromEvent(web.KeyboardEvent event) {
+    switch (event.key) {
+      case 'KeyW':
+        return LogicalKey.w;
+      case 'KeyA':
+        return LogicalKey.a;
+      case 'KeyS':
+        return LogicalKey.s;
+      case 'KeyD':
+        return LogicalKey.d;
       default:
         return null;
     }

thermion_dart/lib/src/input/src/delegate_input_handler.dart

@@ -64,16 +64,16 @@ class DelegateInputHandler implements InputHandler {
     _processing = true;
 
     final delegate = delegates.first;
-    final keyUp = <PhysicalKey, KeyEvent>{};
+    final keyUp = <LogicalKey, KeyEvent>{};
-    final keyDown = <PhysicalKey, KeyEvent>{};
+    final keyDown = <LogicalKey, KeyEvent>{};
 
     for (final event in _events) {
       if (event is KeyEvent) {
         switch (event.type) {
           case KeyEventType.up:
-            keyUp[event.key] = event;
+            keyUp[event.logicalKey] = event;
           case KeyEventType.down:
-            keyDown[event.key] = event;
+            keyDown[event.logicalKey] = event;
         }
       }
     }

thermion_dart/lib/src/input/src/implementations/free_flight_camera_delegate_v2.dart

@@ -69,32 +69,33 @@ class FreeFlightInputHandlerDelegateV2 implements InputHandlerDelegate {
           break;
         case ScaleEndEvent(numPointers: final numPointers):
           break;
-        case KeyEvent(type: final type, key: var key):
+        case KeyEvent(type: final type, logicalKey: var logicalKey, physicalKey: var physicalKey  ):
-          switch (key) {
+          switch (physicalKey) {
-            case PhysicalKey.A:
+            case PhysicalKey.a:
               translation += Vector3(
                 -sensitivity.keySensitivity,
                 0,
                 0,
               );
               break;
-            case PhysicalKey.S:
+            case PhysicalKey.s:
               translation += Vector3(0, 0, sensitivity.keySensitivity);
               break;
-            case PhysicalKey.D:
+            case PhysicalKey.d:
               translation += Vector3(
                 sensitivity.keySensitivity,
                 0,
                 0,
               );
               break;
-            case PhysicalKey.W:
+            case PhysicalKey.w:
               translation += Vector3(
                 0,
                 0,
                 -sensitivity.keySensitivity,
               );
               break;
+            default:
           }
           break;
       }

thermion_dart/lib/src/input/src/input_types.dart

@@ -80,13 +80,16 @@ class ScrollEvent extends InputEvent {
 
 class KeyEvent extends InputEvent {
   final KeyEventType type;
-  final PhysicalKey key;
+  final LogicalKey logicalKey;
+  final PhysicalKey physicalKey;
 
-  KeyEvent(this.type, this.key);
+  KeyEvent(this.type, this.logicalKey, this.physicalKey);
 }
 
 enum KeyEventType { down, up }
 
-enum PhysicalKey { W, A, S, D }
+enum LogicalKey { w, a, s, d, g, r, shift, esc, del }
+
+enum PhysicalKey { w, a, s, d, g, r, shift, esc, del }
 
 enum InputAction { TRANSLATE, ROTATE, PICK, ZOOM, NONE }

thermion_flutter/thermion_flutter/lib/src/widgets/src/thermion_listener_widget.dart

@@ -61,24 +61,40 @@ class _ThermionListenerWidgetState extends State<ThermionListenerWidget> {
     HardwareKeyboard.instance.addHandler(_handleKeyEvent);
   }
 
-  final _keyMap = {
+  final _physicalKeyMap = {
-    PhysicalKeyboardKey.keyW: PhysicalKey.W,
+    PhysicalKeyboardKey.keyW: PhysicalKey.w,
-    PhysicalKeyboardKey.keyA: PhysicalKey.A,
+    PhysicalKeyboardKey.keyA: PhysicalKey.a,
-    PhysicalKeyboardKey.keyS: PhysicalKey.S,
+    PhysicalKeyboardKey.keyS: PhysicalKey.s,
-    PhysicalKeyboardKey.keyD: PhysicalKey.D,
+    PhysicalKeyboardKey.keyD: PhysicalKey.d,
+    PhysicalKeyboardKey.escape: PhysicalKey.esc,
+    PhysicalKeyboardKey.delete: PhysicalKey.del,
+    PhysicalKeyboardKey.keyG: PhysicalKey.g,
+    PhysicalKeyboardKey.keyR: PhysicalKey.r,
+  };
+
+  final _logicalKeyMap = {
+    LogicalKeyboardKey.keyW: LogicalKey.w,
+    LogicalKeyboardKey.keyA: LogicalKey.a,
+    LogicalKeyboardKey.keyS: LogicalKey.s,
+    LogicalKeyboardKey.keyD: LogicalKey.d,
+    LogicalKeyboardKey.escape: LogicalKey.esc,
+    LogicalKeyboardKey.delete: LogicalKey.del,
+    LogicalKeyboardKey.keyG: LogicalKey.g,
+    LogicalKeyboardKey.keyR: LogicalKey.r,
   };
 
   bool _handleKeyEvent(KeyEvent event) {
-    PhysicalKey? key = _keyMap[event.physicalKey];
+    final physicalKey = _physicalKeyMap[event.physicalKey];
+    final logicalKey = _logicalKeyMap[event.logicalKey];
 
-    if (key == null) {
+    if (physicalKey == null || logicalKey == null) {
       return false;
     }
 
     if (event is KeyDownEvent || event is KeyRepeatEvent) {
-      widget.inputHandler.handle(t.KeyEvent(KeyEventType.down, key));
+      widget.inputHandler.handle(t.KeyEvent(KeyEventType.down, logicalKey, physicalKey));
     } else if (event is KeyUpEvent) {
-      widget.inputHandler.handle(t.KeyEvent(KeyEventType.up, key));
+      widget.inputHandler.handle(t.KeyEvent(KeyEventType.up, logicalKey, physicalKey));
       return true;
     }
     return false;
@@ -189,12 +205,6 @@ class _MobileListenerWidgetState extends State<_MobileListenerWidget> {
   Widget build(BuildContext context) {
     return GestureDetector(
         behavior: HitTestBehavior.translucent,
-        // onPanDown: (event) {
-        //   print("PAN DOWN");
-        // },
-        // onTapMove: (event) {
-        //   print("TAP MOVE");
-        // },
         onTapDown: (details) {
           widget.inputHandler.handle(TouchEvent(TouchEventType.tap,
               details.localPosition.toVector2() * widget.pixelRatio, null));