@3driseai/3drise-viewer 0.1.7 → 0.1.8

package/dist/shaders/landscape/LandscapeMaterial.d.ts

@@ -0,0 +1,73 @@
+import * as THREE from 'three';
+/**
+ * The landscape surface material.
+ *
+ * ## Why this extends MeshStandardMaterial instead of being a ShaderMaterial
+ *
+ * `TerrainMaterial` is a `ShaderMaterial` with `lights: true` and the light
+ * uniform blocks merged in by hand, because it does its own atmospheric
+ * lighting. A landscape is textured, not procedurally shaded: it wants ordinary
+ * PBR, the scene's HDR environment, shadow receive, fog and tonemapping — all of
+ * which come free by extending the stock material and patching four chunks. That
+ * is also why the reference project reaches for `three-custom-shader-material`;
+ * this is the same four injection points without the dependency, which matters
+ * because `packages/*` reach the client as a hand-copied `dist`.
+ *
+ * ## Shape is compiled in
+ *
+ * Surface count, blend width and the sampling modes are `#define`s, so every
+ * loop in the fragment shader has constant bounds and unrolls, and the stochastic
+ * and triplanar paths compile out entirely when they are off. The cost is that
+ * changing one of them needs a new material — which is what `shapeKey` is for,
+ * and why the controller commits those particular knobs on release rather than
+ * live.
+ *
+ * ## What NOT to do
+ *
+ * Do not set `glslVersion: GLSL3`. three r163+ already compiles every material
+ * as `#version 300 es` and injects `#define texture2D texture` plus the
+ * `gl_FragColor` alias; asking for GLSL3 explicitly removes that alias and the
+ * stock chunks stop compiling. `sampler2DArray` and `textureGrad` work as they
+ * are.
+ */
+export interface LandscapeMaterialShape {
+    /** Number of surfaces, 1..8. */
+    count: number;
+    /** How many are blended per pixel, 1..4, clamped to count. */
+    samples: number;
+    /** Splat maps supplied, 0..2. Ignored when `auto`. */
+    splats: number;
+    /** Generate weights from height and slope instead of from splat maps. */
+    auto: boolean;
+    stochastic: boolean;
+    triplanar: boolean;
+    ao: boolean;
+}
+export interface LandscapeUniforms {
+    [key: string]: THREE.IUniform;
+}
+export declare function landscapeShapeKey(shape: LandscapeMaterialShape): string;
+/** Every uniform both the surface material and the depth material read. Built
+ *  once and shared by reference, so a per-frame write reaches both. */
+export declare function createLandscapeUniforms(count: number): LandscapeUniforms;
+export declare class LandscapeMaterial extends THREE.MeshStandardMaterial {
+    readonly uniforms: LandscapeUniforms;
+    readonly shape: LandscapeMaterialShape;
+    constructor(shape: LandscapeMaterialShape, uniforms: LandscapeUniforms);
+    /** three keys its program cache on this, and two landscapes with different
+     *  defines must not share one. */
+    customProgramCacheKey(): string;
+}
+/**
+ * The depth material for shadow casting, displaced identically.
+ *
+ * This is the thing the procedural terrain cannot have: its shadow camera would
+ * need to frame 25 km, so a mountain never shadows an object standing in its
+ * valley. A landscape is a bounded tile, so the sun's existing shadow camera
+ * already covers it and the only missing piece is a depth pass that agrees with
+ * the surface about where the ground is.
+ */
+export declare function createLandscapeDepthMaterial(uniforms: LandscapeUniforms): THREE.MeshDepthMaterial;
+/** Distance material, for point-light shadows. Same displacement again. */
+export declare function createLandscapeDistanceMaterial(uniforms: LandscapeUniforms): THREE.MeshDistanceMaterial;
+//# sourceMappingURL=LandscapeMaterial.d.ts.map

package/dist/shaders/landscape/LandscapeMaterial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LandscapeMaterial.d.ts","sourceRoot":"","sources":["../../../src/shaders/landscape/LandscapeMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAS9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,MAAM,WAAW,sBAAsB;IACnC,gCAAgC;IAChC,KAAK,EAAE,MAAM,CAAA;IACb,8DAA8D;IAC9D,OAAO,EAAE,MAAM,CAAA;IACf,sDAAsD;IACtD,MAAM,EAAE,MAAM,CAAA;IACd,yEAAyE;IACzE,IAAI,EAAE,OAAO,CAAA;IACb,UAAU,EAAE,OAAO,CAAA;IACnB,SAAS,EAAE,OAAO,CAAA;IAClB,EAAE,EAAE,OAAO,CAAA;CACd;AAED,MAAM,WAAW,iBAAiB;IAC9B,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,QAAQ,CAAA;CAChC;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,sBAAsB,GAAG,MAAM,CAUvE;AAED;uEACuE;AACvE,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,iBAAiB,CAgCxE;AAuBD,qBAAa,iBAAkB,SAAQ,KAAK,CAAC,oBAAoB;IAC7D,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAA;IACpC,QAAQ,CAAC,KAAK,EAAE,sBAAsB,CAAA;gBAE1B,KAAK,EAAE,sBAAsB,EAAE,QAAQ,EAAE,iBAAiB;IA+CtE;sCACkC;IAClC,qBAAqB,IAAI,MAAM;CAGlC;AAED;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,iBAAiB,GAAG,KAAK,CAAC,iBAAiB,CASjG;AAED,2EAA2E;AAC3E,wBAAgB,+BAA+B,CAAC,QAAQ,EAAE,iBAAiB,GAAG,KAAK,CAAC,oBAAoB,CASvG"}

package/dist/shaders/landscape/LandscapeMaterial.js

@@ -0,0 +1,136 @@
+import * as THREE from 'three';
+import { landscapeFragmentBody, landscapeFragmentPars, landscapeNormalBody, landscapeVertexBody, landscapeVertexPars, } from '../glsl/landscapeCore.glsl.js';
+export function landscapeShapeKey(shape) {
+    return [
+        shape.count,
+        shape.samples,
+        shape.splats,
+        shape.auto ? 1 : 0,
+        shape.stochastic ? 1 : 0,
+        shape.triplanar ? 1 : 0,
+        shape.ao ? 1 : 0,
+    ].join(':');
+}
+/** Every uniform both the surface material and the depth material read. Built
+ *  once and shared by reference, so a per-frame write reaches both. */
+export function createLandscapeUniforms(count) {
+    const vec4s = (fill) => Array.from({ length: count }, () => fill.clone());
+    return {
+        u_lsHeight: { value: null },
+        u_lsHeightSize: { value: new THREE.Vector2(1024, 1024) },
+        u_lsSmoothness: { value: 1 },
+        u_lsElevation: { value: 300 },
+        u_lsElevationBias: { value: 0 },
+        u_lsSize: { value: 2048 },
+        u_lsField: { value: null },
+        u_lsGradScale: { value: 0.05 },
+        u_lsFieldTexel: { value: new THREE.Vector2(1 / 1024, 1 / 1024) },
+        u_lsDiffuse: { value: null },
+        u_lsNormal: { value: null },
+        u_lsSplat0: { value: null },
+        u_lsSplat1: { value: null },
+        u_lsAo: { value: null },
+        u_lsSurfA: { value: vec4s(new THREE.Vector4(200, 0.6, 0.9, 0.6)) },
+        u_lsSurfB: { value: vec4s(new THREE.Vector4(1, 1, 1, 1)) },
+        u_lsSurfC: { value: vec4s(new THREE.Vector4(0, 1, 0, 0)) },
+        u_lsSurfMean: { value: Array.from({ length: count }, () => new THREE.Vector3(0.5, 0.5, 0.5)) },
+        u_lsAuto: { value: new THREE.Vector4(0.45, 0.35, 0.62, 0.12) },
+        u_lsAutoBands: { value: Array.from({ length: count }, (_, i) => i / Math.max(count - 1, 1)) },
+        u_lsNoiseScale: { value: 1 / 400 },
+        u_lsMacro: { value: 0.25 },
+        u_lsMacroScale: { value: 1 / 900 },
+        u_lsAoIntensity: { value: 0.8 },
+    };
+}
+function defines(shape) {
+    const out = {
+        // vUv is not declared unless something asks for it, and every map here is
+        // sampled by hand rather than assigned to `material.map`.
+        USE_UV: '',
+        LS_COUNT: Math.max(1, Math.min(8, Math.round(shape.count))),
+        LS_SAMPLES: Math.max(1, Math.min(4, Math.min(shape.samples, shape.count))),
+    };
+    if (shape.auto)
+        out.LS_AUTO = '';
+    if (shape.stochastic)
+        out.LS_STOCHASTIC = '';
+    if (shape.triplanar)
+        out.LS_TRIPLANAR = '';
+    return out;
+}
+function patchVertex(shader) {
+    shader.vertexShader = shader.vertexShader
+        .replace('#include <common>', `#include <common>\n${landscapeVertexPars}`)
+        .replace('#include <beginnormal_vertex>', landscapeNormalBody)
+        .replace('#include <begin_vertex>', landscapeVertexBody);
+}
+export class LandscapeMaterial extends THREE.MeshStandardMaterial {
+    uniforms;
+    shape;
+    constructor(shape, uniforms) {
+        super({
+            color: 0xffffff,
+            roughness: 1,
+            metalness: 0,
+            // The ground is opaque and single-sided; the winding is fixed in the
+            // RTIN emitter rather than papered over with DoubleSide.
+            side: THREE.FrontSide,
+        });
+        this.shape = shape;
+        this.uniforms = uniforms;
+        this.defines = { ...this.defines, ...defines(shape) };
+        this.onBeforeCompile = (shader) => {
+            Object.assign(shader.uniforms, uniforms);
+            patchVertex(shader);
+            let fs = shader.fragmentShader
+                .replace('#include <common>', `#include <common>\n${landscapeFragmentPars}`)
+                .replace('#include <map_fragment>', `${landscapeFragmentBody}\ndiffuseColor.rgb *= lsAlbedo;`)
+                .replace('#include <roughnessmap_fragment>', 'float roughnessFactor = clamp(lsRoughness, 0.04, 1.0);')
+                .replace('#include <metalnessmap_fragment>', 'float metalnessFactor = clamp(lsMetalness, 0.0, 1.0);')
+                .replace('#include <normal_fragment_maps>', 
+            // lsNormalW is world space; three shades in view space.
+            'normal = normalize((viewMatrix * vec4(lsNormalW, 0.0)).xyz);');
+            if (shape.ao) {
+                fs = fs.replace('#include <aomap_fragment>', `float lsAo = texture2D(u_lsAo, vUv).r;
+                     float ambientOcclusion = (lsAo - 1.0) * u_lsAoIntensity + 1.0;
+                     reflectedLight.indirectDiffuse *= ambientOcclusion;`);
+            }
+            shader.fragmentShader = fs;
+        };
+    }
+    /** three keys its program cache on this, and two landscapes with different
+     *  defines must not share one. */
+    customProgramCacheKey() {
+        return `landscape:${landscapeShapeKey(this.shape)}`;
+    }
+}
+/**
+ * The depth material for shadow casting, displaced identically.
+ *
+ * This is the thing the procedural terrain cannot have: its shadow camera would
+ * need to frame 25 km, so a mountain never shadows an object standing in its
+ * valley. A landscape is a bounded tile, so the sun's existing shadow camera
+ * already covers it and the only missing piece is a depth pass that agrees with
+ * the surface about where the ground is.
+ */
+export function createLandscapeDepthMaterial(uniforms) {
+    const material = new THREE.MeshDepthMaterial({ depthPacking: THREE.RGBADepthPacking });
+    material.defines = { ...material.defines, USE_UV: '' };
+    material.onBeforeCompile = (shader) => {
+        Object.assign(shader.uniforms, uniforms);
+        patchVertex(shader);
+    };
+    material.customProgramCacheKey = () => 'landscape-depth';
+    return material;
+}
+/** Distance material, for point-light shadows. Same displacement again. */
+export function createLandscapeDistanceMaterial(uniforms) {
+    const material = new THREE.MeshDistanceMaterial();
+    material.defines = { ...material.defines, USE_UV: '' };
+    material.onBeforeCompile = (shader) => {
+        Object.assign(shader.uniforms, uniforms);
+        patchVertex(shader);
+    };
+    material.customProgramCacheKey = () => 'landscape-distance';
+    return material;
+}

package/dist/shaders/ocean/OceanSurfaceMaterial.d.ts

@@ -0,0 +1,57 @@
+import * as THREE from 'three';
+import { type ThreeElement } from '@react-three/fiber';
+export interface OceanMaterialUniforms {
+    [key: string]: THREE.IUniform;
+}
+/** Uniform-space defaults. Config units are converted by `applyOceanUniforms`;
+ *  these are only what the material holds before anything is applied. */
+export declare const oceanMaterialDefaults: {
+    u_waveA: THREE.Vector4[];
+    u_waveB: THREE.Vector4[];
+    u_waveCount: number;
+    u_time: number;
+    u_waterLevel: number;
+    u_choppiness: number;
+    u_amplitudeScale: number;
+    u_bodyHalf: THREE.Vector2;
+    u_edgeFade: number;
+    u_deepColor: THREE.Color;
+    u_shallowColor: THREE.Color;
+    u_foamColor: THREE.Color;
+    u_sssColor: THREE.Color;
+    u_absorption: number;
+    u_clarity: number;
+    u_roughness: number;
+    u_specular: number;
+    u_sssStrength: number;
+    u_detailStrength: number;
+    u_detailScale: number;
+    u_detailFade: number;
+    u_pixelScale: number;
+    u_foamAmount: number;
+    u_foamDecay: number;
+    u_foamScale: number;
+    u_ambientScale: number;
+    u_fogDensity: number;
+    u_exposure: number;
+    u_curvature: number;
+    u_receiveShadows: number;
+    u_sunDir: THREE.Vector3;
+    u_sunColor: THREE.Color;
+    u_skyAmbient: THREE.Color;
+    u_groundAmbient: THREE.Color;
+    u_sunIntensity: number;
+    u_turbidity: number;
+    u_rayleigh: number;
+    u_mieCoefficient: number;
+    u_mieG: number;
+};
+export declare class OceanSurfaceMaterial extends THREE.ShaderMaterial {
+    constructor();
+}
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        oceanSurfaceMaterial: ThreeElement<typeof OceanSurfaceMaterial>;
+    }
+}
+//# sourceMappingURL=OceanSurfaceMaterial.d.ts.map

package/dist/shaders/ocean/OceanSurfaceMaterial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OceanSurfaceMaterial.d.ts","sourceRoot":"","sources":["../../../src/shaders/ocean/OceanSurfaceMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,EAAU,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAmM9D,MAAM,WAAW,qBAAqB;IAClC,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,QAAQ,CAAA;CAChC;AAMD;yEACyE;AACzE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8CjC,CAAA;AAgBD,qBAAa,oBAAqB,SAAQ,KAAK,CAAC,cAAc;;CAa7D;AAID,OAAO,QAAQ,oBAAoB,CAAC;IAChC,UAAU,aAAa;QACnB,oBAAoB,EAAE,YAAY,CAAC,OAAO,oBAAoB,CAAC,CAAA;KAClE;CACJ"}

package/dist/shaders/ocean/OceanSurfaceMaterial.js

@@ -0,0 +1,268 @@
+import * as THREE from 'three';
+import { extend } from '@react-three/fiber';
+import { skyLib } from '../glsl/cloudCore.glsl.js';
+import { oceanFull, MAX_WAVES } from '../glsl/oceanCore.glsl.js';
+/**
+ * The water surface material. Used by both hosts — the world clipmap and a
+ * placed body — and by all four water types, which differ in the spectrum the
+ * CPU uploads, not in the shader.
+ *
+ * ## Why this is not drei's `shaderMaterial`
+ *
+ * The same reason `TerrainMaterial` is not: water has to RECEIVE the scene's
+ * shadow map, so a boat casts onto it. That needs `lights: true` and
+ * `UniformsLib.lights` merged in, and drei's helper builds neither. Everything
+ * else about the house convention is kept — `u_` uniforms, a defaults export,
+ * `/* glsl *\/` strings, `extend()` and the `ThreeElements` augmentation.
+ *
+ * ## Three shadow sources, not one
+ *
+ * - **Objects onto water** — three's shadow map, `getShadowMask()`. Sized for
+ *   objects, correct for them.
+ * - **Terrain onto water** — an analytic march down the sun vector against the
+ *   terrain height field, marched per vertex (phase 4). Terrain does not write
+ *   into the scene shadow map at all, so this is the only route.
+ * - **Waves onto themselves** — not marched. Crests are small and a trough's
+ *   occlusion is approximated from the wave's own height for a fraction of the
+ *   cost.
+ *
+ * ## The vertex stage does the waves
+ *
+ * Displacement, the analytic tangent frame and the Jacobian all come out of one
+ * loop and travel down as varyings. That is the opposite of the terrain
+ * material, which re-evaluates its field per fragment, and the reason is in
+ * `oceanCore.glsl`: the LOD rule removes every wave the mesh cannot carry, so
+ * here the mesh really is the surface.
+ */
+const vertex = /* glsl */ `
+#include <common>
+#include <shadowmap_pars_vertex>
+#include <fog_pars_vertex>
+
+// three's <common> already supplies PI and saturate, so cloudCommon must NOT be
+// included beside it - redefining PI with a different literal is a compile error.
+${skyLib}
+${oceanFull}
+
+/** World size of this vertex's cell. Per-vertex so one material serves every
+ *  clipmap ring, and a placed body sets it from its own grid. */
+attribute float aCell;
+/** 0 in the body of a ring, ramping to 1 across its outer band. Always 0 on a
+ *  placed body, which has no neighbour to morph toward. */
+attribute float aMorph;
+/** Offset to the parent-grid neighbour. Zero on even indices, and on a body. */
+attribute vec2 aCoarse;
+
+varying vec3  vWorld;
+varying vec3  vNormal_;
+varying float vFoam;
+varying float vRelHeight;
+varying float vDist;
+varying float vDepthFactor;
+
+void main(){
+  // Geomorph first, waves second. The other order blends two different points on
+  // the surface and reopens the seam it is there to close: done this way,
+  // neighbouring rings evaluate the SAME world XZ at their shared boundary and
+  // therefore the same wave sum, so the surfaces coincide by construction.
+  vec2 local = position.xz + aCoarse * aMorph;
+
+  vec3 flatPos = vec3(local.x, 0.0, local.y);
+  vec4 worldFlat = modelMatrix * vec4(flatPos, 1.0);
+  vec2 wxz = worldFlat.xz;
+
+  // The LOD cell morphs with the vertex, so a ring's outer edge samples at
+  // exactly the next ring's cell size and both sides of the seam fade the same
+  // components by the same amount.
+  float cellLod = aCell * (1.0 + aMorph);
+
+  float edge = oceanEdgeMask(local);
+
+  // Where the wave field is evaluated. The world ocean is evaluated in world XZ,
+  // because its clipmap slides under a camera that moves through the world and
+  // the sea must not slide with it. A placed body is evaluated in its OWN space,
+  // so its waves rotate with it and stay inside its rim.
+  bool isBody = u_bodyHalf.x > 0.0;
+  vec2 fieldXZ = isBody ? local : wxz;
+
+  vec3 disp; vec3 nrm; float jac; float rel;
+  oceanWaveSum(fieldXZ, cellLod, u_amplitudeScale * edge, disp, nrm, jac, rel);
+
+  vFoam = oceanFoam(jac, rel, vec3(fieldXZ.x, 0.0, fieldXZ.y));
+  vRelHeight = rel;
+
+  // Open water until the refraction grab lands; the shoreline reads its depth
+  // from that, and from the terrain field when it is included.
+  vDepthFactor = 1.0;
+
+  // Displacement is in field space, which for both hosts is object space up to a
+  // translation - so it can be added to transformed directly. Deriving it from
+  // a world position instead would need inverse(modelMatrix), which GLSL ES 1.00
+  // does not have, and three compiles these as ES 1.00.
+  vec3 transformed = vec3(local.x + disp.x, disp.y, local.y + disp.z);
+
+  // Planetary curvature, applied here and only here, and only to the world
+  // ocean. It is a view-relative bend, so folding it into the surface itself
+  // would make the water move when the camera does; and a swimming pool does not
+  // need a horizon.
+  if (!isBody) {
+    vec2 fromCam = wxz - cameraPosition.xz;
+    transformed.y -= u_curvature * dot(fromCam, fromCam);
+  }
+
+  vec3 world = (modelMatrix * vec4(transformed, 1.0)).xyz;
+  vNormal_ = normalize(mat3(modelMatrix) * normalize(mix(vec3(0.0, 1.0, 0.0), nrm, edge)));
+
+  vWorld = world;
+  vDist = distance(world, cameraPosition);
+
+  vec3 objectNormal = vec3(0.0, 1.0, 0.0);
+  vec3 transformedNormal = normalMatrix * objectNormal;
+
+  vec4 mvPosition = modelViewMatrix * vec4(transformed, 1.0);
+  gl_Position = projectionMatrix * mvPosition;
+
+  #include <worldpos_vertex>
+  #include <shadowmap_vertex>
+  #include <fog_vertex>
+}
+`;
+const fragment = /* glsl */ `
+#include <common>
+#include <packing>
+#include <fog_pars_fragment>
+// lights_pars_begin declares the bool uniform receiveShadow that
+// shadowmask_pars_fragment reads. Include the shadow chunks without it and the
+// shader fails to compile with 'undeclared identifier: receiveShadow', and the
+// material renders black with nothing but a console error to say why.
+#include <lights_pars_begin>
+#include <shadowmap_pars_fragment>
+#include <shadowmask_pars_fragment>
+
+${skyLib}
+${oceanFull}
+
+varying vec3  vWorld;
+varying vec3  vNormal_;
+varying float vFoam;
+varying float vRelHeight;
+varying float vDist;
+varying float vDepthFactor;
+
+void main(){
+  vec3 viewDir = normalize(vWorld - cameraPosition);
+
+  vec3 n = normalize(vNormal_);
+  float detail = oceanDetailFade(vDist);
+  n = oceanDetailNormal(n, vWorld, detail);
+
+  // Backfacing water is water seen from underneath. Flipping the normal keeps
+  // the shading sane there until the underwater pass exists.
+  if (!gl_FrontFacing) n = -n;
+
+  // Geometric specular antialiasing (Kaplanyan/Tokuyoshi): measure how much the
+  // shading normal turns across this pixel and widen the specular lobe by that
+  // much. On water this is not a nicety - the mesh carries waves down to a
+  // couple of cells and the lobe is tight enough that every crest facet flashes
+  // on and off between frames. Filtering the normal instead of softening the
+  // water keeps the glitter and loses the boil.
+  vec3 nDx = dFdx(n);
+  vec3 nDy = dFdy(n);
+  float normalVar = 0.5 * (dot(nDx, nDx) + dot(nDy, nDy));
+  float roughAA = min(sqrt(normalVar) * 0.8, 0.25);
+  // Detail the fade removed was real roughness; hand it to the lobe rather than
+  // deleting it, or distant water turns to plastic.
+  roughAA += (1.0 - detail) * u_detailStrength * 0.06;
+
+  float sceneShadow = 1.0;
+  #ifdef USE_SHADOWMAP
+    sceneShadow = mix(1.0, getShadowMask(), u_receiveShadows);
+  #endif
+
+  vec3 col = oceanLight(vWorld, n, viewDir, vFoam, vRelHeight, sceneShadow, vDepthFactor, roughAA, vec3(0.0));
+  col = oceanAerial(col, viewDir, vDist);
+  col *= u_exposure;
+
+  gl_FragColor = vec4(col, 1.0);
+
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+  #include <fog_fragment>
+}
+`;
+function emptyWaveTable() {
+    return Array.from({ length: MAX_WAVES }, () => new THREE.Vector4());
+}
+/** Uniform-space defaults. Config units are converted by `applyOceanUniforms`;
+ *  these are only what the material holds before anything is applied. */
+export const oceanMaterialDefaults = {
+    u_waveA: emptyWaveTable(),
+    u_waveB: emptyWaveTable(),
+    u_waveCount: 0,
+    u_time: 0,
+    u_waterLevel: 0,
+    u_choppiness: 0.85,
+    u_amplitudeScale: 1,
+    u_bodyHalf: new THREE.Vector2(0, 0),
+    u_edgeFade: 0.15,
+    u_deepColor: new THREE.Color('#052539'),
+    u_shallowColor: new THREE.Color('#1b7f8c'),
+    u_foamColor: new THREE.Color('#eef6f8'),
+    u_sssColor: new THREE.Color('#2f8f74'),
+    u_absorption: 0.06,
+    u_clarity: 0.25,
+    u_roughness: 0.09,
+    u_specular: 1,
+    u_sssStrength: 0.7,
+    u_detailStrength: 0.55,
+    u_detailScale: 1 / 2.2,
+    u_detailFade: 1 / 900,
+    u_pixelScale: 0.0026,
+    u_foamAmount: 0.8,
+    u_foamDecay: 0.5,
+    u_foamScale: 1 / 6,
+    u_ambientScale: 1,
+    u_fogDensity: 0.00009,
+    u_exposure: 1,
+    u_curvature: 1 / (2 * 6371000),
+    u_receiveShadows: 1,
+    // Shared with the cloud and terrain materials, set by the same
+    // applySunUniforms() off the same useCloudSun state.
+    u_sunDir: new THREE.Vector3(0.35, 0.42, 0.84).normalize(),
+    u_sunColor: new THREE.Color(1, 1, 1),
+    u_skyAmbient: new THREE.Color(0.6, 0.9, 1.6),
+    u_groundAmbient: new THREE.Color(0.45, 0.42, 0.37),
+    u_sunIntensity: 1,
+    u_turbidity: 2,
+    u_rayleigh: 1,
+    u_mieCoefficient: 0.005,
+    u_mieG: 0.76,
+};
+function buildUniforms() {
+    const own = {};
+    for (const [key, value] of Object.entries(oceanMaterialDefaults)) {
+        own[key] = { value };
+    }
+    // The lights block first, so a name collision would resolve to ours; there
+    // are none, because everything of ours is u_-prefixed.
+    return THREE.UniformsUtils.merge([
+        THREE.UniformsLib.lights,
+        THREE.UniformsLib.fog,
+        own,
+    ]);
+}
+export class OceanSurfaceMaterial extends THREE.ShaderMaterial {
+    constructor() {
+        super({
+            uniforms: buildUniforms(),
+            vertexShader: vertex,
+            fragmentShader: fragment,
+            lights: true,
+            fog: true,
+        });
+        // Both sides: the camera goes under the surface, and a placed body is
+        // routinely looked into from above its own rim.
+        this.side = THREE.DoubleSide;
+    }
+}
+extend({ OceanSurfaceMaterial });

package/dist/shaders/terrain/TerrainMaterial.d.ts

@@ -0,0 +1,80 @@
+import * as THREE from 'three';
+import { type ThreeElement } from '@react-three/fiber';
+export interface TerrainMaterialUniforms {
+    [key: string]: THREE.IUniform;
+}
+/** Uniform-space defaults. Config units are converted by `applyTerrainUniforms`;
+ *  these are only what the material holds before anything is applied. */
+export declare const terrainMaterialDefaults: {
+    u_terrainType: number;
+    u_elevation: number;
+    u_seaLevel: number;
+    u_baseScale: number;
+    u_octaves: number;
+    u_lacunarity: number;
+    u_gain: number;
+    u_ridge: number;
+    u_warpStrength: number;
+    u_warpScale: number;
+    u_erosion: number;
+    u_terraces: number;
+    u_terraceSharp: number;
+    u_bearingDir: THREE.Vector2;
+    u_duneFreq: number;
+    u_duneAsym: number;
+    u_plateau: number;
+    u_valleyDepth: number;
+    u_valleyWidth: number;
+    u_cellSize: number;
+    u_curvature: number;
+    u_lowColor: THREE.Color;
+    u_midColor: THREE.Color;
+    u_rockColor: THREE.Color;
+    u_peakColor: THREE.Color;
+    u_slopeRockStart: number;
+    u_slopeRockEnd: number;
+    u_peakLevel: number;
+    u_peakBlend: number;
+    u_peakSlopeFalloff: number;
+    u_macroVariation: number;
+    u_macroScale: number;
+    u_detailStrength: number;
+    u_detailScale: number;
+    u_detailFade: number;
+    u_roughness: number;
+    u_specular: number;
+    u_ambient: number;
+    u_bounce: number;
+    u_sunShadow: number;
+    u_shadowSoftness: number;
+    u_shadowDistance: number;
+    u_fogDensity: number;
+    u_exposure: number;
+    u_shadowSteps: number;
+    u_receiveShadows: number;
+    u_sunDir: THREE.Vector3;
+    u_sunColor: THREE.Color;
+    u_skyAmbient: THREE.Color;
+    u_groundAmbient: THREE.Color;
+    u_sunIntensity: number;
+    u_turbidity: number;
+    u_rayleigh: number;
+    u_mieCoefficient: number;
+    u_mieG: number;
+};
+/**
+ * `UniformsUtils.merge` clones by `Uniform.clone()`, which deep-copies Colors and
+ * Vectors but turns a plain object into a shallow copy — fine here, since every
+ * own uniform is a number, Color or Vector. The lights block must come first so
+ * a name collision would resolve to ours; there are none, because everything of
+ * ours is `u_`-prefixed.
+ */
+export declare class TerrainMaterial extends THREE.ShaderMaterial {
+    constructor();
+}
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        terrainMaterial: ThreeElement<typeof TerrainMaterial>;
+    }
+}
+//# sourceMappingURL=TerrainMaterial.d.ts.map

package/dist/shaders/terrain/TerrainMaterial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TerrainMaterial.d.ts","sourceRoot":"","sources":["../../../src/shaders/terrain/TerrainMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,EAAU,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAyM9D,MAAM,WAAW,uBAAuB;IACpC,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,QAAQ,CAAA;CAChC;AAED;yEACyE;AACzE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgEnC,CAAA;AAcD;;;;;;GAMG;AACH,qBAAa,eAAgB,SAAQ,KAAK,CAAC,cAAc;;CAWxD;AAID,OAAO,QAAQ,oBAAoB,CAAC;IAChC,UAAU,aAAa;QACnB,eAAe,EAAE,YAAY,CAAC,OAAO,eAAe,CAAC,CAAA;KACxD;CACJ"}