@woosh/meep-engine 3.31.0 → 3.33.0

package/src/shade/RENDERER_CONTRACT.md

@@ -398,14 +398,18 @@ class PathExtension extends RenderExtension {
         }
 
         const scene = frame.get(SceneColor);
+        const view = frame.get(ViewTextures);
 
-        scene.color = this.#renderer.graph_draw({
+        const drawn = this.#renderer.graph_draw({
             graph: frame.graph,
             batch: this.#batch,
             color: scene.color,
-            depth: frame.get(ViewTextures).depth,
+            depth: view.depth,
             camera: frame.view.camera.buffer
         });
+
+        scene.color = drawn.color;
+        view.depth = drawn.depth;
     }
 }
 
@@ -590,6 +594,15 @@ which is what effects want. Set it and the pass writes depth instead: a solid su
 build behind it has no depth ordering otherwise, and no CPU sort can give it one, because a painter's
 order over triangles is wrong wherever two of them interpenetrate.
 
+`graph_draw` hands back `{ color, depth }`, and an extension publishes both, as in §6. The depth is a
+new handle when the pass wrote it. Anything reading the scene depth after you — depth of field,
+motion blur, the NSS upscaler, the next extension — has to be given that handle; a development build
+refuses the frame when it is not. Left `false`, the depth comes back as it went in.
+
+That is also what decides the phase for solid content. At `AfterLighting` transparency has not run
+yet, and it tests against the depth you published, so glass in front of the batch covers it. At
+`AfterTransparency` the glass is already resolved into the colour, and the batch is drawn over it.
+
 Residency is keyed on **the geometry**, not on batch membership, so a mesh that blinks off for a
 frame or is removed and re-added keeps its buffers.
 

package/src/shade/device/IMMEDIATE_DATA_PLAN_2026_08_28.md

@@ -562,3 +562,8 @@ harness. Keeping the door open costs nothing; walking through it preemptively co
   call sites are the strongest case for immediates, but the standing TODO there is a separate bug —
   the 2025-09-13 note says the obvious fix produced garbage and was never chased down. Immediates
   route around it for the ≤64-byte cases without explaining it.
+  Answered 2026-09-26: fixed independently. The garbage was frame-graph aliasing — a `queue.writeBuffer`
+  into a pooled buffer lands ahead of the whole submission, and a pass earlier in it had written that
+  buffer for another resource. The import now writes with `writeValueBuffer`, in order, and creates no
+  buffer per frame; `graph_import_typed_buffer.spec.js` pins both. Immediates would still drop the
+  buffer altogether for the ≤64-byte cases.

package/src/shade/device/ShadeGPUCommandContext.d.ts

@@ -268,6 +268,8 @@ export class ShadeGPUCommandContext {
      */
     allocateTransientValueBuffer<T>(type: WebGPUType, value: T, usage?: number | GPUBufferUsage): GPUBuffer;
     /**
+     * Like {@link writeBuffer}, with the bytes serialised from `value` as `type` lays them out.
+     *
      * @template T
      * @param {GPUBuffer} buffer
      * @param {number} buffer_offset
@@ -276,12 +278,22 @@ export class ShadeGPUCommandContext {
      */
     writeValueBuffer<T_1>(buffer: GPUBuffer, buffer_offset: number, type: WebGPUType, value: T_1): void;
     /**
-     * Very similar to {@link GPUQueue.writeBuffer}, but instead of doing the operation direction on the queue - uses a staging buffer under the hood and performs the actual write operation as part of the commmand buffer
+     * Write bytes into `buffer` at this point in the command stream: after everything recorded
+     * before this call, and before everything recorded after it.
+     *
+     * That is the difference from {@link GPUQueue#writeBuffer}, which lands ahead of the whole
+     * submission — ahead of passes recorded earlier in it that may still need the old contents. Here
+     * the bytes are staged, and a copy out of the staging is recorded in their place. Small writes
+     * are staged in this context's upload blocks, which reach the GPU with one queue write each when
+     * the context finishes, so a frame of thousands of them costs no mapping at all; writes of
+     * {@link MAPPED_UPLOAD_THRESHOLD} bytes or more go through a mapped staging buffer each, which is
+     * the faster road for bytes.
+     *
      * @param {GPUBuffer} buffer
      * @param {number} buffer_offset
      * @param {ArrayBuffer} data
      * @param {number} data_offset
-     * @param {number} size
+     * @param {number} size a multiple of 4, as for any buffer copy
      */
     writeBuffer(buffer: GPUBuffer, buffer_offset: number, data: ArrayBuffer, data_offset: number, size: number): void;
     /**
@@ -297,6 +309,7 @@ export type GraphicsContext = import("../renderer/GraphicsContext.js").GraphicsC
 export type ShaderResourceSetDescriptor = import("../renderer/shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor;
 export type WebGPUType = import("../renderer/shader/type/WebGPUType.js").WebGPUType;
 export type TextureManager = import("../renderer/texture/TextureManager.js").TextureManager;
+export type GPUUploadBlock = import("../renderer/buffer/GPUUploadBlock.js").GPUUploadBlock;
 export type GPUFrameRecorder = import("./timing/profile/GPUFrameRecorder.js").GPUFrameRecorder;
 import { GraphicsExecutionContext } from "./graph/GraphicsExecutionContext.js";
 import { ShadeGPUComputePassEncoder } from "./pass/ShadeGPUComputePassEncoder.js";

package/src/shade/device/ShadeGPUCommandContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShadeGPUCommandContext.d.ts","sourceRoot":"","sources":["../../../../src/shade/device/ShadeGPUCommandContext.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"ShadeGPUCommandContext.d.ts","sourceRoot":"","sources":["../../../../src/shade/device/ShadeGPUCommandContext.js"],"names":[],"mappings":"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"}

package/src/shade/device/ShadeGPUCommandContext.js

@@ -10,6 +10,7 @@ import { ShadeGPURenderPassEncoder } from "./pass/ShadeGPURenderPassEncoder.js";
 import { ShadeGPUContextProfiler } from "./timing/ShadeGPUContextProfiler.js";
 import { warn_limited } from "../util/warn_limited.js";
 import { write_gpu_typed_buffer } from "../renderer/shader/type/serde/write_gpu_typed_buffer.js";
+import { MAPPED_UPLOAD_THRESHOLD } from "../renderer/buffer/GPUBufferUploadAllocator.js";
 import { BufferResourceDescriptor } from "./graph/BufferResourceDescriptor.js";
 import { GraphicsExecutionContext } from "./graph/GraphicsExecutionContext.js";
 
@@ -24,6 +25,7 @@ import { GraphicsExecutionContext } from "./graph/GraphicsExecutionContext.js";
  * @typedef {import("../renderer/shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor} ShaderResourceSetDescriptor
  * @typedef {import("../renderer/shader/type/WebGPUType.js").WebGPUType} WebGPUType
  * @typedef {import("../renderer/texture/TextureManager.js").TextureManager} TextureManager
+ * @typedef {import("../renderer/buffer/GPUUploadBlock.js").GPUUploadBlock} GPUUploadBlock
  * @typedef {import("./timing/profile/GPUFrameRecorder.js").GPUFrameRecorder} GPUFrameRecorder
  */
 
@@ -180,6 +182,17 @@ export class ShadeGPUCommandContext {
     #transient_buffers = [];
 
     /**
+     * Upload blocks this context has written its small uploads into, the one being filled last. Sent
+     * to the GPU just before the submit, one queue write per block, and given back when the context
+     * finishes.
+     *
+     * @type {GPUUploadBlock[]}
+     */
+    #upload_blocks = [];
+
+    /**
+     * Mapped staging buffers this context's large uploads went through, one each. Given back when the
+     * context finishes, and mapped again by their pool before it hands them out anew.
      *
      * @type {GPUBuffer[]}
      */
@@ -727,6 +740,8 @@ export class ShadeGPUCommandContext {
     }
 
     /**
+     * Like {@link writeBuffer}, with the bytes serialised from `value` as `type` lays them out.
+     *
      * @template T
      * @param {GPUBuffer} buffer
      * @param {number} buffer_offset
@@ -737,30 +752,48 @@ export class ShadeGPUCommandContext {
 
         assert.notOk(this.#finished, 'already finished');
 
-        const gfx = this.#graphics;
-
         const size = type.aligned_size;
 
-        const stage = gfx.buffer_allocator_staging.get(size);
+        if (size >= MAPPED_UPLOAD_THRESHOLD) {
+            const stage = this.#graphics.buffer_allocator_staging.get(size);
+
+            // recorded before it is filled, so a fill that throws still gives it back
+            this.#staging_buffers.push(stage);
 
-        const mapped = stage.getMappedRange(0, size);
+            write_gpu_typed_buffer(value, type, stage.getMappedRange(0, size), 0);
 
-        write_gpu_typed_buffer(value, type, mapped, 0);
+            stage.unmap();
 
-        stage.unmap();
+            this.copyBufferToBuffer(stage, 0, buffer, buffer_offset, size);
 
-        this.#staging_buffers.push(stage);
+            return;
+        }
+
+        const block = this.#upload_block_with_room(size);
+        const offset = block.allocate(size);
+
+        write_gpu_typed_buffer(value, type, block.data, offset);
 
-        this.copyBufferToBuffer(stage, 0, buffer, buffer_offset, size);
+        this.copyBufferToBuffer(block.buffer, offset, buffer, buffer_offset, size);
     }
 
     /**
-     * Very similar to {@link GPUQueue.writeBuffer}, but instead of doing the operation direction on the queue - uses a staging buffer under the hood and performs the actual write operation as part of the commmand buffer
+     * Write bytes into `buffer` at this point in the command stream: after everything recorded
+     * before this call, and before everything recorded after it.
+     *
+     * That is the difference from {@link GPUQueue#writeBuffer}, which lands ahead of the whole
+     * submission — ahead of passes recorded earlier in it that may still need the old contents. Here
+     * the bytes are staged, and a copy out of the staging is recorded in their place. Small writes
+     * are staged in this context's upload blocks, which reach the GPU with one queue write each when
+     * the context finishes, so a frame of thousands of them costs no mapping at all; writes of
+     * {@link MAPPED_UPLOAD_THRESHOLD} bytes or more go through a mapped staging buffer each, which is
+     * the faster road for bytes.
+     *
      * @param {GPUBuffer} buffer
      * @param {number} buffer_offset
      * @param {ArrayBuffer} data
      * @param {number} data_offset
-     * @param {number} size
+     * @param {number} size a multiple of 4, as for any buffer copy
      */
     writeBuffer(buffer, buffer_offset, data, data_offset, size) {
         assert.defined(buffer, 'buffer');
@@ -769,20 +802,95 @@ export class ShadeGPUCommandContext {
         assert.isNonNegativeInteger(data_offset, 'data_offset');
         assert.isNonNegativeInteger(size, 'size');
 
-        const gfx = this.#graphics;
+        assert.notOk(this.#finished, 'already finished');
+
+        if (size % 4 !== 0) {
+            // Refused here rather than left to the copy, as a mapped staging buffer of this size
+            // always was: a copy moves whole 4-byte words, and one that cannot takes the context's
+            // whole submission down with it, later, without naming the write that did it.
+            throw new RangeError(`writeBuffer: size ${size} is not a multiple of 4`);
+        }
+
+        if (size === 0) {
+            // a copy of nothing changes nothing
+            return;
+        }
+
+        if (size >= MAPPED_UPLOAD_THRESHOLD) {
+            const stage = this.#graphics.buffer_allocator_staging.get(size);
 
-        const stage = gfx.buffer_allocator_staging.get(size);
+            // recorded before it is filled, so a fill that throws still gives it back
+            this.#staging_buffers.push(stage);
 
-        const mapped = stage.getMappedRange(0, size);
+            array_buffer_copy(data, data_offset, stage.getMappedRange(0, size), 0, size);
 
-        array_buffer_copy(data, data_offset, mapped, 0, size);
+            stage.unmap();
 
-        stage.unmap();
+            this.copyBufferToBuffer(stage, 0, buffer, buffer_offset, size);
 
-        this.#staging_buffers.push(stage);
+            return;
+        }
 
-        this.copyBufferToBuffer(stage, 0, buffer, buffer_offset, size);
+        const block = this.#upload_block_with_room(size);
+        const offset = block.allocate(size);
 
+        array_buffer_copy(data, data_offset, block.data, offset, size);
+
+        this.copyBufferToBuffer(block.buffer, offset, buffer, buffer_offset, size);
+    }
+
+    /**
+     * The block to take the next `size` bytes of upload from: the one being filled, or a fresh one
+     * when that is full. Every write that comes here is smaller than
+     * {@link MAPPED_UPLOAD_THRESHOLD}, so any empty block holds it.
+     *
+     * A block that cannot take the next write is not revisited: what is left in it is wasted until
+     * the context finishes, which bounds the waste at one block's tail per block and keeps every
+     * write a single contiguous copy.
+     *
+     * @param {number} size
+     * @returns {GPUUploadBlock}
+     */
+    #upload_block_with_room(size) {
+        const blocks = this.#upload_blocks;
+        const last = blocks.length - 1;
+
+        if (last >= 0 && blocks[last].fits(size)) {
+            return blocks[last];
+        }
+
+        const block = this.#graphics.buffer_allocator_upload.get();
+
+        blocks.push(block);
+
+        return block;
+    }
+
+    /**
+     * Put this context's upload blocks on the GPU: one queue write per block, of the part written.
+     *
+     * Must come immediately before the submit, and this is the whole of why a block can go back to
+     * its pool the moment its context finishes rather than when the GPU is done with it. The queue
+     * runs its operations in order, so a write issued here lands after everything submitted before
+     * this context — including the copies of any earlier context that held the same block — and
+     * before this context's own copies read it. Nothing is mapped, so nothing is waited for.
+     *
+     * A queue write lands ahead of its whole submission, which is why it goes only into a block and
+     * never into a destination: blocks come from a pool of their own that nothing aliases, while
+     * the frame graph's buffers are aliased within a submission, and a queue write into one of those
+     * would overwrite what an earlier pass in it still needs.
+     *
+     * @param {GPUQueue} queue
+     */
+    #send_uploads(queue) {
+        const blocks = this.#upload_blocks;
+        const count = blocks.length;
+
+        for (let i = 0; i < count; i++) {
+            const block = blocks[i];
+
+            queue.writeBuffer(block.buffer, 0, block.data, 0, block.used);
+        }
     }
 
     #cleanup() {
@@ -802,11 +910,29 @@ export class ShadeGPUCommandContext {
 
         }
 
-        // staging buffers
+        // Blocks go back now rather than when the GPU is done with them — see #send_uploads.
+        const buffer_allocator_upload = this.#graphics.buffer_allocator_upload;
+
+        for (const block of this.#upload_blocks) {
+            buffer_allocator_upload.release(block);
+        }
+
+        this.#upload_blocks.length = 0;
+
+        // staging buffers are mapped again by their pool, which is when they are free again
         const buffer_allocator_staging = this.#graphics.buffer_allocator_staging;
+
         for (const staging of this.#staging_buffers) {
+            if (staging.mapState === "mapped") {
+                // a write that threw while filling it, so no copy out of it was recorded; unmapped
+                // here so its pool maps it afresh rather than handing out a range already given out
+                staging.unmap();
+            }
+
             buffer_allocator_staging.release(staging);
         }
+
+        this.#staging_buffers.length = 0;
     }
 
     /**
@@ -844,19 +970,22 @@ export class ShadeGPUCommandContext {
 
          GPUCommandEncoder.finish() throws when the encoder is locked — any pass left un-end()ed
          anywhere in the frame graph — and queue.submit throws on a malformed argument. This used
-         to be a bare sequence, so either throw skipped #cleanup() and every buffer in
-         #transient_buffers and #staging_buffers stayed checked out of its allocator for good: one
-         staging buffer per writeBuffer call, which is most of the uniform traffic, every frame,
-         until the process ran out of GPU memory. onFinished never fired either, so a promise
-         already awaiting done never woke and profiling_absorbed hung with it — a recoverable
-         encoding bug turned into an unbounded leak plus a hung frame, with the original error
-         hidden behind the hang.
+         to be a bare sequence, so either throw skipped #cleanup() and every buffer the context held
+         stayed checked out of its allocator for good — then, a staging buffer per writeBuffer
+         call, which is most of the uniform traffic, every frame, until the process ran out of GPU
+         memory. onFinished never fired either, so a promise already awaiting done never woke and
+         profiling_absorbed hung with it — a recoverable encoding bug turned into an unbounded leak
+         plus a hung frame, with the original error hidden behind the hang.
 
          The error still propagates: it is the thing that names the misplaced end().
         */
         try {
             const command_buffer = encoder.finish();
 
+            // after finish(), so a command buffer that could not be made sends nothing, and
+            // immediately before the submit, which is what makes the blocks safe to hand back
+            this.#send_uploads(queue);
+
             queue.submit([command_buffer]);
         } finally {
             // cleanup allocated memory

package/src/shade/device/mock/SoftwareGPURenderPassEncoder.d.ts

@@ -27,7 +27,11 @@ export class SoftwareGPURenderPassEncoder extends SoftwareGPUObjectBase implemen
      * `-1` rather than a number read out of a buffer nobody filled — the same admission
      * {@link SoftwareGPUComputePassEncoder#dispatchWorkgroupsIndirect} makes.
      *
-     * @type {{pipeline: GPURenderPipeline|null, bind_groups: GPUBindGroup[], dynamic_offsets: number[][], vertex_buffers: object[], index_buffer: object|null, viewport: object|null, scissor: object|null, vertex_count: number, instance_count: number, indexed: boolean, indirect: boolean}[]}
+     * A direct draw also records where it starts — `first_vertex` and `first_instance`, or for an
+     * indexed one `first_index`, `base_vertex` and `first_instance` — with WebGPU's defaults of 0
+     * where they were left out. An indirect one records none of them: they are in the buffer too.
+     *
+     * @type {{pipeline: GPURenderPipeline|null, bind_groups: GPUBindGroup[], dynamic_offsets: number[][], vertex_buffers: object[], index_buffer: object|null, viewport: object|null, scissor: object|null, vertex_count: number, instance_count: number, first_vertex?: number, first_index?: number, base_vertex?: number, first_instance?: number, indexed: boolean, indirect: boolean}[]}
      */
     draws: {
         pipeline: GPURenderPipeline | null;
@@ -39,6 +43,10 @@ export class SoftwareGPURenderPassEncoder extends SoftwareGPUObjectBase implemen
         scissor: object | null;
         vertex_count: number;
         instance_count: number;
+        first_vertex?: number;
+        first_index?: number;
+        base_vertex?: number;
+        first_instance?: number;
         indexed: boolean;
         indirect: boolean;
     }[];
@@ -118,15 +126,24 @@ export class SoftwareGPURenderPassEncoder extends SoftwareGPUObjectBase implemen
     setStencilReference(reference: number): void;
     stencil_reference: number;
     /**
+     * Where the draw starts is recorded with its counts: a direct draw's `instance_index` counts from
+     * `first_instance`, and a draw that picks its row of a table through it names that row nowhere
+     * else.
+     *
      * @param {number} vertex_count
      * @param {number} [instance_count]
+     * @param {number} [first_vertex]
+     * @param {number} [first_instance]
      */
-    draw(vertex_count: number, instance_count?: number): void;
+    draw(vertex_count: number, instance_count?: number, first_vertex?: number, first_instance?: number): void;
     /**
      * @param {number} index_count
      * @param {number} [instance_count]
+     * @param {number} [first_index]
+     * @param {number} [base_vertex]
+     * @param {number} [first_instance]
      */
-    drawIndexed(index_count: number, instance_count?: number): void;
+    drawIndexed(index_count: number, instance_count?: number, first_index?: number, base_vertex?: number, first_instance?: number): void;
     /**
      * @param {GPUBuffer} indirect_buffer
      * @param {number} indirect_offset

package/src/shade/device/mock/SoftwareGPURenderPassEncoder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoftwareGPURenderPassEncoder.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPURenderPassEncoder.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,mFAFgB,oBAAoB;IAmFhC;;;OAGG;IACH,sFAQC;IA5FD;;;;;;;;;OASG;IACH,OAFU;QAAC,QAAQ,EAAE,oBAAkB,IAAI,CAAC;QAAC,WAAW,EAAE,cAAc,CAAC;QAAC,eAAe,EAAE,MAAM,EAAE,EAAE,CAAC;QAAC,cAAc,EAAE,MAAM,EAAE,CAAC;QAAC,YAAY,EAAE,MAAM,GAAC,IAAI,CAAC;QAAC,QAAQ,EAAE,MAAM,GAAC,IAAI,CAAC;QAAC,OAAO,EAAE,MAAM,GAAC,IAAI,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAC,EAAE,CAElR;IAEX;;;;;;OAMG;IACH,oCAAW;IAoDX;;;;OAIG;IACH,uBAEC;IAsBD;;OAEG;IACH,+CAIC;IAED;;;;;;;;OAQG;IACH,oBANW,MAAM,8CAEN,MAAM,EAAE,GAAC,WAAW,0BACpB,MAAM,2BACN,MAAM,QA0BhB;IAED;;;;;OAKG;IACH,4BALW,MAAM,QACN,WAAW,GAAC,eAAe,gBAC3B,MAAM,cACN,MAAM,QAUhB;IAED;;;;;OAKG;IACH,sBALW,MAAM,8BAEN,MAAM,SACN,MAAM,QAShB;IAED;;;;;OAKG;IACH,yEAHW,MAAM,SACN,MAAM,QAQhB;IAED;;;;;;;OAOG;IACH,eAPW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,aACN,MAAM,aACN,MAAM,QAMhB;IAED;;;;;OAKG;IACH,kBALW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAMhB;IAED;;OAEG;IACH,wCAIC;IADG,yBAA2B;IAG/B;;OAEG;IACH,+BAFW,MAAM,QAMhB;IADG,0BAAkC;IAwCtC;;;OAGG;IACH,mBAHW,MAAM,mBACN,MAAM,QAahB;IAED;;;OAGG;IACH,yBAHW,MAAM,mBACN,MAAM,QAahB;IAED;;;OAGG;IACH,0DAFW,MAAM,QAkBhB;IAED;;;OAGG;IACH,iEAFW,MAAM,QAiBhB;IAED;;OAEG;IACH,sBAFW,MAAM,QAIhB;IAED,sBAEC;IAED;;OAEG;IACH,yBAFW,MAAM,QAIhB;IAED,YAQC;IAGL;;;OAGG;IACH,yCAFU,OAAO,CAEoD;;CANpE;sCAzYqC,4BAA4B"}
+{"version":3,"file":"SoftwareGPURenderPassEncoder.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPURenderPassEncoder.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,mFAFgB,oBAAoB;IAuFhC;;;OAGG;IACH,sFAQC;IAhGD;;;;;;;;;;;;;OAaG;IACH,OAFU;QAAC,QAAQ,EAAE,oBAAkB,IAAI,CAAC;QAAC,WAAW,EAAE,cAAc,CAAC;QAAC,eAAe,EAAE,MAAM,EAAE,EAAE,CAAC;QAAC,cAAc,EAAE,MAAM,EAAE,CAAC;QAAC,YAAY,EAAE,MAAM,GAAC,IAAI,CAAC;QAAC,QAAQ,EAAE,MAAM,GAAC,IAAI,CAAC;QAAC,OAAO,EAAE,MAAM,GAAC,IAAI,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAC,EAAE,CAE9W;IAEX;;;;;;OAMG;IACH,oCAAW;IAoDX;;;;OAIG;IACH,uBAEC;IAsBD;;OAEG;IACH,+CAIC;IAED;;;;;;;;OAQG;IACH,oBANW,MAAM,8CAEN,MAAM,EAAE,GAAC,WAAW,0BACpB,MAAM,2BACN,MAAM,QA0BhB;IAED;;;;;OAKG;IACH,4BALW,MAAM,QACN,WAAW,GAAC,eAAe,gBAC3B,MAAM,cACN,MAAM,QAUhB;IAED;;;;;OAKG;IACH,sBALW,MAAM,8BAEN,MAAM,SACN,MAAM,QAShB;IAED;;;;;OAKG;IACH,yEAHW,MAAM,SACN,MAAM,QAQhB;IAED;;;;;;;OAOG;IACH,eAPW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,aACN,MAAM,aACN,MAAM,QAMhB;IAED;;;;;OAKG;IACH,kBALW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAMhB;IAED;;OAEG;IACH,wCAIC;IADG,yBAA2B;IAG/B;;OAEG;IACH,+BAFW,MAAM,QAMhB;IADG,0BAAkC;IAwCtC;;;;;;;;;OASG;IACH,mBALW,MAAM,mBACN,MAAM,iBACN,MAAM,mBACN,MAAM,QAehB;IAED;;;;;;OAMG;IACH,yBANW,MAAM,mBACN,MAAM,gBACN,MAAM,gBACN,MAAM,mBACN,MAAM,QAgBhB;IAED;;;OAGG;IACH,0DAFW,MAAM,QAkBhB;IAED;;;OAGG;IACH,iEAFW,MAAM,QAiBhB;IAED;;OAEG;IACH,sBAFW,MAAM,QAIhB;IAED,sBAEC;IAED;;OAEG;IACH,yBAFW,MAAM,QAIhB;IAED,YAQC;IAGL;;;OAGG;IACH,yCAFU,OAAO,CAEoD;;CANpE;sCA3ZqC,4BAA4B"}

package/src/shade/device/mock/SoftwareGPURenderPassEncoder.js

@@ -28,7 +28,11 @@ export class SoftwareGPURenderPassEncoder extends SoftwareGPUObjectBase {
      * `-1` rather than a number read out of a buffer nobody filled — the same admission
      * {@link SoftwareGPUComputePassEncoder#dispatchWorkgroupsIndirect} makes.
      *
-     * @type {{pipeline: GPURenderPipeline|null, bind_groups: GPUBindGroup[], dynamic_offsets: number[][], vertex_buffers: object[], index_buffer: object|null, viewport: object|null, scissor: object|null, vertex_count: number, instance_count: number, indexed: boolean, indirect: boolean}[]}
+     * A direct draw also records where it starts — `first_vertex` and `first_instance`, or for an
+     * indexed one `first_index`, `base_vertex` and `first_instance` — with WebGPU's defaults of 0
+     * where they were left out. An indirect one records none of them: they are in the buffer too.
+     *
+     * @type {{pipeline: GPURenderPipeline|null, bind_groups: GPUBindGroup[], dynamic_offsets: number[][], vertex_buffers: object[], index_buffer: object|null, viewport: object|null, scissor: object|null, vertex_count: number, instance_count: number, first_vertex?: number, first_index?: number, base_vertex?: number, first_instance?: number, indexed: boolean, indirect: boolean}[]}
      */
     draws = [];
 
@@ -291,10 +295,16 @@ export class SoftwareGPURenderPassEncoder extends SoftwareGPUObjectBase {
     }
 
     /**
+     * Where the draw starts is recorded with its counts: a direct draw's `instance_index` counts from
+     * `first_instance`, and a draw that picks its row of a table through it names that row nowhere
+     * else.
+     *
      * @param {number} vertex_count
      * @param {number} [instance_count]
+     * @param {number} [first_vertex]
+     * @param {number} [first_instance]
      */
-    draw(vertex_count, instance_count = 1) {
+    draw(vertex_count, instance_count = 1, first_vertex = 0, first_instance = 0) {
         this.#assert_encoding();
         this.#validate_immediates();
 
@@ -302,6 +312,8 @@ export class SoftwareGPURenderPassEncoder extends SoftwareGPUObjectBase {
             ...this.#snapshot(),
             vertex_count,
             instance_count,
+            first_vertex,
+            first_instance,
             indexed: false,
             indirect: false,
         });
@@ -310,8 +322,11 @@ export class SoftwareGPURenderPassEncoder extends SoftwareGPUObjectBase {
     /**
      * @param {number} index_count
      * @param {number} [instance_count]
+     * @param {number} [first_index]
+     * @param {number} [base_vertex]
+     * @param {number} [first_instance]
      */
-    drawIndexed(index_count, instance_count = 1) {
+    drawIndexed(index_count, instance_count = 1, first_index = 0, base_vertex = 0, first_instance = 0) {
         this.#assert_encoding();
         this.#validate_immediates();
 
@@ -319,6 +334,9 @@ export class SoftwareGPURenderPassEncoder extends SoftwareGPUObjectBase {
             ...this.#snapshot(),
             vertex_count: index_count,
             instance_count,
+            first_index,
+            base_vertex,
+            first_instance,
             indexed: true,
             indirect: false,
         });

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}.
@@ -104,6 +111,17 @@ export class GraphicsContext {
         offset: number;
         size: number;
     }): void;
+    /**
+     * Set one bind group of `pipeline`'s layout, leaving the others as they are — for a pass whose
+     * groups change at different rates, where {@link setPipelineBindings} would set every group up
+     * to the last one on each change.
+     *
+     * @param {GPUBindingCommandsMixin} pass
+     * @param {PipelineDescriptorBase} pipeline
+     * @param {number} index the group's index in the pipeline's layout
+     * @param {GPUBindingResource[]} resources the group's entries, in binding order
+     */
+    setPipelineBindGroup(pass: GPUBindingCommandsMixin, pipeline: PipelineDescriptorBase, index: number, resources: GPUBindingResource[]): void;
     /**
      *
      * @param {BufferDescriptor} buffer_descriptor
@@ -142,6 +160,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,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"}
+{"version":3,"file":"GraphicsContext.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/GraphicsContext.js"],"names":[],"mappings":"AAmCA;IAqKI,yBAiCC;IArMD;;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,uBAQC;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,QA2B9D;IAED;;;;;;;;;OASG;IACH,8DAJW,sBAAsB,SACtB,MAAM,aACN,oBAAoB,QA0C9B;IAED;;;;OAIG;IACH,gCAHW,gBAAgB,GACd,gBAAgB,CAI5B;IAED;;OAEG;IACH,+BAgBC;IAED,4BAEC;IAED,eAoDC;IAED,gBAoBC;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;+BArZY,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"}