@aura3d/input 1.4.0 → 1.4.2

package/src/XRFixtures.ts

@@ -1,203 +0,0 @@
-export type XRFixtureSessionMode = "inline" | "immersive-vr" | "immersive-ar";
-export type XRFixtureLodLevel = "high" | "medium" | "low" | "culled";
-
-export interface XRFixtureOptions {
-  readonly requestedMode?: XRFixtureSessionMode;
-  readonly gaze?: readonly [number, number];
-  readonly objectCount?: number;
-}
-
-export interface XRRuntimeFixture {
-  readonly source: "origin-master-xr-session-input-foveated-adapted";
-  readonly requestedMode: XRFixtureSessionMode;
-  readonly fallbackMode: "inline";
-  readonly sessionSupported: boolean;
-  readonly fallbackUsed: boolean;
-  readonly webXRSessionClaimed: false;
-  readonly deviceRuntimeClaimed: false;
-  readonly evidence: {
-    readonly oldCodebasePort: true;
-    readonly sessionCapabilityNegotiation: true;
-    readonly gracefulInlineFallback: true;
-    readonly controllerInputTelemetry: true;
-    readonly handGestureTelemetry: true;
-    readonly gazeBasedLodTelemetry: true;
-  };
-  readonly capabilities: {
-    readonly supportedModes: readonly XRFixtureSessionMode[];
-    readonly requestedFeatures: readonly string[];
-    readonly optionalFeatures: readonly string[];
-    readonly unsupportedFeatures: readonly string[];
-    readonly referenceSpaces: readonly string[];
-    readonly depthSensing: false;
-    readonly handTracking: false;
-    readonly eyeTracking: false;
-    readonly domOverlay: false;
-  };
-  readonly input: {
-    readonly controllerCount: number;
-    readonly handedness: readonly ["left", "right"];
-    readonly triggerPressed: boolean;
-    readonly squeezePressed: boolean;
-    readonly thumbstickMagnitude: number;
-    readonly hapticsClaimed: false;
-    readonly pinchDetected: boolean;
-    readonly pinchStrength: number;
-    readonly pinchDistanceMeters: number;
-    readonly pointDetected: boolean;
-    readonly pointConfidence: number;
-  };
-  readonly gazeLod: {
-    readonly gaze: readonly [number, number];
-    readonly objectCount: number;
-    readonly performanceBudget: number;
-    readonly updatedObjects: number;
-    readonly highDetailCount: number;
-    readonly mediumDetailCount: number;
-    readonly lowDetailCount: number;
-    readonly culledCount: number;
-    readonly transitionsPerFrame: number;
-    readonly selectedLevels: readonly XRFixtureLodLevel[];
-  };
-  readonly blockedClaims: readonly string[];
-  readonly hash: string;
-  readonly claimBoundary: string;
-}
-
-export function sampleXRRuntimeFixture(options: XRFixtureOptions = {}): XRRuntimeFixture {
-  const requestedMode = options.requestedMode ?? "immersive-vr";
-  const gaze = options.gaze ?? [0.48, 0.44] as const;
-  const objectCount = Math.max(6, Math.min(48, Math.trunc(options.objectCount ?? 14)));
-  const supportedModes = ["inline"] as const;
-  const sessionSupported = supportedModes.includes(requestedMode as "inline");
-  const objects = Array.from({ length: objectCount }, (_, index) => {
-    const column = index % 7;
-    const row = Math.floor(index / 7);
-    const x = 0.12 + column * 0.13;
-    const y = 0.18 + row * 0.21;
-    const distance = Math.hypot(x - gaze[0], y - gaze[1]);
-    return { index, distance, lod: lodForDistance(distance) };
-  });
-  const performanceBudget = Math.min(10, objectCount);
-  const updatedObjects = objects
-    .slice()
-    .sort((left, right) => left.distance - right.distance)
-    .slice(0, performanceBudget);
-  const selectedLevels = uniqueLevels(objects.map((object) => object.lod));
-  const pinchDistanceMeters = 0.024;
-  const pointConfidence = 0.82;
-  const unsupportedFeatures = [
-    "local-floor",
-    "bounded-floor",
-    "hand-tracking",
-    "eye-tracking",
-    "depth-sensing",
-    "dom-overlay",
-    "hit-test",
-    "anchors",
-    "plane-detection",
-    "mesh-detection",
-    "light-estimation"
-  ];
-  const blockedClaims = [
-    "real WebXR headset session evidence",
-    "AR hit-test anchor platform parity",
-    "device hand-tracking runtime parity",
-    "eye-tracked foveated rendering",
-    "Unity XR Interaction Toolkit parity",
-    "Unreal XR framework parity"
-  ];
-  const hash = hashStrings([
-    requestedMode,
-    String(sessionSupported),
-    ...selectedLevels,
-    String(updatedObjects.length),
-    String(pinchDistanceMeters),
-    String(pointConfidence),
-    ...blockedClaims
-  ]);
-
-  return {
-    source: "origin-master-xr-session-input-foveated-adapted",
-    requestedMode,
-    fallbackMode: "inline",
-    sessionSupported,
-    fallbackUsed: !sessionSupported,
-    webXRSessionClaimed: false,
-    deviceRuntimeClaimed: false,
-    evidence: {
-      oldCodebasePort: true,
-      sessionCapabilityNegotiation: true,
-      gracefulInlineFallback: true,
-      controllerInputTelemetry: true,
-      handGestureTelemetry: true,
-      gazeBasedLodTelemetry: true
-    },
-    capabilities: {
-      supportedModes,
-      requestedFeatures: ["local-floor"],
-      optionalFeatures: unsupportedFeatures.slice(2),
-      unsupportedFeatures,
-      referenceSpaces: ["viewer"],
-      depthSensing: false,
-      handTracking: false,
-      eyeTracking: false,
-      domOverlay: false
-    },
-    input: {
-      controllerCount: 2,
-      handedness: ["left", "right"],
-      triggerPressed: true,
-      squeezePressed: false,
-      thumbstickMagnitude: round(Math.hypot(0.42, -0.36)),
-      hapticsClaimed: false,
-      pinchDetected: pinchDistanceMeters <= 0.03,
-      pinchStrength: round((0.05 - pinchDistanceMeters) / 0.05),
-      pinchDistanceMeters,
-      pointDetected: true,
-      pointConfidence
-    },
-    gazeLod: {
-      gaze: [round(gaze[0]), round(gaze[1])],
-      objectCount,
-      performanceBudget,
-      updatedObjects: updatedObjects.length,
-      highDetailCount: objects.filter((object) => object.lod === "high").length,
-      mediumDetailCount: objects.filter((object) => object.lod === "medium").length,
-      lowDetailCount: objects.filter((object) => object.lod === "low").length,
-      culledCount: objects.filter((object) => object.lod === "culled").length,
-      transitionsPerFrame: updatedObjects.filter((object) => object.lod !== "medium").length,
-      selectedLevels
-    },
-    blockedClaims,
-    hash,
-    claimBoundary: "Bounded deterministic fixture adapted from old XR session/input/foveated concepts. It does not claim a real WebXR headset session, AR platform support, eye-tracked foveated rendering, Unity XR parity, or Unreal XR parity."
-  };
-}
-
-function lodForDistance(distance: number): XRFixtureLodLevel {
-  if (distance <= 0.18) return "high";
-  if (distance <= 0.36) return "medium";
-  if (distance <= 0.58) return "low";
-  return "culled";
-}
-
-function uniqueLevels(levels: readonly XRFixtureLodLevel[]): readonly XRFixtureLodLevel[] {
-  const order: readonly XRFixtureLodLevel[] = ["high", "medium", "low", "culled"];
-  return order.filter((level) => levels.includes(level));
-}
-
-function hashStrings(values: readonly string[]): string {
-  let hash = 0x811c9dc5;
-  for (const value of values) {
-    for (let index = 0; index < value.length; index += 1) {
-      hash ^= value.charCodeAt(index);
-      hash = Math.imul(hash, 0x01000193);
-    }
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}
-
-function round(value: number): number {
-  return Number(value.toFixed(4));
-}

package/src/controls/CameraRig.ts

@@ -1,38 +0,0 @@
-import type { CameraTransformLike, Vec3Like } from "./ControlTypes";
-
-export interface CameraRigState {
-  readonly position: Vec3Like;
-  readonly target?: Vec3Like;
-}
-
-export class CameraRig {
-  constructor(private readonly camera: CameraTransformLike) {}
-
-  apply(state: CameraRigState): void {
-    this.camera.position.x = state.position.x;
-    this.camera.position.y = state.position.y;
-    this.camera.position.z = state.position.z;
-    if (state.target) {
-      this.camera.lookAt?.(state.target);
-    }
-  }
-
-  blend(from: CameraRigState, to: CameraRigState, alpha: number): CameraRigState {
-    const t = Math.min(1, Math.max(0, alpha));
-    return {
-      position: {
-        x: from.position.x + (to.position.x - from.position.x) * t,
-        y: from.position.y + (to.position.y - from.position.y) * t,
-        z: from.position.z + (to.position.z - from.position.z) * t
-      },
-      target:
-        from.target && to.target
-          ? {
-              x: from.target.x + (to.target.x - from.target.x) * t,
-              y: from.target.y + (to.target.y - from.target.y) * t,
-              z: from.target.z + (to.target.z - from.target.z) * t
-            }
-          : (to.target ?? from.target)
-    };
-  }
-}

package/src/controls/ControlTypes.ts

@@ -1,21 +0,0 @@
-export interface Vec3Like {
-  x: number;
-  y: number;
-  z: number;
-}
-
-export interface EulerLike {
-  x: number;
-  y: number;
-  z: number;
-}
-
-export interface CameraTransformLike {
-  readonly position: Vec3Like;
-  readonly rotation?: EulerLike;
-  lookAt?(target: Vec3Like): void;
-}
-
-export function clamp(value: number, min: number, max: number): number {
-  return Math.min(max, Math.max(min, value));
-}

package/src/controls/EditorFlyControls.ts

@@ -1,55 +0,0 @@
-import type { InputSnapshot } from "../InputSnapshot";
-import { type CameraTransformLike, clamp } from "./ControlTypes";
-
-export interface EditorFlyControlsOptions {
-  readonly baseSpeed?: number;
-  readonly fastMultiplier?: number;
-  readonly lookSpeed?: number;
-}
-
-export class EditorFlyControls {
-  enabled = true;
-  private yaw = 0;
-  private pitch = 0;
-  private readonly baseSpeed: number;
-  private readonly fastMultiplier: number;
-  private readonly lookSpeed: number;
-
-  constructor(
-    private readonly camera: CameraTransformLike,
-    options: EditorFlyControlsOptions = {}
-  ) {
-    this.baseSpeed = options.baseSpeed ?? 3;
-    this.fastMultiplier = options.fastMultiplier ?? 4;
-    this.lookSpeed = options.lookSpeed ?? 0.0025;
-    this.pitch = clamp(camera.rotation?.x ?? 0, -Math.PI / 2 + 0.001, Math.PI / 2 - 0.001);
-    this.yaw = camera.rotation?.y ?? 0;
-  }
-
-  update(snapshot: InputSnapshot, deltaSeconds: number): void {
-    if (!this.enabled) return;
-    if (snapshot.button(1).down || snapshot.button(2).down) {
-      this.yaw -= snapshot.pointer.deltaX * this.lookSpeed;
-      this.pitch = clamp(this.pitch - snapshot.pointer.deltaY * this.lookSpeed, -Math.PI / 2 + 0.001, Math.PI / 2 - 0.001);
-      if (this.camera.rotation) {
-        this.camera.rotation.x = this.pitch;
-        this.camera.rotation.y = this.yaw;
-      }
-    }
-
-    const speed = this.baseSpeed * (snapshot.key("ShiftLeft").down || snapshot.key("ShiftRight").down ? this.fastMultiplier : 1);
-    const forward = (snapshot.key("KeyW").down ? 1 : 0) - (snapshot.key("KeyS").down ? 1 : 0);
-    const strafe = (snapshot.key("KeyD").down ? 1 : 0) - (snapshot.key("KeyA").down ? 1 : 0);
-    const lift = (snapshot.key("KeyE").down ? 1 : 0) - (snapshot.key("KeyQ").down ? 1 : 0);
-    const step = speed * deltaSeconds;
-    const sin = Math.sin(this.yaw);
-    const cos = Math.cos(this.yaw);
-    this.camera.position.x += (strafe * cos + forward * sin) * step;
-    this.camera.position.z += (forward * cos - strafe * sin) * step;
-    this.camera.position.y += lift * step;
-  }
-
-  dispose(): void {
-    this.enabled = false;
-  }
-}

package/src/controls/FirstPersonControls.ts

@@ -1,60 +0,0 @@
-import type { InputSnapshot } from "../InputSnapshot";
-import { clamp, type CameraTransformLike } from "./ControlTypes";
-
-export interface FirstPersonControlsOptions {
-  readonly moveSpeed?: number;
-  readonly lookSpeed?: number;
-  readonly minPitch?: number;
-  readonly maxPitch?: number;
-}
-
-export class FirstPersonControls {
-  enabled = true;
-
-  private yaw = 0;
-  private pitch = 0;
-  private readonly moveSpeed: number;
-  private readonly lookSpeed: number;
-  private readonly minPitch: number;
-  private readonly maxPitch: number;
-
-  constructor(
-    private readonly camera: CameraTransformLike,
-    options: FirstPersonControlsOptions = {}
-  ) {
-    this.moveSpeed = options.moveSpeed ?? 1;
-    this.lookSpeed = options.lookSpeed ?? 0.002;
-    this.minPitch = options.minPitch ?? -Math.PI / 2 + 0.001;
-    this.maxPitch = options.maxPitch ?? Math.PI / 2 - 0.001;
-    this.pitch = clamp(camera.rotation?.x ?? 0, this.minPitch, this.maxPitch);
-    this.yaw = camera.rotation?.y ?? 0;
-  }
-
-  update(snapshot: InputSnapshot, deltaSeconds: number): void {
-    if (!this.enabled) {
-      return;
-    }
-
-    if (snapshot.button(0).down) {
-      this.yaw -= snapshot.pointer.deltaX * this.lookSpeed;
-      this.pitch = clamp(this.pitch - snapshot.pointer.deltaY * this.lookSpeed, this.minPitch, this.maxPitch);
-      if (this.camera.rotation) {
-        this.camera.rotation.x = this.pitch;
-        this.camera.rotation.y = this.yaw;
-      }
-    }
-
-    const forward = (snapshot.key("KeyW").down ? 1 : 0) - (snapshot.key("KeyS").down ? 1 : 0);
-    const strafe = (snapshot.key("KeyD").down ? 1 : 0) - (snapshot.key("KeyA").down ? 1 : 0);
-    const step = this.moveSpeed * deltaSeconds;
-    const sin = Math.sin(this.yaw);
-    const cos = Math.cos(this.yaw);
-
-    this.camera.position.x += (strafe * cos + forward * sin) * step;
-    this.camera.position.z += (forward * cos - strafe * sin) * step;
-  }
-
-  dispose(): void {
-    this.enabled = false;
-  }
-}

package/src/controls/OrbitControls.ts

@@ -1,168 +0,0 @@
-import type { InputSnapshot } from "../InputSnapshot";
-import { clamp, type CameraTransformLike, type Vec3Like } from "./ControlTypes";
-
-export const DEFAULT_ORBIT_MAX_POLAR = Math.PI * 0.37;
-
-export interface OrbitControlsOptions {
-  readonly enabled?: boolean;
-  readonly enablePan?: boolean;
-  readonly enableZoom?: boolean;
-  readonly enableRotate?: boolean;
-  readonly target?: Vec3Like;
-  readonly distance?: number;
-  readonly minDistance?: number;
-  readonly maxDistance?: number;
-  readonly minPolar?: number;
-  readonly maxPolar?: number;
-  readonly rotateSpeed?: number;
-  readonly zoomSpeed?: number;
-  readonly panSpeed?: number;
-}
-
-export class OrbitControls {
-  enabled: boolean;
-  enablePan: boolean;
-  enableZoom: boolean;
-  enableRotate: boolean;
-  readonly target: Vec3Like;
-
-  private azimuth = 0;
-  private polar = Math.PI / 2;
-  private distance: number;
-  private readonly initial: { target: Vec3Like; azimuth: number; polar: number; distance: number };
-  private readonly minDistance: number;
-  private readonly maxDistance: number;
-  private readonly minPolar: number;
-  private readonly maxPolar: number;
-  private readonly rotateSpeed: number;
-  private readonly zoomSpeed: number;
-  private readonly panSpeed: number;
-
-  constructor(
-    private readonly camera: CameraTransformLike,
-    options: OrbitControlsOptions = {}
-  ) {
-    this.enabled = options.enabled ?? true;
-    this.enablePan = options.enablePan ?? true;
-    this.enableZoom = options.enableZoom ?? true;
-    this.enableRotate = options.enableRotate ?? true;
-    this.target = { ...(options.target ?? { x: 0, y: 0, z: 0 }) };
-    this.minDistance = options.minDistance ?? 0.1;
-    this.maxDistance = options.maxDistance ?? 1_000;
-    this.minPolar = options.minPolar ?? 0.001;
-    this.maxPolar = options.maxPolar ?? DEFAULT_ORBIT_MAX_POLAR;
-    this.rotateSpeed = options.rotateSpeed ?? 0.005;
-    this.zoomSpeed = options.zoomSpeed ?? 1;
-    this.panSpeed = options.panSpeed ?? 0.002;
-    const current = orbitStateFromCamera(camera, this.target);
-    this.distance = clamp(options.distance ?? current.distance, this.minDistance, this.maxDistance);
-    this.azimuth = current.azimuth;
-    this.polar = clamp(current.polar, this.minPolar, this.maxPolar);
-    this.initial = {
-      target: { ...this.target },
-      azimuth: this.azimuth,
-      polar: this.polar,
-      distance: this.distance
-    };
-    this.apply();
-  }
-
-  update(snapshot: InputSnapshot): void {
-    if (!this.enabled) {
-      return;
-    }
-
-    const leftButton = snapshot.button(0);
-    const middleButton = snapshot.button(1);
-    const rightButton = snapshot.button(2);
-    const panModifier = snapshot.keys.has("ShiftLeft") || snapshot.keys.has("ShiftRight") || snapshot.keys.has("ControlLeft") || snapshot.keys.has("ControlRight") || snapshot.keys.has("MetaLeft") || snapshot.keys.has("MetaRight");
-
-    if (this.enableRotate && leftButton.down && !panModifier) {
-      this.azimuth -= snapshot.pointer.deltaX * this.rotateSpeed;
-      this.polar = clamp(this.polar - snapshot.pointer.deltaY * this.rotateSpeed, this.minPolar, this.maxPolar);
-    }
-
-    if (this.enablePan && (rightButton.down || middleButton.down || (leftButton.down && panModifier))) {
-      this.pan(snapshot.pointer.deltaX, snapshot.pointer.deltaY);
-    }
-
-    if (this.enableZoom && snapshot.pointer.wheelY !== 0) {
-      this.dollyFromWheel(snapshot.pointer.wheelY);
-    }
-
-    this.apply();
-  }
-
-  getPolarAngle(): number {
-    return this.polar;
-  }
-
-  getAzimuthalAngle(): number {
-    return this.azimuth;
-  }
-
-  getDistance(): number {
-    return this.distance;
-  }
-
-  saveState(): void {
-    this.initial.target.x = this.target.x;
-    this.initial.target.y = this.target.y;
-    this.initial.target.z = this.target.z;
-    this.initial.azimuth = this.azimuth;
-    this.initial.polar = this.polar;
-    this.initial.distance = this.distance;
-  }
-
-  reset(): void {
-    this.target.x = this.initial.target.x;
-    this.target.y = this.initial.target.y;
-    this.target.z = this.initial.target.z;
-    this.azimuth = this.initial.azimuth;
-    this.polar = this.initial.polar;
-    this.distance = this.initial.distance;
-    this.apply();
-  }
-
-  dispose(): void {
-    this.enabled = false;
-  }
-
-  private pan(deltaX: number, deltaY: number): void {
-    const scale = this.distance * this.panSpeed;
-    this.target.x -= deltaX * scale;
-    this.target.y += deltaY * scale;
-  }
-
-  private dollyFromWheel(deltaY: number): void {
-    const normalizedDelta = Math.abs(deltaY * 0.01);
-    const zoomScale = Math.pow(0.95, this.zoomSpeed * normalizedDelta);
-    const nextDistance = deltaY < 0
-      ? this.distance * zoomScale
-      : this.distance / zoomScale;
-    this.distance = clamp(nextDistance, this.minDistance, this.maxDistance);
-  }
-
-  private apply(): void {
-    const sinPolar = Math.sin(this.polar);
-    this.camera.position.x = this.target.x + this.distance * sinPolar * Math.sin(this.azimuth);
-    this.camera.position.y = this.target.y + this.distance * Math.cos(this.polar);
-    this.camera.position.z = this.target.z + this.distance * sinPolar * Math.cos(this.azimuth);
-    this.camera.lookAt?.(this.target);
-  }
-}
-
-function orbitStateFromCamera(camera: CameraTransformLike, target: Vec3Like): { readonly azimuth: number; readonly polar: number; readonly distance: number } {
-  const dx = camera.position.x - target.x;
-  const dy = camera.position.y - target.y;
-  const dz = camera.position.z - target.z;
-  const distance = Math.hypot(dx, dy, dz);
-  if (!Number.isFinite(distance) || distance <= 1e-6) {
-    return { azimuth: 0, polar: Math.PI / 2, distance: 5 };
-  }
-  return {
-    azimuth: Math.atan2(dx, dz),
-    polar: Math.acos(clamp(dy / distance, -1, 1)),
-    distance
-  };
-}

package/src/controls/PointerLockControls.ts

@@ -1,24 +0,0 @@
-import type { InputSnapshot } from "../InputSnapshot";
-import { FirstPersonControls, type FirstPersonControlsOptions } from "./FirstPersonControls";
-import type { CameraTransformLike } from "./ControlTypes";
-
-export class PointerLockControls extends FirstPersonControls {
-  locked = false;
-
-  constructor(camera: CameraTransformLike, options: FirstPersonControlsOptions = {}) {
-    super(camera, options);
-  }
-
-  lock(): void {
-    this.locked = true;
-  }
-
-  unlock(): void {
-    this.locked = false;
-  }
-
-  override update(snapshot: InputSnapshot, deltaSeconds: number): void {
-    if (!this.locked) return;
-    super.update(snapshot, deltaSeconds);
-  }
-}

package/src/controls/SceneCameraAdapter.ts

@@ -1,100 +0,0 @@
-import { Quaternion, Vector3 } from "@aura3d/math";
-import { type Camera } from "@aura3d/scene";
-import { type CameraTransformLike, type EulerLike, type Vec3Like } from "./ControlTypes";
-
-export interface SceneCameraControlAdapter extends CameraTransformLike {
-  readonly camera: Camera;
-  readonly position: Vec3Like;
-  readonly rotation: EulerLike;
-  lookAt(target: Vec3Like): void;
-}
-
-export function createSceneCameraControlAdapter(camera: Camera): SceneCameraControlAdapter {
-  const euler = quaternionToEuler(camera.transform.rotation);
-  const position = {
-    get x(): number {
-      return camera.transform.position[0];
-    },
-    set x(value: number) {
-      camera.transform.setPosition(value, camera.transform.position[1], camera.transform.position[2]);
-      syncCamera(camera);
-    },
-    get y(): number {
-      return camera.transform.position[1];
-    },
-    set y(value: number) {
-      camera.transform.setPosition(camera.transform.position[0], value, camera.transform.position[2]);
-      syncCamera(camera);
-    },
-    get z(): number {
-      return camera.transform.position[2];
-    },
-    set z(value: number) {
-      camera.transform.setPosition(camera.transform.position[0], camera.transform.position[1], value);
-      syncCamera(camera);
-    }
-  };
-  const rotation = {
-    get x(): number {
-      return euler.x;
-    },
-    set x(value: number) {
-      euler.x = value;
-      applyEuler(camera, euler);
-    },
-    get y(): number {
-      return euler.y;
-    },
-    set y(value: number) {
-      euler.y = value;
-      applyEuler(camera, euler);
-    },
-    get z(): number {
-      return euler.z;
-    },
-    set z(value: number) {
-      euler.z = value;
-      applyEuler(camera, euler);
-    }
-  };
-
-  return {
-    camera,
-    position,
-    rotation,
-    lookAt(target: Vec3Like): void {
-      const origin = new Vector3(camera.transform.position[0], camera.transform.position[1], camera.transform.position[2]);
-      const direction = new Vector3(target.x, target.y, target.z).subtract(origin).normalize();
-      if (direction.lengthSquared() === 0) return;
-      const q = Quaternion.fromUnitVectors(Vector3.forward, direction);
-      camera.transform.setRotation(q.x, q.y, q.z, q.w);
-      const nextEuler = quaternionToEuler([q.x, q.y, q.z, q.w]);
-      euler.x = nextEuler.x;
-      euler.y = nextEuler.y;
-      euler.z = nextEuler.z;
-      syncCamera(camera);
-    }
-  };
-}
-
-function applyEuler(camera: Camera, euler: EulerLike): void {
-  const yaw = Quaternion.fromAxisAngle(Vector3.up, euler.y);
-  const pitch = Quaternion.fromAxisAngle(Vector3.right, euler.x);
-  const roll = Quaternion.fromAxisAngle(new Vector3(0, 0, 1), euler.z);
-  const q = yaw.multiply(pitch).multiply(roll).normalize();
-  camera.transform.setRotation(q.x, q.y, q.z, q.w);
-  syncCamera(camera);
-}
-
-function syncCamera(camera: Camera): void {
-  camera.updateCameraMatrices();
-}
-
-function quaternionToEuler(rotation: readonly [number, number, number, number]): EulerLike {
-  const [x, y, z, w] = rotation;
-  const sinPitch = 2 * (w * x - z * y);
-  const pitch = Math.abs(sinPitch) >= 1 ? Math.sign(sinPitch) * Math.PI / 2 : Math.asin(sinPitch);
-  const yaw = Math.atan2(2 * (w * y + x * z), 1 - 2 * (x * x + y * y));
-  const roll = Math.atan2(2 * (w * z + x * y), 1 - 2 * (x * x + z * z));
-  return { x: pitch, y: yaw, z: roll };
-}