@forgeax/engine-render 0.1.6 → 0.1.19

package/src/record/frame.ts

@@ -4,6 +4,7 @@
 import { HANDLE_NINESLICE_QUAD, resolveAssetHandle } from '@forgeax/engine-assets-runtime';
 import type { World } from '@forgeax/engine-ecs';
 import type { RenderReadLease } from '@forgeax/engine-ecs/projection';
+import { mat4 } from '@forgeax/engine-math';
 import {
   type CurrentFrameObservationLease,
   createCurrentFrameObservationLease,
@@ -21,6 +22,7 @@ import type { MaterialRenderState, MeshAsset } from '@forgeax/engine-types';
 import { handleSlot, toShared } from '@forgeax/engine-types';
 import type { MeshGpuHandles } from '../device/gpu-residency';
 import { ObservationUnavailableError, type ObservationUnavailableReason } from '../errors/render';
+import type { FogFrame } from '../extract/environment';
 import type { GpuDrivenProduction, PreparedGpuDrivenFrame } from '../gpu-driven/production-raster';
 import { GpuBuffer } from '../gpu-resource';
 import { GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_VERTEX } from '../gpu-usage';
@@ -40,6 +42,7 @@ import {
   TRANSPARENT_SORT_MODE_LAYER_Y,
   TRANSPARENT_SORT_MODE_LAYER_Z,
 } from '../systems/transparent-sort-config';
+import type { TransmissionDemand } from '../transmission/projection';
 import {
   buildPerFrameBindGroups,
   prepareFrameLighting,
@@ -184,6 +187,7 @@ export async function observeCurrentFrame(
   });
 }
 
+import { createTemporalView, resolveTemporalReset } from '../temporal/view';
 import {
   acquireSwapChainTarget,
   graphExecutionPhase,
@@ -191,6 +195,7 @@ import {
   resolveSpotShadowMapSize,
 } from './frame-targets';
 import {
+  computeProjectionMatrix,
   computeViewMatrix,
   driveLazyEquirectProjection,
   selectLazyEquirectHandle,
@@ -206,7 +211,7 @@ import {
   executeCompiledFrameGraph,
   type RenderFeatureGraphCandidate,
 } from './typed-frame-graph';
-import { writeViewUbo } from './view-ubo';
+import { writePointsLinesViewUbo, writeViewUbo } from './view-ubo';
 
 /**
  * A frame-local material table. Repeated snapshot objects share one UBO slot;
@@ -304,6 +309,7 @@ export function recordFrame(
   skybox: SkyboxSnapshot | undefined,
   skyboxCount: number,
   postProcessParams: ReadonlyMap<string, Uint8Array>,
+  fog: FogFrame | undefined,
   // feat-20260709-editor-world-partition ENGINE-fix-round2 (defect 2): the
   // full worlds[] list passed to `renderer.draw`, indexed by
   // RenderableSnapshot.worldId so the record stage resolves each renderable's
@@ -320,6 +326,11 @@ export function recordFrame(
   },
   renderReadLeases?: readonly RenderReadLease[],
   featureGraphCandidate?: RenderFeatureGraphCandidate,
+  pointsLinesOwner?: import('./render-context').PointsLinesRecordOwner,
+  environmentSignature = '',
+  fogSignature = '',
+  environmentReady = true,
+  transmissionDemand?: TransmissionDemand,
 ): boolean {
   // The `try / finally` wrapper advances `frameState.frameNumber` exactly
   // once per `recordFrame` invocation regardless of which early-return
@@ -520,6 +531,8 @@ export function recordFrame(
         graphShadowMapSize,
         preparedGpuDriven,
         featureGraphCandidate,
+        cameras.length === 0,
+        transmissionDemand,
       ),
     );
     if (preflightGraph === null) return false;
@@ -538,6 +551,79 @@ export function recordFrame(
     const targetW = swapTarget.targetW;
     const targetH = swapTarget.targetH;
 
+    const temporalView =
+      camera.antialias === 'taa' && environmentReady
+        ? (() => {
+            const created = createTemporalView({
+              antialias: camera.antialias,
+              width: targetW,
+              height: targetH,
+              frameIndex: frameState.successfulTemporalFrameIndex ?? 0,
+              viewIdentity: `camera:${camera.entityKey ?? 0}`,
+              environmentSignature,
+              fogSignature,
+              deviceGeneration: internals.deviceScope.generation,
+              ...(camera.historyVersion === undefined
+                ? {}
+                : { historyVersion: camera.historyVersion }),
+            });
+            const previous = frameState.lastSuccessfulTemporalView;
+            const currentUnjitteredViewProjection = mat4.multiply(
+              mat4.create(),
+              computeProjectionMatrix(camera),
+              computeViewMatrix(camera),
+            );
+            const resetCandidate = createTemporalView({
+              antialias: created.input.antialias,
+              width: created.input.width,
+              height: created.input.height,
+              frameIndex: created.input.frameIndex,
+              historyVersion: created.input.historyVersion,
+              viewIdentity: created.input.viewIdentity,
+              environmentSignature,
+              fogSignature,
+              deviceGeneration: internals.deviceScope.generation,
+              cameraCut: created.input.cameraCut,
+              historyValid: false,
+              currentUnjitteredViewProjection,
+            });
+            const resetReason = resolveTemporalReset(previous, resetCandidate);
+            return createTemporalView({
+              ...resetCandidate.input,
+              frameIndex: resetReason === undefined ? resetCandidate.input.frameIndex : 0,
+              historyValid: previous !== undefined && resetReason === undefined,
+              currentUnjitteredViewProjection,
+              resetReason,
+              ...(resetReason !== undefined ||
+              previous?.currentUnjitteredViewProjection === undefined
+                ? {}
+                : {
+                    previousUnjitteredViewProjection: previous.currentUnjitteredViewProjection,
+                  }),
+            });
+          })()
+        : undefined;
+    frameState.pendingTemporalCommit =
+      cameras.length === 0 || !environmentReady || internals.deviceScope === undefined
+        ? { kind: 'none' }
+        : temporalView === undefined
+          ? {
+              kind: 'off',
+              view: createTemporalView({
+                antialias: camera.antialias,
+                width: targetW,
+                height: targetH,
+                frameIndex: frameState.successfulTemporalFrameIndex ?? 0,
+                viewIdentity: `camera:${camera.entityKey ?? 0}`,
+                environmentSignature,
+                fogSignature,
+                deviceGeneration: internals.deviceScope.generation,
+              }),
+            }
+          : { kind: 'taa', view: temporalView };
+    const recordCamera: CameraSnapshot =
+      temporalView === undefined ? camera : { ...camera, temporal: temporalView };
+
     const depthView: TextureView | null = null;
     // feat-20260709 M3 / D-3: clear-color read from the active CameraSnapshot's
     // single `clearColor` array field (first-archetype-hit per OOS-2). When the
@@ -582,7 +668,7 @@ export function recordFrame(
     const { tonemapActive, skyboxActive } = resolveSkyboxActive(
       internals,
       frameState,
-      camera,
+      recordCamera,
       skybox,
     );
 
@@ -698,7 +784,18 @@ export function recordFrame(
           light,
           lights,
           frameState.spotShadowSnapshots,
+          fog,
+          temporalView,
         );
+        if (pipelineState.pointsLinesViewBuffer !== undefined) {
+          writePointsLinesViewUbo(
+            internals.device.queue,
+            pipelineState.pointsLinesViewBuffer,
+            camera,
+            targetW,
+            targetH,
+          );
+        }
         writeShadowCasterUniforms(
           internals.device.queue,
           pipelineState.shadowCasterCascadeBuffer,
@@ -773,12 +870,29 @@ export function recordFrame(
     // errorRegistry + shader-cache lookups) surfaces (`internals` itself satisfies
     // `RenderSystemRuntime` so `runtime: internals` is a zero-cost reference). The
     // 0-consumed `skyboxCount` residual is dropped.
+    // Camera-owned temporal controls are projected into the per-frame
+    // post-process parameter map at record time. The extracted ECS map only
+    // carries explicit PostProcessParams components; without this bridge the
+    // builtin motion-blur pass receives its all-zero registration default and
+    // becomes a no-op even though the temporal scene target is populated.
+    const framePostProcessParams = new Map(postProcessParams);
+    if (camera.motionBlur !== undefined) {
+      const motionBlurParams = new Uint8Array(16);
+      const motionBlurView = new DataView(motionBlurParams.buffer);
+      motionBlurView.setFloat32(0, camera.motionBlur.shutterAngle, true);
+      motionBlurView.setFloat32(4, camera.motionBlur.maxRadiusPixels, true);
+      motionBlurView.setUint32(8, camera.motionBlur.sampleCount, true);
+      motionBlurView.setUint32(12, temporalView?.historyValid === true ? 0 : 1, true);
+      framePostProcessParams.set('forgeax.motion-blur', motionBlurParams);
+    }
+
     const passCtx: _InternalRenderPipelineContext = {
       assets: internals.assets,
       world,
       gpuDrivenEntityKeys: gpuOwnedEntityKeys,
       store: internals.gpuStore,
       pipelineState,
+      bloomResources: pipelineState.perPassResources.getBloomResources?.() ?? null,
       runtime: internals,
       encoder,
       view,
@@ -786,7 +900,7 @@ export function recordFrame(
       targetW,
       targetH,
       currentTexture,
-      camera,
+      camera: recordCamera,
       tonemapActive,
       geometryColorView,
       geometryDepthView,
@@ -807,7 +921,7 @@ export function recordFrame(
       msaaActive,
       geometryColorResolveView,
       ldrSpriteColorView,
-      postProcessParams,
+      postProcessParams: framePostProcessParams,
       dispatch: transparentDispatch,
       hdrpClusterBindGroup,
       hdrpClusterMembershipBindGroup,
@@ -816,6 +930,7 @@ export function recordFrame(
       materialSlots,
       materialSlotOwners,
       materialSlotCount,
+      pointsLines: pointsLinesOwner,
       materialBgAssemblyCache: frameState.materialBgAssemblyCache,
       directionalShadowCacheReuse: directionalShadowCache.reuse,
       ...(profilePhase !== undefined ? { profilePhase } : {}),

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

@@ -21,6 +21,8 @@ import type { InstanceBufferCacheEntry } from '../instance-buffer-cache';
 import { SPRITE_PREMULTIPLIED_ALPHA_BLEND } from '../materials';
 import { SKIN_MATERIAL_SHADER_ID } from '../pbr-pipeline';
 import { renderStateHash, variantSetFromVertexLayoutProjection } from '../pipeline-spec';
+import type { PointsLinesRecordPlan } from '../points-lines/record';
+import { POINTS_LINES_MATERIAL_SHADER_ID } from '../points-lines/record';
 import type { RenderRecordPhase } from '../render-contract';
 import type { MaterialSnapshot } from '../render-system-extract';
 import { worldEntityKey } from './frame-snapshot';
@@ -40,6 +42,7 @@ import {
 } from './mesh-ssbo';
 import type { _InternalRenderPipelineContext } from './render-context';
 import { MATERIAL_PER_ENTITY_STRIDE } from './render-context';
+import { POINTS_LINES_VIEW_SLOT_STRIDE, writePointsLinesViewUbo } from './view-ubo';
 
 type GeometryInstanceDraw = {
   readonly instanceBuffer: Buffer;
@@ -54,7 +57,7 @@ type GeometryBindingState = {
 
 type MaterialPipelineLookup = {
   readonly materialShaderId: string;
-  readonly tonemapActive: boolean;
+  readonly isHdrTarget: boolean;
   readonly renderStateKey: string;
   readonly topology: PrimitiveTopology;
   readonly indexFormat: 'uint16' | 'uint32';
@@ -68,6 +71,27 @@ type MaterialPipelineLookup = {
 
 type GeometryRecordProfileSegment = 'material-bind-groups' | 'pipeline-selection' | 'draw-submit';
 
+type GeometryRenderState = ReturnType<typeof geometryRenderStateForTopology>;
+
+/**
+ * Resolve the depth contract for a geometry pass without changing the base
+ * material state. Temporal scene-data shares the main pass depth attachment:
+ * it is read-only and accepts the equal depth produced by the unjittered
+ * temporal projection, while still rejecting fragments behind the visible
+ * surface.
+ */
+export function geometryRenderStateForPass(
+  base: GeometryRenderState,
+  passKind: PassKind,
+): GeometryRenderState {
+  if (passKind !== 'temporal') return base;
+  return {
+    ...base,
+    depthWriteEnabled: false,
+    depthCompare: 'less-equal' as const,
+  };
+}
+
 function geometryRecordPhase(
   passKind: PassKind,
   segment: GeometryRecordProfileSegment,
@@ -115,6 +139,23 @@ function submitSubmeshDraws(
   }
 }
 
+/**
+ * Issues a prepared Points/Lines draw into the already-open geometry pass.
+ * Pass lifetime, attachments, bind groups, and submission remain owned by the
+ * existing main-pass interpreter.
+ */
+export function recordPointsLinesDraw(
+  pass: RhiRenderPassEncoder,
+  plan: PointsLinesRecordPlan,
+): void {
+  if (plan.drawCount === 0) return;
+  if (plan.indexCount > 0) {
+    pass.drawIndexed(plan.indexCount, 1, 0, 0, 0);
+    return;
+  }
+  pass.draw(plan.vertexCount, 1, 0, 0);
+}
+
 /**
  * feat-20260704 M3/w19: per-entity geometry (main colour) draw loop, extracted
  * verbatim from recordMainPass. Walks `c.validatedOrdered`, selects the
@@ -155,8 +196,15 @@ export function recordGeometryDraws(
     msaaActive,
     validatedOrdered,
     splitLdrSprite,
+    viewBindGroup,
   } = c;
   const colorFormatOverride = c.transparentColorFormat as GPUTextureFormat | undefined;
+  // A no-tone frame may still render into the graph-owned rgba16float target
+  // (the linear-LDR route). Shader variants must follow the attachment's
+  // 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';
   let lastVertexBuffer: GpuBuffer | null = null;
   let lastIndexBuffer: GpuBuffer | null = null;
   const bindingState: GeometryBindingState = {
@@ -205,7 +253,7 @@ export function recordGeometryDraws(
     if (cachedLookups !== undefined) {
       for (const cached of cachedLookups) {
         if (
-          cached.tonemapActive === tonemapActive &&
+          cached.isHdrTarget === isHdrTarget &&
           cached.renderStateKey === renderStateKey &&
           cached.topology === topology &&
           cached.indexFormat === indexFormat &&
@@ -219,10 +267,11 @@ export function recordGeometryDraws(
         }
       }
     }
-    const resolvedVariantSetResult = variantSetFromVertexLayoutProjection(
-      layoutProjection,
-      variantSet,
-    );
+    const resolvedVariantSetResult =
+      variantSet === undefined &&
+      (materialShaderId === 'forgeax::sprite' || materialShaderId === 'forgeax::sprite-lit')
+        ? ({ ok: true, value: undefined } as const)
+        : variantSetFromVertexLayoutProjection(layoutProjection, variantSet);
     if (!resolvedVariantSetResult.ok) {
       runtime.errorRegistry.fire(resolvedVariantSetResult.error);
       return null;
@@ -231,7 +280,7 @@ export function recordGeometryDraws(
     const resolvePipeline = () =>
       runtime.getMaterialShaderPipeline?.(
         materialShaderId,
-        tonemapActive,
+        isHdrTarget,
         renderState,
         topology,
         indexFormat,
@@ -249,25 +298,37 @@ export function recordGeometryDraws(
       profilePhase === undefined
         ? resolvePipeline()
         : profileGeometrySegment(c, passKind, 'pipeline-selection', resolvePipeline);
-    const nextLookup: MaterialPipelineLookup = {
-      materialShaderId,
-      tonemapActive,
-      renderStateKey,
-      topology,
-      indexFormat,
-      variantSet,
-      passKind,
-      layoutProjection,
-      sampleCount,
-      colorFormatOverride: colorFormat,
-      handle,
-    };
-    if (shaderLookupCache === undefined) {
-      materialPipelineLookupCache.set(materialShaderId, new Map([[renderStateKey, [nextLookup]]]));
-    } else if (cachedLookups === undefined) {
-      shaderLookupCache.set(renderStateKey, [nextLookup]);
-    } else {
-      cachedLookups.push(nextLookup);
+    // A null handle is a transient async-build signal (`rhi-not-available`),
+    // not a stable pipeline result. Do not memoize it in this frame's lookup:
+    // caching the first pending lookup would turn a one-frame shader warm-up
+    // into a permanent skip for every later frame in a tight smoke loop. The
+    // owning runtime cache remains the SSOT; retrying here is bounded by the
+    // existing per-frame draw path and preserves the explicit skip-draw
+    // recovery while the pipeline becomes ready.
+    if (handle !== null) {
+      const nextLookup: MaterialPipelineLookup = {
+        materialShaderId,
+        isHdrTarget,
+        renderStateKey,
+        topology,
+        indexFormat,
+        variantSet,
+        passKind,
+        layoutProjection,
+        sampleCount,
+        colorFormatOverride: colorFormat,
+        handle,
+      };
+      if (shaderLookupCache === undefined) {
+        materialPipelineLookupCache.set(
+          materialShaderId,
+          new Map([[renderStateKey, [nextLookup]]]),
+        );
+      } else if (cachedLookups === undefined) {
+        shaderLookupCache.set(renderStateKey, [nextLookup]);
+      } else {
+        cachedLookups.push(nextLookup);
+      }
     }
     return handle;
   };
@@ -276,6 +337,13 @@ export function recordGeometryDraws(
     const entry = validatedOrdered[i];
     if (entry === undefined) continue;
 
+    // Points/Lines share the Standard geometry pass. Their retained source
+    // is prepared once by the renderer owner, while this loop remains the
+    // sole pass/draw submission owner and preserves the authored topology.
+    const pointsLinesSubmission = c.pointsLines?.prepare(entry, frameState.isHdrpActive);
+    if (entry.source.pointsLines !== undefined && pointsLinesSubmission?.plan.drawCount !== 1)
+      continue;
+
     if (
       passKind === 'forward' &&
       c.gpuDrivenEntityKeys.has(worldEntityKey(entry.source.worldId, entry.source.entityKey))
@@ -316,6 +384,70 @@ export function recordGeometryDraws(
       lastStencilReference = stencilReference;
     }
 
+    if (pointsLinesSubmission !== undefined && entry.source.pointsLines !== undefined) {
+      const pointsLinesMaterial: MaterialSnapshot = {
+        ...entry.source.material,
+        materialShaderId: POINTS_LINES_MATERIAL_SHADER_ID,
+        materialParamSchema:
+          runtime.getParamSchema?.(POINTS_LINES_MATERIAL_SHADER_ID) ??
+          entry.source.material.materialParamSchema,
+      };
+      const materialSlot = materialSlotIndices[i]?.[0] ?? 0;
+      const pointsLinesBindGroup = resolveMaterialBindGroup(
+        materialSlot,
+        pointsLinesMaterial,
+        entry.source.entityKey,
+        entry.world ?? c.world,
+      );
+      const pointsLinesPipeline = resolveMaterialPipeline(
+        POINTS_LINES_MATERIAL_SHADER_ID,
+        {
+          ...pointsLinesMaterial.renderState,
+          cullMode: 'none',
+        },
+        'triangle-list',
+        'uint32',
+        undefined,
+        colorFormatOverride,
+        pointsLinesSubmission.layoutProjection,
+      );
+      if (pointsLinesPipeline === null) continue;
+      if (pipelineState.pointsLinesViewBuffer === undefined) continue;
+      writePointsLinesViewUbo(
+        runtime.device.queue,
+        pipelineState.pointsLinesViewBuffer,
+        c.camera,
+        c.targetW,
+        c.targetH,
+        entry.source.transform.world,
+        entry.source.pointsLines.style,
+        i * POINTS_LINES_VIEW_SLOT_STRIDE,
+      );
+      pass.setBindGroup(
+        0,
+        viewBindGroup as BindGroup,
+        new Uint32Array([i * POINTS_LINES_VIEW_SLOT_STRIDE]),
+        0,
+        1,
+      );
+      pass.setPipeline(pointsLinesPipeline);
+      pass.setVertexBuffer(0, pointsLinesSubmission.vertexBuffer);
+      pass.setIndexBuffer(pointsLinesSubmission.indexBuffer, 'uint32');
+      materialGroup1DynamicOffsets[0] = materialSlot * MATERIAL_PER_ENTITY_STRIDE;
+      pass.setBindGroup(1, pointsLinesBindGroup, materialGroup1DynamicOffsets, 0, 1);
+      const pointsLinesMeshGroup = meshBindGroup ?? meshGroup2;
+      if (pointsLinesMeshGroup === null) continue;
+      pass.setBindGroup(2, pointsLinesMeshGroup, meshGroup2DynamicOffsets);
+      pass.setBindGroup(
+        3,
+        identityInstanceDraws[0]?.instanceBindGroup ??
+          resolveGeometryInstancesBindGroup(c, identityInstanceBuffer),
+      );
+      recordPointsLinesDraw(pass, pointsLinesSubmission.plan);
+      pass.setBindGroup(0, viewBindGroup as BindGroup, [0]);
+      continue;
+    }
+
     if (entry.mesh.vertexBuffer !== lastVertexBuffer) {
       pass.setVertexBuffer(0, entry.mesh.vertexBuffer.handle);
       lastVertexBuffer = entry.mesh.vertexBuffer;
@@ -414,7 +546,7 @@ export function recordGeometryDraws(
       skinResources !== null && skinVariantSetResult.ok
         ? (runtime.getMaterialShaderPipeline?.(
             SKIN_MATERIAL_SHADER_ID,
-            tonemapActive,
+            isHdrTarget,
             entry.source.material.renderState,
             entry.mesh.submeshes[0]?.topology ?? 'triangle-list',
             entry.mesh.indexFormat,
@@ -635,7 +767,7 @@ export function recordGeometryDraws(
       // Preserve the dedicated sprite-pass state when the linear-LDR graph
       // routes a sprite through this generic geometry path. Negative scale
       // flips winding, so back-face culling would erase the quad.
-      const pipelineRenderState = isSpriteShader
+      const basePipelineRenderState = isSpriteShader
         ? {
             ...submeshMaterial.renderState,
             depthWriteEnabled: false,
@@ -644,6 +776,7 @@ export function recordGeometryDraws(
             blend: submeshMaterial.renderState?.blend ?? SPRITE_PREMULTIPLIED_ALPHA_BLEND,
           }
         : geometryRenderStateForTopology(smTopology, submeshMaterial.renderState);
+      const pipelineRenderState = geometryRenderStateForPass(basePipelineRenderState, passKind);
       let smPipelineHandle: typeof pipelineState.unlitPipeline;
       if (smMaterialShaderId === undefined || smMaterialShaderId === 'forgeax::default-unlit') {
         const unlitShaderId = smMaterialShaderId ?? 'forgeax::default-unlit';
@@ -671,7 +804,7 @@ export function recordGeometryDraws(
         smPipelineHandle =
           unlitRsp ??
           (colorFormatOverride === undefined
-            ? selectGeometryPipeline(pipelineState, tonemapActive, msaaActive)
+            ? selectGeometryPipeline(pipelineState, isHdrTarget, msaaActive)
             : null);
       } else if (smMaterialShaderId !== undefined) {
         // feat-20260609 M4.5 / w38 (D-11): the variantSet handed to
@@ -701,18 +834,23 @@ export function recordGeometryDraws(
             ? ''
             : 'CLUSTER_FORWARD_AVAILABLE=true+STORAGE_BUFFER_AVAILABLE=true'
           : 'CLUSTER_FORWARD_AVAILABLE=false+STORAGE_BUFFER_AVAILABLE=true';
-        const authoredVariantSet =
-          isSpriteShader && entry.source.spriteInstances !== undefined ? '' : entry.variantSet;
-        const variantSet =
-          authoredVariantSet === undefined
+        // Sprite's base request must retain the boot-selected artifact. Only
+        // SpriteInstances uses the explicit empty key for the
+        // PER_INSTANCE_REGION=true variant; synthesizing the generic PBR
+        // capability axes for a base sprite would invent a lazy module label
+        // that has no boot seed and skip the first HDR draw.
+        const variantSet = isSpriteShader
+          ? smMaterialShaderId === 'forgeax::sprite' && entry.source.spriteInstances !== undefined
+            ? ''
+            : undefined
+          : entry.variantSet === undefined
             ? capabilityVariantSet
             : capabilityVariantSet === ''
-              ? authoredVariantSet
-              : `${capabilityVariantSet}+${authoredVariantSet}`;
-        const projectionVariantSetResult = variantSetFromVertexLayoutProjection(
-          entry.mesh.layoutProjection,
-          variantSet,
-        );
+              ? entry.variantSet
+              : `${capabilityVariantSet}+${entry.variantSet}`;
+        const projectionVariantSetResult = isSpriteShader
+          ? ({ ok: true, value: variantSet } as const)
+          : variantSetFromVertexLayoutProjection(entry.mesh.layoutProjection, variantSet);
         if (!projectionVariantSetResult.ok) {
           runtime.errorRegistry.fire(projectionVariantSetResult.error);
           continue;
@@ -741,7 +879,7 @@ export function recordGeometryDraws(
         // fires on per-submesh topology variance miss.
         smPipelineHandle = cachedPipeline ?? null;
       } else {
-        smPipelineHandle = selectGeometryPipeline(pipelineState, tonemapActive, msaaActive);
+        smPipelineHandle = selectGeometryPipeline(pipelineState, isHdrTarget, msaaActive);
       }
 
       if (smPipelineHandle === null) {