@woosh/meep-engine 3.30.0 → 3.32.0

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

@@ -64,10 +64,17 @@ export class GraphicsContext {
      */
     buffer_allocator_native: GPUBufferAllocatorNative;
     /**
-     * Used to upload data to the GPU
+     * Mapped `MAP_WRITE` buffers, one per upload: where a {@link ShadeGPUCommandContext} sends its
+     * large writes, for which a mapping is the faster road (see `MAPPED_UPLOAD_THRESHOLD`).
      * @type {GPUBufferStagingAllocator}
      */
     buffer_allocator_staging: GPUBufferStagingAllocator;
+    /**
+     * Upload blocks for {@link ShadeGPUCommandContext}'s small writes — every uniform a pass is
+     * handed by value among them. Sent with one queue write per block, not mapped.
+     * @type {GPUBufferUploadAllocator}
+     */
+    buffer_allocator_upload: GPUBufferUploadAllocator;
     /**
      * Used to read data back from the GPU: `MAP_READ` buffers, held by the CPU across frames, which
      * is why they cannot come from {@link buffer_allocator_main}.
@@ -142,6 +149,7 @@ import { BindGroupManager } from "./binding/BindGroupManager.js";
 import { GPUBufferAllocator } from "./buffer/GPUBufferAllocator.js";
 import { GPUBufferAllocatorNative } from "./buffer/GPUBufferAllocatorNative.js";
 import { GPUBufferStagingAllocator } from "./buffer/GPUBufferStagingAllocator.js";
+import { GPUBufferUploadAllocator } from "./buffer/GPUBufferUploadAllocator.js";
 import { GPUBufferReadbackAllocator } from "./buffer/GPUBufferReadbackAllocator.js";
 import { GPUTextureAllocator } from "./texture/GPUTextureAllocator.js";
 import { GPUBufferContext } from "./buffer/GPUBufferContext.js";

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":"AAmCA;IAoKI,yBAiCC;IApMD;;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;;;;OAIG;IACH,0BAFU,yBAAyB,CAEV;IAEzB;;;;OAIG;IACH,yBAFU,wBAAwB,CAEV;IAExB;;;;OAIG;IACH,2BAFU,0BAA0B,CAEV;IAE1B;;;OAGG;IACH,oBAFU,mBAAmB,CAEV;IAUnB;;;OAGG;IACH,8BAEC;IAED,uBAOC;IAED;;;OAGG;IACH,wBAEC;IAqCD;;;;;;;;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,+BAgBC;IAED,4BAEC;IAED,eAmDC;IAED,gBAoBC;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;+BAvYY,OAAO,0CAA0C,EAAE,gBAAgB;qCACnE,OAAO,kDAAkD,EAAE,sBAAsB;2BAKjF,OAAO,mCAAmC,EAAE,YAAY;mCAjBlC,kCAAkC;mCAGlC,kCAAkC;kCADnC,wBAAwB;2CAEf,mDAAmD;oCAH1D,2CAA2C;sCAbzC,6CAA6C;sCAC7C,6CAA6C;uCAF5C,8CAA8C;qCAIhD,0CAA0C;+BAgBhD,6BAA6B;sCACtB,4CAA4C;iCAfjD,+BAA+B;mCAC7B,gCAAgC;yCAC1B,sCAAsC;0CAGrC,uCAAuC;yCACxC,sCAAsC;2CAFpC,wCAAwC;oCAS/C,kCAAkC;iCAVtB,8BAA8B"}

package/src/shade/renderer/GraphicsContext.js

@@ -11,6 +11,7 @@ import { GPUBufferAllocatorNative } from "./buffer/GPUBufferAllocatorNative.js";
 import { create_buffer, GPUBufferContext } from "./buffer/GPUBufferContext.js";
 import { GPUBufferReadbackAllocator } from "./buffer/GPUBufferReadbackAllocator.js";
 import { GPUBufferStagingAllocator } from "./buffer/GPUBufferStagingAllocator.js";
+import { GPUBufferUploadAllocator } from "./buffer/GPUBufferUploadAllocator.js";
 import { GPUGeometryManager } from "./geometry/GPUGeometryManager.js";
 import { GPUCollectionLimits } from "./rasterize/expand/GPUCollectionLimits.js";
 import { GPUSamplerManager } from "./GPUSamplerManager.js";
@@ -137,11 +138,19 @@ export class GraphicsContext {
     buffer_allocator_native;
 
     /**
-     * Used to upload data to the GPU
+     * Mapped `MAP_WRITE` buffers, one per upload: where a {@link ShadeGPUCommandContext} sends its
+     * large writes, for which a mapping is the faster road (see `MAPPED_UPLOAD_THRESHOLD`).
      * @type {GPUBufferStagingAllocator}
      */
     buffer_allocator_staging;
 
+    /**
+     * Upload blocks for {@link ShadeGPUCommandContext}'s small writes — every uniform a pass is
+     * handed by value among them. Sent with one queue write per block, not mapped.
+     * @type {GPUBufferUploadAllocator}
+     */
+    buffer_allocator_upload;
+
     /**
      * Used to read data back from the GPU: `MAP_READ` buffers, held by the CPU across frames, which
      * is why they cannot come from {@link buffer_allocator_main}.
@@ -174,8 +183,9 @@ export class GraphicsContext {
     increment_time() {
         this.#timer_increment++;
 
-        // advance the single frame clock for both substitutable pools in lockstep
+        // advance the single frame clock for the substitutable pools in lockstep
         this.buffer_allocator_main.increment_time();
+        this.buffer_allocator_upload.increment_time();
         this.allocator_textures.increment_time();
     }
 
@@ -197,6 +207,7 @@ export class GraphicsContext {
         this.buffer_allocator_main = new GPUBufferAllocator(device);
         this.buffer_allocator_native = new GPUBufferAllocatorNative(device);
         this.buffer_allocator_staging = new GPUBufferStagingAllocator(device);
+        this.buffer_allocator_upload = new GPUBufferUploadAllocator(device);
         this.buffer_allocator_readback = new GPUBufferReadbackAllocator(device);
 
         this.allocator_textures = new GPUTextureAllocator(device);
@@ -215,9 +226,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);
     }
 
     /**
@@ -315,6 +327,7 @@ export class GraphicsContext {
 
         r += this.buffer_allocator_main.gpu_memory_usage;
         r += this.buffer_allocator_staging.gpu_memory_usage;
+        r += this.buffer_allocator_upload.gpu_memory_usage;
         r += this.buffer_allocator_readback.gpu_memory_usage;
 
         r += this.allocator_textures.gpu_memory_usage;
@@ -330,35 +343,65 @@ export class GraphicsContext {
     update() {
         const command_ctx = ShadeGPUCommandContext.create(this, 'GraphicsContext.update');
 
-        // The one place per frame the meshlet pool compacts, at the head of the frame: before the
-        // clone flush in geometries.update, before the VG runtime's flush, before any pass. Its
-        // per-frame bound is a bound because this is the only call (COMPACTION_PLAN_2026_09_16
-        // §4.5).
-        this.geometries.meshlets.sweep(command_ctx);
+        /**
+         * What the update raised, if anything. Held so the context is finished before it is
+         * re-raised: a context never finished keeps everything it took for good — an upload block,
+         * transient buffers — and a manager that throws every frame would leak that much every
+         * frame.
+         * @type {*}
+         */
+        let update_error = null;
+
+        try {
+            // The one place per frame the meshlet pool compacts, at the head of the frame: before the
+            // clone flush in geometries.update, before the VG runtime's flush, before any pass. Its
+            // per-frame bound is a bound because this is the only call (COMPACTION_PLAN_2026_09_16
+            // §4.5).
+            this.geometries.meshlets.sweep(command_ctx);
+
+            this.geometries.update(command_ctx);
 
-        this.geometries.update(command_ctx);
+            this.textures.update();
+            this.materials.update(command_ctx);
 
-        this.textures.update();
-        this.materials.update(command_ctx);
+            this.bind_groups.update();
 
-        this.bind_groups.update();
+            this.increment_time();
 
-        this.increment_time();
+            this.allocator_textures.update();
 
-        this.allocator_textures.update();
+            this.#collection_limits.update(command_ctx, this.buffer_allocator_main);
+        } catch (e) {
+            update_error = e;
+        }
 
-        this.#collection_limits.update(command_ctx, this.buffer_allocator_main);
+        try {
+            command_ctx.finish();
+        } catch (teardown_error) {
+            if (update_error === null) {
+                throw teardown_error;
+            }
 
-        command_ctx.finish();
+            // already unwinding: the update's own error is the one the caller needs to see
+        }
+
+        if (update_error !== null) {
+            throw update_error;
+        }
 
         this.buffer_allocator_main.update();
+        this.buffer_allocator_upload.update();
     }
 
     destroy() {
         // TODO implement
 
+        this.textures.destroy();
+
         this.virtual_textures.destroy();
 
+        this.materials.destroy();
+
         if (this.#materials_resident !== undefined) {
             this.#materials_resident.destroy();
         }
@@ -366,6 +409,7 @@ export class GraphicsContext {
         this.buffer_allocator_main.destroy();
         this.buffer_allocator_native.destroy();
         this.buffer_allocator_staging.destroy();
+        this.buffer_allocator_upload.destroy();
         this.buffer_allocator_readback.destroy();
 
         this.#collection_limits.destroy();

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

@@ -210,7 +210,18 @@ export class Renderer {
      * @type {Signal<ShadeDeviceFailure>}
      */
     onDeviceFailure: any;
-    onFrameFinished: Signal;
+    /**
+     * Sent at the end of every frame {@link render} or {@link render_to_target} completes, with the
+     * number of frames completed so far. A frame that throws is not one of them: whatever it had
+     * recorded may still have been submitted, but it sends nothing and is not counted.
+     *
+     * **Submitted, not finished.** The frame's commands have been handed to the queue and the GPU
+     * may not have started them; a listener that needs the GPU to be done with the frame waits on
+     * {@link GPUQueue#onSubmittedWorkDone} instead.
+     *
+     * @type {Signal<number>}
+     */
+    onFrameFinished: any;
     /**
      *
      * @param {number} v
@@ -304,6 +315,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 +412,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;
@@ -395,7 +451,9 @@ export class Renderer {
      * simulation, the animation tick and exposure adaptation all step by it. Zero by default, which
      * draws the current state and moves nothing; a fixed fraction of a second here instead would run
      * the simulation at that rate no matter what the caller's clock was doing.
-     * @returns {boolean} whether frame was rendered, will return false if previous frame hasn't finished yet
+     * @returns {boolean} whether a frame was encoded and submitted. False only when there is nothing
+     * to draw with — the device was lost, or the renderer destroyed. Frames the GPU has not finished
+     * yet neither hold this one back nor make it return false.
      */
     render(camera: PerspectiveCamera, scene: Scene, time_delta_seconds?: number): boolean;
     /**
@@ -412,14 +470,18 @@ export class Renderer {
      * @param {Scene} scene
      * @param {number} time_delta_seconds
      * @param {GPUTextureContext} target must match {@link output_resolution}
-     * @returns {boolean} whether frame was rendered, will return false if previous frame hasn't finished yet
+     * @returns {boolean} whether a frame was encoded and submitted. False only when there is nothing
+     * to draw with — the device was lost, or the renderer destroyed. Frames the GPU has not finished
+     * yet neither hold this one back nor make it return false.
      */
     render_to_target(camera: PerspectiveCamera, scene: Scene, time_delta_seconds: number, target: GPUTextureContext): boolean;
     #private;
 }
+export type GPUFrameRecorder = import("../device/timing/profile/GPUFrameRecorder.js").GPUFrameRecorder;
 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";
@@ -431,7 +493,6 @@ import { DepthOfField } from "./postprocess/dof/raymarch/DepthOfField.js";
 import { DepthOfFieldU } from "./postprocess/dof/gather/DepthOfFieldU.js";
 import { ViewManager } from "./view/ViewManager.js";
 import { GraphicsContext } from "./GraphicsContext.js";
-import Signal from "../../core/events/signal/Signal.js";
 import Vector2 from "../../core/geom/Vector2.js";
 import { GPUTextureContext } from "./texture/GPUTextureContext.js";
 import { FramePhase } from "./extension/FramePhase.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":"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"}
+{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}