@woosh/meep-engine 3.14.6 → 3.16.0

package/src/shade/renderer/extension/FrameRecord.d.ts

@@ -69,6 +69,22 @@ export class FrameRecord {
      * @returns {number} `handle`
      */
     publish(handle: number): number;
+    /**
+     * The renderer re-stating a field after one of its **own** passes superseded the handle in it.
+     * Not something an extension calls.
+     *
+     * Everything {@link publish} checks except {@link is_writable_at}. That restriction is about who
+     * may change what a record *means*, and at which phase — it is not about the frame keeping the
+     * record accurate. `GBufferTextures` is frozen after `AfterGBuffer` precisely so that an
+     * extension cannot republish into it once shading has run, and the AO composite supersedes the
+     * albedo target after that point: a record left naming the pre-AO version hands the next reader
+     * a handle an earlier pass has already replaced, which `validate()` rejects and a stripped build
+     * reads silently.
+     *
+     * @param {number} handle
+     * @returns {number} `handle`
+     */
+    republish(handle: number): number;
     #private;
 }
 //# sourceMappingURL=FrameRecord.d.ts.map

package/src/shade/renderer/extension/FrameRecord.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FrameRecord.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/extension/FrameRecord.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACI;;;;;;;OAOG;IACH,yCAFa,OAAO,CAInB;IAED;;;;;;;;;OASG;IACH,0CAFa,OAAO,CAInB;IAUD;;OAEG;IACH,0BAEC;IAED;;;;;OAKG;IACH,gCAKC;IAED;;;;;OAKG;IACH,aAHW,MAAM,GACJ,MAAM,CAUlB;IAED;;;;;;;;;;;OAWG;IACH,gBAHW,MAAM,GACJ,MAAM,CAqBlB;;CACJ"}
+{"version":3,"file":"FrameRecord.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/extension/FrameRecord.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACI;;;;;;;OAOG;IACH,yCAFa,OAAO,CAInB;IAED;;;;;;;;;OASG;IACH,0CAFa,OAAO,CAInB;IAUD;;OAEG;IACH,0BAEC;IAED;;;;;OAKG;IACH,gCAKC;IAED;;;;;OAKG;IACH,aAHW,MAAM,GACJ,MAAM,CAUlB;IAED;;;;;;;;;;;OAWG;IACH,gBAHW,MAAM,GACJ,MAAM,CAqBlB;IAED;;;;;;;;;;;;;;OAcG;IACH,kBAHW,MAAM,GACJ,MAAM,CAgBlB;;CACJ"}

package/src/shade/renderer/extension/FrameRecord.js

@@ -123,4 +123,35 @@ export class FrameRecord {
 
         return handle;
     }
+
+    /**
+     * The renderer re-stating a field after one of its **own** passes superseded the handle in it.
+     * Not something an extension calls.
+     *
+     * Everything {@link publish} checks except {@link is_writable_at}. That restriction is about who
+     * may change what a record *means*, and at which phase — it is not about the frame keeping the
+     * record accurate. `GBufferTextures` is frozen after `AfterGBuffer` precisely so that an
+     * extension cannot republish into it once shading has run, and the AO composite supersedes the
+     * albedo target after that point: a record left naming the pre-AO version hands the next reader
+     * a handle an earlier pass has already replaced, which `validate()` rejects and a stripped build
+     * reads silently.
+     *
+     * @param {number} handle
+     * @returns {number} `handle`
+     */
+    republish(handle) {
+        const frame = this.#frame;
+        const name = this.constructor.name;
+
+        assert.notNull(frame, `${name} was republished into without belonging to a frame`);
+        assert.equal(frame.is_open, true, `${name} belongs to a frame that has finished; a handle from one frame cannot be published into another`);
+        assert.isNonNegativeInteger(handle, `${name} handle`);
+        assert.equal(
+            frame.graph.is_valid_resource(handle),
+            true,
+            `${name} was republished a superseded handle — one resource entry owns one concrete resource, so an older version of it is not a snapshot of older contents`
+        );
+
+        return handle;
+    }
 }

package/src/shade/renderer/extension/GBufferTextures.d.ts

@@ -23,6 +23,17 @@ export class GBufferTextures extends FrameRecord {
      * @returns {number}
      */
     get albedo(): number;
+    /**
+     * The renderer re-stating the albedo target after its own AO composite superseded it.
+     *
+     * The composite runs well after `AfterGBuffer`, where this record is frozen against extension
+     * publication — deliberately, since publishing into it once shading has run is meaningless. The
+     * freeze is about extensions; the record still has to name the handle that currently *is* the
+     * G-buffer, because this record stays readable through `BeforePresent`.
+     *
+     * @param {number} handle
+     */
+    republish_albedo(handle: number): void;
     set normal(arg: number);
     /**
      * @returns {number}

package/src/shade/renderer/extension/GBufferTextures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GBufferTextures.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/extension/GBufferTextures.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH;IAMI,0CAKC;IAED,2CAEC;IAWD,wBAEC;IAXD;;;;OAIG;IACH,qBAEC;IAaD,wBAEC;IATD;;OAEG;IACH,qBAEC;IAeD,qBAEC;IAXD;;;;OAIG;IACH,kBAEC;IAaD,0BAEC;IATD;;OAEG;IACH,uBAEC;;CAKJ;4BAjF2B,kBAAkB"}
+{"version":3,"file":"GBufferTextures.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/extension/GBufferTextures.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH;IAMI,0CAKC;IAED,2CAEC;IAWD,wBAEC;IAXD;;;;OAIG;IACH,qBAEC;IAMD;;;;;;;;;OASG;IACH,yBAFW,MAAM,QAIhB;IASD,wBAEC;IATD;;OAEG;IACH,qBAEC;IAeD,qBAEC;IAXD;;;;OAIG;IACH,kBAEC;IAaD,0BAEC;IATD;;OAEG;IACH,uBAEC;;CAKJ;4BA/F2B,kBAAkB"}

package/src/shade/renderer/extension/GBufferTextures.js

@@ -46,6 +46,20 @@ export class GBufferTextures extends FrameRecord {
         this.#albedo = this.publish(handle);
     }
 
+    /**
+     * The renderer re-stating the albedo target after its own AO composite superseded it.
+     *
+     * The composite runs well after `AfterGBuffer`, where this record is frozen against extension
+     * publication — deliberately, since publishing into it once shading has run is meaningless. The
+     * freeze is about extensions; the record still has to name the handle that currently *is* the
+     * G-buffer, because this record stays readable through `BeforePresent`.
+     *
+     * @param {number} handle
+     */
+    republish_albedo(handle) {
+        this.#albedo = this.republish(handle);
+    }
+
     /**
      * @returns {number}
      */

package/src/shade/renderer/geometry/attribute/gpu_vertex_buffer_layout_from_spec.js

@@ -42,7 +42,7 @@ export function gpu_vertex_buffer_layout_from_spec(vertex_data_spec, shader_loca
 
     layout.normalize();
 
-    assert(layout.validate(console.error), 'layout invalid');
+    assert.ok(layout.validate(console.error), 'layout invalid');
 
     return layout;
 }

package/src/shade/renderer/geometry/util/geometry_stripify.js

@@ -71,7 +71,7 @@ function findStripNext(buffer, buffer_size, e0, e1) {
 export function geometry_stripify_bound(index_count) {
 
     assert.isNonNegativeInteger(index_count, 'index_count');
-    assert(index_count % 3 === 0);
+    assert.ok(index_count % 3 === 0);
 
     // worst case without restarts is 2 degenerate indices and 3 indices per triangle
     // worst case with restarts is 1 restart index and 3 indices per triangle
@@ -96,8 +96,8 @@ export function geometry_stripify(
 ) {
     // @see Francine Evans, Steven Skiena and Amitabh Varshney. "Optimizing Triangle Strips for Fast Rendering". 1996
 
-    assert(destination != indices);
-    assert(index_count % 3 == 0);
+    assert.ok(destination != indices);
+    assert.ok(index_count % 3 == 0);
 
     /**
      * The advantages to be gained from larger buffer sizes diminish rapidly beyond a buffer size of about 8.
@@ -121,7 +121,7 @@ export function geometry_stripify(
 
     for (let i = 0; i < index_count; ++i) {
         const index = indices[i];
-        assert(index < vertex_count);
+        assert.ok(index < vertex_count);
 
         valence[index]++;
     }
@@ -129,7 +129,7 @@ export function geometry_stripify(
     let next = -1;
 
     while (buffer_size > 0 || index_offset < index_count) {
-        assert(next < 0 || ((next >> 2) < buffer_size && (next & 3) < 3));
+        assert.ok(next < 0 || ((next >> 2) < buffer_size && (next & 3) < 3));
 
         // fill triangle buffer
         while (buffer_size < buffer_capacity && index_offset < index_count) {
@@ -141,7 +141,7 @@ export function geometry_stripify(
             index_offset += 3;
         }
 
-        assert(buffer_size > 0);
+        assert.ok(buffer_size > 0);
 
         if (next >= 0) {
             const i = next >> 2;

package/src/shade/renderer/geometry/virtual/format/prototypeVGEOFormatViewer.js

@@ -1635,7 +1635,7 @@ class VGeoViewer {
         this.camera.near = 0.05;
         this.camera.far = 500;
         this.camera.fov = 55 * DEG_TO_RAD;
-        this.camera.transform.position.set(0, 0.5, 2);
+        this.camera.transform.setTranslation(0, 0.5, 2);
         this.camera.transform.lookAt(Vector3.zero);
 
         this.controller = new OrbitalCameraController(this.camera, this.canvas);
@@ -1695,15 +1695,15 @@ class VGeoViewer {
     #frame(dt) {
         this.controller.update(dt);
 
-        const position = this.camera.transform.position;
+        const position = this.camera.transform;
 
-        const moved = position.x !== this.#eye[0]
-            || position.y !== this.#eye[1]
-            || position.z !== this.#eye[2];
+        const moved = position.translation_x !== this.#eye[0]
+            || position.translation_y !== this.#eye[1]
+            || position.translation_z !== this.#eye[2];
 
-        this.#eye[0] = position.x;
-        this.#eye[1] = position.y;
-        this.#eye[2] = position.z;
+        this.#eye[0] = position.translation_x;
+        this.#eye[1] = position.translation_y;
+        this.#eye[2] = position.translation_z;
 
         if (moved && this.#auto_adapt) {
             this.adapt();

package/src/shade/renderer/global_illumination/lpv/lpv_visualise_probes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lpv_visualise_probes.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/lpv/lpv_visualise_probes.js"],"names":[],"mappings":"AAwBA,8LAoDC;AAkKD;;;;;GAKG;AACH,yFAwDC"}
+{"version":3,"file":"lpv_visualise_probes.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/lpv/lpv_visualise_probes.js"],"names":[],"mappings":"AAwBA,8LAoDC;AAkKD;;;;;GAKG;AACH,yFAiEC"}

package/src/shade/renderer/global_illumination/lpv/lpv_visualise_probes.js

@@ -7,7 +7,7 @@ import {
 } from "../../../../core/geom/3d/normal/octahedron/encode_unit_to_octahedron.js";
 import Vector3 from "../../../../core/geom/Vector3.js";
 import { clamp01 } from "../../../../core/math/clamp01.js";
-import { Transform } from "../../../../engine/ecs/transform/Transform.js";
+import { Transform64 } from "../../../../engine/ecs/transform/Transform64.js";
 import { Sampler2D } from "../../../../engine/graphics/texture/sampler/Sampler2D.js";
 import { ColorSpace } from "../../texture/ColorSpace.js";
 import { Attribute } from "../../geometry/Attribute.js";
@@ -286,15 +286,24 @@ export function lpv_visualise_probes({
             material.emissive_factor.set(1, 1, 1);
         }
 
-        const transform = new Transform();
+        const transform = new Transform64();
 
-        transform.position.fromArray(lpv.positions, i * 3);
-        transform.scale.setScalar(scale);
+        transform.setTranslation(
+            lpv.positions[i * 3],
+            lpv.positions[i * 3 + 1],
+            lpv.positions[i * 3 + 2]
+        );
+        transform.setScaleScalar(scale);
+
+        // the scale moved, so the matrix owes an update - a Transform64 recomposes nothing on its own
+        transform.updateMatrix();
 
         scene.instances.add(Mesh.from(
             geo,
             material,
-            transform.matrix
+            // the matrix sits at offset 0, so the transform goes straight in as one; Mesh.from
+            // copies the first 16 elements out of it and keeps no reference
+            transform
         ));
 
     }

package/src/shade/renderer/global_illumination/probe/octahedral/GPUProbeAtlas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUProbeAtlas.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe/octahedral/GPUProbeAtlas.js"],"names":[],"mappings":"AAyBA;IAyEI;;;OAGG;IACH,+BAgBC;IAtFD;;;OAGG;IACH,0CAEC;IAGD;;;OAGG;IACH,2BAUC;IAQD;;;OAGG;IACH,uCAEC;IAED;;;OAGG;IACH,kBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,sCAGC;IAED;;;OAGG;IACH,QAFU,MAAM,MAAM,CAEM;IAgC5B;;;;OAIG;IACH,6BAFW,MAAM,QAiChB;IAED;;;;;;;OAOG;IACH,kDAHW,iBAAiB,QAa3B;IAED;;;;;;OAMG;IACH,gFA6PC;IAED,+BAGC;IAED,gBAGC;;CACJ;kCAzbiC,uCAAuC"}
+{"version":3,"file":"GPUProbeAtlas.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe/octahedral/GPUProbeAtlas.js"],"names":[],"mappings":"AAyBA;IAyEI;;;OAGG;IACH,+BAgBC;IAtFD;;;OAGG;IACH,0CAEC;IAGD;;;OAGG;IACH,2BAUC;IAQD;;;OAGG;IACH,uCAEC;IAED;;;OAGG;IACH,kBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,sCAGC;IAED;;;OAGG;IACH,QAFU,MAAM,MAAM,CAEM;IAgC5B;;;;OAIG;IACH,6BAFW,MAAM,QAiChB;IAED;;;;;;;OAOG;IACH,kDAHW,iBAAiB,QAa3B;IAED;;;;;;OAMG;IACH,gFAqQC;IAED,+BAGC;IAED,gBAGC;;CACJ;kCAjciC,uCAAuC"}

package/src/shade/renderer/global_illumination/probe/octahedral/GPUProbeAtlas.js

@@ -297,11 +297,18 @@ export class GPUProbeAtlas {
         });
 
 
-        const t_radiance = graph_import_texture(graph, this.texture_radiance);
-        const t_depth = graph_import_texture(graph, this.#texture_depth);
+        /*
+         Both atlases are threaded from here on: every helper that writes one hands back a renamed
+         handle, and the next reader has to be given that one. Reading the version a previous pass
+         has already superseded is the shape `validate()` exists to reject, and with assertions
+         stripped it leaves the border and convolution passes with no recorded dependency on the
+         passes that filled the atlas.
+        */
+        let t_radiance = graph_import_texture(graph, this.texture_radiance);
+        let t_depth = graph_import_texture(graph, this.#texture_depth);
         const b_probes = graph_import_buffer(graph, scene.light_probe_volume.buffer_probes)
 
-        graph_lpv_shade({
+        ({ radiance: t_radiance } = graph_lpv_shade({
             graph,
             scene,
             atlas: this,
@@ -317,7 +324,7 @@ export class GPUProbeAtlas {
             g_buffer_pbr,
             g_buffer_position,
             g_buffer_indirect,
-        });
+        }));
 
         // avoid upsetting WebGPU validator with empty buffers
         if (update_count > 0) {
@@ -356,7 +363,7 @@ export class GPUProbeAtlas {
                     output_resolution: g_buffer_resolution,
                 });
 
-                graph_compute_pass({
+                ({ tAtlas_depth: t_depth } = graph_compute_pass({
                     graph,
                     shader: shader_lpv_atlas_write_depth,
                     bindings: {
@@ -369,7 +376,7 @@ export class GPUProbeAtlas {
                         Math.ceil(g_buffer_resolution[1] / 16),
                         1
                     ]
-                });
+                }));
             }
 
             {
@@ -380,7 +387,7 @@ export class GPUProbeAtlas {
                 ];
 
                 // Depth
-                graph_lpv_paint_border_depth({
+                t_depth = graph_lpv_paint_border_depth({
                     graph,
                     atlas: t_depth,
                     settings: gr_settings,
@@ -389,7 +396,7 @@ export class GPUProbeAtlas {
                 });
 
                 // Radiance
-                graph_compute_pass({
+                ({ tAtlas: t_radiance } = graph_compute_pass({
                     graph,
                     shader: shader_lpv_atlas_paint_borders_radiance,
                     group_count,
@@ -397,7 +404,7 @@ export class GPUProbeAtlas {
                         settings: gr_settings,
                         tAtlas: t_radiance,
                     }
-                });
+                }));
             }
 
             // perform convolution to compute irradiance
@@ -405,6 +412,7 @@ export class GPUProbeAtlas {
                 graph,
                 atlas: this,
                 scene,
+                atlas_radiance: t_radiance,
                 probe_index_offset: start_index,
                 probe_update_count: update_count,
                 g_buffer_resolution,

package/src/shade/renderer/global_illumination/probe/octahedral/border/graph_lpv_paint_border_depth.d.ts

@@ -6,6 +6,7 @@
  * @param {number} atlas resource texture
  * @param {number} probe_resolution
  * @param {number} update_count
+ * @returns {number} the atlas after the border paint
  */
-export function graph_lpv_paint_border_depth({ graph, settings, atlas, probe_resolution, update_count, }: FrameGraph): void;
+export function graph_lpv_paint_border_depth({ graph, settings, atlas, probe_resolution, update_count, }: FrameGraph): number;
 //# sourceMappingURL=graph_lpv_paint_border_depth.d.ts.map

package/src/shade/renderer/global_illumination/probe/octahedral/border/graph_lpv_paint_border_depth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_lpv_paint_border_depth.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe/octahedral/border/graph_lpv_paint_border_depth.js"],"names":[],"mappings":"AAQA;;;;;;;;GAQG;AACH,4HA+DC"}
+{"version":3,"file":"graph_lpv_paint_border_depth.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe/octahedral/border/graph_lpv_paint_border_depth.js"],"names":[],"mappings":"AAQA;;;;;;;;;GASG;AACH,uHAFa,MAAM,CAmElB"}

package/src/shade/renderer/global_illumination/probe/octahedral/border/graph_lpv_paint_border_depth.js

@@ -14,6 +14,7 @@ import { shader_lpv_atlas_paint_borders_depth } from "./shader_lpv_atlas_paint_b
  * @param {number} atlas resource texture
  * @param {number} probe_resolution
  * @param {number} update_count
+ * @returns {number} the atlas after the border paint
  */
 export function graph_lpv_paint_border_depth({
                                                  graph,
@@ -68,7 +69,7 @@ export function graph_lpv_paint_border_depth({
     ));
 
     // write out
-    graph_compute_pass({
+    const { tAtlas } = graph_compute_pass({
         graph,
         shader: shader_lpv_atlas_paint_borders_depth,
         bindings: {
@@ -78,4 +79,6 @@ export function graph_lpv_paint_border_depth({
         },
         group_count: [group_count, 1, 1]
     });
+
+    return tAtlas;
 }

package/src/shade/renderer/global_illumination/probe/octahedral/convolve/graph_lvp_atlas_to_sh.d.ts

@@ -3,10 +3,11 @@
  * @param {FrameGraph} graph
  * @param {GPUProbeAtlas} atlas
  * @param {GPUSceneContext} scene
+ * @param {number} atlas_radiance resource texture, the version of the radiance atlas to convolve
  * @param {number} probe_index_offset
  * @param {number} probe_update_count
  * @param {number[]} g_buffer_resolution In texels
  * @returns {number} buffer resource with SH3-encoded texels
  */
-export function graph_lvp_atlas_to_sh({ graph, atlas, scene, probe_index_offset, probe_update_count, g_buffer_resolution, }: FrameGraph): number;
+export function graph_lvp_atlas_to_sh({ graph, atlas, scene, atlas_radiance, probe_index_offset, probe_update_count, g_buffer_resolution, }: FrameGraph): number;
 //# sourceMappingURL=graph_lvp_atlas_to_sh.d.ts.map

package/src/shade/renderer/global_illumination/probe/octahedral/convolve/graph_lvp_atlas_to_sh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_lvp_atlas_to_sh.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe/octahedral/convolve/graph_lvp_atlas_to_sh.js"],"names":[],"mappings":"AAqHA;;;;;;;;;GASG;AACH,0IAFa,MAAM,CA8DlB"}
+{"version":3,"file":"graph_lvp_atlas_to_sh.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe/octahedral/convolve/graph_lvp_atlas_to_sh.js"],"names":[],"mappings":"AAqHA;;;;;;;;;;GAUG;AACH,0JAFa,MAAM,CAuElB"}

package/src/shade/renderer/global_illumination/probe/octahedral/convolve/graph_lvp_atlas_to_sh.js

@@ -120,6 +120,7 @@ const shader = ComputeShader.from({
  * @param {FrameGraph} graph
  * @param {GPUProbeAtlas} atlas
  * @param {GPUSceneContext} scene
+ * @param {number} atlas_radiance resource texture, the version of the radiance atlas to convolve
  * @param {number} probe_index_offset
  * @param {number} probe_update_count
  * @param {number[]} g_buffer_resolution In texels
@@ -129,6 +130,7 @@ export function graph_lvp_atlas_to_sh({
                                           graph,
                                           atlas,
                                           scene,
+                                          atlas_radiance,
                                           probe_index_offset,
                                           probe_update_count,
                                           g_buffer_resolution,
@@ -163,7 +165,7 @@ export function graph_lvp_atlas_to_sh({
             bindings: {
                 settings,
                 coefficients: output,
-                tAtlas_radiance: atlas.texture_radiance.obtainView(),
+                tAtlas_radiance: resources.get(data.atlas_radiance).obtainView(),
             },
             thread_count_x: g_buffer_resolution[0],
             thread_count_y: g_buffer_resolution[1],
@@ -184,5 +186,13 @@ export function graph_lvp_atlas_to_sh({
 
     pass_data.output = r_sh_buffer;
 
+    /*
+     Declared rather than reached for through the captured `atlas`. Binding the object left the
+     graph with no edge from the passes that fill the atlas to this one, so culling was free to
+     elide them — they survive today only because they write an imported resource — and neither
+     `validate()` nor the DOT/JSON topology export could see the dependency at all.
+    */
+    pass_data.atlas_radiance = pass.read(atlas_radiance);
+
     return r_sh_buffer;
 }

package/src/shade/renderer/global_illumination/probe/octahedral/graph_lpv_shade.d.ts

@@ -8,6 +8,6 @@
  * @param {number} atlas_radiance
  */
 export function graph_lpv_shade({ graph, atlas_radiance, g_buffer_albedo, g_buffer_emissive, g_buffer_normals, g_buffer_pbr, g_buffer_position, g_buffer_indirect, probe_index_offset, probe_update_count, random_seed, resolution, atlas, scene, }: FrameGraph): {
-    radiance: FrameGraph;
+    radiance: any;
 };
 //# sourceMappingURL=graph_lpv_shade.d.ts.map

package/src/shade/renderer/global_illumination/probe/octahedral/graph_lpv_shade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_lpv_shade.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe/octahedral/graph_lpv_shade.js"],"names":[],"mappings":"AA4UA;;;;;;;;GAQG;AACH;;EAwEC"}
+{"version":3,"file":"graph_lpv_shade.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe/octahedral/graph_lpv_shade.js"],"names":[],"mappings":"AA4UA;;;;;;;;GAQG;AACH;;EA0EC"}

package/src/shade/renderer/global_illumination/probe/octahedral/graph_lpv_shade.js

@@ -362,7 +362,7 @@ export function graph_lpv_shade({
     const lights = scene.lights;
     const geometries = scene.geometries;
 
-    graph_compute_pass({
+    const { tAtlas_radiance: atlas_radiance_written } = graph_compute_pass({
         graph,
         shader,
         group_count: [
@@ -409,6 +409,8 @@ export function graph_lpv_shade({
     });
 
     return {
-        radiance: atlas_radiance
+        // the version this pass produced. Handing back the one we were given makes every later
+        // reader a superseded read of an atlas this pass has already filled.
+        radiance: atlas_radiance_written
     };
 }

package/src/shade/renderer/global_illumination/sharc/SpatialHashRadianceCache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SpatialHashRadianceCache.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/sharc/SpatialHashRadianceCache.js"],"names":[],"mappings":"AAaA;IAkDI;;;;OAIG;IACH,8CAFW,MAAM,EAkBhB;IA1DD,qCAEC;IASD,mCAEC;IAQD,mBAEC;IAQD,6BAIC;IARD,0BAEC;IAiCD;;;;;;;;OAQG;IACH,gHAqGC;IAED,gBAEC;IAED,gBAEC;IAED,cAiBC;IAGD,gBAUC;IAED;;;OAqBC;IAED;;;OAGG;IACH,+BAYC;;CACJ"}
+{"version":3,"file":"SpatialHashRadianceCache.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/sharc/SpatialHashRadianceCache.js"],"names":[],"mappings":"AAaA;IAkDI;;;;OAIG;IACH,8CAFW,MAAM,EAkBhB;IA1DD,qCAEC;IASD,mCAEC;IAQD,mBAEC;IAQD,6BAIC;IARD,0BAEC;IAiCD;;;;;;;;OAQG;IACH,gHAyGC;IAED,gBAEC;IAED,gBAEC;IAED,cAiBC;IAGD,gBAUC;IAED;;;OAqBC;IAED;;;OAGG;IACH,+BAYC;;CACJ"}

package/src/shade/renderer/global_illumination/sharc/SpatialHashRadianceCache.js

@@ -134,7 +134,11 @@ export class SpatialHashRadianceCache {
                 sceneScale: scene_scale,
                 capacity,
                 frame: frame_index,
-                cameraPosition: camera.camera.transform.position.toArray()
+                cameraPosition: [
+                    camera.camera.transform.translation_x,
+                    camera.camera.transform.translation_y,
+                    camera.camera.transform.translation_z
+                ]
             };
 
             // run a compute shader to update the hash table

package/src/shade/renderer/light/cluster/cull/graph_cull_lights.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_cull_lights.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/cluster/cull/graph_cull_lights.js"],"names":[],"mappings":"AAqKA;;;;;;GAMG;AACH,uFAkBC"}
+{"version":3,"file":"graph_cull_lights.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/cluster/cull/graph_cull_lights.js"],"names":[],"mappings":"AAiLA;;;;;;GAMG;AACH,uFA8BC"}

package/src/shade/renderer/light/cluster/cull/graph_cull_lights.js

@@ -1,3 +1,4 @@
+import { graph_import_buffer } from "../../../shader/graph/graph_import_buffer.js";
 import { BufferResourceDescriptor } from "../../../../device/graph/BufferResourceDescriptor.js";
 import { u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import {
@@ -44,11 +45,12 @@ function clusterable_light_count(lights) {
 /**
  *
  * @param {GPULightCollection} lights
- * @param {GPUCameraContext} camera
+ * @param {number} camera graph handle of the camera uniform
+ * @param {number} light_data graph handle of the light database buffer
  * @param {FrameGraph} graph
  * @return {number}
  */
-function graph_cull_lights_frustum({ lights, camera, graph }) {
+function graph_cull_lights_frustum({ lights, camera, light_data, graph }) {
     /**
      *
      * @param data
@@ -58,6 +60,8 @@ function graph_cull_lights_frustum({ lights, camera, graph }) {
     function execute(data, resources, context) {
 
         const output = resources.get(data.output);
+        const camera_buffer = resources.get(data.camera);
+        const light_buffer = resources.get(data.light_data);
 
         // Per-thread dispatch — one thread per (page, in_page_slot)
         // pair, sized to the table's currently allocated capacity.
@@ -72,8 +76,8 @@ function graph_cull_lights_frustum({ lights, camera, graph }) {
         shader_cull_point_lights_frustum.dispatchThreads({
             encoder: context.encoder,
             bindings: {
-                camera: camera.buffer,
-                light_data: lights.buffer_data,
+                camera: camera_buffer,
+                light_data: light_buffer,
                 output,
             },
             thread_count_x: point_thread_count,
@@ -82,8 +86,8 @@ function graph_cull_lights_frustum({ lights, camera, graph }) {
         shader_cull_spot_lights_frustum.dispatchThreads({
             encoder: context.encoder,
             bindings: {
-                camera: camera.buffer,
-                light_data: lights.buffer_data,
+                camera: camera_buffer,
+                light_data: light_buffer,
                 output,
             },
             thread_count_x: spot_thread_count,
@@ -95,6 +99,8 @@ function graph_cull_lights_frustum({ lights, camera, graph }) {
 
     const pass = graph.add("cull lights / frustum", data, execute);
 
+    data.camera = pass.read(camera);
+    data.light_data = pass.read(light_data);
     data.output = pass.create("list", OUTPUT_DESCRIPTOR);
 
     return data.output;
@@ -105,7 +111,8 @@ function graph_cull_lights_frustum({ lights, camera, graph }) {
  *
  * @param {number} list
  * @param {GPULightCollection} lights
- * @param {GPUCameraContext} camera
+ * @param {number} camera graph handle of the camera uniform
+ * @param {number} light_data graph handle of the light database buffer
  * @param {FrameGraph} graph
  * @param {number} hzb
  * @return {number}
@@ -114,6 +121,7 @@ function graph_cull_lights_hzb({
                                    list,
                                    lights,
                                    camera,
+                                   light_data,
                                    graph,
                                    hzb
                                }) {
@@ -128,6 +136,8 @@ function graph_cull_lights_hzb({
         const input = resources.get(data.input);
         const output = resources.get(data.output);
         const hzb = resources.get(data.hzb);
+        const camera_buffer = resources.get(data.camera);
+        const light_buffer = resources.get(data.light_data);
 
         const candidate_count = clusterable_light_count(lights);
 
@@ -142,9 +152,9 @@ function graph_cull_lights_hzb({
             encoder: context.encoder,
             bindings: {
                 texture_hzb: hzb,
-                camera: camera.buffer,
+                camera: camera_buffer,
                 input,
-                light_data: lights.buffer_data,
+                light_data: light_buffer,
                 output,
             },
             thread_count_x: candidate_count,
@@ -158,6 +168,8 @@ function graph_cull_lights_hzb({
 
     data.input = pass.read(list);
     data.hzb = pass.read(hzb);
+    data.camera = pass.read(camera);
+    data.light_data = pass.read(light_data);
     data.output = pass.create("output", OUTPUT_DESCRIPTOR);
 
     return data.output;
@@ -179,12 +191,24 @@ export function graph_cull_lights({
 
     // TODO cull useless lights where radius is <= 0 or total luma is <= 0
 
-    let culled = graph_cull_lights_frustum({ lights, camera, graph });
+    /*
+     Imported once and threaded, rather than reached for through the captured `camera` and `lights`
+     inside each execute. A pass binding a buffer off a captured object is a reader the graph cannot
+     see: culling, ordering and `validate()` all reason about declared handles only, and the DOT and
+     JSON exports and the profiler's topology show the pass with no inputs at all. Once per call
+     rather than once per pass, because two imports of one buffer are two entries the graph cannot
+     tell apart — see `graph_particles.js`, which states the same rule.
+    */
+    const gr_camera = graph_import_buffer(graph, camera.buffer.buffer, "Camera/current");
+    const gr_light_data = graph_import_buffer(graph, lights.buffer_data, "lights/database");
+
+    let culled = graph_cull_lights_frustum({ lights, camera: gr_camera, light_data: gr_light_data, graph });
 
     return graph_cull_lights_hzb({
         list: culled,
         lights,
-        camera,
+        camera: gr_camera,
+        light_data: gr_light_data,
         graph,
         hzb,
     });

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

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