otherplane 0.1.0

package/engine/src/physics/RapierProvider.tsx

@@ -0,0 +1,302 @@
+'use client';
+
+import React, { createContext, useContext, useEffect, useMemo, useRef, useState } from 'react';
+import * as RAPIER from '@dimforge/rapier3d-compat';
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+import * as THREE from 'three';
+import { CONFIG as UNIVERSE_CONFIG } from '@/data/universeconfig'
+import type { WorldDef } from '@/data/presets';
+
+type RapierCtx = {
+  rapier: typeof RAPIER | null;
+  world: RAPIER.World | null;
+  playerBody: RAPIER.RigidBody | null;
+};
+const Ctx = createContext<RapierCtx>({ rapier: null, world: null, playerBody: null });
+
+const FIXED_DT = 1 / 60;
+const MAX_STEPS = 5;
+
+// Find a clear, stand-able floor spot near the room's center, so we don't drop
+// the player inside a wall or a bookshelf. For a grid of candidate (x,z) points
+// (center first), cast a ray straight down from mid-height (inside the room,
+// below any ceiling) to find the floor, then cast up to require player-height
+// headroom. Returns the valid spot nearest the center, or null if none.
+function findValidSpawn(
+  world: RAPIER.World,
+  rapier: typeof RAPIER,
+  aabb: THREE.Box3,
+  RADIUS: number,
+  HALF_HEIGHT: number,
+  excludeBody: RAPIER.RigidBody | null,
+): { x: number; y: number; z: number } | null {
+  const cx = (aabb.min.x + aabb.max.x) / 2;
+  const cz = (aabb.min.z + aabb.max.z) / 2;
+  const midY = (aabb.min.y + aabb.max.y) / 2;
+  const stand = HALF_HEIGHT + RADIUS;            // body-center height above feet
+  const playerH = 2 * HALF_HEIGHT + 2 * RADIUS;  // approx full capsule height
+  const downMax = midY - aabb.min.y + 1;
+  const exclude = excludeBody ?? undefined;
+
+  const cand: Array<[number, number]> = [[cx, cz]];
+  const N = 5;
+  for (let i = 0; i < N; i++) {
+    for (let j = 0; j < N; j++) {
+      const fx = (i + 0.5) / N;
+      const fz = (j + 0.5) / N;
+      cand.push([
+        aabb.min.x + fx * (aabb.max.x - aabb.min.x),
+        aabb.min.z + fz * (aabb.max.z - aabb.min.z),
+      ]);
+    }
+  }
+
+  let best: { x: number; y: number; z: number } | null = null;
+  let bestD = Infinity;
+  for (const [x, z] of cand) {
+    const down = new rapier.Ray({ x, y: midY, z }, { x: 0, y: -1, z: 0 });
+    const dh = world.castRay(down, downMax, true, undefined, undefined, undefined, exclude);
+    if (!dh || dh.toi <= 0.001) continue;        // no floor below, or we're in a solid
+    const floorY = midY - dh.toi;
+    const up = new rapier.Ray({ x, y: floorY + 0.1, z }, { x: 0, y: 1, z: 0 });
+    const uh = world.castRay(up, playerH, true, undefined, undefined, undefined, exclude);
+    if (uh && uh.toi < playerH) continue;        // shelf / low ceiling above — not stand-able
+    const d = (x - cx) ** 2 + (z - cz) ** 2;
+    if (d < bestD) {
+      bestD = d;
+      best = { x, y: floorY + stand + 0.05, z };
+    }
+  }
+  return best;
+}
+
+export function RapierProvider({
+  gravity = UNIVERSE_CONFIG.GRAVITY,
+  world: worldDef,
+  spawn,
+  children,
+}: {
+  gravity?: { x: number; y: number; z: number };
+  world?: WorldDef;
+  /** Entryway spawn (body-center). When set it overrides the floor search. */
+  spawn?: { x: number; y: number; z: number } | null;
+  children: React.ReactNode;
+}) {
+  const [rapierReady, setRapierReady] = useState(false);
+  const worldRef = useRef<RAPIER.World | null>(null);
+  const rapierRef = useRef<typeof RAPIER | null>(null);
+  const accRef = useRef(0);
+  const prevRef = useRef<number>(performance.now());
+  const envBodyRef = useRef<RAPIER.RigidBody | null>(null);
+  const envCollidersRef = useRef<RAPIER.Collider[]>([]);
+  const playerBodyRef = useRef<RAPIER.RigidBody | null>(null);
+  const [playerBodyState, setPlayerBodyState] = useState<RAPIER.RigidBody | null>(null);
+  // spawn the player actually teleports to: the entryway override when provided,
+  // else a best-effort floor search from the room collider.
+  const [resolvedSpawn, setResolvedSpawn] = useState<{ x: number; y: number; z: number } | null>(null);
+  // latest entryway override, read inside the async collider-load callback
+  const spawnPropRef = useRef(spawn);
+  spawnPropRef.current = spawn;
+
+  // init once
+  useEffect(() => {
+    let cancelled = false;
+    (async () => {
+      await RAPIER.init();
+      if (cancelled) return;
+      rapierRef.current = RAPIER;
+      worldRef.current = new RAPIER.World(gravity);
+      setRapierReady(true);
+    })();
+    return () => {
+      cancelled = true;
+      // dispose world on unmount
+      if (worldRef.current) {
+        worldRef.current.free();
+        worldRef.current = null;
+      }
+    };
+  }, [gravity.x, gravity.y, gravity.z]);
+
+  // fixed-step stepping loop (piggybacks on r3f’s render loop if present)
+  useEffect(() => {
+    if (!rapierReady) return;
+    let mounted = true;
+    const loop = (t: number) => {
+      if (!mounted) return;
+      const world = worldRef.current;
+      if (world) {
+        const dt = Math.min((t - prevRef.current) / 1000, 0.1);
+        prevRef.current = t;
+        accRef.current += dt;
+        let steps = 0;
+        while (accRef.current >= FIXED_DT && steps < MAX_STEPS) {
+          world.step();
+          accRef.current -= FIXED_DT;
+          steps++;
+        }
+      }
+      requestAnimationFrame(loop);
+    };
+    prevRef.current = performance.now();
+    requestAnimationFrame(loop);
+    return () => { mounted = false; };
+  }, [rapierReady]);
+
+  // Build the environment collider for the CURRENT room from its Marble collider
+  // GLB, baking the same position/quaternion/scale the splat uses (see SplatWorld)
+  // into the trimesh so walls/floor line up with what you see.
+  const colliderUrl = worldDef?.colliderUrl;
+  const isRoomCollider = !!colliderUrl;
+  const posKey = (worldDef?.position ?? [0, 0, 0]).join(',');
+  const quatKey = (worldDef?.quaternion ?? [0, 0, 0, 1]).join(',');
+  const scaleKey = worldDef?.scale ?? 1;
+
+  useEffect(() => {
+    if (!rapierReady || !colliderUrl) return;
+    const world = worldRef.current;
+    const rapier = rapierRef.current;
+    if (!world || !rapier) return;
+    let disposed = false;
+
+    // transform matching the splat's
+    const M = new THREE.Matrix4();
+    const p = worldDef!.position ?? [0, 0, 0];
+    const q = worldDef!.quaternion ?? [0, 0, 0, 1];
+    const s = worldDef!.scale ?? 1;
+    M.compose(
+      new THREE.Vector3(p[0], p[1], p[2]),
+      new THREE.Quaternion(q[0], q[1], q[2], q[3]),
+      new THREE.Vector3(s, s, s),
+    );
+
+    const loader = new GLTFLoader();
+    loader.load(colliderUrl, (gltf) => {
+      if (disposed) return;
+      const body = world.createRigidBody(rapier.RigidBodyDesc.fixed());
+      envBodyRef.current = body;
+      const created: RAPIER.Collider[] = [];
+      const aabb = new THREE.Box3();
+      gltf.scene.updateMatrixWorld(true);
+      gltf.scene.traverse((child: THREE.Object3D) => {
+        const mesh = child as THREE.Mesh;
+        if (!mesh.isMesh || !mesh.geometry) return;
+        mesh.updateWorldMatrix(true, false);
+        const geom = mesh.geometry.clone();
+        geom.applyMatrix4(new THREE.Matrix4().multiplyMatrices(M, mesh.matrixWorld));
+        const posAttr = geom.getAttribute('position') as THREE.BufferAttribute | null;
+        if (!posAttr) return;
+        geom.computeBoundingBox();
+        if (geom.boundingBox) aabb.union(geom.boundingBox);
+        const vertices = new Float32Array(posAttr.array);
+        let indices: Uint32Array;
+        if (geom.index) indices = new Uint32Array(geom.index.array as ArrayLike<number>);
+        else {
+          indices = new Uint32Array(posAttr.count);
+          for (let i = 0; i < posAttr.count; i++) indices[i] = i;
+        }
+        const colDesc = rapier
+          .ColliderDesc.trimesh(vertices, indices)
+          .setRestitution(UNIVERSE_CONFIG.ENVIRONMENT_RESTITUTION);
+        created.push(world.createCollider(colDesc, body));
+      });
+      envCollidersRef.current = created;
+
+      const override = spawnPropRef.current;
+      if (override) {
+        // The room declares an entryway — trust it (this is the marked, known-good
+        // spot, and what fixes feet-below-floor spawns).
+        setResolvedSpawn(override);
+      } else if (isRoomCollider && !aabb.isEmpty()) {
+        // No entryway yet (e.g. a freshly generated, unmarked room): best-effort.
+        const { RADIUS, HALF_HEIGHT } = UNIVERSE_CONFIG.PLAYER;
+        const found = findValidSpawn(world, rapier, aabb, RADIUS, HALF_HEIGHT, playerBodyRef.current);
+        setResolvedSpawn(
+          found ?? {
+            x: (aabb.min.x + aabb.max.x) / 2,
+            y: aabb.min.y + HALF_HEIGHT + RADIUS + 0.4,
+            z: (aabb.min.z + aabb.max.z) / 2,
+          },
+        );
+      } else {
+        setResolvedSpawn(null);
+      }
+      console.log(`✓ Environment collider loaded (${created.length} mesh parts) from ${colliderUrl}`);
+    });
+
+    return () => {
+      disposed = true;
+      const world = worldRef.current;
+      if (!world) return;
+      for (const c of envCollidersRef.current) world.removeCollider(c, true);
+      envCollidersRef.current = [];
+      if (envBodyRef.current) {
+        world.removeRigidBody(envBodyRef.current);
+        envBodyRef.current = null;
+      }
+    };
+  }, [rapierReady, colliderUrl, isRoomCollider, posKey, quatKey, scaleKey, worldDef]);
+
+  // Create player rigid body and capsule collider
+  useEffect(() => {
+    if (!rapierReady) return;
+    const world = worldRef.current;
+    const rapier = rapierRef.current;
+    if (!world || !rapier) return;
+    // Remove existing if any
+    if (playerBodyRef.current) {
+      world.removeRigidBody(playerBodyRef.current);
+      playerBodyRef.current = null;
+      setPlayerBodyState(null);
+    }
+    const { RADIUS, HALF_HEIGHT, START, FRICTION, RESTI, LINEAR_DAMPING } = UNIVERSE_CONFIG.PLAYER;
+    const bodyDesc = rapier
+      .RigidBodyDesc.dynamic()
+      .setTranslation(START[0], START[1], START[2])
+      .lockRotations()
+      .setLinearDamping(LINEAR_DAMPING)
+      .setCcdEnabled(true);
+    const body = world.createRigidBody(bodyDesc);
+    const colDesc = rapier
+      .ColliderDesc.capsule(HALF_HEIGHT, RADIUS)
+      .setFriction(FRICTION)
+      .setRestitution(RESTI);
+    world.createCollider(colDesc, body);
+    playerBodyRef.current = body;
+    setPlayerBodyState(body);
+    return () => {
+      const w = worldRef.current;
+      if (w && playerBodyRef.current) {
+        w.removeRigidBody(playerBodyRef.current);
+        playerBodyRef.current = null;
+        setPlayerBodyState(null);
+      }
+    };
+  }, [rapierReady]);
+
+  // Keep the resolved spawn in sync if the entryway override changes after the
+  // collider has loaded (e.g. arriving through a different entryway).
+  useEffect(() => {
+    if (spawn) setResolvedSpawn(spawn);
+  }, [spawn?.x, spawn?.y, spawn?.z]);
+
+  // Teleport the player to the resolved spawn once both exist.
+  useEffect(() => {
+    if (!playerBodyState || !resolvedSpawn) return;
+    playerBodyState.setTranslation(resolvedSpawn, true);
+    playerBodyState.setLinvel({ x: 0, y: 0, z: 0 }, true);
+  }, [playerBodyState, resolvedSpawn]);
+
+  const value = useMemo<RapierCtx>(
+    () => ({ rapier: rapierRef.current, world: worldRef.current, playerBody: playerBodyState }),
+    [rapierReady, playerBodyState]
+  );
+
+  return <Ctx.Provider value={value}>{children}</Ctx.Provider>;
+}
+
+export function useRapierWorld() {
+  const ctx = useContext(Ctx);
+  if (!ctx.world || !ctx.rapier) throw new Error('Rapier not ready yet.');
+  return ctx as Required<RapierCtx>;
+}

package/engine/src/physics/index.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './RapierProvider';

package/engine/src/physics/types.ts

@@ -0,0 +1,9 @@
+import * as RAPIER from '@dimforge/rapier3d-compat';
+
+export type RapierRigidBody = RAPIER.RigidBody;
+export type RapierCollider = RAPIER.Collider;
+export type RapierWorld = RAPIER.World;
+export type RapierRigidBodyDesc = RAPIER.RigidBodyDesc;
+export type RapierColliderDesc = RAPIER.ColliderDesc;
+export type RapierShape = RAPIER.Shape;
+export type RapierShapeType = RAPIER.ShapeType;

package/engine/src/providers/audio.tsx

@@ -0,0 +1,215 @@
+// providers/audio.tsx
+'use client';
+
+import React, { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from 'react';
+import { AUDIO_CONFIG } from '@/config/audio';
+
+type AudioAPI = {
+  /** true if we have an AudioContext */
+  ready: boolean;
+  /** Must be called in a user gesture (Click-to-Play). Safe to call multiple times. */
+  init: () => Promise<void>;
+  muted: boolean;
+  setMuted: (m: boolean) => void;
+
+  /** Set/replace the looping background music for the app (null = stop). Safe to call anytime. */
+  setMusic: (url: string | null, opts?: { fadeMs?: number; loop?: boolean }) => Promise<void>;
+  /** Stop background music (with an optional quick fade). */
+  stop: (fadeMs?: number) => void;
+
+  isLoading: boolean;
+  currentUrl: string | null;
+};
+
+const AudioCtx = createContext<AudioAPI | null>(null);
+const DEFAULT_VOL = AUDIO_CONFIG?.MUSIC_VOLUME ?? 0.15;
+
+export function AudioProvider({ children }: { children: React.ReactNode }) {
+  // Core nodes
+  const ctxRef = useRef<AudioContext | null>(null);
+  const masterGainRef = useRef<GainNode | null>(null);
+
+  // Current music chain
+  const musicSrcRef = useRef<AudioBufferSourceNode | null>(null);
+  const musicGainRef = useRef<GainNode | null>(null);
+
+  // State
+  const [muted, setMutedState] = useState(false);
+  const [isLoading, setIsLoading] = useState(false);
+  const [currentUrl, setCurrentUrl] = useState<string | null>(null);
+
+  // Support calling setMusic() before init()
+  const wantedUrlRef = useRef<string | null>(null);
+
+  // Cancel/ignore stale async decodes
+  const requestIdRef = useRef(0);
+
+  // Buffer cache
+  const cacheRef = useRef(new Map<string, AudioBuffer>());
+
+  const ready = !!ctxRef.current;
+
+  const ensureNodes = useCallback(async () => {
+    if (ctxRef.current) {
+      if (ctxRef.current.state === 'suspended') await ctxRef.current.resume();
+      return;
+    }
+
+    const AC = (window as typeof window & { AudioContext?: typeof AudioContext; webkitAudioContext?: typeof AudioContext }).AudioContext ||
+               (window as typeof window & { AudioContext?: typeof AudioContext; webkitAudioContext?: typeof AudioContext }).webkitAudioContext;
+    const ac: AudioContext = new AC();
+
+    const master = ac.createGain();
+    master.gain.setValueAtTime(muted ? 0 : 1, ac.currentTime);
+    master.connect(ac.destination);
+
+    ctxRef.current = ac;
+    masterGainRef.current = master;
+
+    // If there was a queued music URL set before init(), apply it now
+    if (wantedUrlRef.current) {
+      // fire and forget (no await)
+      _switchTo(wantedUrlRef.current).catch(() => {});
+    }
+  }, [muted]);
+
+  const init = useCallback(async () => {
+    await ensureNodes();
+  }, [ensureNodes]);
+
+  const setMuted = useCallback((m: boolean) => {
+    setMutedState(m);
+    const ac = ctxRef.current;
+    const master = masterGainRef.current;
+    if (ac && master) {
+      const now = ac.currentTime;
+      master.gain.cancelScheduledValues(now);
+      master.gain.linearRampToValueAtTime(m ? 0 : 1, now + 0.05);
+    }
+  }, []);
+
+  const loadBuffer = useCallback(async (url: string) => {
+    const cached = cacheRef.current.get(url);
+    if (cached) return cached;
+    const ac = ctxRef.current;
+    if (!ac) throw new Error('Audio not initialized');
+    const res = await fetch(url);
+    const arr = await res.arrayBuffer();
+    const buf = await ac.decodeAudioData(arr);
+    cacheRef.current.set(url, buf);
+    return buf;
+  }, []);
+
+  const stop = useCallback((fadeMs: number = 100) => {
+    const ac = ctxRef.current;
+    if (!ac) return;
+    const src = musicSrcRef.current;
+    const gain = musicGainRef.current;
+    if (!src || !gain) return;
+
+    const t = ac.currentTime;
+    const fade = Math.max(0, fadeMs) / 1000;
+
+    gain.gain.cancelScheduledValues(t);
+    gain.gain.setValueAtTime(gain.gain.value, t);
+    gain.gain.linearRampToValueAtTime(0, t + fade);
+
+    // Slight delay before stopping to avoid clicks
+    try { src.stop(t + fade + 0.01); } catch {}
+
+    musicSrcRef.current = null;
+    musicGainRef.current = null;
+    setCurrentUrl(null);
+  }, []);
+
+  // Internal: switch to a new URL (atomically)
+  const _switchTo = useCallback(async (url: string, opts?: { fadeMs?: number; loop?: boolean }) => {
+    const ac = ctxRef.current;
+    if (!ac) {
+      // queue until init()
+      wantedUrlRef.current = url;
+      return;
+    }
+
+    const myId = ++requestIdRef.current;
+    setIsLoading(true);
+
+    let buffer: AudioBuffer | null = null;
+    try {
+      buffer = await loadBuffer(url);
+    } catch (e) {
+      if (myId !== requestIdRef.current) return; // superseded
+      setIsLoading(false);
+      console.error('Audio load failed:', e);
+      return;
+    }
+    if (myId !== requestIdRef.current) return; // superseded while decoding
+
+    // Stop any current track (short fade)
+    if (musicSrcRef.current) stop(opts?.fadeMs ?? 120);
+
+    // Build new chain: source -> musicGain -> masterGain -> destination
+    const src = ac.createBufferSource();
+    src.buffer = buffer!;
+    src.loop = opts?.loop ?? true;
+
+    const mg = ac.createGain();
+    mg.gain.setValueAtTime(0, ac.currentTime); // fade in
+    src.connect(mg);
+    mg.connect(masterGainRef.current!);
+
+    src.start();
+
+    musicSrcRef.current = src;
+    musicGainRef.current = mg;
+    setCurrentUrl(url);
+
+    // fade in to content volume (master handles mute)
+    const t = ac.currentTime;
+    mg.gain.linearRampToValueAtTime(DEFAULT_VOL, t + (opts?.fadeMs ?? 120) / 1000);
+
+    setIsLoading(false);
+  }, [loadBuffer, stop]);
+
+  const setMusic = useCallback(async (url: string | null, opts?: { fadeMs?: number; loop?: boolean }) => {
+    wantedUrlRef.current = url;
+    if (!url) {
+      stop(opts?.fadeMs ?? 120);
+      return;
+    }
+    // If not ready yet, we just record wantedUrl; _switchTo runs after init()
+    if (!ctxRef.current) return;
+    await _switchTo(url, opts);
+  }, [_switchTo, stop]);
+
+  // Resume audio when tab becomes visible (iOS/Safari behavior)
+  useEffect(() => {
+    const onVis = () => {
+      const ac = ctxRef.current;
+      if (document.visibilityState === 'visible' && ac && ac.state !== 'running') {
+        ac.resume().catch(() => {});
+      }
+    };
+    document.addEventListener('visibilitychange', onVis);
+    return () => document.removeEventListener('visibilitychange', onVis);
+  }, []);
+
+  const api = useMemo<AudioAPI>(() => ({
+    ready,
+    init,
+    muted,
+    setMuted,
+    setMusic,
+    stop,
+    isLoading,
+    currentUrl,
+  }), [ready, init, muted, setMuted, setMusic, stop, isLoading, currentUrl]);
+
+  return <AudioCtx.Provider value={api}>{children}</AudioCtx.Provider>;
+}
+
+export function useAudio(): AudioAPI {
+  const ctx = useContext(AudioCtx);
+  if (!ctx) throw new Error('useAudio must be used within AudioProvider');
+  return ctx;
+}