Skip to content
VibeCodeBench
Back to the app

The code

Swim the Kelp Garden by GPT-6.2 Sol

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

index.html

partly works · auto-checked (Checked by an automated pass. Not hand-played yet.)55.3 KB · 1,138 lines · loads cdn.jsdelivr.net/npm/[email protected]/build/three.min.js
Download
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
<meta name="theme-color" content="#08333e">
<title>Kelp Garden</title>
<style>
  :root{color-scheme:dark;--ink:#f5f4e3;--muted:#c1dcd3;--mint:#a9e6ca;--line:rgba(213,248,233,.26)}
  *{box-sizing:border-box}
  html,body{height:100%;margin:0;overflow:hidden;overscroll-behavior:none}
  body{background:radial-gradient(ellipse at 58% -18%,#87c9aa 0%,#2f8590 33%,#165567 61%,#092733 100%);color:var(--ink);font-family:system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif}
  #water,#water canvas,.vignette{position:fixed;inset:0;width:100%;height:100%}
  #water,#water canvas{display:block;touch-action:none;user-select:none;outline:none}
  #water{cursor:grab}
  body.swimming #water{cursor:grabbing}
  .vignette{pointer-events:none;background:linear-gradient(180deg,rgba(3,23,30,.39),transparent 25%,transparent 69%,rgba(3,22,26,.61)),radial-gradient(ellipse at 50% 45%,transparent 42%,rgba(4,27,34,.25) 100%)}
  .top,.bottom{position:fixed;left:0;right:0;display:flex;justify-content:space-between;pointer-events:none;padding-inline:clamp(17px,3.5vw,56px)}
  .top{top:0;align-items:flex-start;padding-top:max(25px,env(safe-area-inset-top))}
  .bottom{bottom:0;align-items:flex-end;padding-bottom:max(24px,env(safe-area-inset-bottom));gap:12px}
  .identity{display:flex;gap:14px;align-items:center;text-shadow:0 2px 24px #0b3943}
  .mark{width:47px;height:47px;border:1px solid var(--line);background:rgba(6,41,47,.38);border-radius:50%;display:grid;place-items:center;color:var(--mint);flex:none}
  h1{font:400 clamp(31px,4vw,53px)/.98 Georgia,"Times New Roman",serif;letter-spacing:-.055em;margin:0 0 3px}
  .actions{display:flex;gap:8px;pointer-events:auto}
  button{font:600 13px/1 system-ui,sans-serif;color:var(--ink);border:1px solid var(--line);background:rgba(6,39,44,.67);border-radius:999px;min-width:46px;min-height:46px;padding:0 14px;display:inline-flex;gap:8px;align-items:center;justify-content:center;cursor:pointer;touch-action:manipulation;backdrop-filter:blur(12px)}
  button.icon{padding:0}
  button[aria-pressed=true]{border-color:#a9e6ca;color:#dbffea;background:rgba(30,85,73,.82)}
  button:focus-visible{outline:2px solid #e8ffde;outline-offset:3px}
  svg{display:block;flex:none}
  .guide,.telemetry{display:flex;align-items:center;gap:11px;border:1px solid var(--line);background:rgba(6,34,38,.70);border-radius:15px;padding:10px 13px;min-height:58px;backdrop-filter:blur(10px);box-shadow:0 6px 25px #071e222e}
  .guide-icon{color:var(--mint);width:32px;height:32px;display:grid;place-items:center;background:#83d9b719;border-radius:8px}
  .guide strong{display:block;font-size:13px;font-weight:650;line-height:1.25}
  .guide span{display:block;color:var(--muted);font-size:11px;line-height:1.35;margin-top:2px}
  .touch-copy,.touch-icon,.tour-copy,body.touring .mouse-copy,body.touring .touch-copy,body.touring .turn-copy{display:none}
  body.touring .tour-copy{display:block}
  body.swimming .guide{border-color:#a9e6ca85}
  .place{margin:0 0 9px 2px;text-shadow:0 1px 8px #092830;color:#d7f0df;font-weight:650;font-size:10px;letter-spacing:.19em;text-transform:uppercase;display:flex;gap:8px;align-items:center}
  .place::before{content:"";width:6px;height:6px;border-radius:50%;background:#d5eaaa;box-shadow:0 0 10px #d5eaaa80}
  .compass{width:32px;height:32px;border:1px solid #b0dfcc48;border-radius:50%;display:grid;place-items:center;color:var(--mint)}
  .telemetry small{display:block;color:#b7d5cb;font-size:9px;letter-spacing:.17em;text-transform:uppercase}
  #depth{display:block;font-size:16px;font-weight:600;font-variant-numeric:tabular-nums;white-space:nowrap}
  #reticle{position:fixed;top:50%;left:50%;translate:-50% -50%;width:16px;height:16px;border:1px solid #e2f6db9c;border-radius:50%;pointer-events:none;opacity:0;transition:opacity .3s}
  body.swimming #reticle{opacity:1}
  #notice{position:fixed;inset:38% 10% auto;text-align:center;text-wrap:balance;text-shadow:0 1px 10px #002229;font-size:16px}
  #notice[hidden]{display:none}
  @media(pointer:coarse){.mouse-copy,.mouse-icon{display:none}.touch-copy,.touch-icon{display:block}}
  @media(max-width:570px){.top{padding-top:max(16px,env(safe-area-inset-top))}.bottom{padding-bottom:max(15px,env(safe-area-inset-bottom))}.identity{gap:8px;align-items:center;min-height:44px}.mark{width:34px;height:34px}.mark svg{width:20px}.actions{gap:5px}.actions button{min-width:44px;min-height:44px;padding:0}.actions .button-text{position:absolute;width:1px;height:1px;overflow:hidden;clip-path:inset(50%)}.guide,.telemetry{gap:7px;padding:8px;min-height:51px;border-radius:12px}.guide-icon,.compass{width:27px;height:27px}.guide strong{font-size:12px}.guide span{font-size:10px}#depth{font-size:14px}.place{font-size:9px}}
  @media(prefers-reduced-motion:reduce){#reticle{transition:none}}
</style>
</head>
<body>
<div id="water"></div>
<div class="vignette"></div>
<header class="top">
  <div class="identity">
    <div class="mark" aria-hidden="true"><svg width="25" height="25" viewBox="0 0 26 26" fill="none" stroke="currentColor" stroke-width="1.25" stroke-linecap="round"><path d="M3 14c3 0 3-4 6-4s3 4 6 4 3-4 6-4h2M3 19c3 0 3-4 6-4s3 4 6 4 3-4 6-4h2M12 5h5"/></svg></div>
    <h1>Kelp Garden</h1>
  </div>
  <div class="actions">
    <button id="tour" type="button" aria-label="Start scenic tour" aria-pressed="false"><svg width="17" height="17" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="12" cy="12" r="9"/><path d="m10 8 6 4-6 4z"/></svg><span class="button-text" id="tour-label">Scenic tour</span></button>
    <button id="reset" class="icon" type="button" aria-label="Return to the starting view" title="Return to the starting view"><svg width="19" height="19" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.65" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M4 11a8 8 0 1 1 2 6M4 5v6h6"/></svg></button>
  </div>
</header>
<div id="reticle" aria-hidden="true"></div>
<footer class="bottom">
  <div>
    <div class="place" id="place">The Shallows</div>
    <div class="guide">
      <div class="guide-icon" aria-hidden="true">
        <svg class="mouse-icon" width="17" height="20" viewBox="0 0 20 24" fill="none" stroke="currentColor" stroke-width="1.5"><rect x="4" y="2" width="12" height="19" rx="6"/><path d="M10 6v5"/></svg>
        <svg class="touch-icon" width="18" height="20" viewBox="0 0 20 24" fill="none" stroke="currentColor" stroke-width="1.45" stroke-linecap="round" stroke-linejoin="round"><path d="M7 13V5a1.5 1.5 0 0 1 3 0v7l2-2 4 1 2 2v4l-3 4H8l-4-6a1.5 1.5 0 0 1 2-2l2 2"/></svg>
      </div>
      <div><strong class="mouse-copy">Hold to swim</strong><strong class="touch-copy">Press and hold to swim</strong><span class="turn-copy">Drag to turn</span><strong class="tour-copy">Scenic tour</strong><span class="tour-copy">Touch or click to take over</span></div>
    </div>
  </div>
  <div class="telemetry"><div class="compass" aria-hidden="true"><svg id="needle" width="18" height="18" viewBox="0 0 20 20" fill="none"><path d="m10 2 4 13-4-3-4 3z" fill="currentColor"/></svg></div><div><small>Depth</small><output id="depth">15.3 m</output></div></div>
</footer>
<p id="notice" role="status" hidden></p>
<script src="https://cdn.jsdelivr.net/npm/[email protected]/build/three.min.js"></script>
<script>
(() => {
  'use strict';
  const host = document.getElementById('water');
  const notice = document.getElementById('notice');
  function unavailable() {
    notice.textContent = 'The garden couldn’t load. Reload with WebGL and access to the 3D library enabled.';
    notice.hidden = false;
  }
  if (!window.THREE) { unavailable(); return; }
  const T = window.THREE;
  let renderer;
  try {
    renderer = new T.WebGLRenderer({ antialias: true, alpha: false, powerPreference: 'high-performance' });
  } catch (error) { unavailable(); return; }
  host.appendChild(renderer.domElement);
  renderer.domElement.setAttribute('aria-label', 'Swimmable underwater garden');
  renderer.outputEncoding = T.sRGBEncoding;
  const scene = new T.Scene();
  scene.fog = new T.FogExp2(0x185d72, 0.023);
  const camera = new T.PerspectiveCamera(57, 1, .14, 162);
  const surfaceY = 20.9;
  const clockUniform = { value: 0 };
  const dprUniform = { value: 1 };
  const V = (x, y, z) => new T.Vector3(x, y, z);
  const C = hex => new T.Color(hex);
  const PI = Math.PI;
  const TAU = 2 * PI;
  const clamp = T.MathUtils.clamp;
  const mix = T.MathUtils.lerp;
  let seed = 927341;
  function random() {
    seed = (Math.imul(seed, 1664525) + 1013904223) >>> 0;
    return seed / 4294967296;
  }
  const range = (a, b) => mix(a, b, random());
  const pick = list => list[Math.floor(random() * list.length)];
  function floor(x, z) {
    return -.12 + .40 * Math.sin(x * .116 + z * .075) + .31 * Math.cos(z * .141 - x * .059)
      + .17 * Math.cos(x * .31 + z * .23) + .085 * Math.sin(x * .67 + z * .49);
  }
  scene.add(new T.HemisphereLight(0xa6e9e4, 0x68715b, 1.02));
  const sunlight = new T.DirectionalLight(0xffe5ae, 1.42);
  sunlight.position.set(16, 28, -23);
  scene.add(sunlight);
  const bounce = new T.DirectionalLight(0x67cfdb, .39);
  bounce.position.set(-12, 7, 18);
  scene.add(bounce);

  const commonLight = `
    float ribbons(vec2 p, float time) {
      vec2 q = p + .31 * vec2(sin(p.y*1.37-time*.64),sin(p.x*1.62+time*.57));
      float f = sin(q.x*1.5+sin(q.y*1.12+time*.43))
              + .73*sin(q.y*1.92+sin(q.x*.93-time*.36))
              + .24*cos((q.x-q.y)*2.21-time*.57);
      return exp(-12.0*abs(f))*(.55+.45*sin(q.y*.75+q.x*.68+time*.48)*sin(q.y*.75+q.x*.68+time*.48));
    }
  `;
  const kelpMotion = `
    attribute vec2 waterFlex;
    uniform float gardenTime;
  `;
  const kelpBend = `
    transformed.x += waterFlex.x * (.61*sin(gardenTime*.81 + waterFlex.y + position.y*.245)
                       + .32*sin(gardenTime*.47 + position.z*.33 + position.y*.19));
    transformed.z += waterFlex.x * (.48*cos(gardenTime*.69 + waterFlex.y + position.y*.22));
  `;
  const fishBend = `
    float tailWeight = pow(clamp((-position.x-.06)*2.0,0.0,1.4),1.55);
    float phase = 0.0;
    #ifdef USE_INSTANCING
      phase = instanceMatrix[3].x*.93+instanceMatrix[3].z*.69;
    #endif
    transformed.z += tailWeight*.13*sin(gardenTime*7.6+phase+position.x*2.8);
  `;
  const rayBend = `
    float wing = abs(position.x)/3.0;
    transformed.y += pow(wing,1.7)*.72*sin(gardenTime*1.44-wing*1.38-position.z*.23);
    transformed.x -= sign(position.x)*wing*wing*.075*sin(gardenTime*1.44-wing);
  `;
  function material(kind, settings = {}) {
    const mat = new T.MeshStandardMaterial(settings);
    mat.customProgramCacheKey = () => kind;
    mat.onBeforeCompile = shader => {
      shader.uniforms.gardenTime = clockUniform;
      const motion = kind === 'kelp' ? kelpBend : kind === 'fish' ? fishBend : kind === 'ray' ? rayBend : '';
      shader.vertexShader = (kind === 'kelp' ? kelpMotion : 'uniform float gardenTime;\n') +
        'varying vec3 gardenPoint;\n' + shader.vertexShader;
      shader.vertexShader = shader.vertexShader.replace('#include <begin_vertex>', '#include <begin_vertex>\n' + motion);
      shader.vertexShader = shader.vertexShader.replace('#include <project_vertex>', `
        vec4 gardenVertex = vec4(transformed,1.0);
        #ifdef USE_INSTANCING
          gardenVertex = instanceMatrix * gardenVertex;
        #endif
        gardenPoint = (modelMatrix * gardenVertex).xyz;
        #include <project_vertex>
      `);
      shader.fragmentShader = 'uniform float gardenTime;\nvarying vec3 gardenPoint;\n' + commonLight + shader.fragmentShader;
      const tint = {
        sand: `
          vec2 p=gardenPoint.xz;
          float ripple=pow(.5+.5*sin(p.y*9.9+p.x*2.45+1.8*sin(p.x*.7+p.y*.22)+.65*sin(p.y*1.8)),2.7);
          float speck=fract(sin(dot(floor(p*49.0),vec2(27.31,95.43)))*17341.63);
          float patch=.5+.5*sin(p.x*.31+p.y*.38+1.36*sin(p.y*.25-p.x*.13));
          diffuseColor.rgb*=.75+.20*ripple+.13*patch+.095*speck;
        `,
        stone: `
          float band=sin(gardenPoint.y*6.7+gardenPoint.x*.52+1.4*sin(gardenPoint.z*.78));
          float dapple=.5+.5*sin(gardenPoint.x*2.55+gardenPoint.z*2.9+gardenPoint.y*1.3);
          diffuseColor.rgb*=.85+.12*dapple+.067*band;
        `,
        wood: `
          float grain=sin(gardenPoint.y*64.0+gardenPoint.z*13.8+sin(gardenPoint.x*4.1)*1.24);
          diffuseColor.rgb*=.86+.12*grain+.11*sin(gardenPoint.y*19.1+gardenPoint.x*.41);
        `,
        kelp: `
          float translucence=.5+.5*sin(gardenPoint.y*.51+gardenPoint.z*.36);
          diffuseColor.rgb*=.94+.16*translucence;
        `
      }[kind] || '';
      shader.fragmentShader = shader.fragmentShader.replace('#include <color_fragment>', '#include <color_fragment>\n' + tint);
      const strength = { sand: '.48', stone: '.22', wood: '.15', kelp: '.073', coral: '.14', fish: '.08', ray: '.11' }[kind];
      if (strength) shader.fragmentShader = shader.fragmentShader.replace('#include <emissivemap_fragment>', `
        #include <emissivemap_fragment>
        vec2 lightPos = gardenPoint.xz + vec2(.37,-.23)*gardenPoint.y;
        float lightField = ribbons(lightPos*.82,gardenTime) + .41*ribbons(lightPos*1.27+vec2(1.5,-2.1),-gardenTime*.73);
        float locality=.68+.32*sin(lightPos.x*.12-lightPos.y*.091+gardenTime*.29);
        totalEmissiveRadiance += lightField*locality*` + strength + `*vec3(.53,.91,.73);
      `);
    };
    return mat;
  }
  function planeGeometry(size, divisions) {
    const geo = new T.PlaneGeometry(size, size, divisions, divisions);
    geo.rotateX(-PI / 2);
    return geo;
  }
  const sand = planeGeometry(176, 208);
  const sandPos = sand.attributes.position;
  for (let i = 0; i < sandPos.count; i++) sandPos.setY(i, floor(sandPos.getX(i), sandPos.getZ(i)));
  sand.computeVertexNormals();
  scene.add(new T.Mesh(sand, material('sand', { color: 0x9d9567, roughness: 1 })));

  const sky = new T.Mesh(new T.SphereGeometry(113, 32, 20), new T.ShaderMaterial({
    side: T.BackSide, depthWrite: false, fog: false,
    vertexShader: `varying vec3 aim; void main(){aim=position;gl_Position=projectionMatrix*modelViewMatrix*vec4(position,1.0);}`,
    fragmentShader: `
      varying vec3 aim;
      void main() {
        vec3 d=normalize(aim);
        float high=smoothstep(-.25,.69,d.y);
        vec3 water=mix(vec3(.072,.291,.382),vec3(.128,.535,.53),high);
        vec3 s=normalize(vec3(.30,.44,-.84));
        float glow=pow(max(0.,dot(d,s)),10.0)*high;
        water+=glow*vec3(.14,.16,.084);
        gl_FragColor=vec4(water,1.);
      }
    `
  }));
  sky.frustumCulled = false;
  sky.renderOrder = -10;
  scene.add(sky);

  const surface = new T.Mesh(planeGeometry(225, 78), new T.ShaderMaterial({
    side: T.DoubleSide,
    uniforms: { time: clockUniform },
    vertexShader: `
      uniform float time; varying vec3 point;
      void main() {
        vec3 p=position;
        p.y+=.22*sin(p.x*.54+p.z*.49+time*.87)+.13*cos(p.x*.96-p.z*.7-time*.67);
        point=(modelMatrix*vec4(p,1.0)).xyz;
        gl_Position=projectionMatrix*viewMatrix*vec4(point,1.0);
      }
    `,
    fragmentShader: commonLight + `
      uniform float time; varying vec3 point;
      void main() {
        vec2 p=point.xz;
        vec3 view=normalize(point-cameraPosition);
        float dist=length(point-cameraPosition);
        float vein=ribbons(p*.63,time*.92);
        float small=ribbons(p*1.53+vec2(1.1,4.0),-time*.71);
        float swell=.5+.5*sin(p.x*.57+p.y*.61+time*.76+.7*sin(p.y*.84-time*.53));
        float glimmer=pow(max(0.,dot(view,normalize(vec3(.26,.58,-.77)))),11.);
        float scatter=pow(max(0.,dot(view,normalize(vec3(.26,.58,-.77)))),42.);
        vec3 nearWater=mix(vec3(.12,.399,.417),vec3(.24,.59,.562),swell);
        nearWater+=vein*vec3(.18,.32,.254)+small*.125;
        nearWater+=glimmer*vec3(.24,.252,.121)+scatter*vec3(.40,.35,.19);
        vec3 farWater=vec3(.092,.368,.445)+glimmer*vec3(.15,.19,.12);
        gl_FragColor=vec4(mix(farWater,nearWater,exp(-dist*.019)),1.);
      }
    `
  }));
  surface.position.y = surfaceY;
  scene.add(surface);

  class Batch {
    constructor() { this.positions = []; this.colors = []; this.indices = []; }
    vertex(point, color) {
      const i = this.positions.length / 3;
      this.positions.push(point.x, point.y, point.z);
      this.colors.push(color.r, color.g, color.b);
      return i;
    }
    face(a, b, c) { this.indices.push(a, b, c); }
    quad(a, b, c, d) { this.indices.push(a, b, d, b, c, d); }
    geometry() {
      const geo = new T.BufferGeometry();
      geo.setAttribute('position', new T.Float32BufferAttribute(this.positions, 3));
      geo.setAttribute('color', new T.Float32BufferAttribute(this.colors, 3));
      geo.setIndex(this.indices);
      geo.computeVertexNormals();
      return geo;
    }
    mesh(mat, parent = scene) {
      const mesh = new T.Mesh(this.geometry(), mat);
      parent.add(mesh);
      return mesh;
    }
  }
  const up = V(0, 1, 0);
  function tube(batch, points, radii, sides, c1, c2) {
    let prev = -1;
    for (let j = 0; j < points.length; j++) {
      const tangent = points[Math.min(j + 1, points.length - 1)].clone().sub(points[Math.max(0, j - 1)]).normalize();
      const ref = Math.abs(tangent.y) > .9 ? V(1, 0, 0) : up;
      const normal = new T.Vector3().crossVectors(tangent, ref).normalize();
      const binormal = new T.Vector3().crossVectors(tangent, normal);
      const r = radii[j];
      const color = c1.clone().lerp(c2, j / Math.max(1, points.length - 1));
      const row = batch.positions.length / 3;
      for (let side = 0; side < sides; side++) {
        const angle = side * TAU / sides;
        const p = points[j].clone().addScaledVector(normal, r * Math.cos(angle)).addScaledVector(binormal, r * Math.sin(angle));
        batch.vertex(p, color.clone().multiplyScalar(.91 + .11 * Math.cos(angle - .6)));
      }
      if (prev >= 0) {
        for (let s = 0; s < sides; s++) {
          const next = (s + 1) % sides;
          batch.quad(prev + s, prev + next, row + next, row + s);
        }
      }
      prev = row;
    }
  }
  function bar(batch, a, b, width, height, color) {
    const dir = b.clone().sub(a).normalize();
    const side = new T.Vector3().crossVectors(dir, Math.abs(dir.y) > .94 ? V(0, 0, 1) : up).normalize();
    const rise = new T.Vector3().crossVectors(side, dir).normalize();
    const start = batch.positions.length / 3;
    for (const p of [a, b]) {
      for (const s of [[-1,-1], [1,-1], [1,1], [-1,1]]) {
        const point = p.clone().addScaledVector(side, s[0] * width / 2).addScaledVector(rise, s[1] * height / 2);
        batch.vertex(point, color.clone().multiplyScalar(s[1] > 0 ? 1 : .68));
      }
    }
    for (let i = 0; i < 4; i++) {
      const j = (i + 1) % 4;
      batch.quad(start+i, start+j, start+4+j, start+4+i);
    }
    batch.quad(start, start+3, start+2, start+1);
    batch.quad(start+4, start+5, start+6, start+7);
  }

  const solids = [];
  function ellipseSolid(x, y, z, rx, ry, rz, yaw = 0) {
    const cos = Math.cos(yaw), sin = Math.sin(yaw);
    solids.push(p => {
      const dx = p.x - x, dy = p.y - y, dz = p.z - z;
      if (Math.abs(dy) > ry || Math.abs(dx) > rx + rz || Math.abs(dz) > rx + rz) return false;
      const a = (cos * dx - sin * dz) / rx;
      const b = (sin * dx + cos * dz) / rz;
      return a*a + b*b + (dy/ry)**2 < 1;
    });
  }
  const shadowMat = new T.ShaderMaterial({
    transparent: true, depthWrite: false, polygonOffset: true, polygonOffsetFactor: -1,
    vertexShader: `varying vec2 local;void main(){local=uv*2.0-1.0;gl_Position=projectionMatrix*modelViewMatrix*vec4(position,1.0);}`,
    fragmentShader: `varying vec2 local;void main(){gl_FragColor=vec4(.044,.095,.098,.31*pow(max(0.,1.-dot(local,local)),1.9));}`
  });
  function shadow(x, z, width, depth, angle) {
    const g = new T.PlaneGeometry(2, 2, 12, 9);
    const a = g.attributes.position;
    for (let i = 0; i < a.count; i++) {
      const u = a.getX(i)*width, v = a.getY(i)*depth;
      const px = x + Math.cos(angle)*u + Math.sin(angle)*v;
      const pz = z - Math.sin(angle)*u + Math.cos(angle)*v;
      a.setXYZ(i, px, floor(px, pz) + .034, pz);
    }
    g.setIndex(Array.from(g.index.array).map((_, i, list) => i % 3 === 0 ? list[i] : list[i % 3 === 1 ? i + 1 : i - 1]));
    scene.add(new T.Mesh(g, shadowMat));
  }

  const stoneMaterial = material('stone', { vertexColors: true, roughness: 1, flatShading: true });
  const archMaterial = material('stone', { vertexColors: true, roughness: 1, flatShading: true, side: T.DoubleSide });
  const rockShapes = [];
  for (let k = 0; k < 5; k++) {
    const rock = new T.IcosahedronGeometry(1, k < 2 ? 1 : 2);
    const p = rock.attributes.position, colors = [];
    const base = C([0x354c4b,0x3c5650,0x435552,0x3b5750,0x4b5b4b][k]);
    const algae = C(0x5e693b);
    for (let i = 0; i < p.count; i++) {
      const x = p.getX(i), y = p.getY(i), z = p.getZ(i);
      const bulk = 1 + .115*Math.sin(x*5.2+z*4.9+k*3.1)*Math.cos(y*5.2-z*2.8);
      const tint = clamp(y*.38+.29+.24*Math.sin(x*8+z*3.4+k), 0, .78);
      const c = base.clone().lerp(algae, tint).multiplyScalar(.80+.24*Math.cos(x*2.9-y*4.6+z*2.31)**2);
      colors.push(c.r,c.g,c.b);
      p.setXYZ(i, x*bulk+(y*y)*.10, y*bulk, z*bulk);
    }
    rock.setAttribute('color', new T.Float32BufferAttribute(colors, 3));
    rock.computeVertexNormals();
    rockShapes.push(rock);
  }
  function rock(x, z, sx, sy, sz, yaw, lift = 0, keepsOut = true) {
    const y = floor(x,z) + sy * .39 + lift;
    const mesh = new T.Mesh(pick(rockShapes), stoneMaterial);
    mesh.position.set(x, y, z);
    mesh.scale.set(sx, sy, sz);
    mesh.rotation.y = yaw;
    scene.add(mesh);
    if (keepsOut) ellipseSolid(x,y,z,sx*1.3+.39,sy*1.3+.39,sz*1.3+.39,yaw);
    if (sx > .78 && lift === 0) shadow(x,z,sx*1.85,sz*1.7,yaw);
  }

  function arch(x,z,rx,ry,thickness,angle) {
    const base = floor(x,z) - .83;
    const batch = new Batch();
    const cross = 11, sections = 34;
    const dark = C(0x2f4b4a), moss = C(0x617149);
    for (let i = 0; i <= sections; i++) {
      const t = PI*i/sections;
      const cx = rx*Math.cos(t), cy = ry*Math.sin(t);
      const cz = .57*Math.sin(t*2.5)+.25*Math.cos(t*5.2);
      const slab = thickness*(.91+.15*Math.sin(t*7.5+.7)+.12*Math.cos(t*13.7));
      const center = V(x+cx*Math.cos(angle)+cz*Math.sin(angle),base+cy,z-cx*Math.sin(angle)+cz*Math.cos(angle));
      if (i % 2 === 0) ellipseSolid(center.x,center.y,center.z,slab*1.25+.56,slab*1.25+.56,slab*1.08+.56,angle);
      for (let j = 0; j < cross; j++) {
        const a = TAU*j/cross+.13*Math.sin(t*9.);
        const jag = slab*(1+.19*Math.sin(j*3.89+i*2.71)+.09*Math.cos(j*2.27-i*.61));
        const px = cx+Math.cos(t)*Math.cos(a)*jag;
        const py = cy+Math.sin(t)*Math.cos(a)*jag;
        const pz = cz+Math.sin(a)*jag*.93;
        const tone = clamp(.33+.27*Math.cos(a)+.19*Math.sin(i*.89+j*1.22),.04,.86);
        batch.vertex(V(x+px*Math.cos(angle)+pz*Math.sin(angle),base+py,z-px*Math.sin(angle)+pz*Math.cos(angle)),dark.clone().lerp(moss,tone));
        if (i) {
          const n=(j+1)%cross, r=i*cross, p0=(i-1)*cross;
          batch.quad(p0+j,p0+n,r+n,r+j);
        }
      }
    }
    batch.mesh(archMaterial);
    for (const s of [-1,1]) {
      const ax=x+s*rx*Math.cos(angle), az=z-s*rx*Math.sin(angle);
      rock(ax,az,thickness*1.63,thickness*1.45,thickness*1.46,angle);
      rock(ax+s*1.1,az+1.65,thickness*.98,thickness*.65,thickness*.90,angle+.6);
    }
  }
  arch(-9.0,-13.1,5.7,7.5,1.26,-.21);
  arch(15.8,-40.9,7.1,9.3,1.45,.24);
  for (const r of [
    [-13,5.9,2.6,2.5,2.2,-.3],[-10.5,6.7,1.85,1.07,1.35,.6],[-17,-2,3.1,2.75,2.2,.3],
    [13.6,5.8,2.9,2.3,1.9,.5],[10.7,3.4,1.7,1.25,1.32,-.5],[18.4,-7,2.6,2.4,2.96,.9],
    [-19.4,-9.9,3.8,2.26,2.56,1.1],[0,-27.2,3.3,2.1,2.57,.3],[-22,-27,4.9,3.3,3.5,-.5],
    [24,-20,5.8,3.4,4.1,.48],[-4.1,1.1,1.11,.72,1.02,.3],[4.6,5.8,1.13,.60,.94,-.8],
    [-1.9,-8.9,.86,.53,.91,.5],[3.9,-21.5,2.0,1.25,1.63,.4],[1.4,-13.6,1.25,.72,1.34,1.0]
  ]) rock(...r);
  const pebbles = new T.InstancedMesh(rockShapes[1], stoneMaterial, 420);
  const dummy = new T.Object3D();
  for (let i = 0; i < pebbles.count; i++) {
    const x = range(-48,48), z = range(-65,28), s = range(.085,.57);
    dummy.position.set(x,floor(x,z)+s*.20,z);
    dummy.rotation.set(range(-.6,.6),range(0,TAU),range(-.6,.6));
    dummy.scale.set(s*range(.9,1.7),s*range(.34,.73),s);
    dummy.updateMatrix();
    pebbles.setMatrixAt(i,dummy.matrix);
    pebbles.setColorAt(i,C(0xffffff).multiplyScalar(range(.73,1.15)));
    if (s > .39) ellipseSolid(x,dummy.position.y,z,dummy.scale.x*1.35+.33,dummy.scale.y*1.35+.33,s*1.35+.33,dummy.rotation.y);
  }
  scene.add(pebbles);

  const wreck = new T.Group();
  wreck.position.set(7.9,floor(7.9,-11.4)+.35,-11.4);
  wreck.rotation.set(.16,-.24,-.11,'YXZ');
  scene.add(wreck);
  shadow(7.9,-11.4,8.5,3.7,-.24);
  const wood = new Batch(), sail = new Batch();
  const planks = [0x684829,0x795333,0x65402a,0x875c36,0x593d2a,0x77563a].map(C);
  const frame = C(0x4e3629), rails = C(0x99653b), rope = C(0x5b5c44);
  const stations = [
    [-7.4,.18,.38,2.40],[-6.45,1.38,-.22,2.39],[-5.25,1.90,-.46,2.31],[-3.85,2.06,-.61,2.10],
    [-2.15,2.14,-.63,1.90],[-.35,2.18,-.61,1.85],[1.35,2.13,-.56,1.93],[2.95,1.95,-.44,2.04],
    [4.45,1.58,-.24,2.24],[5.77,1.03,.13,2.46],[6.8,.44,.61,2.86],[7.54,.065,1.58,3.31]
  ];
  function hullPoint(st,t,side) {
    const widen = .18+.82*Math.pow(Math.sin(t*PI*.53),.85);
    return V(st[0],mix(st[2],st[3],t),side*st[1]*widen);
  }
  for (const side of [-1,1]) {
    for (let n=0;n<9;n++) {
      const bandColor=pick(planks);
      for (let i=0;i<stations.length-1;i++) {
        if (side===1 && ((i===4&&n>=6)||(i===5&&n>=7)||(i===9&&n===7))) continue;
        const l=stations[i], r=stations[i+1], t0=n/9+.006, t1=(n+1)/9-.006;
        const tint=bandColor.clone().lerp(pick(planks),.32).multiplyScalar(range(.83,1.13));
        const q=[hullPoint(l,t0,side),hullPoint(r,t0,side),hullPoint(r,t1,side),hullPoint(l,t1,side)].map(v=>wood.vertex(v,tint));
        wood.quad(q[0],q[1],q[2],q[3]);
      }
    }
    for (let i=1;i<stations.length-1;i++) {
      const st=stations[i];
      const rib=[.05,.23,.42,.61,.78,1.015].map(t=>hullPoint(st,Math.min(1,t),side).add(V(0,t>1?.25:0,-side*.10)));
      tube(wood,rib,[.12,.125,.115,.105,.09,.065],6,frame,rails);
      if (i===4&&side===1) continue;
      const a=hullPoint(st,1,side).add(V(0,.22,0));
      const b=hullPoint(stations[i+1],1,side).add(V(0,.22,0));
      if (!(side===1&&i===5)) bar(wood,a,b,.17,.15,rails);
      bar(wood,hullPoint(st,.72,side).add(V(0,0,side*.055)),hullPoint(stations[i+1],.72,side).add(V(0,0,side*.055)),.14,.14,frame);
    }
  }
  for (let i=0;i<stations.length-1;i++) {
    const a=stations[i],b=stations[i+1];
    for (let j=-5;j<5;j++) {
      if ((i===4||i===5||i===6) && j>-4 && j<4) continue;
      if ((i===1||i===8)&&j===2) continue;
      const color=pick(planks).clone().multiplyScalar(range(.83,1.08));
      const p=[V(a[0],a[3]-.09,a[1]*(j/5+.012)),V(b[0],b[3]-.09,b[1]*(j/5+.012)),
        V(b[0],b[3]-.09,b[1]*((j+1)/5-.012)),V(a[0],a[3]-.09,a[1]*((j+1)/5-.012))].map(v=>wood.vertex(v,color));
      wood.quad(p[0],p[1],p[2],p[3]);
    }
    bar(wood,V(a[0],a[2]+.03,0),V(b[0],b[2]+.03,0),.30,.29,frame);
  }
  for (const st of stations.slice(2,9)) {
    bar(wood,V(st[0],st[3]-.16,-st[1]*.96),V(st[0],st[3]-.16,st[1]*.96),.15,.18,frame);
  }
  bar(wood,V(6.8,2.87,0),V(8.06,3.64,0),.22,.23,rails);
  bar(wood,V(-7.39,1.03,0),V(-7.61,2.62,0),.33,.28,frame);
  for (let j=-3;j<=3;j++) {
    const z=j*.34;
    bar(wood,V(-6.10,2.29,z),V(-6.19,3.03,z),.11,.14,rails);
    bar(wood,V(-6.18,3.01,z),V(-4.68,2.90,z+.04),.15,.10,pick(planks));
  }
  bar(wood,V(-6.18,3.01,-1.22),V(-6.18,3.01,1.22),.13,.16,frame);
  bar(wood,V(-4.68,2.90,-1.22),V(-4.68,2.90,1.22),.13,.16,frame);
  const mast1=[V(-2.78,.38,0),V(-2.94,5.75,-.25),V(-3.24,9.99,-.49)];
  const mast2=[V(2.4,.38,0),V(2.50,4.9,.16),V(2.60,7.73,.26)];
  tube(wood,mast1,[.27,.18,.105],9,frame,rails);
  tube(wood,mast2,[.22,.14,.075],9,frame,rails);
  const sparA=V(-4.97,8.02,-1.11),sparB=V(-.72,7.13,.97);
  const aftA=V(1.22,6.26,-1.17),aftB=V(4.3,6.45,1.24);
  tube(wood,[sparA,sparB],[.12,.072],7,rails,frame);
  tube(wood,[aftA,aftB],[.087,.050],7,frame,rails);
  bar(wood,V(-3.15,8.77,-.76),V(-3.14,8.80,.05),.22,.15,frame);
  function cable(a,b,sag) {
    const points=[];
    for (let i=0;i<=8;i++) {
      const t=i/8;
      points.push(a.clone().lerp(b,t).add(V(0,-Math.sin(t*PI)*sag,.02*Math.sin(t*TAU))));
    }
    tube(wood,points,points.map(()=>.027),5,rope,rope);
    return points;
  }
  const cables=[
    cable(mast1[2],mast2[2],.83),cable(mast1[2],V(-6.3,2.5,-.57),.34),
    cable(mast1[2],V(-5.2,2.37,1.68),.56),cable(mast1[2],V(-5.2,2.37,-1.68),.32),
    cable(mast2[2],V(7.88,3.57,.06),.44),cable(mast2[2],V(3.72,2.05,1.66),.31),
    cable(sparA,V(-6.1,2.3,-.83),.48),cable(aftB,V(5.19,2.3,1.05),.34)
  ];
  for (let j=0;j<8;j++) {
    const t=.18+j*.074;
    const a=mast1[2].clone().lerp(V(-5.2,2.37,1.68),t);
    const b=mast1[2].clone().lerp(V(-6.3,2.5,-.57),t);
    cable(a,b,.04+t*.09);
  }
  function tornSail(a,b,drop,tint) {
    const strips=24, rows=8, first=sail.positions.length/3;
    for (let j=0;j<=rows;j++) {
      const v=j/rows;
      for (let i=0;i<=strips;i++) {
        const u=i/strips;
        const l=.37+.49*Math.sin(u*PI)+.13*Math.sin(u*19.7)+.12*Math.cos(u*50.5);
        const p=a.clone().lerp(b,u);
        p.y-=v*drop*l;
        p.x+=v*(.19+.31*Math.sin(u*PI));
        p.z+=.58*Math.sin(v*PI*.85)*Math.sin(u*PI)+.13*Math.sin(u*23+v*3)*v;
        sail.vertex(p,tint.clone().multiplyScalar(.83+.12*Math.cos(u*21.5)+v*.10));
        if (i&&j && !(j>4 && ((i>11&&i<15&&j>=7)||(i===5&&j>=6)))) {
          const k=first+j*(strips+1)+i;
          sail.quad(k-strips-2,k-strips-1,k,k-1);
        }
      }
    }
  }
  tornSail(sparA.clone().lerp(sparB,.13),sparA.clone().lerp(sparB,.97),2.96,C(0x9b8b56));
  tornSail(aftA.clone().lerp(aftB,.07),aftA.clone().lerp(aftB,.63),1.50,C(0x697b5a));
  wood.mesh(material('wood',{vertexColors:true,roughness:.96,side:T.DoubleSide}),wreck);
  sail.mesh(material('cloth',{vertexColors:true,roughness:.96,side:T.DoubleSide}),wreck);
  wreck.updateMatrixWorld(true);
  const shipInverse = wreck.matrixWorld.clone().invert();
  const local = new T.Vector3();
  const rigParts = [
    [mast1[0],mast1[2],.48],[mast2[0],mast2[2],.45],[sparA,sparB,.43],[aftA,aftB,.42],
    [sparA.clone().add(V(0,-1.4,0)),sparB.clone().add(V(0,-1.4,.63)),1.43],
    [aftA.clone().add(V(0,-.55,0)),aftA.clone().lerp(aftB,.66).add(V(0,-.55,.36)),.95]
  ];
  for (const points of cables) for (let i=1;i<points.length;i++) rigParts.push([points[i-1],points[i],.35]);
  const rig = rigParts.map(([a,b,r])=>({a,line:b.clone().sub(a),r:r*r}));
  const diff = new T.Vector3();
  solids.push(p=>{
    local.copy(p).applyMatrix4(shipInverse);
    if (local.x < -8.6 || local.x > 8.7 || local.y < -1.3 || local.y > 10.6 || Math.abs(local.z)>3.3) return false;
    if (local.y < (local.x < -4.5 || local.x > 5.7 ? 3.61 : 2.71)) {
      const i=stations.findIndex(s=>s[0]>=local.x);
      const a=stations[Math.max(0,i<0?stations.length-2:i-1)], b=stations[Math.max(1,i<0?stations.length-1:i)];
      const width=mix(a[1],b[1],clamp((local.x-a[0])/(b[0]-a[0]),0,1));
      if (Math.abs(local.z)<width+.68) return true;
    }
    for (const segment of rig) {
      diff.copy(local).sub(segment.a);
      const t=clamp(diff.dot(segment.line)/segment.line.lengthSq(),0,1);
      if (diff.addScaledVector(segment.line,-t).lengthSq()<segment.r) return true;
    }
    return false;
  });

  const kelp = new Batch(), flex = [];
  const kelpGreens = [0x3e6c35,0x527f3b,0x3a713e,0x4c7840,0x6d8a40,0x326d50];
  function plant(x,z,h,size) {
    const begin=kelp.positions.length/3, y=floor(x,z)-.04, phase=range(0,TAU);
    const lean=range(.24,1.4)*h/12, slant=range(0,TAU);
    const base=C(pick(kelpGreens)), young=base.clone().lerp(C(0xa7aa49),range(.18,.43));
    function spine(t) {
      return V(x+Math.cos(slant)*t*t*lean+.23*Math.sin(t*8+phase)*t,
        y+t*h,z+Math.sin(slant)*t*t*lean+.28*Math.sin(t*6+phase)*t);
    }
    const points=[], radii=[];
    for(let i=0;i<=14;i++) {
      points.push(spine(i/14));
      radii.push(size*mix(.10,.018,i/14));
    }
    tube(kelp,points,radii,5,base.clone().multiplyScalar(.62),young);
    const count=Math.min(18, Math.max(4, Math.round(h*.96)));
    for(let f=0;f<count;f++) {
      const t=.12+f/count*.855;
      const root=spine(t);
      const a=phase+f*2.405+range(-.31,.31);
      const dx=Math.cos(a), dz=Math.sin(a);
      const length=(.69+1.90*Math.sin(PI*(.09+t*.83)))*size*range(.68,1.23);
      const width=length*range(.12,.22);
      const tipLift=length*range(.15,.79);
      const curl=range(-.77,.77);
      const color=base.clone().lerp(young,range(.02,.89));
      const cols=4, steps=10;
      for(let j=0;j<=steps;j++) {
        const u=j/steps;
        const spread=width*(.028+.97*Math.pow(Math.sin(PI*u),.67));
        const extension=length*u;
        const bendX=dx*extension-dz*curl*u*u, bendZ=dz*extension+dx*curl*u*u;
        for(let k=0;k<=cols;k++) {
          const across=k/cols*2-1;
          const ripple=Math.sin(u*17+across*2.7+phase+f)*length*.054*across*across;
          const rise=tipLift*Math.sin(u*1.77)-length*.28*u*u*u;
          const p=V(root.x+bendX-dz*spread*across,root.y+rise+ripple-(1-across*across)*.13*spread,root.z+bendZ+dx*spread*across);
          const value=.74+.18*(1-Math.abs(across))+.13*Math.cos(u*18+f)*Math.cos(u*18+f);
          const tint=color.clone().lerp(young,u*.34).multiplyScalar(value+(k===2?.14:0));
          const i=kelp.vertex(p,tint);
          if(j&&k) kelp.quad(i-cols-2,i-cols-1,i,i-1);
        }
      }
    }
    for(let i=begin;i<kelp.positions.length/3;i++) {
      const t=clamp((kelp.positions[i*3+1]-y)/h,0,1.18);
      flex.push(t*t*Math.min(1.65,.54+h*.054),phase);
    }
  }
  for (const g of [
    [-14,9,5,8,23,9,19,1.24],[13.4,8.6,4.9,9.5,24,9,19,1.18],
    [-21,-10,7,14,27,7,19,1.06],[21,-11,6,13,27,7,19,.98],
    [-15,-32,19,8,35,6,19,.94],[18,-38,20,15,38,6,19,.96],[-4,-54,29,11,37,7,18,.92],
    [-6.6,4,2.0,5,13,1.5,4.7,.58],[6.5,4.4,2.3,5,13,1.2,4.7,.59],
    [-19,16,6,13,12,2.5,11,.91],[19,18,5,12,12,2.5,11,.89]
  ]) {
    const [x,z,sx,sz,count,lo,hi,scale]=g;
    for (let i=0;i<count;i++) {
      const a=range(0,TAU), r=Math.sqrt(random());
      plant(x+Math.cos(a)*r*sx,z+Math.sin(a)*r*sz,range(lo,hi),range(.67,1.16)*scale);
    }
  }
  const kelpGeo=kelp.geometry();
  kelpGeo.setAttribute('waterFlex',new T.Float32BufferAttribute(flex,2));
  scene.add(new T.Mesh(kelpGeo,material('kelp',{vertexColors:true,roughness:.78,side:T.DoubleSide})));

  const coral=new Batch();
  const coralColors=[
    [C(0x7c452e),C(0xe08948),C(0xffc27a)],
    [C(0x6e5833),C(0xcf9548),C(0xf0cb71)],
    [C(0x365d50),C(0x538a6a),C(0x9fbe7a)],
    [C(0x8c4730),C(0xc5633c),C(0xf2a160)]
  ];
  function colony(x,z,s,color,lift=0) {
    const root=V(x,floor(x,z)-.025+lift,z);
    const [base,mid,tip]=coralColors[color];
    const count=Math.round(range(5,9));
    for(let i=0;i<count;i++) {
      const angle=range(0,TAU), dist=range(.07,.56)*s;
      const start=root.clone().add(V(Math.cos(angle)*dist*.43,0,Math.sin(angle)*dist*.43));
      const h=s*range(.44,1.01);
      const pts=[];
      for(let j=0;j<=6;j++) {
        const t=j/6, bend=Math.pow(t,1.45)*dist;
        pts.push(start.clone().add(V(Math.cos(angle)*bend+Math.sin(t*4+i)*s*.048*t,h*t,Math.sin(angle)*bend)));
      }
      tube(coral,pts,pts.map((p,j)=>s*mix(.083,.021,j/6)),7,base,mid);
      for(let k=0;k<3;k++) {
        const n=2+k, a=angle+range(-1.48,1.48)+k*1.1, len=s*range(.15,.39);
        const p=pts[n], q=p.clone().add(V(Math.cos(a)*len*.77,len*.66,Math.sin(a)*len*.77));
        const end=q.clone().add(V(Math.cos(a)*len*.20,len*.47,Math.sin(a)*len*.20));
        tube(coral,[p,q,end,end.clone().add(V(0,len*.07,0))],[s*.048,s*.035,s*.017,s*.005],6,mid,tip);
        if (k<2) {
          const bud=q.clone().add(V(Math.cos(a+1.5)*len*.46,len*.30,Math.sin(a+1.5)*len*.46));
          tube(coral,[q,bud,bud.clone().add(V(0,len*.15,0))],[s*.031,s*.022,s*.009],6,mid,tip);
        }
      }
    }
  }
  function sponge(x,z,s,shade) {
    const [base,mid,tip]=coralColors[shade];
    for(let j=0;j<6;j++) {
      const a=range(0,TAU), d=range(.015,.46)*s, h=range(.25,.85)*s, r=range(.08,.19)*s;
      const cx=x+Math.cos(a)*d,cz=z+Math.sin(a)*d,y=floor(cx,cz);
      const rings=[[0,.58],[.22,.77],[.65,.93],[.95,1.14],[1,1.03],[.95,.77],[.67,.63],[.5,.05]];
      const sides=10;
      const n=coral.positions.length/3;
      rings.forEach(([t,rad],k)=>{
        for(let i=0;i<sides;i++) {
          const w=TAU*i/sides;
          const irregular=1+.1*Math.sin(w*3+j);
          const tint=k>=5?base.clone().multiplyScalar(k===5?.69:.41):base.clone().lerp(k===4?tip:mid,t);
          coral.vertex(V(cx+Math.cos(a)*h*t*t*.41+Math.cos(w)*r*rad*irregular,y+h*t+.03*Math.sin(w*2+a)*t,cz+Math.sin(a)*h*t*t*.41+Math.sin(w)*r*rad*irregular),tint);
          if(k) {
            const row=n+k*sides,prev=row-sides,q=(i+1)%sides;
            coral.quad(prev+i,prev+q,row+q,row+i);
          }
        }
      });
    }
  }
  function fan(x,z,s,angle,color) {
    const [base,mid,tip]=coralColors[color], y=floor(x,z)-.03;
    function at(u,v) {return V(x+Math.cos(angle)*u*s,y+v*s,z+Math.sin(angle)*u*s+Math.sin(v*4+u*2)*s*.075);}
    for(let j=-7;j<=7;j++) {
      const f=j/7,w=.71*f,h=.55+.53*Math.cos(f*1.44);
      const p=[at(0,0),at(w*.30,h*.28),at(w*.71,h*.69),at(w,h)];
      tube(coral,p,[.043*s,.032*s,.022*s,.009*s],5,base,tip);
      for(let k=2;k<=7;k++) {
        const t=k/8, u=w*t, v=h*t, n=j%2===0?1:-1;
        tube(coral,[at(u,v),at(u+n*.10*t,v+.07),at(u+n*.17*t,v+.17)],[.019*s,.013*s,.0045*s],5,mid,tip);
      }
    }
  }
  for(const c of [
    [-7.1,5.2,1.72,0],[-5.35,3.0,1.03,3],[-10.3,4.6,1.48,1],[-3.35,.40,.86,0],[-1.8,-5.7,.61,1],
    [6.6,4.8,1.58,3],[8.4,6.6,1.76,0],[10.0,5.8,1.21,1],[5.45,3.3,.98,2],[4.7,-3.8,1.12,0],
    [-11,-7.9,1.3,1],[-14.5,-9.4,1.4,0],[-5.1,-11.2,.95,3],[2.1,-9.0,.93,0],[13.2,-11.2,1.27,2],
    [15.3,-10.0,1.69,1],[-21,-6.4,1.39,2],[-1.4,-21.3,1.06,1],[9.35,-8.7,.55,3,.80]
  ]) colony(...c);
  for(const c of [[-6.4,6.1,1.2,1],[7.0,5.9,1.3,0],[4,1.2,.88,1],[-10.4,-6.1,1.16,0],[11.6,-6.3,1.27,3],[-5.1,-2.6,.85,2],[-3.2,-.8,.82,1],[12.8,1.0,1.2,2]]) sponge(...c);
  for(const c of [[-8.1,5.9,1.68,-.45,3],[8.1,3.2,1.44,.19,1],[-15.5,-5.6,1.43,.42,2],[3.5,-9.0,.88,.14,0],[12.9,-8.3,1.22,.17,3]]) fan(...c);
  for(let i=0;i<28;i++){
    const x=range(-36,36),z=range(-34,12);
    if(Math.abs(x)>6||z<0) colony(x,z,range(.32,1.0),Math.floor(random()*4));
  }
  coral.mesh(material('coral',{vertexColors:true,roughness:.86,side:T.DoubleSide}));

  function fishGeometry(main) {
    const b=new Batch(), gold=C(main), back=gold.clone().multiplyScalar(.47), belly=C(0xe4dc9b);
    const rings=[[-.46,.024,.026],[-.31,.092,.047],[-.12,.17,.082],[.10,.165,.106],[.28,.108,.076],[.39,.056,.045],[.43,.005,.008]];
    for(let i=0;i<rings.length;i++) {
      const [x,h,w]=rings[i];
      for(let j=0;j<10;j++) {
        const a=TAU*j/10, y=Math.cos(a);
        const color=gold.clone().lerp(y>0?back:belly,Math.abs(y)*.62);
        if(i===2||i===3) color.multiplyScalar(.86+.17*Math.abs(y));
        b.vertex(V(x,y*h,Math.sin(a)*w),color);
        if(i) b.quad((i-1)*10+j,(i-1)*10+(j+1)%10,i*10+(j+1)%10,i*10+j);
      }
    }
    function fin(points, tips, color) {
      const ids=points.map((p,i)=>b.vertex(V(...p),i===0?color:tips));
      for(let i=1;i<ids.length-1;i++) b.face(ids[0],ids[i],ids[i+1]);
    }
    fin([[-.40,0,0],[-.74,.235,0],[-.68,.071,0],[-.60,0,0],[-.70,-.09,0],[-.76,-.205,0]],back,gold);
    fin([[.12,.125,.01],[-.05,.252,0],[-.29,.231,0],[-.37,.067,0]],back,gold);
    for(const s of [-1,1]) {
      fin([[.14,-.025,s*.081],[-.18,-.113,s*.172],[-.03,-.126,s*.105]],back,gold);
      const x=.276,y=.024,z=s*.078, eye=C(0x102b2c), id=b.vertex(V(x,y,z+s*.004),eye);
      const rim=[];
      for(let j=0;j<8;j++) rim.push(b.vertex(V(x+.025*Math.cos(j*TAU/8),y+.024*Math.sin(j*TAU/8),z),eye));
      for(let j=0;j<8;j++) b.face(id,rim[j],rim[(j+1)%8]);
    }
    return b.geometry();
  }
  const fishMat=material('fish',{vertexColors:true,roughness:.61,side:T.DoubleSide});
  function school(count,color,params) {
    const mesh=new T.InstancedMesh(fishGeometry(color),fishMat,count);
    mesh.instanceMatrix.setUsage(T.DynamicDrawUsage);
    mesh.frustumCulled=false;
    scene.add(mesh);
    const members=[];
    for(let i=0;i<count;i++) {
      const a=range(0,TAU),r=Math.sqrt(random());
      members.push({along:range(-1,1)*params.width,across:Math.cos(a)*r*params.depth,
        y:Math.sin(a)*r*params.height, phase:range(0,TAU),size:range(.55,1.10)*params.size});
      mesh.setColorAt(i,C(0xffffff).multiplyScalar(range(.72,1.10)));
    }
    return {mesh,members,...params};
  }
  const schools=[
    school(53,0xe9a24b,{x:-4.7,y:8.8,z:-10.5,rx:8.6,rz:4.1,speed:.23,start:.01,width:4.8,depth:1.7,height:1.52,size:.96}),
    school(32,0xbfc789,{x:11.8,y:5.3,z:-14.7,rx:6.3,rz:4.6,speed:-.22,start:2.79,width:3.5,depth:1.75,height:1.15,size:.67}),
    school(45,0x65a6a0,{x:-6.8,y:10.8,z:-28.1,rx:10.4,rz:6,speed:.19,start:.36,width:6.5,depth:2.6,height:1.90,size:.85}),
    school(19,0xc98449,{x:1.1,y:2.35,z:-3.4,rx:4.3,rz:3.2,speed:.28,start:-2.5,width:2.35,depth:1.04,height:.73,size:.52})
  ];
  const across=new T.Vector3(), heading=new T.Vector3(), fishUp=new T.Vector3(), basis=new T.Matrix4();
  function animateFish(t) {
    for(const g of schools) {
      const a=g.start+t*g.speed;
      const x=g.x+g.rx*Math.sin(a), z=g.z+g.rz*Math.cos(a);
      const y=g.y+.75*Math.sin(a*1.7);
      heading.set(g.rx*Math.cos(a)*g.speed,1.275*Math.cos(a*1.7)*g.speed,-g.rz*Math.sin(a)*g.speed).normalize();
      across.crossVectors(heading,up).normalize();
      fishUp.crossVectors(across,heading);
      basis.makeBasis(heading,fishUp,across);
      for(let i=0;i<g.members.length;i++) {
        const m=g.members[i], pulse=Math.sin(t*1.24+m.phase);
        dummy.position.set(x,y+m.y+.15*pulse,z);
        dummy.position.addScaledVector(heading,m.along+.24*pulse).addScaledVector(across,m.across+.17*Math.cos(t*1.34+m.phase));
        dummy.quaternion.setFromRotationMatrix(basis);
        dummy.rotateY(.12*Math.sin(t*2.6+m.phase));
        dummy.rotateX(.13*Math.cos(t*2.0+m.phase));
        dummy.scale.setScalar(m.size);
        dummy.updateMatrix();
        g.mesh.setMatrixAt(i,dummy.matrix);
      }
      g.mesh.instanceMatrix.needsUpdate=true;
    }
  }

  function mantaGeometry() {
    const ray = new Batch();
    const profile=[
      [0,1.20,-1.27,.40],[.35,1.25,-1.15,.35],[.72,1.10,-.93,.24],[1.12,.86,-.88,.15],
      [1.59,.64,-1.01,.095],[2.03,.48,-1.04,.05],[2.43,.24,-.97,.035],[2.77,-.02,-.73,.023],[3.06,-.43,-.50,.002]
    ];
    const top=C(0x205b62), edging=C(0x123e48), pale=C(0x9cbdab), under=C(0x68998e);
    for(const sign of [-1,1]) for(const side of [-1,1]) {
      const n=ray.positions.length/3, rows=10;
      profile.forEach(([x,front,back,thick],i)=>{
        for(let j=0;j<=rows;j++) {
          const t=j/rows, radius=Math.sin(t*PI);
          const y=radius*thick*side-.105*(x/3)**2;
          const color=side>0?top.clone().lerp(edging,clamp(i*.043+(1-radius)*.50,0,1)):
            under.clone().lerp(pale,clamp(radius*.64+(1-x/3)*.37,0,1)).lerp(edging,Math.pow(1-radius,5)*.78);
          const v=ray.vertex(V(x*sign,y,mix(front,back,t)),color);
          if(i&&j) {
            const a=v-rows-2,b=v-rows-1,c=v,d=v-1;
            if(sign===side) ray.quad(a,b,c,d); else ray.quad(d,c,b,a);
          }
        }
      });
    }
    tube(ray,[V(0,.00,-.97),V(0,-.026,-1.45),V(.035,-.08,-2.08),V(.18,-.13,-2.88),V(.33,-.18,-3.49)],[.105,.067,.039,.019,.004],7,top,edging);
    for(const s of [-1,1]) {
      tube(ray,[V(s*.34,-.006,1.05),V(s*.46,-.06,1.24),V(s*.48,-.18,1.48),V(s*.36,-.23,1.60)],[.14,.118,.078,.022],8,top,under);
      tube(ray,[V(s*.52,.047,1.04),V(s*.55,.043,1.108)],[.052,.029],7,edging,C(0x102d32));
      for(let j=0;j<4;j++) {
        const z=.56-j*.122;
        tube(ray,[V(s*.14,-.36+j*.006,z),V(s*.36,-.325+j*.008,z+.08)],[.008,.008],4,under,edging);
      }
    }
    return ray.geometry();
  }
  const rayGeo=mantaGeometry(), rayMat=material('ray',{vertexColors:true,side:T.DoubleSide,roughness:.66});
  const rays=[
    {x:1.4,y:11.0,z:-11.3,rx:9.8,rz:6.0,a:.16,w:.14,scale:1.15},
    {x:15.6,y:13.3,z:-26.2,rx:8.3,rz:7.2,a:2.91,w:-.17,scale:.88},
    {x:-18,y:10.8,z:-26.6,rx:10.1,rz:8.4,a:3.5,w:.111,scale:.85}
  ];
  for(const r of rays) {
    r.mesh=new T.Mesh(rayGeo,rayMat);
    r.mesh.scale.setScalar(r.scale);
    scene.add(r.mesh);
  }
  function animateRays(t){
    for(const r of rays) {
      const a=r.a+t*r.w;
      r.mesh.position.set(r.x+r.rx*Math.sin(a),r.y+1.15*Math.sin(a*1.39+t*.12),r.z+r.rz*Math.cos(a));
      r.mesh.rotation.set(.02+.19*Math.sin(a-1),Math.atan2(r.rx*Math.cos(a)*r.w,-r.rz*Math.sin(a)*r.w),-.23*Math.cos(a+.6),'YXZ');
    }
  }

  const beams=[];
  for(let i=0;i<19;i++) {
    const origin=V(11.5+range(-8,14),surfaceY-.20,-16+range(-23,20));
    const end=origin.clone().add(V(range(-15,-5),range(-24.8,-20.8),range(3,12)));
    const geo=new T.BufferGeometry();
    geo.setAttribute('position',new T.BufferAttribute(new Float32Array(12),3).setUsage(T.DynamicDrawUsage));
    geo.setAttribute('uv',new T.Float32BufferAttribute([0,0,1,0,0,1,1,1],2));
    geo.setIndex([0,1,2,2,1,3]);
    const beam=new T.Mesh(geo,new T.ShaderMaterial({
      side:T.DoubleSide,transparent:true,depthWrite:false,blending:T.AdditiveBlending,
      uniforms:{time:clockUniform,strength:{value:range(.035,.115)},phase:{value:range(0,TAU)}},
      vertexShader:`varying vec2 st;void main(){st=uv;gl_Position=projectionMatrix*modelViewMatrix*vec4(position,1.0);}`,
      fragmentShader:`
        varying vec2 st;uniform float time,strength,phase;
        void main() {
          float profile=pow(max(0.,1.-abs(st.x*2.-1.)),2.25);
          float lengthFade=pow(1.-st.y,1.62)*smoothstep(0.,.074,st.y);
          float glint=.81+.19*sin(time*.73+phase+st.y*10.0);
          vec3 color=mix(vec3(.63,.91,.77),vec3(.28,.76,.79),st.y);
          gl_FragColor=vec4(color,strength*profile*lengthFade*glint);
        }
      `
    }));
    beam.frustumCulled=false; beam.renderOrder=3;
    scene.add(beam);
    beams.push({beam,origin,end,w:range(.47,2.45),phase:range(0,TAU)});
  }
  const beamSide=new T.Vector3(), beamDir=new T.Vector3(), beamView=new T.Vector3(), beamEnd=new T.Vector3();
  function animateBeams(t) {
    for(const b of beams) {
      beamEnd.copy(b.end);
      beamEnd.x+=Math.sin(t*.63+b.phase)*.75;
      beamDir.copy(beamEnd).sub(b.origin);
      beamView.copy(camera.position).sub(b.origin).addScaledVector(beamDir,-.5);
      beamSide.crossVectors(beamDir,beamView).normalize();
      const p=b.beam.geometry.attributes.position;
      for(let i=0;i<4;i++) {
        const q=i<2?b.origin:beamEnd;
        const w=b.w*(i<2?.39:1.6)*(i%2?1:-1);
        p.setXYZ(i,q.x+beamSide.x*w,q.y+beamSide.y*w,q.z+beamSide.z*w);
      }
      p.needsUpdate=true;
    }
  }

  function particles(bubbles) {
    const count=bubbles?280:940, positions=[], sizes=[], states=[];
    const vents=[[-9.3,5.1],[-6.4,1.8],[8.9,-8.9],[11.8,-12.5],[5.9,3.9],[-12.9,-12.7],[2.0,-17.8],[1.6,5.9],[14.7,-24.8]];
    for(let i=0;i<count;i++) {
      if(bubbles) {
        const [x,z]=vents[i%vents.length];
        const ox=x+range(-.69,.69),oz=z+range(-.69,.69);
        positions.push(ox,floor(ox,oz)+range(.15,.75),oz);
        sizes.push(range(.028,.105)*(i%9===0?1.55:1));
      } else {
        positions.push(range(-51,51),range(.5,20.3),range(-70,30));
        sizes.push(range(.013,.051));
      }
      states.push(random(),random());
    }
    const geo=new T.BufferGeometry();
    geo.setAttribute('position',new T.Float32BufferAttribute(positions,3));
    geo.setAttribute('particleSize',new T.Float32BufferAttribute(sizes,1));
    geo.setAttribute('state',new T.Float32BufferAttribute(states,2));
    const data = bubbles ? '#define BUBBLES\n' : '';
    const mat=new T.ShaderMaterial({
      uniforms:{time:clockUniform,pixelRatio:dprUniform},transparent:true,depthWrite:false,
      vertexShader:data+`
        uniform float time,pixelRatio;attribute float particleSize;attribute vec2 state;varying float alpha;varying float hue;
        void main() {
          vec3 p=position;
          #ifdef BUBBLES
            float lift=fract(state.x+time*(.035+state.y*.051));
            p.y+=lift*(13.0+state.y*6.4);
            p.x+=lift*1.64+sin(lift*18.+state.y*22.+time*.48)*.32;
            p.z+=cos(lift*14.+state.y*15.+time*.38)*.36;
            alpha=smoothstep(0.,.04,lift)*(1.-smoothstep(.77,1.,lift));
          #else
            p.x+=sin(time*.19+state.x*29.)*.44;
            p.y+=sin(time*.23+state.y*18.)*.29;
            p.z+=cos(time*.20+state.y*19.)*.43;
            alpha=.21+.45*state.y;
          #endif
          vec4 view=modelViewMatrix*vec4(p,1.);
          float d=-view.z;
          alpha*=exp(-max(0.,d)*.024)*smoothstep(.55,2.1,d);
          hue=state.y;
          gl_PointSize=clamp(particleSize*790.0*pixelRatio/max(d,.1),1.,33.);
          gl_Position=projectionMatrix*view;
        }
      `,
      fragmentShader:data+`
        varying float alpha,hue;
        void main() {
          vec2 q=(gl_PointCoord-.5)*2.;
          float r=length(q);
          if(r>1.) discard;
          #ifdef BUBBLES
            float ring=exp(-pow((r-.78)*6.7,2.))*smoothstep(1.,.84,r);
            float gleam=exp(-17.*length(q-vec2(-.29,-.46)));
            float glancing=pow(max(0.,dot(normalize(q+vec2(.01)),normalize(vec2(-.58,-.81)))),2.0);
            gl_FragColor=vec4(mix(vec3(.53,.84,.78),vec3(.93,1.,.89),glancing),alpha*(ring*(.26+glancing*.40)+gleam*.94+.031));
          #else
            gl_FragColor=vec4(mix(vec3(.57,.84,.78),vec3(1.,.87,.56),hue),alpha*(1.-smoothstep(.06,1.,r)));
          #endif
        }
      `
    });
    const p=new T.Points(geo,mat);
    p.frustumCulled=false; p.renderOrder=4;
    scene.add(p);
  }
  particles(false);
  particles(true);

  const start=V(0,5.65,13.7);
  const swimmer=start.clone();
  let yaw=.006,pitch=-.053,desiredYaw=yaw,desiredPitch=pitch,velocity=0;
  let pointer=null,lastX=0,lastY=0,touring=false,tourTime=0;
  const direction=new T.Vector3(), trial=new T.Vector3(), gaze=new T.Vector3(), step=new T.Vector3();
  const wreckZone=V(7.9,0,-11.4), archZone=V(-9,0,-13.1);
  const tourButton=document.getElementById('tour'),tourLabel=document.getElementById('tour-label');
  const needle=document.getElementById('needle'),depthText=document.getElementById('depth'),place=document.getElementById('place');
  const cameraPath=new T.CatmullRomCurve3([
    start.clone(),V(-6.8,5.45,9.8),V(-11.2,5.26,2.6),V(-10.4,5.9,-3.8),
    V(-4.6,6.05,-3),V(1.15,6.4,.45),V(7.8,7.22,2.95),V(7.9,8.25,9.1),V(3.6,6.25,14.1)
  ],true,'centripetal');
  const lookPath=new T.CatmullRomCurve3([
    V(.14,4.68,-7.5),V(-8.7,4,-10.4),V(-10.1,4.28,-15.6),V(-7.7,4.52,-16.8),
    V(5.5,4.3,-12.8),V(10.8,4.06,-15.3),V(9.0,5.7,-12.0),V(3.4,10.1,-8.4),V(-1.1,7.1,-8.5)
  ],true,'centripetal');

  function forward() {
    direction.set(Math.sin(yaw)*Math.cos(pitch),Math.sin(pitch),-Math.cos(yaw)*Math.cos(pitch));
  }
  function clear(p){
    if(Math.abs(p.x)>60||p.z<-74||p.z>47||p.y>surfaceY-.72||p.y<floor(p.x,p.z)+.87) return false;
    return !solids.some(test=>test(p));
  }
  function move(dx,dy,dz){
    const n=Math.max(1,Math.ceil(Math.hypot(dx,dy,dz)/.17));
    step.set(dx/n,dy/n,dz/n);
    for(let j=0;j<n;j++) {
      trial.copy(swimmer).add(step);
      if(clear(trial)){swimmer.copy(trial);continue;}
      trial.copy(swimmer);trial.x+=step.x;if(clear(trial))swimmer.x=trial.x;
      trial.copy(swimmer);trial.z+=step.z;if(clear(trial))swimmer.z=trial.z;
      trial.copy(swimmer);trial.y+=step.y;if(clear(trial))swimmer.y=trial.y;
    }
  }
  function releasePointer(event) {
    if(event&&pointer!==event.pointerId) return;
    pointer=null;
    document.body.classList.remove('swimming');
  }
  function setTour(on){
    touring=on;
    tourTime=0;
    velocity=0;
    releasePointer();
    document.body.classList.toggle('touring',on);
    tourButton.setAttribute('aria-pressed',String(on));
    tourButton.setAttribute('aria-label',on?'End scenic tour':'Start scenic tour');
    tourLabel.textContent=on?'End tour':'Scenic tour';
  }
  host.addEventListener('pointerdown',event=>{
    if(pointer!==null || (event.pointerType==='mouse'&&event.button!==0)) return;
    if(touring)setTour(false);
    pointer=event.pointerId;lastX=event.clientX;lastY=event.clientY;
    host.setPointerCapture(pointer);
    document.body.classList.add('swimming');
    event.preventDefault();
  });
  host.addEventListener('pointermove',event=>{
    if(event.pointerId!==pointer) return;
    const dx=event.clientX-lastX,dy=event.clientY-lastY;
    lastX=event.clientX;lastY=event.clientY;
    const sensitivity=event.pointerType==='touch'?.00535:.0045;
    desiredYaw+=dx*sensitivity;
    desiredPitch=clamp(desiredPitch-dy*sensitivity,-1.16,1.16);
  });
  host.addEventListener('pointerup',releasePointer);
  host.addEventListener('pointercancel',releasePointer);
  host.addEventListener('lostpointercapture',releasePointer);
  window.addEventListener('blur',()=>releasePointer());
  document.addEventListener('pointerdown',event=>{
    if(touring&&!host.contains(event.target)&&!tourButton.contains(event.target)) setTour(false);
  },true);
  tourButton.addEventListener('click',()=>{
    const begin=!touring;
    setTour(begin);
    if(begin)swimmer.copy(start);
  });
  document.getElementById('reset').addEventListener('click',()=>{
    setTour(false);
    swimmer.copy(start); yaw=desiredYaw=.006;pitch=desiredPitch=-.053;
  });
  if(location.hash==='#demo') setTour(true);

  function resize() {
    const w=host.clientWidth || innerWidth, h=host.clientHeight || innerHeight;
    const cap=w<630?1.45:1.65;
    dprUniform.value=Math.min(window.devicePixelRatio||1,cap);
    renderer.setPixelRatio(dprUniform.value);
    renderer.setSize(w,h,false);
    camera.aspect=w/h;
    camera.fov=w/h<.86?67:57;
    camera.updateProjectionMatrix();
  }
  window.addEventListener('resize',resize);
  resize();
  let prev=performance.now(), time=0, hudClock=0;
  function tick(now){
    const dt=clamp((now-prev)/1000,0,.04);
    prev=now;time+=dt;
    clockUniform.value=time;
    if(touring) {
      const u=(tourTime/21)%1;
      cameraPath.getPoint(u,trial);
      move(trial.x-swimmer.x,trial.y-swimmer.y,trial.z-swimmer.z);
      lookPath.getPoint(u,gaze);
      gaze.sub(swimmer).normalize();
      yaw=desiredYaw=Math.atan2(gaze.x,-gaze.z);
      pitch=desiredPitch=Math.asin(clamp(gaze.y,-1,1));
      tourTime+=dt;
    } else {
      const blend=1-Math.exp(-dt*15);
      yaw=mix(yaw,desiredYaw,blend);
      pitch=mix(pitch,desiredPitch,blend);
      forward();
      velocity=mix(velocity,pointer===null?0:5.7,1-Math.exp(-dt*(pointer===null?6.0:3.7)));
      if(velocity>.005) move(direction.x*velocity*dt,direction.y*velocity*dt,direction.z*velocity*dt);
    }
    forward();
    camera.position.copy(swimmer);
    camera.lookAt(gaze.copy(swimmer).add(direction));
    sky.position.copy(swimmer);
    animateFish(time);
    animateRays(time);
    animateBeams(time);
    hudClock-=dt;
    if(hudClock<=0) {
      depthText.textContent=(surfaceY-swimmer.y).toFixed(1)+' m';
      needle.style.transform='rotate('+(-yaw*180/PI).toFixed(0)+'deg)';
      const dW=Math.hypot(swimmer.x-wreckZone.x,swimmer.z-wreckZone.z);
      const dA=Math.hypot(swimmer.x-archZone.x,swimmer.z-archZone.z);
      const locationName=dW<11&&dW<dA?'The Wreck':dA<11?'The Stone Arch':Math.abs(swimmer.x)>11?'The Kelp Forest':'The Shallows';
      if(place.textContent!==locationName)place.textContent=locationName;
      hudClock=.13;
    }
    renderer.render(scene,camera);
    requestAnimationFrame(tick);
  }
  requestAnimationFrame(tick);
})();
</script>
</body>
</html>