@woosh/meep-engine 3.39.0 → 3.41.0

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

@@ -1,12 +1,14 @@
-import { vec4f } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { u32, vec2i, vec4f } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { GPUDatabaseDefinition } from "../buffer/table/GPUDatabaseDefinition.js";
 import { SCENE_DATABASE_SPEC } from "../scene/SCENE_DATABASE_SPEC.js";
 import { DIRECTIONAL_LIGHT_STRUCT } from "../shader/chunk/light/DIRECTIONAL_LIGHT_STRUCT.js";
 import { POINT_LIGHT_STRUCT } from "../shader/chunk/light/POINT_LIGHT_STRUCT.js";
 import { SPOT_LIGHT_STRUCT } from "../shader/chunk/light/SPOT_LIGHT_STRUCT.js";
 import { CSM_CASCADE_STRUCT } from "../shadow/map/csm/CSM_CASCADE_STRUCT.js";
-import { CSM_SHADOWMAP_STRUCT } from "../shadow/map/csm/CSM_SHADOWMAP_STRUCT.js";
+import { DIRECTIONAL_SHADOWMAP_STRUCT } from "../shadow/map/DIRECTIONAL_SHADOWMAP_STRUCT.js";
 import { SHADOWMAP_VIEW_METADATA_STRUCT } from "../shadow/map/shader/SHADOWMAP_VIEW_METADATA_STRUCT.js";
+import { VSM_RECORD_STRUCT } from "../shadow/vsm/VSM_RECORD_STRUCT.js";
+import { VSM_SLOT_STRUCT } from "../shadow/vsm/VSM_SLOT_STRUCT.js";
 
 export const LIGHT_DATABASE_SPEC = GPUDatabaseDefinition.from({
     light_point: POINT_LIGHT_STRUCT,
@@ -16,15 +18,71 @@ export const LIGHT_DATABASE_SPEC = GPUDatabaseDefinition.from({
     // shadow metadata, indexed by `light.shadow_id` from the matching light record.
     // Point lights store only the atlas rect — sampling is direction-based and uses no
     // projection. Spot lights store atlas + projection for their one view. Directional lights
-    // store where their cascades are, as a range over `shadow_cascade`.
+    // store where their cascades are, as a range over `shadow_cascade`, or which virtual shadow map
+    // they have, as a link into `shadow_virtual`.
     shadow_point: vec4f,
     shadow_spot: SHADOWMAP_VIEW_METADATA_STRUCT,
-    shadow_directional: CSM_SHADOWMAP_STRUCT,
+    shadow_directional: DIRECTIONAL_SHADOWMAP_STRUCT,
 
     // one row per cascade of a directional shadow map, a map's cascades a run of consecutive rows
     // claimed and released by the shadow context: atlas + projection from the CPU, and what the GPU
     // measured of the casters in front of the cascade, read back to fit the next frame's near plane
     shadow_cascade: CSM_CASCADE_STRUCT,
+
+    // one row per virtual shadow map: its light space, clipmap windows, pool, and the main view it
+    // selects levels for
+    shadow_virtual: VSM_RECORD_STRUCT,
+
+    // a virtual shadow map's clipmap windows, a run per map, one row per level: the corner of the
+    // level's window in its own pages — written by the CPU when the window scrolls
+    shadow_virtual_level: vec2i,
+
+    // a virtual shadow map's page table, a run per map, one page-table entry per cell of every
+    // level's window — written by the CPU as pages are installed, evicted and scrolled away
+    shadow_virtual_page: u32,
+
+    // what each slot of a virtual shadow map's pool holds, a run per map — written by the CPU with
+    // the page table, read by the pass that finds pages under moving casters
+    shadow_virtual_slot: VSM_SLOT_STRUCT,
+});
+
+// A directional light's virtual shadow map. Not owning, for the reason the cascade range is not.
+LIGHT_DATABASE_SPEC.add_link({
+    table: 'shadow_directional',
+    field: 'virtual_map',
+    target_database: LIGHT_DATABASE_SPEC,
+    target_table: 'shadow_virtual',
+    nullable: true,
+    owning: false,
+});
+
+// A virtual shadow map's level, page table and slot rows. The shadow context claims the runs with the
+// map and gives them back when it evicts it.
+LIGHT_DATABASE_SPEC.add_range({
+    table: 'shadow_virtual',
+    first_field: 'first_level',
+    count_field: 'level_count',
+    target_database: LIGHT_DATABASE_SPEC,
+    target_table: 'shadow_virtual_level',
+    owning: false,
+});
+
+LIGHT_DATABASE_SPEC.add_range({
+    table: 'shadow_virtual',
+    first_field: 'first_page',
+    count_field: 'page_count',
+    target_database: LIGHT_DATABASE_SPEC,
+    target_table: 'shadow_virtual_page',
+    owning: false,
+});
+
+LIGHT_DATABASE_SPEC.add_range({
+    table: 'shadow_virtual',
+    first_field: 'first_slot',
+    count_field: 'slot_count',
+    target_database: LIGHT_DATABASE_SPEC,
+    target_table: 'shadow_virtual_slot',
+    owning: false,
 });
 
 // A directional shadow map's cascades. Not owning: the shadow context holds the run for the life of

package/src/shade/renderer/light/environment/rgbe/parse_rgbe.d.ts

@@ -8,7 +8,7 @@
 export function parse_rgbe(buffer: ArrayBuffer, type?: BinaryDataType.Float16 | BinaryDataType.Float32): {
     width: number;
     height: number;
-    data: Float32Array | Uint16Array;
+    data: any;
     header: string;
     gamma: number;
     exposure: number;

package/src/shade/renderer/light/environment/rgbe/parse_rgbe.js

@@ -48,7 +48,7 @@ export function parse_rgbe(
         case BinaryDataType.Float16:
 
             numElements = image_rgba_data.length / 4;
-            const halfArray = new Uint16Array(numElements * 4);
+            const halfArray = new Float16Array(numElements * 4);
 
             for (let j = 0; j < numElements; j++) {
 
@@ -76,4 +76,4 @@ export function parse_rgbe(
         type: type
     };
 
-}
+}

package/src/shade/renderer/light/environment/rgbe/rgbe_byte_to_rgb_half.d.ts

@@ -2,8 +2,8 @@
  *
  * @param {Uint8Array} sourceArray
  * @param {number} sourceOffset
- * @param {Uint16Array} destArray
+ * @param {Float16Array} destArray
  * @param {number} destOffset
  */
-export function rgbe_byte_to_rgb_half(sourceArray: Uint8Array, sourceOffset: number, destArray: Uint16Array, destOffset: number): void;
+export function rgbe_byte_to_rgb_half(sourceArray: Uint8Array, sourceOffset: number, destArray: Float16Array, destOffset: number): void;
 //# sourceMappingURL=rgbe_byte_to_rgb_half.d.ts.map

package/src/shade/renderer/light/environment/rgbe/rgbe_byte_to_rgb_half.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rgbe_byte_to_rgb_half.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/environment/rgbe/rgbe_byte_to_rgb_half.js"],"names":[],"mappings":"AAQA;;;;;;GAMG;AACH,mDALW,UAAU,gBACV,MAAM,aACN,WAAW,cACX,MAAM,QAchB"}
+{"version":3,"file":"rgbe_byte_to_rgb_half.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/environment/rgbe/rgbe_byte_to_rgb_half.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,mDALW,UAAU,gBACV,MAAM,uCAEN,MAAM,QAchB"}

package/src/shade/renderer/light/environment/rgbe/rgbe_byte_to_rgb_half.js

@@ -1,16 +1,8 @@
-import { to_half_float_uint16 } from "../../../../../core/binary/to_half_float_uint16.js";
-
-/**
- * Precomputed for simplicity
- * @type {number}
- */
-const F16_1 = to_half_float_uint16(1);
-
 /**
  *
  * @param {Uint8Array} sourceArray
  * @param {number} sourceOffset
- * @param {Uint16Array} destArray
+ * @param {Float16Array} destArray
  * @param {number} destOffset
  */
 export function rgbe_byte_to_rgb_half(sourceArray, sourceOffset, destArray, destOffset) {
@@ -19,10 +11,10 @@ export function rgbe_byte_to_rgb_half(sourceArray, sourceOffset, destArray, dest
     const scale = Math.pow(2.0, e - 128.0) / 255.0;
 
     // clamping to 65504, the maximum representable value in float16
-    destArray[destOffset + 0] = to_half_float_uint16(Math.min(sourceArray[sourceOffset + 0] * scale, 65504));
-    destArray[destOffset + 1] = to_half_float_uint16(Math.min(sourceArray[sourceOffset + 1] * scale, 65504));
-    destArray[destOffset + 2] = to_half_float_uint16(Math.min(sourceArray[sourceOffset + 2] * scale, 65504));
+    destArray[destOffset + 0] = Math.min(sourceArray[sourceOffset + 0] * scale, 65504);
+    destArray[destOffset + 1] = Math.min(sourceArray[sourceOffset + 1] * scale, 65504);
+    destArray[destOffset + 2] = Math.min(sourceArray[sourceOffset + 2] * scale, 65504);
 
-    destArray[destOffset + 3] = F16_1;
+    destArray[destOffset + 3] = 1;
 
-}
+}

package/src/shade/renderer/light/environment/sh_exponential/chunk_sh_exp_workgroup_sum.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_sh_exp_workgroup_sum.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/environment/sh_exponential/chunk_sh_exp_workgroup_sum.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,oCAFU,MAAM,CAEyB;AAEzC;;;;;;;;;GASG;AACH,yCAFU,SAAS,CA8BhB;0BAjDuB,uCAAuC"}
+{"version":3,"file":"chunk_sh_exp_workgroup_sum.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/environment/sh_exponential/chunk_sh_exp_workgroup_sum.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,oCAFU,MAAM,CAEyB;AAMzC;;;;;;;;;GASG;AACH,yCAFU,SAAS,CA8BhB;0BArDuB,uCAAuC"}

package/src/shade/renderer/light/environment/sh_exponential/chunk_sh_exp_workgroup_sum.js

@@ -10,6 +10,10 @@ import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
  */
 export const SH_EXP_WORKGROUP_SIZE = 256;
 
+
+const MIN_SUBGROUP_SIZE = 4;
+const MAX_PARTIALS_SIZE = Math.ceil(SH_EXP_WORKGROUP_SIZE / MIN_SUBGROUP_SIZE);
+
 /**
  * Sum of a `vec4` over the workgroup, subgroup first: `subgroupAdd`, then one elected lane per
  * subgroup claims a slot — invocation indices need not map to subgroups in contiguous blocks — and
@@ -24,7 +28,7 @@ export const chunk_sh_exp_workgroup_sum = CodeChunk.from(
     //language=WGSL
     `
 var<workgroup> sh_exp_partial_count: atomic<u32>;
-var<workgroup> sh_exp_partials: array<vec4<f32>, ${SH_EXP_WORKGROUP_SIZE}>;
+var<workgroup> sh_exp_partials: array<vec4<f32>, ${MAX_PARTIALS_SIZE}>;
 
 fn sh_exp_workgroup_sum(value: vec4<f32>, local_index: u32) -> vec4<f32> {
     let subgroup_sum = subgroupAdd(value);

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

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

package/src/shade/renderer/medium/ParticipatingMedium.d.ts

@@ -48,6 +48,8 @@ export class ParticipatingMedium {
      * @type {number}
      */
     priority: number;
+    /** Authored coefficients changed; resident consumers can queue a write without polling. */
+    onChanged: Signal;
     /**
      * Bumped whenever something that reaches the GPU changes, so the resident media table knows to
      * repack this medium — the contract {@link ShadeMaterial#version} has. {@link add_lobe} and
@@ -105,4 +107,5 @@ export class ParticipatingMedium {
 export type MediumPhaseFunction = import("./phase/MediumPhaseFunction.js").MediumPhaseFunction;
 export type MediumPhaseLobeRecord = import("./phase/MediumPhaseFunction.js").MediumPhaseLobeRecord;
 export type ShadeMaterial = import("../material/ShadeMaterial.js").ShadeMaterial;
+import Signal from "../../../core/events/signal/Signal.js";
 //# sourceMappingURL=ParticipatingMedium.d.ts.map

package/src/shade/renderer/medium/ParticipatingMedium.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticipatingMedium.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/medium/ParticipatingMedium.js"],"names":[],"mappings":"AAuBA;;GAEG;AACH;IACI;;;OAGG;IACH,wBAHW,MAAM,EAAE,SACR,mBAAmB,EAa7B;IAVG;;;OAGG;IACH,YAFU,MAAM,EAAE,CAEU;IAE5B;;OAEG;IACH,OAFU,mBAAmB,CAEX;CAEzB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH;IACI;;;OAGG;IACH,YAFU,MAAM,EAAE,CAEK;IAEvB;;;;;OAKG;IACH,UAFU,MAAM,CAEH;IAYb;;;;;;;OAOG;IACH,sBAEC;IAED;;;;OAIG;IACH,gCAIC;IAED;;;OAGG;IACH,gDAEC;IAED;;;OAGG;IACH,6BAQC;IAED;;;;;OAKG;IACH,qBAHW,MAAM,EAAE,SACR,mBAAmB,QAe7B;IAED;;OAEG;IACH,oBAIC;IAED;;;;OAIG;IACH,iBAFa;QAAC,UAAU,EAAE,MAAM,EAAE,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,qBAAqB,EAAE,CAAA;KAAC,CA8BxG;IAGL;;;OAGG;IACH,gCAFU,OAAO,CAEkC;;CANlD;kCAjMY,OAAO,gCAAgC,EAAE,mBAAmB;oCAC5D,OAAO,gCAAgC,EAAE,qBAAqB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa"}
+{"version":3,"file":"ParticipatingMedium.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/medium/ParticipatingMedium.js"],"names":[],"mappings":"AAwBA;;GAEG;AACH;IACI;;;OAGG;IACH,wBAHW,MAAM,EAAE,SACR,mBAAmB,EAa7B;IAVG;;;OAGG;IACH,YAFU,MAAM,EAAE,CAEU;IAE5B;;OAEG;IACH,OAFU,mBAAmB,CAEX;CAEzB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH;IACI;;;OAGG;IACH,YAFU,MAAM,EAAE,CAEK;IAEvB;;;;;OAKG;IACH,UAFU,MAAM,CAEH;IAYb,2FAA2F;IAC3F,kBAAyB;IAEzB;;;;;;;OAOG;IACH,sBAEC;IAED;;;;OAIG;IACH,gCAKC;IAED;;;OAGG;IACH,gDAEC;IAED;;;OAGG;IACH,6BAQC;IAED;;;;;OAKG;IACH,qBAHW,MAAM,EAAE,SACR,mBAAmB,QAgB7B;IAED;;OAEG;IACH,oBAKC;IAED;;;;OAIG;IACH,iBAFa;QAAC,UAAU,EAAE,MAAM,EAAE,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,qBAAqB,EAAE,CAAA;KAAC,CA8BxG;IAGL;;;OAGG;IACH,gCAFU,OAAO,CAEkC;;CANlD;kCAvMY,OAAO,gCAAgC,EAAE,mBAAmB;oCAC5D,OAAO,gCAAgC,EAAE,qBAAqB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;mBAN9C,uCAAuC"}

package/src/shade/renderer/medium/ParticipatingMedium.js

@@ -1,4 +1,5 @@
 import { assert } from "../../../core/assert.js";
+import Signal from "../../../core/events/signal/Signal.js";
 import { MEDIUM_PHASE_LOBE_LIMIT } from "./MEDIUM_STRUCT.js";
 
 /**
@@ -86,6 +87,9 @@ export class ParticipatingMedium {
      */
     #version = 0;
 
+    /** Authored coefficients changed; resident consumers can queue a write without polling. */
+    onChanged = new Signal();
+
     /**
      * Bumped whenever something that reaches the GPU changes, so the resident media table knows to
      * repack this medium — the contract {@link ShadeMaterial#version} has. {@link add_lobe} and
@@ -106,6 +110,7 @@ export class ParticipatingMedium {
     set needsUpdate(value) {
         if (value) {
             this.#version++;
+            this.onChanged.dispatch();
         }
     }
 
@@ -150,6 +155,7 @@ export class ParticipatingMedium {
         this.#lobes.push(new ParticipatingMediumLobe(scattering.slice(), phase));
 
         this.#version++;
+        this.onChanged.dispatch();
     }
 
     /**
@@ -159,6 +165,7 @@ export class ParticipatingMedium {
         this.#lobes.length = 0;
 
         this.#version++;
+        this.onChanged.dispatch();
     }
 
     /**

package/src/shade/renderer/object_property/chunk_write_object_property.d.ts

@@ -12,7 +12,9 @@
  * `weight` is the weight `value` has already been multiplied by. Only the
  * Node3D writer wants it, and only for rotation: a rotation channel missing
  * its `w` curve defaults to the identity's 1, which has to be weighted the
- * same way the authored channels were.
+ * same way the authored channels were. `rest_rotation` is the target's
+ * rest rotation from its binding, and the same goes for it: only a Node3D
+ * rotation reads it.
  *
  * Each writer lives in its own CodeChunk and operates on whatever storage
  * buffers the importing shader has bound under the documented names —

package/src/shade/renderer/object_property/chunk_write_object_property.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_write_object_property.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/object_property/chunk_write_object_property.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,0CAFU,SAAS,CA2Bb;0BA1DoB,iCAAiC"}
+{"version":3,"file":"chunk_write_object_property.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/object_property/chunk_write_object_property.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,0CAFU,SAAS,CA4Bb;0BA7DoB,iCAAiC"}

package/src/shade/renderer/object_property/chunk_write_object_property.js

@@ -21,7 +21,9 @@ import { ObjectType } from "./ObjectType.js";
  * `weight` is the weight `value` has already been multiplied by. Only the
  * Node3D writer wants it, and only for rotation: a rotation channel missing
  * its `w` curve defaults to the identity's 1, which has to be weighted the
- * same way the authored channels were.
+ * same way the authored channels were. `rest_rotation` is the target's
+ * rest rotation from its binding, and the same goes for it: only a Node3D
+ * rotation reads it.
  *
  * Each writer lives in its own CodeChunk and operates on whatever storage
  * buffers the importing shader has bound under the documented names —
@@ -40,12 +42,13 @@ fn write_object_property(
     mask: u32,
     value: vec4f,
     weight: f32,
+    rest_rotation: vec4f,
 ) {
     let object_type = instance >> 24u;
 
     switch(object_type){
         case ${ObjectType.Node3D}u: {
-            write_object_property_node3d(instance, property, mask, value, weight);
+            write_object_property_node3d(instance, property, mask, value, weight, rest_rotation);
         }
         case ${ObjectType.Material}u: {
             write_object_property_material(instance, property, mask, value);

package/src/shade/renderer/object_property/chunk_write_object_property_node3d.d.ts

@@ -35,6 +35,10 @@
  * channel has to carry the same weight as the channels that were
  * authored; nothing else here does.
  *
+ * `rest_rotation` is the target's rest rotation, from its binding. Only
+ * Rotation reads it: it rides into the slot with the contribution, for
+ * the resolve to write when the rotations summed to nothing.
+ *
  * @type {CodeChunk}
  */
 export const chunk_write_object_property_node3d: CodeChunk;

package/src/shade/renderer/object_property/chunk_write_object_property_node3d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_write_object_property_node3d.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/object_property/chunk_write_object_property_node3d.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,iDAFU,SAAS,CA6Bb;0BArEoB,iCAAiC"}
+{"version":3,"file":"chunk_write_object_property_node3d.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/object_property/chunk_write_object_property_node3d.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,iDAFU,SAAS,CA8Bb;0BA1EoB,iCAAiC"}

package/src/shade/renderer/object_property/chunk_write_object_property_node3d.js

@@ -39,6 +39,10 @@ import { Node3DProperty } from "./Node3DProperty.js";
  * channel has to carry the same weight as the channels that were
  * authored; nothing else here does.
  *
+ * `rest_rotation` is the target's rest rotation, from its binding. Only
+ * Rotation reads it: it rides into the slot with the contribution, for
+ * the resolve to write when the rotations summed to nothing.
+ *
  * @type {CodeChunk}
  */
 export const chunk_write_object_property_node3d = CodeChunk.from(
@@ -50,6 +54,7 @@ fn write_object_property_node3d(
     mask: u32,
     value: vec4f,
     weight: f32,
+    rest_rotation: vec4f,
 ) {
     let node_index = instance & 0x00FFFFFFu;
 
@@ -58,7 +63,7 @@ fn write_object_property_node3d(
             pose_accumulator_add_translation(node_index, value.xyz, mask);
         }
         case ${Node3DProperty.Rotation}u: {
-            pose_accumulator_add_rotation(node_index, value, mask, weight);
+            pose_accumulator_add_rotation(node_index, value, mask, weight, rest_rotation);
         }
         case ${Node3DProperty.Scale}u: {
             pose_accumulator_add_scale(node_index, value.xyz, mask);

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

@@ -1 +1 @@
-{"version":3,"file":"shader_autoexposure_build_histogram.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/eye/shader_autoexposure_build_histogram.js"],"names":[],"mappings":"AA4HA,gEAIE;8BA5H4B,+BAA+B"}
+{"version":3,"file":"shader_autoexposure_build_histogram.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/eye/shader_autoexposure_build_histogram.js"],"names":[],"mappings":"AA8FA,gEAIE;8BA7F4B,+BAA+B"}

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

@@ -1,5 +1,6 @@
 import { chunk_inverse_lerp } from "../../shader/chunk/math/chunk_inverse_lerp.js";
 import { chunk_rgb_to_luminance } from "../../shader/chunk/color/chunk_rgb_to_luminance.js";
+import { chunk_screen_importance } from "../../shader/chunk/screen_space/chunk_screen_importance.js";
 import { chunk_texel_coordinate_to_uv } from "../../shader/chunk/texture/chunk_texel_coordinate_to_uv.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
@@ -18,36 +19,6 @@ const LUMINANCE_MIN = Math.pow(2, AUTOEXPOSURE_HISTOGRAM_LOG_MIN);
 const LUMINANCE_MAX = Math.pow(2, AUTOEXPOSURE_HISTOGRAM_LOG_MAX);
 
 
-/**
- * Exposure metering mask (see https://www.unrealengine.com/en-US/tech-blog/how-epic-games-is-handling-auto-exposure-in-4-25)
- * Prioritize pixels away from the edge of the screen
- * @type {CodeChunk}
- */
-const chunk_compute_vignette = CodeChunk.from(
-    //language=WGSL
-    `
-fn compute_vignette(
-    uv: vec2<f32>,
-    vertical_aspect: f32,
-    border_fraction: f32
-) -> f32{
-    
-    let fov = border_fraction * vec2(vertical_aspect, 1.0);
-
-    let border   = smoothstep(vec2(0.0, 0.0), fov, uv) * (1.0 - smoothstep(vec2(1.0, 1.0) - fov, vec2(1.0, 1.0), uv));
-    let vignette = border.x * border.y;
-    
-    return vignette;
-}
-    `
-)
-
-/**
- * How many distinct steps to use for quantization?
- * @type {number}
- */
-const MASKING_QUANTIZATION_STEPS = 64;
-
 /**
  * NOTE: we do not explicitly initialize groupshared memory, as spec guarantees it to be initialized to default value of 0 already.
  * @type {CodeChunk}
@@ -93,10 +64,9 @@ fn main(
             let bin_index = u32( t * ${ (SCENE_LUMINANCE_HISTOGRAM_BIN_COUNT - 1) });
         
             let uv = texel_coordinate_to_uv(vec2<f32>(global_id.xy), size);
-            
-            let vignette = compute_vignette(uv, f32(size.y) / f32(size.x), 0.13);
-            
-            let quantized = max(1u, u32(vignette * ${MASKING_QUANTIZATION_STEPS}));
+
+            // the metering mask: pixels away from the edge of the screen count for more
+            let quantized = screen_importance_weight(uv, f32(size.y) / f32(size.x));
         
             atomicAdd(&group_histogram.bins[bin_index], quantized);
             
@@ -118,7 +88,7 @@ fn main(
         chunk_rgb_to_luminance,
         chunk_inverse_lerp,
         chunk_texel_coordinate_to_uv,
-        chunk_compute_vignette,
+        chunk_screen_importance,
     ]
 )
 

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

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

package/src/shade/renderer/postprocess/ssr/SSR.d.ts

@@ -5,9 +5,13 @@ export class SSR {
      */
     constructor(graphics: import("../../GraphicsContext.js").GraphicsContext);
     frame_index: number;
-    set spatial_denoising_enabled(value: boolean);
-    /** Toggle the three spatial passes independently of temporal reprojection. @returns {boolean} */
-    get spatial_denoising_enabled(): boolean;
+    set tile_denoising_enabled(value: boolean);
+    /**
+     * Opt-in constant-neighborhood coverage tiles. Classification adds overhead;
+     * measure the scene/device before enabling it, particularly at low resolutions.
+     * @returns {boolean}
+     */
+    get tile_denoising_enabled(): boolean;
     set reset_history(value: boolean);
     /**
      * When set, will disregard history buffer
@@ -15,6 +19,9 @@ export class SSR {
      * @type {boolean}
      */
     get reset_history(): boolean;
+    set spatial_denoising_enabled(value: boolean);
+    /** Toggle the three spatial passes independently of temporal reprojection. @returns {boolean} */
+    get spatial_denoising_enabled(): boolean;
     set reprojection_mode(value: number);
     /** @returns {SSRReprojectionMode} */
     get reprojection_mode(): number;
@@ -47,7 +54,7 @@ export class SSR {
      * @param {import("../../view/GPUViewContext.js").GPUViewContext} [options.view_ctx]
      * @param {ArrayLike<number>} [options.jitter] Raster jitter in internal pixels
      * @param {number} [options.mip] Higher mip = lower resolution trace
-     * @returns {{final:number, trace:number, reflections:number, denoised:number, denoised_1:number}}
+     * @returns {{final:number, trace:number, reflections:number, denoised:number, denoised_1:number, denoise_tiles:number}}
      */
     graph_pass({ graph, input_depth, input_depth_previous, view_ctx, jitter, input_hzb, input_scene_color, input_pbr, input_normal, input_velocity, input_occlusion, input_albedo, resolution, camera_current, camera_previous, input_environment, indirect_lighting_mode, lpv, brick4, mip, }: {
         graph: import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
@@ -76,6 +83,7 @@ export class SSR {
         reflections: number;
         denoised: number;
         denoised_1: number;
+        denoise_tiles: number;
     };
     #private;
 }

package/src/shade/renderer/postprocess/ssr/SSR.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SSR.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/SSR.js"],"names":[],"mappings":"AAiBA;IAyDI;;;OAGG;IACH,sBAFW,OAAO,0BAA0B,EAAE,eAAe,EAkB5D;IA3DD,oBAAgB;IAMhB,8CAOC;IATD,iGAAiG;IACjG,yCAA2E;IA0B3E,kCAMC;IAZD;;;;OAIG;IACH,6BAAmD;IAbnD,qCAMC;IARD,qCAAqC;IACrC,gCAA2D;IA6C3D;;;;OAIG;IACH,UAHW,MAAM,KACN,MAAM,QAUhB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH;QAtBsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;QACjE,WAAW,EAA3B,MAAM;QACW,oBAAoB,GAArC,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,iBAAiB,EAAjC,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QACW,iBAAiB,GAAlC,MAAM;QACqB,UAAU,EAArC,UAAU,MAAM,CAAC;QACD,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QAC8B,sBAAsB,GAA1D,yBAAyB;QAC6D,MAAM,GAA5F,OAAO,oDAAoD,EAAE,cAAc;QACkB,GAAG,GAAhG,OAAO,sDAAsD,EAAE,mBAAmB;QAClB,QAAQ,GAAxE,OAAO,8BAA8B,EAAE,cAAc;QACzB,MAAM,GAAlC,UAAU,MAAM,CAAC;QACA,GAAG,GAApB,MAAM;QACJ;QAAC,KAAK,EAAC,MAAM,CAAC;QAAC,KAAK,EAAC,MAAM,CAAC;QAAC,WAAW,EAAC,MAAM,CAAC;QAAC,QAAQ,EAAC,MAAM,CAAC;QAAC,UAAU,EAAC,MAAM,CAAA;KAAC,CAoQhG;;CACJ;0CA3YyC,oCAAoC"}
+{"version":3,"file":"SSR.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/SSR.js"],"names":[],"mappings":"AAmBA;IAwEI;;;OAGG;IACH,sBAFW,OAAO,0BAA0B,EAAE,eAAe,EAkB5D;IA1ED,oBAAgB;IAWhB,2CAMC;IAZD;;;;OAIG;IACH,sCAAqE;IAoCrE,kCAMC;IAZD;;;;OAIG;IACH,6BAAmD;IAxBnD,8CAOC;IATD,iGAAiG;IACjG,yCAA2E;IAY3E,qCAMC;IARD,qCAAqC;IACrC,gCAA2D;IA6C3D;;;;OAIG;IACH,UAHW,MAAM,KACN,MAAM,QAUhB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH;QAtBsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;QACjE,WAAW,EAA3B,MAAM;QACW,oBAAoB,GAArC,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,iBAAiB,EAAjC,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QACW,iBAAiB,GAAlC,MAAM;QACqB,UAAU,EAArC,UAAU,MAAM,CAAC;QACD,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QAC8B,sBAAsB,GAA1D,yBAAyB;QAC6D,MAAM,GAA5F,OAAO,oDAAoD,EAAE,cAAc;QACkB,GAAG,GAAhG,OAAO,sDAAsD,EAAE,mBAAmB;QAClB,QAAQ,GAAxE,OAAO,8BAA8B,EAAE,cAAc;QACzB,MAAM,GAAlC,UAAU,MAAM,CAAC;QACA,GAAG,GAApB,MAAM;QACJ;QAAC,KAAK,EAAC,MAAM,CAAC;QAAC,KAAK,EAAC,MAAM,CAAC;QAAC,WAAW,EAAC,MAAM,CAAC;QAAC,QAAQ,EAAC,MAAM,CAAC;QAAC,UAAU,EAAC,MAAM,CAAC;QAAC,aAAa,EAAC,MAAM,CAAA;KAAC,CA+QtH;;CACJ;0CAvayC,oCAAoC"}

package/src/shade/renderer/postprocess/ssr/SSR.js

@@ -11,9 +11,11 @@ import { ssr_resolve_shader_LPV } from "./resolve/ssr_resolve_shader_LPV.js";
 import { ssr_combine_shader } from "./ssr_combine_shader.js";
 import { ssr_graph_prefilter_color } from "./ssr_graph_prefilter_color.js";
 import { SSR_PREFILTER_MIP_COUNT } from "./SSR_PREFILTER_MIP_COUNT.js";
-import { ssr_reproject_shader } from "./ssr_reproject_shader.js";
-import { ssr_spatial_denoise_shader, ssr_spatial_denoise_metadata_shader } from "./ssr_spatial_denoise_shader.js";
+import { ssr_reproject_shader, ssr_reproject_tile_shader } from "./ssr_reproject_shader.js";
+import { ssr_spatial_denoise_shader, ssr_spatial_denoise_metadata_shader,
+    ssr_spatial_denoise_tile_shader, ssr_spatial_denoise_metadata_tile_shader } from "./ssr_spatial_denoise_shader.js";
 import { ssr_trace_shader } from "./ssr_trace_shader.js";
+import { ssr_graph_denoise_tiles } from "./ssr_graph_denoise_tiles.js";
 
 export class SSR {
 
@@ -36,6 +38,21 @@ export class SSR {
     frame_index = 0;
     #reprojection_mode = SSRReprojectionMode.Parallax;
     #spatial_denoising_enabled = true;
+    #tile_denoising_enabled = false;
+
+    /**
+     * Opt-in constant-neighborhood coverage tiles. Classification adds overhead;
+     * measure the scene/device before enabling it, particularly at low resolutions.
+     * @returns {boolean}
+     */
+    get tile_denoising_enabled() { return this.#tile_denoising_enabled; }
+    set tile_denoising_enabled(value) {
+        assert.isBoolean(value, 'tile_denoising_enabled');
+        if (value !== this.#tile_denoising_enabled) {
+            this.#tile_denoising_enabled = value;
+            this.reset_history = true;
+        }
+    }
 
     /** Toggle the three spatial passes independently of temporal reprojection. @returns {boolean} */
     get spatial_denoising_enabled() { return this.#spatial_denoising_enabled; }
@@ -132,7 +149,7 @@ export class SSR {
      * @param {import("../../view/GPUViewContext.js").GPUViewContext} [options.view_ctx]
      * @param {ArrayLike<number>} [options.jitter] Raster jitter in internal pixels
      * @param {number} [options.mip] Higher mip = lower resolution trace
-     * @returns {{final:number, trace:number, reflections:number, denoised:number, denoised_1:number}}
+     * @returns {{final:number, trace:number, reflections:number, denoised:number, denoised_1:number, denoise_tiles:number}}
      */
     graph_pass({
                    graph,
@@ -282,7 +299,13 @@ export class SSR {
             },
         });
 
-        // History validity is captured above and consumed by temporal reprojection.
+        const tile_denoising = this.#tile_denoising_enabled
+            && (this.#spatial_denoising_enabled || this.#reprojection_mode !== SSRReprojectionMode.CurrentFrame);
+        const denoise_tiles = tile_denoising ? ssr_graph_denoise_tiles({
+            graph, resolution, input: reflections, metadata: reflection_metadata,
+            history, history_metadata, velocity: input_velocity, history_valid: valid, jitter_delta,
+        }) : -1;
+        const tile_inputs = denoise_tiles >= 0 ? { tDenoiseTiles: denoise_tiles } : {};
 
         // denoise
 
@@ -295,9 +318,10 @@ export class SSR {
         if (this.#spatial_denoising_enabled) {
             [denoised, denoised_metadata] = graph_image_pass({
                 graph,
-                shader: ssr_spatial_denoise_metadata_shader,
+                shader: tile_denoising ? ssr_spatial_denoise_metadata_tile_shader : ssr_spatial_denoise_metadata_shader,
                 output_resolution: resolution,
                 inputs: {
+                    ...tile_inputs,
                     tInput: denoised,
                     tMetadata: denoised_metadata,
                     tDepth: input_depth,
@@ -313,9 +337,10 @@ export class SSR {
 
         [denoised, denoised_metadata] = graph_image_pass({
             graph,
-            shader: ssr_reproject_shader,
+            shader: tile_denoising ? ssr_reproject_tile_shader : ssr_reproject_shader,
             output: [output, output_metadata, output_geometry],
             inputs: {
+                ...tile_inputs,
                 tInput: denoised,
                 tMetadata: denoised_metadata,
                 tHistory: history,
@@ -337,9 +362,10 @@ export class SSR {
             // 2 more spatial denoise steps
             [denoised] = graph_image_pass({
                 graph,
-                shader: ssr_spatial_denoise_shader,
+                shader: tile_denoising ? ssr_spatial_denoise_tile_shader : ssr_spatial_denoise_shader,
                 output_resolution: resolution,
                 inputs: {
+                    ...tile_inputs,
                     tInput: denoised,
                     tDepth: input_depth,
                     tNormal: input_normal,
@@ -352,9 +378,10 @@ export class SSR {
 
             [denoised] = graph_image_pass({
                 graph,
-                shader: ssr_spatial_denoise_shader,
+                shader: tile_denoising ? ssr_spatial_denoise_tile_shader : ssr_spatial_denoise_shader,
                 output_resolution: resolution,
                 inputs: {
+                    ...tile_inputs,
                     tInput: denoised,
                     tDepth: input_depth,
                     tNormal: input_normal,
@@ -391,6 +418,7 @@ export class SSR {
             denoised,
             denoised_1,
             reflections,
+            denoise_tiles,
         };
     }
 }

package/src/shade/renderer/postprocess/ssr/SSR_DENOISE_TILE_SIZE.d.ts

@@ -0,0 +1,3 @@
+/** Tile width in internal pixels; shared by classification and denoise shader variants. */
+export const SSR_DENOISE_TILE_SIZE: 8;
+//# sourceMappingURL=SSR_DENOISE_TILE_SIZE.d.ts.map

package/src/shade/renderer/postprocess/ssr/SSR_DENOISE_TILE_SIZE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SSR_DENOISE_TILE_SIZE.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/SSR_DENOISE_TILE_SIZE.js"],"names":[],"mappings":"AAAA,2FAA2F;AAC3F,sCAAuC"}

package/src/shade/renderer/postprocess/ssr/SSR_DENOISE_TILE_SIZE.js

@@ -0,0 +1,2 @@
+/** Tile width in internal pixels; shared by classification and denoise shader variants. */
+export const SSR_DENOISE_TILE_SIZE = 8;

package/src/shade/renderer/postprocess/ssr/chunk_ssr_denoise_tile_active.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A miss can still contain varying GI radiance or useful history. Only a constant,
+ * stationary, zero-uncertainty neighborhood may take the denoiser's copy path.
+ * Texture names are supplied by shader_ssr_denoise_tile_classify.
+ */
+export const chunk_ssr_denoise_tile_active: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_ssr_denoise_tile_active.d.ts.map

package/src/shade/renderer/postprocess/ssr/chunk_ssr_denoise_tile_active.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_ssr_denoise_tile_active.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/chunk_ssr_denoise_tile_active.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,sDA8B8C;0BAvCpB,oCAAoC"}