@woosh/meep-engine 3.65.0 → 3.68.0

package/src/shade/renderer/postprocess/eye/GPUCameraExposureManager.js

@@ -17,6 +17,11 @@ const HISTOGRAM_DESCRIPTOR = BufferResourceDescriptor.empty(
     GPUBufferUsage.STORAGE,
 );
 
+/**
+ * The luminance an exposure of one shows at middle grey, cd/m²: the scene value the adaptation maps to 0.18.
+ */
+const MIDDLE_GREY = 0.18;
+
 const TARGET_LUMINANCE_DESCRIPTOR = BufferResourceDescriptor.from(
     F32_CONTAINER_STRUCT.size,
     GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
@@ -29,6 +34,10 @@ const TARGET_LUMINANCE_DESCRIPTOR = BufferResourceDescriptor.from(
  * The factor lives in one buffer for the manager's life, {@link multiplier}, which a frame's {@link update} or
  * {@link unadapted} writes over. A pass recorded ahead of that write in the frame reads the factor the last frame was
  * shown with: the exposure of the image on screen, Unreal Engine's `View.PreExposure`.
+ *
+ * Beside it, {@link adaptation}: the luminance the view is adapted to, cd/m², written by the same pass. Adapted, it is
+ * the luminance the eye has adapted to, without {@link exposure_compensation}; unadapted, it is the luminance the
+ * exposure shows at middle grey.
  */
 export class GPUCameraExposureManager {
     /**
@@ -47,6 +56,18 @@ export class GPUCameraExposureManager {
      */
     #multiplier;
 
+    /**
+     * {@link F32_CONTAINER_STRUCT}: the adaptation the last {@link update} or {@link unadapted} wrote, cd/m².
+     * @type {GPUTypedBuffer}
+     */
+    #adaptation;
+
+    /**
+     * The handles {@link update} and {@link unadapted} return, kept across frames.
+     * @type {{multiplier: number, adaptation: number}}
+     */
+    #written = { multiplier: -1, adaptation: -1 };
+
     /**
      * How fast do we adapt to brighter environments?
      * in f-stops per second.
@@ -78,15 +99,16 @@ export class GPUCameraExposureManager {
     exposure_compensation = 0.0;
 
     // what each pass's execution reads, kept across frames: a frame records them and runs them before the next does
-    #unadapted_data = { output: -1 };
+    #unadapted_data = { output: -1, adaptation: -1 };
     #unadapted_value = { value: 1.0 };
+    #unadapted_adaptation = { value: MIDDLE_GREY };
     #build_data = { input_color: -1, output: -1 };
     #parse_data = { input_histogram: -1, output: -1 };
-    #adapt_data = { goal: -1, previous: -1, adapted: -1, out_multiplier: -1 };
+    #adapt_data = { goal: -1, previous: -1, adapted: -1, out_multiplier: -1, out_adaptation: -1 };
     #adapt_settings = { speed_up: 0, speed_down: 0, time_delta: 0, exp_transition_distance: 0, compensation: 0 };
     #build_bindings = { tInput: null, histogram: null };
     #parse_bindings = { histogram: null, output: null };
-    #adapt_bindings = { goal: null, previous: null, settings: this.#adapt_settings, adapted: null, out_multiplier: null };
+    #adapt_bindings = { goal: null, previous: null, settings: this.#adapt_settings, adapted: null, out_multiplier: null, out_adaptation: null };
 
     /**
      *
@@ -110,13 +132,24 @@ export class GPUCameraExposureManager {
         this.#multiplier = GPUTypedBuffer.create({
             label: 'exposure multiplier',
             device,
-            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC,
             type: F32_CONTAINER_STRUCT,
             initial_value: {
                 value: 1.0
             }
         });
 
+        // what a factor of one shows at middle grey, until the first frame writes its own
+        this.#adaptation = GPUTypedBuffer.create({
+            label: 'exposure adaptation',
+            device,
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+            type: F32_CONTAINER_STRUCT,
+            initial_value: {
+                value: MIDDLE_GREY
+            }
+        });
+
     }
 
     destroy() {
@@ -125,6 +158,7 @@ export class GPUCameraExposureManager {
         }
 
         this.#multiplier.destroy();
+        this.#adaptation.destroy();
     }
 
     /**
@@ -132,12 +166,23 @@ export class GPUCameraExposureManager {
      * imports it into its graph once, and hands the handle both to the passes that read it ahead of the exposure,
      * which take the last frame's factor, and to {@link update} or {@link unadapted}, which write this frame's.
      *
-     * @returns {GPUBuffer} usable as a uniform or read-only storage
+     * @returns {GPUBuffer} usable as a uniform or read-only storage, and as a copy source, to read it back
      */
     get multiplier() {
         return this.#multiplier.buffer;
     }
 
+    /**
+     * The luminance the view is adapted to, cd/m², {@link F32_CONTAINER_STRUCT}, as the last {@link update} or
+     * {@link unadapted} wrote it. Imported into a frame's graph once and handed to {@link update} or {@link unadapted},
+     * like {@link multiplier}.
+     *
+     * @returns {GPUBuffer} usable as a uniform or read-only storage
+     */
+    get adaptation() {
+        return this.#adaptation.buffer;
+    }
+
     /**
      * Offer the pipelines {@link update} meters and adapts with — see {@link PipelineEnquiry}.
      * {@link unadapted} dispatches none.
@@ -151,26 +196,37 @@ export class GPUCameraExposureManager {
     }
 
     /**
-     * This frame's factor from {@link exposure_compensation} alone: 2^compensation.
+     * This frame's factor from {@link exposure_compensation} alone: 2^compensation. Its adaptation is the luminance
+     * that factor shows at middle grey, 0.18 / 2^compensation cd/m².
      *
      * @param {Object} options
      * @param {FrameGraph} options.graph
      * @param {number} options.multiplier the graph handle of {@link multiplier}, imported into `graph`
-     * @return {number} the handle of {@link multiplier} with this frame's factor written
+     * @param {number} options.adaptation the graph handle of {@link adaptation}, imported into `graph`
+     * @return {{multiplier: number, adaptation: number}} the handles of {@link multiplier} and {@link adaptation}
+     *         with this frame's written; the object is reused by the next call
      */
     unadapted({
                   graph,
                   multiplier,
+                  adaptation,
               }) {
         assert.defined(graph, 'graph');
         assert.isNonNegativeInteger(multiplier, 'multiplier');
+        assert.isNonNegativeInteger(adaptation, 'adaptation');
 
         const data = this.#unadapted_data;
         const pass = graph.add("unadapted", data, this.#execute_unadapted);
 
         data.output = pass.write(multiplier);
+        data.adaptation = pass.write(adaptation);
+
+        const written = this.#written;
 
-        return data.output;
+        written.multiplier = data.output;
+        written.adaptation = data.adaptation;
+
+        return written;
     }
 
     /**
@@ -186,26 +242,32 @@ export class GPUCameraExposureManager {
 
         // compensation is in f-stops: each stop doubles/halves brightness
         this.#unadapted_value.value = Math.pow(2, this.exposure_compensation);
+        this.#unadapted_adaptation.value = MIDDLE_GREY / this.#unadapted_value.value;
 
         // in the command stream, so a pass recorded ahead of this one still reads the last frame's factor
         encoder.writeValueBuffer(resources.get(data.output), 0, F32_CONTAINER_STRUCT, this.#unadapted_value);
+        encoder.writeValueBuffer(resources.get(data.adaptation), 0, F32_CONTAINER_STRUCT, this.#unadapted_adaptation);
     }
 
     /**
      * This frame's factor metered from `input_color`: the luminance adapted toward the frame's, from the last
-     * frame's, by the adaptation speeds; its factor is middle grey over it, times 2^{@link exposure_compensation}.
+     * frame's, by the adaptation speeds; its factor is middle grey over it, times 2^{@link exposure_compensation}. Its
+     * adaptation is that adapted luminance, without the compensation.
      *
      * @param {Object} options
      * @param {FrameGraph} options.graph
      * @param {number} options.input_color
      * @param {number} options.multiplier the graph handle of {@link multiplier}, imported into `graph`
+     * @param {number} options.adaptation the graph handle of {@link adaptation}, imported into `graph`
      * @param {number} [options.time_delta_seconds]
-     * @return {number} the handle of {@link multiplier} with this frame's factor written
+     * @return {{multiplier: number, adaptation: number}} the handles of {@link multiplier} and {@link adaptation}
+     *         with this frame's written; the object is reused by the next call
      */
     update({
                input_color,
                graph,
                multiplier,
+               adaptation,
                time_delta_seconds = 0.01666,
            }) {
 
@@ -219,6 +281,7 @@ export class GPUCameraExposureManager {
 
         assert.defined(graph, 'graph');
         assert.isNonNegativeInteger(multiplier, 'multiplier');
+        assert.isNonNegativeInteger(adaptation, 'adaptation');
         assert.isNumber(time_delta_seconds, 'time_delta_seconds');
         assert.greaterThanOrEqual(time_delta_seconds, 0, 'time_delta_seconds');
 
@@ -249,8 +312,14 @@ export class GPUCameraExposureManager {
         adapt_data.previous = adapt_pass.read(graph_import_buffer(graph, exposure_buffer_previous.buffer, "previous adapted luminance"));
         adapt_data.adapted = adapt_pass.write(graph_import_buffer(graph, exposure_buffer_current.buffer, "adapted luminance"));
         adapt_data.out_multiplier = adapt_pass.write(multiplier);
+        adapt_data.out_adaptation = adapt_pass.write(adaptation);
+
+        const written = this.#written;
+
+        written.multiplier = adapt_data.out_multiplier;
+        written.adaptation = adapt_data.out_adaptation;
 
-        return adapt_data.out_multiplier;
+        return written;
     }
 
     /**
@@ -319,6 +388,7 @@ export class GPUCameraExposureManager {
         bindings.previous = resources.get(data.previous);
         bindings.adapted = resources.get(data.adapted);
         bindings.out_multiplier = resources.get(data.out_multiplier);
+        bindings.out_adaptation = resources.get(data.out_adaptation);
 
         shader_autoexposure_adapt.dispatch({
             encoder: context.encoder,

package/src/shade/renderer/postprocess/eye/shader_autoexposure_adapt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_autoexposure_adapt.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/eye/shader_autoexposure_adapt.js"],"names":[],"mappings":"AASA,sDAsBE;AA+FF,sDAIG;6BAjI0B,mCAAmC;8BAElC,+BAA+B"}
+{"version":3,"file":"shader_autoexposure_adapt.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/eye/shader_autoexposure_adapt.js"],"names":[],"mappings":"AASA,sDAsBE;AAkGF,sDAIG;6BApI0B,mCAAmC;8BAElC,+BAA+B"}

package/src/shade/renderer/postprocess/eye/shader_autoexposure_adapt.js

@@ -41,6 +41,7 @@ resources.createGroup()
     .addUniform("previous", F32_CONTAINER_STRUCT)
     .addStorageBuffer("adapted", F32_CONTAINER_STRUCT, true)
     .addStorageBuffer("out_multiplier", F32_CONTAINER_STRUCT, true)
+    .addStorageBuffer("out_adaptation", F32_CONTAINER_STRUCT, true)
 ;
 
 
@@ -64,6 +65,7 @@ fn main(){
     */
     if (!(goal.value > 0.0)) {
         adapted.value = previous.value;
+        out_adaptation.value = previous.value;
 
         out_multiplier.value = (MIDDLE_GREY / current_linear) * exp2(settings.compensation);
 
@@ -113,7 +115,8 @@ fn main(){
     // convert back to linear space
     let new_linear = exp2(new_ev);
     adapted.value = new_linear;
-    
+    out_adaptation.value = new_linear;
+
     // apply final transforms
 
     let shifted = MIDDLE_GREY / adapted.value;

package/src/shade/renderer/postprocess/motion_blur/MotionBlur.d.ts

@@ -38,7 +38,7 @@ export class MotionBlur {
      * @param {object} args
      * @param {FrameGraph} args.graph
      * @param {number} args.input_color  FrameGraph handle, rgba16float HDR colour (post-TAA)
-     * @param {number} args.velocity     FrameGraph handle, rg16float pixel-space velocity
+     * @param {number} args.velocity     FrameGraph handle, the velocity buffer (`VELOCITY_FORMAT`), read for its pixel-space deltas
      * @param {number} args.depth        FrameGraph handle, depth texture
      * @param {number[]} args.resolution full output resolution `[w, h]`
      * @param {number[]} [args.velocity_resolution] resolution of `velocity` and `depth`, which are

package/src/shade/renderer/postprocess/motion_blur/MotionBlur.js

@@ -42,7 +42,7 @@ export class MotionBlur {
      * @param {object} args
      * @param {FrameGraph} args.graph
      * @param {number} args.input_color  FrameGraph handle, rgba16float HDR colour (post-TAA)
-     * @param {number} args.velocity     FrameGraph handle, rg16float pixel-space velocity
+     * @param {number} args.velocity     FrameGraph handle, the velocity buffer (`VELOCITY_FORMAT`), read for its pixel-space deltas
      * @param {number} args.depth        FrameGraph handle, depth texture
      * @param {number[]} args.resolution full output resolution `[w, h]`
      * @param {number[]} [args.velocity_resolution] resolution of `velocity` and `depth`, which are

package/src/shade/renderer/postprocess/motion_blur/graph_postprocess_motion_blur.d.ts

@@ -31,7 +31,7 @@
  * @param {object} args
  * @param {FrameGraph} args.graph
  * @param {number} args.input_color    FrameGraph handle, rgba16float HDR colour (post-TAA)
- * @param {number} args.velocity       FrameGraph handle, rg16float pixel-space velocity
+ * @param {number} args.velocity       FrameGraph handle, the velocity buffer (`VELOCITY_FORMAT`), read for its pixel-space deltas
  * @param {number} args.depth          FrameGraph handle, depth texture
  * @param {number[]} args.resolution   Full output resolution `[w, h]`
  * @param {number[]} [args.velocity_resolution] Resolution of `velocity` and `depth`, which are

package/src/shade/renderer/postprocess/motion_blur/graph_postprocess_motion_blur.js

@@ -38,7 +38,7 @@ import { shader_motion_blur_tile_max } from "./shader_motion_blur_tile_max.js";
  * @param {object} args
  * @param {FrameGraph} args.graph
  * @param {number} args.input_color    FrameGraph handle, rgba16float HDR colour (post-TAA)
- * @param {number} args.velocity       FrameGraph handle, rg16float pixel-space velocity
+ * @param {number} args.velocity       FrameGraph handle, the velocity buffer (`VELOCITY_FORMAT`), read for its pixel-space deltas
  * @param {number} args.depth          FrameGraph handle, depth texture
  * @param {number[]} args.resolution   Full output resolution `[w, h]`
  * @param {number[]} [args.velocity_resolution] Resolution of `velocity` and `depth`, which are

package/src/shade/renderer/postprocess/motion_blur/shader_motion_blur_reconstruct.js

@@ -19,7 +19,7 @@ resources.setImmediate("uStrength", F32_CONTAINER_STRUCT);
 resources.createGroup()
     // Post-TAA HDR color we're blurring.
     .addTexture("tColor", "float")
-    // Full-resolution velocity (pixel-space deltas, rg16float).
+    // Full-resolution velocity (VELOCITY_FORMAT; its pixel-space deltas in rg).
     .addTexture("tVelocity", "float")
     // 1/K resolution dilated tile velocity from NeighborMax.
     .addTexture("tNeighborMax", "float")

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

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

package/src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_add_hit_irradiance.js

@@ -128,3 +128,5 @@ chunk_ssr_add_hit_irradiance.add(ShadeIndirectLightingMode.IBL, chunk_ssr_add_hi
 chunk_ssr_add_hit_irradiance.add(ShadeIndirectLightingMode.Brick4, chunk_ssr_add_hit_irradiance_none);
 chunk_ssr_add_hit_irradiance.add(ShadeIndirectLightingMode.LPV, chunk_ssr_add_hit_irradiance_lpv);
 chunk_ssr_add_hit_irradiance.add(ShadeIndirectLightingMode.ProbeClipmap, chunk_ssr_add_hit_irradiance_probe_clipmap);
+// the screen probes light only the deferred opaque surfaces: every other reader takes the world-space probes
+chunk_ssr_add_hit_irradiance.add(ShadeIndirectLightingMode.ScreenProbes, chunk_ssr_add_hit_irradiance_probe_clipmap);

package/src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_sample_radiance.js

@@ -94,3 +94,5 @@ chunk_ssr_sample_radiance.add(ShadeIndirectLightingMode.IBL, chunk_ssr_sample_ra
 chunk_ssr_sample_radiance.add(ShadeIndirectLightingMode.Brick4, chunk_ssr_sample_radiance_brick4);
 chunk_ssr_sample_radiance.add(ShadeIndirectLightingMode.LPV, chunk_ssr_sample_radiance_lpv);
 chunk_ssr_sample_radiance.add(ShadeIndirectLightingMode.ProbeClipmap, chunk_ssr_sample_radiance_probe_clipmap);
+// the screen probes light only the deferred opaque surfaces: every other reader takes the world-space probes
+chunk_ssr_sample_radiance.add(ShadeIndirectLightingMode.ScreenProbes, chunk_ssr_sample_radiance_probe_clipmap);

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

@@ -1,6 +1,12 @@
 /**
  * Returns confidence level in reprojected sample (1 = trust history, 0 = disocclusion).
  *
+ * `depth_motion` is the view depth the point moved through since last frame, the velocity buffer's z
+ * (`VELOCITY_FORMAT`). Last frame's depth is weighed against the point's depth then, its depth now
+ * less that, as UE's TSR weighs it (`PrevClosestDeviceZ`, TSRDilateVelocity.usf). FSR2 has no depth
+ * in its motion and weighs against the depth now, which reads a surface moving away from the camera
+ * as a disocclusion.
+ *
  * NOTE: deliberately uses a 2x2 *min*-gather over inverted-depth prev samples (= farthest
  * in view space), which is the OPPOSITE of FSR2's "closest reconstructed prev depth"
  * semantic. We do this on purpose:

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_fsr2_compute_depth_clip.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/chunk_fsr2_compute_depth_clip.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,4CAFU,SAAS,CAkGjB;0BA9HwB,oCAAoC"}
+{"version":3,"file":"chunk_fsr2_compute_depth_clip.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/chunk_fsr2_compute_depth_clip.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,4CAFU,SAAS,CAoGjB;0BAtIwB,oCAAoC"}

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

@@ -9,6 +9,12 @@ import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 /**
  * Returns confidence level in reprojected sample (1 = trust history, 0 = disocclusion).
  *
+ * `depth_motion` is the view depth the point moved through since last frame, the velocity buffer's z
+ * (`VELOCITY_FORMAT`). Last frame's depth is weighed against the point's depth then, its depth now
+ * less that, as UE's TSR weighs it (`PrevClosestDeviceZ`, TSRDilateVelocity.usf). FSR2 has no depth
+ * in its motion and weighs against the depth now, which reads a surface moving away from the camera
+ * as a disocclusion.
+ *
  * NOTE: deliberately uses a 2x2 *min*-gather over inverted-depth prev samples (= farthest
  * in view space), which is the OPPOSITE of FSR2's "closest reconstructed prev depth"
  * semantic. We do this on purpose:
@@ -39,9 +45,11 @@ export const chunk_fsr2_compute_depth_clip = CodeChunk.from(
 fn fsr2_compute_depth_clip(
     previous_coord: vec2<f32>,
     current_depth_sample: f32,
+    depth_motion: f32,
     render_size: vec2<i32>
 ) -> f32 {
-    let fCurrentDepthViewSpace = get_view_space_depth(current_depth_sample, camera_current);
+    // the point's view depth last frame: its depth now less the depth it moved through
+    let fCurrentDepthViewSpace = get_view_space_depth(current_depth_sample, camera_current) - depth_motion;
 
     // previous_coord is in this frame's pixels, and the previous depth keeps the size it was drawn
     // at across a resolution change, so carry the position into its grid. Equal sizes scale by 1.

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":"AAkBA;;;;;;;;;;;;GAYG;AACH,2CAFU,SAAS,CAsBjB;AAqCF,sDAaG;0BApGuB,oCAAoC;4BAElC,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;;;;;;;;;;;;GAYG;AACH,2CAFU,SAAS,CAsBjB;AAsCF,sDAaG;0BArGuB,oCAAoC;4BAElC,6BAA6B"}

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

@@ -68,12 +68,13 @@ fn main(
 
     // 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 velocity = textureLoad( VelocityBuffer, iNearestDepthCoord, 0 ).xyz;
 
     let prevFrameScreenST = coord.xy - velocity.xy;
 
-    // get depth confidence factor, larger then 0, assume the history is valid
-    let confidence = fsr2_compute_depth_clip( prevFrameScreenST, depth, render_size );
+    // get depth confidence factor, larger then 0, assume the history is valid; against the
+    // point's depth last frame, by the depth it moved through (velocity.z)
+    let confidence = fsr2_compute_depth_clip( prevFrameScreenST, depth, velocity.z, render_size );
 
     // 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.

package/src/shade/renderer/postprocess/velocity/VELOCITY_BUFFER.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The velocity buffer's format: how each pixel's surface point moved since the last frame, four half floats
+ * (`chunk_velocity_texel` makes the texel):
+ *
+ * - **x, y**: internal pixels from the point's place on last frame's screen to its place on this one;
+ * - **z**: the point's view depth now less its view depth then, in world units: negative for a surface coming
+ *   nearer, zero for one moving across the view at its depth, and zero for the sky;
+ * - **w**: zero.
+ *
+ * Both frames' projections are taken free of the TAA jitter, so a still surface under a still camera holds zero
+ * throughout. A delta rather than last frame's depth itself: a half float holds it to a share of the motion, and so
+ * holds the depth recovered from it, `depth − z`, to that share of the motion rather than of the depth.
+ *
+ * @type {GPUTextureFormat}
+ */
+export const VELOCITY_FORMAT: GPUTextureFormat;
+//# sourceMappingURL=VELOCITY_BUFFER.d.ts.map

package/src/shade/renderer/postprocess/velocity/VELOCITY_BUFFER.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VELOCITY_BUFFER.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/velocity/VELOCITY_BUFFER.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,+CAA6C"}

package/src/shade/renderer/postprocess/velocity/VELOCITY_BUFFER.js

@@ -0,0 +1,16 @@
+/**
+ * The velocity buffer's format: how each pixel's surface point moved since the last frame, four half floats
+ * (`chunk_velocity_texel` makes the texel):
+ *
+ * - **x, y**: internal pixels from the point's place on last frame's screen to its place on this one;
+ * - **z**: the point's view depth now less its view depth then, in world units: negative for a surface coming
+ *   nearer, zero for one moving across the view at its depth, and zero for the sky;
+ * - **w**: zero.
+ *
+ * Both frames' projections are taken free of the TAA jitter, so a still surface under a still camera holds zero
+ * throughout. A delta rather than last frame's depth itself: a half float holds it to a share of the motion, and so
+ * holds the depth recovered from it, `depth − z`, to that share of the motion rather than of the depth.
+ *
+ * @type {GPUTextureFormat}
+ */
+export const VELOCITY_FORMAT = 'rgba16float';

package/src/shade/renderer/postprocess/velocity/chunk_velocity_texel.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A pixel's texel of the velocity buffer (`VELOCITY_FORMAT`), from its surface point now and where that point stood a
+ * frame ago:
+ *
+ * ```wgsl
+ * fn velocity_texel(pixel: vec2<f32>, depth: f32, before: vec4<f32>, size: vec2<f32>) -> vec4<f32>
+ * ```
+ *
+ * - `pixel`: the pixel's centre, in the view's internal pixels; `size`: the view's size in them.
+ * - `depth`: the point's clip w this frame.
+ * - `before`: the point a frame ago, in last frame's clip space.
+ *
+ * Both clip spaces are the un-jittered projections' (`view_velocity_matrices`). The texel's z is the clip w now less
+ * then, which a perspective projection makes the view depth; under an orthographic one, whose w is always one, it is
+ * zero.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_velocity_texel: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_velocity_texel.d.ts.map

package/src/shade/renderer/postprocess/velocity/chunk_velocity_texel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_velocity_texel.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/velocity/chunk_velocity_texel.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,mCAFU,SAAS,CAWhB;0BA7BuB,oCAAoC"}

package/src/shade/renderer/postprocess/velocity/chunk_velocity_texel.js

@@ -0,0 +1,30 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * A pixel's texel of the velocity buffer (`VELOCITY_FORMAT`), from its surface point now and where that point stood a
+ * frame ago:
+ *
+ * ```wgsl
+ * fn velocity_texel(pixel: vec2<f32>, depth: f32, before: vec4<f32>, size: vec2<f32>) -> vec4<f32>
+ * ```
+ *
+ * - `pixel`: the pixel's centre, in the view's internal pixels; `size`: the view's size in them.
+ * - `depth`: the point's clip w this frame.
+ * - `before`: the point a frame ago, in last frame's clip space.
+ *
+ * Both clip spaces are the un-jittered projections' (`view_velocity_matrices`). The texel's z is the clip w now less
+ * then, which a perspective projection makes the view depth; under an orthographic one, whose w is always one, it is
+ * zero.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_velocity_texel = CodeChunk.from(
+    //language=WGSL
+    `
+fn velocity_texel(pixel: vec2<f32>, depth: f32, before: vec4<f32>, size: vec2<f32>) -> vec4<f32> {
+    let ndc = before.xy / before.w;
+    let previous = vec2<f32>((ndc.x + 1.0) * 0.5 * size.x, (1.0 - ndc.y) * 0.5 * size.y);
+
+    return vec4<f32>(pixel - previous, depth - before.w, 0.0);
+}
+`);

package/src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.d.ts

@@ -27,10 +27,12 @@ export function enquire_per_object_velocity_pipelines(enquiry: PipelineEnquiry):
  *     per-vertex skin deformation (the limb-ghosting case Stage 1
  *     couldn't address) on top of the per-object motion.
  *
- * The skinned and rigid foreground branches both produce
- * pixel-space deltas in the same units, so downstream consumers
- * (TAA, motion blur) just see velocity — no skinning-awareness
- * needed at any layer above this pass.
+ * The skinned and rigid foreground branches both produce the
+ * velocity buffer's texel (`VELOCITY_FORMAT`: pixel deltas and the
+ * view depth moved through), so downstream consumers (TAA, motion
+ * blur, the screen probes) just see velocity — no
+ * skinning-awareness needed at any layer above this pass. The
+ * background's depth delta is zero.
  *
  * Un-jittered matrices are CPU-built from
  * `camera.projection_matrix × camera.view_matrix` — viewport
@@ -51,7 +53,7 @@ export function enquire_per_object_velocity_pipelines(enquiry: PipelineEnquiry):
  *      placeholders and the shader forces the rigid path.
  * @param {number[]} args.resolution
  * @param {GPUViewContext} args.view
- * @returns {number} FrameGraph handle to the velocity texture (rg16float)
+ * @returns {number} FrameGraph handle to the velocity texture (`VELOCITY_FORMAT`)
  */
 export function graph_add_per_object_velocity({ graph, texture_depth, texture_visibility, buffer_visible_meshlets, buffer_scene_database, buffer_meshlet_metadata, buffer_meshlet_data, buffer_prev_position_offsets, buffer_prev_positions, skinning_active, resolution, view, }: {
     graph: FrameGraph;

package/src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_add_per_object_velocity.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.js"],"names":[],"mappings":"AA8QA;;;;GAIG;AACH,+DAFW,eAAe,QAIzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;IAhB4B,KAAK;IACT,aAAa,EAA1B,MAAM;IACO,kBAAkB,EAA/B,MAAM;IACO,uBAAuB,EAApC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACO,uBAAuB,EAApC,MAAM;IACO,mBAAmB,EAAhC,MAAM;IACO,4BAA4B,EAAzC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACQ,eAAe,EAA7B,OAAO;IAGQ,UAAU,EAAzB,MAAM,EAAE;IACa,IAAI;IACvB,MAAM,CA+DlB;8BA9VY,OAAO,6CAA6C,EAAE,eAAe"}
+{"version":3,"file":"graph_add_per_object_velocity.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.js"],"names":[],"mappings":"AA8QA;;;;GAIG;AACH,+DAFW,eAAe,QAIzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH;IAhB4B,KAAK;IACT,aAAa,EAA1B,MAAM;IACO,kBAAkB,EAA/B,MAAM;IACO,uBAAuB,EAApC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACO,uBAAuB,EAApC,MAAM;IACO,mBAAmB,EAAhC,MAAM;IACO,4BAA4B,EAAzC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACQ,eAAe,EAA7B,OAAO;IAGQ,UAAU,EAAzB,MAAM,EAAE;IACa,IAAI;IACvB,MAAM,CA+DlB;8BA9VY,OAAO,6CAA6C,EAAE,eAAe"}

package/src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.js

@@ -30,7 +30,9 @@ import { graph_image_pass } from "../../shader/graph/graph_image_pass.js";
 import { ImageShader } from "../../shader/ImageShader.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+import { chunk_velocity_texel } from "./chunk_velocity_texel.js";
 import { construct_pixel_reprojection_matrix } from "./construct_pixel_reprojection_matrix.js";
+import { VELOCITY_FORMAT } from "./VELOCITY_BUFFER.js";
 import { view_velocity_matrices } from "./view_velocity_matrices.js";
 import {
     construct_reprojection_matrix_rotation_only,
@@ -92,7 +94,7 @@ fn read_prev_position(base: u32, vertex_index: u32) -> vec3<f32> {
 @fragment
 fn main(
     @builtin(position) coord: vec4<f32>,
-) -> @location(0) vec2<f32> {
+) -> @location(0) vec4<f32> {
 
     let cur_px = coord.xy;
     let texel = vec2<u32>(cur_px);
@@ -103,12 +105,13 @@ fn main(
     // Visibility-buffer clears leave VISIBILITY_NONE on sky
     // pixels, where reverse-Z depth is always 0.0. Passing 0.0
     // directly avoids a tDepth textureLoad on every background pixel.
+    // The sky stands infinitely far, so it has no depth to move through.
     if visibility_word == VISIBILITY_NONE {
         let position_previous = v3_matrix4_project(
             vec3<f32>(cur_px, 0.0),
             mReprojectionRotation
         );
-        return cur_px - position_previous.xy;
+        return vec4<f32>(cur_px - position_previous.xy, 0.0, 0.0);
     }
 
     // ── Reconstruct world-space position for this pixel ─────────
@@ -233,15 +236,11 @@ fn main(
         prev_world = prev_world_h.xyz / prev_world_h.w;
     }
 
-    // ── Project to previous frame, compute pixel delta ──────────
-    let prev_clip = mViewProjPrevious * vec4<f32>(prev_world, 1.0);
-    let prev_ndc = prev_clip.xyz / prev_clip.w;
-    let prev_px = vec2<f32>(
-        (prev_ndc.x + 1.0) * 0.5 * res.x,
-        (1.0 - prev_ndc.y) * 0.5 * res.y,
-    );
-
-    return cur_px - prev_px;
+    // ── Project to previous frame: the pixel and depth deltas ───
+    //
+    // This frame's clip w, the point's view depth, is the reciprocal of
+    // the w its unprojection came out with.
+    return velocity_texel(cur_px, 1.0 / cur_world_h.w, mViewProjPrevious * vec4<f32>(prev_world, 1.0), res);
 }
 `, [
         chunk_v3_matrix4_project,
@@ -251,6 +250,7 @@ fn main(
         chunk_read_meshlet_vertex_position,
         MESHLET_METADATA_STRUCT.declaration_chunk,
         chunk_visibility_decode,
+        chunk_velocity_texel,
     ]
 );
 
@@ -261,7 +261,7 @@ const shader = new ImageShader({
         body
     }),
     targets: [{
-        format: "rg16float",
+        format: VELOCITY_FORMAT,
     }]
 });
 
@@ -300,10 +300,12 @@ export function enquire_per_object_velocity_pipelines(enquiry) {
  *     per-vertex skin deformation (the limb-ghosting case Stage 1
  *     couldn't address) on top of the per-object motion.
  *
- * The skinned and rigid foreground branches both produce
- * pixel-space deltas in the same units, so downstream consumers
- * (TAA, motion blur) just see velocity — no skinning-awareness
- * needed at any layer above this pass.
+ * The skinned and rigid foreground branches both produce the
+ * velocity buffer's texel (`VELOCITY_FORMAT`: pixel deltas and the
+ * view depth moved through), so downstream consumers (TAA, motion
+ * blur, the screen probes) just see velocity — no
+ * skinning-awareness needed at any layer above this pass. The
+ * background's depth delta is zero.
  *
  * Un-jittered matrices are CPU-built from
  * `camera.projection_matrix × camera.view_matrix` — viewport
@@ -324,7 +326,7 @@ export function enquire_per_object_velocity_pipelines(enquiry) {
  *      placeholders and the shader forces the rigid path.
  * @param {number[]} args.resolution
  * @param {GPUViewContext} args.view
- * @returns {number} FrameGraph handle to the velocity texture (rg16float)
+ * @returns {number} FrameGraph handle to the velocity texture (`VELOCITY_FORMAT`)
  */
 export function graph_add_per_object_velocity({
                                                   graph,

package/src/shade/renderer/rasterize/forward/chunk_forward_sample_indirect.js

@@ -35,3 +35,5 @@ chunk_forward_sample_indirect.add(ShadeIndirectLightingMode.IBL, chunk_forward_s
 chunk_forward_sample_indirect.add(ShadeIndirectLightingMode.Brick4, chunk_forward_sample_indirect_brick4);
 chunk_forward_sample_indirect.add(ShadeIndirectLightingMode.LPV, chunk_forward_sample_indirect_environment);
 chunk_forward_sample_indirect.add(ShadeIndirectLightingMode.ProbeClipmap, chunk_forward_sample_indirect_probe_clipmap);
+// the screen probes light only the deferred opaque surfaces: every other reader takes the world-space probes
+chunk_forward_sample_indirect.add(ShadeIndirectLightingMode.ScreenProbes, chunk_forward_sample_indirect_probe_clipmap);