@forgeax/engine-render 0.1.4 → 0.1.7

package/src/record/helpers.ts

@@ -1,21 +1,17 @@
 // @forgeax/engine-runtime - RenderSystem record stage: helpers.
 // Extracted from render-system-record.ts (feat-20260704 M3/w17, pure move).
 
+import { resolveAssetHandle } from '@forgeax/engine-assets-runtime';
 import type { World } from '@forgeax/engine-ecs';
 import { type Mat4, mat4 } from '@forgeax/engine-math';
 import type { EquirectAsset } from '@forgeax/engine-types';
 import { toShared } from '@forgeax/engine-types';
-import { resolveRenderAsset } from '../assets/resolve-render-asset';
 import { EquirectProjectionFailedError } from '../errors/render';
 import { isStandardPbrMaterialShader } from '../pbr-pipeline';
-import type { RenderSystemInternals } from '../render-system';
-import type {
-  CameraSnapshot,
-  MaterialSnapshot,
-  SkyboxSnapshot,
-  SkylightSnapshot,
-} from '../render-system-extract';
+import type { CameraSnapshot } from '../render-contract';
+import type { MaterialSnapshot, SkyboxSnapshot, SkylightSnapshot } from '../render-system-extract';
 import type { RenderFrameState } from './frame-snapshot';
+import type { RenderSystemInternals } from './render-context';
 
 /** Convert pass-owned shader definitions into the manifest's canonical variant key. */
 export function variantSetFromDefines(
@@ -225,7 +221,7 @@ export function driveLazyEquirectProjection(
   if (status !== undefined) return;
 
   // First sight: resolve the equirect POD and fire-and-forget the projection.
-  const podRes = resolveRenderAsset<EquirectAsset>(world, handle);
+  const podRes = resolveAssetHandle<EquirectAsset>(world, handle);
   if (!podRes.ok || podRes.value.kind !== 'equirect') {
     // The handle does not resolve to a live equirect POD (stale / wrong kind).
     // Launch nothing; the store stays empty and the white fallback holds. The
@@ -261,8 +257,7 @@ export function computeViewMatrix(camera: CameraSnapshot): Mat4 {
   // world mat4 (propagateTransforms output) is read straight off the snapshot;
   // no recompose from decomposed TRS.
   const cameraFromWorld = mat4.create();
-  // brand-cast-ok: camera.world is an existing snapshot view read as Mat4 input.
-  mat4.invert(cameraFromWorld, camera.world as unknown as Mat4);
+  mat4.invert(cameraFromWorld, camera.world);
   return cameraFromWorld;
 }
 

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

@@ -2,6 +2,7 @@
 // feat-20260704 M5/w31: further-split from main-pass.ts (AC-05 <=1500 lines/file).
 // recordGeometryDraws + resolveGeometryInstanceBuffer, moved verbatim.
 
+import type { World } from '@forgeax/engine-ecs';
 import {
   type BindGroup,
   type Buffer,
@@ -16,22 +17,20 @@ import {
   GPU_BUFFER_USAGE_STORAGE,
   GPU_BUFFER_USAGE_UNIFORM,
 } from '../gpu-usage';
-import {
-  type InstanceBufferCacheEntry,
-  packTemporalInstanceTransforms,
-} from '../instance-buffer-cache';
+import type { InstanceBufferCacheEntry } from '../instance-buffer-cache';
 import { SPRITE_PREMULTIPLIED_ALPHA_BLEND } from '../materials';
 import { SKIN_MATERIAL_SHADER_ID } from '../pbr-pipeline';
-import { variantSetFromVertexLayoutProjection } from '../pipeline';
-import { renderStateHash } from '../pipeline-spec';
-import type { _InternalRenderPipelineContext } from '../render-pipeline-context';
-import { MATERIAL_PER_ENTITY_STRIDE } from '../render-system';
+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 type { RenderRecordPhase } from '../renderer';
-import { routeMaterialReadiness } from '../renderer/material/pipeline-projection';
-import { rasterItemKey, worldEntityKey } from './frame-snapshot';
-import { isEntityFullyTransparent, selectGeometryPipeline } from './main-pass-material';
-import { interleaveSpriteInstanceBuffer } from './main-pass-sprite';
+import { worldEntityKey } from './frame-snapshot';
+import {
+  geometryRenderStateForTopology,
+  isEntityFullyTransparent,
+  selectGeometryPipeline,
+} from './main-pass-material';
 import {
   getOrCreateFromChain,
   INSTANCE_UBO_FULL_ARRAY_BYTES,
@@ -39,7 +38,11 @@ import {
   MESH_PER_ENTITY_STRIDE,
   MESH_SSBO_BYTES,
   MESH_UBO_FULL_ARRAY_BYTES,
+  packInstanceStorageBuffer,
 } 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;
@@ -72,8 +75,7 @@ function geometryRecordPhase(
   passKind: PassKind,
   segment: GeometryRecordProfileSegment,
 ): RenderRecordPhase {
-  const pass =
-    passKind === 'deferred' ? 'g-buffer' : passKind === 'temporal' ? 'scene-temporal' : 'forward';
+  const pass = passKind === 'deferred' ? 'g-buffer' : 'forward';
   return `record/graph-execute/${pass}/${segment}` as RenderRecordPhase;
 }
 
@@ -116,6 +118,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
@@ -125,22 +144,24 @@ function submitSubmeshDraws(
  * transparent entities are skipped here (drawn in the LDR blend sub-pass);
  * mixed meshes draw their opaque submeshes here and skip transparent submeshes.
  * The pass-selector match set, per-entity material-slot start table, MSAA sample
- * count, group(2) bind group, and the shared per-submesh material BG builder are
- * threaded in explicitly.
+ * count, Standard group(2) bind group, fallback mesh group(2) bind group, and
+ * the shared per-submesh material BG builder are threaded in explicitly.
  *
  * @internal
  */
 export function recordGeometryDraws(
   c: _InternalRenderPipelineContext,
   pass: RhiRenderPassEncoder,
-  matchedIndices: Set<number> | null,
+  matchedMaterials: ReadonlyMap<number, ReadonlySet<number>> | null,
   materialSlotIndices: readonly (readonly number[])[],
   sampleCount: number,
   meshGroup2: BindGroup | null,
+  meshBindGroup: BindGroup | null,
   resolveMaterialBindGroup: (
     materialSlot: number,
     submeshMaterial: MaterialSnapshot,
     entityKey: number,
+    materialWorld: World,
   ) => BindGroup,
   passKind: PassKind = 'forward',
 ): void {
@@ -154,6 +175,7 @@ export function recordGeometryDraws(
     msaaActive,
     validatedOrdered,
     splitLdrSprite,
+    viewBindGroup,
   } = c;
   const colorFormatOverride = c.transparentColorFormat as GPUTextureFormat | undefined;
   let lastVertexBuffer: GpuBuffer | null = null;
@@ -173,7 +195,7 @@ export function recordGeometryDraws(
   const profilePhase = c.profilePhase;
   const materialGroup1DynamicOffsets = new Uint32Array(1);
   const meshGroup2DynamicOffsets = [0];
-  const skinGroup2DynamicOffsets = [0, 0, 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
@@ -197,7 +219,6 @@ export function recordGeometryDraws(
     variantSet: string | undefined,
     colorFormat: GPUTextureFormat | undefined,
     layoutProjection: import('@forgeax/engine-geometry').VertexLayoutProjection,
-    materialGuid?: string,
   ): RenderPipeline | null => {
     const renderStateKey = renderStateHash(renderState);
     const shaderLookupCache = materialPipelineLookupCache.get(materialShaderId);
@@ -243,8 +264,6 @@ export function recordGeometryDraws(
         undefined,
         undefined,
         undefined,
-        materialGuid,
-        undefined,
         layoutProjection,
       ) ?? null;
     const handle =
@@ -257,7 +276,7 @@ export function recordGeometryDraws(
       renderStateKey,
       topology,
       indexFormat,
-      variantSet: resolvedVariantSet,
+      variantSet,
       passKind,
       layoutProjection,
       sampleCount,
@@ -278,8 +297,22 @@ 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))
+    ) {
+      continue;
+    }
+
     // feat-20260609 M2: skip entities that don't match the pass selector.
-    if (matchedIndices !== null && !matchedIndices.has(entry.renderableIndex)) continue;
+    if (matchedMaterials !== null && !matchedMaterials.has(entry.renderableIndex)) continue;
 
     // D-2 generalised feat-20260625 M2 / w7: transparent entities are
     // dispatched in the separate sub-pass (bgra8unorm unorm view,
@@ -297,8 +330,7 @@ export function recordGeometryDraws(
     // decal submesh) is NOT skipped at the entity level; its opaque submeshes
     // draw here and the per-submesh loop below skips the transparent ones
     // (they are drawn in the blend sub-pass instead).
-    if (passKind === 'forward' && splitLdrSprite && isEntityFullyTransparent(entry.source))
-      continue;
+    if (splitLdrSprite && isEntityFullyTransparent(entry.source)) continue;
 
     const pipelineTag: 'unlit' = 'unlit';
 
@@ -312,6 +344,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;
@@ -338,11 +434,11 @@ export function recordGeometryDraws(
     const instanceDraws = resolveGeometryInstanceBuffer(c, entry, identityInstanceDraws);
     if (instanceDraws === null) continue;
 
-    // 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 plus
-    // bindings 1/2 current/previous palette UBOs). Building this here -- not in the
+    // feat-20260611 R2 / M8 / w28 (IS-14): skin entries need a 2-binding
+    // group(2) BG matching `pbr-skin-pl` (binding 0 mesh-array UBO +
+    // binding 1 palette UBO). Building this here -- not in the
     // `meshBindGroup` factory above -- because the binding-shape
-    // (1-entry vs 3-entry) is per-entry, not per-frame. URP / HDRP
+    // (1-entry vs 2-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
@@ -359,7 +455,7 @@ export function recordGeometryDraws(
     // captured. Mirrors the uniform null skip-draw pattern (M6-T1).
     let group2BindGroup: BindGroup = meshGroup2 as BindGroup;
     // feat-20260612-skin-palette-per-frame-upload M3 / m3-2: dyn-offset
-    // tuple sourced from `_computeSkinGroup2DynOffsets`.  Defaults to the
+    // tuple follows the skin group2 offset contract. Defaults to the
     // length-1 non-skin shape; the skin branch below re-computes with the
     // per-entity `entry.source.skin.byteOffset` cursor.
     meshGroup2DynamicOffsets[0] = i * MESH_PER_ENTITY_STRIDE;
@@ -389,12 +485,11 @@ export function recordGeometryDraws(
         ? {
             meshArrayBgl: pipelineState.pbrSkinMeshBindGroupLayout,
             paletteBuffer: skinSlice.buffer,
-            previousPaletteBuffer: skinSlice.previousBuffer ?? skinSlice.buffer,
             paletteBindingWindowBytes: skinAllocator.bindingWindowBytes,
           }
         : null;
     // Probe the skin PSO cache up front so we can decide whether to swap
-    // to the 3-binding skin BG. The same probe + selector is repeated in
+    // to the 2-binding 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
@@ -423,8 +518,6 @@ export function recordGeometryDraws(
             undefined,
             undefined,
             undefined,
-            undefined,
-            undefined,
             entry.mesh.layoutProjection,
           ) ?? null)
         : null;
@@ -446,11 +539,7 @@ export function recordGeometryDraws(
       const skinMissesBefore = bindGroupCounts.createBindGroup;
       const skinBindGroup: BindGroup = getOrCreateFromChain(
         frameState.meshBindGroupCache,
-        [
-          pipelineState.meshStorageBuffer.buffer,
-          skinResources.paletteBuffer,
-          skinResources.previousPaletteBuffer,
-        ],
+        [pipelineState.meshStorageBuffer.buffer, skinResources.paletteBuffer],
         'pbr-skin-mesh',
         () => {
           const result = runtime.device.createBindGroup({
@@ -488,17 +577,6 @@ export function recordGeometryDraws(
                   },
                 },
               },
-              {
-                binding: 2,
-                resource: {
-                  kind: 'buffer',
-                  value: {
-                    buffer: skinResources.previousPaletteBuffer,
-                    offset: 0,
-                    size: skinResources.paletteBindingWindowBytes,
-                  },
-                },
-              },
             ],
           });
           if (!result.ok) throw result.error;
@@ -511,14 +589,13 @@ export function recordGeometryDraws(
         else skinStats.hit += 1;
       }
       group2BindGroup = skinBindGroup;
-      // m3-2: dyn-offset tuple via `_computeSkinGroup2DynOffsets` with the
-      // per-entity palette cursor M2 m2-6 wrote at the extract stage.
+      // m3-2: dyn-offset tuple uses the per-entity palette cursor M2 m2-6
+      // wrote at the extract stage.
       // 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;
-      skinGroup2DynamicOffsets[2] = entry.source.skin?.byteOffset ?? 0;
       group2DynamicOffsets = skinGroup2DynamicOffsets;
     } else if (isSkinEntry) {
       // Skin entry but skin PSO not ready (cache miss / async build pending,
@@ -530,8 +607,6 @@ export function recordGeometryDraws(
       // null skip-draw shape (M6-T1, charter P3 explicit failure).
       continue;
     }
-    pass.setBindGroup(2, group2BindGroup, group2DynamicOffsets);
-
     // feat-20260520-2d-sprite-layer-mvp M-3 / w25 (@fallback sprite
     // bucket): sprite entries get a per-entity material BindGroup so
     // each sprite carries its own texture binding at @group(1) @binding(2).
@@ -582,31 +657,19 @@ export function recordGeometryDraws(
     for (let smIdx = 0; smIdx < entry.mesh.submeshes.length; smIdx++) {
       const sm = entry.mesh.submeshes[smIdx];
       if (sm === undefined) continue;
-      const gpuDrivenDraw = entry.source.gpuDrivenDraws?.find(
-        (draw) => draw.submeshIndex === smIdx,
-      );
-      if (
-        passKind === 'forward' &&
-        gpuDrivenDraw !== undefined &&
-        c.gpuDrivenItemKeys.has(
-          rasterItemKey(
-            entry.source.worldId,
-            entry.source.entityKey,
-            gpuDrivenDraw.submeshIndex,
-            gpuDrivenDraw.passIndex,
-          ),
-        )
-      ) {
-        continue;
-      }
       const matSlotIdx = sm.materialSlot;
       const submeshMaterial = matsForRebind[matSlotIdx] ?? entry.source.material;
+      if (matchedMaterials !== null) {
+        const materialHandles = matchedMaterials.get(entry.renderableIndex);
+        const materialHandle = submeshMaterial.materialHandle ?? 0;
+        if (materialHandles === undefined || !materialHandles.has(materialHandle)) continue;
+      }
       // feat-city-glb Bug 5 (per-submesh transparency): in the LDR split, a
       // transparent submesh is drawn in the blend sub-pass (non-sRGB view),
       // NOT here in the sRGB geometry pass. Skip it. Opaque submeshes of the
       // same (mixed) mesh still draw here. Single-material / fully-opaque
       // meshes are unaffected (their submesh materials are not transparent).
-      if (passKind === 'forward' && splitLdrSprite && submeshMaterial.transparent === true) {
+      if (splitLdrSprite && submeshMaterial.transparent === true) {
         continue;
       }
       // bug-20260610 layer 7d: per-submesh BG construction. Texture
@@ -632,15 +695,25 @@ export function recordGeometryDraws(
       // feat-city-glb Bug 5: per-submesh material BG assembly extracted to
       // the shared `buildPerSubmeshMaterialBg` closure (also called by the
       // LDR blend sub-pass). Resolves the shader's user-region textures
-      // (baseColor/MR/normal + any custom Nth texture), emissive/occlusion
+      // (baseColor/MR/normal + a custom Nth texture), emissive/occlusion
       // injection, and Skylight merge; deduped cross-entity via the
       // shaderId-outer `materialBgShared` cache.
       const materialSlot = materialSlotIndices[i]?.[matSlotIdx] ?? materialSlotIndices[i]?.[0] ?? 0;
       perSubmeshBg =
         profilePhase === undefined
-          ? resolveMaterialBindGroup(materialSlot, submeshMaterial, entry.source.entityKey)
+          ? resolveMaterialBindGroup(
+              materialSlot,
+              submeshMaterial,
+              entry.source.entityKey,
+              entry.world ?? c.world,
+            )
           : profileGeometrySegment(c, passKind, 'material-bind-groups', () =>
-              resolveMaterialBindGroup(materialSlot, submeshMaterial, entry.source.entityKey),
+              resolveMaterialBindGroup(
+                materialSlot,
+                submeshMaterial,
+                entry.source.entityKey,
+                entry.world ?? c.world,
+              ),
             );
       materialGroup1DynamicOffsets[0] = materialSlot * MATERIAL_PER_ENTITY_STRIDE;
       pass.setBindGroup(1, perSubmeshBg, materialGroup1DynamicOffsets, 0, 1);
@@ -649,58 +722,20 @@ export function recordGeometryDraws(
         entry.source.skin !== undefined
           ? SKIN_MATERIAL_SHADER_ID
           : submeshMaterial.materialShaderId;
-      let materialReadyGuid: string | undefined;
-      if (
-        submeshMaterial.materialGuid !== undefined &&
-        runtime.getMaterialReadiness !== undefined
-      ) {
-        const readiness = runtime.getMaterialReadiness(submeshMaterial.materialGuid);
-        if (readiness !== undefined) {
-          const readinessRoute = routeMaterialReadiness({
-            readiness,
-            reportedDiagnosticKeys: frameState.reportedMaterialDiagnosticKeys,
-          });
-          if (readinessRoute.kind === 'skip') {
-            if (readinessRoute.diagnostic !== undefined) {
-              runtime.errorRegistry.fire(
-                new RhiError({
-                  code: 'webgpu-runtime-error',
-                  expected: readinessRoute.diagnostic.expected,
-                  hint: `${readinessRoute.diagnostic.hint} [materialGuid=${readinessRoute.diagnostic.materialGuid}; specializationKey=${readinessRoute.diagnostic.specializationKey}]`,
-                }),
-              );
-            }
-            continue;
-          }
-          materialReadyGuid = readinessRoute.readiness.materialGuid;
-        }
-      }
       const isSpriteShader =
         smMaterialShaderId === 'forgeax::sprite' || smMaterialShaderId === 'forgeax::sprite-lit';
       // 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 temporalRenderState = (() => {
-        if (passKind !== 'temporal') return undefined;
-        const { blend: _blend, ...base } = submeshMaterial.renderState ?? {};
-        return {
-          ...base,
-          depthWriteEnabled: false,
-          depthCompare: 'less-equal' as const,
-          ...(isSpriteShader ? { cullMode: 'none' as const } : {}),
-        };
-      })();
-      const pipelineRenderState =
-        temporalRenderState ??
-        (isSpriteShader
-          ? {
-              ...submeshMaterial.renderState,
-              depthWriteEnabled: false,
-              depthCompare: 'less-equal' as const,
-              cullMode: 'none' as const,
-              blend: submeshMaterial.renderState?.blend ?? SPRITE_PREMULTIPLIED_ALPHA_BLEND,
-            }
-          : submeshMaterial.renderState);
+      const pipelineRenderState = isSpriteShader
+        ? {
+            ...submeshMaterial.renderState,
+            depthWriteEnabled: false,
+            depthCompare: 'less-equal' as const,
+            cullMode: 'none' as const,
+            blend: submeshMaterial.renderState?.blend ?? SPRITE_PREMULTIPLIED_ALPHA_BLEND,
+          }
+        : geometryRenderStateForTopology(smTopology, submeshMaterial.renderState);
       let smPipelineHandle: typeof pipelineState.unlitPipeline;
       if (smMaterialShaderId === undefined || smMaterialShaderId === 'forgeax::default-unlit') {
         const unlitShaderId = smMaterialShaderId ?? 'forgeax::default-unlit';
@@ -724,7 +759,6 @@ export function recordGeometryDraws(
           unlitVariantSet,
           colorFormatOverride,
           entry.mesh.layoutProjection,
-          materialReadyGuid,
         );
         smPipelineHandle =
           unlitRsp ??
@@ -746,8 +780,18 @@ export function recordGeometryDraws(
         // variant's manifest definesKey IS that exact non-empty string
         // (CLUSTER_FORWARD_AVAILABLE=false+STORAGE_BUFFER_AVAILABLE=true)
         // -- the canonical-empty rule only applies to the all-true case.
+        const hasVertexColor = entry.mesh.layoutProjection.attributes.some(
+          (attribute) => attribute.key === 'color',
+        );
+        // The all-true HDRP variant uses the canonical empty key only when
+        // every variant axis is true. A plain mesh adds the geometry-owned
+        // 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 authoredVariantSet =
           isSpriteShader && entry.source.spriteInstances !== undefined ? '' : entry.variantSet;
@@ -765,16 +809,14 @@ export function recordGeometryDraws(
           runtime.errorRegistry.fire(projectionVariantSetResult.error);
           continue;
         }
-        const projectionVariantSet = projectionVariantSetResult.value;
         const cachedPipeline = resolveMaterialPipeline(
           smMaterialShaderId,
           pipelineRenderState,
           smTopology,
           entry.mesh.indexFormat,
-          projectionVariantSet,
+          projectionVariantSetResult.value,
           colorFormatOverride,
           entry.mesh.layoutProjection,
-          materialReadyGuid,
         );
         // feat-20260615-pipeline-spec-ssot M6-T1: cache miss resolves to
         // null uniformly across URP / HDRP / skin shaders. Charter P3
@@ -797,6 +839,23 @@ export function recordGeometryDraws(
       if (smPipelineHandle === null) {
         continue;
       }
+      // Standard clustered PBR variants declare the unified cluster/SSAO
+      // group(2) layout. Unlit and other URP-layout materials must bind the
+      // 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;
+        }
+      }
+      pass.setBindGroup(2, group2BindGroup, group2DynamicOffsets);
 
       if (profilePhase === undefined) {
         submitSubmeshDraws(
@@ -838,9 +897,8 @@ function resolveGeometryInstanceBuffer(
   identityInstanceDraws: readonly GeometryInstanceDraw[],
 ): readonly GeometryInstanceDraw[] | null {
   const { runtime, pipelineState, frameState } = c;
-  const inst = entry.source.instances ?? entry.source.spriteInstances;
+  const inst = entry.source.instances;
   if (inst === undefined) return identityInstanceDraws;
-  const spriteInstances = entry.source.spriteInstances;
   let instanceBuffer: Buffer = pipelineState.identityInstanceBuffer;
   let instanceCount = 1;
   {
@@ -891,21 +949,10 @@ function resolveGeometryInstanceBuffer(
     {
       // Cap-gate (LimitExceededDetail single emit point — feat-20260514
       // M3 / w15 anchor): `requestedBytes <= maxStorageBufferBindingSize`.
-      const upload =
-        spriteInstances === undefined
-          ? uniformFallback
-            ? inst.transforms
-            : packTemporalInstanceTransforms(
-                inst.transforms,
-                entry.source.temporal?.previousInstances?.transforms,
-              )
-          : interleaveSpriteInstanceBuffer(
-              spriteInstances.transforms,
-              spriteInstances.regions,
-              undefined,
-              !uniformFallback,
-            );
-      const requestedBytes = upload.byteLength;
+      const instancePayload = uniformFallback
+        ? inst.transforms
+        : packInstanceStorageBuffer(inst.transforms);
+      const requestedBytes = instancePayload.byteLength;
       const cap = runtime.device.limits.maxStorageBufferBindingSize;
       if (!uniformFallback && typeof cap === 'number' && cap > 0 && requestedBytes > cap) {
         runtime.errorRegistry.fire(
@@ -961,7 +1008,11 @@ function resolveGeometryInstanceBuffer(
           }
         }
         if (active !== null) {
-          const writeRes = runtime.device.queue.writeBuffer(active.buffer.handle, 0, upload);
+          const writeRes = runtime.device.queue.writeBuffer(
+            active.buffer.handle,
+            0,
+            instancePayload,
+          );
           if (!writeRes.ok) {
             runtime.errorRegistry.fire(writeRes.error);
           } else {