@woosh/meep-engine 3.60.4 → 3.60.5

package/src/shade/renderer/hiz/chunk_hzb_footprint_x.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The mip 0 reduction's footprint across x, in source texels, by {@link HZB_FOOTPRINT_X}:
+ *
+ * ```wgsl
+ * const HZB_FOOTPRINT_X: i32
+ * ```
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_hzb_footprint_x: CodeChunkChoice;
+import { CodeChunkChoice } from "../shader/compiler/CodeChunkChoice.js";
+//# sourceMappingURL=chunk_hzb_footprint_x.d.ts.map

package/src/shade/renderer/hiz/chunk_hzb_footprint_x.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_hzb_footprint_x.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/chunk_hzb_footprint_x.js"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH,oCAFU,eAAe,CAEkD;gCAb3C,uCAAuC"}

package/src/shade/renderer/hiz/chunk_hzb_footprint_x.js

@@ -0,0 +1,27 @@
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { CodeChunkChoice } from "../shader/compiler/CodeChunkChoice.js";
+import { HZB_FOOTPRINT_X } from "./HZB_FOOTPRINT_X.js";
+import { HZBFootprint } from "./HZBFootprint.js";
+
+/**
+ * The mip 0 reduction's footprint across x, in source texels, by {@link HZB_FOOTPRINT_X}:
+ *
+ * ```wgsl
+ * const HZB_FOOTPRINT_X: i32
+ * ```
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_hzb_footprint_x = CodeChunkChoice.from(HZB_FOOTPRINT_X);
+
+chunk_hzb_footprint_x.add(HZBFootprint.Two, CodeChunk.from(
+    //language=WGSL
+    `
+const HZB_FOOTPRINT_X: i32 = 2;
+`));
+
+chunk_hzb_footprint_x.add(HZBFootprint.Three, CodeChunk.from(
+    //language=WGSL
+    `
+const HZB_FOOTPRINT_X: i32 = 3;
+`));

package/src/shade/renderer/hiz/chunk_hzb_footprint_y.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The mip 0 reduction's footprint across y, in source texels, by {@link HZB_FOOTPRINT_Y}:
+ *
+ * ```wgsl
+ * const HZB_FOOTPRINT_Y: i32
+ * ```
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_hzb_footprint_y: CodeChunkChoice;
+import { CodeChunkChoice } from "../shader/compiler/CodeChunkChoice.js";
+//# sourceMappingURL=chunk_hzb_footprint_y.d.ts.map

package/src/shade/renderer/hiz/chunk_hzb_footprint_y.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_hzb_footprint_y.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/chunk_hzb_footprint_y.js"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH,oCAFU,eAAe,CAEkD;gCAb3C,uCAAuC"}

package/src/shade/renderer/hiz/chunk_hzb_footprint_y.js

@@ -0,0 +1,27 @@
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { CodeChunkChoice } from "../shader/compiler/CodeChunkChoice.js";
+import { HZB_FOOTPRINT_Y } from "./HZB_FOOTPRINT_Y.js";
+import { HZBFootprint } from "./HZBFootprint.js";
+
+/**
+ * The mip 0 reduction's footprint across y, in source texels, by {@link HZB_FOOTPRINT_Y}:
+ *
+ * ```wgsl
+ * const HZB_FOOTPRINT_Y: i32
+ * ```
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_hzb_footprint_y = CodeChunkChoice.from(HZB_FOOTPRINT_Y);
+
+chunk_hzb_footprint_y.add(HZBFootprint.Two, CodeChunk.from(
+    //language=WGSL
+    `
+const HZB_FOOTPRINT_Y: i32 = 2;
+`));
+
+chunk_hzb_footprint_y.add(HZBFootprint.Three, CodeChunk.from(
+    //language=WGSL
+    `
+const HZB_FOOTPRINT_Y: i32 = 3;
+`));

package/src/shade/renderer/hiz/hzb_footprint_texels.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The widest footprint, in source texels along one axis, of any HZB texel when `output_size` texels cover
+ * `source_size`: HZB texel `i` covers `[i·s/o, (i+1)·s/o)` and reduces every source texel that span
+ * touches, clipped to the source.
+ *
+ * An upper bound on the footprints {@link shader_hzb_reduce_mip0} reads, whose bounds are this span
+ * nudged inward by a float epsilon.
+ *
+ * @param {number} source_size source texels on the axis
+ * @param {number} output_size HZB mip 0 texels on the axis
+ * @returns {number}
+ */
+export function hzb_footprint_texels(source_size: number, output_size: number): number;
+//# sourceMappingURL=hzb_footprint_texels.d.ts.map

package/src/shade/renderer/hiz/hzb_footprint_texels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hzb_footprint_texels.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/hzb_footprint_texels.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,kDAJW,MAAM,eACN,MAAM,GACJ,MAAM,CAqBlB"}

package/src/shade/renderer/hiz/hzb_footprint_texels.js

@@ -0,0 +1,34 @@
+import { assert } from "../../../core/assert.js";
+
+/**
+ * The widest footprint, in source texels along one axis, of any HZB texel when `output_size` texels cover
+ * `source_size`: HZB texel `i` covers `[i·s/o, (i+1)·s/o)` and reduces every source texel that span
+ * touches, clipped to the source.
+ *
+ * An upper bound on the footprints {@link shader_hzb_reduce_mip0} reads, whose bounds are this span
+ * nudged inward by a float epsilon.
+ *
+ * @param {number} source_size source texels on the axis
+ * @param {number} output_size HZB mip 0 texels on the axis
+ * @returns {number}
+ */
+export function hzb_footprint_texels(source_size, output_size) {
+    assert.isNonNegativeInteger(source_size, 'source_size');
+    assert.isNonNegativeInteger(output_size, 'output_size');
+    assert.greaterThan(output_size, 0, 'output_size');
+
+    let widest = 0;
+
+    for (let i = 0; i < output_size; i++) {
+        const first = Math.floor(i * source_size / output_size);
+        const end = Math.min(Math.ceil((i + 1) * source_size / output_size), source_size);
+
+        const width = end - first;
+
+        if (width > widest) {
+            widest = width;
+        }
+    }
+
+    return widest;
+}

package/src/shade/renderer/hiz/shader_hzb_reduce_any.d.ts

@@ -1,8 +1,3 @@
-/**
- * Initial reduction pass, works with non-power-of-two resolutions as input
- * @type {ComputeShader}
- */
-export const shader_hzb_reduce_mip0: ComputeShader;
 /**
  * Mip1+ reduction pass, works with non-power-of-two resolutions as input
  * @type {ComputeShader}

package/src/shade/renderer/hiz/shader_hzb_reduce_any.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_hzb_reduce_any.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/shader_hzb_reduce_any.js"],"names":[],"mappings":"AAoBA;;;GAGG;AACH,qCAFU,aAAa,CAepB;AAGH;;;GAGG;AACH,oCAFU,aAAa,CAcpB;8BAvD2B,4BAA4B"}
+{"version":3,"file":"shader_hzb_reduce_any.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/shader_hzb_reduce_any.js"],"names":[],"mappings":"AAoBA;;;GAGG;AACH,oCAFU,aAAa,CAcpB;8BAnC2B,4BAA4B"}

package/src/shade/renderer/hiz/shader_hzb_reduce_any.js

@@ -1,57 +1,37 @@
-import { vec2f, vec2u } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { ComputeShader } from "../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
-import { generate_downsampler_code } from "./generate_downsampler_code.js";
-
-import { HZB_TEXTURE_FORMAT } from "./HZB_TEXTURE_FORMAT.js";
-
-const resources = new ShaderResourceSetDescriptor();
-
-// per-pass, eight bytes, read-only: immediate data rather than a uniform buffer. The reduction
-// walks the mip chain a pass at a time and every pass wants a different resolution, which used to
-// mean a persistent table of them bound at a per-mip dynamic offset.
-resources.setImmediate("output_resolution", vec2u);
-
-resources.createGroup()
-    .addTexture("tInput", "unfilterable-float")
-    .addStorageTexture("tOutput", HZB_TEXTURE_FORMAT, "2d", "write-only")
-;
-
-
-/**
- * Initial reduction pass, works with non-power-of-two resolutions as input
- * @type {ComputeShader}
- */
-export const shader_hzb_reduce_mip0 = ComputeShader.from({
-    label: 'HZB / reduce mip0',
-    // NOTE: we reduce from depth, so texel read happens from the .R (X) channel for both min and max.
-    body: generate_downsampler_code({
-        type: vec2f,
-        initial_value: 'vec2( 1.0, 0.0 )',
-        //language=WGSL
-        reduction_code: `
-        output.x = min(texel.x, output.x);
-        output.y = max(texel.x, output.y);
-        `,
-    }),
-    resources,
-});
-
-
-/**
- * Mip1+ reduction pass, works with non-power-of-two resolutions as input
- * @type {ComputeShader}
- */
-export const shader_hzb_reduce_any = ComputeShader.from({
-    label: 'HZB / reduce any resolution',
-    body: generate_downsampler_code({
-        type: vec2f,
-        initial_value: 'vec2( 1.0, 0.0 )',
-        //language=WGSL
-        reduction_code: `
-        output.x = min(texel.x, output.x);
-        output.y = max(texel.y, output.y);
-        `,
-    }),
-    resources,
-});
+import { vec2f, vec2u } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { ComputeShader } from "../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { generate_downsampler_code } from "./generate_downsampler_code.js";
+
+import { HZB_TEXTURE_FORMAT } from "./HZB_TEXTURE_FORMAT.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+// per-pass, eight bytes, read-only: immediate data rather than a uniform buffer. The reduction
+// walks the mip chain a pass at a time and every pass wants a different resolution, which used to
+// mean a persistent table of them bound at a per-mip dynamic offset.
+resources.setImmediate("output_resolution", vec2u);
+
+resources.createGroup()
+    .addTexture("tInput", "unfilterable-float")
+    .addStorageTexture("tOutput", HZB_TEXTURE_FORMAT, "2d", "write-only")
+;
+
+
+/**
+ * Mip1+ reduction pass, works with non-power-of-two resolutions as input
+ * @type {ComputeShader}
+ */
+export const shader_hzb_reduce_any = ComputeShader.from({
+    label: 'HZB / reduce any resolution',
+    body: generate_downsampler_code({
+        type: vec2f,
+        initial_value: 'vec2( 1.0, 0.0 )',
+        //language=WGSL
+        reduction_code: `
+        output.x = min(texel.x, output.x);
+        output.y = max(texel.y, output.y);
+        `,
+    }),
+    resources,
+});

package/src/shade/renderer/hiz/shader_hzb_reduce_mip0.d.ts

@@ -0,0 +1,11 @@
+/**
+ * First reduction: depth of a region of the source (`settings.clip_region`) into the HZB's mip 0, min in
+ * R and max in G. The region is the whole viewport for a camera, and a slot of the atlas for a shadow
+ * map. Each HZB texel reduces every source texel its area overlaps, a footprint of
+ * {@link HZB_FOOTPRINT_X} by {@link HZB_FOOTPRINT_Y} texels at most.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_hzb_reduce_mip0: ComputeShader;
+import { ComputeShader } from "../shader/ComputeShader.js";
+//# sourceMappingURL=shader_hzb_reduce_mip0.d.ts.map

package/src/shade/renderer/hiz/shader_hzb_reduce_mip0.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_hzb_reduce_mip0.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/shader_hzb_reduce_mip0.js"],"names":[],"mappings":"AA2GA;;;;;;;GAOG;AACH,qCAFU,aAAa,CAMpB;8BApH2B,4BAA4B"}

package/src/shade/renderer/hiz/{shader_hzb_reduce_mip0_clip.js → shader_hzb_reduce_mip0.js}

@@ -1,111 +1,120 @@
-import { vec2u, vec4u } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
-import { HZB_TEXTURE_FORMAT } from "./HZB_TEXTURE_FORMAT.js";
-
-/**
- * Per-pass, 24 bytes, read-only.
- *
- * `clip_region` and `output_resolution` were two uniforms, so two buffers per pass. WGSL allows one
- * immediate per entry point, so carrying them as immediate data means carrying them together.
- *
- * @type {WebGPUStruct}
- */
-const HZB_CLIP_SETTINGS = WebGPUStruct.from({
-    // x, y, width, height
-    clip_region: vec4u,
-    output_resolution: vec2u,
-}, 'HzbClipSettings');
-
-const resources = new ShaderResourceSetDescriptor();
-
-resources.setImmediate("settings", HZB_CLIP_SETTINGS);
-
-resources.createGroup()
-    .addTexture("tInput", "unfilterable-float")
-    .addStorageTexture("tOutput", HZB_TEXTURE_FORMAT, "2d", "write-only")
-;
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@compute @workgroup_size(16, 16)
-fn main(
-    @builtin(global_invocation_id) global_id: vec3<u32>,
-) {
-    if (any(global_id.xy >= settings.output_resolution)) {
-        return;
-    }
-
-    // 1. Calculate the UV bounds of the current *output* pixel.
-    //    We use the output resolution to determine how wide one pixel is in UV space.
-    let output_resolution_f = vec2<f32>(settings.output_resolution);
-    let uv = (vec2<f32>(global_id.xy) + 0.5) / output_resolution_f;
-    let output_pixel_size2 = 0.5 / output_resolution_f;
-    let uv_min = uv - output_pixel_size2;
-    let uv_max = uv + output_pixel_size2; 
-
-    // minor epsilon to avoid float rounding errors
-    const EPSILON = 1e-6;
-    
-    // Nudge the bounds slightly inward to absorb floating-point drift
-    let safe_uv_min = uv_min + EPSILON;
-    let safe_uv_max = uv_max - EPSILON;
-    
-    // 2. Convert UV bounds to Source Texel coordinates (float).
-    //    We map the 0..1 UVs to the size of the source clip region.
-    let source_size = vec2<f32>(settings.clip_region.zw);
-    let texel_min_f = safe_uv_min * source_size;
-    let texel_max_f = safe_uv_max * source_size;
-
-    // 3. Convert to Integer Loop Bounds.
-    //    Floor the min to find the first pixel.
-    //    Ceil the max to find the exclusive upper bound.
-    //    Example (5px -> 2px):
-    //      Output Px 0 covers UV 0.0-0.5 -> Source 0.0 to 2.5
-    //      Floor(0.0) = 0. Ceil(2.5) = 3. Loop 0, 1, 2. (Pixel 2 is partially covered)
-    //      Output Px 1 covers UV 0.5-1.0 -> Source 2.5 to 5.0
-    //      Floor(2.5) = 2. Ceil(5.0) = 5. Loop 2, 3, 4. (Pixel 2 is partially covered again)
-    let bound_min = vec2<i32>(floor(texel_min_f));
-    let bound_max = vec2<i32>(ceil(texel_max_f));
-
-    // 4. Clamp bounds to the clip region size to be safe.
-    let limit = vec2<i32>(settings.clip_region.zw);
-    
-    let start = max(bound_min, vec2<i32>(0)) + vec2<i32>(settings.clip_region.xy);
-    let end   = min(bound_max, limit) + vec2<i32>(settings.clip_region.xy);
-
-    var output = vec2<f32>(1.0, 0.0); // Initialize min/max
-
-    // 5. Loop. Note strict usage of < end (exclusive) and i32 types.
-    for (var y = start.y; y < end.y; y++) {
-        for (var x = start.x; x < end.x; x++) {
-            
-            // Add the clip region offset (atlas support)
-            let load_coord = vec2<i32>(x, y);
-
-            let v = textureLoad(tInput, load_coord, 0).r;
-            
-            output.x = min(output.x, v);
-            output.y = max(output.y, v);
-        }
-    }
-    
-    textureStore(tOutput, vec2<i32>(global_id.xy), vec4<f32>(output, 0.0, 0.0));
-}
-    `, [
-    ]
-)
-
-/**
- * Same as standard first mip reduction, but with a clipping region.
- * Primarily used for shadow maps where shadows are atlased into a single texture
- * @type {ComputeShader}
- */
-export const shader_hzb_reduce_mip0_clip = ComputeShader.from({
-    label: 'HZB / reduce mip0 with clip',
-    resources,
-    body,
-});
+import { vec2u, vec4u } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { chunk_hzb_footprint_x } from "./chunk_hzb_footprint_x.js";
+import { chunk_hzb_footprint_y } from "./chunk_hzb_footprint_y.js";
+import { HZB_TEXTURE_FORMAT } from "./HZB_TEXTURE_FORMAT.js";
+
+/**
+ * Per-pass, 24 bytes, read-only.
+ *
+ * `clip_region` and `output_resolution` were two uniforms, so two buffers per pass. WGSL allows one
+ * immediate per entry point, so carrying them as immediate data means carrying them together.
+ *
+ * @type {WebGPUStruct}
+ */
+const HZB_CLIP_SETTINGS = WebGPUStruct.from({
+    // x, y, width, height
+    clip_region: vec4u,
+    output_resolution: vec2u,
+}, 'HzbClipSettings');
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", HZB_CLIP_SETTINGS);
+
+resources.createGroup()
+    .addTexture("tInput", "unfilterable-float")
+    .addStorageTexture("tOutput", HZB_TEXTURE_FORMAT, "2d", "write-only")
+;
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(16, 16)
+fn main(
+    @builtin(global_invocation_id) global_id: vec3<u32>,
+) {
+    if (any(global_id.xy >= settings.output_resolution)) {
+        return;
+    }
+
+    // 1. Calculate the UV bounds of the current *output* pixel.
+    //    We use the output resolution to determine how wide one pixel is in UV space.
+    let output_resolution_f = vec2<f32>(settings.output_resolution);
+    let uv = (vec2<f32>(global_id.xy) + 0.5) / output_resolution_f;
+    let output_pixel_size2 = 0.5 / output_resolution_f;
+    let uv_min = uv - output_pixel_size2;
+    let uv_max = uv + output_pixel_size2;
+
+    // minor epsilon to avoid float rounding errors
+    const EPSILON = 1e-6;
+
+    // Nudge the bounds slightly inward to absorb floating-point drift
+    let safe_uv_min = uv_min + EPSILON;
+    let safe_uv_max = uv_max - EPSILON;
+
+    // 2. Convert UV bounds to Source Texel coordinates (float).
+    //    We map the 0..1 UVs to the size of the source clip region.
+    let source_size = vec2<f32>(settings.clip_region.zw);
+    let texel_min_f = safe_uv_min * source_size;
+    let texel_max_f = safe_uv_max * source_size;
+
+    // 3. Convert to Integer Bounds.
+    //    Floor the min to find the first pixel.
+    //    Ceil the max to find the exclusive upper bound.
+    //    Example (5px -> 2px):
+    //      Output Px 0 covers UV 0.0-0.5 -> Source 0.0 to 2.5
+    //      Floor(0.0) = 0. Ceil(2.5) = 3. Pixels 0, 1, 2. (Pixel 2 is partially covered)
+    //      Output Px 1 covers UV 0.5-1.0 -> Source 2.5 to 5.0
+    //      Floor(2.5) = 2. Ceil(5.0) = 5. Pixels 2, 3, 4. (Pixel 2 is partially covered again)
+    let bound_min = vec2<i32>(floor(texel_min_f));
+    let bound_max = vec2<i32>(ceil(texel_max_f));
+
+    // 4. Clamp bounds to the clip region size to be safe.
+    let limit = vec2<i32>(settings.clip_region.zw);
+
+    let start = max(bound_min, vec2<i32>(0)) + vec2<i32>(settings.clip_region.xy);
+    let end   = min(bound_max, limit) + vec2<i32>(settings.clip_region.xy);
+
+    // 5. Read the footprint, HZB_FOOTPRINT_X by HZB_FOOTPRINT_Y texels: the widest footprint of this
+    //    dispatch on each axis. A narrower one repeats its last texel, which min/max ignores.
+    let last = end - vec2<i32>(1);
+
+    var output = vec2<f32>(1.0, 0.0); // Initialize min/max
+
+    for (var j = 0; j < HZB_FOOTPRINT_Y; j++) {
+        for (var i = 0; i < HZB_FOOTPRINT_X; i++) {
+
+            let load_coord = min(start + vec2<i32>(i, j), last);
+
+            let v = textureLoad(tInput, load_coord, 0).r;
+
+            output.x = min(output.x, v);
+            output.y = max(output.y, v);
+        }
+    }
+
+    textureStore(tOutput, vec2<i32>(global_id.xy), vec4<f32>(output, 0.0, 0.0));
+}
+    `, [
+        chunk_hzb_footprint_x,
+        chunk_hzb_footprint_y,
+    ]
+)
+
+/**
+ * First reduction: depth of a region of the source (`settings.clip_region`) into the HZB's mip 0, min in
+ * R and max in G. The region is the whole viewport for a camera, and a slot of the atlas for a shadow
+ * map. Each HZB texel reduces every source texel its area overlaps, a footprint of
+ * {@link HZB_FOOTPRINT_X} by {@link HZB_FOOTPRINT_Y} texels at most.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_hzb_reduce_mip0 = ComputeShader.from({
+    label: 'HZB / reduce mip0',
+    resources,
+    body,
+});

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts

@@ -13,7 +13,7 @@ export class TinyGltf {
      * @readonly
      * @type {TextureFormat}
      */
-    static readonly "__#300@#UNCOMPRESSED_TARGET": TextureFormat;
+    static readonly "__#302@#UNCOMPRESSED_TARGET": TextureFormat;
     /**
      * @param {AssetManager} assetManager
      * @param {AssetRequestScope} [scope]

package/src/shade/renderer/material/GPUMaterialManager.d.ts

@@ -9,6 +9,13 @@ export class GPUMaterialManager {
      * @param {GPUSamplerManager} [samplers] required by templates that bind shared samplers — terrain's
      */
     constructor(device: GPUDevice, textures: TextureManager, render_pipelines: RenderPipelineManager, bindings: BindGroupManager, virtual_textures?: VirtualTextureManager, samplers?: GPUSamplerManager);
+    /**
+     * Sent with a material when {@link update} restages its row because its {@link ShadeMaterial#version}
+     * moved: what the scene's material table and the material's uniform hold changes with this frame.
+     * Not sent for a material's first row, which {@link obtain} writes.
+     * @type {Signal<ShadeMaterial>}
+     */
+    onMaterialRestaged: any;
     /**
      *
      * @type {Map<ShadeMaterial, GPUMaterialContext>}

package/src/shade/renderer/material/GPUMaterialManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUMaterialManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/GPUMaterialManager.js"],"names":[],"mappings":"AA2NA;IAoFI;;;;;;;;OAQG;IACH,yCANW,cAAc,oBACd,qBAAqB,YACrB,gBAAgB,qBAChB,qBAAqB,aACrB,iBAAiB,EAiD3B;IArID;;;OAGG;IACH,UAFU,IAAI,aAAa,EAAE,kBAAkB,CAAC,CAE3B;IAyBrB;;;OAGG;IACH,yCAEC;IAID;;;OAGG;IACH,sBAEC;IAsLD;;;;;;;;OAQG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACE,gBAAgB,EAAhC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACJ;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAiMnF;IAED;;;;OAIG;IACH,iBAHW,aAAa,GACX,kBAAkB,CAqB9B;IAED;;;;;;;;;;;;OAYG;IACH,kBAHW,aAAa,GACX,OAAO,CAyBnB;IAED;;;;OAIG;IACH,gBAaC;IAED;;;;;;;OAOG;IACH,0BAFW,eAAe,QAazB;IAED;;;;;;;;;;;OAWG;IACH,kBAHW,qBAAqB,GACnB,QAAQ,IAAI,CAAC,CAMzB;IAsBD;;;;;;OAMG;IACH,0BAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAED;;;;;;OAMG;IACH,wBAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAuED;;;OAGG;IACH,YAFW,sBAAsB,QAiChC;;CAEJ;8BA33BY,OAAO,0CAA0C,EAAE,eAAe;6BAClE,OAAO,2BAA2B,EAAE,cAAc;yBAIlD,OAAO,2DAA2D,EAAE,UAAU;qCAC9E,OAAO,wCAAwC,EAAE,sBAAsB;oCACvE,OAAO,gDAAgD,EAAE,qBAAqB;+BAC9E,OAAO,gCAAgC,EAAE,gBAAgB;gCACzD,OAAO,yBAAyB,EAAE,iBAAiB;6BACnD,OAAO,8BAA8B,EAAE,cAAc;oCACrD,OAAO,6CAA6C,EAAE,qBAAqB;4BAC3E,OAAO,oBAAoB,EAAE,aAAa;oCAC1C,OAAO,qCAAqC,EAAE,qBAAqB;mCAtBzE,yBAAyB;mCAjBG,8CAA8C"}
+{"version":3,"file":"GPUMaterialManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/GPUMaterialManager.js"],"names":[],"mappings":"AA4NA;IA4FI;;;;;;;;OAQG;IACH,yCANW,cAAc,oBACd,qBAAqB,YACrB,gBAAgB,qBAChB,qBAAqB,aACrB,iBAAiB,EAiD3B;IAlJD;;;;;OAKG;IACH,wBAAkC;IAOlC;;;OAGG;IACH,UAFU,IAAI,aAAa,EAAE,kBAAkB,CAAC,CAE3B;IAyBrB;;;OAGG;IACH,yCAEC;IAID;;;OAGG;IACH,sBAEC;IAsLD;;;;;;;;OAQG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACE,gBAAgB,EAAhC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACJ;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAiMnF;IAED;;;;OAIG;IACH,iBAHW,aAAa,GACX,kBAAkB,CAqB9B;IAED;;;;;;;;;;;;OAYG;IACH,kBAHW,aAAa,GACX,OAAO,CAyBnB;IAED;;;;OAIG;IACH,gBAaC;IAED;;;;;;;OAOG;IACH,0BAFW,eAAe,QAazB;IAED;;;;;;;;;;;OAWG;IACH,kBAHW,qBAAqB,GACnB,QAAQ,IAAI,CAAC,CAMzB;IAsBD;;;;;;OAMG;IACH,0BAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAED;;;;;;OAMG;IACH,wBAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAuED;;;OAGG;IACH,YAFW,sBAAsB,QAmChC;;CAEJ;8BAr4BY,OAAO,0CAA0C,EAAE,eAAe;6BAClE,OAAO,2BAA2B,EAAE,cAAc;yBAIlD,OAAO,2DAA2D,EAAE,UAAU;qCAC9E,OAAO,wCAAwC,EAAE,sBAAsB;oCACvE,OAAO,gDAAgD,EAAE,qBAAqB;+BAC9E,OAAO,gCAAgC,EAAE,gBAAgB;gCACzD,OAAO,yBAAyB,EAAE,iBAAiB;6BACnD,OAAO,8BAA8B,EAAE,cAAc;oCACrD,OAAO,6CAA6C,EAAE,qBAAqB;4BAC3E,OAAO,oBAAoB,EAAE,aAAa;oCAC1C,OAAO,qCAAqC,EAAE,qBAAqB;mCAtBzE,yBAAyB;mCAjBG,8CAA8C"}

package/src/shade/renderer/material/GPUMaterialManager.js

@@ -1,4 +1,5 @@
 import { assert } from "../../../core/assert.js";
+import Signal from "../../../core/events/signal/Signal.js";
 import { BindGroupLayoutDescriptor } from "../../descriptor/binding/BindGroupLayoutDescriptor.js";
 import { BufferBindingLayout } from "../../descriptor/binding/BufferBindingLayout.js";
 import { GPUShaderStage } from "../../descriptor/GPUShaderStage.js";
@@ -219,6 +220,14 @@ const material_buffer_pipeline_descriptor = RenderPipelineDescriptor.from({
 
 export class GPUMaterialManager {
 
+    /**
+     * Sent with a material when {@link update} restages its row because its {@link ShadeMaterial#version}
+     * moved: what the scene's material table and the material's uniform hold changes with this frame.
+     * Not sent for a material's first row, which {@link obtain} writes.
+     * @type {Signal<ShadeMaterial>}
+     */
+    onMaterialRestaged = new Signal();
+
     /**
      * @type {GPUDevice}
      */
@@ -906,6 +915,8 @@ export class GPUMaterialManager {
                 const row = this.#stage_metadata(material_ctx);
 
                 material_ctx.write_uniform(queue, row);
+
+                this.onMaterialRestaged.send1(material_ctx.source);
             }
         }
 

package/src/shade/renderer/material/resident/GPUResidentMaterialContext.d.ts

@@ -5,12 +5,6 @@ export class GPUResidentMaterialContext {
      * @param {GraphicsContext} graphics
      */
     constructor(device: GPUDevice, graphics: GraphicsContext);
-    /**
-     * Sent with a material when it is repacked because its {@link ShadeMaterial#version} moved: the
-     * row the device reads changes with the next {@link update}. Not sent for a material's first pack.
-     * @type {Signal<ShadeMaterial>}
-     */
-    onMaterialRepacked: any;
     /**
      *
      * @returns {number}
@@ -26,10 +20,6 @@ export class GPUResidentMaterialContext {
      * @returns {GPUTextureContext}
      */
     get buffer_textures(): GPUTextureContext;
-    /**
-     * @returns {GPUBuffer}
-     */
-    get buffer_texture_means(): GPUBuffer;
     /**
      *
      * @returns {GPUTextureView}
@@ -54,8 +44,8 @@ export class GPUResidentMaterialContext {
      * Make a material resident, or repack it if its {@link ShadeMaterial#version} has moved since —
      * the same contract {@link GPUMaterialManager} restages by. A hit used to be final, so a factor
      * set after the first pack never reached the row. Every caller re-obtains what it needs before
-     * {@link update}: the scene's drawn list, and the manager's materials whenever its version
-     * moves, so the check rides on walks that already happen.
+     * {@link update} or {@link commit}: the scene's drawn list, the manager's materials whenever its
+     * version moves, or what a card capture traces, so the check rides on walks that already happen.
      *
      * @param {ShadeMaterial} material
      * @returns {MaterialInfo}
@@ -75,6 +65,16 @@ export class GPUResidentMaterialContext {
      * @param {GPUSceneContext} scene_context
      */
     ensure_scene_materials(scene_context: GPUSceneContext): void;
+    /**
+     * Write what {@link obtain_material} made resident or repacked since the last commit, and the media
+     * that moved. Takes none of the manager's materials, unlike {@link update}: for a reader that makes
+     * resident only what it reads.
+     */
+    commit(): void;
+    /**
+     * Make every material the manager holds resident, then {@link commit}: for the readers that trace
+     * the whole scene.
+     */
     update(): void;
     destroy(): void;
     #private;

package/src/shade/renderer/material/resident/GPUResidentMaterialContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUResidentMaterialContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/resident/GPUResidentMaterialContext.js"],"names":[],"mappings":"AAmIA;IAqMI;;;;OAIG;IACH,yCAFW,eAAe,EAyDzB;IA/PD;;;;OAIG;IACH,wBAAkC;IA4BlC;;;OAGG;IACH,6BAEC;IAQD;;;OAGG;IACH,kCAEC;IAQD;;;OAGG;IACH,yCAEC;IAoBD;;OAEG;IACH,sCAEC;IAED;;;OAGG;IACH,kCAIC;IAmED;;;;;OAKG;IACH,0BAEC;IAOD;;;;;;OAMG;IACH,8BAEC;IA6JD;;;;;;;;;OASG;IACH,0BAHW,aAAa,GACX,YAAY,CAqBxB;IAgBD;;;;OAIG;IACH,wBAHW,YAAY,GACV,WAAW,CAIvB;IAGD,uBA4DC;IAkJD,wBA8EC;IAED;;;;OAIG;IACH,sCAFW,eAAe,QAUzB;IAoCD,eAWC;IAGD,gBAMC;;CACJ;8BAh2BY,OAAO,0BAA0B,EAAE,eAAe;8BAClD,OAAO,gCAAgC,EAAE,eAAe;2BACxD,OAAO,+BAA+B,EAAE,YAAY;4BACpD,OAAO,qBAAqB,EAAE,aAAa;oCAC3C,OAAO,6BAA6B,EAAE,qBAAqB;kCAC3D,OAAO,qCAAqC,EAAE,mBAAmB;kCAnB5C,oCAAoC;AAatE;;;;;;;GAOG;AAEH;IACI,WAAM;IAEN;;;OAGG;IACH,SAFU,MAAM,CAEJ;IAEZ;;OAEG;IACH,QAFU,qBAAqB,CAExB;IAEP;;OAEG;IACH,gBAFU,WAAW,CAEP;IAEd;;OAEG;IACH,aAFU,WAAW,CAEV;IAEX;;;;OAIG;IACH,gBAFU,WAAW,GAAC,IAAI,CAEZ;IACd;;OAEG;IACH,kBAFU,WAAW,CAEL;IAEhB;;;OAGG;IACH,aAFU,MAAM,CAEe;CAClC;AAqBD;IACI,WAAO;IAEP;;OAEG;IACH,QAFU,YAAY,CAEf;CACV"}
+{"version":3,"file":"GPUResidentMaterialContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/resident/GPUResidentMaterialContext.js"],"names":[],"mappings":"AAgIA;IAqKI;;;;OAIG;IACH,yCAFW,eAAe,EAkDzB;IA9LD;;;OAGG;IACH,6BAEC;IAQD;;;OAGG;IACH,kCAEC;IAQD;;;OAGG;IACH,yCAEC;IAED;;;OAGG;IACH,kCAIC;IAmED;;;;;OAKG;IACH,0BAEC;IAOD;;;;;;OAMG;IACH,8BAEC;IAsJD;;;;;;;;;OASG;IACH,0BAHW,aAAa,GACX,YAAY,CAmBxB;IAgBD;;;;OAIG;IACH,wBAHW,YAAY,GACV,WAAW,CAIvB;IAGD,uBA0DC;IAuFD,wBA8EC;IAED;;;;OAIG;IACH,sCAFW,eAAe,QAUzB;IAoCD;;;;OAIG;IACH,eAGC;IAED;;;OAGG;IACH,eAGC;IAGD,gBAIC;;CACJ;8BA9vBY,OAAO,0BAA0B,EAAE,eAAe;8BAClD,OAAO,gCAAgC,EAAE,eAAe;2BACxD,OAAO,+BAA+B,EAAE,YAAY;4BACpD,OAAO,qBAAqB,EAAE,aAAa;oCAC3C,OAAO,6BAA6B,EAAE,qBAAqB;kCAC3D,OAAO,qCAAqC,EAAE,mBAAmB;kCAlB5C,oCAAoC;AAYtE;;;;;;;GAOG;AAEH;IACI,WAAM;IAEN;;;OAGG;IACH,SAFU,MAAM,CAEJ;IAEZ;;OAEG;IACH,QAFU,qBAAqB,CAExB;IAEP;;OAEG;IACH,gBAFU,WAAW,CAEP;IAEd;;OAEG;IACH,aAFU,WAAW,CAEV;IAEX;;;;OAIG;IACH,gBAFU,WAAW,GAAC,IAAI,CAEZ;IACd;;OAEG;IACH,kBAFU,WAAW,CAEL;IAEhB;;;OAGG;IACH,aAFU,MAAM,CAEe;CAClC;AAqBD;IACI,WAAO;IAEP;;OAEG;IACH,QAFU,YAAY,CAEf;CACV"}