@woosh/meep-engine 3.60.3 → 3.60.5

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

@@ -0,0 +1,128 @@
+import { chunk_cone_cosine_from_roughness } from "../../shader/chunk/brdf/chunk_cone_cosine_from_roughness.js";
+import {
+    chunk_build_orthonormal_matrix_n
+} from "../../shader/chunk/geometry/normal/chunk_build_orthonormal_matrix_n.js";
+import {
+    chunk_uv_octahedral_unit_decode
+} from "../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
+import {
+    chunk_uv_octahedral_unit_encode
+} from "../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_encode.js";
+import { chunk_uniform_sample_cone } from "../../shader/chunk/geometry/ray/chunk_uniform_sample_cone.js";
+import { chunk_safe_rcp } from "../../shader/chunk/math/chunk_safe_rcp.js";
+import { chunk_hammersley_2d } from "../../shader/chunk/noise/chunk_hammersley_2d.js";
+import {
+    chunk_texture_octahedral_skirt_texel_uv
+} from "../../shader/chunk/texture/octahedral/chunk_texture_octahedral_skirt_texel_uv.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 { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+import { chunk_reflection_sample_weight } from "./chunk_reflection_sample_weight.js";
+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()
+    // level 0 blurred by a Gaussian, see shader_blur_environment_map
+    .addTexture("blurred", "float")
+    .addStorageTexture("output", "rgba16float")
+    .add(ENVIRONMENT_MAP_SAMPLER_RESOURCE)
+;
+
+/**
+ * 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).
+ *
+ * @see https://developer.nvidia.com/gpugems/gpugems3/part-iii-rendering/chapter-20-gpu-based-importance-sampling
+ * @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
+    `
+@compute @workgroup_size(16,16,1)
+fn main(
+    @builtin(global_invocation_id) global_invocation_id : vec3<u32>,
+){
+    let output_size = textureDimensions(output);
+
+    let output_texel_i = global_invocation_id.xy;
+
+    if(any(output_texel_i >= output_size)){
+        return;
+    }
+
+    // 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);
+
+    // the skirt too: a skirt texel takes its interior twin's uv, so it is that texel, computed again
+    let out_uv = texture_octahedral_skirt_texel_uv(output_texel_i, output_size.x);
+    let out_direction = uv_octahedral_unit_decode( out_uv );
+
+    let basis = build_orthonormal_matrix_n(out_direction);
+
+    var weight_accum = 0.0;
+    var radiance_accum = vec4(0.0);
+
+    const sample_count = ${LEVEL_1_SAMPLE_COUNT};
+
+    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 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, lobe_roughness);
+
+        radiance_accum += radiance * weight;
+        weight_accum += weight;
+    }
+
+    let out_radiance = radiance_accum * safe_rcp(weight_accum);
+
+    textureStore(output, output_texel_i, out_radiance);
+}
+    `, [
+        chunk_sphere_probe_lod_to_roughness,
+        chunk_hammersley_2d,
+        chunk_build_orthonormal_matrix_n,
+        chunk_safe_rcp,
+        chunk_uniform_sample_cone,
+        chunk_texture_octahedral_skirt_texel_uv,
+        chunk_texture_octahedral_skirt_uv,
+        chunk_uv_octahedral_unit_decode,
+        chunk_uv_octahedral_unit_encode,
+        chunk_reflection_sample_weight,
+        chunk_cone_cosine_from_roughness,
+    ]
+);
+
+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/loader/gltf/tiny-gltf.d.ts

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

package/src/shade/renderer/material/GPUMaterialManager.d.ts

@@ -9,6 +9,13 @@ export class GPUMaterialManager {
      * @param {GPUSamplerManager} [samplers] required by templates that bind shared samplers — terrain's
      */
     constructor(device: GPUDevice, textures: TextureManager, render_pipelines: RenderPipelineManager, bindings: BindGroupManager, virtual_textures?: VirtualTextureManager, samplers?: GPUSamplerManager);
+    /**
+     * Sent with a material when {@link update} restages its row because its {@link ShadeMaterial#version}
+     * moved: what the scene's material table and the material's uniform hold changes with this frame.
+     * Not sent for a material's first row, which {@link obtain} writes.
+     * @type {Signal<ShadeMaterial>}
+     */
+    onMaterialRestaged: any;
     /**
      *
      * @type {Map<ShadeMaterial, GPUMaterialContext>}

package/src/shade/renderer/material/GPUMaterialManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUMaterialManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/GPUMaterialManager.js"],"names":[],"mappings":"AA2NA;IAoFI;;;;;;;;OAQG;IACH,yCANW,cAAc,oBACd,qBAAqB,YACrB,gBAAgB,qBAChB,qBAAqB,aACrB,iBAAiB,EAiD3B;IArID;;;OAGG;IACH,UAFU,IAAI,aAAa,EAAE,kBAAkB,CAAC,CAE3B;IAyBrB;;;OAGG;IACH,yCAEC;IAID;;;OAGG;IACH,sBAEC;IAsLD;;;;;;;;OAQG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACE,gBAAgB,EAAhC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACJ;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAiMnF;IAED;;;;OAIG;IACH,iBAHW,aAAa,GACX,kBAAkB,CAqB9B;IAED;;;;;;;;;;;;OAYG;IACH,kBAHW,aAAa,GACX,OAAO,CAyBnB;IAED;;;;OAIG;IACH,gBAaC;IAED;;;;;;;OAOG;IACH,0BAFW,eAAe,QAazB;IAED;;;;;;;;;;;OAWG;IACH,kBAHW,qBAAqB,GACnB,QAAQ,IAAI,CAAC,CAMzB;IAsBD;;;;;;OAMG;IACH,0BAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAED;;;;;;OAMG;IACH,wBAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAuED;;;OAGG;IACH,YAFW,sBAAsB,QAiChC;;CAEJ;8BA33BY,OAAO,0CAA0C,EAAE,eAAe;6BAClE,OAAO,2BAA2B,EAAE,cAAc;yBAIlD,OAAO,2DAA2D,EAAE,UAAU;qCAC9E,OAAO,wCAAwC,EAAE,sBAAsB;oCACvE,OAAO,gDAAgD,EAAE,qBAAqB;+BAC9E,OAAO,gCAAgC,EAAE,gBAAgB;gCACzD,OAAO,yBAAyB,EAAE,iBAAiB;6BACnD,OAAO,8BAA8B,EAAE,cAAc;oCACrD,OAAO,6CAA6C,EAAE,qBAAqB;4BAC3E,OAAO,oBAAoB,EAAE,aAAa;oCAC1C,OAAO,qCAAqC,EAAE,qBAAqB;mCAtBzE,yBAAyB;mCAjBG,8CAA8C"}
+{"version":3,"file":"GPUMaterialManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/GPUMaterialManager.js"],"names":[],"mappings":"AA4NA;IA4FI;;;;;;;;OAQG;IACH,yCANW,cAAc,oBACd,qBAAqB,YACrB,gBAAgB,qBAChB,qBAAqB,aACrB,iBAAiB,EAiD3B;IAlJD;;;;;OAKG;IACH,wBAAkC;IAOlC;;;OAGG;IACH,UAFU,IAAI,aAAa,EAAE,kBAAkB,CAAC,CAE3B;IAyBrB;;;OAGG;IACH,yCAEC;IAID;;;OAGG;IACH,sBAEC;IAsLD;;;;;;;;OAQG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACE,gBAAgB,EAAhC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACJ;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAiMnF;IAED;;;;OAIG;IACH,iBAHW,aAAa,GACX,kBAAkB,CAqB9B;IAED;;;;;;;;;;;;OAYG;IACH,kBAHW,aAAa,GACX,OAAO,CAyBnB;IAED;;;;OAIG;IACH,gBAaC;IAED;;;;;;;OAOG;IACH,0BAFW,eAAe,QAazB;IAED;;;;;;;;;;;OAWG;IACH,kBAHW,qBAAqB,GACnB,QAAQ,IAAI,CAAC,CAMzB;IAsBD;;;;;;OAMG;IACH,0BAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAED;;;;;;OAMG;IACH,wBAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAuED;;;OAGG;IACH,YAFW,sBAAsB,QAmChC;;CAEJ;8BAr4BY,OAAO,0CAA0C,EAAE,eAAe;6BAClE,OAAO,2BAA2B,EAAE,cAAc;yBAIlD,OAAO,2DAA2D,EAAE,UAAU;qCAC9E,OAAO,wCAAwC,EAAE,sBAAsB;oCACvE,OAAO,gDAAgD,EAAE,qBAAqB;+BAC9E,OAAO,gCAAgC,EAAE,gBAAgB;gCACzD,OAAO,yBAAyB,EAAE,iBAAiB;6BACnD,OAAO,8BAA8B,EAAE,cAAc;oCACrD,OAAO,6CAA6C,EAAE,qBAAqB;4BAC3E,OAAO,oBAAoB,EAAE,aAAa;oCAC1C,OAAO,qCAAqC,EAAE,qBAAqB;mCAtBzE,yBAAyB;mCAjBG,8CAA8C"}

package/src/shade/renderer/material/GPUMaterialManager.js

@@ -1,4 +1,5 @@
 import { assert } from "../../../core/assert.js";
+import Signal from "../../../core/events/signal/Signal.js";
 import { BindGroupLayoutDescriptor } from "../../descriptor/binding/BindGroupLayoutDescriptor.js";
 import { BufferBindingLayout } from "../../descriptor/binding/BufferBindingLayout.js";
 import { GPUShaderStage } from "../../descriptor/GPUShaderStage.js";
@@ -219,6 +220,14 @@ const material_buffer_pipeline_descriptor = RenderPipelineDescriptor.from({
 
 export class GPUMaterialManager {
 
+    /**
+     * Sent with a material when {@link update} restages its row because its {@link ShadeMaterial#version}
+     * moved: what the scene's material table and the material's uniform hold changes with this frame.
+     * Not sent for a material's first row, which {@link obtain} writes.
+     * @type {Signal<ShadeMaterial>}
+     */
+    onMaterialRestaged = new Signal();
+
     /**
      * @type {GPUDevice}
      */
@@ -906,6 +915,8 @@ export class GPUMaterialManager {
                 const row = this.#stage_metadata(material_ctx);
 
                 material_ctx.write_uniform(queue, row);
+
+                this.onMaterialRestaged.send1(material_ctx.source);
             }
         }
 

package/src/shade/renderer/material/resident/GPUResidentMaterialContext.d.ts

@@ -5,12 +5,6 @@ export class GPUResidentMaterialContext {
      * @param {GraphicsContext} graphics
      */
     constructor(device: GPUDevice, graphics: GraphicsContext);
-    /**
-     * Sent with a material when it is repacked because its {@link ShadeMaterial#version} moved: the
-     * row the device reads changes with the next {@link update}. Not sent for a material's first pack.
-     * @type {Signal<ShadeMaterial>}
-     */
-    onMaterialRepacked: any;
     /**
      *
      * @returns {number}
@@ -26,10 +20,6 @@ export class GPUResidentMaterialContext {
      * @returns {GPUTextureContext}
      */
     get buffer_textures(): GPUTextureContext;
-    /**
-     * @returns {GPUBuffer}
-     */
-    get buffer_texture_means(): GPUBuffer;
     /**
      *
      * @returns {GPUTextureView}
@@ -54,8 +44,8 @@ export class GPUResidentMaterialContext {
      * Make a material resident, or repack it if its {@link ShadeMaterial#version} has moved since —
      * the same contract {@link GPUMaterialManager} restages by. A hit used to be final, so a factor
      * set after the first pack never reached the row. Every caller re-obtains what it needs before
-     * {@link update}: the scene's drawn list, and the manager's materials whenever its version
-     * moves, so the check rides on walks that already happen.
+     * {@link update} or {@link commit}: the scene's drawn list, the manager's materials whenever its
+     * version moves, or what a card capture traces, so the check rides on walks that already happen.
      *
      * @param {ShadeMaterial} material
      * @returns {MaterialInfo}
@@ -75,6 +65,16 @@ export class GPUResidentMaterialContext {
      * @param {GPUSceneContext} scene_context
      */
     ensure_scene_materials(scene_context: GPUSceneContext): void;
+    /**
+     * Write what {@link obtain_material} made resident or repacked since the last commit, and the media
+     * that moved. Takes none of the manager's materials, unlike {@link update}: for a reader that makes
+     * resident only what it reads.
+     */
+    commit(): void;
+    /**
+     * Make every material the manager holds resident, then {@link commit}: for the readers that trace
+     * the whole scene.
+     */
     update(): void;
     destroy(): void;
     #private;

package/src/shade/renderer/material/resident/GPUResidentMaterialContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUResidentMaterialContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/resident/GPUResidentMaterialContext.js"],"names":[],"mappings":"AAmIA;IAqMI;;;;OAIG;IACH,yCAFW,eAAe,EAyDzB;IA/PD;;;;OAIG;IACH,wBAAkC;IA4BlC;;;OAGG;IACH,6BAEC;IAQD;;;OAGG;IACH,kCAEC;IAQD;;;OAGG;IACH,yCAEC;IAoBD;;OAEG;IACH,sCAEC;IAED;;;OAGG;IACH,kCAIC;IAmED;;;;;OAKG;IACH,0BAEC;IAOD;;;;;;OAMG;IACH,8BAEC;IA6JD;;;;;;;;;OASG;IACH,0BAHW,aAAa,GACX,YAAY,CAqBxB;IAgBD;;;;OAIG;IACH,wBAHW,YAAY,GACV,WAAW,CAIvB;IAGD,uBA4DC;IAkJD,wBA8EC;IAED;;;;OAIG;IACH,sCAFW,eAAe,QAUzB;IAoCD,eAWC;IAGD,gBAMC;;CACJ;8BAh2BY,OAAO,0BAA0B,EAAE,eAAe;8BAClD,OAAO,gCAAgC,EAAE,eAAe;2BACxD,OAAO,+BAA+B,EAAE,YAAY;4BACpD,OAAO,qBAAqB,EAAE,aAAa;oCAC3C,OAAO,6BAA6B,EAAE,qBAAqB;kCAC3D,OAAO,qCAAqC,EAAE,mBAAmB;kCAnB5C,oCAAoC;AAatE;;;;;;;GAOG;AAEH;IACI,WAAM;IAEN;;;OAGG;IACH,SAFU,MAAM,CAEJ;IAEZ;;OAEG;IACH,QAFU,qBAAqB,CAExB;IAEP;;OAEG;IACH,gBAFU,WAAW,CAEP;IAEd;;OAEG;IACH,aAFU,WAAW,CAEV;IAEX;;;;OAIG;IACH,gBAFU,WAAW,GAAC,IAAI,CAEZ;IACd;;OAEG;IACH,kBAFU,WAAW,CAEL;IAEhB;;;OAGG;IACH,aAFU,MAAM,CAEe;CAClC;AAqBD;IACI,WAAO;IAEP;;OAEG;IACH,QAFU,YAAY,CAEf;CACV"}
+{"version":3,"file":"GPUResidentMaterialContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/resident/GPUResidentMaterialContext.js"],"names":[],"mappings":"AAgIA;IAqKI;;;;OAIG;IACH,yCAFW,eAAe,EAkDzB;IA9LD;;;OAGG;IACH,6BAEC;IAQD;;;OAGG;IACH,kCAEC;IAQD;;;OAGG;IACH,yCAEC;IAED;;;OAGG;IACH,kCAIC;IAmED;;;;;OAKG;IACH,0BAEC;IAOD;;;;;;OAMG;IACH,8BAEC;IAsJD;;;;;;;;;OASG;IACH,0BAHW,aAAa,GACX,YAAY,CAmBxB;IAgBD;;;;OAIG;IACH,wBAHW,YAAY,GACV,WAAW,CAIvB;IAGD,uBA0DC;IAuFD,wBA8EC;IAED;;;;OAIG;IACH,sCAFW,eAAe,QAUzB;IAoCD;;;;OAIG;IACH,eAGC;IAED;;;OAGG;IACH,eAGC;IAGD,gBAIC;;CACJ;8BA9vBY,OAAO,0BAA0B,EAAE,eAAe;8BAClD,OAAO,gCAAgC,EAAE,eAAe;2BACxD,OAAO,+BAA+B,EAAE,YAAY;4BACpD,OAAO,qBAAqB,EAAE,aAAa;oCAC3C,OAAO,6BAA6B,EAAE,qBAAqB;kCAC3D,OAAO,qCAAqC,EAAE,mBAAmB;kCAlB5C,oCAAoC;AAYtE;;;;;;;GAOG;AAEH;IACI,WAAM;IAEN;;;OAGG;IACH,SAFU,MAAM,CAEJ;IAEZ;;OAEG;IACH,QAFU,qBAAqB,CAExB;IAEP;;OAEG;IACH,gBAFU,WAAW,CAEP;IAEd;;OAEG;IACH,aAFU,WAAW,CAEV;IAEX;;;;OAIG;IACH,gBAFU,WAAW,GAAC,IAAI,CAEZ;IACd;;OAEG;IACH,kBAFU,WAAW,CAEL;IAEhB;;;OAGG;IACH,aAFU,MAAM,CAEe;CAClC;AAqBD;IACI,WAAO;IAEP;;OAEG;IACH,QAFU,YAAY,CAEf;CACV"}

package/src/shade/renderer/material/resident/GPUResidentMaterialContext.js

@@ -1,13 +1,11 @@
 import { assert } from "../../../../core/assert.js";
 import { HashMap } from "../../../../core/collection/map/HashMap.js";
-import Signal from "../../../../core/events/signal/Signal.js";
 import IdPool from "../../../../core/IdPool.js";
 import { isPowerOfTwo } from "../../../../core/math/isPowerOfTwo.js";
 import { round_up } from "../../../../core/math/round_up.js";
 import { TextureViewDescriptor } from "../../../descriptor/texture/TextureViewDescriptor.js";
 import { ShadeGPUCommandContext } from "../../../device/ShadeGPUCommandContext.js";
 import { GPU_DATABASE_NULL } from "../../buffer/table/GPU_DATABASE_NULL.js";
-import { WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION } from "../../gpu_primitive/indirect/WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.js";
 import { MEDIA_TABLE_CAPACITY, MEDIA_TABLE_STRUCT } from "../../medium/MEDIA_TABLE_STRUCT.js";
 import { MEDIUM_STRUCT } from "../../medium/MEDIUM_STRUCT.js";
 import { write_gpu_typed_buffer } from "../../shader/type/serde/write_gpu_typed_buffer.js";
@@ -25,7 +23,6 @@ import {
     RESIDENT_MATERIAL_TEXTURE_RESOLUTION,
     RESIDENT_MATERIAL_TEXTURE_SLOT_RESOLUTION
 } from "./RESIDENT_MATERIAL_TEXTURE_LAYOUT.js";
-import { shader_resident_texture_means, shader_resident_texture_rows } from "./shader_resident_texture_means.js";
 
 /**
  * @typedef {import("../../GraphicsContext.js").GraphicsContext} GraphicsContext
@@ -131,13 +128,6 @@ const NEUTRAL_SURFACE = Object.freeze({
 
 export class GPUResidentMaterialContext {
 
-    /**
-     * Sent with a material when it is repacked because its {@link ShadeMaterial#version} moved: the
-     * row the device reads changes with the next {@link update}. Not sent for a material's first pack.
-     * @type {Signal<ShadeMaterial>}
-     */
-    onMaterialRepacked = new Signal();
-
     /**
      * @type {GraphicsContext}
      */
@@ -200,31 +190,6 @@ export class GPUResidentMaterialContext {
         return this.#buffer_textures;
     }
 
-    /**
-     * Each texture slot's mean, `vec4<f32>`, of its texels as the atlas stores them: an albedo's colour
-     * premultiplied by its coverage. Written whenever the textures are (§6.6 of
-     * PROBE_CLIPMAP_PROPOSAL_2026_10_27.md): what a GI hit that no card sees takes of its material.
-     * Replaced when the slots outgrow it, so take it each frame.
-     *
-     * @type {GPUBuffer}
-     */
-    #buffer_texture_means;
-
-    /** The rows' sums the means are made of. @type {GPUBuffer|null} */
-    #buffer_texture_rows = null;
-
-    /** Slots the means hold. */
-    #texture_means_capacity = 0;
-
-    #texture_means_settings = { slot_count: 0 };
-
-    /**
-     * @returns {GPUBuffer}
-     */
-    get buffer_texture_means() {
-        return this.#buffer_texture_means;
-    }
-
     /**
      *
      * @returns {GPUTextureView}
@@ -368,13 +333,6 @@ export class GPUResidentMaterialContext {
             size: MEDIA_TABLE_STRUCT.size,
         });
 
-        // a slot's worth until the first textures are written
-        this.#buffer_texture_means = device.createBuffer({
-            label: 'Material Texture Means',
-            usage: GPUBufferUsage.STORAGE,
-            size: 16,
-        });
-
         this.#buffer_textures = new GPUTextureContext(device);
         const descriptor = this.#buffer_textures.descriptor;
 
@@ -485,8 +443,8 @@ export class GPUResidentMaterialContext {
      * Make a material resident, or repack it if its {@link ShadeMaterial#version} has moved since —
      * the same contract {@link GPUMaterialManager} restages by. A hit used to be final, so a factor
      * set after the first pack never reached the row. Every caller re-obtains what it needs before
-     * {@link update}: the scene's drawn list, and the manager's materials whenever its version
-     * moves, so the check rides on walks that already happen.
+     * {@link update} or {@link commit}: the scene's drawn list, the manager's materials whenever its
+     * version moves, or what a card capture traces, so the check rides on walks that already happen.
      *
      * @param {ShadeMaterial} material
      * @returns {MaterialInfo}
@@ -505,8 +463,6 @@ export class GPUResidentMaterialContext {
             this.#pack_material(info);
         } else if (info.version !== material.version) {
             this.#pack_material(info);
-
-            this.onMaterialRepacked.send1(material);
         }
 
         return info;
@@ -592,8 +548,6 @@ export class GPUResidentMaterialContext {
             }
         }
 
-        this.#record_texture_means(encoder, textures);
-
         encoder.finish();
 
     }
@@ -683,65 +637,6 @@ export class GPUResidentMaterialContext {
         }
     }
 
-    /**
-     * Every texture slot's mean, after the slots are written (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.6):
-     * the rows' sums, then the slots' means, which {@link buffer_texture_means} holds.
-     *
-     * @param {ShadeGPUCommandContext} encoder
-     * @param {TextureInfo[]} textures
-     */
-    #record_texture_means(encoder, textures) {
-        let slot_count = 0;
-
-        for (let i = 0; i < textures.length; i++) {
-            slot_count = Math.max(slot_count, textures[i].id + 1);
-        }
-
-        if (slot_count === 0) {
-            return;
-        }
-
-        if (this.#texture_means_capacity < slot_count) {
-            // textures arrive a few at a time as a scene loads: doubling replaces the buffers a
-            // logarithmic number of times
-            const capacity = Math.max(slot_count, 2 * this.#texture_means_capacity);
-
-            this.#buffer_texture_means.destroy();
-            this.#buffer_texture_rows?.destroy();
-
-            this.#texture_means_capacity = capacity;
-            this.#buffer_texture_means = this.#device.createBuffer({
-                label: 'Material Texture Means',
-                usage: GPUBufferUsage.STORAGE,
-                size: 16 * capacity,
-            });
-            this.#buffer_texture_rows = this.#device.createBuffer({
-                label: 'Material Texture Rows',
-                usage: GPUBufferUsage.STORAGE,
-                size: 16 * RESIDENT_MATERIAL_TEXTURE_RESOLUTION * capacity,
-            });
-        }
-
-        const settings = this.#texture_means_settings;
-
-        settings.slot_count = slot_count;
-
-        // a workgroup a slot, folded as folded_workgroup_index reads it: the array holds more slots than a
-        // dimension does
-        shader_resident_texture_rows.dispatch({
-            encoder,
-            group_count_x: Math.min(slot_count, WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION),
-            group_count_y: Math.ceil(slot_count / WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION),
-            bindings: { settings, textures: this.textureView, texture_rows: this.#buffer_texture_rows },
-        });
-
-        shader_resident_texture_means.dispatch({
-            encoder,
-            group_count_x: Math.ceil(slot_count / 64),
-            bindings: { settings, texture_rows: this.#buffer_texture_rows, texture_means: this.#buffer_texture_means },
-        });
-    }
-
     build_materials() {
 
         /**
@@ -871,25 +766,29 @@ export class GPUResidentMaterialContext {
 
     }
 
-    update() {
-
-        this.#update_from_manager();
-
+    /**
+     * Write what {@link obtain_material} made resident or repacked since the last commit, and the media
+     * that moved. Takes none of the manager's materials, unlike {@link update}: for a reader that makes
+     * resident only what it reads.
+     */
+    commit() {
         this.#write_media();
-
-        if (this.#version === this.#version_commited) {
-            return;
-        }
-
         this.#commit();
     }
 
+    /**
+     * Make every material the manager holds resident, then {@link commit}: for the readers that trace
+     * the whole scene.
+     */
+    update() {
+        this.#update_from_manager();
+        this.commit();
+    }
+
 
     destroy() {
         this.#buffer_materials.destroy();
         this.#buffer_media.destroy();
         this.#buffer_textures.destroy();
-        this.#buffer_texture_means.destroy();
-        this.#buffer_texture_rows?.destroy();
     }
 }

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"}