@zephyr3d/scene 0.9.27 → 0.10.0

package/dist/render/water_foam.js

@@ -0,0 +1,627 @@
+import { Disposable, Vector4, Vector2 } from '@zephyr3d/base';
+import { getDevice } from '../app/api.js';
+import { drawFullscreenQuad } from './fullscreenquad.js';
+import { fetchSampler } from '../utility/misc.js';
+import { sampleFoamTexture, getDefaultFoamTexture } from '../utility/textures/foam.js';
+import { ShaderHelper } from '../material/shader/helper.js';
+
+/**
+ * The foam field is stepped as Crest steps its persistent simulations
+ * (UpdateFoam.compute, Wave Harmonic, MIT): FOAM_FIELD_FREQUENCY steps per
+ * second, each advecting the field by the water's velocity, fading it and
+ * adding what the sources make; at most FOAM_FIELD_MAX_STEPS catch up per
+ * frame.
+ */ const FOAM_FIELD_FREQUENCY = 30;
+const FOAM_FIELD_MAX_STEPS = 8;
+/** Crest's flow foam: two samples, each slid for up to FOAM_FLOW_PERIOD seconds and faded across. */ const FOAM_FLOW_PERIOD = 2;
+/**
+ * Levels of the field, laid out as Crest's LODs are: all centred on the view,
+ * each twice the size of the one before at the same number of cells, each
+ * stepped on its own, and an advection that would read off a level reading
+ * the next coarser one instead (UpdateFoam.compute). The material reads the
+ * finest level holding a point, blended into the next over its edge.
+ */ const FOAM_FIELD_LEVELS = 4;
+/** Cells along each side of a level. */ const FOAM_FIELD_CELLS = 256;
+/**
+ * Share of a level, from each edge inwards, over which its coverage falls to
+ * 0, so the foam with memory hands over to the foam without it with no seam.
+ */ const FOAM_FIELD_EDGE_BLEND = 0.15;
+/**
+ * Crest's gain on the foam the waves make (UpdateFoam.compute): foam is added
+ * at FOAM_WAVE_GAIN times the strength times how squeezed the water is, per
+ * second.
+ */ const FOAM_WAVE_GAIN = 5;
+/**
+ * Foam with memory: a scalar field over the water, carried by the water's
+ * velocity, fading over time and fed by its sources. FOAM_FIELD_LEVELS levels
+ * of square grids that the water moves along with the view, each twice the
+ * size of the one before; a move of a grid is carried over in the next step,
+ * new cells starting with what the next coarser level holds there, if any.
+ * @public
+ */ class WaterFoamField extends Disposable {
+    /** Ping-pong pair of arrays, a layer per level: the foam in r, the wall foam in g, the sources' state in ba. */ _arrays;
+    _framebuffers;
+    _current;
+    /** Per level: (origin x, origin z, cell size, cells) as the field holds it; 0 cells before it does. */ _regions;
+    /** Per level: where the grid goes this frame. */ _targets;
+    _programs;
+    _timeToSimulate;
+    _lastTime;
+    /** Clock at which the sources last wrote their per-cell state; negative for never. */ _stateTime;
+    _prewarm;
+    _fadeRate;
+    _size;
+    _baseStrength;
+    _drift;
+    /** Velocity the foam drifts at on the wind, metres per second. */ _driftVelocity;
+    _dummy;
+    /** (dt, fade rate, prewarm, level) */ _params;
+    /** (seconds since the sources' state was written, whether this step writes it, 0, 0) */ _stateParams;
+    /** (clock in seconds, 0, 0, 0) */ _clock;
+    _version;
+    constructor(){
+        super();
+        this._arrays = null;
+        this._framebuffers = null;
+        this._current = 0;
+        this._regions = [];
+        this._targets = [];
+        for(let i = 0; i < FOAM_FIELD_LEVELS; i++){
+            this._regions.push(new Vector4());
+            this._targets.push(new Vector4());
+        }
+        this._programs = new Map();
+        this._timeToSimulate = 0;
+        this._lastTime = -1;
+        this._stateTime = -1;
+        this._prewarm = true;
+        this._fadeRate = 0.8;
+        this._size = 128;
+        this._baseStrength = 1;
+        this._drift = 0.03;
+        this._driftVelocity = new Vector2();
+        this._dummy = null;
+        this._params = new Vector4();
+        this._stateParams = new Vector4();
+        this._clock = new Vector4();
+        this._version = 0;
+    }
+    /** How fast the foam fades, per second (Crest's Foam Fade Rate). */ get fadeRate() {
+        return this._fadeRate;
+    }
+    set fadeRate(val) {
+        this._fadeRate = Math.max(1e-3, val);
+    }
+    /**
+   * Side in metres of the finest level, the square of water around the view
+   * that keeps its foam in the most detail; each further level doubles it.
+   */ get size() {
+        return this._size;
+    }
+    set size(val) {
+        this._size = Math.max(8, val);
+    }
+    /**
+   * Scale of the foam the open water's breaking crests leave behind, as
+   * Crest's Wave Foam Strength: 0 leaves foam only while the crest breaks.
+   */ get baseStrength() {
+        return this._baseStrength;
+    }
+    set baseStrength(val) {
+        this._baseStrength = Math.max(0, val);
+    }
+    /**
+   * Share of the wind speed the foam drifts at. Floating objects drift at
+   * about 3% of the wind relative to the water, about sqrt(rho_air /
+   * rho_water) (Wagner, Dell & Eisenman, "How Winds and Ocean Currents
+   * Influence the Drift of Floating Objects", JPO 52(5), 2022).
+   */ get drift() {
+        return this._drift;
+    }
+    set drift(val) {
+        this._drift = Math.max(0, val);
+    }
+    /** Changes every step, for bind groups that only upload on a change. */ get version() {
+        return this._version;
+    }
+    /**
+   * Places the levels around a point of the water, each on whole cells of its
+   * own so that the field is carried over without resampling while the point
+   * stays put, and steps the field to a clock time there. The time behind is
+   * caught up in fixed steps of 1 / FOAM_FIELD_FREQUENCY; with no step due, a
+   * step of no time still carries the field over to where the grids now lie.
+   * The first step prewarms it.
+   * @param focusX - World x the levels are centred on.
+   * @param focusZ - World z the levels are centred on.
+   * @param time - Clock in seconds.
+   * @param wind - Wind velocity in metres per second, or null for none.
+   * @param source - What feeds the field and carries it.
+   */ stepAround(focusX, focusZ, time, wind, source) {
+        let moved = false;
+        for(let i = 0; i < FOAM_FIELD_LEVELS; i++){
+            const size = this._size * (1 << i);
+            const cell = size / FOAM_FIELD_CELLS;
+            const half = size * 0.5;
+            this._targets[i].setXYZW(Math.floor((focusX - half) / cell) * cell, Math.floor((focusZ - half) / cell) * cell, cell, FOAM_FIELD_CELLS);
+            moved = moved || !this._regions[i].equalsTo(this._targets[i]);
+        }
+        this._driftVelocity.setXY((wind?.x ?? 0) * this._drift, (wind?.y ?? 0) * this._drift);
+        const device = getDevice();
+        this.ensureArrays(device);
+        const dt = this._lastTime < 0 ? 0 : Math.min(Math.max(time - this._lastTime, 0), 0.25);
+        this._lastTime = time;
+        // The clock carries the foam texture along; readers see it every frame
+        this._clock.x = time;
+        this._version++;
+        this._timeToSimulate += dt;
+        let steps = Math.floor(this._timeToSimulate * FOAM_FIELD_FREQUENCY);
+        let stepDt = 1 / FOAM_FIELD_FREQUENCY;
+        if (steps > FOAM_FIELD_MAX_STEPS) {
+            steps = FOAM_FIELD_MAX_STEPS;
+            this._timeToSimulate = 0;
+        } else {
+            this._timeToSimulate -= steps * stepDt;
+        }
+        if (steps === 0) {
+            if (!moved && !this._prewarm) {
+                return;
+            }
+            steps = 1;
+            stepDt = 0;
+        }
+        const { program, bindGroup } = this.getStepProgram(device, source);
+        source.applyFoamSourceBindGroup(bindGroup);
+        bindGroup.setValue('ffDrift', this._driftVelocity);
+        // The sources' state is of the water as it is this frame, which every step
+        // of the frame sees alike: it is read as of the last frame that wrote it
+        // and written at the frame's last step
+        const sinceState = this._stateTime < 0 ? 0 : Math.max(time - this._stateTime, 0);
+        const sampler = fetchSampler('clamp_linear_nomip');
+        device.pushDeviceStates();
+        for(let step = 0; step < steps; step++){
+            const fb = this._framebuffers[1 - this._current];
+            bindGroup.setTexture('ffSrc', this._arrays[this._current], sampler);
+            this._stateParams.setXYZW(sinceState, step === steps - 1 ? 1 : 0, 0, 0);
+            bindGroup.setValue('ffState', this._stateParams);
+            for(let i = 0; i < FOAM_FIELD_LEVELS; i++){
+                // Only the first step carries the field across a move of the grids
+                const prev = step === 0 ? this._regions : this._targets;
+                bindGroup.setValue('ffRegion', this._targets[i]);
+                bindGroup.setValue('ffPrevRegion', prev[i]);
+                bindGroup.setValue('ffPrevRegionNext', i + 1 < FOAM_FIELD_LEVELS ? prev[i + 1] : Vector4.zero());
+                this._params.setXYZW(stepDt, this._fadeRate, this._prewarm ? 1 : 0, i);
+                bindGroup.setValue('ffParams', this._params);
+                fb.setColorAttachmentLayer(0, i);
+                device.setFramebuffer(fb);
+                device.setProgram(program);
+                device.setBindGroup(0, bindGroup);
+                drawFullscreenQuad();
+            }
+            this._current = 1 - this._current;
+            this._prewarm = false;
+        }
+        device.popDeviceStates();
+        for(let i = 0; i < FOAM_FIELD_LEVELS; i++){
+            this._regions[i].set(this._targets[i]);
+        }
+        this._stateTime = time;
+    }
+    /** Declares the uniforms {@link WaterFoamField.sample} reads. */ setupUniforms(scope, uniformGroup) {
+        const pb = scope.$builder;
+        scope.ffTex = pb.tex2DArray().uniform(uniformGroup);
+        for(let i = 0; i < FOAM_FIELD_LEVELS; i++){
+            // (origin x, origin z, cell size, cells; 0 cells before the level exists)
+            scope[`ffRegion${i}`] = pb.vec4().uniform(uniformGroup);
+        }
+        scope.ffDrift = pb.vec2().uniform(uniformGroup);
+        scope.ffClock = pb.vec4().uniform(uniformGroup);
+    }
+    /** Sets the uniforms {@link WaterFoamField.setupUniforms} declared. */ applyBindGroup(bindGroup) {
+        bindGroup.setTexture('ffTex', this._arrays ? this._arrays[this._current] : this.getDummy(), fetchSampler('clamp_linear_nomip'));
+        for(let i = 0; i < FOAM_FIELD_LEVELS; i++){
+            bindGroup.setValue(`ffRegion${i}`, this._arrays ? this._regions[i] : Vector4.zero());
+        }
+        bindGroup.setValue('ffDrift', this._driftVelocity);
+        bindGroup.setValue('ffClock', this._clock);
+    }
+    /**
+   * The field at an undisplaced XZ, as vec3(foam density, coverage, wall
+   * foam). The finest level holding the point answers, blended into the next
+   * coarser over the last FOAM_FIELD_EDGE_BLEND of it; coverage falls to 0 over
+   * that share of the coarsest level and is 0 off it, where the reader falls
+   * back to foam with no memory.
+   */ sample(scope, xz) {
+        const pb = scope.$builder;
+        pb.func('ffSample', [
+            pb.vec2('xz')
+        ], function() {
+            this.$l.result = pb.vec3(0);
+            // Share of the answer still to come from coarser levels
+            this.$l.remaining = pb.float(1);
+            for(let i = 0; i < FOAM_FIELD_LEVELS; i++){
+                const r = this[`ffRegion${i}`];
+                this.$l[`uv${i}`] = pb.div(pb.sub(this.xz, r.xy), pb.max(pb.mul(r.z, r.w), 1e-4));
+                const uv = this[`uv${i}`];
+                this.$l[`edge${i}`] = pb.min(pb.min(uv.x, uv.y), pb.min(pb.sub(1, uv.x), pb.sub(1, uv.y)));
+                const edge = this[`edge${i}`];
+                this.$if(pb.and(pb.greaterThan(this.remaining, 0), pb.and(pb.greaterThan(r.w, 0), pb.greaterThan(edge, 0))), function() {
+                    this.$l.w = pb.mul(this.remaining, pb.smoothStep(0, FOAM_FIELD_EDGE_BLEND, edge));
+                    this.$l.texel = pb.textureArraySampleLevel(this.ffTex, uv, i, 0);
+                    this.result = pb.add(this.result, pb.mul(pb.vec3(this.texel.r, 1, this.texel.g), this.w));
+                    this.remaining = pb.sub(this.remaining, this.w);
+                });
+            }
+            this.$return(this.result);
+        });
+        return scope.ffSample(xz);
+    }
+    /**
+   * The foam texture carried by the water, as Crest's ComputeFoamWithFlow:
+   * two samples, each slid along the flow for up to FOAM_FLOW_PERIOD seconds
+   * and then set back, half a period apart, faded across so neither jump
+   * shows. Returns (value, slope along x, slope along z) as
+   * {@link sampleFoamTexture} does.
+   * @param time - Clock in seconds.
+   * @param flow - Velocity of the water in metres per second.
+   */ static flowPattern(scope, tex, uvScale, time, xz, xzGrad, flow) {
+        const pb = scope.$builder;
+        pb.func('ffFlowPattern', [
+            pb.vec2('xz'),
+            pb.vec4('xzGrad'),
+            pb.vec2('flow'),
+            pb.float('time'),
+            pb.float('uvScale')
+        ], function() {
+            const half = FOAM_FLOW_PERIOD * 0.5;
+            this.$l.offset1 = pb.mod(this.time, FOAM_FLOW_PERIOD);
+            this.$l.weight1 = pb.div(this.offset1, half);
+            this.weight1 = this.$choice(pb.greaterThan(this.weight1, 1), pb.sub(2, this.weight1), this.weight1);
+            this.$l.offset2 = pb.mod(pb.add(this.time, half), FOAM_FLOW_PERIOD);
+            this.$l.s1 = sampleFoamTexture(this, tex, pb.mul(pb.sub(this.xz, pb.mul(this.flow, this.offset1)), this.uvScale), this.xzGrad, this.uvScale);
+            this.$l.s2 = sampleFoamTexture(this, tex, pb.mul(pb.sub(this.xz, pb.mul(this.flow, this.offset2)), this.uvScale), this.xzGrad, this.uvScale);
+            this.$return(pb.mix(this.s2, this.s1, this.weight1));
+        });
+        return scope.ffFlowPattern(xz, xzGrad, flow, time, uvScale);
+    }
+    onDispose() {
+        super.onDispose();
+        this.disposeArrays();
+        for (const p of this._programs.values()){
+            p.program.dispose();
+            p.bindGroup.dispose();
+        }
+        this._programs.clear();
+        this._dummy?.dispose();
+        this._dummy = null;
+    }
+    /** @internal */ ensureArrays(device) {
+        if (this._arrays) {
+            return;
+        }
+        const createArray = (name)=>{
+            const tex = device.createTexture2DArray('rgba16f', FOAM_FIELD_CELLS, FOAM_FIELD_CELLS, FOAM_FIELD_LEVELS, {
+                mipmapping: false
+            });
+            tex.name = name;
+            const fb = device.createFrameBuffer([
+                tex
+            ], null);
+            for(let i = 0; i < FOAM_FIELD_LEVELS; i++){
+                fb.setColorAttachmentLayer(0, i);
+                device.setFramebuffer(fb);
+                device.clearFrameBuffer(Vector4.zero(), null, null);
+            }
+            fb.dispose();
+            return tex;
+        };
+        device.pushDeviceStates();
+        try {
+            this._arrays = [
+                createArray('@WaterFoamField0'),
+                createArray('@WaterFoamField1')
+            ];
+            this._current = 0;
+            for (const r of this._regions){
+                r.setXYZW(0, 0, 0, 0);
+            }
+            this._prewarm = true;
+            this._stateTime = -1;
+            this._framebuffers = [
+                0,
+                1
+            ].map((i)=>device.createFrameBuffer([
+                    this._arrays[i]
+                ], null));
+        } finally{
+            device.popDeviceStates();
+        }
+    }
+    /** @internal */ getStepProgram(device, source) {
+        const programKey = source.foamSourceKey;
+        let entry = this._programs.get(programKey);
+        if (!entry) {
+            const program = device.buildRenderProgram({
+                vertex (pb) {
+                    this.$inputs.pos = pb.vec2().attrib('position');
+                    pb.main(function() {
+                        this.$builtins.position = pb.vec4(this.$inputs.pos, 0, 1);
+                    });
+                },
+                fragment (pb) {
+                    this.$outputs.outColor = pb.vec4();
+                    source.setupFoamSourceUniforms(this);
+                    this.ffSrc = pb.tex2DArray().uniform(0);
+                    this.ffRegion = pb.vec4().uniform(0);
+                    // Where this level and the next coarser one lay at the last step; 0 cells for none
+                    this.ffPrevRegion = pb.vec4().uniform(0);
+                    this.ffPrevRegionNext = pb.vec4().uniform(0);
+                    // (dt, fade rate, prewarm, level)
+                    this.ffParams = pb.vec4().uniform(0);
+                    this.ffDrift = pb.vec2().uniform(0);
+                    // (seconds since the sources' state was written, whether this step writes it, 0, 0)
+                    this.ffState = pb.vec4().uniform(0);
+                    // A point of a level as it was: its uv, and whether the level held it
+                    pb.func('ffPrevUV', [
+                        pb.vec2('wp'),
+                        pb.vec4('region')
+                    ], function() {
+                        this.$l.uv = pb.div(pb.sub(this.wp, this.region.xy), pb.max(pb.mul(this.region.z, this.region.w), 1e-4));
+                        this.$l.rMax = pb.sub(0.5, pb.div(1, pb.max(this.region.w, 1)));
+                        this.$l.r = pb.abs(pb.sub(this.uv, pb.vec2(0.5)));
+                        this.$return(pb.vec3(this.uv, this.$choice(pb.and(pb.greaterThan(this.region.w, 0), pb.lessThanEqual(pb.max(this.r.x, this.r.y), this.rMax)), pb.float(1), pb.float(0))));
+                    });
+                    pb.main(function() {
+                        this.$l.dt = this.ffParams.x;
+                        this.$l.fadeRate = this.ffParams.y;
+                        this.$l.prewarm = pb.greaterThan(this.ffParams.z, 0.5);
+                        this.$l.level = pb.int(this.ffParams.w);
+                        // World position of this cell's centre
+                        this.$l.xz = pb.add(this.ffRegion.xy, pb.mul(this.$builtins.fragCoord.xy, this.ffRegion.z));
+                        // The sources' state stays with the cell: from the same place, on
+                        // the grid as it was, where that grid held it
+                        this.$l.stateAt = this.ffPrevUV(this.xz, this.ffPrevRegion);
+                        this.$l.prevState = pb.vec2(0);
+                        this.$l.stateAge = pb.float(-1);
+                        this.$if(pb.greaterThan(this.stateAt.z, 0.5), function() {
+                            this.prevState = pb.textureArraySampleLevel(this.ffSrc, this.stateAt.xy, this.level, 0).ba;
+                            this.$if(pb.and(pb.not(this.prewarm), pb.greaterThan(this.ffState.x, 0)), function() {
+                                this.stateAge = this.ffState.x;
+                            });
+                        });
+                        this.$l.state = pb.vec4(this.prevState, 0, this.stateAge);
+                        this.$l.shape = pb.vec2(0, 1);
+                        this.$l.src = source.calcFoamStep(this, this.xz, this.dt, this.fadeRate, this.prewarm, this.state, this.shape);
+                        // Sample from the previous step, upstream of the flow: this level as
+                        // it was, else the next coarser one, nothing where neither held it
+                        this.$l.flowed = pb.sub(this.xz, pb.mul(this.src.xy, this.dt));
+                        this.$l.at = this.ffPrevUV(this.flowed, this.ffPrevRegion);
+                        // (foam, wall foam)
+                        this.$l.foam = pb.vec2(0);
+                        this.$if(pb.greaterThan(this.at.z, 0.5), function() {
+                            this.foam = pb.textureArraySampleLevel(this.ffSrc, this.at.xy, this.level, 0).rg;
+                        }).$else(function() {
+                            this.$l.atNext = this.ffPrevUV(this.flowed, this.ffPrevRegionNext);
+                            this.$if(pb.greaterThan(this.atNext.z, 0.5), function() {
+                                this.foam = pb.textureArraySampleLevel(this.ffSrc, this.atNext.xy, pb.add(this.level, 1), 0).rg;
+                            });
+                        });
+                        // Fade, then what the sources make
+                        this.foam = pb.mul(this.foam, pb.max(0, pb.sub(1, pb.mul(this.fadeRate, pb.max(this.shape.y, 0), this.dt))));
+                        this.foam = pb.add(this.foam, this.src.zw);
+                        // At least what the source knows is here
+                        this.foam.x = pb.max(this.foam.x, pb.clamp(this.shape.x, 0, 1));
+                        this.$outputs.outColor = pb.vec4(pb.clamp(this.foam, pb.vec2(0), pb.vec2(1)), this.$choice(pb.greaterThan(this.ffState.y, 0.5), this.state.xy, this.prevState));
+                    });
+                }
+            });
+            program.name = `@WaterFoamFieldStep:${programKey}`;
+            entry = {
+                program,
+                bindGroup: device.createBindGroup(program.bindGroupLayouts[0])
+            };
+            this._programs.set(programKey, entry);
+        }
+        return entry;
+    }
+    /** @internal */ disposeArrays() {
+        this._framebuffers?.forEach((fb)=>fb.dispose());
+        this._framebuffers = null;
+        this._arrays?.forEach((tex)=>tex.dispose());
+        this._arrays = null;
+    }
+    /** @internal */ getDummy() {
+        if (!this._dummy) {
+            this._dummy = getDevice().createTexture2DArray('rgba16f', 1, 1, 1, {
+                mipmapping: false
+            });
+        }
+        return this._dummy;
+    }
+}
+/**
+ * The open water's share of the foam field: foam left where the wrapped
+ * generator's crests break, drifting on the wind. Crest feeds its foam
+ * simulation from the Jacobian of its animated waves the same way
+ * (UpdateFoam.compute); here the generator's own foam density stands for the
+ * squeeze, so the field is fed by the same crests the generator shows foam on.
+ * @internal
+ */ class WaveFoamSource {
+    _generator;
+    _field;
+    /** (strength, 0, 0, 0) */ _sourceParams;
+    foamSourceKey;
+    constructor(generator, field){
+        this._generator = generator;
+        this._field = field;
+        this._sourceParams = new Vector4();
+        this.foamSourceKey = `WG:${generator?.getHash() ?? ''}`;
+    }
+    setupFoamSourceUniforms(scope) {
+        const pb = scope.$builder;
+        if (this._generator) {
+            this._generator.setupUniforms(scope, 0);
+            // FBM and Gerstner animate from camera.elapsedTime, which a standalone
+            // program has to declare itself
+            ShaderHelper.declareStandaloneCameraTime(scope, 0);
+        }
+        scope.wgFoamSource = pb.vec4().uniform(0);
+    }
+    applyFoamSourceBindGroup(bindGroup) {
+        if (this._generator) {
+            this._generator.applyWaterBindGroup(bindGroup);
+            ShaderHelper.setStandaloneCameraTime(bindGroup);
+        }
+        this._sourceParams.setXYZW(this._field.baseStrength, 0, 0, 0);
+        bindGroup.setValue('wgFoamSource', this._sourceParams);
+    }
+    calcFoamStep(scope, xz, dt, fadeRate, prewarm, _state, _shape) {
+        const pb = scope.$builder;
+        const that = this;
+        pb.func('wgFoamStep', [
+            pb.vec2('xz'),
+            pb.float('dt'),
+            pb.float('fadeRate'),
+            pb.bool('prewarm')
+        ], function() {
+            this.$l.strength = this.wgFoamSource.x;
+            this.$l.density = pb.float(0);
+            if (that._generator) {
+                this.density = pb.clamp(that._generator.calcFragmentNormalAndFoam(this, this.xz, pb.vec3(0, 1, 0)).w, 0, 1);
+            }
+            // Crest's prewarm of the wave source
+            this.$l.waveDt = this.$choice(this.prewarm, pb.max(this.dt, pb.div(pb.min(1, pb.sub(this.strength, 1)), this.fadeRate)), this.dt);
+            this.$return(pb.vec4(this.ffDrift, pb.mul(FOAM_WAVE_GAIN, this.waveDt, this.strength, this.density), 0));
+        });
+        return scope.wgFoamStep(xz, dt, fadeRate, prewarm);
+    }
+}
+/**
+ * Layers the foam field over the generator it wraps: inside the field the foam
+ * is the field's, which the generator feeds and so must not add a second
+ * time, and the foam texture travels with the water; off the field the
+ * generator's foam shows unchanged. Wraps the base generator, below the
+ * interaction field and the shore waves, whose foam is composed over it.
+ * @internal
+ */ class FoamFieldWaveGenerator extends Disposable {
+    _base;
+    _field;
+    _look;
+    /** Velocity of the water from the drift, from the shore waves while they are on. */ flowSource;
+    calcPrevVertexPosition;
+    calcSurfaceCoverage;
+    calcSheetThickness;
+    calcUnresolvedSlopeVariance;
+    constructor(base, field, look){
+        super();
+        this._base = base;
+        this._field = field;
+        this._look = look;
+        this.flowSource = null;
+        // Optional parts of the surface pass straight through, present only where
+        // the base has them
+        if (base.calcPrevVertexPosition) {
+            this.calcPrevVertexPosition = base.calcPrevVertexPosition.bind(base);
+        }
+        if (base.calcSurfaceCoverage) {
+            this.calcSurfaceCoverage = base.calcSurfaceCoverage.bind(base);
+        }
+        if (base.calcSheetThickness) {
+            this.calcSheetThickness = base.calcSheetThickness.bind(base);
+        }
+        if (base.calcUnresolvedSlopeVariance) {
+            this.calcUnresolvedSlopeVariance = base.calcUnresolvedSlopeVariance.bind(base);
+        }
+    }
+    /** The generator the field is layered over. */ get base() {
+        return this._base;
+    }
+    /** The foam field. */ get field() {
+        return this._field;
+    }
+    get wind() {
+        return this._base.wind;
+    }
+    clone() {
+        return new FoamFieldWaveGenerator(this._base.clone(), this._field, this._look);
+    }
+    get version() {
+        return this._base.version + this._field.version;
+    }
+    setupUniforms(scope, uniformGroup) {
+        const pb = scope.$builder;
+        this._base.setupUniforms(scope, uniformGroup);
+        this._field.setupUniforms(scope, uniformGroup);
+        scope.ffFoamTex = pb.tex2D().uniform(uniformGroup);
+        scope.ffFoamUVScale = pb.float().uniform(uniformGroup);
+    }
+    calcVertexPositionAndNormal(scope, inPos, outPos, outNormal, vertexSpacing) {
+        this._base.calcVertexPositionAndNormal(scope, inPos, outPos, outNormal, vertexSpacing);
+    }
+    calcFragmentNormal(scope, xz, vertexNormal) {
+        return this._base.calcFragmentNormal(scope, xz, vertexNormal);
+    }
+    calcFragmentNormalAndFoam(scope, xz, vertexNormal, foamSample, footprint) {
+        const pb = scope.$builder;
+        const that = this;
+        const params = [
+            pb.vec2('xz'),
+            pb.vec3('vn')
+        ];
+        const args = [
+            xz,
+            vertexNormal
+        ];
+        if (foamSample) {
+            params.push(pb.vec3('fs').inout());
+            args.push(foamSample);
+        }
+        if (footprint) {
+            params.push(pb.vec4('fp'));
+            args.push(footprint);
+        }
+        const funcName = `ffCalcNormalAndFoam${foamSample ? 'S' : ''}${footprint ? 'F' : ''}`;
+        pb.func(funcName, params, function() {
+            // Screen derivatives for the foam texture, here in uniform control flow
+            if (foamSample) {
+                this.$l.xzGrad = pb.vec4(pb.dpdx(this.xz), pb.dpdy(this.xz));
+            }
+            this.$l.nf = that._base.calcFragmentNormalAndFoam(this, this.xz, this.vn, foamSample ? this.fs : undefined, footprint ? this.fp : undefined);
+            this.$l.ff = that._field.sample(this, this.xz);
+            this.$l.ffTotal = pb.clamp(this.ff.x, 0, 1);
+            if (foamSample) {
+                // Carried by the water: the texture travels with the field's foam.
+                // Over the whole field, not only where it holds foam: the flow source
+                // may show foam the field lacks (the near shore), on this pattern.
+                this.$if(pb.greaterThan(this.ff.y, 0), function() {
+                    this.$l.flow = that.flowSource ? that.flowSource.calcFoamFlow(this, this.xz, this.ffDrift) : this.ffDrift;
+                    this.$l.pattern = WaterFoamField.flowPattern(this, this.ffFoamTex, this.ffFoamUVScale, this.ffClock.x, this.xz, this.xzGrad, this.flow);
+                    this.fs = pb.mix(this.fs, this.pattern, this.ff.y);
+                });
+            }
+            this.$return(pb.vec4(this.nf.xyz, pb.mix(pb.clamp(this.nf.w, 0, 1), this.ffTotal, this.ff.y)));
+        });
+        return scope[funcName](...args);
+    }
+    applyWaterBindGroup(bindGroup) {
+        this._base.applyWaterBindGroup(bindGroup);
+        this._field.applyBindGroup(bindGroup);
+        bindGroup.setTexture('ffFoamTex', this._look.getFoamTexture() ?? getDefaultFoamTexture(), fetchSampler('repeat_linear'));
+        bindGroup.setValue('ffFoamUVScale', 1 / Math.max(0.01, this._look.getFoamTextureSize()));
+    }
+    calcClipmapTileAABB(minX, maxX, minZ, maxZ, y, outAABB) {
+        this._base.calcClipmapTileAABB(minX, maxX, minZ, maxZ, y, outAABB);
+    }
+    /** The material steps the base generator and the field; nothing to do here. */ update() {}
+    getHash() {
+        return `${this._base.getHash()}:FF`;
+    }
+    needUpdate() {
+        return true;
+    }
+    isOk(device) {
+        return this._base.isOk(device);
+    }
+}
+
+export { FOAM_WAVE_GAIN, FoamFieldWaveGenerator, WaterFoamField, WaveFoamSource };
+//# sourceMappingURL=water_foam.js.map