@woosh/meep-engine 3.11.1 → 3.11.3

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":"AA2OA;;;;;;;;;;;;GAYG;AACH,+BAFU,MAAM,CAkyBd"}
+{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":"AA0PA;;;;;;;;;;;;GAYG;AACH,+BAFU,MAAM,CAm+Bd"}

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

@@ -1,4 +1,5 @@
 import { assert } from "../../../core/assert.js";
+import { cpu_texture_gather, evaluate_gpu_compare_function } from "./cpu_texture_gather.js";
 import { cpu_texture_sample } from "./cpu_texture_sample.js";
 
 /**
@@ -15,6 +16,20 @@ const FALLBACK_LINEAR_CLAMP_SAMPLER = Object.freeze({
     mipmapFilter: "nearest",
 });
 
+/**
+ * Normalised UV -> texel space, for the gather intrinsics. {@link cpu_texture_gather} takes
+ * texel-space coordinates, the same convention {@link cpu_texture_sample} documents, so the
+ * shader-facing side does the conversion — `textureGather` has no 3D or 1D overload in WGSL,
+ * so only the two axes are ever needed.
+ *
+ * @param {Float32Array | number[]} coords — normalised uv
+ * @param {import("./CPUBitmapData.js").CPUBitmapData} texture
+ * @returns {number[]}
+ */
+function gather_texel_coord(coords, texture) {
+    return [coords[0] * texture.size[0], coords[1] * texture.size[1]];
+}
+
 /**
  * Single-element scratch view used to round a number to IEEE 754 binary16 precision.
  * @type {Float16Array}
@@ -411,6 +426,34 @@ export const WGSLLanguageCore = {
         throw new Error(`determinant: unsupported matrix length ${m.length}`);
     },
 
+    /**
+     * Transpose of a square matrix stored as a flat column-major typed array.
+     *
+     * WGSL's `transpose` also accepts non-square `matCxR`, returning `matRxC`. Matrices here are
+     * flat arrays carrying no shape, so a 2x3 and a 3x2 are indistinguishable at runtime and only
+     * the square sizes can be answered — the same restriction {@link determinant} works under, for
+     * the same reason.
+     *
+     * @param {Float32Array|Float16Array} m
+     */
+    transpose(m) {
+        const n = Math.round(Math.sqrt(m.length));
+
+        if (n * n !== m.length || n < 2 || n > 4) {
+            throw new Error(`transpose: unsupported matrix length ${m.length}, expected a square 2x2, 3x3 or 4x4`);
+        }
+
+        const out = new m.constructor(m.length);
+
+        for (let col = 0; col < n; col++) {
+            for (let row = 0; row < n; row++) {
+                out[col * n + row] = m[row * n + col];
+            }
+        }
+
+        return out;
+    },
+
     // ---------------------------------------------------------------------
     // Arithmetic helpers (work on scalars and vectors element-wise)
     // ---------------------------------------------------------------------
@@ -761,10 +804,15 @@ export const WGSLLanguageCore = {
      * across all channels (with alpha defaulting to 1.0 for textures with
      * fewer than 4 channels - matches WGSL semantics).
      *
+     * A texture flagged `is_depth` returns a bare `f32` instead, matching WGSL: `textureLoad` on a
+     * `texture_depth_*` is declared to yield a scalar, and shader code written against one uses it
+     * as such. Handing that code a vec4 would turn every use into a component-wise broadcast that
+     * neither throws nor matches the device.
+     *
      * @param {import("./CPUBitmapData.js").CPUBitmapData} t
      * @param {Int32Array | Uint32Array | number[] | number} coords
      * @param {number} [_level] - ignored, mipmaps are not modelled
-     * @returns {Float32Array}
+     * @returns {Float32Array | number}
      */
     textureLoad(t, coords, _level_or_index = 0, _array_level = undefined) {
         assert.defined(t, 'texture');
@@ -780,8 +828,14 @@ export const WGSLLanguageCore = {
         */
         const z = (_array_level !== undefined ? _level_or_index : (dim >= 3 ? coords[2] : 0)) | 0;
         const item_size = t.item_size;
+        const out_of_bounds = x < 0 || x >= t.size[0] || y < 0 || y >= t.size[1] || z < 0 || z >= t.size[2];
+
+        if (t.is_depth === true) {
+            return out_of_bounds ? 0.0 : t.data[t.pixel_offset(x, y, z)];
+        }
+
         if (item_size < 4) out[3] = 1.0;
-        if (x < 0 || x >= t.size[0] || y < 0 || y >= t.size[1] || z < 0 || z >= t.size[2]) {
+        if (out_of_bounds) {
             return out;
         }
         const base = t.pixel_offset(x, y, z);
@@ -878,6 +932,160 @@ export const WGSLLanguageCore = {
         return WGSLLanguageCore.textureSampleLevel(t, sampler, coords, 0);
     },
 
+    /**
+     * `textureGather(component, t, s, coords[, array_index][, offset]) -> vec4<f32>` and the
+     * depth-texture overloads `textureGather(t, s, coords[, array_index][, offset])`, which carry
+     * no `component` argument because a `texture_depth_*` has a single channel.
+     *
+     * Returns the four texels of the bilinear footprint unblended, in WGSL's order —
+     * counter-clockwise from the lower-left, so `.wzxy` is row-major. See
+     * {@link cpu_texture_gather} for the footprint derivation, the component order in full, and
+     * why `magFilter` is ignored here (a gather never filters).
+     *
+     * Overloads are told apart by argument SHAPE, the way `textureLoad` and `textureSampleLevel`
+     * already tell their array forms apart: a leading number is the `component` of a colour
+     * gather, a leading texture means the depth overload; among the trailing arguments a number
+     * is an `array_index` and a vector is the const `offset`.
+     *
+     * **Cube textures are not supported** and throw rather than returning something. The emulator
+     * models no cube layout at all — {@link CPUBitmapData} is a flat 1D/2D/3D grid — so there is
+     * no face selection to gather across. A cube gather is recognisable by its `vec3` direction
+     * coordinate (`texture_3d` has no gather overload in WGSL at all).
+     *
+     * @param {number | import("./CPUBitmapData.js").CPUBitmapData} p0 — `component`, or the
+     *   texture in the depth overloads
+     * @param {*} p1
+     * @param {*} p2
+     * @param {*} p3
+     * @param {*} [p4]
+     * @param {*} [p5]
+     * @returns {Float32Array}
+     */
+    textureGather(p0, p1, p2, p3, p4 = undefined, p5 = undefined) {
+        const has_component = typeof p0 === 'number';
+
+        const t = has_component ? p1 : p0;
+        const sampler = has_component ? p2 : p1;
+        const coords = has_component ? p3 : p2;
+
+        assert.defined(t, 'texture');
+
+        if (coords !== null && coords !== undefined && coords.length >= 3) {
+            throw new Error("textureGather: cube textures are not supported — the emulator has no cube layout to gather a face out of (CPUBitmapData is a flat 1D/2D/3D grid). Remap to an octahedral or array atlas, as the engine's shadow path does, and gather from that.");
+        }
+
+        const component = has_component ? (p0 | 0) : 0;
+
+        let array_index = 0;
+        let offset_x = 0;
+        let offset_y = 0;
+
+        const extra_a = has_component ? p4 : p3;
+        const extra_b = has_component ? p5 : p4;
+
+        if (typeof extra_a === 'number') array_index = extra_a;
+        else if (extra_a !== undefined) { offset_x = extra_a[0]; offset_y = extra_a[1]; }
+
+        if (extra_b !== undefined) { offset_x = extra_b[0]; offset_y = extra_b[1]; }
+
+        const result = new Float32Array(4);
+
+        cpu_texture_gather(
+            result,
+            sampler ?? FALLBACK_LINEAR_CLAMP_SAMPLER,
+            t,
+            gather_texel_coord(coords, t),
+            component,
+            offset_x,
+            offset_y,
+            array_index
+        );
+
+        return result;
+    },
+
+    /**
+     * `textureGatherCompare(t, s, coords[, array_index], depth_ref[, offset]) -> vec4<f32>`
+     *
+     * The comparison form: each of the four gathered texels is tested against `depth_ref` and
+     * yields 1.0 or 0.0 — unfiltered, per texel. The blend is the shader's job, which is exactly
+     * what `shadowmap_sample_filtered` does with the result (`.wzxy` into
+     * `interpolate_bilinear_f32`).
+     *
+     * The comparison itself comes from the bound sampler's `compare`, evaluated as
+     * `compare(depth_ref, texel)` — see {@link evaluate_gpu_compare_function} for why that order
+     * is load-bearing. A sampler with no `compare` set is an error rather than a defaulted one:
+     * WGSL requires a `sampler_comparison` here, and picking a direction on the caller's behalf
+     * would invert shadows silently.
+     *
+     * Overload disambiguation is by shape, as in {@link textureGather}: a trailing vector is the
+     * const `offset`, and a fourth argument that is followed by another number is the
+     * `array_index` rather than the reference depth.
+     *
+     * @param {import("./CPUBitmapData.js").CPUBitmapData} t
+     * @param {import("../../descriptor/texture/SamplerDescriptor.js").SamplerDescriptor} sampler
+     * @param {Float32Array | number[]} coords
+     * @param {*} p3 — `depth_ref`, or the `array_index` in the array forms
+     * @param {*} [p4]
+     * @param {*} [p5]
+     * @returns {Float32Array}
+     */
+    textureGatherCompare(t, sampler, coords, p3, p4 = undefined, p5 = undefined) {
+        assert.defined(t, 'texture');
+
+        if (coords !== null && coords !== undefined && coords.length >= 3) {
+            throw new Error("textureGatherCompare: cube textures are not supported — the emulator has no cube layout to gather a face out of (CPUBitmapData is a flat 1D/2D/3D grid). Remap to an octahedral or array atlas, as the engine's shadow path does, and gather from that.");
+        }
+
+        let array_index = 0;
+        let depth_ref;
+        let offset = undefined;
+
+        if (p5 !== undefined) {
+            // (t, s, coords, array_index, depth_ref, offset)
+            array_index = p3;
+            depth_ref = p4;
+            offset = p5;
+        } else if (p4 === undefined) {
+            // (t, s, coords, depth_ref)
+            depth_ref = p3;
+        } else if (typeof p4 === 'number') {
+            // (t, s, coords, array_index, depth_ref) — a scalar in the 5th slot is the reference
+            array_index = p3;
+            depth_ref = p4;
+        } else {
+            // (t, s, coords, depth_ref, offset) — a vector in the 5th slot is the offset
+            depth_ref = p3;
+            offset = p4;
+        }
+
+        const effective_sampler = sampler ?? FALLBACK_LINEAR_CLAMP_SAMPLER;
+        const compare = effective_sampler.compare;
+
+        if (compare === undefined || compare === null) {
+            throw new Error("textureGatherCompare: the bound sampler has no 'compare' function — WGSL requires a sampler_comparison here. Bind a SamplerDescriptor with `compare` set (the engine's shadow path uses SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR, `compare: \"greater\"` for reverse-Z).");
+        }
+
+        const result = new Float32Array(4);
+
+        cpu_texture_gather(
+            result,
+            effective_sampler,
+            t,
+            gather_texel_coord(coords, t),
+            0,
+            offset !== undefined ? offset[0] : 0,
+            offset !== undefined ? offset[1] : 0,
+            array_index
+        );
+
+        for (let i = 0; i < 4; i++) {
+            result[i] = evaluate_gpu_compare_function(compare, depth_ref, result[i]);
+        }
+
+        return result;
+    },
+
     /**
      * `textureStore(t, coords, value) -> ()`
      *

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

@@ -0,0 +1,69 @@
+/**
+ * Read the four texels of a bilinear footprint out of a {@link CPUBitmapData} without
+ * blending them — the CPU side of WGSL's `textureGather` / `textureGatherCompare`.
+ *
+ * **The footprint is the linear filter's footprint.** `cpu_texture_sample` derives it as
+ * `px = texel_coord - 0.5`, then `floor(px)` and `floor(px) + 1` on each axis, each index
+ * passed through {@link wrap_int} for the address mode. A gather covers exactly those four
+ * texels, so this function reuses that arithmetic rather than restating it.
+ *
+ * **`magFilter` is deliberately ignored.** A gather always returns four texels — the
+ * sampler's filter mode selects nothing, because no filtering happens. This is the one
+ * place `cpu_texture_sample` cannot simply be called: under `magFilter: "nearest"` it
+ * collapses to a single texel, which is right for a sample and wrong for a gather. The
+ * address modes still apply, and they are the only part of the sampler this reads.
+ *
+ * **Mipmaps are not modelled — LOD 0 only.** Same stance, and for the same reason, as
+ * {@link cpu_texture_sample}; see its header. `textureGather` has no LOD parameter in WGSL
+ * anyway, so here the restriction costs nothing.
+ *
+ * Convention for `texel_coord`, as in {@link cpu_texture_sample}: **texel-space**
+ * coordinates (UV * size), not normalised UV. The shader-facing intrinsics in
+ * {@link WGSLLanguageCore} do the conversion before calling.
+ *
+ * Component order is WGSL's, counter-clockwise from the lower-left texel — the same order
+ * D3D and Vulkan use:
+ *
+ * ```
+ *   output[0] = (u_min, v_max)   lower-left
+ *   output[1] = (u_max, v_max)   lower-right
+ *   output[2] = (u_max, v_min)   upper-right
+ *   output[3] = (u_min, v_min)   upper-left
+ * ```
+ *
+ * so `gathered.wzxy` is the row-major (x0y0, x1y0, x0y1, x1y1) order a bilinear blend
+ * wants — which is exactly the swizzle `shadowmap_sample_filtered` applies before handing
+ * the result to `interpolate_bilinear_f32`.
+ *
+ * @param {Float32Array | number[]} output — receives the 4 gathered texel values
+ * @param {import("../../descriptor/texture/SamplerDescriptor.js").SamplerDescriptor} sampler
+ * @param {import("./CPUBitmapData.js").CPUBitmapData} texture
+ * @param {Float32Array | number[]} texel_coord — `[x, y]` in texel space
+ * @param {number} [component] — channel to read, 0..3. Forced to 0 for a depth texture,
+ *   which has a single channel and whose WGSL overloads take no component argument.
+ * @param {number} [offset_x] — const `vec2<i32>` offset, applied to the integer texel
+ *   indices *before* the address mode, per WGSL
+ * @param {number} [offset_y]
+ * @param {number} [layer] — array slice for the `_2d_array` forms; clamped to the
+ *   texture's depth
+ */
+export function cpu_texture_gather(output: Float32Array | number[], sampler: import("../../descriptor/texture/SamplerDescriptor.js").SamplerDescriptor, texture: import("./CPUBitmapData.js").CPUBitmapData, texel_coord: Float32Array | number[], component?: number, offset_x?: number, offset_y?: number, layer?: number): void;
+/**
+ * Evaluate a `GPUCompareFunction` the way a comparison sampler does.
+ *
+ * **Argument order matters and is easy to invert.** WebGPU evaluates
+ * `compare(reference, sampled)` — the shader's `depth_ref` is the LEFT operand, the value
+ * read out of the depth texture is the right one. So under `"greater"` (what the engine's
+ * {@link SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR} uses, because shadow maps are reverse-Z) a
+ * receiver passes — result 1.0, "lit" — when its own depth is *greater* than the stored
+ * occluder depth, i.e. when it is nearer to the light. Swapping the operands inverts every
+ * shadow in the engine while still producing plausible-looking output, which is why
+ * `cpu_texture_gather.spec.js` pins the direction explicitly.
+ *
+ * @param {GPUCompareFunction} compare
+ * @param {number} reference — the shader's `depth_ref`
+ * @param {number} sampled — the texel read from the depth texture
+ * @returns {number} 1.0 when the comparison passes, 0.0 when it fails
+ */
+export function evaluate_gpu_compare_function(compare: GPUCompareFunction, reference: number, sampled: number): number;
+//# sourceMappingURL=cpu_texture_gather.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cpu_texture_gather.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/cpu_texture_gather.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,2CAZW,YAAY,GAAG,MAAM,EAAE,WACvB,OAAO,+CAA+C,EAAE,iBAAiB,WACzE,OAAO,oBAAoB,EAAE,aAAa,eAC1C,YAAY,GAAG,MAAM,EAAE,cACvB,MAAM,aAEN,MAAM,aAEN,MAAM,UACN,MAAM,QAqChB;AAwBD;;;;;;;;;;;;;;;;GAgBG;AACH,sFAJW,MAAM,WACN,MAAM,GACJ,MAAM,CAuBlB"}

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

@@ -0,0 +1,148 @@
+import { wrap_int } from "./cpu_texture_sample.js";
+
+/**
+ * Read the four texels of a bilinear footprint out of a {@link CPUBitmapData} without
+ * blending them — the CPU side of WGSL's `textureGather` / `textureGatherCompare`.
+ *
+ * **The footprint is the linear filter's footprint.** `cpu_texture_sample` derives it as
+ * `px = texel_coord - 0.5`, then `floor(px)` and `floor(px) + 1` on each axis, each index
+ * passed through {@link wrap_int} for the address mode. A gather covers exactly those four
+ * texels, so this function reuses that arithmetic rather than restating it.
+ *
+ * **`magFilter` is deliberately ignored.** A gather always returns four texels — the
+ * sampler's filter mode selects nothing, because no filtering happens. This is the one
+ * place `cpu_texture_sample` cannot simply be called: under `magFilter: "nearest"` it
+ * collapses to a single texel, which is right for a sample and wrong for a gather. The
+ * address modes still apply, and they are the only part of the sampler this reads.
+ *
+ * **Mipmaps are not modelled — LOD 0 only.** Same stance, and for the same reason, as
+ * {@link cpu_texture_sample}; see its header. `textureGather` has no LOD parameter in WGSL
+ * anyway, so here the restriction costs nothing.
+ *
+ * Convention for `texel_coord`, as in {@link cpu_texture_sample}: **texel-space**
+ * coordinates (UV * size), not normalised UV. The shader-facing intrinsics in
+ * {@link WGSLLanguageCore} do the conversion before calling.
+ *
+ * Component order is WGSL's, counter-clockwise from the lower-left texel — the same order
+ * D3D and Vulkan use:
+ *
+ * ```
+ *   output[0] = (u_min, v_max)   lower-left
+ *   output[1] = (u_max, v_max)   lower-right
+ *   output[2] = (u_max, v_min)   upper-right
+ *   output[3] = (u_min, v_min)   upper-left
+ * ```
+ *
+ * so `gathered.wzxy` is the row-major (x0y0, x1y0, x0y1, x1y1) order a bilinear blend
+ * wants — which is exactly the swizzle `shadowmap_sample_filtered` applies before handing
+ * the result to `interpolate_bilinear_f32`.
+ *
+ * @param {Float32Array | number[]} output — receives the 4 gathered texel values
+ * @param {import("../../descriptor/texture/SamplerDescriptor.js").SamplerDescriptor} sampler
+ * @param {import("./CPUBitmapData.js").CPUBitmapData} texture
+ * @param {Float32Array | number[]} texel_coord — `[x, y]` in texel space
+ * @param {number} [component] — channel to read, 0..3. Forced to 0 for a depth texture,
+ *   which has a single channel and whose WGSL overloads take no component argument.
+ * @param {number} [offset_x] — const `vec2<i32>` offset, applied to the integer texel
+ *   indices *before* the address mode, per WGSL
+ * @param {number} [offset_y]
+ * @param {number} [layer] — array slice for the `_2d_array` forms; clamped to the
+ *   texture's depth
+ */
+export function cpu_texture_gather(
+    output,
+    sampler,
+    texture,
+    texel_coord,
+    component = 0,
+    offset_x = 0,
+    offset_y = 0,
+    layer = 0
+) {
+    const w = texture.size[0];
+    const h = texture.size[1];
+    const d = texture.size[2];
+
+    // A depth texture is single-channel; its gather overloads carry no component argument.
+    const channel = texture.is_depth === true ? 0 : (component | 0);
+
+    // Same derivation as the linear branch of `cpu_texture_sample`: shift by half a texel so
+    // the footprint is anchored on texel CENTRES, then floor.
+    const x_floor = Math.floor(texel_coord[0] - 0.5) + (offset_x | 0);
+    const y_floor = Math.floor(texel_coord[1] - 0.5) + (offset_y | 0);
+
+    const x0 = wrap_int(x_floor, w, sampler.addressModeU);
+    const x1 = wrap_int(x_floor + 1, w, sampler.addressModeU);
+    const y0 = wrap_int(y_floor, h, sampler.addressModeV);
+    const y1 = wrap_int(y_floor + 1, h, sampler.addressModeV);
+
+    // The array index is not an address-mode axis — WGSL clamps it to the layer count.
+    const z = d <= 0 ? 0 : Math.min(Math.max(layer | 0, 0), d - 1);
+
+    output[0] = read_channel(texture, x0, y1, z, channel);
+    output[1] = read_channel(texture, x1, y1, z, channel);
+    output[2] = read_channel(texture, x1, y0, z, channel);
+    output[3] = read_channel(texture, x0, y0, z, channel);
+}
+
+/**
+ * One channel of one texel. Channels past the texture's `item_size` follow the same
+ * convention `cpu_texture_sample` uses for its output vector: zero, with alpha defaulting
+ * to 1 — matching WGSL's rule for formats with fewer than four channels.
+ *
+ * Coordinates arrive already wrapped by {@link wrap_int}, so no bounds check is needed.
+ *
+ * @param {import("./CPUBitmapData.js").CPUBitmapData} texture
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number} component
+ * @returns {number}
+ */
+function read_channel(texture, x, y, z, component) {
+    if (component >= texture.item_size) {
+        return component === 3 ? 1 : 0;
+    }
+
+    return texture.data[texture.pixel_offset(x, y, z) + component];
+}
+
+/**
+ * Evaluate a `GPUCompareFunction` the way a comparison sampler does.
+ *
+ * **Argument order matters and is easy to invert.** WebGPU evaluates
+ * `compare(reference, sampled)` — the shader's `depth_ref` is the LEFT operand, the value
+ * read out of the depth texture is the right one. So under `"greater"` (what the engine's
+ * {@link SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR} uses, because shadow maps are reverse-Z) a
+ * receiver passes — result 1.0, "lit" — when its own depth is *greater* than the stored
+ * occluder depth, i.e. when it is nearer to the light. Swapping the operands inverts every
+ * shadow in the engine while still producing plausible-looking output, which is why
+ * `cpu_texture_gather.spec.js` pins the direction explicitly.
+ *
+ * @param {GPUCompareFunction} compare
+ * @param {number} reference — the shader's `depth_ref`
+ * @param {number} sampled — the texel read from the depth texture
+ * @returns {number} 1.0 when the comparison passes, 0.0 when it fails
+ */
+export function evaluate_gpu_compare_function(compare, reference, sampled) {
+    switch (compare) {
+        case "never":
+            return 0;
+        case "less":
+            return reference < sampled ? 1 : 0;
+        case "equal":
+            return reference === sampled ? 1 : 0;
+        case "less-equal":
+            return reference <= sampled ? 1 : 0;
+        case "greater":
+            return reference > sampled ? 1 : 0;
+        case "not-equal":
+            return reference !== sampled ? 1 : 0;
+        case "greater-equal":
+            return reference >= sampled ? 1 : 0;
+        case "always":
+            return 1;
+        default:
+            throw new Error(`evaluate_gpu_compare_function: unsupported compare function '${compare}' (expected one of "never", "less", "equal", "less-equal", "greater", "not-equal", "greater-equal", "always")`);
+    }
+}

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

@@ -36,4 +36,20 @@
  *   `texture.dimensionality` (1, 2 or 3 entries)
  */
 export function cpu_texture_sample(output: Float32Array | number[], sampler: import("../../descriptor/texture/SamplerDescriptor.js").SamplerDescriptor, texture: import("./CPUBitmapData.js").CPUBitmapData, texel_coord: Float32Array | number[]): void;
+/**
+ * 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: number, size: number, mode: GPUAddressMode): number;
 //# sourceMappingURL=cpu_texture_sample.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"cpu_texture_sample.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/cpu_texture_sample.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,2CARW,YAAY,GAAG,MAAM,EAAE,WAGvB,OAAO,+CAA+C,EAAE,iBAAiB,WACzE,OAAO,oBAAoB,EAAE,aAAa,eAC1C,YAAY,GAAG,MAAM,EAAE,QAsGjC"}
+{"version":3,"file":"cpu_texture_sample.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/cpu_texture_sample.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,2CARW,YAAY,GAAG,MAAM,EAAE,WAGvB,OAAO,+CAA+C,EAAE,iBAAiB,WACzE,OAAO,oBAAoB,EAAE,aAAa,eAC1C,YAAY,GAAG,MAAM,EAAE,QAsGjC;AAED;;;;;;;;;;;;;;GAcG;AACH,4BALW,MAAM,QACN,MAAM,yBAEJ,MAAM,CAsBlB"}