Skip to content

Capture iPhone LiDAR and photos, reconstruct editable Three.js rooms, and explore them in a browser.

TypeScript
29.1 KB
Raw Blame
import { appURL } from './asset-base';
import { collectInventory, showKnolling, stopKnolling } from './knolling';
import { showLayout } from './layout';
import * as THREE from 'three';
import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
import { PointerLockControls } from 'three/addons/controls/PointerLockControls.js';
import { ROOMS, roomById, type BuiltRoom } from '../../../demos/index';
import type { RoomModule } from '../../../packages/room-runtime/types';
import { configureRenderer, disposeMirror } from '../../../packages/room-runtime/lighting';
import { disposeObjects } from '../../../packages/room-runtime/dispose';
import { updateCameraDepth } from '../../../packages/room-runtime/camera-depth';
import { setMaxAnisotropy } from '../../../packages/room-runtime/materials';
import { applyRoomRendering, createPipeline, precompileRoomRendering } from '../../../packages/room-runtime/render';

document.querySelector('.play-link')!.addEventListener('click', () => { location.href = appURL('play.html') + location.search; });

const EYE_HEIGHT = 1.6;
const WALK_SPEED = 1.5; // m/s
const RUN_SPEED = 3.5;

const canvas = document.querySelector<HTMLCanvasElement>('#scene')!;
const loaderEl = document.querySelector<HTMLDivElement>('#loader')!;
const hud = document.querySelector<HTMLDivElement>('#hud')!;
const viewport = document.querySelector<HTMLElement>('#viewport')!;
const controlsToggle = document.querySelector<HTMLButtonElement>('#controls-toggle')!;
function toggleControls(open: boolean) {
  document.body.classList.toggle('controls-open', open);
  controlsToggle.setAttribute('aria-expanded', String(open));
}
controlsToggle.addEventListener('click', () => toggleControls(controlsToggle.getAttribute('aria-expanded') !== 'true'));
document.addEventListener('keydown', event => {
  if (event.key === 'Escape' && document.body.classList.contains('controls-open')) {
    toggleControls(false);
    controlsToggle.focus();
  }
});

const renderer = new THREE.WebGLRenderer({ canvas, antialias: true });
renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
renderer.setSize(viewport.clientWidth, viewport.clientHeight);
setMaxAnisotropy(renderer.capabilities.getMaxAnisotropy());

const scene = new THREE.Scene();
scene.background = new THREE.Color('#111');
configureRenderer(renderer, scene);

const camera = new THREE.PerspectiveCamera(55, viewport.clientWidth / viewport.clientHeight, 0.05, 100);
const orbit = new OrbitControls(camera, canvas);
orbit.enableDamping = true;
orbit.maxDistance = 30;
orbit.minDistance = 0.25;
orbit.maxPolarAngle = Math.PI / 2 + 0.12;
orbit.zoomToCursor = true;
// Keep a little smoothing without the long glide that delays full-resolution rendering.
orbit.dampingFactor = 0.35;
orbit.rotateSpeed = 0.7;
orbit.screenSpacePanning = true;
canvas.tabIndex = 0;
orbit.listenToKeyEvents(canvas);
canvas.setAttribute('aria-label', 'Interactive room. Drag to orbit, scroll to zoom, double-click to focus. Home resets the view.');
const walk = new PointerLockControls(camera, canvas);
const pipeline = createPipeline(renderer, scene, camera);
let dirty = true;
let pendingFrame = 0;
function requestFrame() {
  if (!pendingFrame && !document.hidden) pendingFrame = requestAnimationFrame(renderFrame);
}
const invalidate = () => { dirty = true; requestFrame(); };
THREE.DefaultLoadingManager.onLoad = invalidate;
orbit.addEventListener('change', invalidate);
walk.addEventListener('change', invalidate);
// Preserve full resolution for a settled view; spend fewer pixels while navigating.
let movingRatio = Math.min(window.devicePixelRatio, 1);
let lastMotion = -Infinity;
let slowFrames = 0;
let fastFrames = 0;
let lastFrame = 0;
const renderedPosition = new THREE.Vector3(Infinity, Infinity, Infinity);
const renderedRotation = new THREE.Quaternion();
function resolution(ratio: number) {
  if (renderer.getPixelRatio() === ratio) return;
  renderer.setPixelRatio(ratio);
  pipeline.setPixelRatio(ratio);
  invalidate();
}


// --- Rooms -----------------------------------------------------------------

const walkButton = hud.querySelector<HTMLButtonElement>('[data-mode=walk]')!;
if (!canvas.requestPointerLock) {
  walkButton.disabled = true;
  walkButton.title = 'Walking requires a browser with mouse pointer lock.';
}

const roomSelect = document.querySelector<HTMLDivElement>('[data-group="room"]')!;
for (const r of ROOMS) {
  const b = document.createElement('button');
  b.textContent = r.label;
  b.dataset.room = r.id;
  b.addEventListener('click', () => loadRoom(r.id));
  roomSelect.append(b);
}

const roomBounds = new THREE.Box3();
let room: BuiltRoom | undefined;
let roomId = '';
let activeRoomId = '';
let roomRequest = 0;
const statusEl = document.querySelector<HTMLOutputElement>('#viewer-status')!;
const layoutHost = document.querySelector<HTMLElement>('#layout')!;
const knollingHost = document.querySelector<HTMLElement>('#knolling')!;
let reference: THREE.Object3D | undefined;
let referenceLoading: Promise<THREE.Object3D> | undefined;
let referenceEpoch = 0;
const built = new Map<string, Promise<BuiltRoom>>();
const cachedRooms = new Map<string, BuiltRoom>();
let renderedRoom: BuiltRoom | undefined;
let preparing: Promise<void> | undefined;
async function prepareRendering() {
  if (preparing) await preparing;
  if (room && renderedRoom !== room) {
    const owner = room;
    preparing = (async () => {
    // A cached room may still have its previous camera's cutaway applied.
    owner.walls.forEach(w => { w.group.visible = true; });
    owner.ceiling.forEach(c => { c.visible = true; });
    statusEl.textContent = 'Preparing room lighting…';
    pipeline.setSceneRenderer();
    await precompileRoomRendering(renderer, scene, owner, camera);
    if (room !== owner) return;
    applyRoomRendering(renderer, scene, owner, pipeline);
    renderedRoom = owner;
    statusEl.textContent = roomById(roomId).label;
    })();
    try { await preparing; } finally { preparing = undefined; invalidate(); }
  }
}

async function loadRoom(id: string, updated?: RoomModule) {
  const mod = updated ?? roomById(id);
  if (mod.id === roomId && !updated) return;
  if (updated) { saveLiveView(); built.delete(mod.id); }
  if (mode === 'walk') setMode('orbit');
  roomId = mod.id;
  const request = ++roomRequest;
  if (!room) loaderEl.classList.remove('done');
  loaderEl.querySelector<HTMLElement>('.fill')!.style.width = '0%';
  loaderEl.querySelector('.pct')!.textContent = '';
  hud.hidden = false;
  statusEl.textContent = `${updated ? 'Updating' : 'Loading'} ${mod.label}…`;
  let next: BuiltRoom;
  try {
    if (!built.has(mod.id)) built.set(mod.id, mod.build());
    next = await built.get(mod.id)!;
  } catch (error) {
    built.delete(mod.id);
    if (request === roomRequest) {
      roomId = room ? activeRoomId : '';
      loaderEl.classList.add('done');
      hud.hidden = false;
      statusEl.textContent = `Could not load ${mod.label}. Select the room to retry.`;
    }
    console.error(error);
    return;
  }
  if (request !== roomRequest) return; // switched again while building

  const replaced = updated ? cachedRooms.get(mod.id) : undefined;
  const oldReference = reference;
  cachedRooms.set(mod.id, next);
  const releaseReplaced = () => {
    const retained: THREE.Object3D[] = [...cachedRooms.values()].flatMap(r => [r.group, r.lights]);
    if (reference) retained.push(reference);
    if (replaced && replaced !== next) {
      if (replaced.environment.mirror !== next.environment.mirror) disposeMirror(replaced.environment.mirror);
      disposeObjects([replaced.group, replaced.lights], retained);
    }
    if (oldReference) disposeObjects([oldReference], retained);
  };
  if (room) scene.remove(room.group, room.lights);
  if (reference) scene.remove(reference);
  reference = undefined;
  referenceLoading = undefined;
  referenceEpoch++;
  room = next;
  activeRoomId = mod.id;
  transition = undefined;
  movingRatio = Math.min(window.devicePixelRatio, 1);
  slowFrames = fastFrames = 0;
  scene.add(room.group, room.lights);
  roomBounds.setFromObject(room.group);
  // The assembled house currently has no combined scan reference.
  hud.querySelectorAll<HTMLButtonElement>('[data-source]').forEach(button => {
    button.disabled = room?.referenceAvailable === false && ['scan', 'overlay'].includes(button.dataset.source ?? '');
  });
  if (room?.referenceAvailable === false && (source === 'scan' || source === 'overlay')) source = 'model';
  orbit.maxDistance = mod.id === 'house' ? 80 : 30;
  collectInventory(room);
  room.optimize?.({ static: true });
  if (mode !== 'layout' && mode !== 'knolling' && !['layout', 'knolling'].includes(new URLSearchParams(location.search).get('view') ?? '')) await prepareRendering();
  if (request !== roomRequest) { releaseReplaced(); return; }

  if (room.layout) showLayout(layoutHost, room.layout, mod.label);
  hud.querySelector<HTMLButtonElement>('[data-mode=layout]')!.disabled = !room.layout;
  if (mode === 'layout' && !room.layout) setMode('orbit');
  clearDamping();
  camera.position.copy(homePosition());
  orbit.target.set(...room.camera.target);
  restoreLiveView(mod.id);
  orbit.update();
  activate('room', mod.id);
  statusEl.textContent = mod.label;
  const url = new URL(location.href);
  if (url.searchParams.get('room') !== mod.id) url.searchParams.delete('camera');
  url.searchParams.set('room', mod.id);
  history.replaceState(null, '', url);
  loaderEl.classList.add('done');
  hud.hidden = false;
  await setSource(source, true);
  // HMR can rebuild hundreds of meshes repeatedly during an authoring session.
  // Release the superseded GPU allocations after the replacement is compiled.
  releaseReplaced();
  if (mode === 'knolling') void showKnolling(knollingHost, room, mod.label);
  invalidate();
}

function ensureReference() {
  const owner = room!, epoch = referenceEpoch;
  referenceLoading ??= owner.loadReference((p) => { if (room === owner && referenceEpoch === epoch && (source === 'scan' || source === 'overlay')) setProgress(p); }).then((r) => {
    // A reference may finish after the user returns to Rebuilt or selects another room.
    if (room === owner && referenceEpoch === epoch) {
      reference = r;
      r.visible = (source === 'scan' || source === 'overlay');
      scene.add(r);
      loaderEl.classList.add('done');
    }
    return r;
  }).catch(error => {
    if (room === owner && referenceEpoch === epoch) referenceLoading = undefined;
    throw error;
  });
  return referenceLoading;
}

function setProgress(p: number) {
  loaderEl.classList.remove('done');
  loaderEl.querySelector<HTMLDivElement>('.fill')!.style.width = `${Math.round(p * 100)}%`;
  loaderEl.querySelector('.pct')!.textContent = `${Math.round(p * 100)}%`;
}

// --- Source: rebuilt model, raw scan/layout, or both overlaid ----------------------

type Source = 'model' | 'scan' | 'overlay' | 'wireframe';
let source: Source = 'model';
// A render-only override keeps original textures/materials intact, including cached rooms.
const wireframeMaterial = new THREE.MeshBasicMaterial({
  color: '#9de2f0', wireframe: true, toneMapped: false, side: THREE.DoubleSide,
});
function renderWireframe() {
  const previous = scene.overrideMaterial;
  const shadows = renderer.shadowMap.enabled;
  try {
    scene.overrideMaterial = wireframeMaterial;
    renderer.shadowMap.enabled = false;
    renderer.setRenderTarget(null);
    // Draw the complete tree directly, including all house rooms, without AO/bloom.
    renderer.render(scene, camera);
  } finally {
    scene.overrideMaterial = previous;
    renderer.shadowMap.enabled = shadows;
  }
}


async function setSource(next: Source, force = false) {
  if (next === source && !force) return;
  source = next;
  if (!room) return;
  const owner = room, epoch = referenceEpoch;
  if (next === 'scan' || next === 'overlay') {
    try { await ensureReference(); }
    catch (error) {
      if (room === owner && referenceEpoch === epoch && source === next) {
        referenceLoading = undefined;
        loaderEl.classList.add('done');
        statusEl.textContent = 'Reference could not load. Select Scan or Overlay to retry.';
        await setSource('model', true);
      }
      console.error(error);
      return;
    }
  } else loaderEl.classList.add('done');
  if (source !== next || room !== owner || referenceEpoch !== epoch) return; // changed while loading
  room.group.visible = next !== 'scan';
  room.lights.visible = room.group.visible;
  if (reference) {
    reference.visible = next === 'scan' || next === 'overlay';
    if (room.referenceKind === 'scan') {
      reference.traverse((obj) => {
        if (!(obj instanceof THREE.Mesh)) return;
        const mat = obj.material as THREE.MeshBasicMaterial;
        mat.transparent = next === 'overlay';
        mat.opacity = next === 'overlay' ? 0.45 : 1;
        mat.depthWrite = next !== 'overlay';
        mat.needsUpdate = true;
      });
    }
  }
  activate('source', next);
  invalidate();
}

// --- Navigation modes ------------------------------------------------------

type Mode = 'orbit' | 'walk' | 'layout' | 'knolling';
let mode: Mode = 'orbit';
const savedOrbit = { position: new THREE.Vector3(), target: new THREE.Vector3() };

function setMode(next: Mode) {
  if (next === mode || !room || (next === 'layout' && !room.layout)) return;
  transition = undefined;
  keys.clear();
  walkVelocity.set(0, 0);
  clearDamping();
  if (next === 'walk') toggleControls(false);
  const previous = mode;
  mode = next;
  layoutHost.hidden = mode !== 'layout';
  canvas.hidden = mode === 'layout' || mode === 'knolling';
  knollingHost.hidden = mode !== 'knolling';
  document.body.classList.toggle('knolling-mode', mode === 'knolling');
  if (mode === 'knolling') void showKnolling(knollingHost, room, roomById(roomId).label);
  else stopKnolling();
  document.body.classList.toggle('layout-mode', mode === 'layout');
  hud.querySelector<HTMLElement>('[data-group=source]')!.hidden = mode === 'layout' || mode === 'knolling';
  const url = new URL(location.href);
  url.searchParams.set('view', mode);
  history.replaceState(null, '', url);

  if (mode === 'walk') {
    savedOrbit.position.copy(camera.position);
    savedOrbit.target.copy(orbit.target);
    orbit.enabled = false;
    camera.position.set(...room.camera.walk);
    camera.lookAt(...room.camera.walkLook);
    canvas.focus({ preventScroll: true });
    walk.lock();
  } else {
    if (walk.isLocked) walk.unlock();
    if (previous === 'walk') {
      camera.position.copy(savedOrbit.position);
      orbit.target.copy(savedOrbit.target);
    }
    orbit.enabled = true;
    orbit.update();
  }

  if (mode !== 'layout' && mode !== 'knolling') void prepareRendering();
  navigation.hidden = mode !== 'orbit';
  activate('mode', mode);
  invalidate();
  hud.querySelectorAll<HTMLElement>('.help').forEach((el) => {
    el.hidden = el.dataset.for !== mode;
  });
}

function activate(group: 'source' | 'mode' | 'room', value: string) {
  hud.querySelectorAll<HTMLButtonElement>(`[data-group="${group}"] button`).forEach((btn) => {
    btn.classList.toggle('active', btn.dataset[group] === value);
    btn.setAttribute('aria-pressed', String(btn.dataset[group] === value));
  });
}

hud.querySelectorAll<HTMLButtonElement>('button[data-mode]').forEach((btn) => {
  btn.addEventListener('click', () => setMode(btn.dataset.mode as Mode));
});
hud.querySelectorAll<HTMLButtonElement>('button[data-source]').forEach((btn) => {
  btn.addEventListener('click', () => setSource(btn.dataset.source as Source));
});

// Esc releases pointer lock; treat that as leaving walk mode
walk.addEventListener('unlock', () => { if (mode === 'walk') setMode('orbit'); });
// Browsers refuse re-locking right after an Esc, so fall back instead of getting stuck
document.addEventListener('pointerlockerror', () => setMode('orbit'));

// --- Dollhouse cutaway: hide walls between the camera and the room ---------

const mid = new THREE.Vector3();
const toCam = new THREE.Vector3();
function updateCutaway() {
  if (!room) return;
  const inside = mode === 'walk';
  for (const { def, group } of room.walls) {
    mid.copy(def.origin).addScaledVector(def.u, def.length / 2);
    group.visible = inside || toCam.copy(camera.position).sub(mid).dot(def.n) > 0;
  }
  for (const c of room.ceiling) c.visible = inside || camera.position.y < room.wallTop;
}

// --- Walk movement ---------------------------------------------------------

const keys = new Set<string>();
window.addEventListener('keydown', (e) => {
  if (e.target instanceof HTMLElement && (e.target.matches('input, select, textarea, button') || e.target.isContentEditable)) return;
  if (e.metaKey || e.ctrlKey || e.altKey) return;
  if (mode === 'walk' && ['KeyW', 'KeyA', 'KeyS', 'KeyD', 'ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight', 'ShiftLeft', 'ShiftRight'].includes(e.code)) {
    e.preventDefault();
    keys.add(e.code);
    requestFrame();
  }
  if (mode !== 'orbit') return;
  const views: Record<string, View> = { Home: 'home', Digit1: 'home', Digit2: 'top', Digit3: 'front', Digit4: 'side' };
  if (views[e.code]) { e.preventDefault(); preset(views[e.code]); }
  if (e.code === 'Equal' || e.code === 'Minus') { e.preventDefault(); zoom(e.code === 'Equal' ? 0.8 : 1.25); }
});
window.addEventListener('keyup', (e) => keys.delete(e.code));
window.addEventListener('blur', () => { keys.clear(); walkVelocity.set(0, 0); });

const before = new THREE.Vector3();
const movedPosition = new THREE.Vector3();
const walkVelocity = new THREE.Vector2();
const walkDirection = new THREE.Vector2();
function updateWalk(dt: number) {
  const forward = Number(keys.has('KeyW') || keys.has('ArrowUp')) - Number(keys.has('KeyS') || keys.has('ArrowDown'));
  const right = Number(keys.has('KeyD') || keys.has('ArrowRight')) - Number(keys.has('KeyA') || keys.has('ArrowLeft'));
  if (!walk.isLocked) { walkVelocity.set(0, 0); return; }

  const speed = keys.has('ShiftLeft') || keys.has('ShiftRight') ? RUN_SPEED : WALK_SPEED;
  walkDirection.set(right, forward).normalize().multiplyScalar(speed);
  walkVelocity.lerp(walkDirection, 1 - Math.exp(-14 * dt));
  if (walkVelocity.lengthSq() < 0.0001) { walkVelocity.set(0, 0); return; }
  before.copy(camera.position);
  walk.moveForward(walkVelocity.y * dt);
  walk.moveRight(walkVelocity.x * dt);
  // No collision with furniture, but stay inside the room (slide along walls)
  if (!room!.walkable(camera.position.x, camera.position.z)) {
    const moved = movedPosition.copy(camera.position);
    camera.position.set(moved.x, before.y, before.z);
    if (!room!.walkable(camera.position.x, camera.position.z)) {
      camera.position.set(before.x, before.y, moved.z);
      if (!room!.walkable(camera.position.x, camera.position.z)) camera.position.copy(before);
    }
  }
  camera.position.y = EYE_HEIGHT;
}

// --- Camera navigation -----------------------------------------------------

type View = 'home' | 'top' | 'front' | 'side';
const navigation = document.querySelector<HTMLElement>('#navigation')!;
const reducedMotion = matchMedia('(prefers-reduced-motion: reduce)');
let transition: { start: number; from: THREE.Vector3; to: THREE.Vector3; fromTarget: THREE.Vector3; toTarget: THREE.Vector3 } | undefined;
function clearDamping() {
  const damping = orbit.enableDamping;
  orbit.enableDamping = false;
  orbit.update();
  orbit.enableDamping = damping;
}
function moveCamera(position: THREE.Vector3, target: THREE.Vector3) {
  clearDamping();
  transition = { start: performance.now(), from: camera.position.clone(), to: position,
    fromTarget: orbit.target.clone(), toTarget: target };
  invalidate();
}
function homePosition() {
  const target = new THREE.Vector3(...room!.camera.target);
  return new THREE.Vector3(...room!.camera.orbit).sub(target).multiplyScalar(Math.max(1, 1.18 / camera.aspect)).add(target);
}
function preset(view: View) {
  if (!room || mode !== 'orbit') return;
  const target = new THREE.Vector3(...room.camera.target);
  const home = homePosition();
  const distance = home.distanceTo(target);
  const directions = { top: new THREE.Vector3(0, 1, 0.001), front: new THREE.Vector3(0, 0.18, 1), side: new THREE.Vector3(1, 0.18, 0) };
  moveCamera(view === 'home' ? home : directions[view].normalize().multiplyScalar(distance).add(target), target);
}
function zoom(factor: number) {
  if (mode !== 'orbit') return;
  const offset = camera.position.clone().sub(orbit.target);
  offset.setLength(THREE.MathUtils.clamp(offset.length() * factor, orbit.minDistance, orbit.maxDistance));
  moveCamera(orbit.target.clone().add(offset), orbit.target.clone());
}
navigation.querySelectorAll<HTMLButtonElement>('[data-view]').forEach(button => {
  button.addEventListener('click', () => preset(button.dataset.view as View));
});
navigation.querySelector<HTMLButtonElement>('[data-zoom=in]')!.addEventListener('click', () => zoom(0.8));
navigation.querySelector<HTMLButtonElement>('[data-zoom=out]')!.addEventListener('click', () => zoom(1.25));
orbit.addEventListener('start', () => { transition = undefined; lastMotion = performance.now(); requestFrame(); });
canvas.addEventListener('pointerdown', () => canvas.focus({ preventScroll: true }));
const raycaster = new THREE.Raycaster();
canvas.addEventListener('dblclick', event => {
  if (!room || mode !== 'orbit') return;
  const rect = canvas.getBoundingClientRect();
  raycaster.setFromCamera(new THREE.Vector2((event.clientX - rect.left) / rect.width * 2 - 1, -(event.clientY - rect.top) / rect.height * 2 + 1), camera);
  const meshes: THREE.Object3D[] = [];
  for (const root of [room.group, reference]) root?.traverseVisible(o => { if ((o as THREE.Mesh).isMesh) meshes.push(o); });
  const hit = raycaster.intersectObjects(meshes, false)[0];
  if (!hit) return;
  const offset = camera.position.clone().sub(hit.point);
  offset.setLength(THREE.MathUtils.clamp(offset.length() * 0.65, 0.6, orbit.maxDistance));
  moveCamera(hit.point.clone().add(offset), hit.point.clone());
});

type Quality = 'auto' | 'detail' | 'fast';
const qualitySelect = document.querySelector<HTMLSelectElement>('#quality')!;
let quality: Quality = 'auto';
qualitySelect.addEventListener('change', () => {
  quality = qualitySelect.value as Quality;
  movingRatio = Math.min(devicePixelRatio, 1);
  slowFrames = fastFrames = 0;
  invalidate();
});

// Portable camera bookmarks include the orbit target: position alone loses the view angle.
const cameraCoordinates = document.querySelector<HTMLOutputElement>('#camera-coordinates')!;
const cameraLink = document.querySelector<HTMLInputElement>('#camera-link')!;
const cameraCopyStatus = document.querySelector<HTMLElement>('#camera-copy-status')!;
function updateCameraHelper() {
  if (!room || mode !== 'orbit') return;
  const values = [...camera.position.toArray(), ...orbit.target.toArray(), camera.fov].map(n => Number(n.toFixed(5)));
  const coordinates = `Position (m)\n${values.slice(0,3).join(', ')}\nLooking at (m)\n${values.slice(3,6).join(', ')}`;
  if (cameraCoordinates.textContent !== coordinates) cameraCoordinates.textContent = coordinates;
  const url = new URL(location.href);
  url.searchParams.set('room', activeRoomId);
  url.searchParams.set('view', 'orbit');
  url.searchParams.set('camera', values.join(','));
  if (cameraLink.value !== url.href) {
    cameraLink.value = url.href;
    cameraCopyStatus.textContent = '';
  }
}
document.querySelector('#copy-camera-link')!.addEventListener('click', async () => {
  updateCameraHelper();
  try {
    await navigator.clipboard.writeText(cameraLink.value);
    cameraCopyStatus.textContent = 'View link copied';
  } catch {
    cameraLink.focus(); cameraLink.select();
    cameraCopyStatus.textContent = 'Copy the selected link to save this view.';
  }
});
function restoreCameraLink() {
  const encoded = new URLSearchParams(location.search).get('camera');
  if (!encoded) return;
  const values = encoded.split(',').map(Number);
  if (values.length !== 7 || values.some(n => !Number.isFinite(n) || Math.abs(n) > 1000)
    || values[6] < 10 || values[6] > 120) return;
  const position = new THREE.Vector3(...values.slice(0,3));
  const target = new THREE.Vector3(...values.slice(3,6));
  if (position.distanceTo(target) < orbit.minDistance || position.distanceTo(target) > orbit.maxDistance) return;
  clearDamping();
  camera.position.copy(position); orbit.target.copy(target);
  camera.fov = values[6]; camera.updateProjectionMatrix(); orbit.update(); invalidate();
}

// Keep the recorded angle across development rebuilds. Each room has its own
// session-only camera; a broken/stale entry must never prevent a room loading.
function saveLiveView() {
  if (!import.meta.env.DEV || !room || mode !== 'orbit' ) return;
  try {
    sessionStorage.setItem(`room-viewer:live:${activeRoomId}`, JSON.stringify({
      position: camera.position.toArray(), target: orbit.target.toArray(), quality,
    }));
  } catch { /* Private browsing can disable storage. */ }
}
function restoreLiveView(id: string) {
  if (!import.meta.env.DEV) return;
  try {
    const saved = JSON.parse(sessionStorage.getItem(`room-viewer:live:${id}`) ?? 'null');
    const valid = (v: unknown): v is number[] => Array.isArray(v) && v.length === 3
      && v.every(n => typeof n === 'number' && Number.isFinite(n) && Math.abs(n) < 1000);
    if (!valid(saved?.position) || !valid(saved?.target)) return;
    camera.position.fromArray(saved.position);
    orbit.target.fromArray(saved.target);
    if (['auto', 'detail', 'fast'].includes(saved.quality)) {
      quality = saved.quality;
      qualitySelect.value = quality;
    }
  } catch { /* Ignore malformed state. */ }
}
if (import.meta.hot) import.meta.hot.on('vite:beforeFullReload', saveLiveView);
window.addEventListener('pagehide', saveLiveView);

// --- Render only while something changes ----------------------------------

let previousTime = 0;
let renderedFrames = 0;
function renderFrame(time: number) {
  pendingFrame = 0;
  const dt = previousTime ? Math.min((time - previousTime) / 1000, 0.05) : 1 / 60;
  previousTime = time;
  if (mode === 'layout' || mode === 'knolling' || document.hidden || !room || preparing) { lastFrame = 0; previousTime = 0; return; }
  else if (mode === 'walk') updateWalk(dt);
  else if (transition) {
    const progress = reducedMotion.matches ? 1 : Math.min(1, (time - transition.start) / 350);
    const eased = 1 - Math.pow(1 - progress, 3);
    camera.position.lerpVectors(transition.from, transition.to, eased);
    orbit.target.lerpVectors(transition.fromTarget, transition.toTarget, eased);
    orbit.update();
    if (progress === 1) transition = undefined;
  } else orbit.update();
  updateCameraHelper();
  const moved = renderedPosition.distanceToSquared(camera.position) > 1e-10
    || 1 - Math.abs(renderedRotation.dot(camera.quaternion)) > 1e-10;
  if (moved) {
    lastMotion = time;
    // Only consecutive moving frames are useful; startup and idle aren't GPU pressure.
    const elapsed = lastFrame ? time - lastFrame : 0;
    slowFrames = elapsed > 24 && elapsed < 150 ? slowFrames + 1 : Math.max(0, slowFrames - 1);
    fastFrames = elapsed > 0 && elapsed < 19 ? fastFrames + 1 : 0;
    if (slowFrames >= 12) { movingRatio = Math.max(Math.min(devicePixelRatio, 0.65), movingRatio - 0.15); slowFrames = 0; }
    if (fastFrames >= 90) { movingRatio = Math.min(devicePixelRatio, 1, movingRatio + 0.1); fastFrames = 0; }
  }
  const moving = time - lastMotion < 80;
  const navigating = (quality === 'fast' || (quality === 'auto' && moving));
  resolution(navigating ? movingRatio : Math.min(devicePixelRatio, 2));
  // Auto changes pixel count while retaining the room's contact shading and glow.
  const effects = source !== 'scan' && (quality !== 'fast');
  if (pipeline.ao !== effects) { pipeline.ao = effects; dirty = true; }
  if (dirty || moved) {
    updateCutaway();
    updateCameraDepth(camera, roomBounds, mode === 'orbit' && (source === 'model' || source === 'wireframe'));
    if (source === 'wireframe') renderWireframe();
    else pipeline.render();
    renderedFrames++;
    renderedPosition.copy(camera.position);
    renderedRotation.copy(camera.quaternion);
    dirty = false;
  }
  lastFrame = moving ? time : 0;
  if (moving || transition || (mode === 'walk' && walk.isLocked && walkVelocity.lengthSq() > 0)) requestFrame();
  else { previousTime = 0; saveLiveView(); }
}

document.addEventListener('visibilitychange', () => {
  keys.clear();
  walkVelocity.set(0, 0);
  previousTime = lastFrame = 0;
  if (document.hidden && pendingFrame) { cancelAnimationFrame(pendingFrame); pendingFrame = 0; }
  else invalidate();
});
const viewportObserver = new ResizeObserver(() => {
  camera.aspect = viewport.clientWidth / viewport.clientHeight;
  camera.updateProjectionMatrix();
  renderer.setSize(viewport.clientWidth, viewport.clientHeight);
  pipeline.setSize(viewport.clientWidth, viewport.clientHeight);
  invalidate();
});

viewportObserver.observe(viewport);

// Keep the canvas and shader cache alive while room modules are authored. The
// old scene remains visible until a replacement has finished building.
if (import.meta.hot) {
  import.meta.hot.accept('../../../demos/index', next => {
    if (next) void loadRoom(roomId, next.roomById(roomId));
  });
}

await loadRoom(new URLSearchParams(location.search).get('room') ?? ROOMS[0].id);

const initialView = new URLSearchParams(location.search).get('view');
if (initialView === 'layout' || initialView === 'knolling') setMode(initialView);
else restoreCameraLink();
updateCameraHelper();

if (import.meta.env.DEV) Object.assign(window, { __viewer: { renderer, scene, camera, pipeline, orbit,
  get room() { return room; }, get stats() { return { renderedFrames, pendingFrame, movingRatio, quality }; } } });