@aardworx/wombat.rendering 0.19.15 → 0.19.17

package/package.json

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

@@ -35,7 +35,17 @@ import { ISampler } from "../core/sampler.js";
 /** Map shader-defined sampler state (FShade Filter/WrapMode names) to a
  *  GPUSamplerDescriptor (heap path). */
 function samplerDescriptorFromState(
-  state: { readonly filter: string; readonly addressU: string; readonly addressV: string },
+  state: {
+    readonly filter: string;
+    readonly addressU: string;
+    readonly addressV: string;
+    readonly addressW?: string;
+    readonly comparison?: string;
+    readonly maxAnisotropy?: number;
+    readonly minLod?: number;
+    readonly maxLod?: number;
+    readonly mipLodBias?: number;
+  },
 ): GPUSamplerDescriptor {
   // FShade WrapMode names. WebGPU has no Border / MirrorOnce — map them to
   // their closest modes (clamp-to-edge / mirror-repeat).
@@ -66,11 +76,36 @@ function samplerDescriptorFromState(
     case "MinLinearMagPoint": mag = "nearest"; break;
     default: break; // unknown → all-linear
   }
-  return {
+  // Explicit maxAnisotropy overrides the Anisotropic-filter default.
+  // WebGPU validation: maxAnisotropy > 1 requires all-linear filtering.
+  if (state.maxAnisotropy !== undefined) aniso = state.maxAnisotropy;
+  if (min !== "linear" || mag !== "linear" || mip !== "linear") aniso = 1;
+  const desc: GPUSamplerDescriptor = {
     magFilter: mag, minFilter: min, mipmapFilter: mip,
     addressModeU: addr(state.addressU), addressModeV: addr(state.addressV),
     maxAnisotropy: aniso,
   };
+  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;
+  // `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";
@@ -371,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

@@ -52,9 +52,20 @@ export interface HeapSamplerBinding {
   readonly name: string;
   /** WGSL type — "sampler" or "sampler_comparison". */
   readonly wgslType: string;
-  /** Shader-defined sampler state (filter/address) from the IR; the adapter
-   *  builds the GPUSamplerDescriptor from it, overriding the scene default. */
-  readonly state?: { readonly filter: string; readonly addressU: string; readonly addressV: string } | undefined;
+  /** Shader-defined sampler state (filter/address/lod/anisotropy) from the
+   *  IR; the adapter builds the GPUSamplerDescriptor from it, overriding the
+   *  scene default. */
+  readonly state?: {
+    readonly filter: string;
+    readonly addressU: string;
+    readonly addressV: string;
+    readonly addressW?: string;
+    readonly comparison?: string;
+    readonly maxAnisotropy?: number;
+    readonly minLod?: number;
+    readonly maxLod?: number;
+    readonly mipLodBias?: number;
+  } | undefined;
 }
 
 export interface HeapEffectSchema {
@@ -236,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) {