@aardworx/wombat.rendering 0.19.8 → 0.19.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aardworx/wombat.rendering",
-  "version": "0.19.8",
+  "version": "0.19.9",
   "description": "WebGPU rendering layer for the Wombat TypeScript stack — RenderObject/RenderTask/runtime + window glue, port of Aardvark.Rendering's lower layers on top of WebGPU and wombat.shader.",
   "license": "MIT",
   "author": "krauthaufen",

package/src/runtime/heapAdapter.ts

@@ -27,13 +27,14 @@
 // `ro.samplers.count <= 1` are classifier invariants.
 
 import { type aval, type AdaptiveToken } from "@aardworx/wombat.adaptive";
-import type { IBuffer, HostBufferSource } from "../core/buffer.js";
-import type { BufferView } from "../core/bufferView.js";
+import { IBuffer, type HostBufferSource } from "../core/buffer.js";
+import { BufferView } from "../core/bufferView.js";
 import { ITexture, type HostTextureSource } from "../core/texture.js";
 import { ISampler } from "../core/sampler.js";
 import type { RenderObject } from "../core/renderObject.js";
 import { asAttributeProvider, asUniformProvider } from "../core/provider.js";
 import type { HeapDrawSpec, HeapTextureSet } from "./heapScene.js";
+import { isBufferView } from "./heapScene/pools.js";
 import { compileHeapEffect } from "./heapEffect.js";
 import { AtlasPool } from "./textureAtlas/atlasPool.js";
 
@@ -50,13 +51,29 @@ function asUint32(data: HostBufferSource): Uint32Array {
   return new Uint32Array(data);
 }
 
+// Widen 16-bit indices to u32 (the heap's indexStorage is u32). Copy, not a
+// reinterpret view — each u16 index becomes a u32 element.
+function widenU16(data: HostBufferSource): Uint32Array {
+  const u16 = data instanceof Uint16Array
+    ? data
+    : ArrayBuffer.isView(data)
+      ? new Uint16Array(data.buffer, data.byteOffset, data.byteLength / 2)
+      : new Uint16Array(data);
+  return Uint32Array.from(u16);
+}
+
 // IndexPool keys on aval identity → ROs sharing the same
 // `ro.indices.buffer` must produce the SAME downstream
 // `aval<Uint32Array>`. A fresh `.map(…)` per RO would defeat the
 // pool's identity-based sharing and balloon GPU memory (e.g. 11K
 // spheres each allocating their own copy of the 6144-index buffer
 // → 270 MB).
-const indicesAvalCache = new WeakMap<aval<IBuffer>, aval<Uint32Array>>();
+// Keyed by (buffer aval, baseVertex). baseVertex is baked into the index
+// VALUES (index[i] + baseVertex), so a buffer drawn with two different
+// baseVertex offsets needs two distinct transcoded arrays — but the common
+// case (baseVertex 0, or per-primitive index buffers that aren't shared)
+// keeps one entry per buffer and preserves the pool's identity sharing.
+const indicesAvalCache = new WeakMap<aval<IBuffer>, Map<number, aval<Uint32Array>>>();
 
 // Per-aval shared "current pool ref" cell. ROs that share an
 // `aval<ITexture>` (and therefore one AtlasPool entry) all read
@@ -71,20 +88,79 @@ function currentRefCellFor(av: aval<ITexture>, initial: number): { ref: number }
   }
   return c;
 }
-function indicesAvalFor(ibAval: aval<IBuffer>): aval<Uint32Array> {
-  let av = indicesAvalCache.get(ibAval);
+function indicesAvalFor(ibAval: aval<IBuffer>, indexFormat: GPUIndexFormat, baseVertex: number): aval<Uint32Array> {
+  let byBase = indicesAvalCache.get(ibAval);
+  if (byBase === undefined) {
+    byBase = new Map();
+    indicesAvalCache.set(ibAval, byBase);
+  }
+  let av = byBase.get(baseVertex);
   if (av === undefined) {
     av = ibAval.map((ib: IBuffer) => {
       if (ib.kind !== "host") {
         throw new Error("heapAdapter: index buffer flipped to native GPUBuffer; classifier should have caught this");
       }
-      return asUint32(ib.data);
+      const u32 = indexFormat === "uint16" ? widenU16(ib.data) : asUint32(ib.data);
+      if (baseVertex === 0) return u32;
+      // Fold baseVertex into the index values so the megacall decode
+      // (vid = indexStorage[...]) lands on the right vertex with no
+      // extra record field. Copy (don't mutate the shared view).
+      const out = new Uint32Array(u32.length);
+      for (let i = 0; i < u32.length; i++) out[i] = u32[i]! + baseVertex;
+      return out;
     });
-    indicesAvalCache.set(ibAval, av);
+    byBase.set(baseVertex, av);
   }
   return av;
 }
 
+// Byte view over a host buffer source (for the de-interleave gather).
+function bytesOf(data: HostBufferSource): Uint8Array {
+  if (data instanceof Uint8Array) return data;
+  if (ArrayBuffer.isView(data)) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  return new Uint8Array(data);
+}
+
+// De-interleaved (tight, offset-0) views, keyed by (source buffer aval,
+// offset, stride) so ROs sharing one interleaved buffer + the same attribute
+// share a single gathered allocation.
+const deinterleaveCache = new WeakMap<aval<IBuffer>, Map<string, aval<IBuffer>>>();
+
+/**
+ * Make a tight, offset-0 BufferView the arena can ingest. Tight/broadcast
+ * views pass through unchanged; interleaved or offset views are gathered
+ * into a fresh packed host buffer (every `stride` bytes from `offset`,
+ * `byteSize` each) wrapped as a new whole-buffer view.
+ */
+function tightenBufferView(bv: BufferView): BufferView {
+  if (bv.singleValue !== undefined) return bv; // broadcast → lowered to a uniform
+  const byteSize = bv.elementType.byteSize;
+  const offset = bv.offset ?? 0;
+  const stride = (bv.stride !== undefined && bv.stride > 0) ? bv.stride : byteSize;
+  if (offset === 0 && stride === byteSize) return bv; // already tight
+  let byKey = deinterleaveCache.get(bv.buffer);
+  if (byKey === undefined) { byKey = new Map(); deinterleaveCache.set(bv.buffer, byKey); }
+  const key = `${offset}:${stride}:${byteSize}`;
+  let tight = byKey.get(key);
+  if (tight === undefined) {
+    tight = bv.buffer.map((ib: IBuffer): IBuffer => {
+      if (ib.kind !== "host") {
+        throw new Error("heapAdapter: interleaved attribute buffer flipped to native GPUBuffer; classifier should have caught this");
+      }
+      const src = bytesOf(ib.data);
+      const count = Math.max(0, Math.floor((src.byteLength - offset - byteSize) / stride) + 1);
+      const out = new Uint8Array(count * byteSize);
+      for (let i = 0; i < count; i++) {
+        const s = offset + i * stride;
+        out.set(src.subarray(s, s + byteSize), i * byteSize);
+      }
+      return IBuffer.fromHost(out);
+    });
+    byKey.set(key, tight);
+  }
+  return BufferView.ofBuffer(tight, bv.elementType);
+}
+
 /**
  * Pull `(format, width, height, mipLevelCount)` out of an ITexture so
  * we can run Tier-S eligibility against it. Both variants expose this:
@@ -197,7 +273,7 @@ export function renderObjectToHeapSpec(
   const inputs: { [name: string]: aval<unknown> | unknown } = {};
   for (const a of schema.attributes) {
     const bv = vAttr.tryGet(a.name);
-    if (bv !== undefined) inputs[a.name] = bv;
+    if (bv !== undefined) inputs[a.name] = isBufferView(bv) ? tightenBufferView(bv) : bv;
   }
   const pullUniform = (name: string): void => {
     if (Object.prototype.hasOwnProperty.call(inputs, name)) return;
@@ -222,17 +298,25 @@ export function renderObjectToHeapSpec(
       instanceAttributes = {};
       for (const n of names) {
         const bv = iAttr.tryGet(n);
-        if (bv !== undefined) instanceAttributes[n] = bv;
+        if (bv !== undefined) instanceAttributes[n] = isBufferView(bv) ? tightenBufferView(bv) : bv;
       }
     }
   }
 
+  // DrawCall: read once (snapshot — like instanceCount/vertexCount).
+  //    Slice offsets fold in here: firstIndex → record indexStart,
+  //    indexCount → record slice length, baseVertex → baked into the
+  //    transcoded index values (so it needs no record field).
+  const dc = ro.drawCall.getValue(token);
+  const baseVertex = dc.kind === "indexed" ? dc.baseVertex : 0;
+
   // 2. Indices: BufferView → aval<Uint32Array>. Map the underlying
-  //    IBuffer aval; the heap path's IndexPool will key on this aval.
+  //    IBuffer aval; the heap path's IndexPool will key on this aval
+  //    (and on baseVertex, since it's baked into the values).
   //    Non-indexed ROs (no `ro.indices`) carry no index aval — the spec
   //    then sets `vertexCount` and the megacall decodes the vertex directly.
   const indices: aval<Uint32Array> | undefined =
-    ro.indices !== undefined ? indicesAvalFor(ro.indices.buffer) : undefined;
+    ro.indices !== undefined ? indicesAvalFor(ro.indices.buffer, ro.indices.elementType.indexFormat ?? "uint32", baseVertex) : undefined;
 
   // 3. Texture/sampler: single-pair v1. The Sg compile layer binds
   //    each texture aval under both `name` and `${name}_view` so the
@@ -355,19 +439,20 @@ export function renderObjectToHeapSpec(
     );
   }
 
-  // 4. DrawCall: read once. Classifier validates fields are heap-
-  //    compatible (indexed, instanceCount=1, zero offsets).
-  const dc = ro.drawCall.getValue(token);
+  // 4. DrawCall geometry. Classifier validates fields are heap-
+  //    compatible (instanceCount≥1, firstInstance=0, non-indexed firstVertex=0).
   if (dc.kind === "indexed" && indices === undefined) {
     throw new Error("heapAdapter: indexed drawCall without indices");
   }
   if (dc.kind === "non-indexed" && indices !== undefined) {
     throw new Error("heapAdapter: non-indexed drawCall with an index buffer");
   }
-  // Indexed → carry the index aval; non-indexed → carry the vertex count and
-  // the megacall uses the local vertex index directly (no index lookup).
+  // Indexed → carry the index aval + the firstIndex/indexCount slice (folded
+  // into the record's indexStart/indexCount; baseVertex is already baked into
+  // the index values). Non-indexed → carry the vertex count; the megacall uses
+  // the local vertex index directly (no index lookup).
   const geom = dc.kind === "indexed"
-    ? { indices: indices! }
+    ? { indices: indices!, firstIndex: dc.firstIndex, indexCount: dc.indexCount }
     : { vertexCount: dc.vertexCount };
 
   return {

package/src/runtime/heapEligibility.ts

@@ -185,27 +185,17 @@ export function isHeapEligible(ro: RenderObject): aval<boolean> {
     return AVal.constant(false);
   }
 
-  // 2. BufferView stride wedge — only tight per-vertex/per-instance
-  //    layouts (and broadcasts via `singleValue` / stride 0) are
-  //    ingested. The shader-side cyclic addressing (`vid % length`,
-  //    `iidx % length`) makes broadcasts a degenerate length-1 case,
-  //    so we don't reject them here — but interleaved strides remain
-  //    unsupported. Per-instance attributes follow the same rule.
-  let strideBlocked = false;
-  const checkStride = (v: BufferView): void => {
-    const stride = v.stride ?? v.elementType.byteSize;
-    const isBroadcast = v.singleValue !== undefined || stride === 0;
-    if (!isBroadcast && stride !== v.elementType.byteSize) strideBlocked = true;
-  };
-  for (const v of attrViews(asAttributeProvider(ro.vertexAttributes))) checkStride(v);
-  if (ro.instanceAttributes !== undefined) {
-    for (const v of attrViews(asAttributeProvider(ro.instanceAttributes))) checkStride(v);
-  }
-  if (strideBlocked) return AVal.constant(false);
+  // 2. Interleaved / offset attributes are handled by de-interleaving at
+  //    ingest (heapAdapter.tightenBufferView gathers a tight, offset-0
+  //    copy keyed by (buffer, offset, stride) so sharing is preserved), so
+  //    no stride/offset wedge remains. Broadcasts (singleValue / stride 0)
+  //    still pass through as a degenerate length-1 case.
 
-  // 3. Index-format wedge — heap stores indices as u32.
-  if (ro.indices !== undefined && ro.indices.elementType.indexFormat !== "uint32") {
-    return AVal.constant(false);
+  // 3. Index-format wedge — heap stores indices as u32; u16 is widened
+  //    to u32 at ingest (heapAdapter.widenU16). Anything else is rejected.
+  if (ro.indices !== undefined) {
+    const fmt = ro.indices.elementType.indexFormat;
+    if (fmt !== "uint32" && fmt !== "uint16") return AVal.constant(false);
   }
 
   const buffers  = bufferAvals(ro);
@@ -233,27 +223,19 @@ export function isHeapEligible(ro: RenderObject): aval<boolean> {
     if (dc.firstInstance !== 0) return false;
     if (dc.kind === "indexed") {
       if (ro.indices === undefined) return false;
-      if (dc.baseVertex !== 0) return false;
-      if (dc.firstIndex !== 0) return false;
-      // Whole-buffer wedge: the heap ingests the ENTIRE index + vertex
-      // buffers for an RO (IndexPool/AttributeArena copy `arr.length`,
-      // not the drawCall slice). An RO that consumes only a PREFIX of a
-      // shared index buffer (firstIndex=0 but indexCount < bufferCount —
-      // e.g. one glyph in a multi-glyph text run whose glyphs share a
-      // single atlas index buffer) would therefore drag the rest of the
-      // buffer into its draw: the trailing indices reference vertices
-      // past this RO's range, painting stray triangles. Until the heap
-      // honours the drawCall slice, only ROs that own their whole index
-      // buffer are eligible.
-      const ib = ro.indices.buffer.getValue(token);
-      if (ib.kind === "host") {
-        const idxBufCount = ib.sizeBytes >>> 2; // u32 indices
-        if (dc.indexCount !== idxBufCount) return false;
-      }
+      // Offsets and shared sub-buffer slices are all eligible now: the heap
+      // still ingests the WHOLE index + vertex buffers (one shared arena
+      // allocation per buffer aval — sharing is the heap's whole point), but
+      // the record now honours the drawCall slice. firstIndex folds into the
+      // record's indexStart, indexCount becomes the slice length (so a single
+      // glyph of a multi-glyph run reads only its run of indices), and
+      // baseVertex is baked into the transcoded index values at ingest
+      // (heapAdapter.indicesAvalFor). No drawCall wedge remains here.
     } else {
       // Non-indexed: the megacall uses the local vertex index directly, so a
-      // prefix read is safe (vid = 0..vertexCount-1) — no whole-buffer wedge.
-      // firstVertex must be 0 (the heap maps vid → attribute[vid] from base 0).
+      // prefix read is safe (vid = 0..vertexCount-1). firstVertex must be 0 —
+      // a non-indexed vertex offset would need a per-record field (the index
+      // bake-in trick doesn't apply with no index buffer), so it's deferred.
       if (ro.indices !== undefined) return false;
       if (dc.firstVertex !== 0) return false;
     }

package/src/runtime/heapScene.ts

@@ -465,6 +465,17 @@ export interface HeapDrawSpec {
   readonly indices?: aval<Uint32Array> | Uint32Array;
   /** Vertex count for a non-indexed draw (when `indices` is omitted). */
   readonly vertexCount?: number;
+  /**
+   * Optional index slice into a (possibly shared) index buffer. The heap
+   * still allocates/uploads the WHOLE `indices` buffer once per aval (so N
+   * draws sharing it cost one allocation), but this draw emits only
+   * `[firstIndex, firstIndex+indexCount)`. Folds into the record's
+   * indexStart (`alloc.firstIndex + firstIndex`) and indexCount. Omit for a
+   * whole-buffer draw (defaults: firstIndex 0, indexCount = buffer length).
+   * (baseVertex is handled upstream by baking it into the index values.)
+   */
+  readonly firstIndex?: number;
+  readonly indexCount?: number;
   /**
    * Optional texture set. When present, adds a `texture_2d<f32>` at
    * binding 4 and a sampler at binding 5; the FS must declare them.
@@ -3025,8 +3036,11 @@ export function buildHeapScene(
       ? indexPool.acquire(device, arena.indices, indicesAval!, bucket.chunkIdx, readPlain(spec.indices!) as Uint32Array)
       : undefined;
     // Emit count per instance + the firstIndex field written to the record.
-    const emitCount = hasIndices ? idxAlloc!.count : (spec.vertexCount ?? 0);
-    const firstIndexField = hasIndices ? idxAlloc!.firstIndex : HEAP_NONINDEXED;
+    // Slice: emit only [firstIndex, firstIndex+indexCount) of the (shared,
+    // whole-buffer) index allocation. firstIndex folds into indexStart;
+    // indexCount defaults to the whole buffer.
+    const emitCount = hasIndices ? (spec.indexCount ?? idxAlloc!.count) : (spec.vertexCount ?? 0);
+    const firstIndexField = hasIndices ? (idxAlloc!.firstIndex + (spec.firstIndex ?? 0)) : HEAP_NONINDEXED;
 
     const localSlot = bucket.drawHeap.alloc();
     // Per-RO instancing: read `spec.instanceCount` (defaults to 1).