@woosh/meep-engine 3.49.0 → 3.51.0

package/src/shade/renderer/wind/WIND_FIELD_STRUCT.d.ts

@@ -0,0 +1,36 @@
+/**
+ * What a reader needs of one cascade beyond its window: where its tile is, and how far its last
+ * step has decayed toward the far field since. 16 bytes.
+ *
+ * @type {WebGPUStruct}
+ */
+export const WIND_CASCADE_STRUCT: WebGPUStruct;
+/**
+ * The cascades' read records, finest first, as a field of {@link WIND_FIELD_STRUCT}.
+ * @type {WebGPUArray}
+ */
+export const WIND_CASCADE_ARRAY: WebGPUArray;
+/**
+ * The published wind field as a shader reads it: the uniform `wind_field`
+ * (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §11). 800 bytes.
+ *
+ * Cascade `c` (finest first, below `cascade_count`) is two rows at index `c`:
+ * - `levels[c]`: its window as a clipmap level (`CLIPMAP_LEVEL_STRUCT`) — the world cell at
+ *   window-local 0 (`corner`, in the cascade's cells), the cell's edge in metres (`cell_size`), and
+ *   the window's cells on each axis (`size`). A world corner is `corner · cell_size`. The table is
+ *   the shared clipmap module's, so `clipmap_select_finest` walks it as it is;
+ * - `cascades[c]`: its tile and its decay ({@link WIND_CASCADE_STRUCT}).
+ *
+ * Rows at and past `cascade_count` are never read.
+ *
+ * - `far_velocity`: `v_far(t)`, m/s, the far field now: the wind everywhere no cascade holds, and
+ *   what every cascade's deviation decays toward.
+ * - `inverse_atlas_size`: one over the atlas texture's texels along x, y and z, so a texel coordinate
+ *   times it is the normalised one a sample takes.
+ *
+ * @type {WebGPUStruct}
+ */
+export const WIND_FIELD_STRUCT: WebGPUStruct;
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+import { WebGPUArray } from "../shader/type/WebGPUArray.js";
+//# sourceMappingURL=WIND_FIELD_STRUCT.d.ts.map

package/src/shade/renderer/wind/WIND_FIELD_STRUCT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WIND_FIELD_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/wind/WIND_FIELD_STRUCT.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,kCAFU,YAAY,CAgBJ;AAElB;;;GAGG;AACH,iCAFU,WAAW,CAE6E;AAElG;;;;;;;;;;;;;;;;;;;GAmBG;AACH,gCAFU,YAAY,CAQN;6BAzDa,gCAAgC;4BADjC,+BAA+B"}

package/src/shade/renderer/wind/WIND_FIELD_STRUCT.js

@@ -0,0 +1,61 @@
+import { CLIPMAP_LEVEL_ARRAY } from "../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
+import { f32, u32, vec3f } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+import { WIND_FIELD_CASCADE_LIMIT } from "./WIND_FIELD.js";
+
+/**
+ * What a reader needs of one cascade beyond its window: where its tile is, and how far its last
+ * step has decayed toward the far field since. 16 bytes.
+ *
+ * @type {WebGPUStruct}
+ */
+export const WIND_CASCADE_STRUCT = WebGPUStruct.from({
+    /**
+     * The atlas texel coordinate of window-local position 0, the window's lowest corner: the tile's
+     * slot origin plus the border. Window-local cell `c` is the texel centred at
+     * `content_origin + c + 0.5`, which is where the cell's centre falls, so a window-local
+     * position `l` in cells is the texel coordinate `content_origin + l`.
+     */
+    content_origin: vec3f,
+    /**
+     * `k_c = e^(−(Λ(t) − Λ(t_s,c)))`, in [0, 1]: what is left now of the deviation from the far field
+     * the cascade's last step, at `t_s,c`, published. 1 the frame it steps under no drag, 0 for a
+     * cascade with no step to show.
+     */
+    decay: f32,
+}, "WindCascade");
+
+/**
+ * The cascades' read records, finest first, as a field of {@link WIND_FIELD_STRUCT}.
+ * @type {WebGPUArray}
+ */
+export const WIND_CASCADE_ARRAY = WebGPUArray.from(WIND_CASCADE_STRUCT, WIND_FIELD_CASCADE_LIMIT);
+
+/**
+ * The published wind field as a shader reads it: the uniform `wind_field`
+ * (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §11). 800 bytes.
+ *
+ * Cascade `c` (finest first, below `cascade_count`) is two rows at index `c`:
+ * - `levels[c]`: its window as a clipmap level (`CLIPMAP_LEVEL_STRUCT`) — the world cell at
+ *   window-local 0 (`corner`, in the cascade's cells), the cell's edge in metres (`cell_size`), and
+ *   the window's cells on each axis (`size`). A world corner is `corner · cell_size`. The table is
+ *   the shared clipmap module's, so `clipmap_select_finest` walks it as it is;
+ * - `cascades[c]`: its tile and its decay ({@link WIND_CASCADE_STRUCT}).
+ *
+ * Rows at and past `cascade_count` are never read.
+ *
+ * - `far_velocity`: `v_far(t)`, m/s, the far field now: the wind everywhere no cascade holds, and
+ *   what every cascade's deviation decays toward.
+ * - `inverse_atlas_size`: one over the atlas texture's texels along x, y and z, so a texel coordinate
+ *   times it is the normalised one a sample takes.
+ *
+ * @type {WebGPUStruct}
+ */
+export const WIND_FIELD_STRUCT = WebGPUStruct.from({
+    levels: CLIPMAP_LEVEL_ARRAY,
+    cascades: WIND_CASCADE_ARRAY,
+    far_velocity: vec3f,
+    cascade_count: u32,
+    inverse_atlas_size: vec3f,
+}, "WindField");

package/src/shade/renderer/wind/WIND_FIELD_UNIFORM.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Whether the published wind field is uniform: it holds no cascades, so the wind is
+ * `wind_field.far_velocity` at every point — `GPUSceneWind.cascade_count` is 0, which is every scene
+ * no producer fills (one without a GPU fluid). Decided by `chunk_wind_field_sample`, whose uniform
+ * alternative is the far field and nothing else, and by `chunk_participating_media_noise`, whose
+ * uniform alternative is the scroll alone: with no departure from the far field anywhere, the flow
+ * map has nothing to carry.
+ *
+ * A pass sets it from the field it binds, `scene.wind.cascade_count === 0`, the frame it binds it.
+ * `false`, the default, is the field read as it is, cascades or none, so a pass that never sets it
+ * reads the wind exactly as it always did.
+ *
+ * @type {ShaderSwitch}
+ */
+export const WIND_FIELD_UNIFORM: ShaderSwitch;
+import { ShaderSwitch } from "../shader/compiler/ShaderSwitch.js";
+//# sourceMappingURL=WIND_FIELD_UNIFORM.d.ts.map

package/src/shade/renderer/wind/WIND_FIELD_UNIFORM.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WIND_FIELD_UNIFORM.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/wind/WIND_FIELD_UNIFORM.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,iCAFU,YAAY,CAEoD;6BAhB7C,oCAAoC"}

package/src/shade/renderer/wind/WIND_FIELD_UNIFORM.js

@@ -0,0 +1,17 @@
+import { ShaderSwitch } from "../shader/compiler/ShaderSwitch.js";
+
+/**
+ * Whether the published wind field is uniform: it holds no cascades, so the wind is
+ * `wind_field.far_velocity` at every point — `GPUSceneWind.cascade_count` is 0, which is every scene
+ * no producer fills (one without a GPU fluid). Decided by `chunk_wind_field_sample`, whose uniform
+ * alternative is the far field and nothing else, and by `chunk_participating_media_noise`, whose
+ * uniform alternative is the scroll alone: with no departure from the far field anywhere, the flow
+ * map has nothing to carry.
+ *
+ * A pass sets it from the field it binds, `scene.wind.cascade_count === 0`, the frame it binds it.
+ * `false`, the default, is the field read as it is, cascades or none, so a pass that never sets it
+ * reads the wind exactly as it always did.
+ *
+ * @type {ShaderSwitch}
+ */
+export const WIND_FIELD_UNIFORM = ShaderSwitch.bool('wind field uniform');

package/src/shade/renderer/wind/chunk_wind_field_sample.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The wind at a world point, m/s: `wind_field_sample(position_ws)`, the one read every GPU consumer of
+ * the wind takes (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §6, §11).
+ *
+ * Reads the bindings {@link wind_field_add_resources} declares — `wind_field`
+ * ({@link WIND_FIELD_STRUCT}), `wind_field_atlas` (`texture_3d<f32>`) and `wind_field_sampler`
+ * (linear, clamped) — and no storage buffer, so a pass at the binding floor can take it. A consumer
+ * includes this chunk and declares the bindings through that helper; `GPUSceneWind.bind` fills them.
+ *
+ * By the field's shape ({@link WIND_FIELD_UNIFORM}), the same function either way:
+ * - as it is (`false`, the default): through the cascades, finest first, blended across their bands,
+ *   the far field outside them all ({@link chunk_wind_field_sample_cascades});
+ * - uniform (`true`), no cascades: the far field, `v_far(t)`, which is what the cascaded read returns
+ *   at every point of such a field ({@link chunk_wind_field_sample_uniform}).
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_wind_field_sample: CodeChunkChoice;
+import { CodeChunkChoice } from "../shader/compiler/CodeChunkChoice.js";
+//# sourceMappingURL=chunk_wind_field_sample.d.ts.map

package/src/shade/renderer/wind/chunk_wind_field_sample.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_wind_field_sample.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/wind/chunk_wind_field_sample.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;GAgBG;AACH,sCAFU,eAAe,CAEuD;gCAtBhD,uCAAuC"}

package/src/shade/renderer/wind/chunk_wind_field_sample.js

@@ -0,0 +1,26 @@
+import { CodeChunkChoice } from "../shader/compiler/CodeChunkChoice.js";
+import { chunk_wind_field_sample_cascades } from "./chunk_wind_field_sample_cascades.js";
+import { chunk_wind_field_sample_uniform } from "./chunk_wind_field_sample_uniform.js";
+import { WIND_FIELD_UNIFORM } from "./WIND_FIELD_UNIFORM.js";
+
+/**
+ * The wind at a world point, m/s: `wind_field_sample(position_ws)`, the one read every GPU consumer of
+ * the wind takes (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §6, §11).
+ *
+ * Reads the bindings {@link wind_field_add_resources} declares — `wind_field`
+ * ({@link WIND_FIELD_STRUCT}), `wind_field_atlas` (`texture_3d<f32>`) and `wind_field_sampler`
+ * (linear, clamped) — and no storage buffer, so a pass at the binding floor can take it. A consumer
+ * includes this chunk and declares the bindings through that helper; `GPUSceneWind.bind` fills them.
+ *
+ * By the field's shape ({@link WIND_FIELD_UNIFORM}), the same function either way:
+ * - as it is (`false`, the default): through the cascades, finest first, blended across their bands,
+ *   the far field outside them all ({@link chunk_wind_field_sample_cascades});
+ * - uniform (`true`), no cascades: the far field, `v_far(t)`, which is what the cascaded read returns
+ *   at every point of such a field ({@link chunk_wind_field_sample_uniform}).
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_wind_field_sample = CodeChunkChoice.from(WIND_FIELD_UNIFORM);
+
+chunk_wind_field_sample.add(false, chunk_wind_field_sample_cascades);
+chunk_wind_field_sample.add(true, chunk_wind_field_sample_uniform);

package/src/shade/renderer/wind/chunk_wind_field_sample_cascades.d.ts

@@ -0,0 +1,40 @@
+/**
+ * `wind_field_sample(position_ws)` through the field's cascades: the read
+ * `chunk_wind_field_sample` links for a field as it is ({@link WIND_FIELD_UNIFORM} `false`), any
+ * number of cascades, none included.
+ *
+ * Reads `wind_field` ({@link WIND_FIELD_STRUCT}), `wind_field_atlas` and `wind_field_sampler`, as
+ * {@link wind_field_add_resources} declares them.
+ *
+ * **The read:**
+ * - `clipmap_select_finest` walks the cascades' windows, finest first, and the first holding the point
+ *   answers, with how far into its edge band of {@link WIND_FIELD_BAND_WIDTH} cells the point is;
+ * - a cascade's read is the atmosphere identity, `v_far(t) + tap · k_c`: one trilinear tap of its tile,
+ *   which holds `v − v_far(t_s,c)` at cell centres, times its decay;
+ * - in the band, a second read blends in linearly, all of it on the window's face: the parent's
+ *   identity read, or `v_far(t)` for the coarsest; deeper than the band, one read;
+ * - outside every cascade, `v_far(t)`.
+ *
+ * The blend and the decay are taken now, at the sample, so a cascade that last stepped ticks ago reads
+ * the far field's current gust and drag. Air at the far field publishes a deviation of 0 and reads
+ * back `v_far(t)` exactly, on every cascade, in every band, at every instant: the blend is written as
+ * `inner + (outer − inner)·w`, which leaves equal reads as they are.
+ *
+ * A child cascade's window lies inside its parent's (the host refuses one that does not), so the
+ * parent's tap in the child's band lands in the parent's tile. The read is continuous across a
+ * child's face wherever that face is deeper than the parent's own band, which nesting with a margin
+ * gives.
+ *
+ * **Precision.** The tap is the hardware's trilinear: WebGPU guarantees no filter-weight precision, and
+ * Vulkan core only 4 bits (1/16 of a texel); the RTX 4090 rounds its weights to the nearest 1/256
+ * (measured), which is presentation-grade and accepted here. Tiles are `rgba16float` deviations, so
+ * their rounding scales with the deviation and not the wind.
+ *
+ * Positions are `f32` world positions divided into the cascade's cells, so a read at `p` places its tap
+ * to about `2⁻²⁴ · |p| / h` cells.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_wind_field_sample_cascades: CodeChunk;
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_wind_field_sample_cascades.d.ts.map

package/src/shade/renderer/wind/chunk_wind_field_sample_cascades.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_wind_field_sample_cascades.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/wind/chunk_wind_field_sample_cascades.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,+CAFU,SAAS,CAmDjB;0BA1FwB,iCAAiC"}

package/src/shade/renderer/wind/chunk_wind_field_sample_cascades.js

@@ -0,0 +1,92 @@
+import { chunk_clipmap_select_finest } from "../shader/chunk/clipmap/chunk_clipmap_select_finest.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { WIND_FIELD_BAND_WIDTH } from "./WIND_FIELD.js";
+import { WIND_FIELD_STRUCT } from "./WIND_FIELD_STRUCT.js";
+
+/**
+ * `wind_field_sample(position_ws)` through the field's cascades: the read
+ * `chunk_wind_field_sample` links for a field as it is ({@link WIND_FIELD_UNIFORM} `false`), any
+ * number of cascades, none included.
+ *
+ * Reads `wind_field` ({@link WIND_FIELD_STRUCT}), `wind_field_atlas` and `wind_field_sampler`, as
+ * {@link wind_field_add_resources} declares them.
+ *
+ * **The read:**
+ * - `clipmap_select_finest` walks the cascades' windows, finest first, and the first holding the point
+ *   answers, with how far into its edge band of {@link WIND_FIELD_BAND_WIDTH} cells the point is;
+ * - a cascade's read is the atmosphere identity, `v_far(t) + tap · k_c`: one trilinear tap of its tile,
+ *   which holds `v − v_far(t_s,c)` at cell centres, times its decay;
+ * - in the band, a second read blends in linearly, all of it on the window's face: the parent's
+ *   identity read, or `v_far(t)` for the coarsest; deeper than the band, one read;
+ * - outside every cascade, `v_far(t)`.
+ *
+ * The blend and the decay are taken now, at the sample, so a cascade that last stepped ticks ago reads
+ * the far field's current gust and drag. Air at the far field publishes a deviation of 0 and reads
+ * back `v_far(t)` exactly, on every cascade, in every band, at every instant: the blend is written as
+ * `inner + (outer − inner)·w`, which leaves equal reads as they are.
+ *
+ * A child cascade's window lies inside its parent's (the host refuses one that does not), so the
+ * parent's tap in the child's band lands in the parent's tile. The read is continuous across a
+ * child's face wherever that face is deeper than the parent's own band, which nesting with a margin
+ * gives.
+ *
+ * **Precision.** The tap is the hardware's trilinear: WebGPU guarantees no filter-weight precision, and
+ * Vulkan core only 4 bits (1/16 of a texel); the RTX 4090 rounds its weights to the nearest 1/256
+ * (measured), which is presentation-grade and accepted here. Tiles are `rgba16float` deviations, so
+ * their rounding scales with the deviation and not the wind.
+ *
+ * Positions are `f32` world positions divided into the cascade's cells, so a read at `p` places its tap
+ * to about `2⁻²⁴ · |p| / h` cells.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_wind_field_sample_cascades = CodeChunk.from(
+    //language=WGSL
+    `
+const WIND_FIELD_BAND_WIDTH: f32 = ${WIND_FIELD_BAND_WIDTH}.0;
+
+// cascade c's identity read at a world point its window holds
+fn wind_field_cascade_read(c: u32, position_ws: vec3<f32>) -> vec3<f32> {
+    let level = wind_field.levels[c];
+    let cascade = wind_field.cascades[c];
+
+    // window-local position in the cascade's cells, which is a texel offset from the tile's content
+    let local = position_ws / level.cell_size - vec3<f32>(level.corner);
+    let uvw = (cascade.content_origin + local) * wind_field.inverse_atlas_size;
+
+    let deviation = textureSampleLevel(wind_field_atlas, wind_field_sampler, uvw, 0.0).xyz;
+
+    return wind_field.far_velocity + deviation * cascade.decay;
+}
+
+fn wind_field_sample(position_ws: vec3<f32>) -> vec3<f32> {
+    let count = wind_field.cascade_count;
+
+    let selection = clipmap_select_finest(&wind_field.levels, count, position_ws, WIND_FIELD_BAND_WIDTH);
+
+    if (selection.level == CLIPMAP_LEVEL_NONE) {
+        return wind_field.far_velocity;
+    }
+
+    let inner = wind_field_cascade_read(selection.level, position_ws);
+
+    if (selection.edge_weight <= 0.0) {
+        return inner;
+    }
+
+    let parent = selection.level + 1u;
+
+    var outer = wind_field.far_velocity;
+
+    if (parent < count) {
+        outer = wind_field_cascade_read(parent, position_ws);
+    }
+
+    // mix's form, written so that equal reads blend to themselves exactly
+    return inner + (outer - inner) * selection.edge_weight;
+}
+`, [
+        WIND_FIELD_STRUCT.declaration_chunk,
+        chunk_clipmap_select_finest,
+    ]
+);

package/src/shade/renderer/wind/chunk_wind_field_sample_uniform.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `wind_field_sample(position_ws)` in a uniform field ({@link WIND_FIELD_UNIFORM} `true`): one with no
+ * cascades, where the wind is `v_far(t)` at every point, which is what the cascaded read returns there,
+ * exactly, having found no window that holds the point.
+ *
+ * Reads `wind_field.far_velocity` and nothing else; the atlas and its sampler stay bound and unread.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_wind_field_sample_uniform: CodeChunk;
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_wind_field_sample_uniform.d.ts.map

package/src/shade/renderer/wind/chunk_wind_field_sample_uniform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_wind_field_sample_uniform.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/wind/chunk_wind_field_sample_uniform.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,8CAFU,SAAS,CAWjB;0BArBwB,iCAAiC"}

package/src/shade/renderer/wind/chunk_wind_field_sample_uniform.js

@@ -0,0 +1,22 @@
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { WIND_FIELD_STRUCT } from "./WIND_FIELD_STRUCT.js";
+
+/**
+ * `wind_field_sample(position_ws)` in a uniform field ({@link WIND_FIELD_UNIFORM} `true`): one with no
+ * cascades, where the wind is `v_far(t)` at every point, which is what the cascaded read returns there,
+ * exactly, having found no window that holds the point.
+ *
+ * Reads `wind_field.far_velocity` and nothing else; the atlas and its sampler stay bound and unread.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_wind_field_sample_uniform = CodeChunk.from(
+    //language=WGSL
+    `
+fn wind_field_sample(position_ws: vec3<f32>) -> vec3<f32> {
+    return wind_field.far_velocity;
+}
+`, [
+        WIND_FIELD_STRUCT.declaration_chunk,
+    ]
+);

package/src/shade/renderer/wind/wind_field_add_resources.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Declare the published wind field's bindings in a consumer's resource group, under the names
+ * `chunk_wind_field_sample` reads:
+ * - `wind_field`: the uniform {@link WIND_FIELD_STRUCT};
+ * - `wind_field_atlas`: the tiles, `texture_3d<f32>`, filterable;
+ * - `wind_field_sampler`: linear and clamped, by default the field's own, so a host binds only the
+ *   other two (`GPUSceneWind.bind`).
+ *
+ * One uniform, one texture, one sampler, and no storage buffer.
+ *
+ * @param {import("../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor} group
+ * @returns {import("../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor} group
+ */
+export function wind_field_add_resources(group: import("../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor): import("../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor;
+//# sourceMappingURL=wind_field_add_resources.d.ts.map

package/src/shade/renderer/wind/wind_field_add_resources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wind_field_add_resources.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/wind/wind_field_add_resources.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,gDAHW,OAAO,qDAAqD,EAAE,6BAA6B,GACzF,OAAO,qDAAqD,EAAE,6BAA6B,CAOvG"}

package/src/shade/renderer/wind/wind_field_add_resources.js

@@ -0,0 +1,22 @@
+import { WIND_FIELD_SAMPLER_DESCRIPTOR } from "./WIND_FIELD.js";
+import { WIND_FIELD_STRUCT } from "./WIND_FIELD_STRUCT.js";
+
+/**
+ * Declare the published wind field's bindings in a consumer's resource group, under the names
+ * `chunk_wind_field_sample` reads:
+ * - `wind_field`: the uniform {@link WIND_FIELD_STRUCT};
+ * - `wind_field_atlas`: the tiles, `texture_3d<f32>`, filterable;
+ * - `wind_field_sampler`: linear and clamped, by default the field's own, so a host binds only the
+ *   other two (`GPUSceneWind.bind`).
+ *
+ * One uniform, one texture, one sampler, and no storage buffer.
+ *
+ * @param {import("../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor} group
+ * @returns {import("../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor} group
+ */
+export function wind_field_add_resources(group) {
+    return group
+        .addUniform("wind_field", WIND_FIELD_STRUCT)
+        .addTexture("wind_field_atlas", "float", "3d")
+        .addSampler("wind_field_sampler", "filtering", WIND_FIELD_SAMPLER_DESCRIPTOR);
+}

package/src/shade/wgsl/emulator/CPUBitmapData.d.ts

@@ -135,8 +135,11 @@ export class CPUBitmapData {
     /**
      * Effective dimension count (1, 2 or 3) inferred from which trailing
      * size axes are 1. A `width=W height=1 depth=1` texture is 1D; a
-     * `width=W height=H depth=1` is 2D; otherwise 3D. Used by the emulator
-     * to decide what `textureDimensions` should return.
+     * `width=W height=H depth=1` is 2D; otherwise 3D. This is the storage's
+     * shape, not the texture type: a shader's declaration decides what
+     * `textureDimensions` returns and which axes a load or store bounds-checks.
+     * Filtering may use it, because an axis of size 1 samples the same texel
+     * under every address mode.
      * @returns {1 | 2 | 3}
      */
     get dimensionality(): 1 | 2 | 3;

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

@@ -1 +1 @@
-{"version":3,"file":"CPUBitmapData.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/CPUBitmapData.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IA6II;;;;;OAKG;IACH,wBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,yBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,yBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,uBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,wBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,wBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,0BALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,0BALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;;;;OAQG;IACH,sBALW,MAAM,WACN,MAAM,UACN,MAAM,GACJ,aAAa,CAQzB;IAxMD;;;;;;OAMG;IACH,kBANW,UAAU,MAAM,CAAC,aACjB,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,EAmBhB;IA3DD;;;OAGG;IACH,MAFU,YAAY,kBAAkB,SAAS,GAAG,UAAU,GAAG,UAAU,GAAG,UAAU,GAAG,WAAW,GAAG,WAAW,GAAG,MAAM,EAAE,CAE1H;IAEL;;;OAGG;IACH,WAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,MAFU,WAAW,CAEhB;IAEL;;;;;;;;;;;;;OAaG;IACH,UAFU,OAAO,CAEA;IA4BjB,wBAAwB;IACxB,oBAAoC;IACpC,wBAAwB;IACxB,qBAAqC;IACrC,wBAAwB;IACxB,oBAAoC;IAEpC;;;;;;OAMG;IACH,gCAIC;IAED;;;;;;;OAOG;IACH,gBALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAMlB;IAED;;;;;;;;;OASG;IACH,QANW,MAAM,KACN,MAAM,KACN,MAAM,OACN,UAAU,MAAM,CAAC,GAAG;QAAE,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,eAC3C,MAAM,QAWhB;IAED;;;;;;;;;OASG;IACH,SANW,MAAM,KACN,MAAM,KACN,MAAM,OACN,UAAU,MAAM,CAAC,eACjB,MAAM,QAQhB;CAwGJ"}
+{"version":3,"file":"CPUBitmapData.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/CPUBitmapData.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAgJI;;;;;OAKG;IACH,wBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,yBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,yBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,uBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,wBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,wBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,0BALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,0BALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;;;;OAQG;IACH,sBALW,MAAM,WACN,MAAM,UACN,MAAM,GACJ,aAAa,CAQzB;IA3MD;;;;;;OAMG;IACH,kBANW,UAAU,MAAM,CAAC,aACjB,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,EAmBhB;IA3DD;;;OAGG;IACH,MAFU,YAAY,kBAAkB,SAAS,GAAG,UAAU,GAAG,UAAU,GAAG,UAAU,GAAG,WAAW,GAAG,WAAW,GAAG,MAAM,EAAE,CAE1H;IAEL;;;OAGG;IACH,WAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,MAFU,WAAW,CAEhB;IAEL;;;;;;;;;;;;;OAaG;IACH,UAFU,OAAO,CAEA;IA4BjB,wBAAwB;IACxB,oBAAoC;IACpC,wBAAwB;IACxB,qBAAqC;IACrC,wBAAwB;IACxB,oBAAoC;IAEpC;;;;;;;;;OASG;IACH,gCAIC;IAED;;;;;;;OAOG;IACH,gBALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAMlB;IAED;;;;;;;;;OASG;IACH,QANW,MAAM,KACN,MAAM,KACN,MAAM,OACN,UAAU,MAAM,CAAC,GAAG;QAAE,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,eAC3C,MAAM,QAWhB;IAED;;;;;;;;;OASG;IACH,SANW,MAAM,KACN,MAAM,KACN,MAAM,OACN,UAAU,MAAM,CAAC,eACjB,MAAM,QAQhB;CAwGJ"}

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

@@ -94,8 +94,11 @@ export class CPUBitmapData {
     /**
      * Effective dimension count (1, 2 or 3) inferred from which trailing
      * size axes are 1. A `width=W height=1 depth=1` texture is 1D; a
-     * `width=W height=H depth=1` is 2D; otherwise 3D. Used by the emulator
-     * to decide what `textureDimensions` should return.
+     * `width=W height=H depth=1` is 2D; otherwise 3D. This is the storage's
+     * shape, not the texture type: a shader's declaration decides what
+     * `textureDimensions` returns and which axes a load or store bounds-checks.
+     * Filtering may use it, because an axis of size 1 samples the same texel
+     * under every address mode.
      * @returns {1 | 2 | 3}
      */
     get dimensionality() {

package/src/shade/wgsl/emulator/WGSLJavaScriptCompiler.d.ts

@@ -32,7 +32,7 @@ export class WGSLJavaScriptCompiler {
     compile(ast: Tree): string;
 }
 export type WgslType = {
-    kind: 'primitive' | 'abstract' | 'vec' | 'mat' | 'array' | 'struct' | 'texture_2d' | 'sampler' | 'atomic' | 'unknown';
+    kind: 'primitive' | 'abstract' | 'vec' | 'mat' | 'array' | 'struct' | 'texture' | 'sampler' | 'atomic' | 'unknown';
     name?: string;
     size?: number;
     cols?: number;
@@ -40,5 +40,9 @@ export type WgslType = {
     scalar?: string;
     element?: WgslType;
     count?: number;
+    /**
+     * — of a texture: the size of what `textureDimensions` returns
+     */
+    dimension?: 1 | 2 | 3;
 };
 //# sourceMappingURL=WGSLJavaScriptCompiler.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"WGSLJavaScriptCompiler.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLJavaScriptCompiler.js"],"names":[],"mappings":"AA+nBA;IAEI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,oBAFa,MAAM,CAMlB;CACJ;;UA1pBa,WAAW,GAAG,UAAU,GAAG,KAAK,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS;WAC/G,MAAM;WACN,MAAM;WACN,MAAM;WACN,MAAM;aACN,MAAM;cACN,QAAQ;YACR,MAAM"}
+{"version":3,"file":"WGSLJavaScriptCompiler.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLJavaScriptCompiler.js"],"names":[],"mappings":"AAkpBA;IAEI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,oBAFa,MAAM,CAMlB;CACJ;;UA7qBa,WAAW,GAAG,UAAU,GAAG,KAAK,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS;WAC5G,MAAM;WACN,MAAM;WACN,MAAM;WACN,MAAM;aACN,MAAM;cACN,QAAQ;YACR,MAAM;;;;gBACN,CAAC,GAAG,CAAC,GAAG,CAAC"}