{
  id, name, nameEn, group, curvature, color, tagline, facts: [...], description, controls: [...], scene: 'poincare' | 'klein' | 'halfspace' | 'hyperboloid' | 'sphere' | 'h2r' | 'sol' | 'euclid' | 's2r' | 'sl2r' | 'nil'
}

export interface BuiltScene {
  root: THREE.Group;
  update: (dt: number, t: number, params: Record<string, number|boolean>) => void;
  dispose: () => void;
  cameraHint?: { pos: [number,number,number]; target: [number,number,number] };
}

const e1 = A.clone().normalize();
let e2 = B.clone().sub(e1.clone().multiplyScalar(B.dot(e1)));
if (e2.lengthSq() < 1e-8) -> diameter line
e2.normalize();
// coordinates
const ax = A.length(), ay = 0;
const bx = B.dot(e1), by = B.dot(e2);
const cx = (ax*ax + 1) / (2*ax);
const cy = (bx*bx + by*by + 1 - 2*cx*bx) / (2*by);
const C = e1*cx + e2*cy; radius r = sqrt(|C|²-1)
// angles of A,B around C in basis (e1,e2)

function builder(...) {
  const dynamic: { build: (p, t) => void; continuous?: boolean }[] = [];
  ...
  update: (_dt, t, p) => {
    const key = JSON.stringify(p);
    const changed = key !== lastKey;
    lastKey = key;
    dynamic.forEach((d) => {
      if (changed || d.continuous) d.build(p, t);
    });
  },

import { useEffect, useRef } from 'react';
import * as THREE from 'three';
import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
import type { SpaceDef } from '../data/spaces';
import { SCENE_BUILDERS, type BuiltScene, type ParamValues } from '../three/scenes';

interface Props {
  space: SpaceDef;
  params: ParamValues;
}

<div class="h-screen flex flex-col bg-[#06080b] text-[#e8ebee]">
  <Header onMenu />
  <div class="flex flex-1 min-h-0">
    <Sidebar ... />
    <main class="flex-1 relative min-w-0">
      {space.id === 'lab' ? <CurvatureLab params/> : <ExplorerCanvas space params/>}
      <ControlBar space params onChange /> // floating bottom
    </main>
    <InfoPanel space /> // right, hidden on <lg
  </div>
</div>

t=0; p=pos; v=raydir (vec4 tangent unit);
for i<128: d = sdf(p); if d<eps break; 
  step = d*s (unit coord step);
  p = cos(step)*p + sin(step)*v;
  v = −sin(step)*p_old + cos(step)*v; // careful order
  t += step; if t>MAX break;

#version 300 es
precision highp float;
uniform int uMode; // 0 euclid, 1 sphere, 2 hyper, 3 h2r
uniform float uS; // sqrt|K|
uniform vec2 uRes;
uniform vec4 uPos, uFwd, uRight, uUp;      // const3
uniform vec3 uPos3; uniform float uY;       // h2r
uniform vec3 uFwdH, uRightH; uniform float uFwdW; // h2r: horizontal fwd unit tangent, vertical component
uniform vec4 uSphC[4]; uniform float uSphR[4]; uniform vec3 uSphCol[4];
uniform vec4 uCubeC; uniform vec4 uCubeN0,uCubeN1,uCubeN2; uniform float uCubeHalf; uniform vec3 uCubeCol;
uniform vec4 uSphC3[4]; uniform float uSphY[4]; // h2r centers (hyperboloid vec3 + y)
uniform vec3 uCubeC3; uniform float uCubeY;
out vec4 frag;

<div absolute inset-0 bg-black>
  <canvas/>
  {unlocked && crosshair}
  top-left: space pills (4)
  top-right: info chip (badge, name, hint)
  bottom-center: K slider + speed note (hidden for h2r)
  bottom-left: keys help
  {!locked && center overlay card: 点击进入第一人称 / WASD...}
</div>

#version 300 es
precision highp float;

uniform int uMode;
uniform float uS;
uniform vec2 uRes;
uniform float uTime;

uniform vec4 uPos, uFwd, uRight, uUp;
uniform vec4 uSphC[4];
uniform float uSphR[4];
uniform vec4 uCubeC;
uniform float uCubePhi[3];
uniform float uCubeHalf;

uniform vec3 uPos3; uniform float uY;
uniform vec3 uFwdH, uRightH; uniform float uFwdW;
uniform vec3 uSphC3[4]; uniform float uSphY[4];
uniform vec3 uCubeC3; uniform float uCubeY; uniform float uCubePhiH[3];

out vec4 fragColor;

const vec3 SPH_COL[4] = vec3[4](vec3(0.98,0.42,0.35), vec3(0.35,0.65,1.0), vec3(1.0,0.78,0.3), vec3(0.75,0.5,1.0));
const vec3 CUBE_COL = vec3(0.45,0.95,0.6);
const float AX = 2.6, AY = 2.0, AZ = 2.6;

float mdot(vec4 a, vec4 b){ // metric dot
  if(uMode==2) return -a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w;
  return dot(a,b);
}

float distPt(vec4 p, vec4 c){
  if(uMode==1) return acos(clamp(dot(p,c),-1.,1.))/uS;
  if(uMode==2) return acosh(clamp(-mdot(p,c),1.,1e9))/uS;
  return length(p-c);
}
float phi(vec4 p, vec4 n){ // signed true-unit distance to plane through origin with unit normal n
  if(uMode==1) return asin(clamp(dot(p,n),-1.,1.))/uS;
  if(uMode==2) return asinh(mdot(p,n))/uS;
  return dot(p-n?)... // euclid: dot(p - 0, n) = dot(p,n) since plane through origin and p=(0,xyz), n=(0,ej): dot = coord. good: return dot(p,n);
}

vec2 sdScene(vec4 p){ // (dist, materialId)
  // room
  vec3 ph = vec3(phi(p, vec4(0,1,0,0)), phi(p, vec4(0,0,1,0)), phi(p, vec4(0,0,0,1)));

  vec3 ra = vec3(abs(ph.x)-AX, abs(ph.y)-AY, abs(ph.z)-AZ);
  float room = max(ra.x, max(ra.y, ra.z));
  float d = room; float id = 0.;
  for(int i=0;i<4;i++){
    float ds = distPt(p, uSphC[i]) - uSphR[i];
    if(ds<d){d=ds;id=1.+float(i);}
  }
  float dc = max(abs(phi(p,N0)-uCubePhi[0]), max(abs(phi(p,N1)-uCubePhi[1]), abs(phi(p,N2)-uCubePhi[2]))) - uCubeHalf;
  if(dc<d){d=dc; id=5.;}
  return vec2(d,id);
}

vec4 shade(vec4 p, vec4 v, float td, float id){
  // normal
  ...
}

vec4 N = vec4(0);
for j in 1..3:
  tj = tangent(j);
  float h = 0.004;
  move p±: pp = movePoint(p, tj, h) ... 

vec2 gc = the two coords * 2.0;
vec2 gf = abs(fract(gc)-0.5)/fwidth(gc);
float line = 1.0 - min(min(gf.x,gf.y),1.0);
col += lineColor * line * 0.5;

float tU = 0.; vec4 p = uPos; vec4 v = rayDir;
float id = -1.;
for(int i=0;i<170;i++){
  vec2 r = sdScene(p);
  if(r.x < 0.0028){ id = r.y; break; }
  float stepU = (uMode==0) ? r.x : r.x * uS;
  // clamp step to avoid tunneling? fine
  vec4 pn = movePoint(p, v, stepU_in_true?) ...

  if(uMode==1 && tTrue > 6.4/uS) break;
  if(uMode==2 && tTrue > 10.0) break;
  if(uMode==0 && tTrue > 30.0) break;
}
if(id<0) background;
else shade.

vec4 movePoint(vec4 p, vec4 v, float d){
  if(uMode==1){ float a=d*uS; return cos(a)*p + sin(a)*v; }
  if(uMode==2){ float a=d*uS; return cosh(a)*p + sinh(a)*v; }
  return p + d*v;
}
vec4 moveDir(vec4 p, vec4 v, float d){ // parallel transport direction
  if(uMode==1){ float a=d*uS; return -sin(a)*p + cos(a)*v; }
  if(uMode==2){ float a=d*uS; return sinh(a)*p + cosh(a)*v; }
  return v;
}

vec3 m3(vec3 a, vec3 b){ return vec3(-a.x*b.x + a.y*b.y + a.z*b.z); } // returns scalar actually — float m3.
float phiH(vec3 p, vec3 n){ return asinh(m3(p,n)); }
float distH(vec3 p, vec3 c){ return acosh(clamp(-m3(p,c),1.,1e9)); }
vec2 sdScene3(vec3 p, float y){
  float dH = distH(p, vec3(1,0,0));
  float room = max(dH - 2.4, abs(y) - 2.0);
  float d = room; float id = 0.;
  for i: ds = length(vec2(distH(p,uSphC3[i]), y - uSphY[i])) - uSphR[i]; ...
  cube: max(max(abs(phiH(p,N30)-uCubePhiH[0]), abs(phiH(p,N31)-uCubePhiH[1])) - uCubeHalf, abs(y-uCubeY)-uCubeHalf)
}

float av0 = length? vh0 = uFwdH + uv.x*ta*aspect*uRightH + uv.y*ta*uUpH_component...

function transportConst3(st, d, dirLocal) { // dirLocal: combination of f,r,u
  // st: {p, f, r, u, metric}
  // move along dir (unit tangent)
  ...
}

transport(st, D, dTrue):
  a = dTrue * s
  pA = cs(a), pB = sn(a)  // p(a) = pA*p + pB*D ; D(a) = -sign*pB? 

embed(off): mode1: d=len(off)*s; [cos d, sin d*off/len]; mode2: [cosh d, sinh d*off/len...]; mode0: [0, off...].
cube phi: phi(c) per axis: mode1 asin(c_j)/s; mode2 asinh(c_j)/s; mode0 c_j.
h2r embed: d=len2(off.xz)*1? For h2r curvature fixed −1: dH = hypot(off.x, off.z); c3 = [cosh dH, sinh dH*off.x/dH, sinh dH*off.z/dH]; cy = off.y. cubePhiH[j] = asinh(c3[j+1]).

#version 300 es
void main(){ vec2 p = vec2[](vec2(-1,-1),vec2(3,-1),vec2(-1,3))[gl_VertexID]; gl_Position=vec4(p,0,1);}

      float g1 = sdDist3(cosh(a*h)*p + sinh(a*h)*uh*0. + sinh(h)*t1, y) - sdDist3(cosh(h)*p - sinh(h)*t1, y);
      // simpler robust gradient: small steps along t1, t2, and y
      g1 = sdDist3(normalize(p + h*t1 + (m3(p + h*t1, p + h*t1) > 0. ? vec3(0.) : vec3(0.)), y) );
      g1 = sdDist3(p + h*t1, y) - sdDist3(p - h*t1, y);

      float g1 = sdDist3(p + h*t1, y) - sdDist3(p - h*t1, y);

type Vec4 = [number,number,number,number];
interface Cam3 { p: Vec4; f: Vec4; r: Vec4; u: Vec4; }
const signOf = (mode) => mode===1 ? 1 : -1; // metric sign of p
mdot(a,b,mode) = mode===2 ? -a0b0+... : dot

interface CamH { p: [n,n,n]; y: number; base: [n,n,n]; right: [n,n,n]; pitch: number }

embedConst3(off:[x,y,z], mode, s): Vec4
  L = len(off); if L~0 return [1,0,0,0]-ish (mode0: [0,0,0,0])
  d = L*s
  mode1: [cos d, sin d*off/L ...]
  mode2: [cosh d, sinh d*off/L...]
  mode0: [0, off...]
cubePhiConst3(c, mode, s): for j: mode0 c[j]; mode1 asin(clamp(c[j]))/s; mode2 asinh(c[j])/s
embedH2R(off): dH = hypot(off.x, off.z); c3 = [cosh dH, sinh dH*off.x/dH, sinh dH*off.z/dH]; y=off.y; phiH_j = asinh(c3[j+1])

float roomD = -(max(ra.x, max(ra.y, ra.z)));  // positive inside room
d = roomD; id = 0;
for spheres: ds... if ds<d ...

const resize = () => { canvas.width = ...; gl.viewport... }

gl.uniform1i(loc.uMode, st.mode);

cam.f = norm(removeP(cam.f));
cam.r = norm(removePF(cam.r));
cam.u = norm(removePFR(cam.u));

function reOrth3(cam: Cam3, mode: number) {
  const sign = mode === 1 ? 1 : -1;
  const remove = (X: V4, Y: V4, ySign: number): V4 => add4(X, Y, -mdot4(X, Y, mode) * ySign);
  const norm = (X: V4): V4 => scale4(X, 1 / Math.sqrt(Math.max(mdot4(X, X, mode), 1e-12)));
  cam.f = norm(remove(cam.f, cam.p, sign));
  cam.r = norm(remove(remove(cam.r, cam.p, sign), cam.f, 1));
  cam.u = norm(remove(remove(remove(cam.u, cam.p, sign), cam.f, 1), cam.r, 1));
}

const norm = ...
cam.base = norm(add3(cam.base, cam.p, m3(cam.base, cam.p))); // remove p comp: X + <X,p>*p since <p,p>=-1 → X - (<X,p>/-1)p = X + <X,p> p
cam.right = norm(add3(add3(cam.right, cam.p, m3(cam.right, cam.p)), cam.base, -m3(cam.right, cam.base)));

cam.base = norm(strip(strip(cam.base, cam.p, -1), cam.base, 1));

vec2 fw = fwidth(gc * 1.6);
float fade = clamp(0.5 / max(max(fw.x, fw.y), 1e-4), 0., 1.);
vec2 gf = abs(fract(gc*1.6+0.5)-0.5) / max(fw, 1e-4);
float gl = (1. - min(min(gf.x, gf.y), 1.)) * fade;

if(uMode==1){ col *= exp(-max(td-3.4, 0.0)*0.55); }

if(uMode == 2) return asinh(mdot(p, n)) / uS;

if(uMode == 2) col *= exp(-td * 0.16);
else if(uMode == 0) col *= exp(-td * 0.03);

function embedConst3(off: V3, mode: number, s: number): V4 {

function phiConst3(off: V3, j: number, mode: number, s: number): number {
  if (mode === 1) {
    const lim = Math.PI / (2 * s) - 0.05;
    return Math.max(-lim, Math.min(lim, off[j]));
  }
  return off[j];
}

vec3 ph = vec3(phi(p, N1), phi(p, N2), phi(p, N3));
vec3 ra = vec3(abs(ph.x) - AX, abs(ph.y) - AY, abs(ph.z) - AZ);

vec3 ph = vec3(phi(p, N1), phi(p, N2), phi(p, N3));
vec3 he = uMode == 1 ? vec3(1.4) : vec3(AX, AY, AZ);
vec3 ra = abs(ph) - he;

const yawA = -e.movementX * sens;
const nf = f*cos(yawA) + r*sin(yawA);
const nr = f*(-sin(yawA)) + r*cos(yawA);

{!locked && (
  <div className="pointer-events-none absolute inset-0 flex items-center justify-center bg-black/45">
    <div className="flex max-w-sm ... backdrop-blur">
      ...
      <button onClick={requestLock} className="pointer-events-auto mt-4 rounded-full border border-[#d3fd50]/50 px-5 py-2 font-mono text-[12px] text-[#d3fd50] hover:bg-[#d3fd50]/10">
        点 击 进 入
      </button>