@aardworx/wombat.rendering 0.19.1 → 0.19.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aardworx/wombat.rendering",
-  "version": "0.19.1",
+  "version": "0.19.3",
   "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",
@@ -56,7 +56,7 @@
   ],
   "dependencies": {
     "@aardworx/wombat.adaptive": "^0.2.4",
-    "@aardworx/wombat.base": "^0.4.3",
+    "@aardworx/wombat.base": "^0.4.4",
     "@aardworx/wombat.shader": "^0.5.9"
   },
   "devDependencies": {

package/src/resources/preparedRenderObject.ts

@@ -357,6 +357,7 @@ export class PreparedRenderObject {
     private readonly drawCall: aval<import("../core/index.js").DrawCall>,
     pipelineCtx: PipelineBuildContext,
     pipelineState: import("../core/index.js").PipelineState,
+    private readonly active: aval<boolean> | undefined = undefined,
   ) {
     this.groups = groups;
     this._pipelineCtx = pipelineCtx;
@@ -398,6 +399,12 @@ export class PreparedRenderObject {
   }
 
   record(pass: GPURenderPassEncoder, token: AdaptiveToken): void {
+    // Active gate: a reactive `RenderObject.active` flipping to false
+    // skips the draw entirely (legacy/standalone path's equivalent of
+    // the heap path's indexCount→0). Subscribed via getValue so the
+    // task re-records when it flips back. Without this, `<Sg Active=…>`
+    // is a no-op on the non-heap path and gated subtrees keep drawing.
+    if (this.active !== undefined && !this.active.getValue(token)) return;
     // Resolve current pipeline. If `update` was already called by the
     // walker this is a no-op cache hit; otherwise we still pick the
     // right pipeline for the token-evaluated values.
@@ -741,6 +748,7 @@ export function prepareRenderObject(
     obj.drawCall,
     pipelineCtx,
     obj.pipelineState,
+    obj.active,
   );
 }
 

package/src/runtime/heapEligibility.ts

@@ -234,6 +234,25 @@ export function isHeapEligible(ro: RenderObject): aval<boolean> {
     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) {
+      const ib = ro.indices.buffer.getValue(token);
+      if (ib.kind === "host") {
+        const idxBufCount = ib.sizeBytes >>> 2; // u32 indices
+        if (dc.indexCount !== idxBufCount) return false;
+      }
+    }
     return true;
   });
 }

package/src/runtime/heapScene.ts

@@ -2398,12 +2398,24 @@ export function buildHeapScene(
             `has no captured descriptor — bucket promotion cannot synthesise a migration combo.`,
           );
         }
+        // Read EFFECTIVE indexCount from the CPU slot's drawTable shadow
+        // — for an active=false draw this is 0, so the new GPU master
+        // record must carry the 0, not the original entry.indexCount.
+        // Otherwise the CPU→GPU bucket promotion silently resurrects
+        // every hidden draw.
+        const cpuRecIdx = slot !== undefined ? slot.slotToRecord[ls] : undefined;
+        const effIc = (cpuRecIdx !== undefined && cpuRecIdx >= 0 && slot !== undefined)
+          ? slot.drawTableShadow![cpuRecIdx * RECORD_U32 + 3]!
+          : e.indexCount;
+        const effInst = (cpuRecIdx !== undefined && cpuRecIdx >= 0 && slot !== undefined)
+          ? slot.drawTableShadow![cpuRecIdx * RECORD_U32 + 4]!
+          : e.instanceCount;
         cpuMigration.push({
           localSlot:     ls,
           drawId,
           firstIndex:    e.firstIndex,
-          indexCount:    e.indexCount,
-          instanceCount: e.instanceCount,
+          indexCount:    effIc,
+          instanceCount: effInst,
           perDrawRefs:   bucket.localPerDrawRefs[ls]!,
           descriptor,
           targetComboId: 0,
@@ -3682,10 +3694,17 @@ export function buildHeapScene(
           // Swap-pop from old slot's drawTable.
           const oldSlot = bucket.slots[oldSlotIdx]!;
           const entry = bucket.localEntries[localSlot];
-          const emit = entry !== undefined ? entry.indexCount * entry.instanceCount : 0;
           const oldRecIdx = oldSlot.slotToRecord[localSlot]!;
           const lastRecIdx = oldSlot.recordCount - 1;
           const oldShadow = oldSlot.drawTableShadow!;
+          // Read the EFFECTIVE indexCount from the old slot's drawTable
+          // shadow — for an active=false draw this is already 0, so the
+          // emit accounting on the OLD slot must NOT subtract the
+          // original (entry.indexCount) which would double-decrement and
+          // also pin the carried-over count below.
+          const effectiveIndexCount = oldShadow[oldRecIdx * RECORD_U32 + 3]!;
+          const effectiveInstanceCount = oldShadow[oldRecIdx * RECORD_U32 + 4]!;
+          const emit = effectiveIndexCount * effectiveInstanceCount;
           if (oldRecIdx !== lastRecIdx) {
             const dst = oldRecIdx * RECORD_U32;
             const src = lastRecIdx * RECORD_U32;
@@ -3720,8 +3739,13 @@ export function buildHeapScene(
           newShadow[newRecIdx * RECORD_U32 + 0] = 0;
           newShadow[newRecIdx * RECORD_U32 + 1] = localSlot;
           newShadow[newRecIdx * RECORD_U32 + 2] = entry !== undefined ? entry.firstIndex : 0;
-          newShadow[newRecIdx * RECORD_U32 + 3] = entry !== undefined ? entry.indexCount : 0;
-          newShadow[newRecIdx * RECORD_U32 + 4] = entry !== undefined ? entry.instanceCount : 0;
+          // Carry over the EFFECTIVE indexCount (read from oldShadow
+          // above) so an active=false draw remains hidden after the
+          // reslot. Using entry.indexCount here was the bug: it always
+          // wrote the ORIGINAL count, resurrecting hidden draws every
+          // time a mode-key flip moved them between slots.
+          newShadow[newRecIdx * RECORD_U32 + 3] = effectiveIndexCount;
+          newShadow[newRecIdx * RECORD_U32 + 4] = effectiveInstanceCount;
           newSlot.recordCount = newRecIdx + 1;
           newSlot.slotToRecord[localSlot] = newRecIdx;
           newSlot.recordToSlot[newRecIdx] = localSlot;