@zephyr3d/scene 0.9.27 → 0.10.0

package/dist/scene/water_surface_sampler.js

@@ -0,0 +1,324 @@
+import { Vector3 } from '@zephyr3d/base';
+
+/**
+ * Height queries against a water surface, driven by the material's own
+ * evaluation of it.
+ *
+ * {@link Water.getSurfacePoint} evaluates the GPU displacement itself, so the
+ * result is exact by construction rather than a CPU re-implementation of the
+ * waves. By default it includes ambient waves and external interaction
+ * impulses, but excludes disturber wakes to prevent buoyancy feeding itself.
+ * Set includeDisturbers for queries that need the complete rendered surface.
+ * Each batch costs one point-list draw and one readback, so queries are
+ * batched and throttled rather than issued per call.
+ *
+ * The queries are placed on a fixed lattice at construction; the whole set
+ * costs one draw and one readback and the answer is interpolated across the
+ * lattice on demand. Moving positions (a hull's footprint, say) ride along
+ * through {@link addExtraPoints}.
+ *
+ * ## The motion
+ *
+ * The reported height eases exponentially towards the newest measurement; the
+ * query lag is not compensated. A rigid body should read
+ * {@link sampleWorldYRaw} instead and supply its own inertia.
+ *
+ * Consequences a caller has to accept:
+ * - Resolution is the lattice spacing. A grid at `h` metres resolves nothing
+ *   shorter than about `2 * h`.
+ * - A probe outside the lattice is answered by the nearest cell rather than by
+ *   a wrapped one; this is a window on the water, not a repeating field.
+ * - Nothing is known until the first batch lands; until then queries return
+ *   the still-water level.
+ *
+ * @public
+ */ class WaterSurfaceSampler {
+    _water;
+    _includeDisturbers;
+    _spacing;
+    _cols;
+    _rows;
+    _updateHz;
+    _timeConstant;
+    _pending;
+    _elapsed;
+    _waveTime;
+    _readCount;
+    _failCount;
+    _totalPoints;
+    _pendingSince;
+    _lastLatency;
+    _batchFrames;
+    _framesSinceLastBatch;
+    _originX;
+    _originZ;
+    _inputs;
+    _outPos;
+    _extraListeners;
+    _batchInputs;
+    _batchOutputs;
+    _extrasDirty;
+    /** Heights the queries read; null until the first batch. */ _height;
+    /** Where the newest measurement put the surface. */ _target;
+    /**
+   * Creates a sampler over a body of water.
+   * @param water - The water to sample.
+   * @param options - Lattice and rate options.
+   */ constructor(water, options = {}){
+        this._water = water;
+        this._includeDisturbers = options.includeDisturbers ?? false;
+        this._spacing = Math.max(0.01, options.spacing ?? 6);
+        this._cols = Math.max(2, Math.floor(options.cols ?? 24));
+        this._rows = Math.max(2, Math.floor(options.rows ?? 24));
+        this._updateHz = Math.max(0.1, options.updateHz ?? 30);
+        this._timeConstant = Math.max(0.001, options.timeConstant ?? 0.25);
+        this._pending = false;
+        this._elapsed = 0;
+        this._waveTime = 0;
+        this._readCount = 0;
+        this._failCount = 0;
+        this._totalPoints = 0;
+        this._pendingSince = 0;
+        this._lastLatency = 0;
+        this._batchFrames = 0;
+        this._framesSinceLastBatch = 0;
+        // The lattice is anchored on the water's origin, in world space.
+        const ox = water.worldMatrix.m03;
+        const oz = water.worldMatrix.m23;
+        this._originX = ox - (this._cols - 1) / 2 * this._spacing;
+        this._originZ = oz - (this._rows - 1) / 2 * this._spacing;
+        const count = this._cols * this._rows;
+        this._inputs = new Array(count);
+        this._outPos = new Array(count);
+        for(let j = 0; j < this._rows; j++){
+            for(let i = 0; i < this._cols; i++){
+                const k = j * this._cols + i;
+                this._inputs[k] = new Vector3(this._originX + i * this._spacing, 0, this._originZ + j * this._spacing);
+                this._outPos[k] = new Vector3();
+            }
+        }
+        this._extraListeners = [];
+        this._batchInputs = this._inputs;
+        this._batchOutputs = this._outPos;
+        this._extrasDirty = false;
+        this._height = null;
+        this._target = null;
+    }
+    /** Water clock of the newest accepted batch, in seconds. */ get waveTime() {
+        return this._waveTime;
+    }
+    /**
+   * Upper bound on the query rate in hertz.
+   *
+   * A ceiling, not a schedule: the achieved rate is also limited by batch cost.
+   */ get updateHz() {
+        return this._updateHz;
+    }
+    set updateHz(val) {
+        this._updateHz = Math.max(0.1, val);
+    }
+    /**
+   * Seconds for the reported height to close most of the gap to a new
+   * measurement. Independent of frame rate.
+   */ get timeConstant() {
+        return this._timeConstant;
+    }
+    set timeConstant(val) {
+        this._timeConstant = Math.max(0.001, val);
+    }
+    /** Batches completed since construction. */ get readCount() {
+        return this._readCount;
+    }
+    /** Batches that failed. */ get failCount() {
+        return this._failCount;
+    }
+    /** True while a batch is in flight. */ get pending() {
+        return this._pending;
+    }
+    /** Seconds the batch in flight has been outstanding, or 0 when none is. */ get pendingSeconds() {
+        return this._pending ? this._pendingSince : 0;
+    }
+    /** Batch latency in seconds, as of the last one that landed. */ get lastLatency() {
+        return this._lastLatency;
+    }
+    /** Frames the newest batch took to come back. */ get batchFrames() {
+        return this._batchFrames;
+    }
+    /** Points evaluated per batch, the cost driver of this sampler. */ get batchSize() {
+        return this._totalPoints;
+    }
+    /** True once a batch has landed and queries return surface heights. */ get ready() {
+        return !!this._height;
+    }
+    /** World metres between lattice samples. */ get spacing() {
+        return this._spacing;
+    }
+    /** World Y of the still-water level. */ get waterLevel() {
+        return this._water.worldMatrix.m13;
+    }
+    /**
+   * Register world positions to evaluate alongside the lattice, every batch.
+   *
+   * The array is held by reference and read when a batch is issued, so a
+   * caller updates the vectors in place each frame and the next batch picks
+   * them up. The listener receives the surface positions for those inputs when
+   * the batch lands, in the same order.
+   *
+   * @param inputs - World positions; only X and Z are used.
+   * @param onResult - Called per batch with the surface positions.
+   * @returns A function that unregisters the points.
+   */ addExtraPoints(inputs, onResult) {
+        const outputs = inputs.map(()=>new Vector3());
+        const entry = {
+            inputs,
+            outputs,
+            onResult
+        };
+        this._extraListeners.push(entry);
+        this._extrasDirty = true;
+        return ()=>{
+            const i = this._extraListeners.indexOf(entry);
+            if (i >= 0) {
+                this._extraListeners.splice(i, 1);
+                this._extrasDirty = true;
+            }
+        };
+    }
+    /**
+   * Advance the sampler. Call once per frame with the frame's delta.
+   * @param deltaSeconds - Frame delta in seconds.
+   */ update(deltaSeconds) {
+        this._framesSinceLastBatch++;
+        // Ease once a frame so every query in a frame sees the same value; exact
+        // exponential decay keeps the result independent of frame size.
+        if (this._height && this._target) {
+            const k = 1 - Math.exp(-deltaSeconds / this._timeConstant);
+            const height = this._height;
+            const target = this._target;
+            for(let i = 0; i < height.length; i++){
+                height[i] += (target[i] - height[i]) * k;
+            }
+        }
+        if (this._pending) {
+            this._pendingSince += deltaSeconds;
+            return;
+        }
+        this._elapsed += deltaSeconds;
+        // Fire as soon as the previous batch has landed, capped at `updateHz`.
+        if (this._elapsed >= 1 / this._updateHz) {
+            this._elapsed = 0;
+            this._pending = true;
+            this._pendingSince = 0;
+            this._rebuildBatchArrays();
+            this._totalPoints = this._batchInputs.length;
+            // Only positions: the normal attachment would double the readback.
+            this._water.getSurfacePoint(this._batchInputs, this._batchOutputs, undefined, this._includeDisturbers).then(()=>this._acceptBatch()).catch((err)=>{
+                this._pending = false;
+                this._pendingSince = 0;
+                this._failCount++;
+                console.error('WaterSurfaceSampler: surface query failed', err);
+            });
+        }
+    }
+    /**
+   * Surface world Y at a world XZ, eased.
+   *
+   * Bilinear over the lattice, clamped at the edges. A pure lookup of the table
+   * advanced by {@link update}. For objects placed directly at the height,
+   * without inertia of their own.
+   */ sampleWorldY(x, z) {
+        return this._sampleTable(this._height, x, z);
+    }
+    /**
+   * Surface world Y at a world XZ, from the newest measurement with no easing.
+   *
+   * For a rigid body, which would otherwise get the easing lag on top of the
+   * query lag.
+   */ sampleWorldYRaw(x, z) {
+        return this._sampleTable(this._target, x, z);
+    }
+    /**
+   * Surface normal from the eased lattice, by central differences one cell
+   * apart.
+   * @param out - Destination, or a new vector.
+   * @returns Unit normal, Y up.
+   */ sampleNormal(x, z, out) {
+        const h = this._spacing;
+        const dx = this.sampleWorldY(x + h, z) - this.sampleWorldY(x - h, z);
+        const dz = this.sampleWorldY(x, z + h) - this.sampleWorldY(x, z - h);
+        const nx = -dx / (2 * h);
+        const nz = -dz / (2 * h);
+        const len = Math.hypot(nx, 1, nz);
+        return (out ?? new Vector3()).setXYZ(nx / len, 1 / len, nz / len);
+    }
+    /** @internal */ _rebuildBatchArrays() {
+        if (!this._extrasDirty) {
+            return;
+        }
+        this._extrasDirty = false;
+        if (this._extraListeners.length === 0) {
+            this._batchInputs = this._inputs;
+            this._batchOutputs = this._outPos;
+            return;
+        }
+        const inputs = this._inputs.slice();
+        const outputs = this._outPos.slice();
+        for (const entry of this._extraListeners){
+            for(let i = 0; i < entry.inputs.length; i++){
+                inputs.push(entry.inputs[i]);
+                outputs.push(entry.outputs[i]);
+            }
+        }
+        this._batchInputs = inputs;
+        this._batchOutputs = outputs;
+    }
+    /**
+   * Point the sampler at a batch that just landed. The measurement becomes the
+   * target the reported height eases towards; the first batch is adopted
+   * outright, since there is no previous surface to ease from.
+   * @internal
+   */ _acceptBatch() {
+        this._pending = false;
+        this._lastLatency = this._pendingSince;
+        this._pendingSince = 0;
+        this._elapsed = 0;
+        const count = this._outPos.length;
+        if (!this._target) {
+            this._target = new Float32Array(count);
+            for(let i = 0; i < count; i++){
+                this._target[i] = this._outPos[i].y;
+            }
+            this._height = this._target.slice();
+        } else {
+            for(let i = 0; i < count; i++){
+                this._target[i] = this._outPos[i].y;
+            }
+        }
+        this._batchFrames = this._framesSinceLastBatch;
+        this._framesSinceLastBatch = 0;
+        this._readCount++;
+        this._waveTime = this._water.waveTime;
+        for (const entry of this._extraListeners){
+            entry.onResult(entry.outputs, entry.inputs);
+        }
+    }
+    /** @internal */ _sampleTable(table, x, z) {
+        if (!table) {
+            return this._water.worldMatrix.m13;
+        }
+        const u = (x - this._originX) / this._spacing;
+        const v = (z - this._originZ) / this._spacing;
+        const cu = Math.min(this._cols - 1, Math.max(0, u));
+        const cv = Math.min(this._rows - 1, Math.max(0, v));
+        const i0 = Math.min(this._cols - 2, Math.max(0, Math.floor(cu)));
+        const j0 = Math.min(this._rows - 2, Math.max(0, Math.floor(cv)));
+        const fu = Math.min(1, Math.max(0, cu - i0));
+        const fv = Math.min(1, Math.max(0, cv - j0));
+        const r0 = j0 * this._cols;
+        const r1 = (j0 + 1) * this._cols;
+        return (table[r0 + i0] * (1 - fu) + table[r0 + i0 + 1] * fu) * (1 - fv) + (table[r1 + i0] * (1 - fu) + table[r1 + i0 + 1] * fu) * fv;
+    }
+}
+
+export { WaterSurfaceSampler };
+//# sourceMappingURL=water_surface_sampler.js.map

package/dist/scene/water_surface_sampler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"water_surface_sampler.js","sources":["../../src/scene/water_surface_sampler.ts"],"sourcesContent":["import type { Nullable } from '@zephyr3d/base';\r\nimport { Vector3 } from '@zephyr3d/base';\r\n\r\n/**\r\n * What {@link WaterSurfaceSampler} needs from a body of water: where its rest\r\n * plane is, what time its surface is at, and a way to evaluate the displaced\r\n * surface at a set of positions. {@link Water} provides all three.\r\n * @public\r\n */\r\nexport interface WaterSurfaceSource {\r\n  /** World matrix; only the translation is read. */\r\n  readonly worldMatrix: { readonly m03: number; readonly m13: number; readonly m23: number };\r\n  /** Wave clock of the surface, in seconds. */\r\n  readonly waveTime: number;\r\n  /** Evaluate the displaced surface over world XZ positions. */\r\n  getSurfacePoint(\r\n    points: Vector3[],\r\n    outPos?: Vector3[],\r\n    outNorm?: Vector3[],\r\n    includeDisturbers?: boolean\r\n  ): Promise<void>;\r\n}\r\n\r\n/**\r\n * Options for {@link WaterSurfaceSampler}.\r\n * @public\r\n */\r\nexport interface WaterSurfaceSamplerOptions {\r\n  /** Include moving disturbers' wakes. Defaults to false to prevent buoyancy feedback. */\r\n  includeDisturbers?: boolean;\r\n  /** Lattice cell size in world metres. Defaults to 6. */\r\n  spacing?: number;\r\n  /** Lattice columns, along X. Defaults to 24. */\r\n  cols?: number;\r\n  /** Lattice rows, along Z. Defaults to 24. */\r\n  rows?: number;\r\n  /**\r\n   * Upper bound on the query rate in hertz. The achieved rate is the lower of\r\n   * this and what a batch costs. Defaults to 30.\r\n   */\r\n  updateHz?: number;\r\n  /**\r\n   * Seconds for the reported height to close most of the gap to a new\r\n   * measurement. Lower is tighter to the wave, higher is heavier. Defaults to\r\n   * 0.25.\r\n   */\r\n  timeConstant?: number;\r\n}\r\n\r\n/** A set of moving positions evaluated alongside the lattice. @internal */\r\ninterface ExtraPoints {\r\n  inputs: Vector3[];\r\n  outputs: Vector3[];\r\n  onResult: (results: Vector3[], inputs: Vector3[]) => void;\r\n}\r\n\r\n/**\r\n * Height queries against a water surface, driven by the material's own\r\n * evaluation of it.\r\n *\r\n * {@link Water.getSurfacePoint} evaluates the GPU displacement itself, so the\r\n * result is exact by construction rather than a CPU re-implementation of the\r\n * waves. By default it includes ambient waves and external interaction\r\n * impulses, but excludes disturber wakes to prevent buoyancy feeding itself.\r\n * Set includeDisturbers for queries that need the complete rendered surface.\r\n * Each batch costs one point-list draw and one readback, so queries are\r\n * batched and throttled rather than issued per call.\r\n *\r\n * The queries are placed on a fixed lattice at construction; the whole set\r\n * costs one draw and one readback and the answer is interpolated across the\r\n * lattice on demand. Moving positions (a hull's footprint, say) ride along\r\n * through {@link addExtraPoints}.\r\n *\r\n * ## The motion\r\n *\r\n * The reported height eases exponentially towards the newest measurement; the\r\n * query lag is not compensated. A rigid body should read\r\n * {@link sampleWorldYRaw} instead and supply its own inertia.\r\n *\r\n * Consequences a caller has to accept:\r\n * - Resolution is the lattice spacing. A grid at `h` metres resolves nothing\r\n *   shorter than about `2 * h`.\r\n * - A probe outside the lattice is answered by the nearest cell rather than by\r\n *   a wrapped one; this is a window on the water, not a repeating field.\r\n * - Nothing is known until the first batch lands; until then queries return\r\n *   the still-water level.\r\n *\r\n * @public\r\n */\r\nexport class WaterSurfaceSampler {\r\n  private readonly _water: WaterSurfaceSource;\r\n  private readonly _includeDisturbers: boolean;\r\n  private readonly _spacing: number;\r\n  private readonly _cols: number;\r\n  private readonly _rows: number;\r\n  private _updateHz: number;\r\n  private _timeConstant: number;\r\n  private _pending: boolean;\r\n  private _elapsed: number;\r\n  private _waveTime: number;\r\n  private _readCount: number;\r\n  private _failCount: number;\r\n  private _totalPoints: number;\r\n  private _pendingSince: number;\r\n  private _lastLatency: number;\r\n  private _batchFrames: number;\r\n  private _framesSinceLastBatch: number;\r\n  private readonly _originX: number;\r\n  private readonly _originZ: number;\r\n  private readonly _inputs: Vector3[];\r\n  private readonly _outPos: Vector3[];\r\n  private readonly _extraListeners: ExtraPoints[];\r\n  private _batchInputs: Vector3[];\r\n  private _batchOutputs: Vector3[];\r\n  private _extrasDirty: boolean;\r\n  /** Heights the queries read; null until the first batch. */\r\n  private _height: Nullable<Float32Array>;\r\n  /** Where the newest measurement put the surface. */\r\n  private _target: Nullable<Float32Array>;\r\n  /**\r\n   * Creates a sampler over a body of water.\r\n   * @param water - The water to sample.\r\n   * @param options - Lattice and rate options.\r\n   */\r\n  constructor(water: WaterSurfaceSource, options: WaterSurfaceSamplerOptions = {}) {\r\n    this._water = water;\r\n    this._includeDisturbers = options.includeDisturbers ?? false;\r\n    this._spacing = Math.max(0.01, options.spacing ?? 6);\r\n    this._cols = Math.max(2, Math.floor(options.cols ?? 24));\r\n    this._rows = Math.max(2, Math.floor(options.rows ?? 24));\r\n    this._updateHz = Math.max(0.1, options.updateHz ?? 30);\r\n    this._timeConstant = Math.max(0.001, options.timeConstant ?? 0.25);\r\n    this._pending = false;\r\n    this._elapsed = 0;\r\n    this._waveTime = 0;\r\n    this._readCount = 0;\r\n    this._failCount = 0;\r\n    this._totalPoints = 0;\r\n    this._pendingSince = 0;\r\n    this._lastLatency = 0;\r\n    this._batchFrames = 0;\r\n    this._framesSinceLastBatch = 0;\r\n    // The lattice is anchored on the water's origin, in world space.\r\n    const ox = water.worldMatrix.m03;\r\n    const oz = water.worldMatrix.m23;\r\n    this._originX = ox - ((this._cols - 1) / 2) * this._spacing;\r\n    this._originZ = oz - ((this._rows - 1) / 2) * this._spacing;\r\n    const count = this._cols * this._rows;\r\n    this._inputs = new Array(count);\r\n    this._outPos = new Array(count);\r\n    for (let j = 0; j < this._rows; j++) {\r\n      for (let i = 0; i < this._cols; i++) {\r\n        const k = j * this._cols + i;\r\n        this._inputs[k] = new Vector3(\r\n          this._originX + i * this._spacing,\r\n          0,\r\n          this._originZ + j * this._spacing\r\n        );\r\n        this._outPos[k] = new Vector3();\r\n      }\r\n    }\r\n    this._extraListeners = [];\r\n    this._batchInputs = this._inputs;\r\n    this._batchOutputs = this._outPos;\r\n    this._extrasDirty = false;\r\n    this._height = null;\r\n    this._target = null;\r\n  }\r\n  /** Water clock of the newest accepted batch, in seconds. */\r\n  get waveTime() {\r\n    return this._waveTime;\r\n  }\r\n  /**\r\n   * Upper bound on the query rate in hertz.\r\n   *\r\n   * A ceiling, not a schedule: the achieved rate is also limited by batch cost.\r\n   */\r\n  get updateHz() {\r\n    return this._updateHz;\r\n  }\r\n  set updateHz(val: number) {\r\n    this._updateHz = Math.max(0.1, val);\r\n  }\r\n  /**\r\n   * Seconds for the reported height to close most of the gap to a new\r\n   * measurement. Independent of frame rate.\r\n   */\r\n  get timeConstant() {\r\n    return this._timeConstant;\r\n  }\r\n  set timeConstant(val: number) {\r\n    this._timeConstant = Math.max(0.001, val);\r\n  }\r\n  /** Batches completed since construction. */\r\n  get readCount() {\r\n    return this._readCount;\r\n  }\r\n  /** Batches that failed. */\r\n  get failCount() {\r\n    return this._failCount;\r\n  }\r\n  /** True while a batch is in flight. */\r\n  get pending() {\r\n    return this._pending;\r\n  }\r\n  /** Seconds the batch in flight has been outstanding, or 0 when none is. */\r\n  get pendingSeconds() {\r\n    return this._pending ? this._pendingSince : 0;\r\n  }\r\n  /** Batch latency in seconds, as of the last one that landed. */\r\n  get lastLatency() {\r\n    return this._lastLatency;\r\n  }\r\n  /** Frames the newest batch took to come back. */\r\n  get batchFrames() {\r\n    return this._batchFrames;\r\n  }\r\n  /** Points evaluated per batch, the cost driver of this sampler. */\r\n  get batchSize() {\r\n    return this._totalPoints;\r\n  }\r\n  /** True once a batch has landed and queries return surface heights. */\r\n  get ready() {\r\n    return !!this._height;\r\n  }\r\n  /** World metres between lattice samples. */\r\n  get spacing() {\r\n    return this._spacing;\r\n  }\r\n  /** World Y of the still-water level. */\r\n  get waterLevel() {\r\n    return this._water.worldMatrix.m13;\r\n  }\r\n  /**\r\n   * Register world positions to evaluate alongside the lattice, every batch.\r\n   *\r\n   * The array is held by reference and read when a batch is issued, so a\r\n   * caller updates the vectors in place each frame and the next batch picks\r\n   * them up. The listener receives the surface positions for those inputs when\r\n   * the batch lands, in the same order.\r\n   *\r\n   * @param inputs - World positions; only X and Z are used.\r\n   * @param onResult - Called per batch with the surface positions.\r\n   * @returns A function that unregisters the points.\r\n   */\r\n  addExtraPoints(inputs: Vector3[], onResult: (results: Vector3[], inputs: Vector3[]) => void) {\r\n    const outputs = inputs.map(() => new Vector3());\r\n    const entry: ExtraPoints = { inputs, outputs, onResult };\r\n    this._extraListeners.push(entry);\r\n    this._extrasDirty = true;\r\n    return () => {\r\n      const i = this._extraListeners.indexOf(entry);\r\n      if (i >= 0) {\r\n        this._extraListeners.splice(i, 1);\r\n        this._extrasDirty = true;\r\n      }\r\n    };\r\n  }\r\n  /**\r\n   * Advance the sampler. Call once per frame with the frame's delta.\r\n   * @param deltaSeconds - Frame delta in seconds.\r\n   */\r\n  update(deltaSeconds: number) {\r\n    this._framesSinceLastBatch++;\r\n    // Ease once a frame so every query in a frame sees the same value; exact\r\n    // exponential decay keeps the result independent of frame size.\r\n    if (this._height && this._target) {\r\n      const k = 1 - Math.exp(-deltaSeconds / this._timeConstant);\r\n      const height = this._height;\r\n      const target = this._target;\r\n      for (let i = 0; i < height.length; i++) {\r\n        height[i] += (target[i] - height[i]) * k;\r\n      }\r\n    }\r\n    if (this._pending) {\r\n      this._pendingSince += deltaSeconds;\r\n      return;\r\n    }\r\n    this._elapsed += deltaSeconds;\r\n    // Fire as soon as the previous batch has landed, capped at `updateHz`.\r\n    if (this._elapsed >= 1 / this._updateHz) {\r\n      this._elapsed = 0;\r\n      this._pending = true;\r\n      this._pendingSince = 0;\r\n      this._rebuildBatchArrays();\r\n      this._totalPoints = this._batchInputs.length;\r\n      // Only positions: the normal attachment would double the readback.\r\n      this._water\r\n        .getSurfacePoint(this._batchInputs, this._batchOutputs, undefined, this._includeDisturbers)\r\n        .then(() => this._acceptBatch())\r\n        .catch((err) => {\r\n          this._pending = false;\r\n          this._pendingSince = 0;\r\n          this._failCount++;\r\n          console.error('WaterSurfaceSampler: surface query failed', err);\r\n        });\r\n    }\r\n  }\r\n  /**\r\n   * Surface world Y at a world XZ, eased.\r\n   *\r\n   * Bilinear over the lattice, clamped at the edges. A pure lookup of the table\r\n   * advanced by {@link update}. For objects placed directly at the height,\r\n   * without inertia of their own.\r\n   */\r\n  sampleWorldY(x: number, z: number) {\r\n    return this._sampleTable(this._height, x, z);\r\n  }\r\n  /**\r\n   * Surface world Y at a world XZ, from the newest measurement with no easing.\r\n   *\r\n   * For a rigid body, which would otherwise get the easing lag on top of the\r\n   * query lag.\r\n   */\r\n  sampleWorldYRaw(x: number, z: number) {\r\n    return this._sampleTable(this._target, x, z);\r\n  }\r\n  /**\r\n   * Surface normal from the eased lattice, by central differences one cell\r\n   * apart.\r\n   * @param out - Destination, or a new vector.\r\n   * @returns Unit normal, Y up.\r\n   */\r\n  sampleNormal(x: number, z: number, out?: Vector3) {\r\n    const h = this._spacing;\r\n    const dx = this.sampleWorldY(x + h, z) - this.sampleWorldY(x - h, z);\r\n    const dz = this.sampleWorldY(x, z + h) - this.sampleWorldY(x, z - h);\r\n    const nx = -dx / (2 * h);\r\n    const nz = -dz / (2 * h);\r\n    const len = Math.hypot(nx, 1, nz);\r\n    return (out ?? new Vector3()).setXYZ(nx / len, 1 / len, nz / len);\r\n  }\r\n  /** @internal */\r\n  private _rebuildBatchArrays() {\r\n    if (!this._extrasDirty) {\r\n      return;\r\n    }\r\n    this._extrasDirty = false;\r\n    if (this._extraListeners.length === 0) {\r\n      this._batchInputs = this._inputs;\r\n      this._batchOutputs = this._outPos;\r\n      return;\r\n    }\r\n    const inputs = this._inputs.slice();\r\n    const outputs = this._outPos.slice();\r\n    for (const entry of this._extraListeners) {\r\n      for (let i = 0; i < entry.inputs.length; i++) {\r\n        inputs.push(entry.inputs[i]);\r\n        outputs.push(entry.outputs[i]);\r\n      }\r\n    }\r\n    this._batchInputs = inputs;\r\n    this._batchOutputs = outputs;\r\n  }\r\n  /**\r\n   * Point the sampler at a batch that just landed. The measurement becomes the\r\n   * target the reported height eases towards; the first batch is adopted\r\n   * outright, since there is no previous surface to ease from.\r\n   * @internal\r\n   */\r\n  private _acceptBatch() {\r\n    this._pending = false;\r\n    this._lastLatency = this._pendingSince;\r\n    this._pendingSince = 0;\r\n    this._elapsed = 0;\r\n    const count = this._outPos.length;\r\n    if (!this._target) {\r\n      this._target = new Float32Array(count);\r\n      for (let i = 0; i < count; i++) {\r\n        this._target[i] = this._outPos[i].y;\r\n      }\r\n      this._height = this._target.slice();\r\n    } else {\r\n      for (let i = 0; i < count; i++) {\r\n        this._target[i] = this._outPos[i].y;\r\n      }\r\n    }\r\n    this._batchFrames = this._framesSinceLastBatch;\r\n    this._framesSinceLastBatch = 0;\r\n    this._readCount++;\r\n    this._waveTime = this._water.waveTime;\r\n    for (const entry of this._extraListeners) {\r\n      entry.onResult(entry.outputs, entry.inputs);\r\n    }\r\n  }\r\n  /** @internal */\r\n  private _sampleTable(table: Nullable<Float32Array>, x: number, z: number) {\r\n    if (!table) {\r\n      return this._water.worldMatrix.m13;\r\n    }\r\n    const u = (x - this._originX) / this._spacing;\r\n    const v = (z - this._originZ) / this._spacing;\r\n    const cu = Math.min(this._cols - 1, Math.max(0, u));\r\n    const cv = Math.min(this._rows - 1, Math.max(0, v));\r\n    const i0 = Math.min(this._cols - 2, Math.max(0, Math.floor(cu)));\r\n    const j0 = Math.min(this._rows - 2, Math.max(0, Math.floor(cv)));\r\n    const fu = Math.min(1, Math.max(0, cu - i0));\r\n    const fv = Math.min(1, Math.max(0, cv - j0));\r\n    const r0 = j0 * this._cols;\r\n    const r1 = (j0 + 1) * this._cols;\r\n    return (\r\n      (table[r0 + i0] * (1 - fu) + table[r0 + i0 + 1] * fu) * (1 - fv) +\r\n      (table[r1 + i0] * (1 - fu) + table[r1 + i0 + 1] * fu) * fv\r\n    );\r\n  }\r\n}\r\n"],"names":["WaterSurfaceSampler","_water","_includeDisturbers","_spacing","_cols","_rows","_updateHz","_timeConstant","_pending","_elapsed","_waveTime","_readCount","_failCount","_totalPoints","_pendingSince","_lastLatency","_batchFrames","_framesSinceLastBatch","_originX","_originZ","_inputs","_outPos","_extraListeners","_batchInputs","_batchOutputs","_extrasDirty","water","options","includeDisturbers","Math","max","spacing","floor","cols","rows","updateHz","timeConstant","ox","worldMatrix","m03","oz","m23","count","Array","j","i","k","Vector3","_height","_target","waveTime","val","readCount","failCount","pending","pendingSeconds","lastLatency","batchFrames","batchSize","ready","waterLevel","m13","addExtraPoints","inputs","onResult","outputs","map","entry","push","indexOf","splice","update","deltaSeconds","exp","height","target","length","_rebuildBatchArrays","getSurfacePoint","undefined","then","_acceptBatch","catch","err","console","error","sampleWorldY","x","z","_sampleTable","sampleWorldYRaw","sampleNormal","out","h","dx","dz","nx","nz","len","hypot","setXYZ","slice","Float32Array","y","table","u","v","cu","min","cv","i0","j0","fu","fv","r0","r1"],"mappings":"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"}