@woosh/meep-engine 3.49.0 → 3.51.0

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

@@ -8,7 +8,7 @@ import LineBuilder from "../../../core/codegen/LineBuilder.js";
 
 /**
  * @typedef {object} WgslType
- * @property {'primitive' | 'abstract' | 'vec' | 'mat' | 'array' | 'struct' | 'texture_2d' | 'sampler' | 'atomic' | 'unknown'} kind
+ * @property {'primitive' | 'abstract' | 'vec' | 'mat' | 'array' | 'struct' | 'texture' | 'sampler' | 'atomic' | 'unknown'} kind
  * @property {string} [name]
  * @property {number} [size]
  * @property {number} [cols]
@@ -16,6 +16,7 @@ import LineBuilder from "../../../core/codegen/LineBuilder.js";
  * @property {string} [scalar]
  * @property {WgslType} [element]
  * @property {number} [count]
+ * @property {1 | 2 | 3} [dimension] — of a texture: the size of what `textureDimensions` returns
  */
 
 const T_UNKNOWN = Object.freeze({ kind: 'unknown' });
@@ -34,6 +35,31 @@ const T_F32 = Object.freeze({ kind: 'primitive', name: 'f32' });
 const T_ABSTRACT_INT = Object.freeze({ kind: 'abstract', name: 'AbstractInt' });
 const T_ABSTRACT_FLOAT = Object.freeze({ kind: 'abstract', name: 'AbstractFloat' });
 
+/**
+ * Every WGSL texture type, by the number of components `textureDimensions` returns for it: a
+ * `u32` for 1D, a `vec2<u32>` for the 2D, array, cube and multisampled types, a `vec3<u32>` for 3D.
+ * @type {Object<string, 1 | 2 | 3>}
+ */
+const TEXTURE_DIMENSION = {
+    texture_1d: 1,
+    texture_storage_1d: 1,
+    texture_2d: 2,
+    texture_2d_array: 2,
+    texture_cube: 2,
+    texture_cube_array: 2,
+    texture_multisampled_2d: 2,
+    texture_external: 2,
+    texture_storage_2d: 2,
+    texture_storage_2d_array: 2,
+    texture_depth_2d: 2,
+    texture_depth_2d_array: 2,
+    texture_depth_cube: 2,
+    texture_depth_cube_array: 2,
+    texture_depth_multisampled_2d: 2,
+    texture_3d: 3,
+    texture_storage_3d: 3,
+};
+
 const VECTOR_ALIASES = {
     vec2i: { size: 2, scalar: 'i32' },
     vec3i: { size: 3, scalar: 'i32' },
@@ -56,10 +82,11 @@ const SWIZZLE_LETTERS = new Set(['x', 'y', 'z', 'w', 'r', 'g', 'b', 'a']);
 const SWIZZLE_INDEX = { x: 0, y: 1, z: 2, w: 3, r: 0, g: 1, b: 2, a: 3 };
 
 /**
- * Build a vec type alias name (e.g., {size:3, scalar:'f32'} → 'vec3f').
+ * Build a vec type alias name (e.g., {size:3, scalar:'f32'} → 'vec3f'). A `vec3<bool>` is the
+ * runtime's `vec3b`, which WGSL itself does not spell.
  */
 function vecAliasName(size, scalar) {
-    const suffix = { i32: 'i', u32: 'u', f32: 'f', f16: 'h' }[scalar] || 'f';
+    const suffix = { i32: 'i', u32: 'u', f32: 'f', f16: 'h', bool: 'b' }[scalar] || 'f';
     return `vec${size}${suffix}`;
 }
 
@@ -352,20 +379,12 @@ function classifyType(ident, args, template_list_node) {
         const inner = args.length > 0 ? args[0] : 'i32';
         return { kind: 'atomic', scalar: inner };
     }
-    // Texture types - 1D / 2D / 3D, sampled and storage variants. We
-    // collapse all of them to a single kind because the intrinsics in
-    // WGSLLanguageCore dispatch on the bound CPUBitmapData's
-    // `dimensionality`, not on the static WGSL type. (The 'texture_2d'
-    // kind label is preserved for backward compatibility with any
-    // downstream consumer that may grep for it.)
-    if (
-        ident === 'texture_2d' || ident === 'texture_storage_2d'
-        || ident === 'texture_1d' || ident === 'texture_storage_1d'
-        || ident === 'texture_3d' || ident === 'texture_storage_3d'
-        || ident === 'texture_2d_array'
-    ) {
+    // Texture types carry the dimension their declaration names. It is what `textureDimensions`
+    // answers with; the bound CPUBitmapData cannot say it, since a 1x1 bitmap is as much a
+    // texture_2d as a texture_1d.
+    if (TEXTURE_DIMENSION.hasOwnProperty(ident)) {
         const scalar = args.length > 0 ? args[0] : 'f32';
-        return { kind: 'texture_2d', scalar };
+        return { kind: 'texture', scalar, dimension: TEXTURE_DIMENSION[ident] };
     }
     if (ident === 'sampler') {
         return { kind: 'sampler' };
@@ -1613,7 +1632,7 @@ function ownedValueCode(compiled) {
         case 'primitive':
         case 'abstract':
         case 'atomic':
-        case 'texture_2d':
+        case 'texture':
         case 'sampler':
             return compiled.code;
         default:
@@ -2473,11 +2492,16 @@ function inferBinaryArithResultType(a, b) {
 
 /**
  * Pick the result type of a non-arithmetic binary op (comparison / logical / bitwise / shift).
- * Comparisons return bool; bitwise and shift preserve the leftmost known integer operand type.
+ * Comparisons return bool, or a `vec<bool>` of the operands' size when either is a vector, so a
+ * swizzle on the result indexes it; bitwise and shift preserve the leftmost known integer operand type.
  */
 function inferRawBinaryResultType(a, b, op) {
     const COMPARISON = new Set(['==', '!=', '<', '>', '<=', '>=']);
     const LOGICAL = new Set(['&&', '||']);
+    if (COMPARISON.has(op)) {
+        const vec = a && a.kind === 'vec' ? a : b && b.kind === 'vec' ? b : null;
+        if (vec !== null) return { kind: 'vec', size: vec.size, scalar: 'bool' };
+    }
     if (COMPARISON.has(op) || LOGICAL.has(op)) {
         return { kind: 'primitive', name: 'bool' };
     }
@@ -2509,6 +2533,7 @@ function compileUnaryExpression(c, node) {
             value: operand.value === undefined ? undefined : -operand.value,
         };
     }
+    if (prefix === '!' && operand.type && operand.type.kind === 'vec') return { code: `wgsl.logical_not(${operand.code})`, type: operand.type };
     if (prefix === '!') return { code: `!${operand.code}`, type: operand.type };
     if (prefix === '~') return { code: `wgsl.not(${operand.code})`, type: operand.type };
     if (prefix === '*' && operand.pointer_box === true) return { code: `${operand.code}.value`, type: operand.type };
@@ -2692,10 +2717,11 @@ function compileCallPhraseTyped(c, node) {
         }
         if (scalar === undefined) {
             // No explicit template — infer the component type from the arguments, mirroring
-            // WGSL's overload resolution. e.g. `vec4(some_u32)` is `vec4<u32>`, not `vec4<f32>`.
+            // WGSL's overload resolution. e.g. `vec4(some_u32)` is `vec4<u32>`, not `vec4<f32>`,
+            // and `vec2(a < b, c)` is a `vec2<bool>`.
             for (const a of arg_results) {
                 const t = a.type;
-                if (t && t.kind === 'primitive' && t.name !== 'bool') { scalar = t.name; break; }
+                if (t && t.kind === 'primitive') { scalar = t.name; break; }
                 if (t && (t.kind === 'vec' || t.kind === 'mat')) { scalar = t.scalar; break; }
             }
             if (scalar === undefined) scalar = 'f32';
@@ -2835,6 +2861,27 @@ function compileCallPhraseTyped(c, node) {
 
     // 9) WGSL builtins — best-effort type inference for common helpers.
     //
+    // `textureDimensions` answers with as many components as the texture's declaration has
+    // dimensions, which only the declaration says. A chunk compiled on its own may name a texture
+    // its importing shader declares; that compiles, and throws only if it runs.
+    if (callee_name === 'textureDimensions') {
+        const texture_type = arg_results[0] === undefined ? undefined : arg_results[0].type;
+
+        if (texture_type === undefined || texture_type.kind !== 'texture') {
+            const message = `textureDimensions: '${args[0]}' is not declared as a texture in this module, so its dimension is unknown`;
+
+            return {
+                code: `(() => { throw new Error(${JSON.stringify(message)}); })()`,
+                type: T_UNKNOWN,
+            };
+        }
+
+        return {
+            code: `wgsl.textureDimensions_${texture_type.dimension}d(${args.join(', ')})`,
+            type: inferBuiltinReturnType(callee_name, arg_results),
+        };
+    }
+
     // A few of them mean different things on i32 and on u32, and the operand type is the only
     // thing that says which — the same selection the arithmetic operators make.
     if (INTEGER_TYPED_BUILTIN.has(callee_name)) {
@@ -2869,7 +2916,8 @@ const INTEGER_TYPED_BUILTIN = new Set(['abs', 'firstLeadingBit', 'firstTrailingB
 
 /**
  * Element-wise builtins: the result has the type of the arguments. Most are vector-preserving
- * math; subgroupBroadcastFirst is not math, but has the same shape.
+ * math; subgroupBroadcastFirst is not math, but has the same shape. So have the derivatives, which
+ * the core refuses but a caller's core may answer.
  * @type {Set<string>}
  */
 const ELEMENT_WISE_BUILTIN = new Set([
@@ -2878,6 +2926,7 @@ const ELEMENT_WISE_BUILTIN = new Set([
     'pow', 'atan2', 'min', 'max', 'step', 'clamp', 'saturate', 'mix', 'smoothstep',
     'normalize', 'reflect', 'fma',
     'subgroupBroadcastFirst',
+    'dpdx', 'dpdy', 'fwidth', 'dpdxFine', 'dpdyFine', 'fwidthFine', 'dpdxCoarse', 'dpdyCoarse', 'fwidthCoarse',
 ]);
 
 /**
@@ -2936,7 +2985,11 @@ function inferBuiltinReturnType(name, args) {
         return { kind: 'vec', size: 4, scalar: 'f32' };
     }
     if (name === 'textureDimensions') {
-        return { kind: 'vec', size: 2, scalar: 'u32' };
+        const dimension = args[0].type.dimension;
+
+        return dimension === 1
+            ? { kind: 'primitive', name: 'u32' }
+            : { kind: 'vec', size: dimension, scalar: 'u32' };
     }
     if (name === 'atomicLoad') return { kind: 'primitive', name: 'i32' };
     if (name === 'unpack2x16unorm' || name === 'unpack2x16snorm' || name === 'unpack2x16float') {

package/src/shade/wgsl/emulator/WGSLLanguageCore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":";IAy/CA;;;;;;;;;;;;;;OAcG;IACH,+DAmDC"}
+{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":";IA6jDA;;;;;;;;;;;;;;OAcG;IACH,+DAmDC"}

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"}