@woosh/meep-engine 3.11.1 → 3.11.3

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

@@ -1,172 +1,176 @@
-import { assert } from "../../../core/assert.js";
-
-/**
- * Sample a {@link CPUBitmapData} as if it were a GPU texture bound with
- * the given sampler. Routes through nearest or linear filtering on each of
- * the texture's actual axes (1D / 2D / 3D inferred from
- * `texture.dimensionality`).
- *
- * **Mipmaps are intentionally not modelled.** The emulator runs at LOD 0
- * only — there is no mip pyramid in {@link CPUBitmapData}, and
- * `mipmapFilter` / `lodMinClamp` / `lodMaxClamp` on the sampler are
- * ignored. We pick `magFilter` for the actual filter mode, which matches
- * the intuition that emulator tests are typically up-sampling. Add a mip
- * pyramid + minification path later if a test ever needs minified
- * sampling.
- *
- * Convention for `texel_coord`: this is **TEXEL-SPACE coordinates** (i.e.
- * UV * size, NOT normalised UV in [0, 1]). The shader-facing intrinsics
- * `textureSample` / `textureSampleLevel` take normalised UV; the emulator
- * converts to texel-space before calling here so the address-mode
- * arithmetic doesn't have to special-case sub-1.0 jitter. WebGPU's
- * convention places texel `i`'s centre at texel-space `i + 0.5`, so the
- * left edge of the texture is at 0 and the right edge at `size`.
- *
- * Address-mode handling lives in {@link wrap_int}: every integer texel
- * index produced by either filter passes through it before reading the
- * backing buffer. Out-of-range fractional inputs fall out naturally from
- * floor + integer wrap, so we don't pre-clamp the fractional coord (a
- * previous version did and lost full-edge texel sampling for
- * `clamp-to-edge`).
- *
- * @param {Float32Array | number[]} output — receives 4 channel values
- *   (channels beyond `texture.item_size` are zero, with alpha forced to 1
- *   for textures with fewer than 4 channels — matches WGSL semantics)
- * @param {import("../../descriptor/texture/SamplerDescriptor.js").SamplerDescriptor} sampler
- * @param {import("./CPUBitmapData.js").CPUBitmapData} texture
- * @param {Float32Array | number[]} texel_coord — length matches
- *   `texture.dimensionality` (1, 2 or 3 entries)
- */
-export function cpu_texture_sample(output, sampler, texture, texel_coord) {
-    assert.defined(output, 'output');
-    assert.defined(sampler, 'sampler');
-    assert.defined(texture, 'texture');
-    assert.defined(texel_coord, 'texel_coord');
-
-    // Default channels 0..3 to 0; alpha to 1 if the texture has < 4 channels.
-    const item_size = texture.item_size;
-    for (let i = 0; i < 4; i++) output[i] = 0;
-    if (item_size < 4) output[3] = 1;
-
-    const dim = texture.dimensionality;
-    const w = texture.size[0];
-    const h = texture.size[1];
-    const d = texture.size[2];
-
-    const tx = texel_coord[0];
-    const ty = dim >= 2 ? texel_coord[1] : 0;
-    const tz = dim >= 3 ? texel_coord[2] : 0;
-
-    // Mipmaps not modelled — see header. Use magFilter as the single
-    // filter setting (sampler is bound at LOD 0 conceptually).
-    const filter = sampler.magFilter;
-
-    if (filter === "nearest") {
-        // WGSL nearest: texel index = floor(texel_coord), then wrap.
-        const ix = wrap_int(Math.floor(tx), w, sampler.addressModeU);
-        const iy = dim >= 2 ? wrap_int(Math.floor(ty), h, sampler.addressModeV) : 0;
-        const iz = dim >= 3 ? wrap_int(Math.floor(tz), d, sampler.addressModeW) : 0;
-        const base = texture.pixel_offset(ix, iy, iz);
-        const n = Math.min(item_size, 4);
-        for (let i = 0; i < n; i++) output[i] = texture.data[base + i];
-        return;
-    }
-
-    if (filter !== "linear") {
-        throw new Error(`cpu_texture_sample: unsupported magFilter '${filter}' (expected "nearest" or "linear")`);
-    }
-
-    // Linear filter. Sample 2 (1D) / 4 (2D) / 8 (3D) neighbouring texels
-    // around `texel_coord - 0.5` (the offset puts the bilinear origin at
-    // texel CENTRES) with weights `(1 - frac, frac)` per axis. Each
-    // integer index passes through `wrap_int` so the right/bottom/back
-    // neighbour falling off the edge is resolved by the address mode.
-    const px = tx - 0.5;
-    const fx_floor = Math.floor(px);
-    const ix0 = wrap_int(fx_floor, w, sampler.addressModeU);
-    const ix1 = wrap_int(fx_floor + 1, w, sampler.addressModeU);
-    const fx = px - fx_floor;
-
-    let iy0 = 0, iy1 = 0, fy = 0;
-    if (dim >= 2) {
-        const py = ty - 0.5;
-        const fy_floor = Math.floor(py);
-        iy0 = wrap_int(fy_floor, h, sampler.addressModeV);
-        iy1 = wrap_int(fy_floor + 1, h, sampler.addressModeV);
-        fy = py - fy_floor;
-    }
-
-    let iz0 = 0, iz1 = 0, fz = 0;
-    if (dim >= 3) {
-        const pz = tz - 0.5;
-        const fz_floor = Math.floor(pz);
-        iz0 = wrap_int(fz_floor, d, sampler.addressModeW);
-        iz1 = wrap_int(fz_floor + 1, d, sampler.addressModeW);
-        fz = pz - fz_floor;
-    }
-
-    const n = Math.min(item_size, 4);
-
-    // Unrolled 2-corner loop per active axis (max 8 corners total). Skip
-    // zero-weight corners early — common when the fractional offset is
-    // exactly an integer (texel-centre sample).
-    const xs = [ix0, ix1];
-    const wxs = [1 - fx, fx];
-    const ys = [iy0, iy1];
-    const wys = [1 - fy, fy];
-    const zs = [iz0, iz1];
-    const wzs = [1 - fz, fz];
-
-    const y_count = dim >= 2 ? 2 : 1;
-    const z_count = dim >= 3 ? 2 : 1;
-
-    for (let kz = 0; kz < z_count; kz++) {
-        const wz = z_count === 1 ? 1 : wzs[kz];
-        const z = zs[kz];
-        for (let ky = 0; ky < y_count; ky++) {
-            const wy = y_count === 1 ? 1 : wys[ky];
-            const y = ys[ky];
-            for (let kx = 0; kx < 2; kx++) {
-                const wx = wxs[kx];
-                const x = xs[kx];
-                const weight = wx * wy * wz;
-                if (weight === 0) continue;
-                const base = texture.pixel_offset(x, y, z);
-                for (let i = 0; i < n; i++) output[i] += texture.data[base + i] * weight;
-            }
-        }
-    }
-}
-
-/**
- * Wrap an integer texel index back into `[0, size)` using the address
- * mode. Shared by both nearest and linear filtering — the linear filter
- * passes both the floor and floor+1 indices through this so wrapping at
- * the edge is consistent.
- *
- * @param {number} i
- * @param {number} size
- * @param {GPUAddressMode} mode
- * @returns {number}
- */
-function wrap_int(i, size, mode) {
-    if (size <= 0) return 0;
-    switch (mode) {
-        case "clamp-to-edge":
-            if (i < 0) return 0;
-            if (i >= size) return size - 1;
-            return i;
-        case "repeat":
-            return ((i % size) + size) % size;
-        case "mirror-repeat": {
-            // fold the second half of the period back onto the first:
-            // w in [size, 2*size) maps to period - 1 - w in [0, size)
-            const period = size * 2;
-            let w = ((i % period) + period) % period;
-            if (w >= size) w = period - 1 - w;
-            return w;
-        }
-        default:
-            throw new Error(`cpu_texture_sample: unsupported address mode '${mode}' (expected "clamp-to-edge", "repeat", or "mirror-repeat")`);
-    }
-}
+import { assert } from "../../../core/assert.js";
+
+/**
+ * Sample a {@link CPUBitmapData} as if it were a GPU texture bound with
+ * the given sampler. Routes through nearest or linear filtering on each of
+ * the texture's actual axes (1D / 2D / 3D inferred from
+ * `texture.dimensionality`).
+ *
+ * **Mipmaps are intentionally not modelled.** The emulator runs at LOD 0
+ * only — there is no mip pyramid in {@link CPUBitmapData}, and
+ * `mipmapFilter` / `lodMinClamp` / `lodMaxClamp` on the sampler are
+ * ignored. We pick `magFilter` for the actual filter mode, which matches
+ * the intuition that emulator tests are typically up-sampling. Add a mip
+ * pyramid + minification path later if a test ever needs minified
+ * sampling.
+ *
+ * Convention for `texel_coord`: this is **TEXEL-SPACE coordinates** (i.e.
+ * UV * size, NOT normalised UV in [0, 1]). The shader-facing intrinsics
+ * `textureSample` / `textureSampleLevel` take normalised UV; the emulator
+ * converts to texel-space before calling here so the address-mode
+ * arithmetic doesn't have to special-case sub-1.0 jitter. WebGPU's
+ * convention places texel `i`'s centre at texel-space `i + 0.5`, so the
+ * left edge of the texture is at 0 and the right edge at `size`.
+ *
+ * Address-mode handling lives in {@link wrap_int}: every integer texel
+ * index produced by either filter passes through it before reading the
+ * backing buffer. Out-of-range fractional inputs fall out naturally from
+ * floor + integer wrap, so we don't pre-clamp the fractional coord (a
+ * previous version did and lost full-edge texel sampling for
+ * `clamp-to-edge`).
+ *
+ * @param {Float32Array | number[]} output — receives 4 channel values
+ *   (channels beyond `texture.item_size` are zero, with alpha forced to 1
+ *   for textures with fewer than 4 channels — matches WGSL semantics)
+ * @param {import("../../descriptor/texture/SamplerDescriptor.js").SamplerDescriptor} sampler
+ * @param {import("./CPUBitmapData.js").CPUBitmapData} texture
+ * @param {Float32Array | number[]} texel_coord — length matches
+ *   `texture.dimensionality` (1, 2 or 3 entries)
+ */
+export function cpu_texture_sample(output, sampler, texture, texel_coord) {
+    assert.defined(output, 'output');
+    assert.defined(sampler, 'sampler');
+    assert.defined(texture, 'texture');
+    assert.defined(texel_coord, 'texel_coord');
+
+    // Default channels 0..3 to 0; alpha to 1 if the texture has < 4 channels.
+    const item_size = texture.item_size;
+    for (let i = 0; i < 4; i++) output[i] = 0;
+    if (item_size < 4) output[3] = 1;
+
+    const dim = texture.dimensionality;
+    const w = texture.size[0];
+    const h = texture.size[1];
+    const d = texture.size[2];
+
+    const tx = texel_coord[0];
+    const ty = dim >= 2 ? texel_coord[1] : 0;
+    const tz = dim >= 3 ? texel_coord[2] : 0;
+
+    // Mipmaps not modelled — see header. Use magFilter as the single
+    // filter setting (sampler is bound at LOD 0 conceptually).
+    const filter = sampler.magFilter;
+
+    if (filter === "nearest") {
+        // WGSL nearest: texel index = floor(texel_coord), then wrap.
+        const ix = wrap_int(Math.floor(tx), w, sampler.addressModeU);
+        const iy = dim >= 2 ? wrap_int(Math.floor(ty), h, sampler.addressModeV) : 0;
+        const iz = dim >= 3 ? wrap_int(Math.floor(tz), d, sampler.addressModeW) : 0;
+        const base = texture.pixel_offset(ix, iy, iz);
+        const n = Math.min(item_size, 4);
+        for (let i = 0; i < n; i++) output[i] = texture.data[base + i];
+        return;
+    }
+
+    if (filter !== "linear") {
+        throw new Error(`cpu_texture_sample: unsupported magFilter '${filter}' (expected "nearest" or "linear")`);
+    }
+
+    // Linear filter. Sample 2 (1D) / 4 (2D) / 8 (3D) neighbouring texels
+    // around `texel_coord - 0.5` (the offset puts the bilinear origin at
+    // texel CENTRES) with weights `(1 - frac, frac)` per axis. Each
+    // integer index passes through `wrap_int` so the right/bottom/back
+    // neighbour falling off the edge is resolved by the address mode.
+    const px = tx - 0.5;
+    const fx_floor = Math.floor(px);
+    const ix0 = wrap_int(fx_floor, w, sampler.addressModeU);
+    const ix1 = wrap_int(fx_floor + 1, w, sampler.addressModeU);
+    const fx = px - fx_floor;
+
+    let iy0 = 0, iy1 = 0, fy = 0;
+    if (dim >= 2) {
+        const py = ty - 0.5;
+        const fy_floor = Math.floor(py);
+        iy0 = wrap_int(fy_floor, h, sampler.addressModeV);
+        iy1 = wrap_int(fy_floor + 1, h, sampler.addressModeV);
+        fy = py - fy_floor;
+    }
+
+    let iz0 = 0, iz1 = 0, fz = 0;
+    if (dim >= 3) {
+        const pz = tz - 0.5;
+        const fz_floor = Math.floor(pz);
+        iz0 = wrap_int(fz_floor, d, sampler.addressModeW);
+        iz1 = wrap_int(fz_floor + 1, d, sampler.addressModeW);
+        fz = pz - fz_floor;
+    }
+
+    const n = Math.min(item_size, 4);
+
+    // Unrolled 2-corner loop per active axis (max 8 corners total). Skip
+    // zero-weight corners early — common when the fractional offset is
+    // exactly an integer (texel-centre sample).
+    const xs = [ix0, ix1];
+    const wxs = [1 - fx, fx];
+    const ys = [iy0, iy1];
+    const wys = [1 - fy, fy];
+    const zs = [iz0, iz1];
+    const wzs = [1 - fz, fz];
+
+    const y_count = dim >= 2 ? 2 : 1;
+    const z_count = dim >= 3 ? 2 : 1;
+
+    for (let kz = 0; kz < z_count; kz++) {
+        const wz = z_count === 1 ? 1 : wzs[kz];
+        const z = zs[kz];
+        for (let ky = 0; ky < y_count; ky++) {
+            const wy = y_count === 1 ? 1 : wys[ky];
+            const y = ys[ky];
+            for (let kx = 0; kx < 2; kx++) {
+                const wx = wxs[kx];
+                const x = xs[kx];
+                const weight = wx * wy * wz;
+                if (weight === 0) continue;
+                const base = texture.pixel_offset(x, y, z);
+                for (let i = 0; i < n; i++) output[i] += texture.data[base + i] * weight;
+            }
+        }
+    }
+}
+
+/**
+ * Wrap an integer texel index back into `[0, size)` using the address
+ * mode. Shared by both nearest and linear filtering — the linear filter
+ * passes both the floor and floor+1 indices through this so wrapping at
+ * the edge is consistent.
+ *
+ * Exported because {@link cpu_texture_gather} needs the *same* address
+ * arithmetic: a gather's 2x2 footprint is the linear filter's footprint,
+ * and a second copy of this switch would be free to drift from it.
+ *
+ * @param {number} i
+ * @param {number} size
+ * @param {GPUAddressMode} mode
+ * @returns {number}
+ */
+export function wrap_int(i, size, mode) {
+    if (size <= 0) return 0;
+    switch (mode) {
+        case "clamp-to-edge":
+            if (i < 0) return 0;
+            if (i >= size) return size - 1;
+            return i;
+        case "repeat":
+            return ((i % size) + size) % size;
+        case "mirror-repeat": {
+            // fold the second half of the period back onto the first:
+            // w in [size, 2*size) maps to period - 1 - w in [0, size)
+            const period = size * 2;
+            let w = ((i % period) + period) % period;
+            if (w >= size) w = period - 1 - w;
+            return w;
+        }
+        default:
+            throw new Error(`cpu_texture_sample: unsupported address mode '${mode}' (expected "clamp-to-edge", "repeat", or "mirror-repeat")`);
+    }
+}

package/src/shade/renderer/volumetrics/VOLUMETRICS_WORKGROUP_RESOLUTION.d.ts

@@ -1,2 +0,0 @@
-export const VOLUMETRICS_WORKGROUP_RESOLUTION: number[];
-//# sourceMappingURL=VOLUMETRICS_WORKGROUP_RESOLUTION.d.ts.map

package/src/shade/renderer/volumetrics/VOLUMETRICS_WORKGROUP_RESOLUTION.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"VOLUMETRICS_WORKGROUP_RESOLUTION.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/VOLUMETRICS_WORKGROUP_RESOLUTION.js"],"names":[],"mappings":"AAAA,wDAA0D"}

package/src/shade/renderer/volumetrics/VOLUMETRICS_WORKGROUP_RESOLUTION.js

@@ -1 +0,0 @@
-export const VOLUMETRICS_WORKGROUP_RESOLUTION = [8, 8, 4];