@zephyr3d/scene 0.9.26 → 0.10.0

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

@@ -1,18 +1,19 @@
-import { Vector2 } from '@zephyr3d/base';
+import { Vector2, Vector3 } from '@zephyr3d/base';
 import '../../../scene/scene.js';
-import '../../../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,10 +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';
@@ -48,6 +55,8 @@ 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() {
     return {
@@ -199,31 +208,6 @@ import '../../../scene/raycast_visitor.js';
                         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',
@@ -231,7 +215,7 @@ import '../../../scene/raycast_visitor.js';
                     default: [
                         0.4,
                         0.4,
-                        0.2
+                        0.4
                     ],
                     options: {
                         animatable: true,
@@ -278,6 +262,716 @@ import '../../../scene/raycast_visitor.js';
         }
     };
 }
+/** @internal */ function getGerstnerWaveGeneratorClass() {
+    return {
+        ctor: GerstnerWaveGenerator,
+        name: 'GerstnerWaveGenerator',
+        getProps () {
+            return defineProps([
+                {
+                    name: 'NumWaves',
+                    description: 'Number of independent Gerstner waves summed to form the surface',
+                    type: 'int',
+                    options: {
+                        minValue: 1,
+                        maxValue: MAX_GERSTNER_WAVE_COUNT
+                    },
+                    get (value) {
+                        value.num[0] = this.numWaves;
+                    },
+                    set (value) {
+                        this.numWaves = value.num[0];
+                    }
+                },
+                {
+                    name: 'Waves',
+                    description: 'Per-wave parameters, one entry per wave in NumWaves order',
+                    type: 'object_array',
+                    options: {
+                        objectTypes: [
+                            GerstnerWave
+                        ]
+                    },
+                    get (value) {
+                        value.object = [];
+                        for(let i = 0; i < this.numWaves; i++){
+                            const wave = new GerstnerWave();
+                            wave.bind(this, i);
+                            value.object.push(wave);
+                        }
+                    },
+                    set (value) {
+                        const waves = value.object;
+                        // The wave count is ground truth for how many slots the shader
+                        // reads. NumWaves and Waves are applied concurrently during
+                        // deserialization, so this setter must leave the generator in the
+                        // state this array implies regardless of which one runs first.
+                        this.numWaves = waves.length;
+                        for(let i = 0; i < waves.length; i++){
+                            waves[i].applyTo(this, i);
+                        }
+                    },
+                    add (value, index) {
+                        const wave = value?.object?.[0];
+                        const insertAt = index ?? this.numWaves;
+                        this.insertWave(insertAt);
+                        wave?.applyTo(this, insertAt);
+                    },
+                    delete (index) {
+                        this.deleteWave(index);
+                    }
+                },
+                {
+                    name: 'FoamWidth',
+                    description: 'Width of foam bands generated on the wave crests',
+                    type: 'float',
+                    default: 1.2,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 10
+                    },
+                    get (value) {
+                        value.num[0] = this.foamWidth;
+                    },
+                    set (value) {
+                        this.foamWidth = value.num[0];
+                    }
+                },
+                {
+                    name: 'FoamContrast',
+                    description: 'Contrast of the foam pattern on Gerstner waves',
+                    type: 'float',
+                    default: 7.2,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 10
+                    },
+                    get (value) {
+                        value.num[0] = this.foamContrast;
+                    },
+                    set (value) {
+                        this.foamContrast = value.num[0];
+                    }
+                }
+            ]);
+        }
+    };
+}
+/**
+ * A single Gerstner wave, as the editor sees one entry of the
+ * `Waves` object array on a {@link GerstnerWaveGenerator}.
+ *
+ * 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: `_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;
+    _direction;
+    _steepness;
+    _amplitude;
+    _length;
+    _omni;
+    _originX;
+    _originZ;
+    constructor(){
+        this._owner = null;
+        this._index = -1;
+        this._direction = 0;
+        this._steepness = 0;
+        this._amplitude = 0;
+        this._length = 1;
+        this._omni = false;
+        this._originX = 0;
+        this._originZ = 0;
+    }
+    /**
+   * Binds this entry to a slot of `owner`, so the field setters write through
+   * to the generator. Called by the `Waves` getter and by `add`; the index is
+   * the slot the entry currently represents.
+   * @internal
+   */ bind(owner, index) {
+        this._owner = owner;
+        this._index = index;
+        this.loadFromOwner(owner, index);
+    }
+    /**
+   * Copies the values in slot `index` of `owner` into this object, refreshing
+   * the cached fields without writing back.
+   * @internal
+   */ loadFromOwner(owner, index) {
+        this._direction = owner.getWaveDirection(index);
+        this._steepness = owner.getWaveSteepness(index);
+        this._amplitude = owner.getWaveAmplitude(index);
+        this._length = owner.getWaveLength(index);
+        this._omni = owner.isOmniWave(index);
+        this._originX = owner.getOriginX(index);
+        this._originZ = owner.getOriginZ(index);
+    }
+    /**
+   * Writes this object's values into slot `index` of `owner`, unconditionally.
+   *
+   * 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);
+        owner.setWaveSteepness(index, this._steepness);
+        owner.setWaveAmplitude(index, this._amplitude);
+        owner.setWaveLength(index, this._length);
+        owner.setOmniWave(index, this._omni);
+        owner.setOrigin(index, this._originX, this._originZ);
+        this._owner = owner;
+        this._index = index;
+    }
+    /** @internal */ writethrough(setter, val) {
+        const owner = this._owner;
+        if (owner) {
+            setter(owner, this._index, val);
+        }
+    }
+    /** Gets the wave direction angle in radians. */ get direction() {
+        return this._direction;
+    }
+    set direction(val) {
+        this._direction = val;
+        this.writethrough((o, i, v)=>o.setWaveDirection(i, v), val);
+    }
+    /** Gets the wave steepness. */ get steepness() {
+        return this._steepness;
+    }
+    set steepness(val) {
+        this._steepness = val;
+        this.writethrough((o, i, v)=>o.setWaveSteepness(i, v), val);
+    }
+    /** Gets the wave amplitude. */ get amplitude() {
+        return this._amplitude;
+    }
+    set amplitude(val) {
+        this._amplitude = val;
+        this.writethrough((o, i, v)=>o.setWaveAmplitude(i, v), val);
+    }
+    /** Gets the wave length in meters. */ get length() {
+        return this._length;
+    }
+    set length(val) {
+        this._length = val;
+        this.writethrough((o, i, v)=>o.setWaveLength(i, v), val);
+    }
+    /** Gets whether the wave is omni-directional. */ get omni() {
+        return this._omni;
+    }
+    set omni(val) {
+        this._omni = val;
+        if (this._owner) {
+            this._owner.setOmniWave(this._index, val);
+        }
+    }
+    /** Gets the origin X of an omni-directional wave. */ get originX() {
+        return this._originX;
+    }
+    set originX(val) {
+        this._originX = val;
+        if (this._owner) {
+            this._owner.setOrigin(this._index, val, this._originZ);
+        }
+    }
+    /** Gets the origin Z of an omni-directional wave. */ get originZ() {
+        return this._originZ;
+    }
+    set originZ(val) {
+        this._originZ = val;
+        if (this._owner) {
+            this._owner.setOrigin(this._index, this._originX, val);
+        }
+    }
+}
+/** @internal */ function getGerstnerWaveClass() {
+    return {
+        ctor: GerstnerWave,
+        name: 'GerstnerWave',
+        getProps () {
+            return defineProps([
+                {
+                    name: 'Direction',
+                    description: 'Wave direction angle in radians',
+                    type: 'float',
+                    options: {
+                        animatable: true,
+                        minValue: -3.14,
+                        maxValue: 3.14
+                    },
+                    get (value) {
+                        value.num[0] = this.direction;
+                    },
+                    set (value) {
+                        this.direction = value.num[0];
+                    }
+                },
+                {
+                    name: 'Steepness',
+                    description: 'Wave steepness. The sum of steepness across waves sets how sharply crests fold',
+                    type: 'float',
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 2
+                    },
+                    get (value) {
+                        value.num[0] = this.steepness;
+                    },
+                    set (value) {
+                        this.steepness = value.num[0];
+                    }
+                },
+                {
+                    name: 'Amplitude',
+                    description: 'Wave height amplitude',
+                    type: 'float',
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 5
+                    },
+                    get (value) {
+                        value.num[0] = this.amplitude;
+                    },
+                    set (value) {
+                        this.amplitude = value.num[0];
+                    }
+                },
+                {
+                    name: 'Length',
+                    description: 'Wave length in meters',
+                    type: 'float',
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 100
+                    },
+                    get (value) {
+                        value.num[0] = this.length;
+                    },
+                    set (value) {
+                        this.length = value.num[0];
+                    }
+                },
+                {
+                    name: 'Omni',
+                    description: 'If true, radiates outward from an origin rather than travelling in one direction',
+                    type: 'bool',
+                    get (value) {
+                        value.bool[0] = this.omni;
+                    },
+                    set (value) {
+                        this.omni = value.bool[0];
+                    }
+                },
+                {
+                    name: 'Origin',
+                    description: 'Origin of an omni-directional wave, ignored by directional waves',
+                    type: 'vec2',
+                    options: {
+                        animatable: true,
+                        minValue: -1e3,
+                        maxValue: 1000
+                    },
+                    get (value) {
+                        value.num[0] = this.originX;
+                        value.num[1] = this.originZ;
+                    },
+                    set (value) {
+                        this.originX = value.num[0];
+                        this.originZ = value.num[1];
+                    }
+                }
+            ]);
+        }
+    };
+}
+/**
+ * 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,
@@ -291,7 +985,7 @@ import '../../../scene/raycast_visitor.js';
             };
         },
         getProps () {
-            return defineProps([
+            return layoutWaterProps(defineProps([
                 {
                     name: 'WaveGenerator',
                     description: 'Wave generator used to drive the water surface',
@@ -300,7 +994,8 @@ import '../../../scene/raycast_visitor.js';
                     options: {
                         objectTypes: [
                             FFTWaveGenerator,
-                            FBMWaveGenerator
+                            FBMWaveGenerator,
+                            GerstnerWaveGenerator
                         ]
                     },
                     isNullable () {
@@ -317,6 +1012,26 @@ import '../../../scene/raycast_visitor.js';
                         }
                     }
                 },
+                {
+                    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',
@@ -363,135 +1078,1779 @@ import '../../../scene/raycast_visitor.js';
                     }
                 },
                 {
-                    name: 'DepthScale',
-                    description: 'Depth attenuation scale for the water material',
+                    name: 'Infinite',
+                    description: 'Draw the surface as an unbounded ocean reaching the horizon instead of a body of water ending at the node extent. Reaches the horizon without enlarging the camera far plane, so near-scene depth precision is unaffected. Leave off for ponds, lakes and pools, which have an edge.',
+                    type: 'bool',
+                    default: false,
+                    get (value) {
+                        value.bool[0] = this.infinite;
+                    },
+                    set (value) {
+                        this.infinite = value.bool[0];
+                    }
+                },
+                {
+                    name: 'ViewDistance',
+                    description: 'How far the surface is built out from the camera, in meters, or 0 to derive it from the true horizon distance for the camera height. Keep the sky AerialPerspectiveDistance at least this large, or the far water stops converging towards the sky colour and the hard band comes back.',
                     type: 'float',
-                    default: 10,
+                    default: 0,
                     options: {
-                        animatable: true,
                         minValue: 0,
-                        maxValue: 100
+                        maxValue: 100000
+                    },
+                    isHidden () {
+                        return !this.infinite;
                     },
                     get (value) {
-                        value.num[0] = this.material.depthMulti;
+                        value.num[0] = this.viewDistance;
                     },
                     set (value) {
-                        this.material.depthMulti = value.num[0];
+                        this.viewDistance = value.num[0];
                     }
                 },
                 {
-                    name: 'RefractionStrength',
-                    description: 'Strength of underwater refraction',
+                    name: 'CausticsEnabled',
+                    description: 'Whether the water projects caustics onto the geometry below it',
+                    type: 'bool',
+                    default: true,
+                    get (value) {
+                        value.bool[0] = this.causticsEnabled;
+                    },
+                    set (value) {
+                        this.causticsEnabled = value.bool[0];
+                    }
+                },
+                {
+                    name: 'CausticsIntensity',
+                    description: 'Strength of the caustic contrast',
                     type: 'float',
-                    default: 0,
+                    default: 1,
                     options: {
                         animatable: true,
                         minValue: 0,
-                        maxValue: 1
+                        maxValue: 5
+                    },
+                    isHidden () {
+                        return !this.causticsEnabled;
+                    },
+                    get (value) {
+                        value.num[0] = this.causticsIntensity;
+                    },
+                    set (value) {
+                        this.causticsIntensity = value.num[0];
+                    }
+                },
+                {
+                    name: 'CausticsDepth',
+                    description: 'Depth in meters below the surface where the caustics are in focus',
+                    type: 'float',
+                    default: 4,
+                    options: {
+                        animatable: true,
+                        minValue: 0.01,
+                        maxValue: 100
+                    },
+                    isHidden () {
+                        return !this.causticsEnabled;
                     },
                     get (value) {
-                        value.num[0] = this.material.refractionStrength;
+                        value.num[0] = this.causticsDepth;
                     },
                     set (value) {
-                        this.material.refractionStrength = value.num[0];
+                        this.causticsDepth = value.num[0];
                     }
                 },
                 {
-                    name: 'Displace',
-                    description: 'Vertex displacement scale for water waves',
+                    name: 'CausticsRange',
+                    description: 'Furthest distance in meters from the camera the caustic map reaches',
                     type: 'float',
-                    default: 16,
+                    default: 4,
                     options: {
                         minValue: 1,
-                        maxValue: 256
+                        maxValue: 1000
+                    },
+                    isHidden () {
+                        return !this.causticsEnabled;
                     },
                     get (value) {
-                        value.num[0] = this.material.displace;
+                        value.num[0] = this.causticsRange;
                     },
                     set (value) {
-                        this.material.displace = value.num[0];
+                        this.causticsRange = value.num[0];
                     }
                 },
                 {
-                    name: 'TAAStrength',
-                    description: 'Temporal anti-aliasing strength for the water surface',
+                    name: 'CausticsFadeDistance',
+                    description: 'Width in meters the caustics fade out over at the edge of the map, or 0 to derive it from the range',
                     type: 'float',
-                    default: 0.4,
+                    default: 0,
                     options: {
                         minValue: 0,
-                        maxValue: 1
+                        maxValue: 100
+                    },
+                    isHidden () {
+                        return !this.causticsEnabled;
                     },
                     get (value) {
-                        value.num[0] = this.TAAStrength;
+                        value.num[0] = this.causticsFadeDistance;
                     },
                     set (value) {
-                        this.TAAStrength = value.num[0];
+                        this.causticsFadeDistance = value.num[0];
                     }
                 },
                 {
-                    name: 'ScatterRampTexture',
-                    description: 'Ramp texture used for water scatter lighting',
-                    type: 'object',
-                    default: null,
-                    isNullable () {
-                        return true;
-                    },
+                    name: 'CausticsSceneDepth',
+                    description: 'Land caustics on the scene instead of on a plane at CausticsDepth. Reuses the sun shadow cascade, so it costs no extra geometry pass; WebGL2 keeps the plane, which its shadow map format cannot avoid.',
+                    type: 'bool',
+                    default: true,
                     get (value) {
-                        value.str[0] = manager.getAssetId(this.material.scatterRampTexture) ?? '';
+                        value.bool[0] = this.causticsSceneDepth;
                     },
-                    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.causticsSceneDepth = value.bool[0];
                     }
                 },
                 {
-                    name: 'AbsorptionRampTexture',
-                    description: 'Ramp texture used for water absorption',
-                    type: 'object',
-                    default: null,
-                    isNullable () {
-                        return true;
+                    name: 'CausticsWarp',
+                    description: 'How strongly caustic map texels are concentrated near the camera; ignored while the map already fits the water within range',
+                    type: 'float',
+                    default: 1.5,
+                    options: {
+                        minValue: 0,
+                        maxValue: 8
+                    },
+                    isHidden () {
+                        return !this.causticsEnabled;
                     },
                     get (value) {
-                        value.str[0] = manager.getAssetId(this.material.absorptionRampTexture) ?? '';
+                        value.num[0] = this.causticsWarp;
                     },
-                    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.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.',
+                    type: 'bool',
+                    default: true,
+                    get (value) {
+                        value.bool[0] = this.underwaterEnabled;
+                    },
+                    set (value) {
+                        this.underwaterEnabled = value.bool[0];
+                    }
+                },
+                {
+                    name: 'UnderwaterAmbientIntensity',
+                    description: 'Scale on the downwelling sky light filling the water column. This is what the water fades to in the distance, so it sets how bright the underwater haze reads.',
+                    type: 'float',
+                    default: 1,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 5
+                    },
+                    isHidden () {
+                        return !this.underwaterEnabled;
+                    },
+                    get (value) {
+                        value.num[0] = this.underwaterAmbientIntensity;
+                    },
+                    set (value) {
+                        this.underwaterAmbientIntensity = value.num[0];
+                    }
+                },
+                {
+                    name: 'UnderwaterGodRays',
+                    description: 'Whether shafts of sunlight are marched through the water column. Reads the caustic map as the surface transmittance, so the shafts carry the pattern that lands on the sea bed; needs CausticsEnabled.',
+                    type: 'bool',
+                    default: true,
+                    isHidden () {
+                        return !this.underwaterEnabled;
+                    },
+                    get (value) {
+                        value.bool[0] = this.underwaterGodRays;
+                    },
+                    set (value) {
+                        this.underwaterGodRays = value.bool[0];
+                    }
+                },
+                {
+                    name: 'UnderwaterGodRayIntensity',
+                    description: 'Strength of the light shafts, 1 for the value the medium implies',
+                    type: 'float',
+                    default: 1,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 5
+                    },
+                    isHidden () {
+                        return !this.underwaterEnabled || !this.underwaterGodRays;
+                    },
+                    get (value) {
+                        value.num[0] = this.underwaterGodRayIntensity;
+                    },
+                    set (value) {
+                        this.underwaterGodRayIntensity = value.num[0];
+                    }
+                },
+                {
+                    name: 'UnderwaterGodRaySteps',
+                    description: 'Samples taken along each view ray for the light shafts. Raise it when the shafts read as grain rather than as beams.',
+                    type: 'int',
+                    default: 24,
+                    options: {
+                        minValue: 4,
+                        maxValue: 96
+                    },
+                    isHidden () {
+                        return !this.underwaterEnabled || !this.underwaterGodRays;
+                    },
+                    get (value) {
+                        value.num[0] = this.underwaterGodRaySteps;
+                    },
+                    set (value) {
+                        this.underwaterGodRaySteps = value.num[0];
+                    }
+                },
+                {
+                    name: 'UnderwaterGodRayShadow',
+                    description: 'Whether geometry standing in the water breaks the light shafts. The shafts come from the caustic map, which knows only what the surface did to the sunlight, so without this a shaft runs straight through a piling. Costs a shadow map lookup per march step.',
+                    type: 'bool',
+                    default: false,
+                    isHidden () {
+                        return !this.underwaterEnabled || !this.underwaterGodRays;
+                    },
+                    get (value) {
+                        value.bool[0] = this.underwaterGodRayShadow;
+                    },
+                    set (value) {
+                        this.underwaterGodRayShadow = value.bool[0];
+                    }
+                },
+                {
+                    name: 'UnderwaterHysteresis',
+                    description: 'Half-width in meters of the dead band around the surface the submerged test uses, so a camera at water level does not flip state every frame',
+                    type: 'float',
+                    default: 0.05,
+                    options: {
+                        minValue: 0,
+                        maxValue: 2
+                    },
+                    isHidden () {
+                        return !this.underwaterEnabled;
+                    },
+                    get (value) {
+                        value.num[0] = this.underwaterHysteresis;
+                    },
+                    set (value) {
+                        this.underwaterHysteresis = value.num[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.',
+                    type: 'string',
+                    default: 'march',
+                    options: {
+                        enum: {
+                            labels: [
+                                'March (accurate)',
+                                'Offset (cheap)'
+                            ],
+                            values: [
+                                'march',
+                                'offset'
+                            ]
+                        }
+                    },
+                    get (value) {
+                        value.str[0] = this.material.refractionMode;
+                    },
+                    set (value) {
+                        this.material.refractionMode = value.str[0];
+                    }
+                },
+                {
+                    name: 'DebugOutput',
+                    description: 'Debugging aid: replaces the water colour with one of the shading terms it is built from, so a broken term can be identified by eye',
+                    type: 'string',
+                    default: 'none',
+                    options: {
+                        enum: {
+                            labels: WATER_DEBUG_OUTPUTS.map((e)=>e.label),
+                            values: WATER_DEBUG_OUTPUTS.map((e)=>e.value)
+                        }
+                    },
+                    get (value) {
+                        value.str[0] = this.debugOutput;
+                    },
+                    set (value) {
+                        this.debugOutput = value.str[0];
+                    }
+                },
+                {
+                    name: 'Absorption',
+                    description: 'Absorption coefficient sigma_a of the water medium, per meter, per channel',
+                    type: 'rgb',
+                    default: [
+                        1.0,
+                        0.25,
+                        0.15
+                    ],
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 10
+                    },
+                    get (value) {
+                        value.num[0] = this.material.absorption.x;
+                        value.num[1] = this.material.absorption.y;
+                        value.num[2] = this.material.absorption.z;
+                    },
+                    set (value) {
+                        this.material.absorption = new Vector3(value.num[0], value.num[1], value.num[2]);
+                    }
+                },
+                {
+                    name: 'AbsorptionScale',
+                    description: 'Scale for the absorption coefficient',
+                    type: 'float',
+                    default: 1,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 10
+                    },
+                    get (value) {
+                        value.num[0] = this.material.absorptionScale;
+                    },
+                    set (value) {
+                        this.material.absorptionScale = value.num[0];
+                    }
+                },
+                {
+                    name: 'Scattering',
+                    description: 'Scattering coefficient sigma_s of the water medium, per meter, per channel',
+                    type: 'rgb',
+                    default: [
+                        0.05,
+                        0.12,
+                        0.18
+                    ],
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 10
+                    },
+                    get (value) {
+                        value.num[0] = this.material.scattering.x;
+                        value.num[1] = this.material.scattering.y;
+                        value.num[2] = this.material.scattering.z;
+                    },
+                    set (value) {
+                        this.material.scattering = new Vector3(value.num[0], value.num[1], value.num[2]);
+                    }
+                },
+                {
+                    name: 'ScatteringScale',
+                    description: 'Scale for the scattering coefficient',
+                    type: 'float',
+                    default: 1,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 10
+                    },
+                    get (value) {
+                        value.num[0] = this.material.scatteringScale;
+                    },
+                    set (value) {
+                        this.material.scatteringScale = 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.',
+                    type: 'float',
+                    default: 1,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.material.reflectionStrength;
+                    },
+                    set (value) {
+                        this.material.reflectionStrength = value.num[0];
+                    }
+                },
+                {
+                    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: 0.5,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 10
+                    },
+                    get (value) {
+                        value.num[0] = this.material.subsurfaceIntensity;
+                    },
+                    set (value) {
+                        this.material.subsurfaceIntensity = value.num[0];
+                    }
+                },
+                {
+                    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: 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: 1
+                    },
+                    get (value) {
+                        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.subsurfaceTint = new Vector3(value.num[0], value.num[1], value.num[2]);
+                    }
+                },
+                {
+                    name: 'SunScatteringIntensity',
+                    description: 'Strength of the sunlight scattered out of the water column towards the eye, 1 for the value the medium coefficients imply. This is what makes a shadow on the water darken the water itself and a low sun tint it; 0 leaves the body lit by the environment alone.',
+                    type: 'float',
+                    default: 1,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 4
+                    },
+                    get (value) {
+                        value.num[0] = this.material.sunScatteringIntensity;
+                    },
+                    set (value) {
+                        this.material.sunScatteringIntensity = value.num[0];
+                    }
+                },
+                {
+                    name: 'FoamAmount',
+                    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: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 4
+                    },
+                    get (value) {
+                        value.num[0] = this.material.foamAmount;
+                    },
+                    set (value) {
+                        this.material.foamAmount = value.num[0];
+                    }
+                },
+                {
+                    name: 'FoamFalloff',
+                    description: 'Falloff applied to crest foam coverage. Above 1 pushes light folding towards no foam at all, so only a genuinely broken crest shows - which is what keeps a windy sea from turning uniformly white.',
+                    type: 'float',
+                    default: 1.5,
+                    options: {
+                        animatable: true,
+                        minValue: 0.01,
+                        maxValue: 8
+                    },
+                    isHidden () {
+                        return this.material.foamAmount <= 0;
+                    },
+                    get (value) {
+                        value.num[0] = this.material.foamFalloff;
+                    },
+                    set (value) {
+                        this.material.foamFalloff = value.num[0];
+                    }
+                },
+                {
+                    name: 'FoamColor',
+                    description: 'Diffuse albedo of the foam, shared by the crest foam and the shoreline foam. Slightly off-white and slightly blue - sea foam is water and air, and a pure white one reads as snow.',
+                    type: 'rgb',
+                    default: [
+                        0.92,
+                        0.95,
+                        0.97
+                    ],
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.material.foamColor.x;
+                        value.num[1] = this.material.foamColor.y;
+                        value.num[2] = this.material.foamColor.z;
+                    },
+                    set (value) {
+                        this.material.foamColor = new Vector3(value.num[0], value.num[1], value.num[2]);
+                    }
+                },
+                {
+                    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.4,
+                    options: {
+                        animatable: true,
+                        minValue: 0.001,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.material.foamFeather;
+                    },
+                    set (value) {
+                        this.material.foamFeather = value.num[0];
+                    }
+                },
+                {
+                    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: 3.5,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 30
+                    },
+                    get (value) {
+                        value.num[0] = this.material.foamNormalStrength;
+                    },
+                    set (value) {
+                        this.material.foamNormalStrength = value.num[0];
+                    }
+                },
+                {
+                    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,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.material.foamBubbleColor.x;
+                        value.num[1] = this.material.foamBubbleColor.y;
+                        value.num[2] = this.material.foamBubbleColor.z;
+                    },
+                    set (value) {
+                        this.material.foamBubbleColor = new Vector3(value.num[0], value.num[1], value.num[2]);
+                    }
+                },
+                {
+                    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: 1.68,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 5
+                    },
+                    get (value) {
+                        value.num[0] = this.material.foamBubbleCoverage;
+                    },
+                    set (value) {
+                        this.material.foamBubbleCoverage = value.num[0];
+                    }
+                },
+                {
+                    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.14,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.material.foamBubbleDepth;
+                    },
+                    set (value) {
+                        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: '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: 4,
+                    options: {
+                        animatable: true,
+                        minValue: 0.01,
+                        maxValue: 50
+                    },
+                    get (value) {
+                        value.num[0] = this.material.foamTextureSize;
+                    },
+                    set (value) {
+                        this.material.foamTextureSize = value.num[0];
+                    }
+                },
+                {
+                    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: 1,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 5
+                    },
+                    get (value) {
+                        value.num[0] = this.foamTrailStrength;
+                    },
+                    set (value) {
+                        this.foamTrailStrength = value.num[0];
+                    }
+                },
+                {
+                    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: 0.8,
+                    options: {
+                        animatable: true,
+                        minValue: 0.01,
+                        maxValue: 20
+                    },
+                    get (value) {
+                        value.num[0] = this.foamFadeRate;
+                    },
+                    set (value) {
+                        this.foamFadeRate = value.num[0];
+                    }
+                },
+                {
+                    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: 0.03,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 0.2
+                    },
+                    get (value) {
+                        value.num[0] = this.foamDrift;
+                    },
+                    set (value) {
+                        this.foamDrift = value.num[0];
+                    }
+                },
+                {
+                    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: 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: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.edgeFadeWidth;
+                    },
+                    set (value) {
+                        this.edgeFadeWidth = value.num[0];
+                    }
+                },
+                {
+                    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: 0,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 3
+                    },
+                    isHidden () {
+                        return false;
+                    },
+                    get (value) {
+                        value.num[0] = this.shoreWaveHeight;
+                    },
+                    set (value) {
+                        this.shoreWaveHeight = value.num[0];
+                    }
+                },
+                {
+                    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: 8,
+                    options: {
+                        animatable: true,
+                        minValue: 0.5,
+                        maxValue: 100
+                    },
+                    isHidden () {
+                        return this.shoreWaveHeight <= 0;
+                    },
+                    get (value) {
+                        value.num[0] = this.shoreWaveLength;
+                    },
+                    set (value) {
+                        this.shoreWaveLength = value.num[0];
+                    }
+                },
+                {
+                    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.num[0] = this.shoreWavePeriod;
+                    },
+                    set (value) {
+                        this.shoreWavePeriod = value.num[0];
+                    }
+                },
+                {
+                    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.num[0] = this.shoreWaveZone;
+                    },
+                    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];
                     }
                 }
             ]);
@@ -499,5 +2858,5 @@ import '../../../scene/raycast_visitor.js';
     };
 }
 
-export { getFBMWaveGeneratorClass, getFFTWaveGeneratorClass, getWaterClass };
+export { getFBMWaveGeneratorClass, getFFTWaveGeneratorClass, getGerstnerWaveClass, getGerstnerWaveGeneratorClass, getWaterClass, getWaterDisturberClass, getWaterInteractionClass };
 //# sourceMappingURL=water.js.map