@woosh/meep-engine 3.30.0 → 3.31.0

package/src/shade/renderer/GraphicsContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GraphicsContext.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/GraphicsContext.js"],"names":[],"mappings":"AAkCA;IA2JI,yBA+BC;IAzLD;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAOV;;OAEG;IACH,UAFU,iBAAiB,CAElB;IAET;;;OAGG;IACH,qDAOC;IAOD;;;OAGG;IACH,6CAEC;IAED;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,mBAFU,sBAAsB,CAEd;IAGlB;;OAEG;IACH,gBAFU,oBAAoB,CAEf;IAEf;;OAEG;IACH,UAFU,cAAc,CAEf;IAET;;;;OAIG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,aAFU,gBAAgB,CAEd;IAQZ;;;OAGG;IACH,uBAFU,kBAAkB,CAEN;IAEtB;;;;OAIG;IACH,yBAFU,wBAAwB,CAEV;IAExB;;;OAGG;IACH,0BAFU,yBAAyB,CAEV;IAEzB;;;;OAIG;IACH,2BAFU,0BAA0B,CAEV;IAE1B;;;OAGG;IACH,oBAFU,mBAAmB,CAEV;IAUnB;;;OAGG;IACH,8BAEC;IAED,uBAMC;IAED;;;OAGG;IACH,wBAEC;IAmCD;;;;;;;;OAQG;IACH,6DANW,sBAAsB,aACtB,oBAAoB,EAAE,cACtB;QAAC,MAAM,EAAE,YAAY,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,QAmE9D;IAED;;;;OAIG;IACH,gCAHW,gBAAgB,GACd,gBAAgB,CAI5B;IAED;;OAEG;IACH,+BAeC;IAED,4BAEC;IAED,eAyBC;IAED,gBAeC;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;+BA5VY,OAAO,0CAA0C,EAAE,gBAAgB;qCACnE,OAAO,kDAAkD,EAAE,sBAAsB;2BAKjF,OAAO,mCAAmC,EAAE,YAAY;mCAjBlC,kCAAkC;mCAGlC,kCAAkC;kCADnC,wBAAwB;2CAEf,mDAAmD;oCAH1D,2CAA2C;sCAZzC,6CAA6C;sCAC7C,6CAA6C;uCAF5C,8CAA8C;qCAIhD,0CAA0C;+BAehD,6BAA6B;sCACtB,4CAA4C;iCAdjD,+BAA+B;mCAC7B,gCAAgC;yCAC1B,sCAAsC;0CAGrC,uCAAuC;2CADtC,wCAAwC;oCAQ/C,kCAAkC;iCATtB,8BAA8B"}
+{"version":3,"file":"GraphicsContext.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/GraphicsContext.js"],"names":[],"mappings":"AAkCA;IA2JI,yBAgCC;IA1LD;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAOV;;OAEG;IACH,UAFU,iBAAiB,CAElB;IAET;;;OAGG;IACH,qDAOC;IAOD;;;OAGG;IACH,6CAEC;IAED;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,mBAFU,sBAAsB,CAEd;IAGlB;;OAEG;IACH,gBAFU,oBAAoB,CAEf;IAEf;;OAEG;IACH,UAFU,cAAc,CAEf;IAET;;;;OAIG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,aAFU,gBAAgB,CAEd;IAQZ;;;OAGG;IACH,uBAFU,kBAAkB,CAEN;IAEtB;;;;OAIG;IACH,yBAFU,wBAAwB,CAEV;IAExB;;;OAGG;IACH,0BAFU,yBAAyB,CAEV;IAEzB;;;;OAIG;IACH,2BAFU,0BAA0B,CAEV;IAE1B;;;OAGG;IACH,oBAFU,mBAAmB,CAEV;IAUnB;;;OAGG;IACH,8BAEC;IAED,uBAMC;IAED;;;OAGG;IACH,wBAEC;IAoCD;;;;;;;;OAQG;IACH,6DANW,sBAAsB,aACtB,oBAAoB,EAAE,cACtB;QAAC,MAAM,EAAE,YAAY,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,QAmE9D;IAED;;;;OAIG;IACH,gCAHW,gBAAgB,GACd,gBAAgB,CAI5B;IAED;;OAEG;IACH,+BAeC;IAED,4BAEC;IAED,eAyBC;IAED,gBAmBC;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;+BAjWY,OAAO,0CAA0C,EAAE,gBAAgB;qCACnE,OAAO,kDAAkD,EAAE,sBAAsB;2BAKjF,OAAO,mCAAmC,EAAE,YAAY;mCAjBlC,kCAAkC;mCAGlC,kCAAkC;kCADnC,wBAAwB;2CAEf,mDAAmD;oCAH1D,2CAA2C;sCAZzC,6CAA6C;sCAC7C,6CAA6C;uCAF5C,8CAA8C;qCAIhD,0CAA0C;+BAehD,6BAA6B;sCACtB,4CAA4C;iCAdjD,+BAA+B;mCAC7B,gCAAgC;yCAC1B,sCAAsC;0CAGrC,uCAAuC;2CADtC,wCAAwC;oCAQ/C,kCAAkC;iCATtB,8BAA8B"}

package/src/shade/renderer/GraphicsContext.js

@@ -215,9 +215,10 @@ export class GraphicsContext {
 
         this.virtual_textures = new VirtualTextureManager(device);
 
-        this.materials = new GPUMaterialManager(device, this.textures, this.render_pipelines, this.bind_groups, this.virtual_textures);
-
+        // before the materials, whose templates bind shared samplers
         this.samplers = new GPUSamplerManager(device);
+
+        this.materials = new GPUMaterialManager(device, this.textures, this.render_pipelines, this.bind_groups, this.virtual_textures, this.samplers);
     }
 
     /**
@@ -357,8 +358,12 @@ export class GraphicsContext {
     destroy() {
         // TODO implement
 
+        this.textures.destroy();
+
         this.virtual_textures.destroy();
 
+        this.materials.destroy();
+
         if (this.#materials_resident !== undefined) {
             this.#materials_resident.destroy();
         }

package/src/shade/renderer/Renderer.d.ts

@@ -304,6 +304,36 @@ export class Renderer {
      * @returns {number} how many extensions are registered on `phase`
      */
     extension_count(phase: FramePhase): number;
+    /**
+     * Put a transparent source that is not a meshlet bucket into the transparency pipeline: an
+     * `AVBOITSideChannel`, whose fragments are then composited order-independently against the
+     * transparent meshes, the particles and every other channel.
+     *
+     * **This is what an extension cannot do.** Work at `AfterTransparency` composites over the
+     * resolved transparency and cannot interleave with it. A channel is asked instead for its
+     * occupancy, its splat and its draw at the three points where the meshlet buckets contribute
+     * theirs, every frame; one that says it has nothing to add (`avboit_is_empty`) is left out of
+     * that frame, so registering one does not by itself make the pipeline run. There is no order to
+     * declare — order among channels changes no pixel.
+     *
+     * **AVBOIT only.** Under {@link ShadeTransparencyMode.MBOIT}, or with transparency off, a channel
+     * is asked for nothing and what it holds is not drawn — as for the particles.
+     *
+     * @param {AVBOITSideChannel} channel
+     * @returns {AVBOITSideChannel} `channel`, for handing back to {@link remove_transparency_channel}
+     */
+    add_transparency_channel(channel: AVBOITSideChannel): AVBOITSideChannel;
+    /**
+     * Take a channel back out of the transparency pipeline.
+     *
+     * @param {AVBOITSideChannel} channel
+     * @returns {boolean} whether it was registered
+     */
+    remove_transparency_channel(channel: AVBOITSideChannel): boolean;
+    /**
+     * @returns {number} how many transparency channels are registered
+     */
+    transparency_channel_count(): number;
     /**
      *
      * @param {Scene} scene
@@ -371,7 +401,22 @@ export class Renderer {
         pixelRatio?: number;
     }): Promise<void>;
     /**
-     * Cleanup
+     * Release everything {@link initialize} built, in reverse.
+     *
+     * This used to be the media-query listener and the particle systems, and nothing else: not the
+     * graphics context, not the depth ping-pong or TAA history textures, not the visibility
+     * target, not the scene, view or camera contexts — each of which owns GPU buffers — and none
+     * of the post-process subsystems. GraphicsEngine.stop() calls it and its own doc calls
+     * stop/start symmetric and repeatable, so a tool that swaps renderers per document exhausted
+     * device memory in a handful of cycles, leaking a whole G-buffer, depth and history set at
+     * output resolution plus the scene database, the meshlet pool, the light collection, every
+     * shadow view's camera buffer and the entire texture cache, every time.
+     *
+     * Two things stay out of it: {@link #postprocess} and {@link #path_tracer} own no GPU
+     * resources of their own and expose no teardown, and the device itself is not destroyed here
+     * because the renderer may not own it.
+     *
+     * @returns {void}
      */
     destroy(): void;
     init_render_targets(): void;
@@ -420,6 +465,7 @@ export class Renderer {
 export type GPUProfileSession = import("../device/timing/profile/GPUProfileSession.js").GPUProfileSession;
 export type PerspectiveCamera = import("./camera/PerspectiveCamera.js").PerspectiveCamera;
 export type RenderExtension = import("./extension/RenderExtension.js").RenderExtension;
+export type AVBOITSideChannel = import("./rasterize/native/avboit/AVBOITSideChannel.js").AVBOITSideChannel;
 export type GPUSceneContext = import("./scene/GPUSceneContext.js").GPUSceneContext;
 export type Scene = import("./scene/Scene.js").Scene;
 import { SceneManager } from "./scene/SceneManager.js";

package/src/shade/renderer/Renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"AA2GA;IAOI,0BAEC;IAED;;OAEG;IACH,0BAAQ;IAER;;;;;;OAMG;IACH,kDAEC;IAED;;OAEG;IACH,kBAAO;IAYP;;;OAGG;IACH,2BAEC;IAaD,wCAGC;IAED,uCAEC;IAED;;;;OAIG;IACH,wBAFU,yBAAyB,CAEoB;IAEvD;;;;;;;OAOG;IACH,mBAFU,qBAAqB,CAEkB;IAEjD;;;OAGG;IACH,QAFU,cAAc,CAEM;IAE9B;;;;;;;;;OASG;IACH,2BAFU,OAAO,CAEiB;IAElC,6BAA4B;IAC5B,8BAA4B;IAC5B;;;;OAIG;IACH,mCAAkC;IAClC;;;;;;;OAOG;IACH,mCAFU,OAAO,CAEyB;IAW1C,oCAIC;IAED,mCAEC;IAED,+BAA6B;IAC7B,4CAA0C;IAkB1C,qCAKC;IArBD;;;;;;;;;;OAUG;IACH,oCAGC;IASD;;;;;;;OAOG;IACH,0BAFU,OAAO,CAEe;IAQhC;;;;;OAKG;IACH,oCAOC;IAjBD,mCAEC;IAiBD;;;;;;;;;OASG;IACH,6BAFU,OAAO,CAEmB;IAWpC;;;;;OAKG;IACH,8BAA+C;IAE/C;;;;;;;;OAQG;IACH,6BAFU,OAAO,CAEmB;IAEpC;;;;;;;;;;;;;;OAcG;IACH,8BAFU,OAAO,CAEoB;IAErC;;;;;;;;;;OAUG;IACH,qBAFU,OAAO,CAEW;IAU5B;;;;;OAKG;IACH,wBAA0C;IAE1C;;;;;;;;OAQG;IACH,eAFU,UAAU,GAAC,QAAQ,CAEF;IAU3B;;;;OAIG;IACH,gCAAwD;IAExD;;;OAGG;IACH,4BAFU,OAAO,CAEiB;IAKlC;;;OAGG;IACH,yBAEC;IAOD;;;OAGG;IACH,gCAEC;IAcD;;;;;;;;;OASG;IACH,qBAA+B;IAE/B,wBAA+B;IAgB/B;;;OAGG;IACH,yCAeC;IAED;;;OAGG;IACH,wCAEC;IA0BD;;;OAGG;IACH,iCAEC;IAED;;;;OAIG;IACH,2BAEC;IAQD;;;OAGG;IACH,+CAIC;IAED;;;OAGG;IACH,gDAIC;IAwCD;;;OAGG;IACH,+BAcC;IA1BD;;;OAGG;IACH,0BAEC;IAsBD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,iBAFU,iBAAiB,GAAC,IAAI,CAET;IAEvB;;OAEG;IACH;;;;;;;;;;;;;;OAcG;IACH,yBAHW,eAAe,GACb,eAAe,CAI3B;IAED;;;;;OAKG;IACH,4BAHW,eAAe,GACb,OAAO,CAInB;IAED;;;OAGG;IACH,uBAHW,UAAU,GACR,MAAM,CAIlB;IAgBD;;;;OAIG;IACH,yBAHW,KAAK,GACJ,gBAAgB,CAW3B;IAED;;;OAGG;IACH,6BAYC;IAED;;;;OAIG;IACH,gCAHW,KAAK,GACH,2BAA2B,CAcvC;IAGD;;;OAGG;IACH,kBAFW,KAAK,QAyBf;IA8OD,oGAAoG;IACpG,kDAA2C;IAO3C;;;;OAIG;IACH,0BAEC;IAeD;;;;;;OAMG;IACH,qBAHW,eAAe,GACb,iBAAiB,CAW7B;IAgBD;;;;;;OAMG;IACH,cAFU,iBAAiB,CAEU;IAErC;;;;;;OAMG;IACH,eAgBC;IAiFD;;;;;;OAMG;IACH;QAJsC,OAAO;QACd,MAAM;QACT,UAAU,GAA3B,MAAM;sBAoOhB;IAED;;OAEG;IACH,gBAQC;IAQD,4BAwBC;IAqID;;;;;OAKG;IACH,UAHW,MAAM,KACN,MAAM,QAgBhB;IAoFD,0CAMC;IAED;;;;;;;;;;;;;OAaG;IACH,eARW,iBAAiB,SACjB,KAAK,uBACL,MAAM,GAIJ,OAAO,CAsBnB;IAED;;;;;;;;;;;;;;;OAeG;IACH,yBANW,iBAAiB,SACjB,KAAK,sBACL,MAAM,UACN,iBAAiB,GACf,OAAO,CA02BnB;;CACJ;gCA9gFY,OAAO,+CAA+C,EAAE,iBAAiB;gCACzE,OAAO,+BAA+B,EAAE,iBAAiB;8BACzD,OAAO,gCAAgC,EAAE,eAAe;8BACxD,OAAO,4BAA4B,EAAE,eAAe;oBACpD,OAAO,kBAAkB,EAAE,KAAK;6BArBhB,yBAAyB;0CACZ,gCAAgC;sCACpC,4BAA4B;+BACnC,6CAA6C;2BA1BjD,yCAAyC;6BAFvC,4CAA4C;8BAD3C,2CAA2C;4BAwC7C,uBAAuB;gCA7CnB,sBAAsB;mBArCnC,oCAAoC;oBACnC,4BAA4B;kCA8Ed,gCAAgC;2BA3DvC,2BAA2B;iCAyDrB,0CAA0C;4CA3C/B,+DAA+D;yBAgClF,yBAAyB;kCAChB,kCAAkC;kCAQlC,wBAAwB;oBA7BtC,0BAA0B;uCAPP,sDAAsD"}
+{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}

package/src/shade/renderer/Renderer.js

@@ -1,4 +1,5 @@
 import { assert } from "../../core/assert.js";
+import { frame_jitter_applies } from "./frame_jitter_applies.js";
 import Signal from "../../core/events/signal/Signal.js";
 import Vector2 from "../../core/geom/Vector2.js";
 import { clamp } from "../../core/math/clamp.js";
@@ -87,6 +88,7 @@ import { ViewManager } from "./view/ViewManager.js";
  * @typedef {import("../device/timing/profile/GPUProfileSession.js").GPUProfileSession} GPUProfileSession
  * @typedef {import("./camera/PerspectiveCamera.js").PerspectiveCamera} PerspectiveCamera
  * @typedef {import("./extension/RenderExtension.js").RenderExtension} RenderExtension
+ * @typedef {import("./rasterize/native/avboit/AVBOITSideChannel.js").AVBOITSideChannel} AVBOITSideChannel
  * @typedef {import("./scene/GPUSceneContext.js").GPUSceneContext} GPUSceneContext
  * @typedef {import("./scene/Scene.js").Scene} Scene
  */
@@ -702,6 +704,79 @@ export class Renderer {
         return this.#extensions.count(phase);
     }
 
+    /**
+     * Transparent sources an outside caller has put into the transparency pipeline, in the order
+     * they were added — which means nothing: the volume and the accumulators they draw into are sums.
+     *
+     * @type {AVBOITSideChannel[]}
+     */
+    #transparency_channels = [];
+
+    /**
+     * Put a transparent source that is not a meshlet bucket into the transparency pipeline: an
+     * `AVBOITSideChannel`, whose fragments are then composited order-independently against the
+     * transparent meshes, the particles and every other channel.
+     *
+     * **This is what an extension cannot do.** Work at `AfterTransparency` composites over the
+     * resolved transparency and cannot interleave with it. A channel is asked instead for its
+     * occupancy, its splat and its draw at the three points where the meshlet buckets contribute
+     * theirs, every frame; one that says it has nothing to add (`avboit_is_empty`) is left out of
+     * that frame, so registering one does not by itself make the pipeline run. There is no order to
+     * declare — order among channels changes no pixel.
+     *
+     * **AVBOIT only.** Under {@link ShadeTransparencyMode.MBOIT}, or with transparency off, a channel
+     * is asked for nothing and what it holds is not drawn — as for the particles.
+     *
+     * @param {AVBOITSideChannel} channel
+     * @returns {AVBOITSideChannel} `channel`, for handing back to {@link remove_transparency_channel}
+     */
+    add_transparency_channel(channel) {
+        assert.defined(channel, 'channel');
+        assert.isFunction(channel.avboit_occupancy, 'channel.avboit_occupancy');
+        assert.isFunction(channel.avboit_splat, 'channel.avboit_splat');
+        assert.isFunction(channel.avboit_draw, 'channel.avboit_draw');
+
+        if (channel.avboit_is_empty !== undefined) {
+            // optional, but asked every frame when present — a flag where a method belongs would
+            // throw in the middle of a frame rather than here
+            assert.isFunction(channel.avboit_is_empty, 'channel.avboit_is_empty');
+        }
+
+        // Once, whatever the caller does. In the list twice it would be drawn twice — every
+        // extinction and every colour it adds, doubled — and that has to hold in a build whose
+        // asserts are stripped, so a repeat is a no-op rather than a failed assertion.
+        if (!this.#transparency_channels.includes(channel)) {
+            this.#transparency_channels.push(channel);
+        }
+
+        return channel;
+    }
+
+    /**
+     * Take a channel back out of the transparency pipeline.
+     *
+     * @param {AVBOITSideChannel} channel
+     * @returns {boolean} whether it was registered
+     */
+    remove_transparency_channel(channel) {
+        const index = this.#transparency_channels.indexOf(channel);
+
+        if (index === -1) {
+            return false;
+        }
+
+        this.#transparency_channels.splice(index, 1);
+
+        return true;
+    }
+
+    /**
+     * @returns {number} how many transparency channels are registered
+     */
+    transparency_channel_count() {
+        return this.#transparency_channels.length;
+    }
+
 
     /**
      *
@@ -1060,10 +1135,12 @@ export class Renderer {
     #particle_systems = new Map();
 
     /**
-     * The side-channel list handed to the transparency orchestrator, reused frame to frame.
-     * @type {GPUParticleSystem[]}
+     * The side-channel list handed to the transparency orchestrator, rebuilt every frame and reused
+     * frame to frame: the particles when they are on, then every registered transparency channel
+     * that has something to add.
+     * @type {AVBOITSideChannel[]}
      */
-    #particle_side_channels = [];
+    #side_channels = [];
 
     /**
      * The particle system of a scene — created on first use, so a scene without emitters costs
@@ -1446,9 +1523,37 @@ export class Renderer {
     }
 
     /**
-     * Cleanup
+     * Whether {@link destroy} has been called. Rendering afterwards would encode against resources
+     * that are gone, so it refuses the same way a lost device does.
+     *
+     * @type {boolean}
+     */
+    #destroyed = false;
+
+    /**
+     * Release everything {@link initialize} built, in reverse.
+     *
+     * This used to be the media-query listener and the particle systems, and nothing else: not the
+     * graphics context, not the depth ping-pong or TAA history textures, not the visibility
+     * target, not the scene, view or camera contexts — each of which owns GPU buffers — and none
+     * of the post-process subsystems. GraphicsEngine.stop() calls it and its own doc calls
+     * stop/start symmetric and repeatable, so a tool that swaps renderers per document exhausted
+     * device memory in a handful of cycles, leaking a whole G-buffer, depth and history set at
+     * output resolution plus the scene database, the meshlet pool, the light collection, every
+     * shadow view's camera buffer and the entire texture cache, every time.
+     *
+     * Two things stay out of it: {@link #postprocess} and {@link #path_tracer} own no GPU
+     * resources of their own and expose no teardown, and the device itself is not destroyed here
+     * because the renderer may not own it.
+     *
+     * @returns {void}
      */
     destroy() {
+        if (this.#destroyed) {
+            return;
+        }
+
+        this.#destroyed = true;
 
         window.matchMedia("(dynamic-range: high)").removeEventListener("change", this.#update_hdr_support);
 
@@ -1456,6 +1561,54 @@ export class Renderer {
             system.destroy();
         }
         this.#particle_systems.clear();
+
+        for (const baker of this.#probe_bakers.values()) {
+            baker.destroy();
+        }
+        this.#probe_bakers.clear();
+
+        for (const sdf of this.#scene_sdfs.values()) {
+            sdf.destroy();
+        }
+        this.#scene_sdfs.clear();
+
+        this.#autoexposure?.destroy();
+        this.#depth_of_field?.destroy();
+        this.#depth_of_field_unreal?.destroy();
+        this.#restir_di?.destroy();
+        this.#nss?.destroy();
+
+        this.#views?.destroy();
+        this.#scenes?.destroy();
+        this.#cameras?.destroy();
+
+        this.#destroy_render_targets();
+
+        this.#graphics?.destroy();
+    }
+
+    /**
+     * The textures {@link init_render_targets} and {@link #resize_render_targets} allocate outside
+     * the frame graph. They come from `textures.contextFromDescriptor`, which does not put them in
+     * the manager's cache, so nothing else will ever release them.
+     *
+     * @returns {void}
+     */
+    #destroy_render_targets() {
+        const targets = [
+            ...this.#textures_depth,
+            ...this.#textures_taa_history,
+            ...(this.#vis_render_target?.color_attachments ?? []),
+        ];
+
+        for (const target of targets) {
+            target?.destroy();
+        }
+
+        this.#textures_depth.fill(undefined);
+        this.#textures_taa_history.fill(undefined);
+
+        this.#vis_render_target = undefined;
     }
 
 
@@ -1752,8 +1905,9 @@ export class Renderer {
         scene,
         time_delta_seconds = 0
     ) {
-        if (this.#device_lost) {
-            // device is lost, can't render — and asking the context for a texture would throw
+        if (this.#device_lost || this.#destroyed) {
+            // device is lost or the renderer was torn down, so there is nothing to encode against —
+            // and asking the context for a texture would throw
             return false;
         }
 
@@ -1794,8 +1948,8 @@ export class Renderer {
         assert.defined(target, 'target');
         assert.equal(target.isGPUTextureContext, true, 'target.isGPUTextureContext !== true');
 
-        if (this.#device_lost) {
-            // device is lost, can't render
+        if (this.#device_lost || this.#destroyed) {
+            // device is lost or the renderer was torn down, so there is nothing to encode against
             return false;
         }
 
@@ -1839,8 +1993,11 @@ export class Renderer {
 
         const resolution_internal = this.#internal_resolution;
         {
-            const jitter_x = jitter_source.Jitter[0];
-            const jitter_y = jitter_source.Jitter[1];
+            // no jitter when nothing is going to resolve it — see frame_jitter_applies
+            const jitter_applies = frame_jitter_applies(this.#feature_taa_enabled, this.upscale_type);
+
+            const jitter_x = jitter_applies ? jitter_source.Jitter[0] : 0;
+            const jitter_y = jitter_applies ? jitter_source.Jitter[1] : 0;
 
             view_ctx.setJitter(jitter_x, jitter_y);
             view_ctx.setViewportSize(resolution_internal.x, resolution_internal.y);
@@ -2326,8 +2483,8 @@ export class Renderer {
 
         // Particles move here, after the scene's nodes have their world matrices for the frame, and
         // draw below as a side channel of the transparency pipeline.
-        const particle_side_channels = this.#particle_side_channels;
-        particle_side_channels.length = 0;
+        const side_channels = this.#side_channels;
+        side_channels.length = 0;
 
         if (this.feature_particles_enabled) {
             const particles = this.particles(scene_ctx);
@@ -2345,7 +2502,26 @@ export class Renderer {
                 dt: time_delta_seconds,
             });
 
-            particle_side_channels.push(particles);
+            side_channels.push(particles);
+        }
+
+        // Every channel registered from outside, unless it says it has nothing to add: the
+        // orchestrator runs whenever it has a channel, and one that is always registered would
+        // otherwise make every frame pay for the whole pipeline. Only when something will ask them
+        // — with transparency off, or under MBOIT, which takes no side channels, a channel is not
+        // consulted at all.
+        if (this.#feature_enabled_transparencies && this.transparency_mode === ShadeTransparencyMode.AVBOIT) {
+            const transparency_channels = this.#transparency_channels;
+
+            for (let i = 0; i < transparency_channels.length; i++) {
+                const channel = transparency_channels[i];
+
+                if (channel.avboit_is_empty !== undefined && channel.avboit_is_empty()) {
+                    continue;
+                }
+
+                side_channels.push(channel);
+            }
         }
 
         if (this.#feature_enabled_transparencies) {
@@ -2379,7 +2555,7 @@ export class Renderer {
 
                 indirect_lighting_mode: this.indirect_lighting_mode,
                 avboit: this.avboit,
-                side_channels: particle_side_channels,
+                side_channels,
             });
 
             graph.pop_scope();
@@ -2484,6 +2660,9 @@ export class Renderer {
                 velocity: gr_velocity,
                 depth: gr_texture_depth_current,
                 resolution: this.#output_resolution.asArray(),
+                // both are built against the internal resolution, which is not the output grid
+                // whenever anything is being upscaled
+                velocity_resolution: this.#internal_resolution.asArray(),
             });
         }
 
@@ -2505,27 +2684,45 @@ export class Renderer {
 
         let exposure = -1;
 
-        if (this.feature_bloom_enabled || this.feature_automatic_exposure_enabled) {
+        /*
+         The scene as it stands before bloom composites over it: what the metering reads, and what
+         bloom reads too.
+
+         The metering used to read `bloom.downsampled` — mip 0 of the bloom chain — because it was
+         already half-res and already there. It is produced by `downsample_karis`, which weights
+         each tap by 1/(1+luma) for the express purpose of DESTROYING bright outliers so they do not
+         bloom, and the histogram is read over the 70th to 95th percentile window: exactly the
+         bright tail that weighting suppresses. Three dark texels and one bright one in a quad
+         average 6x darker through it than through a box filter, so a scene with small bright
+         highlights — sun glints, emissive signage, a lit window in a dark room — metered low and
+         was therefore rendered over-exposed by the same amount. The coupling was invisible from
+         here: the two subsystems shared a texture for a reason that had nothing to do with
+         metering, and the filter that made it wrong lives in the bloom folder.
+
+         Full-res, so the tail it meters is the tail that is on screen. That is four times the
+         histogram invocations of the old half-res mip, on a shader that is a load, a luminance and
+         an atomic add.
+        */
+        const metered_color = current_color_out;
+
+        if (this.feature_bloom_enabled) {
             const bloom = graph_postprocess_bloom({
                 graph,
                 input: current_color_out,
                 resolution: this.#output_resolution.asArray(),
             });
 
-            if (this.feature_bloom_enabled) {
-                current_color_out = bloom.composited;
-            }
+            current_color_out = bloom.composited;
+        }
 
-            if (this.feature_automatic_exposure_enabled) {
-                // TODO force time_delta_second to a very high value on view transition
-
-                exposure = this.#autoexposure.update({
-                    graph,
-                    input_color: bloom.downsampled,
-                    time_delta_seconds,
-                });
-            }
+        if (this.feature_automatic_exposure_enabled) {
+            // TODO force time_delta_second to a very high value on view transition
 
+            exposure = this.#autoexposure.update({
+                graph,
+                input_color: metered_color,
+                time_delta_seconds,
+            });
         }
 
 

package/src/shade/renderer/animation/ANIMATION_CLIP_STATE_STRUCT.d.ts

@@ -7,13 +7,10 @@
  * the curves' clock) and feeds the result to each bound track's curve
  * evaluator.
  *
- * Membership is represented as a singly-linked list of bound-track group
- * nodes whose head index is {@link bound_track_group_head}. Group nodes
- * each inline up to {@link TRACKS_PER_GROUP_NODE} bindings and chain
- * forward via their own `next` pointer; clips with zero bindings store
- * `0xFFFFFFFF`. The chain replaces the previous `animation_clip_bindings`
- * relationship table, so adding bindings to a clip no longer touches a
- * separate table.
+ * Membership is a run of rows of `animation_bindings`, named by
+ * {@link bindings_first} and {@link bindings_count} — a range the database
+ * knows about, so removing the clip's row takes its bindings with it. A
+ * clip with no bindings yet holds the empty range `(0xFFFFFFFF, 0)`.
  *
  * Tracks within a clip don't have to share the clip's `[time_start,
  * time_end]` window — their curves are clamped to their own

package/src/shade/renderer/animation/ANIMATION_CLIP_STATE_STRUCT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ANIMATION_CLIP_STATE_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/ANIMATION_CLIP_STATE_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,uDA2EyB;6BApGI,gCAAgC"}
+{"version":3,"file":"ANIMATION_CLIP_STATE_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/ANIMATION_CLIP_STATE_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,uDAiFyB;6BAvGI,gCAAgC"}

package/src/shade/renderer/animation/ANIMATION_CLIP_STATE_STRUCT.js

@@ -10,13 +10,10 @@ import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
  * the curves' clock) and feeds the result to each bound track's curve
  * evaluator.
  *
- * Membership is represented as a singly-linked list of bound-track group
- * nodes whose head index is {@link bound_track_group_head}. Group nodes
- * each inline up to {@link TRACKS_PER_GROUP_NODE} bindings and chain
- * forward via their own `next` pointer; clips with zero bindings store
- * `0xFFFFFFFF`. The chain replaces the previous `animation_clip_bindings`
- * relationship table, so adding bindings to a clip no longer touches a
- * separate table.
+ * Membership is a run of rows of `animation_bindings`, named by
+ * {@link bindings_first} and {@link bindings_count} — a range the database
+ * knows about, so removing the clip's row takes its bindings with it. A
+ * clip with no bindings yet holds the empty range `(0xFFFFFFFF, 0)`.
  *
  * Tracks within a clip don't have to share the clip's `[time_start,
  * time_end]` window — their curves are clamped to their own
@@ -55,11 +52,15 @@ export const ANIMATION_CLIP_STATE_STRUCT = WebGPUStruct.from({
     time_end: f32,
 
     /**
-     * Index of the head node of the bound-track group chain in the
-     * `animation_bound_track_groups` table, or `0xFFFFFFFF` if the clip
-     * has no bindings.
+     * First row of the clip's bindings in the `animation_bindings` table,
+     * or `0xFFFFFFFF` if the clip has none.
      */
-    bound_track_group_head: u32,
+    bindings_first: u32,
+
+    /**
+     * How many bindings the run holds; 0 if the clip has none.
+     */
+    bindings_count: u32,
 
     /**
      * Per-frame `time` advance is `dt * playback_rate`. `1.0` is
@@ -71,11 +72,13 @@ export const ANIMATION_CLIP_STATE_STRUCT = WebGPUStruct.from({
 
     /**
      * Bitfield of {@link AnimationClipFlags} — `Playing`, `Loop`, etc.
-     * The tick shader reads this every frame; the host writes it via
-     * {@link GPUAnimationManager#set_flags} (full overwrite) or has it
-     * partially toggled by {@link GPUAnimationManager#start} /
-     * {@link GPUAnimationManager#stop} (Playing bit only). Defaults to
-     * `0` at clip creation: not playing, not looping.
+     * The tick shader reads this every frame and never writes it; the
+     * host sets and clears bits of it via
+     * {@link GPUAnimationManager#set_flags} /
+     * {@link GPUAnimationManager#clear_flags}, or the Playing bit alone
+     * via {@link GPUAnimationManager#start} /
+     * {@link GPUAnimationManager#stop}. Defaults to `0` at clip
+     * creation: not playing, not looping.
      */
     flags: u32,
 

package/src/shade/renderer/animation/ANIMATION_CURVE_HEADER_STRUCT.js

@@ -7,21 +7,21 @@ export const ANIMATION_CURVE_HEADER_STRUCT = WebGPUStruct.from({
      */
     kind: u32,
     /**
-     * Index of the head keyframe block in the `animation_keyframe_blocks`
-     * table. The block at this index inlines up to
-     * {@link KEYFRAMES_PER_BLOCK} keyframes and points at the next block
-     * via its own `next` field; the chain ends when a block's `next` is
-     * `0xFFFFFFFF`. Replaces the previous "contiguous run of keyframes"
-     * layout, so curves can grow independently without forcing
-     * keyframe-table compaction.
+     * First row of the curve's keyframes in the `animation_keyframes` table: a run of
+     * {@link keyframe_count} rows, one keyframe each, in ascending time order. The two words are a
+     * range the database knows about, so removing the curve's row would take its keyframes with it.
      */
-    keyframe_block_head: u32,
+    keyframes_first: u32,
     /**
-     * Total number of keyframes summed across the chain. The evaluator
-     * uses this only for the single-keyframe fast path; ordinary
-     * evaluation walks blocks until it hits the chain terminator.
+     * How many keyframes the run holds — at least one for any curve.
      */
     keyframe_count: u32,
+    /**
+     * Time of the first keyframe.
+     */
     time_min: f32,
+    /**
+     * Time of the last keyframe.
+     */
     time_max: f32,
 })

package/src/shade/renderer/animation/ANIMATION_DATABASE_SPEC.d.ts

@@ -4,30 +4,26 @@
  * Tables fall into three categories:
  *
  *  - **Animation data** (immutable per curve definition): `animation_curves`
- *    (curve headers), `animation_keyframe_blocks` (linked-list nodes
- *    holding inline keyframes), `animation_tracks` (per-track masks +
+ *    (curve headers, each naming a run of keyframes), `animation_keyframes`
+ *    (one keyframe per row), `animation_tracks` (per-track masks +
  *    curve refs). Pure shape — no reference to specific targets. Multiple
  *    bound clips can share the same tracks.
  *
  *  - **Bound state**: `animation_clips` (per bound clip — `time`,
- *    `time_start`, `time_end`, head of bound-track group chain) and
- *    `animation_bound_track_groups` (linked-list nodes inlining the
- *    bound-track records). One thread per group node drives the apply
- *    pass; nodes back-reference their owning clip so that dispatch
- *    doesn't need to walk from the clip end.
+ *    `time_start`, `time_end`, and the run of its bindings) and
+ *    `animation_bindings` (one bound track per row, carrying its clip).
+ *    One thread per binding drives the apply pass, finding its clip's
+ *    time through the binding's own `clip`.
  *
- *  - **Skinning**: `animation_skins` (one row per skin — joint count
- *    plus head of joint block chain plus base offset into the shared
- *    skin-matrices scratch buffer) and `animation_skin_joint_blocks`
- *    (linked-list nodes inlining joint records: Node3D ref +
- *    inverse-bind matrix). The skin-matrix-prep pass walks the joint
- *    blocks per-frame; one thread per block writes
- *    `node.global * inverse_bind` for every inline joint into the
- *    scratch buffer at the block's pre-baked absolute offset.
+ *  - **Skinning**: `animation_skins` (one row per skin — the run of its
+ *    joints) and `animation_skin_joints` (one joint per row: Node3D ref +
+ *    inverse-bind matrix). The skin-matrix-prep pass runs one thread per
+ *    joint row, writing `node.global * inverse_bind` into the shared
+ *    skin-matrices scratch buffer at the joint's own row.
  *
- * The previous `animation_bindings` and `animation_clip_bindings` tables
- * are gone — the group-node chain inlines binding records and replaces
- * the relationship table.
+ * Where a record has many of something, they are a run of rows it names by
+ * its first row and a count — a range, declared below, so removing the
+ * record removes the run.
  */
 export const ANIMATION_DATABASE_SPEC: GPUDatabaseDefinition;
 import { GPUDatabaseDefinition } from "../buffer/table/GPUDatabaseDefinition.js";

package/src/shade/renderer/animation/ANIMATION_DATABASE_SPEC.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ANIMATION_DATABASE_SPEC.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/ANIMATION_DATABASE_SPEC.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,4DAQG;sCAhDmC,0CAA0C"}
+{"version":3,"file":"ANIMATION_DATABASE_SPEC.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/ANIMATION_DATABASE_SPEC.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,4DAQG;sCA7CmC,0CAA0C"}