@woosh/meep-engine 3.49.0 → 3.50.0

package/src/shade/wgsl/emulator/WGSLLanguageCore.js

@@ -26,6 +26,18 @@ const FALLBACK_LINEAR_CLAMP_SAMPLER = Object.freeze({
  * @param {import("./CPUBitmapData.js").CPUBitmapData} texture
  * @returns {number[]}
  */
+/**
+ * How many axes a texel coordinate addresses: a scalar for a 1D texture, a vector of the texture's
+ * dimension otherwise. WGSL makes a coordinate match the texture's declaration, so this is the
+ * declared dimension, where the bound bitmap only knows its size.
+ *
+ * @param {ArrayLike<number> | number} coords
+ * @returns {number}
+ */
+function coordinate_axis_count(coords) {
+    return typeof coords === 'number' ? 1 : coords.length;
+}
+
 function gather_texel_coord(coords, texture) {
     return [coords[0] * texture.size[0], coords[1] * texture.size[1]];
 }
@@ -83,6 +95,31 @@ function makeVec(TypedArrayCtor, size, args) {
     return out;
 }
 
+/**
+ * Build a `vec<bool>` as a plain `Array<boolean>`, the shape {@link binop_cmp} gives a vector
+ * comparison. Arguments are as for {@link makeVec}; each component converts as `bool(x)` does, so
+ * `vec2<bool>(vec2<f32>(0, 2))` is `[false, true]`.
+ *
+ * @param {number} size
+ * @param {*[]} args
+ * @returns {boolean[]}
+ */
+function makeBoolVec(size, args) {
+    const out = new Array(size).fill(false);
+    if (args.length === 1 && !is_vec(args[0])) {
+        return out.fill(!!args[0]);
+    }
+    let i = 0;
+    for (const a of args) {
+        if (is_vec(a)) {
+            for (let j = 0; j < a.length; j++) out[i++] = !!a[j];
+        } else {
+            out[i++] = !!a;
+        }
+    }
+    return out;
+}
+
 /**
  * Build a matrix constructor returning a typed array of `total_elements` entries. The returned
  * function accepts (a) no args → zero-filled, (b) `total_elements` scalars in column-major order,
@@ -370,6 +407,12 @@ export const WGSLLanguageCore = {
     vec3u: (...args) => makeVec(Uint32Array, 3, args),
     vec4u: (...args) => makeVec(Uint32Array, 4, args),
 
+    // vec<bool>, the Array<boolean> the comparison helpers return. WGSL has no `vec2b` alias; the
+    // compiler names these for `vec2<bool>`.
+    vec2b: (...args) => makeBoolVec(2, args),
+    vec3b: (...args) => makeBoolVec(3, args),
+    vec4b: (...args) => makeBoolVec(4, args),
+
     // ---------------------------------------------------------------------
     // Matrix constructors — column-major flat arrays. matCxR has C columns of R rows each,
     // for a total of C*R entries. Args may be scalars, column vectors, or a mix.
@@ -592,6 +635,8 @@ export const WGSLLanguageCore = {
 
     neg: (a) => unop(a, x => -x),
     not: (a) => unop(a, x => (~x) >>> 0),
+    // `!` on a vec<bool>; JS's raw `!` on the array is `false` whatever it holds
+    logical_not: (a) => unop(a, x => !x),
 
     // Bit-field extract / insert (WGSL §17.9). Component-wise over vectors; `offset` and
     // `count` are scalar u32 even when `e` / `newbits` are vectors, matching the WGSL
@@ -964,8 +1009,10 @@ export const WGSLLanguageCore = {
     },
 
     // ---------------------------------------------------------------------
-    // Texture intrinsics - backed by `CPUBitmapData` (1D / 2D / 3D inferred
-    // from the texture's `size`). Sampling routes through
+    // Texture intrinsics - backed by `CPUBitmapData`. A texture's dimension is the one its WGSL
+    // declaration names, never the bitmap's: a 1x1 bitmap may be bound to any texture type. The
+    // load and store builtins count the axes of their coordinate, and `textureDimensions` is
+    // compiled to the variant its declaration selects. Sampling routes through
     // `cpu_texture_sample`, which honours the bound `SamplerDescriptor`'s
     // address modes and filter. Mipmaps are not modelled (LOD 0 only) -
     // see cpu_texture_sample header for details.
@@ -974,8 +1021,8 @@ export const WGSLLanguageCore = {
     /**
      * `textureLoad(t, coords, level) -> vec4<T>`
      *
-     * Integer-coord fetch. `coords` is i32-vector matching the texture's
-     * dimensionality (1, 2, or 3 entries). Out-of-bounds reads return zero
+     * Integer-coord fetch. `coords` is a scalar for a texture_1d and a vector of the texture's
+     * dimension otherwise, so its length says which axes to bounds-check. Out-of-bounds reads return zero
      * across all channels (with alpha defaulting to 1.0 for textures with
      * fewer than 4 channels - matches WGSL semantics).
      *
@@ -992,9 +1039,9 @@ export const WGSLLanguageCore = {
     textureLoad(t, coords, _level_or_index = 0, _array_level = undefined) {
         assert.defined(t, 'texture');
         const out = new Float32Array(4);
-        const dim = t.dimensionality;
         // textureLoad on texture_1d takes a scalar i32 in WGSL (not vec1).
-        const x = (dim >= 1 ? (typeof coords === 'number' ? coords : coords[0]) : 0) | 0;
+        const dim = coordinate_axis_count(coords);
+        const x = (dim === 1 ? coords : coords[0]) | 0;
         const y = (dim >= 2 ? coords[1] : 0) | 0;
         /*
          Four arguments is the texture_2d_array form — (t, coords, array_index, level) — where the
@@ -1265,8 +1312,8 @@ export const WGSLLanguageCore = {
      * `textureStore(t, coords, value) -> ()`
      *
      * Integer-coord write into a storage texture. Out-of-bounds writes are
-     * silently dropped (WGSL semantics). `coords` length matches the
-     * texture dimensionality.
+     * silently dropped (WGSL semantics). `coords` is a scalar for a texture_storage_1d and a
+     * vector of the texture's dimension otherwise.
      *
      * Four arguments is the `texture_storage_2d_array` form — `(t, coords, array_index, value)` —
      * where the third argument selects the slice, stored along z as the sampling side reads it.
@@ -1282,8 +1329,8 @@ export const WGSLLanguageCore = {
             t.write(coords[0] | 0, coords[1] | 0, value_or_index | 0, array_value);
             return;
         }
-        const dim = t.dimensionality;
-        const x = (dim >= 1 ? (typeof coords === 'number' ? coords : coords[0]) : 0) | 0;
+        const dim = coordinate_axis_count(coords);
+        const x = (dim === 1 ? coords : coords[0]) | 0;
         const y = (dim >= 2 ? coords[1] : 0) | 0;
         const z = (dim >= 3 ? coords[2] : 0) | 0;
         t.write(x, y, z, value_or_index);
@@ -1292,23 +1339,44 @@ export const WGSLLanguageCore = {
     // CPUBitmapData models one stored mip level.
     textureNumLevels(_t) { return 1; },
 
+    /*
+     `textureDimensions(t, level)` comes in three variants, one per number of components it returns,
+     and the compiler picks the one the texture's declaration selects: `texture_1d` → `u32`; the 2D,
+     array, cube and multisampled types → `vec2<u32>`; `texture_3d` → `vec3<u32>`. The bound
+     bitmap's size cannot select it — a 1x1 `texture_2d` is still `vec2(1, 1)`.
+     */
+
     /**
-     * `textureDimensions(t, level) -> u32 | vec2<u32> | vec3<u32>`
-     *
-     * Returns the texture's size as a vector matching its dimensionality.
-     * 1D textures return a scalar `u32` in WGSL; we still hand back a
-     * length-1 Uint32Array so the calling shader can swizzle/index it
-     * uniformly with the multi-axis case.
-     *
+     * `textureDimensions` of a `texture_1d` or `texture_storage_1d`.
      * @param {import("./CPUBitmapData.js").CPUBitmapData} t
-     * @param {number} [_level]
+     * @param {number} [_level] - ignored, mipmaps are not modelled
+     * @returns {number}
+     */
+    textureDimensions_1d(t, _level = 0) {
+        assert.defined(t, 'texture');
+        return t.size[0];
+    },
+
+    /**
+     * `textureDimensions` of a 2D, array, cube or multisampled texture. An array texture's layers
+     * are not part of it.
+     * @param {import("./CPUBitmapData.js").CPUBitmapData} t
+     * @param {number} [_level] - ignored, mipmaps are not modelled
      * @returns {Uint32Array}
      */
-    textureDimensions(t, _level = 0) {
+    textureDimensions_2d(t, _level = 0) {
+        assert.defined(t, 'texture');
+        return new Uint32Array([t.size[0], t.size[1]]);
+    },
+
+    /**
+     * `textureDimensions` of a `texture_3d` or `texture_storage_3d`.
+     * @param {import("./CPUBitmapData.js").CPUBitmapData} t
+     * @param {number} [_level] - ignored, mipmaps are not modelled
+     * @returns {Uint32Array}
+     */
+    textureDimensions_3d(t, _level = 0) {
         assert.defined(t, 'texture');
-        const dim = t.dimensionality;
-        if (dim === 1) return new Uint32Array([t.size[0]]);
-        if (dim === 2) return new Uint32Array([t.size[0], t.size[1]]);
         return new Uint32Array([t.size[0], t.size[1], t.size[2]]);
     },
 

package/src/engine/physics/cloth/wind/ClothAmbientWind.d.ts

@@ -1,87 +0,0 @@
-/**
- * # The air everywhere a fluid simulation is not
- *
- * §10's fallback: "a `GlobalFluidEffector`-shaped ambient term — a constant
- * `wind` vector plus a small band-limited noise for gusting". The shape is
- * deliberate. `GlobalFluidEffector` with a `wind` and a `drag` makes every fluid
- * field relax *toward* `wind`, so a field with one in the scene already reads
- * `wind` away from whatever is disturbing it — which means this is not an
- * approximation of the simulation, it is **the same far field the simulation
- * has**, evaluated where no simulation exists. A cloth walking out of a fluid
- * volume walks into the volume's own ambient rather than into still air.
- *
- * ## The gust is three sinusoids, not a noise function
- *
- * "Band-limited" is exactly what a sum of sinusoids is, and the three properties
- * that matters for here are all free: it is bounded (so `gust` is a real
- * amplitude rather than a scale factor over an unbounded tail), it is smooth
- * (so a settled banner is lifted rather than kicked), and it carries **no
- * state** — `g(t)` is a pure function of the cloth world's own fixed-step clock,
- * which is what lets two systems sharing this source produce bit-identical
- * cloth. A value-noise lattice would need a seed and an interpolation rule to
- * buy the same three.
- *
- * The three components sit at 1, 2.41 and 5.83 times the base frequency, which
- * are mutually irrational enough that the pattern does not visibly repeat, and
- * the three axes are offset in phase so the gust turns as well as pulses. It is
- * the cheapest thing that reads as weather; it is not turbulence, and a scene
- * that wants turbulence has a fluid simulator.
- *
- * The clock `g(t)` reads is the **asking cloth's own age**, handed in per
- * sample, not a clock this object holds — see {@link AbstractClothWind} for the
- * parity argument. The visible consequence is that two garments spawned a second
- * apart are a second apart in the gust rather than in phase with it, which for a
- * bounded sum of sinusoids is indistinguishable from weather and is the reason
- * this costs nothing to make true.
- *
- * ## Uniform in space, and that is the interesting limit
- *
- * {@link varies} is always `false`, so a whole garment costs **one** sample —
- * which is what makes the no-simulation case essentially free on the main thread
- * regardless of particle count (`MEASUREMENTS.md` §47). The cost is that the
- * whole cloth is lifted together and a long banner does not see a gust arrive at
- * one end before the other. Spatial structure is the thing a fluid field has and
- * this does not, and §10's argument is that building a second, worse one here
- * would be the duplication the design exists to avoid.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export class ClothAmbientWind extends AbstractClothWind {
-    /**
-     * Prevailing wind, world-space metres per second. The same quantity and the
-     * same units as `GlobalFluidEffector#wind`.
-     * @type {Float64Array}
-     */
-    wind: Float64Array;
-    /**
-     * Peak gust speed on top of {@link wind}, metres per second. The gust is
-     * bounded by exactly this — the component amplitudes below sum to one — so
-     * the air's speed never leaves `|wind| ± gust`.
-     * @type {number}
-     */
-    gust: number;
-    /**
-     * Period of the gust's slowest component, seconds. Four is a breeze that
-     * arrives and leaves a few times a minute; a fraction of a second is a
-     * flutter.
-     * @type {number}
-     */
-    period: number;
-    /**
-     * @param {number} time
-     * @param {EntityComponentDataset} [ecd]
-     * @returns {void}
-     */
-    begin(time: number, ecd?: EntityComponentDataset): void;
-    /**
-     * Always `false`: the ambient is one vector for the whole world at any
-     * instant, so one sample describes a garment exactly rather than
-     * approximately.
-     *
-     * @returns {boolean}
-     */
-    varies(): boolean;
-}
-import { AbstractClothWind } from "./AbstractClothWind.js";
-//# sourceMappingURL=ClothAmbientWind.d.ts.map

package/src/engine/physics/cloth/wind/ClothAmbientWind.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ClothAmbientWind.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/wind/ClothAmbientWind.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;IAEI;;;;OAIG;IACH,MAFU,YAAY,CAEK;IAE3B;;;;;OAKG;IACH,MAFU,MAAM,CAEP;IAET;;;;;OAKG;IACH,QAFU,MAAM,CAEL;IAEX;;;;OAIG;IACH,YAJW,MAAM,iCAEJ,IAAI,CAKhB;IAED;;;;;;OAMG;IACH,UAFa,OAAO,CAInB;CAuCJ;kCAtIiC,wBAAwB"}

package/src/engine/physics/cloth/wind/ClothAmbientWind.js

@@ -1,185 +0,0 @@
-import { AbstractClothWind } from "./AbstractClothWind.js";
-
-/**
- * # The air everywhere a fluid simulation is not
- *
- * §10's fallback: "a `GlobalFluidEffector`-shaped ambient term — a constant
- * `wind` vector plus a small band-limited noise for gusting". The shape is
- * deliberate. `GlobalFluidEffector` with a `wind` and a `drag` makes every fluid
- * field relax *toward* `wind`, so a field with one in the scene already reads
- * `wind` away from whatever is disturbing it — which means this is not an
- * approximation of the simulation, it is **the same far field the simulation
- * has**, evaluated where no simulation exists. A cloth walking out of a fluid
- * volume walks into the volume's own ambient rather than into still air.
- *
- * ## The gust is three sinusoids, not a noise function
- *
- * "Band-limited" is exactly what a sum of sinusoids is, and the three properties
- * that matters for here are all free: it is bounded (so `gust` is a real
- * amplitude rather than a scale factor over an unbounded tail), it is smooth
- * (so a settled banner is lifted rather than kicked), and it carries **no
- * state** — `g(t)` is a pure function of the cloth world's own fixed-step clock,
- * which is what lets two systems sharing this source produce bit-identical
- * cloth. A value-noise lattice would need a seed and an interpolation rule to
- * buy the same three.
- *
- * The three components sit at 1, 2.41 and 5.83 times the base frequency, which
- * are mutually irrational enough that the pattern does not visibly repeat, and
- * the three axes are offset in phase so the gust turns as well as pulses. It is
- * the cheapest thing that reads as weather; it is not turbulence, and a scene
- * that wants turbulence has a fluid simulator.
- *
- * The clock `g(t)` reads is the **asking cloth's own age**, handed in per
- * sample, not a clock this object holds — see {@link AbstractClothWind} for the
- * parity argument. The visible consequence is that two garments spawned a second
- * apart are a second apart in the gust rather than in phase with it, which for a
- * bounded sum of sinusoids is indistinguishable from weather and is the reason
- * this costs nothing to make true.
- *
- * ## Uniform in space, and that is the interesting limit
- *
- * {@link varies} is always `false`, so a whole garment costs **one** sample —
- * which is what makes the no-simulation case essentially free on the main thread
- * regardless of particle count (`MEASUREMENTS.md` §47). The cost is that the
- * whole cloth is lifted together and a long banner does not see a gust arrive at
- * one end before the other. Spatial structure is the thing a fluid field has and
- * this does not, and §10's argument is that building a second, worse one here
- * would be the duplication the design exists to avoid.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export class ClothAmbientWind extends AbstractClothWind {
-
-    /**
-     * Prevailing wind, world-space metres per second. The same quantity and the
-     * same units as `GlobalFluidEffector#wind`.
-     * @type {Float64Array}
-     */
-    wind = new Float64Array(3);
-
-    /**
-     * Peak gust speed on top of {@link wind}, metres per second. The gust is
-     * bounded by exactly this — the component amplitudes below sum to one — so
-     * the air's speed never leaves `|wind| ± gust`.
-     * @type {number}
-     */
-    gust = 0;
-
-    /**
-     * Period of the gust's slowest component, seconds. Four is a breeze that
-     * arrives and leaves a few times a minute; a fraction of a second is a
-     * flutter.
-     * @type {number}
-     */
-    period = 4;
-
-    /**
-     * @param {number} time
-     * @param {EntityComponentDataset} [ecd]
-     * @returns {void}
-     */
-    begin(time, ecd) {
-        // Nothing to refresh: the gust is a pure function of the time each
-        // sample is taken at, and there is no scene to walk.
-    }
-
-    /**
-     * Always `false`: the ambient is one vector for the whole world at any
-     * instant, so one sample describes a garment exactly rather than
-     * approximately.
-     *
-     * @returns {boolean}
-     */
-    varies() {
-        return false;
-    }
-
-    /**
-     * @param {Float64Array|number[]} out
-     * @param {number} x unused — the ambient has no spatial structure
-     * @param {number} y
-     * @param {number} z
-     * @param {number} time seconds the asking cloth has stepped
-     * @returns {Float64Array|number[]}
-     */
-    sample(out, x, y, z, time) {
-        const wind = this.wind;
-
-        out[0] = wind[0];
-        out[1] = wind[1];
-        out[2] = wind[2];
-
-        const gust = this.gust;
-
-        if (gust === 0) {
-            return out;
-        }
-
-        const period = this.period > 0 ? this.period : 1;
-
-        const w = 2 * Math.PI * time / period;
-
-        for (let axis = 0; axis < 3; axis++) {
-            const phase = PHASE[axis];
-
-            out[axis] += gust * (
-                AMPLITUDE_0 * Math.sin(w * RATE_0 + phase)
-                + AMPLITUDE_1 * Math.sin(w * RATE_1 + phase * 2)
-                + AMPLITUDE_2 * Math.sin(w * RATE_2 + phase * 3)
-            );
-        }
-
-        return out;
-    }
-}
-
-/**
- * Component rates, as multiples of the base frequency. Mutually irrational
- * enough that the sum's own period is far longer than anyone watches.
- * @type {number}
- * @private
- */
-const RATE_0 = 1;
-
-/**
- * @type {number}
- * @private
- */
-const RATE_1 = 2.41;
-
-/**
- * @type {number}
- * @private
- */
-const RATE_2 = 5.83;
-
-/**
- * Component amplitudes. They sum to exactly one, which is what makes
- * {@link ClothAmbientWind#gust} a bound rather than a scale — a pink-ish
- * `1 : 1/2 : 1/4` normalised by its own total.
- * @type {number}
- * @private
- */
-const AMPLITUDE_0 = 4 / 7;
-
-/**
- * @type {number}
- * @private
- */
-const AMPLITUDE_1 = 2 / 7;
-
-/**
- * @type {number}
- * @private
- */
-const AMPLITUDE_2 = 1 / 7;
-
-/**
- * Per-axis phase offsets, so the three axes are not a single pulse along the
- * diagonal. Thirds of a turn, scaled per component so the axes stay apart at
- * every rate rather than only at the slowest.
- * @type {number[]}
- * @private
- */
-const PHASE = [0, 2 * Math.PI / 3, 4 * Math.PI / 3];

package/src/shade/renderer/geometry/sdf/chunk_sdf_slot_index_to_texture_offset.d.ts

@@ -1,7 +0,0 @@
-/**
- * TODO align with {@link chunk_index_to_grid3d}
- * @type {CodeChunk}
- */
-export const chunk_sdf_slot_index_to_texture_offset: CodeChunk;
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-//# sourceMappingURL=chunk_sdf_slot_index_to_texture_offset.d.ts.map

package/src/shade/renderer/geometry/sdf/chunk_sdf_slot_index_to_texture_offset.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_sdf_slot_index_to_texture_offset.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/chunk_sdf_slot_index_to_texture_offset.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,qDAFU,SAAS,CAmBjB;0BAxBwB,oCAAoC"}

package/src/shade/renderer/geometry/sdf/chunk_sdf_slot_index_to_texture_offset.js

@@ -1,25 +0,0 @@
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-
-
-/**
- * TODO align with {@link chunk_index_to_grid3d}
- * @type {CodeChunk}
- */
-export const chunk_sdf_slot_index_to_texture_offset = CodeChunk.from(
-    //language=WGSL
-    `
-fn sdf_slot_index_to_texture_offset(slot_index:u32, texture_slot_resolution:vec3<u32>) -> vec3<u32>{
-
-    let slice_size = texture_slot_resolution.x * texture_slot_resolution.y;
-    
-    let slot_offset_z = slot_index / slice_size;
-    
-    let index_in_slice = slot_index - slot_offset_z*slice_size;
-    
-    let slot_offset_y = index_in_slice / texture_slot_resolution.x;
-    let slot_offset_x = slot_index % texture_slot_resolution.x;
-    
-    return vec3(slot_offset_x, slot_offset_y, slot_offset_z);
-}
-    `
-);

package/src/shade/renderer/global_illumination/clipmap/GPUClipMap3D.d.ts

@@ -1,43 +0,0 @@
-export class GPUClipMap3D {
-    /**
-     *
-     * @param {GPUDevice} device
-     */
-    constructor(device: GPUDevice);
-    /**
-     *
-     * @return {GPUTextureContext}
-     */
-    get texture(): GPUTextureContext;
-    /**
-     *
-     * @return {GPUTypedBuffer}
-     */
-    get metadata(): GPUTypedBuffer;
-    update(): void;
-    /**
-     *
-     * @param {number} v
-     */
-    set cascade_resolution(v: number);
-    /**
-     *
-     * @return {number}
-     */
-    get cascade_resolution(): number;
-    /**
-     *
-     * @param {number} v
-     */
-    set cascade_count(v: number);
-    /**
-     *
-     * @return {number}
-     */
-    get cascade_count(): number;
-    destroy(): void;
-    #private;
-}
-import { GPUTextureContext } from "../../texture/GPUTextureContext.js";
-import { GPUTypedBuffer } from "../../buffer/GPUTypedBuffer.js";
-//# sourceMappingURL=GPUClipMap3D.d.ts.map

package/src/shade/renderer/global_illumination/clipmap/GPUClipMap3D.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"GPUClipMap3D.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/clipmap/GPUClipMap3D.js"],"names":[],"mappings":"AAMA;IA4DI;;;OAGG;IACH,+BAiCC;IA/DD;;;OAGG;IACH,iCAIC;IAQD;;;OAGG;IACH,+BAIC;IAyCD,eAOC;IAuCD;;;OAGG;IACH,kCAWC;IAED;;;OAGG;IACH,iCAEC;IAED;;;OAGG;IACH,6BAYC;IAED;;;OAGG;IACH,4BAEC;IAED,gBAGC;;CACJ;kCA3MiC,oCAAoC;+BADvC,gCAAgC"}