@zephyr3d/scene 0.9.27 → 0.10.0

package/dist/utility/serialization/scene/water.js

@@ -1,18 +1,19 @@
 import { Vector2, Vector3 } from '@zephyr3d/base';
 import '../../../scene/scene.js';
-import { MAX_GERSTNER_WAVE_COUNT } from '../../../values.js';
-import '../../../render/render_queue.js';
 import '../../../render/primitive.js';
 import '@zephyr3d/device';
+import { MAX_GERSTNER_WAVE_COUNT } from '../../../values.js';
+import '../../../render/render_queue.js';
 import '../../../material/shader/helper.js';
 import '../../../material/lambert.js';
 import '../../../material/blinn.js';
 import '../../../material/unlit.js';
+import '../../../material/meshmaterial.js';
 import '../../../material/particle.js';
 import '../../../material/subsurfaceprofile.js';
-import '../../../material/skin.js';
+import '../../../material/sssprofile.js';
+import '../../../material/sss.js';
 import '../../../material/eye.js';
-import '../../../material/meshmaterial.js';
 import '../../../material/hair.js';
 import '../../../material/hairstrand.js';
 import '../../../material/grassmaterial.js';
@@ -30,11 +31,16 @@ import '../../../render/lightpass.js';
 import '../../../render/sky.js';
 import '../../../render/clipmap.js';
 import '../../../render/envlight.js';
+import '../../../render/lod.js';
 import '../../../render/dualdepthpeeling_oit.js';
 import { FFTWaveGenerator } from '../../../render/fft_wavegenerator.js';
 import { GerstnerWaveGenerator } from '../../../render/gerstner_wavegenerator.js';
 import { FBMWaveGenerator } from '../../../render/fbm_wavegenerator.js';
+import { WaterInteraction, WaterDisturber } from '../../../render/water_interaction.js';
 import '../../../render/rendergraph/scene_render_context.js';
+import '../../../render/sdf/scene_sdf.js';
+import '../../../render/sdf/global_sdf.js';
+import '../../../render/gi/voxelize_pass.js';
 import { GraphNode } from '../../../scene/graph_node.js';
 import '../../../shadow/shadowmapper.js';
 import '../../../scene/mesh.js';
@@ -49,6 +55,7 @@ import '../../../scene/batchgroup.js';
 import '../../../scene/terrain-cm/terrain-cm.js';
 import '../../../scene/terrain-cm/grass.js';
 import '../../../scene/raycast_visitor.js';
+import '../../../scene/foliage.js';
 import { WATER_DEBUG_OUTPUTS, DEFAULT_SCATTER_ANISOTROPY } from '../../../material/water.js';
 
 /** @internal */ function getFBMWaveGeneratorClass() {
@@ -201,31 +208,6 @@ import { WATER_DEBUG_OUTPUTS, DEFAULT_SCATTER_ANISOTROPY } from '../../../materi
                         this.foamContrast = value.num[0];
                     }
                 },
-                {
-                    name: 'WaveLengthCascades',
-                    description: 'Wavelength values for the three FFT wave cascades',
-                    type: 'vec3',
-                    default: [
-                        400,
-                        100,
-                        15
-                    ],
-                    options: {
-                        animatable: true,
-                        minValue: 0,
-                        maxValue: 1000
-                    },
-                    get (value) {
-                        value.num[0] = this.getWaveLength(0);
-                        value.num[1] = this.getWaveLength(1);
-                        value.num[2] = this.getWaveLength(2);
-                    },
-                    set (value) {
-                        this.setWaveLength(0, value.num[0]);
-                        this.setWaveLength(1, value.num[1]);
-                        this.setWaveLength(2, value.num[2]);
-                    }
-                },
                 {
                     name: 'WaveStrengthCascades',
                     description: 'Strength values for the three FFT wave cascades',
@@ -233,7 +215,7 @@ import { WATER_DEBUG_OUTPUTS, DEFAULT_SCATTER_ANISOTROPY } from '../../../materi
                     default: [
                         0.4,
                         0.4,
-                        0.2
+                        0.4
                     ],
                     options: {
                         animatable: true,
@@ -381,17 +363,12 @@ import { WATER_DEBUG_OUTPUTS, DEFAULT_SCATTER_ANISOTROPY } from '../../../materi
  * A single Gerstner wave, as the editor sees one entry of the
  * `Waves` object array on a {@link GerstnerWaveGenerator}.
  *
- * It behaves as a live view while it is bound: the field setters write the new
- * value straight through to the generator's wave buffer, which is what makes an
- * edit in the property panel take effect on the water immediately. Without that
- * the editor would only touch this object's own fields and the surface would
- * keep the previous wave until something else bumped the generator's version.
+ * While bound it is a live view: the field setters write straight through to
+ * the generator's wave buffer, so a property panel edit takes effect at once.
  *
- * The binding is transient and scoped to one editor session: `_owner` and
- * `_index` are set when the `Waves` getter builds the entry, and the editor
- * rebuilds the whole array from that getter after every add/delete. A copy that
- * survives a list mutation is never reused, so the cached index cannot drift
- * onto a different wave - the same reason it is safe to write through with it.
+ * The binding is transient: `_owner` and `_index` are set when the `Waves`
+ * getter builds the entry, and the editor rebuilds the array from that getter
+ * after every add/delete, so the cached index never drifts onto another wave.
  */ class GerstnerWave {
     _owner;
     _index;
@@ -439,10 +416,8 @@ import { WATER_DEBUG_OUTPUTS, DEFAULT_SCATTER_ANISOTROPY } from '../../../materi
     /**
    * Writes this object's values into slot `index` of `owner`, unconditionally.
    *
-   * Used by the `Waves` setter for a serialised-in array, whose entries were
-   * constructed without an owner, and by `add` for a freshly created one. It is
-   * distinct from the write-through in the field setters, which fire on each
-   * individual edit.
+   * Used by the `Waves` setter for a deserialized array, whose entries have no
+   * owner, and by `add` for a freshly created one.
    * @internal
    */ applyTo(owner, index) {
         owner.setWaveDirection(index, this._direction);
@@ -619,6 +594,384 @@ import { WATER_DEBUG_OUTPUTS, DEFAULT_SCATTER_ANISOTROPY } from '../../../materi
         }
     };
 }
+/**
+ * Inspector layout of the water's properties: group (sub-groups after a
+ * slash) and label of each, in the order the groups are shown; the inspector
+ * opens the groups marked open. Presentation only; serialized names are unaffected.
+ */ const WATER_PROPERTY_LAYOUT = [
+    {
+        group: 'Surface',
+        open: true,
+        props: [
+            [
+                'WaveGenerator',
+                'Wave Generator'
+            ],
+            [
+                'Interaction',
+                'Interaction'
+            ],
+            [
+                'AnimationSpeed',
+                'Animation Speed'
+            ],
+            [
+                'Infinite',
+                'Infinite'
+            ]
+        ]
+    },
+    {
+        group: 'Water Color',
+        open: true,
+        props: [
+            [
+                'Absorption',
+                'Absorption'
+            ],
+            [
+                'AbsorptionScale',
+                'Absorption Scale'
+            ],
+            [
+                'Scattering',
+                'Scattering'
+            ],
+            [
+                'ScatteringScale',
+                'Scattering Scale'
+            ]
+        ]
+    },
+    {
+        group: 'Lighting',
+        props: [
+            [
+                'ReflectionStrength',
+                'Reflection'
+            ],
+            [
+                'SunScatteringIntensity',
+                'Sun Scattering'
+            ],
+            [
+                'ScatterAnisotropy',
+                'Sun Scattering Anisotropy'
+            ],
+            [
+                'SubsurfaceIntensity',
+                'Crest Glow'
+            ],
+            [
+                'SubsurfaceCrestHeight',
+                'Crest Glow Height'
+            ],
+            [
+                'SubsurfaceTint',
+                'Crest Glow Tint'
+            ]
+        ]
+    },
+    {
+        group: 'Refraction',
+        props: [
+            [
+                'RefractionMode',
+                'Mode'
+            ],
+            [
+                'RefractionScale',
+                'Strength'
+            ],
+            [
+                'RefractionBlur',
+                'Blur'
+            ],
+            [
+                'CheapRefractionDepth',
+                'Offset Depth'
+            ]
+        ]
+    },
+    {
+        group: 'Foam',
+        props: [
+            [
+                'FoamAmount',
+                'Wave Foam'
+            ],
+            [
+                'FoamColor',
+                'Color'
+            ],
+            [
+                'FoamTexture',
+                'Texture'
+            ],
+            [
+                'FoamTextureSize',
+                'Texture Size'
+            ],
+            [
+                'FoamFeather',
+                'Edge Softness'
+            ]
+        ]
+    },
+    {
+        group: 'Foam/Look',
+        props: [
+            [
+                'FoamFalloff',
+                'Wave Foam Falloff'
+            ],
+            [
+                'FoamNormalStrength',
+                'Relief'
+            ],
+            [
+                'FoamBubbleColor',
+                'Bubble Color'
+            ],
+            [
+                'FoamBubbleCoverage',
+                'Bubbles'
+            ],
+            [
+                'FoamBubbleDepth',
+                'Bubble Depth'
+            ]
+        ]
+    },
+    {
+        group: 'Foam/Trails',
+        props: [
+            [
+                'FoamTrailStrength',
+                'Strength'
+            ],
+            [
+                'FoamFadeRate',
+                'Fade Rate'
+            ],
+            [
+                'FoamDrift',
+                'Wind Drift'
+            ],
+            [
+                'FoamFieldSize',
+                'Range'
+            ]
+        ]
+    },
+    {
+        group: 'Shore',
+        props: [
+            [
+                'EdgeFadeWidth',
+                'Edge Fade'
+            ]
+        ]
+    },
+    {
+        group: 'Shore/Waves',
+        props: [
+            [
+                'ShoreWaveHeight',
+                'Height'
+            ],
+            [
+                'ShoreWaveLength',
+                'Wavelength'
+            ],
+            [
+                'ShoreWavePeriod',
+                'Period'
+            ],
+            [
+                'ShoreWaveZone',
+                'Zone'
+            ],
+            [
+                'ShoreWaveSharpness',
+                'Sharpness'
+            ],
+            [
+                'ShoreWaveLean',
+                'Lean'
+            ],
+            [
+                'ShoreWaveIrregularity',
+                'Irregularity'
+            ]
+        ]
+    },
+    {
+        group: 'Shore/Waves/Foam',
+        props: [
+            [
+                'ShoreWaveFoamStrength',
+                'Breaking Foam'
+            ],
+            [
+                'ShoreWaveFoamCoverage',
+                'Breaking Coverage'
+            ],
+            [
+                'ShoreWaveShallowFoamStrength',
+                'Shallow Foam'
+            ],
+            [
+                'ShoreWaveShallowFoamDepth',
+                'Shallow Depth'
+            ],
+            [
+                'WallFoamStrength',
+                'Wall Foam'
+            ],
+            [
+                'WallFoamMinSpeed',
+                'Wall Min Speed'
+            ],
+            [
+                'WallFoamMaxSpeed',
+                'Wall Max Speed'
+            ],
+            [
+                'WallFoamDrift',
+                'Wall Foam Spread'
+            ]
+        ]
+    },
+    {
+        group: 'Caustics',
+        props: [
+            [
+                'CausticsEnabled',
+                'Enabled'
+            ],
+            [
+                'CausticsIntensity',
+                'Intensity'
+            ],
+            [
+                'CausticsDepth',
+                'Depth'
+            ],
+            [
+                'CausticsRange',
+                'Range'
+            ],
+            [
+                'CausticsFadeDistance',
+                'Fade Distance'
+            ],
+            [
+                'CausticsSceneDepth',
+                'Scene Depth'
+            ],
+            [
+                'CausticsWarp',
+                'Warp'
+            ],
+            [
+                'CausticsMinDepth',
+                'Min Depth'
+            ]
+        ]
+    },
+    {
+        group: 'Underwater',
+        props: [
+            [
+                'UnderwaterEnabled',
+                'Enabled'
+            ],
+            [
+                'UnderwaterAmbientIntensity',
+                'Ambient'
+            ],
+            [
+                'UnderwaterGodRays',
+                'God Rays'
+            ],
+            [
+                'UnderwaterGodRayIntensity',
+                'God Ray Intensity'
+            ],
+            [
+                'UnderwaterGodRaySteps',
+                'God Ray Steps'
+            ],
+            [
+                'UnderwaterGodRayShadow',
+                'God Ray Shadow'
+            ],
+            [
+                'UnderwaterHysteresis',
+                'Surface Hysteresis'
+            ]
+        ]
+    },
+    {
+        group: 'Advanced',
+        props: [
+            [
+                'ViewDistance',
+                'View Distance'
+            ],
+            [
+                'GridScale',
+                'Grid Scale'
+            ],
+            [
+                'TAAStrength',
+                'TAA Strength'
+            ],
+            [
+                'Wireframe',
+                'Wireframe'
+            ],
+            [
+                'DebugOutput',
+                'Debug Output'
+            ]
+        ]
+    }
+];
+/** Gives the water's properties their group and label, ordered as {@link WATER_PROPERTY_LAYOUT}. */ function layoutWaterProps(props) {
+    const placement = new Map();
+    let order = 0;
+    for (const entry of WATER_PROPERTY_LAYOUT){
+        for (const [name, label] of entry.props){
+            placement.set(name, {
+                order: order++,
+                group: entry.group,
+                label,
+                open: !!entry.open
+            });
+        }
+    }
+    for (const prop of props){
+        const place = placement.get(prop.name);
+        if (place) {
+            prop.options = {
+                ...prop.options,
+                group: place.group,
+                label: prop.options?.label ?? place.label,
+                ...place.open ? {
+                    defaultOpen: true
+                } : {}
+            };
+        }
+    }
+    // Stable: anything left out of the layout keeps its place after the rest
+    return props.map((prop, index)=>({
+            prop,
+            index,
+            order: placement.get(prop.name)?.order ?? order + index
+        })).sort((a, b)=>a.order - b.order).map((e)=>e.prop);
+}
 /** @internal */ function getWaterClass(manager) {
     return {
         ctor: Water,
@@ -632,7 +985,7 @@ import { WATER_DEBUG_OUTPUTS, DEFAULT_SCATTER_ANISOTROPY } from '../../../materi
             };
         },
         getProps () {
-            return defineProps([
+            return layoutWaterProps(defineProps([
                 {
                     name: 'WaveGenerator',
                     description: 'Wave generator used to drive the water surface',
@@ -659,6 +1012,26 @@ import { WATER_DEBUG_OUTPUTS, DEFAULT_SCATTER_ANISOTROPY } from '../../../materi
                         }
                     }
                 },
+                {
+                    name: 'Interaction',
+                    description: 'Dynamic height field layered over the surface, driven by things moving through the water: ripples, wakes and a foam trail. Null for none.',
+                    type: 'object',
+                    default: null,
+                    options: {
+                        objectTypes: [
+                            WaterInteraction
+                        ]
+                    },
+                    isNullable () {
+                        return true;
+                    },
+                    get (value) {
+                        value.object[0] = this.interaction ?? null;
+                    },
+                    set (value) {
+                        this.interaction = value.object[0] ?? null;
+                    }
+                },
                 {
                     name: 'GridScale',
                     description: 'Scale of the water simulation grid',
@@ -856,6 +1229,26 @@ import { WATER_DEBUG_OUTPUTS, DEFAULT_SCATTER_ANISOTROPY } from '../../../materi
                         this.causticsWarp = value.num[0];
                     }
                 },
+                {
+                    name: 'CausticsMinDepth',
+                    description: "Water shallower than this, in metres, shows no caustics, fading in around it: raise it if dark or jagged caustic patches appear where the water thins out on a beach, lower it to bring the light patterns closer to the water's edge.",
+                    type: 'float',
+                    default: 0.15,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 2
+                    },
+                    isHidden () {
+                        return !this.causticsEnabled;
+                    },
+                    get (value) {
+                        value.num[0] = this.causticsMinDepth;
+                    },
+                    set (value) {
+                        this.causticsMinDepth = value.num[0];
+                    }
+                },
                 {
                     name: 'UnderwaterEnabled',
                     description: 'Whether a camera inside this water sees it from the inside: the medium over the whole scene, the sky replaced by water, and the surface read from below with its Snell window. Atmospheric fog is suppressed while submerged.',
@@ -976,30 +1369,6 @@ import { WATER_DEBUG_OUTPUTS, DEFAULT_SCATTER_ANISOTROPY } from '../../../materi
                         this.underwaterHysteresis = value.num[0];
                     }
                 },
-                {
-                    name: 'MediumMode',
-                    description: 'How the water medium attenuates light: physical coefficients, or the legacy ramp textures',
-                    type: 'string',
-                    default: 'physical',
-                    options: {
-                        enum: {
-                            labels: [
-                                'Physical',
-                                'Ramp'
-                            ],
-                            values: [
-                                'physical',
-                                'ramp'
-                            ]
-                        }
-                    },
-                    get (value) {
-                        value.str[0] = this.material.mediumMode;
-                    },
-                    set (value) {
-                        this.material.mediumMode = value.str[0];
-                    }
-                },
                 {
                     name: 'RefractionMode',
                     description: 'How the refracted view sample is located. March walks the refracted ray against the scene depth and samples where it lands, which keeps the sample on the object behind the water; Offset skips the search and displaces the screen UV by the wave normal, which costs no depth fetches but samples the wrong point. Use Offset on hardware that cannot afford the search.',
@@ -1056,9 +1425,6 @@ import { WATER_DEBUG_OUTPUTS, DEFAULT_SCATTER_ANISOTROPY } from '../../../materi
                         minValue: 0,
                         maxValue: 10
                     },
-                    isHidden () {
-                        return this.material.mediumMode !== 'physical';
-                    },
                     get (value) {
                         value.num[0] = this.material.absorption.x;
                         value.num[1] = this.material.absorption.y;
@@ -1078,9 +1444,6 @@ import { WATER_DEBUG_OUTPUTS, DEFAULT_SCATTER_ANISOTROPY } from '../../../materi
                         minValue: 0,
                         maxValue: 10
                     },
-                    isHidden () {
-                        return this.material.mediumMode !== 'physical';
-                    },
                     get (value) {
                         value.num[0] = this.material.absorptionScale;
                     },
@@ -1102,9 +1465,6 @@ import { WATER_DEBUG_OUTPUTS, DEFAULT_SCATTER_ANISOTROPY } from '../../../materi
                         minValue: 0,
                         maxValue: 10
                     },
-                    isHidden () {
-                        return this.material.mediumMode !== 'physical';
-                    },
                     get (value) {
                         value.num[0] = this.material.scattering.x;
                         value.num[1] = this.material.scattering.y;
@@ -1124,9 +1484,6 @@ import { WATER_DEBUG_OUTPUTS, DEFAULT_SCATTER_ANISOTROPY } from '../../../materi
                         minValue: 0,
                         maxValue: 10
                     },
-                    isHidden () {
-                        return this.material.mediumMode !== 'physical';
-                    },
                     get (value) {
                         value.num[0] = this.material.scatteringScale;
                     },
@@ -1134,26 +1491,6 @@ import { WATER_DEBUG_OUTPUTS, DEFAULT_SCATTER_ANISOTROPY } from '../../../materi
                         this.material.scatteringScale = value.num[0];
                     }
                 },
-                {
-                    name: 'DepthScale',
-                    description: 'Depth attenuation scale for the water material (ramp medium only)',
-                    type: 'float',
-                    default: 10,
-                    options: {
-                        animatable: true,
-                        minValue: 0,
-                        maxValue: 100
-                    },
-                    isHidden () {
-                        return this.material.mediumMode !== 'ramp';
-                    },
-                    get (value) {
-                        value.num[0] = this.material.depthMulti;
-                    },
-                    set (value) {
-                        this.material.depthMulti = value.num[0];
-                    }
-                },
                 {
                     name: 'ReflectionStrength',
                     description: 'Scale on the Fresnel reflectance, 1 for the physical value. Lower it to trade the reflection away and show more of what is beneath the surface.',
@@ -1175,7 +1512,7 @@ import { WATER_DEBUG_OUTPUTS, DEFAULT_SCATTER_ANISOTROPY } from '../../../materi
                     name: 'SubsurfaceIntensity',
                     description: 'Strength of the sunlight scattered forward through a wave crest, which is what makes a backlit crest glow. Grazing views of a low sun show it; looking down at the water does not.',
                     type: 'float',
-                    default: 1.5,
+                    default: 0.5,
                     options: {
                         animatable: true,
                         minValue: 0,
@@ -1189,20 +1526,43 @@ import { WATER_DEBUG_OUTPUTS, DEFAULT_SCATTER_ANISOTROPY } from '../../../materi
                     }
                 },
                 {
-                    name: 'SubsurfaceSteepness',
-                    description: 'How sharply surface tilt gates the subsurface glow. Higher makes gentle swell glow too; lower restricts it to steep wave flanks.',
+                    name: 'SubsurfaceCrestHeight',
+                    description: 'Height above the still-water level, in meters, over which the lit wall of a crest thins by a factor of e. Crests are thin and glow; troughs see the full path through the medium and are absorbed, so they keep only a tinted trace. Lower it for a calm sea whose crests barely rise, raise it so only the tallest waves light up.',
                     type: 'float',
-                    default: 60,
+                    default: 1.5,
+                    options: {
+                        animatable: true,
+                        minValue: 0.05,
+                        maxValue: 10
+                    },
+                    get (value) {
+                        value.num[0] = this.material.subsurfaceCrestHeight;
+                    },
+                    set (value) {
+                        this.material.subsurfaceCrestHeight = value.num[0];
+                    }
+                },
+                {
+                    name: 'SubsurfaceTint',
+                    description: 'Colour of the crest glow, before the crest gate tints it with the medium extinction. A warm yellow-green keeps some red on the crests where the troughs have lost it.',
+                    type: 'rgb',
+                    default: [
+                        0.86,
+                        0.98,
+                        0.71
+                    ],
                     options: {
                         animatable: true,
                         minValue: 0,
-                        maxValue: 100
+                        maxValue: 1
                     },
                     get (value) {
-                        value.num[0] = this.material.subsurfaceSteepness;
+                        value.num[0] = this.material.subsurfaceTint.x;
+                        value.num[1] = this.material.subsurfaceTint.y;
+                        value.num[2] = this.material.subsurfaceTint.z;
                     },
                     set (value) {
-                        this.material.subsurfaceSteepness = value.num[0];
+                        this.material.subsurfaceTint = new Vector3(value.num[0], value.num[1], value.num[2]);
                     }
                 },
                 {
@@ -1224,7 +1584,7 @@ import { WATER_DEBUG_OUTPUTS, DEFAULT_SCATTER_ANISOTROPY } from '../../../materi
                 },
                 {
                     name: 'FoamAmount',
-                    description: 'Coverage of the foam on breaking wave crests, mapped from the folding the wave generator reports. 0 disables crest foam. Independent of ShoreFoamAmount.',
+                    description: 'Coverage of the foam on breaking wave crests, mapped from the folding the wave generator reports. 0 disables crest foam.',
                     type: 'float',
                     default: 1,
                     options: {
@@ -1283,295 +1643,1214 @@ import { WATER_DEBUG_OUTPUTS, DEFAULT_SCATTER_ANISOTROPY } from '../../../materi
                     }
                 },
                 {
-                    name: 'ShoreFoamAmount',
-                    description: 'Coverage of the foam that collects where the water meets a surface - the waterline on a shelving bed, and the collar around a piling or a hull. 0 disables it, which also removes its cost. Independent of the crest foam the wave generator produces. Requires WebGL2 or WebGPU.',
+                    name: 'FoamFeather',
+                    description: 'How the white foam ends at its edges: low values cut crisp, separate clumps with hard outlines; high values let the foam thin out gradually into the bubbles beneath. Shared by all foam.',
                     type: 'float',
-                    default: 0,
-                    // Deliberately not animatable: crossing zero switches the whole
-                    // feature in and out of the shader, so an animation curve driving this
-                    // through zero rebuilds the program on the way past.
+                    default: 0.4,
                     options: {
-                        minValue: 0,
-                        maxValue: 4
+                        animatable: true,
+                        minValue: 0.001,
+                        maxValue: 1
                     },
                     get (value) {
-                        value.num[0] = this.shoreFoamAmount;
+                        value.num[0] = this.material.foamFeather;
                     },
                     set (value) {
-                        this.shoreFoamAmount = value.num[0];
+                        this.material.foamFeather = value.num[0];
                     }
                 },
                 {
-                    name: 'ShoreFoamDepth',
-                    description: 'How far the foam band reaches from the surface behind it, in meters. Over a bed this is a depth of water; against something vertical it is the horizontal distance to its side, and one value serves both. How wide that is on screen depends on the geometry: a thin line on a steep drop-off, a broad stretch on a flat shelf.',
+                    name: 'FoamNormalStrength',
+                    description: 'How lumpy the white foam looks: higher values light it as a heaped-up relief with bright rims towards the sun and shaded hollows; 0 lights it as a flat sheet.',
                     type: 'float',
-                    default: 0.5,
+                    default: 3.5,
                     options: {
                         animatable: true,
-                        minValue: 0.001,
-                        maxValue: 20
-                    },
-                    isHidden () {
-                        return this.shoreFoamAmount <= 0;
+                        minValue: 0,
+                        maxValue: 30
                     },
                     get (value) {
-                        value.num[0] = this.shoreFoamDepth;
+                        value.num[0] = this.material.foamNormalStrength;
                     },
                     set (value) {
-                        this.shoreFoamDepth = value.num[0];
+                        this.material.foamNormalStrength = value.num[0];
                     }
                 },
                 {
-                    name: 'ShoreFoamFalloff',
-                    description: 'Falloff across the foam band. Above 1 pushes the coverage towards the contact line and keeps the outer edge thin and broken.',
-                    type: 'float',
-                    default: 1.5,
+                    name: 'FoamBubbleColor',
+                    description: 'Tint of the cloud of bubbles under and around the white foam, which gives it a soft, milky halo in the water instead of a cut-out edge.',
+                    type: 'rgb',
+                    default: [
+                        0.64,
+                        0.83,
+                        0.82
+                    ],
                     options: {
                         animatable: true,
-                        minValue: 0.01,
-                        maxValue: 8
-                    },
-                    isHidden () {
-                        return this.shoreFoamAmount <= 0;
+                        minValue: 0,
+                        maxValue: 1
                     },
                     get (value) {
-                        value.num[0] = this.shoreFoamFalloff;
+                        value.num[0] = this.material.foamBubbleColor.x;
+                        value.num[1] = this.material.foamBubbleColor.y;
+                        value.num[2] = this.material.foamBubbleColor.z;
                     },
                     set (value) {
-                        this.shoreFoamFalloff = value.num[0];
+                        this.material.foamBubbleColor = new Vector3(value.num[0], value.num[1], value.num[2]);
                     }
                 },
                 {
-                    name: 'ShoreFoamScale',
-                    description: 'Size of the clumps the band breaks into, as cycles across the band rather than cycles per meter. Being relative to the band width, one value reads the same on a shoreline metres across and on a collar a handspan wide.',
+                    name: 'FoamBubbleCoverage',
+                    description: 'How strongly the bubble cloud shows and how far it reaches past the white foam, lightening the water around it. 0 removes it, leaving only the white foam.',
                     type: 'float',
-                    default: 2.5,
+                    default: 1.68,
                     options: {
                         animatable: true,
                         minValue: 0,
-                        maxValue: 20
-                    },
-                    isHidden () {
-                        return this.shoreFoamAmount <= 0;
+                        maxValue: 5
                     },
                     get (value) {
-                        value.num[0] = this.shoreFoamScale;
+                        value.num[0] = this.material.foamBubbleCoverage;
                     },
                     set (value) {
-                        this.shoreFoamScale = value.num[0];
+                        this.material.foamBubbleCoverage = value.num[0];
                     }
                 },
                 {
-                    name: 'ShoreFoamWashAmount',
-                    description: 'How far the waterline runs up and back, as a fraction of ShoreFoamDepth. This is what makes the band read as surf rather than as a painted rim; 0 leaves it static. Above 1 the band closes completely at the bottom of the cycle, which looks like the foam blinking out.',
+                    name: 'FoamBubbleDepth',
+                    description: 'How deep under the surface the bubble cloud seems to float, in metres: it slides against the white foam as the view moves, giving the foam depth. 0 keeps it on the surface.',
                     type: 'float',
-                    default: 0.5,
+                    default: 0.14,
                     options: {
                         animatable: true,
                         minValue: 0,
-                        maxValue: 2
-                    },
-                    isHidden () {
-                        return this.shoreFoamAmount <= 0;
+                        maxValue: 1
                     },
                     get (value) {
-                        value.num[0] = this.shoreFoamWashAmount;
+                        value.num[0] = this.material.foamBubbleDepth;
                     },
                     set (value) {
-                        this.shoreFoamWashAmount = value.num[0];
+                        this.material.foamBubbleDepth = value.num[0];
+                    }
+                },
+                {
+                    name: 'FoamTexture',
+                    description: 'Pattern the foam is cut from (red channel): as the foam thickens it shows the bright parts of the texture first and fills the dark ones last, so bright clumps appear before dark holes close. Empty for the built-in bubble pattern, which thickens as any foam texture does, so the same settings look alike with or without one. Shared by all foam.',
+                    type: 'object',
+                    default: '',
+                    options: {
+                        mimeTypes: [
+                            'image/jpeg',
+                            'image/png',
+                            'image/tga',
+                            'image/vnd.radiance',
+                            'image/x-dds',
+                            'image/webp'
+                        ]
+                    },
+                    isNullable () {
+                        return true;
+                    },
+                    get (value) {
+                        value.str[0] = manager.getAssetId(this.material.foamTexture) ?? '';
+                    },
+                    async set (value) {
+                        if (!value) {
+                            this.material.foamTexture = null;
+                        } else if (value.str[0]) {
+                            const assetId = value.str[0];
+                            let tex;
+                            try {
+                                tex = await manager.fetchTexture(assetId);
+                            } catch (err) {
+                                console.error(`Load asset failed: ${value.str[0]}: ${err}`);
+                                tex = null;
+                            }
+                            if (tex?.isTexture2D()) {
+                                this.material.foamTexture = tex;
+                            } else {
+                                console.error('Invalid texture type');
+                            }
+                        }
                     }
                 },
                 {
-                    name: 'ShoreFoamWashSpeed',
-                    description: 'Run-up cycles per second. Swell rather than wind waves, so well under 1.',
+                    name: 'FoamTextureSize',
+                    description: 'How large the foam pattern is on the water, in metres per repeat of the foam texture: larger values give bigger clumps and holes.',
                     type: 'float',
-                    default: 0.12,
+                    default: 4,
                     options: {
                         animatable: true,
-                        minValue: 0,
-                        maxValue: 2
-                    },
-                    isHidden () {
-                        return this.shoreFoamAmount <= 0;
+                        minValue: 0.01,
+                        maxValue: 50
                     },
                     get (value) {
-                        value.num[0] = this.shoreFoamWashSpeed;
+                        value.num[0] = this.material.foamTextureSize;
                     },
                     set (value) {
-                        this.shoreFoamWashSpeed = value.num[0];
+                        this.material.foamTextureSize = value.num[0];
                     }
                 },
                 {
-                    name: 'ShoreFoamWashScale',
-                    description: 'Spatial frequency of the run-up phase, in cycles per meter. At 0 the whole waterline rises and falls in lockstep, which reads as the water level itself changing; a cycle every few tens of meters breaks a long shoreline into sections that run out of step with one another.',
+                    name: 'FoamTrailStrength',
+                    description: 'How much foam the breaking crests of the open water leave behind: the foam lingers after the crest has passed, drifts on the wind and fades into streaks and patches. 0 keeps foam only while a crest breaks.',
                     type: 'float',
-                    default: 0.03,
+                    default: 1,
                     options: {
                         animatable: true,
                         minValue: 0,
-                        maxValue: 1
-                    },
-                    isHidden () {
-                        return this.shoreFoamAmount <= 0;
+                        maxValue: 5
                     },
                     get (value) {
-                        value.num[0] = this.shoreFoamWashScale;
+                        value.num[0] = this.foamTrailStrength;
                     },
                     set (value) {
-                        this.shoreFoamWashScale = value.num[0];
+                        this.foamTrailStrength = value.num[0];
                     }
                 },
                 {
-                    name: 'CheapRefractionDepth',
-                    description: 'Depth in meters the cheap refraction mode assumes the water is. Sets how strong the distortion looks when RefractionMode is Offset; ignored by March. A constant rather than the measured distance to the bottom, because an offset scaled by that distance paints a second copy of any object breaking the surface.',
+                    name: 'FoamFadeRate',
+                    description: 'How quickly lingering foam dies away, behind breaking crests and shore waves alike: low values leave long-lasting trails and sheets of foam, high values keep only fresh foam at the breaking crests.',
                     type: 'float',
-                    default: 1,
+                    default: 0.8,
                     options: {
                         animatable: true,
-                        minValue: 0,
+                        minValue: 0.01,
                         maxValue: 20
                     },
-                    isHidden () {
-                        return this.material.refractionMode !== 'offset';
-                    },
                     get (value) {
-                        value.num[0] = this.material.cheapRefractionDepth;
+                        value.num[0] = this.foamFadeRate;
                     },
                     set (value) {
-                        this.material.cheapRefractionDepth = value.num[0];
+                        this.foamFadeRate = value.num[0];
                     }
                 },
                 {
-                    name: 'RefractionBlur',
-                    description: 'Scale on how much the medium blurs what is seen through it, 1 for the width the scattering coefficient and the path length imply. Turbid or deep water smudges the bottom; 0 keeps it sharp at any depth.',
+                    name: 'FoamDrift',
+                    description: 'How fast lingering foam drifts downwind, as a share of the wind speed: about 0.03 in nature. 0 leaves it where the crest broke.',
                     type: 'float',
-                    default: 1,
+                    default: 0.03,
                     options: {
                         animatable: true,
                         minValue: 0,
-                        maxValue: 4
+                        maxValue: 0.2
                     },
                     get (value) {
-                        value.num[0] = this.material.refractionBlur;
+                        value.num[0] = this.foamDrift;
                     },
                     set (value) {
-                        this.material.refractionBlur = value.num[0];
+                        this.foamDrift = value.num[0];
                     }
                 },
                 {
-                    name: 'ScatterAnisotropy',
-                    description: 'Mean cosine of a single scattering event. 0 scatters equally in all directions; higher brightens the water when looking towards the sun through it. Sea water measures near 0.9, but a turbid column blends towards isotropic on its own.',
+                    name: 'FoamFieldSize',
+                    description: 'Size in metres of the square of water around where the camera looks in which lingering foam keeps its finest detail. Coarser rings reach eight times as far before foam shows only on the breaking crests; larger values reach further at coarser detail throughout.',
                     type: 'float',
-                    default: DEFAULT_SCATTER_ANISOTROPY,
+                    default: 128,
+                    options: {
+                        animatable: false,
+                        minValue: 16,
+                        maxValue: 1024
+                    },
+                    get (value) {
+                        value.num[0] = this.foamFieldSize;
+                    },
+                    set (value) {
+                        this.foamFieldSize = value.num[0];
+                    }
+                },
+                {
+                    name: 'EdgeFadeWidth',
+                    description: 'Thickness in metres over which a thin sheet of water fades in from the ground under it, so swash running up the sand shows the sand through it. 0 disables it.',
+                    type: 'float',
+                    default: 0.05,
                     options: {
                         animatable: true,
                         minValue: 0,
-                        maxValue: 0.95
+                        maxValue: 1
                     },
                     get (value) {
-                        value.num[0] = this.material.scatterAnisotropy;
+                        value.num[0] = this.edgeFadeWidth;
                     },
                     set (value) {
-                        this.material.scatterAnisotropy = value.num[0];
+                        this.edgeFadeWidth = value.num[0];
                     }
                 },
                 {
-                    name: 'RefractionScale',
-                    description: 'Artistic scale on the refracted view offset. 1 is physical: the view ray is bent by Snell’s law and followed to whatever is behind the water, so the incidence angle, the depth and the perspective are already accounted for. 0 disables refraction.',
+                    name: 'ShoreWaveHeight',
+                    description: 'Crest to trough height in metres of the waves rolling in to the shore and washing up the beach, 0 for none. They come square on to the coast whatever its shape, bunch up as the water shallows, sharpen and lean as they near the shore, and each crest lifts the water up the sand and lets it drain back; boats ride them. Needs the scene signed distance field: WebGPU with the scene SDFEnabled on.',
                     type: 'float',
-                    default: 1,
+                    default: 0,
                     options: {
                         animatable: true,
                         minValue: 0,
-                        maxValue: 4
+                        maxValue: 3
+                    },
+                    isHidden () {
+                        return false;
                     },
                     get (value) {
-                        value.num[0] = this.material.refractionScale;
+                        value.num[0] = this.shoreWaveHeight;
                     },
                     set (value) {
-                        this.material.refractionScale = value.num[0];
+                        this.shoreWaveHeight = value.num[0];
                     }
                 },
                 {
-                    name: 'TAAStrength',
-                    description: 'Temporal anti-aliasing strength for the water surface',
+                    name: 'ShoreWaveLength',
+                    description: 'Distance in metres between crests at the outer edge of the zone. They bunch up towards the shore as real waves do in shallowing water.',
                     type: 'float',
-                    default: 0.4,
+                    default: 8,
                     options: {
-                        minValue: 0,
-                        maxValue: 1
+                        animatable: true,
+                        minValue: 0.5,
+                        maxValue: 100
+                    },
+                    isHidden () {
+                        return this.shoreWaveHeight <= 0;
                     },
                     get (value) {
-                        value.num[0] = this.TAAStrength;
+                        value.num[0] = this.shoreWaveLength;
                     },
                     set (value) {
-                        this.TAAStrength = value.num[0];
+                        this.shoreWaveLength = value.num[0];
                     }
                 },
                 {
-                    name: 'ScatterRampTexture',
-                    description: 'Ramp texture used for water scatter lighting',
-                    type: 'object',
-                    default: null,
-                    isNullable () {
-                        return true;
+                    name: 'ShoreWavePeriod',
+                    description: 'Seconds between successive shore waves.',
+                    type: 'float',
+                    default: 6,
+                    options: {
+                        animatable: true,
+                        minValue: 0.5,
+                        maxValue: 30
+                    },
+                    isHidden () {
+                        return this.shoreWaveHeight <= 0;
                     },
                     get (value) {
-                        value.str[0] = manager.getAssetId(this.material.scatterRampTexture) ?? '';
+                        value.num[0] = this.shoreWavePeriod;
                     },
-                    async set (value) {
-                        if (!value) {
-                            this.material.scatterRampTexture = null;
-                        } else {
-                            if (value.str[0]) {
-                                const assetId = value.str[0];
-                                let tex;
-                                try {
-                                    tex = await manager.fetchTexture(assetId);
-                                } catch (err) {
-                                    console.error(`Load asset failed: ${value.str[0]}: ${err}`);
-                                    tex = null;
-                                }
-                                if (tex?.isTexture2D()) {
-                                    this.material.scatterRampTexture = tex;
-                                } else {
-                                    console.error('Invalid texture type');
-                                }
-                            }
-                        }
+                    set (value) {
+                        this.shoreWavePeriod = value.num[0];
                     }
                 },
                 {
-                    name: 'AbsorptionRampTexture',
-                    description: 'Ramp texture used for water absorption',
-                    type: 'object',
-                    default: null,
-                    isNullable () {
-                        return true;
+                    name: 'ShoreWaveZone',
+                    description: 'How far out from the waterline the shore waves rise, in metres. They grow over the zone and break near its inner end.',
+                    type: 'float',
+                    default: 20,
+                    options: {
+                        animatable: true,
+                        minValue: 1,
+                        maxValue: 200
+                    },
+                    isHidden () {
+                        return this.shoreWaveHeight <= 0;
                     },
                     get (value) {
-                        value.str[0] = manager.getAssetId(this.material.absorptionRampTexture) ?? '';
+                        value.num[0] = this.shoreWaveZone;
                     },
-                    async set (value) {
-                        if (!value) {
-                            this.material.absorptionRampTexture = null;
-                        } else {
-                            if (value.str[0]) {
-                                const assetId = value.str[0];
-                                let tex;
-                                try {
-                                    tex = await manager.fetchTexture(assetId);
-                                } catch (err) {
-                                    console.error(`Load asset failed: ${value.str[0]}: ${err}`);
-                                    tex = null;
-                                }
-                                if (tex?.isTexture2D()) {
-                                    this.material.absorptionRampTexture = tex;
-                                } else {
-                                    console.error('Invalid texture type');
-                                }
+                    set (value) {
+                        this.shoreWaveZone = value.num[0];
+                    }
+                },
+                {
+                    name: 'ShoreWaveSharpness',
+                    description: 'How sharp the crests become at the shore: 0 keeps a rounded sine, towards 1 a pointed crest between long flat troughs.',
+                    type: 'float',
+                    default: 0.7,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 0.95
+                    },
+                    isHidden () {
+                        return this.shoreWaveHeight <= 0;
+                    },
+                    get (value) {
+                        value.num[0] = this.shoreWaveSharpness;
+                    },
+                    set (value) {
+                        this.shoreWaveSharpness = value.num[0];
+                    }
+                },
+                {
+                    name: 'ShoreWaveLean',
+                    description: 'How far the crests lean towards the shore there: 0 keeps them upright, 1 gives a steep front face and a long gentle back.',
+                    type: 'float',
+                    default: 0.5,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    isHidden () {
+                        return this.shoreWaveHeight <= 0;
+                    },
+                    get (value) {
+                        value.num[0] = this.shoreWaveLean;
+                    },
+                    set (value) {
+                        this.shoreWaveLean = value.num[0];
+                    }
+                },
+                {
+                    name: 'ShoreWaveIrregularity',
+                    description: 'How irregular the shore waves are: at 0 the crests roll in as parallel lines evenly spaced; higher, each wave comes with a spacing and a bend of its own, so crests close up and spread apart, curve differently along the shore and keep those shapes as they come in.',
+                    type: 'float',
+                    default: 0.6,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    isHidden () {
+                        return this.shoreWaveHeight <= 0;
+                    },
+                    get (value) {
+                        value.num[0] = this.shoreWaveIrregularity;
+                    },
+                    set (value) {
+                        this.shoreWaveIrregularity = value.num[0];
+                    }
+                },
+                {
+                    name: 'ShoreWaveFoamStrength',
+                    description: 'How much foam the breaking shore waves throw up: higher values give thicker, whiter foam on and behind the crests. Balance it against the fade rate.',
+                    type: 'float',
+                    default: 1,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 5
+                    },
+                    isHidden () {
+                        return this.shoreWaveHeight <= 0;
+                    },
+                    get (value) {
+                        value.num[0] = this.shoreWaveFoamStrength;
+                    },
+                    set (value) {
+                        this.shoreWaveFoamStrength = value.num[0];
+                    }
+                },
+                {
+                    name: 'ShoreWaveFoamCoverage',
+                    description: 'How much of each shore wave foams: low values foam only at the steepest breaking fronts, high values spread foam over more of the wave.',
+                    type: 'float',
+                    default: 0.55,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    isHidden () {
+                        return this.shoreWaveHeight <= 0;
+                    },
+                    get (value) {
+                        value.num[0] = this.shoreWaveFoamCoverage;
+                    },
+                    set (value) {
+                        this.shoreWaveFoamCoverage = value.num[0];
+                    }
+                },
+                {
+                    name: 'ShoreWaveShallowFoamDepth',
+                    description: 'How deep the water can be and still churn up foam as the waves run in, in metres: larger values widen the band of foam along the beach.',
+                    type: 'float',
+                    default: 0.65,
+                    options: {
+                        animatable: true,
+                        minValue: 0.01,
+                        maxValue: 3
+                    },
+                    isHidden () {
+                        return this.shoreWaveHeight <= 0;
+                    },
+                    get (value) {
+                        value.num[0] = this.shoreWaveShallowFoamDepth;
+                    },
+                    set (value) {
+                        this.shoreWaveShallowFoamDepth = value.num[0];
+                    }
+                },
+                {
+                    name: 'ShoreWaveShallowFoamStrength',
+                    description: "How much foam the shallow water at the beach makes as the waves wash over it: higher values give a denser white wash, 0 leaves only the breaking crests' foam.",
+                    type: 'float',
+                    default: 2,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 5
+                    },
+                    isHidden () {
+                        return this.shoreWaveHeight <= 0;
+                    },
+                    get (value) {
+                        value.num[0] = this.shoreWaveShallowFoamStrength;
+                    },
+                    set (value) {
+                        this.shoreWaveShallowFoamStrength = value.num[0];
+                    }
+                },
+                {
+                    name: 'WallFoamStrength',
+                    description: 'How solid the ring of foam is where the water dashes against rocks, walls and piers standing in it: 1 for a thick white fringe, lower for a thinner, more see-through one, 0 for none. The ring always goes all the way round; how far it spreads is Wall Foam Spread. Needs the shore waves on.',
+                    type: 'float',
+                    default: 1,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    isHidden () {
+                        return this.shoreWaveHeight <= 0;
+                    },
+                    get (value) {
+                        value.num[0] = this.wallFoamStrength;
+                    },
+                    set (value) {
+                        this.wallFoamStrength = value.num[0];
+                    }
+                },
+                {
+                    name: 'WallFoamMinSpeed',
+                    description: 'How hard the water has to hit a wall before it foams there, in metres per second: raise it to keep calm water clean against rocks, lower it to fringe them with foam in a gentle swell.',
+                    type: 'float',
+                    default: 0.2,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 5
+                    },
+                    isHidden () {
+                        return this.shoreWaveHeight <= 0;
+                    },
+                    get (value) {
+                        value.num[0] = this.wallFoamMinSpeed;
+                    },
+                    set (value) {
+                        this.wallFoamMinSpeed = value.num[0];
+                    }
+                },
+                {
+                    name: 'WallFoamMaxSpeed',
+                    description: 'How hard the water has to hit a wall for the thickest foam, in metres per second: lower it for full white water against rocks in a moderate sea, raise it to keep that for a heavy one.',
+                    type: 'float',
+                    default: 1.5,
+                    options: {
+                        animatable: true,
+                        minValue: 0.01,
+                        maxValue: 10
+                    },
+                    isHidden () {
+                        return this.shoreWaveHeight <= 0;
+                    },
+                    get (value) {
+                        value.num[0] = this.wallFoamMaxSpeed;
+                    },
+                    set (value) {
+                        this.wallFoamMaxSpeed = value.num[0];
+                    }
+                },
+                {
+                    name: 'WallFoamDrift',
+                    description: 'How fast the foam spreads out from rocks, walls and piers, in metres per second: higher for a wider ring of foam around them, lower to keep it close in. It spreads evenly on every side whichever way the wind blows.',
+                    type: 'float',
+                    default: 0.3,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 3
+                    },
+                    isHidden () {
+                        return this.shoreWaveHeight <= 0;
+                    },
+                    get (value) {
+                        value.num[0] = this.wallFoamDrift;
+                    },
+                    set (value) {
+                        this.wallFoamDrift = value.num[0];
+                    }
+                },
+                {
+                    name: 'SurfFoamDuration',
+                    description: 'How long, in seconds, the foam of each breaking wave lasts as the wave comes in and washes up the beach: higher for long white trails behind the crests and foam carried all the way up the sand, lower for brief flashes of white that clear before the wave has run up.',
+                    type: 'float',
+                    default: 1.5,
+                    options: {
+                        animatable: true,
+                        minValue: 0.05,
+                        maxValue: 6
+                    },
+                    isHidden () {
+                        return this.shoreWaveHeight <= 0;
+                    },
+                    get (value) {
+                        value.num[0] = this.surfFoamDuration;
+                    },
+                    set (value) {
+                        this.surfFoamDuration = value.num[0];
+                    }
+                },
+                {
+                    name: 'FoamSettleDepth',
+                    description: 'Water depth in metres at and below which foam stops drifting and stays where it is, on the thin wash and the wet sand alike, until it fades: higher to leave foam lying over a wider band of the shallows and the beach, lower to let it drift until the water is almost gone.',
+                    type: 'float',
+                    default: 0.02,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    isHidden () {
+                        return this.shoreWaveHeight <= 0;
+                    },
+                    get (value) {
+                        value.num[0] = this.foamSettleDepth;
+                    },
+                    set (value) {
+                        this.foamSettleDepth = value.num[0];
+                    }
+                },
+                {
+                    name: 'FoamDriftDepth',
+                    description: 'Water depth in metres at and beyond which foam drifts freely with the water; between this and FoamSettleDepth it slows down the shallower the water gets. Higher to calm the foam over a wider band of shallow water, lower to keep it moving until close in.',
+                    type: 'float',
+                    default: 0.3,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 3
+                    },
+                    isHidden () {
+                        return this.shoreWaveHeight <= 0;
+                    },
+                    get (value) {
+                        value.num[0] = this.foamDriftDepth;
+                    },
+                    set (value) {
+                        this.foamDriftDepth = value.num[0];
+                    }
+                },
+                {
+                    name: 'SettledFoamFade',
+                    description: 'How fast foam that has come to rest in shallow water and on the sand fades, compared with foam on open water: lower to leave the foam lying on the beach longer after each wave drains, 1 to let it vanish as quickly as foam out at sea.',
+                    type: 'float',
+                    default: 0.25,
+                    options: {
+                        animatable: true,
+                        minValue: 0.01,
+                        maxValue: 1
+                    },
+                    isHidden () {
+                        return this.shoreWaveHeight <= 0;
+                    },
+                    get (value) {
+                        value.num[0] = this.settledFoamFade;
+                    },
+                    set (value) {
+                        this.settledFoamFade = value.num[0];
+                    }
+                },
+                {
+                    name: 'CheapRefractionDepth',
+                    description: 'Depth in meters the cheap refraction mode assumes the water is. Sets how strong the distortion looks when RefractionMode is Offset; ignored by March. A constant rather than the measured distance to the bottom, because an offset scaled by that distance paints a second copy of any object breaking the surface.',
+                    type: 'float',
+                    default: 1,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 20
+                    },
+                    isHidden () {
+                        return this.material.refractionMode !== 'offset';
+                    },
+                    get (value) {
+                        value.num[0] = this.material.cheapRefractionDepth;
+                    },
+                    set (value) {
+                        this.material.cheapRefractionDepth = value.num[0];
+                    }
+                },
+                {
+                    name: 'RefractionBlur',
+                    description: 'Scale on how much the medium blurs what is seen through it, 1 for the width the scattering coefficient and the path length imply. Turbid or deep water smudges the bottom; 0 keeps it sharp at any depth.',
+                    type: 'float',
+                    default: 1,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 4
+                    },
+                    get (value) {
+                        value.num[0] = this.material.refractionBlur;
+                    },
+                    set (value) {
+                        this.material.refractionBlur = value.num[0];
+                    }
+                },
+                {
+                    name: 'ScatterAnisotropy',
+                    description: 'Mean cosine of a single scattering event. 0 scatters equally in all directions; higher brightens the water when looking towards the sun through it. Sea water measures near 0.9, but a turbid column blends towards isotropic on its own.',
+                    type: 'float',
+                    default: DEFAULT_SCATTER_ANISOTROPY,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 0.95
+                    },
+                    get (value) {
+                        value.num[0] = this.material.scatterAnisotropy;
+                    },
+                    set (value) {
+                        this.material.scatterAnisotropy = value.num[0];
+                    }
+                },
+                {
+                    name: 'RefractionScale',
+                    description: 'Artistic scale on the refracted view offset. 1 is physical: the view ray is bent by Snell’s law and followed to whatever is behind the water, so the incidence angle, the depth and the perspective are already accounted for. 0 disables refraction.',
+                    type: 'float',
+                    default: 1,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 4
+                    },
+                    get (value) {
+                        value.num[0] = this.material.refractionScale;
+                    },
+                    set (value) {
+                        this.material.refractionScale = value.num[0];
+                    }
+                },
+                {
+                    name: 'TAAStrength',
+                    description: 'Share of the temporal anti-aliasing history kept on the water surface. Lower trades smoothing for less smearing of fast waves; much lower lets the sub-pixel camera jitter through, and the waterline visibly shakes. 0 keeps no history at all.',
+                    type: 'float',
+                    default: 0.9,
+                    options: {
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.TAAStrength;
+                    },
+                    set (value) {
+                        this.TAAStrength = value.num[0];
+                    }
+                }
+            ]));
+        }
+    };
+}
+const WATER_INTERACTION_FOLLOW_MODES = [
+    {
+        label: 'Camera',
+        value: 'camera'
+    },
+    {
+        label: 'Node',
+        value: 'node'
+    },
+    {
+        label: 'Fixed',
+        value: 'fixed'
+    }
+];
+const WATER_DISTURBER_SHAPES = [
+    {
+        label: 'Sphere',
+        value: 'sphere'
+    },
+    {
+        label: 'Capsule',
+        value: 'capsule'
+    },
+    {
+        label: 'Box',
+        value: 'box'
+    }
+];
+/** @internal */ function getWaterInteractionClass() {
+    return {
+        ctor: WaterInteraction,
+        name: 'WaterInteraction',
+        getProps () {
+            return defineProps([
+                {
+                    name: 'Resolution',
+                    description: 'Texels along each side of the simulation window. Changing it discards the field.',
+                    type: 'int',
+                    default: 512,
+                    options: {
+                        minValue: 64,
+                        maxValue: 2048
+                    },
+                    get (value) {
+                        value.num[0] = this.resolution;
+                    },
+                    set (value) {
+                        this.resolution = value.num[0];
+                    }
+                },
+                {
+                    name: 'WindowSize',
+                    description: 'Side of the simulation window in metres. Changing it discards the field.',
+                    type: 'float',
+                    default: 64,
+                    options: {
+                        minValue: 4,
+                        maxValue: 512
+                    },
+                    get (value) {
+                        value.num[0] = this.windowSize;
+                    },
+                    set (value) {
+                        this.windowSize = value.num[0];
+                    }
+                },
+                {
+                    name: 'WaveSpeed',
+                    description: 'Speed disturbances spread at, in metres per second. Clamped to what the window can integrate stably.',
+                    type: 'float',
+                    default: 1.5,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 10
+                    },
+                    get (value) {
+                        value.num[0] = this.waveSpeed;
+                    },
+                    set (value) {
+                        this.waveSpeed = value.num[0];
+                    }
+                },
+                {
+                    name: 'ShallowDepth',
+                    description: 'Depth in metres below which waves slow down as shallow water waves do: WaveSpeed in deeper water, falling with the square root of the depth below this. A wave running onto a beach then slows, shortens, grows and turns to meet the shore. 0 ignores the depth. The depth comes from the scene signed distance field where SDFEnabled is on, else from the terrain.',
+                    type: 'float',
+                    default: 2,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 50
+                    },
+                    get (value) {
+                        value.num[0] = this.shallowDepth;
+                    },
+                    set (value) {
+                        this.shallowDepth = value.num[0];
+                    }
+                },
+                {
+                    name: 'ShoreAbsorbDepth',
+                    description: 'Depth in metres over which the beach absorbs the waves reaching it, instead of reflecting them back out to sea.',
+                    type: 'float',
+                    default: 0.2,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 5
+                    },
+                    isHidden () {
+                        return this.shallowDepth <= 0;
+                    },
+                    get (value) {
+                        value.num[0] = this.shoreAbsorbDepth;
+                    },
+                    set (value) {
+                        this.shoreAbsorbDepth = value.num[0];
+                    }
+                },
+                {
+                    name: 'Damping',
+                    description: 'Rate the field loses energy at, in 1/s',
+                    type: 'float',
+                    default: 1,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 10
+                    },
+                    get (value) {
+                        value.num[0] = this.damping;
+                    },
+                    set (value) {
+                        this.damping = value.num[0];
+                    }
+                },
+                {
+                    name: 'MaxAmplitude',
+                    description: 'Height in metres the field is clamped to either side of the rest level',
+                    type: 'float',
+                    default: 0.5,
+                    options: {
+                        minValue: 0.01,
+                        maxValue: 5
+                    },
+                    get (value) {
+                        value.num[0] = this.maxAmplitude;
+                    },
+                    set (value) {
+                        this.maxAmplitude = value.num[0];
+                    }
+                },
+                {
+                    name: 'SpongeWidth',
+                    description: 'Width of the absorbing band inside the window edge, as a fraction of the window',
+                    type: 'float',
+                    default: 0.1,
+                    options: {
+                        minValue: 0.01,
+                        maxValue: 0.45
+                    },
+                    get (value) {
+                        value.num[0] = this.spongeWidth;
+                    },
+                    set (value) {
+                        this.spongeWidth = value.num[0];
+                    }
+                },
+                {
+                    name: 'FollowMode',
+                    description: 'How the window is positioned: on the water the camera looks at, on a node, or fixed',
+                    type: 'string',
+                    default: 'camera',
+                    options: {
+                        enum: {
+                            labels: WATER_INTERACTION_FOLLOW_MODES.map((e)=>e.label),
+                            values: WATER_INTERACTION_FOLLOW_MODES.map((e)=>e.value)
+                        }
+                    },
+                    get (value) {
+                        value.str[0] = this.followMode;
+                    },
+                    set (value) {
+                        this.followMode = value.str[0];
+                    }
+                },
+                {
+                    name: 'FollowNode',
+                    description: 'Node the window follows while FollowMode is Node',
+                    type: 'string',
+                    default: '',
+                    options: {
+                        sceneNode: {
+                            kind: 'node'
+                        }
+                    },
+                    get (value) {
+                        value.str[0] = this.followNode?.persistentId ?? this.followNodeId;
+                    },
+                    set (value) {
+                        this.followNodeId = value.str[0] ?? '';
+                        this.followNode = null;
+                    }
+                },
+                {
+                    name: 'Center',
+                    description: 'World XZ the window is centred on while FollowMode is Fixed',
+                    type: 'vec2',
+                    default: [
+                        0,
+                        0
+                    ],
+                    get (value) {
+                        value.num[0] = this.center.x;
+                        value.num[1] = this.center.y;
+                    },
+                    set (value) {
+                        this.center = new Vector2(value.num[0], value.num[1]);
+                    }
+                },
+                {
+                    name: 'FoamAmount',
+                    description: 'Rate foam is made at where the water is churned to the full, in coverage per second; 0 disables the foam',
+                    type: 'float',
+                    default: 3,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 30
+                    },
+                    get (value) {
+                        value.num[0] = this.foamAmount;
+                    },
+                    set (value) {
+                        this.foamAmount = value.num[0];
+                    }
+                },
+                {
+                    name: 'FoamDecay',
+                    description: 'Rate the foam trail fades at, in 1/s',
+                    type: 'float',
+                    default: 0.6,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 5
+                    },
+                    get (value) {
+                        value.num[0] = this.foamDecay;
+                    },
+                    set (value) {
+                        this.foamDecay = value.num[0];
+                    }
+                },
+                {
+                    name: 'FoamMinSpeed',
+                    description: 'Speed of the water in m/s below which it traps no air and makes no foam',
+                    type: 'float',
+                    default: 0.5,
+                    options: {
+                        minValue: 0,
+                        maxValue: 10
+                    },
+                    get (value) {
+                        value.num[0] = this.foamMinSpeed;
+                    },
+                    set (value) {
+                        this.foamMinSpeed = value.num[0];
+                    }
+                },
+                {
+                    name: 'FoamMaxSpeed',
+                    description: 'Speed of the water in m/s from which it foams to the full',
+                    type: 'float',
+                    default: 2,
+                    options: {
+                        minValue: 0,
+                        maxValue: 20
+                    },
+                    get (value) {
+                        value.num[0] = this.foamMaxSpeed;
+                    },
+                    set (value) {
+                        this.foamMaxSpeed = value.num[0];
+                    }
+                },
+                {
+                    name: 'BreakingAcceleration',
+                    description: "Downward acceleration of a crest, as a share of gravity, at which it breaks and foams; Longuet-Higgins' limit is 0.5",
+                    type: 'float',
+                    default: 0.5,
+                    options: {
+                        minValue: 0.01,
+                        maxValue: 4
+                    },
+                    get (value) {
+                        value.num[0] = this.breakingAcceleration;
+                    },
+                    set (value) {
+                        this.breakingAcceleration = value.num[0];
+                    }
+                },
+                {
+                    name: 'FoamDiffusion',
+                    description: 'Turbulent diffusivity the foam spreads by, in square metres per second',
+                    type: 'float',
+                    default: 0.1,
+                    options: {
+                        minValue: 0,
+                        maxValue: 2
+                    },
+                    get (value) {
+                        value.num[0] = this.foamDiffusion;
+                    },
+                    set (value) {
+                        this.foamDiffusion = value.num[0];
+                    }
+                },
+                {
+                    name: 'Disturbers',
+                    description: 'Things that disturb the water by moving through it, each following a scene node',
+                    type: 'object_array',
+                    options: {
+                        objectTypes: [
+                            WaterDisturber
+                        ]
+                    },
+                    get (value) {
+                        value.object = [
+                            ...this.disturbers
+                        ];
+                    },
+                    set (value) {
+                        const next = value.object.filter((d)=>d instanceof WaterDisturber);
+                        for (const d of [
+                            ...this.disturbers
+                        ]){
+                            if (!next.includes(d)) {
+                                this.removeDisturber(d);
                             }
                         }
+                        for (const d of next){
+                            this.addDisturber(d);
+                        }
+                    },
+                    add (value) {
+                        const d = value?.object?.[0];
+                        this.addDisturber(d instanceof WaterDisturber ? d : new WaterDisturber());
+                    },
+                    delete (index) {
+                        const d = this.disturbers[index];
+                        if (d) {
+                            this.removeDisturber(d);
+                        }
+                    }
+                }
+            ]);
+        }
+    };
+}
+/** @internal */ function getWaterDisturberClass() {
+    return {
+        ctor: WaterDisturber,
+        name: 'WaterDisturber',
+        getProps () {
+            return defineProps([
+                {
+                    name: 'Node',
+                    description: 'Scene node the shape follows',
+                    type: 'string',
+                    default: '',
+                    options: {
+                        sceneNode: {
+                            kind: 'node'
+                        }
+                    },
+                    get (value) {
+                        value.str[0] = this.node?.persistentId ?? this.nodeId;
+                    },
+                    set (value) {
+                        this.nodeId = value.str[0] ?? '';
+                        this.node = null;
+                    }
+                },
+                {
+                    name: 'Shape',
+                    description: 'Footprint shape: a sphere or a capsule of Radius, or a box of Size',
+                    type: 'string',
+                    default: 'sphere',
+                    options: {
+                        enum: {
+                            labels: WATER_DISTURBER_SHAPES.map((e)=>e.label),
+                            values: WATER_DISTURBER_SHAPES.map((e)=>e.value)
+                        }
+                    },
+                    get (value) {
+                        value.str[0] = this.shape;
+                    },
+                    set (value) {
+                        this.shape = value.str[0];
+                    }
+                },
+                {
+                    name: 'Radius',
+                    description: 'Radius in metres, for a sphere or a capsule',
+                    type: 'float',
+                    default: 0.5,
+                    options: {
+                        minValue: 0.01,
+                        maxValue: 50
+                    },
+                    get (value) {
+                        value.num[0] = this.radius;
+                    },
+                    set (value) {
+                        this.radius = value.num[0];
+                    }
+                },
+                {
+                    name: 'HalfLength',
+                    description: 'Half the segment length in metres, for a capsule, along the local Y axis',
+                    type: 'float',
+                    default: 0.5,
+                    options: {
+                        minValue: 0,
+                        maxValue: 50
+                    },
+                    get (value) {
+                        value.num[0] = this.halfLength;
+                    },
+                    set (value) {
+                        this.halfLength = value.num[0];
+                    }
+                },
+                {
+                    name: 'Size',
+                    description: 'Extents in metres along the local axes, for a box',
+                    type: 'vec3',
+                    default: [
+                        1,
+                        1,
+                        1
+                    ],
+                    get (value) {
+                        value.num[0] = this.size.x;
+                        value.num[1] = this.size.y;
+                        value.num[2] = this.size.z;
+                    },
+                    set (value) {
+                        this.size = new Vector3(value.num[0], value.num[1], value.num[2]);
+                    }
+                },
+                {
+                    name: 'Strength',
+                    description: 'Water column the fully submerged shape displaces, in metres of surface height',
+                    type: 'float',
+                    default: 0.15,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 2
+                    },
+                    get (value) {
+                        value.num[0] = this.strength;
+                    },
+                    set (value) {
+                        this.strength = value.num[0];
+                    }
+                },
+                {
+                    name: 'Blocking',
+                    description: 'Whether waves stop at and reflect off the footprint',
+                    type: 'bool',
+                    default: false,
+                    get (value) {
+                        value.bool[0] = this.blocking;
+                    },
+                    set (value) {
+                        this.blocking = value.bool[0];
+                    }
+                },
+                {
+                    name: 'Floating',
+                    description: 'Whether the shape floats, as a boat hull does: it displaces its full strength however it bobs and leaves a wake only by moving',
+                    type: 'bool',
+                    default: false,
+                    get (value) {
+                        value.bool[0] = this.floating;
+                    },
+                    set (value) {
+                        this.floating = value.bool[0];
+                    }
+                },
+                {
+                    name: 'Enabled',
+                    description: 'Whether the disturber is taken into account',
+                    type: 'bool',
+                    default: true,
+                    get (value) {
+                        value.bool[0] = this.enabled;
+                    },
+                    set (value) {
+                        this.enabled = value.bool[0];
                     }
                 }
             ]);
@@ -1579,5 +2858,5 @@ import { WATER_DEBUG_OUTPUTS, DEFAULT_SCATTER_ANISOTROPY } from '../../../materi
     };
 }
 
-export { getFBMWaveGeneratorClass, getFFTWaveGeneratorClass, getGerstnerWaveClass, getGerstnerWaveGeneratorClass, getWaterClass };
+export { getFBMWaveGeneratorClass, getFFTWaveGeneratorClass, getGerstnerWaveClass, getGerstnerWaveGeneratorClass, getWaterClass, getWaterDisturberClass, getWaterInteractionClass };
 //# sourceMappingURL=water.js.map