@aura3d/input 1.3.3 → 1.4.1

package/src/InputReplay.ts

@@ -1,275 +0,0 @@
-export type InputReplayEventType =
-  | "key"
-  | "pointer-button"
-  | "pointer-move"
-  | "pointer-wheel"
-  | "gamepad-axis"
-  | "gamepad-button"
-  | "action"
-  | "frame";
-
-export interface InputReplayEvent {
-  readonly type: InputReplayEventType;
-  readonly timestampMs: number;
-  readonly frame: number;
-  readonly code?: string;
-  readonly down?: boolean;
-  readonly button?: number;
-  readonly x?: number;
-  readonly y?: number;
-  readonly deltaX?: number;
-  readonly deltaY?: number;
-  readonly gamepadIndex?: number;
-  readonly controlIndex?: number;
-  readonly action?: string;
-  readonly context?: string;
-  readonly value?: number;
-  readonly vector?: readonly [number, number];
-  readonly deltaTimeMs?: number;
-}
-
-export interface InputRecordingMetadata {
-  readonly version: "1.0.0";
-  readonly source: "origin-master-input-recorder-playback-adapted";
-  readonly startTimeMs: number;
-  readonly endTimeMs: number;
-  readonly durationMs: number;
-  readonly frameCount: number;
-  readonly eventCount: number;
-  readonly evidence: {
-    readonly oldCodebasePort: true;
-    readonly recording: boolean;
-    readonly playback: boolean;
-    readonly seek: boolean;
-    readonly looping: boolean;
-  };
-}
-
-export interface InputRecording {
-  readonly metadata: InputRecordingMetadata;
-  readonly events: readonly InputReplayEvent[];
-}
-
-export interface InputPlaybackOptions {
-  readonly speed?: number;
-  readonly loop?: boolean;
-}
-
-export interface InputPlaybackSnapshot {
-  readonly state: "stopped" | "playing" | "paused";
-  readonly currentTimeMs: number;
-  readonly emittedEvents: number;
-  readonly loopCount: number;
-  readonly recordingEventCount: number;
-  readonly evidence: InputRecordingMetadata["evidence"];
-}
-
-export class InputRecorder {
-  private readonly events: InputReplayEvent[] = [];
-  private readonly maxEvents: number;
-  private recording = false;
-  private startTimeMs = 0;
-  private lastTimestampMs = 0;
-  private frame = 0;
-
-  constructor(options: { readonly maxEvents?: number } = {}) {
-    this.maxEvents = options.maxEvents ?? 4096;
-  }
-
-  start(startTimeMs = 0): void {
-    this.events.length = 0;
-    this.recording = true;
-    this.startTimeMs = finite(startTimeMs, 0);
-    this.lastTimestampMs = this.startTimeMs;
-    this.frame = 0;
-  }
-
-  stop(endTimeMs = this.lastTimestampMs): InputRecording {
-    this.recording = false;
-    this.lastTimestampMs = Math.max(this.startTimeMs, finite(endTimeMs, this.lastTimestampMs));
-    return this.recordingSnapshot();
-  }
-
-  recordFrame(deltaTimeMs: number, timestampMs = this.lastTimestampMs + deltaTimeMs): void {
-    this.push({
-      type: "frame",
-      timestampMs: finite(timestampMs, this.lastTimestampMs),
-      frame: this.frame,
-      deltaTimeMs: Math.max(0, finite(deltaTimeMs, 0))
-    });
-    this.frame += 1;
-  }
-
-  recordKey(code: string, down: boolean, timestampMs = this.lastTimestampMs): void {
-    this.push({ type: "key", timestampMs: finite(timestampMs, this.lastTimestampMs), frame: this.frame, code, down });
-  }
-
-  recordPointerButton(button: number, down: boolean, x: number, y: number, timestampMs = this.lastTimestampMs): void {
-    this.push({ type: "pointer-button", timestampMs: finite(timestampMs, this.lastTimestampMs), frame: this.frame, button, down, x, y });
-  }
-
-  recordPointerMove(x: number, y: number, deltaX: number, deltaY: number, timestampMs = this.lastTimestampMs): void {
-    this.push({ type: "pointer-move", timestampMs: finite(timestampMs, this.lastTimestampMs), frame: this.frame, x, y, deltaX, deltaY });
-  }
-
-  recordPointerWheel(deltaX: number, deltaY: number, timestampMs = this.lastTimestampMs): void {
-    this.push({ type: "pointer-wheel", timestampMs: finite(timestampMs, this.lastTimestampMs), frame: this.frame, deltaX, deltaY });
-  }
-
-  recordGamepadAxis(gamepadIndex: number, controlIndex: number, value: number, timestampMs = this.lastTimestampMs): void {
-    this.push({ type: "gamepad-axis", timestampMs: finite(timestampMs, this.lastTimestampMs), frame: this.frame, gamepadIndex, controlIndex, value });
-  }
-
-  recordGamepadButton(gamepadIndex: number, controlIndex: number, down: boolean, value: number, timestampMs = this.lastTimestampMs): void {
-    this.push({ type: "gamepad-button", timestampMs: finite(timestampMs, this.lastTimestampMs), frame: this.frame, gamepadIndex, controlIndex, down, value });
-  }
-
-  recordAction(context: string, action: string, value: number, vector?: readonly [number, number], timestampMs = this.lastTimestampMs): void {
-    this.push({ type: "action", timestampMs: finite(timestampMs, this.lastTimestampMs), frame: this.frame, context, action, value, vector });
-  }
-
-  recordingSnapshot(): InputRecording {
-    const endTimeMs = Math.max(this.lastTimestampMs, this.events.at(-1)?.timestampMs ?? this.startTimeMs);
-    return Object.freeze({
-      metadata: Object.freeze({
-        version: "1.0.0" as const,
-        source: "origin-master-input-recorder-playback-adapted" as const,
-        startTimeMs: this.startTimeMs,
-        endTimeMs,
-        durationMs: Math.max(0, endTimeMs - this.startTimeMs),
-        frameCount: this.frame,
-        eventCount: this.events.length,
-        evidence: replayEvidence()
-      }),
-      events: Object.freeze([...this.events])
-    });
-  }
-
-  toJSON(): string {
-    return JSON.stringify(this.recordingSnapshot());
-  }
-
-  private push(event: InputReplayEvent): void {
-    if (!this.recording) throw new Error("InputRecorder must be started before recording events.");
-    if (this.events.length >= this.maxEvents) throw new Error(`InputRecorder exceeded maxEvents=${this.maxEvents}.`);
-    this.lastTimestampMs = Math.max(this.lastTimestampMs, event.timestampMs);
-    this.events.push(Object.freeze({ ...event, timestampMs: this.lastTimestampMs }));
-  }
-}
-
-export class InputPlayback {
-  private recording: InputRecording | undefined;
-  private state: InputPlaybackSnapshot["state"] = "stopped";
-  private currentTimeMs = 0;
-  private eventIndex = 0;
-  private emittedEvents = 0;
-  private loopCount = 0;
-  private speed: number;
-  private loop: boolean;
-
-  constructor(options: InputPlaybackOptions = {}) {
-    this.speed = Math.max(0.01, finite(options.speed, 1));
-    this.loop = options.loop ?? false;
-  }
-
-  load(recording: InputRecording): void {
-    this.recording = normalizeRecording(recording);
-    this.stop();
-  }
-
-  play(): void {
-    if (!this.recording) throw new Error("InputPlayback requires a recording before play().");
-    this.state = "playing";
-  }
-
-  pause(): void {
-    if (this.state === "playing") this.state = "paused";
-  }
-
-  stop(): void {
-    this.state = "stopped";
-    this.currentTimeMs = 0;
-    this.eventIndex = 0;
-  }
-
-  seek(timeMs: number): void {
-    const recording = this.requireRecording();
-    this.currentTimeMs = clamp(finite(timeMs, 0), 0, recording.metadata.durationMs);
-    this.eventIndex = recording.events.findIndex((event) => event.timestampMs >= recording.metadata.startTimeMs + this.currentTimeMs);
-    if (this.eventIndex < 0) this.eventIndex = recording.events.length;
-  }
-
-  update(deltaTimeMs: number): readonly InputReplayEvent[] {
-    if (this.state !== "playing") return [];
-    const recording = this.requireRecording();
-    this.currentTimeMs += Math.max(0, finite(deltaTimeMs, 0)) * this.speed;
-    const absoluteTime = recording.metadata.startTimeMs + this.currentTimeMs;
-    const emitted: InputReplayEvent[] = [];
-    while (this.eventIndex < recording.events.length && (recording.events[this.eventIndex]?.timestampMs ?? Infinity) <= absoluteTime) {
-      emitted.push(recording.events[this.eventIndex]!);
-      this.eventIndex += 1;
-    }
-    if (this.currentTimeMs >= recording.metadata.durationMs) {
-      if (this.loop && recording.metadata.durationMs > 0) {
-        this.loopCount += 1;
-        this.currentTimeMs %= recording.metadata.durationMs;
-        this.eventIndex = 0;
-      } else {
-        this.state = "stopped";
-        this.currentTimeMs = recording.metadata.durationMs;
-      }
-    }
-    this.emittedEvents += emitted.length;
-    return Object.freeze(emitted);
-  }
-
-  snapshot(): InputPlaybackSnapshot {
-    return Object.freeze({
-      state: this.state,
-      currentTimeMs: Number(this.currentTimeMs.toFixed(3)),
-      emittedEvents: this.emittedEvents,
-      loopCount: this.loopCount,
-      recordingEventCount: this.recording?.metadata.eventCount ?? 0,
-      evidence: replayEvidence()
-    });
-  }
-
-  private requireRecording(): InputRecording {
-    if (!this.recording) throw new Error("InputPlayback has no loaded recording.");
-    return this.recording;
-  }
-}
-
-export function parseInputRecording(json: string): InputRecording {
-  return normalizeRecording(JSON.parse(json) as InputRecording);
-}
-
-function normalizeRecording(recording: InputRecording): InputRecording {
-  const events = [...recording.events].sort((left, right) => left.timestampMs - right.timestampMs || left.frame - right.frame);
-  return Object.freeze({
-    metadata: Object.freeze({
-      ...recording.metadata,
-      evidence: replayEvidence()
-    }),
-    events: Object.freeze(events.map((event) => Object.freeze({ ...event })))
-  });
-}
-
-function replayEvidence(): InputRecordingMetadata["evidence"] {
-  return {
-    oldCodebasePort: true,
-    recording: true,
-    playback: true,
-    seek: true,
-    looping: true
-  };
-}
-
-function finite(value: unknown, fallback: number): number {
-  const number = Number(value);
-  return Number.isFinite(number) ? number : fallback;
-}
-
-function clamp(value: number, min: number, max: number): number {
-  return Math.max(min, Math.min(max, value));
-}

package/src/InputSnapshot.ts

@@ -1,92 +0,0 @@
-export type ButtonState = Readonly<{
-  down: boolean;
-  pressed: boolean;
-  released: boolean;
-}>;
-
-export interface PointerSnapshot {
-  readonly x: number;
-  readonly y: number;
-  readonly deltaX: number;
-  readonly deltaY: number;
-  readonly wheelX: number;
-  readonly wheelY: number;
-  readonly buttons: ReadonlyMap<number, ButtonState>;
-  readonly touches: readonly PointerTouch[];
-}
-
-export interface PointerTouch {
-  readonly id: number;
-  readonly x: number;
-  readonly y: number;
-}
-
-export interface GamepadSnapshot {
-  readonly id: string;
-  readonly index: number;
-  readonly axes: readonly number[];
-  readonly buttons: readonly ButtonState[];
-}
-
-export interface InputSnapshotOptions {
-  readonly keys?: ReadonlySet<string>;
-  readonly previousKeys?: ReadonlySet<string>;
-  readonly pointer?: Partial<PointerSnapshot>;
-  readonly previousPointerButtons?: ReadonlySet<number>;
-  readonly gamepads?: readonly GamepadSnapshot[];
-}
-
-const EMPTY_SET = new Set<string>();
-const EMPTY_BUTTON_SET = new Set<number>();
-
-export class InputSnapshot {
-  readonly keys: ReadonlySet<string>;
-  readonly pointer: PointerSnapshot;
-  readonly gamepads: readonly GamepadSnapshot[];
-
-  private readonly previousKeys: ReadonlySet<string>;
-
-  constructor(options: InputSnapshotOptions = {}) {
-    this.keys = new Set(options.keys ?? EMPTY_SET);
-    this.previousKeys = new Set(options.previousKeys ?? EMPTY_SET);
-    this.gamepads = Object.freeze([...(options.gamepads ?? [])]);
-
-    const previousButtons = options.previousPointerButtons ?? EMPTY_BUTTON_SET;
-    const currentButtons = new Set(options.pointer?.buttons?.keys() ?? []);
-    const buttons = new Map<number, ButtonState>();
-
-    for (const button of new Set([...previousButtons, ...currentButtons])) {
-      const down = currentButtons.has(button);
-      const wasDown = previousButtons.has(button);
-      buttons.set(button, Object.freeze({ down, pressed: down && !wasDown, released: !down && wasDown }));
-    }
-
-    this.pointer = Object.freeze({
-      x: options.pointer?.x ?? 0,
-      y: options.pointer?.y ?? 0,
-      deltaX: options.pointer?.deltaX ?? 0,
-      deltaY: options.pointer?.deltaY ?? 0,
-      wheelX: options.pointer?.wheelX ?? 0,
-      wheelY: options.pointer?.wheelY ?? 0,
-      buttons,
-      touches: Object.freeze([...(options.pointer?.touches ?? [])])
-    });
-  }
-
-  key(code: string): ButtonState {
-    const down = this.keys.has(code);
-    const wasDown = this.previousKeys.has(code);
-    return Object.freeze({ down, pressed: down && !wasDown, released: !down && wasDown });
-  }
-
-  button(button: number): ButtonState {
-    return this.pointer.buttons.get(button) ?? Object.freeze({ down: false, pressed: false, released: false });
-  }
-
-  gamepadButton(gamepadIndex: number, buttonIndex: number): ButtonState {
-    return (
-      this.gamepads.find((gamepad) => gamepad.index === gamepadIndex)?.buttons[buttonIndex] ??
-      Object.freeze({ down: false, pressed: false, released: false })
-    );
-  }
-}

package/src/InputSystem.ts

@@ -1,92 +0,0 @@
-import { ActionMap } from "./ActionMap";
-import { GamepadDevice, type GamepadLike } from "./GamepadDevice";
-import { InputSnapshot } from "./InputSnapshot";
-import { KeyboardDevice, type KeyboardEventLike } from "./KeyboardDevice";
-import { PointerDevice, type PointerEventLike, type WheelEventLike } from "./PointerDevice";
-
-export interface InputEventTargetLike {
-  addEventListener(type: string, listener: EventListener): void;
-  removeEventListener(type: string, listener: EventListener): void;
-}
-
-export class InputSystem {
-  readonly keyboard = new KeyboardDevice();
-  readonly pointer = new PointerDevice();
-  readonly gamepads = new GamepadDevice();
-  readonly actions = new ActionMap();
-
-  private readonly attachedTargets = new Map<InputEventTargetLike, Array<() => void>>();
-  private snapshotRef = new InputSnapshot();
-
-  constructor(target?: InputEventTargetLike) {
-    if (target) {
-      this.attach(target);
-    }
-  }
-
-  get snapshot(): InputSnapshot {
-    return this.snapshotRef;
-  }
-
-  attach(target: InputEventTargetLike): void {
-    if (this.attachedTargets.has(target)) {
-      return;
-    }
-
-    const onKeyDown = ((event: Event) => this.keyboard.keyDown(event as unknown as KeyboardEventLike)) as EventListener;
-    const onKeyUp = ((event: Event) => this.keyboard.keyUp(event as unknown as KeyboardEventLike)) as EventListener;
-    const onPointerMove = ((event: Event) => this.pointer.move(event as unknown as PointerEventLike)) as EventListener;
-    const onPointerDown = ((event: Event) => this.pointer.down(event as unknown as PointerEventLike)) as EventListener;
-    const onPointerUp = ((event: Event) => this.pointer.up(event as unknown as PointerEventLike)) as EventListener;
-    const onWheel = ((event: Event) => this.pointer.wheel(event as unknown as WheelEventLike)) as EventListener;
-    const onBlur = (() => {
-      this.keyboard.blur();
-      this.pointer.blur();
-    }) as EventListener;
-
-    const listeners: Array<readonly [string, EventListener]> = [
-      ["keydown", onKeyDown],
-      ["keyup", onKeyUp],
-      ["pointermove", onPointerMove],
-      ["pointerdown", onPointerDown],
-      ["pointerup", onPointerUp],
-      ["wheel", onWheel],
-      ["blur", onBlur]
-    ];
-
-    const disposers: Array<() => void> = [];
-    for (const [type, listener] of listeners) {
-      target.addEventListener(type, listener);
-      disposers.push(() => target.removeEventListener(type, listener));
-    }
-    this.attachedTargets.set(target, disposers);
-  }
-
-  update(gamepads: readonly (GamepadLike | null | undefined)[] = []): InputSnapshot {
-    const keyboard = this.keyboard.snapshotSets();
-    const pointer = this.pointer.snapshotData();
-    this.snapshotRef = new InputSnapshot({
-      ...keyboard,
-      ...pointer,
-      gamepads: this.gamepads.poll(gamepads)
-    });
-    this.actions.useSnapshot(this.snapshotRef);
-    return this.snapshotRef;
-  }
-
-  endFrame(): void {
-    this.keyboard.endFrame();
-    this.pointer.endFrame();
-  }
-
-  dispose(): void {
-    for (const disposers of this.attachedTargets.values()) {
-      while (disposers.length > 0) {
-        disposers.pop()?.();
-      }
-    }
-    this.attachedTargets.clear();
-    this.keyboard.blur();
-    this.pointer.blur();
-  }
-}

package/src/InteractionSystem.ts

@@ -1,119 +0,0 @@
-import type { Ray } from "@aura3d/math";
-import type { SceneNode } from "@aura3d/scene";
-import type { InputSnapshot } from "./InputSnapshot";
-
-type Tuple3 = readonly [number, number, number];
-
-export interface InteractionBounds {
-  readonly min: Tuple3;
-  readonly max: Tuple3;
-}
-
-export interface InteractionTarget {
-  readonly id: string;
-  readonly node?: SceneNode;
-  readonly bounds: InteractionBounds;
-}
-
-export interface InteractionHit {
-  readonly target: InteractionTarget;
-  readonly distance: number;
-}
-
-export type InteractionEventType = "hover-enter" | "hover-exit" | "pointer-down" | "drag-start" | "drag" | "drag-end" | "click";
-
-export interface InteractionEvent {
-  readonly type: InteractionEventType;
-  readonly hit?: InteractionHit;
-  readonly target?: InteractionTarget;
-  readonly snapshot: InputSnapshot;
-}
-
-export type InteractionListener = (event: InteractionEvent) => void;
-export type InteractionRayProvider = (snapshot: InputSnapshot) => Ray;
-export type InteractionTargetProvider = () => readonly InteractionTarget[];
-
-export class InteractionSystem {
-  private readonly listeners = new Set<InteractionListener>();
-  private hovered?: InteractionTarget;
-  private pressed?: InteractionTarget;
-  private dragging = false;
-
-  constructor(
-    private readonly rayProvider: InteractionRayProvider,
-    private readonly targetProvider: InteractionTargetProvider
-  ) {}
-
-  subscribe(listener: InteractionListener): () => void {
-    this.listeners.add(listener);
-    return () => this.listeners.delete(listener);
-  }
-
-  update(snapshot: InputSnapshot): InteractionHit | undefined {
-    const hit = this.pick(this.rayProvider(snapshot));
-    const target = hit?.target;
-
-    if (this.hovered?.id !== target?.id) {
-      if (this.hovered) this.emit({ type: "hover-exit", target: this.hovered, snapshot });
-      if (target) this.emit({ type: "hover-enter", hit, target, snapshot });
-      this.hovered = target;
-    }
-
-    if (snapshot.button(0).pressed && target) {
-      this.pressed = target;
-      this.dragging = false;
-      this.emit({ type: "pointer-down", hit, target, snapshot });
-    }
-
-    if (this.pressed && snapshot.button(0).down && (snapshot.pointer.deltaX !== 0 || snapshot.pointer.deltaY !== 0)) {
-      this.emit({ type: this.dragging ? "drag" : "drag-start", hit, target: this.pressed, snapshot });
-      this.dragging = true;
-    }
-
-    if (this.pressed && snapshot.button(0).released) {
-      this.emit({ type: this.dragging ? "drag-end" : "click", hit, target: this.pressed, snapshot });
-      this.pressed = undefined;
-      this.dragging = false;
-    }
-
-    return hit;
-  }
-
-  pick(ray: Ray): InteractionHit | undefined {
-    const hits = this.targetProvider()
-      .map((target) => ({ target, distance: intersectBounds(ray, target.bounds) }))
-      .filter((hit): hit is InteractionHit => hit.distance !== undefined)
-      .sort((a, b) => a.distance - b.distance);
-    return hits[0];
-  }
-
-  private emit(event: InteractionEvent): void {
-    for (const listener of [...this.listeners]) listener(event);
-  }
-}
-
-function intersectBounds(ray: Ray, bounds: InteractionBounds): number | undefined {
-  let tmin = Number.NEGATIVE_INFINITY;
-  let tmax = Number.POSITIVE_INFINITY;
-
-  for (const axis of [0, 1, 2] as const) {
-    const origin = axis === 0 ? ray.origin.x : axis === 1 ? ray.origin.y : ray.origin.z;
-    const direction = axis === 0 ? ray.direction.x : axis === 1 ? ray.direction.y : ray.direction.z;
-    const min = bounds.min[axis];
-    const max = bounds.max[axis];
-    if (Math.abs(direction) < 1e-8) {
-      if (origin < min || origin > max) return undefined;
-      continue;
-    }
-    const invD = 1 / direction;
-    let near = (min - origin) * invD;
-    let far = (max - origin) * invD;
-    if (near > far) [near, far] = [far, near];
-    tmin = Math.max(tmin, near);
-    tmax = Math.min(tmax, far);
-    if (tmin > tmax) return undefined;
-  }
-
-  const distance = tmin >= 0 ? tmin : tmax;
-  return distance >= 0 ? distance : undefined;
-}

package/src/KeyboardDevice.ts

@@ -1,32 +0,0 @@
-export interface KeyboardEventLike {
-  readonly code: string;
-  readonly repeat?: boolean;
-  preventDefault?(): void;
-}
-
-export class KeyboardDevice {
-  private current = new Set<string>();
-  private previous = new Set<string>();
-
-  keyDown(event: KeyboardEventLike): void {
-    if (!event.repeat) {
-      this.current.add(event.code);
-    }
-  }
-
-  keyUp(event: KeyboardEventLike): void {
-    this.current.delete(event.code);
-  }
-
-  blur(): void {
-    this.current.clear();
-  }
-
-  snapshotSets(): { readonly keys: ReadonlySet<string>; readonly previousKeys: ReadonlySet<string> } {
-    return { keys: new Set(this.current), previousKeys: new Set(this.previous) };
-  }
-
-  endFrame(): void {
-    this.previous = new Set(this.current);
-  }
-}

package/src/PickingRay.ts

@@ -1,49 +0,0 @@
-import { Ray, Vector3 } from "@aura3d/math";
-import { invertMat4, type Camera } from "@aura3d/scene";
-
-type Tuple3 = readonly [number, number, number];
-type TupleMat4 = readonly [
-  number, number, number, number,
-  number, number, number, number,
-  number, number, number, number,
-  number, number, number, number
-];
-
-export interface PickingRayViewport {
-  readonly x: number;
-  readonly y: number;
-  readonly width: number;
-  readonly height: number;
-}
-
-export function pickingRayFromCamera(
-  camera: Camera,
-  screenX: number,
-  screenY: number,
-  viewport: PickingRayViewport = camera.viewport
-): Ray {
-  camera.updateCameraMatrices();
-  const ndcX = ((screenX - viewport.x) / viewport.width) * 2 - 1;
-  const ndcY = 1 - ((screenY - viewport.y) / viewport.height) * 2;
-  const inverseViewProjection = invertMat4(camera.viewProjectionMatrix) as TupleMat4;
-  const near = transformClip(inverseViewProjection, [ndcX, ndcY, -1]);
-  const far = transformClip(inverseViewProjection, [ndcX, ndcY, 1]);
-  return new Ray(toVector3(near), toVector3(far).subtract(toVector3(near)));
-}
-
-function transformClip(matrix: TupleMat4, point: Tuple3): Tuple3 {
-  const x = point[0];
-  const y = point[1];
-  const z = point[2];
-  const w = matrix[3] * x + matrix[7] * y + matrix[11] * z + matrix[15];
-  const invW = Math.abs(w) <= 1e-8 ? 1 : 1 / w;
-  return [
-    (matrix[0] * x + matrix[4] * y + matrix[8] * z + matrix[12]) * invW,
-    (matrix[1] * x + matrix[5] * y + matrix[9] * z + matrix[13]) * invW,
-    (matrix[2] * x + matrix[6] * y + matrix[10] * z + matrix[14]) * invW
-  ];
-}
-
-function toVector3(value: Tuple3): Vector3 {
-  return new Vector3(value[0], value[1], value[2]);
-}