@aardworx/wombat.rendering 0.19.10 → 0.19.12

package/src/runtime/derivedUniforms/slots.ts

@@ -87,6 +87,21 @@ export class ConstituentSlots {
     this.mirror = new Float32Array(initialCapacity * 32);
   }
 
+  /** Allocate a fwd+inv slot pair for a GPU-WRITTEN output (not keyed by any
+   *  aval, never dirty-tracked or CPU-uploaded). Used for a per-RO `Model`
+   *  produced by the transform-propagation chain pass and then consumed by §7
+   *  as a constituent. Free with `freeOutputPair`. */
+  allocOutputPair(): PairedSlots {
+    const fwd = this.pool.alloc() as SlotIndex;
+    const inv = this.pool.alloc() as SlotIndex;
+    this.ensureCapacity(this.pool.highWaterMark);
+    return { fwd, inv };
+  }
+  freeOutputPair(p: PairedSlots): void {
+    this.pool.release(p.fwd);
+    this.pool.release(p.inv);
+  }
+
   acquire(av: aval<Trafo3d>): PairedSlots {
     let entry = this.byAval.get(av);
     if (entry === undefined) {

package/src/runtime/heapAdapter.ts

@@ -464,6 +464,7 @@ export function renderObjectToHeapSpec(
     ...geom,
     ...(textures !== undefined ? { textures } : {}),
     ...(ro.modeRules !== undefined ? { modeRules: ro.modeRules } : {}),
+    ...(ro.modelChain !== undefined ? { modelChain: ro.modelChain } : {}),
     // Pass `active` through unforced so the heap path can subscribe
     // and react to flips without re-running the spec adapter.
     ...(ro.active !== undefined ? { active: ro.active } : {}),

package/src/runtime/heapScene.ts

@@ -530,6 +530,16 @@ export interface HeapDrawSpec {
     readonly depthWrite?:     import("./derivedModes/rule.js").DerivedModeRule<"depthWrite">;
     readonly alphaToCoverage?: import("./derivedModes/rule.js").DerivedModeRule<"alphaToCoverage">;
   };
+  /**
+   * GPU transform propagation: this RO's `Model` ancestor trafo chain (root→
+   * leaf, constant runs folded) as `aval<Trafo3d>` links. When present, the §7
+   * compute pass composes a per-RO Model constituent from these on the GPU
+   * (instead of the RO supplying a single composed `ModelTrafo` aval), and the
+   * standard recipes / custom rules derive ModelView / inverses / NormalMatrix
+   * from it. Eliminates the CPU fan-out of a shared root trafo over many ROs.
+   * See docs/gpu-transform-propagation.md.
+   */
+  readonly modelChain?: readonly aval<Trafo3d>[];
 }
 
 export interface HeapSceneStats {
@@ -1193,6 +1203,10 @@ export function buildHeapScene(
     // just means "this RO doesn't supply the base trafos", so the field falls back to its
     // packed `spec.inputs` value (or errors later if there is none — same as without §7).
     for (const inp of inputsOf(rule.ir)) {
+      // `Model` may be supplied by the GPU transform-propagation chain rather
+      // than a ModelTrafo aval — treat it as bound when a modelChain is present
+      // (registerRoDerivations points the §7 Model leaf at the chain output).
+      if (inp.name === "Model" && spec.modelChain !== undefined) continue;
       const specName = STANDARD_TRAFO_LEAVES.get(inp.name) ?? inp.name;
       const lv = spec.inputs[specName];
       if (lv === undefined || isDerivedRule(lv)) {
@@ -3415,6 +3429,7 @@ export function buildHeapScene(
         const reg = registerRoDerivations(derivedScene, {}, {
           rules: ruleSubset,
           trafoAvals,
+          ...(spec.modelChain !== undefined ? { modelChain: spec.modelChain } : {}),
           hostUniformOffset: (n) => {
             const r = perDrawRefs.get(n);
             return r === undefined ? undefined : r + ALLOC_HEADER_PAD_TO;