@woosh/meep-engine 3.49.0 → 3.50.0

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

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