@woosh/meep-engine 3.30.0 → 3.32.0

package/src/shade/renderer/postprocess/gtao/fragment_shader_gtao.d.ts

@@ -1,19 +1,7 @@
-/**
- * see https://github.com/GameTechDev/XeGTAO/blob/a5b1686c7ea37788eeb3576b5be47f7c03db532c/Source/Rendering/Shaders/XeGTAO.h#L55
- * @type {number}
- */
-export const GTAO_DEPTH_MIP_LEVELS: number;
-/**
- * distant samples contribute less
- * must be in [0, 1] range
- */
-export const GTAO_EFFECT_FALLOFF_RANGE: 0.615;
-/**
- * In world-space units (meters)
- * [ALEX] From various industry talks it is recommended to limit SSAO to ~1m of world space. I think it's very arbitrary, but seems intuitively OK for human-scale objects/scenes.
- * @type {number}
- */
-export const GTAO_EFFECT_RADIUS: number;
 export const fragment_shader_gtao: ImageShader;
+import { GTAO_DEPTH_MIP_LEVELS } from "./GTAO_CONSTANTS.js";
+import { GTAO_EFFECT_FALLOFF_RANGE } from "./GTAO_CONSTANTS.js";
+import { GTAO_EFFECT_RADIUS } from "./GTAO_CONSTANTS.js";
 import { ImageShader } from "../../shader/ImageShader.js";
+export { GTAO_DEPTH_MIP_LEVELS, GTAO_EFFECT_FALLOFF_RANGE, GTAO_EFFECT_RADIUS };
 //# sourceMappingURL=fragment_shader_gtao.d.ts.map

package/src/shade/renderer/postprocess/gtao/fragment_shader_gtao.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fragment_shader_gtao.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/fragment_shader_gtao.js"],"names":[],"mappings":"AAyEA;;;GAGG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,8CAA+C;AAE/C;;;;GAIG;AACH,iCAFU,MAAM,CAEoB;AAiQpC,+CA6BG;4BA1WyB,6BAA6B"}
+{"version":3,"file":"fragment_shader_gtao.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/fragment_shader_gtao.js"],"names":[],"mappings":"AAiTA,+CA6BG;sCApTI,qBAAqB;0CAArB,qBAAqB;mCAArB,qBAAqB;4BAZA,6BAA6B"}

package/src/shade/renderer/postprocess/gtao/fragment_shader_gtao.js

@@ -18,6 +18,13 @@ import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
 import { HILBERT_R2_INDEX_TEXTURE } from "../../texture/noise/HILBERT_R2_INDEX_TEXTURE.js";
 import { SAMPLER_NEAREST } from "../../texture/SAMPLER_LINEAR_UPSCALE.js";
 import { chunk_integrate_bent_normal_fast } from "./chunk_integrate_bent_normal_fast.js";
+import {
+    GTAO_DEPTH_MIP_LEVELS,
+    GTAO_EFFECT_FALLOFF_RANGE,
+    GTAO_EFFECT_RADIUS,
+    GTAO_QUALITY_PROFILES,
+    GTAO_QUALITY_TYPE
+} from "./GTAO_CONSTANTS.js";
 import { GTAO_RENDER_SETTINGS } from "./GTAO_RENDER_SETTINGS.js";
 
 const resources = new ShaderResourceSetDescriptor();
@@ -36,59 +43,10 @@ resources.createGroup()
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)
 ;
 
-const QualityType = {
-    Low: 0,
-    Medium: 1,
-    High: 2,
-    Ultra: 3,
-}
-
-/**
- * @see https://github.com/GameTechDev/XeGTAO/blob/a5b1686c7ea37788eeb3576b5be47f7c03db532c/Source/Rendering/Shaders/vaGTAO.hlsl#L101
- * @type {Object<QualityType, {slices: number, steps: number}>}
- */
-const QUALITY_PROFILES = {
-    [QualityType.Low]: {
-        slices: 2,
-        steps: 2,
-    },
-    [QualityType.Medium]: {
-        slices: 2,
-        steps: 4,
-    },
-    [QualityType.High]: {
-        slices: 2,
-        steps: 10,
-    },
-    [QualityType.Ultra]: {
-        slices: 4,
-        steps: 14,
-    }
-};
-
-/**
- * @type {{slices:number,steps:number}}
- */
-const QUALITY_SETTINGS = QUALITY_PROFILES[QualityType.Medium];
+const QUALITY_SETTINGS = GTAO_QUALITY_PROFILES[GTAO_QUALITY_TYPE.Medium];
 
-/**
- * see https://github.com/GameTechDev/XeGTAO/blob/a5b1686c7ea37788eeb3576b5be47f7c03db532c/Source/Rendering/Shaders/XeGTAO.h#L55
- * @type {number}
- */
-export const GTAO_DEPTH_MIP_LEVELS = 0;
-
-/**
- * distant samples contribute less
- * must be in [0, 1] range
- */
-export const GTAO_EFFECT_FALLOFF_RANGE = 0.615;
-
-/**
- * In world-space units (meters)
- * [ALEX] From various industry talks it is recommended to limit SSAO to ~1m of world space. I think it's very arbitrary, but seems intuitively OK for human-scale objects/scenes.
- * @type {number}
- */
-export const GTAO_EFFECT_RADIUS = 1;
+// the import paths these already had, kept working
+export { GTAO_DEPTH_MIP_LEVELS, GTAO_EFFECT_FALLOFF_RANGE, GTAO_EFFECT_RADIUS };
 
 /*
 based on https://github.com/GameTechDev/XeGTAO/tree/e7698f874e90f2516fca26c696ec3cd2c70e505a

package/src/shade/renderer/postprocess/gtao/fragment_shader_gtao_with_irradiance.d.ts

@@ -1,19 +1,3 @@
-/**
- * see https://github.com/GameTechDev/XeGTAO/blob/a5b1686c7ea37788eeb3576b5be47f7c03db532c/Source/Rendering/Shaders/XeGTAO.h#L55
- * @type {number}
- */
-export const GTAO_DEPTH_MIP_LEVELS: number;
-/**
- * distant samples contribute less
- * must be in [0, 1] range
- */
-export const GTAO_EFFECT_FALLOFF_RANGE: 0.615;
-/**
- * In world-space units (meters)
- * [ALEX] From various industry talks it is recommended to limit SSAO to ~1m of world space. I think it's very arbitrary, but seems intuitively OK for human-scale objects/scenes.
- * @type {number}
- */
-export const GTAO_EFFECT_RADIUS: number;
 export const fragment_shader_gtao_with_irradiance: ImageShader;
 import { ImageShader } from "../../shader/ImageShader.js";
 //# sourceMappingURL=fragment_shader_gtao_with_irradiance.d.ts.map

package/src/shade/renderer/postprocess/gtao/fragment_shader_gtao_with_irradiance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fragment_shader_gtao_with_irradiance.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/fragment_shader_gtao_with_irradiance.js"],"names":[],"mappings":"AA4EA;;;GAGG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,8CAA+C;AAE/C;;;;GAIG;AACH,iCAFU,MAAM,CAEoB;AA0TpC,+DAkCG;4BAxayB,6BAA6B"}
+{"version":3,"file":"fragment_shader_gtao_with_irradiance.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/fragment_shader_gtao_with_irradiance.js"],"names":[],"mappings":"AAuXA,+DAkCG;4BAxYyB,6BAA6B"}

package/src/shade/renderer/postprocess/gtao/fragment_shader_gtao_with_irradiance.js

@@ -24,6 +24,12 @@ import { SAMPLER_NEAREST } from "../../texture/SAMPLER_LINEAR_UPSCALE.js";
 import { chunk_is_background } from "../../shader/chunk/depth/chunk_is_background.js";
 import { chunk_integrate_bent_normal_fast } from "./chunk_integrate_bent_normal_fast.js";
 import { chunk_horizon_integrate_lighting_sample } from "./chunk_integrate_lighting_sample.js";
+import {
+    GTAO_EFFECT_FALLOFF_RANGE,
+    GTAO_EFFECT_RADIUS,
+    GTAO_QUALITY_PROFILES,
+    GTAO_QUALITY_TYPE
+} from "./GTAO_CONSTANTS.js";
 import { GTAO_RENDER_SETTINGS } from "./GTAO_RENDER_SETTINGS.js";
 
 const resources = new ShaderResourceSetDescriptor();
@@ -39,59 +45,12 @@ resources.createGroup()
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)
 ;
 
-const QualityType = {
-    Low: 0,
-    Medium: 1,
-    High: 2,
-    Ultra: 3,
-}
-
-/**
- * @see https://github.com/GameTechDev/XeGTAO/blob/a5b1686c7ea37788eeb3576b5be47f7c03db532c/Source/Rendering/Shaders/vaGTAO.hlsl#L101
- * @type {Object<QualityType, {slices: number, steps: number}>}
- */
-const QUALITY_PROFILES = {
-    [QualityType.Low]: {
-        slices: 2,
-        steps: 2,
-    },
-    [QualityType.Medium]: {
-        slices: 2,
-        steps: 4,
-    },
-    [QualityType.High]: {
-        slices: 2,
-        steps: 10,
-    },
-    [QualityType.Ultra]: {
-        slices: 4,
-        steps: 14,
-    }
-};
-
 /**
+ * One step below the AO-only shader's Medium, because every sample here also integrates incoming
+ * radiance. A deliberate difference, unlike the ones this fork used to carry by accident.
  * @type {{slices:number,steps:number}}
  */
-const QUALITY_SETTINGS = QUALITY_PROFILES[QualityType.Low];
-
-/**
- * see https://github.com/GameTechDev/XeGTAO/blob/a5b1686c7ea37788eeb3576b5be47f7c03db532c/Source/Rendering/Shaders/XeGTAO.h#L55
- * @type {number}
- */
-export const GTAO_DEPTH_MIP_LEVELS = 0;
-
-/**
- * distant samples contribute less
- * must be in [0, 1] range
- */
-export const GTAO_EFFECT_FALLOFF_RANGE = 0.615;
-
-/**
- * In world-space units (meters)
- * [ALEX] From various industry talks it is recommended to limit SSAO to ~1m of world space. I think it's very arbitrary, but seems intuitively OK for human-scale objects/scenes.
- * @type {number}
- */
-export const GTAO_EFFECT_RADIUS = 1;
+const QUALITY_SETTINGS = GTAO_QUALITY_PROFILES[GTAO_QUALITY_TYPE.Low];
 
 // this is our own thickness heuristic that relies on sooner discarding samples behind the center
 const GTAO_DEFAULT_THIN_OCCLUDER_COMPENSATION = 0.0;
@@ -162,7 +121,11 @@ fn main(
     const pixelTooCloseThreshold  = 1.3;      // if the offset is under approx pixel size (pixelTooCloseThreshold), push it out to the minimum distance
 
     // approx viewspace pixel size at pixCoord; approximation of NDCToViewspace( normalizedScreenPos.xy + consts.ViewportPixelSize.xy, pixCenterPos.z ).xy - pixCenterPos.xy;
-    let NDCToViewMul_x_PixelSize = camera.device_depth_to_view_space.w * ViewportPixelSize.x;
+    // device_depth_to_view_space.z = 1/a = aspect * tan(fovY/2) = tan(fovX/2), pairs with horizontal pixel size.
+    // factor of 2 converts a single uv-step (= 1 pixel) into the matching ndc-step (range 2 wide).
+    // This read .w — tan(fovY/2) — with no factor of 2, i.e. 2*aspect too small, 3.56x at 16:9, which
+    // put every AO sample that much further out than the effect radius asked for.
+    let NDCToViewMul_x_PixelSize = 2.0 * camera.device_depth_to_view_space.z * ViewportPixelSize.x;
     let pixelDirRBViewspaceSizeAtCenterZ  = viewspaceZ * NDCToViewMul_x_PixelSize;
 
     let screenspaceRadius = abs( ${GTAO_EFFECT_RADIUS} / pixelDirRBViewspaceSizeAtCenterZ);
@@ -325,9 +288,6 @@ fn main(
                         
         }
         
-        // I can't figure out the slight overdarkening on high slopes, so I'm adding this fudge - in the training set, 0.05 is close (PSNR 21.34) to disabled (PSNR 21.45)
-        projectedNormalVecLength = mix( projectedNormalVecLength, 1, 0.05 );
-            
         // line ~27, unrolled
         let h0 = -fast_acos(horizonCos1);
         let h1 = fast_acos(horizonCos0);
@@ -337,11 +297,19 @@ fn main(
         
         let iarc0 = ( fma( h0 , norm_sin2, norm_cos ) - cos( fma( 2.0, h0, - n)) ) * 0.25;
         let iarc1 = ( fma( h1 , norm_sin2, norm_cos ) - cos( fma( 2.0, h1, - n)) ) * 0.25;
+
+        // Slight overdarkening on high slopes is compensated by tilting projected length toward 1.
+        // In the training set, 0.05 is close (PSNR 21.34) to disabled (PSNR 21.45).
+        // Scoped to the visibility branch so bent normals keep their unfudged slice weighting — this
+        // used to assign back into projectedNormalVecLength, so the bent-normal accumulation below got
+        // the fudged weight too.
+        let visibilityProjLength = mix( projectedNormalVecLength, 1, 0.05 );
         
-        let localVisibility = projectedNormalVecLength * ( iarc0 + iarc1 );
+        let localVisibility = visibilityProjLength * ( iarc0 + iarc1 );
         
         visibility += localVisibility;
         
+        // unfudged, like the bent normal below: the fudge corrects the visibility integral only
         sliceLighting *= projectedNormalVecLength;
         
         lighting += sliceLighting;

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

@@ -41,14 +41,17 @@ export class MotionBlur {
      * @param {number} args.velocity     FrameGraph handle, rg16float pixel-space velocity
      * @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
+     *   produced at the internal render resolution. Defaults to `resolution`.
      * @returns {number} FrameGraph handle to the motion-blurred colour
      */
-    render({ graph, input_color, velocity, depth, resolution }: {
+    render({ graph, input_color, velocity, depth, resolution, velocity_resolution }: {
         graph: FrameGraph;
         input_color: number;
         velocity: number;
         depth: number;
         resolution: number[];
+        velocity_resolution?: number[];
     }): number;
 }
 export type FrameGraph = import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;

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

@@ -1 +1 @@
-{"version":3,"file":"MotionBlur.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/motion_blur/MotionBlur.js"],"names":[],"mappings":"AAEA;;GAEG;AAEH;;;;;;;;;;;;GAYG;AACH;IACI;;;;;;;;;OASG;IACH,UAFU,MAAM,CAED;IAEf;;;;;;;;;;;;;;;;OAgBG;IACH;QAP4B,KAAK,EAAtB,UAAU;QACG,WAAW,EAAxB,MAAM;QACO,QAAQ,EAArB,MAAM;QACO,KAAK,EAAlB,MAAM;QACS,UAAU,EAAzB,MAAM,EAAE;QACN,MAAM,CAWlB;CACJ;yBAxDY,OAAO,8DAA8D,EAAE,UAAU"}
+{"version":3,"file":"MotionBlur.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/motion_blur/MotionBlur.js"],"names":[],"mappings":"AAEA;;GAEG;AAEH;;;;;;;;;;;;GAYG;AACH;IACI;;;;;;;;;OASG;IACH,UAFU,MAAM,CAED;IAEf;;;;;;;;;;;;;;;;;;OAkBG;IACH;QAT4B,KAAK,EAAtB,UAAU;QACG,WAAW,EAAxB,MAAM;QACO,QAAQ,EAArB,MAAM;QACO,KAAK,EAAlB,MAAM;QACS,UAAU,EAAzB,MAAM,EAAE;QACQ,mBAAmB,GAAnC,MAAM,EAAE;QAEN,MAAM,CAYlB;CACJ;yBA3DY,OAAO,8DAA8D,EAAE,UAAU"}

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

@@ -45,15 +45,18 @@ export class MotionBlur {
      * @param {number} args.velocity     FrameGraph handle, rg16float pixel-space velocity
      * @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
+     *   produced at the internal render resolution. Defaults to `resolution`.
      * @returns {number} FrameGraph handle to the motion-blurred colour
      */
-    render({ graph, input_color, velocity, depth, resolution }) {
+    render({ graph, input_color, velocity, depth, resolution, velocity_resolution }) {
         return graph_postprocess_motion_blur({
             graph,
             input_color,
             velocity,
             depth,
             resolution,
+            velocity_resolution,
             strength: this.strength,
         });
     }

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

@@ -0,0 +1,18 @@
+/**
+ * Moving between the two grids the reconstruction pass straddles.
+ *
+ * Velocity and depth are produced at the INTERNAL render resolution; the reconstruction runs one
+ * thread per OUTPUT pixel, on colour that TAA has already upscaled. The pass used to treat the two
+ * as one grid: it loaded velocity and depth at the output pixel's own coordinate, stepped its taps
+ * by a velocity measured in render pixels, and took its tile from an output-resolution tile grid.
+ * At a 0.5 internal scale on a 1920x1080 output that meant the right and bottom halves of the screen
+ * indexed tiles nothing had written — so those pixels short-circuited and got no blur at all — while
+ * in the covered quadrant a trail that should have been 80 output pixels long was 40, and the
+ * velocity and depth for output pixel (300, 200) were read off render texel (300, 200), a different
+ * surface.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_motion_blur_resolution: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_motion_blur_resolution.d.ts.map

package/src/shade/renderer/postprocess/motion_blur/chunk_motion_blur_resolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_motion_blur_resolution.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/motion_blur/chunk_motion_blur_resolution.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,2CAFU,SAAS,CA2BhB;0BA1CuB,oCAAoC"}

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

@@ -0,0 +1,43 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * Moving between the two grids the reconstruction pass straddles.
+ *
+ * Velocity and depth are produced at the INTERNAL render resolution; the reconstruction runs one
+ * thread per OUTPUT pixel, on colour that TAA has already upscaled. The pass used to treat the two
+ * as one grid: it loaded velocity and depth at the output pixel's own coordinate, stepped its taps
+ * by a velocity measured in render pixels, and took its tile from an output-resolution tile grid.
+ * At a 0.5 internal scale on a 1920x1080 output that meant the right and bottom halves of the screen
+ * indexed tiles nothing had written — so those pixels short-circuited and got no blur at all — while
+ * in the covered quadrant a trail that should have been 80 output pixels long was 40, and the
+ * velocity and depth for output pixel (300, 200) were read off render texel (300, 200), a different
+ * surface.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_motion_blur_resolution = CodeChunk.from(
+    //language=WGSL
+    `
+/** Where an output-space pixel sits in the velocity/depth grid. */
+fn motion_blur_velocity_texel(
+    pixel: vec2<f32>,
+    color_dimensions: vec2<f32>,
+    velocity_dimensions: vec2<f32>
+) -> vec2<i32> {
+    let scaled = pixel * velocity_dimensions / color_dimensions;
+
+    return min(
+        vec2<i32>(scaled),
+        vec2<i32>(velocity_dimensions) - vec2<i32>(1, 1)
+    );
+}
+
+/** A velocity measured in render pixels, as a displacement in output pixels. */
+fn motion_blur_velocity_to_output(
+    velocity: vec2<f32>,
+    color_dimensions: vec2<f32>,
+    velocity_dimensions: vec2<f32>
+) -> vec2<f32> {
+    return velocity * color_dimensions / velocity_dimensions;
+}
+`);

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

@@ -34,15 +34,19 @@
  * @param {number} args.velocity       FrameGraph handle, rg16float pixel-space velocity
  * @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
+ *   produced at the INTERNAL render resolution and are not the same grid as `resolution` whenever
+ *   anything is being upscaled. Defaults to `resolution`.
  * @param {number} [args.strength]     Velocity scale, default 1.0 (physical)
  * @returns {number} FrameGraph handle to the motion-blurred colour texture (rgba16float)
  */
-export function graph_postprocess_motion_blur({ graph, input_color, velocity, depth, resolution, strength, }: {
+export function graph_postprocess_motion_blur({ graph, input_color, velocity, depth, resolution, velocity_resolution, strength, }: {
     graph: FrameGraph;
     input_color: number;
     velocity: number;
     depth: number;
     resolution: number[];
+    velocity_resolution?: number[];
     strength?: number;
 }): number;
 //# sourceMappingURL=graph_postprocess_motion_blur.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"graph_postprocess_motion_blur.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/motion_blur/graph_postprocess_motion_blur.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH;IAR4B,KAAK;IACT,WAAW,EAAxB,MAAM;IACO,QAAQ,EAArB,MAAM;IACO,KAAK,EAAlB,MAAM;IACS,UAAU,EAAzB,MAAM,EAAE;IACM,QAAQ,GAAtB,MAAM;IACJ,MAAM,CA6DlB"}
+{"version":3,"file":"graph_postprocess_motion_blur.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/motion_blur/graph_postprocess_motion_blur.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH;IAX4B,KAAK;IACT,WAAW,EAAxB,MAAM;IACO,QAAQ,EAArB,MAAM;IACO,KAAK,EAAlB,MAAM;IACS,UAAU,EAAzB,MAAM,EAAE;IACQ,mBAAmB,GAAnC,MAAM,EAAE;IAGM,QAAQ,GAAtB,MAAM;IACJ,MAAM,CAoElB"}

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

@@ -41,6 +41,9 @@ import { shader_motion_blur_tile_max } from "./shader_motion_blur_tile_max.js";
  * @param {number} args.velocity       FrameGraph handle, rg16float pixel-space velocity
  * @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
+ *   produced at the INTERNAL render resolution and are not the same grid as `resolution` whenever
+ *   anything is being upscaled. Defaults to `resolution`.
  * @param {number} [args.strength]     Velocity scale, default 1.0 (physical)
  * @returns {number} FrameGraph handle to the motion-blurred colour texture (rgba16float)
  */
@@ -50,6 +53,7 @@ export function graph_postprocess_motion_blur({
                                                   velocity,
                                                   depth,
                                                   resolution,
+                                                  velocity_resolution = resolution,
                                                   strength = 1.0,
                                               }) {
     assert.defined(graph, 'graph');
@@ -57,15 +61,21 @@ export function graph_postprocess_motion_blur({
     assert.isNonNegativeInteger(velocity, 'velocity');
     assert.isNonNegativeInteger(depth, 'depth');
     assert.isArrayLike(resolution, 'resolution');
+    assert.isArrayLike(velocity_resolution, 'velocity_resolution');
     assert.isNumber(strength, 'strength');
 
     // Tile-resolution = full / TILE_SIZE, rounded up so the right
     // and bottom edges aren't dropped when the screen isn't an
     // exact multiple of the tile size. The TileMax shader's tail
     // bounds check picks up the slack.
+    // ...of the VELOCITY buffer, which is what TileMax scans. It used to be of the output, so at a
+    // half internal scale the grid was 120x68 tiles over a texture that fills 60x34 of them: every
+    // pixel in the right or bottom half of the screen read a tile nothing had written, its
+    // neighbour-max came back zero, and the reconstruction short-circuited to the input colour. The
+    // effect silently became a quarter-screen one the moment upscaling was on.
     const tile_resolution = [
-        Math.ceil(resolution[0] / MOTION_BLUR_TILE_SIZE),
-        Math.ceil(resolution[1] / MOTION_BLUR_TILE_SIZE),
+        Math.ceil(velocity_resolution[0] / MOTION_BLUR_TILE_SIZE),
+        Math.ceil(velocity_resolution[1] / MOTION_BLUR_TILE_SIZE),
     ];
 
     // ── TileMax ─────────────────────────────────────────────────

package/src/shade/renderer/postprocess/motion_blur/shader_motion_blur_reconstruct.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_motion_blur_reconstruct.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/motion_blur/shader_motion_blur_reconstruct.js"],"names":[],"mappings":"AAwKA;;;;;;;;;;;;GAYG;AACH,yDASG;4BA7LyB,6BAA6B"}
+{"version":3,"file":"shader_motion_blur_reconstruct.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/motion_blur/shader_motion_blur_reconstruct.js"],"names":[],"mappings":"AAmMA;;;;;;;;;;;;GAYG;AACH,yDASG;4BAxNyB,6BAA6B"}

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

@@ -4,6 +4,7 @@ import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourc
 import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
 import { chunk_interleaved_gradient_noise } from "../../shader/chunk/noise/chunk_interleaved_gradient_noise.js";
 import { F32_CONTAINER_STRUCT } from "../../shader/type/F32_CONTAINER_STRUCT.js";
+import { chunk_motion_blur_resolution } from "./chunk_motion_blur_resolution.js";
 import { chunk_motion_blur_weighting } from "./chunk_motion_blur_weighting.js";
 import {
     MOTION_BLUR_HALF_VELOCITY_CUTOFF,
@@ -52,6 +53,14 @@ fn main(
 
     let center_color = textureLoad(tColor, pixel_i, 0);
 
+    // Velocity and depth are produced at the INTERNAL render resolution; this pass runs one thread
+    // per OUTPUT pixel, on colour TAA has already upscaled. The two are different grids the moment
+    // anything is being upscaled, and this pass used to treat them as one.
+    let color_dimensions = vec2<f32>(textureDimensions(tColor));
+    let velocity_dimensions = vec2<f32>(textureDimensions(tVelocity));
+
+    let velocity_texel = motion_blur_velocity_texel(pixel_f, color_dimensions, velocity_dimensions);
+
     // ── NeighborMax lookup ─────────────────────────────────────
     //
     // The tile that contains this pixel has the max-magnitude
@@ -59,8 +68,13 @@ fn main(
     // NeighborMax dilation). We sample along this V_N because it
     // bounds the worst-case blur trail length any nearby moving
     // point could project onto this pixel.
-    let tile_xy = vec2<i32>(pixel_f / TILE_SIZE);
-    let v_neighbor = textureLoad(tNeighborMax, tile_xy, 0).rg * uStrength.value;
+    // the tile grid is over the VELOCITY buffer, so the tile is found there rather than here
+    let tile_xy = vec2<i32>(vec2<f32>(velocity_texel) / TILE_SIZE);
+    let v_neighbor = motion_blur_velocity_to_output(
+        textureLoad(tNeighborMax, tile_xy, 0).rg,
+        color_dimensions,
+        velocity_dimensions
+    ) * uStrength.value;
     let v_neighbor_len = length(v_neighbor);
 
     // Pixels in tiles with effectively no motion short-circuit
@@ -75,9 +89,13 @@ fn main(
     // Scale by uStrength symmetrically with v_neighbor so the
     // per-tap cone/cylinder weights stay in the same ratio
     // regardless of strength.
-    let v_self = textureLoad(tVelocity, pixel_i, 0).rg * uStrength.value;
+    let v_self = motion_blur_velocity_to_output(
+        textureLoad(tVelocity, velocity_texel, 0).rg,
+        color_dimensions,
+        velocity_dimensions
+    ) * uStrength.value;
     let v_self_len = length(v_self);
-    let z_self = textureLoad(tDepth, pixel_i, 0);
+    let z_self = textureLoad(tDepth, velocity_texel, 0);
 
     // Symmetric tap distribution along ±V_N around the centre,
     // jittered by per-pixel interleaved gradient noise to break banding.
@@ -117,9 +135,17 @@ fn main(
             continue;
         }
 
-        let v_tap = textureLoad(tVelocity, sample_pixel_i, 0).rg * uStrength.value;
+        let tap_velocity_texel = motion_blur_velocity_texel(
+            sample_pixel_f, color_dimensions, velocity_dimensions
+        );
+
+        let v_tap = motion_blur_velocity_to_output(
+            textureLoad(tVelocity, tap_velocity_texel, 0).rg,
+            color_dimensions,
+            velocity_dimensions
+        ) * uStrength.value;
         let v_tap_len = length(v_tap);
-        let z_tap = textureLoad(tDepth, sample_pixel_i, 0);
+        let z_tap = textureLoad(tDepth, tap_velocity_texel, 0);
         let c_tap = textureLoad(tColor, sample_pixel_i, 0);
 
         // Distance from centre pixel to this tap, in pixels.
@@ -162,6 +188,7 @@ fn main(
 }
     `, [
         chunk_motion_blur_weighting,
+        chunk_motion_blur_resolution,
         chunk_interleaved_gradient_noise,
     ]
 );

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

@@ -53,22 +53,21 @@ export class NSS {
      * @returns {number}
      */
     static recommended_jitter_sequence_size(upscale_ratio: number): number;
-    static "__#180@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
+    static "__#185@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
     /**
      * @param {GraphicsContext} graphics
      */
     constructor(graphics: GraphicsContext);
     /**
-     * Sub-pixel jitter offset applied to the current frame's projection,
-     * in render-resolution pixels, range [-0.5, 0.5].
-     * @type {number[]}
+     * Offset for the current frame, in render-resolution pixels.
+     * @returns {number[]}
      */
-    Jitter: number[];
+    get Jitter(): number[];
     /**
      * Frame-to-frame delta of {@link Jitter}.
-     * @type {number[]}
+     * @returns {number[]}
      */
-    JitterDelta: number[];
+    get JitterDelta(): number[];
     /**
      * Discard history on the next frame. Defaults to true so the very
      * first frame after construction is treated as a clean slate
@@ -157,9 +156,18 @@ export class NSS {
      * Release GPU resources owned by this instance.
      */
     destroy(): void;
+    /**
+     * @param {number} size
+     */
     set jitter_sequence_size(size: number);
+    /**
+     * @returns {number}
+     */
     get jitter_sequence_size(): number;
-    set frame_index(i: any);
+    /**
+     * @param {number} i
+     */
+    set frame_index(i: number);
     set frame_count(v: number);
     get frame_count(): number;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"NSS.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/nss/NSS.js"],"names":[],"mappings":"AAgCA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH;IAgaI;;;;;;OAMG;IACH,uDAHW,MAAM,GACJ,MAAM,CAKlB;IA2CD,uGAQC;IAlSD;;OAEG;IACH,sBAFW,eAAe,EA0CzB;IApOD;;;;OAIG;IACH,QAFU,MAAM,EAAE,CAEF;IAEhB;;;OAGG;IACH,aAFU,MAAM,EAAE,CAEG;IAErB;;;;;OAKG;IACH,eAFU,OAAO,CAEI;IAErB;;;;;;;;OAQG;IACH,mBAFU,MAAM,CAEQ;IAExB;;;;;;;OAOG;IACH,gBAFU,MAAM,CAEM;IAEtB;;;;;OAKG;IACH,YAFU,MAAM,CAED;IAEf;;;;;;;;;;;OAWG;IACH,mBAFU,MAAM,CAEQ;IAExB;;;;;;OAMG;IACH,gBAFU,MAAM,CAEK;IAErB;;;;;;OAMG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;;;;;;OASG;IACH,eAFU,MAAM,CAEI;IACpB,wCAAwC;IACxC,eAD8B,MAAM,CAChB;IAyKpB;;;;;OAKG;IACH,+BAyHC;IAED,wCAAwC;IACxC,0BAEC;IArKD;;OAEG;IACH,gBA4BC;IAkJD,uCAIC;IACD,mCAAiE;IAcjE,wBASC;IA4CD,2BAAkF;IAClF,0BAA+C;IAE/C;;;;;;;;;;;;;;;;;;OAkBG;IACH;QAf4B,KAAK,EAAtB,UAAU;QACG,qBAAqB,EAAlC,MAAM;QACO,qBAAqB,EAAlC,MAAM;QACO,gBAAgB,EAA7B,MAAM;QACO,+BAA+B,EAA5C,MAAM;QAKO,qBAAqB,EAAlC,MAAM;QACO,cAAc,EAA3B,MAAM;QACS,iBAAiB,EAAhC,MAAM,EAAE;QACO,iBAAiB,EAAhC,MAAM,EAAE;QACN,MAAM,CA0NlB;;CACJ;yBA9vBY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,0BAA0B,EAAE,eAAe;2BATpC,iBAAiB;0CAtBF,oDAAoD"}
+{"version":3,"file":"NSS.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/nss/NSS.js"],"names":[],"mappings":"AAgCA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH;IAsaI;;;;;;OAMG;IACH,uDAHW,MAAM,GACJ,MAAM,CAKlB;IAuCD,uGAQC;IAzRD;;OAEG;IACH,sBAFW,eAAe,EAwCzB;IAhOD;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;;;;OAKG;IACH,eAFU,OAAO,CAEI;IAErB;;;;;;;;OAQG;IACH,mBAFU,MAAM,CAEQ;IAExB;;;;;;;OAOG;IACH,gBAFU,MAAM,CAEM;IAEtB;;;;;OAKG;IACH,YAFU,MAAM,CAED;IAEf;;;;;;;;;;;OAWG;IACH,mBAFU,MAAM,CAEQ;IAExB;;;;;;OAMG;IACH,gBAFU,MAAM,CAEK;IAErB;;;;;;OAMG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;;;;;;OASG;IACH,eAFU,MAAM,CAEI;IACpB,wCAAwC;IACxC,eAD8B,MAAM,CAChB;IAkKpB;;;;;OAKG;IACH,+BAyHC;IAED,wCAAwC;IACxC,0BAEC;IArKD;;OAEG;IACH,gBA4BC;IAwID;;OAEG;IACH,uCAEC;IAED;;OAEG;IACH,mCAEC;IAcD;;OAEG;IACH,2BAEC;IA4CD,2BAAkF;IAClF,0BAA+C;IAE/C;;;;;;;;;;;;;;;;;;OAkBG;IACH;QAf4B,KAAK,EAAtB,UAAU;QACG,qBAAqB,EAAlC,MAAM;QACO,qBAAqB,EAAlC,MAAM;QACO,gBAAgB,EAA7B,MAAM;QACO,+BAA+B,EAA5C,MAAM;QAKO,qBAAqB,EAAlC,MAAM;QACO,cAAc,EAA3B,MAAM;QACS,iBAAiB,EAAhC,MAAM,EAAE;QACO,iBAAiB,EAAhC,MAAM,EAAE;QACN,MAAM,CA0NlB;;CACJ;yBAhwBY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,0BAA0B,EAAE,eAAe;2BATpC,iBAAiB;0CAvBF,oDAAoD"}