add (very rough) gizmo, restructure Dart package into library, add EntityListWidget

lib/filament/utils/camera_orientation.dart

@@ -0,0 +1,15 @@
+import 'package:vector_math/vector_math_64.dart' as v;
+
+class CameraOrientation {
+  v.Vector3 position = v.Vector3(0, 0, 0);
+
+  var rotationX = 0.0;
+  var rotationY = 0.0;
+  var rotationZ = 0.0;
+
+  v.Quaternion compose() {
+    return v.Quaternion.axisAngle(v.Vector3(0, 0, 1), rotationZ) *
+        v.Quaternion.axisAngle(v.Vector3(0, 1, 0), rotationY) *
+        v.Quaternion.axisAngle(v.Vector3(1, 0, 0), rotationX);
+  }
+}

lib/filament/utils/hardware_keyboard_listener.dart

@@ -0,0 +1,60 @@
+import 'package:flutter/services.dart';
+import 'package:flutter_filament/filament/entities/entity_transform_controller.dart';
+
+class HardwareKeyboardListener {
+  final EntityTransformController _controller;
+  var _listening = true;
+  HardwareKeyboardListener(this._controller) {
+    // Get the global handler.
+    final KeyMessageHandler? existing =
+        ServicesBinding.instance.keyEventManager.keyMessageHandler;
+    // The handler is guaranteed non-null since
+    // `FallbackKeyEventRegistrar.instance` is only called during
+    // `Focus.onFocusChange`, at which time `ServicesBinding.instance` must
+    // have been called somewhere.
+    assert(existing != null);
+    // Assign the global handler with a patched handler.
+    ServicesBinding.instance.keyEventManager.keyMessageHandler = (keyMessage) {
+      if (keyMessage.rawEvent == null) {
+        return false;
+      }
+      if (!_listening) {
+        return false;
+      }
+      var event = keyMessage.rawEvent!;
+      switch (event.logicalKey) {
+        case LogicalKeyboardKey.escape:
+          _listening = false;
+          break;
+        case LogicalKeyboardKey.keyW:
+          (event is RawKeyDownEvent)
+              ? _controller.forwardPressed()
+              : _controller.forwardReleased();
+          break;
+        case LogicalKeyboardKey.keyA:
+          event is RawKeyDownEvent
+              ? _controller.strafeLeftPressed()
+              : _controller.strafeLeftReleased();
+          break;
+        case LogicalKeyboardKey.keyS:
+          event is RawKeyDownEvent
+              ? _controller.backPressed()
+              : _controller.backReleased();
+          break;
+        case LogicalKeyboardKey.keyD:
+          event is RawKeyDownEvent
+              ? _controller.strafeRightPressed()
+              : _controller.strafeRightReleased();
+          break;
+        default:
+          break;
+      }
+      return true;
+    };
+  }
+
+  void dispose() {
+    ServicesBinding.instance.keyEventManager.keyMessageHandler = null;
+    _controller.dispose();
+  }
+}

lib/filament/utils/hardware_keyboard_poll.dart

@@ -0,0 +1,40 @@
+import 'dart:async';
+
+import 'package:flutter/services.dart';
+import 'package:flutter_filament/filament/entities/entity_transform_controller.dart';
+
+class HardwareKeyboardPoll {
+  final EntityTransformController _controller;
+  late Timer _timer;
+  HardwareKeyboardPoll(this._controller) {
+    _timer = Timer.periodic(const Duration(milliseconds: 16), (_) {
+      if (RawKeyboard.instance.keysPressed.contains(LogicalKeyboardKey.keyW)) {
+        _controller.forwardPressed();
+      } else {
+        _controller.forwardReleased();
+      }
+
+      if (RawKeyboard.instance.keysPressed.contains(LogicalKeyboardKey.keyS)) {
+        _controller.backPressed();
+      } else {
+        _controller.backReleased();
+      }
+
+      if (RawKeyboard.instance.keysPressed.contains(LogicalKeyboardKey.keyA)) {
+        _controller.strafeLeftPressed();
+      } else {
+        _controller.strafeLeftReleased();
+      }
+
+      if (RawKeyboard.instance.keysPressed.contains(LogicalKeyboardKey.keyD)) {
+        _controller.strafeRightPressed();
+      } else {
+        _controller.strafeRightReleased();
+      }
+    });
+  }
+
+  void dispose() {
+    _timer.cancel();
+  }
+}

lib/filament/utils/light_options.dart

@@ -0,0 +1,29 @@
+import 'package:vector_math/vector_math_64.dart' as v;
+
+class LightOptions {
+  String? iblPath;
+  double iblIntensity;
+  int directionalType;
+  double directionalColor;
+  double directionalIntensity;
+  bool directionalCastShadows;
+  late v.Vector3 directionalPosition;
+  late v.Vector3 directionalDirection;
+
+  LightOptions(
+      {required this.iblPath,
+      required this.iblIntensity,
+      required this.directionalType,
+      required this.directionalColor,
+      required this.directionalIntensity,
+      required this.directionalCastShadows,
+      v.Vector3? directionalDirection,
+      v.Vector3? directionalPosition}) {
+    this.directionalDirection = directionalDirection == null
+        ? v.Vector3(0, -1, 0)
+        : directionalDirection;
+    this.directionalPosition = directionalPosition == null
+        ? v.Vector3(0, 100, 0)
+        : directionalPosition;
+  }
+}

lib/filament/utils/using_pointer.dart

@@ -0,0 +1,10 @@
+import 'dart:ffi';
+
+import 'package:ffi/ffi.dart';
+
+final allocator = calloc;
+
+void using(Pointer ptr, Future Function(Pointer ptr) function) async {
+  await function.call(ptr);
+  allocator.free(ptr);
+}