@forgeax/engine-render 0.1.4 → 0.1.6

package/src/tilemap-chunk-extract-system.ts

@@ -3,7 +3,7 @@
 // Walks every TileLayer attached to a Tilemap via ChildOf; when a layer is
 // dirty (or has never been extracted), purges its previously-spawned derived
 // per-cell entities and re-spawns one ECS entity per non-zero cell. Each
-// derived entity carries Transform + MeshFilter (a World-owned unit-quad ref) + MeshRenderer
+// derived entity carries Transform + MeshFilter (HANDLE_QUAD) + MeshRenderer
 // + Layer + ChildOf { parent: layerEntity }. The ChildOf edge lets
 // `world.despawn(tilemapEntity)` cascade-despawn the entire subtree
 // (Tilemap -> TileLayer -> derived render entities) via the engine's
@@ -49,8 +49,12 @@
 // §D-2 (multi-cell + flip x pivot) + §D-5 (M0 baseline file-by-file
 // ECS API adaptation) + §D-7 step 3 (half-texel UV inset).
 
+import {
+  HANDLE_QUAD,
+  resolveTilesetRuntime,
+  type TilesetAtlasLookup,
+} from '@forgeax/engine-assets-runtime';
 import type { EntityHandle, World } from '@forgeax/engine-ecs';
-import { createPrimitiveMesh } from '@forgeax/engine-geometry';
 import { decodeTileBits } from '@forgeax/engine-graphics-extras';
 import { type box3, frustum, mat4 } from '@forgeax/engine-math';
 import { ChildOf, Children, Transform } from '@forgeax/engine-scene';
@@ -60,6 +64,7 @@ import {
   type TilesetAsset,
   type TilesetRegion,
   type TilesetTileEntry,
+  toShared,
   unwrapHandle,
 } from '@forgeax/engine-types';
 import {
@@ -74,8 +79,7 @@ import {
   TileLayer,
   Tilemap,
 } from './components';
-import { materialTextureValue, SPRITE_PREMULTIPLIED_ALPHA_BLEND } from './materials';
-import { resolveTilesetRuntime, type TilesetAtlasLookup } from './tilemap/resolve-tileset-runtime';
+import { SPRITE_PREMULTIPLIED_ALPHA_BLEND } from './materials';
 
 // Module-scoped caches (charter P5 — engine-side memoisation; AI users
 // never reach in). Test harness can flush them via the reset helpers.
@@ -94,18 +98,8 @@ import { resolveTilesetRuntime, type TilesetAtlasLookup } from './tilemap/resolv
 //      The shader's PER_INSTANCE_REGION=true variant reads per-instance
 //      UV from the instance buffer, not from the material UBO, so the
 //      placeholder is ignored at draw time.
-let atlasMaterialCache = new WeakMap<World, Map<string, number>>();
-let atlasOnlyMaterialCache = new WeakMap<World, Map<string, number>>();
-const unitQuadHandleByWorld = new WeakMap<World, Handle<'MeshAsset', 'shared'>>();
-
-function unitQuadHandle(world: World): Handle<'MeshAsset', 'shared'> {
-  const existing = unitQuadHandleByWorld.get(world);
-  if (existing !== undefined) return existing;
-  const mesh = createPrimitiveMesh('quad').unwrap();
-  const handle = world.internSharedRef('MeshAsset', mesh);
-  unitQuadHandleByWorld.set(world, handle);
-  return handle;
-}
+let atlasMaterialCache = new WeakMap<World, Map<string, Handle<'MaterialAsset', 'shared'>>>();
+let atlasOnlyMaterialCache = new WeakMap<World, Map<string, Handle<'MaterialAsset', 'shared'>>>();
 // tweak-20260714 M3 (plan-strategy §2 D-3): the terrain (sortScope='layer')
 // derived-entity tracker Map + first-frame-heuristic Set that used to live
 // alongside these material caches were retired once every derived entity
@@ -159,7 +153,7 @@ interface StreamLayerCache {
 }
 interface PerWorldStreamingCache {
   readonly layers: Map<string, StreamLayerCache>;
-  readonly chunkEntities: Map<string, number[]>;
+  readonly chunkEntities: Map<string, EntityHandle[]>;
   readonly activeChunks: Map<string, Set<number>>;
 }
 
@@ -183,8 +177,8 @@ function streamingCache(world: World): PerWorldStreamingCache {
  * TilesetAsset reload.
  */
 export function resetTilemapChunkExtractCache(): void {
-  atlasMaterialCache = new WeakMap<World, Map<string, number>>();
-  atlasOnlyMaterialCache = new WeakMap<World, Map<string, number>>();
+  atlasMaterialCache = new WeakMap<World, Map<string, Handle<'MaterialAsset', 'shared'>>>();
+  atlasOnlyMaterialCache = new WeakMap<World, Map<string, Handle<'MaterialAsset', 'shared'>>>();
 }
 
 /**
@@ -288,22 +282,23 @@ function resolveTilesetMaterial(
   tileset: TilesetAsset,
   regionIndex: number,
   lookup: (guid: string) => TilesetAtlasLookup,
-): number {
+): Handle<'MaterialAsset', 'shared'> {
   const region = tileset.regions[regionIndex];
-  if (region === undefined) return 0;
+  if (region === undefined) return toShared<'MaterialAsset'>(0);
   // 3-hop walk: regions[i].atlasIndex (default 0) -> atlases[atlasIndex].
   // atlasIndex out-of-range is register-time fail-fast via
   // `validateTilesetPayload` (m1-t6); the runtime resolver still bails
   // when the slot is unexpectedly empty (charter P3 fail-safe).
   const atlasIndex = region.atlasIndex ?? 0;
   const atlasGuid = tileset.atlases[atlasIndex];
-  if (atlasGuid === undefined) return 0;
+  if (atlasGuid === undefined) return toShared<'MaterialAsset'>(0);
   const atlas = resolveTilesetRuntime(world, atlasGuid, lookup);
-  if (!atlas.ok) return 0;
+  if (!atlas.ok) return toShared<'MaterialAsset'>(0);
   const atlasHandle = atlas.value.handle;
   const atlasId = unwrapHandle(atlasHandle);
   const cacheKey = `${atlasId}|${regionIndex}`;
-  const cache = atlasMaterialCache.get(world) ?? new Map<string, number>();
+  const cache =
+    atlasMaterialCache.get(world) ?? new Map<string, Handle<'MaterialAsset', 'shared'>>();
   atlasMaterialCache.set(world, cache);
   const cached = cache.get(cacheKey);
   if (cached !== undefined) return cached;
@@ -345,7 +340,7 @@ function resolveTilesetMaterial(
     ],
     values: {
       colorTint: [1.0, 1.0, 1.0, 1.0],
-      baseColorTexture: materialTextureValue(atlasHandle),
+      baseColorTexture: atlasHandle,
       region: [u, v, w, h],
       pivotAndSize: [0.5, 0.5, 1.0, 1.0],
       flipY: 1.0,
@@ -355,9 +350,8 @@ function resolveTilesetMaterial(
     'MaterialAsset',
     matPayload,
   );
-  const id = unwrapHandle(matHandle);
-  cache.set(cacheKey, id);
-  return id;
+  cache.set(cacheKey, matHandle);
+  return matHandle;
 }
 
 /**
@@ -381,15 +375,16 @@ function resolveAtlasOnlyMaterial(
   tileset: TilesetAsset,
   atlasIndex: number,
   lookup: (guid: string) => TilesetAtlasLookup,
-): number {
+): Handle<'MaterialAsset', 'shared'> {
   const atlasGuid = tileset.atlases[atlasIndex];
-  if (atlasGuid === undefined) return 0;
+  if (atlasGuid === undefined) return toShared<'MaterialAsset'>(0);
   const atlas = resolveTilesetRuntime(world, atlasGuid, lookup);
-  if (!atlas.ok) return 0;
+  if (!atlas.ok) return toShared<'MaterialAsset'>(0);
   const atlasHandle = atlas.value.handle;
   const atlasId = unwrapHandle(atlasHandle);
   const cacheKey = String(atlasId);
-  const cache = atlasOnlyMaterialCache.get(world) ?? new Map<string, number>();
+  const cache =
+    atlasOnlyMaterialCache.get(world) ?? new Map<string, Handle<'MaterialAsset', 'shared'>>();
   atlasOnlyMaterialCache.set(world, cache);
   const cached = cache.get(cacheKey);
   if (cached !== undefined) return cached;
@@ -409,7 +404,7 @@ function resolveAtlasOnlyMaterial(
     ],
     values: {
       colorTint: [1.0, 1.0, 1.0, 1.0],
-      baseColorTexture: materialTextureValue(atlasHandle),
+      baseColorTexture: atlasHandle,
       region: [0.0, 0.0, 1.0, 1.0],
       pivotAndSize: [0.5, 0.5, 1.0, 1.0],
       flipY: 1.0,
@@ -419,9 +414,8 @@ function resolveAtlasOnlyMaterial(
     'MaterialAsset',
     matPayload,
   );
-  const id = unwrapHandle(matHandle);
-  cache.set(cacheKey, id);
-  return id;
+  cache.set(cacheKey, matHandle);
+  return matHandle;
 }
 
 /**
@@ -460,7 +454,7 @@ interface DerivedSpawnSpec {
   readonly cellY: number;
   readonly tileId: number;
   readonly packedTile: number;
-  readonly materialHandle: number;
+  readonly materialHandle: Handle<'MaterialAsset', 'shared'>;
   readonly chunkIndex: number;
   // M2: multi-cell footprint + custom pivot land per-tile via TilesetTileEntry.
   readonly widthCells: number;
@@ -512,7 +506,7 @@ function specFor(
   chunkSize: number,
   cellIndex: number,
   packedTile: number,
-  materialHandle: number,
+  materialHandle: Handle<'MaterialAsset', 'shared'>,
   entry: TilesetTileEntry,
   atlasIndex: number,
 ): DerivedSpawnSpec {
@@ -627,11 +621,11 @@ function spawnDerivedRenderEntities(
           scale: [scaleX, scaleY, 1],
         },
       },
-      { component: MeshFilter, data: { assetHandle: unitQuadHandle(world) } },
+      { component: MeshFilter, data: { assetHandle: HANDLE_QUAD } },
       {
         component: MeshRenderer,
         data: {
-          materials: [spec.materialHandle as unknown as Handle<'MaterialAsset', 'shared'>],
+          materials: [spec.materialHandle],
         },
       },
       { component: Layer, data: { value: layerValue } },
@@ -654,7 +648,7 @@ function spawnDerivedRenderEntities(
  *
  * Layout:
  *   - Transform: identity (the per-instance mat4 carries world-space TRS).
- *   - MeshFilter: the World-owned unit-quad shared reference.
+ *   - MeshFilter: HANDLE_QUAD.
  *   - MeshRenderer: atlas-only sprite material (region placeholder; shader
  *     reads per-instance UV from SpriteInstances.regions under the
  *     PER_INSTANCE_REGION=true variant — selected at record stage).
@@ -678,21 +672,20 @@ function spawnSpriteInstancesGroup(
   layerOrder: number,
   chunkIndex: number,
   atlasIndex: number,
-  materialHandle: number,
+  materialHandle: Handle<'MaterialAsset', 'shared'>,
   cellSpecs: readonly DerivedSpawnSpec[],
 ): EntityHandle | undefined {
   if (cellSpecs.length === 0) return undefined;
   const N = cellSpecs.length;
   const transforms = new Float32Array(N * 16);
   const regions = new Float32Array(N * 4);
-  const tmpMat = new Float32Array(16) as unknown as Parameters<typeof mat4.compose>[0];
-  const tmpF = tmpMat as unknown as Float32Array;
+  const tmpMat = mat4.create();
   const tmpT: [number, number, number] = [0, 0, 0];
   const tmpR: [number, number, number, number] = [0, 0, 0, 1];
   const tmpS: [number, number, number] = [1, 1, 1];
 
   // Per-chunk frustum cull: entity Transform = chunk world center + chunk
-  // extents (scaleX/Y). The frustum culler reads the entity AABB (unit quad
+  // extents (scaleX/Y). The frustum culler reads the entity AABB (HANDLE_QUAD
   // local [-0.5, 0.5]² expanded by entity scale/pos) → world AABB exactly
   // covers the chunk footprint.
   //
@@ -744,10 +737,10 @@ function spawnSpriteInstancesGroup(
     const dst = i * 16;
     for (let c = 0; c < 4; c++) {
       const base = c * 4;
-      const w3 = tmpF[base + 3] as number;
-      transforms[dst + base + 0] = ((tmpF[base + 0] as number) - chunkCenterX * w3) * invSX;
-      transforms[dst + base + 1] = ((tmpF[base + 1] as number) - chunkCenterY * w3) * invSY;
-      transforms[dst + base + 2] = tmpF[base + 2] as number;
+      const w3 = tmpMat[base + 3] ?? 0;
+      transforms[dst + base + 0] = ((tmpMat[base + 0] ?? 0) - chunkCenterX * w3) * invSX;
+      transforms[dst + base + 1] = ((tmpMat[base + 1] ?? 0) - chunkCenterY * w3) * invSY;
+      transforms[dst + base + 2] = tmpMat[base + 2] ?? 0;
       transforms[dst + base + 3] = w3;
     }
 
@@ -779,11 +772,11 @@ function spawnSpriteInstancesGroup(
           scale: [chunkScaleX, chunkScaleY, 1],
         },
       },
-      { component: MeshFilter, data: { assetHandle: unitQuadHandle(world) } },
+      { component: MeshFilter, data: { assetHandle: HANDLE_QUAD } },
       {
         component: MeshRenderer,
         data: {
-          materials: [materialHandle as unknown as Handle<'MaterialAsset', 'shared'>],
+          materials: [materialHandle],
         },
       },
       { component: SpriteInstances, data: { transforms, regions } },
@@ -890,18 +883,8 @@ function buildCameraFrustumPlanes(world: World): frustum.Frustum | null {
     const trRes = world.get(camEntity, Transform);
     if (!camRes.ok || !trRes.ok) continue;
 
-    const cam = camRes.value as unknown as {
-      near: number;
-      far: number;
-      projection: number;
-      left: number;
-      right: number;
-      bottom: number;
-      top: number;
-      fov: number;
-      aspect: number;
-    };
-    const tr = trRes.value as unknown as { world: Float32Array };
+    const cam = camRes.value;
+    const tr = trRes.value;
 
     const { near, far } = cam;
     if (near >= far) continue;
@@ -960,7 +943,7 @@ function buildCameraFrustumPlanes(world: World): frustum.Frustum | null {
  * §2 D-4). `bucketTileLayer` filters empty cells before the byChunk map
  * is built, so this branch should never trigger in production; the
  * sentinel is an explicit "no visible pixels" value that
- * `frustum.intersectsBox` rejects immediately, avoiding any silent NaN
+ * `frustum.intersectsBox` rejects immediately, avoiding a silent NaN
  * propagation path (charter P3 explicit failure).
  *
  * Note: `frustum.intersectsBox` picks a p-vertex per plane and computes
@@ -997,7 +980,7 @@ export function computeChunkStreamBounds(
     if (x1 > maxX) maxX = x1;
     if (y1 > maxY) maxY = y1;
   }
-  return [minX, minY, -1, maxX, maxY, 1] as unknown as box3.Box3Like;
+  return [minX, minY, -1, maxX, maxY, 1];
 }
 
 /**
@@ -1074,7 +1057,7 @@ function evictDeadPerCellStreamingCaches(work: readonly LayerWork[], world: Worl
   const cache = streamingCache(world);
   const aliveLayerKeys = new Set<string>();
   for (const w of work) {
-    aliveLayerKeys.add(String(unwrapHandle(w.layerEntity as unknown as Handle<string, 'shared'>)));
+    aliveLayerKeys.add(String(w.layerEntity));
   }
   const deadLayerKeys = new Set<string>();
   for (const layerKey of cache.activeChunks.keys()) {
@@ -1144,7 +1127,7 @@ export function tilemapChunkExtractSystem(
   for (const w of work) {
     // The outer WeakMap owns World identity; this generation-bearing packed
     // entity handle prevents aliasing when an ECS slot is reused.
-    const layerKey = String(unwrapHandle(w.layerEntity as unknown as Handle<string, 'shared'>));
+    const layerKey = String(w.layerEntity);
     // AC-04: decode via the canonical SortScope union; avoid relying on the
     // raw encoding (0='layer', 1='per-cell') leaking through this call site.
     // `decodeSortScope` is the SSOT used throughout `bucketTileLayer` (see
@@ -1277,7 +1260,7 @@ export function tilemapChunkExtractSystem(
 
       if (visible && !wasActive) {
         // Spawn per-cell entities for this newly-visible chunk.
-        const spawned: number[] = [];
+        const spawned: EntityHandle[] = [];
         for (const spec of specs) {
           const e = spawnDerivedRenderEntities(
             world,
@@ -1288,7 +1271,7 @@ export function tilemapChunkExtractSystem(
             spec.packedTile,
             cache.sortScope,
           );
-          spawned.push(unwrapHandle(e as unknown as Handle<string, 'shared'>));
+          spawned.push(e);
         }
         streaming.chunkEntities.set(`${layerKey}:${chunkIdx}`, spawned);
         activeSet.add(chunkIdx);
@@ -1297,7 +1280,7 @@ export function tilemapChunkExtractSystem(
         const key = `${layerKey}:${chunkIdx}`;
         const entities = streaming.chunkEntities.get(key);
         if (entities !== undefined) {
-          for (const e of entities) world.despawn(e as EntityHandle);
+          for (const e of entities) world.despawn(e);
           streaming.chunkEntities.delete(key);
         }
         activeSet.delete(chunkIdx);

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

@@ -13,26 +13,27 @@ import {
   GPU_TEXTURE_USAGE_RENDER_ATTACHMENT,
   GPU_TEXTURE_USAGE_TEXTURE_BINDING,
 } from './gpu-texture-usage';
+import { buildPerFrameBindGroups } from './record/frame-lighting';
+import { encodeMainPass } from './record/main-pass';
+import type {
+  _InternalRenderPipelineContext,
+  RenderSystemInternals,
+} from './record/render-context';
 import {
-  encodeMainPass,
   encodeSkyboxPass,
   recordBloomBlurHPass,
   recordBloomBlurVPass,
   recordBloomBrightPass,
   recordBloomCompositePass,
-} from './record';
-import { buildPerFrameBindGroups } from './record/frame-lighting';
+} from './record/skybox-post-pass';
+import { STANDARD_TONEMAP_FEATURE_ID } from './render-contract';
 import {
   encodeFullscreenPass,
   recordSsaoBlurPass,
   recordSsaoCalcPass,
-  TONEMAP_POST_PROCESS_ID,
 } from './render-graph-primitives';
 import type { RenderPipelineFrame, RenderPipelineGpuDrivenProjection } from './render-pipeline';
-import type { _InternalRenderPipelineContext } from './render-pipeline-context';
-import { createRenderPipelineTarget, type RenderPipelineTarget } from './render-pipeline-target';
-import type { RenderSystemInternals } from './render-system';
-import type { ResolvedSsaoParameters } from './ssao-config';
+import { createRenderPipelineTarget, type RenderPipelineTarget } from './render-pipeline';
 
 function resolvedView(resources: GraphResourceResolver, view: GraphTextureView): TextureView {
   const result = resources.textureView(view);
@@ -180,14 +181,14 @@ export function addTypedScenePass(
           : resolvedView(resources, options.spotShadow.view);
       const ssao =
         options.ssao === undefined ? undefined : resolvedView(resources, options.ssao.view);
-      frame.frameState.currentDirectionalShadowView = directionalShadow ?? null;
-      frame.frameState.currentSpotShadowView = spotShadow ?? null;
+      internal.frameState.currentDirectionalShadowView = directionalShadow ?? null;
+      internal.frameState.currentSpotShadowView = spotShadow ?? null;
       const groups = buildPerFrameBindGroups(
-        frame.runtime as RenderSystemInternals,
-        frame.frameState,
-        frame.pipelineState,
-        frame.validated.length > 0 || options.gpuDriven !== undefined,
-        frame.bindGroupCounts,
+        internal.runtime as RenderSystemInternals,
+        internal.frameState,
+        internal.pipelineState,
+        internal.validated.length > 0 || options.gpuDriven !== undefined,
+        internal.bindGroupCounts,
         { directionalShadow, spotShadow },
       );
       if (groups.viewBindGroup !== null) {
@@ -224,14 +225,15 @@ export function addTypedScenePass(
 export function addTypedFrameObservationPass(
   graph: RenderGraphBuilder<RenderPipelineFrame>,
   target: RenderPipelineTarget,
-  pipelineId: 'forgeax::urp' | 'forgeax::hdrp',
+  pipelineId: 'forgeax::standard',
 ): Result<void, RenderGraphError> {
   return graph.addCopyPass('linear-hdr-observation', {
     accesses: [{ resource: target.view, usage: 'copy-src' }],
     encode: ({ frame, resources }) => {
+      const internal = frame as _InternalRenderPipelineContext;
       const texture = resources.texture(target.texture);
       if (!texture.ok) throw texture.error;
-      frame.frameState.currentFrameObservationSource = {
+      internal.frameState.currentFrameObservationSource = {
         texture: texture.value,
         descriptor: {
           texture: texture.value,
@@ -243,7 +245,7 @@ export function addTypedFrameObservationPass(
             GPU_TEXTURE_USAGE_TEXTURE_BINDING,
           sample: target.sampleCount,
         },
-        frameId: frame.frameState.frameNumber,
+        frameId: internal.frameState.frameNumber,
         pipelineId,
         backendId: frame.runtime.device.caps.backendKind,
       };
@@ -330,7 +332,6 @@ export interface TypedSsaoTargets {
   readonly depth: RenderPipelineTarget;
   readonly raw: RenderPipelineTarget;
   readonly blurred: RenderPipelineTarget;
-  readonly parameters: ResolvedSsaoParameters;
 }
 
 export function addTypedSsaoPasses(
@@ -367,7 +368,6 @@ export function addTypedSsaoPasses(
           depth: resolvedDepthView(frame, resources, targets.depth),
           depthCacheKey,
         },
-        targets.parameters,
       );
     },
   });
@@ -475,21 +475,31 @@ export function addTypedCompositePostEffects(
   depth: RenderPipelineTarget,
   size: { readonly width: number; readonly height: number },
 ): Result<void, RenderGraphError> {
+  let currentInput = input;
   for (let index = 0; index < effects.length; index += 1) {
     const shader = effects[index];
     if (shader === undefined) continue;
+    const effectInput = currentInput;
     const scratch = createRenderPipelineTarget(graph, `post-effect-scratch-${index}`, {
       format: output.format as GPUTextureFormat,
       size: 'surface',
     });
     if (!scratch.ok) return scratch;
+    const effectOutput =
+      index === effects.length - 1
+        ? ok(output)
+        : createRenderPipelineTarget(graph, `post-effect-output-${index}`, {
+            format: output.format as GPUTextureFormat,
+            size: 'surface',
+          });
+    if (!effectOutput.ok) return effectOutput;
     const copied = graph.addCopyPass(`post-effect-copy-${index}`, {
       accesses: [
-        { resource: input.view, usage: 'copy-src' },
+        { resource: effectInput.view, usage: 'copy-src' },
         { resource: scratch.value.view, usage: 'copy-dst' },
       ],
       encode: ({ encoder, resources }) => {
-        const source = resources.texture(input.texture);
+        const source = resources.texture(effectInput.texture);
         if (!source.ok) throw source.error;
         const destination = resources.texture(scratch.value.texture);
         if (!destination.ok) throw destination.error;
@@ -505,10 +515,11 @@ export function addTypedCompositePostEffects(
       name: `post-effect-${index}`,
       shader,
       input: scratch.value,
-      output,
+      output: effectOutput.value,
       depth,
     });
     if (!effect.ok) return effect;
+    currentInput = effectOutput.value;
   }
   return ok(undefined);
 }
@@ -521,7 +532,7 @@ export function addTypedTonemapPass(
 ): Result<void, RenderGraphError> {
   return addTypedFullscreenPass(graph, {
     name: outputOnly ? 'output' : 'tonemap',
-    shader: TONEMAP_POST_PROCESS_ID,
+    shader: STANDARD_TONEMAP_FEATURE_ID,
     input,
     output,
     outputOnly,

package/src/typed-shadow-passes.ts

@@ -1,23 +1,15 @@
 import type { RenderGraphBuilder, RenderGraphError } from '@forgeax/engine-render-graph';
 import { ok, type Result } from '@forgeax/engine-types';
 import { PointShadowAtlasUninitializedError } from './errors/render';
-import {
-  directionalCascadeAtlasSize,
-  directionalCascadeRasterViewport,
-} from './extract/directional-csm';
 import { GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING } from './gpu-texture-usage';
+import type { _InternalRenderPipelineContext } from './record/render-context';
 import {
   encodeDirectionalShadowPass,
   encodePointShadowPass,
   encodeSpotShadowPass,
 } from './record/shadow-pass';
-import type {
-  RenderPipelineFrame,
-  RenderPipelineGpuDrivenShadowProjection,
-  RenderPipelineTopology,
-} from './render-pipeline';
-import type { _InternalRenderPipelineContext } from './render-pipeline-context';
-import { createRenderPipelineTarget, type RenderPipelineTarget } from './render-pipeline-target';
+import type { RenderPipelineFrame, RenderPipelineTopology } from './render-pipeline';
+import { createRenderPipelineTarget, type RenderPipelineTarget } from './render-pipeline';
 
 export interface TypedShadowTargets {
   readonly directional: RenderPipelineTarget;
@@ -25,17 +17,16 @@ export interface TypedShadowTargets {
   readonly point?: RenderPipelineTarget | undefined;
 }
 
-function addShadowPass(
+function recordShadowPass(
   graph: RenderGraphBuilder<RenderPipelineFrame>,
   name: string,
   target: RenderPipelineTarget,
   loadOp: 'clear' | 'load',
   encode: Parameters<RenderGraphBuilder<RenderPipelineFrame>['addRasterPass']>[1]['encode'],
   executeIf?: (frame: RenderPipelineFrame) => boolean,
-  extraAccesses: readonly import('@forgeax/engine-render-graph').GraphAccess[] = [],
 ): Result<void, RenderGraphError> {
   return graph.addRasterPass(name, {
-    accesses: [{ resource: target.view, usage: 'depth-stencil-write' }, ...extraAccesses],
+    accesses: [{ resource: target.view, usage: 'depth-stencil-write' }],
     colorAttachments: [],
     depthStencilAttachment: {
       view: target.view,
@@ -51,64 +42,42 @@ function addShadowPass(
 export function addTypedShadowPasses(
   graph: RenderGraphBuilder<RenderPipelineFrame>,
   topology: RenderPipelineTopology,
-  gpuDrivenShadow: readonly RenderPipelineGpuDrivenShadowProjection[] = [],
 ): Result<TypedShadowTargets, RenderGraphError> {
-  const rasterViewports = Array.from({ length: topology.shadow.cascadeCount }, (_, cascade) =>
-    directionalCascadeRasterViewport(
-      cascade,
-      topology.shadow.cascadeCount,
-      topology.shadow.mapSize,
-    ),
-  );
-  const atlasSize = directionalCascadeAtlasSize(
-    topology.shadow.cascadeCount,
-    topology.shadow.mapSize,
-  );
+  const tilesPerSide = Math.ceil(Math.sqrt(topology.shadow.cascadeCount));
   const directional = createRenderPipelineTarget(graph, 'directional-shadow-depth', {
     format: 'depth32float',
-    size: atlasSize,
+    size: {
+      width: topology.shadow.mapSize * tilesPerSide,
+      height: topology.shadow.mapSize * tilesPerSide,
+    },
   });
   if (!directional.ok) return directional;
-  const resetDirectionalAtlas = addShadowPass(
-    graph,
-    'directional-shadow-reset',
-    directional.value,
-    'clear',
-    () => {},
-    // Keep a stable, inspectable topology name for capture/debug consumers.
-    // The independent legacy shadow encoder owns the cache-aware atlas clear;
-    // opening this declarative graph pass would add a second depth pass.
-    () => false,
-  );
-  if (!resetDirectionalAtlas.ok) return resetDirectionalAtlas;
   for (let cascade = 0; cascade < topology.shadow.cascadeCount; cascade += 1) {
-    const rasterViewport = rasterViewports[cascade];
-    if (rasterViewport === undefined) throw new RangeError('directional cascade viewport missing');
-    const gpuShadow = gpuDrivenShadow.find((candidate) => candidate.cascadeIndex === cascade);
-    const added = addShadowPass(
+    const col = cascade % tilesPerSide;
+    const row = Math.floor(cascade / tilesPerSide);
+    const added = recordShadowPass(
       graph,
       `shadowCascade${cascade}`,
       directional.value,
       cascade === 0 ? 'clear' : 'load',
-      ({ pass, frame, resources }) =>
-        encodeDirectionalShadowPass(
-          frame as never,
-          pass,
-          cascade,
-          rasterViewport,
-          gpuShadow === undefined ? undefined : { projection: gpuShadow, resources },
-        ),
+      ({ 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,
-      gpuShadow?.accesses,
     );
     if (!added.ok) return added;
   }
   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;
-      frame.pipelineState.perPassResources.shadowTexture = texture.value;
+      internal.pipelineState.perPassResources.shadowTexture = texture.value;
     },
   });
   if (!observation.ok) return observation;
@@ -127,7 +96,8 @@ export function addTypedShadowPasses(
         usage: GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING,
       },
       (frame) => {
-        const atlas = frame.frameState.pointShadowAtlas?.getTexture();
+        const internal = frame as _InternalRenderPipelineContext;
+        const atlas = internal.frameState.pointShadowAtlas?.getTexture();
         if (atlas === null || atlas === undefined) {
           throw new PointShadowAtlasUninitializedError();
         }
@@ -158,7 +128,7 @@ export function addTypedShadowPasses(
           arrayLayerCount: 1,
         });
         if (!faceView.ok) return faceView;
-        const added = addShadowPass(
+        const added = recordShadowPass(
           graph,
           `point-shadow-${pointIndex}-${face}`,
           {
@@ -181,7 +151,7 @@ export function addTypedShadowPasses(
   });
   if (!spot.ok) return spot;
   for (let spotIndex = 0; spotIndex < Math.max(1, topology.shadow.spotCount); spotIndex += 1) {
-    const added = addShadowPass(
+    const added = recordShadowPass(
       graph,
       topology.shadow.spotCount === 0 ? 'spot-shadow' : `spot-shadow-${spotIndex}`,
       spot.value,

package/dist/__tests__/analytic-sky-contract.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=analytic-sky-contract.test.d.ts.map

package/dist/__tests__/analytic-sky-contract.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"analytic-sky-contract.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/analytic-sky-contract.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/analytic-sky-falsify.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=analytic-sky-falsify.test.d.ts.map

package/dist/__tests__/analytic-sky-falsify.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"analytic-sky-falsify.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/analytic-sky-falsify.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/assets-runtime-handoff.integration.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=assets-runtime-handoff.integration.test.d.ts.map