@forgeax/engine-render 0.1.19 → 0.1.21

package/src/targets/physical.ts

@@ -0,0 +1,18 @@
+import type { Texture, TextureView } from '@forgeax/engine-rhi';
+import type { RenderTargetDescriptor } from './contracts';
+
+/** Renderer-private physical storage for one logical target generation. */
+export interface RenderTargetPhysical {
+  readonly generation: number;
+  readonly descriptor: RenderTargetDescriptor;
+  readonly texture: Texture;
+  readonly view: TextureView;
+  readonly mipViews: readonly TextureView[];
+  readonly colorTextures: readonly Texture[];
+  readonly faceViews: readonly TextureView[];
+  readonly depthTextures: readonly Texture[];
+  readonly depthViews: readonly TextureView[];
+  readonly resolveTexture?: Texture;
+  readonly resolveView: TextureView;
+  readonly resolveFaceViews: readonly TextureView[];
+}

package/src/targets/readback.ts

@@ -0,0 +1,153 @@
+import type { RenderError } from '../errors/render';
+import { RenderTargetOperationFailedError, RenderTargetStateInvalidError } from '../errors/render';
+import type { RenderResult } from '../render-contract';
+import type { RenderTarget } from './contracts';
+
+export interface RenderTargetReadbackReceipt {
+  readonly frameId: number;
+  readonly deviceGeneration: number;
+}
+
+export interface RenderTargetReadbackTicketInput {
+  readonly frameId?: number;
+  deviceGeneration: number;
+  readonly mipLevel: number;
+  readonly face?: number;
+  readonly width: number;
+  readonly height: number;
+  readonly bytesPerPixel: number;
+}
+
+export interface RenderTargetReadbackTicket {
+  readonly target: RenderTarget;
+  frameId: number | undefined;
+  deviceGeneration: number;
+  readonly mipLevel: number;
+  readonly face?: number;
+  readonly width: number;
+  readonly height: number;
+  readonly bytesPerRow: number;
+  readonly byteLength: number;
+  consumed: boolean;
+}
+
+export interface RenderTargetReadbackResult {
+  readonly bytes: Uint8Array;
+  readonly frameId: number;
+  readonly deviceGeneration: number;
+  readonly mipLevel: number;
+  readonly face?: number;
+}
+
+function invalidTicket(
+  ticket: RenderTargetReadbackTicket,
+  reason: 'uninitialized' | 'generation-mismatch' | 'destroyed',
+): RenderResult<never, RenderError> {
+  return {
+    ok: false,
+    error: new RenderTargetStateInvalidError({
+      operation: 'readback',
+      reason,
+      state: reason === 'destroyed' ? 'destroyed' : 'active',
+      generation: ticket.deviceGeneration,
+    }),
+  };
+}
+
+export function bindRenderTargetReadbackTicket(
+  ticket: RenderTargetReadbackTicket,
+  receipt: RenderTargetReadbackReceipt,
+): RenderResult<void, RenderError> {
+  if (ticket.consumed) return invalidTicket(ticket, 'destroyed');
+  if (ticket.frameId !== undefined) {
+    return invalidTicket(ticket, 'generation-mismatch');
+  }
+  ticket.frameId = receipt.frameId;
+  ticket.deviceGeneration = receipt.deviceGeneration;
+  return { ok: true, value: undefined };
+}
+
+export function createRenderTargetReadbackTicket(
+  target: RenderTarget,
+  input: RenderTargetReadbackTicketInput,
+): RenderResult<RenderTargetReadbackTicket, RenderError> {
+  if (
+    (input.frameId !== undefined && (!Number.isInteger(input.frameId) || input.frameId < 0)) ||
+    !Number.isInteger(input.deviceGeneration) ||
+    input.deviceGeneration < 0 ||
+    !Number.isInteger(input.mipLevel) ||
+    input.mipLevel < 0 ||
+    !Number.isInteger(input.width) ||
+    input.width < 1 ||
+    !Number.isInteger(input.height) ||
+    input.height < 1 ||
+    !Number.isInteger(input.bytesPerPixel) ||
+    input.bytesPerPixel < 1
+  ) {
+    return {
+      ok: false,
+      error: new RenderTargetOperationFailedError({
+        operation: 'readback',
+        stage: 'copy',
+        generation: input.deviceGeneration,
+        cause: new Error('readback dimensions and identity must be non-negative integers'),
+        recovery: 'retry',
+      }),
+    };
+  }
+  const unalignedRowBytes = input.width * input.bytesPerPixel;
+  const bytesPerRow = Math.ceil(unalignedRowBytes / 256) * 256;
+  return {
+    ok: true,
+    value: {
+      target,
+      frameId: input.frameId,
+      deviceGeneration: input.deviceGeneration,
+      mipLevel: input.mipLevel,
+      ...(input.face === undefined ? {} : { face: input.face }),
+      width: input.width,
+      height: input.height,
+      bytesPerRow,
+      byteLength: bytesPerRow * input.height,
+      consumed: false,
+    },
+  };
+}
+
+export function completeRenderTargetReadback(
+  ticket: RenderTargetReadbackTicket,
+  receipt: RenderTargetReadbackReceipt,
+  bytes: Uint8Array,
+): RenderResult<RenderTargetReadbackResult, RenderError> {
+  if (ticket.consumed) return invalidTicket(ticket, 'destroyed');
+  if (
+    ticket.frameId === undefined ||
+    receipt.frameId !== ticket.frameId ||
+    receipt.deviceGeneration !== ticket.deviceGeneration
+  ) {
+    return invalidTicket(ticket, 'generation-mismatch');
+  }
+  if (bytes.byteLength !== ticket.byteLength) {
+    return {
+      ok: false,
+      error: new RenderTargetOperationFailedError({
+        operation: 'readback',
+        stage: 'copy',
+        generation: ticket.deviceGeneration,
+        cause: new Error(`expected ${ticket.byteLength} bytes, received ${bytes.byteLength}`),
+        recovery: 'retry',
+      }),
+    };
+  }
+  ticket.consumed = true;
+  return {
+    ok: true,
+    value: {
+      bytes,
+      frameId: ticket.frameId,
+      deviceGeneration: ticket.deviceGeneration,
+      mipLevel: ticket.mipLevel,
+      ...(ticket.face === undefined ? {} : { face: ticket.face }),
+    },
+  };
+}

package/src/temporal/frame.ts

@@ -0,0 +1,128 @@
+import { err, ok, type Result } from '@forgeax/engine-types';
+import { TemporalFrameSubmitError } from '../errors/render';
+
+export type TemporalResetReason =
+  | 'none'
+  | 'camera-cut'
+  | 'resize'
+  | 'signature-change'
+  | 'depth-discontinuity'
+  | 'out-of-screen'
+  | 'queue-submit-failed'
+  | 'device-recovery';
+
+export interface TemporalFrameInput {
+  readonly frameId: number;
+  readonly currentViewProjection: Float32Array;
+  readonly jitter: readonly [number, number];
+  readonly viewport: { readonly width: number; readonly height: number };
+  /** Current camera origin, retained only as accepted temporal history. */
+  readonly cameraPosition?: readonly [number, number, number];
+  readonly resetReason?: Exclude<TemporalResetReason, 'none' | 'queue-submit-failed'>;
+}
+
+export interface TemporalFrame {
+  readonly frameId: number;
+  readonly currentViewProjection: Float32Array;
+  readonly previousViewProjection: Float32Array | undefined;
+  readonly jitter: readonly [number, number];
+  readonly viewport: { readonly width: number; readonly height: number };
+  readonly currentCameraPosition: readonly [number, number, number];
+  readonly previousCameraPosition: readonly [number, number, number] | undefined;
+  readonly resetReason: TemporalResetReason;
+  readonly historyEpoch: number;
+  readonly deviceEpoch: number;
+}
+
+export interface TemporalSubmitResult {
+  readonly accepted: boolean;
+  readonly reason?: 'queue-submit-failed';
+  readonly resetReason?: Exclude<TemporalResetReason, 'none' | 'queue-submit-failed'>;
+}
+
+export interface TemporalFrameTransaction {
+  stage(input: TemporalFrameInput): void;
+  commit(submit: TemporalSubmitResult): Result<TemporalFrame, TemporalFrameSubmitError>;
+  snapshot(): TemporalFrame;
+}
+
+function copyInput(input: TemporalFrameInput): TemporalFrameInput {
+  return {
+    ...input,
+    currentViewProjection: new Float32Array(input.currentViewProjection),
+    jitter: [input.jitter[0], input.jitter[1]],
+    viewport: { ...input.viewport },
+    ...(input.cameraPosition === undefined
+      ? {}
+      : { cameraPosition: [...input.cameraPosition] as [number, number, number] }),
+  };
+}
+
+function copyFrame(frame: TemporalFrame): TemporalFrame {
+  return {
+    ...frame,
+    currentViewProjection: new Float32Array(frame.currentViewProjection),
+    previousViewProjection:
+      frame.previousViewProjection === undefined
+        ? undefined
+        : new Float32Array(frame.previousViewProjection),
+    jitter: [frame.jitter[0], frame.jitter[1]],
+    viewport: { ...frame.viewport },
+    currentCameraPosition: [...frame.currentCameraPosition] as [number, number, number],
+    previousCameraPosition:
+      frame.previousCameraPosition === undefined
+        ? undefined
+        : ([...frame.previousCameraPosition] as [number, number, number]),
+  };
+}
+
+export function createTemporalFrameTransaction(options: {
+  readonly deviceEpoch: number;
+}): TemporalFrameTransaction {
+  let accepted: TemporalFrame | undefined;
+  let staged: TemporalFrameInput | undefined;
+  let historyEpoch = 0;
+
+  return {
+    stage(input) {
+      staged = copyInput(input);
+    },
+    commit(submit) {
+      if (!submit.accepted) {
+        staged = undefined;
+        return err(new TemporalFrameSubmitError(submit.reason ?? 'queue-submit-failed'));
+      }
+      if (staged === undefined) {
+        return err(new TemporalFrameSubmitError('queue-submit-failed'));
+      }
+
+      const resetReason = submit.resetReason ?? staged.resetReason ?? 'none';
+      const shouldReset = resetReason !== 'none';
+      if (shouldReset) historyEpoch += 1;
+      const next: TemporalFrame = {
+        frameId: staged.frameId,
+        currentViewProjection: new Float32Array(staged.currentViewProjection),
+        previousViewProjection:
+          accepted === undefined || shouldReset
+            ? undefined
+            : new Float32Array(accepted.currentViewProjection),
+        jitter: [staged.jitter[0], staged.jitter[1]],
+        viewport: { ...staged.viewport },
+        currentCameraPosition: staged.cameraPosition ?? [0, 0, 0],
+        previousCameraPosition:
+          accepted === undefined || shouldReset ? undefined : accepted.currentCameraPosition,
+        resetReason,
+        historyEpoch,
+        deviceEpoch: options.deviceEpoch,
+      };
+      accepted = next;
+      staged = undefined;
+      return ok(copyFrame(next));
+    },
+    snapshot() {
+      if (accepted === undefined)
+        throw new Error('TemporalFrame snapshot is unavailable before commit');
+      return copyFrame(accepted);
+    },
+  };
+}

package/src/transmission/__tests__/standard-transmission.dawn.test.ts

@@ -14,6 +14,7 @@ import {
   DirectionalLight,
   MeshFilter,
   MeshRenderer,
+  PointLight,
   TONEMAP_LINEAR,
 } from '../../components';
 import { constructRendererHost, type RhiBackendPack } from '../../construct-renderer';
@@ -57,20 +58,21 @@ interface TransmissionCase {
   readonly thicknessTexture?: number;
   readonly masked?: boolean;
   readonly overlap?: boolean;
-  readonly lane?: 'direct' | 'clustered';
+  readonly renderPath?: 'forward' | 'deferred';
   readonly surfaceQuat?: readonly [number, number, number, number];
+  readonly directionalLight?: boolean;
+  readonly localLight?: boolean;
 }
 
 function textureAsset(value: number): TextureAsset {
   const channel = Math.round(value * 255);
   return {
     kind: 'texture',
-    width: 1,
-    height: 1,
+    shape: { viewDimension: '2d', extent: { width: 1, height: 1 } },
     format: 'rgba8unorm',
     data: Uint8Array.from([channel, channel, channel, 255]),
     colorSpace: 'linear',
-    mipmap: false,
+    mips: { kind: 'none' },
   };
 }
 
@@ -107,6 +109,7 @@ async function renderCase(testCase: TransmissionCase): Promise<{
   readonly pixel: readonly [number, number, number, number];
   readonly passNames: readonly string[];
   readonly observation: boolean;
+  readonly errors: readonly string[];
 }> {
   let device: GPUDevice | undefined;
   let configuredDevice: GPUDevice | undefined;
@@ -158,7 +161,7 @@ async function renderCase(testCase: TransmissionCase): Promise<{
       {
         standardProfile: {
           ...DEFAULT_STANDARD_PROFILE,
-          lighting: testCase.lane ?? 'direct',
+          renderPath: testCase.renderPath ?? DEFAULT_STANDARD_PROFILE.renderPath,
         },
       },
       { shaderManifestUrl: ENGINE_MANIFEST_URL },
@@ -173,6 +176,10 @@ async function renderCase(testCase: TransmissionCase): Promise<{
   }
 
   const { renderer } = host.value;
+  const errors: string[] = [];
+  const unsubscribe = renderer.subscribe((event) => {
+    if (event.kind === 'error') errors.push(event.error.code);
+  });
   const world = new World();
   const lease = renderer.attach(world);
   if (!lease.ok) throw lease.error;
@@ -278,12 +285,22 @@ async function renderCase(testCase: TransmissionCase): Promise<{
   );
   expect(cameraEntity.ok, `${testCase.name}: camera spawn must succeed`).toBe(true);
   if (!cameraEntity.ok) throw cameraEntity.error;
-  const lightEntity = world.spawn({
-    component: DirectionalLight,
-    data: { direction: [0, 0, -1], color: [1, 1, 1], intensity: 1, castShadow: false },
-  });
-  expect(lightEntity.ok, `${testCase.name}: light spawn must succeed`).toBe(true);
-  if (!lightEntity.ok) throw lightEntity.error;
+  if (testCase.directionalLight !== false) {
+    const lightEntity = world.spawn({
+      component: DirectionalLight,
+      data: { direction: [0, 0, -1], color: [1, 1, 1], intensity: 1, castShadow: false },
+    });
+    expect(lightEntity.ok, `${testCase.name}: light spawn must succeed`).toBe(true);
+    if (!lightEntity.ok) throw lightEntity.error;
+  }
+  if (testCase.localLight === true) {
+    const localLightEntity = world.spawn(
+      { component: Transform, data: { pos: [0, 0, 1] } },
+      { component: PointLight, data: { intensity: 8, range: 10 } },
+    );
+    expect(localLightEntity.ok, `${testCase.name}: local light spawn must succeed`).toBe(true);
+    if (!localLightEntity.ok) throw localLightEntity.error;
+  }
   world.update().unwrap();
   const drawn = renderer.draw({
     leases: [lease.value],
@@ -300,10 +317,12 @@ async function renderCase(testCase: TransmissionCase): Promise<{
   const renderDevice = configuredDevice ?? device;
   const passNames = renderer.inspect().perFramePassNames;
   expect(renderer.inspect().renderScene.projectionRecords).toBeGreaterThanOrEqual(1);
+  unsubscribe();
   return {
     pixel: await readCenter(renderDevice, target),
     passNames,
     observation: observation.ok,
+    errors,
   };
 }
 
@@ -404,9 +423,9 @@ describe('Standard transmission Dawn ROI', () => {
     );
   }, 120_000);
 
-  it('exercises direct/clustered lanes and transmission-before-BLEND overlap order', async () => {
-    const direct = await renderCase({
-      name: 'direct',
+  it('exercises both Standard render paths and transmission-before-BLEND overlap order', async () => {
+    const forward = await renderCase({
+      name: 'forward',
       transmission: 1,
       ior: 1.5,
       thickness: 0.5,
@@ -414,10 +433,10 @@ describe('Standard transmission Dawn ROI', () => {
       attenuationColor: [0.7, 0.8, 0.9],
       attenuationDistance: 2,
       overlap: true,
-      lane: 'direct',
+      renderPath: 'forward',
     });
-    const clustered = await renderCase({
-      name: 'clustered',
+    const deferred = await renderCase({
+      name: 'deferred',
       transmission: 1,
       ior: 1.5,
       thickness: 0.5,
@@ -425,14 +444,33 @@ describe('Standard transmission Dawn ROI', () => {
       attenuationColor: [0.7, 0.8, 0.9],
       attenuationDistance: 2,
       overlap: true,
-      lane: 'clustered',
+      renderPath: 'deferred',
     });
-    const transmissionIndex = direct.passNames.indexOf('transmission-forward');
-    const transparentIndex = direct.passNames.indexOf('transparent');
+    const transmissionIndex = forward.passNames.indexOf('transmission-forward');
+    const transparentIndex = forward.passNames.indexOf('transparent');
     expect(transmissionIndex).toBeGreaterThanOrEqual(0);
     expect(transparentIndex).toBeGreaterThan(transmissionIndex);
-    expect(clustered.pixel).not.toEqual(direct.pixel);
-    expect(clustered.pixel.every(Number.isFinite)).toBe(true);
-    expect(direct.pixel.every(Number.isFinite)).toBe(true);
+    expect(deferred.pixel.every(Number.isFinite)).toBe(true);
+    expect(forward.pixel.every(Number.isFinite)).toBe(true);
+  }, 120_000);
+
+  it('submits a real clustered local-light frame through the Standard front door', async () => {
+    const clustered = await renderCase({
+      name: 'clustered-local-light',
+      transmission: 0,
+      ior: 1.5,
+      thickness: 0,
+      roughness: 0.4,
+      attenuationColor: [1, 1, 1],
+      directionalLight: false,
+      localLight: true,
+      renderPath: 'forward',
+    });
+
+    expect(clustered.passNames).toEqual(
+      expect.arrayContaining(['cluster-membership-producer', 'main', 'output-transform']),
+    );
+    expect(clustered.observation).toBe(true);
+    expect(clustered.errors).toEqual([]);
   }, 120_000);
 });

package/src/typed-render-graph-primitives.ts

@@ -215,7 +215,15 @@ export function addTypedScenePass(
         internal.pipelineState,
         internal.validated.length > 0 || options.gpuDriven !== undefined,
         internal.bindGroupCounts,
-        { directionalShadow, spotShadow },
+        {
+          directionalShadow,
+          spotShadow,
+          projector: internal.spotLightProjector?.view ?? internal.volumetricFog?.projectorView,
+          projectorSampler:
+            internal.spotLightProjector?.sampler ?? internal.volumetricFog?.projectorSampler,
+        },
+        true,
+        internal.standardLighting,
       );
       if (groups.viewBindGroup !== null) {
         options.gpuDriven?.encode(groups.viewBindGroup, pass, resources);
@@ -461,6 +469,10 @@ export interface TypedFullscreenPassOptions {
     readonly key: string;
     readonly target: RenderPipelineTarget;
   }[];
+  /** Optional per-pass copy of the params UBO payload. */
+  readonly paramsTransform?:
+    | ((params: Uint8Array | undefined) => Uint8Array | undefined)
+    | undefined;
 }
 
 export interface TypedTemporalResolveTargets {
@@ -615,6 +627,11 @@ export function addTypedFullscreenPass(
         ...(options.rawSwapchainOutput === undefined
           ? {}
           : { rawSwapchainOutput: options.rawSwapchainOutput }),
+        ...(options.paramsTransform === undefined
+          ? {}
+          : {
+              paramsOverride: options.paramsTransform(frame.postProcessParams.get(options.shader)),
+            }),
       });
     },
   });
@@ -681,8 +698,9 @@ export function addTypedOutputTransformPass(
   graph: RenderGraphBuilder<RenderPipelineFrame>,
   input: RenderPipelineTarget,
   output: RenderPipelineTarget,
-  outputOnly = false,
+  options: { readonly outputOnly?: boolean; readonly dither?: boolean } = {},
 ): Result<void, RenderGraphError> {
+  const outputOnly = options.outputOnly ?? false;
   return addTypedFullscreenPass(graph, {
     name: outputOnly ? 'present' : 'output-transform',
     shader: STANDARD_OUTPUT_TRANSFORM_FEATURE_ID,
@@ -690,5 +708,19 @@ export function addTypedOutputTransformPass(
     output,
     outputOnly,
     rawSwapchainOutput: outputOnly,
+    ...(options.dither !== undefined
+      ? {
+          paramsTransform: (params: Uint8Array | undefined): Uint8Array | undefined => {
+            if (params === undefined || params.byteLength !== 16) return params;
+            const transformed = params.slice();
+            new DataView(
+              transformed.buffer,
+              transformed.byteOffset,
+              transformed.byteLength,
+            ).setFloat32(12, options.dither === true ? 1 : 0, true);
+            return transformed;
+          },
+        }
+      : {}),
   });
 }

package/src/typed-shadow-atlas.ts

@@ -0,0 +1,17 @@
+export interface DirectionalShadowAtlasGrid {
+  readonly columns: 1 | 2;
+  readonly rows: 1 | 2;
+}
+
+/**
+ * The directional CSM atlas layout is one compact contract for raster writes
+ * and shader reads: 1 -> 1x1, 2 -> 2x1, and 3/4 -> 2x2.
+ */
+export function resolveDirectionalShadowAtlasGrid(
+  cascadeCount: number,
+): DirectionalShadowAtlasGrid {
+  const count = Math.max(1, Math.min(4, Math.round(cascadeCount)));
+  if (count === 1) return { columns: 1, rows: 1 };
+  if (count === 2) return { columns: 2, rows: 1 };
+  return { columns: 2, rows: 2 };
+}

package/src/typed-shadow-passes.ts

@@ -10,9 +10,10 @@ import {
 } from './record/shadow-pass';
 import type { RenderPipelineFrame, RenderPipelineTopology } from './render-pipeline';
 import { createRenderPipelineTarget, type RenderPipelineTarget } from './render-pipeline';
+import { resolveDirectionalShadowAtlasGrid } from './typed-shadow-atlas';
 
 export interface TypedShadowTargets {
-  readonly directional: RenderPipelineTarget;
+  readonly directional?: RenderPipelineTarget | undefined;
   readonly spot: RenderPipelineTarget;
   readonly point?: RenderPipelineTarget | undefined;
 }
@@ -43,44 +44,50 @@ export function addTypedShadowPasses(
   graph: RenderGraphBuilder<RenderPipelineFrame>,
   topology: RenderPipelineTopology,
 ): Result<TypedShadowTargets, RenderGraphError> {
-  const tilesPerSide = Math.ceil(Math.sqrt(topology.shadow.cascadeCount));
-  const directional = createRenderPipelineTarget(graph, 'directional-shadow-depth', {
-    format: 'depth32float',
-    size: {
-      width: topology.shadow.mapSize * tilesPerSide,
-      height: topology.shadow.mapSize * tilesPerSide,
-    },
-  });
-  if (!directional.ok) return directional;
-  for (let cascade = 0; cascade < topology.shadow.cascadeCount; cascade += 1) {
-    const col = cascade % tilesPerSide;
-    const row = Math.floor(cascade / tilesPerSide);
-    const added = recordShadowPass(
-      graph,
-      `shadowCascade${cascade}`,
-      directional.value,
-      cascade === 0 ? 'clear' : 'load',
-      ({ pass, frame }) =>
-        encodeDirectionalShadowPass(frame as never, pass, cascade, {
-          x: col * topology.shadow.mapSize,
-          y: row * topology.shadow.mapSize,
-          w: topology.shadow.mapSize,
-          h: topology.shadow.mapSize,
-        }),
-      (frame) => !(frame as _InternalRenderPipelineContext).directionalShadowCacheReuse,
-    );
-    if (!added.ok) return added;
+  let directional: RenderPipelineTarget | undefined;
+  if (topology.shadow.directional !== 'disabled') {
+    const { mapSize, cascadeCount } = topology.shadow.directional;
+    const atlasGrid = resolveDirectionalShadowAtlasGrid(cascadeCount);
+    const target = createRenderPipelineTarget(graph, 'directional-shadow-depth', {
+      format: 'depth32float',
+      size: {
+        width: mapSize * atlasGrid.columns,
+        height: mapSize * atlasGrid.rows,
+      },
+    });
+    if (!target.ok) return target;
+    const directionalTarget = target.value;
+    directional = directionalTarget;
+    for (let cascade = 0; cascade < cascadeCount; cascade += 1) {
+      const col = cascade % atlasGrid.columns;
+      const row = Math.floor(cascade / atlasGrid.columns);
+      const added = recordShadowPass(
+        graph,
+        `shadowCascade${cascade}`,
+        directionalTarget,
+        cascade === 0 ? 'clear' : 'load',
+        ({ pass, frame }) =>
+          encodeDirectionalShadowPass(frame as never, pass, cascade, {
+            x: col * mapSize,
+            y: row * mapSize,
+            w: mapSize,
+            h: mapSize,
+          }),
+        (frame) => !(frame as _InternalRenderPipelineContext).directionalShadowCacheReuse,
+      );
+      if (!added.ok) return added;
+    }
+    const observation = graph.addCopyPass('directional-shadow-observation', {
+      accesses: [{ resource: directionalTarget.view, usage: 'copy-src' }],
+      encode: ({ frame, resources }) => {
+        const internal = frame as _InternalRenderPipelineContext;
+        const texture = resources.texture(directionalTarget.texture);
+        if (!texture.ok) throw texture.error;
+        internal.pipelineState.perPassResources.shadowTexture = texture.value;
+      },
+    });
+    if (!observation.ok) return observation;
   }
-  const observation = graph.addCopyPass('directional-shadow-observation', {
-    accesses: [{ resource: directional.value.view, usage: 'copy-src' }],
-    encode: ({ frame, resources }) => {
-      const internal = frame as _InternalRenderPipelineContext;
-      const texture = resources.texture(directional.value.texture);
-      if (!texture.ok) throw texture.error;
-      internal.pipelineState.perPassResources.shadowTexture = texture.value;
-    },
-  });
-  if (!observation.ok) return observation;
 
   let point: RenderPipelineTarget | undefined;
   if (topology.shadow.pointCount > 0) {
@@ -147,7 +154,7 @@ export function addTypedShadowPasses(
 
   const spot = createRenderPipelineTarget(graph, 'spot-shadow-depth', {
     format: 'depth32float',
-    size: { width: topology.shadow.mapSize * 2, height: topology.shadow.mapSize * 2 },
+    size: { width: topology.shadow.spotMapSize * 2, height: topology.shadow.spotMapSize * 2 },
   });
   if (!spot.ok) return spot;
   for (let spotIndex = 0; spotIndex < Math.max(1, topology.shadow.spotCount); spotIndex += 1) {
@@ -161,5 +168,5 @@ export function addTypedShadowPasses(
     if (!added.ok) return added;
   }
 
-  return ok({ directional: directional.value, spot: spot.value, point });
+  return ok({ directional, spot: spot.value, point });
 }