@forgeax/engine-render 0.1.29 → 0.1.31

package/src/record/frame.ts

@@ -1,3 +1,5 @@
+import { collectGpuDrivenMaterialArtifacts } from '../gpu-driven/material-artifacts';
+import { materialBindingKey, projectMaterialBindingClasses } from '../gpu-driven/material-bindings';
 import { uploadMaterialUniforms } from './material-uniforms';
 // @forgeax/engine-runtime - RenderSystem record stage: frame.
 // Extracted from render-system-record.ts (feat-20260704 M3/w17, pure move).
@@ -43,6 +45,7 @@ import {
   GPU_BUFFER_USAGE_VERTEX,
 } from '../gpu-usage';
 import { disposeTransientInstanceBuffers } from '../instance-buffer-cache';
+import { deriveRenderExtent } from '../pipeline/render-extent';
 import { inspectStandardLighting } from '../pipeline/standard-lighting/inspection';
 import { standardLightingTopologySignature } from '../pipeline/standard-lighting/topology';
 import { inspectPointShadow } from '../point-shadow-inspection';
@@ -401,18 +404,25 @@ export interface MaterialSlotPlan<T extends object> {
  */
 export function buildMaterialSlotPlan<T extends object>(
   materialGroups: readonly (readonly T[])[],
+  bindingClass?: (material: T, owner: number) => string,
 ): MaterialSlotPlan<T> {
-  const slotByMaterial = new Map<T, number>();
+  const slotByMaterial = new Map<T, Map<string, number>>();
   const slots: T[] = [];
   const slotOwners: number[] = [];
   const slotIndices = materialGroups.map((materials, ownerIndex) =>
     materials.map((material) => {
-      const cached = slotByMaterial.get(material);
+      const resourceClass = bindingClass?.(material, ownerIndex) ?? '';
+      let materialClasses = slotByMaterial.get(material);
+      if (materialClasses === undefined) {
+        materialClasses = new Map();
+        slotByMaterial.set(material, materialClasses);
+      }
+      const cached = materialClasses.get(resourceClass);
       if (cached !== undefined) return cached;
       const slot = slots.length;
       slots.push(material);
       slotOwners.push(ownerIndex);
-      slotByMaterial.set(material, slot);
+      materialClasses.set(resourceClass, slot);
       return slot;
     }),
   );
@@ -482,6 +492,7 @@ function limitRowsToMeshSsboCapacity<T>(rows: readonly T[], availableSlots: numb
 export type RecordProfileRunner = <T>(phase: RenderRecordPhase, action: () => T) => T;
 
 export interface CubeCaptureFrameInput {
+  readonly captureDispatch?: readonly DispatchEntry[];
   readonly snapshots: readonly CubeCameraSnapshot[];
   readonly scheduler: import('../capture/scheduler').CubeCaptureScheduler;
   readonly state: CubeCaptureGraphState;
@@ -659,15 +670,19 @@ async function mapReflectionFallbackReadback(
     for (let y = 0; y < request.height; y += 1) {
       for (let x = 0; x < request.width; x += 1) {
         const offset = y * request.bytesPerRow + x * 8;
-        const pixel = [0, 1, 2, 3].map((channel) =>
-          halfFloatToNumber(view.getUint16(offset + channel * 2, true)),
-        ) as [number, number, number, number];
-        // The clear attachment carries alpha=1, so alpha alone is not
-        // evidence that the Standard BRDF wrote a fallback lobe. Decode the
-        // RGB channels from the mapped MRT and admit the first finite
-        // non-zero color sample only.
-        if (pixel.slice(0, 3).some((value) => Number.isFinite(value) && value !== 0)) {
-          linearHdr = pixel;
+        // Validation above already rejects non-finite half floats. Scan the
+        // raw RGB magnitudes (both signed zero encodings are empty) without
+        // allocating/decoding millions of background pixels each frame.
+        const red = view.getUint16(offset, true);
+        const green = view.getUint16(offset + 2, true);
+        const blue = view.getUint16(offset + 4, true);
+        if ((red & 0x7fff) !== 0 || (green & 0x7fff) !== 0 || (blue & 0x7fff) !== 0) {
+          linearHdr = [
+            halfFloatToNumber(red),
+            halfFloatToNumber(green),
+            halfFloatToNumber(blue),
+            halfFloatToNumber(view.getUint16(offset + 6, true)),
+          ];
           y = request.height;
           break;
         }
@@ -1854,15 +1869,21 @@ export function recordFrame(
       (volumetricFog?.status === 'degraded' && acceptedFallback !== undefined);
 
     let preparedGpuDriven: PreparedGpuDrivenFrame | undefined;
+    let materialBindingClasses: ReadonlyMap<string, string> | undefined;
     const abortPreparedGpuDriven = (): void => {
       preparedGpuDriven?._abortResourceReplacement?.();
     };
     const cubeCaptureWork = prepareCubeCapture(internals, cubeCapture, camera);
     const reflectionFallbackCandidate = cubeCapture?.reflectionProbes?.fallbackDemand === true;
-    // The Standard PBR GPU raster owns one color target. Reflection fallback
-    // adds an MRT attachment, so keep this frame on the ordinary CPU producer
-    // instead of claiming rows that the one-target GPU pipeline cannot draw.
-    const frameGpuDriven = reflectionFallbackCandidate ? undefined : gpuDriven;
+    // Capture views have independent draw ownership; display-camera GPU work
+    // remains active while their faces and SSR fallback attachments are recorded.
+    // ProbeBlendRecord is an object-level fragment ABI. The scene-index GPU
+    // lane has no binding for that record yet, so claiming a probe-bearing
+    // row would silently fall back to Skylight and make local diffuse probes
+    // visually ineffective. Keep the whole frame on the CPU producer until
+    // the scene-index lane carries the same record contract.
+    const probeBlendFrame = renderables.some((entry) => entry.probeBlendRecord !== undefined);
+    const frameGpuDriven = probeBlendFrame ? undefined : gpuDriven;
 
     // Validate first so user meshes are resident in the same frame. The GPU
     // owner consumes this producer-owned map together with the builtin mesh
@@ -1914,6 +1935,41 @@ export function recordFrame(
       ? projectValidatedRows(validatedProjection, renderables)
       : validatedProjection;
 
+    // S_fallback is the second output of the built-in Standard PBR BRDF. A
+    // graph may still carry the detached owner tickets for inspection, but
+    // the MRT is admitted only when every CPU-rendered primary row in this
+    // frame uses that exact output contract. Unsupported compositions remain
+    // fail-closed for SSR instead of submitting a device-invalid command.
+    const sceneInputs =
+      validatedForResidency.length > 0 &&
+      validatedForResidency.every(
+        (entry) => entry.source.material.materialShaderId === 'forgeax::default-standard-pbr',
+      );
+    const ssrAdmission =
+      ssrDependencies === undefined
+        ? undefined
+        : admitSsrSpatial({
+            camera,
+            environment: {
+              lane: standard.prepared.renderPath === 'deferred' ? 'deferred' : 'forward',
+              m0: ssrDependencies.admission,
+              sceneInputs,
+              // Standard geometry produces current motion/coverage in this
+              // graph, including its first frame. Prior history is optional.
+              temporal: sceneInputs,
+              reflectionFallback: ssrDependencies.reflectionFallback !== undefined,
+              capabilities: {
+                compute: internals.device.caps.compute,
+                storageTexture: internals.device.caps.storageTexture,
+                rgba16floatRenderable: internals.device.caps.rgba16floatRenderable,
+                r32floatSampledStorage: ssrDependencies.format?.verdict === 'admitted',
+              },
+              recovery: true,
+            },
+          });
+    frameState.reflectionFallbackDemand =
+      (reflectionFallbackCandidate || ssrAdmission?.status === 'admitted') && sceneInputs;
+
     if (frameGpuDriven !== undefined) {
       const gpuDrivenMeshes = new Map(
         gpuDrivenMeshesForFrame(internals, pipelineState, worlds, frameGpuDriven.scene),
@@ -1930,10 +1986,28 @@ export function recordFrame(
         );
         if (slot !== undefined) gpuDrivenMeshes.set(slot, row.mesh);
       }
-      const standardPbrArtifact = internals.getMaterialShaderArtifact?.(
-        'forgeax::default-standard-pbr',
+      // Resolve one producer artifact for every prepared draw. COLOR_0 is a
+      // per-geometry ABI axis, so a residency-wide `.some(color)` would pair
+      // a no-color draw with the colored receipt (or vice versa) and collapse
+      // two distinct pipeline/projection identities before indirect record.
+      materialBindingClasses = projectMaterialBindingClasses(
+        validatedForResidency,
+        transparentDispatch,
+        cubeCapture?.reflectionProbes,
       );
-      const standardPbrSkinArtifact = internals.getMaterialShaderArtifact?.('forgeax::pbr-skin');
+      const { materialArtifacts, shadowMaterialArtifacts, firstArtifact, firstSkinArtifact } =
+        collectGpuDrivenMaterialArtifacts({
+          rows: validatedForResidency,
+          shadowRows: validatedShadowForResidency ?? [],
+          dispatch: transparentDispatch,
+          shadowDispatch: shadowCasterProjection?.dispatch ?? [],
+          resolve: internals.getMaterialShaderArtifact,
+          clustered:
+            standard.kind === 'clustered' &&
+            (standard.prepared.local.length > 0 ||
+              frameState.installedPipelineConfig?.ssao?.enabled === true),
+          reflectionFallback: frameState.reflectionFallbackDemand === true,
+        });
       const paletteUploadBytes = validatedForResidency.reduce(
         (total, row) => total + (row.source.skin?.uploadBytes ?? 0),
         0,
@@ -1944,14 +2018,7 @@ export function recordFrame(
         meshBySlot: gpuDrivenMeshes,
         viewBindGroupLayout: pipelineState.viewBindGroupLayout,
         meshResidencyEpoch: internals.gpuStore.meshResidencyEpoch,
-        // GPU-driven Standard PBR currently owns the non-clustered path only.
-        // Cluster bindings also carry screen-space ambient occlusion. Admit
-        // the scene-index variant only when none of those surface inputs are
-        // required; a zero local-light count alone does not establish that.
-        hdrp:
-          standard.kind === 'clustered' &&
-          (standard.prepared.local.length > 0 ||
-            frameState.installedPipelineConfig?.ssao?.enabled === true),
+        materialBindingClasses,
         ...(frameGpuDriven.activeEntityKeys === undefined
           ? {}
           : { activeEntityKeys: frameGpuDriven.activeEntityKeys }),
@@ -1970,9 +2037,14 @@ export function recordFrame(
                 paletteUploadBytes,
               },
             }),
-        ...(standardPbrArtifact === undefined ? {} : { standardPbrArtifact }),
-        ...(standardPbrSkinArtifact === undefined ? {} : { standardPbrSkinArtifact }),
-        standardPbrPipelineState: pipelineState,
+        ...(firstArtifact === undefined ? {} : { materialArtifact: firstArtifact }),
+        ...(firstSkinArtifact === undefined ? {} : { materialSkinArtifact: firstSkinArtifact }),
+        ...(materialArtifacts.size === 0 ? {} : { materialArtifacts }),
+        ...(shadowMaterialArtifacts.size === 0 ? {} : { shadowMaterialArtifacts }),
+        materialPipelineState: pipelineState,
+        ...(internals.getMaterialShaderPipelineEntry === undefined
+          ? {}
+          : { materialPipelineFactory: internals.getMaterialShaderPipelineEntry }),
         ...(shadowCasterDrawKeys === undefined ? {} : { shadowCasterDrawKeys }),
         ...(shadowCasterMembership === undefined ? {} : { shadowCasterMembership }),
       });
@@ -2062,40 +2134,22 @@ export function recordFrame(
     // the current frame. This keeps the graph topology and its execution
     // closure on the same prepared GPU-owned draw set.
 
-    // S_fallback is the second output of the built-in Standard PBR BRDF. A
-    // graph may still carry the detached owner tickets for inspection, but
-    // the MRT is admitted only when every CPU-rendered primary row in this
-    // frame uses that exact output contract. Unsupported compositions remain
-    // fail-closed for SSR instead of submitting a device-invalid command.
-    const sceneInputs =
-      validated.length > 0 &&
-      validated.every(
-        (entry) => entry.source.material.materialShaderId === 'forgeax::default-standard-pbr',
-      );
-    const ssrAdmission =
-      ssrDependencies === undefined
+    // RenderExtent is an authored DynamicResolution path. The native TAA path
+    // intentionally has no extent object, so every Standard consumer keeps the
+    // exact surface domain even when a surface is not 8-pixel aligned. An
+    // adaptive range remains unavailable until a renderer-owned timing/
+    // controller chain exists; do not turn maxScale into a fake performance
+    // decision. Fixed minScale=maxScale is the only extent currently admitted.
+    const renderExtent =
+      camera.dynamicResolution === undefined ||
+      camera.dynamicResolution.minScale !== camera.dynamicResolution.maxScale
         ? undefined
-        : admitSsrSpatial({
-            camera,
-            environment: {
-              lane: standard.prepared.renderPath === 'deferred' ? 'deferred' : 'forward',
-              m0: ssrDependencies.admission,
-              sceneInputs,
-              // Standard geometry produces current motion/coverage in this
-              // graph, including its first frame. Prior history is optional.
-              temporal: sceneInputs,
-              reflectionFallback: ssrDependencies.reflectionFallback !== undefined,
-              capabilities: {
-                compute: internals.device.caps.compute,
-                storageTexture: internals.device.caps.storageTexture,
-                rgba16floatRenderable: internals.device.caps.rgba16floatRenderable,
-                r32floatSampledStorage: ssrDependencies.format?.verdict === 'admitted',
-              },
-              recovery: true,
-            },
+        : deriveRenderExtent({
+            outputWidth: Math.max(1, internals.canvas.width),
+            outputHeight: Math.max(1, internals.canvas.height),
+            requestedScale: camera.dynamicResolution.minScale,
+            generation: internals.deviceScope?.generation ?? 0,
           });
-    frameState.reflectionFallbackDemand =
-      (reflectionFallbackCandidate || ssrAdmission?.status === 'admitted') && sceneInputs;
     const preflightGraph = runRecordProfilePhase(profilePhase, 'record/render-graph', () =>
       ensureCompiledFrameGraph(
         internals,
@@ -2117,6 +2171,7 @@ export function recordFrame(
         standard,
         undefined,
         ssrAdmission,
+        renderExtent,
       ),
     );
     if (preflightGraph === null) {
@@ -2214,6 +2269,12 @@ export function recordFrame(
       environmentSignature,
       fogSignature,
       deviceGeneration: internals.deviceScope?.generation ?? 0,
+      ...(renderExtent === undefined
+        ? {}
+        : {
+            internalWidth: renderExtent.internalWidth,
+            internalHeight: renderExtent.internalHeight,
+          }),
       ...(camera.historyVersion === undefined ? {} : { historyVersion: camera.historyVersion }),
       historyValid: false,
       currentUnjitteredViewProjection,
@@ -2371,6 +2432,7 @@ export function recordFrame(
         transparentDispatch,
         foldBuckets,
         validatedShadowForResidency ?? [],
+        materialBindingClasses,
       ),
     );
     const validatedOrdered = dispatchPlan.validatedOrdered;
@@ -2594,6 +2656,7 @@ export function recordFrame(
       clear,
       targetW,
       targetH,
+      ...(renderExtent === undefined ? {} : { extent: renderExtent }),
       currentTexture,
       camera: recordCamera,
       tonemapActive,
@@ -2656,6 +2719,9 @@ export function recordFrame(
       ...(cubeCapture?.reflectionProbes === undefined
         ? {}
         : { reflectionProbes: cubeCapture.reflectionProbes }),
+      ...(cubeCapture?.captureDispatch === undefined
+        ? {}
+        : { captureDispatch: cubeCapture.captureDispatch }),
       pointsLines: pointsLinesOwner,
       materialBgAssemblyCache: frameState.materialBgAssemblyCache,
       ...(onRenderableDraw === undefined ? {} : { onRenderableDraw }),
@@ -2669,7 +2735,10 @@ export function recordFrame(
       ...(profilePhase !== undefined ? { profilePhase } : {}),
     };
     uploadMaterialUniforms(passCtx);
-    const fallbackReadbackRequest = createReflectionFallbackReadbackRequest(internals, frameState);
+    const fallbackReadbackRequest =
+      internals.captureReflectionFallbackReadback === true
+        ? createReflectionFallbackReadbackRequest(internals, frameState)
+        : undefined;
     if (fallbackReadbackRequest !== undefined) {
       frameState.reflectionFallbackReadback = fallbackReadbackRequest;
     }
@@ -2779,21 +2848,20 @@ export function recordFrame(
     if (!submitted && fallbackReadbackRequest !== undefined) {
       internals.device.destroyBuffer(fallbackReadbackRequest.buffer);
     }
+    const fallbackSource =
+      frameState.reflectionFallbackObservationSource as RenderFrameState['reflectionFallbackObservationSource'];
     const reflectionFallbackCompletion = cubeCapture?.reflectionProbes?.completeSubmission(
       submitted,
       completion,
-      fallbackReadbackRequest === undefined || fallbackReadback === undefined
+      fallbackSource === undefined
         ? undefined
         : {
-            format: fallbackReadbackRequest.expected.format,
-            size: {
-              width: fallbackReadbackRequest.expected.width,
-              height: fallbackReadbackRequest.expected.height,
-            },
-            frameId: fallbackReadbackRequest.expected.frameId,
-            graphGeneration: fallbackReadbackRequest.expected.graphGeneration,
-            textureIdentity: fallbackReadbackRequest.expected.textureIdentity,
-            readback: fallbackReadback,
+            format: fallbackSource.descriptor.format,
+            size: fallbackSource.descriptor.size,
+            frameId: fallbackSource.frameId,
+            graphGeneration: frameState.graphGeneration,
+            textureIdentity: getTextureIdentity(fallbackSource.texture),
+            ...(fallbackReadback === undefined ? {} : { readback: fallbackReadback }),
           },
       frameState.reflectionFallbackDemand,
     );
@@ -3330,6 +3398,7 @@ export function buildDispatchPlan(
   transparentDispatch: readonly DispatchEntry[],
   foldBuckets: readonly FoldBucket[],
   shadowValidated: readonly ValidatedRenderable[] = [],
+  materialBindingClasses?: ReadonlyMap<string, string>,
 ): {
   validatedOrdered: readonly ValidatedRenderable[];
   shadowValidatedOrdered: readonly ValidatedRenderable[];
@@ -3411,7 +3480,14 @@ export function buildDispatchPlan(
     }
     return entry.source.materials.length > 0 ? entry.source.materials : [entry.source.material];
   });
-  const materialSlotPlan = buildMaterialSlotPlan(materialGroups);
+  const materialSlotPlan = buildMaterialSlotPlan(materialGroups, (material, owner) => {
+    const row = materialRows[owner];
+    return row === undefined
+      ? ''
+      : (materialBindingClasses?.get(
+          materialBindingKey(row.source, material.materialHandle ?? -1),
+        ) ?? '');
+  });
   let materialSlotIndices = materialSlotPlan.slotIndices;
   let materialSlots = materialSlotPlan.slots;
   let materialSlotOwners = materialSlotPlan.slotOwners.map((index) => {

package/src/record/main-pass-geometry.ts

@@ -73,6 +73,23 @@ import type { _InternalRenderPipelineContext, MaterialShaderPipelineEntry } from
 import { MATERIAL_PER_ENTITY_STRIDE } from './render-context';
 import { POINTS_LINES_VIEW_SLOT_STRIDE, writePointsLinesViewUbo } from './view-ubo';
 
+/** Temporal ignores authored color entry points; opaque duplicates are idempotent. */
+export function sameOpaqueTemporalDraw(a: DispatchEntry, b: DispatchEntry): boolean {
+  return (
+    (isStandardPbrMaterialShader(a.materialShaderId) ||
+      (a.tags.SurfaceKind === 'standard' &&
+        b.tags.SurfaceKind === 'standard' &&
+        a.tags.SurfaceModule === b.tags.SurfaceModule)) &&
+    a.materialShaderId === b.materialShaderId &&
+    a.renderState?.blend === undefined &&
+    b.renderState?.blend === undefined &&
+    a.renderState?.stencil === undefined &&
+    b.renderState?.stencil === undefined &&
+    a.stencilReference === b.stencilReference &&
+    renderStateHash(a.renderState) === renderStateHash(b.renderState)
+  );
+}
+
 type GeometryInstanceDraw = {
   readonly instanceBuffer: Buffer;
   readonly instanceBindGroup: BindGroup;
@@ -133,6 +150,25 @@ type GeometryRecordProfileSegment = 'material-bind-groups' | 'pipeline-selection
 
 type GeometryRenderState = ReturnType<typeof geometryRenderStateForTopology>;
 
+/** Coverage is a dedicated temporal material variant, not a color/alpha tap. */
+export function variantSetForCoveragePass(
+  variantSet: string | undefined,
+  coverageOnly: boolean,
+): string | undefined {
+  if (!coverageOnly) return variantSet;
+  if (variantSet?.includes('COVERAGE_ONLY=')) return variantSet;
+  return variantSet === undefined || variantSet === ''
+    ? 'COVERAGE_ONLY=true'
+    : `${variantSet}+COVERAGE_ONLY=true`;
+}
+
+export function isHdrGeometryTarget(
+  tonemapActive: boolean,
+  colorFormatOverride: GPUTextureFormat | undefined,
+): boolean {
+  return colorFormatOverride === undefined ? tonemapActive : colorFormatOverride === 'rgba16float';
+}
+
 function gpuDrivenDrawIndicesBySubmesh(
   source: RenderableSnapshot,
   mesh: _InternalRenderPipelineContext['validatedOrdered'][number]['mesh'],
@@ -319,11 +355,12 @@ export function effectiveMaterialLayoutIdentity(
 export function geometryRenderStateForPass(
   base: GeometryRenderState,
   passKind: PassKind,
+  coverageOnly = false,
 ): GeometryRenderState {
   if (passKind !== 'temporal') return base;
   return {
     ...base,
-    depthWriteEnabled: false,
+    depthWriteEnabled: coverageOnly,
     depthCompare: 'less-equal' as const,
   };
 }
@@ -434,6 +471,7 @@ export function recordGeometryDraws(
   passKind: PassKind = 'forward',
   selectedDispatch?: readonly DispatchEntry[],
   colorFormats: readonly GPUTextureFormat[] = [],
+  coverageOnly = false,
 ): void {
   const {
     runtime,
@@ -457,7 +495,11 @@ export function recordGeometryDraws(
     }
     const passes = byMaterial.get(dispatch.materialHandle);
     if (passes === undefined) byMaterial.set(dispatch.materialHandle, [dispatch]);
-    else passes.push(dispatch);
+    else if (
+      passKind !== 'temporal' ||
+      !passes.some((previous) => sameOpaqueTemporalDraw(previous, dispatch))
+    )
+      passes.push(dispatch);
   }
   const diagnosticsEnabled = materialDiagnosticsEnabled();
   const colorFormatOverride = c.transparentColorFormat as GPUTextureFormat | undefined;
@@ -470,7 +512,9 @@ export function recordGeometryDraws(
   // numeric domain rather than the camera's tone-map switch, otherwise the
   // LDR/OETF fragment entry point is encoded once here and again by the
   // output transform.
-  const isHdrTarget = tonemapActive || colorFormatOverride === 'rgba16float';
+  const isHdrTarget = isHdrGeometryTarget(tonemapActive, colorFormatOverride);
+  const withCoverageVariant = (variantSet: string | undefined): string | undefined =>
+    variantSetForCoveragePass(variantSet, coverageOnly);
   let lastVertexBuffer: GpuBuffer | null = null;
   let lastIndexBuffer: GpuBuffer | null = null;
   const bindingState: GeometryBindingState = {
@@ -520,6 +564,7 @@ export function recordGeometryDraws(
     fragmentEntry?: string,
     textureMask?: number,
   ): MaterialShaderPipelineEntry | null => {
+    const pipelineVariantSet = withCoverageVariant(variantSet);
     // The fallback MRT is an extension of the built-in Standard PBR output
     // contract only.  The render pass may carry a second attachment whenever
     // another renderable needs S_fallback, but shaders such as unlit, sprite,
@@ -545,7 +590,7 @@ export function recordGeometryDraws(
           cached.renderStateKey === renderStateKey &&
           cached.topology === topology &&
           cached.indexFormat === indexFormat &&
-          cached.variantSet === variantSet &&
+          cached.variantSet === pipelineVariantSet &&
           cached.vertexEntry === vertexEntry &&
           cached.fragmentEntry === fragmentEntry &&
           cached.textureMask === textureMask &&
@@ -562,10 +607,10 @@ export function recordGeometryDraws(
     const resolvedVariantSetResult =
       runtime.getMaterialArtifact?.(materialShaderId) !== undefined
         ? ({ ok: true, value: undefined } as const)
-        : variantSet === undefined &&
+        : pipelineVariantSet === undefined &&
             (materialShaderId === 'forgeax::sprite' || materialShaderId === 'forgeax::sprite-lit')
           ? ({ ok: true, value: undefined } as const)
-          : variantSetFromVertexLayoutProjection(layoutProjection, variantSet);
+          : variantSetFromVertexLayoutProjection(layoutProjection, pipelineVariantSet);
     if (!resolvedVariantSetResult.ok) {
       runtime.errorRegistry.fire(resolvedVariantSetResult.error);
       return null;
@@ -620,7 +665,7 @@ export function recordGeometryDraws(
         renderStateKey,
         topology,
         indexFormat,
-        variantSet,
+        variantSet: pipelineVariantSet,
         vertexEntry,
         fragmentEntry,
         passKind,
@@ -878,7 +923,9 @@ export function recordGeometryDraws(
       ),
     );
     if (!skinVariantSetResult.ok) runtime.errorRegistry.fire(skinVariantSetResult.error);
-    const skinVariantSet = skinVariantSetResult.ok ? skinVariantSetResult.value : undefined;
+    const skinVariantSet = skinVariantSetResult.ok
+      ? withCoverageVariant(skinVariantSetResult.value)
+      : undefined;
     const skinPsoProbe =
       skinResources !== null && skinVariantSetResult.ok
         ? (runtime.getMaterialShaderPipeline?.(
@@ -1196,7 +1243,11 @@ export function recordGeometryDraws(
               blend: selectedRenderState?.blend ?? SPRITE_PREMULTIPLIED_ALPHA_BLEND,
             }
           : geometryRenderStateForTopology(smTopology, selectedRenderState);
-        const pipelineRenderState = geometryRenderStateForPass(basePipelineRenderState, passKind);
+        const pipelineRenderState = geometryRenderStateForPass(
+          basePipelineRenderState,
+          passKind,
+          coverageOnly,
+        );
         let smPipelineHandle: typeof pipelineState.unlitPipeline;
         let materialGroup2Contract: 'mesh' | 'skin' | 'cluster' | 'skin-cluster' | undefined;
         let materialPipelineEntry: MaterialShaderPipelineEntry | null = null;