@aura3d/physics 1.4.0 → 1.4.1

package/src/RigidBody.ts

@@ -1,311 +0,0 @@
-import { addVec3, cloneVec3, scaleVec3, validateFiniteVec3, type Vec3, vec3 } from "./Shape.js";
-
-export type RigidBodyType = "dynamic" | "static" | "kinematic";
-export type Quat = readonly [number, number, number, number];
-
-export type RigidBodyDescriptor = {
-  readonly type?: RigidBodyType;
-  readonly position?: Vec3;
-  readonly rotation?: Quat;
-  readonly velocity?: Vec3;
-  readonly angularVelocity?: Vec3;
-  readonly mass?: number;
-  readonly inertia?: Vec3;
-  readonly linearDamping?: number;
-  readonly angularDamping?: number;
-  readonly restitution?: number;
-  readonly friction?: number;
-  readonly sleeping?: boolean;
-};
-
-export type RigidBodySnapshot = {
-  readonly id: number;
-  readonly type: RigidBodyType;
-  readonly position: Vec3;
-  readonly rotation: Quat;
-  readonly velocity: Vec3;
-  readonly angularVelocity: Vec3;
-  readonly mass: number;
-  readonly inverseMass: number;
-  readonly inverseInertia: Vec3;
-  readonly sleeping: boolean;
-};
-
-export class RigidBody {
-  readonly id: number;
-  readonly type: RigidBodyType;
-  readonly mass: number;
-  readonly inverseMass: number;
-  readonly restitution: number;
-  readonly friction: number;
-  position: [number, number, number];
-  previousPosition: [number, number, number];
-  rotation: [number, number, number, number];
-  previousRotation: [number, number, number, number];
-  velocity: [number, number, number];
-  angularVelocity: [number, number, number];
-  linearDamping: number;
-  angularDamping: number;
-  inverseInertia: [number, number, number];
-  sleeping: boolean;
-  private accumulatedForce: [number, number, number];
-  private accumulatedTorque: [number, number, number];
-  private sleepTimer = 0;
-
-  constructor(id: number, descriptor: RigidBodyDescriptor = {}) {
-    if (!Number.isInteger(id) || id <= 0) {
-      throw new Error("RigidBody id must be a positive integer.");
-    }
-    this.id = id;
-    this.type = descriptor.type ?? "dynamic";
-    this.position = cloneVec3(descriptor.position ?? vec3());
-    this.previousPosition = cloneVec3(this.position);
-    this.rotation = normalizeQuat(descriptor.rotation ?? [0, 0, 0, 1]);
-    this.previousRotation = cloneQuat(this.rotation);
-    this.velocity = cloneVec3(descriptor.velocity ?? vec3());
-    this.angularVelocity = cloneVec3(descriptor.angularVelocity ?? vec3());
-    this.linearDamping = descriptor.linearDamping ?? 0;
-    this.angularDamping = descriptor.angularDamping ?? 0;
-    this.restitution = descriptor.restitution ?? 0;
-    this.friction = descriptor.friction ?? 0.5;
-    this.sleeping = descriptor.sleeping ?? false;
-    validateFiniteVec3(this.position, "body position");
-    validateFiniteVec3(this.velocity, "body velocity");
-    validateFiniteVec3(this.angularVelocity, "body angularVelocity");
-    if (!Number.isFinite(this.linearDamping) || this.linearDamping < 0) {
-      throw new Error("linearDamping must be finite and non-negative.");
-    }
-    if (!Number.isFinite(this.angularDamping) || this.angularDamping < 0) {
-      throw new Error("angularDamping must be finite and non-negative.");
-    }
-    const mass = descriptor.mass ?? 1;
-    if (this.type === "dynamic") {
-      if (!Number.isFinite(mass) || mass <= 0) {
-        throw new Error("dynamic body mass must be a finite positive number.");
-      }
-      this.mass = mass;
-      this.inverseMass = 1 / mass;
-      this.inverseInertia = inverseInertia(descriptor.inertia ?? [mass, mass, mass]);
-    } else {
-      this.mass = Number.POSITIVE_INFINITY;
-      this.inverseMass = 0;
-      this.inverseInertia = vec3();
-    }
-    this.accumulatedForce = vec3();
-    this.accumulatedTorque = vec3();
-  }
-
-  setPosition(position: Vec3): void {
-    validateFiniteVec3(position, "body position");
-    this.previousPosition = cloneVec3(this.position);
-    this.position = cloneVec3(position);
-    this.wake();
-  }
-
-  setVelocity(velocity: Vec3): void {
-    validateFiniteVec3(velocity, "body velocity");
-    this.velocity = cloneVec3(velocity);
-    this.wake();
-  }
-
-  setRotation(rotation: Quat): void {
-    this.previousRotation = cloneQuat(this.rotation);
-    this.rotation = normalizeQuat(rotation);
-    this.wake();
-  }
-
-  setAngularVelocity(angularVelocity: Vec3): void {
-    validateFiniteVec3(angularVelocity, "body angularVelocity");
-    this.angularVelocity = cloneVec3(angularVelocity);
-    this.wake();
-  }
-
-  applyForce(force: Vec3): void {
-    validateFiniteVec3(force, "force");
-    if (this.type !== "dynamic") {
-      return;
-    }
-    this.accumulatedForce = addVec3(this.accumulatedForce, force);
-    this.wake();
-  }
-
-  applyTorque(torque: Vec3): void {
-    validateFiniteVec3(torque, "torque");
-    if (this.type !== "dynamic") {
-      return;
-    }
-    this.accumulatedTorque = addVec3(this.accumulatedTorque, torque);
-    this.wake();
-  }
-
-  applyImpulse(impulse: Vec3): void {
-    validateFiniteVec3(impulse, "impulse");
-    if (this.type !== "dynamic") {
-      return;
-    }
-    this.velocity = addVec3(this.velocity, scaleVec3(impulse, this.inverseMass));
-    this.wake();
-  }
-
-  applyAngularImpulse(impulse: Vec3): void {
-    validateFiniteVec3(impulse, "angular impulse");
-    if (this.type !== "dynamic") {
-      return;
-    }
-    this.angularVelocity = addVec3(this.angularVelocity, multiplyVec3(impulse, this.inverseInertia));
-    this.wake();
-  }
-
-  applyImpulseAtPoint(impulse: Vec3, worldPoint: Vec3): void {
-    validateFiniteVec3(impulse, "impulse");
-    validateFiniteVec3(worldPoint, "impulse point");
-    if (this.type !== "dynamic") {
-      return;
-    }
-    this.applyImpulse(impulse);
-    this.applyAngularImpulse(crossVec3(subVec3(worldPoint, this.position), impulse));
-  }
-
-  integrate(dt: number, gravity: Vec3): void {
-    if (!Number.isFinite(dt) || dt <= 0) {
-      throw new Error("dt must be a finite positive number.");
-    }
-    if (this.type !== "dynamic" || this.sleeping) {
-      this.clearForces();
-      this.previousPosition = cloneVec3(this.position);
-      this.previousRotation = cloneQuat(this.rotation);
-      return;
-    }
-    this.previousPosition = cloneVec3(this.position);
-    this.previousRotation = cloneQuat(this.rotation);
-    const acceleration = addVec3(gravity, scaleVec3(this.accumulatedForce, this.inverseMass));
-    this.velocity = addVec3(this.velocity, scaleVec3(acceleration, dt));
-    this.angularVelocity = addVec3(this.angularVelocity, scaleVec3(multiplyVec3(this.accumulatedTorque, this.inverseInertia), dt));
-    const dampingFactor = Math.max(0, 1 - this.linearDamping * dt);
-    const angularDampingFactor = Math.max(0, 1 - this.angularDamping * dt);
-    this.velocity = scaleVec3(this.velocity, dampingFactor);
-    this.angularVelocity = scaleVec3(this.angularVelocity, angularDampingFactor);
-    this.position = addVec3(this.position, scaleVec3(this.velocity, dt));
-    this.rotation = integrateRotation(this.rotation, this.angularVelocity, dt);
-    this.clearForces();
-  }
-
-  clearForces(): void {
-    this.accumulatedForce = vec3();
-    this.accumulatedTorque = vec3();
-  }
-
-  speedSquared(): number {
-    return this.velocity[0] * this.velocity[0] + this.velocity[1] * this.velocity[1] + this.velocity[2] * this.velocity[2] +
-      this.angularVelocity[0] * this.angularVelocity[0] + this.angularVelocity[1] * this.angularVelocity[1] + this.angularVelocity[2] * this.angularVelocity[2];
-  }
-
-  wake(): void {
-    if (this.type !== "dynamic") {
-      return;
-    }
-    this.sleeping = false;
-    this.sleepTimer = 0;
-  }
-
-  sleep(): void {
-    if (this.type !== "dynamic") {
-      return;
-    }
-    this.velocity = vec3();
-    this.angularVelocity = vec3();
-    this.clearForces();
-    this.sleeping = true;
-  }
-
-  resetSleepTimer(): void {
-    this.sleepTimer = 0;
-  }
-
-  accumulateSleepTime(dt: number): number {
-    if (!Number.isFinite(dt) || dt < 0) {
-      throw new Error("sleep dt must be finite and non-negative.");
-    }
-    this.sleepTimer += dt;
-    return this.sleepTimer;
-  }
-
-  snapshot(): RigidBodySnapshot {
-    return {
-      id: this.id,
-      type: this.type,
-      position: cloneVec3(this.position),
-      rotation: cloneQuat(this.rotation),
-      velocity: cloneVec3(this.velocity),
-      angularVelocity: cloneVec3(this.angularVelocity),
-      mass: this.mass,
-      inverseMass: this.inverseMass,
-      inverseInertia: cloneVec3(this.inverseInertia),
-      sleeping: this.sleeping
-    };
-  }
-}
-
-function cloneQuat(value: Quat): [number, number, number, number] {
-  return [value[0], value[1], value[2], value[3]];
-}
-
-function normalizeQuat(value: Quat): [number, number, number, number] {
-  if (value.length !== 4 || !Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2]) || !Number.isFinite(value[3])) {
-    throw new Error("body rotation must be a finite quaternion.");
-  }
-  const length = Math.hypot(value[0], value[1], value[2], value[3]);
-  if (length <= 1e-9) {
-    throw new Error("body rotation quaternion cannot be zero.");
-  }
-  return [value[0] / length, value[1] / length, value[2] / length, value[3] / length];
-}
-
-function inverseInertia(inertia: Vec3): [number, number, number] {
-  validateFiniteVec3(inertia, "body inertia");
-  if (inertia[0] <= 0 || inertia[1] <= 0 || inertia[2] <= 0) {
-    throw new Error("dynamic body inertia must contain finite positive principal moments.");
-  }
-  return [1 / inertia[0], 1 / inertia[1], 1 / inertia[2]];
-}
-
-function multiplyVec3(a: Vec3, b: Vec3): [number, number, number] {
-  return [a[0] * b[0], a[1] * b[1], a[2] * b[2]];
-}
-
-function subVec3(a: Vec3, b: Vec3): [number, number, number] {
-  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
-}
-
-function crossVec3(a: Vec3, b: Vec3): [number, number, number] {
-  return [
-    a[1] * b[2] - a[2] * b[1],
-    a[2] * b[0] - a[0] * b[2],
-    a[0] * b[1] - a[1] * b[0]
-  ];
-}
-
-function integrateRotation(rotation: Quat, angularVelocity: Vec3, dt: number): [number, number, number, number] {
-  const speed = Math.hypot(angularVelocity[0], angularVelocity[1], angularVelocity[2]);
-  if (speed <= 1e-12) {
-    return cloneQuat(rotation);
-  }
-  const halfAngle = speed * dt * 0.5;
-  const sinHalf = Math.sin(halfAngle);
-  const delta: Quat = [
-    angularVelocity[0] / speed * sinHalf,
-    angularVelocity[1] / speed * sinHalf,
-    angularVelocity[2] / speed * sinHalf,
-    Math.cos(halfAngle)
-  ];
-  return normalizeQuat(multiplyQuat(delta, rotation));
-}
-
-function multiplyQuat(a: Quat, b: Quat): [number, number, number, number] {
-  return [
-    a[3] * b[0] + a[0] * b[3] + a[1] * b[2] - a[2] * b[1],
-    a[3] * b[1] - a[0] * b[2] + a[1] * b[3] + a[2] * b[0],
-    a[3] * b[2] + a[0] * b[1] - a[1] * b[0] + a[2] * b[3],
-    a[3] * b[3] - a[0] * b[0] - a[1] * b[1] - a[2] * b[2]
-  ];
-}

package/src/ScenePhysicsBridge.ts

@@ -1,207 +0,0 @@
-import type { PhysicsWorld } from "./PhysicsWorld.js";
-import type { Quat } from "./RigidBody.js";
-import type { Vec3 } from "./Shape.js";
-
-type MutableQuat = [number, number, number, number];
-type QuaternionObject = {
-  x: number;
-  y: number;
-  z: number;
-  w: number;
-  set?: (x: number, y: number, z: number, w: number) => void;
-  toArray?: () => readonly number[];
-};
-
-export type ScenePhysicsNode = {
-  position?: [number, number, number];
-  rotation?: MutableQuat;
-  quaternion?: MutableQuat | QuaternionObject;
-  getWorldPosition?: () => Vec3;
-  getWorldQuaternion?: () => Quat;
-  getQuaternion?: () => Quat;
-  setWorldPosition?: (position: Vec3) => void;
-  setWorldQuaternion?: (rotation: Quat) => void;
-  setPosition?: (position: Vec3) => void;
-  setRotation?: (rotation: Quat) => void;
-  setQuaternion?: (rotation: Quat) => void;
-};
-
-export type ScenePhysicsBinding = {
-  readonly bodyId: number;
-  readonly node: ScenePhysicsNode;
-  readonly mode?: "dynamic" | "kinematic";
-};
-
-export class ScenePhysicsBridge {
-  private readonly bindings: ScenePhysicsBinding[] = [];
-
-  bind(binding: ScenePhysicsBinding): void {
-    if (this.bindings.some((existing) => existing.bodyId === binding.bodyId)) {
-      throw new Error(`Body ${binding.bodyId} is already bound to a scene node.`);
-    }
-    this.bindings.push(binding);
-  }
-
-  unbind(bodyId: number): void {
-    const index = this.bindings.findIndex((binding) => binding.bodyId === bodyId);
-    if (index >= 0) {
-      this.bindings.splice(index, 1);
-    }
-  }
-
-  pushKinematic(world: Pick<PhysicsWorld, "getBody">): void {
-    for (const binding of this.bindings) {
-      if (binding.mode !== "kinematic") {
-        continue;
-      }
-      const body = world.getBody(binding.bodyId);
-      const position = readNodePosition(binding.node);
-      if (body && position) {
-        body.setPosition(position);
-      }
-      const rotation = readNodeRotation(binding.node);
-      if (body && rotation) {
-        body.setRotation(rotation);
-      }
-    }
-  }
-
-  pullDynamic(world: Pick<PhysicsWorld, "getBody">, alpha = 1): void {
-    const interpolationAlpha = clamp01(alpha);
-    for (const binding of this.bindings) {
-      if (binding.mode === "kinematic") {
-        continue;
-      }
-      const body = world.getBody(binding.bodyId);
-      if (body) {
-        writeNodePosition(binding.node, interpolatePosition(body.previousPosition, body.position, interpolationAlpha));
-        writeNodeRotation(binding.node, interpolateRotation(body.previousRotation, body.rotation, interpolationAlpha));
-      }
-    }
-  }
-
-  update(world: Pick<PhysicsWorld, "getBody">, alpha = 1): void {
-    this.pushKinematic(world);
-    this.pullDynamic(world, alpha);
-  }
-}
-
-export function interpolatePosition(previous: Vec3, current: Vec3, alpha: number): [number, number, number] {
-  const t = clamp01(alpha);
-  return [
-    previous[0] + (current[0] - previous[0]) * t,
-    previous[1] + (current[1] - previous[1]) * t,
-    previous[2] + (current[2] - previous[2]) * t
-  ];
-}
-
-export function interpolateRotation(previous: Quat, current: Quat, alpha: number): MutableQuat {
-  const t = clamp01(alpha);
-  const currentSign = dotQuat(previous, current) < 0 ? -1 : 1;
-  const x = previous[0] + (current[0] * currentSign - previous[0]) * t;
-  const y = previous[1] + (current[1] * currentSign - previous[1]) * t;
-  const z = previous[2] + (current[2] * currentSign - previous[2]) * t;
-  const w = previous[3] + (current[3] * currentSign - previous[3]) * t;
-  return normalizeRotation([x, y, z, w]);
-}
-
-function clamp01(value: number): number {
-  if (!Number.isFinite(value)) {
-    throw new Error("Physics interpolation alpha must be finite.");
-  }
-  return Math.min(1, Math.max(0, value));
-}
-
-function dotQuat(a: Quat, b: Quat): number {
-  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
-}
-
-function readNodePosition(node: ScenePhysicsNode): Vec3 | undefined {
-  if (node.getWorldPosition) {
-    return node.getWorldPosition();
-  }
-  return node.position;
-}
-
-function readNodeRotation(node: ScenePhysicsNode): Quat | undefined {
-  if (node.getWorldQuaternion) {
-    return normalizeRotation(node.getWorldQuaternion());
-  }
-  if (node.getQuaternion) {
-    return normalizeRotation(node.getQuaternion());
-  }
-  if (Array.isArray(node.rotation)) {
-    return normalizeRotation(node.rotation);
-  }
-  if (Array.isArray(node.quaternion)) {
-    return normalizeRotation(node.quaternion);
-  }
-  if (node.quaternion?.toArray) {
-    return normalizeRotation(node.quaternion.toArray());
-  }
-  if (node.quaternion) {
-    return normalizeRotation([node.quaternion.x, node.quaternion.y, node.quaternion.z, node.quaternion.w]);
-  }
-  return undefined;
-}
-
-function writeNodePosition(node: ScenePhysicsNode, position: Vec3): void {
-  if (node.setWorldPosition) {
-    node.setWorldPosition(position);
-  } else if (node.setPosition) {
-    node.setPosition(position);
-  } else if (node.position) {
-    node.position[0] = position[0];
-    node.position[1] = position[1];
-    node.position[2] = position[2];
-  } else {
-    node.position = [position[0], position[1], position[2]];
-  }
-}
-
-function writeNodeRotation(node: ScenePhysicsNode, rotation: Quat): void {
-  const normalized = normalizeRotation(rotation);
-  if (node.setWorldQuaternion) {
-    node.setWorldQuaternion(normalized);
-  } else if (node.setQuaternion) {
-    node.setQuaternion(normalized);
-  } else if (node.setRotation) {
-    node.setRotation(normalized);
-  } else if (Array.isArray(node.rotation)) {
-    node.rotation[0] = normalized[0];
-    node.rotation[1] = normalized[1];
-    node.rotation[2] = normalized[2];
-    node.rotation[3] = normalized[3];
-  } else if (Array.isArray(node.quaternion)) {
-    node.quaternion[0] = normalized[0];
-    node.quaternion[1] = normalized[1];
-    node.quaternion[2] = normalized[2];
-    node.quaternion[3] = normalized[3];
-  } else if (node.quaternion?.set) {
-    node.quaternion.set(normalized[0], normalized[1], normalized[2], normalized[3]);
-  } else if (node.quaternion) {
-    node.quaternion.x = normalized[0];
-    node.quaternion.y = normalized[1];
-    node.quaternion.z = normalized[2];
-    node.quaternion.w = normalized[3];
-  } else {
-    node.rotation = [normalized[0], normalized[1], normalized[2], normalized[3]];
-  }
-}
-
-function normalizeRotation(rotation: readonly number[]): MutableQuat {
-  if (
-    rotation.length !== 4 ||
-    !Number.isFinite(rotation[0]) ||
-    !Number.isFinite(rotation[1]) ||
-    !Number.isFinite(rotation[2]) ||
-    !Number.isFinite(rotation[3])
-  ) {
-    throw new Error("Scene physics node rotation must be a finite quaternion.");
-  }
-  const length = Math.hypot(rotation[0], rotation[1], rotation[2], rotation[3]);
-  if (length <= 1e-9) {
-    throw new Error("Scene physics node rotation quaternion cannot be zero.");
-  }
-  return [rotation[0] / length, rotation[1] / length, rotation[2] / length, rotation[3] / length];
-}

package/src/Shape.ts

@@ -1,195 +0,0 @@
-export type Vec3 = readonly [number, number, number];
-
-export type BoxShape = {
-  readonly kind: "box";
-  readonly halfExtents: Vec3;
-};
-
-export type SphereShape = {
-  readonly kind: "sphere";
-  readonly radius: number;
-};
-
-export type CapsuleShape = {
-  readonly kind: "capsule";
-  readonly radius: number;
-  readonly halfHeight: number;
-};
-
-export type PlaneShape = {
-  readonly kind: "plane";
-  readonly normal: Vec3;
-  readonly constant: number;
-};
-
-export type MeshShape = {
-  readonly kind: "mesh";
-  readonly vertices: readonly Vec3[];
-  readonly indices: readonly number[];
-};
-
-export type PhysicsShape = BoxShape | SphereShape | CapsuleShape | PlaneShape | MeshShape;
-
-export type Bounds = {
-  readonly min: Vec3;
-  readonly max: Vec3;
-};
-
-export const EPSILON = 1e-9;
-
-export function vec3(x = 0, y = 0, z = 0): [number, number, number] {
-  return [x, y, z];
-}
-
-export function cloneVec3(value: Vec3): [number, number, number] {
-  return [value[0], value[1], value[2]];
-}
-
-export function addVec3(a: Vec3, b: Vec3): [number, number, number] {
-  return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
-}
-
-export function subVec3(a: Vec3, b: Vec3): [number, number, number] {
-  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
-}
-
-export function scaleVec3(value: Vec3, scalar: number): [number, number, number] {
-  return [value[0] * scalar, value[1] * scalar, value[2] * scalar];
-}
-
-export function dotVec3(a: Vec3, b: Vec3): number {
-  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-}
-
-export function lengthVec3(value: Vec3): number {
-  return Math.hypot(value[0], value[1], value[2]);
-}
-
-export function normalizeVec3(value: Vec3): [number, number, number] {
-  const length = lengthVec3(value);
-  if (length <= EPSILON) {
-    throw new Error("Cannot normalize a zero-length vector.");
-  }
-  return [value[0] / length, value[1] / length, value[2] / length];
-}
-
-export function minVec3(a: Vec3, b: Vec3): [number, number, number] {
-  return [Math.min(a[0], b[0]), Math.min(a[1], b[1]), Math.min(a[2], b[2])];
-}
-
-export function maxVec3(a: Vec3, b: Vec3): [number, number, number] {
-  return [Math.max(a[0], b[0]), Math.max(a[1], b[1]), Math.max(a[2], b[2])];
-}
-
-export function validateFiniteVec3(value: Vec3, name: string): void {
-  if (value.length !== 3 || !Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2])) {
-    throw new Error(`${name} must be a finite 3D vector.`);
-  }
-}
-
-function validatePositive(value: number, name: string): void {
-  if (!Number.isFinite(value) || value <= 0) {
-    throw new Error(`${name} must be a finite positive number.`);
-  }
-}
-
-export class Shape {
-  static box(x: number, y: number, z: number): BoxShape {
-    validatePositive(x, "box x half extent");
-    validatePositive(y, "box y half extent");
-    validatePositive(z, "box z half extent");
-    return { kind: "box", halfExtents: [x, y, z] };
-  }
-
-  static sphere(radius: number): SphereShape {
-    validatePositive(radius, "sphere radius");
-    return { kind: "sphere", radius };
-  }
-
-  static capsule(radius: number, halfHeight: number): CapsuleShape {
-    validatePositive(radius, "capsule radius");
-    validatePositive(halfHeight, "capsule half height");
-    return { kind: "capsule", radius, halfHeight };
-  }
-
-  static plane(normal: Vec3 = [0, 1, 0], constant = 0): PlaneShape {
-    validateFiniteVec3(normal, "plane normal");
-    if (!Number.isFinite(constant)) {
-      throw new Error("plane constant must be finite.");
-    }
-    return { kind: "plane", normal: normalizeVec3(normal), constant };
-  }
-
-  static mesh(vertices: readonly Vec3[], indices: readonly number[]): MeshShape {
-    if (vertices.length < 3) {
-      throw new Error("mesh shape requires at least three vertices.");
-    }
-    for (const [index, vertex] of vertices.entries()) {
-      validateFiniteVec3(vertex, `mesh vertex ${index}`);
-    }
-    if (indices.length === 0 || indices.length % 3 !== 0) {
-      throw new Error("mesh shape indices must contain one or more complete triangles.");
-    }
-    for (const index of indices) {
-      if (!Number.isInteger(index) || index < 0 || index >= vertices.length) {
-        throw new Error(`mesh shape index ${index} is out of range.`);
-      }
-    }
-    return {
-      kind: "mesh",
-      vertices: vertices.map(cloneVec3),
-      indices: [...indices]
-    };
-  }
-
-  static bounds(shape: PhysicsShape, position: Vec3): Bounds {
-    validateFiniteVec3(position, "shape position");
-    switch (shape.kind) {
-      case "box":
-        return {
-          min: subVec3(position, shape.halfExtents),
-          max: addVec3(position, shape.halfExtents)
-        };
-      case "sphere":
-        return {
-          min: [position[0] - shape.radius, position[1] - shape.radius, position[2] - shape.radius],
-          max: [position[0] + shape.radius, position[1] + shape.radius, position[2] + shape.radius]
-        };
-      case "capsule": {
-        const yRadius = shape.radius + shape.halfHeight;
-        return {
-          min: [position[0] - shape.radius, position[1] - yRadius, position[2] - shape.radius],
-          max: [position[0] + shape.radius, position[1] + yRadius, position[2] + shape.radius]
-        };
-      }
-      case "plane":
-        return {
-          min: [-Number.MAX_SAFE_INTEGER, -Number.MAX_SAFE_INTEGER, -Number.MAX_SAFE_INTEGER],
-          max: [Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]
-        };
-      case "mesh": {
-        let min = addVec3(position, shape.vertices[0]!);
-        let max = cloneVec3(min);
-        for (let index = 1; index < shape.vertices.length; index += 1) {
-          const vertex = addVec3(position, shape.vertices[index]!);
-          min = minVec3(min, vertex);
-          max = maxVec3(max, vertex);
-        }
-        return { min, max };
-      }
-  }
-}
-}
-
-export function rotateVec3ByQuat(v: Vec3, q: readonly [number, number, number, number]): [number, number, number] {
-  // q * v * q^-1 for rotating a vector by a unit quaternion
-  const x = q[0], y = q[1], z = q[2], w = q[3];
-  const tx = 2 * (y * v[2] - z * v[1]);
-  const ty = 2 * (z * v[0] - x * v[2]);
-  const tz = 2 * (x * v[1] - y * v[0]);
-  return [
-    v[0] + w * tx + (y * tz - z * ty),
-    v[1] + w * ty + (z * tx - x * tz),
-    v[2] + w * tz + (x * ty - y * tx)
-  ];
-}