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.)<!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/three@0.160.0/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>
