@3driseai/3drise-viewer 0.1.28 → 0.1.29

package/dist/presets/terrainPresets.js

@@ -7,11 +7,10 @@ const mountainPresets = [
         terrainType: 'mountains',
         description: 'Sharp granite ridges above a snow line, glaciated valleys between them. The default mountain.',
         tags: ['snow', 'sharp', 'high', 'granite'],
+        biome: 'Alpine meadow',
         settings: {
             elevation: 1700, featureSize: 3800, octaves: 9, gain: 0.5,
             ridgeSharpness: 0.68, warpStrength: 0.3, erosion: 0.75,
-            peakLevel: 0.7, peakBlend: 0.1, peakSlopeFalloff: 1.6,
-            lowColor: '#3c4a33', midColor: '#5b5a44', rockColor: '#6d6659', peakColor: '#f2f5fa',
             slopeRockStart: 0.3, slopeRockEnd: 0.55,
             aerialPerspective: 0.00005,
         },
@@ -21,11 +20,10 @@ const mountainPresets = [
         terrainType: 'mountains',
         description: 'The approach rather than the summit: broad shoulders, forest colours, no snow.',
         tags: ['low', 'green', 'gentle', 'approach'],
+        biome: 'Green hills',
         settings: {
             elevation: 520, featureSize: 2400, octaves: 8, gain: 0.47,
             ridgeSharpness: 0.4, warpStrength: 0.38, erosion: 0.6,
-            peakLevel: 0.92, peakBlend: 0.15,
-            lowColor: '#37461f', midColor: '#4c5730', rockColor: '#75695a', peakColor: '#8b9166',
             slopeRockStart: 0.42, slopeRockEnd: 0.7,
             aerialPerspective: 0.00009,
         },
@@ -35,13 +33,11 @@ const mountainPresets = [
         terrainType: 'mountains',
         description: 'Steep, dark and young. Little erosion, so the flanks stay smooth and the ridges stay raw.',
         tags: ['dark', 'basalt', 'steep', 'ash'],
+        biome: 'Volcanic',
         settings: {
             elevation: 1300, featureSize: 3000, octaves: 8, gain: 0.54,
             ridgeSharpness: 0.5, warpStrength: 0.16, erosion: 0.25,
-            peakLevel: 0.86, peakBlend: 0.06, peakSlopeFalloff: 2.2,
-            lowColor: '#2a2622', midColor: '#3a342e', rockColor: '#4a423a', peakColor: '#d8d4cc',
             slopeRockStart: 0.22, slopeRockEnd: 0.45,
-            macroVariation: 0.34, roughness: 0.94, specular: 0.02,
         },
     },
     {
@@ -49,12 +45,11 @@ const mountainPresets = [
         terrainType: 'mountains',
         description: 'Pale limestone spires with banded walls. Strata on, sharpened hard.',
         tags: ['limestone', 'towers', 'strata', 'pale'],
+        biome: 'Alpine meadow',
         settings: {
             elevation: 1250, featureSize: 2600, octaves: 9, gain: 0.55,
             ridgeSharpness: 0.82, warpStrength: 0.22, erosion: 0.5,
             terraces: 22, terraceSharpness: 0.85,
-            peakLevel: 0.74, peakBlend: 0.08,
-            lowColor: '#4a5238', midColor: '#7d7867', rockColor: '#b3ab9a', peakColor: '#eef0f4',
             slopeRockStart: 0.22, slopeRockEnd: 0.42,
         },
     },
@@ -63,13 +58,12 @@ const mountainPresets = [
         terrainType: 'mountains',
         description: 'Old, worn and wide. Erosion near maximum flattens the floors and leaves the ridges as fins.',
         tags: ['old', 'worn', 'moorland', 'wide'],
+        biome: 'Moorland',
         settings: {
             elevation: 800, featureSize: 5000, octaves: 10, gain: 0.44,
             ridgeSharpness: 0.55, warpStrength: 0.46, erosion: 0.95,
-            peakLevel: 0.88, peakBlend: 0.22,
-            lowColor: '#454a2e', midColor: '#5e5a3d', rockColor: '#726a5c', peakColor: '#9aa07c',
             slopeRockStart: 0.4, slopeRockEnd: 0.68,
-            macroVariation: 0.34, aerialPerspective: 0.00007,
+            aerialPerspective: 0.00007,
         },
     },
 ];
@@ -82,11 +76,11 @@ const dunePresets = [
         terrainType: 'dunes',
         description: 'A full sand sea: tall transverse dunes, crest after crest to the horizon.',
         tags: ['sahara', 'tall', 'transverse', 'sand sea'],
+        biome: 'Desert sand',
         settings: {
             elevation: 180, featureSize: 5200, duneWavelength: 420, duneAsymmetry: 0.7,
             octaves: 6, gain: 0.44, warpStrength: 0.22,
-            lowColor: '#b08a53', midColor: '#dcb87e', peakColor: '#f4e2bc',
-            specular: 0.18, bounce: 0.6,
+            bounce: 0.6,
         },
     },
     {
@@ -94,11 +88,10 @@ const dunePresets = [
         terrainType: 'dunes',
         description: 'Isolated crescent dunes on a hard desert floor. Low, widely spaced, strong slip faces.',
         tags: ['crescent', 'sparse', 'low', 'hardpan'],
+        biome: 'Desert sand',
         settings: {
             elevation: 70, featureSize: 2800, duneWavelength: 260, duneAsymmetry: 0.88,
             octaves: 6, gain: 0.38, warpStrength: 0.3,
-            lowColor: '#9c8360', midColor: '#c8a878', peakColor: '#e8d2a8',
-            macroVariation: 0.2, specular: 0.14,
         },
     },
     {
@@ -106,11 +99,11 @@ const dunePresets = [
         terrainType: 'dunes',
         description: 'Low marram-held ridges behind a beach. Damp sand, so more sheen and cooler colour.',
         tags: ['coast', 'low', 'damp', 'beach'],
+        biome: 'Desert sand',
         settings: {
             elevation: 34, featureSize: 1600, duneWavelength: 120, duneAsymmetry: 0.5,
             octaves: 7, gain: 0.46, warpStrength: 0.4, ridgeSharpness: 0.1,
-            lowColor: '#a99b7c', midColor: '#cfc3a3', peakColor: '#e6dcc4',
-            roughness: 0.42, specular: 0.3, detailSize: 2.2, detailStrength: 0.4,
+            detailSize: 2.2, detailStrength: 0.4,
             aerialPerspective: 0.00011,
         },
     },
@@ -119,11 +112,10 @@ const dunePresets = [
         terrainType: 'dunes',
         description: 'Iron-stained linear dunes: long parallel ridges rather than a crescent field.',
         tags: ['red', 'linear', 'outback', 'iron'],
+        biome: 'Red rock',
         settings: {
             elevation: 120, featureSize: 8000, duneWavelength: 520, duneAsymmetry: 0.4,
             octaves: 5, gain: 0.4, warpStrength: 0.1,
-            lowColor: '#8c3f22', midColor: '#c06334', rockColor: '#9c5029', peakColor: '#e09a5c',
-            macroVariation: 0.24, specular: 0.1,
         },
     },
     {
@@ -131,12 +123,11 @@ const dunePresets = [
         terrainType: 'dunes',
         description: 'Almost nothing: a bright pan with the faintest relief. The reference for a flat, huge horizon.',
         tags: ['flat', 'bright', 'playa', 'minimal'],
+        biome: 'Salt flat',
         settings: {
             elevation: 6, featureSize: 12000, duneWavelength: 900, duneAsymmetry: 0.1,
             octaves: 5, gain: 0.42, warpStrength: 0.5, ridgeSharpness: 0,
-            lowColor: '#cfc9bc', midColor: '#e8e4da', peakColor: '#f8f6f1',
             slopeRockStart: 0.8, slopeRockEnd: 0.95,
-            macroVariation: 0.16, roughness: 0.4, specular: 0.22,
             aerialPerspective: 0.00013,
         },
     },
@@ -150,10 +141,10 @@ const hillPresets = [
         terrainType: 'hills',
         description: 'Soft chalk hills under grass. Wide, rounded and calm — the friendly default.',
         tags: ['grass', 'rounded', 'calm', 'pastoral'],
+        biome: 'Green hills',
         settings: {
             elevation: 160, featureSize: 3000, octaves: 8, gain: 0.45,
             ridgeSharpness: 0.02, warpStrength: 0.34, erosion: 0.4,
-            lowColor: '#3f5326', midColor: '#5b6b3c', peakColor: '#93a06a',
         },
     },
     {
@@ -161,11 +152,11 @@ const hillPresets = [
         terrainType: 'hills',
         description: 'Almost flat, very wide. Dry grass to the horizon with barely a fold in it.',
         tags: ['flat', 'dry', 'wide', 'grassland'],
+        biome: 'Dry grassland',
         settings: {
             elevation: 55, featureSize: 9000, octaves: 7, gain: 0.42,
             ridgeSharpness: 0, warpStrength: 0.45, erosion: 0.35,
-            lowColor: '#6b6836', midColor: '#8a8047', peakColor: '#a89a63',
-            macroVariation: 0.36, aerialPerspective: 0.0001,
+            aerialPerspective: 0.0001,
         },
     },
     {
@@ -173,12 +164,12 @@ const hillPresets = [
         terrainType: 'hills',
         description: 'Peat and heather over rough ground: darker, coarser and more broken than downland.',
         tags: ['heather', 'peat', 'rough', 'dark'],
+        biome: 'Moorland',
         settings: {
             elevation: 280, featureSize: 3400, octaves: 9, gain: 0.5,
             ridgeSharpness: 0.18, warpStrength: 0.28, erosion: 0.62,
-            lowColor: '#3a3626', midColor: '#4f4630', rockColor: '#6b6455', peakColor: '#6e6444',
             slopeRockStart: 0.42, slopeRockEnd: 0.68,
-            macroVariation: 0.4, detailStrength: 0.65,
+            detailStrength: 0.65,
         },
     },
     {
@@ -186,11 +177,10 @@ const hillPresets = [
         terrainType: 'hills',
         description: 'A single broad valley with soft shoulders. Heavy erosion gives it a real floor to stand on.',
         tags: ['valley', 'green', 'floor', 'soft'],
+        biome: 'Green hills',
         settings: {
             elevation: 220, featureSize: 5200, octaves: 8, gain: 0.43,
             ridgeSharpness: 0.08, warpStrength: 0.5, erosion: 0.88,
-            lowColor: '#445a24', midColor: '#5d6f36', peakColor: '#8fa15f',
-            macroVariation: 0.3,
         },
     },
     {
@@ -198,12 +188,11 @@ const hillPresets = [
         terrainType: 'hills',
         description: 'Low frozen ground with snow settling in the hollows rather than on the tops.',
         tags: ['cold', 'snow', 'low', 'arctic'],
+        biome: 'Tundra',
         settings: {
             elevation: 130, featureSize: 4200, octaves: 8, gain: 0.44,
             ridgeSharpness: 0.05, warpStrength: 0.36, erosion: 0.5,
-            lowColor: '#8e9299', midColor: '#6d6f66', rockColor: '#5f5d58', peakColor: '#eaf0f6',
-            peakLevel: 0.5, peakBlend: 0.28, peakSlopeFalloff: 0.8,
-            roughness: 0.6, specular: 0.12, ambient: 1.2,
+            ambient: 1.2,
         },
     },
 ];
@@ -216,10 +205,10 @@ const canyonPresets = [
         terrainType: 'canyon',
         description: 'Banded sandstone walls above a branching network of washes. The default canyon.',
         tags: ['sandstone', 'red', 'strata', 'network'],
+        biome: 'Red rock',
         settings: {
             elevation: 700, featureSize: 2800, plateau: 0.55, valleyDepth: 0.8, valleyWidth: 0.22,
             terraces: 14, terraceSharpness: 0.72, erosion: 0.85,
-            lowColor: '#7a4a30', midColor: '#a4643c', rockColor: '#c07a4a', peakColor: '#d9a877',
         },
     },
     {
@@ -227,10 +216,10 @@ const canyonPresets = [
         terrainType: 'canyon',
         description: 'A narrow deep cut in an almost flat plateau. Incision at its narrowest and deepest.',
         tags: ['narrow', 'deep', 'slot', 'antelope'],
+        biome: 'Red rock',
         settings: {
             elevation: 420, featureSize: 3200, plateau: 0.85, valleyDepth: 1.25, valleyWidth: 0.07,
             terraces: 20, terraceSharpness: 0.9, erosion: 0.7, octaves: 9,
-            lowColor: '#6b3a22', midColor: '#a35a2c', rockColor: '#cf8348', peakColor: '#c9a06a',
             shadowSoftness: 5,
         },
     },
@@ -239,10 +228,10 @@ const canyonPresets = [
         terrainType: 'canyon',
         description: 'Flat-topped tables standing above a wide desert floor, cut well apart from each other.',
         tags: ['mesa', 'butte', 'flat top', 'monument'],
+        biome: 'Red rock',
         settings: {
             elevation: 620, featureSize: 4200, plateau: 0.95, valleyDepth: 1.1, valleyWidth: 0.55,
             terraces: 10, terraceSharpness: 0.95, erosion: 0.9, ridgeSharpness: 0.2,
-            lowColor: '#8a5a3a', midColor: '#b0703f', rockColor: '#c9834c', peakColor: '#e0b184',
             slopeRockStart: 0.2, slopeRockEnd: 0.38,
             aerialPerspective: 0.00007,
         },
@@ -252,11 +241,10 @@ const canyonPresets = [
         terrainType: 'canyon',
         description: 'Densely dissected, chaotic and low. Almost all wall and almost no floor.',
         tags: ['dissected', 'chaotic', 'low', 'clay'],
+        biome: 'Red rock',
         settings: {
             elevation: 240, featureSize: 1800, plateau: 0.4, valleyDepth: 0.9, valleyWidth: 0.42,
             terraces: 26, terraceSharpness: 0.6, erosion: 0.55, octaves: 10, ridgeSharpness: 0.45,
-            lowColor: '#6e6252', midColor: '#94836a', rockColor: '#ab9a80', peakColor: '#c9bda4',
-            macroVariation: 0.34,
         },
     },
     {
@@ -264,10 +252,10 @@ const canyonPresets = [
         terrainType: 'canyon',
         description: 'One enormous incision across a high plateau, layered from rim to river. Built for the horizon.',
         tags: ['huge', 'layered', 'rim', 'grand'],
+        biome: 'Red rock',
         settings: {
             elevation: 1600, featureSize: 9000, plateau: 0.75, valleyDepth: 1.35, valleyWidth: 0.3,
             terraces: 30, terraceSharpness: 0.8, erosion: 0.92, octaves: 10,
-            lowColor: '#6a4130', midColor: '#9a5f3c', rockColor: '#bd7c4e', peakColor: '#d4ab80',
             aerialPerspective: 0.00007,
         },
     },

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

@@ -42,9 +42,9 @@
 /** 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 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\n// Moonlight (useOceanMaterial, from the same moon as the key light and the\n// moon disc). u_moonColor already carries strength: black by day, so the moon\n// terms below cost two dot products and add nothing.\nuniform vec3  u_moonDir;\nuniform vec3  u_moonColor;\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";
+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  // The moon: its own glitter path down the water toward the camera, and a\n  // little light on the body. Same lobe, same filtering, so the path breaks up\n  // on the waves exactly as the sun's does. Below the horizon u_moonColor is 0.\n  vec3 Lm = normalize(u_moonDir);\n  vec3 hm = normalize(Lm + V);\n  float ndhm = max(dot(n, hm), 0.0);\n  float denomM = ndhm * ndhm * (a * a - 1.0) + 1.0;\n  float ggxM = (a * a) / (PI * denomM * denomM);\n  spec += u_moonColor * ggxM * u_specular * fres;\n  bodyLit += body * u_moonColor * (0.25 + 0.55 * max(dot(n, Lm), 0.0));\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. */

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

@@ -1 +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"}
+{"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,28DAsDzB,CAAC;AAEF,eAAO,MAAM,UAAU,gjJAoHtB,CAAC;AAEF,eAAO,MAAM,UAAU,ssUAyNtB,CAAC;AAEF,qDAAqD;AACrD,eAAO,MAAM,UAAU,QAAyC,CAAC;AAEjE,uBAAuB;AACvB,eAAO,MAAM,SAAS,QAAqD,CAAC"}

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

@@ -90,6 +90,12 @@ uniform float u_receiveShadows;
 // material - one atmosphere for the sky, the clouds, the ground and the water.
 uniform vec3  u_skyAmbient;
 uniform vec3  u_groundAmbient;
+
+// Moonlight (useOceanMaterial, from the same moon as the key light and the
+// moon disc). u_moonColor already carries strength: black by day, so the moon
+// terms below cost two dot products and add nothing.
+uniform vec3  u_moonDir;
+uniform vec3  u_moonColor;
 `;
 export const oceanWaves = /* glsl */ `
 /**
@@ -395,6 +401,17 @@ vec3 oceanLight(
   float ggx = (a * a) / (PI * denom * denom);
   vec3 spec = sun * ggx * u_specular * fres;
 
+  // The moon: its own glitter path down the water toward the camera, and a
+  // little light on the body. Same lobe, same filtering, so the path breaks up
+  // on the waves exactly as the sun's does. Below the horizon u_moonColor is 0.
+  vec3 Lm = normalize(u_moonDir);
+  vec3 hm = normalize(Lm + V);
+  float ndhm = max(dot(n, hm), 0.0);
+  float denomM = ndhm * ndhm * (a * a - 1.0) + 1.0;
+  float ggxM = (a * a) / (PI * denomM * denomM);
+  spec += u_moonColor * ggxM * u_specular * fres;
+  bodyLit += body * u_moonColor * (0.25 + 0.55 * max(dot(n, Lm), 0.0));
+
   vec3 col = mix(bodyLit + sss, sky, fres) + spec;
 
   // Foam is a rough dielectric, so it takes the sky and the sun diffusely and

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

@@ -0,0 +1,21 @@
+/**
+ * Surface sampling for splat-textured ground — texture arrays, stochastic tiling,
+ * height blending inputs and normal blending.
+ *
+ * Taken from the landscape module (`landscapeCore.glsl.ts`), where every piece of
+ * it was debugged by rendering. It is the terrain's now; the landscape keeps its
+ * own copy until it is retired. Everything is `sf`-prefixed so it can sit beside
+ * three's `<common>` and the terrain chunks.
+ *
+ * Needs GLSL ES 3.0 (`sampler2DArray`, `textureGrad`). three r163+ compiles every
+ * non-raw ShaderMaterial as `#version 300 es` with a `texture2D -> texture`
+ * define, so this works with no `glslVersion` override — and setting one would
+ * remove the `gl_FragColor` alias the terrain fragment writes to.
+ *
+ * Single exit and initialised results throughout: ANGLE on Windows rewrites early
+ * returns, and D3D then warns X4000 about the function's own result.
+ *
+ * A backtick inside this template literal terminates the string.
+ */
+export declare const surfaceSampling = "\n// Arithmetic hash. Never fract(sin(dot(...))).\nvec2 sfHash2(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);\n}\n\n// Stochastic cell size, in texture tiles. A cell wants to be a tile or two across\n// so it randomises PATCHES; a third of a tile (the bare 3.4641 constant on tiled\n// UVs) goes sub-pixel almost at once and the repeat grid comes straight back.\n#define SF_CELL_TILES 1.5\n\nvoid sfTriGrid(vec2 uv, out vec3 w, out vec2 v1, out vec2 v2, out vec2 v3) {\n  w = vec3(0.0);\n  v1 = vec2(0.0);\n  v2 = vec2(0.0);\n  v3 = vec2(0.0);\n  vec2 skewed = mat2(1.0, 0.0, -0.57735027, 1.15470054) * (uv * (3.4641016 / SF_CELL_TILES));\n  vec2 base = floor(skewed);\n  vec3 t = vec3(fract(skewed), 0.0);\n  t.z = 1.0 - t.x - t.y;\n  if (t.z > 0.0) {\n    w = vec3(t.z, t.y, t.x);\n    v1 = base;\n    v2 = base + vec2(0.0, 1.0);\n    v3 = base + vec2(1.0, 0.0);\n  } else {\n    w = vec3(-t.z, 1.0 - t.y, 1.0 - t.x);\n    v1 = base + vec2(1.0, 1.0);\n    v2 = base + vec2(1.0, 0.0);\n    v3 = base + vec2(0.0, 1.0);\n  }\n}\n\n/**\n * One layer of an array, tiled without a visible repeat grid: three taps at\n * hashed offsets, weighted by the barycentric position in a triangle cell, with a\n * variance-preserving blend (a plain weighted sum washes contrast toward the\n * mean). mean is the layer's mean in the space the sampler returns.\n *\n * The UV gradients are passed in, not taken here. Which layer a pixel samples is\n * decided per pixel, so this is called from non-uniform control flow, where\n * dFdx / dFdy are undefined. The caller takes the derivatives of the world\n * position once, at the top of main, and scales them by the layer's tiling.\n *\n * THE FOOTPRINT FADE IS NOT OPTIONAL. Once a cell is about a pixel the three taps\n * land in unrelated parts of the texture, the correction amplifies the\n * difference, and the far field becomes black speckle that looks exactly like\n * shadow acne. Past the fade this is a plain mip-mapped sample.\n */\nvec4 sfSample(sampler2DArray tex, vec2 uv, vec2 dx, vec2 dy, float layer, vec4 mean) {\n  vec4 result = vec4(0.0);\n  float footprint = max(length(dx), length(dy)) * (3.4641016 / SF_CELL_TILES);\n  float fade = smoothstep(0.45, 1.10, footprint);\n  if (fade > 0.995) {\n    result = textureGrad(tex, vec3(uv, layer), dx, dy);\n  } else {\n    vec3 w;\n    vec2 v1, v2, v3;\n    sfTriGrid(uv, w, v1, v2, v3);\n    vec4 c1 = textureGrad(tex, vec3(uv + sfHash2(v1), layer), dx, dy);\n    vec4 c2 = textureGrad(tex, vec3(uv + sfHash2(v2), layer), dx, dy);\n    vec4 c3 = textureGrad(tex, vec3(uv + sfHash2(v3), layer), dx, dy);\n    vec4 d = w.x * (c1 - mean) + w.y * (c2 - mean) + w.z * (c3 - mean);\n    result = clamp(mean + d * inversesqrt(max(dot(w, w), 1e-4)), 0.0, 1.0);\n    if (fade >= 0.005) {\n      result = mix(result, textureGrad(tex, vec3(uv, layer), dx, dy), fade);\n    }\n  }\n  return result;\n}\n\n/** Tangent-space normal from an RGB texel, XY scaled by strength. */\nvec3 sfUnpackNormal(vec3 rgb, float strength) {\n  vec3 t = rgb * 2.0 - 1.0;\n  t.xy *= strength;\n  return t;\n}\n\n/**\n * Whiteout blend of a tangent-space normal onto a world normal n, for a texture\n * projected from above (uv = world xz / tile). Tangent +x is world +x and\n * tangent +y is world +z, which is the mapping a top-down projection gives.\n * Returns an UNnormalised world normal so several layers can be summed and\n * normalised once.\n */\nvec3 sfWhiteoutTop(vec3 n, vec3 t) {\n  return vec3(t.x + n.x, abs(t.z) * n.y, t.y + n.z);\n}\n\n/** The same for side projections, used by the biplanar rock layer.\n *  X plane: uv = world zy. Z plane: uv = world xy. */\nvec3 sfWhiteoutX(vec3 n, vec3 t) {\n  vec3 r = vec3(t.xy + n.zy, abs(t.z) * n.x);\n  return r.zyx;\n}\nvec3 sfWhiteoutZ(vec3 n, vec3 t) {\n  return vec3(t.xy + n.xy, abs(t.z) * n.z);\n}\n";
+//# sourceMappingURL=surfaceCore.glsl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"surfaceCore.glsl.d.ts","sourceRoot":"","sources":["../../../src/shaders/glsl/surfaceCore.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,eAAe,s2HAoG3B,CAAA"}

package/dist/shaders/glsl/surfaceCore.glsl.js

@@ -0,0 +1,120 @@
+/**
+ * Surface sampling for splat-textured ground — texture arrays, stochastic tiling,
+ * height blending inputs and normal blending.
+ *
+ * Taken from the landscape module (`landscapeCore.glsl.ts`), where every piece of
+ * it was debugged by rendering. It is the terrain's now; the landscape keeps its
+ * own copy until it is retired. Everything is `sf`-prefixed so it can sit beside
+ * three's `<common>` and the terrain chunks.
+ *
+ * Needs GLSL ES 3.0 (`sampler2DArray`, `textureGrad`). three r163+ compiles every
+ * non-raw ShaderMaterial as `#version 300 es` with a `texture2D -> texture`
+ * define, so this works with no `glslVersion` override — and setting one would
+ * remove the `gl_FragColor` alias the terrain fragment writes to.
+ *
+ * Single exit and initialised results throughout: ANGLE on Windows rewrites early
+ * returns, and D3D then warns X4000 about the function's own result.
+ *
+ * A backtick inside this template literal terminates the string.
+ */
+export const surfaceSampling = /* glsl */ `
+// Arithmetic hash. Never fract(sin(dot(...))).
+vec2 sfHash2(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);
+}
+
+// Stochastic cell size, in texture tiles. A cell wants to be a tile or two across
+// so it randomises PATCHES; a third of a tile (the bare 3.4641 constant on tiled
+// UVs) goes sub-pixel almost at once and the repeat grid comes straight back.
+#define SF_CELL_TILES 1.5
+
+void sfTriGrid(vec2 uv, out vec3 w, out vec2 v1, out vec2 v2, out vec2 v3) {
+  w = vec3(0.0);
+  v1 = vec2(0.0);
+  v2 = vec2(0.0);
+  v3 = vec2(0.0);
+  vec2 skewed = mat2(1.0, 0.0, -0.57735027, 1.15470054) * (uv * (3.4641016 / SF_CELL_TILES));
+  vec2 base = floor(skewed);
+  vec3 t = vec3(fract(skewed), 0.0);
+  t.z = 1.0 - t.x - t.y;
+  if (t.z > 0.0) {
+    w = vec3(t.z, t.y, t.x);
+    v1 = base;
+    v2 = base + vec2(0.0, 1.0);
+    v3 = base + vec2(1.0, 0.0);
+  } else {
+    w = vec3(-t.z, 1.0 - t.y, 1.0 - t.x);
+    v1 = base + vec2(1.0, 1.0);
+    v2 = base + vec2(1.0, 0.0);
+    v3 = base + vec2(0.0, 1.0);
+  }
+}
+
+/**
+ * One layer of an array, tiled without a visible repeat grid: three taps at
+ * hashed offsets, weighted by the barycentric position in a triangle cell, with a
+ * variance-preserving blend (a plain weighted sum washes contrast toward the
+ * mean). mean is the layer's mean in the space the sampler returns.
+ *
+ * The UV gradients are passed in, not taken here. Which layer a pixel samples is
+ * decided per pixel, so this is called from non-uniform control flow, where
+ * dFdx / dFdy are undefined. The caller takes the derivatives of the world
+ * position once, at the top of main, and scales them by the layer's tiling.
+ *
+ * THE FOOTPRINT FADE IS NOT OPTIONAL. Once a cell is about a pixel the three taps
+ * land in unrelated parts of the texture, the correction amplifies the
+ * difference, and the far field becomes black speckle that looks exactly like
+ * shadow acne. Past the fade this is a plain mip-mapped sample.
+ */
+vec4 sfSample(sampler2DArray tex, vec2 uv, vec2 dx, vec2 dy, float layer, vec4 mean) {
+  vec4 result = vec4(0.0);
+  float footprint = max(length(dx), length(dy)) * (3.4641016 / SF_CELL_TILES);
+  float fade = smoothstep(0.45, 1.10, footprint);
+  if (fade > 0.995) {
+    result = textureGrad(tex, vec3(uv, layer), dx, dy);
+  } else {
+    vec3 w;
+    vec2 v1, v2, v3;
+    sfTriGrid(uv, w, v1, v2, v3);
+    vec4 c1 = textureGrad(tex, vec3(uv + sfHash2(v1), layer), dx, dy);
+    vec4 c2 = textureGrad(tex, vec3(uv + sfHash2(v2), layer), dx, dy);
+    vec4 c3 = textureGrad(tex, vec3(uv + sfHash2(v3), layer), dx, dy);
+    vec4 d = w.x * (c1 - mean) + w.y * (c2 - mean) + w.z * (c3 - mean);
+    result = clamp(mean + d * inversesqrt(max(dot(w, w), 1e-4)), 0.0, 1.0);
+    if (fade >= 0.005) {
+      result = mix(result, textureGrad(tex, vec3(uv, layer), dx, dy), fade);
+    }
+  }
+  return result;
+}
+
+/** Tangent-space normal from an RGB texel, XY scaled by strength. */
+vec3 sfUnpackNormal(vec3 rgb, float strength) {
+  vec3 t = rgb * 2.0 - 1.0;
+  t.xy *= strength;
+  return t;
+}
+
+/**
+ * Whiteout blend of a tangent-space normal onto a world normal n, for a texture
+ * projected from above (uv = world xz / tile). Tangent +x is world +x and
+ * tangent +y is world +z, which is the mapping a top-down projection gives.
+ * Returns an UNnormalised world normal so several layers can be summed and
+ * normalised once.
+ */
+vec3 sfWhiteoutTop(vec3 n, vec3 t) {
+  return vec3(t.x + n.x, abs(t.z) * n.y, t.y + n.z);
+}
+
+/** The same for side projections, used by the biplanar rock layer.
+ *  X plane: uv = world zy. Z plane: uv = world xy. */
+vec3 sfWhiteoutX(vec3 n, vec3 t) {
+  vec3 r = vec3(t.xy + n.zy, abs(t.z) * n.x);
+  return r.zyx;
+}
+vec3 sfWhiteoutZ(vec3 n, vec3 t) {
+  return vec3(t.xy + n.xy, abs(t.z) * n.z);
+}
+`;