@aardworx/wombat.rendering 0.19.6 → 0.19.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aardworx/wombat.rendering",
-  "version": "0.19.6",
+  "version": "0.19.8",
   "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/resources/preparedRenderObject.ts

@@ -215,11 +215,16 @@ function sampleTypeFor(type: Type): GPUTextureSampleType {
     if (type.comparison === true) return "depth";
     const s = type.sampled;
     if (s.kind === "Int") return s.signed ? "sint" : "uint";
-    return "float";
+    // Multisampled float textures can't be filtered — bind as unfilterable.
+    return type.multisampled ? "unfilterable-float" : "float";
   }
   return "float";
 }
 
+function isMultisampled(type: Type): boolean {
+  return type.kind === "Texture" && type.multisampled;
+}
+
 // ---------------------------------------------------------------------------
 // Bind-group entry descriptions
 // ---------------------------------------------------------------------------
@@ -227,7 +232,7 @@ function sampleTypeFor(type: Type): GPUTextureSampleType {
 type EntryDesc =
   | { kind: "ubuf";    binding: number; resource: AdaptiveResource<GPUBuffer> }
   | { kind: "sbuf";    binding: number; resource: AdaptiveResource<GPUBuffer>; access: "read" | "read_write" }
-  | { kind: "tex";     binding: number; resource: AdaptiveResource<GPUTexture>; sampleType: GPUTextureSampleType }
+  | { kind: "tex";     binding: number; resource: AdaptiveResource<GPUTexture>; sampleType: GPUTextureSampleType; multisampled: boolean }
   | { kind: "sampler"; binding: number; resource: AdaptiveResource<GPUSampler> };
 
 interface GroupDesc {
@@ -253,7 +258,7 @@ function buildGroups(device: GPUDevice, descs: readonly EntryDesc[][]): GroupDes
           visibility: e.access === "read_write" ? ShaderStage.FRAGMENT : visibility,
           buffer: { type: e.access === "read_write" ? "storage" : "read-only-storage" },
         };
-        case "tex":    return { binding: e.binding, visibility, texture: { sampleType: e.sampleType } };
+        case "tex":    return { binding: e.binding, visibility, texture: { sampleType: e.sampleType, ...(e.multisampled ? { multisampled: true } : {}) } };
         case "sampler": return { binding: e.binding, visibility, sampler: { type: "filtering" } };
       }
     });
@@ -693,7 +698,7 @@ export function prepareRenderObject(
     const res = prepareAdaptiveTexture(device, av, {
       ...(opts.label !== undefined ? { label: `${opts.label}.${t.name}` } : {}),
     });
-    perGroup[t.group]!.push({ kind: "tex", binding: slotOf(t), resource: res, sampleType: sampleTypeFor(t.type) });
+    perGroup[t.group]!.push({ kind: "tex", binding: slotOf(t), resource: res, sampleType: sampleTypeFor(t.type), multisampled: isMultisampled(t.type) });
   }
 
   for (const s of iface.samplers) {

package/src/runtime/heapAdapter.ts

@@ -229,10 +229,10 @@ export function renderObjectToHeapSpec(
 
   // 2. Indices: BufferView → aval<Uint32Array>. Map the underlying
   //    IBuffer aval; the heap path's IndexPool will key on this aval.
-  if (ro.indices === undefined) {
-    throw new Error("heapAdapter: RenderObject without indices not supported (heap is indexed-only)");
-  }
-  const indices: aval<Uint32Array> = indicesAvalFor(ro.indices.buffer);
+  //    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;
 
   // 3. Texture/sampler: single-pair v1. The Sg compile layer binds
   //    each texture aval under both `name` and `${name}_view` so the
@@ -358,9 +358,17 @@ export function renderObjectToHeapSpec(
   // 4. DrawCall: read once. Classifier validates fields are heap-
   //    compatible (indexed, instanceCount=1, zero offsets).
   const dc = ro.drawCall.getValue(token);
-  if (dc.kind !== "indexed") {
-    throw new Error("heapAdapter: non-indexed drawCall; classifier should have caught this");
+  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).
+  const geom = dc.kind === "indexed"
+    ? { indices: indices! }
+    : { vertexCount: dc.vertexCount };
 
   return {
     effect: ro.effect,
@@ -368,7 +376,7 @@ export function renderObjectToHeapSpec(
     inputs,
     ...(instanceAttributes !== undefined ? { instanceAttributes } : {}),
     ...(dc.instanceCount > 1 ? { instanceCount: dc.instanceCount } : {}),
-    indices,
+    ...geom,
     ...(textures !== undefined ? { textures } : {}),
     ...(ro.modeRules !== undefined ? { modeRules: ro.modeRules } : {}),
     // Pass `active` through unforced so the heap path can subscribe

package/src/runtime/heapEffect.ts

@@ -839,5 +839,5 @@ export function megacallSearchPrelude(): string {
   // to receive them as `u32` parameters — module-scope `var<private>`
   // is rejected by some WGSL parsers (Safari/WebKit), so we thread the
   // values through helper signatures instead.
-  return `  let _tileIdx = emitIdx >> 6u;\n  var lo: u32 = firstDrawInTile[_tileIdx];\n  var hi: u32 = firstDrawInTile[_tileIdx + 1u];\n  loop {\n    if (lo >= hi) { break; }\n    let _mid = (lo + hi + 1u) >> 1u;\n    if (drawTable[_mid * 5u] <= emitIdx) { lo = _mid; } else { hi = _mid - 1u; }\n  }\n  let _slot = lo;\n  let _firstEmit  = drawTable[_slot * 5u + 0u];\n  let heap_drawIdx: u32 = drawTable[_slot * 5u + 1u];\n  let _indexStart = drawTable[_slot * 5u + 2u];\n  let _indexCount = drawTable[_slot * 5u + 3u];\n  let _local      = emitIdx - _firstEmit;\n  let instId: u32 = _local / _indexCount;\n  let vid: u32    = indexStorage[_indexStart + (_local % _indexCount)];\n`;
+  return `  let _tileIdx = emitIdx >> 6u;\n  var lo: u32 = firstDrawInTile[_tileIdx];\n  var hi: u32 = firstDrawInTile[_tileIdx + 1u];\n  loop {\n    if (lo >= hi) { break; }\n    let _mid = (lo + hi + 1u) >> 1u;\n    if (drawTable[_mid * 5u] <= emitIdx) { lo = _mid; } else { hi = _mid - 1u; }\n  }\n  let _slot = lo;\n  let _firstEmit  = drawTable[_slot * 5u + 0u];\n  let heap_drawIdx: u32 = drawTable[_slot * 5u + 1u];\n  let _indexStart = drawTable[_slot * 5u + 2u];\n  let _indexCount = drawTable[_slot * 5u + 3u];\n  let _local      = emitIdx - _firstEmit;\n  let instId: u32 = _local / _indexCount;\n  let _li: u32    = _local % _indexCount;\n  var vid: u32    = _li;\n  if (_indexStart != 0xffffffffu) { vid = indexStorage[_indexStart + _li]; }\n`;
 }

package/src/runtime/heapEligibility.ts

@@ -229,29 +229,33 @@ export function isHeapEligible(ro: RenderObject): aval<boolean> {
     for (const av of textures) if (!isHeapServableTexture(av.getValue(token))) return false;
     for (const av of samplers) if (!isHeapServableSampler(av.getValue(token))) return false;
     const dc = ro.drawCall.getValue(token);
-    if (dc.kind !== "indexed") return false;
     if (dc.instanceCount < 1) return false;
-    if (dc.baseVertex !== 0) return false;
-    if (dc.firstIndex !== 0) return false;
     if (dc.firstInstance !== 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 (including the next sub-mesh's / this
-    // glyph's band vertices), painting stray triangles. Until the heap
-    // honours the drawCall slice, only ROs that own their whole index
-    // buffer are eligible. Single-mesh ROs (indexCount === bufferCount)
-    // pass; shared-atlas slices fall to the legacy ScenePass.
-    if (ro.indices !== undefined) {
+    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;
       }
+    } 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).
+      if (ro.indices !== undefined) return false;
+      if (dc.firstVertex !== 0) return false;
     }
     return true;
   });

package/src/runtime/heapIrBuilders.ts

@@ -354,11 +354,21 @@ export function buildMegacallPrelude(emitIdx: Expr): { stmts: Stmt[]; locals: Me
   stmts.push({ kind: "Declare", var: localOff, init: { kind: "Expr", value: sub(emitIdx, varExpr(firstEmit), Tu32) } });
   // let instId = _local / _indexCount;
   stmts.push({ kind: "Declare", var: instId, init: { kind: "Expr", value: div(varExpr(localOff), varExpr(indexCount), Tu32) } });
-  // let vid = indexStorage[_indexStart + (_local % _indexCount)];
+  // Non-indexed records carry _indexStart == 0xffffffff (HEAP_NONINDEXED): the
+  // vertex is the local index directly; otherwise decode through indexStorage.
+  //   let vid = (_indexStart == 0xffffffff)
+  //     ? (_local % _indexCount)
+  //     : indexStorage[_indexStart + (_local % _indexCount)];
+  const liExpr = (): Expr => mod(varExpr(localOff), varExpr(indexCount), Tu32);
   stmts.push({
     kind: "Declare",
     var: vid,
-    init: { kind: "Expr", value: item(indexStorage, add(varExpr(indexStart), mod(varExpr(localOff), varExpr(indexCount), Tu32), Tu32), Tu32) },
+    init: { kind: "Expr", value: select(
+      eqU32(varExpr(indexStart), constU32(0xffffffff)),
+      liExpr(),
+      item(indexStorage, add(varExpr(indexStart), liExpr(), Tu32), Tu32),
+      Tu32,
+    ) },
   });
 
   return { stmts, locals: { heapDrawIdx, instId, vid } };

package/src/runtime/heapScene.ts

@@ -143,6 +143,11 @@ import {
  * Geometry triple. Tightly-packed Float32 positions / normals (3
  * floats per vertex) plus Uint32 indices.
  */
+/** drawTable `firstIndex` sentinel marking a non-indexed record: the megacall
+ *  prelude then uses the local vertex index directly (no indexStorage lookup).
+ *  Must match the literal in heapEffect.ts's `megacallSearchPrelude`. */
+export const HEAP_NONINDEXED = 0xffffffff;
+
 export interface HeapGeometry {
   readonly positions: Float32Array;
   readonly normals:   Float32Array;
@@ -453,8 +458,13 @@ export interface HeapDrawSpec {
   /**
    * Index buffer for this draw. Indices live in their own `INDEX`-
    * usage `GPUBuffer` (WebGPU forces this), separate from the arena.
+   * Omit for a NON-INDEXED draw — then `vertexCount` is required and the
+   * megacall uses the local vertex index directly (no index-buffer lookup,
+   * no index-pool allocation). See the megacall prelude's `vid` select.
    */
-  readonly indices: aval<Uint32Array> | Uint32Array;
+  readonly indices?: aval<Uint32Array> | Uint32Array;
+  /** Vertex count for a non-indexed draw (when `indices` is omitted). */
+  readonly vertexCount?: 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.
@@ -3005,10 +3015,18 @@ export function buildHeapScene(
 
     // Indices live in their own INDEX-usage buffer (WebGPU constraint).
     // Aval-keyed: 19K instanced clones of the same mesh share one
-    // index allocation + one upload.
-    const indicesAval = asAval(spec.indices) as aval<Uint32Array>;
-    const indicesArr = readPlain(spec.indices) as Uint32Array;
-    const idxAlloc = indexPool.acquire(device, arena.indices, indicesAval, bucket.chunkIdx, indicesArr);
+    // index allocation + one upload. NON-INDEXED draws (spec.indices
+    // omitted) skip the index pool entirely: the drawTable record stores
+    // firstIndex = HEAP_NONINDEXED (sentinel) and indexCount = vertexCount,
+    // and the megacall prelude uses the local vertex index directly.
+    const hasIndices = spec.indices !== undefined;
+    const indicesAval = hasIndices ? (asAval(spec.indices!) as aval<Uint32Array>) : undefined;
+    const idxAlloc = hasIndices
+      ? 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;
 
     const localSlot = bucket.drawHeap.alloc();
     // Per-RO instancing: read `spec.instanceCount` (defaults to 1).
@@ -3101,7 +3119,7 @@ export function buildHeapScene(
     bucket.localPosRefs[localSlot] = perDrawRefs.get("Positions");
     bucket.localNorRefs[localSlot] = perDrawRefs.get("Normals");
     bucket.localEntries[localSlot] = {
-      indexCount: idxAlloc.count, firstIndex: idxAlloc.firstIndex, instanceCount,
+      indexCount: emitCount, firstIndex: firstIndexField, instanceCount,
     };
     bucket.localToDrawId[localSlot] = drawId;
     bucket.drawSlots.add(localSlot);
@@ -3217,7 +3235,7 @@ export function buildHeapScene(
       const uniformRefs: number[] = (bucket.uniformOrder ?? []).map(
         name => perDrawRefs.get(name) ?? 0,
       );
-      partition.appendRecord(localSlot, idxAlloc.firstIndex, idxAlloc.count, instanceCount, roComboId, uniformRefs);
+      partition.appendRecord(localSlot, firstIndexField, emitCount, instanceCount, roComboId, uniformRefs);
       bucket.drawIdToRecord!.set(drawId, recIdx);
       bucket.recordToDrawId![recIdx] = drawId;
       bucket.drawIdToComboId!.set(drawId, roComboId);
@@ -3228,7 +3246,7 @@ export function buildHeapScene(
       const numRecords = recIdx + 1;
       const recBytes = numRecords * RECORD_BYTES;
       const needBlocks = Math.max(1, Math.ceil(numRecords / SCAN_TILE_SIZE));
-      const emitDelta = idxAlloc.count * instanceCount;
+      const emitDelta = emitCount * instanceCount;
       for (const s of bucket.slots) {
         s.drawTableBuf!.ensureCapacity(recBytes);
         s.drawTableBuf!.setUsed(Math.max(s.drawTableBuf!.usedBytes, recBytes));
@@ -3261,15 +3279,15 @@ export function buildHeapScene(
       // firstEmit is GPU-overwritten by the prefix-sum pass; 0 is fine.
       shadow[recIdx * RECORD_U32 + 0] = 0;
       shadow[recIdx * RECORD_U32 + 1] = localSlot;
-      shadow[recIdx * RECORD_U32 + 2] = idxAlloc.firstIndex;
-      shadow[recIdx * RECORD_U32 + 3] = idxAlloc.count;
+      shadow[recIdx * RECORD_U32 + 2] = firstIndexField;
+      shadow[recIdx * RECORD_U32 + 3] = emitCount;
       shadow[recIdx * RECORD_U32 + 4] = instanceCount;
       roSlot.recordCount = recIdx + 1;
       roSlot.slotToRecord[localSlot] = recIdx;
       roSlot.recordToSlot[recIdx] = localSlot;
       if (byteOff < roSlot.drawTableDirtyMin) roSlot.drawTableDirtyMin = byteOff;
       if (byteOff + RECORD_BYTES > roSlot.drawTableDirtyMax) roSlot.drawTableDirtyMax = byteOff + RECORD_BYTES;
-      roSlot.totalEmitEstimate += idxAlloc.count * instanceCount;
+      roSlot.totalEmitEstimate += emitCount * instanceCount;
       const newNumTiles = Math.max(1, Math.ceil(roSlot.totalEmitEstimate / TILE_K));
       roSlot.firstDrawInTileBuf!.ensureCapacity((newNumTiles + 1) * 4);
       roSlot.scanDirty = true;
@@ -3286,7 +3304,7 @@ export function buildHeapScene(
     // `subscribeActive` → `activeDirty` and drained in `update()`.
     if (spec.active !== undefined) {
       drawIdToActiveAval.set(drawId, spec.active);
-      drawIdToOrigIndexCount.set(drawId, idxAlloc.count);
+      drawIdToOrigIndexCount.set(drawId, emitCount);
       const initial = spec.active.getValue(outerTok);
       subscribeActive(spec.active, drawId);
       if (initial === false) {
@@ -5157,7 +5175,9 @@ export function buildHeapScene(
           let _instCount  = drawTable[_slot * 5u + 4u];
           let _local      = emitIdx - _firstEmit;
           let _instId     = _local / _indexCount;
-          let _vid        = indexStorage[_indexStart + (_local % _indexCount)];
+          let _li         = _local % _indexCount;
+          var _vid: u32   = _li;
+          if (_indexStart != 0xffffffffu) { _vid = indexStorage[_indexStart + _li]; }
           let base = i * 8u;
           outRows[base + 0u] = _slot;
           outRows[base + 1u] = _drawIdx;