@woosh/meep-engine 3.14.1 → 3.14.3

package/src/shade/renderer/material/resident/GPUResidentMaterialContext.js

@@ -322,7 +322,17 @@ export class GPUResidentMaterialContext {
 
             const is_square = source_ctx.width === source_ctx.height;
 
-            const is_srgb = source.image.color_space === ColorSpace.SRGB;
+            /*
+             The fast path is a copyTextureToTexture, which requires the two formats to be
+             copy-compatible. `!is_srgb` used to stand in for that and was true only by accident: every
+             material texture was rgba8unorm, so the only way to differ was the srgb suffix. A BC7
+             source would have reached the copy and failed validation.
+
+             Asking the question directly costs nothing and covers every format at once — a source
+             that does not match takes the render path below, which samples it into the atlas and is
+             what that path exists for.
+            */
+            const format_matches = source_ctx.gpu_texture.format === target_texture.gpu_texture.format;
 
             const is_pot_w = isPowerOfTwo(source_ctx.width) && isPowerOfTwo(source_ctx.height);
 
@@ -335,7 +345,7 @@ export class GPUResidentMaterialContext {
             const texture_slot_y = Math.floor(id_in_slice / RESIDENT_MATERIAL_TEXTURE_SLOT_RESOLUTION);
             const texture_slot_x = id_in_slice % RESIDENT_MATERIAL_TEXTURE_SLOT_RESOLUTION;
 
-            if (is_square && is_pot_w && source_mip_w >= 0 && source_ctx.gpu_texture.mipLevelCount >= source_mip_w && !is_srgb) {
+            if (is_square && is_pot_w && source_mip_w >= 0 && source_ctx.gpu_texture.mipLevelCount >= source_mip_w && format_matches) {
 
                 encoder.copyTextureToTexture(
                     {

package/src/shade/renderer/material/standard/fragment_gbuffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fragment_gbuffer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/fragment_gbuffer.js"],"names":[],"mappings":"AA4EA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAR6B,OAAO,GAAzB,MAAM;IACW,GAAG,EAApB,MAAM;IACW,MAAM,EAAvB,MAAM;IACW,OAAO,EAAxB,MAAM;IACW,QAAQ,EAAzB,MAAM;kBACN,SAAS,EAAE,GACT,SAAS,CAiOrB;AAhRD,oEAA2E;AAI3E,oIAEG;AASH,sIAEG;AAwQH,8CAIE;0BAzSwB,oCAAoC;4CAClB,sDAAsD;iCACjE,kCAAkC"}
+{"version":3,"file":"fragment_gbuffer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/fragment_gbuffer.js"],"names":[],"mappings":"AA6EA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAR6B,OAAO,GAAzB,MAAM;IACW,GAAG,EAApB,MAAM;IACW,MAAM,EAAvB,MAAM;IACW,OAAO,EAAxB,MAAM;IACW,QAAQ,EAAzB,MAAM;kBACN,SAAS,EAAE,GACT,SAAS,CAkOrB;AAjRD,oEAA2E;AAI3E,oIAEG;AASH,sIAEG;AAyQH,8CAIE;0BA1SwB,oCAAoC;4CAClB,sDAAsD;iCACjE,kCAAkC"}

package/src/shade/renderer/material/standard/fragment_gbuffer.js

@@ -1,4 +1,5 @@
 import { GPUShaderStage } from "../../../descriptor/GPUShaderStage.js";
+import { chunk_decode_tangent_normal } from "../../shader/chunk/geometry/normal/chunk_decode_tangent_normal.js";
 import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
 import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
@@ -308,6 +309,7 @@ fn main(
         chunk_compute_normal_matrix_from_m4,
         chunk_anti_alias_roughness_kaplanyan,
         chunk_build_orthonormal_matrix_nt,
+        chunk_decode_tangent_normal,
         chunk_read_meshlet_triangle_vertices,
         chunk_decode_meshlet_element,
         chunk_compute_triangle_face_normal,
@@ -322,7 +324,7 @@ fn main(
 
 const body = build_gbuffer_fragment_body({
     orm: `textureSampleBarycentric(texture_orm, texture_orm_sampler, uv_info)`,
-    normal: `textureSampleBarycentric(texture_normal, texture_normal_sampler, uv_info).rgb * 2.0 - 1.0`,
+    normal: `decode_tangent_normal(textureSampleBarycentric(texture_normal, texture_normal_sampler, uv_info))`,
     diffuse: `textureSampleBarycentric(texture_diffuse, texture_diffuse_sampler, uv_info)`,
     emissive: `textureSampleBarycentric(texture_emissive, texture_emissive_sampler, uv_info).rgb`,
 });

package/src/shade/renderer/material/standard/fragment_gbuffer_vt.js

@@ -1,169 +1,169 @@
-import { GPUShaderStage } from "../../../descriptor/GPUShaderStage.js";
-import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { G_BUFFER_COLOR_TARGETS } from "../../gbuffer/G_BUFFER_COLOR_TARGETS.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
-import { ShaderResourceGroupDescriptor } from "../../shader/resource/ShaderResourceGroupDescriptor.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { VT_STACK_INFO_STRUCT } from "../../texture/virtual/VT_STACK_INFO_STRUCT.js";
-import { MATERIAL_METADATA_STRUCT } from "../MATERIAL_METADATA_STRUCT.js";
-import {
-    build_gbuffer_fragment_body,
-    g_buffer_scene_resources,
-    g_buffer_viz_resources,
-} from "./fragment_gbuffer.js";
-import { material_gbuffer_vertex_shader_code } from "./material_gbuffer_vertex.js";
-
-/**
- * Group 0 of the virtual-texture material variant. Replaces the four
- * per-material texture bindings of the standard group with the VT globals:
- * the shared page table, the stack info buffer and the physical cache
- * layers — identical for every VT material, which is what lets hundreds of
- * them share one pipeline and the same feedback/table infrastructure.
- * Emissive stays a regular per-material texture (emissive maps are rarely
- * the memory problem VT solves).
- *
- * `material_info` must stay at binding 0 — the shared vertex stage
- * ({@link material_gbuffer_vertex_shader_code}) addresses it there.
- */
-export const SHADING_MATERIAL_VT_RESOURCE_GROUP = new ShaderResourceGroupDescriptor();
-
-SHADING_MATERIAL_VT_RESOURCE_GROUP.label = "Material VT";
-
-SHADING_MATERIAL_VT_RESOURCE_GROUP
-    .addUniform("material_info", MATERIAL_METADATA_STRUCT)
-    .addTexture("texture_emissive", "float")
-    .addSampler("texture_emissive_sampler")
-    .addTexture("vt_page_table", "uint")
-    .addStorageBuffer("vt_stacks", WebGPUArray.from(VT_STACK_INFO_STRUCT))
-    .addTexture("vt_cache_albedo", "float")
-    .addTexture("vt_cache_normal", "float")
-    .addTexture("vt_cache_orm", "float")
-    .addSampler("vt_cache_sampler");
-
-export const vt_gbuffer_shader_resources = new ShaderResourceSetDescriptor();
-
-// group order mirrors the standard material set — groups 1 and 2 are the
-// *same descriptor objects*, so the two pipelines are bind-group compatible
-// and the material pass can set viz/scene groups once for both
-vt_gbuffer_shader_resources.addGroup(SHADING_MATERIAL_VT_RESOURCE_GROUP);
-vt_gbuffer_shader_resources.addGroup(g_buffer_viz_resources);
-vt_gbuffer_shader_resources.addGroup(g_buffer_scene_resources);
-
-vt_gbuffer_shader_resources.addVisibility(GPUShaderStage.FRAGMENT);
-vt_gbuffer_shader_resources.getResourceByName("material_info").addVisibility(GPUShaderStage.VERTEX);
-
-const chunk_vt_sample_layer = new WeakMap();
-
-/**
- * Build the VT variant of the G-buffer material pipeline for a concrete
- * cache geometry. Called (and memoized) by the VirtualTextureManager once
- * its configuration is frozen.
- *
- * Sampling model (v1): one page-table fetch per pixel serves all three
- * layers — the stack's UV set, wrap mode and residency resolve once, then
- * albedo/normal/ORM are three bilinear fetches at the same physical
- * coordinate in their respective atlases. Missing layers and not-yet-
- * resident cells fall back to per-layer neutral values (albedo falls back
- * to the stack's average colour).
- *
- * @param {CodeChunk} chunk_vt_lookup from {@link build_chunk_vt_lookup}
- * @returns {RenderPipelineDescriptor}
- */
-export function build_vt_material_pipeline_descriptor(chunk_vt_lookup) {
-
-    let sample_chunk = chunk_vt_sample_layer.get(chunk_vt_lookup);
-
-    if (sample_chunk === undefined) {
-        sample_chunk = CodeChunk.from(
-            //language=WGSL
-            `
-fn vt_sample_layer(
-    cache: texture_2d<f32>,
-    cache_sampler: sampler,
-    phys: VTPhysical,
-    available: bool,
-    fallback: vec4<f32>,
-) -> vec4<f32> {
-    if (!available) {
-        return fallback;
-    }
-
-    // physical atlases are single-mip; virtual mip selection already
-    // happened through the page table
-    return textureSampleLevel(cache, cache_sampler, phys.uv, 0.0);
-}
-`,
-            [chunk_vt_lookup]
-        );
-
-        chunk_vt_sample_layer.set(chunk_vt_lookup, sample_chunk);
-    }
-
-    const body = build_gbuffer_fragment_body(
-        {
-            prelude: `
-    // ── virtual texture resolve, once per pixel for all layers ──────
-    let vt_info = vt_stacks[material_info.vt_stack];
-    let vt_layer_mask = vt_info.flags >> 8u;
-
-    if ((vt_info.flags & VT_STACK_FLAG_UV_SET_1) != 0u) {
-        // stack binds the second UV set — re-interpolate and re-bias
-        uv_info = barycentric_interpolate_uv(barycentric, vertex_0.uv1, vertex_1.uv1, vertex_2.uv1);
-        uv_info.ddx *= uv_derivative_bias.x;
-        uv_info.ddy *= uv_derivative_bias.y;
-    }
-
-    let vt_uv = vt_stack_wrap_uv(uv_info.uv, vt_info.flags);
-    let vt_mip = vt_mip_select(vt_info, uv_info.ddx, uv_info.ddy, 0.0);
-    let vt_entry = vt_page_table_load(vt_page_table, vt_info, vt_uv, vt_mip);
-
-    var vt_phys = VTPhysical(vec2<f32>(0.0), 0.0);
-
-    if (vt_entry.valid) {
-        vt_phys = vt_physical_uv(vt_entry, vt_info, vt_uv);
-    }
-`,
-            orm: `vt_sample_layer(vt_cache_orm, vt_cache_sampler, vt_phys, vt_entry.valid && (vt_layer_mask & 4u) != 0u, vec4<f32>(1.0, 1.0, 0.0, 1.0))`,
-            normal: `vt_sample_layer(vt_cache_normal, vt_cache_sampler, vt_phys, vt_entry.valid && (vt_layer_mask & 2u) != 0u, vec4<f32>(0.5, 0.5, 1.0, 1.0)).rgb * 2.0 - 1.0`,
-            diffuse: `vt_sample_layer(vt_cache_albedo, vt_cache_sampler, vt_phys, vt_entry.valid && (vt_layer_mask & 1u) != 0u, vt_info.average_color)`,
-            emissive: `textureSampleBarycentric(texture_emissive, texture_emissive_sampler, uv_info).rgb`,
-        },
-        [
-            sample_chunk,
-        ]
-    );
-
-    const shader = ShaderDescriptor.from({
-        label: "Material / GBuffer laydown (virtual texture)",
-        resources: vt_gbuffer_shader_resources,
-        body,
-    });
-
-    return RenderPipelineDescriptor.from({
-        label: "VT material / Viz-Buffer to G-Buffer laydown",
-        layout: vt_gbuffer_shader_resources.generatePipelineLayoutDescriptor(),
-        vertex: {
-            module: {
-                code: material_gbuffer_vertex_shader_code
-            }
-        },
-        fragment: {
-            module: {
-                code: shader.source,
-            },
-            targets: G_BUFFER_COLOR_TARGETS
-        },
-        depthStencil: {
-            // depth is a material mask — see the standard material pipeline
-            depthCompare: 'equal',
-            format: 'depth32float',
-            depthWriteEnabled: false
-        },
-        primitive: {
-            topology: 'triangle-list',
-            cullMode: 'none',
-        }
-    });
-}
+import { GPUShaderStage } from "../../../descriptor/GPUShaderStage.js";
+import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { G_BUFFER_COLOR_TARGETS } from "../../gbuffer/G_BUFFER_COLOR_TARGETS.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+import { ShaderResourceGroupDescriptor } from "../../shader/resource/ShaderResourceGroupDescriptor.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { VT_STACK_INFO_STRUCT } from "../../texture/virtual/VT_STACK_INFO_STRUCT.js";
+import { MATERIAL_METADATA_STRUCT } from "../MATERIAL_METADATA_STRUCT.js";
+import {
+    build_gbuffer_fragment_body,
+    g_buffer_scene_resources,
+    g_buffer_viz_resources,
+} from "./fragment_gbuffer.js";
+import { material_gbuffer_vertex_shader_code } from "./material_gbuffer_vertex.js";
+
+/**
+ * Group 0 of the virtual-texture material variant. Replaces the four
+ * per-material texture bindings of the standard group with the VT globals:
+ * the shared page table, the stack info buffer and the physical cache
+ * layers — identical for every VT material, which is what lets hundreds of
+ * them share one pipeline and the same feedback/table infrastructure.
+ * Emissive stays a regular per-material texture (emissive maps are rarely
+ * the memory problem VT solves).
+ *
+ * `material_info` must stay at binding 0 — the shared vertex stage
+ * ({@link material_gbuffer_vertex_shader_code}) addresses it there.
+ */
+export const SHADING_MATERIAL_VT_RESOURCE_GROUP = new ShaderResourceGroupDescriptor();
+
+SHADING_MATERIAL_VT_RESOURCE_GROUP.label = "Material VT";
+
+SHADING_MATERIAL_VT_RESOURCE_GROUP
+    .addUniform("material_info", MATERIAL_METADATA_STRUCT)
+    .addTexture("texture_emissive", "float")
+    .addSampler("texture_emissive_sampler")
+    .addTexture("vt_page_table", "uint")
+    .addStorageBuffer("vt_stacks", WebGPUArray.from(VT_STACK_INFO_STRUCT))
+    .addTexture("vt_cache_albedo", "float")
+    .addTexture("vt_cache_normal", "float")
+    .addTexture("vt_cache_orm", "float")
+    .addSampler("vt_cache_sampler");
+
+export const vt_gbuffer_shader_resources = new ShaderResourceSetDescriptor();
+
+// group order mirrors the standard material set — groups 1 and 2 are the
+// *same descriptor objects*, so the two pipelines are bind-group compatible
+// and the material pass can set viz/scene groups once for both
+vt_gbuffer_shader_resources.addGroup(SHADING_MATERIAL_VT_RESOURCE_GROUP);
+vt_gbuffer_shader_resources.addGroup(g_buffer_viz_resources);
+vt_gbuffer_shader_resources.addGroup(g_buffer_scene_resources);
+
+vt_gbuffer_shader_resources.addVisibility(GPUShaderStage.FRAGMENT);
+vt_gbuffer_shader_resources.getResourceByName("material_info").addVisibility(GPUShaderStage.VERTEX);
+
+const chunk_vt_sample_layer = new WeakMap();
+
+/**
+ * Build the VT variant of the G-buffer material pipeline for a concrete
+ * cache geometry. Called (and memoized) by the VirtualTextureManager once
+ * its configuration is frozen.
+ *
+ * Sampling model (v1): one page-table fetch per pixel serves all three
+ * layers — the stack's UV set, wrap mode and residency resolve once, then
+ * albedo/normal/ORM are three bilinear fetches at the same physical
+ * coordinate in their respective atlases. Missing layers and not-yet-
+ * resident cells fall back to per-layer neutral values (albedo falls back
+ * to the stack's average colour).
+ *
+ * @param {CodeChunk} chunk_vt_lookup from {@link build_chunk_vt_lookup}
+ * @returns {RenderPipelineDescriptor}
+ */
+export function build_vt_material_pipeline_descriptor(chunk_vt_lookup) {
+
+    let sample_chunk = chunk_vt_sample_layer.get(chunk_vt_lookup);
+
+    if (sample_chunk === undefined) {
+        sample_chunk = CodeChunk.from(
+            //language=WGSL
+            `
+fn vt_sample_layer(
+    cache: texture_2d<f32>,
+    cache_sampler: sampler,
+    phys: VTPhysical,
+    available: bool,
+    fallback: vec4<f32>,
+) -> vec4<f32> {
+    if (!available) {
+        return fallback;
+    }
+
+    // physical atlases are single-mip; virtual mip selection already
+    // happened through the page table
+    return textureSampleLevel(cache, cache_sampler, phys.uv, 0.0);
+}
+`,
+            [chunk_vt_lookup]
+        );
+
+        chunk_vt_sample_layer.set(chunk_vt_lookup, sample_chunk);
+    }
+
+    const body = build_gbuffer_fragment_body(
+        {
+            prelude: `
+    // ── virtual texture resolve, once per pixel for all layers ──────
+    let vt_info = vt_stacks[material_info.vt_stack];
+    let vt_layer_mask = vt_info.flags >> 8u;
+
+    if ((vt_info.flags & VT_STACK_FLAG_UV_SET_1) != 0u) {
+        // stack binds the second UV set — re-interpolate and re-bias
+        uv_info = barycentric_interpolate_uv(barycentric, vertex_0.uv1, vertex_1.uv1, vertex_2.uv1);
+        uv_info.ddx *= uv_derivative_bias.x;
+        uv_info.ddy *= uv_derivative_bias.y;
+    }
+
+    let vt_uv = vt_stack_wrap_uv(uv_info.uv, vt_info.flags);
+    let vt_mip = vt_mip_select(vt_info, uv_info.ddx, uv_info.ddy, 0.0);
+    let vt_entry = vt_page_table_load(vt_page_table, vt_info, vt_uv, vt_mip);
+
+    var vt_phys = VTPhysical(vec2<f32>(0.0), 0.0);
+
+    if (vt_entry.valid) {
+        vt_phys = vt_physical_uv(vt_entry, vt_info, vt_uv);
+    }
+`,
+            orm: `vt_sample_layer(vt_cache_orm, vt_cache_sampler, vt_phys, vt_entry.valid && (vt_layer_mask & 4u) != 0u, vec4<f32>(1.0, 1.0, 0.0, 1.0))`,
+            normal: `decode_tangent_normal(vt_sample_layer(vt_cache_normal, vt_cache_sampler, vt_phys, vt_entry.valid && (vt_layer_mask & 2u) != 0u, vec4<f32>(0.5, 0.5, 1.0, 1.0)))`,
+            diffuse: `vt_sample_layer(vt_cache_albedo, vt_cache_sampler, vt_phys, vt_entry.valid && (vt_layer_mask & 1u) != 0u, vt_info.average_color)`,
+            emissive: `textureSampleBarycentric(texture_emissive, texture_emissive_sampler, uv_info).rgb`,
+        },
+        [
+            sample_chunk,
+        ]
+    );
+
+    const shader = ShaderDescriptor.from({
+        label: "Material / GBuffer laydown (virtual texture)",
+        resources: vt_gbuffer_shader_resources,
+        body,
+    });
+
+    return RenderPipelineDescriptor.from({
+        label: "VT material / Viz-Buffer to G-Buffer laydown",
+        layout: vt_gbuffer_shader_resources.generatePipelineLayoutDescriptor(),
+        vertex: {
+            module: {
+                code: material_gbuffer_vertex_shader_code
+            }
+        },
+        fragment: {
+            module: {
+                code: shader.source,
+            },
+            targets: G_BUFFER_COLOR_TARGETS
+        },
+        depthStencil: {
+            // depth is a material mask — see the standard material pipeline
+            depthCompare: 'equal',
+            format: 'depth32float',
+            depthWriteEnabled: false
+        },
+        primitive: {
+            topology: 'triangle-list',
+            cullMode: 'none',
+        }
+    });
+}

package/src/shade/renderer/path_tracer/shader/chunk_sample_material_data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_sample_material_data.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_sample_material_data.js"],"names":[],"mappings":"AA6BA;;;GAGG;AACH,0CAFU,SAAS,CA8FlB;AAED,mDAqHC;0BA9NyB,oCAAoC"}
+{"version":3,"file":"chunk_sample_material_data.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_sample_material_data.js"],"names":[],"mappings":"AA8BA;;;GAGG;AACH,0CAFU,SAAS,CA8FlB;AAED,mDAsHC;0BA/NyB,oCAAoC"}

package/src/shade/renderer/path_tracer/shader/chunk_sample_material_data.js

@@ -1,4 +1,5 @@
 import { chunk_compute_normal_matrix_from_m4 } from "../../shader/chunk/geometry/mat4/chunk_compute_normal_matrix_from_m4.js";
+import { chunk_decode_tangent_normal } from "../../shader/chunk/geometry/normal/chunk_decode_tangent_normal.js";
 import { chunk_F_Hauber } from "../../shader/chunk/brdf/fresnel/chunk_F_Hauber.js";
 import {
     chunk_build_orthonormal_matrix_nt
@@ -202,7 +203,7 @@ fn sample_material_data(
 
     let world_tangent_frame = build_orthonormal_matrix_nt(world_vertex_normal, vec4(world_tangent, geometry_tangent.w));
 
-    var normal_sample = indirect_sample_texture(material.texture_normal, material.sampler_normal, uv).rgb * 2.0 - 1.0;
+    var normal_sample = decode_tangent_normal(indirect_sample_texture(material.texture_normal, material.sampler_normal, uv));
     
     var output: ${STANDARD_MATERIAL_DATA_STRUCT.wgsl_ref};
     
@@ -238,6 +239,7 @@ fn sample_material_data(
         chunk_interpolate_attribute_4f32,
         chunk_compute_normal_matrix_from_m4,
         chunk_build_orthonormal_matrix_nt,
+        chunk_decode_tangent_normal,
         chunk_compute_triangle_face_normal,
         chunk_indirect_sample_texture,
         chunk_random_vec3,

package/src/shade/renderer/postprocess/nss/NSS.d.ts

@@ -49,7 +49,7 @@ export class NSS {
      * @returns {number}
      */
     static recommended_jitter_sequence_size(upscale_ratio: number): number;
-    static "__#136@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
+    static "__#131@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
     /**
      * @param {GraphicsContext} graphics
      */

package/src/shade/renderer/postprocess/taa/TAA.d.ts

@@ -21,14 +21,14 @@ export class TAA {
     /**
      *
      * @param {FrameGraph} graph
-     * @param {number} texture_velocity
+     * @param {number} texture_velocity raw velocity buffer, internal resolution
      * @param {number} texture_color_current
      * @param {number} texture_color_history
      * @param {number} texture_output
-     * @param {number} texture_occlusion
+     * @param {number} texture_occlusion depth-clip pass output: confidence in r, nearest-depth offset in g
      * @param view
      */
-    graph_pass({ graph, texture_velocity, texture_color_current, texture_color_history, texture_output, camera_current, camera_previous, texture_occlusion, }: FrameGraph): number;
+    graph_pass({ graph, texture_velocity, texture_color_current, texture_color_history, texture_output, texture_occlusion, }: FrameGraph): number;
     #private;
 }
 //# sourceMappingURL=TAA.d.ts.map

package/src/shade/renderer/postprocess/taa/TAA.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TAA.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/TAA.js"],"names":[],"mappings":"AAQA;IAEI,iBAAgB;IAChB,sBAAqB;IAErB;;;;OAIG;IACH,eAFU,OAAO,CAEK;IA0BtB;;;OAGG;IACH,sCAIC;IAED,mCAEC;IAED;;;OAGG;IACH,6BAmBC;IAED;;;;;;;;;OASG;IACH,+KAmCC;;CACJ"}
+{"version":3,"file":"TAA.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/TAA.js"],"names":[],"mappings":"AAQA;IAEI,iBAAgB;IAChB,sBAAqB;IAErB;;;;OAIG;IACH,eAFU,OAAO,CAEK;IA0BtB;;;OAGG;IACH,sCAIC;IAED,mCAEC;IAED;;;OAGG;IACH,6BAmBC;IAED;;;;;;;;;OASG;IACH,8IA+BC;;CACJ"}

package/src/shade/renderer/postprocess/taa/TAA.js

@@ -84,11 +84,11 @@ export class TAA {
     /**
      *
      * @param {FrameGraph} graph
-     * @param {number} texture_velocity
+     * @param {number} texture_velocity raw velocity buffer, internal resolution
      * @param {number} texture_color_current
      * @param {number} texture_color_history
      * @param {number} texture_output
-     * @param {number} texture_occlusion
+     * @param {number} texture_occlusion depth-clip pass output: confidence in r, nearest-depth offset in g
      * @param view
      */
     graph_pass({
@@ -97,8 +97,6 @@ export class TAA {
                    texture_color_current = -1,
                    texture_color_history = -1,
                    texture_output,
-                   camera_current = -1,
-                   camera_previous = -1,
                    texture_occlusion = -1,
                }) {
 
@@ -115,8 +113,6 @@ export class TAA {
                 HistoryTexture: texture_color_history,
                 ColourTexture: texture_color_current,
                 tOcclusion: texture_occlusion,
-                camera_current,
-                camera_previous,
                 settings: {
                     jitter: this.Jitter,
                     history_validity,

package/src/shade/renderer/postprocess/taa/chunk_depth_clip_offset_codec.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The depth-clip pass picks one of the 9 texels around a pixel by nearest depth and computes the
+ * history confidence for the velocity found there. It publishes that choice in the g channel of its
+ * rg8unorm output, so a consumer can fetch exactly the velocity the confidence was computed for from
+ * the raw velocity buffer: no repeated search, no second velocity texture.
+ *
+ * Encoding: index / 8 with index = (dy + 1) * 3 + (dx + 1), in [0, 8]. Every index survives 8-bit
+ * unorm quantisation with a margin of at least 0.48 before the decode rounds, pinned in
+ * shader_depth_occlusion_clip.spec.js.
+ *
+ * depth_clip_validated_velocity is the consumer side: given the depth-clip output and the raw
+ * velocity buffer, the velocity the confidence at `coord` was computed for. TAA and ReSTIR temporal
+ * reuse both reproject with it, so a pixel's confidence and its reprojection always agree.
+ * @type {CodeChunk}
+ */
+export const chunk_depth_clip_offset_codec: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_depth_clip_offset_codec.d.ts.map

package/src/shade/renderer/postprocess/taa/chunk_depth_clip_offset_codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_depth_clip_offset_codec.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/chunk_depth_clip_offset_codec.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,4CAFU,SAAS,CAoBjB;0BAnCwB,oCAAoC"}

package/src/shade/renderer/postprocess/taa/chunk_depth_clip_offset_codec.js

@@ -0,0 +1,36 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * The depth-clip pass picks one of the 9 texels around a pixel by nearest depth and computes the
+ * history confidence for the velocity found there. It publishes that choice in the g channel of its
+ * rg8unorm output, so a consumer can fetch exactly the velocity the confidence was computed for from
+ * the raw velocity buffer: no repeated search, no second velocity texture.
+ *
+ * Encoding: index / 8 with index = (dy + 1) * 3 + (dx + 1), in [0, 8]. Every index survives 8-bit
+ * unorm quantisation with a margin of at least 0.48 before the decode rounds, pinned in
+ * shader_depth_occlusion_clip.spec.js.
+ *
+ * depth_clip_validated_velocity is the consumer side: given the depth-clip output and the raw
+ * velocity buffer, the velocity the confidence at `coord` was computed for. TAA and ReSTIR temporal
+ * reuse both reproject with it, so a pixel's confidence and its reprojection always agree.
+ * @type {CodeChunk}
+ */
+export const chunk_depth_clip_offset_codec = CodeChunk.from(
+    //language=WGSL
+    `
+fn depth_clip_encode_offset(offset: vec2<i32>) -> f32 {
+    let index = (offset.y + 1) * 3 + (offset.x + 1);
+    return f32(index) / 8.0;
+}
+
+fn depth_clip_decode_offset(encoded: f32) -> vec2<i32> {
+    let index = i32(round(encoded * 8.0));
+    return vec2<i32>(index % 3 - 1, index / 3 - 1);
+}
+
+fn depth_clip_validated_velocity(depth_clip: texture_2d<f32>, velocity: texture_2d<f32>, coord: vec2<i32>) -> vec2<f32> {
+    let encoded = textureLoad(depth_clip, coord, 0).g;
+    return textureLoad(velocity, coord + depth_clip_decode_offset(encoded), 0).rg;
+}
+    `
+);

package/src/shade/renderer/postprocess/taa/chunk_taa_history_color_bounding_box_YCoCg.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_taa_history_color_bounding_box_YCoCg.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/chunk_taa_history_color_bounding_box_YCoCg.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,yDAFU,SAAS,CAiElB;0BAzEyB,oCAAoC"}
+{"version":3,"file":"chunk_taa_history_color_bounding_box_YCoCg.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/chunk_taa_history_color_bounding_box_YCoCg.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,yDAFU,SAAS,CAoElB;0BA5EyB,oCAAoC"}

package/src/shade/renderer/postprocess/taa/chunk_taa_history_color_bounding_box_YCoCg.js

@@ -43,8 +43,11 @@ fn taa_history_color_bounding_box_YCoCg(
     var moment1 = current_color_YCoCg;
     var moment2 = moment1 * moment1;
     
+    // clamp the gather to the texture: an out-of-bounds textureLoad is implementation-defined in WGSL
+    let last_texel = vec2<i32>(textureDimensions(current_color_texture)) - 1;
+
     for (var  i = 0; i < iteratorMax; i++ ) {
-        let new_st = in_screen_st + offsets[ i ];
+        let new_st = clamp(in_screen_st + offsets[ i ], vec2(0), last_texel);
 
         let new_colour =  taa_encode_color( textureLoad(current_color_texture, new_st, 0 ).rgb );
         

package/src/shade/renderer/postprocess/taa/shader_depth_occlusion_clip.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_depth_occlusion_clip.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/shader_depth_occlusion_clip.js"],"names":[],"mappings":"AAiBA;;;;GAIG;AACH,2CAFU,SAAS,CA0DjB;AAkCF,sDAYG;0BA1HuB,oCAAoC;4BAClC,6BAA6B"}
+{"version":3,"file":"shader_depth_occlusion_clip.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/shader_depth_occlusion_clip.js"],"names":[],"mappings":"AAkBA;;;;GAIG;AACH,2CAFU,SAAS,CA0DjB;AAqCF,sDAaG;0BA/HuB,oCAAoC;4BAClC,6BAA6B"}

package/src/shade/renderer/postprocess/taa/shader_depth_occlusion_clip.js

@@ -4,6 +4,7 @@ import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ImageShader } from "../../shader/ImageShader.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+import { chunk_depth_clip_offset_codec } from "./chunk_depth_clip_offset_codec.js";
 import { chunk_fsr2_compute_depth_clip } from "./chunk_fsr2_compute_depth_clip.js";
 
 const resources = new ShaderResourceSetDescriptor();
@@ -84,7 +85,7 @@ const body = CodeChunk.from(
 @fragment
 fn main(
     @builtin(position) coord: vec4<f32>,
-) -> @location(0) f32 {
+) -> @location(0) vec2<f32> {
     let render_size = vec2<i32>(textureDimensions(DepthBuffer));
     
     let screenST = vec2<i32>( coord.xy );
@@ -93,8 +94,8 @@ fn main(
     var iNearestDepthCoord:vec2<i32>;
     let depth = ffx_find_nearest_depth( DepthBuffer, screenST, render_size, &iNearestDepthCoord );
 
-    // Velocity is already dilated to the nearest-depth pixel via iNearestDepthCoord
-    // (FSR2's strategy). Don't chain a second magnitude-based dilation on top.
+    // Velocity at the nearest-depth pixel (FSR2's strategy). The choice is published in g below so
+    // the TAA resolve reprojects with the same velocity; don't chain a second dilation on top.
     let velocity = textureLoad( VelocityBuffer, iNearestDepthCoord, 0 ).rg;
 
     let prevFrameScreenST = coord.xy - velocity.xy;
@@ -102,11 +103,14 @@ fn main(
     // get depth confidence factor, larger then 0, assume the history is valid
     let confidence = fsr2_compute_depth_clip( prevFrameScreenST, depth, render_size );
 
-    return saturate(confidence);
+    // r: history confidence. g: which texel won the nearest-depth search, so a consumer can fetch
+    // the velocity this confidence was computed for from the raw velocity buffer.
+    return vec2(saturate(confidence), depth_clip_encode_offset(iNearestDepthCoord - screenST));
 }
     `, [
         chunk_fsr2_compute_depth_clip,
-        chunk_ffx_find_nearest_depth
+        chunk_ffx_find_nearest_depth,
+        chunk_depth_clip_offset_codec,
     ]
 )
 
@@ -117,9 +121,10 @@ export const shader_depth_occlusion_clip = new ImageShader({
         resources,
     }),
     targets: [
-        // Confidence is in [0, 1] post-saturate; r8unorm is sufficient and halves
-        // memory/bandwidth vs r16float. All consumers point-sample this texture.
-        { format: "r8unorm" }
+        // Both channels are point-sampled. r: confidence in [0, 1] post-saturate, 8 bits is enough.
+        // g: nearest-depth offset, see chunk_depth_clip_offset_codec. One byte per pixel over the
+        // old r8unorm buys the TAA resolve the exact velocity this pass validated.
+        { format: "rg8unorm" },
     ]
 
 });