chore: rearrange library dirs, gesture handler improvements

thermion_dart/lib/thermion_dart.dart

@@ -1,4 +1,5 @@
 library filament_dart;
 
+export 'thermion_dart/input/input.dart';
 export 'thermion_dart/thermion_viewer.dart';
 export 'thermion_dart/utils/geometry.dart';

thermion_dart/lib/thermion_dart/input/input.dart

@@ -0,0 +1,5 @@
+library;
+
+export 'src/input_handler.dart';
+export 'src/delegates.dart';
+export 'src/delegate_gesture_handler.dart';

thermion_dart/lib/thermion_dart/input/src/delegate_gesture_handler.dart

@@ -0,0 +1,237 @@
+import 'dart:async';
+import 'package:logging/logging.dart';
+import 'package:thermion_dart/thermion_dart/input/src/delegates.dart';
+import 'package:vector_math/vector_math_64.dart';
+
+import '../../viewer/thermion_viewer_base.dart';
+import 'implementations/fixed_orbit_camera_rotation_delegate.dart';
+import 'implementations/free_flight_camera_delegate.dart';
+import 'input_handler.dart';
+
+class DelegateInputHandler implements InputHandler {
+  final ThermionViewer viewer;
+
+  final _logger = Logger("DelegateInputHandler");
+
+  InputHandlerDelegate? transformDelegate;
+  PickDelegate? pickDelegate;
+
+  final Set<PhysicalKey> _pressedKeys = {};
+
+  final _inputDeltas = <InputType, Vector3>{};
+
+  Map<InputType, InputAction> _actions = {
+    InputType.LMB_HOLD_AND_MOVE: InputAction.TRANSLATE,
+    InputType.MMB_HOLD_AND_MOVE: InputAction.ROTATE,
+    InputType.SCROLLWHEEL: InputAction.TRANSLATE,
+    InputType.POINTER_MOVE: InputAction.NONE,
+    InputType.KEYDOWN_W: InputAction.TRANSLATE,
+    InputType.KEYDOWN_S: InputAction.TRANSLATE,
+    InputType.KEYDOWN_A: InputAction.TRANSLATE,
+    InputType.KEYDOWN_D: InputAction.TRANSLATE,
+  };
+
+  final _axes = <InputType, Matrix3>{};
+
+  void setTransformForAction(InputType inputType, Matrix3 transform) {
+    _axes[inputType] = transform;
+  }
+
+  DelegateInputHandler({
+    required this.viewer,
+    required this.transformDelegate,
+    this.pickDelegate,
+    Map<InputType, InputAction>? actions,
+  }) {
+    if (actions != null) {
+      _actions = actions;
+    }
+
+    for (var gestureType in InputType.values) {
+      _inputDeltas[gestureType] = Vector3.zero();
+    }
+
+    viewer.registerRequestFrameHook(process);
+  }
+
+  factory DelegateInputHandler.fixedOrbit(ThermionViewer viewer,
+          {double minimumDistance = 10.0,
+          double? Function(Vector3)? getDistanceToTarget,
+          ThermionEntity? entity,
+          PickDelegate? pickDelegate}) =>
+      DelegateInputHandler(
+          viewer: viewer,
+          pickDelegate: pickDelegate,
+          transformDelegate: FixedOrbitRotateInputHandlerDelegate(viewer,
+              getDistanceToTarget: getDistanceToTarget,
+              minimumDistance: minimumDistance),
+          actions: {
+            InputType.MMB_HOLD_AND_MOVE: InputAction.ROTATE,
+            InputType.SCROLLWHEEL: InputAction.TRANSLATE
+          });
+
+  factory DelegateInputHandler.flight(ThermionViewer viewer,
+          {PickDelegate? pickDelegate, bool freeLook=false}) =>
+      DelegateInputHandler(
+          viewer: viewer,
+          pickDelegate: pickDelegate,
+          transformDelegate: FreeFlightInputHandlerDelegate(viewer),
+          actions: {
+            InputType.MMB_HOLD_AND_MOVE: InputAction.ROTATE,
+            InputType.SCROLLWHEEL: InputAction.TRANSLATE,
+            InputType.LMB_HOLD_AND_MOVE: InputAction.TRANSLATE,
+            InputType.KEYDOWN_A: InputAction.TRANSLATE,
+            InputType.KEYDOWN_W: InputAction.TRANSLATE,
+            InputType.KEYDOWN_S: InputAction.TRANSLATE,
+            InputType.KEYDOWN_D: InputAction.TRANSLATE,
+            if(freeLook)
+            InputType.POINTER_MOVE: InputAction.ROTATE,
+          });
+
+  bool _processing = false;
+  Future<void> process() async {
+    _processing = true;
+    for (var gestureType in _inputDeltas.keys) {
+      var vector = _inputDeltas[gestureType]!;
+      var action = _actions[gestureType];
+      if (action == null) {
+        continue;
+      }
+      final transform = _axes[gestureType];
+      if (transform != null) {
+        vector = transform * vector;
+      }
+
+      await transformDelegate?.queue(action, vector);
+    }
+
+    for (final key in _pressedKeys) {
+      InputAction? keyAction;
+      Vector3? vector;
+
+      switch (key) {
+        case PhysicalKey.W:
+          keyAction = _actions[InputType.KEYDOWN_W];
+          vector = Vector3(0, 0, -1);
+          break;
+        case PhysicalKey.A:
+          keyAction = _actions[InputType.KEYDOWN_A];
+          vector = Vector3(-1, 0, 0);
+          break;
+        case PhysicalKey.S:
+          keyAction = _actions[InputType.KEYDOWN_S];
+          vector = Vector3(0, 0, 1);
+          break;
+        case PhysicalKey.D:
+          keyAction = _actions[InputType.KEYDOWN_D];
+          vector = Vector3(1, 0, 0);
+          break;
+      }
+      if (keyAction != null) {
+        var transform = _axes[keyAction];
+        if (transform != null) {
+          vector = transform * vector;
+        }
+        transformDelegate?.queue(keyAction, vector!);
+      }
+    }
+
+    await transformDelegate?.execute();
+    _inputDeltas.clear();
+    _processing = false;
+  }
+
+  @override
+  Future<void> onPointerDown(Vector2 localPosition, bool isMiddle) async {
+    if (!isMiddle) {
+      final action = _actions[InputType.LMB_DOWN];
+      switch (action) {
+        case InputAction.PICK:
+          pickDelegate?.pick(localPosition);
+        default:
+        // noop
+      }
+    }
+  }
+
+  @override
+  Future<void> onPointerMove(
+      Vector2 localPosition, Vector2 delta, bool isMiddle) async {
+    if (_processing) {
+      return;
+    }
+    if (isMiddle) {
+      _inputDeltas[InputType.MMB_HOLD_AND_MOVE] =
+          (_inputDeltas[InputType.MMB_HOLD_AND_MOVE] ?? Vector3.zero()) + Vector3(delta.x, delta.y, 0.0);
+    } else {
+      _inputDeltas[InputType.LMB_HOLD_AND_MOVE] =
+          (_inputDeltas[InputType.LMB_HOLD_AND_MOVE] ?? Vector3.zero()) + Vector3(delta.x, delta.y, 0.0);
+    }
+    // else {
+    //   _inputDeltas[InputType.POINTER_MOVE] =
+    //       (_inputDeltas[InputType.POINTER_MOVE] ?? Vector3.zero()) + delta;
+    // }
+  }
+
+  @override
+  Future<void> onPointerUp(bool isMiddle) async {}
+
+  @override
+  Future<void> onPointerHover(Vector2 localPosition, Vector2 delta) async {
+    if (_processing) {
+      return;
+    }
+    _inputDeltas[InputType.POINTER_MOVE] =
+        (_inputDeltas[InputType.POINTER_MOVE] ?? Vector3.zero()) + Vector3(delta.x, delta.y, 0.0);
+  }
+
+  @override
+  Future<void> onPointerScroll(
+      Vector2 localPosition, double scrollDelta) async {
+    if (_processing) {
+      return;
+    }
+    try {
+      _inputDeltas[InputType.SCROLLWHEEL] =
+          (_inputDeltas[InputType.SCROLLWHEEL] ?? Vector3.zero())
+              + Vector3(0,0, scrollDelta > 0 ? 1 : -1);
+    } catch (e) {
+      _logger.warning("Error during scroll accumulation: $e");
+    }
+  }
+
+  @override
+  Future dispose() async {
+    viewer.unregisterRequestFrameHook(process);
+  }
+
+  @override
+  Future<bool> get initialized => viewer.initialized;
+
+  @override
+  Future<void> onScaleEnd() async {}
+
+  @override
+  Future<void> onScaleStart() async {}
+
+  @override
+  Future<void> onScaleUpdate() async {}
+
+  @override
+  void setActionForType(InputType gestureType, InputAction gestureAction) {
+    _actions[gestureType] = gestureAction;
+  }
+
+  @override
+  InputAction? getActionForType(InputType gestureType) {
+    return _actions[gestureType];
+  }
+
+  void keyDown(PhysicalKey key) {
+    _pressedKeys.add(key);
+  }
+
+  void keyUp(PhysicalKey key) {
+    _pressedKeys.remove(key);
+  }
+}

thermion_dart/lib/thermion_dart/input/src/delegates.dart

@@ -0,0 +1,27 @@
+import 'package:vector_math/vector_math_64.dart';
+
+import 'input_handler.dart';
+
+abstract class InputHandlerDelegate {
+  Future queue(InputAction action, Vector3? delta);
+  Future execute();
+}
+
+abstract class VelocityDelegate {
+  Vector2? get velocity;
+
+  void updateVelocity(Vector2 delta);
+
+  void startDeceleration();
+
+  void stopDeceleration();
+
+  void dispose() {
+    stopDeceleration();
+  }
+}
+
+abstract class PickDelegate {
+  const PickDelegate();
+  void pick(Vector2 location);
+}

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

@@ -0,0 +1,87 @@
+// import 'dart:async';
+// import 'dart:ui';
+
+// import 'package:flutter/services.dart';
+// import 'package:thermion_dart/thermion_dart/thermion_viewer.dart';
+// import 'package:thermion_dart/thermion_dart/input/delegates.dart';
+// import 'package:vector_math/vector_math_64.dart';
+
+// class DefaultKeyboardCameraFlightDelegate
+//      {
+//   final ThermionViewer viewer;
+
+//   static const double _panSensitivity = 0.005;
+//   static const double _keyMoveSensitivity = 0.1;
+
+//   final Map<PhysicalKeyboardKey, bool> _pressedKeys = {};
+//   Timer? _moveTimer;
+
+//   DefaultKeyboardCameraFlightDelegate(this.viewer) {
+//     _startMoveLoop();
+//   }
+
+//   @override
+//   Future<void> panCamera(Offset delta, Vector2? velocity) async {
+//     double deltaX = delta.dx;
+//     double deltaY = delta.dy;
+//     deltaX *= _panSensitivity * viewer.pixelRatio;
+//     deltaY *= _panSensitivity * viewer.pixelRatio;
+
+//     await _moveCamera(deltaX, deltaY, 0);
+//   }
+
+//   @override
+//   Future<void> onKeypress(PhysicalKeyboardKey key) async {
+//     _pressedKeys[key] = true;
+//   }
+
+//   // New method to handle key release
+//   Future<void> onKeyRelease(PhysicalKeyboardKey key) async {
+//     _pressedKeys.remove(key);
+//   }
+
+//   void _startMoveLoop() {
+//     _moveTimer = Timer.periodic(
+//         Duration(milliseconds: 16), (_) => _processKeyboardInput());
+//   }
+
+//   Future<void> _processKeyboardInput() async {
+//     double dx = 0, dy = 0, dz = 0;
+
+//     if (_pressedKeys[PhysicalKeyboardKey.keyW] == true)
+//       dz += _keyMoveSensitivity;
+//     if (_pressedKeys[PhysicalKeyboardKey.keyS] == true)
+//       dz -= _keyMoveSensitivity;
+//     if (_pressedKeys[PhysicalKeyboardKey.keyA] == true)
+//       dx -= _keyMoveSensitivity;
+//     if (_pressedKeys[PhysicalKeyboardKey.keyD] == true)
+//       dx += _keyMoveSensitivity;
+
+//     if (dx != 0 || dy != 0 || dz != 0) {
+//       await _moveCamera(dx, dy, dz);
+//     }
+//     // Removed _pressedKeys.clear(); from here
+//   }
+
+//   Future<void> _moveCamera(double dx, double dy, double dz) async {
+//     Matrix4 currentModelMatrix = await viewer.getCameraModelMatrix();
+//     Vector3 currentPosition = currentModelMatrix.getTranslation();
+//     Quaternion currentRotation =
+//         Quaternion.fromRotation(currentModelMatrix.getRotation());
+
+//     Vector3 forward = Vector3(0, 0, -1)..applyQuaternion(currentRotation);
+//     Vector3 right = Vector3(1, 0, 0)..applyQuaternion(currentRotation);
+//     Vector3 up = Vector3(0, 1, 0)..applyQuaternion(currentRotation);
+
+//     Vector3 moveOffset = right * dx + up * dy + forward * dz;
+//     Vector3 newPosition = currentPosition + moveOffset;
+
+//     Matrix4 newModelMatrix =
+//         Matrix4.compose(newPosition, currentRotation, Vector3(1, 1, 1));
+//     await viewer.setCameraModelMatrix4(newModelMatrix);
+//   }
+
+//   void dispose() {
+//     _moveTimer?.cancel();
+//   }
+// }

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

@@ -0,0 +1,35 @@
+// import 'dart:ui';
+
+// import 'package:thermion_dart/thermion_dart/thermion_viewer.dart';
+// import 'package:thermion_flutter/thermion/widgets/camera/gestures/v2/delegates.dart';
+// import 'package:vector_math/vector_math_64.dart';
+
+// class DefaultPanInputHandlerDelegate implements PanInputHandlerDelegate {
+//   final ThermionViewer viewer;
+
+//   static const double _panSensitivity = 0.005;
+
+//   DefaultPanInputHandlerDelegate(this.viewer);
+//   static const double _panSensitivity = 0.005;
+
+//   @override
+//   Future<void> panCamera(Offset delta, Vector2? velocity) async {
+//     double deltaX = delta.dx;
+//     double deltaY = delta.dy;
+//     deltaX *= _panSensitivity * viewer.pixelRatio;
+//     deltaY *= _panSensitivity * viewer.pixelRatio;
+
+//     Matrix4 currentModelMatrix = await viewer.getCameraModelMatrix();
+//     Vector3 currentPosition = currentModelMatrix.getTranslation();
+//     Quaternion currentRotation = Quaternion.fromRotation(currentModelMatrix.getRotation());
+
+//     Vector3 right = Vector3(1, 0, 0)..applyQuaternion(currentRotation);
+//     Vector3 up = Vector3(0, 1, 0)..applyQuaternion(currentRotation);
+
+//     Vector3 panOffset = right * -deltaX + up * deltaY;
+//     Vector3 newPosition = currentPosition + panOffset;
+
+//     Matrix4 newModelMatrix = Matrix4.compose(newPosition, currentRotation, Vector3(1, 1, 1));
+//     await viewer.setCameraModelMatrix4(newModelMatrix);
+//   }
+// }

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

@@ -0,0 +1,131 @@
+import 'dart:async';
+import 'package:thermion_dart/thermion_dart/thermion_viewer.dart';
+import 'package:thermion_dart/thermion_dart/input/src/delegates.dart';
+import 'package:vector_math/vector_math_64.dart';
+import '../../../viewer/shared_types/camera.dart';
+import '../input_handler.dart';
+
+class FixedOrbitRotateInputHandlerDelegate implements InputHandlerDelegate {
+  final ThermionViewer viewer;
+  late Future<Camera> _camera;
+  final double minimumDistance;
+  double? Function(Vector3)? getDistanceToTarget;
+
+  Vector2 _queuedRotationDelta = Vector2.zero();
+  double _queuedZoomDelta = 0.0;
+
+  static final _up = Vector3(0, 1, 0);
+  Timer? _updateTimer;
+
+  FixedOrbitRotateInputHandlerDelegate(
+    this.viewer, {
+    this.getDistanceToTarget,
+    this.minimumDistance = 10.0,
+  }) {
+    _camera = viewer.getMainCamera();
+  }
+
+  void dispose() {
+    _updateTimer?.cancel();
+  }
+
+  @override
+  Future<void> queue(InputAction action, Vector3? delta) async {
+    if (delta == null) return;
+
+    switch (action) {
+      case InputAction.ROTATE:
+        _queuedRotationDelta += Vector2(delta.x, delta.y);
+        break;
+      case InputAction.TRANSLATE:
+        _queuedZoomDelta += delta!.z;
+        break;
+      case InputAction.PICK:
+        // Assuming PICK is used for zoom in this context
+        _queuedZoomDelta += delta.z;
+        break;
+      case InputAction.NONE:
+        // Do nothing
+        break;
+    }
+  }
+
+  @override
+  Future<void> execute() async {
+    if (_queuedRotationDelta.length2 == 0.0 && _queuedZoomDelta == 0.0) {
+      return;
+    }
+
+    var viewMatrix = await viewer.getCameraViewMatrix();
+    var modelMatrix = await viewer.getCameraModelMatrix();
+    var projectionMatrix = await viewer.getCameraProjectionMatrix();
+    var inverseProjectionMatrix = projectionMatrix.clone()..invert();
+    Vector3 currentPosition = modelMatrix.getTranslation();
+
+    Vector3 forward = -currentPosition.normalized();
+    Vector3 right = _up.cross(forward).normalized();
+    Vector3 up = forward.cross(right);
+
+    // Calculate intersection point and depth
+    double radius = getDistanceToTarget?.call(currentPosition) ?? 1.0;
+    if (radius != 1.0) {
+      radius = currentPosition.length - radius;
+    }
+    Vector3 intersection = (-forward).scaled(radius);
+
+    final intersectionInViewSpace = viewMatrix *
+        Vector4(intersection.x, intersection.y, intersection.z, 1.0);
+    final intersectionInClipSpace = projectionMatrix * intersectionInViewSpace;
+    final intersectionInNdcSpace =
+        intersectionInClipSpace / intersectionInClipSpace.w;
+
+    // Calculate new camera position based on rotation
+    final ndcX = 2 *
+        ((-_queuedRotationDelta.x * viewer.pixelRatio) /
+            viewer.viewportDimensions.$1);
+    final ndcY = 2 *
+        ((_queuedRotationDelta.y * viewer.pixelRatio) /
+            viewer.viewportDimensions.$2);
+    final ndc = Vector4(ndcX, ndcY, intersectionInNdcSpace.z, 1.0);
+
+    var clipSpace = Vector4(
+        ndc.x * intersectionInClipSpace.w,
+        ndcY * intersectionInClipSpace.w,
+        ndc.z * intersectionInClipSpace.w,
+        intersectionInClipSpace.w);
+    Vector4 cameraSpace = inverseProjectionMatrix * clipSpace;
+    Vector4 worldSpace = modelMatrix * cameraSpace;
+
+    var worldSpace3 = worldSpace.xyz.normalized() * currentPosition.length;
+    currentPosition = worldSpace3;
+
+    // Apply zoom
+    if (_queuedZoomDelta != 0.0) {
+      Vector3 toSurface = currentPosition - intersection;
+      currentPosition =
+          currentPosition + toSurface.scaled(_queuedZoomDelta * 0.1);
+    }
+
+    // Ensure minimum distance
+    if (currentPosition.length < radius + minimumDistance) {
+      currentPosition =
+          (currentPosition.normalized() * (radius + minimumDistance));
+    }
+
+    // Calculate view matrix
+    forward = -currentPosition.normalized();
+    right = _up.cross(forward).normalized();
+    up = forward.cross(right);
+
+    Matrix4 newViewMatrix = makeViewMatrix(currentPosition, Vector3.zero(), up);
+    newViewMatrix.invert();
+
+    // Set the camera model matrix
+    var camera = await _camera;
+    await camera.setModelMatrix(newViewMatrix);
+
+    // Reset queued deltas
+    _queuedRotationDelta = Vector2.zero();
+    _queuedZoomDelta = 0.0;
+  }
+}

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

@@ -0,0 +1,156 @@
+import 'dart:async';
+import 'package:thermion_dart/thermion_dart/input/src/input_handler.dart';
+import 'package:thermion_dart/thermion_dart/thermion_viewer.dart';
+import 'package:vector_math/vector_math_64.dart';
+import '../delegates.dart';
+
+class FreeFlightInputHandlerDelegate implements InputHandlerDelegate {
+  
+  final ThermionViewer viewer;
+  final Vector3? minBounds;
+  final Vector3? maxBounds;
+  final double rotationSensitivity;
+  final double movementSensitivity;
+  final double zoomSensitivity;
+  final double panSensitivity;
+
+  static final _up = Vector3(0, 1, 0);
+  static final _forward = Vector3(0, 0, -1);
+  static final Vector3 _right = Vector3(1, 0, 0);
+
+  Vector2 _queuedRotationDelta = Vector2.zero();
+  Vector2 _queuedPanDelta = Vector2.zero();
+  double _queuedZoomDelta = 0.0;
+  Vector3 _queuedMoveDelta = Vector3.zero();
+
+  FreeFlightInputHandlerDelegate(
+    this.viewer, {
+    this.minBounds,
+    this.maxBounds,
+    this.rotationSensitivity = 0.001,
+    this.movementSensitivity = 0.1,
+    this.zoomSensitivity = 0.1,
+    this.panSensitivity = 0.1,
+  });
+
+  @override
+  Future<void> queue(InputAction action, Vector3? delta) async {
+    if (delta == null) return;
+
+    switch (action) {
+      case InputAction.ROTATE:
+        _queuedRotationDelta += Vector2(delta.x, delta.y);
+        break;
+      case InputAction.TRANSLATE:
+        _queuedPanDelta += Vector2(delta.x, delta.y);
+        _queuedZoomDelta += delta.z;
+        break;
+      case InputAction.PICK:
+        // Assuming PICK is used for zoom in this context
+        _queuedZoomDelta += delta.z;
+        break;
+      case InputAction.NONE:
+        // Do nothing
+        break;
+    }
+  }
+
+  bool _executing = false;
+
+  @override
+  Future<void> execute() async {
+    if (_executing) {
+      return;
+    }
+
+    _executing = true;
+
+    if (_queuedRotationDelta.length2 == 0.0 &&
+        _queuedPanDelta.length2 == 0.0 &&
+        _queuedZoomDelta == 0.0 &&
+        _queuedMoveDelta.length2 == 0.0) {
+      _executing = false;
+      return;
+    }
+
+    Matrix4 currentModelMatrix = await viewer.getCameraModelMatrix();
+    Vector3 currentPosition = currentModelMatrix.getTranslation();
+    Quaternion currentRotation =
+        Quaternion.fromRotation(currentModelMatrix.getRotation());
+
+    // Apply rotation
+    if (_queuedRotationDelta.length2 > 0.0) {
+      double deltaX =
+          _queuedRotationDelta.x * rotationSensitivity * viewer.pixelRatio;
+      double deltaY =
+          _queuedRotationDelta.y * rotationSensitivity * viewer.pixelRatio;
+
+      Quaternion yawRotation = Quaternion.axisAngle(_up, -deltaX);
+      Quaternion pitchRotation = Quaternion.axisAngle(_right, -deltaY);
+
+      currentRotation = currentRotation * pitchRotation * yawRotation;
+      currentRotation.normalize();
+
+      _queuedRotationDelta = Vector2.zero();
+    }
+
+    // Apply pan
+    if (_queuedPanDelta.length2 > 0.0) {
+      Vector3 right = _right.clone()..applyQuaternion(currentRotation);
+      Vector3 up = _up.clone()..applyQuaternion(currentRotation);
+
+      double deltaX = _queuedPanDelta.x * panSensitivity * viewer.pixelRatio;
+      double deltaY = _queuedPanDelta.y * panSensitivity * viewer.pixelRatio;
+
+      Vector3 panOffset = right * deltaX + up * deltaY;
+      currentPosition += panOffset;
+
+      _queuedPanDelta = Vector2.zero();
+    }
+
+    // Apply zoom
+    if (_queuedZoomDelta != 0.0) {
+      Vector3 forward = _forward.clone()..applyQuaternion(currentRotation);
+      currentPosition += forward * -_queuedZoomDelta * zoomSensitivity;
+      _queuedZoomDelta = 0.0;
+    }
+
+    // Apply queued movement
+    if (_queuedMoveDelta.length2 > 0.0) {
+      Vector3 forward = _forward.clone()..applyQuaternion(currentRotation);
+      Vector3 right = _right.clone()..applyQuaternion(currentRotation);
+      Vector3 up = _up.clone()..applyQuaternion(currentRotation);
+
+      Vector3 moveOffset = right * _queuedMoveDelta.x +
+          up * _queuedMoveDelta.y +
+          forward * _queuedMoveDelta.z;
+      currentPosition += moveOffset;
+
+      _queuedMoveDelta = Vector3.zero();
+    }
+
+    // Constrain position
+    currentPosition = _constrainPosition(currentPosition);
+
+    // Update camera
+    Matrix4 newModelMatrix =
+        Matrix4.compose(currentPosition, currentRotation, Vector3(1, 1, 1));
+    await viewer.setCameraModelMatrix4(newModelMatrix);
+
+    _executing = false;
+  }
+
+  Vector3 _constrainPosition(Vector3 position) {
+    if (minBounds != null) {
+      position.x = position.x.clamp(minBounds!.x, double.infinity);
+      position.y = position.y.clamp(minBounds!.y, double.infinity);
+      position.z = position.z.clamp(minBounds!.z, double.infinity);
+    }
+    if (maxBounds != null) {
+      position.x = position.x.clamp(double.negativeInfinity, maxBounds!.x);
+      position.y = position.y.clamp(double.negativeInfinity, maxBounds!.y);
+      position.z = position.z.clamp(double.negativeInfinity, maxBounds!.z);
+    }
+    return position;
+  }
+}

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

@@ -0,0 +1,230 @@
+// import 'dart:async';
+
+// import 'package:flutter/gestures.dart';
+// import 'package:flutter/services.dart';
+// import 'package:logging/logging.dart';
+// import 'package:thermion_dart/thermion_dart/entities/abstract_gizmo.dart';
+// import 'package:thermion_dart/thermion_dart/thermion_viewer.dart';
+// import 'dart:ui';
+// import 'package:thermion_dart/thermion_dart/input/input_handler.dart';
+
+// // Renamed implementation
+// class PickingCameraGestureHandler implements InputHandler {
+//   final ThermionViewer viewer;
+//   final bool enableCamera;
+//   final bool enablePicking;
+//   final Logger _logger = Logger("PickingCameraGestureHandler");
+
+//   AbstractGizmo? _gizmo;
+//   Timer? _scrollTimer;
+//   ThermionEntity? _highlightedEntity;
+//   StreamSubscription<FilamentPickResult>? _pickResultSubscription;
+
+//   bool _gizmoAttached = false;
+
+//   PickingCameraGestureHandler({
+//     required this.viewer,
+//     this.enableCamera = true,
+//     this.enablePicking = true,
+//   }) {
+//     try {
+//       _gizmo = viewer.gizmo;
+//     } catch (err) {
+//       _logger.warning(
+//           "Failed to get gizmo. If you are running on WASM, this is expected");
+//     }
+
+//     _pickResultSubscription = viewer.pickResult.listen(_onPickResult);
+
+//     // Add keyboard listener
+//     RawKeyboard.instance.addListener(_handleKeyEvent);
+//   }
+
+//   @override
+//   ThermionGestureState get currentState => _currentState;
+
+//   void _handleKeyEvent(RawKeyEvent event) {
+//     if (event is RawKeyDownEvent &&
+//         event.logicalKey == LogicalKeyboardKey.escape) {
+//       _resetToNullState();
+//     }
+//   }
+
+//   void _resetToNullState() async {
+//     _currentState = ThermionGestureState.NULL;
+//     if (_highlightedEntity != null) {
+//       await viewer.removeStencilHighlight(_highlightedEntity!);
+//       _highlightedEntity = null;
+//     }
+//   }
+
+//   void _onPickResult(FilamentPickResult result) async {
+//     var targetEntity = await viewer.getAncestor(result.entity) ?? result.entity;
+
+//     if (_highlightedEntity != targetEntity) {
+//       if (_highlightedEntity != null) {
+//         await viewer.removeStencilHighlight(_highlightedEntity!);
+//       }
+
+//       _highlightedEntity = targetEntity;
+//       if (_highlightedEntity != null) {
+//         await viewer.setStencilHighlight(_highlightedEntity!);
+//         _gizmo?.attach(_highlightedEntity!);
+//       }
+//     }
+//   }
+
+//   @override
+//   Future<void> onPointerHover(Offset localPosition, Offset delta) async {
+//     if (_gizmoAttached) {
+//       _gizmo?.checkHover(localPosition.dx, localPosition.dy);
+//     }
+
+//     if (_highlightedEntity != null) {
+//       await viewer.queuePositionUpdateFromViewportCoords(
+//         _highlightedEntity!,
+//         localPosition.dx,
+//         localPosition.dy,
+//       );
+//     }
+//   }
+
+//   @override
+//   Future<void> onPointerScroll(Offset localPosition, double scrollDelta) async {
+//     if (!enableCamera) {
+//       return;
+//     }
+//     if (_currentState == ThermionGestureState.NULL ||
+//         _currentState == ThermionGestureState.ZOOMING) {
+//       await _zoom(localPosition, scrollDelta);
+//     }
+//   }
+
+//   @override
+//   Future<void> onPointerDown(Offset localPosition, int buttons) async {
+//     if (_highlightedEntity != null) {
+//       _resetToNullState();
+//       return;
+//     }
+
+//     if (enablePicking && buttons != kMiddleMouseButton) {
+//       viewer.pick(localPosition.dx.toInt(), localPosition.dy.toInt());
+//     }
+
+//     if (buttons == kMiddleMouseButton && enableCamera) {
+//       await viewer.rotateStart(localPosition.dx, localPosition.dy);
+//       _currentState = ThermionGestureState.ROTATING;
+//     } else if (buttons == kPrimaryMouseButton && enableCamera) {
+//       await viewer.panStart(localPosition.dx, localPosition.dy);
+//       _currentState = ThermionGestureState.PANNING;
+//     }
+//   }
+
+//   @override
+//   Future<void> onPointerMove(
+//       Offset localPosition, Offset delta, int buttons) async {
+//     if (_highlightedEntity != null) {
+//       await _handleEntityHighlightedMove(localPosition);
+//       return;
+//     }
+
+//     switch (_currentState) {
+//       case ThermionGestureState.NULL:
+//         break;
+
+//       case ThermionGestureState.ROTATING:
+//         if (enableCamera) {
+//           await viewer.rotateUpdate(localPosition.dx, localPosition.dy);
+//         }
+//         break;
+//       case ThermionGestureState.PANNING:
+//         if (enableCamera) {
+//           await viewer.panUpdate(localPosition.dx, localPosition.dy);
+//         }
+//         break;
+//       case ThermionGestureState.ZOOMING:
+//         // ignore
+//         break;
+//     }
+//   }
+
+//   @override
+//   Future<void> onPointerUp(int buttons) async {
+//     switch (_currentState) {
+//       case ThermionGestureState.ROTATING:
+//         await viewer.rotateEnd();
+//         _currentState = ThermionGestureState.NULL;
+//         break;
+//       case ThermionGestureState.PANNING:
+//         await viewer.panEnd();
+//         _currentState = ThermionGestureState.NULL;
+//         break;
+//       default:
+//         break;
+//     }
+//   }
+
+//   Future<void> _handleEntityHighlightedMove(Offset localPosition) async {
+//     if (_highlightedEntity != null) {
+//       await viewer.queuePositionUpdateFromViewportCoords(
+//         _highlightedEntity!,
+//         localPosition.dx,
+//         localPosition.dy,
+//       );
+//     }
+//   }
+
+//   Future<void> _zoom(Offset localPosition, double scrollDelta) async {
+//     _scrollTimer?.cancel();
+//     _currentState = ThermionGestureState.ZOOMING;
+//     await viewer.zoomBegin();
+//     await viewer.zoomUpdate(
+//         localPosition.dx, localPosition.dy, scrollDelta > 0 ? 1 : -1);
+
+//     _scrollTimer = Timer(const Duration(milliseconds: 100), () async {
+//       await viewer.zoomEnd();
+//       _currentState = ThermionGestureState.NULL;
+//     });
+//   }
+
+//   @override
+//   void dispose() {
+//     _pickResultSubscription?.cancel();
+//     if (_highlightedEntity != null) {
+//       viewer.removeStencilHighlight(_highlightedEntity!);
+//     }
+//     RawKeyboard.instance.removeListener(_handleKeyEvent);
+//   }
+
+//   @override
+//   Future<bool> get initialized => viewer.initialized;
+
+//   @override
+//   InputAction getActionForType(InputType type) {
+//     // TODO: implement getActionForType
+//     throw UnimplementedError();
+//   }
+
+//   @override
+//   Future<void> onScaleEnd() {
+//     // TODO: implement onScaleEnd
+//     throw UnimplementedError();
+//   }
+
+//   @override
+//   Future<void> onScaleStart() {
+//     // TODO: implement onScaleStart
+//     throw UnimplementedError();
+//   }
+
+//   @override
+//   Future<void> onScaleUpdate() {
+//     // TODO: implement onScaleUpdate
+//     throw UnimplementedError();
+//   }
+
+//   @override
+//   void setActionForType(InputType type, InputAction action) {
+//     // TODO: implement setActionForType
+//   }
+// }

thermion_dart/lib/thermion_dart/input/src/input_handler.dart

@@ -0,0 +1,47 @@
+import 'dart:async';
+
+import 'package:vector_math/vector_math_64.dart';
+
+enum InputType {
+  LMB_DOWN,
+  LMB_HOLD_AND_MOVE,
+  LMB_UP,
+  LMB_HOVER,
+  MMB_DOWN,
+  MMB_HOLD_AND_MOVE,
+
+  MMB_UP,
+  MMB_HOVER,
+  SCALE1,
+  SCALE2,
+  SCROLLWHEEL,
+  POINTER_MOVE,
+  KEYDOWN_W,
+  KEYDOWN_A,
+  KEYDOWN_S,
+  KEYDOWN_D,
+}
+
+enum PhysicalKey { W, A, S, D }
+
+enum InputAction { TRANSLATE, ROTATE, PICK, NONE }
+
+abstract class InputHandler {
+  
+  Future<void> onPointerHover(Vector2 localPosition, Vector2 delta);
+  Future<void> onPointerScroll(Vector2 localPosition, double scrollDelta);
+  Future<void> onPointerDown(Vector2 localPosition, bool isMiddle);
+  Future<void> onPointerMove(Vector2 localPosition, Vector2 delta, bool isMiddle);
+  Future<void> onPointerUp(bool isMiddle);
+  Future<void> onScaleStart();
+  Future<void> onScaleUpdate();
+  Future<void> onScaleEnd();
+  Future<bool> get initialized;
+  Future dispose();
+
+  void setActionForType(InputType gestureType, InputAction gestureAction);
+  InputAction? getActionForType(InputType gestureType);
+
+  void keyDown(PhysicalKey key);
+  void keyUp(PhysicalKey key);
+}

thermion_dart/lib/thermion_dart/viewer/ffi/src/camera_ffi.dart

@@ -29,9 +29,24 @@ class ThermionFFICamera extends Camera {
     var entity = Camera_getEntity(camera);
     Engine_setTransform(engine, entity, matrix4ToDouble4x4(transform));
   }
-  
+
   @override
-  Future setLensProjection({double near = kNear, double far = kFar, double aspect = 1.0, double focalLength = kFocalLength}) async {
+  Future setLensProjection(
+      {double near = kNear,
+      double far = kFar,
+      double aspect = 1.0,
+      double focalLength = kFocalLength}) async {
     Camera_setLensProjection(camera, near, far, aspect, focalLength);
   }
+
+  @override
+  ThermionEntity getEntity() {
+    // TODO: implement getEntity
+    throw UnimplementedError();
+  }
+
+  @override
+  Future setModelMatrix(Matrix4 matrix) async {
+    Camera_setModelMatrix(camera, matrix4ToDouble4x4(matrix));
+  }
 }

thermion_dart/lib/thermion_dart/viewer/ffi/src/thermion_dart.g.dart

@@ -915,6 +915,12 @@ external void Camera_setCustomProjectionWithCulling(
   double far,
 );
 
+@ffi.Native<ffi.Void Function(ffi.Pointer<TCamera>, double4x4)>(isLeaf: true)
+external void Camera_setModelMatrix(
+  ffi.Pointer<TCamera> camera,
+  double4x4 modelMatrix,
+);
+
 @ffi.Native<
     ffi.Void Function(ffi.Pointer<TCamera>, ffi.Double, ffi.Double, ffi.Double,
         ffi.Double)>(isLeaf: true)

thermion_dart/lib/thermion_dart/viewer/ffi/src/thermion_viewer_ffi.dart

@@ -119,8 +119,7 @@ class ThermionViewerFFI extends ThermionViewer {
     if (focalLength.abs() < 0.1) {
       focalLength = kFocalLength;
     }
-    Camera_setLensProjection(
-        mainCamera.camera, near, far, aspect, focalLength);
+    Camera_setLensProjection(mainCamera.camera, near, far, aspect, focalLength);
   }
 
   Future createSwapChain(double width, double height,
@@ -1333,8 +1332,7 @@ class ThermionViewerFFI extends ThermionViewer {
   Future setCameraExposure(
       double aperture, double shutterSpeed, double sensitivity) async {
     var mainCamera = await getMainCamera() as ThermionFFICamera;
-    set_camera_exposure(
-        mainCamera.camera, aperture, shutterSpeed, sensitivity);
+    set_camera_exposure(mainCamera.camera, aperture, shutterSpeed, sensitivity);
   }
 
   ///
@@ -2167,7 +2165,10 @@ class ThermionViewerFFI extends ThermionViewer {
   }
 
   @override
-  void requestFrame() {
+  Future requestFrame() async {
+    for (final hook in _hooks) {
+      await hook.call();
+    }
     request_frame_render_thread(_viewer!);
   }
 
@@ -2187,6 +2188,22 @@ class ThermionViewerFFI extends ThermionViewer {
   Future setActiveCamera(ThermionFFICamera camera) async {
     SceneManager_setCamera(_sceneManager!, camera.camera);
   }
+
+  final _hooks = <Future Function()>[];
+
+  @override
+  Future registerRequestFrameHook(Future Function() hook) async {
+    if (!_hooks.contains(hook)) {
+      _hooks.add(hook);
+    }
+  }
+
+  @override
+  Future unregisterRequestFrameHook(Future Function() hook) async {
+    if (_hooks.contains(hook)) {
+      _hooks.remove(hook);
+    }
+  }
 }
 
 class ThermionFFITexture extends ThermionTexture {

thermion_dart/lib/thermion_dart/viewer/shared_types/camera.dart

@@ -9,10 +9,13 @@ abstract class Camera {
   Future setLensProjection(
       {double near = kNear,
       double far = kFar,
-      double aspect=1.0,
+      double aspect = 1.0,
       double focalLength = kFocalLength});
 
   Future<Matrix4> getModelMatrix();
+  Future setModelMatrix(Matrix4 matrix);
+
+  ThermionEntity getEntity();
 
   Future setTransform(Matrix4 transform);
 }

thermion_dart/lib/thermion_dart/viewer/shared_types/manipulator.dart

@@ -1,4 +1,4 @@
 // see filament Manipulator.h for more details
 @Deprecated(
-    "This is used  the native pointer manipulator Prefer ThermionGestureHandler instead")
+    "This is used  the native pointer manipulator Prefer InputHandler instead")
 enum ManipulatorMode { ORBIT, MAP, FREE_FLIGHT }

thermion_dart/lib/thermion_dart/viewer/thermion_viewer_base.dart

@@ -66,7 +66,7 @@ abstract class ThermionViewer {
   ///
   /// Requests a single frame to be rendered. This is only intended to be used internally.
   ///
-  void requestFrame();
+  Future requestFrame();
 
   ///
   /// Render a single frame and copy the pixel buffer to [out].
@@ -748,7 +748,7 @@ abstract class ThermionViewer {
   /// Sets the options for manipulating the camera via the viewport.
   /// ManipulatorMode.FREE_FLIGHT and ManipulatorMode.MAP are currently unsupported and will throw an exception.
   ///
-  @Deprecated("Use ThermionGestureHandler instead")
+  @Deprecated("Use InputHandler instead")
   Future setCameraManipulatorOptions(
       {ManipulatorMode mode = ManipulatorMode.ORBIT,
       double orbitSpeedX = 0.01,
@@ -970,4 +970,14 @@ abstract class ThermionViewer {
   ///
   ///
   Future setActiveCamera(covariant Camera camera);
+
+  ///
+  ///
+  ///
+  Future registerRequestFrameHook(Future Function() hook);
+
+  ///
+  ///
+  ///
+  Future unregisterRequestFrameHook(Future Function() hook);
 }

thermion_dart/lib/thermion_dart/viewer/thermion_viewer_stub.dart

@@ -944,8 +944,8 @@ class ThermionViewerStub extends ThermionViewer {
   }
   
   @override
-  void requestFrame() {
-    // TODO: implement requestFrame
+  Future requestFrame() {
+    throw UnimplementedError();
   }
   
   @override
@@ -965,6 +965,36 @@ class ThermionViewerStub extends ThermionViewer {
     // TODO: implement getMainCamera
     throw UnimplementedError();
   }
+  
+  @override
+  Future<Camera> createCamera() {
+    // TODO: implement createCamera
+    throw UnimplementedError();
+  }
+  
+  @override
+  Future registerRenderHook(Future Function() hook) {
+    // TODO: implement registerRenderHook
+    throw UnimplementedError();
+  }
+  
+  @override
+  Future setActiveCamera(covariant Camera camera) {
+    // TODO: implement setActiveCamera
+    throw UnimplementedError();
+  }
+  
+  @override
+  Future registerRequestFrameHook(Future Function() hook) {
+    // TODO: implement registerRequestFrameHook
+    throw UnimplementedError();
+  }
+  
+  @override
+  Future unregisterRequestFrameHook(Future Function() hook) {
+    // TODO: implement unregisterRequestFrameHook
+    throw UnimplementedError();
+  }
 
   
 }

thermion_dart/lib/thermion_dart/viewer/web_js/src/thermion_viewer_js.dart

@@ -1048,10 +1048,6 @@ class ThermionViewerJS implements ThermionViewer {
     throw UnimplementedError();
   }
 
-  @override
-  void requestFrame() {
-    // TODO: implement requestFrame
-  }
 
   @override
   // TODO: implement sceneUpdated
@@ -1080,4 +1076,34 @@ class ThermionViewerJS implements ThermionViewer {
     // TODO: implement setCameraLensProjection
     throw UnimplementedError();
   }
+  
+  @override
+  Future<Camera> createCamera() {
+    // TODO: implement createCamera
+    throw UnimplementedError();
+  }
+  
+  @override
+  Future registerRequestFrameHook(Future Function() hook) {
+    // TODO: implement registerRequestFrameHook
+    throw UnimplementedError();
+  }
+  
+  @override
+  Future requestFrame() {
+    // TODO: implement requestFrame
+    throw UnimplementedError();
+  }
+  
+  @override
+  Future setActiveCamera(covariant Camera camera) {
+    // TODO: implement setActiveCamera
+    throw UnimplementedError();
+  }
+  
+  @override
+  Future unregisterRequestFrameHook(Future Function() hook) {
+    // TODO: implement unregisterRequestFrameHook
+    throw UnimplementedError();
+  }
 }

thermion_dart/lib/thermion_dart/viewer/web_wasm/src/camera.dart

@@ -1,6 +1,8 @@
 import 'package:thermion_dart/thermion_dart/viewer/shared_types/camera.dart';
 import 'package:vector_math/vector_math_64.dart';
 
+import '../../thermion_viewer_base.dart';
+
 class ThermionWasmCamera extends Camera {
   
   final int pointer;
@@ -13,4 +15,22 @@ class ThermionWasmCamera extends Camera {
     // TODO: implement setProjectionMatrixWithCulling
     throw UnimplementedError();
   }
+  
+  @override
+  Future<Matrix4> getModelMatrix() {
+    // TODO: implement getModelMatrix
+    throw UnimplementedError();
+  }
+  
+  @override
+  Future setLensProjection({double near = kNear, double far = kFar, double aspect = 1.0, double focalLength = kFocalLength}) {
+    // TODO: implement setLensProjection
+    throw UnimplementedError();
+  }
+  
+  @override
+  Future setTransform(Matrix4 transform) {
+    // TODO: implement setTransform
+    throw UnimplementedError();
+  }
 }

thermion_dart/lib/thermion_dart/viewer/web_wasm/src/thermion_viewer_wasm.dart

@@ -2446,7 +2446,7 @@ class ThermionViewerWasm implements ThermionViewer {
   }
 
   @override
-  void requestFrame() {
+  Future requestFrame() async {
     // TODO: implement requestFrame
   }
 
@@ -2478,4 +2478,32 @@ class ThermionViewerWasm implements ThermionViewer {
     // TODO: implement setCameraLensProjection
     throw UnimplementedError();
   }
+  
+  @override
+  Future<Camera> createCamera() {
+    // TODO: implement createCamera
+    throw UnimplementedError();
+  }
+    
+  @override
+  Future setActiveCamera(covariant Camera camera) {
+    // TODO: implement setActiveCamera
+    throw UnimplementedError();
+  }
+  
+  final _hooks = <Future Function()>[];
+
+  @override
+  Future registerRequestFrameHook(Future Function() hook) async {
+    if (!_hooks.contains(hook)) {
+      _hooks.add(hook);
+    }
+  }
+
+  @override
+  Future unregisterRequestFrameHook(Future Function() hook) async {
+    if (_hooks.contains(hook)) {
+      _hooks.remove(hook);
+    }
+  }
 }