@aardworx/wombat.rendering 0.19.16 → 0.19.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aardworx/wombat.rendering",
-  "version": "0.19.16",
+  "version": "0.19.18",
   "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

@@ -88,10 +88,25 @@ function samplerDescriptorFromState(
   if (state.addressW !== undefined) (desc as { addressModeW?: GPUAddressMode }).addressModeW = addr(state.addressW);
   if (state.minLod !== undefined) (desc as { lodMinClamp?: number }).lodMinClamp = state.minLod;
   if (state.maxLod !== undefined) (desc as { lodMaxClamp?: number }).lodMaxClamp = state.maxLod;
-  // NOT applied: `comparison` (a compare sampler needs a sampler_comparison
-  // binding — separate feature) and `mipLodBias` (no WebGPU counterpart).
+  // `comparison` is applied by the caller when the binding is a
+  // sampler_comparison (a compare function on a filtering sampler would
+  // fail WebGPU validation). `mipLodBias` has no WebGPU counterpart.
   return desc;
 }
+
+/** FShade ComparisonFunction case name → GPUCompareFunction. */
+function compareFunctionOf(name: string): GPUCompareFunction {
+  switch (name) {
+    case "Never": return "never";
+    case "Less": return "less";
+    case "Equal": return "equal";
+    case "LessOrEqual": return "less-equal";
+    case "Greater": return "greater";
+    case "GreaterOrEqual": return "greater-equal";
+    case "NotEqual": return "not-equal";
+    default: return "always";
+  }
+}
 import type { RenderObject } from "../core/renderObject.js";
 import { asAttributeProvider, asUniformProvider } from "../core/provider.js";
 import type { HeapDrawSpec, HeapTextureSet } from "./heapScene.js";
@@ -391,8 +406,16 @@ export function renderObjectToHeapSpec(
   // builder, carried through the IR) overrides the scene's default sampler.
   const stateBinding = schema.samplers.find(b => b.state !== undefined);
   if (stateBinding?.state !== undefined) {
+    const desc = samplerDescriptorFromState(stateBinding.state);
+    if (stateBinding.wgslType === "sampler_comparison") {
+      // Shadow sampler: the binding requires a compare function. WebGPU
+      // also forbids anisotropy unless all filters are linear; keep the
+      // state's choice (samplerDescriptorFromState already clamps).
+      (desc as { compare?: GPUCompareFunction }).compare =
+        compareFunctionOf(stateBinding.state.comparison ?? "LessOrEqual");
+    }
     distinctSamplerAvals.add(
-      AVal.constant(ISampler.fromDescriptor(samplerDescriptorFromState(stateBinding.state))) as aval<ISampler>,
+      AVal.constant(ISampler.fromDescriptor(desc)) as aval<ISampler>,
     );
   } else {
     ro.samplers.iter((_n, av) => { distinctSamplerAvals.add(av as aval<ISampler>); });

package/src/runtime/heapEffect.ts

@@ -247,15 +247,18 @@ function buildSchema(iface: ProgramInterface): HeapEffectSchema {
   const fragmentOutputs = iface.fragmentOutputs.map(o => ({
     name: o.name, location: o.location, wgslType: irTypeToWgsl(o.type),
   }));
-  // Texture/sampler bindings post-DCE. The IR Type for textures is a
-  // structured kind we don't fully model here yet — for v1 every
-  // texture maps to "texture_2d<f32>" and every sampler to plain
-  // "sampler". Specialise as multi-kind support lands in the DSL.
+  // Texture/sampler bindings post-DCE. Comparison (shadow) samplers pair
+  // with depth textures: the legalise pass marks both with
+  // `comparison: true` — map them to "texture_depth_2d" /
+  // "sampler_comparison". Everything else stays the v1 2D-float kind;
+  // specialise further as multi-kind support lands in the DSL.
+  const isComparison = (t: unknown): boolean =>
+    typeof t === "object" && t !== null && (t as { comparison?: boolean }).comparison === true;
   const textures: HeapTextureBinding[] = iface.textures.map(t => ({
-    name: t.name, wgslType: "texture_2d<f32>",
+    name: t.name, wgslType: isComparison(t.type) ? "texture_depth_2d" : "texture_2d<f32>",
   }));
   const samplers: HeapSamplerBinding[] = iface.samplers.map(s => ({
-    name: s.name, wgslType: "sampler",
+    name: s.name, wgslType: isComparison(s.type) ? "sampler_comparison" : "sampler",
     ...(s.state !== undefined ? { state: s.state } : {}),
   }));
   return { attributes, uniforms, varyings, fragmentOutputs, textures, samplers };

package/src/runtime/heapScene/pools.ts

@@ -23,6 +23,17 @@ import { GrowBuffer, ALIGN16, DEFAULT_MAX_BUFFER_BYTES } from "./growBuffer.js";
 import { Freelist } from "./freelist.js";
 import { ChunkedAttributeArena, ChunkedIndexAllocator } from "./chunkedArena.js";
 
+// ─── Debug toggles ─────────────────────────────────────────────────────
+
+/** Opt-in O(live-allocs) overlap validation on every alloc. Set
+ *  `globalThis.__wombatDebugAllocOverlap = true` BEFORE scene creation
+ *  to enable. Default OFF: the scan made scene build O(n²) — 65 s for a
+ *  20 k-object scene, renderer-crash territory at 68 k. The O(1)
+ *  release-side checks (double-free, size mismatch) stay always-on. */
+const DEBUG_ALLOC_OVERLAP: boolean =
+  (globalThis as Record<string, unknown> & typeof globalThis)
+    .__wombatDebugAllocOverlap === true;
+
 // ─── Per-allocation header layout ──────────────────────────────────────
 
 /** Per-allocation header: (u32 typeId, u32 length). Data follows
@@ -485,19 +496,20 @@ export class AttributeArena {
       this.buf.setUsed(this.cursor);
     }
   }
-  /** Throws if the just-returned alloc overlaps any live allocation. */
+  /** Tracks the alloc; with `__wombatDebugAllocOverlap` set, also
+   *  throws if it overlaps any live allocation (O(live) per alloc —
+   *  made scene build O(n²) when always-on, hence opt-in). */
   private recordAlloc(off: number, size: number, source: string): void {
-    // Check against every existing live alloc — O(N). Cheap while N
-    // is small (per-tile demos run with ~hundreds of allocs). Wire
-    // off behind an env-flag if it ever becomes a hot path.
-    for (const [liveOff, liveSize] of this.liveAllocs) {
+    if (DEBUG_ALLOC_OVERLAP) {
       // [a, a+sa) vs [b, b+sb) overlap iff a < b+sb && b < a+sa
-      if (off < liveOff + liveSize && liveOff < off + size) {
-        throw new Error(
-          `AttributeArena.tryAlloc(${source}): returned [${off},${off + size}) ` +
-          `(size=${size}) overlaps live alloc at [${liveOff},${liveOff + liveSize}) ` +
-          `(size=${liveSize}). Allocator is handing out shared memory!`,
-        );
+      for (const [liveOff, liveSize] of this.liveAllocs) {
+        if (off < liveOff + liveSize && liveOff < off + size) {
+          throw new Error(
+            `AttributeArena.tryAlloc(${source}): returned [${off},${off + size}) ` +
+            `(size=${size}) overlaps live alloc at [${liveOff},${liveOff + liveSize}) ` +
+            `(size=${liveSize}). Allocator is handing out shared memory!`,
+          );
+        }
       }
     }
     this.liveAllocs.set(off, size);
@@ -566,13 +578,15 @@ export class IndexAllocator {
     return off;
   }
   private recordAlloc(off: number, size: number, source: string): void {
-    for (const [liveOff, liveSize] of this.liveAllocs) {
-      if (off < liveOff + liveSize && liveOff < off + size) {
-        throw new Error(
-          `IndexAllocator.tryAlloc(${source}): returned [${off},${off + size}) ` +
-          `(size=${size}) overlaps live alloc at [${liveOff},${liveOff + liveSize}) ` +
-          `(size=${liveSize}). Index allocator is handing out shared memory!`,
-        );
+    if (DEBUG_ALLOC_OVERLAP) {
+      for (const [liveOff, liveSize] of this.liveAllocs) {
+        if (off < liveOff + liveSize && liveOff < off + size) {
+          throw new Error(
+            `IndexAllocator.tryAlloc(${source}): returned [${off},${off + size}) ` +
+            `(size=${size}) overlaps live alloc at [${liveOff},${liveOff + liveSize}) ` +
+            `(size=${liveSize}). Index allocator is handing out shared memory!`,
+          );
+        }
       }
     }
     this.liveAllocs.set(off, size);

package/src/runtime/heapScene.ts

@@ -1273,7 +1273,10 @@ export function buildHeapScene(
   interface BglEntry { bgl: GPUBindGroupLayout; pipelineLayout: GPUPipelineLayout }
   const bglCache = new Map<string, BglEntry>();
   function getBgl(layout: BucketLayout, withAtlasArrays: boolean): BglEntry {
-    const key = `t${layout.textureBindings.length}|s${layout.samplerBindings.length}|a${withAtlasArrays ? 1 : 0}`;
+    const key =
+      `t${layout.textureBindings.map(t => t.wgslType).join(",")}` +
+      `|s${layout.samplerBindings.map(s => s.wgslType).join(",")}` +
+      `|a${withAtlasArrays ? 1 : 0}`;
     let e = bglCache.get(key);
     if (e !== undefined) return e;
     // Heap data buffers are read by both stages: FS uniform-via-varying
@@ -1294,13 +1297,13 @@ export function buildHeapScene(
     for (const t of layout.textureBindings) {
       entries.push({
         binding: t.binding, visibility: GPUShaderStage.FRAGMENT,
-        texture: { sampleType: "float" },
+        texture: { sampleType: t.wgslType === "texture_depth_2d" ? "depth" : "float" },
       });
     }
     for (const s of layout.samplerBindings) {
       entries.push({
         binding: s.binding, visibility: GPUShaderStage.FRAGMENT,
-        sampler: { type: "filtering" },
+        sampler: { type: s.wgslType === "sampler_comparison" ? "comparison" : "filtering" },
       });
     }
     if (withAtlasArrays) {