@forgeax/engine-render 0.1.19 → 0.1.21

package/src/record/gpu-timing.ts

@@ -0,0 +1,233 @@
+import type { Buffer, QuerySet, RhiCommandEncoder, RhiDevice, RhiError } from '@forgeax/engine-rhi';
+import { ok, type Result } from '@forgeax/engine-types';
+import {
+  GPU_BUFFER_USAGE_COPY_DST,
+  GPU_BUFFER_USAGE_COPY_SRC,
+  GPU_BUFFER_USAGE_MAP_READ,
+  GPU_BUFFER_USAGE_QUERY_RESOLVE,
+} from '../gpu-usage';
+
+const MAX_VOLUME_PASSES = 4;
+const QUERY_COUNT = MAX_VOLUME_PASSES * 2;
+const QUERY_STRIDE_BYTES = 256;
+const READBACK_BYTES = QUERY_COUNT * QUERY_STRIDE_BYTES;
+const PASS_NAMES = [
+  'volume-inject',
+  'volume-integrate',
+  'volume-temporal',
+  'volume-composite',
+] as const;
+
+export type VolumeTimingObservation =
+  | {
+      readonly status: 'ready';
+      readonly unit: 'ms';
+      readonly totalMs: number;
+      readonly passes: readonly { readonly name: string; readonly milliseconds: number }[];
+    }
+  | {
+      readonly status: 'unavailable';
+      readonly reason: string;
+    };
+
+function unavailable(reason: string): VolumeTimingObservation {
+  return Object.freeze({ status: 'unavailable', reason });
+}
+
+export interface VolumeTimingTimestampWrites {
+  readonly querySet: QuerySet;
+  readonly beginningOfPassWriteIndex: number;
+  readonly endOfPassWriteIndex: number;
+}
+
+/**
+ * Renderer-owned timestamp capture for the authored volume graph. Query
+ * resources are private to one accepted submit and never cross the receipt
+ * boundary. This publishes raw renderer timings; a benchmark runner owns
+ * runner class, frame-count, and threshold qualification.
+ */
+export class GpuTimingCapture {
+  readonly #device: RhiDevice;
+  readonly #querySet: QuerySet;
+  readonly #resolveBuffer: Buffer;
+  readonly #readbackBuffer: Buffer;
+  readonly #periodNanoseconds: number;
+  readonly #started = new Map<string, number>();
+  readonly #finished = new Map<string, number>();
+  #resolved = false;
+  #submitted = false;
+  #discarded = false;
+  #disposed = false;
+  #observation: Promise<VolumeTimingObservation> | undefined;
+
+  private constructor(
+    device: RhiDevice,
+    querySet: QuerySet,
+    resolveBuffer: Buffer,
+    readbackBuffer: Buffer,
+    periodNanoseconds: number,
+  ) {
+    this.#device = device;
+    this.#querySet = querySet;
+    this.#resolveBuffer = resolveBuffer;
+    this.#readbackBuffer = readbackBuffer;
+    this.#periodNanoseconds = periodNanoseconds;
+  }
+
+  static create(device: RhiDevice): Result<GpuTimingCapture | undefined, RhiError> {
+    const period = device.caps.timestampPeriodNanoseconds;
+    if (!device.caps.timestampQuery || period === null || !Number.isFinite(period) || period <= 0) {
+      return ok(undefined);
+    }
+    const querySet = device.createQuerySet({
+      label: 'volume-timing',
+      type: 'timestamp',
+      count: QUERY_COUNT,
+    });
+    if (!querySet.ok) return querySet;
+    const resolveBuffer = device.createBuffer({
+      label: 'volume-timing.resolve',
+      size: READBACK_BYTES,
+      usage: GPU_BUFFER_USAGE_QUERY_RESOLVE | GPU_BUFFER_USAGE_COPY_SRC,
+    });
+    if (!resolveBuffer.ok) {
+      device.destroyQuerySet(querySet.value);
+      return resolveBuffer;
+    }
+    const readbackBuffer = device.createBuffer({
+      label: 'volume-timing.readback',
+      size: READBACK_BYTES,
+      usage: GPU_BUFFER_USAGE_MAP_READ | GPU_BUFFER_USAGE_COPY_DST,
+    });
+    if (!readbackBuffer.ok) {
+      device.destroyBuffer(resolveBuffer.value);
+      device.destroyQuerySet(querySet.value);
+      return readbackBuffer;
+    }
+    return ok(
+      new GpuTimingCapture(
+        device,
+        querySet.value,
+        resolveBuffer.value,
+        readbackBuffer.value,
+        period,
+      ),
+    );
+  }
+
+  recordPass(name: string): VolumeTimingTimestampWrites | undefined {
+    const index = PASS_NAMES.indexOf(name as (typeof PASS_NAMES)[number]);
+    if (index < 0 || this.#started.has(name) || this.#discarded) return undefined;
+    this.#started.set(name, index);
+    this.#finished.set(name, index);
+    return {
+      querySet: this.#querySet,
+      beginningOfPassWriteIndex: index * 2,
+      endOfPassWriteIndex: index * 2 + 1,
+    };
+  }
+
+  skipPass(name: string): void {
+    this.#started.delete(name);
+    this.#finished.delete(name);
+  }
+
+  resolve(encoder: RhiCommandEncoder): Result<void, RhiError> {
+    if (this.#started.size === 0) {
+      this.#resolved = true;
+      return ok(undefined);
+    }
+    const resolved = encoder.resolveQuerySet(
+      this.#querySet,
+      0,
+      QUERY_COUNT,
+      this.#resolveBuffer,
+      0,
+    );
+    if (!resolved.ok) return resolved;
+    encoder.copyBufferToBuffer(this.#resolveBuffer, this.#readbackBuffer, READBACK_BYTES);
+    this.#resolved = true;
+    return ok(undefined);
+  }
+
+  markSubmitted(): void {
+    if (!this.#discarded) this.#submitted = true;
+  }
+
+  discard(): void {
+    if (this.#discarded) return;
+    this.#discarded = true;
+    this.#resolved = true;
+    this.#submitted = false;
+    this.#dispose();
+  }
+
+  observation(): Promise<VolumeTimingObservation> {
+    if (this.#observation !== undefined) return this.#observation;
+    if (this.#discarded || !this.#resolved || !this.#submitted || this.#started.size === 0) {
+      this.#observation = Promise.resolve(
+        unavailable('timestamp capture did not reach an accepted volume submit'),
+      );
+      this.#dispose();
+      return this.#observation;
+    }
+    this.#observation = this.#readbackBuffer
+      .mapAsync(GPU_BUFFER_USAGE_MAP_READ)
+      .then((mapped) => {
+        if (!mapped.ok) return unavailable(`timestamp readback failed: ${mapped.error.code}`);
+        const range = mapped.value.getMappedRange();
+        if (!range.ok) {
+          mapped.value.unmap();
+          return unavailable(`timestamp mapping failed: ${range.error.code}`);
+        }
+        const values = new DataView(range.value);
+        const decoded = [...this.#finished.entries()]
+          .sort((a, b) => a[1] - b[1])
+          .map(([name, index]) => ({
+            name,
+            begin: values.getBigUint64(index * 2 * QUERY_STRIDE_BYTES, true),
+            end: values.getBigUint64((index * 2 + 1) * QUERY_STRIDE_BYTES, true),
+          }));
+        if (decoded.some(({ end, begin }) => end < begin)) {
+          mapped.value.unmap();
+          this.#dispose();
+          return unavailable('timestamp query returned an end before its begin');
+        }
+        const passes = decoded.map(({ name, begin, end }) => ({
+          name,
+          milliseconds: (Number(end - begin) * this.#periodNanoseconds) / 1_000_000,
+        }));
+        const firstBegin = decoded.reduce(
+          (first, sample) => (sample.begin < first ? sample.begin : first),
+          decoded[0]?.begin ?? 0n,
+        );
+        const lastEnd = decoded.reduce(
+          (last, sample) => (sample.end > last ? sample.end : last),
+          decoded[0]?.end ?? 0n,
+        );
+        const totalMs = (Number(lastEnd - firstBegin) * this.#periodNanoseconds) / 1_000_000;
+        mapped.value.unmap();
+        this.#dispose();
+        if (
+          !Number.isFinite(totalMs) ||
+          passes.some((pass) => !Number.isFinite(pass.milliseconds))
+        ) {
+          return unavailable('timestamp query returned a non-finite duration');
+        }
+        return Object.freeze({ status: 'ready', unit: 'ms', totalMs, passes });
+      })
+      .catch((cause: unknown) => {
+        this.#dispose();
+        return unavailable(`timestamp readback failed: ${String(cause)}`);
+      });
+    return this.#observation;
+  }
+
+  #dispose(): void {
+    if (this.#disposed) return;
+    this.#disposed = true;
+    this.#device.destroyBuffer(this.#resolveBuffer);
+    this.#device.destroyBuffer(this.#readbackBuffer);
+    this.#device.destroyQuerySet(this.#querySet);
+  }
+}

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

@@ -17,10 +17,20 @@ import {
   GPU_BUFFER_USAGE_STORAGE,
   GPU_BUFFER_USAGE_UNIFORM,
 } from '../gpu-usage';
+import { createHdrpSkinUnifiedBindGroup, getOrCreateHdrpBuffers } from '../hdrp-buffers';
 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 {
+  createPbrSkinMeshBindGroupEntries,
+  pbrSkinMeshDynamicOffsets,
+  SKIN_MATERIAL_SHADER_ID,
+} from '../pbr-pipeline';
+import {
+  renderStateHash,
+  standardStorageVariantSet,
+  standardTopologyVariantSet,
+  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';
@@ -30,6 +40,7 @@ import {
   geometryRenderStateForTopology,
   isEntityFullyTransparent,
   selectGeometryPipeline,
+  selectMaterialGroup2,
 } from './main-pass-material';
 import {
   getOrCreateFromChain,
@@ -40,7 +51,7 @@ import {
   MESH_UBO_FULL_ARRAY_BYTES,
   packInstanceStorageBuffer,
 } from './mesh-ssbo';
-import type { _InternalRenderPipelineContext } from './render-context';
+import type { _InternalRenderPipelineContext, MaterialShaderPipelineEntry } from './render-context';
 import { MATERIAL_PER_ENTITY_STRIDE } from './render-context';
 import { POINTS_LINES_VIEW_SLOT_STRIDE, writePointsLinesViewUbo } from './view-ubo';
 
@@ -66,7 +77,7 @@ type MaterialPipelineLookup = {
   readonly layoutProjection: import('@forgeax/engine-geometry').VertexLayoutProjection;
   readonly sampleCount: number;
   readonly colorFormatOverride: GPUTextureFormat | undefined;
-  readonly handle: RenderPipeline | null;
+  readonly handle: MaterialShaderPipelineEntry | null;
 };
 
 type GeometryRecordProfileSegment = 'material-bind-groups' | 'pipeline-selection' | 'draw-submit';
@@ -197,8 +208,13 @@ export function recordGeometryDraws(
     validatedOrdered,
     splitLdrSprite,
     viewBindGroup,
+    viewBindGroupDynamicOffset = 0,
   } = c;
   const colorFormatOverride = c.transparentColorFormat as GPUTextureFormat | undefined;
+  // The prepared Standard topology is the frame authority. A bind-group
+  // identity is only a resource result; using it to infer the shader lane
+  // would silently fall back to URP when the clustered resource is missing.
+  const clusteredLighting = c.standardLighting?.kind === 'clustered';
   // 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
@@ -222,7 +238,6 @@ export function recordGeometryDraws(
   const profilePhase = c.profilePhase;
   const materialGroup1DynamicOffsets = new Uint32Array(1);
   const meshGroup2DynamicOffsets = [0];
-  const skinGroup2DynamicOffsets = [0, 0];
   let lastStencilReference: number | null = null;
   // feat-20260625-refactor-sprite-as-transparent-mesh M3 / w14 (D-7):
   // sprite PSO selection no longer maintains a dedicated tag — the
@@ -246,7 +261,7 @@ export function recordGeometryDraws(
     variantSet: string | undefined,
     colorFormat: GPUTextureFormat | undefined,
     layoutProjection: import('@forgeax/engine-geometry').VertexLayoutProjection,
-  ): RenderPipeline | null => {
+  ): MaterialShaderPipelineEntry | null => {
     const renderStateKey = renderStateHash(renderState);
     const shaderLookupCache = materialPipelineLookupCache.get(materialShaderId);
     const cachedLookups = shaderLookupCache?.get(renderStateKey);
@@ -278,7 +293,7 @@ export function recordGeometryDraws(
     }
     const resolvedVariantSet = resolvedVariantSetResult.value;
     const resolvePipeline = () =>
-      runtime.getMaterialShaderPipeline?.(
+      runtime.getMaterialShaderPipelineEntry?.(
         materialShaderId,
         isHdrTarget,
         renderState,
@@ -340,7 +355,7 @@ export function recordGeometryDraws(
     // 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);
+    const pointsLinesSubmission = c.pointsLines?.prepare(entry, clusteredLighting);
     if (entry.source.pointsLines !== undefined && pointsLinesSubmission?.plan.drawCount !== 1)
       continue;
 
@@ -399,7 +414,7 @@ export function recordGeometryDraws(
         entry.source.entityKey,
         entry.world ?? c.world,
       );
-      const pointsLinesPipeline = resolveMaterialPipeline(
+      const pointsLinesPipelineEntry = resolveMaterialPipeline(
         POINTS_LINES_MATERIAL_SHADER_ID,
         {
           ...pointsLinesMaterial.renderState,
@@ -411,7 +426,8 @@ export function recordGeometryDraws(
         colorFormatOverride,
         pointsLinesSubmission.layoutProjection,
       );
-      if (pointsLinesPipeline === null) continue;
+      if (pointsLinesPipelineEntry === null) continue;
+      const pointsLinesPipeline = pointsLinesPipelineEntry.pipeline;
       if (pipelineState.pointsLinesViewBuffer === undefined) continue;
       writePointsLinesViewUbo(
         runtime.device.queue,
@@ -426,9 +442,9 @@ export function recordGeometryDraws(
       pass.setBindGroup(
         0,
         viewBindGroup as BindGroup,
-        new Uint32Array([i * POINTS_LINES_VIEW_SLOT_STRIDE]),
+        new Uint32Array([0, i * POINTS_LINES_VIEW_SLOT_STRIDE]),
         0,
-        1,
+        2,
       );
       pass.setPipeline(pointsLinesPipeline);
       pass.setVertexBuffer(0, pointsLinesSubmission.vertexBuffer);
@@ -444,7 +460,7 @@ export function recordGeometryDraws(
           resolveGeometryInstancesBindGroup(c, identityInstanceBuffer),
       );
       recordPointsLinesDraw(pass, pointsLinesSubmission.plan);
-      pass.setBindGroup(0, viewBindGroup as BindGroup, [0]);
+      pass.setBindGroup(0, viewBindGroup as BindGroup, [viewBindGroupDynamicOffset, 0]);
       continue;
     }
 
@@ -474,11 +490,12 @@ export function recordGeometryDraws(
     const instanceDraws = resolveGeometryInstanceBuffer(c, entry, identityInstanceDraws);
     if (instanceDraws === null) continue;
 
-    // feat-20260611 R2 / M8 / w28 (IS-14): skin entries need a 2-binding
+    // feat-20260611 R2 / M8 / w28 (IS-14): skin entries need a 3-binding
     // group(2) BG matching `pbr-skin-pl` (binding 0 mesh-array UBO +
-    // binding 1 palette UBO). Building this here -- not in the
+    // binding 1 current palette UBO + binding 2 previous palette UBO).
+    // Building this here -- not in the
     // `meshBindGroup` factory above -- because the binding-shape
-    // (1-entry vs 2-entry) is per-entry, not per-frame. URP / HDRP
+    // (1-entry vs 3-entry) is per-entry, not per-frame. URP / HDRP
     // entries keep using `meshGroup2` (1-entry mesh-array or HDRP
     // unified). The skin-variant cache key includes both buffer
     // identities so a future allocator-driven palette buffer rotation
@@ -489,7 +506,7 @@ export function recordGeometryDraws(
     // BGL-build failure), AND (b) the skin PSO cache returns a non-null
     // pipeline for this entry. Without (b), the per-submesh selector
     // below falls back to URP `standardPipeline` (`pbr-pl` layout,
-    // 1-entry mesh-array BGL); binding the 2-entry skin BG against
+    // 1-entry mesh-array BGL); binding the 3-entry skin BG against
     // that pipeline reproduces the exact `pbr-mesh-array-bgl ... does
     // not match layout pbr-skin-mesh-array-bgl` device error R1
     // captured. Mirrors the uniform null skip-draw pattern (M6-T1).
@@ -517,28 +534,40 @@ export function recordGeometryDraws(
     // and walks 0, 1536, 3072, ... on the storage path.
     const skinAllocator = pipelineState.skinPaletteAllocator;
     const skinSlice = entry.source.skin;
+    const clusteredSkin = clusteredLighting;
+    const skinMeshBindGroupLayout = clusteredSkin
+      ? pipelineState.hdrpSkinMeshBindGroupLayout
+      : pipelineState.pbrSkinMeshBindGroupLayout;
+    const hdrpSkinBuffers =
+      isSkinEntry && clusteredSkin
+        ? getOrCreateHdrpBuffers(runtime, frameState.installedPipelineConfig?.clusterGrid)
+        : null;
     const skinResources =
       isSkinEntry &&
-      pipelineState.pbrSkinMeshBindGroupLayout !== null &&
+      skinMeshBindGroupLayout !== null &&
       skinAllocator !== null &&
-      skinSlice !== undefined
+      skinSlice !== undefined &&
+      (!clusteredSkin || hdrpSkinBuffers !== null)
         ? {
-            meshArrayBgl: pipelineState.pbrSkinMeshBindGroupLayout,
+            meshArrayBgl: skinMeshBindGroupLayout,
             paletteBuffer: skinSlice.buffer,
             paletteBindingWindowBytes: skinAllocator.bindingWindowBytes,
+            hdrpBuffers: hdrpSkinBuffers,
           }
         : null;
     // Probe the skin PSO cache up front so we can decide whether to swap
-    // to the 2-binding skin BG. The same probe + selector is repeated in
+    // to the skin BG. The same probe + selector is repeated in
     // the per-submesh loop below (the loop's variantSet derivation is
     // identical -- skin shader registers a single all-true variant so
     // the canonical empty-key rule applies on HDRP and the URP key is
     // the explicit expanded form, mirroring the standard PBR path).
     const skinVariantSetResult = variantSetFromVertexLayoutProjection(
       entry.mesh.layoutProjection,
-      frameState.isHdrpActive
-        ? ''
-        : 'CLUSTER_FORWARD_AVAILABLE=false+STORAGE_BUFFER_AVAILABLE=true',
+      standardTopologyVariantSet(
+        c.standardLighting,
+        runtime.device.caps.storageBuffer,
+        entry.mesh.layoutProjection.attributes.some((attribute) => attribute.key === 'color'),
+      ),
     );
     if (!skinVariantSetResult.ok) runtime.errorRegistry.fire(skinVariantSetResult.error);
     const skinVariantSet = skinVariantSetResult.ok ? skinVariantSetResult.value : undefined;
@@ -579,45 +608,47 @@ export function recordGeometryDraws(
       const skinMissesBefore = bindGroupCounts.createBindGroup;
       const skinBindGroup: BindGroup = getOrCreateFromChain(
         frameState.meshBindGroupCache,
-        [pipelineState.meshStorageBuffer.buffer, skinResources.paletteBuffer],
+        [
+          pipelineState.meshStorageBuffer.buffer,
+          skinResources.paletteBuffer,
+          ...(skinResources.hdrpBuffers === null
+            ? []
+            : [
+                skinResources.hdrpBuffers.lightDataBuffer,
+                skinResources.hdrpBuffers.clusterGridBuffer,
+                skinResources.hdrpBuffers.lightIndexListBuffer,
+                skinResources.hdrpBuffers.clusterUniformBuffer,
+              ]),
+        ],
         'pbr-skin-mesh',
         () => {
+          if (skinResources.hdrpBuffers !== null) {
+            const result = createHdrpSkinUnifiedBindGroup(
+              runtime,
+              skinResources.hdrpBuffers,
+              skinResources.meshArrayBgl,
+              pipelineState.meshStorageBuffer.buffer,
+              skinResources.paletteBuffer,
+              skinResources.paletteBindingWindowBytes,
+            );
+            if (result === null) {
+              throw new RhiError({
+                code: 'webgpu-runtime-error',
+                expected: 'HDRP clustered skin BindGroup creation succeeds',
+                hint: 'inspect prior errorRegistry events for createBindGroup failure detail',
+              });
+            }
+            return result;
+          }
           const result = runtime.device.createBindGroup({
             label: 'pbr-skin-mesh-bg',
             layout: skinResources.meshArrayBgl,
-            entries: [
-              {
-                binding: 0,
-                resource: {
-                  kind: 'buffer',
-                  value: {
-                    buffer: pipelineState.meshStorageBuffer.buffer,
-                    offset: 0,
-                    size: meshBindSize,
-                  },
-                },
-              },
-              {
-                binding: 1,
-                resource: {
-                  kind: 'buffer',
-                  value: {
-                    buffer: skinResources.paletteBuffer,
-                    offset: 0,
-                    // M6 SSOT: static BG entry size (= MAX_JOINTS * 64 =
-                    // 16320 B) sourced from the allocator. The per-draw
-                    // window slides via `group2DynamicOffsets[1]`
-                    // (= entry.source.skin.byteOffset) so this size
-                    // stays at the worst case across all skin entries
-                    // -- one BG covers every skinned draw in the frame
-                    // (m3-1b miss=1 + hit=N-1 contract). The allocator
-                    // guarantees `buffer.size >= byteOffset + this size`
-                    // so dynOffset[1] passes WebGPU validation.
-                    size: skinResources.paletteBindingWindowBytes,
-                  },
-                },
-              },
-            ],
+            entries: createPbrSkinMeshBindGroupEntries(
+              pipelineState.meshStorageBuffer.buffer,
+              meshBindSize,
+              skinResources.paletteBuffer,
+              skinResources.paletteBindingWindowBytes,
+            ),
           });
           if (!result.ok) throw result.error;
           return result.value;
@@ -634,9 +665,10 @@ export function recordGeometryDraws(
       // Replaces the prior PR #353 hard-coded `0` second slot -- every
       // skin entry now points the palette window at its own slice while
       // sharing the worst-case BG entry size above.
-      skinGroup2DynamicOffsets[0] = i * MESH_PER_ENTITY_STRIDE;
-      skinGroup2DynamicOffsets[1] = entry.source.skin?.byteOffset ?? 0;
-      group2DynamicOffsets = skinGroup2DynamicOffsets;
+      group2DynamicOffsets = pbrSkinMeshDynamicOffsets(
+        i * MESH_PER_ENTITY_STRIDE,
+        entry.source.skin?.byteOffset ?? 0,
+      );
     } else if (isSkinEntry) {
       // Skin entry but skin PSO not ready (cache miss / async build pending,
       // or skin pipeline layout failed at boot). Skip the draw rather than
@@ -778,6 +810,8 @@ export function recordGeometryDraws(
         : geometryRenderStateForTopology(smTopology, submeshMaterial.renderState);
       const pipelineRenderState = geometryRenderStateForPass(basePipelineRenderState, passKind);
       let smPipelineHandle: typeof pipelineState.unlitPipeline;
+      let materialGroup2Contract: 'mesh' | 'skin' | 'cluster' | 'skin-cluster' | undefined;
+      let materialPipelineEntry: MaterialShaderPipelineEntry | null = null;
       if (smMaterialShaderId === undefined || smMaterialShaderId === 'forgeax::default-unlit') {
         const unlitShaderId = smMaterialShaderId ?? 'forgeax::default-unlit';
         const unlitProjectionVariantResult = variantSetFromVertexLayoutProjection(
@@ -789,9 +823,10 @@ export function recordGeometryDraws(
           continue;
         }
         const unlitHasColor = unlitProjectionVariantResult.value === 'VERTEX_COLOR_AVAILABLE=true';
-        const unlitVariantSet = unlitHasColor
-          ? ''
-          : 'STORAGE_BUFFER_AVAILABLE=true+VERTEX_COLOR_AVAILABLE=false';
+        const unlitVariantSet = standardStorageVariantSet(
+          runtime.device.caps.storageBuffer,
+          unlitHasColor,
+        );
         const unlitRsp = resolveMaterialPipeline(
           unlitShaderId,
           pipelineRenderState,
@@ -801,8 +836,9 @@ export function recordGeometryDraws(
           colorFormatOverride,
           entry.mesh.layoutProjection,
         );
+        materialPipelineEntry = unlitRsp;
         smPipelineHandle =
-          unlitRsp ??
+          unlitRsp?.pipeline ??
           (colorFormatOverride === undefined
             ? selectGeometryPipeline(pipelineState, isHdrTarget, msaaActive)
             : null);
@@ -829,11 +865,11 @@ export function recordGeometryDraws(
         // VERTEX_COLOR_AVAILABLE=false axis, so retain the two capability
         // axes explicitly or the selector would silently choose the URP
         // group(2) layout for an HDRP cluster bind group.
-        const capabilityVariantSet = frameState.isHdrpActive
-          ? hasVertexColor
-            ? ''
-            : 'CLUSTER_FORWARD_AVAILABLE=true+STORAGE_BUFFER_AVAILABLE=true'
-          : 'CLUSTER_FORWARD_AVAILABLE=false+STORAGE_BUFFER_AVAILABLE=true';
+        const capabilityVariantSet = standardTopologyVariantSet(
+          c.standardLighting,
+          runtime.device.caps.storageBuffer,
+          hasVertexColor,
+        );
         // 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
@@ -877,7 +913,8 @@ export function recordGeometryDraws(
         // build resolves. The pre-loop skin-PSO probe still skips the
         // entire entry on first-submesh probe miss; this site only
         // fires on per-submesh topology variance miss.
-        smPipelineHandle = cachedPipeline ?? null;
+        materialPipelineEntry = cachedPipeline;
+        smPipelineHandle = cachedPipeline?.pipeline ?? null;
       } else {
         smPipelineHandle = selectGeometryPipeline(pipelineState, isHdrTarget, msaaActive);
       }
@@ -890,16 +927,16 @@ export function recordGeometryDraws(
       // ordinary mesh group instead; choosing one group for the whole pass
       // makes Dawn reject an otherwise valid unlit pipeline and invalidates
       // the command buffer before it reaches the surface.
-      const usesStandardClusterBindings = smMaterialShaderId === 'forgeax::default-standard-pbr';
       if (!isSkinEntry) {
-        if (usesStandardClusterBindings) {
-          if (meshGroup2 === null) continue;
-          group2BindGroup = meshGroup2;
-        } else {
-          const fallbackGroup = meshBindGroup ?? meshGroup2;
-          if (fallbackGroup === null) continue;
-          group2BindGroup = fallbackGroup;
-        }
+        materialGroup2Contract = materialPipelineEntry?.group2Contract;
+        if (materialGroup2Contract === undefined) continue;
+        const selectedGroup = selectMaterialGroup2(
+          meshGroup2,
+          meshBindGroup,
+          materialGroup2Contract,
+        );
+        if (selectedGroup === null) continue;
+        group2BindGroup = selectedGroup;
       }
       pass.setBindGroup(2, group2BindGroup, group2DynamicOffsets);
 
@@ -945,6 +982,9 @@ function resolveGeometryInstanceBuffer(
   const { runtime, pipelineState, frameState } = c;
   const inst = entry.source.instances;
   if (inst === undefined) return identityInstanceDraws;
+  // A present, empty Instances array means zero draws. Do not fall back to
+  // the shared identity buffer, which would silently render one instance.
+  if (inst.instanceCount === 0) return [];
   let instanceBuffer: Buffer = pipelineState.identityInstanceBuffer;
   let instanceCount = 1;
   {