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

works · auto-checked (Checked by an automated pass. Not hand-played yet.)55.4 KB · 1,155 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, viewport-fit=cover">
<meta name="theme-color" content="#092e38">
<title>The Kelp Garden</title>
<style>
  :root{color-scheme:dark;--cream:#f0f0da;--gold:#e7c98a;--soft:#c3d5cd;--edge:rgba(214,235,214,.24);--glass:rgba(7,36,43,.73)}
  *{box-sizing:border-box}
  html,body{margin:0;width:100%;height:100%;overflow:hidden;background:#082d3a;color:var(--cream)}
  body{font:14px/1.4 system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;overscroll-behavior:none}
  #dive{position:relative;isolation:isolate;width:100%;height:100%;height:100dvh;overflow:hidden;background:radial-gradient(ellipse at 55% 0%,#3c8d86,#146070 34%,#092e43 79%);touch-action:none;user-select:none;-webkit-user-select:none}
  #water{position:absolute;inset:0;width:100%;height:100%;outline:none;display:block;touch-action:none;cursor:grab}
  .swimming #water{cursor:grabbing}
  .shade{position:absolute;inset:0;pointer-events:none;background:linear-gradient(90deg,rgba(4,25,30,.52),transparent 48%),linear-gradient(180deg,rgba(4,25,31,.45),transparent 32%,transparent 65%,rgba(4,23,25,.71));}
  .top{position:absolute;top:max(32px,env(safe-area-inset-top));left:max(43px,env(safe-area-inset-left));right:max(43px,env(safe-area-inset-right));display:flex;justify-content:space-between;align-items:flex-start;pointer-events:none}
  .identity{padding-top:25px;transition:opacity .7s ease,transform .7s ease}
  .explored .identity{opacity:.42;transform:translateY(-12px)}
  .mode{display:flex;align-items:center;gap:10px;font-size:10px;font-weight:650;letter-spacing:.24em;text-transform:uppercase;color:#e6e4c9}
  .mode svg{width:28px;height:28px;padding:5px;border:1px solid rgba(231,201,138,.53);border-radius:50%;color:var(--gold)}
  h1{font-family:Georgia,"Times New Roman",serif;font-weight:400;font-size:clamp(52px,5.6vw,100px);letter-spacing:-.065em;line-height:.88;margin:20px 0 0;text-shadow:0 3px 28px rgba(1,21,25,.25)}
  h1 em{display:block;color:var(--gold);font-weight:400;padding-right:.15em}
  .depth{width:127px;padding:12px 13px 11px;border:1px solid var(--edge);border-radius:13px;background:var(--glass);box-shadow:0 3px 20px #052b3433;backdrop-filter:blur(10px)}
  .depth-label,.heading-label{font-size:9px;letter-spacing:.17em;text-transform:uppercase;color:var(--soft);font-weight:660}
  .depth-label{display:flex;justify-content:space-between;align-items:center}
  .depth-label svg{width:15px;height:12px;color:var(--gold)}
  .depth-value{display:flex;align-items:baseline;gap:5px;margin-top:2px;font-size:26px;font-weight:450;font-variant-numeric:tabular-nums;letter-spacing:-.06em}
  .depth-value small{font-size:11px;color:var(--soft);letter-spacing:0}
  .depth-track{height:4px;background:repeating-linear-gradient(90deg,#88a7a1 0 1px,transparent 1px 8px);opacity:.8;position:relative;margin-top:4px}
  #level{position:absolute;width:2px;height:6px;left:62%;top:-1px;background:var(--gold);box-shadow:0 0 6px #e7c98a66}
  .aim{position:absolute;left:50%;top:50%;transform:translate(-50%,-50%);width:18px;height:18px;border:1px solid rgba(228,239,217,.62);border-radius:50%;box-shadow:0 0 9px #173e41;pointer-events:none;opacity:0;transition:opacity .35s}
  .aim::after{content:"";width:2px;height:2px;background:var(--cream);border-radius:50%;position:absolute;left:7px;top:7px}
  .swimming .aim{opacity:.8}
  .touring .aim{opacity:0}
  .bottom{position:absolute;bottom:max(28px,calc(env(safe-area-inset-bottom) + 10px));left:max(43px,env(safe-area-inset-left));right:max(43px,env(safe-area-inset-right));display:grid;grid-template-columns:1fr auto 1fr;gap:14px;align-items:center;pointer-events:none}
  .heading{display:flex;align-items:center;gap:11px}
  .compass{height:45px;width:45px;border:1px solid var(--edge);border-radius:50%;display:grid;place-items:center;position:relative;background:var(--glass);backdrop-filter:blur(8px)}
  .compass::after{content:"";position:absolute;inset:4px;border:1px dotted #9fbcad8c;border-radius:50%}
  .compass svg{height:24px;width:24px;overflow:visible}
  #bearing{font-size:12px;font-variant-numeric:tabular-nums;color:var(--cream);margin-top:2px;letter-spacing:.04em}
  .hint{margin:0;display:flex;align-items:center;gap:9px;font-size:12px;font-weight:500;white-space:nowrap;border:1px solid var(--edge);color:#edf2dd;background:var(--glass);border-radius:100px;padding:10px 15px;backdrop-filter:blur(8px)}
  .hint svg{width:16px;height:16px;color:var(--gold)}
  .actions{justify-self:end;display:flex;gap:7px}
  button{display:inline-flex;align-items:center;justify-content:center;gap:8px;min-height:46px;min-width:46px;margin:0;padding:0 13px;font:inherit;font-size:12px;font-weight:620;color:var(--cream);border:1px solid var(--edge);border-radius:11px;background:var(--glass);backdrop-filter:blur(8px);cursor:pointer;touch-action:manipulation;pointer-events:auto;-webkit-tap-highlight-color:transparent}
  button svg{width:17px;height:17px;color:var(--gold)}
  button:active,[aria-pressed="true"]{background:#284e4a;border-color:#baad77}
  button:focus-visible{outline:2px solid var(--gold);outline-offset:3px}
  .loading{position:absolute;top:50%;left:50%;width:max-content;max-width:82%;transform:translate(-50%,-50%);padding:12px 20px;background:var(--glass);border:1px solid var(--edge);border-radius:30px;text-align:center;pointer-events:none}
  [hidden]{display:none!important}
  @media(max-width:700px){.top{left:max(20px,env(safe-area-inset-left));right:max(20px,env(safe-area-inset-right));top:max(20px,calc(env(safe-area-inset-top) + 9px))}
    .identity{padding-top:9px}.mode{gap:7px;font-size:8px}.mode svg{width:24px;height:24px}
    h1{margin-top:13px;font-size:clamp(42px,10vw,64px)}
    .depth{width:91px;padding:9px 10px}.depth-value{font-size:22px}
    .bottom{left:max(17px,env(safe-area-inset-left));right:max(17px,env(safe-area-inset-right));grid-template-columns:1fr 1fr;gap:8px}
    .hint{grid-column:1/-1;grid-row:1;justify-self:center;margin-bottom:3px;padding:8px 12px;font-size:11px}
    .heading{grid-row:2;gap:7px}.actions{grid-row:2}.shade{background:linear-gradient(180deg,rgba(4,25,31,.49),transparent 32%,transparent 68%,rgba(4,23,25,.71))}
  }
  @media(max-height:500px){.top{top:14px}.identity{padding-top:0}.mode svg{width:23px;height:23px}h1{font-size:48px;margin-top:8px}.bottom{bottom:12px}.depth{padding-block:7px}}
  @media(prefers-reduced-motion:reduce){.identity,.aim{transition:none}}
</style>
</head>
<body>
<main id="dive" aria-label="The Kelp Garden underwater experience">
  <canvas id="water" aria-label="Underwater garden. Hold to swim and drag to turn."></canvas>
  <div class="shade"></div>
  <div class="top">
    <header class="identity">
      <div class="mode">
        <svg viewBox="0 0 20 20" fill="none" aria-hidden="true"><path d="M10 18V3m0 10C5 13 4 10 4 7c4 1 6 3 6 6Zm0-3c4 0 6-3 6-6-4 1-6 3-6 6Z" stroke="currentColor" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/></svg>
        <span id="mode">Free swim</span>
      </div>
      <h1>The Kelp <em>Garden</em></h1>
    </header>
    <div class="depth" aria-label="Dive depth">
      <div class="depth-label">Depth <svg viewBox="0 0 18 14" fill="none" aria-hidden="true"><path d="M1 3c3-3 5 3 8 0s5 3 8 0M1 7c3-3 5 3 8 0s5 3 8 0m-8 2v4m-2-2 2 2 2-2" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round"/></svg></div>
      <div class="depth-value"><span id="depth">9.3</span><small>m</small></div>
      <div class="depth-track" aria-hidden="true"><span id="level"></span></div>
    </div>
  </div>
  <div class="aim" aria-hidden="true"></div>
  <div class="bottom">
    <div class="heading" aria-label="Compass">
      <div class="compass"><svg id="needle" viewBox="0 0 24 24" aria-hidden="true"><path fill="#e7c98a" d="m12 2 4 11-4-2-4 2z"/><path fill="#85a9a0" d="m12 22-4-9 4 2 4-2z"/></svg></div>
      <div><div class="heading-label">Heading</div><div id="bearing">N 000°</div></div>
    </div>
    <p class="hint"><svg viewBox="0 0 20 20" fill="none" aria-hidden="true"><path d="M10 2v16M2 10h16M7 5l3-3 3 3M7 15l3 3 3-3M5 7l-3 3 3 3m10-6 3 3-3 3" stroke="currentColor" stroke-width="1.15" stroke-linecap="round" stroke-linejoin="round"/></svg><span id="hint">Hold to swim · Drag to turn</span></p>
    <div class="actions">
      <button id="tour" type="button" aria-pressed="false" disabled><svg viewBox="0 0 20 20" fill="none" aria-hidden="true"><path id="tour-icon" d="m7 4 9 6-9 6z" stroke="currentColor" stroke-width="1.4" stroke-linejoin="round"/></svg><span id="tour-label">Play tour</span></button>
      <button id="reset" type="button" aria-label="Return to start" title="Return to start" disabled><svg viewBox="0 0 20 20" fill="none" aria-hidden="true"><path d="M4 8a6.5 6.5 0 1 1 1.3 6M4 8V3m0 5h5" stroke="currentColor" stroke-width="1.4" stroke-linecap="round" stroke-linejoin="round"/></svg></button>
    </div>
  </div>
  <div id="loading" class="loading" role="status">Entering the water…</div>
</main>
<script type="module">
const get = id => document.getElementById(id);
const loading = get("loading");
try {
  const THREE = await import("https://cdn.jsdelivr.net/npm/[email protected]/build/three.module.js");
  buildGarden(THREE);
} catch (error) {
  loading.textContent = "The garden needs WebGL and a connection to load.";
  console.error(error);
}

function buildGarden(T) {
  const PI = Math.PI, TAU = 2 * PI;
  const mix = (a,b,t) => a+(b-a)*t;
  const clamp = (v,a,b) => Math.max(a,Math.min(b,v));
  let seed = 823713;
  function random() {
    seed = (Math.imul(1664525,seed) + 1013904223) >>> 0;
    return seed / 4294967296;
  }
  const range = (a,b) => mix(a,b,random());
  const V = (x=0,y=0,z=0) => new T.Vector3(x,y,z);
  const C = hex => new T.Color(hex);
  const canvas = get("water"), dive = get("dive");
  const renderer = new T.WebGLRenderer({canvas, antialias:true, alpha:false, powerPreference:"high-performance"});
  renderer.outputColorSpace = T.SRGBColorSpace;
  renderer.setClearColor(0x12536a);
  const scene = new T.Scene();
  const fog = C(0x15586d), density = .024;
  scene.fog = new T.FogExp2(fog,density);
  const camera = new T.PerspectiveCamera(55,1,.09,195);
  camera.rotation.order = "YXZ";
  scene.add(new T.HemisphereLight(0xb4e4d5,0x527269,1.65));
  const sun = new T.DirectionalLight(0xffdda0,2.15);
  sun.position.set(-17,24,-11);
  scene.add(sun);
  const fill = new T.DirectionalLight(0x65beba,.72);
  fill.position.set(11,9,22);
  scene.add(fill);
  const clock = {value:0};
  const fogUniform = {value:fog};
  const fogCode = "float mist(float depth){return 1.0-exp(-0.000576*depth*depth);}";
  const outputCode = "\n#include <colorspace_fragment>\n";
  const worldVertex = `
    varying vec3 world;
    varying float depth;
    void main(){
      vec4 p=modelMatrix*vec4(position,1.);
      world=p.xyz;
      vec4 view=viewMatrix*p;
      depth=-view.z;
      gl_Position=projectionMatrix*view;
    }`;
  const ocean = new T.Mesh(new T.SphereGeometry(145,36,20),new T.ShaderMaterial({
    side:T.BackSide,depthWrite:false,
    vertexShader:worldVertex,
    fragmentShader:`varying vec3 world;
      void main(){
        vec3 d=normalize(world-cameraPosition);
        float up=smoothstep(-.28,.68,d.y);
        float light=pow(max(dot(d,normalize(vec3(-.29,.55,-.79))),0.),6.);
        vec3 color=mix(vec3(.016,.090,.139),vec3(.023,.284,.284),up);
        color+=vec3(.105,.200,.114)*light;
        gl_FragColor=vec4(color,1.);
        ${outputCode}
      }`
  }));
  ocean.renderOrder = -20;
  scene.add(ocean);

  const rippleCode = `
    float ripple(vec2 p,float t){
      vec2 q=p+vec2(.47*sin(1.3*p.y+t),.45*sin(1.1*p.x-.77*t));
      float a=sin(q.x*1.7+q.y*1.55+.56*sin(q.y*2.1+t)+.29*t);
      float b=sin(q.y*1.82-q.x*1.14+.6*sin(q.x*2.46-t)-.45*t);
      float c=sin(q.x*2.5+q.y*1.13+.7*sin(q.y-t));
      return .68*pow(1.-abs(a*.67+b*.33),8.)+.32*pow(1.-abs(b*.76+c*.24),10.);
    }`;
  const surfaceGeometry = new T.PlaneGeometry(185,185,76,76);
  surfaceGeometry.rotateX(-PI/2);
  const surfaceY = 14.6;
  const surface = new T.Mesh(surfaceGeometry,new T.ShaderMaterial({
    side:T.DoubleSide,uniforms:{time:clock,haze:fogUniform},
    vertexShader:`uniform float time;
      varying vec3 world;
      varying float depth;
      void main(){
        vec4 p=modelMatrix*vec4(position,1.);
        p.y+=.105*sin(p.x*.63+p.z*.35+time*.86)+.072*cos(p.z*1.07-p.x*.38-time*.73);
        world=p.xyz;
        vec4 view=viewMatrix*p;
        depth=-view.z;
        gl_Position=projectionMatrix*view;
      }`,
    fragmentShader:`uniform float time;
      uniform vec3 haze; varying vec3 world; varying float depth;
      ${fogCode} ${rippleCode}
      void main(){
        vec2 p=world.xz;
        float incidence=abs(normalize(world-cameraPosition).y);
        float folds=.5+.5*sin(p.x*.49+p.y*.8+.82*sin(p.x*.94-p.y*.2+time*.65)-time*.85);
        float flecks=ripple(p*1.12,time*.74);
        float patch=exp(-length((p-vec2(-10.,-11.))*vec2(.058,.038)));
        float shimmer=smoothstep(.37,.8,flecks);
        vec3 c=mix(vec3(.023,.205,.227),vec3(.111,.418,.364),folds*.65+incidence*.25);
        c+=patch*vec3(.24,.27,.108);
        c+=flecks*vec3(.064,.16,.14)+shimmer*patch*vec3(.44,.57,.28);
        c=mix(c,haze,mist(depth)*.83);
        gl_FragColor=vec4(c,1.);
        ${outputCode}
      }`
  }));
  surface.position.set(0,surfaceY,-9);
  scene.add(surface);

  function ground(x,z) {
    const banks=.75*Math.exp(-Math.pow((Math.abs(x)-24)/10,2));
    return -.38 + banks + .38*Math.sin(.155*x+.21*z) + .22*Math.sin(.36*x-.28*z) + .09*Math.cos(.63*x+.42*z);
  }
  const terrain = new T.PlaneGeometry(158,158,125,125);
  terrain.rotateX(-PI/2);
  terrain.translate(0,0,-14);
  const groundPositions = terrain.attributes.position;
  for(let i=0;i<groundPositions.count;i++){
    groundPositions.setY(i,ground(groundPositions.getX(i),groundPositions.getZ(i)));
  }
  scene.add(new T.Mesh(terrain,new T.ShaderMaterial({
    uniforms:{time:clock,haze:fogUniform},vertexShader:worldVertex,
    fragmentShader:`uniform float time;
      uniform vec3 haze; varying vec3 world; varying float depth;
      ${fogCode} ${rippleCode}
      float shadow(vec2 p,vec2 center,vec2 size){
        vec2 d=(p-center)/size;
        return exp(-dot(d,d)*1.3);
      }
      void main(){
        vec2 p=world.xz;
        float dune=.5+.5*sin(p.y*8.1+p.x*2.9+1.8*sin(p.x*.65+p.y*.24)+.55*sin(p.x*2.1));
        float broad=.5+.5*sin(p.x*.32+p.y*.29+sin(p.y*.51));
        float grain=fract(sin(dot(floor(p*140.),vec2(12.9898,78.233)))*43758.5453);
        float patch=.42+.58*exp(-length((p-vec2(-.9,3.))*vec2(.063,.039)));
        float shade=.46*shadow(p,vec2(9.,-4.4),vec2(8.,2.65));
        shade+=.34*shadow(p,vec2(-8.3,1.7),vec2(5.6,2.2));
        shade+=.37*shadow(p,vec2(-13.2,11.),vec2(4.3,5.));
        shade+=.34*shadow(p,vec2(13.4,9.),vec2(4.5,4.9));
        float detail=1.-smoothstep(19.,50.,depth);
        float caustic=ripple(p*.91,time*.72);
        float smaller=ripple(p*1.73+vec2(3.,1.),time*.91);
        vec3 color=mix(vec3(.113,.162,.106),vec3(.318,.283,.150),patch);
        color*=.79+broad*.24+dune*.13*detail+(grain-.5)*.12*detail;
        color+=(caustic*.78+smaller*.22)*patch*vec3(.22,.30,.175);
        color*=1.-min(shade,.67);
        color=mix(color,haze,mist(depth));
        gl_FragColor=vec4(color,1.);
        ${outputCode}
      }`
  })));

  class GeometryBuilder {
    constructor(){this.positions=[];this.colors=[];this.uvs=[];this.indices=[];this.roots=[];}
    point(p,c,u=0,v=0,root=null){
      const index=this.positions.length/3;
      this.positions.push(p.x,p.y,p.z);
      this.colors.push(c.r,c.g,c.b);
      this.uvs.push(u,v);
      if(root) this.roots.push(root.x,root.y,root.z);
      return index;
    }
    tri(a,b,c){this.indices.push(a,b,c);}
    face(a,b,c,d){this.tri(a,b,d);this.tri(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.setAttribute("uv",new T.Float32BufferAttribute(this.uvs,2));
      if(this.roots.length) geo.setAttribute("root",new T.Float32BufferAttribute(this.roots,3));
      geo.setIndex(this.indices);
      geo.computeVertexNormals();
      return geo;
    }
  }
  function meshFor(builder,material,parent=scene) {
    const mesh=new T.Mesh(builder.geometry(),material);
    parent.add(mesh);
    return mesh;
  }
  function tube(builder, points, radii, color, sides=7, root=null) {
    const base=builder.positions.length/3;
    for(let i=0;i<points.length;i++){
      const tangent=points[Math.min(i+1,points.length-1)].clone().sub(points[Math.max(0,i-1)]).normalize();
      const normal=V(0,0,1).cross(tangent);
      if(normal.lengthSq()<.001) normal.set(0,1,0).cross(tangent);
      normal.normalize();
      const side=tangent.clone().cross(normal);
      for(let j=0;j<sides;j++){
        const a=j/sides*TAU;
        const p=points[i].clone().addScaledVector(normal,Math.cos(a)*radii[i]).addScaledVector(side,Math.sin(a)*radii[i]);
        builder.point(p,color,root?2:i/Math.max(1,points.length-1),j/sides,root);
        if(i){
          const prev=base+(i-1)*sides;
          const next=(j+1)%sides;
          builder.face(prev+j,prev+next,prev+sides+next,prev+sides+j);
        }
      }
    }
  }

  const stones=[], archPieces=[];
  const rockDark=C(0x224149), rockLight=C(0x63756a), rockOchre=C(0x9d8f61);
  function stoneTint(x,y,z){
    const band=.5+.5*Math.sin(y*12+x*6.2-z*4.1+Math.sin(z*13)*.8);
    const m=clamp(.38+y*.20+(band-.5)*.39,0,1);
    return rockDark.clone().lerp(rockLight,m).lerp(rockOchre, Math.max(0,band-.69)*.49);
  }
  function arch(x,z,rx,ry,phase){
    const geometry=new GeometryBuilder();
    const rows=42, sides=16;
    const baseY=ground(x,z)-.52;
    for(let i=0;i<=rows;i++){
      const a=i/rows*PI;
      const w=Math.sin(a), s=Math.cos(a);
      const center=V(x+rx*s+.40*Math.sin(a*2),baseY+ry*w,z+.72*Math.sin(a*2+phase)+.38*s);
      const normal=V(ry*s,rx*w,0).normalize();
      const thick=mix(1.43,.91,w)+.13*Math.sin(a*8.+phase)+.08*Math.cos(a*15.);
      for(let j=0;j<sides;j++){
        const angle=j/sides*TAU;
        const bump=1.+.14*Math.sin(angle*5+a*23)+.095*Math.cos(angle*3-a*28)+.06*Math.sin(angle*7+a*15);
        const p=center.clone().addScaledVector(normal,Math.cos(angle)*thick*bump);
        p.z+=Math.sin(angle)*thick*1.37*bump;
        geometry.point(p,stoneTint(p.x*.42,Math.cos(angle)+w*.48,p.z*.45).multiplyScalar(.83+.16*bump));
        if(i){
          const k=(i-1)*sides, next=(j+1)%sides;
          geometry.face(k+j,k+sides+j,k+sides+next,k+next);
        }
      }
      if(i%2===0) archPieces.push({p:center,r:thick*1.73+.40});
    }
    meshFor(geometry,new T.MeshStandardMaterial({vertexColors:true,roughness:.99,side:T.DoubleSide}));
  }
  arch(-8.5,1.5,4.45,7.4,.9);
  arch(6.3,-23,5.1,6.5,2.1);
  arch(-21,-22,3.65,5.2,1.4);
  const rockGeo=new T.IcosahedronGeometry(1,3);
  const rockPositions=rockGeo.attributes.position, rockColors=[];
  for(let i=0;i<rockPositions.count;i++){
    const x=rockPositions.getX(i),y=rockPositions.getY(i),z=rockPositions.getZ(i);
    const k= .9 + .12*Math.sin(x*9+z*4)*Math.cos(y*7-z*2) + .08*Math.cos(x*16-y*10+z*17);
    rockPositions.setXYZ(i,x*k,y*k,z*k);
    const c=stoneTint(x,y,z);
    rockColors.push(c.r,c.g,c.b);
  }
  rockGeo.setAttribute("color",new T.Float32BufferAttribute(rockColors,3));
  rockGeo.computeVertexNormals();
  const rockPlacements=[];
  function rock(x,z,sx,sy,sz,fixedY){
    const y=fixedY ?? ground(x,z)+sy*.25;
    const a=range(-PI,PI);
    rockPlacements.push({p:V(x,y,z),s:V(sx,sy,sz),a,c:C(0xffffff).lerp(C(0xbbd3a9),random()*.67)});
    if(Math.max(sx,sy,sz)>.62) stones.push({p:V(x,y,z),s:V(sx*1.13+.42,sy*1.13+.42,sz*1.13+.42),sine:Math.sin(a),cosine:Math.cos(a)});
  }
  [
    [-13,2.1,2.2,1.32,1.62],[-4.1,1.6,1.45,.88,1.53],[-14.1,11.3,3.4,2.2,2.35],
    [-10,12.8,1.8,1.1,1.44],[-12.7,16,2.4,1.5,1.9],[12.8,10.2,3.0,1.62,2.44],
    [15.1,14.2,2.66,2.36,2.44],[8.9,12.1,1.25,.68,.95],[10.8,6,1.43,1.06,1.15],
    [-16.3,-7.5,3.6,2.1,3.36],[-12,-12.1,2.65,1.82,1.8],[18.4,-1.4,3.2,1.98,2.54],
    [18.9,-12,4.16,2.7,2.67],[1.1,-23,1.7,1.0,1.4],[11.4,-23,2.4,1.35,2.3],
    [-6.9,16.2,1.11,.61,1.17],[7.1,16.9,.88,.46,.74],[4.6,-11.7,1.66,.97,1.35]
  ].forEach(values=>rock(...values));
  for(let i=0;i<78;i++){
    const x=range(8,45)*(random()<.5?-1:1), z=range(-60,25);
    const s=range(.24,1.65);
    rock(x,z,s*range(.82,1.6),s*range(.52,1.13),s*range(.67,1.44));
  }
  for(let i=0;i<160;i++){
    const x=range(-34,34), z=range(-42,32), s=range(.07,.27);
    rock(x,z,s*1.2,s*.66,s*.9);
  }
  const rockMeshes=new T.InstancedMesh(rockGeo,new T.MeshStandardMaterial({vertexColors:true,roughness:.99}),rockPlacements.length);
  const dummy=new T.Object3D();
  rockPlacements.forEach((r,i)=>{
    dummy.position.copy(r.p); dummy.rotation.set(0,r.a,0); dummy.scale.copy(r.s); dummy.updateMatrix();
    rockMeshes.setMatrixAt(i,dummy.matrix); rockMeshes.setColorAt(i,r.c);
  });
  scene.add(rockMeshes);

  const woodCanvas=document.createElement("canvas");
  woodCanvas.width=512; woodCanvas.height=96;
  const ink=woodCanvas.getContext("2d");
  ink.fillStyle="#b09872";
  ink.fillRect(0,0,512,96);
  for(let i=0;i<630;i++){
    const y=range(0,96), x=range(-100,480);
    ink.strokeStyle=random()<.58?`rgba(56,38,24,${range(.05,.29)})`:`rgba(245,222,162,${range(.08,.39)})`;
    ink.lineWidth=range(.3,1.7);
    ink.beginPath(); ink.moveTo(x,y);
    ink.bezierCurveTo(x+85,y+range(-3,3),x+165,y+range(-2,2),x+range(180,380),y+range(-2,2));
    ink.stroke();
  }
  for(let i=0;i<31;i++){
    const x=range(0,512), y=range(0,96);
    ink.fillStyle="rgba(45,34,23,.20)";
    ink.beginPath(); ink.ellipse(x,y,range(4,25),range(.7,2.9),0,0,TAU); ink.fill();
  }
  const woodTexture=new T.CanvasTexture(woodCanvas);
  woodTexture.colorSpace=T.SRGBColorSpace;
  woodTexture.wrapS=woodTexture.wrapT=T.RepeatWrapping;
  woodTexture.anisotropy=Math.min(4,renderer.capabilities.getMaxAnisotropy());
  const woodMaterial=new T.MeshStandardMaterial({map:woodTexture,vertexColors:true,roughness:.89,side:T.DoubleSide});
  const ship=new T.Group();
  ship.position.set(9.3,ground(9.3,-4.9)+.16,-4.9);
  ship.rotation.set(.13,-.28,-.10,"YXZ");
  scene.add(ship);
  const wood=new GeometryBuilder(), cloth=new GeometryBuilder(), lines=new GeometryBuilder();
  const weathered=C(0xbe8752), darkWood=C(0x513c2d), trim=C(0xa67748), splitWood=C(0xd19b63);
  const length=7.35;
  function hull(t,v,side){
    const w=Math.pow(Math.max(0,1-t*t),.60)*(2.37-.29*t);
    const base=.13+.95*Math.pow(Math.abs(t),3)+.12*t;
    const sheer=2.56+.96*Math.pow(t,4)+.21*t;
    return V(t*length,mix(base,sheer,v),side*w*(.13+.87*Math.pow(v,.56)));
  }
  function timber(a,b,width,height,color) {
    const axis=b.clone().sub(a).normalize();
    const side=V(0,1,0).cross(axis);
    if(side.lengthSq()<.001) side.set(1,0,0).cross(axis);
    side.normalize().multiplyScalar(width/2);
    const up=axis.clone().cross(side).normalize().multiplyScalar(height/2);
    const roots=[a,b].map(p=>[
      p.clone().sub(side).sub(up),p.clone().add(side).sub(up),
      p.clone().add(side).add(up),p.clone().sub(side).add(up)
    ]);
    for(let j=0;j<4;j++){
      const k=(j+1)%4, l=Math.max(.2,a.distanceTo(b)/3);
      const p=wood.point(roots[0][j],color,0,j*.34);
      wood.point(roots[1][j],color,l,j*.34);
      wood.point(roots[1][k],color,l,j*.34+.29);
      wood.point(roots[0][k],color,0,j*.34+.29);
      wood.face(p,p+1,p+2,p+3);
    }
    for(let end=0;end<2;end++){
      const p=wood.positions.length/3;
      roots[end].forEach((corner,i)=>wood.point(corner,color,i%2,Math.floor(i/2)));
      wood.face(p,p+1,p+2,p+3);
    }
  }
  for(const side of [-1,1]){
    for(let j=0;j<10;j++){
      const v0=(j+.033)/10, v1=(j+.972)/10;
      for(let k=0;k<27;k++){
        const t0=-1+k*2/27,t1=-1+(k+1)*2/27;
        const hole=(j===7 && [5,9,13,17].includes(k));
        const damage=(k>18 && k<24 && j>7-(k%3)) || (k>11 && k<15 && j===9);
        if(hole || damage) continue;
        const color=weathered.clone().lerp(darkWood,range(.08,.47));
        if(j===2 || j===6) color.multiplyScalar(.69);
        const p=wood.point(hull(t0,v0,side),color,t0*2.8,.05+j*.31);
        wood.point(hull(t1,v0,side),color,t1*2.8,.05+j*.31);
        wood.point(hull(t1,v1,side),color,t1*2.8,.34+j*.31);
        wood.point(hull(t0,v1,side),color,t0*2.8,.34+j*.31);
        wood.face(p,p+1,p+2,p+3);
      }
    }
    for(let k=0;k<19;k++){
      const t0=-1+k*2/19,t1=-1+(k+1)*2/19;
      if(k!==13 && k!==14 && k!==15) timber(hull(t0,1.018,side),hull(t1,1.018,side),.14,.12,trim);
    }
  }
  for(let i=0;i<14;i++){
    const t=-.87+i*.132;
    for(const side of [-1,1]){
      for(let j=1;j<8;j++){
        const v0=j/9, v1=(j+1)/9;
        const a=hull(t,v0,side), b=hull(t,v1,side);
        a.z*=.945; b.z*=.945;
        timber(a,b,.135,.16,trim);
      }
      const rail=hull(t,1,side);
      if(i<4 || i>10) timber(rail,rail.clone().add(V(.07,.33+range(0,.19),0)),.10,.13,darkWood);
    }
    if(i%2===0 || i<5){
      const a=hull(t,.91,-1), b=hull(t,.91,1);
      timber(a,b,.22,.17,darkWood);
    }
  }
  for(let i=-9;i<=9;i++){
    const z=i*.226, tA=-.91+Math.abs(i)*.037, tB=range(-.22,.06);
    timber(V(tA*length,hull(tA,.98,1).y-.08,z),V(tB*length,2.43,z),.214,.09,weathered.clone().multiplyScalar(range(.66,1.13)));
    if(Math.abs(i)<6 && i%4!==0){
      const f=range(.57,.70);
      timber(V(f*length,2.55,z),V((.90-Math.abs(i)*.038)*length,2.82,z),.207,.09,trim);
    }
  }
  timber(V(-7.15,1.04,0),V(-7.50,3.57,0),.34,.28,darkWood);
  timber(V(6.94,1.12,0),V(7.54,3.95,0),.28,.31,splitWood);
  timber(V(5.85,3.06,.05),V(10.19,4.04,.15),.21,.22,trim);
  timber(V(-.95,1.1,.13),V(-1.96,8.18,-.46),.34,.33,trim);
  timber(V(-2.44,6.5,-2.93),V(-1.44,6.26,2.68),.17,.16,splitWood);
  timber(V(-4.73,2.82,.16),V(-5.19,5.14,.42),.24,.25,darkWood);
  timber(V(-5.83,4.37,.22),V(-4.37,4.55,.29),.13,.15,trim);
  const rigging=C(0x68583b);
  tube(lines,[V(-5.86,3.11,1.10),V(-4.11,5.12,.68),V(-1.96,8.18,-.46)],[.039,.035,.025],rigging,5);
  tube(lines,[V(-1.95,7.98,-.46),V(.95,5.27,-.08),V(6.14,3.27,.13)],[.026,.036,.035],rigging,5);
  tube(lines,[V(-1.45,6.28,2.67),V(-.73,4.8,2.35),V(-.16,2.63,2.09)],[.032,.032,.022],rigging,5);
  tube(lines,[V(.35,2.59,1.2),V(.2,2.09,2.11),V(.62,.88,2.72),V(1.3,.34,2.87),V(1.9,.28,2.85)],[.065,.064,.059,.05,.04],rigging,7);
  const sailColor=C(0x9f9b62);
  const sailRows=12, sailColumns=20;
  for(let i=0;i<=sailRows;i++){
    for(let j=0;j<=sailColumns;j++){
      const u=j/sailColumns, v=i/sailRows;
      const rag=.50+.34*Math.sin(u*4.2)+.18*Math.sin(u*9.0)+.08*Math.sin(u*37);
      const p=V(-2.44+u-.42*Math.sin(PI*v)+.16*Math.sin(u*8+v*5)*v,
        6.50-u*.24-v*(1.79*rag+.24*Math.sin(PI*u)),
        -2.91+u*5.51+v*(.15-.69*(u-.5)));
      const c=sailColor.clone().lerp(C(0x5a674a),v*.44+Math.pow(Math.sin(u*16),2)*.22);
      const a=cloth.point(p,c,u,v);
      if(i && j && !(i>=10 && (j===6 || j===11 || j===15))) cloth.face(a-1-sailColumns-1,a-sailColumns-1,a,a-1);
    }
  }
  meshFor(wood,woodMaterial,ship);
  meshFor(cloth,new T.MeshStandardMaterial({vertexColors:true,side:T.DoubleSide,roughness:1}),ship);
  meshFor(lines,new T.MeshStandardMaterial({vertexColors:true,roughness:1}),ship);
  ship.updateMatrixWorld(true);
  const shipInverse=ship.matrixWorld.clone().invert();
  const posts=[
    [V(-.95,1.1,.13),V(-1.96,8.18,-.46),.62],
    [V(-2.44,6.5,-2.93),V(-1.44,6.26,2.68),.53],
    [V(-4.73,2.75,.16),V(-5.19,5.14,.42),.55],
    [V(-5.83,4.37,.22),V(-4.37,4.55,.29),.49],
    [V(5.85,3.06,.05),V(10.19,4.04,.15),.57]
  ].map(([a,b,r])=>({a,d:b.clone().sub(a),r}));

  const reef=new GeometryBuilder();
  const coralShades=[C(0xd08043),C(0xc76638),C(0xdd9e47),C(0xb0954f),C(0xe1ae66)];
  function coralFan(x,z,size,angle,shade,y=ground(x,z)){
    const right=V(Math.cos(angle),0,Math.sin(angle)), away=V(-Math.sin(angle),0,Math.cos(angle));
    const base=V(x,y-.06,z);
    function branch(p,d,length,width,level){
      const end=p.clone().addScaledVector(d,length);
      const mid=p.clone().lerp(end,.45).addScaledVector(away,range(-.075,.075)*size);
      const color=shade.clone().lerp(coralShades[4], (3-level)*.18).multiplyScalar(range(.83,1.12));
      tube(reef,[p,mid,end],[width,width*.74,width*(level===0?.20:.52)],color,6);
      if(!level) return;
      for(let k=0;k<2;k++){
        const from=k===0?end:p.clone().lerp(end,.64);
        const next=d.clone().addScaledVector(right,(k===0?1:-1)*range(.32,.86)).addScaledVector(away,range(-.25,.25)).add(V(0,.16,0)).normalize();
        branch(from,next,length*range(.56,.79),width*.58,level-1);
      }
    }
    for(let i=-2;i<=2;i++){
      const dir=V(0,1,0).addScaledVector(right,i*.43).addScaledVector(away,range(-.2,.2)).normalize();
      branch(base,dir,size*range(.39,.63),size*.063,3);
    }
  }
  function cup(x,z,size,shade){
    const y=ground(x,z), slices=18, rings=6;
    for(let i=0;i<=rings;i++){
      const t=i/rings, radius=size*(.10+.89*Math.pow(t,1.37));
      for(let j=0;j<slices;j++){
        const a=j/slices*TAU;
        const lip=.14*Math.sin(a*5)+.09*Math.cos(a*9);
        const p=V(x+Math.cos(a)*radius,y+size*(.12+t*.72)+t*t*lip*size,z+Math.sin(a)*radius);
        const color=shade.clone().multiplyScalar(.64+t*.39+(j%2)*.13);
        reef.point(p,color);
      }
      if(i){
        const base=reef.positions.length/3-slices*2;
        for(let j=0;j<slices;j++){
          const n=(j+1)%slices;
          reef.face(base+j,base+n,base+slices+n,base+slices+j);
        }
      }
    }
  }
  [
    [-6.3,16.2,1.28,0],[-7.7,14.9,1.42,1],[-5.9,13.6,.85,2],
    [7.2,16.9,1.18,1],[8.55,14.3,1.52,0],[5.6,16,.64,2],
    [-10.4,5.2,1.3,1],[-4.55,2.7,.88,0],[-12.2,2.4,1.14,2],[-10.4,1.65,.72,2,6.22],
    [6.6,-1.5,.87,2],[12.7,-1.8,1.13,1],[15.8,-3.7,1.14,3],
    [12.5,10.6,.92,2],[-14.2,13.7,1.1,2],[-15.6,-4.6,1.2,0],
    [-2.7,-11.2,.86,2],[2.2,-22,1.18,0],[15.7,-16.1,1.18,1]
  ].forEach(([x,z,size,color,y])=>coralFan(x,z,size,range(-.5,.8),coralShades[color],y));
  for(let i=0;i<21;i++){
    const x=range(3.9,19)*(random()<.5?-1:1), z=range(-25,23);
    cup(x,z,range(.19,.55),coralShades[i%coralShades.length]);
  }
  cup(-6.7,15.5,.66,coralShades[0]); cup(6.8,15.8,.55,coralShades[2]);
  cup(-5.3,13.7,.43,coralShades[2]); cup(7.6,16.3,.42,coralShades[1]);
  meshFor(reef,new T.MeshStandardMaterial({vertexColors:true,side:T.DoubleSide,roughness:.91}));

  const kelp=new GeometryBuilder();
  const green=C(0x416327), deepGreen=C(0x173d2c), kelpGold=C(0xa78c3b), edgeGold=C(0xc0a34e);
  function stalk(x,z,height,angle,richness=1){
    const root=V(x,ground(x,z)-.09,z);
    const lean=range(.45,1.38), curve=range(-.6,.6), phase=range(0,TAU);
    const heading=V(Math.cos(angle),0,Math.sin(angle)), transverse=V(-Math.sin(angle),0,Math.cos(angle));
    const baseColor=deepGreen.clone().lerp(green,range(.39,1));
    const bladeColor=baseColor.clone().lerp(kelpGold,range(.03,.49));
    const stem=t=>root.clone().addScaledVector(heading,lean*t*t+.32*Math.sin(t*6.5)*t)
      .addScaledVector(transverse,curve*t+.29*t*Math.sin(t*7.4+phase)).add(V(0,height*t,0));
    const path=Array.from({length:13},(_,i)=>stem(i/12));
    tube(kelp,path,path.map((_,i)=>mix(.079,.019,i/12)),baseColor,5,root);
    const count=Math.round(clamp(height*1.33,6,15)*richness);
    for(let l=0;l<count;l++){
      const t=.14+l/Math.max(1,count-1)*.84;
      const start=stem(t);
      const turn=angle+(l%2?PI:0)+range(-.98,.98)+.27*Math.sin(t*14+phase);
      const direction=V(Math.cos(turn),0,Math.sin(turn));
      const across=V(-Math.sin(turn),0,Math.cos(turn));
      const len=range(1.08,2.85)*Math.sin(PI*mix(.21,.91,t))*Math.min(height/6.5,1.24);
      const width=range(.20,.46)*Math.min(1.32,height/7.5), salt=range(0,TAU);
      const leafColor=bladeColor.clone().lerp(kelpGold,range(0,.30)+(t>.74?.12:0));
      const crossSections=10;
      for(let k=0;k<=crossSections;k++){
        const u=k/crossSections;
        const ridge=start.clone().addScaledVector(direction,len*(.96*u-.28*u*u))
          .addScaledVector(across,len*.19*Math.sin(u*4.6+salt)*u)
          .add(V(0,len*(.89*u+.15*Math.sin(u*4.55)),0));
        const half=width*Math.pow(Math.max(0,Math.sin(u*PI)),.72);
        const twist=.65*Math.sin(u*4.35+salt)+.35;
        for(let j=-1;j<=1;j++){
          const p=ridge.clone().addScaledVector(across,j*half*(.8+.19*Math.sin(u*19+salt)))
            .add(V(0,half*(j*twist+Math.abs(j)*(.13+.25*Math.sin(u*14+salt))),0));
          const color=leafColor.clone().lerp(edgeGold,Math.abs(j)*.135+u*.12)
            .multiplyScalar(.8+.22*Math.sin(u*3.65+.4));
          const ix=kelp.point(p,color,j,u,root);
          if(k && j>-1) kelp.face(ix-4,ix-3,ix,ix-1);
        }
      }
    }
  }
  function grove(x,z,n,h,radius){
    for(let i=0;i<n;i++){
      const a=range(0,TAU), r=radius*Math.sqrt(random());
      stalk(x+Math.cos(a)*r,z+Math.sin(a)*r,h*range(.69,1.24),range(0,TAU));
    }
  }
  [
    [-12.6,16.5,8,11.1,2.1],[12.7,14.7,9,10.1,2.7],[-15,9.2,8,9.9,2.7],[15.1,8.1,7,10.6,2.9],
    [-13.4,3.5,6,8.3,1.95],[-17.2,-4.6,8,10.2,3.35],[16.5,-2.2,6,9.2,2.4],[-10.4,-7.4,6,7.4,2.8],
    [4.4,-9.5,4,6.8,1.7],[13.8,-14.5,8,10.3,3.1],[-19,-18,7,9.7,3.7],[-7.9,-19.5,9,9.4,3.3],
    [0,-27.2,9,8.4,3.55],[16,-27.7,9,10,4.1],[-25,-31,8,10.2,4.6],[24,-34,8,10.4,3.9],
    [-14,-36,8,10.2,3.8],[5.7,-41.2,11,10.4,5],[-25,-8.9,6,9.8,4.2],[25,-11.4,6,10,4.0],
    [-10,20.5,4,9.7,1.55],[10.4,20.5,4,8.2,1.45]
  ].forEach(args=>grove(...args));
  function grass(x,z,h){
    const root=V(x,ground(x,z)-.05,z);
    for(let l=0;l<5;l++){
      const a=range(0,TAU), len=h*range(.45,1.19), w=len*range(.055,.13);
      const dx=Math.cos(a), dz=Math.sin(a);
      const color=deepGreen.clone().lerp(kelpGold,range(.23,.54));
      for(let k=0;k<=6;k++){
        const t=k/6, spread=w*Math.sin(PI*t)*.72, extend=.94*len*t*t;
        for(const j of [-1,1]){
          const p=root.clone().add(V(dx*extend-j*dz*spread,len*(t-.22*t*t),dz*extend+j*dx*spread));
          const i=kelp.point(p,color,j*.78,t,root);
          if(k && j===1) kelp.face(i-3,i-2,i,i-1);
        }
      }
    }
  }
  for(let i=0;i<236;i++){
    const x=range(-28,28), z=range(-40,28);
    if(Math.abs(x)<2 && random()<.62) continue;
    grass(x,z,range(.27,1.08));
  }
  for(const [x,z] of [[-6.8,16],[-8.5,13.9],[7.65,17.0],[9.65,12.8],[-11.2,5],[12.2,5]]){
    for(let i=0;i<12;i++) grass(x+range(-1.4,1.4),z+range(-1.4,1.4),range(.38,.95));
  }
  meshFor(kelp,new T.ShaderMaterial({
    side:T.DoubleSide,vertexColors:true,uniforms:{time:clock,haze:fogUniform},
    vertexShader:`attribute vec3 root;
      uniform float time;
      varying vec3 tint; varying vec3 leafNormal; varying vec2 mark; varying float depth; varying float high;
      void main(){
        vec3 p=position;
        float h=max(p.y-root.y,0.);
        float flex=pow(h*.1,1.55);
        float phase=root.x*.23+root.z*.14+h*.19;
        p.x+=flex*(1.03*sin(time*.79+phase)+.24*sin(time*1.36+p.z*.31));
        p.z+=flex*(.71*cos(time*.64+phase)+.19*sin(p.x*.8+time));
        p.y+=flex*.13*sin(time*.90+phase);
        vec4 view=viewMatrix*vec4(p,1.);
        depth=-view.z;high=p.y; tint=color; mark=uv; leafNormal=normal;
        gl_Position=projectionMatrix*view;
      }`,
    fragmentShader:`uniform vec3 haze;
      varying vec3 tint; varying vec3 leafNormal; varying vec2 mark; varying float depth; varying float high;
      ${fogCode}
      void main(){
        float facing=abs(dot(normalize(leafNormal),normalize(vec3(-.43,.86,-.25))));
        float veins=0.;
        if(abs(mark.x)<1.03){
          float spine=1.-smoothstep(.035,.13,abs(mark.x));
          float strip=pow(.5+.5*sin(mark.y*86.-abs(mark.x)*7.),7.);
          veins=spine*.23+strip*.08+pow(abs(mark.x),8.)*.14;
        }
        vec3 c=tint*(.75+facing*.52+high*.027+veins);
        c+=vec3(.028,.034,.010)*veins;
        c=mix(c,haze,mist(depth));
        gl_FragColor=vec4(c,1.);
        ${outputCode}
      }`
  }));

  const beamBuilder=new GeometryBuilder();
  const beamStarts=[],beamEnds=[],beamWidths=[],beamPhases=[];
  function shaft(x,z,lean,width,intensity,phase){
    const index=beamBuilder.positions.length/3;
    const top=V(x,surfaceY+.02,z), bottom=V(x+lean,-.76,z+range(1.7,6.8));
    for(const [u,v] of [[-1,0],[1,0],[1,1],[-1,1]]){
      beamBuilder.point(top,C(0xf5eec6),u,v);
      beamStarts.push(top.x,top.y,top.z);
      beamEnds.push(bottom.x,bottom.y,bottom.z);
      beamWidths.push(width,intensity);
      beamPhases.push(phase);
    }
    beamBuilder.face(index,index+1,index+2,index+3);
  }
  shaft(-11,-7.6,13.2,2.64,.19,.7);
  shaft(-8.8,-8.8,12.8,1.05,.25,2.1);
  shaft(-6.85,-10,11.4,.78,.21,1.2);
  shaft(-13.7,-12.8,15.1,.87,.22,3.1);
  shaft(-3.4,-18.5,12.9,1.46,.18,4.8);
  shaft(-1.8,-21.9,13.5,.72,.22,4.4);
  shaft(-16.3,-23.5,14.3,1.8,.16,4);
  shaft(1.9,-27,10.8,2.2,.16,2.7);
  shaft(7.7,-14.7,10.4,1.9,.12,.5);
  shaft(-17,-6.4,11.2,1.04,.14,5.7);
  const beams=beamBuilder.geometry();
  beams.setAttribute("top",new T.Float32BufferAttribute(beamStarts,3));
  beams.setAttribute("bottom",new T.Float32BufferAttribute(beamEnds,3));
  beams.setAttribute("widthPower",new T.Float32BufferAttribute(beamWidths,2));
  beams.setAttribute("phase",new T.Float32BufferAttribute(beamPhases,1));
  const beamMesh=new T.Mesh(beams,new T.ShaderMaterial({
    side:T.DoubleSide,transparent:true,depthWrite:false,blending:T.AdditiveBlending,uniforms:{time:clock},
    vertexShader:`attribute vec3 top; attribute vec3 bottom; attribute vec2 widthPower; attribute float phase;
      uniform float time;
      varying vec2 ray; varying float opacity; varying float pulse; varying float distanceToEye;
      void main(){
        vec3 shift=vec3(.46*sin(time*.45+phase),0.,.29*cos(time*.38+phase));
        vec3 axis=bottom-top;
        vec3 mid=mix(top,bottom,uv.y)+shift;
        vec3 side=normalize(cross(axis,cameraPosition-mid)+vec3(.0001,0.,0.));
        vec3 p=mid+side*uv.x*widthPower.x*mix(.38,1.51,uv.y);
        ray=uv;opacity=widthPower.y;pulse=phase;distanceToEye=length(p-cameraPosition);
        gl_Position=projectionMatrix*viewMatrix*vec4(p,1.);
      }`,
    fragmentShader:`uniform float time; varying vec2 ray; varying float opacity; varying float pulse; varying float distanceToEye;
      void main(){
        float rim=exp(-ray.x*ray.x*5.6)*(1.-smoothstep(.62,1.,abs(ray.x)));
        float ends=smoothstep(0.,.12,ray.y)*(1.-smoothstep(.40,1.,ray.y));
        float flicker=.76+.20*sin(time*.62+pulse+ray.y*3.1)+.09*sin(time*1.67+pulse*3.6);
        float fade=exp(-distanceToEye*.019);
        gl_FragColor=vec4(vec3(.46,.64,.50),rim*ends*opacity*flicker*fade);
        ${outputCode}
      }`
  }));
  beamMesh.frustumCulled=false;
  beamMesh.renderOrder=4;
  scene.add(beamMesh);

  function fishGeometry(colorA,colorB){
    const model=new GeometryBuilder(), flank=C(colorA), back=C(colorB), belly=C(0xe6c28a), fin=C(0xa87543);
    const rows=[[-.45,.022,.033],[-.30,.086,.055],[-.11,.151,.091],[.12,.159,.109],[.31,.115,.081],[.44,.061,.044],[.49,.004,.006]];
    const sides=12;
    for(let i=0;i<rows.length;i++){
      const [x,ry,rz]=rows[i];
      for(let j=0;j<sides;j++){
        const a=j/sides*TAU, y=Math.cos(a), z=Math.sin(a);
        const c=flank.clone().lerp(y>=0?back:belly,Math.abs(y)*.69);
        if(i===2) c.lerp(back,.29);
        if(i===4) c.lerp(belly,.18);
        model.point(V(x,ry*y,rz*z),c);
        if(i){
          const k=(i-1)*sides,n=(j+1)%sides;
          model.face(k+j,k+sides+j,k+sides+n,k+n);
        }
      }
    }
    function triangle(a,b,c,tint){
      const k=model.point(V(...a),tint);
      model.point(V(...b),tint);
      model.point(V(...c),tint);
      model.tri(k,k+1,k+2);
    }
    triangle([-.37,0,0],[-.83,.205,.008],[-.67,0,0],fin);
    triangle([-.37,0,0],[-.67,0,0],[-.83,-.177,.008],fin);
    triangle([.17,.12,0],[-.16,.25,.004],[-.30,.073,0],back);
    triangle([.18,-.04,.08],[-.11,-.15,.18],[-.08,-.04,.13],fin);
    triangle([.18,-.04,-.08],[-.11,-.15,-.18],[-.08,-.04,-.13],fin);
    for(const side of [-1,1]){
      const center=model.point(V(.329,.038,.077*side),C(0x153239));
      for(let i=0;i<=10;i++){
        const a=i/10*TAU;
        model.point(V(.328+.031*Math.cos(a),.038+.031*Math.sin(a),.075*side),C(0x896539));
        if(i) model.tri(center,center+i,center+i+1);
      }
    }
    return model.geometry();
  }
  function fishMaterial(){
    const material=new T.MeshStandardMaterial({vertexColors:true,side:T.DoubleSide,roughness:.62,emissive:0x194437,emissiveIntensity:.25});
    material.onBeforeCompile=shader=>{
      shader.uniforms.time=clock;
      shader.vertexShader="uniform float time;\n"+shader.vertexShader;
      shader.vertexShader=shader.vertexShader.replace("#include <begin_vertex>",`
        #include <begin_vertex>
        float finWeight=max(0.,-.13-position.x);
        float fishPhase=instanceMatrix[3].x*.66+instanceMatrix[3].z*.21;
        transformed.z+=finWeight*sin(time*9.+position.x*5.+fishPhase)*.26;
      `);
    };
    return material;
  }
  const schools=[];
  function school(x,y,z,rx,rz,rate,phase,count,size,colors){
    const shoal=new T.InstancedMesh(fishGeometry(...colors),fishMaterial(),count);
    shoal.instanceMatrix.setUsage(T.DynamicDrawUsage);
    shoal.frustumCulled=false;
    scene.add(shoal);
    const members=[];
    for(let i=0;i<count;i++){
      const r=Math.sqrt(random()), a=range(0,TAU);
      members.push({x:Math.cos(a)*r*range(2.15,4.5),y:Math.sin(a)*r*range(.7,1.45),z:range(-1.60,1.60),
        s:range(.56,1.23)*size,p:range(0,TAU)});
      shoal.setColorAt(i,C(0xffffff).lerp(C(0xc1bea0),random()*.69));
    }
    schools.push({shoal,members,x,y,z,rx,rz,rate,phase});
  }
  school(-7.2,6.8,-2.2,7.6,5.5,.25,.07,38,.74,[0xc29c52,0x3f6d55]);
  school(2.3,8.1,-17.1,10.5,7.2,-.19,1.1,42,.71,[0x78b3aa,0x2d6470]);
  school(7.1,3.4,1.5,8.0,3.8,.24,2.23,30,.51,[0xdfa052,0x96673e]);
  school(-10.5,3.9,-17,9.7,7.2,.23,2.3,32,.53,[0x8db998,0x427b74]);
  const swimAxis=V(1,0,0), direction=V(), cross=V(), up=V(0,1,0);
  function updateSchools(t){
    for(const s of schools){
      const a=t*s.rate+s.phase, c=Math.cos(a), n=Math.sin(a);
      const x=s.x+s.rx*n, y=s.y+.76*Math.sin(a*1.37), z=s.z+s.rz*c;
      direction.set(s.rx*c*s.rate,.76*1.37*Math.cos(a*1.37)*s.rate,-s.rz*n*s.rate).normalize();
      cross.crossVectors(direction,up).normalize();
      dummy.quaternion.setFromUnitVectors(swimAxis,direction);
      for(let i=0;i<s.members.length;i++){
        const f=s.members[i], drift=t*.99+f.p;
        dummy.position.set(x,y+f.y+.16*Math.sin(drift),z)
          .addScaledVector(direction,f.x+.27*Math.sin(drift))
          .addScaledVector(cross,f.z+.19*Math.cos(drift));
        dummy.scale.setScalar(f.s);
        dummy.updateMatrix();
        s.shoal.setMatrixAt(i,dummy.matrix);
      }
      s.shoal.instanceMatrix.needsUpdate=true;
    }
  }

  const rayBody=new GeometryBuilder(), rows=32, chord=14;
  for(const side of [-1,1]){
    const base=rayBody.positions.length/3;
    for(let i=0;i<=rows;i++){
      const u=i/rows*2-1, s=Math.abs(u), z=u*3.36;
      const lead=1.27-1.94*Math.pow(s,1.38), tail=-1.39+.72*s-.45*Math.sin(PI*s);
      for(let j=0;j<=chord;j++){
        const a=j/chord;
        const thickness=.33*Math.pow(1-s,.8)*Math.pow(Math.sin(a*PI),.76);
        const p=V(mix(lead,tail,a),side*thickness-.13*Math.sin(s*PI)+.19*s*s,z);
        const c=side>0?C(0x265661).lerp(C(0x537e70),s*.40):C(0x759c8a).lerp(C(0x244d56),Math.pow(s,.85)*.87);
        c.lerp(C(0x163d52),Math.pow(Math.abs(a-.5)*2,8)*.42);
        if(side<0 && a>.24 && a<.55 && s>.15 && s<.38) c.lerp(C(0xa7ad7c),.43);
        const k=rayBody.point(p,c);
        if(i && j){
          const b=base+(i-1)*(chord+1)+j-1;
          if(side<0) rayBody.face(b,b+1,k,k-1);
          else rayBody.face(b,k-1,k,b+1);
        }
      }
    }
  }
  tube(rayBody,[V(-1.12,-.01,0),V(-2.05,-.045,.045),V(-2.93,.08,.13),V(-3.71,.14,.23),V(-4.27,.21,.16)],[.105,.068,.042,.024,.006],C(0x305963),7);
  for(const side of [-1,1]){
    tube(rayBody,[V(.86,-.06,.40*side),V(1.23,-.11,.435*side),V(1.58,-.13,.365*side),V(1.69,-.075,.29*side)],[.151,.122,.079,.02],C(0x416d71),8);
  }
  const mantaGeometry=rayBody.geometry();
  const mantas=[];
  for(let i=0;i<3;i++){
    const material=new T.MeshStandardMaterial({side:T.DoubleSide,vertexColors:true,roughness:.73});
    const phase={value:i*1.7};
    material.onBeforeCompile=shader=>{
      shader.uniforms.time=clock;
      shader.uniforms.rayPhase=phase;
      shader.vertexShader="uniform float time;uniform float rayPhase;\n"+shader.vertexShader;
      shader.vertexShader=shader.vertexShader.replace("#include <begin_vertex>",`
        #include <begin_vertex>
        float wing=min(abs(position.z)/3.36,1.);
        transformed.y+=pow(wing,1.72)*(.79*sin(time*1.52-wing*1.8+rayPhase)+.20);
        transformed.z*=1.-pow(wing,3.)*.048*cos(time*1.52+rayPhase);
        transformed.y+=max(0.,-position.x-1.45)*sin(time*1.63-position.x+rayPhase)*.058;
      `);
    };
    const mesh=new T.Mesh(mantaGeometry,material);
    mesh.scale.setScalar([1.04,.76,.68][i]);
    scene.add(mesh);
    mantas.push(mesh);
  }
  const rayPaths=[
    {x:-8,y:9.15,z:1.0,rx:10.9,rz:12.9,rate:.118,phase:.40},
    {x:13,y:9.8,z:-22,rx:11.3,rz:10.6,rate:-.106,phase:2.65},
    {x:-12,y:7.3,z:-25,rx:11.2,rz:8.5,rate:.12,phase:4.42}
  ];
  function updateMantas(t){
    mantas.forEach((ray,i)=>{
      const p=rayPaths[i], a=t*p.rate+p.phase;
      ray.position.set(p.x+p.rx*Math.cos(a),p.y+.79*Math.sin(a*1.5+i),p.z+p.rz*Math.sin(a));
      direction.set(-p.rx*Math.sin(a)*p.rate,1.185*Math.cos(a*1.5+i)*p.rate,p.rz*Math.cos(a)*p.rate).normalize();
      ray.quaternion.setFromUnitVectors(swimAxis,direction);
      ray.rotateX(.18*Math.sin(a+i*.63));
    });
  }

  function particles(bubbles){
    const positions=[],params=[];
    const vents=[[-6.5,15.5],[7.5,16.3],[-11.45,3.5],[7.1,-1.9],[13.9,-4.3],[-9.4,-16.4],[0.8,-18.0]];
    const count=bubbles?81:780;
    for(let i=0;i<count;i++){
      const vent=vents[i%vents.length];
      const x=bubbles?vent[0]+range(-.39,.39):range(-48,48);
      const z=bubbles?vent[1]+range(-.41,.41):range(-61,37);
      positions.push(x,bubbles?Math.max(ground(x,z)+.4,.05):range(.6,14.4),z);
      params.push(range(0,1),range(.33,1.0),bubbles?range(.055,.143):range(.016,.054));
    }
    const geometry=new T.BufferGeometry();
    geometry.setAttribute("position",new T.Float32BufferAttribute(positions,3));
    geometry.setAttribute("spec",new T.Float32BufferAttribute(params,3));
    const pixels={value:1};
    const points=new T.Points(geometry,new T.ShaderMaterial({
      transparent:true,depthWrite:false,uniforms:{time:clock,pixels},
      vertexShader:`uniform float time; uniform float pixels;
        attribute vec3 spec;
        varying float faint; varying float seed;
        void main(){
          vec3 p=position;
          float rise=fract(spec.x+time*mix(.035,.102,spec.y));
          ${bubbles?
            "p.y=mix(p.y,14.44,rise);p.x+=.7*rise+.24*sin(rise*9.+time*1.32+position.x);p.z+=.27*cos(rise*11.+position.z);":
            "p.x+=.65*sin(time*.23+spec.x*6.3);p.y+=.24*sin(time*.34+position.z);p.z+=.49*cos(time*.15+position.x);"}
          vec4 mv=viewMatrix*vec4(p,1.);
          float depth=-mv.z;
          faint=exp(-max(0.,depth)*.026)*spec.y*smoothstep(.18,1.3,depth);
          ${bubbles?"faint*=smoothstep(0.,.08,rise)*(1.-smoothstep(.91,1.,rise));":""}
          seed=spec.x;
          gl_PointSize=clamp(pixels*spec.z/max(depth,.25),1.,${bubbles?"39.":"7."});
          gl_Position=projectionMatrix*mv;
        }`,
      fragmentShader:`varying float faint; varying float seed;
        void main(){
          vec2 p=gl_PointCoord-.5;
          float d=length(p);
          ${bubbles?`
            float edge=exp(-pow((d-.405)*24.,2.));
            float shine=exp(-dot(p-vec2(-.17,-.22),p-vec2(-.17,-.22))*160.);
            float lower=exp(-dot(p-vec2(.18,.29),p-vec2(.18,.29))*220.);
            float alpha=(.36*edge+.89*shine+.31*lower+.075*max(0.,1.-d*2.))*faint;
            gl_FragColor=vec4(vec3(.56,.83,.75),alpha*(1.-smoothstep(.44,.5,d)));
          `:`
            float alpha=exp(-d*d*19.)*(1.-smoothstep(.40,.50,d))*faint*.76;
            gl_FragColor=vec4(mix(vec3(.42,.70,.64),vec3(.85,.76,.44),seed),alpha);
          `}
          ${outputCode}
        }`
    }));
    points.renderOrder=bubbles?6:5;
    points.frustumCulled=false;
    scene.add(points);
    return pixels;
  }
  const pixelScales=[particles(true),particles(false)];

  const initial=V(0,5.31,25.4);
  const position=initial.clone(), proposed=V(), local=V(), nearest=V();
  const forward=V(), move=V(), target=V();
  let yaw=.016, pitch=-.059, desiredYaw=yaw, desiredPitch=pitch, speed=0;
  let pointer=null, lastX=0, lastY=0, demo=false, touchEndedTour=false;
  let tourStart=0, tourEntry=0;
  const tourEntryPos=V(), tourEntryAim=V();
  const route=new T.CatmullRomCurve3([
    initial.clone(),V(-1.65,4.02,15.1),V(-1.23,4.83,7.70),V(1.35,5.57,6.12),
    V(4.22,7.24,10.7),V(2.67,7.7,18.4)
  ],true,"centripetal");
  const gazes=new T.CatmullRomCurve3([
    V(-.48,3.54,-4.2),V(-7.1,3.82,1.5),V(-6.7,5.06,-1.3),
    V(7.85,3.87,-4.6),V(11.25,4.47,-5.3),V(.10,9.65,-11.7)
  ],true,"centripetal");
  function clear(p){
    if(p.y<ground(p.x,p.z)+.57 || p.y>surfaceY-.54 || Math.abs(p.x)>51 || p.z< -64 || p.z>37) return false;
    for(const r of stones){
      const dx=p.x-r.p.x, dy=p.y-r.p.y, dz=p.z-r.p.z;
      if(Math.abs(dx)>r.s.x+r.s.z || Math.abs(dz)>r.s.x+r.s.z || Math.abs(dy)>r.s.y) continue;
      const x=(dx*r.cosine-dz*r.sine)/r.s.x, z=(dx*r.sine+dz*r.cosine)/r.s.z;
      if(x*x+z*z+(dy/r.s.y)**2<1) return false;
    }
    for(const r of archPieces){
      if(p.distanceToSquared(r.p)<r.r*r.r) return false;
    }
    local.copy(p).applyMatrix4(shipInverse);
    if(Math.abs(local.x)<10.85 && Math.abs(local.z)<3.7){
      if(Math.abs(local.x)<7.9 && local.y>-.69 &&
         local.y<3.22+1.03*Math.pow(Math.min(1,Math.abs(local.x)/length),4) &&
         Math.abs(local.z)<.62+2.33*Math.pow(Math.max(0,1-(local.x/7.87)**2),.59)) return false;
      for(const part of posts){
        const along=clamp(nearest.copy(local).sub(part.a).dot(part.d)/part.d.lengthSq(),0,1);
        nearest.copy(part.a).addScaledVector(part.d,along);
        if(nearest.distanceToSquared(local)<part.r*part.r) return false;
      }
      if(local.x> -3.25 && local.x<-.92 && Math.abs(local.z)<3.19 && local.y>4.13 && local.y<6.86) return false;
    }
    return true;
  }
  function swim(delta){
    speed=T.MathUtils.damp(speed,pointer===null?0:4.15,pointer===null?10.5:6,delta);
    forward.set(-Math.sin(yaw)*Math.cos(pitch),Math.sin(pitch),-Math.cos(yaw)*Math.cos(pitch));
    move.copy(forward).multiplyScalar(speed*delta);
    proposed.copy(position).add(move);
    if(clear(proposed)){
      position.copy(proposed);
      return;
    }
    for(const axis of ["x","y","z"]){
      proposed.copy(position);
      proposed[axis]+=move[axis];
      if(clear(proposed)) position.copy(proposed);
    }
  }
  function setTour(value){
    if(demo===value) return;
    demo=value;
    get("tour").setAttribute("aria-pressed",String(value));
    get("tour-label").textContent=value?"End tour":"Play tour";
    get("tour-icon").setAttribute("d",value?"M7 5v10m6-10v10":"m7 4 9 6-9 6z");
    get("mode").textContent=value?"Guided dive":"Free swim";
    get("hint").textContent=value?"Touch or click to take over":"Hold to swim · Drag to turn";
    dive.classList.toggle("touring",value);
    if(value){
      tourStart=clock.value;
      tourEntry=tourStart>0?.95:0;
      tourEntryPos.copy(position);
      tourEntryAim.set(-Math.sin(yaw)*Math.cos(pitch),Math.sin(pitch),-Math.cos(yaw)*Math.cos(pitch))
        .multiplyScalar(22).add(position);
      speed=0;
    } else {
      desiredYaw=yaw;
      desiredPitch=pitch;
    }
  }
  function tourCamera(t){
    const elapsed=t-tourStart, progress=(Math.max(0,elapsed-tourEntry)%21.5)/21.5;
    route.getPoint(progress,proposed);
    gazes.getPoint(progress,target);
    if(elapsed<tourEntry){
      const a=elapsed/tourEntry, ease=a*a*(3-2*a);
      proposed.lerpVectors(tourEntryPos,proposed,ease);
      target.lerpVectors(tourEntryAim,target,ease);
    }
    if(clear(proposed)) position.copy(proposed);
    direction.copy(target).sub(position).normalize();
    yaw=Math.atan2(-direction.x,-direction.z);
    pitch=Math.asin(clamp(direction.y,-1,1));
  }

  dive.addEventListener("pointerdown",event=>{
    if(demo && event.isTrusted){
      touchEndedTour=event.target.closest("#tour")!==null;
      setTour(false);
    } else {
      touchEndedTour=false;
    }
  },true);
  canvas.addEventListener("pointerdown",event=>{
    if(pointer!==null || (event.pointerType==="mouse" && event.button!==0)) return;
    event.preventDefault();
    pointer=event.pointerId;
    lastX=event.clientX;lastY=event.clientY;
    canvas.setPointerCapture(pointer);
    dive.classList.add("swimming","explored");
  });
  canvas.addEventListener("pointermove",event=>{
    if(event.pointerId!==pointer) return;
    const gain=event.pointerType==="touch"?.006:.0044;
    desiredYaw-=(event.clientX-lastX)*gain;
    desiredPitch=clamp(desiredPitch-(event.clientY-lastY)*gain,-1.22,1.22);
    lastX=event.clientX;lastY=event.clientY;
  });
  function finishPointer(event){
    if(pointer===null || (event && pointer!==event.pointerId)) return;
    if(canvas.hasPointerCapture(pointer)) canvas.releasePointerCapture(pointer);
    pointer=null;
    dive.classList.remove("swimming");
  }
  for(const type of ["pointerup","pointercancel","lostpointercapture"]) canvas.addEventListener(type,finishPointer);
  window.addEventListener("blur",()=>finishPointer());
  canvas.addEventListener("contextmenu",event=>event.preventDefault());
  get("tour").addEventListener("click",()=>{
    if(touchEndedTour){touchEndedTour=false;return;}
    finishPointer();
    setTour(!demo);
  });
  get("reset").addEventListener("click",()=>{
    finishPointer();setTour(false); speed=0;
    position.copy(initial); yaw=desiredYaw=.016; pitch=desiredPitch=-.059;
    dive.classList.remove("explored");
  });
  window.addEventListener("hashchange",()=>setTour(location.hash.toLowerCase()==="#demo"));

  function resize(){
    const w=dive.clientWidth, h=dive.clientHeight, aspect=w/Math.max(1,h);
    renderer.setPixelRatio(Math.min(devicePixelRatio||1,aspect<.92?1.45:1.65));
    renderer.setSize(w,h,false);
    camera.aspect=aspect;
    camera.fov=aspect<.79?70:aspect<1.22?60:55;
    camera.updateProjectionMatrix();
    const pointScale=h*renderer.getPixelRatio()/(2*Math.tan(camera.fov*PI/360));
    for(const uniform of pixelScales) uniform.value=pointScale;
  }
  window.addEventListener("resize",resize);
  resize();
  const depthText=get("depth"), level=get("level"), bearing=get("bearing"), needle=get("needle");
  const headings=["N","NE","E","SE","S","SW","W","NW"];
  let lastTime=performance.now(), t=0, hudElapsed=1;
  const reduce=matchMedia("(prefers-reduced-motion: reduce)").matches;
  function render(now){
    const dt=clamp((now-lastTime)*.001,0,.05);
    lastTime=now; t+=dt; clock.value=t;
    if(demo) tourCamera(t);
    else {
      yaw=T.MathUtils.damp(yaw,desiredYaw,14,dt);
      pitch=T.MathUtils.damp(pitch,desiredPitch,14,dt);
      swim(dt);
    }
    camera.position.copy(position);
    camera.rotation.set(pitch,yaw,reduce?0:Math.sin(t*.69)*.0045);
    if(!reduce && pointer===null) camera.position.y+=Math.sin(t*.83)*.047;
    updateSchools(t);
    updateMantas(t);
    hudElapsed+=dt;
    if(hudElapsed>.095){
      hudElapsed=0;
      const depth=surfaceY-position.y, degrees=((Math.round(-yaw*180/PI)%360)+360)%360;
      depthText.textContent=depth.toFixed(1);
      level.style.left=`${depth/surfaceY*100}%`;
      bearing.textContent=`${headings[Math.round(degrees/45)%8]} ${String(degrees).padStart(3,"0")}°`;
      needle.style.transform=`rotate(${-degrees}deg)`;
    }
    renderer.render(scene,camera);
    requestAnimationFrame(render);
  }
  get("tour").disabled=false;
  get("reset").disabled=false;
  if(location.hash.toLowerCase()==="#demo") setTour(true);
  render(lastTime);
  loading.hidden=true;
}
</script>
</body>
</html>