Skip to content
VibeCodeBench
Back to the app

The code

Swim the Kelp Garden by Claude Opus 5.5

Exactly as the AI wrote it. Shown as text, so nothing runs on this page.

index.html

works · auto-checked (Checked by an automated pass. Not hand-played yet.)41.1 KB · 572 lines · loads cdn.jsdelivr.net/npm/[email protected]/build/three.module.js
Download
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1,maximum-scale=1,user-scalable=no,viewport-fit=cover">
<title>Kelp Garden</title>
<style>
html,body{margin:0;height:100%;overflow:hidden;background:#0c3f68;font-family:system-ui,-apple-system,"Segoe UI",Roboto,sans-serif;color:#e8f7f1;-webkit-user-select:none;user-select:none;-webkit-touch-callout:none;-webkit-tap-highlight-color:transparent}
canvas{display:block;touch-action:none}
#ov{position:fixed;inset:0;display:flex;align-items:center;justify-content:center;background:radial-gradient(ellipse at 50% 28%,rgba(35,163,154,.45),rgba(6,24,48,.88));transition:opacity .9s;z-index:5}
#ov.hide{opacity:0;pointer-events:none}
.card{max-width:min(440px,88vw);text-align:center;padding:24px}
h1{font-size:clamp(32px,9vw,50px);margin:0 0 10px;color:#f2bd4e;letter-spacing:.03em;text-shadow:0 3px 20px rgba(0,0,0,.45)}
.card p{margin:10px 0;font-size:17px;line-height:1.5;color:#cdeee4}
#go{margin-top:20px;min-height:66px;padding:0 48px;border:0;border-radius:40px;font:inherit;font-size:22px;font-weight:700;color:#3b1c06;background:linear-gradient(#f6cd63,#e8743b);box-shadow:0 8px 28px rgba(232,116,59,.45);cursor:pointer}
#snd{position:fixed;right:16px;bottom:calc(16px + env(safe-area-inset-bottom));width:62px;height:62px;border-radius:50%;border:2px solid rgba(242,189,78,.75);background:rgba(8,40,70,.55);color:#f2bd4e;font-size:28px;cursor:pointer;z-index:4;display:flex;align-items:center;justify-content:center;padding:0}
#snd.off{opacity:.5;text-decoration:line-through}
#tip{position:fixed;left:50%;bottom:calc(28px + env(safe-area-inset-bottom));transform:translateX(-50%);padding:12px 20px;border-radius:24px;background:rgba(6,30,56,.6);font-size:15px;text-align:center;pointer-events:none;opacity:0;transition:opacity 1s;z-index:3;max-width:calc(100vw - 190px);box-sizing:border-box}
</style>
</head>
<body>
<div id="ov"><div class="card">
<h1>Kelp Garden</h1>
<p>Drift through a quiet kelp forest, past rocky arches and an old sunken ship.</p>
<p><b>Phone:</b> press &amp; hold to glide, drag to turn.<br><b>Mouse:</b> hold the button and move the pointer.</p>
<p id="msg"></p>
<button id="go">Dive in</button>
</div></div>
<button id="snd" class="off" aria-label="Sound on or off">&#9834;</button>
<div id="tip"></div>
<script type="module">
import * as THREE from 'https://cdn.jsdelivr.net/npm/[email protected]/build/three.module.js';
const $ = id => document.getElementById(id);
const DEMO = location.hash === '#demo';
let demoOn = DEMO;
const SURF = 34, WORLD = 125, PR = .9, SL = 11, SX = 24, SZ = -48;
let sd = 20261122;
const rnd = () => { sd = sd + 0x6D2B79F5 | 0; let t = Math.imul(sd ^ sd >>> 15, 1 | sd); t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t; return ((t ^ t >>> 14) >>> 0) / 4294967296; };
const R = (a, b) => a + (b - a) * rnd();
const V = (x = 0, y = 0, z = 0) => new THREE.Vector3(x, y, z);
const col = h => new THREE.Color(h);
const wrapA = a => Math.atan2(Math.sin(a), Math.cos(a));
const H = (x, z) => 1.6 * Math.sin(x * .045 + 1.3) * Math.cos(z * .038) + .9 * Math.sin(x * .11 - z * .07) + .5 * Math.cos(z * .17 + x * .05);
const hs = (x, y, z) => { const h = Math.sin(x * 127.1 + y * 311.7 + z * 74.7) * 43758.5453; return h - Math.floor(h); };
function vn(x, y, z) {
  const X = Math.floor(x), Y = Math.floor(y), Z = Math.floor(z); let u = x - X, v = y - Y, w = z - Z;
  u = u * u * (3 - 2 * u); v = v * v * (3 - 2 * v); w = w * w * (3 - 2 * w);
  const L = (a, b, t) => a + (b - a) * t, f = (i, j, k) => hs(X + i, Y + j, Z + k);
  return L(L(L(f(0,0,0), f(1,0,0), u), L(f(0,1,0), f(1,1,0), u), v), L(L(f(0,0,1), f(1,0,1), u), L(f(0,1,1), f(1,1,1), u), v), w);
}
const fbm = (x, y, z) => vn(x, y, z) * .55 + vn(x * 2.1, y * 2.1, z * 2.1) * .3 + vn(x * 4.3, y * 4.3, z * 4.3) * .15;

let renderer;
try { renderer = new THREE.WebGLRenderer({ antialias: true }); }
catch (e) { $('msg').textContent = 'Sorry, this device cannot show 3D graphics (WebGL).'; throw e; }
renderer.setPixelRatio(Math.min(window.devicePixelRatio || 1, 1.75));
const cv = renderer.domElement; document.body.prepend(cv);
const scene = new THREE.Scene();
const C = { teal: col(0x23a39a), deep: col(0x0d3360), kelp: col(0x4f8f2c), gold: col(0xf2bd4e), orange: col(0xe8743b) };
const FOG_D = col(0x0c3f68), FOG_S = col(0x1a7f8c);
scene.fog = new THREE.FogExp2(FOG_D.clone(), .02);
const camera = new THREE.PerspectiveCamera(65, 1, .1, 600); camera.rotation.order = 'YXZ';
const SUN = V(.38, -1, .22).normalize();
scene.add(new THREE.HemisphereLight(0x8fdccf, 0x0d3360, 1.7), new THREE.AmbientLight(0x2a7f8f, .7));
const dl = new THREE.DirectionalLight(0xffdc94, 2.2); dl.position.copy(SUN).multiplyScalar(-60); scene.add(dl);
const dummy = new THREE.Object3D(), tmpC = new THREE.Color(), qq = new THREE.Quaternion(), sc = V(), UP = V(0, 1, 0);
const tmp = V(), tg = V(), tv = V(), fw = V(), nrm = V(), lp = V(), o = V();
const pp = V(0, 6, 32), vel = V();

/* ---------- shared shader patch: world position, caustics, extras ---------- */
const uT = { value: 0 }, uCaus = { value: col(0xffe2a0) }, uH = { value: 800 }, uDen = { value: .02 }, fogU = { value: scene.fog.color };
const GC = `uniform float uT;uniform vec3 uCaus;varying vec3 vWP;varying vec3 vWN;
float caus(vec2 p){float t=uT*.55;vec2 q=p+vec2(sin(p.y*.8+t),cos(p.x*.7-t*.9))*.9;float a=sin(q.x*2.1+t)*cos(q.y*1.9-t*.7);
vec2 r=p*1.6+vec2(cos(p.y*1.1-t*1.2),sin(p.x*1.3+t))*.7;float b=sin(r.x*1.7-t*.8)*cos(r.y*2.2+t*.6);return pow(1.-abs(a+b)*.5,7.);}
`;
function patch(m, op = {}) {
  m.onBeforeCompile = s => {
    s.uniforms.uT = uT; s.uniforms.uCaus = uCaus;
    s.vertexShader = 'uniform float uT;\nvarying vec3 vWP;\nvarying vec3 vWN;\n' + (op.attr || '') + s.vertexShader
      .replace('#include <begin_vertex>', '#include <begin_vertex>\n' + (op.vert || ''))
      .replace('#include <project_vertex>', '#include <project_vertex>\nvec4 wq=vec4(transformed,1.);\n#ifdef USE_INSTANCING\nwq=instanceMatrix*wq;\n#endif\nvWP=(modelMatrix*wq).xyz;vWN=normalize((vec4(transformedNormal,0.)*viewMatrix).xyz);');
    s.fragmentShader = GC + s.fragmentShader
      .replace('#include <color_fragment>', '#include <color_fragment>\n' + (op.frag || ''))
      .replace('#include <emissivemap_fragment>', '#include <emissivemap_fragment>\ntotalEmissiveRadiance+=diffuseColor.rgb*uCaus*caus(vWP.xz*.3)*(' + (op.cw || 'smoothstep(.1,.9,vWN.y)') + ')*' + (op.ck || '.9') + '*(1.-smoothstep(35.,80.,distance(vWP,cameraPosition)));');
  };
  m.customProgramCacheKey = () => op.key || 'b';
  return m;
}
function inst(geo, mat, ms, cs) {
  const m = new THREE.InstancedMesh(geo, mat, ms.length);
  ms.forEach((x, i) => { m.setMatrixAt(i, x); if (cs) m.setColorAt(i, cs[i]); });
  m.frustumCulled = false; scene.add(m); return m;
}

/* ---------- demo path (also kept clear of rocks) ---------- */
const mkC = a => new THREE.CatmullRomCurve3(a.map(p => V(...p)), true, 'centripetal');
const cP = mkC([[0,6,32],[0,4.9,6],[0,4.9,-12],[5,8,-30],[6,10,-48],[13,15,-70],[-6,20,-56],[-15,12,-22],[-19,8,10]]);
const cL = mkC([[0,4,0],[0,5,-20],[8,6,-40],[22,4,-45],[23,4,-48],[23,3,-45],[-16,44,-66],[-26,6,0],[0,5,32]]);
const demoPts = cP.getSpacedPoints(160);

/* ---------- sand floor with caustics ---------- */
{
  const g = new THREE.PlaneGeometry(340, 340, 170, 170).rotateX(-Math.PI / 2), p = g.attributes.position, cc = [], c = new THREE.Color();
  const A = col(0xe9c88a), B = col(0xd99659);
  for (let i = 0; i < p.count; i++) {
    const x = p.getX(i), z = p.getZ(i), y = H(x, z), n = fbm(x * .06, 3.1, z * .06);
    p.setY(i, y); c.copy(A).lerp(B, n).multiplyScalar(.55 + .06 * (y + 3) + n * .2); cc.push(c.r, c.g, c.b);
  }
  g.setAttribute('color', new THREE.Float32BufferAttribute(cc, 3)); g.computeVertexNormals();
  scene.add(new THREE.Mesh(g, patch(new THREE.MeshLambertMaterial({ vertexColors: true }), { key: 'floor', ck: '1.25', frag: 'diffuseColor.rgb*=.86+.14*sin(vWP.x*1.3+sin(vWP.z*.33)*2.6+vWP.z*.35);' })));
}

/* ---------- water backdrop, rippling surface, sunbeams ---------- */
const sky = new THREE.Mesh(new THREE.SphereGeometry(480, 32, 16), new THREE.ShaderMaterial({
  side: THREE.BackSide, depthWrite: false, uniforms: { uFog: fogU, uTop: { value: col(0x58c2b8) }, uBot: { value: col(0x051a36) } },
  vertexShader: 'varying vec3 vD;void main(){vD=position;gl_Position=projectionMatrix*modelViewMatrix*vec4(position,1.);}',
  fragmentShader: 'uniform vec3 uFog,uTop,uBot;varying vec3 vD;void main(){float y=normalize(vD).y;vec3 c=mix(uFog,uBot,1.-smoothstep(-.75,0.,y));c=mix(c,uTop,smoothstep(.05,.95,y)*.55);gl_FragColor=vec4(c,1.);\n#include <colorspace_fragment>\n}'
}));
sky.renderOrder = -1; scene.add(sky);

const surf = new THREE.Mesh(new THREE.PlaneGeometry(900, 900), new THREE.ShaderMaterial({
  side: THREE.DoubleSide,
  uniforms: { uT, uFog: fogU, uDen, uA: { value: col(0xb6efe0) }, uB: { value: col(0x0f4f73) }, uG: { value: col(0xffe3a3) }, uSun: { value: SUN } },
  vertexShader: 'varying vec3 vW;void main(){vec4 w=modelMatrix*vec4(position,1.);vW=w.xyz;gl_Position=projectionMatrix*viewMatrix*w;}',
  fragmentShader: `uniform float uT,uDen;uniform vec3 uFog,uA,uB,uG,uSun;varying vec3 vW;
void main(){vec3 d=vW-cameraPosition;float dist=length(d);vec3 v=d/dist;vec2 p=vW.xz*.08;float t=uT*.5;
float w=sin(p.x*3.+t)*sin(p.y*2.6-t*.8)+sin((p.x+p.y)*4.4+t*1.3)*.5+sin((p.x-p.y)*7.-t*1.7)*.25;
float sn=smoothstep(.55,.85,v.y);vec3 c=mix(uB,uA,sn);
c+=uG*pow(max(0.,1.-abs(w)*.9),6.)*(.25+.6*sn);c+=uG*pow(max(0.,dot(v,-uSun)),40.)*1.4;
float f=1.-exp(-uDen*uDen*dist*dist*.55);gl_FragColor=vec4(mix(c,uFog,f),1.);
#include <colorspace_fragment>
}`
}));
surf.rotation.x = Math.PI / 2; surf.position.y = SURF; scene.add(surf);

{
  const g = new THREE.CylinderGeometry(.7, 2.8, 1, 18, 1, true).translate(0, -.5, 0), n = 30, ph = new Float32Array(n), ms = [];
  const q = new THREE.Quaternion().setFromUnitVectors(V(0, -1, 0), SUN);
  for (let i = 0; i < n; i++) { const w = R(.5, 1.6); ms.push(new THREE.Matrix4().compose(V(R(-60, 60), SURF, R(-60, 60)), q, V(w, R(30, 42), w))); ph[i] = R(0, 6.28); }
  g.setAttribute('aPh', new THREE.InstancedBufferAttribute(ph, 1));
  inst(g, new THREE.ShaderMaterial({
    transparent: true, depthWrite: false, blending: THREE.AdditiveBlending, side: THREE.DoubleSide,
    uniforms: { uT, uDen, uC: { value: col(0xffe3a3) } },
    vertexShader: `attribute float aPh;uniform float uT;varying float vA,vD,vF;varying vec3 vN,vV;
void main(){vec4 w=instanceMatrix*vec4(position,1.);vec2 ip=instanceMatrix[3].xz-cameraPosition.xz;w.xz+=mod(ip+60.,120.)-60.-ip;
vec4 mv=viewMatrix*w;vV=-mv.xyz;vD=length(mv.xyz);vN=normalize(mat3(viewMatrix)*mat3(instanceMatrix)*normal);vA=uv.y;
vF=.5+.5*sin(uT*.6+aPh)*sin(uT*.37+aPh*1.9);gl_Position=projectionMatrix*mv;}`,
    fragmentShader: `uniform vec3 uC;uniform float uDen;varying float vA,vD,vF;varying vec3 vN,vV;
void main(){float e=abs(dot(normalize(vN),normalize(vV)));float a=e*e*smoothstep(0.,.7,vA)*(.35+vF)*.05*exp(-uDen*uDen*vD*vD*.5)*smoothstep(2.,8.,vD);
gl_FragColor=vec4(uC*a,1.);
#include <colorspace_fragment>
}`
  }), ms);
}

/* ---------- rocks and arches (solid) ---------- */
const rockSpec = [], cols = [], segs = [], boxes = [];
function addRock(x, y, z, s, sy, full) {
  rockSpec.push({ x, y, z, s, sy, rx: full ? R(0, 6.3) : R(-.25, .25), ry: R(0, 6.3), rz: full ? R(0, 6.3) : R(-.25, .25) });
  cols.push({ x, y, z, rh: s * 1.1, rv: s * sy * 1.1 });
}
const ARCH = [[0, -5, 0, 10], [-48, -38, .9, 9], [46, 28, -.6, 8]];
for (const [cx, cz, rot, Rr] of ARCH) {
  const by = H(cx, cz) - 1, ax = Math.cos(rot), az = -Math.sin(rot), nx = Math.sin(rot), nz = Math.cos(rot);
  for (let ring = 0; ring < 2; ring++) {
    const n = 13, off = ring ? R(1, 1.6) : -R(1, 1.6), k = ring ? .85 : 1;
    for (let i = 0; i <= n; i++) {
      const a = i / n * Math.PI, s = R(2.9, 3.4) * k * (i === 0 || i === n ? 1.25 : 1);
      addRock(cx + ax * Math.cos(a) * Rr + nx * off, by + Math.sin(a) * Rr * 1.08, cz + az * Math.cos(a) * Rr + nz * off, s, 1, true);
    }
  }
  for (const sg of [-1, 1]) for (let j = 0; j < 3; j++) { const d = Rr + R(1.5, 3.5), of = R(-2.5, 2.5); addRock(cx + ax * sg * d + nx * of, by + R(-.5, 1), cz + az * sg * d + nz * of, R(2.8, 4), R(.75, 1), false); }
}
function clearAt(x, z, r) {
  if (Math.hypot(x - SX, z - SZ) < 15 + r || Math.hypot(x - pp.x, z - pp.z) < 6 + r) return false;
  for (const a of ARCH) if (Math.hypot(x - a[0], z - a[1]) < a[3] + 7 + r) return false;
  for (const p of demoPts) if (Math.hypot(x - p.x, z - p.z) < r + 4) return false;
  return true;
}
for (let i = 0, tr = 0; i < 70 && tr < 2500; tr++) {
  const big = rnd() < .3, s = big ? R(3, 6) : R(.6, 2.2), a = R(0, 6.283), d = Math.sqrt(rnd()) * 115, x = Math.cos(a) * d, z = Math.sin(a) * d;
  if (!clearAt(x, z, s * 1.2)) continue;
  const sy = R(.55, .95); addRock(x, H(x, z) - s * sy * .3, z, s, sy, false); i++;
}
function rockGeo(k) {
  const g = new THREE.IcosahedronGeometry(1, 3), p = g.attributes.position, v = V();
  for (let i = 0; i < p.count; i++) {
    v.fromBufferAttribute(p, i); v.multiplyScalar(.78 + fbm(v.x * 1.3 + k, v.y * 1.3, v.z * 1.3 - k) * .5);
    if (v.y < -.3) v.y = -.3 + (v.y + .3) * .4; p.setXYZ(i, v.x, v.y, v.z);
  }
  g.computeVertexNormals(); return g;
}
{
  const mat = patch(new THREE.MeshLambertMaterial(), { key: 'rock', frag: 'diffuseColor.rgb=mix(diffuseColor.rgb,vec3(.09,.27,.035),smoothstep(.5,.95,vWN.y)*.6);' });
  const RA = col(0x3b5f7d), RB = col(0x2d6a6c);
  [rockGeo(0), rockGeo(7.3)].forEach((g, k) => {
    const ms = [], cs = [];
    rockSpec.forEach((r, i) => { if (i % 2 !== k) return; dummy.position.set(r.x, r.y, r.z); dummy.rotation.set(r.rx, r.ry, r.rz); dummy.scale.set(r.s, r.s * r.sy, r.s); dummy.updateMatrix(); ms.push(dummy.matrix.clone()); cs.push(RA.clone().lerp(RB, rnd()).multiplyScalar(R(.8, 1.15))); });
    inst(g, mat, ms, cs);
  });
}

/* ---------- coral (palette only) ---------- */
const CORAL = [C.orange, C.gold, C.teal, col(0xff9150), col(0xffd27a), col(0x3cc4b0)];
const brM = [], brC = [], ballM = [], ballC = [], tubeM = [], tubeC = [];
function branch(p, dir, len, rad, depth, c, axis) {
  qq.setFromUnitVectors(UP, dir); brM.push(new THREE.Matrix4().compose(p, qq, sc.set(rad, len, rad))); brC.push(c);
  const e = p.clone().addScaledVector(dir, len);
  if (depth <= 0) { if (!axis) { ballM.push(new THREE.Matrix4().compose(e, qq, sc.setScalar(rad * 1.2))); ballC.push(c.clone().lerp(C.gold, .3)); } return; }
  const k = 2 + (rnd() < .35 ? 1 : 0);
  for (let i = 0; i < k; i++) {
    const nd = axis ? dir.clone().applyAxisAngle(axis, R(-.75, .75)) : dir.clone().add(V(R(-.9, .9), R(0, .5), R(-.9, .9))).normalize();
    if (nd.y < .2) { nd.y = .2; nd.normalize(); }
    branch(e, nd, len * R(.65, .85), rad * .72, depth - 1, c, axis);
  }
}
function coralAt(x, z, y, c) {
  const ty = rnd();
  if (ty < .35) branch(V(x, y, z), V(R(-.2, .2), 1, R(-.2, .2)).normalize(), R(.6, 1), R(.12, .2), 3, c, null);
  else if (ty < .5) { const a = R(0, 6.283); branch(V(x, y, z), UP.clone(), R(.5, .8), .07, 4, c, V(Math.cos(a), 0, Math.sin(a))); }
  else if (ty < .78) { const s = R(.5, 1.5); ballM.push(new THREE.Matrix4().compose(V(x, y, z), qq.setFromAxisAngle(UP, R(0, 6.3)), sc.set(s, s * R(.55, .8), s))); ballC.push(c); }
  else for (let k = 0, m = 3 + Math.floor(rnd() * 4); k < m; k++) {
    const tx = x + R(-.7, .7), tz = z + R(-.7, .7);
    tubeM.push(new THREE.Matrix4().compose(V(tx, H(tx, tz) - .2, tz), qq.setFromEuler(new THREE.Euler(R(-.25, .25), 0, R(-.25, .25))), sc.set(R(.8, 1.3), R(.7, 2.4), R(.8, 1.3)))); tubeC.push(c);
  }
}
for (let i = 0, tr = 0; i < 60 && tr < 3000; tr++) {
  const a = R(0, 6.283), d = 8 + Math.sqrt(rnd()) * 110, px = Math.cos(a) * d, pz = Math.sin(a) * d;
  if (Math.hypot(px - SX, pz - SZ) < 14) continue; i++;
  for (let j = 0, n = 3 + Math.floor(rnd() * 5); j < n; j++) { const x = px + R(-4, 4), z = pz + R(-4, 4); coralAt(x, z, H(x, z) - .15, CORAL[Math.floor(rnd() * 6)]); }
}
rockSpec.forEach(r => { if (r.sy < 1 && r.s > 3 && rnd() < .6) coralAt(r.x + R(-.5, .5), r.z + R(-.5, .5), r.y + r.s * r.sy * .92, CORAL[Math.floor(rnd() * 6)]); });
{
  const coralMat = patch(new THREE.MeshLambertMaterial(), { key: 'coral' });
  const bg = new THREE.IcosahedronGeometry(1, 2), bp = bg.attributes.position, v = V();
  for (let i = 0; i < bp.count; i++) { v.fromBufferAttribute(bp, i); v.multiplyScalar(1 + .12 * Math.sin(v.x * 9) * Math.sin(v.y * 9) * Math.sin(v.z * 9)); bp.setXYZ(i, v.x, v.y, v.z); }
  bg.computeVertexNormals();
  inst(new THREE.CylinderGeometry(.55, 1, 1, 6).translate(0, .5, 0), coralMat, brM, brC);
  inst(bg, coralMat, ballM, ballC);
  inst(new THREE.CylinderGeometry(.32, .26, 1, 10, 1, true).translate(0, .5, 0), patch(new THREE.MeshLambertMaterial({ side: THREE.DoubleSide }), { key: 'tube', frag: 'if(!gl_FrontFacing)diffuseColor.rgb*=.3;' }), tubeM, tubeC);
}

/* ---------- swaying kelp ---------- */
{
  const seg = 30, P = [], CC = [], I = [], base = C.kelp.clone().multiplyScalar(.45), tip = C.kelp.clone().lerp(C.gold, .4);
  for (let i = 0; i <= seg; i++) {
    const v = i / seg, w = (.06 + .5 * Math.sqrt(Math.sin(Math.min(1, v * 1.4) * Math.PI * .5)) * (1 - v * .5)) * (1 + .22 * Math.sin(v * 70));
    const a = v * 5.5, cx = Math.cos(a) * w, cz = Math.sin(a) * w, ru = Math.sin(v * 90) * .06, c = base.clone().lerp(tip, v);
    P.push(-cx, v, -cz + ru, cx, v, cz + ru); CC.push(c.r, c.g, c.b, c.r * .85, c.g * .9, c.b * .8);
    if (i < seg) { const k = i * 2; I.push(k, k + 1, k + 2, k + 1, k + 3, k + 2); }
  }
  const g = new THREE.BufferGeometry(); g.setAttribute('position', new THREE.Float32BufferAttribute(P, 3)); g.setAttribute('color', new THREE.Float32BufferAttribute(CC, 3)); g.setIndex(I); g.computeVertexNormals();
  const KV = `#ifdef USE_INSTANCING
mat3 kM=mat3(instanceMatrix);vec3 kP=instanceMatrix[3].xyz;float kH=position.y*length(kM[1]);float kF=kP.x*.13+kP.z*.09;float kB=kH*kH*.0024;
vec3 kO=vec3(.7+sin(uT*.55+kF-kH*.09)*1.1,0.,.3+cos(uT*.42+kF*1.3-kH*.07)*.8)*kB;kO.y=-dot(kO.xz,kO.xz)*.03;
transformed+=(kO*kM)/vec3(dot(kM[0],kM[0]),dot(kM[1],kM[1]),dot(kM[2],kM[2]));
#endif
`;
  const ok = (x, z) => {
    if (Math.hypot(x - SX, z - SZ) < 14) return false;
    for (const a of ARCH) if (Math.hypot(x - a[0], z - a[1]) < a[3] + 4) return false;
    for (let i = 0; i < demoPts.length; i += 2) if (Math.hypot(x - demoPts[i].x, z - demoPts[i].z) < 3) return false;
    return true;
  };
  const forests = [[-28, -18, 9, 34], [-14, 38, 8, 26], [32, 6, 8, 26], [-38, 30, 7, 20], [12, -78, 9, 28]];
  for (let i = 0; i < 46; i++) { const a = R(0, 6.283), d = 12 + Math.sqrt(rnd()) * 105; forests.push([Math.cos(a) * d, Math.sin(a) * d, R(3, 7), Math.floor(R(5, 13))]); }
  const ms = [], cs = [];
  for (const [fx, fz, fr, n] of forests) for (let j = 0; j < n; j++) {
    const a = R(0, 6.283), d = Math.sqrt(rnd()) * fr, x = fx + Math.cos(a) * d, z = fz + Math.sin(a) * d;
    if (!ok(x, z)) continue;
    const s = R(.9, 1.5); dummy.position.set(x, H(x, z) - .3, z); dummy.rotation.set(0, R(0, 6.283), 0); dummy.scale.set(s, R(13, 30), s); dummy.updateMatrix();
    ms.push(dummy.matrix.clone()); cs.push(new THREE.Color(1, 1, 1).multiplyScalar(R(.75, 1.15)));
  }
  inst(g, patch(new THREE.MeshLambertMaterial({ vertexColors: true, side: THREE.DoubleSide, emissive: 0x0e2c08 }), { key: 'kelp', vert: KV, cw: '.4', ck: '.6' }), ms, cs);
}

/* ---------- sunken wooden ship (solid) ---------- */
const W = u => 4.2 * Math.pow(Math.max(0, 1 - u * u), u > 0 ? .8 : .4), D = u => 3.8 * (1 - .3 * u * u), S = u => .5 * u * u + (u < 0 ? .8 * u * u : 0);
function woodTex() {
  const c = document.createElement('canvas'); c.width = 512; c.height = 256; const x = c.getContext('2d'), ph = 256 / 12;
  for (let i = 0; i < 12; i++) {
    x.fillStyle = `hsl(${22 + rnd() * 10},${55 + rnd() * 15}%,${30 + rnd() * 14}%)`; x.fillRect(0, i * ph, 512, ph);
    for (let k = 0; k < 40; k++) { x.fillStyle = `rgba(60,25,5,${rnd() * .25})`; x.fillRect(rnd() * 512, i * ph + rnd() * ph, 20 + rnd() * 120, 1 + rnd() * 1.5); }
    x.fillStyle = 'rgba(30,12,2,.8)'; for (let k = 0; k < 3; k++) x.fillRect(rnd() * 512, i * ph, 3, ph);
    x.fillStyle = 'rgba(25,10,2,.9)'; x.fillRect(0, i * ph, 512, 2.5);
  }
  for (let k = 0; k < 140; k++) { x.fillStyle = `rgba(${60 + rnd() * 30},${110 + rnd() * 40},${30 + rnd() * 20},${rnd() * .35})`; x.beginPath(); x.arc(rnd() * 512, 80 + rnd() * 96, 4 + rnd() * 22, 0, 7); x.fill(); }
  x.fillStyle = 'rgba(6,14,28,.92)'; for (let k = 0; k < 5; k++) { x.beginPath(); x.ellipse(rnd() * 512, 40 + rnd() * 170, 10 + rnd() * 22, 6 + rnd() * 12, rnd(), 0, 7); x.fill(); }
  const t = new THREE.CanvasTexture(c); t.wrapS = t.wrapT = THREE.RepeatWrapping; t.colorSpace = THREE.SRGBColorSpace; t.anisotropy = 4; return t;
}
const ship = new THREE.Group(), shipInv = new THREE.Matrix4();
const woodMat = patch(new THREE.MeshLambertMaterial({ map: woodTex(), side: THREE.DoubleSide }), { key: 'wood', cw: 'max(vWN.y,0.)', ck: '.7' });
{
  const nu = 44, nv = 26, P = [], UV = [], I = [];
  for (let i = 0; i <= nu; i++) {
    const u = -1 + 2 * i / nu, w = Math.max(W(u), .04), d = D(u), s = S(u);
    for (let j = 0; j <= nv; j++) { const th = j / nv * Math.PI, c = Math.cos(th); P.push(w * Math.sign(c) * Math.pow(Math.abs(c), .7), s - d * Math.pow(Math.sin(th), 1.3), u * SL); UV.push(i / nu * 3, j / nv); }
  }
  for (let i = 0; i < nu; i++) for (let j = 0; j < nv; j++) { const a = i * (nv + 1) + j, b = a + nv + 1; I.push(a, b, a + 1, b, b + 1, a + 1); }
  const g = new THREE.BufferGeometry(); g.setAttribute('position', new THREE.Float32BufferAttribute(P, 3)); g.setAttribute('uv', new THREE.Float32BufferAttribute(UV, 2)); g.setIndex(I); g.computeVertexNormals();
  ship.add(new THREE.Mesh(g, woodMat));
  const deck = [];
  for (let z = -9.5; z <= 9.5; z += 1.02) { if (rnd() < .3) continue; const u = z / SL, w = W(u) * .97; if (w < .4) continue; deck.push(new THREE.Matrix4().compose(V(R(-.1, .1), S(u) - .22, z), qq.setFromEuler(new THREE.Euler(R(-.04, .04), R(-.03, .03), R(-.05, .05))), sc.set(w * 2, .16, .94))); }
  const dm = new THREE.InstancedMesh(new THREE.BoxGeometry(1, 1, 1), woodMat, deck.length); deck.forEach((m, i) => dm.setMatrixAt(i, m)); ship.add(dm);
}
const mast = new THREE.Mesh(new THREE.CylinderGeometry(.26, .36, 15, 10), woodMat); mast.position.set(0, 7.2, .5); mast.rotation.set(-.06, 0, .12); ship.add(mast);
const yard = new THREE.Mesh(new THREE.CylinderGeometry(.14, .16, 9, 8), woodMat); yard.position.y = 4.6; yard.rotation.z = Math.PI / 2 + .08; mast.add(yard);
const stump = new THREE.Mesh(new THREE.CylinderGeometry(.27, .33, 4.6, 10), woodMat); stump.position.set(0, 2.2, 6.4); stump.rotation.z = -.22; ship.add(stump);
const sprit = new THREE.Mesh(new THREE.CylinderGeometry(.14, .2, 6, 8), woodMat); sprit.position.set(0, 1.6, 12.6); sprit.rotation.x = Math.PI / 2 - .4; ship.add(sprit);
const sailG = new THREE.PlaneGeometry(7.4, 5.4, 12, 8).translate(0, -2.7, 0);
{ const p = sailG.attributes.position; for (let i = 0; i < p.count; i++) { const y = p.getY(i); if (y < -3.6) p.setY(i, y + R(0, 2.2) * ((y + 3.6) / -1.8)); p.setZ(i, Math.sin(p.getX(i) * .5) * .25); } sailG.computeVertexNormals(); }
const sail = new THREE.Mesh(sailG, patch(new THREE.MeshLambertMaterial({ color: 0xd9a066, side: THREE.DoubleSide }), { key: 'sail', vert: 'transformed.z+=sin(uT*.9+position.x*.6+position.y*.5)*(-position.y)*.08;', cw: '.35', ck: '.5' }));
sail.position.set(0, 4.3, .45); mast.add(sail);
{
  const sa = .35, bx = Math.sin(sa) * SL, bz = Math.cos(sa) * SL;
  ship.position.set(SX, (H(SX, SZ) + H(SX + bx, SZ + bz) + H(SX - bx, SZ - bz)) / 3 + 2.2, SZ);
  ship.rotation.set(0, sa, .2); scene.add(ship); ship.updateMatrixWorld(true); shipInv.copy(ship.matrixWorld).invert();
  const cap = (m, h, r) => { const a = m.localToWorld(V(0, -h, 0)), d = m.localToWorld(V(0, h, 0)).sub(a); segs.push({ a, d, l2: d.lengthSq(), r }); };
  cap(mast, 7.5, .4); cap(yard, 4.5, .25); cap(stump, 2.3, .4); cap(sprit, 3, .25);
  boxes.push({ inv: sail.matrixWorld.clone().invert(), mw: sail.matrixWorld.clone(), hx: 3.7, hy: 2.7, cy: -2.7, hz: .4 });
  const bg = new THREE.CylinderGeometry(.6, .6, 1.5, 12), p = bg.attributes.position;
  for (let i = 0; i < p.count; i++) { const k = 1 + .15 * Math.cos(p.getY(i) / .75 * Math.PI / 2); p.setX(i, p.getX(i) * k); p.setZ(i, p.getZ(i) * k); }
  bg.computeVertexNormals();
  [[SX - 9, SZ + 6, .3], [SX - 7.5, SZ + 8.5, 1.4], [SX + 8, SZ - 9, 2.2]].forEach(([x, z, r]) => {
    const m = new THREE.Mesh(bg, woodMat), y = H(x, z) + .45; m.position.set(x, y, z); m.rotation.set(0, r, Math.PI / 2); scene.add(m); cols.push({ x, y, z, rh: .95, rv: .95 });
  });
}

/* ---------- fish schools that turn together ---------- */
const fishGeo = (() => {
  const N = [0, 0, .55], T = [0, 0, -.32], U = [0, .19, .04], Dn = [0, -.15, .04], L = [-.1, 0, .04], Rt = [.1, 0, .04];
  const tr = [N, U, Rt, N, Rt, Dn, N, Dn, L, N, L, U, T, Rt, U, T, Dn, Rt, T, L, Dn, T, U, L, T, [0, .25, -.62], [0, .02, -.48], T, [0, -.02, -.48], [0, -.25, -.62], U, [0, .3, -.14], [0, .11, -.2]];
  const P = [], CC = []; tr.forEach(v => { P.push(...v); const b = v[1] < -.05 ? 1.35 : v[1] > .1 ? .72 : 1; CC.push(b, b, b); });
  const g = new THREE.BufferGeometry(); g.setAttribute('position', new THREE.Float32BufferAttribute(P, 3)); g.setAttribute('color', new THREE.Float32BufferAttribute(CC, 3)); g.computeVertexNormals(); return g;
})();
const SCH = [[0, 7, -24, 48, C.gold], [-30, 10, 8, 40, C.orange], [30, 9, -14, 44, C.teal], [-22, 13, -62, 36, C.gold], [16, 7, 24, 34, C.orange], [52, 12, -50, 30, C.teal]];
const schools = SCH.map(([x, y, z, n, c], si) => {
  const s = { home: V(x, y, z), c: V(x, y, z), yaw: R(0, 6.28), pitch: 0, ty: 0, tp: 0, sp: R(2.4, 3.4), tm: R(1, 4), fish: [] }, k = 1 + n / 40;
  s.ty = s.yaw;
  for (let i = 0; i < n; i++) {
    const of = V(R(-1, 1), R(-1, 1), R(-1, 1)); if (of.lengthSq() > 1) { i--; continue; }
    of.multiply(V(2.8 * k, 1.4 * k, 4 * k));
    s.fish.push({ o: of, p: s.c.clone().add(of), v: V(), sc: R(.75, 1.15) * (si % 2 ? 1 : .85), c: c.clone().multiplyScalar(R(.8, 1.2)) });
  }
  return s;
});
const allFish = schools.flatMap(s => s.fish), fph = new Float32Array(allFish.length);
for (let i = 0; i < fph.length; i++) fph[i] = rnd();
fishGeo.setAttribute('aPh', new THREE.InstancedBufferAttribute(fph, 1));
const fishMesh = inst(fishGeo, patch(new THREE.MeshLambertMaterial({ vertexColors: true, side: THREE.DoubleSide }), { key: 'fish', attr: 'attribute float aPh;\n', vert: 'float fz=max(0.,.12-position.z);transformed.x+=sin(uT*11.+aPh*6.283+position.z*5.)*fz*fz*.32;', cw: '.5', ck: '.45' }), allFish.map(() => new THREE.Matrix4()), allFish.map(f => f.c));
const eu = new THREE.Euler(0, 0, 0, 'YXZ'), sq = new THREE.Quaternion();
function updFish(dt, t) {
  let idx = 0;
  for (const s of schools) {
    if ((s.tm -= dt) < 0) { s.tm = R(4, 8); s.ty = s.yaw + R(.9, 2.3) * (rnd() < .5 ? -1 : 1); s.tp = R(-.2, .2); }
    const hx = s.home.x - s.c.x, hz = s.home.z - s.c.z;
    if (hx * hx + hz * hz > 900) s.ty = s.yaw + wrapA(Math.atan2(hx, hz) - s.yaw);
    for (const c of cols) { const dx = s.c.x - c.x, dz = s.c.z - c.z, rr = c.rh + 5; if (dx * dx + dz * dz < rr * rr && s.c.y < c.y + c.rv + 4) { s.ty = s.yaw + wrapA(Math.atan2(dx, dz) - s.yaw); break; } }
    const fy = H(s.c.x, s.c.z); if (s.c.y < fy + 4) s.tp = .3; else if (s.c.y > SURF - 7) s.tp = -.3;
    s.yaw += Math.max(-1.2 * dt, Math.min(1.2 * dt, wrapA(s.ty - s.yaw)));
    s.pitch += (s.tp - s.pitch) * Math.min(1, dt * 1.5);
    eu.set(-s.pitch, s.yaw, 0); sq.setFromEuler(eu); fw.set(0, 0, 1).applyQuaternion(sq);
    s.c.addScaledVector(fw, s.sp * dt);
    for (const f of s.fish) {
      tg.copy(f.o).applyQuaternion(sq).add(s.c); tg.y += Math.sin(t * 1.3 + f.sc * 20) * .25;
      tmp.subVectors(f.p, pp); const dd = tmp.length(); if (dd < 7) tg.addScaledVector(tmp, (7 - dd) / Math.max(dd, .1) * 1.1);
      tv.copy(fw).multiplyScalar(s.sp).sub(f.v);
      f.v.addScaledVector(tmp.subVectors(tg, f.p), 3 * dt).addScaledVector(tv, 2.4 * dt);
      f.p.addScaledVector(f.v, dt);
      dummy.position.copy(f.p); dummy.lookAt(tmp.copy(f.p).add(f.v.lengthSq() > .01 ? f.v : fw)); dummy.scale.setScalar(f.sc); dummy.updateMatrix();
      fishMesh.setMatrixAt(idx++, dummy.matrix);
    }
  }
  fishMesh.instanceMatrix.needsUpdate = true;
}

/* ---------- manta rays ---------- */
const mantaGeo = (() => {
  const g = new THREE.PlaneGeometry(2, 2, 24, 12).rotateX(-Math.PI / 2), p = g.attributes.position;
  for (let i = 0; i < p.count; i++) {
    const x = p.getX(i), z = p.getZ(i), ax = Math.abs(x), lead = 1.35 - 2.15 * Math.pow(ax, 1.15), trail = -1.25 + .38 * Math.pow(ax, .8), t = (z + 1) / 2;
    p.setXYZ(i, x * 3.4, .28 * Math.exp(-x * x * 10) * (1 - (2 * t - 1) ** 2), (trail + t * (lead - trail)) * 1.5);
  }
  g.computeVertexNormals(); return g;
})();
const mantaMat = patch(new THREE.MeshLambertMaterial({ color: 0x1d4f7a, side: THREE.DoubleSide }), { key: 'manta', vert: 'float mx=abs(position.x);float mq=modelMatrix[3].x*.05+modelMatrix[3].z*.04;transformed.y+=sin(uT*1.5+mq-mx*.45)*mx*mx*.085;', frag: 'if(!gl_FrontFacing)diffuseColor.rgb=vec3(.42,.72,.66);', cw: 'max(vWN.y,0.)*.5', ck: '.4' });
const tailGeo = new THREE.ConeGeometry(.07, 3.4, 5).rotateX(-Math.PI / 2).translate(0, 0, -3.5);
const MP = [[0, 21, -40, 34, 26, .11, 0], [-30, 24, 2, 28, 38, -.09, 2], [22, 22, 10, 36, 28, .08, 4]];
const mantas = MP.map(() => { const m = new THREE.Mesh(mantaGeo, mantaMat); m.add(new THREE.Mesh(tailGeo, mantaMat)); m.scale.setScalar(R(.85, 1.15)); scene.add(m); return m; });
function updMantas(t) {
  MP.forEach(([cx, cy, cz, rx, rz, w, ph], i) => {
    const a = t * w + ph, m = mantas[i];
    m.position.set(cx + rx * Math.cos(a), cy + 2.5 * Math.sin(t * .37 + ph), cz + rz * Math.sin(a));
    m.lookAt(tmp.set(-rx * w * Math.sin(a), .925 * Math.cos(t * .37 + ph), rz * w * Math.cos(a)).add(m.position));
    m.rotateZ(Math.sign(w) * .22 + Math.sin(t * .6 + ph) * .06);
  });
}

/* ---------- bubbles and drifting specks ---------- */
const NB = 360, bPos = new Float32Array(NB * 3), bS = new Float32Array(NB), bubs = [];
const vents = [V(SX + 1, 0, SZ + 2), V(3, 0, -13), V(-26, 0, -16), V(34, 0, 8)]; vents.forEach(v => v.y = H(v.x, v.z));
function resetBub(b, init) {
  if (b.vi >= 0) { const v = vents[b.vi]; b.x = v.x + R(-.3, .3); b.z = v.z + R(-.3, .3); b.y = init ? R(v.y, SURF) : v.y + R(0, .5); b.s = R(.08, .28); }
  else { const a = R(0, 6.28), d = R(3, 30); b.x = pp.x + Math.cos(a) * d; b.z = pp.z + Math.sin(a) * d; const fy = H(b.x, b.z); b.y = init ? R(fy, SURF) : fy + R(0, 2); b.s = R(.05, .16); }
  b.sp = 1.1 + b.s * 5 + R(0, .4);
}
for (let i = 0; i < NB; i++) { const b = { vi: i < 200 ? i % vents.length : -1, ph: R(0, 6.28) }; resetBub(b, true); bubs.push(b); }
const bubGeo = new THREE.BufferGeometry(); bubGeo.setAttribute('position', new THREE.BufferAttribute(bPos, 3)); bubGeo.setAttribute('aS', new THREE.BufferAttribute(bS, 1));
const bubbles = new THREE.Points(bubGeo, new THREE.ShaderMaterial({
  transparent: true, depthWrite: false, uniforms: { uH, uDen, uC: { value: col(0xd8fff4) } },
  vertexShader: 'attribute float aS;uniform float uH;varying float vD;void main(){vec4 mv=modelViewMatrix*vec4(position,1.);vD=-mv.z;gl_PointSize=clamp(aS*uH/max(vD,.1),1.,64.);gl_Position=projectionMatrix*mv;}',
  fragmentShader: 'uniform vec3 uC;uniform float uDen;varying float vD;void main(){vec2 c=gl_PointCoord*2.-1.;float r=length(c);if(r>1.)discard;float a=smoothstep(.55,.95,r)*(1.-smoothstep(.9,1.,r))*.9+(1.-smoothstep(0.,.45,length(c-vec2(-.35,-.35))))*.9+.06;a*=exp(-uDen*uDen*vD*vD*.8);gl_FragColor=vec4(uC,a);\n#include <colorspace_fragment>\n}'
}));
bubbles.frustumCulled = false; scene.add(bubbles);
{
  const n = 1400, p = new Float32Array(n * 3), s = new Float32Array(n);
  for (let i = 0; i < n; i++) { p[i * 3] = R(0, 60); p[i * 3 + 1] = R(0, 60); p[i * 3 + 2] = R(0, 60); s[i] = R(.4, 1); }
  const g = new THREE.BufferGeometry(); g.setAttribute('position', new THREE.BufferAttribute(p, 3)); g.setAttribute('aS', new THREE.BufferAttribute(s, 1));
  const snow = new THREE.Points(g, new THREE.ShaderMaterial({
    transparent: true, depthWrite: false, uniforms: { uH, uT, uDen, uC: { value: col(0xf6dca0) } },
    vertexShader: 'attribute float aS;uniform float uH,uT;varying float vD,vA;void main(){vec3 p=position;p.y+=uT*.12*(.4+aS);p.x+=sin(uT*.2+position.z)*.5;vec3 rel=mod(p-cameraPosition+30.,60.)-30.;vec4 mv=viewMatrix*vec4(cameraPosition+rel,1.);vD=-mv.z;vA=1.-smoothstep(18.,30.,length(rel));gl_PointSize=clamp(aS*uH*.04/max(vD,.1),1.,6.);gl_Position=projectionMatrix*mv;}',
    fragmentShader: 'uniform vec3 uC;uniform float uDen;varying float vD,vA;void main(){float r=length(gl_PointCoord*2.-1.);float a=(1.-smoothstep(.2,1.,r))*.45*vA*exp(-uDen*uDen*vD*vD*.6);gl_FragColor=vec4(uC,a);\n#include <colorspace_fragment>\n}'
  }));
  snow.frustumCulled = false; scene.add(snow);
}
function updBubbles(dt, t) {
  for (let i = 0; i < NB; i++) {
    const b = bubs[i]; b.y += b.sp * dt;
    if (b.y > SURF - .3 || (b.vi < 0 && (Math.abs(b.x - pp.x) > 36 || Math.abs(b.z - pp.z) > 36))) resetBub(b, false);
    bPos[i * 3] = b.x + Math.sin(t * 2.2 + b.ph + b.y * .6) * .25; bPos[i * 3 + 1] = b.y; bPos[i * 3 + 2] = b.z + Math.cos(t * 1.7 + b.ph) * .15; bS[i] = b.s;
  }
  bubGeo.attributes.position.needsUpdate = true; bubGeo.attributes.aS.needsUpdate = true;
}

/* ---------- collisions: never through rocks or the ship ---------- */
function pushV(a, b, v) { nrm.subVectors(b, a); const l = nrm.length(); if (l > 1e-6) { nrm.multiplyScalar(1 / l); const d = v.dot(nrm); if (d < 0) v.addScaledVector(nrm, -d); } }
function hull(p, v) {
  lp.copy(p).applyMatrix4(shipInv);
  const u = lp.z / SL; if (Math.abs(u) > 1.06) return;
  const uc = Math.max(-1, Math.min(1, u)), w0 = W(uc), d = D(uc), s = S(uc), top = s + .3 + PR, bot = s - d - PR;
  if (lp.y > top || lp.y < bot) return;
  const sn = Math.pow(Math.min(1, Math.max(0, (s - lp.y) / d)), 1 / 1.3), wy = w0 * Math.pow(Math.sqrt(Math.max(0, 1 - sn * sn)), .7) + PR;
  if (Math.abs(lp.x) > wy) return;
  o.copy(p);
  const px = wy - Math.abs(lp.x), py = top - lp.y, pz = SL * 1.06 - Math.abs(lp.z);
  if (px <= py && px <= pz) lp.x = (lp.x < 0 ? -1 : 1) * wy; else if (py <= pz) lp.y = top; else lp.z = (lp.z < 0 ? -1 : 1) * SL * 1.06;
  p.copy(lp.applyMatrix4(ship.matrixWorld)); pushV(o, p, v);
}
function collide(p, v) {
  for (let it = 0; it < 2; it++) {
    for (const c of cols) {
      const ax = c.rh + PR, ay = c.rv + PR; let qx = (p.x - c.x) / ax, qy = (p.y - c.y) / ay, qz = (p.z - c.z) / ax; const l2 = qx * qx + qy * qy + qz * qz;
      if (l2 < 1) { let l = Math.sqrt(l2); if (l < 1e-4) { qy = 1; l = 1; } o.copy(p); p.set(c.x + qx / l * ax, c.y + qy / l * ay, c.z + qz / l * ax); pushV(o, p, v); }
    }
    for (const s of segs) {
      tmp.subVectors(p, s.a); const t = Math.max(0, Math.min(1, tmp.dot(s.d) / s.l2)); tg.copy(s.a).addScaledVector(s.d, t); tmp.subVectors(p, tg);
      const dist = tmp.length(), rr = s.r + PR; if (dist < rr && dist > 1e-5) { o.copy(p); p.copy(tg).addScaledVector(tmp, rr / dist); pushV(o, p, v); }
    }
    for (const b of boxes) {
      lp.copy(p).applyMatrix4(b.inv); const dx = b.hx + PR - Math.abs(lp.x), dy = b.hy + PR - Math.abs(lp.y - b.cy), dz = b.hz + PR - Math.abs(lp.z);
      if (dx > 0 && dy > 0 && dz > 0) {
        o.copy(p);
        if (dz <= dx && dz <= dy) lp.z = (lp.z < 0 ? -1 : 1) * (b.hz + PR); else if (dx <= dy) lp.x = (lp.x < 0 ? -1 : 1) * (b.hx + PR); else lp.y = b.cy + (lp.y < b.cy ? -1 : 1) * (b.hy + PR);
        p.copy(lp.applyMatrix4(b.mw)); pushV(o, p, v);
      }
    }
    hull(p, v);
  }
  const fy = H(p.x, p.z) + 1.2; if (p.y < fy) { p.y = fy; if (v.y < 0) v.y = 0; }
  if (p.y > SURF - 1.5) { p.y = SURF - 1.5; if (v.y > 0) v.y = 0; }
  const r = Math.hypot(p.x, p.z); if (r > WORLD) { p.x *= WORLD / r; p.z *= WORLD / r; v.x *= .5; v.z *= .5; }
}

/* ---------- sound (synthesized) ---------- */
let AC = null, master = null, swimG = null, soundOn = false;
const sndBtn = $('snd');
function setSound(on) {
  soundOn = on; sndBtn.classList.toggle('off', !on);
  if (!AC) return;
  if (on && AC.state === 'suspended') AC.resume();
  master.gain.setTargetAtTime(on ? .6 : 0, AC.currentTime, .4);
}
function startAudio() {
  if (AC) { setSound(true); return; }
  try { AC = new (window.AudioContext || window.webkitAudioContext)(); } catch (e) { AC = null; return; }
  master = AC.createGain(); master.gain.value = 0; master.connect(AC.destination);
  const nb = AC.createBuffer(1, AC.sampleRate * 3, AC.sampleRate), d = nb.getChannelData(0); let l = 0;
  for (let i = 0; i < d.length; i++) { l = (l + .02 * (Math.random() * 2 - 1)) / 1.02; d[i] = l * 3.5; }
  const src = () => { const s = AC.createBufferSource(); s.buffer = nb; s.loop = true; s.start(); return s; };
  const lpf = AC.createBiquadFilter(); lpf.type = 'lowpass'; lpf.frequency.value = 320; const og = AC.createGain(); og.gain.value = .5;
  src().connect(lpf); lpf.connect(og); og.connect(master);
  const lfo = AC.createOscillator(); lfo.frequency.value = .07; const lg = AC.createGain(); lg.gain.value = .25; lfo.connect(lg); lg.connect(og.gain); lfo.start();
  [110, 164.81, 220, 277.18, 329.63].forEach((f, i) => {
    const os = AC.createOscillator(), g = AC.createGain(), tr = AC.createOscillator(), tgn = AC.createGain();
    os.frequency.value = f; os.detune.value = i % 2 ? 4 : -4; g.gain.value = .022; tr.frequency.value = .05 + i * .031; tgn.gain.value = .016;
    tr.connect(tgn); tgn.connect(g.gain); os.connect(g); g.connect(master); os.start(); tr.start();
  });
  const bp = AC.createBiquadFilter(); bp.type = 'bandpass'; bp.frequency.value = 500; bp.Q.value = .7; swimG = AC.createGain(); swimG.gain.value = 0;
  src().connect(bp); bp.connect(swimG); swimG.connect(master);
  setSound(true);
}
function bloop() {
  if (!AC || !soundOn) return;
  const t = AC.currentTime, os = AC.createOscillator(), g = AC.createGain(), f = 260 + Math.random() * 500;
  os.frequency.setValueAtTime(f, t); os.frequency.exponentialRampToValueAtTime(f * 2.6, t + .09);
  g.gain.setValueAtTime(.0001, t); g.gain.exponentialRampToValueAtTime(.05, t + .01); g.gain.exponentialRampToValueAtTime(.0001, t + .14);
  os.connect(g); let n = g; if (AC.createStereoPanner) { const pn = AC.createStereoPanner(); pn.pan.value = Math.random() * 1.6 - .8; g.connect(pn); n = pn; }
  n.connect(master); os.start(t); os.stop(t + .16);
}
sndBtn.addEventListener('click', () => { if (!AC) startAudio(); else setSound(!soundOn); });
document.addEventListener('visibilitychange', () => { if (!AC) return; if (document.hidden) AC.suspend(); else if (soundOn) AC.resume(); });

/* ---------- input: hold to glide, drag to turn ---------- */
const tipEl = $('tip'); let tipT = 0;
function setTip(s, sec) { tipEl.textContent = s; tipEl.style.opacity = 1; tipT = sec; }
let yaw = 0, pitch = -.05, yawAcc = 0, turnV = 0, holding = false, pid = null, lx = 0, ly = 0;
function endDemo() {
  demoOn = false; camera.getWorldDirection(tmp);
  yaw = Math.atan2(-tmp.x, -tmp.z); pitch = Math.asin(Math.max(-1, Math.min(1, tmp.y))); vel.set(0, 0, 0);
  setTip('Hold to glide · drag to turn', 5);
}
addEventListener('pointerdown', e => { if (demoOn && e.isTrusted) endDemo(); }, true);
cv.addEventListener('pointerdown', e => {
  if (pid !== null) return; pid = e.pointerId; holding = true; lx = e.clientX; ly = e.clientY;
  try { cv.setPointerCapture(pid); } catch (_) {}
  if (tipT > 1) tipT = 1;
});
cv.addEventListener('pointermove', e => {
  if (e.pointerId !== pid) return;
  const k = 2.6 / Math.max(240, Math.min(innerWidth, innerHeight)), dx = (e.clientX - lx) * k;
  yaw -= dx; yawAcc -= dx; pitch = Math.max(-1.25, Math.min(1.25, pitch - (e.clientY - ly) * k)); lx = e.clientX; ly = e.clientY;
});
const release = e => { if (e.pointerId === pid) { pid = null; holding = false; } };
['pointerup', 'pointercancel', 'lostpointercapture'].forEach(n => cv.addEventListener(n, release));
cv.addEventListener('contextmenu', e => e.preventDefault());
$('go').addEventListener('click', () => { $('ov').classList.add('hide'); startAudio(); setTip('Hold to glide · drag to turn', 6); });
if (DEMO) { $('ov').classList.add('hide'); setTip('Demo · touch anywhere to swim', 1e9); }

function resize() {
  const w = innerWidth, h = innerHeight; renderer.setSize(w, h);
  camera.aspect = w / h; camera.fov = w < h ? 74 : 62; camera.updateProjectionMatrix();
  uH.value = cv.height / (2 * Math.tan(THREE.MathUtils.degToRad(camera.fov) / 2));
}
addEventListener('resize', resize); resize();
camera.position.copy(pp); camera.rotation.set(pitch, yaw, 0);

/* ---------- main loop ---------- */
const clock = new THREE.Clock(); let t = 0, bubT = 2;
renderer.setAnimationLoop(() => {
  const dt = Math.min(clock.getDelta(), .05); t += dt; uT.value = t;
  if (demoOn) {
    const u = (t % 22) / 22; cP.getPoint(u, camera.position); camera.lookAt(cL.getPoint(u, tmp)); pp.copy(camera.position);
  } else {
    turnV += (yawAcc / Math.max(dt, 1e-3) - turnV) * Math.min(1, dt * 4); yawAcc = 0;
    camera.rotation.set(pitch, yaw, Math.max(-.22, Math.min(.22, turnV * .06)));
    fw.set(0, 0, -1).applyQuaternion(camera.quaternion);
    if (holding) vel.addScaledVector(fw, 9 * dt);
    vel.multiplyScalar(Math.exp(-1.4 * dt));
    pp.addScaledVector(vel, dt); collide(pp, vel);
    camera.position.set(pp.x, pp.y + Math.sin(t * .8) * .12, pp.z);
  }
  scene.fog.color.copy(FOG_D).lerp(FOG_S, Math.min(1, Math.max(0, pp.y / SURF)) * .55);
  sky.position.copy(camera.position); surf.position.x = camera.position.x; surf.position.z = camera.position.z;
  updFish(dt, t); updMantas(t); updBubbles(dt, t);
  if (AC && swimG) swimG.gain.setTargetAtTime(Math.min(.4, vel.length() * .06), AC.currentTime, .15);
  if ((bubT -= dt) < 0) { bubT = 1.5 + Math.random() * 3; bloop(); }
  if (tipT > 0 && (tipT -= dt) <= 0) tipEl.style.opacity = 0;
  renderer.render(scene, camera);
});
</script>
</body>
</html>