@woosh/meep-engine 3.67.0 → 3.68.0

package/src/shade/renderer/light/GPULightCollection.js

@@ -1,7 +1,10 @@
 import { assert } from "../../../core/assert.js";
 import { gpu_texture_format_info } from "../../descriptor/texture/format/gpu_texture_format_info.js";
+import { TextureViewDescriptor } from "../../descriptor/texture/TextureViewDescriptor.js";
 import { isImageBitmap } from "../../../core/dom/isImageBitmap.js";
 import { ShadeGPUCommandContext } from "../../device/ShadeGPUCommandContext.js";
+import { create_atmosphere_sun_state, resolve_atmosphere_sun } from "../atmosphere/resolve_atmosphere_sun.js";
+import { SKY_IRRADIANCE_LUT_RESOLUTION, shader_sky_irradiance_lut } from "../atmosphere/shader_sky_irradiance_lut.js";
 import { GPUDatabase } from "../buffer/table/GPUDatabase.js";
 import { GPUSceneShadowmapContext } from "../shadow/map/GPUSceneShadowmapContext.js";
 import { GPUTextureContext } from "../texture/GPUTextureContext.js";
@@ -50,15 +53,23 @@ import {
  */
 const MAX_DIRECTIONAL_LIGHTS = 32;
 
+const MIP_0_VIEW_DESCRIPTOR = TextureViewDescriptor.from({
+    baseMipLevel: 0,
+    mipLevelCount: 1,
+});
+
+const ZERO_ENVIRONMENT_SH = new Float32Array(ENVIRONMENT_SH_TYPE.size / 4);
+
 export class GPULightCollection {
 
     /**
      * Offer the pipelines a scene's lights are updated with — the environment map's filtering and
-     * projection, and the pose refresh — see {@link PipelineEnquiry}.
+     * projection, procedural sky mip-0 synthesis, and the pose refresh — see {@link PipelineEnquiry}.
      *
      * @param {PipelineEnquiry} enquiry
      */
     static enquirePipelines(enquiry) {
+        enquiry.render.push(shader_sky_irradiance_lut.pipeline);
         enquire_filter_environment_map_pipelines(enquiry);
         enquiry.compute.push(shader_project_environment_sh.pipeline);
         enquiry.compute.push(shader_project_far_field_irradiance_sh.pipeline);
@@ -66,6 +77,11 @@ export class GPULightCollection {
     }
 
 
+    /**
+     * @type {GPUSceneContext}
+     */
+    #scene_ctx;
+
     /**
      * @type {LightCollection}
      */
@@ -178,10 +194,39 @@ export class GPULightCollection {
     #environment;
 
     /**
-     * @type {ShadeTexture}
+     * @type {ShadeTexture|undefined}
      */
     #environment_source;
 
+    /**
+     * Active backing mode for {@link #environment}: `"black"` (`1×1` zeroed fallback),
+     * `"texture"` (authored `ShadeTexture` from `lights.environment`), or `"atmosphere"`
+     * (procedural Hillaire octahedral sky driven by `scene.atmosphere`).
+     *
+     * @type {"black" | "texture" | "atmosphere"}
+     */
+    #environment_mode = "black";
+
+    /**
+     * Reusable per-update sun descriptor for procedural sky synthesis.
+     */
+    #atmosphere_sun_state = create_atmosphere_sun_state();
+
+    /**
+     * Reusable immediate settings payload for {@link shader_sky_irradiance_lut}.
+     */
+    #sky_irradiance_settings = {
+        sun_direction: this.#atmosphere_sun_state.sun_direction,
+        reference_altitude: 0,
+        sun_irradiance: this.#atmosphere_sun_state.sun_irradiance,
+        resolution: SKY_IRRADIANCE_LUT_RESOLUTION,
+    };
+
+    #committed_atmosphere_version = -1;
+    #committed_reference_altitude = NaN;
+    #committed_sun_direction = new Float32Array([NaN, NaN, NaN]);
+    #committed_sun_irradiance = new Float32Array([NaN, NaN, NaN]);
+
     /**
      * The environment's radiance as RGB SH2, projected from {@link #environment} whenever it changes;
      * see {@link shader_project_environment_sh}.
@@ -258,6 +303,7 @@ export class GPULightCollection {
         const device = graphics.device;
 
         this.#device = device;
+        this.#scene_ctx = scene_ctx;
         this.#source = scene.lights;
 
         this.#source.onRemoved.add(this.#removed, this);
@@ -268,6 +314,7 @@ export class GPULightCollection {
         this.#environment.descriptor.usage |=
             GPUTextureUsage.COPY_DST // so we can write to it
             | GPUTextureUsage.STORAGE_BINDING // so we can convolve it in compute shader
+            | GPUTextureUsage.RENDER_ATTACHMENT // for procedural sky mip-0 synthesis and ImageBitmap uploads
         ;
 
         // zeroed on creation, which is what an absent environment projects to
@@ -298,115 +345,201 @@ export class GPULightCollection {
      */
     #update_environment(ctx) {
         const source_env = this.#source.environment;
+        const gpu_ctx = this.#environment;
+
+        if (source_env !== undefined) {
+            if (this.#environment_mode === "texture" && this.#environment_source === source_env) {
+                return;
+            }
+
+            const source_image = source_env.image;
+
+            /*
+             An environment map comes with a one-texel octahedral skirt: the octahedral square in the
+             interior, each texel of the outer ring a copy of the one the fold puts beside it. The renderer
+             filters it in hardware through that skirt and skirts the levels it filters itself; an
+             unskirted map is the caller's error, and it would read as seams along the octahedron's
+             edges. Every level the roughness mapping reaches needs an interior, so 3 texels at the last.
+             `resample_equirectangular_to_octahedral` and the offline converter write the skirt by default.
+
+             Checked where the pixels are on hand; an ImageBitmap's are not.
+            */
+            assert.greaterThanOrEqual(
+                source_image.width >> (SPHERE_PROBE_MIPMAP_LEVELS - 1),
+                3,
+                'environment map too small for its last filtered level'
+            );
+
+            assert.equal(source_image.width, source_image.height, 'an octahedral environment map is square');
+
+            const source_texels = source_image.source;
+
+            if (source_texels?.isSampler2D === true) {
+                assert.ok(
+                    octahedral_skirt_matches(source_texels.data, source_texels.itemSize, source_texels.width),
+                    'environment map has no octahedral skirt (see sampler2d_octahedral_skirt_fill)'
+                );
+            } else if (
+                source_texels?.isShadeTexelData === true
+                && source_texels.levels[0] !== undefined
+                && gpu_texture_format_info(source_texels.format).block_width === 1
+            ) {
+                assert.ok(
+                    octahedral_skirt_matches(
+                        source_texels.levels[0],
+                        gpu_texture_format_info(source_texels.format).bytes_per_block,
+                        source_texels.width
+                    ),
+                    'environment map has no octahedral skirt (see sampler2d_octahedral_skirt_fill)'
+                );
+            }
+
+            this.#environment_mode = "texture";
+            this.#environment_source = source_env;
+
+            /*
+             Assign descriptor.size directly rather than calling gpu_ctx.resize(): resize() immediately
+             re-allocates when the context is already in TEXTURE_STATE_ALLOCATED, which would call
+             createTexture with the new size and the previous map's mipLevelCount (failing WebGPU
+             validation whenever the new map is smaller) before allocate() below replaces it again.
+            */
+            gpu_ctx.descriptor.size = [source_image.width, source_image.height, 1];
+            /*
+             The environment map is octahedral 2D and this context keeps the default dimension while
+             `size` above sets two spatial axes. Asked of the descriptor rather than assumed, so the
+             count follows if that ever stops being true.
+            */
+            const gpu_size = gpu_ctx.descriptor.size;
+
+            gpu_ctx.descriptor.mipLevelCount = texture_mip_level_count(
+                gpu_size.width, gpu_size.height, gpu_size.depthOrArrayLayers, gpu_ctx.descriptor.dimension
+            );
+
+            if (isImageBitmap(source_image.source)) {
+                // need RENDER_ATTACHMENT to use GPUQueue.copyExternalImageToTexture API
+                gpu_ctx.descriptor.usage |= GPUTextureUsage.RENDER_ATTACHMENT;
+            }
+
+            gpu_ctx.allocate();
+            gpu_ctx.incrementVersion();
+
+            texture_write_to_gpu(source_image, gpu_ctx.gpu_texture, this.#device.queue, source_image.level_count);
+
+            // convolve
+            const cmd = ShadeGPUCommandContext.create(ctx);
+
+            encode_filter_environment_map(gpu_ctx, cmd);
 
-        if (this.#environment_source === source_env) {
-            // assume up-to-date
+            // after the prefilter, whose roughest levels are what it reads
+            shader_project_environment_sh.dispatch({
+                encoder: cmd,
+                group_count_x: 1,
+                bindings: {
+                    tEnvironment: gpu_ctx.obtainView(),
+                    output: this.#environment_sh,
+                },
+            });
+
+            this.#far_field_sh_dirty = true;
+
+            cmd.finish();
             return;
         }
 
-        this.#environment_source = source_env;
-
-        const gpu_ctx = this.#environment;
+        const scene = this.#scene_ctx.scene;
+        const atmosphere = scene.atmosphere;
 
         /*
-         No environment is a supported state, not a mistake: LightCollection's setter takes
-         undefined — its assert is conditional on the value being defined — and serialize_scene
-         writes the absence of one. Clearing a map that had been set used to walk straight into
-         source_env.image and take the frame down from inside the renderer's per-frame update.
-
-         Every consumer binds this texture unconditionally — the path tracer, the probe atlas, the
-         lightmap baker, the transparent passes all call obtainView() on it without asking whether
-         there is an environment — so it has to keep existing. A freshly allocated 1x1 at one mip
-         is zeroed, which is the same black IBL they read before an environment is ever assigned.
+         No authored environment and procedural atmosphere disabled: keep a valid 1x1 zeroed texture
+         and zeroed SH buffer because downstream consumers (path tracer, probe atlas, lightmap baker,
+         transparent passes) bind `environment` unconditionally via `obtainView()`.
         */
-        if (source_env === undefined) {
+        if (!atmosphere.enabled) {
+            if (this.#environment_mode === "black") {
+                return;
+            }
+
+            this.#environment_mode = "black";
+            this.#environment_source = undefined;
+
             gpu_ctx.descriptor.mipLevelCount = 1;
             gpu_ctx.descriptor.size = [1, 1, 1];
 
             gpu_ctx.allocate();
+            gpu_ctx.incrementVersion();
 
             // what a black environment projects to; nothing to run the projection over
-            this.#device.queue.writeBuffer(this.#environment_sh, 0, new Float32Array(this.#environment_sh.size / 4));
+            this.#device.queue.writeBuffer(this.#environment_sh, 0, ZERO_ENVIRONMENT_SH);
             this.#far_field_sh_dirty = true;
 
             return;
         }
 
-        const source_image = source_env.image;
-
-        /*
-         An environment map comes with a one-texel octahedral skirt: the octahedral square in the
-         interior, each texel of the outer ring a copy of the one the fold puts beside it. The renderer
-         filters it in hardware through that skirt and skirts the levels it filters itself; an
-         unskirted map is the caller's error, and it would read as seams along the octahedron's
-         edges. Every level the roughness mapping reaches needs an interior, so 3 texels at the last.
-         `resample_equirectangular_to_octahedral` and the offline converter write the skirt by default.
-
-         Checked where the pixels are on hand; an ImageBitmap's are not.
-        */
-        assert.greaterThanOrEqual(
-            source_image.width >> (SPHERE_PROBE_MIPMAP_LEVELS - 1),
-            3,
-            'environment map too small for its last filtered level'
-        );
-
-        assert.equal(source_image.width, source_image.height, 'an octahedral environment map is square');
+        const sun = resolve_atmosphere_sun(scene, this.#atmosphere_sun_state);
+
+        if (
+            this.#environment_mode === "atmosphere"
+            && this.#committed_atmosphere_version === atmosphere.version
+            && this.#committed_reference_altitude === atmosphere.reference_altitude
+            && this.#committed_sun_direction[0] === sun.sun_direction[0]
+            && this.#committed_sun_direction[1] === sun.sun_direction[1]
+            && this.#committed_sun_direction[2] === sun.sun_direction[2]
+            && this.#committed_sun_irradiance[0] === sun.sun_irradiance[0]
+            && this.#committed_sun_irradiance[1] === sun.sun_irradiance[1]
+            && this.#committed_sun_irradiance[2] === sun.sun_irradiance[2]
+        ) {
+            return;
+        }
 
-        const source_texels = source_image.source;
+        const sky = this.#scene_ctx.sky;
+        sky.update();
 
-        if (source_texels?.isSampler2D === true) {
-            assert.ok(
-                octahedral_skirt_matches(source_texels.data, source_texels.itemSize, source_texels.width),
-                'environment map has no octahedral skirt (see sampler2d_octahedral_skirt_fill)'
-            );
-        } else if (
-            source_texels?.isShadeTexelData === true
-            && source_texels.levels[0] !== undefined
-            && gpu_texture_format_info(source_texels.format).block_width === 1
+        if (
+            this.#environment_mode !== "atmosphere"
+            || gpu_ctx.width !== SKY_IRRADIANCE_LUT_RESOLUTION
+            || gpu_ctx.height !== SKY_IRRADIANCE_LUT_RESOLUTION
         ) {
-            assert.ok(
-                octahedral_skirt_matches(
-                    source_texels.levels[0],
-                    gpu_texture_format_info(source_texels.format).bytes_per_block,
-                    source_texels.width
-                ),
-                'environment map has no octahedral skirt (see sampler2d_octahedral_skirt_fill)'
+            gpu_ctx.descriptor.size = [SKY_IRRADIANCE_LUT_RESOLUTION, SKY_IRRADIANCE_LUT_RESOLUTION, 1];
+            const gpu_size = gpu_ctx.descriptor.size;
+            gpu_ctx.descriptor.mipLevelCount = texture_mip_level_count(
+                gpu_size.width, gpu_size.height, gpu_size.depthOrArrayLayers, gpu_ctx.descriptor.dimension
             );
+            gpu_ctx.allocate();
         }
 
-        /*
-         Assign descriptor.size directly rather than calling gpu_ctx.resize(): resize() immediately
-         re-allocates when the context is already in TEXTURE_STATE_ALLOCATED, which would call
-         createTexture with the new size and the previous map's mipLevelCount (failing WebGPU
-         validation whenever the new map is smaller) before allocate() below replaces it again.
-        */
-        gpu_ctx.descriptor.size = [source_image.width, source_image.height, 1];
-        /*
-         The environment map is equirectangular and this context is built 2D a few lines up — the
-         descriptor keeps the default dimension and `size` above only sets two spatial axes. Asked of
-         the descriptor rather than assumed, so the count follows if that ever stops being true.
-        */
-        const gpu_size = gpu_ctx.descriptor.size;
+        gpu_ctx.incrementVersion();
 
-        gpu_ctx.descriptor.mipLevelCount = texture_mip_level_count(
-            gpu_size.width, gpu_size.height, gpu_size.depthOrArrayLayers, gpu_ctx.descriptor.dimension
-        );
+        this.#environment_mode = "atmosphere";
+        this.#environment_source = undefined;
+        this.#committed_atmosphere_version = atmosphere.version;
+        this.#committed_reference_altitude = atmosphere.reference_altitude;
+        this.#committed_sun_direction.set(sun.sun_direction);
+        this.#committed_sun_irradiance.set(sun.sun_irradiance);
 
-        if (isImageBitmap(source_image.source)) {
-            // need RENDER_ATTACHMENT to use GPUQueue.copyExternalImageToTexture API
-            gpu_ctx.descriptor.usage |= GPUTextureUsage.RENDER_ATTACHMENT;
-        }
-
-        gpu_ctx.allocate();
+        this.#sky_irradiance_settings.reference_altitude = atmosphere.reference_altitude;
 
-        texture_write_to_gpu(source_image, gpu_ctx.gpu_texture, this.#device.queue, source_image.level_count);
+        const cmd = ShadeGPUCommandContext.create(ctx, "GPULightCollection/sky_environment");
 
-        // convolve
-        const cmd = ShadeGPUCommandContext.create(ctx);
+        shader_sky_irradiance_lut.draw({
+            encoder: cmd,
+            bindings: {
+                settings: this.#sky_irradiance_settings,
+                atmosphere: sky.parameters_buffer.buffer,
+                tSkyLutTransmittance: sky.lut_transmittance.obtainView(),
+                tSkyLutMultiscatter: sky.lut_multiple_scattering.obtainView(),
+            },
+            colorAttachments: [
+                {
+                    view: gpu_ctx.obtainView(MIP_0_VIEW_DESCRIPTOR),
+                    loadOp: "clear",
+                    storeOp: "store",
+                    clearValue: [0, 0, 0, 1],
+                }
+            ],
+        });
 
         encode_filter_environment_map(gpu_ctx, cmd);
 
-        // after the prefilter, whose roughest levels are what it reads
         shader_project_environment_sh.dispatch({
             encoder: cmd,
             group_count_x: 1,

package/src/shade/renderer/{atmosphere → light/environment}/chunk_sample_environment_color.d.ts

@@ -2,9 +2,8 @@
  * The environment map's level 0 in a direction: one hardware bilinear tap through the octahedral
  * skirt (see `texture_octahedral_skirt_uv`).
  *
- * see {@link shader_sky_irradiance_lut}
  * @type {CodeChunk}
  */
 export const chunk_sample_environment_color: CodeChunk;
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_sample_environment_color.d.ts.map

package/src/shade/renderer/light/environment/chunk_sample_environment_color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_sample_environment_color.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/chunk_sample_environment_color.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,6CAFU,SAAS,CAcjB;0BApBwB,oCAAoC"}

package/src/shade/renderer/{atmosphere → light/environment}/chunk_sample_environment_color.js

@@ -1,12 +1,11 @@
-import { chunk_uv_octahedral_unit_encode } from "../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_encode.js";
-import { chunk_texture_octahedral_skirt_uv } from "../shader/chunk/texture/octahedral/chunk_texture_octahedral_skirt_uv.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { chunk_uv_octahedral_unit_encode } from "../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_encode.js";
+import { chunk_texture_octahedral_skirt_uv } from "../../shader/chunk/texture/octahedral/chunk_texture_octahedral_skirt_uv.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 
 /**
  * The environment map's level 0 in a direction: one hardware bilinear tap through the octahedral
  * skirt (see `texture_octahedral_skirt_uv`).
  *
- * see {@link shader_sky_irradiance_lut}
  * @type {CodeChunk}
  */
 export const chunk_sample_environment_color = CodeChunk.from(

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

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

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

@@ -1,6 +1,6 @@
 import { f32, u32, vec3f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
-import { chunk_sample_environment_color } from "../../atmosphere/chunk_sample_environment_color.js";
+import { chunk_sample_environment_color } from "../../light/environment/chunk_sample_environment_color.js";
 import { chunk_scene_database_access } from "../../scene/chunk_scene_database_access.js";
 import { chunk_BRDF_GGX } from "../../shader/chunk/brdf/chunk_BRDF_GGX.js";
 import { chunk_compute_ggx_vndf_pdf } from "../../shader/chunk/brdf/chunk_compute_ggx_pdf.js";

package/src/shade/renderer/postprocess/denoise/debug/graph_pass_debug_reprojection.js

@@ -41,7 +41,7 @@ fn main(
 
     let depth = textureLoad( DepthBuffer, current_coord, 0 ).r;
 
-    let velocity = textureLoad( VelocityBuffer, current_coord, 0 ).rgb;
+    let velocity = textureLoad( VelocityBuffer, current_coord, 0 ).rg;
     let current_coord_f = vec2<f32>(current_coord.xy);
     
     let previous_coord = current_coord_f - velocity.xy;

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';