@woosh/meep-engine 3.60.4 → 3.60.6

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>}
@@ -31,13 +38,16 @@ export class GPUMaterialManager {
      * @param {GPUViewContext} options.view
      * @param {number} options.texture_viz_mesh
      * @param {number} options.texture_viz_triangle
+     * @param {number} options.texture_normal the normal target to write, `rgba16uint` at the view's
+     *   resolution. The caller owns it so that it outlives the frame: reprojection reads last frame's.
      * @returns {{g_pbr: number, g_normal: number, g_albedo: number, g_emissive: number}} updated g-buffer
      */
-    graph_viz_render({ graph, view, texture_viz_mesh, texture_viz_triangle, }: {
+    graph_viz_render({ graph, view, texture_viz_mesh, texture_viz_triangle, texture_normal, }: {
         graph: FrameGraph;
         view: GPUViewContext;
         texture_viz_mesh: number;
         texture_viz_triangle: number;
+        texture_normal: number;
     }): {
         g_pbr: number;
         g_normal: number;

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;;;;;;;;;;OAUG;IACH;QAR+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACE,gBAAgB,EAAhC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,cAAc,EAA9B,MAAM;QAEJ;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CA4LnF;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;8BAl4BY,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}
      */
@@ -458,6 +467,8 @@ export class GPUMaterialManager {
      * @param {GPUViewContext} options.view
      * @param {number} options.texture_viz_mesh
      * @param {number} options.texture_viz_triangle
+     * @param {number} options.texture_normal the normal target to write, `rgba16uint` at the view's
+     *   resolution. The caller owns it so that it outlives the frame: reprojection reads last frame's.
      * @returns {{g_pbr: number, g_normal: number, g_albedo: number, g_emissive: number}} updated g-buffer
      */
     graph_viz_render({
@@ -465,9 +476,11 @@ export class GPUMaterialManager {
                          view,
                          texture_viz_mesh,
                          texture_viz_triangle,
+                         texture_normal,
                      }) {
 
         assert.defined(graph, 'graph');
+        assert.isNonNegativeInteger(texture_normal, 'texture_normal');
         assert.defined(view, 'view');
 
         /**
@@ -611,14 +624,7 @@ export class GPUMaterialManager {
                 usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
             })
         );
-        pass_data.g_normal = pass.create(
-            "g-buffer / Normal",
-            TextureResourceDescriptor.from({
-                format: 'rgba16uint',
-                resolution: view.resolution,
-                usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
-            })
-        );
+        pass_data.g_normal = pass.write(texture_normal);
         pass_data.g_albedo = pass.create(
             "g-buffer / Albedo",
             TextureResourceDescriptor.from({
@@ -906,6 +912,8 @@ export class GPUMaterialManager {
                 const row = this.#stage_metadata(material_ctx);
 
                 material_ctx.write_uniform(queue, row);
+
+                this.onMaterialRestaged.send1(material_ctx.source);
             }
         }