@aardworx/wombat.rendering 0.19.16 → 0.19.17

package/package.json

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