@aardworx/wombat.rendering 0.19.7 → 0.19.8

package/dist/runtime/heapScene.js

@@ -60,6 +60,39 @@ import { emitPartitionKernel, substituteReadInputInStmt, collectUniformReadsInSt
 import {} from "./derivedModes/rule.js";
 import { addMarkingCallback } from "@aardworx/wombat.adaptive";
 import { analyseOutputSet, evaluateStructural, evaluateStructuralSet, stableStringify, } from "@aardworx/wombat.shader/ir";
+// GrowBuffer + ALIGN16 + MIN_BUFFER_BYTES + POW2 live in ./heapScene/growBuffer.
+// Packers (WGSL-type → JS-value → arena bytes) live in ./heapScene/packers.
+// ---------------------------------------------------------------------------
+// Shared WGSL prelude (struct + bindings + VS)
+// ---------------------------------------------------------------------------
+// Common decls — struct + bindings + helpers. Always concatenated
+// into every group's shader, before its custom VS+FS bodies.
+//
+// One arena GPUBuffer is bound through multiple typed views. Today
+// only `array<DrawHeader>` and `array<f32>` are wired; later we add
+// `array<u32>`, `array<vec2<f32>>`, `array<vec4<f32>>`, etc. (skip
+// `vec3` — its storage stride is 16, doesn't match tight packing).
+//
+// `attrRef` style: each attribute reference in DrawHeader is a byte
+// offset into the arena pointing at the allocation's header. The
+// header is `(u32 typeId, u32 length)`; data follows 16 bytes after
+// the ref. Today every attribute is V3F_TIGHT-encoded so the shader
+// reads 3 consecutive f32s from the f32 view; once we add more
+// encodings, `loadVec3Attr` grows a branch on `typeId & 0xFFFFu`.
+// (Per-bucket WGSL preludes are now generated by `buildBucketLayout`
+// in heapEffect.ts; this module just glues the bucket layout, the
+// shared arena, and the per-bucket DrawHeap together.)
+// ---------------------------------------------------------------------------
+// Geometry packing
+// ---------------------------------------------------------------------------
+/**
+ * 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 function buildHeapScene(device, sig, initialDraws, opts = {}) {
     const atlasPool = opts.atlasPool;
     const colorAttachmentName = sig.colorNames[0];
@@ -2133,10 +2166,18 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
         const effectFields = fam.fieldsForEffect.get(spec.effect.id);
         // 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);
-        const indicesArr = readPlain(spec.indices);
-        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) : undefined;
+        const idxAlloc = hasIndices
+            ? indexPool.acquire(device, arena.indices, indicesAval, bucket.chunkIdx, readPlain(spec.indices))
+            : 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).
         const instanceCount = spec.instanceCount !== undefined
@@ -2219,7 +2260,7 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
         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);
@@ -2327,7 +2368,7 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
             // it) get 0 — the kernel only reads refs through combo fns that
             // gate on `r.comboId`, so an unread 0 is harmless.
             const uniformRefs = (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);
@@ -2338,7 +2379,7 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
             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));
@@ -2370,8 +2411,8 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
             // 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;
@@ -2380,7 +2421,7 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
                 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;
@@ -2395,7 +2436,7 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
         // `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) {
@@ -4224,7 +4265,9 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
           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;