@forgeax/engine-render 0.1.34 → 0.1.36

package/src/record/shadow-pass.ts

@@ -1,4 +1,5 @@
 import { probeVideoHighPerfUpload } from '@forgeax/engine-graphics-extras';
+import { box3, frustum } from '@forgeax/engine-math';
 import {
   type BindGroup,
   type BindGroupEntry,
@@ -24,6 +25,7 @@ import {
 import { assembleMaterialWithSkylightEntries } from '../ibl/skylight-bind-group';
 import type { InstanceBufferCacheEntry } from '../instance-buffer-cache';
 import { instanceUploadRangesForResident } from '../instances';
+import { deriveInstancesUnionBounds } from '../instances-derived-bounds';
 import {
   buildPbrMaterialUserRegionEntries,
   createPbrSkinMeshBindGroupEntries,
@@ -643,6 +645,29 @@ function shadowCasterKeys(c: _InternalRenderPipelineContext): ReadonlySet<string
   return c.gpuDrivenShadowDrawKeys ?? new Set<string>();
 }
 
+function shadowViewContains(source: RenderableSnapshot, planes: Float32Array | undefined): boolean {
+  if (planes === undefined || planes.length === 0 || source.localAabb === undefined) return true;
+  // The extracted mesh AABB is bind-pose geometry, not a conservative bound
+  // for the current skin palette. Keep skinned residuals until extraction owns
+  // a deformation-aware bound.
+  if (source.skin !== undefined) return true;
+  if (source.spriteInstances !== undefined) return true;
+  let worldBounds: Float32Array;
+  if (source.instances !== undefined) {
+    if (source.instances.instanceCount === 0) return false;
+    const derived = deriveInstancesUnionBounds({
+      meshAabb: source.localAabb,
+      entityWorld: source.transform.world,
+      transforms: source.instances.transforms,
+    });
+    if (derived === undefined) return true;
+    worldBounds = derived;
+  } else {
+    worldBounds = box3.transformBox3(box3.create(), source.localAabb, source.transform.world);
+  }
+  return frustum.intersectsBox(planes as frustum.Frustum, worldBounds as box3.Box3Like);
+}
+
 function validateShadowOwnership(
   c: _InternalRenderPipelineContext,
   identity: ShadowViewIdentity,
@@ -654,12 +679,39 @@ function validateShadowOwnership(
     (c.gpuDrivenShadowDrawKeys === undefined || c.gpuDrivenShadowDrawKeys.size === 0)
   )
     return;
-  const expectedKeys = shadowCasterKeys(c);
+  const viewPlanes = c.shadowViewPlanesByView?.get(shadowViewIdentityKey(identity));
+  const visibleRenderableIndices =
+    viewPlanes === undefined
+      ? undefined
+      : new Set(
+          (c.shadowValidatedOrdered ?? c.validatedOrdered)
+            .filter((entry) => shadowViewContains(entry.source, viewPlanes))
+            .map((entry) => entry.renderableIndex),
+        );
+  const allExpectedKeys = shadowCasterKeys(c);
+  const visibleExpectedKeys =
+    visibleRenderableIndices === undefined || c.shadowCasterMembership === undefined
+      ? allExpectedKeys
+      : new Set(
+          c.shadowCasterMembership
+            .filter((membership) => visibleRenderableIndices.has(membership.renderableIndex))
+            .map((membership) =>
+              gpuDrivenShadowDrawKey(
+                membership.worldEntity,
+                membership.materialHandle,
+                membership.drawItemIndex,
+                membership.passIndex,
+              ),
+            ),
+        );
   const claimed = claimedKeys ?? new Set<string>();
   const overlap = [...claimed].filter((key) => recordedKeys.has(key));
   const union = new Set([...claimed, ...recordedKeys]);
-  const missing = [...expectedKeys].filter((key) => !union.has(key));
-  const unexpectedClaims = [...claimed].filter((key) => !expectedKeys.has(key));
+  const missing = [...visibleExpectedKeys].filter((key) => !union.has(key));
+  // GPU ownership is projected before its own per-view culling. A claim may
+  // therefore be outside the CPU residual's conservative visible subset and
+  // is still valid as long as it belongs to the extracted caster membership.
+  const unexpectedClaims = [...claimed].filter((key) => !allExpectedKeys.has(key));
   // `shadowCasterMembership` describes the concrete draws that the GPU
   // producer is eligible to claim.  A renderable that stays on the CPU lane
   // (for example a clustered frame without a compatible GPU-driven PBR
@@ -674,7 +726,7 @@ function validateShadowOwnership(
   throw new RhiError({
     code: 'internal-error',
     expected: `disjoint ShadowCaster ownership for ${shadowViewIdentityKey(identity)}`,
-    hint: `claimed=${[...claimed].sort().join(',')} recorded=${[...recordedKeys].sort().join(',')} missing=${missing.sort().join(',')} unexpectedClaims=${unexpectedClaims.sort().join(',')}`,
+    hint: `expected=${[...allExpectedKeys].sort().join(',')} visibleExpected=${[...visibleExpectedKeys].sort().join(',')} claimed=${[...claimed].sort().join(',')} recorded=${[...recordedKeys].sort().join(',')} missing=${missing.sort().join(',')} unexpectedClaims=${unexpectedClaims.sort().join(',')}`,
   });
 }
 
@@ -842,9 +894,11 @@ export function encodeDirectionalShadowPass(
   cascadeIndex: number,
   viewport: { readonly x: number; readonly y: number; readonly w: number; readonly h: number },
   drawFeatures?: (view: BindGroup) => void,
+  forceRaster = false,
 ): void {
   const directionalIdentity = { kind: 'directional' as const, index: cascadeIndex };
   if (
+    !forceRaster &&
     (c.gpuDrivenShadowViews?.cacheHit(directionalIdentity) === true ||
       (c.gpuDrivenShadowViews === undefined && c.directionalShadowCacheReuse)) &&
     drawFeatures === undefined
@@ -941,6 +995,8 @@ export function encodeDirectionalShadowPass(
     }),
     shadowShaderMap(c),
     claimedKeys,
+    false,
+    c.shadowViewPlanesByView?.get(shadowViewIdentityKey(directionalIdentity)),
   );
   validateShadowOwnership(c, directionalIdentity, claimedKeys, recordedKeys);
   c.frameState.directionalShadowCacheRecorded =
@@ -1047,6 +1103,7 @@ export function encodePointShadowPass(
     shadowShaderMap(c),
     claimedKeys,
     true,
+    c.shadowViewPlanesByView?.get(shadowViewIdentityKey(pointIdentity)),
   );
   validateShadowOwnership(c, pointIdentity, claimedKeys, recordedKeys);
 }
@@ -1171,6 +1228,8 @@ export function encodeSpotShadowPass(
     }),
     shadowShaderMap(c),
     claimedKeys,
+    false,
+    c.shadowViewPlanesByView?.get(shadowViewIdentityKey(spotIdentity)),
   );
   validateShadowOwnership(c, spotIdentity, claimedKeys, recordedKeys);
 }
@@ -1303,6 +1362,7 @@ export function recordShadowCasterDraws(
   shadowDispatchByRenderableIdx: ShadowDispatchMap,
   gpuDrivenShadowDrawKeys: ReadonlySet<string> | undefined,
   reflected = false,
+  viewPlanes?: Float32Array,
 ): ReadonlySet<string> {
   const {
     runtime,
@@ -1330,6 +1390,7 @@ export function recordShadowCasterDraws(
   for (let i = 0; i < validatedOrdered.length; i++) {
     const entry = validatedOrdered[i];
     if (entry === undefined) continue;
+    if (!shadowViewContains(entry.source, viewPlanes)) continue;
 
     // feat-20260609 M2: skip entities that don't match the pass selector.
     if (matchedIndices !== null && !matchedIndices.has(entry.renderableIndex)) continue;
@@ -1874,7 +1935,6 @@ function ensureSpotShadowMaterialBg(c: _InternalRenderPipelineContext): BindGrou
             prefilterView: fb.prefilterView,
             prefilterSampler: fb.sampler,
             brdfLutView: fb.brdfLutView,
-            brdfLutSampler: fb.sampler,
             intensityBuffer: fb.intensityBuffer,
           },
           transmissionBackdropAvailable(runtime.device.limits.maxSampledTexturesPerShaderStage)
@@ -1956,7 +2016,6 @@ function ensureGpuDrivenAlphaMaskMaterialBg(
     prefilterView: fallback.prefilterView,
     prefilterSampler: fallback.sampler,
     brdfLutView: fallback.brdfLutView,
-    brdfLutSampler: fallback.sampler,
     intensityBuffer: fallback.intensityBuffer,
   } satisfies import('../ibl/skylight-bind-group').SkylightBindGroupResources;
   const deps: PerSubmeshMaterialBgDeps = {
@@ -2022,7 +2081,6 @@ function ensureGpuDrivenCustomShadowMaterialBg(
     prefilterView: fallback.prefilterView,
     prefilterSampler: fallback.sampler,
     brdfLutView: fallback.brdfLutView,
-    brdfLutSampler: fallback.sampler,
     intensityBuffer: fallback.intensityBuffer,
   } satisfies import('../ibl/skylight-bind-group').SkylightBindGroupResources;
   const deps: PerSubmeshMaterialBgDeps = {

package/src/record/sprite-instance-buffer.ts

@@ -0,0 +1,155 @@
+import { type Buffer, RhiError } from '@forgeax/engine-rhi';
+import { GpuBuffer } from '../gpu-resource';
+import {
+  GPU_BUFFER_USAGE_COPY_DST,
+  GPU_BUFFER_USAGE_STORAGE,
+  GPU_BUFFER_USAGE_UNIFORM,
+} from '../gpu-usage';
+import type { InstanceBufferCacheEntry } from '../instance-buffer-cache';
+import type { SpriteInstancesSnapshot } from '../render-system-extract';
+import { worldEntityKey } from './frame-snapshot';
+import type { _InternalRenderPipelineContext } from './render-context';
+
+export type { SpriteInstancesSnapshot } from '../render-system-extract';
+
+/**
+ * Build the interleaved sprite instance payload consumed by this record owner.
+ * The extract stage validates the two packed arrays before they reach this
+ * function, so the record path has one source of count-mismatch errors.
+ */
+export function interleaveSpriteInstanceBuffer(
+  transforms: Float32Array,
+  regions: Float32Array,
+  includePrevious = false,
+): Float32Array {
+  const count = transforms.length / 16;
+  const stride = includePrevious ? 36 : 20;
+  const regionOffset = includePrevious ? 32 : 16;
+  const out = new Float32Array(count * stride);
+  for (let i = 0; i < count; i++) {
+    const dstBase = i * stride;
+    const transformBase = i * 16;
+    const regionBase = i * 4;
+    for (let k = 0; k < 16; k++) out[dstBase + k] = transforms[transformBase + k] ?? 0;
+    if (includePrevious) {
+      for (let k = 0; k < 16; k++) {
+        out[dstBase + 16 + k] = transforms[transformBase + k] ?? 0;
+      }
+    }
+    for (let k = 0; k < 4; k++) {
+      out[dstBase + regionOffset + k] = regions[regionBase + k] ?? 0;
+    }
+  }
+  return out;
+}
+
+/**
+ * Check whether the existing per-entity sprite buffer still matches the
+ * extract snapshot and interleaved byte count.
+ */
+export function spriteInstancesCacheHit(
+  entry: InstanceBufferCacheEntry | undefined,
+  snapshot: SpriteInstancesSnapshot,
+  requestedBytes: number,
+): boolean {
+  return (
+    entry !== undefined &&
+    entry.uploadedArchVersion === snapshot.archVersion &&
+    entry.uploadedByteLength === requestedBytes
+  );
+}
+
+/**
+ * feat-20260704 M3/w19: resolve the interleaved SpriteInstances (@group(3))
+ * buffer + instanceCount for a sprite entity in the LDR blend sub-pass,
+ * extracted verbatim from recordSpriteEntityDraws. Uploads the interleaved
+ * mat4 + per-instance UV region transforms (cache-keyed on the snapshot); on
+ * over-cap fires the structured limit-exceeded error and leaves the passed-in
+ * fallback buffer/count. Returns the resolved (or unchanged) buffer + count.
+ *
+ * @internal
+ */
+export function resolveSpriteInstancesBuffer(
+  c: Pick<_InternalRenderPipelineContext, 'runtime' | 'frameState'>,
+  spriteEntry: _InternalRenderPipelineContext['validatedOrdered'][number],
+  fallbackBuffer: Buffer,
+  fallbackCount: number,
+): { buffer: Buffer; count: number } {
+  const { runtime, frameState } = c;
+  let buffer = fallbackBuffer;
+  let count = fallbackCount;
+  const spriteInstancesSnap: SpriteInstancesSnapshot | undefined =
+    spriteEntry.source.spriteInstances;
+  if (spriteInstancesSnap !== undefined) {
+    if (spriteInstancesSnap.instanceCount === 0) return { buffer, count: 0 };
+    const uniformFallback = runtime.device.caps.storageBuffer === false;
+    const interleaved = interleaveSpriteInstanceBuffer(
+      spriteInstancesSnap.transforms,
+      spriteInstancesSnap.regions,
+      !uniformFallback,
+    );
+    const requestedBytes = interleaved.byteLength;
+    const cap = runtime.device.limits.maxStorageBufferBindingSize;
+    if (typeof cap === 'number' && requestedBytes > cap) {
+      runtime.errorRegistry.fire(
+        new RhiError({
+          code: 'limit-exceeded',
+          expected: `requestedBytes (${requestedBytes}) <= maxStorageBufferBindingSize (${cap})`,
+          hint: 'reduce SpriteInstances instance count to fit within device.limits.maxStorageBufferBindingSize (144 bytes per instance: current mat4 64B + previous mat4 64B + region 16B)',
+          detail: {
+            maxStorageBufferBindingSize: cap,
+            requestedBytes,
+          },
+        }),
+      );
+    } else {
+      const cachedSpriteInst = frameState.instanceBuffers.get(
+        worldEntityKey(spriteEntry.source.worldId, spriteInstancesSnap.cacheKey),
+      );
+      let activeSpriteInst: InstanceBufferCacheEntry | null = null;
+      if (spriteInstancesCacheHit(cachedSpriteInst, spriteInstancesSnap, requestedBytes)) {
+        activeSpriteInst = cachedSpriteInst ?? null;
+      } else if (requestedBytes > 0) {
+        const bufRes = runtime.device.createBuffer({
+          size: requestedBytes,
+          usage:
+            (uniformFallback ? GPU_BUFFER_USAGE_UNIFORM : GPU_BUFFER_USAGE_STORAGE) |
+            GPU_BUFFER_USAGE_COPY_DST,
+          mappedAtCreation: false,
+        });
+        if (!bufRes.ok) {
+          runtime.errorRegistry.fire(bufRes.error);
+        } else {
+          if (cachedSpriteInst !== undefined && !cachedSpriteInst.buffer.isDestroyed) {
+            const r = cachedSpriteInst.buffer.destroy();
+            if (!r.ok) runtime.errorRegistry.fire(r.error);
+          }
+          const newBuf = new GpuBuffer(runtime.device, bufRes.value);
+          activeSpriteInst = {
+            buffer: newBuf,
+            uploadedArchVersion: spriteInstancesSnap.archVersion,
+            uploadedByteLength: requestedBytes,
+          };
+          frameState.instanceBuffers.set(
+            worldEntityKey(spriteEntry.source.worldId, spriteInstancesSnap.cacheKey),
+            activeSpriteInst,
+          );
+        }
+      }
+      if (activeSpriteInst !== null && requestedBytes > 0) {
+        const writeRes = runtime.device.queue.writeBuffer(
+          activeSpriteInst.buffer.handle,
+          0,
+          interleaved,
+        );
+        if (!writeRes.ok) {
+          runtime.errorRegistry.fire(writeRes.error);
+        } else {
+          buffer = activeSpriteInst.buffer.handle;
+          count = spriteInstancesSnap.instanceCount;
+        }
+      }
+    }
+  }
+  return { buffer, count };
+}

package/src/record/target-capture-graph.ts

@@ -0,0 +1,258 @@
+import type { RenderGraphBuilder, RenderGraphError } from '@forgeax/engine-render-graph';
+import type { Texture, TextureView } from '@forgeax/engine-rhi';
+import { ok, type Result } from '@forgeax/engine-types';
+import type { RenderPipelineFrame } from '../render-pipeline';
+import type { RenderTarget } from '../targets/contracts';
+import { resolveRenderTargetMaterialSource } from '../targets/material-source';
+import type { RenderTargetPhysical } from '../targets/physical';
+import { encodeMainPass } from './main-pass';
+import type { _InternalRenderPipelineContext } from './render-context';
+import type { ReflectionProbeGraphState } from './typed-frame-graph';
+
+export interface CubeCaptureGraphWork {
+  readonly target: RenderTarget;
+  readonly faceIndex: number;
+  readonly physical: RenderTargetPhysical;
+  readonly faceCamera: import('../render-contract').CameraSnapshot;
+  readonly viewBindGroupDynamicOffset: number;
+}
+
+export interface CubeCaptureGraphState {
+  work: readonly CubeCaptureGraphWork[];
+  reflectionProbes?: ReflectionProbeGraphState;
+}
+
+function renderTargetMipCount(work: CubeCaptureGraphWork): number {
+  const { descriptor } = work.physical;
+  return descriptor.mipLevels === 1
+    ? 1
+    : Math.floor(Math.log2(Math.max(descriptor.width, descriptor.height))) + 1;
+}
+
+export function addTargetCaptureGraphPasses(
+  builder: RenderGraphBuilder<RenderPipelineFrame>,
+  state: CubeCaptureGraphState,
+): Result<void, RenderGraphError> {
+  for (let index = 0; index < state.work.length; index += 1) {
+    const slot = index;
+    const initial = state.work[slot];
+    if (initial === undefined) continue;
+    const current = (): CubeCaptureGraphWork => state.work[slot] ?? initial;
+    const texture = builder.importTexture(
+      `cube-capture.${slot}.texture`,
+      {
+        format: initial.physical.descriptor.format,
+        size: {
+          width: initial.physical.descriptor.width,
+          height: initial.physical.descriptor.height,
+          depthOrArrayLayers:
+            initial.physical.descriptor.sampleCount === 4 ||
+            initial.physical.descriptor.shape === '2d'
+              ? 1
+              : 6,
+        },
+        mipLevelCount:
+          initial.physical.descriptor.sampleCount === 4 ? 1 : renderTargetMipCount(initial),
+        sampleCount: initial.physical.descriptor.sampleCount,
+        dimension: '2d',
+        usage: 0x10 | 0x04 | 0x01,
+      },
+      () => current().physical.colorTextures[current().faceIndex] ?? initial.physical.texture,
+    );
+    if (!texture.ok) return texture;
+    const color = builder.importView(
+      texture.value,
+      {
+        label: `cube-capture.${slot}.color`,
+        dimension: '2d',
+        baseMipLevel: 0,
+        mipLevelCount: 1,
+        baseArrayLayer: initial.physical.descriptor.sampleCount === 4 ? 0 : initial.faceIndex,
+        arrayLayerCount: 1,
+      },
+      () =>
+        current().physical.faceViews[current().faceIndex] ??
+        initial.physical.faceViews[initial.faceIndex] ??
+        initial.physical.view,
+    );
+    if (!color.ok) return color;
+    const depthTexture = builder.importTexture(
+      `cube-capture.${slot}.depth-texture`,
+      {
+        format: 'depth24plus-stencil8',
+        size: {
+          width: initial.physical.descriptor.width,
+          height: initial.physical.descriptor.height,
+          depthOrArrayLayers:
+            initial.physical.descriptor.sampleCount === 4 ||
+            initial.physical.descriptor.shape === '2d'
+              ? 1
+              : 6,
+        },
+        mipLevelCount: 1,
+        sampleCount: initial.physical.descriptor.sampleCount,
+        dimension: '2d',
+        usage: 0x10,
+      },
+      () => current().physical.depthTextures[current().faceIndex] as Texture,
+    );
+    if (!depthTexture.ok) return depthTexture;
+    const depth = builder.importView(
+      depthTexture.value,
+      {
+        label: `cube-capture.${slot}.depth`,
+        dimension: '2d',
+        baseArrayLayer: initial.physical.descriptor.sampleCount === 4 ? 0 : initial.faceIndex,
+        arrayLayerCount: 1,
+      },
+      () => current().physical.depthViews[current().faceIndex] as TextureView,
+    );
+    if (!depth.ok) return depth;
+    const resolveTexture =
+      initial.physical.descriptor.sampleCount === 4
+        ? builder.importTexture(
+            `cube-capture.${slot}.resolve-texture`,
+            {
+              format: initial.physical.descriptor.format,
+              size: {
+                width: initial.physical.descriptor.width,
+                height: initial.physical.descriptor.height,
+                depthOrArrayLayers: initial.physical.descriptor.shape === 'cube' ? 6 : 1,
+              },
+              mipLevelCount: renderTargetMipCount(initial),
+              sampleCount: 1,
+              dimension: '2d',
+              usage: 0x10 | 0x04 | 0x01,
+            },
+            () =>
+              current().physical.resolveTexture ??
+              initial.physical.resolveTexture ??
+              initial.physical.texture,
+          )
+        : undefined;
+    if (resolveTexture !== undefined && !resolveTexture.ok) return resolveTexture;
+    const resolve =
+      resolveTexture === undefined
+        ? undefined
+        : builder.importView(
+            resolveTexture.value,
+            {
+              label: `cube-capture.${slot}.resolve`,
+              dimension: '2d',
+              baseMipLevel: 0,
+              mipLevelCount: 1,
+              baseArrayLayer: initial.faceIndex,
+              arrayLayerCount: 1,
+            },
+            () =>
+              current().physical.resolveFaceViews[current().faceIndex] ??
+              initial.physical.resolveFaceViews[initial.faceIndex] ??
+              initial.physical.resolveView,
+          );
+    if (resolve !== undefined && !resolve.ok) return resolve;
+    const added = builder.addRasterPass(`cube-capture-face.${slot}`, {
+      accesses: [
+        { resource: color.value, usage: 'color-attachment' },
+        { resource: depth.value, usage: 'depth-stencil-write' },
+        ...(resolve === undefined
+          ? []
+          : [{ resource: resolve.value, usage: 'color-attachment' as const }]),
+      ],
+      colorAttachments: [
+        {
+          view: color.value,
+          ...(resolve === undefined ? {} : { resolveTarget: resolve.value }),
+          loadOp: 'clear',
+          storeOp: 'store',
+          clearValue: () => {
+            const clear =
+              current().physical.descriptor.shape === '2d'
+                ? current().faceCamera.clearColor
+                : [0, 0, 0, 1];
+            return { r: clear[0] ?? 0, g: clear[1] ?? 0, b: clear[2] ?? 0, a: clear[3] ?? 1 };
+          },
+        },
+      ],
+      depthStencilAttachment: {
+        view: depth.value,
+        depthClearValue: 1,
+        depthLoadOp: 'clear',
+        depthStoreOp: 'store',
+        stencilClearValue: 0,
+        stencilLoadOp: 'clear',
+        stencilStoreOp: 'store',
+      },
+      encode: ({ pass, frame, resources }) => {
+        const internal = frame as _InternalRenderPipelineContext;
+        const captureColor = resources.textureView(color.value);
+        if (!captureColor.ok) return;
+        const captureDepth = resources.textureView(depth.value);
+        if (!captureDepth.ok) return;
+        const captureResolve =
+          resolve === undefined ? undefined : resources.textureView(resolve.value);
+        if (resolve !== undefined && (captureResolve === undefined || !captureResolve.ok)) return;
+        const captureResolveView = captureResolve?.ok ? captureResolve.value : null;
+        const selfSampling = new Map<number, Set<number>>();
+        for (const row of internal.validatedOrdered) {
+          for (const material of row.source.materials) {
+            if (
+              ![...(material.textureSources?.values() ?? [])].some(
+                (source) => resolveRenderTargetMaterialSource(source)?.target === current().target,
+              )
+            )
+              continue;
+            let handles = selfSampling.get(row.renderableIndex);
+            if (handles === undefined) {
+              handles = new Set();
+              selfSampling.set(row.renderableIndex, handles);
+            }
+            handles.add(material.materialHandle ?? 0);
+          }
+        }
+        const captureContext = {
+          ...internal,
+          camera: current().faceCamera,
+          targetW: current().physical.descriptor.width,
+          targetH: current().physical.descriptor.height,
+          dispatch: (internal.captureDispatch ?? internal.dispatch).filter(
+            (entry) => !selfSampling.get(entry.renderableIndex)?.has(entry.materialHandle),
+          ),
+          foldDispatchPlan: null,
+
+          // Cube faces are raw scene captures, not display-camera HDR output.
+          // Select the PSO against the actual target attachment so an LDR
+          // cube target is rendered by a compatible forward pipeline.
+          tonemapActive: false,
+          skyboxActive: false,
+          transparentColorFormat: initial.physical.descriptor.format as GPUTextureFormat,
+          msaaActive: initial.physical.descriptor.sampleCount === 4,
+          viewBindGroupDynamicOffset: current().viewBindGroupDynamicOffset,
+          geometryColorView: captureColor.value,
+          geometryDepthView: captureDepth.value,
+          geometryColorResolveView: captureResolveView,
+          splitLdrSprite: false,
+          ldrSpritePassView: null,
+        };
+        delete captureContext.gpuDrivenDrawKeys;
+        delete captureContext.gpuDrivenStandardPbrFrameResources;
+        encodeMainPass(
+          captureContext,
+          pass,
+          { LightMode: ['Forward'] },
+          {
+            colorViews: [captureColor.value],
+            colorFormats: [initial.physical.descriptor.format as GPUTextureFormat],
+            depthView: captureDepth.value,
+            passKind: 'forward',
+            clearColor:
+              current().physical.descriptor.shape === '2d'
+                ? current().faceCamera.clearColor
+                : [0, 0, 0, 1],
+          },
+        );
+      },
+    });
+    if (!added.ok) return added;
+  }
+  return ok(undefined);
+}