@3driseai/3drise-viewer 0.1.7 → 0.1.8

package/dist/shaders/glsl/noiseBake.glsl.js

@@ -0,0 +1,164 @@
+/**
+ * Bake-time noise. Runs once at startup, never per frame.
+ *
+ * Everything here is *tileable*: the hash wraps its lattice with mod(p, freq) so the
+ * volumes repeat seamlessly under RepeatWrapping. Non-tileable noise in a repeating
+ * 3D texture produces a visible grid of seams across the sky, which is the single most
+ * common giveaway in a volumetric cloud implementation.
+ */
+export const bakeCommon = /* glsl */ `
+#define PI 3.14159265359
+#define saturate(x) clamp(x, 0.0, 1.0)
+float remap(float v, float a, float b, float c, float d){
+  return c + (v - a) * (d - c) / max(b - a, 1e-6);
+}
+
+vec3 hash33t(vec3 p, float f){
+  p = mod(p, vec3(f));
+  p = fract(p * vec3(0.1031, 0.1030, 0.0973));
+  p += dot(p, p.yxz + 19.19);
+  return fract((p.xxy + p.yxx) * p.zyx);
+}
+vec2 hash22t(vec2 p, float f){
+  p = mod(p, vec2(f));
+  vec3 q = fract(vec3(p.xyx) * vec3(0.1031, 0.1030, 0.0973));
+  q += dot(q, q.yzx + 19.19);
+  return fract((q.xx + q.yz) * q.zy);
+}
+
+float perlin3(vec3 x, float f){
+  vec3 p = x * f;
+  vec3 i = floor(p); vec3 t = p - i;
+  vec3 u = t*t*t*(t*(t*6.0-15.0)+10.0);
+  float n000 = dot(hash33t(i+vec3(0,0,0),f)*2.0-1.0, t-vec3(0,0,0));
+  float n100 = dot(hash33t(i+vec3(1,0,0),f)*2.0-1.0, t-vec3(1,0,0));
+  float n010 = dot(hash33t(i+vec3(0,1,0),f)*2.0-1.0, t-vec3(0,1,0));
+  float n110 = dot(hash33t(i+vec3(1,1,0),f)*2.0-1.0, t-vec3(1,1,0));
+  float n001 = dot(hash33t(i+vec3(0,0,1),f)*2.0-1.0, t-vec3(0,0,1));
+  float n101 = dot(hash33t(i+vec3(1,0,1),f)*2.0-1.0, t-vec3(1,0,1));
+  float n011 = dot(hash33t(i+vec3(0,1,1),f)*2.0-1.0, t-vec3(0,1,1));
+  float n111 = dot(hash33t(i+vec3(1,1,1),f)*2.0-1.0, t-vec3(1,1,1));
+  float x00 = mix(n000,n100,u.x), x10 = mix(n010,n110,u.x);
+  float x01 = mix(n001,n101,u.x), x11 = mix(n011,n111,u.x);
+  return mix(mix(x00,x10,u.y), mix(x01,x11,u.y), u.z);
+}
+
+float perlin2(vec2 x, float f){
+  vec2 p = x * f;
+  vec2 i = floor(p); vec2 t = p - i;
+  vec2 u = t*t*t*(t*(t*6.0-15.0)+10.0);
+  float n00 = dot(hash22t(i+vec2(0,0),f)*2.0-1.0, t-vec2(0,0));
+  float n10 = dot(hash22t(i+vec2(1,0),f)*2.0-1.0, t-vec2(1,0));
+  float n01 = dot(hash22t(i+vec2(0,1),f)*2.0-1.0, t-vec2(0,1));
+  float n11 = dot(hash22t(i+vec2(1,1),f)*2.0-1.0, t-vec2(1,1));
+  return mix(mix(n00,n10,u.x), mix(n01,n11,u.x), u.y);
+}
+
+float worley3(vec3 x, float f){
+  vec3 p = x * f;
+  vec3 i = floor(p); vec3 t = p - i;
+  float md = 1e9;
+  for(int z=-1; z<=1; z++)
+  for(int y=-1; y<=1; y++)
+  for(int w=-1; w<=1; w++){
+    vec3 o = vec3(float(w), float(y), float(z));
+    vec3 h = hash33t(i + o, f);
+    vec3 d = o + h - t;
+    md = min(md, dot(d, d));
+  }
+  return saturate(sqrt(md));
+}
+`;
+export const bakeVertex = /* glsl */ `
+out vec2 vUv;
+void main(){ vUv = uv; gl_Position = vec4(position.xy, 0.0, 1.0); }
+`;
+/** Declarations every bake fragment shader shares. Must precede atlasUnpack, which reads vUv. */
+const bakeHeader = /* glsl */ `
+in vec2 vUv;
+out vec4 outColor;
+`;
+/** Slice atlas -> volume coordinate. Tiles run left-to-right, top-to-bottom. */
+const atlasUnpack = /* glsl */ `
+uniform vec2 u_atlas;
+uniform float u_tiles;
+uniform float u_res;
+vec3 volCoord(){
+  vec2 px   = floor(vUv * u_atlas);
+  vec2 tile = floor(px / u_res);
+  float z   = tile.y * u_tiles + tile.x;
+  vec2 xy   = px - tile * u_res;
+  return (vec3(xy, z) + 0.5) / u_res;
+}
+`;
+/**
+ * Base shape, 128³ RGBA.
+ *   R = Perlin-Worley (Schneider): perlin fbm remapped by an inverted-worley fbm, which
+ *       gives billowy tops without losing perlin's connectedness.
+ *   G/B/A = inverted worley at 4 / 8 / 16, recombined in the march as the low-frequency
+ *       fbm that erodes R.
+ */
+export const bakeBaseFrag = /* glsl */ `
+${bakeCommon}
+${bakeHeader}
+${atlasUnpack}
+void main(){
+  vec3 p = volCoord();
+  float pf = perlin3(p, 4.0) * 0.5 + perlin3(p, 8.0) * 0.25
+           + perlin3(p, 16.0) * 0.125 + perlin3(p, 32.0) * 0.0625;
+  pf = saturate(pf * 1.35 + 0.5);
+  float w4  = 1.0 - worley3(p,  4.0);
+  float w8  = 1.0 - worley3(p,  8.0);
+  float w16 = 1.0 - worley3(p, 16.0);
+  float wfbm = saturate(w4 * 0.625 + w8 * 0.25 + w16 * 0.125);
+  outColor = vec4(saturate(remap(pf, wfbm - 1.0, 1.0, 0.0, 1.0)), w4, w8, w16);
+}
+`;
+/** Detail erosion, 64³ RGB inverted worley at 4 / 8 / 16. */
+export const bakeDetailFrag = /* glsl */ `
+${bakeCommon}
+${bakeHeader}
+${atlasUnpack}
+void main(){
+  vec3 p = volCoord();
+  outColor = vec4(1.0 - worley3(p, 4.0), 1.0 - worley3(p, 8.0), 1.0 - worley3(p, 16.0), 1.0);
+}
+`;
+/**
+ * Weather map, 512² RGBA. Domain-warped so cell edges are not perlin-round.
+ * The warp offsets are themselves tileable, so the map still wraps exactly.
+ *   R = coverage, low frequency        B = cloud type bias
+ *   G = coverage, high frequency       A = precipitation
+ */
+export const bakeWeatherFrag = /* glsl */ `
+${bakeCommon}
+${bakeHeader}
+void main(){
+  vec2 q = vUv;
+  vec2 w = vec2(perlin2(q, 3.0), perlin2(q + vec2(0.37, 0.11), 3.0));
+  vec2 qw = q + w * 0.11;
+  float c1 = perlin2(qw, 3.0) * 0.60 + perlin2(qw, 6.0)  * 0.28 + perlin2(qw, 12.0) * 0.12;
+  float c2 = perlin2(qw, 7.0) * 0.52 + perlin2(qw, 14.0) * 0.30 + perlin2(qw, 28.0) * 0.18;
+  float ty = perlin2(q + vec2(5.1, 2.3), 2.0);
+  float pr = perlin2(q + vec2(1.7, 8.2), 5.0) * 0.7 + perlin2(q + vec2(1.7, 8.2), 10.0) * 0.3;
+  outColor = vec4(
+    saturate(c1 * 1.55 + 0.5),
+    saturate(c2 * 1.60 + 0.5),
+    saturate(ty * 1.60 + 0.5),
+    saturate(pr * 1.60 + 0.5)
+  );
+}
+`;
+/** Curl field, 128² RG. Curl of a scalar fbm — divergence free, so it swirls rather than pushes. */
+export const bakeCurlFrag = /* glsl */ `
+${bakeCommon}
+${bakeHeader}
+float fld(vec2 q){ return perlin2(q, 6.0) * 0.6 + perlin2(q, 12.0) * 0.3 + perlin2(q, 24.0) * 0.15; }
+void main(){
+  float e = 1.0 / 128.0;
+  float dx = fld(vUv + vec2(e, 0.0)) - fld(vUv - vec2(e, 0.0));
+  float dy = fld(vUv + vec2(0.0, e)) - fld(vUv - vec2(0.0, e));
+  vec2 c = clamp(vec2(dy, -dx) / (2.0 * e) / 26.0, -1.0, 1.0);
+  outColor = vec4(c * 0.5 + 0.5, 0.0, 1.0);
+}
+`;

package/dist/shaders/glsl/oceanCore.glsl.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The ocean surface model, in GLSL.
+ *
+ * Split into chunks the way `cloudCore` and `terrainCore` are, so the vertex and
+ * fragment stages take only what they use and the FFT phase can replace exactly
+ * one of them.
+ *
+ *   oceanUniforms   the wave table and every config value
+ *   oceanWaves      the height field: displacement, analytic frame, Jacobian
+ *   oceanShade      foam, detail normal, lighting, aerial perspective
+ *   oceanFull       all three
+ *
+ * ## Why the wave table is a uniform array and not computed here
+ *
+ * The obvious shape is to derive each component's wavelength and amplitude from
+ * the Pierson-Moskowitz spectrum inside the loop. That is an `exp` and two `pow`
+ * per component per vertex, and the spectrum does not change between vertices —
+ * it changes when somebody moves the wind slider. So the fit runs once on the
+ * CPU in `oceanUniforms.ts` and uploads a table; the shader does nothing but sum
+ * sines. It is also the shape the FFT phase wants: a spectrum baked once,
+ * evaluated per vertex.
+ *
+ * ## Why the normal comes from the vertex stage
+ *
+ * Terrain re-evaluates its height field per fragment, because a clipmap triangle
+ * is a poor approximation of a mountain and shading off the mesh normal draws
+ * every splat threshold along a triangle edge. Water is the opposite case: every
+ * component shorter than the cell has already been faded out by the LOD rule
+ * below, so the mesh IS the wave field to within a cell, and an interpolated
+ * normal is the right answer. Twenty sines per pixel would buy nothing. What the
+ * fragment stage adds is detail *below* the mesh — which is exactly the energy
+ * the LOD fade removed.
+ *
+ * ## The uniform-name trap
+ *
+ * When terrain interaction is on, `terrainField` is included beside this, and it
+ * brings `u_seaLevel` and `u_elevation` with it. Those are TERRAIN'S. The water's
+ * own level is `u_waterLevel`. Read `u_seaLevel` in this file and you will get
+ * the height the ground was built around, which is usually 0 and therefore looks
+ * correct until somebody moves it.
+ */
+/** Hard cap on the wave table. The loop is bounded by it because GLSL ES 1.00
+ *  requires a constant bound; `u_waveCount` breaks out early. */
+export declare const MAX_WAVES = 32;
+export declare const oceanUniforms = "\n#define MAX_WAVES 32\n\n// Per component: (dirX, dirZ, amplitude, wavenumber k).\nuniform vec4  u_waveA[MAX_WAVES];\n// Per component: (angular frequency w, phase, steepness Q, wavelength).\nuniform vec4  u_waveB[MAX_WAVES];\nuniform float u_waveCount;\n\nuniform float u_time;\nuniform float u_waterLevel;\nuniform float u_choppiness;\nuniform float u_amplitudeScale;\n\n// Half-extent of a placed body, and the width of its rim taper. Both zero on the\n// world host, which is what switches the taper off - a sea has no rim.\nuniform vec2  u_bodyHalf;\nuniform float u_edgeFade;\n\nuniform vec3  u_deepColor;\nuniform vec3  u_shallowColor;\nuniform vec3  u_foamColor;\nuniform vec3  u_sssColor;\nuniform float u_absorption;\nuniform float u_clarity;\nuniform float u_roughness;\nuniform float u_specular;\nuniform float u_sssStrength;\nuniform float u_detailStrength;\nuniform float u_detailScale;      // 1 / detailSize\nuniform float u_detailFade;       // 1 / detailFadeDistance\n// World size of one pixel at one unit of distance: 2*tan(fov/2) / viewportHeight.\n// What turns a distance into a screen-space footprint, which is the only thing\n// that decides whether a ripple is a shape or a shimmer.\nuniform float u_pixelScale;\nuniform float u_foamAmount;\nuniform float u_foamDecay;\nuniform float u_foamScale;        // 1 / foamSize\nuniform float u_ambientScale;\nuniform float u_fogDensity;\nuniform float u_exposure;\nuniform float u_curvature;\nuniform float u_receiveShadows;\n\n// Filled by applySunUniforms and applyTerrainAmbient, exactly as on the terrain\n// material - one atmosphere for the sky, the clouds, the ground and the water.\nuniform vec3  u_skyAmbient;\nuniform vec3  u_groundAmbient;\n";
+export declare const oceanWaves = "\n/**\n * One trochoidal component, accumulated.\n *\n * Gerstner displaces along the direction of travel as well as vertically:\n *\n *   x' = x + d * Q * A * sin(theta)\n *   y  =     A * cos(theta)\n *   theta = k * dot(d, x) + w * t + phase\n *\n * Q is what peaks the crests and flattens the troughs. It also compresses the\n * horizontal map near a crest, and where that compression turns the map\n * degenerate the wave is breaking - which is where the foam is. That falls out\n * of the same derivatives, for free, so foam here is measured rather than faked.\n *\n * Everything is differentiated in closed form. A central difference would need\n * four more evaluations of the whole sum for the normal alone; this is the same\n * decision, and the same 13x, that the terrain height field made.\n */\nvoid oceanWaveSum(\n  vec2 p, float cellLod, float amp,\n  out vec3 disp,        // displacement from the flat plane, world units\n  out vec3 nrm,         // analytic surface normal\n  out float jacobian,   // det of the horizontal map. < 1 compresses, < 0 folds\n  out float relHeight   // vertical displacement in standard deviations of the surface\n){\n  disp = vec3(0.0);\n  jacobian = 0.0;\n  relHeight = 0.0;\n\n  // Horizontal derivatives of the horizontal displacement, and of the height.\n  float dXdx = 0.0, dXdz = 0.0, dZdx = 0.0, dZdz = 0.0;\n  float dYdx = 0.0, dYdz = 0.0;\n  float totalSq = 0.0;\n\n  for (int i = 0; i < MAX_WAVES; i++) {\n    if (float(i) >= u_waveCount) break;\n\n    vec4 a = u_waveA[i];\n    vec4 b = u_waveB[i];\n    vec2 d = a.xy;\n    float A = a.z * amp;\n    float k = a.w;\n    float w = b.x;\n    float phase = b.y;\n    float Q = b.z;\n    float wl = b.w;\n\n    // Per-ring wave LOD. A component of wavelength L cannot be represented on a\n    // cell coarser than about L/4 - sampled there it aliases into crawling\n    // noise, which is what a naive clipmap ocean looks like at the horizon. So\n    // it fades out as the cell approaches its wavelength.\n    //\n    // cellLod is aCell * (1 + aMorph), the same morphing LOD the terrain uses,\n    // which is what makes the two sides of a ring seam agree: the outer edge of\n    // ring l evaluates at exactly ring l+1's cell size, so both sides fade the\n    // same components by the same amount and the surface is continuous across\n    // the boundary.\n    float lod = 1.0 - smoothstep(wl * 0.25, wl * 0.75, cellLod);\n    A *= lod;\n\n    float theta = k * dot(d, p) + w * u_time + phase;\n    float S = sin(theta);\n    float C = cos(theta);\n\n    float QA = Q * A;\n\n    disp.x += d.x * QA * S;\n    disp.z += d.y * QA * S;\n    disp.y += A * C;\n    totalSq += A * A;\n\n    float kQA = k * QA;\n    dXdx += d.x * d.x * kQA * C;\n    dXdz += d.x * d.y * kQA * C;\n    dZdx += d.y * d.x * kQA * C;\n    dZdz += d.y * d.y * kQA * C;\n\n    float kA = k * A;\n    dYdx -= d.x * kA * S;\n    dYdz -= d.y * kA * S;\n  }\n\n  // Tangent frame of the displaced surface. Taking the cross product rather than\n  // the usual closed-form shortcut costs three multiplies and stays correct when\n  // choppiness is high, where the shortcut - which assumes the horizontal map is\n  // near-identity - visibly tilts the crests the wrong way.\n  vec3 tx = vec3(1.0 + dXdx, dYdx, dZdx);\n  vec3 tz = vec3(dXdz, dYdz, 1.0 + dZdz);\n  nrm = normalize(cross(tz, tx));\n\n  jacobian = (1.0 + dXdx) * (1.0 + dZdz) - dXdz * dZdx;\n\n  // Height in standard deviations of the surface, NOT as a fraction of the\n  // summed amplitudes. Dividing by the sum is the obvious thing and it is wrong\n  // by a factor of sqrt(2N): random-phase components almost never align, so the\n  // surface only ever reaches a fraction of that sum, and everything keyed on\n  // relative height - the foam's crest gate, the subsurface term - was being\n  // multiplied by ~0.15 and silently doing nothing. A storm with whitecaps\n  // turned up had no foam at all, which is how this was found.\n  //\n  // sigma is the RMS surface elevation, so this is roughly -3..3 with the usual\n  // excursion at +-1, and a threshold expressed in it means what it looks like.\n  relHeight = disp.y / max(sqrt(totalSq * 0.5), 1e-4);\n}\n\n/** Rim taper for a placed body: displacement to zero at the edge, so the\n *  boundary is still water rather than a sawn-off cliff of it. Returns 1 on the\n *  world host, where u_bodyHalf is zero. */\nfloat oceanEdgeMask(vec2 local){\n  if (u_bodyHalf.x <= 0.0) return 1.0;\n  vec2 t = abs(local) / max(u_bodyHalf, vec2(1e-3));\n  float e = max(t.x, t.y);\n  float band = max(u_edgeFade, 1e-3);\n  return 1.0 - smoothstep(1.0 - band, 1.0, e);\n}\n";
+export declare const oceanShade = "\n/** Arithmetic hash. Never the fract(sin(dot())) one: four hashes per octave of\n *  two sines each was most of the terrain frame budget before it was replaced,\n *  and every noise tutorial online still teaches the expensive version. */\nvec2 oHash(vec2 p){\n  vec3 p3 = fract(vec3(p.xyx) * vec3(0.1031, 0.1030, 0.0973));\n  p3 += dot(p3, p3.yzx + 33.33);\n  return fract((p3.xx + p3.yz) * p3.zy) * 2.0 - 1.0;\n}\n\n/** Gradient noise with its derivative, so a detail normal costs one evaluation\n *  instead of three. */\nvec3 oNoised(vec2 x){\n  vec2 i = floor(x);\n  vec2 f = fract(x);\n  vec2 u = f * f * (3.0 - 2.0 * f);\n  vec2 du = 6.0 * f * (1.0 - f);\n\n  vec2 ga = oHash(i + vec2(0.0, 0.0));\n  vec2 gb = oHash(i + vec2(1.0, 0.0));\n  vec2 gc = oHash(i + vec2(0.0, 1.0));\n  vec2 gd = oHash(i + vec2(1.0, 1.0));\n\n  float va = dot(ga, f - vec2(0.0, 0.0));\n  float vb = dot(gb, f - vec2(1.0, 0.0));\n  float vc = dot(gc, f - vec2(0.0, 1.0));\n  float vd = dot(gd, f - vec2(1.0, 1.0));\n\n  float v = va + u.x * (vb - va) + u.y * (vc - va) + u.x * u.y * (va - vb - vc + vd);\n  vec2 g = ga + u.x * (gb - ga) + u.y * (gc - ga) + u.x * u.y * (ga - gb - gc + gd)\n         + du * (u.yx * (va - vb - vc + vd) + vec2(vb, vc) - va);\n  return vec3(v, g);\n}\n\n/**\n * Ripple below the mesh.\n *\n * This is not decoration: the per-ring LOD in oceanWaveSum deletes every\n * component shorter than the cell, and near the camera that is most of the\n * high-frequency energy in the sea. Putting it back as a normal perturbation is\n * cheaper than carrying it in geometry and, past a few metres, indistinguishable\n * - a ripple two pixels across is a normal, not a shape.\n *\n * Two octaves drifting in opposite directions, because one drifting field reads\n * as a texture being dragged across the water.\n */\nfloat oceanDetailFade(float dist){\n  // Two fades, and the second is the one that matters. Distance alone is not\n  // what makes a ripple alias - a screen-space footprint is. A two-metre ripple\n  // is a shape at fifty metres and sub-pixel noise at two thousand, and which of\n  // those it is depends on the field of view and the resolution, not on the\n  // distance. Fading on the footprint means the same water looks right in a\n  // wide shot and a telephoto one.\n  float footprint = dist * u_pixelScale;\n  float size = 1.0 / max(u_detailScale, 1e-4);\n  float screen = 1.0 - smoothstep(size * 0.35, size * 1.4, footprint);\n  return exp(-dist * u_detailFade) * screen;\n}\n\nvec3 oceanDetailNormal(vec3 n, vec3 wp, float fade){\n  float amt = u_detailStrength * fade;\n  if (amt <= 0.001) return n;\n\n  vec2 p = wp.xz * u_detailScale;\n  vec2 drift = vec2(u_time * 0.06, u_time * 0.043);\n\n  vec3 a = oNoised(p + drift);\n  vec3 b = oNoised(p * 2.17 - drift * 1.6);\n  vec2 g = a.yz + b.yz * 0.5;\n\n  // Perturb in the surface plane, so a steep wave face keeps its own orientation\n  // and only gains texture.\n  vec3 t = normalize(cross(vec3(0.0, 1.0, 0.0), n) + vec3(1e-5, 0.0, 0.0));\n  vec3 bt = cross(n, t);\n  // 0.12, not 0.4. The gradient of the noise is order 1, so the constant IS the\n  // maximum slope the ripple adds: at 0.4 the default strength tilts the normal\n  // by twelve degrees, and at grazing angles - which is most of an ocean - a\n  // twelve degree tilt swings the Fresnel term between reflecting the sky and\n  // not. The whole surface then boils with white speckle, which is exactly what\n  // it did. Sub-metre ripple on open water is a few degrees of slope.\n  return normalize(n - (t * g.x + bt * g.y) * amt * 0.12);\n}\n\n/**\n * Whitecaps, from the Jacobian of the horizontal map.\n *\n * Where the determinant falls toward zero the surface is folding into itself,\n * which is physically what a breaking crest is. It is the same quantity an FFT\n * ocean reads off its displacement cascade, and a Gerstner sum hands it over for\n * nothing, so foam is measured here rather than paint over the crests.\n *\n * u_foamDecay is a stand-in for a real accumulation buffer: it widens the\n * threshold on the trailing side, so foam persists behind the crest instead of\n * flickering on and off with it. The honest version writes into a persistent\n * target and advects it - deferred with the FFT phase.\n */\nfloat oceanFoam(float jacobian, float relHeight, vec3 wp){\n  float compress = saturate(1.0 - jacobian);\n\n  // Thresholds are calibrated against the compression the wave table actually\n  // produces, which is a much narrower range than it looks: at the defaults the\n  // Jacobian sits just above zero at the sharpest crest and near 1 everywhere\n  // else. A threshold picked by eye either foams the whole sea or none of it.\n  float thr = mix(0.85, 0.15, saturate(u_foamAmount * 0.6));\n  float sharp = smoothstep(thr, thr + 0.15, compress);\n  float trail = smoothstep(thr * 0.55, thr + 0.4, compress);\n  float f = mix(sharp, max(sharp, trail), saturate(u_foamDecay));\n\n  // Foam belongs on and just behind the crest, never in the trough.\n  f *= smoothstep(-0.15, 0.45, relHeight);\n\n  // Break it up, or it reads as a decal following the wave.\n  vec2 q = wp.xz * u_foamScale;\n  float n = oNoised(q + vec2(u_time * 0.05, -u_time * 0.03)).x * 0.5 + 0.5;\n  n = mix(n, 1.0, 0.35);\n  return saturate(f * n * u_foamAmount);\n}\n\n/**\n * The water shading.\n *\n * Reflection is the whole story above a few degrees of grazing - most of what\n * you see looking at the sea is the sky - so the Fresnel split, the sky radiance\n * and the aerial perspective all have to come from the same atmosphere the sky\n * itself is drawn with, or the water is obviously pasted onto the scene. That is\n * skyRadiance from cloudCore, driven by applySunUniforms off the same\n * useCloudSun state as the clouds and the terrain.\n */\nvec3 oceanLight(\n  vec3 wp, vec3 n, vec3 viewDir,   // viewDir points FROM the camera TO the surface\n  float foam, float relHeight, float shadow, float depthFactor,\n  float roughnessBoost,            // specular antialiasing, see the caller\n  vec3 reflectionColor\n){\n  vec3 V = -viewDir;\n  vec3 L = normalize(u_sunDir);\n  float NdotL = max(dot(n, L), 0.0);\n  vec3 sun = u_sunColor * u_sunIntensity * shadow;\n\n  // Reflection. Bending the reflected ray back above the horizon is a cheat, and\n  // the alternative is worse: at grazing angles a wave face routinely reflects\n  // just below the horizon, and sampling the sky's ground term there puts a band\n  // of dirt across the brightest part of the water.\n  vec3 R = reflect(viewDir, n);\n  R.y = max(R.y, 0.015);\n  vec3 sky = length(reflectionColor) > 0.0 ? reflectionColor : skyRadiance(R);\n\n  // Prefilter the reflection by the same roughness the specular lobe uses.\n  // Without this the specular is filtered and the reflection is not, and on\n  // water that is the wrong half: reflection is most of what you see, and a\n  // mirror sampled through a noisy normal aliases exactly as hard as a highlight\n  // does. u_skyAmbient is already the hemispheric average of this sky, so it is\n  // the infinitely-rough end of the same lobe and costs nothing to mix toward.\n  float rough = clamp(u_roughness + roughnessBoost, 0.01, 1.0);\n  sky = mix(sky, u_skyAmbient * 0.6, saturate(rough * 2.2));\n\n  float fres = 0.02 + 0.98 * pow(1.0 - saturate(dot(V, n)), 5.0);\n\n  // Body colour. depthFactor is 1 in open water and ramps to 0 as the bottom\n  // comes up; until the refraction grab exists it is 1 everywhere.\n  vec3 body = mix(u_shallowColor, u_deepColor, saturate(depthFactor));\n  body = mix(body, u_shallowColor, u_clarity * 0.35);\n  vec3 bodyLit = body * (u_skyAmbient * u_ambientScale * 0.22 + sun * (0.25 + 0.55 * NdotL));\n\n  // Subsurface. A wave lit from behind glows through its own crest, and the\n  // effect is strongest where the surface is steep and thin - so it keys off the\n  // wave's own height rather than off thickness we do not have.\n  float back = pow(saturate(dot(V, -L) * 0.5 + 0.5), 3.0);\n  float thin = saturate(relHeight * 1.4);\n  vec3 sss = u_sssColor * u_sssStrength * back * thin * u_sunColor * u_sunIntensity * (0.35 + 0.65 * shadow);\n\n  // GGX. The glitter path from the horizon to the camera is most of what says\n  // \"water\" at distance, and it is a specular lobe on a normal that is moving -\n  // which is why the detail normal matters as much as the mesh does.\n  // Water is nearly smooth, which is exactly what makes it alias: a specular\n  // lobe this tight flips between nothing and a blown-out highlight across one\n  // pixel, and a sea of them boils. The fix is not a softer sea - it is to widen\n  // the lobe by however much the normal varies inside the pixel, so the energy\n  // is kept and the flicker is not. roughnessBoost carries that in, and the\n  // reflection above is filtered by the same number.\n  float a = max(rough * rough, 2e-4);\n  vec3 h = normalize(L + V);\n  float ndh = max(dot(n, h), 0.0);\n  float denom = ndh * ndh * (a * a - 1.0) + 1.0;\n  float ggx = (a * a) / (PI * denom * denom);\n  vec3 spec = sun * ggx * u_specular * fres;\n\n  vec3 col = mix(bodyLit + sss, sky, fres) + spec;\n\n  // Foam is a rough dielectric, so it takes the sky and the sun diffusely and\n  // kills the reflection under it.\n  vec3 foamLit = u_foamColor * (u_skyAmbient * u_ambientScale * 0.5 + sun * (0.3 + 0.7 * NdotL));\n  col = mix(col, foamLit, saturate(foam));\n\n  return col;\n}\n\n/** Fade into the sky the water is seen through. Same term as the terrain's,\n *  and it needs to be stronger here: an ocean runs to the horizon in every\n *  direction, so it is the only thing stopping the far field reading as a\n *  painted plane. */\nvec3 oceanAerial(vec3 col, vec3 rd, float dist){\n  float f = 1.0 - exp(-u_fogDensity * dist);\n  if (f < 0.002) return col;\n  return mix(col, skyRadiance(rd), f);\n}\n";
+/** Height field only — what a vertex stage needs. */
+export declare const oceanField: string;
+/** The whole model. */
+export declare const oceanFull: string;
+//# sourceMappingURL=oceanCore.glsl.d.ts.map

package/dist/shaders/glsl/oceanCore.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oceanCore.glsl.d.ts","sourceRoot":"","sources":["../../../src/shaders/glsl/oceanCore.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH;iEACiE;AACjE,eAAO,MAAM,SAAS,KAAK,CAAC;AAE5B,eAAO,MAAM,aAAa,+rDAgDzB,CAAC;AAEF,eAAO,MAAM,UAAU,gjJAoHtB,CAAC;AAEF,eAAO,MAAM,UAAU,woTA8MtB,CAAC;AAEF,qDAAqD;AACrD,eAAO,MAAM,UAAU,QAAyC,CAAC;AAEjE,uBAAuB;AACvB,eAAO,MAAM,SAAS,QAAqD,CAAC"}

package/dist/shaders/glsl/oceanCore.glsl.js

@@ -0,0 +1,421 @@
+/**
+ * The ocean surface model, in GLSL.
+ *
+ * Split into chunks the way `cloudCore` and `terrainCore` are, so the vertex and
+ * fragment stages take only what they use and the FFT phase can replace exactly
+ * one of them.
+ *
+ *   oceanUniforms   the wave table and every config value
+ *   oceanWaves      the height field: displacement, analytic frame, Jacobian
+ *   oceanShade      foam, detail normal, lighting, aerial perspective
+ *   oceanFull       all three
+ *
+ * ## Why the wave table is a uniform array and not computed here
+ *
+ * The obvious shape is to derive each component's wavelength and amplitude from
+ * the Pierson-Moskowitz spectrum inside the loop. That is an `exp` and two `pow`
+ * per component per vertex, and the spectrum does not change between vertices —
+ * it changes when somebody moves the wind slider. So the fit runs once on the
+ * CPU in `oceanUniforms.ts` and uploads a table; the shader does nothing but sum
+ * sines. It is also the shape the FFT phase wants: a spectrum baked once,
+ * evaluated per vertex.
+ *
+ * ## Why the normal comes from the vertex stage
+ *
+ * Terrain re-evaluates its height field per fragment, because a clipmap triangle
+ * is a poor approximation of a mountain and shading off the mesh normal draws
+ * every splat threshold along a triangle edge. Water is the opposite case: every
+ * component shorter than the cell has already been faded out by the LOD rule
+ * below, so the mesh IS the wave field to within a cell, and an interpolated
+ * normal is the right answer. Twenty sines per pixel would buy nothing. What the
+ * fragment stage adds is detail *below* the mesh — which is exactly the energy
+ * the LOD fade removed.
+ *
+ * ## The uniform-name trap
+ *
+ * When terrain interaction is on, `terrainField` is included beside this, and it
+ * brings `u_seaLevel` and `u_elevation` with it. Those are TERRAIN'S. The water's
+ * own level is `u_waterLevel`. Read `u_seaLevel` in this file and you will get
+ * the height the ground was built around, which is usually 0 and therefore looks
+ * correct until somebody moves it.
+ */
+/** Hard cap on the wave table. The loop is bounded by it because GLSL ES 1.00
+ *  requires a constant bound; `u_waveCount` breaks out early. */
+export const MAX_WAVES = 32;
+export const oceanUniforms = /* glsl */ `
+#define MAX_WAVES 32
+
+// Per component: (dirX, dirZ, amplitude, wavenumber k).
+uniform vec4  u_waveA[MAX_WAVES];
+// Per component: (angular frequency w, phase, steepness Q, wavelength).
+uniform vec4  u_waveB[MAX_WAVES];
+uniform float u_waveCount;
+
+uniform float u_time;
+uniform float u_waterLevel;
+uniform float u_choppiness;
+uniform float u_amplitudeScale;
+
+// Half-extent of a placed body, and the width of its rim taper. Both zero on the
+// world host, which is what switches the taper off - a sea has no rim.
+uniform vec2  u_bodyHalf;
+uniform float u_edgeFade;
+
+uniform vec3  u_deepColor;
+uniform vec3  u_shallowColor;
+uniform vec3  u_foamColor;
+uniform vec3  u_sssColor;
+uniform float u_absorption;
+uniform float u_clarity;
+uniform float u_roughness;
+uniform float u_specular;
+uniform float u_sssStrength;
+uniform float u_detailStrength;
+uniform float u_detailScale;      // 1 / detailSize
+uniform float u_detailFade;       // 1 / detailFadeDistance
+// World size of one pixel at one unit of distance: 2*tan(fov/2) / viewportHeight.
+// What turns a distance into a screen-space footprint, which is the only thing
+// that decides whether a ripple is a shape or a shimmer.
+uniform float u_pixelScale;
+uniform float u_foamAmount;
+uniform float u_foamDecay;
+uniform float u_foamScale;        // 1 / foamSize
+uniform float u_ambientScale;
+uniform float u_fogDensity;
+uniform float u_exposure;
+uniform float u_curvature;
+uniform float u_receiveShadows;
+
+// Filled by applySunUniforms and applyTerrainAmbient, exactly as on the terrain
+// material - one atmosphere for the sky, the clouds, the ground and the water.
+uniform vec3  u_skyAmbient;
+uniform vec3  u_groundAmbient;
+`;
+export const oceanWaves = /* glsl */ `
+/**
+ * One trochoidal component, accumulated.
+ *
+ * Gerstner displaces along the direction of travel as well as vertically:
+ *
+ *   x' = x + d * Q * A * sin(theta)
+ *   y  =     A * cos(theta)
+ *   theta = k * dot(d, x) + w * t + phase
+ *
+ * Q is what peaks the crests and flattens the troughs. It also compresses the
+ * horizontal map near a crest, and where that compression turns the map
+ * degenerate the wave is breaking - which is where the foam is. That falls out
+ * of the same derivatives, for free, so foam here is measured rather than faked.
+ *
+ * Everything is differentiated in closed form. A central difference would need
+ * four more evaluations of the whole sum for the normal alone; this is the same
+ * decision, and the same 13x, that the terrain height field made.
+ */
+void oceanWaveSum(
+  vec2 p, float cellLod, float amp,
+  out vec3 disp,        // displacement from the flat plane, world units
+  out vec3 nrm,         // analytic surface normal
+  out float jacobian,   // det of the horizontal map. < 1 compresses, < 0 folds
+  out float relHeight   // vertical displacement in standard deviations of the surface
+){
+  disp = vec3(0.0);
+  jacobian = 0.0;
+  relHeight = 0.0;
+
+  // Horizontal derivatives of the horizontal displacement, and of the height.
+  float dXdx = 0.0, dXdz = 0.0, dZdx = 0.0, dZdz = 0.0;
+  float dYdx = 0.0, dYdz = 0.0;
+  float totalSq = 0.0;
+
+  for (int i = 0; i < MAX_WAVES; i++) {
+    if (float(i) >= u_waveCount) break;
+
+    vec4 a = u_waveA[i];
+    vec4 b = u_waveB[i];
+    vec2 d = a.xy;
+    float A = a.z * amp;
+    float k = a.w;
+    float w = b.x;
+    float phase = b.y;
+    float Q = b.z;
+    float wl = b.w;
+
+    // Per-ring wave LOD. A component of wavelength L cannot be represented on a
+    // cell coarser than about L/4 - sampled there it aliases into crawling
+    // noise, which is what a naive clipmap ocean looks like at the horizon. So
+    // it fades out as the cell approaches its wavelength.
+    //
+    // cellLod is aCell * (1 + aMorph), the same morphing LOD the terrain uses,
+    // which is what makes the two sides of a ring seam agree: the outer edge of
+    // ring l evaluates at exactly ring l+1's cell size, so both sides fade the
+    // same components by the same amount and the surface is continuous across
+    // the boundary.
+    float lod = 1.0 - smoothstep(wl * 0.25, wl * 0.75, cellLod);
+    A *= lod;
+
+    float theta = k * dot(d, p) + w * u_time + phase;
+    float S = sin(theta);
+    float C = cos(theta);
+
+    float QA = Q * A;
+
+    disp.x += d.x * QA * S;
+    disp.z += d.y * QA * S;
+    disp.y += A * C;
+    totalSq += A * A;
+
+    float kQA = k * QA;
+    dXdx += d.x * d.x * kQA * C;
+    dXdz += d.x * d.y * kQA * C;
+    dZdx += d.y * d.x * kQA * C;
+    dZdz += d.y * d.y * kQA * C;
+
+    float kA = k * A;
+    dYdx -= d.x * kA * S;
+    dYdz -= d.y * kA * S;
+  }
+
+  // Tangent frame of the displaced surface. Taking the cross product rather than
+  // the usual closed-form shortcut costs three multiplies and stays correct when
+  // choppiness is high, where the shortcut - which assumes the horizontal map is
+  // near-identity - visibly tilts the crests the wrong way.
+  vec3 tx = vec3(1.0 + dXdx, dYdx, dZdx);
+  vec3 tz = vec3(dXdz, dYdz, 1.0 + dZdz);
+  nrm = normalize(cross(tz, tx));
+
+  jacobian = (1.0 + dXdx) * (1.0 + dZdz) - dXdz * dZdx;
+
+  // Height in standard deviations of the surface, NOT as a fraction of the
+  // summed amplitudes. Dividing by the sum is the obvious thing and it is wrong
+  // by a factor of sqrt(2N): random-phase components almost never align, so the
+  // surface only ever reaches a fraction of that sum, and everything keyed on
+  // relative height - the foam's crest gate, the subsurface term - was being
+  // multiplied by ~0.15 and silently doing nothing. A storm with whitecaps
+  // turned up had no foam at all, which is how this was found.
+  //
+  // sigma is the RMS surface elevation, so this is roughly -3..3 with the usual
+  // excursion at +-1, and a threshold expressed in it means what it looks like.
+  relHeight = disp.y / max(sqrt(totalSq * 0.5), 1e-4);
+}
+
+/** Rim taper for a placed body: displacement to zero at the edge, so the
+ *  boundary is still water rather than a sawn-off cliff of it. Returns 1 on the
+ *  world host, where u_bodyHalf is zero. */
+float oceanEdgeMask(vec2 local){
+  if (u_bodyHalf.x <= 0.0) return 1.0;
+  vec2 t = abs(local) / max(u_bodyHalf, vec2(1e-3));
+  float e = max(t.x, t.y);
+  float band = max(u_edgeFade, 1e-3);
+  return 1.0 - smoothstep(1.0 - band, 1.0, e);
+}
+`;
+export const oceanShade = /* glsl */ `
+/** Arithmetic hash. Never the fract(sin(dot())) one: four hashes per octave of
+ *  two sines each was most of the terrain frame budget before it was replaced,
+ *  and every noise tutorial online still teaches the expensive version. */
+vec2 oHash(vec2 p){
+  vec3 p3 = fract(vec3(p.xyx) * vec3(0.1031, 0.1030, 0.0973));
+  p3 += dot(p3, p3.yzx + 33.33);
+  return fract((p3.xx + p3.yz) * p3.zy) * 2.0 - 1.0;
+}
+
+/** Gradient noise with its derivative, so a detail normal costs one evaluation
+ *  instead of three. */
+vec3 oNoised(vec2 x){
+  vec2 i = floor(x);
+  vec2 f = fract(x);
+  vec2 u = f * f * (3.0 - 2.0 * f);
+  vec2 du = 6.0 * f * (1.0 - f);
+
+  vec2 ga = oHash(i + vec2(0.0, 0.0));
+  vec2 gb = oHash(i + vec2(1.0, 0.0));
+  vec2 gc = oHash(i + vec2(0.0, 1.0));
+  vec2 gd = oHash(i + vec2(1.0, 1.0));
+
+  float va = dot(ga, f - vec2(0.0, 0.0));
+  float vb = dot(gb, f - vec2(1.0, 0.0));
+  float vc = dot(gc, f - vec2(0.0, 1.0));
+  float vd = dot(gd, f - vec2(1.0, 1.0));
+
+  float v = va + u.x * (vb - va) + u.y * (vc - va) + u.x * u.y * (va - vb - vc + vd);
+  vec2 g = ga + u.x * (gb - ga) + u.y * (gc - ga) + u.x * u.y * (ga - gb - gc + gd)
+         + du * (u.yx * (va - vb - vc + vd) + vec2(vb, vc) - va);
+  return vec3(v, g);
+}
+
+/**
+ * Ripple below the mesh.
+ *
+ * This is not decoration: the per-ring LOD in oceanWaveSum deletes every
+ * component shorter than the cell, and near the camera that is most of the
+ * high-frequency energy in the sea. Putting it back as a normal perturbation is
+ * cheaper than carrying it in geometry and, past a few metres, indistinguishable
+ * - a ripple two pixels across is a normal, not a shape.
+ *
+ * Two octaves drifting in opposite directions, because one drifting field reads
+ * as a texture being dragged across the water.
+ */
+float oceanDetailFade(float dist){
+  // Two fades, and the second is the one that matters. Distance alone is not
+  // what makes a ripple alias - a screen-space footprint is. A two-metre ripple
+  // is a shape at fifty metres and sub-pixel noise at two thousand, and which of
+  // those it is depends on the field of view and the resolution, not on the
+  // distance. Fading on the footprint means the same water looks right in a
+  // wide shot and a telephoto one.
+  float footprint = dist * u_pixelScale;
+  float size = 1.0 / max(u_detailScale, 1e-4);
+  float screen = 1.0 - smoothstep(size * 0.35, size * 1.4, footprint);
+  return exp(-dist * u_detailFade) * screen;
+}
+
+vec3 oceanDetailNormal(vec3 n, vec3 wp, float fade){
+  float amt = u_detailStrength * fade;
+  if (amt <= 0.001) return n;
+
+  vec2 p = wp.xz * u_detailScale;
+  vec2 drift = vec2(u_time * 0.06, u_time * 0.043);
+
+  vec3 a = oNoised(p + drift);
+  vec3 b = oNoised(p * 2.17 - drift * 1.6);
+  vec2 g = a.yz + b.yz * 0.5;
+
+  // Perturb in the surface plane, so a steep wave face keeps its own orientation
+  // and only gains texture.
+  vec3 t = normalize(cross(vec3(0.0, 1.0, 0.0), n) + vec3(1e-5, 0.0, 0.0));
+  vec3 bt = cross(n, t);
+  // 0.12, not 0.4. The gradient of the noise is order 1, so the constant IS the
+  // maximum slope the ripple adds: at 0.4 the default strength tilts the normal
+  // by twelve degrees, and at grazing angles - which is most of an ocean - a
+  // twelve degree tilt swings the Fresnel term between reflecting the sky and
+  // not. The whole surface then boils with white speckle, which is exactly what
+  // it did. Sub-metre ripple on open water is a few degrees of slope.
+  return normalize(n - (t * g.x + bt * g.y) * amt * 0.12);
+}
+
+/**
+ * Whitecaps, from the Jacobian of the horizontal map.
+ *
+ * Where the determinant falls toward zero the surface is folding into itself,
+ * which is physically what a breaking crest is. It is the same quantity an FFT
+ * ocean reads off its displacement cascade, and a Gerstner sum hands it over for
+ * nothing, so foam is measured here rather than paint over the crests.
+ *
+ * u_foamDecay is a stand-in for a real accumulation buffer: it widens the
+ * threshold on the trailing side, so foam persists behind the crest instead of
+ * flickering on and off with it. The honest version writes into a persistent
+ * target and advects it - deferred with the FFT phase.
+ */
+float oceanFoam(float jacobian, float relHeight, vec3 wp){
+  float compress = saturate(1.0 - jacobian);
+
+  // Thresholds are calibrated against the compression the wave table actually
+  // produces, which is a much narrower range than it looks: at the defaults the
+  // Jacobian sits just above zero at the sharpest crest and near 1 everywhere
+  // else. A threshold picked by eye either foams the whole sea or none of it.
+  float thr = mix(0.85, 0.15, saturate(u_foamAmount * 0.6));
+  float sharp = smoothstep(thr, thr + 0.15, compress);
+  float trail = smoothstep(thr * 0.55, thr + 0.4, compress);
+  float f = mix(sharp, max(sharp, trail), saturate(u_foamDecay));
+
+  // Foam belongs on and just behind the crest, never in the trough.
+  f *= smoothstep(-0.15, 0.45, relHeight);
+
+  // Break it up, or it reads as a decal following the wave.
+  vec2 q = wp.xz * u_foamScale;
+  float n = oNoised(q + vec2(u_time * 0.05, -u_time * 0.03)).x * 0.5 + 0.5;
+  n = mix(n, 1.0, 0.35);
+  return saturate(f * n * u_foamAmount);
+}
+
+/**
+ * The water shading.
+ *
+ * Reflection is the whole story above a few degrees of grazing - most of what
+ * you see looking at the sea is the sky - so the Fresnel split, the sky radiance
+ * and the aerial perspective all have to come from the same atmosphere the sky
+ * itself is drawn with, or the water is obviously pasted onto the scene. That is
+ * skyRadiance from cloudCore, driven by applySunUniforms off the same
+ * useCloudSun state as the clouds and the terrain.
+ */
+vec3 oceanLight(
+  vec3 wp, vec3 n, vec3 viewDir,   // viewDir points FROM the camera TO the surface
+  float foam, float relHeight, float shadow, float depthFactor,
+  float roughnessBoost,            // specular antialiasing, see the caller
+  vec3 reflectionColor
+){
+  vec3 V = -viewDir;
+  vec3 L = normalize(u_sunDir);
+  float NdotL = max(dot(n, L), 0.0);
+  vec3 sun = u_sunColor * u_sunIntensity * shadow;
+
+  // Reflection. Bending the reflected ray back above the horizon is a cheat, and
+  // the alternative is worse: at grazing angles a wave face routinely reflects
+  // just below the horizon, and sampling the sky's ground term there puts a band
+  // of dirt across the brightest part of the water.
+  vec3 R = reflect(viewDir, n);
+  R.y = max(R.y, 0.015);
+  vec3 sky = length(reflectionColor) > 0.0 ? reflectionColor : skyRadiance(R);
+
+  // Prefilter the reflection by the same roughness the specular lobe uses.
+  // Without this the specular is filtered and the reflection is not, and on
+  // water that is the wrong half: reflection is most of what you see, and a
+  // mirror sampled through a noisy normal aliases exactly as hard as a highlight
+  // does. u_skyAmbient is already the hemispheric average of this sky, so it is
+  // the infinitely-rough end of the same lobe and costs nothing to mix toward.
+  float rough = clamp(u_roughness + roughnessBoost, 0.01, 1.0);
+  sky = mix(sky, u_skyAmbient * 0.6, saturate(rough * 2.2));
+
+  float fres = 0.02 + 0.98 * pow(1.0 - saturate(dot(V, n)), 5.0);
+
+  // Body colour. depthFactor is 1 in open water and ramps to 0 as the bottom
+  // comes up; until the refraction grab exists it is 1 everywhere.
+  vec3 body = mix(u_shallowColor, u_deepColor, saturate(depthFactor));
+  body = mix(body, u_shallowColor, u_clarity * 0.35);
+  vec3 bodyLit = body * (u_skyAmbient * u_ambientScale * 0.22 + sun * (0.25 + 0.55 * NdotL));
+
+  // Subsurface. A wave lit from behind glows through its own crest, and the
+  // effect is strongest where the surface is steep and thin - so it keys off the
+  // wave's own height rather than off thickness we do not have.
+  float back = pow(saturate(dot(V, -L) * 0.5 + 0.5), 3.0);
+  float thin = saturate(relHeight * 1.4);
+  vec3 sss = u_sssColor * u_sssStrength * back * thin * u_sunColor * u_sunIntensity * (0.35 + 0.65 * shadow);
+
+  // GGX. The glitter path from the horizon to the camera is most of what says
+  // "water" at distance, and it is a specular lobe on a normal that is moving -
+  // which is why the detail normal matters as much as the mesh does.
+  // Water is nearly smooth, which is exactly what makes it alias: a specular
+  // lobe this tight flips between nothing and a blown-out highlight across one
+  // pixel, and a sea of them boils. The fix is not a softer sea - it is to widen
+  // the lobe by however much the normal varies inside the pixel, so the energy
+  // is kept and the flicker is not. roughnessBoost carries that in, and the
+  // reflection above is filtered by the same number.
+  float a = max(rough * rough, 2e-4);
+  vec3 h = normalize(L + V);
+  float ndh = max(dot(n, h), 0.0);
+  float denom = ndh * ndh * (a * a - 1.0) + 1.0;
+  float ggx = (a * a) / (PI * denom * denom);
+  vec3 spec = sun * ggx * u_specular * fres;
+
+  vec3 col = mix(bodyLit + sss, sky, fres) + spec;
+
+  // Foam is a rough dielectric, so it takes the sky and the sun diffusely and
+  // kills the reflection under it.
+  vec3 foamLit = u_foamColor * (u_skyAmbient * u_ambientScale * 0.5 + sun * (0.3 + 0.7 * NdotL));
+  col = mix(col, foamLit, saturate(foam));
+
+  return col;
+}
+
+/** Fade into the sky the water is seen through. Same term as the terrain's,
+ *  and it needs to be stronger here: an ocean runs to the horizon in every
+ *  direction, so it is the only thing stopping the far field reading as a
+ *  painted plane. */
+vec3 oceanAerial(vec3 col, vec3 rd, float dist){
+  float f = 1.0 - exp(-u_fogDensity * dist);
+  if (f < 0.002) return col;
+  return mix(col, skyRadiance(rd), f);
+}
+`;
+/** Height field only — what a vertex stage needs. */
+export const oceanField = [oceanUniforms, oceanWaves].join('\n');
+/** The whole model. */
+export const oceanFull = [oceanUniforms, oceanWaves, oceanShade].join('\n');