Skip to content
VibeCodeBench
Back to the app

The code

Swim the Kelp Garden by Claude Opus 5.5

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

index.html

works · auto-checked (Checked by an automated pass. Not hand-played yet.)36.6 KB · 701 lines · loads cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js
Download
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1,maximum-scale=1,user-scalable=no">
<title>Kelp Garden Swim</title>
<style>
html,body{margin:0;height:100%;overflow:hidden;background:#0b3a5e;font-family:system-ui,-apple-system,"Segoe UI",Roboto,sans-serif;color:#ffd894;-webkit-user-select:none;user-select:none;-webkit-touch-callout:none;-webkit-tap-highlight-color:transparent}
canvas{display:block;touch-action:none;width:100%;height:100%;cursor:grab}
canvas:active{cursor:grabbing}
#vig{position:fixed;inset:0;pointer-events:none;background:radial-gradient(ellipse at 50% 42%,rgba(0,0,0,0) 52%,rgba(2,22,44,.6) 100%)}
.pill{position:fixed;left:50%;bottom:26px;transform:translateX(-50%);padding:14px 22px;border-radius:20px;background:rgba(6,42,68,.66);border:1px solid rgba(255,196,104,.35);font-size:17px;line-height:1.45;text-align:center;pointer-events:none;transition:opacity 1.2s;max-width:82vw}
#tag{opacity:0;transition:opacity .6s;font-size:15px}
#tour{position:fixed;right:16px;top:16px;min-width:76px;height:64px;padding:0 22px;border-radius:32px;border:2px solid rgba(255,196,104,.65);background:rgba(8,54,80,.72);color:#ffd27a;font-size:19px;font-weight:600;cursor:pointer;touch-action:manipulation}
#tour:active{background:rgba(20,90,110,.85)}
#err{display:none;position:fixed;inset:0;align-items:center;justify-content:center;text-align:center;padding:24px;font-size:18px}
</style>
</head>
<body>
<div id="vig"></div>
<div id="hint" class="pill">Press &amp; hold to glide ahead<br>Drag to turn</div>
<div id="tag" class="pill">Hands-free tour &middot; touch anywhere to swim</div>
<button id="tour" type="button">&#9654; Tour</button>
<div id="err">Sorry, this underwater garden needs WebGL and could not start here.</div>
<script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js"></script>
<script>
(function(){
const errBox=document.getElementById('err');
function fail(){errBox.style.display='flex';}
if(!window.THREE){fail();return;}
const T=THREE;
let renderer;
try{renderer=new T.WebGLRenderer({antialias:true});}catch(e){fail();return;}
renderer.setPixelRatio(Math.min(window.devicePixelRatio||1,1.5));
renderer.setSize(innerWidth,innerHeight);
document.body.insertBefore(renderer.domElement,document.body.firstChild);

/* ---------- helpers ---------- */
let seed=20261122;
const rnd=()=>{seed=(seed*16807)%2147483647;return (seed-1)/2147483646;};
const R=(a,b)=>a+(b-a)*rnd();
const clamp=(v,a,b)=>v<a?a:v>b?b:v;
const V=(x,y,z)=>new T.Vector3(x,y,z);
const UP=V(0,1,0),ONE=V(1,1,1);
function h3(x,y,z){const s=Math.sin(x*127.1+y*311.7+z*74.7)*43758.5453;return s-Math.floor(s);}
function vn(x,y,z){const X=Math.floor(x),Y=Math.floor(y),Z=Math.floor(z);let a=x-X,b=y-Y,c=z-Z;a=a*a*(3-2*a);b=b*b*(3-2*b);c=c*c*(3-2*c);
 const l=(p,q,t)=>p+(q-p)*t;
 return l(l(l(h3(X,Y,Z),h3(X+1,Y,Z),a),l(h3(X,Y+1,Z),h3(X+1,Y+1,Z),a),b),l(l(h3(X,Y,Z+1),h3(X+1,Y,Z+1),a),l(h3(X,Y+1,Z+1),h3(X+1,Y+1,Z+1),a),b),c);}
function fbm(x,y,z){return vn(x,y,z)*.55+vn(x*2.1+5,y*2.1,z*2.1)*.3+vn(x*4.3,y*4.3+3,z*4.3)*.15;}
function ground(x,z){const r=Math.hypot(x,z);return .6*Math.sin(x*.07)*Math.cos(z*.06)+.35*Math.sin(x*.17+z*.11)+.3*Math.sin(z*.21-x*.05)+(r>62?(r-62)*(r-62)*.012:0);}

/* palette */
const ORANGE=[1,.52,.2],GOLD=[.95,.74,.3],TEAL=[.14,.58,.58],DEEP=[.07,.19,.36],KELP=[.22,.46,.16];

/* ---------- scene ---------- */
const scene=new T.Scene();
const FOG=new T.Color(0x0b3a5e);
scene.background=FOG;
scene.fog=new T.FogExp2(FOG,0.021);
const camera=new T.PerspectiveCamera(70,innerWidth/innerHeight,0.1,400);
camera.rotation.order='YXZ';
scene.add(new T.HemisphereLight(0x58c8c0,0x0a2848,0.95));
const SUN=V(-0.35,1,-0.2).normalize();
const dl=new T.DirectionalLight(0xffc870,0.85);dl.position.copy(SUN).multiplyScalar(50);scene.add(dl);
const timeU={value:0};
const scaleU={value:innerHeight*renderer.getPixelRatio()*0.714};

/* ---------- shaders ---------- */
const CAUS=`
float caus(vec2 uv,float time){
 vec2 p=mod(uv*6.2831853,6.2831853)-250.0;
 vec2 i=p;float c=1.0;float inten=0.005;
 for(int n=0;n<5;n++){
  float t=time*(1.0-(3.5/float(n+1)));
  i=p+vec2(cos(t-i.x)+sin(t+i.y),sin(t-i.y)+cos(t+i.x));
  c+=1.0/length(vec2(p.x/(sin(i.x+t)/inten),p.y/(cos(i.y+t)/inten)));
 }
 c/=5.0;c=1.17-pow(c,1.4);
 return pow(abs(c),8.0);
}`;
const LIT_VS=`
#include <fog_pars_vertex>
varying vec3 vW;varying vec3 vN;varying vec3 vC;varying vec2 vUv;
void main(){
 vec4 w=modelMatrix*vec4(position,1.0);
 vW=w.xyz;vN=normalize(mat3(modelMatrix)*normal);
 #ifdef USE_COLOR
 vC=color;
 #else
 vC=vec3(1.0);
 #endif
 vUv=uv;
 vec4 mvPosition=viewMatrix*w;
 gl_Position=projectionMatrix*mvPosition;
 #include <fog_vertex>
}`;
const LIT_FS=`
uniform float uTime;uniform vec3 uSun;uniform sampler2D uMap;uniform float uUseMap;uniform float uSand;
varying vec3 vW;varying vec3 vN;varying vec3 vC;varying vec2 vUv;
#include <fog_pars_fragment>
${CAUS}
void main(){
 vec3 n=normalize(vN);
 if(!gl_FrontFacing)n=-n;
 vec3 base=vC;
 if(uUseMap>0.5)base*=texture2D(uMap,vUv).rgb;
 if(uSand>0.5){float r=sin(vW.x*1.3+sin(vW.z*0.35)*2.0+vW.z*0.4);base*=0.9+0.1*r;}
 float hemi=n.y*0.5+0.5;
 vec3 amb=mix(vec3(0.03,0.10,0.20),vec3(0.16,0.42,0.48),hemi);
 float sun=max(dot(n,uSun),0.0);
 float depthL=clamp(0.62+vW.y*0.02,0.55,1.0);
 float c=0.0;
 if(n.y>0.02)c=caus(vW.xz*0.085+vec2(vW.y*0.03),uTime*0.45+23.0)*smoothstep(0.0,0.7,n.y);
 vec3 col=base*(amb+vec3(1.0,0.82,0.5)*sun*0.75*depthL)+base*vec3(1.0,0.85,0.55)*c*1.5*depthL+vec3(0.9,0.75,0.45)*c*0.07;
 gl_FragColor=vec4(col,1.0);
 #include <fog_fragment>
}`;
function litMat(o){
 o=o||{};
 const u=T.UniformsUtils.merge([T.UniformsLib.fog,{uMap:{value:null},uUseMap:{value:0},uSand:{value:0},uSun:{value:SUN.clone()}}]);
 u.uTime=timeU;
 if(o.map){u.uMap.value=o.map;u.uUseMap.value=1;}
 if(o.sand)u.uSand.value=1;
 return new T.ShaderMaterial({uniforms:u,vertexShader:LIT_VS,fragmentShader:LIT_FS,fog:true,vertexColors:true,side:T.DoubleSide});
}
function paint(g,c){const n=g.attributes.position.count,a=new Float32Array(n*3);for(let i=0;i<n;i++)a.set(c,i*3);g.setAttribute('color',new T.BufferAttribute(a,3));return g;}
function Merger(){this.p=[];this.n=[];this.c=[];this.u=[];}
Merger.prototype.add=function(geo,m,colFn){
 const g=geo.index?geo.toNonIndexed():geo.clone();
 if(m)g.applyMatrix4(m);
 if(!g.attributes.normal)g.computeVertexNormals();
 const P=g.attributes.position,N=g.attributes.normal,U=g.attributes.uv;
 for(let i=0;i<P.count;i++){
  const x=P.getX(i),y=P.getY(i),z=P.getZ(i),nx=N.getX(i),ny=N.getY(i),nz=N.getZ(i);
  this.p.push(x,y,z);this.n.push(nx,ny,nz);
  const c=colFn(x,y,z,nx,ny,nz);this.c.push(c[0],c[1],c[2]);
  this.u.push(U?U.getX(i):0,U?U.getY(i):0);
 }
};
Merger.prototype.mesh=function(mat){
 const g=new T.BufferGeometry();
 g.setAttribute('position',new T.Float32BufferAttribute(this.p,3));
 g.setAttribute('normal',new T.Float32BufferAttribute(this.n,3));
 g.setAttribute('color',new T.Float32BufferAttribute(this.c,3));
 g.setAttribute('uv',new T.Float32BufferAttribute(this.u,2));
 return new T.Mesh(g,mat);
};
const _v=V(0,0,0),_u=V(0,0,0),_a=V(0,0,0),_b=V(0,0,0),_d=V(0,0,0),_e=V(0,0,0),_p=V(0,0,0);
const _f1=V(0,0,0),_f2=V(0,0,0),_fw=V(0,0,0),_rt=V(0,0,0),_up=V(0,0,0);
const _m=new T.Matrix4(),_q=new T.Quaternion();

/* ---------- rocks & collision ---------- */
const rockMat=litMat();
const rocks=new Merger();
const rockCols=[];
function rockK(x,y,z,s){return .8+.42*fbm(x*1.5+s,y*1.5+s*.37,z*1.5-s*.61);}
function rockColor(x,y,z,nx,ny){
 const f=fbm(x*.35,y*.35,z*.35);
 let r=.10+.06*f,g=.20+.10*f,b=.31+.08*f;
 const a=clamp((ny-.4)*2.2,0,1)*(.5+.5*f);
 r+=(.20-r)*a;g+=(.42-g)*a;b+=(.22-b)*a;
 const s=vn(x*1.3,y*1.3,z*1.3);
 if(s>.8){r=.78;g=.44;b=.17;}else if(s<.12){r=.62;g=.5;b=.22;}
 return [r,g,b];
}
function addRock(pos,sc,ry,rx,detail){
 const sd=R(0,100);
 const g=new T.IcosahedronGeometry(1,detail);
 const P=g.attributes.position;
 for(let i=0;i<P.count;i++){const x=P.getX(i),y=P.getY(i),z=P.getZ(i),k=rockK(x,y,z,sd);P.setXYZ(i,x*k*sc.x,y*k*sc.y,z*k*sc.z);}
 g.computeVertexNormals();
 const q=new T.Quaternion().setFromEuler(new T.Euler(rx,ry,0));
 rocks.add(g,new T.Matrix4().compose(pos,q,ONE),rockColor);
 const rc={c:pos.clone(),q:q.clone().conjugate(),s:sc.clone(),sd:sd,max:Math.max(sc.x,sc.y,sc.z)*1.32};
 rockCols.push(rc);return rc;
}
function pushRock(p,r,rc){
 _v.subVectors(p,rc.c);const D=_v.length();
 if(D>rc.max+r||D<1e-4)return false;
 _u.copy(_v).applyQuaternion(rc.q);
 _u.set(_u.x/rc.s.x,_u.y/rc.s.y,_u.z/rc.s.z).normalize();
 const k=rockK(_u.x,_u.y,_u.z,rc.sd)*1.05;
 _u.set(_u.x*k*rc.s.x,_u.y*k*rc.s.y,_u.z*k*rc.s.z);
 const L=_u.length();
 if(D<L+r){p.copy(rc.c).addScaledVector(_v,(L+r)/D);return true;}
 return false;
}
const shipCols=[];
function boxCol(mat,min,max){shipCols.push({m:mat.clone(),inv:mat.clone().invert(),min:min.clone(),max:max.clone()});}
function meshCol(mesh){mesh.updateMatrixWorld(true);mesh.geometry.computeBoundingBox();const bb=mesh.geometry.boundingBox;boxCol(mesh.matrixWorld,bb.min,bb.max);}
function pushBox(p,r,b){
 _v.copy(p).applyMatrix4(b.inv);
 const qx=clamp(_v.x,b.min.x,b.max.x),qy=clamp(_v.y,b.min.y,b.max.y),qz=clamp(_v.z,b.min.z,b.max.z);
 const dx=_v.x-qx,dy=_v.y-qy,dz=_v.z-qz,d=Math.sqrt(dx*dx+dy*dy+dz*dz);
 if(d>=r)return false;
 if(d>1e-5){const s=r/d;_v.set(qx+dx*s,qy+dy*s,qz+dz*s);}
 else{
  const c=[_v.x-b.min.x,b.max.x-_v.x,_v.y-b.min.y,b.max.y-_v.y,_v.z-b.min.z,b.max.z-_v.z];
  let k=0;for(let i=1;i<6;i++)if(c[i]<c[k])k=i;
  if(k===0)_v.x=b.min.x-r;else if(k===1)_v.x=b.max.x+r;else if(k===2)_v.y=b.min.y-r;else if(k===3)_v.y=b.max.y+r;else if(k===4)_v.z=b.min.z-r;else _v.z=b.max.z+r;
 }
 p.copy(_v.applyMatrix4(b.m));return true;
}
let SHIPC=V(18,0,-20);
function resolve(p,r,fl){
 for(let i=0;i<rockCols.length;i++)pushRock(p,r,rockCols[i]);
 if(p.distanceToSquared(SHIPC)<900)for(let i=0;i<shipCols.length;i++)pushBox(p,r,shipCols[i]);
 const g=ground(p.x,p.z)+fl;if(p.y<g)p.y=g;
}

/* ---------- tour path ---------- */
const b1=ground(-14,-8)-.5,b2=ground(8,18)-.5;
const PATH=new T.CatmullRomCurve3([
 [0,6,34],[8,b2+3.0,26],[8,b2+2.7,18],[7,b2+3.4,10],[2,7,-6],[5,8,-31],[-12,6,-24],
 [-14,b1+3.2,-15],[-14,b1+3.0,-8],[-14,b1+3.4,-1],[-8,7,18]
].map(a=>V(a[0],a[1],a[2])),true,'centripetal');
const pathPts=PATH.getSpacedPoints(300);
function nearPath(p,d){for(let i=0;i<pathPts.length;i++)if(pathPts[i].distanceTo(p)<d)return true;return false;}
function nearPathXZ(x,z,d){for(let i=0;i<pathPts.length;i++){const q=pathPts[i];if(Math.hypot(q.x-x,q.z-z)<d)return true;}return false;}

/* ---------- arches ---------- */
const arches=[];
function arch(cx,cz,ang,Rr,n,smin,smax){
 const base=ground(cx,cz)-.5,ux=Math.cos(ang),uz=Math.sin(ang);
 arches.push([cx,cz,Rr]);
 for(let k=0;k<n;k++){
  const th=Math.PI*k/(n-1),s=R(smin,smax);
  addRock(V(cx+ux*Math.cos(th)*Rr,base+Math.sin(th)*Rr,cz+uz*Math.cos(th)*Rr),V(s*R(.9,1.15),s*R(.85,1.05),s*R(.9,1.15)),R(0,6.28),R(-.4,.4),2);
 }
 for(const sg of [-1,1]){const s=smax*1.3;addRock(V(cx+ux*sg*Rr*1.05,base-.3,cz+uz*sg*Rr*1.05),V(s,s*.8,s),R(0,6.28),0,2);}
}
arch(-14,-8,0,8,13,1.8,2.2);
arch(8,18,0,6.5,11,1.5,1.9);
arch(-34,30,1.0,7,12,1.6,2.1);
arch(38,-4,2.2,6,10,1.5,1.9);

/* ---------- sunken ship ---------- */
function plankTex(){
 const c=document.createElement('canvas');c.width=c.height=256;const x=c.getContext('2d');
 for(let i=0;i<8;i++){
  x.fillStyle='hsl('+(20+rnd()*14)+','+(52+rnd()*18)+'%,'+(26+rnd()*14)+'%)';x.fillRect(0,i*32,256,32);
  for(let k=0;k<26;k++){x.fillStyle=rnd()<.5?'rgba(70,32,10,.35)':'rgba(210,130,60,.22)';x.fillRect(rnd()*256,i*32+3+rnd()*26,12+rnd()*50,1.5);}
  x.fillStyle='rgba(28,12,4,.8)';x.fillRect(0,i*32,256,2);const o=rnd()*220;x.fillRect(o,i*32,2,32);
  x.fillStyle='rgba(240,190,90,.7)';x.fillRect(o+5,i*32+8,2,2);x.fillRect(o+5,i*32+22,2,2);
 }
 for(let k=0;k<34;k++){x.fillStyle='rgba('+(30+rnd()*30)+','+(100+rnd()*40)+','+(70+rnd()*30)+','+(.12+rnd()*.25)+')';x.beginPath();x.ellipse(rnd()*256,rnd()*256,6+rnd()*26,3+rnd()*10,rnd()*3,0,6.3);x.fill();}
 const t=new T.CanvasTexture(c);t.wrapS=t.wrapT=T.RepeatWrapping;return t;
}
const shipMat=litMat({map:plankTex()});
const L=20,W=3.2,D=3.4,NS=16,NK=10;
const hw=f=>Math.max(.12,W*(f>0?Math.sqrt(Math.max(0,1-f*f)):1-.28*f*f));
const sh=f=>.9*f*f+(f>0?.35*f:0);
const dp=f=>D*(1-.35*f*f);
const ship=new T.Group();
{
 const pos=[],uv=[],idx=[];
 for(let i=0;i<=NS;i++){const f=-1+2*i/NS,x=f*L/2,w=hw(f),s=sh(f),d=dp(f);
  for(let k=0;k<=NK;k++){const a=Math.PI*k/NK;pos.push(x,s-d*Math.pow(Math.sin(a),.7),w*Math.cos(a));uv.push(i/NS*4,k/NK*1.5);}}
 for(let i=0;i<NS;i++)for(let k=0;k<NK;k++){const a=i*(NK+1)+k,b=a+NK+1;idx.push(a,b,a+1,b,b+1,a+1);}
 for(const i of [0,NS]){const f=i?1:-1,ci=pos.length/3,o=i*(NK+1);pos.push(f*L/2,sh(f)-dp(f)*.5,0);uv.push(.5,.5);
  for(let k=0;k<NK;k++)idx.push(ci,o+k,o+k+1);idx.push(ci,o+NK,o);}
 const g=new T.BufferGeometry();g.setAttribute('position',new T.Float32BufferAttribute(pos,3));g.setAttribute('uv',new T.Float32BufferAttribute(uv,2));g.setIndex(idx);g.computeVertexNormals();
 ship.add(new T.Mesh(paint(g,[1,1,1]),shipMat));
 const dpo=[],duv=[],di=[];
 for(let i=0;i<=NS;i++){const f=-1+2*i/NS,x=f*L/2,w=hw(f)*.97,y=sh(f)-.45;dpo.push(x,y,w,x,y,-w);duv.push(i/NS*4,0,i/NS*4,1.2);}
 for(let i=0;i<NS;i++){const a=i*2;di.push(a,a+1,a+2,a+1,a+3,a+2);}
 const dg=new T.BufferGeometry();dg.setAttribute('position',new T.Float32BufferAttribute(dpo,3));dg.setAttribute('uv',new T.Float32BufferAttribute(duv,2));dg.setIndex(di);dg.computeVertexNormals();
 ship.add(new T.Mesh(paint(dg,[.85,.82,.78]),shipMat));
}
const deckY=x=>sh(x/(L/2))-.45;
const shipParts=[];
function part(geo,col,mat,x,y,z,rx,ry,rz){const m=new T.Mesh(paint(geo,col),mat||shipMat);m.position.set(x,y,z);m.rotation.set(rx||0,ry||0,rz||0);ship.add(m);shipParts.push(m);return m;}
part(new T.BoxGeometry(5,2.2,2*hw(-.7)*.92),[.92,.82,.72],null,-7,deckY(-7)+1.1,0);
part(new T.BoxGeometry(5.6,.25,2*hw(-.7)*.98),[.7,.6,.5],null,-7,deckY(-7)+2.3,0);
part(new T.CylinderGeometry(.2,.3,13,8),[.75,.62,.5],null,1.5,deckY(1.5)+6.5,0);
part(new T.CylinderGeometry(.12,.12,7.5,6),[.75,.62,.5],null,1.5,deckY(1.5)+10.4,0,Math.PI/2,0,0);
part(new T.CylinderGeometry(.18,.25,5,8),[.75,.62,.5],null,-4.5,deckY(-4.5)+2.5,0,0,0,.08);
part(new T.CylinderGeometry(.17,.2,9,8),[.7,.58,.46],null,-1.5,deckY(-1.5)+.9,1.2,0,.35,1.35);
part(new T.CylinderGeometry(.12,.2,6,8),[.75,.62,.5],null,L/2+1.6,sh(1)+.9,0,0,0,-1.2);
{
 const g=new T.PlaneGeometry(6.4,5,10,8),P=g.attributes.position;
 for(let i=0;i<P.count;i++){const x=P.getX(i),y=P.getY(i);let yy=y;if(y<-2.4)yy+=R(0,1.4);
  P.setXYZ(i,x,yy,Math.sin(Math.PI*(x/6.4+.5))*Math.sin(Math.PI*(y/5+.5))*.7+R(-.05,.05));}
 g.rotateY(Math.PI/2);g.computeVertexNormals();
 part(g,[.62,.36,.17],rockMat,1.85,deckY(1.5)+7.9,0);
}
ship.position.set(18,ground(18,-20)+2.2,-20);
ship.rotation.set(.2,.6,.06,'YXZ');
scene.add(ship);ship.updateMatrixWorld(true);
SHIPC=ship.position.clone();
const shipInv=ship.matrixWorld.clone().invert();
for(let i=0;i<NS;i++){
 const f0=-1+2*i/NS,f1=-1+2*(i+1)/NS,w=Math.max(hw(f0),hw(f1));
 boxCol(ship.matrixWorld,V(f0*L/2,Math.min(sh(f0)-dp(f0),sh(f1)-dp(f1))-.2,-w),V(f1*L/2,Math.max(sh(f0),sh(f1))+.15,w));
}
shipParts.forEach(meshCol);
function inShip(x,z,pad){_v.set(x,SHIPC.y,z).applyMatrix4(shipInv);return Math.abs(_v.x)<L/2+3+pad&&Math.abs(_v.z)<W+1+pad;}
function nearArch(x,z,pad){for(const a of arches)if(Math.hypot(x-a[0],z-a[1])<a[2]+pad)return true;return false;}

/* ---------- boulders ---------- */
const boulders=[];
for(let tries=0;tries<900&&boulders.length<34;tries++){
 const a=R(0,6.283),r=R(8,76),x=Math.cos(a)*r,z=Math.sin(a)*r,s=R(1.2,4.2);
 const p=V(x,ground(x,z)-s*.35,z);
 if(nearPath(p,s*1.9+2))continue;
 if(Math.hypot(x,z-34)<s*1.8+6)continue;
 if(inShip(x,z,s*1.5)||nearArch(x,z,s+3))continue;
 boulders.push(addRock(p,V(s*R(.8,1.4),s*R(.5,.9),s*R(.8,1.3)),R(0,6.28),R(-.2,.2),s>2.5?2:1));
}
scene.add(rocks.mesh(rockMat));
function inRock(x,z,pad){for(const rc of rockCols)if(Math.hypot(x-rc.c.x,z-rc.c.z)<Math.max(rc.s.x,rc.s.z)*1.1+pad)return true;return false;}

/* ---------- kelp ---------- */
const kp=[],kb=[],kh=[],kph=[],kl=[],ku=[],ki=[];
function kelp(x,z){
 const len=R(9,21),w=R(.5,.9),ph=R(0,6.28),tw=R(2,4.5),y0=ground(x,z)-.2,segs=18;
 for(const off of [0,1.57]){
  const st=kp.length/3;
  for(let j=0;j<=segs;j++){
   const t=j/segs,y=y0+t*len;
   const wd=w*(.25+.9*Math.sin(Math.min(1,t*1.15)*Math.PI*.95)+.18*Math.sin(t*25+ph))*(off?.6:1);
   const a=ph+off+t*tw,dx=Math.cos(a)*wd*.5,dz=Math.sin(a)*wd*.5;
   kp.push(x-dx,y,z-dz,x+dx,y,z+dz);ku.push(-1,1);
   for(let q=0;q<2;q++){kb.push(x,y0,z);kh.push(t);kph.push(ph);kl.push(len);}
   if(j<segs){const a0=st+j*2;ki.push(a0,a0+1,a0+2,a0+1,a0+3,a0+2);}
  }
 }
}
function okKelp(x,z){return Math.hypot(x,z)<80&&!nearPathXZ(x,z,2.4)&&!inRock(x,z,.4)&&!inShip(x,z,0)&&Math.hypot(x,z-34)>3;}
const patches=[[-5,24],[16,6],[-24,-2],[-5,-15],[27,17],[-28,14],[6,-36],[32,-34],[-38,-30],[-2,48],[44,6],[-48,6],[20,42],[-18,40]];
for(const pc of patches){const n=Math.floor(R(14,28));for(let i=0;i<n;i++){const a=R(0,6.28),r=Math.sqrt(rnd())*7.5,x=pc[0]+Math.cos(a)*r,z=pc[1]+Math.sin(a)*r;if(okKelp(x,z))kelp(x,z);}}
for(let i=0;i<50;i++){const a=R(0,6.28),r=R(6,72),x=Math.cos(a)*r,z=Math.sin(a)*r;if(okKelp(x,z))kelp(x,z);}
{
 const g=new T.BufferGeometry();
 g.setAttribute('position',new T.Float32BufferAttribute(kp,3));
 g.setAttribute('aBase',new T.Float32BufferAttribute(kb,3));
 g.setAttribute('aH',new T.Float32BufferAttribute(kh,1));
 g.setAttribute('aPh',new T.Float32BufferAttribute(kph,1));
 g.setAttribute('aLen',new T.Float32BufferAttribute(kl,1));
 g.setAttribute('aU',new T.Float32BufferAttribute(ku,1));
 g.setIndex(ki);
 const u=T.UniformsUtils.merge([T.UniformsLib.fog,{}]);u.uTime=timeU;
 const m=new T.ShaderMaterial({uniforms:u,fog:true,side:T.DoubleSide,
  vertexShader:`
uniform float uTime;attribute vec3 aBase;attribute float aH;attribute float aPh;attribute float aLen;attribute float aU;
varying float vH;varying float vU;varying vec3 vW;
#include <fog_pars_vertex>
void main(){
 vec3 p=position;float h2=aH*aH;
 float s1=sin(uTime*0.6+aPh+aBase.x*0.07)+0.35*sin(uTime*1.25+aPh*2.0+aH*3.0);
 float s2=cos(uTime*0.5+aPh*1.7+aBase.z*0.07);
 p.x+=(s1*0.8+0.9)*h2*aLen*0.1;
 p.z+=s2*0.7*h2*aLen*0.09;
 p.y-=h2*aLen*0.04*(1.0+0.5*s1);
 vH=aH;vU=aU;vW=p;
 vec4 mvPosition=viewMatrix*vec4(p,1.0);
 gl_Position=projectionMatrix*mvPosition;
 #include <fog_vertex>
}`,
  fragmentShader:`
uniform float uTime;varying float vH;varying float vU;varying vec3 vW;
#include <fog_pars_fragment>
${CAUS}
void main(){
 vec3 col=mix(vec3(0.05,0.17,0.07),vec3(0.2,0.46,0.13),smoothstep(0.0,0.6,vH));
 col=mix(col,vec3(0.66,0.58,0.2),smoothstep(0.55,1.0,vH)*0.5);
 col*=0.8+0.35*(1.0-abs(vU));
 float c=caus(vW.xz*0.085+vec2(vW.y*0.03),uTime*0.45+23.0);
 col+=col*c*0.7;
 col*=0.55+0.6*vH;
 gl_FragColor=vec4(col,1.0);
 #include <fog_fragment>
}`});
 const km=new T.Mesh(g,m);km.frustumCulled=false;scene.add(km);
}

/* ---------- coral ---------- */
const corals=new Merger();
const vary=(c,v)=>{const k=1+R(-v,v);return [c[0]*k,c[1]*k,c[2]*k];};
function branchCoral(pos,col){
 const st=[[pos.clone(),UP.clone(),R(.6,1),.13,0]];
 while(st.length){
  const it=st.pop(),p=it[0],d=it[1],len=it[2],rad=it[3],dep=it[4];
  const q=new T.Quaternion().setFromUnitVectors(UP,d),c=p.clone().addScaledVector(d,len/2);
  const cc=dep>=2?vary(GOLD,.1):col;
  corals.add(new T.CylinderGeometry(rad*.7,rad,len,5,1,true),new T.Matrix4().compose(c,q,ONE),()=>cc);
  if(dep<3){const tip=p.clone().addScaledVector(d,len),nb=dep===0?3:2;
   for(let b=0;b<nb;b++)st.push([tip,d.clone().add(V(R(-.8,.8),R(.1,.6),R(-.8,.8))).normalize(),len*R(.6,.8),rad*.72,dep+1]);}
 }
}
function fan(pos,col){
 const g=new T.CircleGeometry(R(.8,1.5),16,0,Math.PI),P=g.attributes.position;
 for(let i=0;i<P.count;i++){const x=P.getX(i),y=P.getY(i);P.setZ(i,Math.sin(x*3)*.1+Math.sin(y*4)*.06);}
 g.computeVertexNormals();
 corals.add(g,new T.Matrix4().compose(pos,new T.Quaternion().setFromEuler(new T.Euler(R(-.2,.2),R(0,6.3),0)),ONE),()=>col);
}
function tubes(pos){
 const n=3+Math.floor(R(0,3));
 for(let i=0;i<n;i++){const r=R(.15,.28),h=R(.6,1.5),c=vary(rnd()<.6?TEAL:[.1,.36,.5],.12);
  corals.add(new T.CylinderGeometry(r,r*1.2,h,8,1,true),new T.Matrix4().compose(V(pos.x+R(-.4,.4),pos.y+h/2,pos.z+R(-.4,.4)),new T.Quaternion().setFromEuler(new T.Euler(R(-.2,.2),0,R(-.2,.2))),ONE),()=>c);}
}
function brain(pos,col){const r=R(.4,.85);corals.add(new T.SphereGeometry(r,10,7),new T.Matrix4().compose(pos,new T.Quaternion(),V(1,.62,1)),(x,y,z)=>{const s=.85+.15*Math.sin(x*14+Math.sin(z*11)*2);return [col[0]*s,col[1]*s,col[2]*s];});}
function soft(pos,col){
 for(let i=0;i<9;i++){const d=V(R(-.6,.6),1,R(-.6,.6)).normalize(),h=R(.4,.8);
  corals.add(new T.ConeGeometry(.07,h,5,1,true),new T.Matrix4().compose(pos.clone().addScaledVector(d,h/2),new T.Quaternion().setFromUnitVectors(UP,d),ONE),()=>col);}
}
for(let i=0;i<52;i++){
 let x,z;
 if(i<24&&boulders.length){const rc=boulders[i%boulders.length],a=R(0,6.28),rr=Math.max(rc.s.x,rc.s.z)*1.1+.5;x=rc.c.x+Math.cos(a)*rr;z=rc.c.z+Math.sin(a)*rr;}
 else{const a=R(0,6.28),r=R(5,70);x=Math.cos(a)*r;z=Math.sin(a)*r;}
 if(inShip(x,z,0))continue;
 const n=3+Math.floor(R(0,4));
 for(let k=0;k<n;k++){
  const px=x+R(-1.8,1.8),pz=z+R(-1.8,1.8),p=V(px,ground(px,pz)-.05,pz),t=rnd();
  if(t<.3)branchCoral(p,vary(rnd()<.6?ORANGE:GOLD,.1));
  else if(t<.5)fan(p,vary(rnd()<.5?ORANGE:GOLD,.12));
  else if(t<.68)tubes(p);
  else if(t<.84)brain(p,vary(rnd()<.5?GOLD:ORANGE,.1));
  else soft(p,vary(ORANGE,.12));
 }
}
scene.add(corals.mesh(rockMat));

/* ---------- sand ---------- */
{
 const g=new T.PlaneGeometry(420,420,210,210);g.rotateX(-Math.PI/2);
 const P=g.attributes.position,cols=new Float32Array(P.count*3);
 for(let i=0;i<P.count;i++){
  const x=P.getX(i),z=P.getZ(i);P.setY(i,ground(x,z));
  const n1=fbm(x*.05,0,z*.05),n2=vn(x*.4,1,z*.4),k=.85+.25*n2;
  let r=(.56+.14*n1)*k,gg=(.46+.11*n1)*k,b=(.28+.06*n1)*k;
  const al=clamp((fbm(x*.03+9,2,z*.03)-.62)*4,0,1);
  r+=(.16-r)*al*.7;gg+=(.36-gg)*al*.7;b+=(.2-b)*al*.7;
  cols[i*3]=r;cols[i*3+1]=gg;cols[i*3+2]=b;
 }
 g.setAttribute('color',new T.BufferAttribute(cols,3));g.computeVertexNormals();
 scene.add(new T.Mesh(g,litMat({sand:true})));
}

/* ---------- rippling surface ---------- */
const surfU=T.UniformsUtils.merge([T.UniformsLib.fog,{uSun:{value:SUN.clone()}}]);surfU.uTime=timeU;
const surf=new T.Mesh((function(){const g=new T.PlaneGeometry(700,700,70,70);g.rotateX(Math.PI/2);return g;})(),new T.ShaderMaterial({uniforms:surfU,fog:true,side:T.DoubleSide,
 vertexShader:`
uniform float uTime;varying vec3 vW;
#include <fog_pars_vertex>
void main(){
 vec4 w=modelMatrix*vec4(position,1.0);
 w.y+=sin(w.x*0.12+uTime*0.8)*0.35+cos(w.z*0.1+uTime*0.6)*0.35;
 vW=w.xyz;
 vec4 mvPosition=viewMatrix*w;
 gl_Position=projectionMatrix*mvPosition;
 #include <fog_vertex>
}`,
 fragmentShader:`
uniform float uTime;uniform vec3 uSun;varying vec3 vW;
#include <fog_pars_fragment>
${CAUS}
void main(){
 vec3 v=normalize(vW-cameraPosition);
 float win=smoothstep(0.58,0.78,v.y);
 float c=caus(vW.xz*0.03,uTime*0.5+11.0);
 float w=0.5+0.5*sin(vW.x*0.21+uTime*0.9+sin(vW.z*0.13+uTime*0.6)*2.0);
 vec3 deep=vec3(0.06,0.28,0.40)+vec3(0.04,0.10,0.08)*w;
 vec3 bright=mix(vec3(0.28,0.70,0.68),vec3(0.95,0.84,0.52),0.3*w+0.6*c);
 vec3 col=mix(deep,bright,win);
 col+=vec3(1.0,0.82,0.45)*pow(max(dot(v,uSun),0.0),40.0)*1.6;
 gl_FragColor=vec4(col,1.0);
 #include <fog_fragment>
}`}));
surf.position.y=28;surf.frustumCulled=false;scene.add(surf);

/* ---------- sunbeams ---------- */
const BEAM_VS=`varying vec2 vUv;varying vec3 vN;varying vec3 vW;
void main(){vUv=uv;vN=normalize(mat3(modelMatrix)*normal);vec4 w=modelMatrix*vec4(position,1.0);vW=w.xyz;gl_Position=projectionMatrix*viewMatrix*w;}`;
const BEAM_FS=`uniform float uTime;uniform float uPh;uniform float uStr;varying vec2 vUv;varying vec3 vN;varying vec3 vW;
void main(){
 vec3 Vd=normalize(cameraPosition-vW);
 float e=pow(abs(dot(normalize(vN),Vd)),1.5);
 float f=smoothstep(0.3,1.0,vUv.y);
 float fl=0.55+0.45*sin(uTime*0.6+uPh+vW.y*0.12)*sin(uTime*0.37+uPh*1.7);
 float d=length(cameraPosition-vW);
 float a=e*f*fl*uStr*exp(-d*0.016);
 gl_FragColor=vec4(vec3(1.0,0.83,0.5)*a,1.0);
}`;
const beams=[];
for(let i=0;i<18;i++){
 const a=R(0,6.28),r=i<5?R(4,18):Math.sqrt(rnd())*58,x=Math.cos(a)*r,z=(i<5?14:0)+Math.sin(a)*r;
 const rt=R(1,2.6),rb=rt*R(1.8,2.6);
 const m=new T.ShaderMaterial({uniforms:{uTime:timeU,uPh:{value:R(0,6.28)},uStr:{value:R(.08,.16)}},vertexShader:BEAM_VS,fragmentShader:BEAM_FS,transparent:true,depthWrite:false,blending:T.AdditiveBlending,side:T.DoubleSide});
 const b=new T.Mesh(new T.CylinderGeometry(rt,rb,46,18,1,true),m);
 b.quaternion.setFromUnitVectors(UP,SUN);
 b.position.set(x,28,z).addScaledVector(SUN,-23);
 b.userData={bx:b.position.x,ph:R(0,6.28)};b.renderOrder=2;
 scene.add(b);beams.push(b);
}

/* ---------- marine snow ---------- */
{
 const N=1400,p=new Float32Array(N*3),s=new Float32Array(N);
 for(let i=0;i<N;i++){p[i*3]=R(-30,30);p[i*3+1]=R(-30,30);p[i*3+2]=R(-30,30);s[i]=R(.03,.09);}
 const g=new T.BufferGeometry();g.setAttribute('position',new T.BufferAttribute(p,3));g.setAttribute('aS',new T.BufferAttribute(s,1));
 const pts=new T.Points(g,new T.ShaderMaterial({uniforms:{uTime:timeU,uScale:scaleU},transparent:true,depthWrite:false,blending:T.AdditiveBlending,
  vertexShader:`uniform float uTime;uniform float uScale;attribute float aS;varying float vA;
void main(){
 vec3 p=position+vec3(sin(uTime*0.2+position.y)*0.6,-uTime*0.12,cos(uTime*0.15+position.x)*0.6);
 p=mod(p-cameraPosition+30.0,60.0)-30.0+cameraPosition;
 vec4 mv=viewMatrix*vec4(p,1.0);gl_Position=projectionMatrix*mv;
 float d=max(-mv.z,0.1);gl_PointSize=clamp(aS*uScale/d,1.0,6.0);vA=clamp(1.0-d/30.0,0.0,1.0)*0.5;
}`,
  fragmentShader:`varying float vA;void main(){float a=smoothstep(0.5,0.1,length(gl_PointCoord-0.5))*vA;gl_FragColor=vec4(0.75,0.86,0.62,a);}`}));
 pts.frustumCulled=false;scene.add(pts);
}

/* ---------- bubbles ---------- */
const vents=[];
for(let i=0;i<Math.min(7,boulders.length);i++){const rc=boulders[i],a=R(0,6.28),rr=Math.max(rc.s.x,rc.s.z)*1.15+.4,x=rc.c.x+Math.cos(a)*rr,z=rc.c.z+Math.sin(a)*rr;vents.push(V(x,ground(x,z)+.1,z));}
vents.push(V(3,ground(3,21)+.1,21),V(-9,ground(-9,-6)+.1,-6));
vents.push(ship.localToWorld(V(-7,deckY(-7)+2.5,0)),ship.localToWorld(V(3,deckY(3)+.1,.8)));
const VB=280,PB=40,BN=VB+PB;
const bp=new Float32Array(BN*3),bsz=new Float32Array(BN),bspd=new Float32Array(BN),bph=new Float32Array(BN);
function spawnV(i,init){const v=vents[i%vents.length],k=i*3;bp[k]=v.x+R(-.3,.3);bp[k+1]=init?v.y+R(0,27-v.y):v.y;bp[k+2]=v.z+R(-.3,.3);bspd[i]=R(1,2);}
for(let i=0;i<BN;i++){bph[i]=R(0,6.28);if(i<VB){bsz[i]=R(.08,.3);spawnV(i,true);}else{bsz[i]=R(.05,.13);bp[i*3+1]=-999;}}
const bgeo=new T.BufferGeometry();bgeo.setAttribute('position',new T.BufferAttribute(bp,3));bgeo.setAttribute('aS',new T.BufferAttribute(bsz,1));
{
 const pts=new T.Points(bgeo,new T.ShaderMaterial({uniforms:{uScale:scaleU},transparent:true,depthWrite:false,blending:T.AdditiveBlending,
  vertexShader:`uniform float uScale;attribute float aS;varying float vA;
void main(){vec4 mv=modelViewMatrix*vec4(position,1.0);gl_Position=projectionMatrix*mv;float d=max(-mv.z,0.1);gl_PointSize=clamp(aS*uScale/d,0.0,90.0);vA=exp(-d*0.03);}`,
  fragmentShader:`varying float vA;
void main(){vec2 c=gl_PointCoord-0.5;float d=length(c);if(d>0.5)discard;
 float rim=smoothstep(0.30,0.46,d)*(1.0-smoothstep(0.46,0.5,d));
 float hl=smoothstep(0.16,0.0,length(c-vec2(-0.16,-0.16)));
 float a=(rim*0.75+hl*0.9+0.06)*vA;
 gl_FragColor=vec4(0.72,0.95,0.9,a);}`}));
 pts.frustumCulled=false;pts.renderOrder=3;scene.add(pts);
}
let emitT=1.5,pbi=0;
function updBubbles(dt,t){
 for(let i=0;i<BN;i++){const k=i*3;if(bp[k+1]<-500)continue;
  bp[k+1]+=bspd[i]*dt;bp[k]+=Math.sin(t*2.2+bph[i])*.35*dt;bp[k+2]+=Math.cos(t*1.8+bph[i])*.35*dt;
  if(bp[k+1]>27.4){if(i<VB)spawnV(i,false);else bp[k+1]=-999;}}
 emitT-=dt;
 if(emitT<=0){emitT=R(2.4,4);const n=4+Math.floor(R(0,4));
  for(let j=0;j<n;j++){const i=VB+(pbi++%PB);_e.set(R(-.4,.4),-.6+R(-.15,.15),-1.3+R(-.2,.2)).applyQuaternion(camera.quaternion).add(camera.position);
   bp[i*3]=_e.x;bp[i*3+1]=_e.y-j*.12;bp[i*3+2]=_e.z;bspd[i]=R(1.2,1.9);}}
 bgeo.attributes.position.needsUpdate=true;
}

/* ---------- fish schools ---------- */
function fishGeo(){
 const v=[],N=[0,0,.5],J=[0,0,-.35],Tp=[0,.15,.05],B=[0,-.13,.05],Lf=[-.08,0,.05],Rt=[.08,0,.05];
 const tri=(a,b,c)=>v.push(a[0],a[1],a[2],b[0],b[1],b[2],c[0],c[1],c[2]);
 tri(N,Tp,Rt);tri(N,Rt,B);tri(N,B,Lf);tri(N,Lf,Tp);tri(J,Rt,Tp);tri(J,B,Rt);tri(J,Lf,B);tri(J,Tp,Lf);
 tri([0,0,-.3],[0,.18,-.62],[0,-.18,-.62]);tri([0,.13,.08],[0,.25,-.1],[0,.1,-.2]);
 const g=new T.BufferGeometry();g.setAttribute('position',new T.Float32BufferAttribute(v,3));g.computeVertexNormals();return g;
}
const SCH=[
 {c:[4,6,14],a:[10,2,9],n:40,s:.45,col:GOLD},
 {c:[-20,8,8],a:[9,2.5,12],n:32,s:.6,col:ORANGE},
 {c:[-4,9,-18],a:[8,2,7],n:36,s:.5,col:TEAL},
 {c:[25,9,10],a:[9,2,10],n:30,s:.55,col:[.95,.62,.25]},
 {c:[-30,6,-25],a:[10,2,8],n:28,s:.7,col:ORANGE},
 {c:[8,12,32],a:[12,2,7],n:36,s:.45,col:[.3,.75,.65]}
];
for(const S of SCH){S.w=R(.1,.15);S.k=R(1.3,1.75);S.p=[R(0,6.28),R(0,6.28),R(0,6.28),R(0,6.28)];}
function sPos(S,t,o){const w=S.w;return o.set(S.c[0]+S.a[0]*Math.sin(w*t+S.p[0])+.35*S.a[0]*Math.sin(2.1*w*t+S.p[3]),S.c[1]+S.a[1]*Math.sin(.6*w*t+S.p[1]),S.c[2]+S.a[2]*Math.sin(S.k*w*t+S.p[2]));}
const FISH=[];
for(const S of SCH){const sp=1+S.n/45;for(let i=0;i<S.n;i++){let o;do{o=V(R(-1,1),R(-1,1),R(-1,1));}while(o.lengthSq()>1);o.multiply(V(2.2*sp,sp,3*sp));FISH.push({s:S,o:o,lag:.5-o.z*.2+R(0,.2),ph:R(0,6.28),sc:S.s*R(.85,1.15)});}}
const fishMesh=new T.InstancedMesh(fishGeo(),new T.MeshLambertMaterial({side:T.DoubleSide,emissive:0x0a1c26}),FISH.length);
FISH.forEach((f,i)=>{const c=f.s.col,k=R(.85,1.15);fishMesh.setColorAt(i,new T.Color(c[0]*k,c[1]*k,c[2]*k));});
if(fishMesh.instanceColor)fishMesh.instanceColor.needsUpdate=true;
fishMesh.frustumCulled=false;scene.add(fishMesh);
const dummy=new T.Object3D();
function updFish(t){
 const C=camera.position;
 for(let i=0;i<FISH.length;i++){
  const f=FISH[i],tt=t-f.lag;
  sPos(f.s,tt,_f1);sPos(f.s,tt+.15,_f2);_fw.subVectors(_f2,_f1).normalize();
  _rt.crossVectors(_fw,UP).normalize();_up.crossVectors(_rt,_fw);
  _p.copy(_f1).addScaledVector(_rt,f.o.x).addScaledVector(_up,f.o.y).addScaledVector(_fw,f.o.z);
  _e.subVectors(_p,C);const d=_e.length();if(d<3.2&&d>1e-3)_p.addScaledVector(_e,(3.2-d)/d);
  resolve(_p,.35*f.sc/.5,.6);
  dummy.position.copy(_p);_f2.copy(_p).add(_fw);dummy.lookAt(_f2);
  dummy.rotateY(Math.sin(t*9+f.ph)*.22);dummy.scale.setScalar(f.sc);dummy.updateMatrix();
  fishMesh.setMatrixAt(i,dummy.matrix);
 }
 fishMesh.instanceMatrix.needsUpdate=true;
}

/* ---------- manta rays ---------- */
const NX=13,NZ=5,NM=NX*NZ;
const mantaMat=new T.MeshLambertMaterial({vertexColors:true,side:T.DoubleSide});
const mantas=[];
function makeManta(cx,cz,rad,y0,dir,sc){
 const g=new T.BufferGeometry(),pos=new Float32Array((NM+3)*3),col=new Float32Array((NM+3)*3),idx=[];
 for(let i=0;i<NX;i++)for(let j=0;j<NZ;j++){const au=Math.abs(-1+2*i/(NX-1)),v=j/(NZ-1),k=(i*NZ+j)*3,t=au*.85,e=v>.8?.04:0;
  col[k]=DEEP[0]+(TEAL[0]-DEEP[0])*t+e;col[k+1]=DEEP[1]+(TEAL[1]-DEEP[1])*t+e;col[k+2]=DEEP[2]+(TEAL[2]-DEEP[2])*t+e;}
 for(let k=NM*3;k<(NM+3)*3;k+=3){col[k]=DEEP[0];col[k+1]=DEEP[1];col[k+2]=DEEP[2];}
 for(let i=0;i<NX-1;i++)for(let j=0;j<NZ-1;j++){const a=i*NZ+j,b=(i+1)*NZ+j;idx.push(a,b,a+1,b,b+1,a+1);}
 idx.push(NM,NM+1,NM+2);
 g.setAttribute('position',new T.BufferAttribute(pos,3));g.setAttribute('color',new T.BufferAttribute(col,3));g.setIndex(idx);
 const m=new T.Mesh(g,mantaMat);m.scale.setScalar(sc);m.frustumCulled=false;scene.add(m);
 mantas.push({m:m,g:g,cx:cx,cz:cz,rad:rad,y0:y0,w:dir*2.4/rad,ph:R(0,6.28)});
}
makeManta(0,0,30,16,1,2.8);makeManta(10,-10,24,18.5,-1,3.2);makeManta(-20,16,20,14.5,1,2.4);
function mPos(M,t,o){const a=M.w*t+M.ph;return o.set(M.cx+M.rad*Math.cos(a),M.y0+1.5*Math.sin(.25*t+M.ph),M.cz+M.rad*Math.sin(a));}
function updMantas(t){
 for(const M of mantas){
  const P=M.g.attributes.position.array,fl=t*1.5+M.ph;
  for(let i=0;i<NX;i++){const u=-1+2*i/(NX-1),au=Math.abs(u),lift=Math.sin(fl-au*1.3)*.32*Math.pow(au,1.5),fr=.55-.74*au,bk=-.42+.22*au;
   for(let j=0;j<NZ;j++){const v=j/(NZ-1),k=(i*NZ+j)*3;P[k]=u;P[k+2]=bk+(fr-bk)*v;P[k+1]=.1*(1-au)*(1-au)*Math.sin(Math.PI*v)+lift+.05*Math.sin(fl-au*1.3-v*2)*au;}}
  const k=NM*3;P[k]=-.025;P[k+1]=.02;P[k+2]=-.4;P[k+3]=.025;P[k+4]=.02;P[k+5]=-.4;P[k+6]=0;P[k+7]=Math.sin(fl-1.5)*.12;P[k+8]=-1.6;
  M.g.attributes.position.needsUpdate=true;M.g.computeVertexNormals();
  mPos(M,t,_a);mPos(M,t+.2,_b);M.m.position.copy(_a);M.m.lookAt(_b);M.m.rotateZ(Math.sign(M.w)*.25);
 }
}

/* ---------- player & input ---------- */
const player={p:V(0,6,34),v:V(0,0,0),yaw:0,pitch:-.05,ty:0,tp:-.05};
let hold=false,pid=null,lx=0,ly=0,thrust=0,hintTimer=null;
const cv=renderer.domElement,hint=document.getElementById('hint'),tag=document.getElementById('tag'),tourBtn=document.getElementById('tour');
function hideHint(){if(hintTimer)return;hintTimer=setTimeout(()=>{hint.style.opacity=0;},2500);}
cv.addEventListener('pointerdown',e=>{
 if(pid!==null)return;pid=e.pointerId;hold=true;lx=e.clientX;ly=e.clientY;
 try{cv.setPointerCapture(pid);}catch(_){}
 hideHint();e.preventDefault();
});
cv.addEventListener('pointermove',e=>{
 if(e.pointerId!==pid)return;
 const k=2.6/Math.min(innerWidth,innerHeight);
 player.ty-=(e.clientX-lx)*k;player.tp=clamp(player.tp-(e.clientY-ly)*k*.8,-1.2,1.2);
 lx=e.clientX;ly=e.clientY;
});
const release=e=>{if(e.pointerId!==pid)return;pid=null;hold=false;};
cv.addEventListener('pointerup',release);cv.addEventListener('pointercancel',release);cv.addEventListener('lostpointercapture',release);
cv.addEventListener('contextmenu',e=>e.preventDefault());

/* ---------- hands-free tour ---------- */
let demo=false,demoT=0,demoSnap=false;
let uShip=0,uUp=0,best=1e9,best2=1e9;
const upPt=V(-12,5,8);
pathPts.forEach((q,i)=>{const d=q.distanceTo(SHIPC);if(d<best){best=d;uShip=i/300;}const d2=q.distanceTo(upPt);if(d2<best2){best2=d2;uUp=i/300;}});
const cyc=x=>{x=Math.abs(x)%1;return Math.min(x,1-x);};
function startDemo(){demo=true;demoT=0;demoSnap=true;tag.style.opacity=1;hint.style.opacity=0;tourBtn.innerHTML='&#9632; Stop';}
function stopDemo(){
 if(!demo)return;demo=false;tag.style.opacity=0;tourBtn.innerHTML='&#9654; Tour';
 player.p.copy(camera.position);player.v.set(0,0,0);thrust=0;
 _d.set(0,0,-1).applyQuaternion(camera.quaternion);
 player.yaw=player.ty=Math.atan2(-_d.x,-_d.z);player.pitch=player.tp=Math.asin(clamp(_d.y,-1,1));
 resolve(player.p,.9,1);
}
window.addEventListener('pointerdown',e=>{if(demo&&e.isTrusted&&!(e.target&&e.target.closest&&e.target.closest('#tour')))stopDemo();},true);
window.addEventListener('touchstart',e=>{if(demo&&e.isTrusted&&!(e.target&&e.target.closest&&e.target.closest('#tour')))stopDemo();},{capture:true,passive:true});
tourBtn.addEventListener('click',()=>{if(demo)stopDemo();else startDemo();});
if(location.hash==='#demo')startDemo();
window.addEventListener('hashchange',()=>{if(location.hash==='#demo')startDemo();});

function demoCam(dt){
 demoT=(demoT+dt)%20;const u=demoT/20;
 PATH.getPointAt(u,_a);PATH.getPointAt((u+.02)%1,_b);
 _d.subVectors(_b,_a).normalize();
 const ws=Math.max(0,1-cyc(u-uShip)/.12);
 if(ws>0){_e.subVectors(SHIPC,_a).normalize();_d.lerp(_e,ws*.8).normalize();}
 const wu=Math.max(0,1-cyc(u-uUp)/.08);_d.y+=wu*.5;_d.normalize();
 _b.copy(_a).add(_d);
 _m.lookAt(_a,_b,UP);_q.setFromRotationMatrix(_m);
 if(demoSnap){camera.quaternion.copy(_q);demoSnap=false;}else camera.quaternion.slerp(_q,1-Math.exp(-dt*3));
 camera.position.copy(_a);
}
function swimCam(dt,t){
 const kk=1-Math.exp(-dt*7);
 player.yaw+=(player.ty-player.yaw)*kk;player.pitch+=(player.tp-player.pitch)*kk;
 thrust+=((hold?1:0)-thrust)*(1-Math.exp(-dt*(hold?2.2:1.2)));
 const cp=Math.cos(player.pitch);
 _d.set(-Math.sin(player.yaw)*cp,Math.sin(player.pitch),-Math.cos(player.yaw)*cp).multiplyScalar(5.5*thrust);
 player.v.lerp(_d,1-Math.exp(-dt*1.6));
 const p=player.p;p.addScaledVector(player.v,dt);
 const r=Math.hypot(p.x,p.z);if(r>86){p.x*=86/r;p.z*=86/r;}
 if(p.y>25.5)p.y=25.5;
 resolve(p,.9,1);resolve(p,.9,1);
 camera.position.copy(p);camera.position.y+=Math.sin(t*1.3)*.07;
 const roll=clamp(-(player.ty-player.yaw)*.6,-.25,.25)+Math.sin(t*.7)*.015;
 camera.rotation.set(player.pitch,player.yaw,roll,'YXZ');
}

/* ---------- loop ---------- */
addEventListener('resize',()=>{renderer.setSize(innerWidth,innerHeight);camera.aspect=innerWidth/innerHeight;camera.updateProjectionMatrix();scaleU.value=innerHeight*renderer.getPixelRatio()*.714;});
let last=performance.now(),time=0;
function frame(now){
 requestAnimationFrame(frame);
 const dt=Math.min(.05,Math.max(0,(now-last)/1000));last=now;time+=dt;timeU.value=time;
 if(demo)demoCam(dt);else swimCam(dt,time);
 updFish(time);updMantas(time);updBubbles(dt,time);
 for(const b of beams)b.position.x=b.userData.bx+Math.sin(time*.07+b.userData.ph)*1.5;
 surf.position.x=Math.round(camera.position.x/10)*10;surf.position.z=Math.round(camera.position.z/10)*10;
 renderer.render(scene,camera);
}
requestAnimationFrame(frame);
})();
</script>
</body>
</html>