@woosh/meep-engine 3.60.2 → 3.60.4

package/src/shade/renderer/light/environment/{shader_convolve_reflection_map_from_averages.js → shader_convolve_reflection_map_from_blurred.js}

@@ -23,65 +23,42 @@ import { chunk_reflection_sample_weight } from "./chunk_reflection_sample_weight
 import { chunk_sphere_probe_lod_to_roughness } from "./chunk_sphere_probe_lod_to_roughness.js";
 import { BSDF_ROUGHNESS_MINIMUM } from "./DEFINES.js";
 import { ENVIRONMENT_MAP_SAMPLER_RESOURCE } from "./ENVIRONMENT_MAP_SAMPLER_RESOURCE.js";
+import { LEVEL_1_SAMPLE_COUNT } from "./environment_level_1_blur_plan.js";
 
 const resources = new ShaderResourceSetDescriptor();
 
+// the lobe's roughness once narrowed by the blur it reads through, see environment_level_1_blur_plan
+resources.setImmediate("lobe_roughness", "f32");
+
 resources.createGroup()
-    // the map's level 0, and its plain averages from level 1 down (see shader_downsample_environment_map)
-    .addTexture("level_0", "float")
-    .addTexture("averages", "float")
+    // level 0 blurred by a Gaussian, see shader_blur_environment_map
+    .addTexture("blurred", "float")
     .addStorageTexture("output", "rgba16float")
     .add(ENVIRONMENT_MAP_SAMPLER_RESOURCE)
 ;
 
 /**
- * Samples per texel. Each reads the average whose texel matches the solid angle it stands for, so
- * the count sets the noise of the lobe's shape, not whether a bright texel is counted. Measured on a
- * single bright texel of a 1024 map at 48 places, level 1 over level 0 in solid-angle energy:
- * 32 → 0.995 ± 0.014, 64 → 0.998 ± 0.008 (at most 1.005), 196 → 1.001 ± 0.019 — 196 asks for a
- * finer average than the 2x2 one, so it point-samples level 0 again. UE filters with 32 below
- * roughness 0.1 and 64 above.
- * @type {number}
- */
-export const CONVOLVE_FROM_AVERAGES_SAMPLE_COUNT = 64;
-
-/**
- * Level 1 of the prefilter, by filtered importance sampling: each sample reads the plain average of
- * level 0 whose texel is the solid angle the sample stands for, so a texel brighter than its
- * neighbours is averaged into the coarser texel the sample reads instead of being hit or missed by
- * the sample pattern. Point taps into level 0 — 196 of them over a cone of 639 level-0 texels — put
- * one bright texel's share of level 1 anywhere from 0.79 to 1.21 of its energy, and an HDR sun
- * came out 0.66% brighter than it went in.
+ * Level 1 of the prefilter, from a copy of level 0 blurred by a Gaussian.
+ *
+ * Point taps into level 0 — 196 of them over a cone of 639 level-0 texels on a 1024 map — put one
+ * bright texel's share of level 1 anywhere from 0.79 to 1.21 of its energy, and an HDR sun came out
+ * 0.66% brighter than it went in. Read from a copy blurred wider than the samples are apart, every
+ * texel lands in level 1 once, whatever the sample pattern. The blur and the lobe are both Gaussians,
+ * so the lobe narrows by the blur's variance and level 1 comes out the lobe it is asked for.
+ *
+ * Samples are uniform in the cone, so each stands for the same solid angle. UE importance-samples
+ * and reads a coarser average in the lobe's tail than in its core; here the sun came out in blocks.
  *
  * Level 1 only. The levels after it read the level above, already smooth at their sample spacing
- * (see shader_convolve_reflection_map). Read from level 0 instead, their samples land on averages
- * 8 to 16 texels a side, too coarse an octahedral grid to keep a bright texel's energy: ±11% at
- * level 4, and a sky 11% brighter.
+ * (see shader_convolve_reflection_map).
  *
  * @see https://developer.nvidia.com/gpugems/gpugems3/part-iii-rendering/chapter-20-gpu-based-importance-sampling
- * @see https://github.com/EpicGames/UnrealEngine/blob/5.4/Engine/Shaders/Private/ReflectionEnvironmentShaders.usf FilterPS
  * @see https://projects.blender.org/blender/blender/src/commit/866ef5b468589587395b1ee7480ea75b4c0fbc26/source/blender/draw/engines/eevee_next/shaders/eevee_lightprobe_sphere_convolve_comp.glsl for the lobe
  * @type {CodeChunk}
  */
 const body = CodeChunk.from(
     //language=WGSL
     `
-/// level 0 is the map's own, the levels below it are the averages
-fn sample_source_level(direction: vec3<f32>, level: u32) -> vec4<f32> {
-    let uv = uv_octahedral_unit_encode(direction);
-
-    if (level == 0u) {
-        let size = f32(textureDimensions(level_0).x);
-
-        return textureSampleLevel(level_0, sEnvironment, texture_octahedral_skirt_uv(uv, size), 0.0);
-    }
-
-    let average_level = level - 1u;
-    let size = f32(textureDimensions(averages, average_level).x);
-
-    return textureSampleLevel(averages, sEnvironment, texture_octahedral_skirt_uv(uv, size), f32(average_level));
-}
-
 @compute @workgroup_size(16,16,1)
 fn main(
     @builtin(global_invocation_id) global_invocation_id : vec3<u32>,
@@ -94,7 +71,7 @@ fn main(
         return;
     }
 
-    /* From mip to linear roughness (same as UI). */
+    // the cone is the lobe's as asked for; only its weights narrow
     let roughness = max(sphere_probe_lod_to_roughness(1.0), ${BSDF_ROUGHNESS_MINIMUM});
     let cone_cos = cone_cosine_from_roughness(roughness);
 
@@ -107,37 +84,19 @@ fn main(
     var weight_accum = 0.0;
     var radiance_accum = vec4(0.0);
 
-    const sample_count = ${CONVOLVE_FROM_AVERAGES_SAMPLE_COUNT};
+    const sample_count = ${LEVEL_1_SAMPLE_COUNT};
 
-    // uniform in the cone, so every sample stands for the same solid angle
-    let sample_solid_angle = 2.0 * PI * (1.0 - cone_cos) / f32(sample_count);
-
-    // level 0's octahedral square, n texels a side, spans 2 in octahedron coordinates; a texel there
-    // covers (2/n)^2 of it, and the octahedron's solid angle per unit area is |d|_1^3 along unit d
-    let level_0_interior = f32(textureDimensions(level_0).x) - 2.0;
-    let level_0_texel_area = 4.0 / (level_0_interior * level_0_interior);
-
-    let last_level = f32(textureNumLevels(averages));
+    let blurred_size = f32(textureDimensions(blurred).x);
 
     for (var i = 0u; i < sample_count; i++) {
         let rand = hammersley_2d(i, sample_count);
 
         let in_direction = normalize(basis * uniform_sample_cone(rand, cone_cos));
 
-        let l1 = dot(abs(in_direction), vec3(1.0));
-        let texel_solid_angle = level_0_texel_area * l1 * l1 * l1;
-
-        let lod = clamp(0.5 * log2(sample_solid_angle / texel_solid_angle), 0.0, last_level);
-        let lod_floor = floor(lod);
-        let level = u32(lod_floor);
-
-        let radiance = mix(
-            sample_source_level(in_direction, level),
-            sample_source_level(in_direction, min(level + 1u, u32(last_level))),
-            lod - lod_floor
-        );
+        let in_uv = texture_octahedral_skirt_uv(uv_octahedral_unit_encode(in_direction), blurred_size);
+        let radiance = textureSampleLevel(blurred, sEnvironment, in_uv, 0.0);
 
-        let weight = reflection_sample_weight(out_direction, in_direction, roughness);
+        let weight = reflection_sample_weight(out_direction, in_direction, lobe_roughness);
 
         radiance_accum += radiance * weight;
         weight_accum += weight;
@@ -162,8 +121,8 @@ fn main(
     ]
 );
 
-export const shader_convolve_reflection_map_from_averages = new ComputeShader(ShaderDescriptor.from({
-    label: 'Convolve reflection map from averages',
+export const shader_convolve_reflection_map_from_blurred = new ComputeShader(ShaderDescriptor.from({
+    label: 'Convolve reflection map from blurred',
     body,
     resources
 }));

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

@@ -1 +1 @@
-{"version":3,"file":"shader_downsample_environment_map.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/shader_downsample_environment_map.js"],"names":[],"mappings":"AAoGA,8DAII;8BAjG0B,+BAA+B"}
+{"version":3,"file":"shader_downsample_environment_map.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/shader_downsample_environment_map.js"],"names":[],"mappings":"AAmGA,8DAII;8BAhG0B,+BAA+B"}

package/src/shade/renderer/light/environment/shader_downsample_environment_map.js

@@ -29,7 +29,6 @@ resources.createGroup()
  * (chunk_octahedral_solid_angle): a texel the octahedral fold crosses is no pair of spherical
  * triangles, and a bright one came out 4.7% dim.
  *
- * @see https://github.com/EpicGames/UnrealEngine/blob/5.4/Engine/Shaders/Private/ReflectionEnvironmentShaders.usf DownsamplePS
  * @type {CodeChunk}
  */
 const body = CodeChunk.from(

package/src/shade/renderer/particles/EMITTER_GLOBAL_STATE_PLAN_2026_10_29.md

@@ -274,10 +274,7 @@ machine. Every VM pass and the bind pass compile and build pipelines under Tint
 
 ## Sources
 
-- UE 5.4 source on disk: `Plugins/FX/Niagara/Source/Niagara/Public/NiagaraTypes.h`
-  (`FNiagaraEmitterParameters` and `FNiagaraSystemParameters` are the engine's members of each scope,
-  with User values beside them), `Classes/NiagaraGPUSystemTick.h`,
-  `Classes/NiagaraParameterCollection.h` (globals bound by name).
+- Niagara Emitter and System parameter namespaces (with User values beside them) and Parameter Collections (globals bound by name).
 - [Niagara key concepts (namespace read/write table)](https://dev.epicgames.com/documentation/unreal-engine/key-concepts-in-niagara-effects-for-unreal-engine)
 - [VFX Graph instancing](https://docs.unity3d.com/Packages/com.unity.visualeffectgraph@17.2/manual/Instancing.html)
   — instances share code and load their properties per instance.

package/src/shade/renderer/particles/ORIENTATION_PLAN_2026_10_15.md

@@ -359,8 +359,8 @@ Register peaks are pinned in `particle_group_library.spec.js`, all far under 48.
 - **An emitter-local frame** (Shuriken "Local"). It needs the scene database in the draw.
   `emitterRotation` does the same in INIT.
 
-Precedent, read from source: Niagara meshes, Niagara sprites, Unity VFX Graph and PopcornFX all
-compose the particle's rotation inside the facing frame. The mesh paths (Niagara `MeshOrientation`,
+Precedent: Niagara meshes, Niagara sprites, Unity VFX Graph and PopcornFX all
+compose the particle's rotation inside the facing frame. The mesh paths (Niagara mesh orientation,
 PopcornFX `Orientation`, Houdini `orient`) store a quaternion.
 
 ## Touch list

package/src/shade/renderer/postprocess/nss/NOTES.md

@@ -1,6 +1,6 @@
 # Neural Super Sampling (NSS)
 
-Port of [ARM's Neural Super Sampling](https://github.com/arm/neural-graphics-for-unreal/tree/main)
+Port of ARM's Neural Super Sampling
 reference design onto the engine's FrameGraph. Same role as TAA — temporal
 anti-aliasing + upscale — but the spatial reconstruction kernel is predicted
 per-pixel by a small CNN (Kernel-Prediction Network) instead of a fixed
@@ -116,8 +116,7 @@ automatically; the renderer only needs to flip
 
 ### Source
 
-Extracted from `nss_v0_1_1_int8.vgf` in the ARM Neural Graphics for
-Unreal SDK in two passes:
+Extracted from `nss_v0_1_1_int8.vgf` in the ARM Neural Graphics SDK in two passes:
 
 1. **VGF constants table** via ARM's own `Model_Parser.exe` — gives
    us the conv weights for every layer and biases for the 7 encoder
@@ -217,18 +216,14 @@ fp32 throughout our pipeline so the offset is implicit.
 #### Head ordering — ARM's quantized model
 
 The 6 heads come out of the SPIR-V in CONCAT order, which is NOT
-KPN col 0..3 + ThetaAlpha + FB. ARM's UE5.5 plugin
-(`UE5.5/Source/NSS/Private/NSS.cpp:241-246`) hard-codes the
-quantized-model `OutputIndices`:
-
-```cpp
-Result->OutputIndices.Feedback     = 0;
-Result->OutputIndices.ThetaAlpha   = 1;
-Result->OutputIndices.KPNFilterCol3 = 2;
-Result->OutputIndices.KPNFilterCol2 = 3;
-Result->OutputIndices.KPNFilterCol1 = 4;
-Result->OutputIndices.KPNFilterCol0 = 5;
-```
+KPN col 0..3 + ThetaAlpha + FB. ARM's quantized model assigns the output head slots as:
+
+- Slot 0: Feedback
+- Slot 1: ThetaAlpha
+- Slot 2: KPN column 3
+- Slot 3: KPN column 2
+- Slot 4: KPN column 1
+- Slot 5: KPN column 0
 
 Our postprocess shader reads the columns from `[5, 4, 3, 2]` in
 that order to recover (col 0, col 1, col 2, col 3), and reads
@@ -236,7 +231,7 @@ ThetaAlpha from slot 1.
 
 #### Postprocess two-stage blend
 
-Mirrors ARM's `NSSPostprocess.usf` (UE5.5):
+Mirrors ARM's reference postprocess:
 1. Apply the 4×4 KPN to the jittered colour, normalising by
    the (positive) weight sum. The centre tap (col=1, row=1) is also
    captured separately.
@@ -275,8 +270,7 @@ Audited against `ffx_nss_callbacks_glsl.h`, `ffx_nss_preprocess.h`,
   zeros tiny motion (`MotionWarpThresh=0.01`) and scales
   disocclusion by `~0.725` on near-static frames
   (`MotionDisThresh=0.25`). We do neither.
-- **History warp filter:** ARM uses Catmull-Rom with deringing
-  (`CatmullRomWithDering`, NSSPostprocess.usf:55). We use plain
+- **History warp filter:** ARM uses Catmull-Rom with deringing. We use plain
   bilinear via `SAMPLER_LINEAR_UPSCALE`. Slight softness on
   high-frequency history detail.
 - **Per-tensor input scales (forward pass):** ARM's INT8
@@ -292,7 +286,7 @@ Audited against `ffx_nss_callbacks_glsl.h`, `ffx_nss_preprocess.h`,
 - **Exposure factor:** ARM multiplies network colour reads by
   `Exposure()` and the final write by `1/Exposure()`
   (`ffx_nss_postprocess.h:48`). We hard-code `EXPOSURE = e^2` to
-  match ARM's `NSSCommon.ush` constant — adequate for SDR output,
+  match ARM's reference constant — adequate for SDR output,
   but doesn't track engine exposure changes.
 - **2x preset KPN footprint:** ARM's 2x path uses a precomputed
   `kernelLUT` indexed by `(out_pixel + jitter_tile_offset) % 2`,
@@ -326,12 +320,11 @@ via `NSS.recommended_jitter_sequence_size(upscale_ratio)`), forwards
 | INT8 quantization with TOSA RESCALE + TABLE | Per-channel `127 * mult / 2^shift` rescale + per-head `output_zp` shift before LUT lookup; LUT dequant matches ARM's `(int8 + 127) / 255` |
 | 2× preset uses a 4-tap LUT pattern | Generic 4×4 KPN footprint for any upscale ratio |
 | Mirror-pad to round to 8 | Compute shader early-outs out-of-range threads; same effect, no extra pass |
-| UE's sparse motion vectors | Engine velocity is already dense and pixel-space; no convert pass |
+| Sparse motion vectors | Engine velocity is already dense and pixel-space; no convert pass |
 | Feedback aliased as R8G8B8A8_SNORM image | Plain rgba16f texture |
 
 ## References
 
-- ARM / Unreal plugin: <https://github.com/arm/neural-graphics-for-unreal/tree/main>
 - ARM SDK (kernel sources): `Source/NG-SDK/sdk/include/FidelityFX/gpu/nss/`
 - ARM SDK Model Parser: `Source/NG-SDK/sdk/tools/binary_store/Model_Parser.exe`
 - FSR2 depth-clip (used unchanged for the disocclusion mask):

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

@@ -3,9 +3,7 @@
  * @typedef {import("../../GraphicsContext.js").GraphicsContext} GraphicsContext
  */
 /**
- * Neural Super Sampling — port of ARM's NSS reference design
- * (`https://github.com/arm/neural-graphics-for-unreal`) onto the
- * engine's FrameGraph.
+ * Neural Super Sampling — port of ARM's NSS reference design onto the engine's FrameGraph.
  *
  * Pipeline (per frame):
  *   1. Preprocess — assemble a 12-channel tensor from

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;IAsaI;;;;;;OAMG;IACH,uDAHW,MAAM,GACJ,MAAM,CAKlB;IAsCD,uGAQC;IAxRD;;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;IA2CD,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,CA4NlB;;CACJ;yBAjwBY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,0BAA0B,EAAE,eAAe;2BATpC,iBAAiB;0CAvBF,oDAAoD"}
+{"version":3,"file":"NSS.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/nss/NSS.js"],"names":[],"mappings":"AAgCA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH;IAsaI;;;;;;OAMG;IACH,uDAHW,MAAM,GACJ,MAAM,CAKlB;IAsCD,uGAQC;IAxRD;;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;IA2CD,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,CA4NlB;;CACJ;yBA/vBY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,0BAA0B,EAAE,eAAe;2BATpC,iBAAiB;0CAvBF,oDAAoD"}

package/src/shade/renderer/postprocess/nss/NSS.js

@@ -36,9 +36,7 @@ import { shader_nss_preprocess } from "./shader_nss_preprocess.js";
  */
 
 /**
- * Neural Super Sampling — port of ARM's NSS reference design
- * (`https://github.com/arm/neural-graphics-for-unreal`) onto the
- * engine's FrameGraph.
+ * Neural Super Sampling — port of ARM's NSS reference design onto the engine's FrameGraph.
  *
  * Pipeline (per frame):
  *   1. Preprocess — assemble a 12-channel tensor from

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

@@ -9,14 +9,13 @@
  * ReLU; decoder is conv8..conv12 without bias; 6 parallel output
  * heads each carry their own RESCALE + TABLE LUT.
  *
- * Head ordering matches ARM's `OutputIndices` mapping for the
- * QUANTIZED model (NSS.cpp:241-246):
+ * Head ordering for the quantized model:
  *   slot 0 = Feedback (FB) — passed back to next frame's preprocess
  *   slot 1 = ThetaAlpha    — sigmoid temporal-blend params
- *   slot 2 = KPNFilterCol3 — kernel column 3 (rightmost)
- *   slot 3 = KPNFilterCol2
- *   slot 4 = KPNFilterCol1
- *   slot 5 = KPNFilterCol0 — kernel column 0 (leftmost)
+ *   slot 2 = KPN column 3  — kernel column 3 (rightmost)
+ *   slot 3 = KPN column 2
+ *   slot 4 = KPN column 1
+ *   slot 5 = KPN column 0  — kernel column 0 (leftmost)
  *
  * The KPN slot order is reversed because ARM packs the network outputs
  * in CONCAT order while our postprocess reads them as columns 0..3.

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

@@ -1 +1 @@
-{"version":3,"file":"NSS_NETWORK_SCHEMA.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/nss/NSS_NETWORK_SCHEMA.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,oEAAoE;AACpE,6CACqE;AAErE;;;;GAIG;AACH,yCAA0C;AAE1C,kEAAkE;AAClE,mCAAoC;AAEpC,6DAA6D;AAC7D,qCAAsC;AAEtC,yCAAyC;AACzC,yCAA0C"}
+{"version":3,"file":"NSS_NETWORK_SCHEMA.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/nss/NSS_NETWORK_SCHEMA.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,oEAAoE;AACpE,6CACqE;AAErE;;;;GAIG;AACH,yCAA0C;AAE1C,kEAAkE;AAClE,mCAAoC;AAEpC,6DAA6D;AAC7D,qCAAsC;AAEtC,yCAAyC;AACzC,yCAA0C"}

package/src/shade/renderer/postprocess/nss/NSS_NETWORK_SCHEMA.js

@@ -9,14 +9,13 @@
  * ReLU; decoder is conv8..conv12 without bias; 6 parallel output
  * heads each carry their own RESCALE + TABLE LUT.
  *
- * Head ordering matches ARM's `OutputIndices` mapping for the
- * QUANTIZED model (NSS.cpp:241-246):
+ * Head ordering for the quantized model:
  *   slot 0 = Feedback (FB) — passed back to next frame's preprocess
  *   slot 1 = ThetaAlpha    — sigmoid temporal-blend params
- *   slot 2 = KPNFilterCol3 — kernel column 3 (rightmost)
- *   slot 3 = KPNFilterCol2
- *   slot 4 = KPNFilterCol1
- *   slot 5 = KPNFilterCol0 — kernel column 0 (leftmost)
+ *   slot 2 = KPN column 3  — kernel column 3 (rightmost)
+ *   slot 3 = KPN column 2
+ *   slot 4 = KPN column 1
+ *   slot 5 = KPN column 0  — kernel column 0 (leftmost)
  *
  * The KPN slot order is reversed because ARM packs the network outputs
  * in CONCAT order while our postprocess reads them as columns 0..3.
@@ -52,10 +51,10 @@ export const NSS_NETWORK_SCHEMA = Object.freeze({
         // the slot index is what the postprocess reads back.
         { in: 16, out: 4, output_layer_offset: 0, kind: 'feedback'      }, // 12  FB
         { in: 16, out: 4, output_layer_offset: 1, kind: 'theta_alpha'   }, // 13  ThetaAlpha (sigmoid)
-        { in: 16, out: 4, output_layer_offset: 2, kind: 'kpn_col_3'     }, // 14  KPNFilterCol3
-        { in: 16, out: 4, output_layer_offset: 3, kind: 'kpn_col_2'     }, // 15  KPNFilterCol2
-        { in: 16, out: 4, output_layer_offset: 4, kind: 'kpn_col_1'     }, // 16  KPNFilterCol1
-        { in: 16, out: 4, output_layer_offset: 5, kind: 'kpn_col_0'     }, // 17  KPNFilterCol0
+        { in: 16, out: 4, output_layer_offset: 2, kind: 'kpn_col_3'     }, // 14  KPN column 3
+        { in: 16, out: 4, output_layer_offset: 3, kind: 'kpn_col_2'     }, // 15  KPN column 2
+        { in: 16, out: 4, output_layer_offset: 4, kind: 'kpn_col_1'     }, // 16  KPN column 1
+        { in: 16, out: 4, output_layer_offset: 5, kind: 'kpn_col_0'     }, // 17  KPN column 0
     ],
 });
 

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

@@ -1 +1 @@
-{"version":3,"file":"shader_nss_extract_feedback.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/nss/shader_nss_extract_feedback.js"],"names":[],"mappings":"AA4CA,wDAIG;8BA/C2B,+BAA+B"}
+{"version":3,"file":"shader_nss_extract_feedback.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/nss/shader_nss_extract_feedback.js"],"names":[],"mappings":"AA2CA,wDAIG;8BA9C2B,+BAA+B"}

package/src/shade/renderer/postprocess/nss/shader_nss_extract_feedback.js

@@ -1,49 +1,48 @@
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { NSS_WORKGROUP_SIZE } from "./NSS_CONSTANTS.js";
-
-/**
- * Copies the feedback channel-group (z = 0 — head slot 0 in ARM's
- * quantized model output ordering, see NSS_NETWORK_SCHEMA) of the
- * network's 3D output tensor into a standalone 2D rgba16f texture, so
- * the next frame's preprocess pass can sample it as a regular 2D
- * texture (with bilinear filtering for the warp).
- *
- * Trivial pass — included as a separate shader rather than folded into
- * postprocess because postprocess runs at output-res while feedback is
- * needed at render-res.
- */
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addTexture("tNetworkOut", "float", "3d")
-    .addStorageTexture("tFeedback", "rgba16float", "2d", "write-only")
-;
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@compute @workgroup_size(${NSS_WORKGROUP_SIZE}, ${NSS_WORKGROUP_SIZE}, 1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let dim = textureDimensions(tFeedback);
-
-    if (any(gid.xy >= dim)) {
-        return;
-    }
-
-    let st = vec2<i32>(gid.xy);
-
-    // Slot 0 of the network output is the feedback tensor (ARM's
-    // quantized-model OutputIndices.Feedback = 0).
-    let fb = textureLoad(tNetworkOut, vec3<i32>(st, 0), 0);
-
-    textureStore(tFeedback, st, fb);
-}
-    `
-);
-
-export const shader_nss_extract_feedback = ComputeShader.from({
-    label: "NSS / extract feedback",
-    body,
-    resources,
-});
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { NSS_WORKGROUP_SIZE } from "./NSS_CONSTANTS.js";
+
+/**
+ * Copies the feedback channel-group (z = 0 — head slot 0 in ARM's
+ * quantized model output ordering, see NSS_NETWORK_SCHEMA) of the
+ * network's 3D output tensor into a standalone 2D rgba16f texture, so
+ * the next frame's preprocess pass can sample it as a regular 2D
+ * texture (with bilinear filtering for the warp).
+ *
+ * Trivial pass — included as a separate shader rather than folded into
+ * postprocess because postprocess runs at output-res while feedback is
+ * needed at render-res.
+ */
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    .addTexture("tNetworkOut", "float", "3d")
+    .addStorageTexture("tFeedback", "rgba16float", "2d", "write-only")
+;
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(${NSS_WORKGROUP_SIZE}, ${NSS_WORKGROUP_SIZE}, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let dim = textureDimensions(tFeedback);
+
+    if (any(gid.xy >= dim)) {
+        return;
+    }
+
+    let st = vec2<i32>(gid.xy);
+
+    // Slot 0 of the network output is the feedback tensor.
+    let fb = textureLoad(tNetworkOut, vec3<i32>(st, 0), 0);
+
+    textureStore(tFeedback, st, fb);
+}
+    `
+);
+
+export const shader_nss_extract_feedback = ComputeShader.from({
+    label: "NSS / extract feedback",
+    body,
+    resources,
+});

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

@@ -1 +1 @@
-{"version":3,"file":"shader_nss_postprocess.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/nss/shader_nss_postprocess.js"],"names":[],"mappings":"AAqSA,mDAIG;8BAvS2B,+BAA+B"}
+{"version":3,"file":"shader_nss_postprocess.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/nss/shader_nss_postprocess.js"],"names":[],"mappings":"AAiSA,mDAIG;8BAnS2B,+BAA+B"}

package/src/shade/renderer/postprocess/nss/shader_nss_postprocess.js

@@ -1,4 +1,4 @@
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { F16_MAX_DEFINITION } from "../../shader/chunk/math/F16_MAX_DEFINITION.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
@@ -19,7 +19,7 @@ import { NSS_SETTINGS_STRUCT } from "./NSS_SETTINGS_STRUCT.js";
  *   - the warped history at output-res
  *   - the nearest-depth offset from preprocess (used to dilate velocity)
  *
- * Per-output-pixel logic mirrors ARM's reference (UE5.5 NSSPostprocess.usf):
+ * Per-output-pixel logic mirrors ARM's reference:
  *   1. Solve which render-res pixel feeds each of the 4x4 KPN taps.
  *   2. Apply the KPN to those taps, normalising by the weight sum.
  *   3. Warp the history (bilinear) using velocity dilated by the nearest
@@ -27,9 +27,6 @@ import { NSS_SETTINGS_STRUCT } from "./NSS_SETTINGS_STRUCT.js";
  *   4. Blend the KPN colour with warped history using theta.
  *   5. In tonemapped (Karis) space, accumulate the center tap with alpha.
  *   6. Inverse tonemap, divide by EXPOSURE, write.
- *
- * @see ARM reference: UE5.5/Shaders/Private/NSSPostprocess.usf and
- *      NSSCommon.ush in github.com/arm/neural-graphics-for-unreal
  */
 
 const resources = new ShaderResourceSetDescriptor();
@@ -53,9 +50,9 @@ resources.createGroup()
 const body = CodeChunk.from(
     //language=WGSL
     `
-const NSS_EXPOSURE: f32 = 7.38905609893; // e^2, matches ARM's NSSCommon.ush
+const NSS_EXPOSURE: f32 = 7.38905609893; // e^2
 
-// Karis tonemap (max-of-channels) — matches ARM's NSSCommon.ush.
+// Karis tonemap (max-of-channels).
 // The guard is a FINITE clamp, not just a non-negative one: this target is rgba16float, so shading
 // above its range stores as +Inf and rgb / (1.0 + m) is Inf/Inf = NaN, which goes straight into the
 // next frame's history and stays there. NaN fails every comparison including with itself, which is
@@ -106,7 +103,7 @@ fn nss_sample_layer_bilinear(render_pos: vec2<f32>, render_res_max: vec2<i32>, l
 
 // SolveInputLocation: figure out which render-res pixel maps to a given
 // output-res pixel position, given upscale ratio and jitter. Direct port
-// of ARM's helper (NSSPostprocess.usf:80). Returns -1 when no render-res
+// of ARM's reference helper. Returns -1 when no render-res
 // sample lands at this output position.
 fn nss_solve_input_location(out_idx: i32, upscale: f32, jitter: f32) -> i32 {
     let lower = f32(out_idx) / upscale - (-jitter + 0.5);
@@ -144,8 +141,7 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
     let coef_st_clamped = clamp(coef_st, vec2<i32>(0, 0), render_res_max);
 
     // ── KPN columns ──
-    // ARM's quantized model maps OutputIndices.KPNFilterCol0 = 5,
-    // KPNFilterCol1 = 4, KPNFilterCol2 = 3, KPNFilterCol3 = 2 (NSS.cpp:243).
+    // ARM's quantized model maps KPN columns 0..3 to head slots 5, 4, 3, 2.
     // Each column has 4 channels = the 4 row weights for that column.
     // Bilinear at render_centre (matches ARM's ManualBilinear4) — without
     // this, every 2x2 output block in 2x mode shares one set of weights and
@@ -155,7 +151,7 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
     let col2 = nss_sample_layer_bilinear(render_centre, render_res_max, 3);
     let col3 = nss_sample_layer_bilinear(render_centre, render_res_max, 2);
     // Force tiny positive — ARM does this to dodge 0/0 in the
-    // weight-normalisation divide (NSSPostprocess.usf:118).
+    // weight-normalisation divide.
     let kpn_cols = array<vec4<f32>, 4>(
         max(col0, vec4<f32>(1e-7)),
         max(col1, vec4<f32>(1e-7)),
@@ -208,7 +204,7 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
     let nearest_offset = vec2<i32>(round(nearest_packed * 2.0 - 1.0));
 
     var velocity = textureLoad(tVelocity, coef_st_clamped + nearest_offset, 0).rg;
-    // Motion zero-clamp (ARM NSSPostprocess.usf:215). Sub-pixel velocity on
+    // Motion zero-clamp. Sub-pixel velocity on
     // near-static frames drifts prev_uv by fractions of a pixel each frame
     // and bilinear-resamples the history at slightly different sub-pixel
     // positions — visible as flicker even when nothing in the scene is
@@ -225,10 +221,10 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
     let on_screen_f = select(0.0, 1.0, all(prev_uv >= vec2<f32>(0.0)) && all(prev_uv <= vec2<f32>(1.0)));
 
     // ── ThetaAlpha (head slot 1) ──
-    // ARM's quantized model maps OutputIndices.ThetaAlpha = 1
-    // (NSS.cpp:242). Channel x = theta (history blend weight, [0, 1] from
+    // ARM's quantized model maps ThetaAlpha to head slot 1.
+    // Channel x = theta (history blend weight, [0, 1] from
     // sigmoid LUT), channel y = alpha (raw [0, 1], remapped to
-    // [0.05, 0.4] per NSSPostprocess.usf:248).
+    // [0.05, 0.4]).
     // Bilinear at render_centre — same reasoning as the KPN cols above.
     let ta = nss_sample_layer_bilinear(render_centre, render_res_max, 1);
     let theta_network = saturate(ta.x);
@@ -286,7 +282,7 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
     textureStore(tOutput, out_st, vec4<f32>(final_rgb, theta));
 }
     `, [
-        F16_MAX_DEFINITION,
+        F16_MAX_DEFINITION,
         NSS_SETTINGS_STRUCT.declaration_chunk,
     ]
 );