@aura3d/input 1.0.6

package/src/WebXRSessionController.ts

@@ -0,0 +1,248 @@
+export type A3DXRSessionMode = "inline" | "immersive-vr" | "immersive-ar";
+export type A3DXRReferenceSpaceType = "viewer" | "local" | "local-floor" | "bounded-floor" | "unbounded";
+export type A3DXRHandedness = "none" | "left" | "right";
+
+export interface A3DXRSystemLike {
+  isSessionSupported?(mode: A3DXRSessionMode): Promise<boolean>;
+  requestSession(mode: A3DXRSessionMode, options?: A3DXRSessionInit): Promise<A3DXRSessionLike>;
+}
+
+export interface A3DXRSessionInit {
+  readonly requiredFeatures?: readonly string[];
+  readonly optionalFeatures?: readonly string[];
+}
+
+export interface A3DXRSessionLike {
+  readonly inputSources?: readonly A3DXRInputSourceLike[];
+  requestReferenceSpace?(type: A3DXRReferenceSpaceType): Promise<A3DXRReferenceSpaceLike>;
+  requestAnimationFrame?(callback: (time: number, frame: A3DXRFrameLike) => void): number;
+  end?(): Promise<void>;
+}
+
+export interface A3DXRInputSourceLike {
+  readonly handedness?: A3DXRHandedness;
+  readonly targetRayMode?: "gaze" | "tracked-pointer" | "screen";
+  readonly profiles?: readonly string[];
+  readonly targetRaySpace?: unknown;
+  readonly gripSpace?: unknown;
+  readonly gamepad?: {
+    readonly buttons?: readonly { readonly pressed?: boolean; readonly touched?: boolean; readonly value?: number }[];
+    readonly axes?: readonly number[];
+    readonly hapticActuators?: readonly { pulse?(intensity: number, duration: number): Promise<boolean> | boolean }[];
+  };
+}
+
+export interface A3DXRFrameLike {
+  getHitTestResults?(source: unknown): readonly A3DXRHitTestResultLike[];
+  getPose?(space: unknown, baseSpace: A3DXRReferenceSpaceLike): A3DXRPoseLike | undefined;
+}
+
+export interface A3DXRReferenceSpaceLike {
+  readonly type?: A3DXRReferenceSpaceType;
+}
+
+export interface A3DXRHitTestResultLike {
+  readonly position?: readonly [number, number, number];
+  readonly normal?: readonly [number, number, number];
+}
+
+export interface A3DXRPoseLike {
+  readonly transform?: {
+    readonly matrix?: readonly number[];
+    readonly position?: readonly [number, number, number];
+    readonly orientation?: readonly [number, number, number, number];
+  };
+}
+
+export interface WebXRSessionControllerOptions {
+  readonly xr?: A3DXRSystemLike;
+  readonly mode?: A3DXRSessionMode;
+  readonly requiredFeatures?: readonly string[];
+  readonly optionalFeatures?: readonly string[];
+  readonly referenceSpace?: A3DXRReferenceSpaceType;
+}
+
+export interface WebXRControllerSample {
+  readonly handedness: A3DXRHandedness;
+  readonly targetRayMode: "gaze" | "tracked-pointer" | "screen";
+  readonly profiles: readonly string[];
+  readonly triggerPressed: boolean;
+  readonly squeezePressed: boolean;
+  readonly primaryValue: number;
+  readonly axes: readonly number[];
+  readonly targetRayMatrix: readonly number[] | null;
+  readonly gripMatrix: readonly number[] | null;
+  readonly hapticActuatorCount: number;
+}
+
+export interface WebXRHitTestSample {
+  readonly position: readonly [number, number, number];
+  readonly normal: readonly [number, number, number];
+}
+
+export interface WebXRFrameSample {
+  readonly mode: A3DXRSessionMode;
+  readonly referenceSpace: A3DXRReferenceSpaceType;
+  readonly active: boolean;
+  readonly controllerCount: number;
+  readonly controllers: readonly WebXRControllerSample[];
+  readonly hitTestCount: number;
+  readonly hitTests: readonly WebXRHitTestSample[];
+}
+
+export interface WebXRSessionStartResult {
+  readonly mode: A3DXRSessionMode;
+  readonly referenceSpace: A3DXRReferenceSpaceType;
+  readonly supported: boolean;
+  readonly started: boolean;
+}
+
+export class WebXRSessionController {
+  readonly mode: A3DXRSessionMode;
+  readonly requiredFeatures: readonly string[];
+  readonly optionalFeatures: readonly string[];
+  readonly referenceSpaceType: A3DXRReferenceSpaceType;
+
+  private readonly xr?: A3DXRSystemLike;
+  private session: A3DXRSessionLike | null = null;
+  private referenceSpace: A3DXRReferenceSpaceLike | null = null;
+
+  constructor(options: WebXRSessionControllerOptions = {}) {
+    this.xr = options.xr ?? readNavigatorXR();
+    this.mode = options.mode ?? "immersive-vr";
+    this.requiredFeatures = options.requiredFeatures ?? [];
+    this.optionalFeatures = options.optionalFeatures ?? [];
+    this.referenceSpaceType = options.referenceSpace ?? (this.mode === "immersive-ar" ? "viewer" : "local-floor");
+  }
+
+  get active(): boolean {
+    return this.session !== null;
+  }
+
+  async isSupported(): Promise<boolean> {
+    if (!this.xr) return false;
+    if (!this.xr.isSessionSupported) return true;
+    return this.xr.isSessionSupported(this.mode);
+  }
+
+  async start(): Promise<WebXRSessionStartResult> {
+    if (!this.xr) {
+      return {
+        mode: this.mode,
+        referenceSpace: this.referenceSpaceType,
+        supported: false,
+        started: false
+      };
+    }
+    const supported = await this.isSupported();
+    if (!supported) {
+      return {
+        mode: this.mode,
+        referenceSpace: this.referenceSpaceType,
+        supported: false,
+        started: false
+      };
+    }
+    this.session = await this.xr.requestSession(this.mode, {
+      requiredFeatures: this.requiredFeatures,
+      optionalFeatures: this.optionalFeatures
+    });
+    this.referenceSpace = await this.session.requestReferenceSpace?.(this.referenceSpaceType) ?? { type: this.referenceSpaceType };
+    return {
+      mode: this.mode,
+      referenceSpace: this.referenceSpace?.type ?? this.referenceSpaceType,
+      supported: true,
+      started: true
+    };
+  }
+
+  sampleFrame(frame?: A3DXRFrameLike, hitTestSource?: unknown): WebXRFrameSample {
+    const referenceSpace = this.referenceSpace ?? { type: this.referenceSpaceType };
+    const controllers = Array.from(this.session?.inputSources ?? []).map((source) => sampleInputSource(source, frame, referenceSpace));
+    const hitTests = frame?.getHitTestResults && hitTestSource
+      ? frame.getHitTestResults(hitTestSource).map(sampleHitTest)
+      : [];
+    return {
+      mode: this.mode,
+      referenceSpace: this.referenceSpace?.type ?? this.referenceSpaceType,
+      active: this.active,
+      controllerCount: controllers.length,
+      controllers,
+      hitTestCount: hitTests.length,
+      hitTests
+    };
+  }
+
+  async end(): Promise<void> {
+    const session = this.session;
+    this.session = null;
+    this.referenceSpace = null;
+    await session?.end?.();
+  }
+
+  async pulseHaptics(intensity = 0.5, duration = 35): Promise<number> {
+    if (!Number.isFinite(intensity) || intensity < 0 || intensity > 1) throw new RangeError("WebXR haptic intensity must be in [0, 1].");
+    if (!Number.isFinite(duration) || duration < 0) throw new RangeError("WebXR haptic duration must be finite and non-negative.");
+    let pulses = 0;
+    for (const source of this.session?.inputSources ?? []) {
+      for (const actuator of source.gamepad?.hapticActuators ?? []) {
+        const accepted = await actuator.pulse?.(intensity, duration);
+        if (accepted !== false) pulses += 1;
+      }
+    }
+    return pulses;
+  }
+}
+
+function sampleInputSource(source: A3DXRInputSourceLike, frame: A3DXRFrameLike | undefined, referenceSpace: A3DXRReferenceSpaceLike): WebXRControllerSample {
+  const buttons = source.gamepad?.buttons ?? [];
+  const axes = source.gamepad?.axes ?? [];
+  const trigger = buttons[0];
+  const squeeze = buttons[1];
+  return {
+    handedness: source.handedness ?? "none",
+    targetRayMode: source.targetRayMode ?? "tracked-pointer",
+    profiles: source.profiles ?? [],
+    triggerPressed: Boolean(trigger?.pressed),
+    squeezePressed: Boolean(squeeze?.pressed),
+    primaryValue: finiteOrZero(trigger?.value),
+    axes: axes.map(finiteOrZero),
+    targetRayMatrix: samplePoseMatrix(frame, source.targetRaySpace, referenceSpace),
+    gripMatrix: samplePoseMatrix(frame, source.gripSpace, referenceSpace),
+    hapticActuatorCount: source.gamepad?.hapticActuators?.length ?? 0
+  };
+}
+
+function samplePoseMatrix(frame: A3DXRFrameLike | undefined, space: unknown, referenceSpace: A3DXRReferenceSpaceLike): readonly number[] | null {
+  if (!frame?.getPose || !space) return null;
+  return sanitizeMatrix4(frame.getPose(space, referenceSpace)?.transform?.matrix);
+}
+
+function sampleHitTest(result: A3DXRHitTestResultLike): WebXRHitTestSample {
+  return {
+    position: sanitizeVec3(result.position, [0, 0, 0]),
+    normal: sanitizeVec3(result.normal, [0, 1, 0])
+  };
+}
+
+function sanitizeVec3(value: readonly number[] | undefined, fallback: readonly [number, number, number]): readonly [number, number, number] {
+  if (!value || value.length < 3) return fallback;
+  const x = finiteOrZero(value[0]);
+  const y = finiteOrZero(value[1]);
+  const z = finiteOrZero(value[2]);
+  return [x, y, z];
+}
+
+function finiteOrZero(value: unknown): number {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+function sanitizeMatrix4(value: readonly number[] | undefined): readonly number[] | null {
+  if (!value || value.length < 16) return null;
+  const matrix = Array.from(value.slice(0, 16), finiteOrZero);
+  return matrix;
+}
+
+function readNavigatorXR(): A3DXRSystemLike | undefined {
+  return (globalThis.navigator as Navigator & { xr?: A3DXRSystemLike } | undefined)?.xr;
+}

package/src/XRFixtures.ts

@@ -0,0 +1,203 @@
+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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,60 @@
+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;
+  }
+}