@zephyr3d/scene 0.9.21 → 0.9.23

package/dist/render/rendergraph/forward_plus_builder.js

@@ -1,4 +1,4 @@
-import { Vector4 } from '@zephyr3d/base';
+import { REVERSE_Z, Vector4, DEPTH_CLEAR_VALUE, DEPTH_COMPARE_DEFAULT } from '@zephyr3d/base';
 import { RenderQueue } from '../render_queue.js';
 import { LightPass } from '../lightpass.js';
 import { ShadowMapPass } from '../shadowmap_pass.js';
@@ -11,13 +11,18 @@ import '@zephyr3d/device';
 import { CopyBlitter } from '../../blitter/copy.js';
 import { fetchSampler } from '../../utility/misc.js';
 import { MaterialVaryingFlags } from '../../values.js';
+import { ShaderHelper } from '../../material/shader/helper.js';
 import { PostEffectLayer, AbstractPostEffect } from '../../posteffect/posteffect.js';
 import { RenderGraph } from './rendergraph.js';
 import { RenderGraphExecutor } from './executor.js';
+import { RGTextureAffinityCache } from './texture_affinity_cache.js';
 import { DevicePoolAllocator } from './device_pool_allocator.js';
 import { HistoryResourceManager } from './history_resource_manager.js';
 import { RGHistoryResources } from './history_resources.js';
 import { FrameResources, RGBlackboard } from './blackboard.js';
+import { OrderingScope } from './render_context.js';
+import { RenderPipeline } from './render_pipeline.js';
+import { mergeFrameResourceRequirements } from './frame_resource_requirements.js';
 import { renderObjectColors } from '../gpu_picking.js';
 import { BoxShape } from '../../shapes/box.js';
 import '../../shapes/capsule.js';
@@ -27,16 +32,28 @@ import '../../shapes/plane.js';
 import '../../shapes/sphere.js';
 import '../../shapes/tetrahedron.js';
 
-// ─── Shared Pass Instances ──────────────────────────────────────────
 const _scenePass = new LightPass();
 const _depthPass = new DepthPass();
 const _shadowMapPass = new ShadowMapPass();
 const _clusters = [];
 const _shadowMaskRenderer = new ShadowMaskRenderer();
 const _devicePoolAllocator = new DevicePoolAllocator();
+const _textureAffinityCaches = new WeakMap();
+function getTextureAffinityCache(camera, device) {
+    const current = _textureAffinityCaches.get(camera);
+    if (current?.device === device) {
+        return current.cache;
+    }
+    const cache = new RGTextureAffinityCache();
+    _textureAffinityCaches.set(camera, {
+        device,
+        cache
+    });
+    return cache;
+}
 let _backDepthColorState = null;
 let _frontDepthColorState = null;
-const SURFACE_MRT_FLAGS = MaterialVaryingFlags.SSR_STORE_ROUGHNESS | MaterialVaryingFlags.SSS_STORE_PROFILE | MaterialVaryingFlags.SSS_STORE_DIFFUSE | MaterialVaryingFlags.SSS_STORE_NORMAL | MaterialVaryingFlags.SSS_STORE_TRANSMISSION | MaterialVaryingFlags.SKIN_SSS_STORE;
+const SURFACE_MRT_FLAGS = MaterialVaryingFlags.SCENE_STORE_ROUGHNESS | MaterialVaryingFlags.SSS_STORE_PROFILE | MaterialVaryingFlags.SSS_STORE_DIFFUSE | MaterialVaryingFlags.SCENE_STORE_NORMAL | MaterialVaryingFlags.SSS_STORE_TRANSMISSION | MaterialVaryingFlags.SKIN_SSS_STORE;
 function getClusteredLight() {
     return _clusters.length > 0 ? _clusters.pop() : new ClusteredLight();
 }
@@ -164,23 +181,26 @@ function getSurfaceTextureFormat(ctx) {
 function getTextureFormatBytes(ctx, format) {
     return ctx.device.getDeviceCaps().textureCaps.getTextureFormatInfo(format).size;
 }
+function supportsSSGIRenderTargets(ctx) {
+    const caps = ctx.device.getDeviceCaps();
+    const rgba16fBytes = caps.textureCaps.getTextureFormatInfo('rgba16f').size;
+    return !!(caps.textureCaps.supportHalfFloatColorBuffer && caps.framebufferCaps.maxDrawBuffers >= 2 && caps.framebufferCaps.maxColorAttachmentBytesPerSample >= rgba16fBytes * 2);
+}
 function shouldStoreSSSDiffuse(ctx) {
     return ctx.camera.sssStrength > 0 && ctx.camera.sssBlurScale > 0;
 }
 function shouldStoreSSSTransmission(ctx) {
     return ctx.camera.sssStrength > 0 && ctx.camera.sssTransmissionStrength > 0;
 }
-function getSSSLightingTextureFormat(ctx, attachmentCount, includeSSRSurfaceMRT) {
+function getSSSLightingTextureFormat(ctx, attachmentCount, surfaceAttachmentCount) {
     const colorFormat = ctx.colorFormat;
-    if (!includeSSRSurfaceMRT || attachmentCount === 0) {
+    if (surfaceAttachmentCount === 0 || attachmentCount === 0) {
         return colorFormat;
     }
     const caps = ctx.device.getDeviceCaps();
-    // The SSR roughness/normal MRT textures use the glossy surface format; they
-    // are graph textures now, so derive the format directly instead of reading
-    // the (not yet resolved) DrawContext fields.
+    // MRT graph textures are not resolved on DrawContext yet.
     const surfaceFormat = getSurfaceTextureFormat(ctx);
-    const colorBytes = getTextureFormatBytes(ctx, colorFormat) + getTextureFormatBytes(ctx, surfaceFormat) + getTextureFormatBytes(ctx, surfaceFormat);
+    const colorBytes = getTextureFormatBytes(ctx, colorFormat) + getTextureFormatBytes(ctx, surfaceFormat) * surfaceAttachmentCount;
     const fullPrecisionBytes = colorBytes + getTextureFormatBytes(ctx, colorFormat) * attachmentCount;
     if (fullPrecisionBytes <= caps.framebufferCaps.maxColorAttachmentBytesPerSample) {
         return colorFormat;
@@ -197,10 +217,11 @@ function getLightPassColorAttachments(ctx, colorAttachment) {
     const attachments = [
         colorAttachment
     ];
-    if (ctx.materialFlags & MaterialVaryingFlags.SSR_STORE_ROUGHNESS) {
-        attachments.push(ctx.SSRRoughnessTexture, ctx.SSRNormalTexture);
-    } else if (ctx.materialFlags & MaterialVaryingFlags.SSS_STORE_NORMAL) {
-        attachments.push(ctx.SSRNormalTexture);
+    if (ctx.materialFlags & MaterialVaryingFlags.SCENE_STORE_ROUGHNESS) {
+        attachments.push(ctx.SceneRoughnessTexture);
+    }
+    if (ctx.materialFlags & MaterialVaryingFlags.SCENE_STORE_NORMAL) {
+        attachments.push(ctx.SceneNormalTexture);
     }
     if (ctx.materialFlags & MaterialVaryingFlags.SSS_STORE_PROFILE) {
         attachments.push(ctx.SSSProfileTexture, ctx.SSSParamTexture);
@@ -216,89 +237,143 @@ function getLightPassColorAttachments(ctx, colorAttachment) {
     }
     return attachments.length === 1 ? attachments[0] : attachments;
 }
-/**
- * Derive pipeline options from the current scene/camera state.
- * @internal
- */ function deriveForwardPlusOptions(scene, camera, deviceType, renderQueue) {
+/** Derive Forward+ options from scene and camera state. @internal */ function deriveForwardPlusOptions(scene, camera, deviceType, renderQueue) {
     const ssr = camera.SSR && scene.env.light.envLight && scene.env.light.envLight.hasRadiance();
+    const ssgi = camera.SSGI && camera.HDR && camera.ssgiIntensity > 0 && scene.env.light.type === 'ibl' && !!scene.env.light.envLight?.hasRadiance() && !!scene.env.light.envLight?.hasIrradiance();
     const sss = camera.SSS && renderQueueHasActiveSSS(renderQueue);
     const skinSSS = camera.skinSSS && renderQueueHasActiveSkinSSS(renderQueue);
     const needSceneColor = renderQueue.needSceneColor();
     const needSceneColorWithDepth = renderQueue.needSceneColorWithDepth();
     return {
         depthPrepass: true,
-        motionVectors: deviceType !== 'webgl' && (camera.TAA || camera.motionBlur || !!ssr && camera.ssrTemporal),
-        hiZ: camera.HiZ && deviceType !== 'webgl',
+        motionVectors: false,
+        hiZ: false,
+        sceneNormal: false,
+        sceneRoughness: false,
+        shadowMask: false,
         ssr: !!ssr,
+        ssgi: !!ssgi,
         ssrCalcThickness: !!ssr && camera.ssrCalcThickness,
         gpuPicking: !!camera.getPickResultResolveFunc(),
         needSceneColor,
         needSceneColorWithDepth,
         needsTransmissionDepthForSSR: !!ssr && needSceneColor && !needSceneColorWithDepth,
         sss: !!sss,
-        skinSSS: !!skinSSS
+        skinSSS: !!skinSSS,
+        fogPresents: !!scene.env.sky?.fogPresents
     };
 }
-// ─── Forward+ Graph Builder ─────────────────────────────────────────
-/**
- * Constructs a render graph representing the forward+ pipeline.
- *
- * Each step in the existing `SceneRenderer._renderScene` becomes a graph pass.
- * Execute callbacks delegate to the existing rendering code, sharing a mutable
- * `FrameState`.
- *
- * @param graph - The render graph to populate.
- * @param ctx - The draw context for this frame.
- * @param renderQueue - The culled render queue.
- * @param options - Pipeline feature toggles.
- * @returns The backbuffer handle (graph output).
- *
- * @public
- */ function buildForwardPlusGraph(graph, ctx, renderQueue, options) {
-    return buildForwardPlusGraphInternal(graph, ctx, renderQueue, options).backbuffer;
+function resolveFrameResourceRequirements(ctx, options, requirements) {
+    const deviceType = ctx.device.type;
+    options.motionVectors ||= !!requirements.motionVector;
+    options.hiZ ||= !!requirements.hiZ;
+    options.sceneNormal ||= !!requirements.sceneNormal;
+    options.sceneRoughness ||= !!requirements.sceneRoughness;
+    options.shadowMask ||= !!requirements.shadowMask;
+    if (options.motionVectors && deviceType === 'webgl') {
+        throw new Error('Forward+: MotionVector was requested but is not supported by the WebGL backend.');
+    }
+    if (options.hiZ && deviceType === 'webgl') {
+        throw new Error('Forward+: HiZ was requested but is not supported by the WebGL backend.');
+    }
+    if (options.shadowMask && deviceType === 'webgl') {
+        throw new Error('Forward+: ShadowMask was requested but is not supported by the WebGL backend.');
+    }
+    const surfaceAttachmentCount = Number(options.sceneNormal) + Number(options.sceneRoughness);
+    if (surfaceAttachmentCount > 0) {
+        const caps = ctx.device.getDeviceCaps();
+        const maxDrawBuffers = caps.framebufferCaps.maxDrawBuffers ?? Number.MAX_SAFE_INTEGER;
+        if (1 + surfaceAttachmentCount > maxDrawBuffers) {
+            throw new Error(`Forward+: ${surfaceAttachmentCount} scene surface attachment(s) were requested, ` + `but the device supports only ${maxDrawBuffers} color attachments.`);
+        }
+        const bytesPerSample = getTextureFormatBytes(ctx, ctx.colorFormat) + getTextureFormatBytes(ctx, getSurfaceTextureFormat(ctx)) * surfaceAttachmentCount;
+        if (bytesPerSample > caps.framebufferCaps.maxColorAttachmentBytesPerSample) {
+            throw new Error(`Forward+: requested scene surface attachments require ${bytesPerSample} bytes per sample, ` + `but the device limit is ${caps.framebufferCaps.maxColorAttachmentBytesPerSample}.`);
+        }
+    }
+    ctx.motionVectors = options.motionVectors;
+    ctx.HiZ = options.hiZ;
+    ctx.SSGI = options.ssgi;
+    ctx.screenSpaceShadowMask = options.shadowMask;
+    ctx.SSS = options.sss;
 }
-function buildForwardPlusGraphInternal(graph, ctx, renderQueue, options) {
-    const backbuffer = graph.importTexture('backbuffer');
-    ctx.SSS = !!options.sss;
-    ctx.SkinSSSTexture = null;
-    // Named registry of shared frame resources (consumed by post effect setup)
-    const blackboard = new RGBlackboard();
-    // Shared mutable frame state
-    const frame = {
-        ctx,
-        renderQueue,
-        depthFramebuffer: null,
-        sunLightColor: null,
-        options,
-        renderQueueDisposed: false,
-        clusteredLightReleased: false,
-        sunLightRestored: false
-    };
-    // ── 1. Sky Update ─────────────────────────────────────────────────
-    let orderToken = graph.addPass('SkyUpdate', (builder)=>{
-        const done = builder.createToken('SkyUpdateDone');
-        builder.sideEffect();
-        builder.setExecute(()=>{
-            frame.sunLightColor = ctx.scene.env.sky.update(ctx);
+function validateProducedFrameResources(blackboard, options, renderQueue) {
+    const required = [
+        [
+            options.motionVectors,
+            FrameResources.MotionVector
+        ],
+        [
+            options.hiZ,
+            FrameResources.HiZ
+        ],
+        [
+            options.sceneNormal,
+            FrameResources.SceneNormal
+        ],
+        [
+            options.sceneRoughness,
+            FrameResources.SceneRoughness
+        ],
+        [
+            options.shadowMask && renderQueue.shadowedLights.length > 0,
+            FrameResources.ShadowMask
+        ]
+    ];
+    for (const [needed, resource] of required){
+        if (needed && !blackboard.has(resource)) {
+            throw new Error(`Forward+: frame resource "${resource}" was requested but no enabled RenderModule produced it.`);
+        }
+    }
+}
+/** Require state produced by an earlier module. @internal */ function requireBuildState(fg, key, producerType, consumerType) {
+    const value = fg.state[key];
+    if (!value) {
+        throw new Error(`Forward+ module "${consumerType}" requires module "${producerType}" ` + `(build state "${String(key)}" was not produced). Did you remove it from the pipeline?`);
+    }
+    return value;
+}
+/** @internal */ const SkyUpdateModule = {
+    type: 'SkyUpdate',
+    prepare: ()=>({
+            enabled: true
+        }),
+    setup ({ graph, ctx, frame, ordering }) {
+        graph.addPass('SkyUpdate', (builder)=>{
+            ordering.emit(builder, 'SkyUpdateDone');
+            builder.sideEffect();
+            builder.setExecute(()=>{
+                frame.sunLightColor = ctx.scene.env.sky.update(ctx);
+            });
         });
-        return done;
-    });
-    // ── 2. Clustered Light Setup ──────────────────────────────────────
-    orderToken = graph.addPass('ClusterLights', (builder)=>{
-        builder.read(orderToken);
-        const done = builder.createToken('ClusterLightsDone');
-        builder.sideEffect();
-        builder.setExecute(()=>{
-            ctx.clusteredLight = getClusteredLight();
-            ctx.clusteredLight.calculateLightIndex(ctx.camera, renderQueue);
+    }
+};
+/** @internal */ const ClusterLightsModule = {
+    type: 'ClusterLights',
+    prepare: ()=>({
+            enabled: true
+        }),
+    setup ({ graph, ctx, renderQueue, ordering }) {
+        graph.addPass('ClusterLights', (builder)=>{
+            ordering.chainInto(builder);
+            ordering.emit(builder, 'ClusterLightsDone');
+            builder.sideEffect();
+            builder.setExecute(()=>{
+                ctx.clusteredLight = getClusteredLight();
+                ctx.clusteredLight.calculateLightIndex(ctx.camera, renderQueue, ctx.screenSpaceShadowMask, ShaderHelper.getPreExposure(ctx));
+            });
         });
-        return done;
-    });
-    // ── 3. GPU Picking (optional, sideEffect) ─────────────────────────
-    if (options.gpuPicking) {
-        orderToken = graph.addPass('GPUPicking', (builder)=>{
-            builder.read(orderToken);
-            const done = builder.createToken('GPUPickingDone');
+    }
+};
+/** @internal */ const GPUPickingModule = {
+    type: 'GPUPicking',
+    prepare: ({ options })=>({
+            enabled: options.gpuPicking
+        }),
+    setup ({ graph, ctx, renderQueue, ordering }) {
+        graph.addPass('GPUPicking', (builder)=>{
+            ordering.chainInto(builder);
+            ordering.emit(builder, 'GPUPickingDone');
             builder.sideEffect();
             builder.setExecute(()=>{
                 const pickResolveFunc = ctx.camera.getPickResultResolveFunc();
@@ -306,125 +381,140 @@ function buildForwardPlusGraphInternal(graph, ctx, renderQueue, options) {
                     renderObjectColors(ctx, pickResolveFunc, renderQueue);
                 }
             });
-            return done;
         });
     }
-    // ── 4. Shadow Maps ────────────────────────────────────────────────
-    // Shadow maps are managed internally by lights, mark as side effect
-    if (renderQueue.shadowedLights.length > 0) {
-        orderToken = graph.addPass('ShadowMaps', (builder)=>{
-            builder.read(orderToken);
-            const done = builder.createToken('ShadowMapsDone');
+};
+/** @internal */ const ShadowMapsModule = {
+    type: 'ShadowMaps',
+    // Light-owned shadow maps are observable side effects.
+    prepare: ({ renderQueue })=>({
+            enabled: renderQueue.shadowedLights.length > 0
+        }),
+    setup ({ graph, ctx, renderQueue, ordering }) {
+        graph.addPass('ShadowMaps', (builder)=>{
+            ordering.chainInto(builder);
+            ordering.emit(builder, 'ShadowMapsDone');
             builder.sideEffect();
             builder.setExecute(()=>{
                 renderShadowMaps(ctx, renderQueue.shadowedLights);
             });
-            return done;
         });
     }
-    // ── 5. Depth Prepass ──────────────────────────────────────────────
-    // Declare transient depth and motion vector textures
-    const depthPassResult = graph.addPass('DepthPrepass', (builder)=>{
-        builder.read(orderToken);
-        const format = ctx.device.type === 'webgl' ? ctx.SSRCalcThickness ? 'rgba16f' : 'rgba8unorm' : ctx.SSRCalcThickness ? 'rg32f' : 'r32f';
-        const mvFormat = 'rgba16f';
-        const depthHandle = builder.createTexture({
-            format,
-            label: 'linearDepth'
-        });
-        const motionVectorHandle = options.motionVectors ? builder.createTexture({
-            format: mvFormat,
-            label: 'motionVector'
-        }) : undefined;
-        const finalDepthAttachment = ctx.finalFramebuffer?.getDepthAttachment();
-        const externalDepthAttachment = finalDepthAttachment?.isTexture2D() ? finalDepthAttachment : null;
-        const graphDepthAttachmentHandle = externalDepthAttachment ? undefined : builder.createTexture({
-            format: ctx.depthFormat,
-            label: 'sceneDepth'
-        });
-        const depthAttachmentOrFormat = externalDepthAttachment ?? graphDepthAttachmentHandle ?? ctx.depthFormat;
-        const depthFramebufferHandle = builder.createFramebuffer({
-            label: 'DepthPrepassFramebuffer',
-            width: ctx.renderWidth,
-            height: ctx.renderHeight,
-            colorAttachments: motionVectorHandle ? [
+};
+/** @internal */ const DepthPrepassModule = {
+    type: 'DepthPrepass',
+    writes: [
+        FrameResources.LinearDepth,
+        FrameResources.MotionVector,
+        FrameResources.SceneDepthAttachment
+    ],
+    prepare: ()=>({
+            enabled: true
+        }),
+    setup (fg) {
+        const { graph, ctx, frame, ordering, blackboard, options } = fg;
+        const result = graph.addPass('DepthPrepass', (builder)=>{
+            ordering.chainInto(builder);
+            const format = ctx.device.type === 'webgl' ? ctx.SSRCalcThickness ? 'rgba16f' : 'rgba8unorm' : ctx.SSRCalcThickness ? 'rg32f' : 'r32f';
+            const mvFormat = 'rgba16f';
+            const depthHandle = builder.createTexture({
+                format,
+                label: 'linearDepth',
+                allocationKey: 'ForwardPlus.LinearDepth'
+            });
+            const motionVectorHandle = options.motionVectors ? builder.createTexture({
+                format: mvFormat,
+                label: 'motionVector',
+                allocationKey: 'ForwardPlus.MotionVector'
+            }) : undefined;
+            const finalDepthAttachment = ctx.finalFramebuffer?.getDepthAttachment();
+            const externalDepthAttachment = finalDepthAttachment?.isTexture2D() ? finalDepthAttachment : null;
+            const externalDepthAttachmentHandle = externalDepthAttachment ? graph.importTexture('externalSceneDepth') : undefined;
+            const graphDepthAttachmentHandle = externalDepthAttachment ? undefined : builder.createTexture({
+                format: ctx.depthFormat,
+                label: 'sceneDepth',
+                allocationKey: 'ForwardPlus.SceneDepth'
+            });
+            const depthAttachmentOrFormat = externalDepthAttachmentHandle ?? graphDepthAttachmentHandle ?? ctx.depthFormat;
+            const depthFramebufferHandle = builder.createFramebuffer({
+                label: 'DepthPrepassFramebuffer',
+                width: ctx.renderWidth,
+                height: ctx.renderHeight,
+                colorAttachments: motionVectorHandle ? [
+                    depthHandle,
+                    motionVectorHandle
+                ] : depthHandle,
+                depthAttachment: depthAttachmentOrFormat,
+                ignoreDepthStencil: false
+            });
+            const skyMotionVectorFramebufferHandle = motionVectorHandle ? builder.createFramebuffer({
+                label: 'SkyMotionVectorFramebuffer',
+                width: ctx.renderWidth,
+                height: ctx.renderHeight,
+                colorAttachments: motionVectorHandle,
+                depthAttachment: depthAttachmentOrFormat
+            }) : undefined;
+            builder.addSubpass('SceneDepth', (rgCtx)=>{
+                const depthFramebuffer = rgCtx.getFramebuffer(depthFramebufferHandle);
+                frame.depthFramebuffer = renderSceneDepth(frame, depthFramebuffer, rgCtx, undefined, undefined, false);
+            });
+            if (skyMotionVectorFramebufferHandle) {
+                builder.addSubpass('SkyMotionVectors', (rgCtx)=>{
+                    renderSkyMotionVectors(ctx, rgCtx, skyMotionVectorFramebufferHandle);
+                });
+            }
+            return {
                 depthHandle,
-                motionVectorHandle
-            ] : depthHandle,
-            depthAttachment: depthAttachmentOrFormat,
-            ignoreDepthStencil: false
-        });
-        const skyMotionVectorFramebufferHandle = motionVectorHandle ? builder.createFramebuffer({
-            label: 'SkyMotionVectorFramebuffer',
-            width: ctx.renderWidth,
-            height: ctx.renderHeight,
-            colorAttachments: motionVectorHandle,
-            depthAttachment: depthAttachmentOrFormat
-        }) : undefined;
-        builder.addSubpass('SceneDepth', (rgCtx)=>{
-            const depthFramebuffer = rgCtx.getFramebuffer(depthFramebufferHandle);
-            frame.depthFramebuffer = renderSceneDepth(frame, depthFramebuffer, rgCtx, undefined, undefined, false);
+                motionVectorHandle,
+                graphDepthAttachmentHandle,
+                externalDepthAttachmentHandle,
+                externalDepthAttachment,
+                depthFramebufferHandle
+            };
         });
-        if (skyMotionVectorFramebufferHandle) {
-            builder.addSubpass('SkyMotionVectors', (rgCtx)=>{
-                renderSkyMotionVectors(ctx, rgCtx, skyMotionVectorFramebufferHandle);
-            });
+        fg.state.depth = result;
+        // Depth mutations re-register their versions through the blackboard.
+        blackboard.set(FrameResources.LinearDepth, result.depthHandle);
+        if (result.motionVectorHandle) {
+            blackboard.set(FrameResources.MotionVector, result.motionVectorHandle);
         }
-        return {
-            depthHandle,
-            motionVectorHandle,
-            graphDepthAttachmentHandle,
-            externalDepthAttachment,
-            depthFramebufferHandle
-        };
-    });
-    let depthHandle = depthPassResult.depthHandle;
-    const motionVectorHandle = depthPassResult.motionVectorHandle;
-    blackboard.set(FrameResources.LinearDepth, depthHandle);
-    if (motionVectorHandle) {
-        blackboard.set(FrameResources.MotionVector, motionVectorHandle);
-    }
-    if (depthPassResult.graphDepthAttachmentHandle) {
-        blackboard.set(FrameResources.SceneDepthAttachment, depthPassResult.graphDepthAttachmentHandle);
+        blackboard.set(FrameResources.SceneDepthAttachment, result.graphDepthAttachmentHandle ?? result.externalDepthAttachmentHandle);
+        // Later modules share this attachment without owning it.
+        fg.state.renderDepthAttachment = result.graphDepthAttachmentHandle ?? result.externalDepthAttachmentHandle ?? null;
+        // Opaque effects require a texture and may require surface MRT attachments.
+        const opaqueLayerHasEffects = !!ctx.compositor?.layerHasEnabledEffect(PostEffectLayer.opaque);
+        fg.state.useFinalFramebufferAsIntermediate = !!result.externalDepthAttachment && result.externalDepthAttachment === ctx.finalFramebuffer?.getDepthAttachment() && !opaqueLayerHasEffects;
     }
-    // ── Screen-space shadow mask ────────────────────────────────────────────
-    // When active, render each shadow-casting light's visibility into an RGBA8
-    // texture array (4 lights per layer). The clustered LightPass samples this
-    // mask instead of each shadowed light running its own additive pass. The
-    // layer/channel order is locked to ClusteredLight.getVisibleLights: shadow
-    // lights fill clustered buffer indices 1..N in renderQueue.shadowedLights
-    // order, and ordinal s = index-1 maps to layer s>>2, channel s&3.
-    let shadowMaskHandle = null;
-    // Reset any mask carried over from a previous frame; the pass below re-sets it
-    // during execution only when the mask is actually produced.
-    ctx.shadowMaskTexture = null;
-    // Gate on build-time state only: renderQueue.shadowedLights is available now,
-    // whereas ctx.shadowMapInfo is populated later by the ShadowMaps pass execute
-    // (which runs before this pass thanks to the orderToken chain), so it must not
-    // be part of the pass-creation condition.
-    const useShadowMask = ctx.screenSpaceShadowMask && renderQueue.shadowedLights.length > 0;
-    if (useShadowMask) {
+};
+/** @internal */ const ShadowMaskModule = {
+    type: 'ShadowMaskPass',
+    writes: [
+        FrameResources.ShadowMask
+    ],
+    // shadowMapInfo is populated at execute time and cannot gate graph building.
+    prepare: ({ ctx, options, renderQueue })=>({
+            enabled: options.shadowMask && renderQueue.shadowedLights.length > 0,
+            requirements: {
+                shadowMask: ctx.device.type !== 'webgl' && ctx.camera.screenSpaceShadowMask && renderQueue.shadowedLights.length > 0
+            }
+        }),
+    setup (fg) {
+        // Four shadow lights share each RGBA8 layer in clustered-light order.
+        const { graph, ctx, renderQueue, blackboard } = fg;
+        const depthPassResult = requireBuildState(fg, 'depth', 'DepthPrepass', 'ShadowMaskPass');
         const numShadowLights = renderQueue.shadowedLights.length;
         const numLayers = ShadowMaskRenderer.getLayerCount(numShadowLights);
         const maskPassResult = graph.addPass('ShadowMaskPass', (builder)=>{
-            // Freeze the current linear-depth handle at build time. `depthHandle` is a
-            // mutable `let` that a later TransmissionDepth pass reassigns to a new
-            // version ('linearDepth@TransmissionDepth'); if the execute closure below
-            // captured it by reference it would read a handle this pass never declared,
-            // tripping RenderGraphExecutor's access assertion. The shadow mask is built
-            // from the opaque prepass depth, so the pre-transmission version is correct.
-            const maskDepthHandle = depthHandle;
+            // Capture the depth version declared at this pipeline position.
+            const maskDepthHandle = blackboard.expect(FrameResources.LinearDepth);
             builder.read(maskDepthHandle);
             builder.read(depthPassResult.depthFramebufferHandle);
-            // createTexture already registers this pass as the resource producer, so
-            // downstream passes read this handle directly (same pattern as HiZ). The
-            // per-layer framebuffers are created inside execute (rgCtx.createFramebuffer),
-            // which the graph cannot see; the createTexture producer edge is what keeps
-            // the resource alive and ordered before the LightPass reader.
+            // Per-layer framebuffers are temporary views of this graph texture.
             const maskHandle = builder.createTexture({
                 format: 'rgba8unorm',
                 label: 'shadowMask',
-                arrayLayers: numLayers
+                arrayLayers: numLayers,
+                allocationKey: 'ForwardPlus.ShadowMask'
             });
             builder.setExecute((rgCtx)=>{
                 const depthTex = rgCtx.getTexture(maskDepthHandle);
@@ -436,34 +526,31 @@ function buildForwardPlusGraphInternal(graph, ctx, renderQueue, options) {
                         depthAttachment: null,
                         attachmentLayer: layer
                     }));
-                ctx.shadowMaskTexture = maskTex;
             });
             return {
                 maskHandle
             };
         });
-        shadowMaskHandle = maskPassResult.maskHandle;
-        blackboard.set(FrameResources.ShadowMask, shadowMaskHandle);
+        blackboard.set(FrameResources.ShadowMask, maskPassResult.maskHandle);
     }
-    const renderDepthAttachment = depthPassResult.graphDepthAttachmentHandle ?? depthPassResult.externalDepthAttachment ?? null;
-    // Rendering the scene directly into the final framebuffer is only possible
-    // when no opaque-layer effect is enabled: those effects must sample the
-    // opaque scene color as a texture and may require surface MRT attachments
-    // (SSR roughness / SSS / SkinSSS), which the single-color final framebuffer
-    // cannot carry. The legacy compositor.begin() used to redirect rendering to
-    // a temporal MRT framebuffer in that case; the graph path uses the regular
-    // scene color texture pipeline instead.
-    const opaqueLayerHasEffects = !!ctx.compositor?.layerHasEnabledEffect(PostEffectLayer.opaque);
-    const useFinalFramebufferAsIntermediate = !!depthPassResult.externalDepthAttachment && depthPassResult.externalDepthAttachment === ctx.finalFramebuffer?.getDepthAttachment() && !opaqueLayerHasEffects;
-    let preLightTransmissionDepthToken;
-    if (options.needsTransmissionDepthForSSR) {
+};
+/** @internal */ const TransmissionDepthForSSRModule = {
+    type: 'TransmissionDepthForSSR',
+    writes: [
+        FrameResources.LinearDepth
+    ],
+    prepare: ({ options })=>({
+            enabled: options.needsTransmissionDepthForSSR
+        }),
+    setup (fg) {
+        const { graph, frame, blackboard } = fg;
+        const depthPassResult = requireBuildState(fg, 'depth', 'DepthPrepass', 'TransmissionDepthForSSR');
         const transmissionDepthResult = graph.addPass('TransmissionDepthForSSR', (builder)=>{
-            builder.read(depthHandle);
+            const currentDepth = blackboard.expect(FrameResources.LinearDepth);
+            builder.read(currentDepth);
             builder.read(depthPassResult.depthFramebufferHandle);
-            // This pass renders transmission geometry into the prepass linear-depth
-            // texture: model the mutation as a write so later readers order against
-            // it through data flow instead of relying on the token alone.
-            const depthOut = builder.write(depthHandle);
+            // Version the in-place depth mutation for downstream dependencies.
+            const depthOut = builder.write(currentDepth);
             const done = builder.createToken('TransmissionDepthForSSRDone');
             builder.sideEffect();
             builder.setExecute((rgCtx)=>{
@@ -474,24 +561,38 @@ function buildForwardPlusGraphInternal(graph, ctx, renderQueue, options) {
                 depthOut
             };
         });
-        preLightTransmissionDepthToken = transmissionDepthResult.done;
-        depthHandle = transmissionDepthResult.depthOut;
-        // Re-register so blackboard consumers read the post-transmission version.
-        blackboard.set(FrameResources.LinearDepth, depthHandle);
+        fg.state.preLightTransmissionDepthToken = transmissionDepthResult.done;
+        // Publish the post-transmission depth version.
+        blackboard.set(FrameResources.LinearDepth, transmissionDepthResult.depthOut);
     }
-    // ── 6. Hi-Z (optional) ───────────────────────────────────────────
-    let hiZHandle;
-    if (options.hiZ) {
+};
+/** @internal */ const HiZModule = {
+    type: 'HiZ',
+    writes: [
+        FrameResources.HiZ
+    ],
+    prepare: ({ options })=>({
+            enabled: options.hiZ
+        }),
+    setup (fg) {
+        const { graph, ctx, frame, blackboard } = fg;
+        const depthPassResult = requireBuildState(fg, 'depth', 'DepthPrepass', 'HiZ');
+        const preLightTransmissionDepthToken = fg.state.preLightTransmissionDepthToken;
+        //const hiZWidth = nextPowerOf2(ctx.renderWidth);
+        //const hiZHeight = nextPowerOf2(ctx.renderHeight);
+        let hiZHandle;
         graph.addPass('HiZ', (builder)=>{
-            builder.read(depthHandle);
+            builder.read(blackboard.expect(FrameResources.LinearDepth));
             builder.read(depthPassResult.depthFramebufferHandle);
             if (preLightTransmissionDepthToken) {
                 builder.read(preLightTransmissionDepthToken);
             }
             hiZHandle = builder.createTexture({
-                format: 'rg32f',
+                format: REVERSE_Z ? 'r16f' : 'r32f',
                 label: 'hiZ',
-                mipLevels: getFullMipLevelCount(ctx.renderWidth, ctx.renderHeight)
+                sizeMode: 'backbuffer-relative',
+                mipLevels: getFullMipLevelCount(ctx.renderWidth, ctx.renderHeight),
+                allocationKey: 'ForwardPlus.HiZ'
             });
             const hiZFramebufferHandle = builder.createFramebuffer({
                 label: 'HiZFramebuffer',
@@ -499,79 +600,55 @@ function buildForwardPlusGraphInternal(graph, ctx, renderQueue, options) {
                 depthAttachment: null
             });
             builder.setExecute((rgCtx)=>{
-                const ctx = frame.ctx;
-                // Use the depth texture from the framebuffer (which contains the RenderGraph texture)
-                const depthTex = frame.depthFramebuffer?.getDepthAttachment();
-                if (depthTex) {
-                    // Get the HiZ texture allocated by the executor
-                    const hiZTex = rgCtx.getTexture(hiZHandle);
-                    const HiZFrameBuffer = rgCtx.getFramebuffer(hiZFramebufferHandle);
-                    buildHiZ(depthTex, HiZFrameBuffer);
-                    ctx.HiZTexture = hiZTex;
+                const passCtx = frame.ctx;
+                // Resolve the declared handle, not mutable framebuffer state.
+                const depthFb = rgCtx.getFramebuffer(depthPassResult.depthFramebufferHandle);
+                const depthTex = depthFb.getDepthAttachment();
+                if (!depthTex) {
+                    throw new Error('HiZ pass: depth prepass framebuffer has no depth attachment.');
                 }
+                const hiZTex = rgCtx.getTexture(hiZHandle);
+                const HiZFrameBuffer = rgCtx.getFramebuffer(hiZFramebufferHandle);
+                buildHiZ(depthTex, HiZFrameBuffer);
+                passCtx.HiZTexture = hiZTex;
             });
         });
         if (hiZHandle) {
             blackboard.set(FrameResources.HiZ, hiZHandle);
         }
     }
-    // ── 7. Main Light Pass ────────────────────────────────────────────
-    const historyManager = ctx.camera?.getHistoryResourceManager?.() ?? null;
-    const lightHistoryReadBindings = [];
-    const historySize = {
-        width: ctx.renderWidth,
-        height: ctx.renderHeight
-    };
-    if (historyManager && options.ssr && ctx.camera?.ssrTemporal && options.motionVectors) {
-        const reflectHistoryHandle = historyManager.importPreviousIfCompatible(graph, RGHistoryResources.SSR_REFLECT, {
-            format: 'rgba16f',
-            sizeMode: 'absolute',
-            width: ctx.renderWidth,
-            height: ctx.renderHeight
-        }, historySize);
-        const motionVectorHistoryHandle = historyManager.importPreviousIfCompatible(graph, RGHistoryResources.SSR_MOTION_VECTOR, {
-            format: 'rgba16f',
-            sizeMode: 'absolute',
-            width: ctx.renderWidth,
-            height: ctx.renderHeight
-        }, historySize);
-        if (reflectHistoryHandle && motionVectorHistoryHandle) {
-            lightHistoryReadBindings.push({
-                name: RGHistoryResources.SSR_REFLECT,
-                handle: reflectHistoryHandle
-            }, {
-                name: RGHistoryResources.SSR_MOTION_VECTOR,
-                handle: motionVectorHistoryHandle
-            });
-        }
-    }
-    // Note: TAA history import/commit is handled by TAA.setup() (self-describing).
-    let sssProfileResult;
-    if (options.sss) {
-        sssProfileResult = graph.addPass('SSSProfile', (builder)=>{
-            builder.read(depthHandle);
+};
+/** @internal */ const SSSProfileModule = {
+    type: 'SSSProfile',
+    prepare: ({ options })=>({
+            enabled: options.sss
+        }),
+    setup (fg) {
+        const { graph, ctx, frame, blackboard } = fg;
+        const depthPassResult = requireBuildState(fg, 'depth', 'DepthPrepass', 'SSSProfile');
+        const preLightTransmissionDepthToken = fg.state.preLightTransmissionDepthToken;
+        const shadowMaskHandle = blackboard.get(FrameResources.ShadowMask);
+        const renderDepthAttachment = fg.state.renderDepthAttachment;
+        const sssProfileResult = graph.addPass('SSSProfile', (builder)=>{
+            builder.read(blackboard.expect(FrameResources.LinearDepth));
             builder.read(depthPassResult.depthFramebufferHandle);
             if (preLightTransmissionDepthToken) {
                 builder.read(preLightTransmissionDepthToken);
             }
+            if (shadowMaskHandle) {
+                builder.read(shadowMaskHandle);
+            }
             const profileHandle = builder.createTexture({
                 format: 'rgba16f',
-                label: 'sssProfile'
+                label: 'sssProfile',
+                allocationKey: 'ForwardPlus.SSSProfile'
             });
             const paramHandle = builder.createTexture({
                 format: 'rgba8unorm',
-                label: 'sssParam'
+                label: 'sssParam',
+                allocationKey: 'ForwardPlus.SSSParam'
             });
-            const normalHandle = options.ssr ? undefined : builder.createTexture({
-                format: getSurfaceTextureFormat(ctx),
-                label: 'sssNormal'
-            });
-            const colorAttachments = normalHandle ? [
-                ctx.colorFormat,
-                normalHandle,
-                profileHandle,
-                paramHandle
-            ] : [
+            const colorAttachments = [
                 ctx.colorFormat,
                 profileHandle,
                 paramHandle
@@ -585,34 +662,46 @@ function buildForwardPlusGraphInternal(graph, ctx, renderQueue, options) {
                 ignoreDepthStencil: false
             });
             builder.setExecute((rgCtx)=>{
-                renderForwardSSSProfile(frame, rgCtx.getFramebuffer(framebufferHandle), rgCtx.getTexture(profileHandle), rgCtx.getTexture(paramHandle), normalHandle ? rgCtx.getTexture(normalHandle) : null);
+                ctx.shadowMaskTexture = shadowMaskHandle ? rgCtx.getTexture(shadowMaskHandle) : null;
+                renderForwardSSSProfile(frame, rgCtx.getFramebuffer(framebufferHandle), rgCtx.getTexture(profileHandle), rgCtx.getTexture(paramHandle), null);
             });
             return {
                 profileHandle,
                 paramHandle,
-                normalHandle,
                 framebufferHandle
             };
         });
+        blackboard.set(FrameResources.SSSProfile, sssProfileResult.profileHandle);
+        blackboard.set(FrameResources.SSSParam, sssProfileResult.paramHandle);
     }
-    // 7b. Scene color grab: renders the full scene (no transmission) into a copy
-    // texture that transmission/refraction materials sample as background.
-    // Extracted from the former monolithic light pass.
-    let grabResult;
-    if (options.needSceneColor) {
-        grabResult = graph.addPass('SceneColorGrab', (builder)=>{
-            builder.read(depthHandle);
+};
+/** @internal */ const SceneColorGrabModule = {
+    type: 'SceneColorGrab',
+    prepare: ({ options })=>({
+            enabled: options.needSceneColor
+        }),
+    setup (fg) {
+        // Refraction samples this non-transmission scene copy.
+        const { graph, ctx, frame, blackboard, options } = fg;
+        const depthPassResult = requireBuildState(fg, 'depth', 'DepthPrepass', 'SceneColorGrab');
+        const preLightTransmissionDepthToken = fg.state.preLightTransmissionDepthToken;
+        const shadowMaskHandle = blackboard.get(FrameResources.ShadowMask);
+        const renderDepthAttachment = fg.state.renderDepthAttachment;
+        const grabResult = graph.addPass('SceneColorGrab', (builder)=>{
+            builder.read(blackboard.expect(FrameResources.LinearDepth));
             builder.read(depthPassResult.depthFramebufferHandle);
             if (preLightTransmissionDepthToken) {
                 builder.read(preLightTransmissionDepthToken);
             }
+            if (shadowMaskHandle) {
+                builder.read(shadowMaskHandle);
+            }
             const copyHandle = builder.createTexture({
                 format: ctx.colorFormat,
-                label: 'sceneColorCopy'
+                label: 'sceneColorCopy',
+                allocationKey: 'ForwardPlus.SceneColorCopy'
             });
-            // SSR may pre-insert transmission depth before LightPass for Hi-Z. In that
-            // case the refraction scene-color copy needs an isolated depth buffer so
-            // transmission surfaces do not occlude the background they sample.
+            // Isolate depth when SSR inserts transmission depth before LightPass.
             const copyFramebufferHandle = !options.needsTransmissionDepthForSSR ? builder.createFramebuffer({
                 label: 'SceneColorCopyFramebuffer',
                 width: ctx.renderWidth,
@@ -622,6 +711,7 @@ function buildForwardPlusGraphInternal(graph, ctx, renderQueue, options) {
                 ignoreDepthStencil: false
             }) : undefined;
             builder.setExecute((rgCtx)=>{
+                ctx.shadowMaskTexture = shadowMaskHandle ? rgCtx.getTexture(shadowMaskHandle) : null;
                 renderSceneColorGrab(frame, rgCtx, copyHandle, copyFramebufferHandle);
             });
             return {
@@ -629,366 +719,569 @@ function buildForwardPlusGraphInternal(graph, ctx, renderQueue, options) {
                 copyFramebufferHandle
             };
         });
+        blackboard.set(FrameResources.SceneColorCopy, grabResult.copyHandle);
     }
-    const lightPassResult = graph.addPass('LightPass', (builder)=>{
-        builder.read(depthHandle);
-        builder.read(depthPassResult.depthFramebufferHandle);
-        if (shadowMaskHandle) {
-            builder.read(shadowMaskHandle);
-        }
-        if (preLightTransmissionDepthToken) {
-            builder.read(preLightTransmissionDepthToken);
-        }
-        if (hiZHandle) {
-            builder.read(hiZHandle);
-        }
-        for (const binding of lightHistoryReadBindings){
-            builder.read(binding.handle);
-        }
-        // Scene color: in final-framebuffer-as-intermediate mode the scene is
-        // physically rendered into the final framebuffer, so declare the
-        // backbuffer write — the graph sees the real data flow and no keep-alive
-        // reads are needed downstream. Otherwise render into a graph texture.
-        const sceneColorHandle = useFinalFramebufferAsIntermediate ? builder.write(backbuffer) : builder.createTexture({
-            format: ctx.colorFormat,
-            label: 'sceneColor'
-        });
-        // Transmission/refraction background produced by the SceneColorGrab pass
-        const sceneColorCopyHandle = grabResult?.copyHandle;
-        if (sceneColorCopyHandle) {
-            builder.read(sceneColorCopyHandle);
-        }
-        if (sssProfileResult) {
-            builder.read(sssProfileResult.profileHandle);
-            builder.read(sssProfileResult.paramHandle);
-            if (sssProfileResult.normalHandle) {
-                builder.read(sssProfileResult.normalHandle);
+};
+/** @internal */ const LightPassModule = {
+    type: 'LightPass',
+    writes: [
+        FrameResources.SceneColor,
+        FrameResources.SceneRoughness,
+        FrameResources.SceneNormal,
+        FrameResources.SSSDiffuse,
+        FrameResources.SSSTransmission,
+        FrameResources.SkinSSS
+    ],
+    prepare: ()=>({
+            enabled: true
+        }),
+    setup (fg) {
+        const { graph, ctx, frame, blackboard, options, backbuffer } = fg;
+        const depthPassResult = requireBuildState(fg, 'depth', 'DepthPrepass', 'LightPass');
+        const shadowMaskHandle = blackboard.get(FrameResources.ShadowMask);
+        const preLightTransmissionDepthToken = fg.state.preLightTransmissionDepthToken;
+        const hiZHandle = blackboard.get(FrameResources.HiZ);
+        const sssProfileHandle = blackboard.get(FrameResources.SSSProfile);
+        const sssParamHandle = blackboard.get(FrameResources.SSSParam);
+        const sceneColorCopyHandle = blackboard.get(FrameResources.SceneColorCopy);
+        const useFinalFramebufferAsIntermediate = fg.state.useFinalFramebufferAsIntermediate;
+        const renderDepthAttachment = fg.state.renderDepthAttachment;
+        const historyManager = fg.history;
+        // Keep SSR history scoped while the light pass executes.
+        const lightHistoryReadBindings = fg.state.lightHistoryReadBindings;
+        const historySize = {
+            width: ctx.renderWidth,
+            height: ctx.renderHeight
+        };
+        if (historyManager && options.ssr && ctx.camera?.ssrTemporal && options.motionVectors) {
+            const reflectHistoryHandle = historyManager.importPreviousIfCompatible(graph, RGHistoryResources.SSR_REFLECT, {
+                format: 'rgba16f',
+                sizeMode: 'absolute',
+                width: ctx.renderWidth,
+                height: ctx.renderHeight
+            }, historySize);
+            const motionVectorHistoryHandle = historyManager.importPreviousIfCompatible(graph, RGHistoryResources.SSR_MOTION_VECTOR, {
+                format: 'rgba16f',
+                sizeMode: 'absolute',
+                width: ctx.renderWidth,
+                height: ctx.renderHeight
+            }, historySize);
+            if (reflectHistoryHandle && motionVectorHistoryHandle) {
+                lightHistoryReadBindings.push({
+                    name: RGHistoryResources.SSR_REFLECT,
+                    handle: reflectHistoryHandle
+                }, {
+                    name: RGHistoryResources.SSR_MOTION_VECTOR,
+                    handle: motionVectorHistoryHandle
+                });
             }
         }
-        const includeSSRSurfaceMRT = !!options.ssr;
-        // SSR glossy-surface MRT outputs (roughness + world normal) are graph
-        // textures owned by this pass; effects reach them through the blackboard
-        // handles (or the ctx fields resolved below during execution).
-        const ssrRoughnessHandle = includeSSRSurfaceMRT ? builder.createTexture({
-            format: getSurfaceTextureFormat(ctx),
-            label: 'ssrRoughness'
-        }) : undefined;
-        const ssrNormalHandle = includeSSRSurfaceMRT ? builder.createTexture({
-            format: getSurfaceTextureFormat(ctx),
-            label: 'ssrNormal'
-        }) : undefined;
-        const writeSSSDiffuse = options.sss && shouldStoreSSSDiffuse(ctx);
-        let writeSSSTransmission = options.sss && shouldStoreSSSTransmission(ctx);
-        if (writeSSSDiffuse && writeSSSTransmission && includeSSRSurfaceMRT && getSSSLightingTextureFormat(ctx, 2, includeSSRSurfaceMRT) !== ctx.colorFormat) {
-            writeSSSTransmission = false;
+        if (historyManager && options.ssgi) {
+            const ssgiHistorySize = {
+                width: ctx.renderWidth,
+                height: ctx.renderHeight
+            };
+            const irradianceHistoryHandle = historyManager.importPreviousIfCompatible(graph, RGHistoryResources.SSGI_IRRADIANCE, {
+                format: 'rgba16f',
+                sizeMode: 'absolute',
+                width: ctx.renderWidth,
+                height: ctx.renderHeight
+            }, ssgiHistorySize);
+            const surfaceHistoryHandle = historyManager.importPreviousIfCompatible(graph, RGHistoryResources.SSGI_SURFACE, {
+                format: 'rgba16f',
+                sizeMode: 'absolute',
+                width: ctx.renderWidth,
+                height: ctx.renderHeight
+            }, ssgiHistorySize);
+            if (irradianceHistoryHandle && surfaceHistoryHandle) {
+                lightHistoryReadBindings.push({
+                    name: RGHistoryResources.SSGI_IRRADIANCE,
+                    handle: irradianceHistoryHandle
+                }, {
+                    name: RGHistoryResources.SSGI_SURFACE,
+                    handle: surfaceHistoryHandle
+                });
+            }
         }
-        const writeSkinSSS = options.skinSSS;
-        const sssLightingAttachmentCount = (writeSSSDiffuse ? 1 : 0) + (writeSSSTransmission ? 1 : 0) + (writeSkinSSS ? 1 : 0);
-        const sssLightingFormat = getSSSLightingTextureFormat(ctx, sssLightingAttachmentCount, includeSSRSurfaceMRT);
-        const sssDiffuseHandle = writeSSSDiffuse ? builder.createTexture({
-            format: sssLightingFormat,
-            label: 'sssDiffuse'
-        }) : undefined;
-        const sssTransmissionHandle = writeSSSTransmission ? builder.createTexture({
-            format: sssLightingFormat,
-            label: 'sssTransmission'
-        }) : undefined;
-        const skinSSSHandle = writeSkinSSS ? builder.createTexture({
-            format: sssLightingFormat,
-            label: 'skinSSS'
-        }) : undefined;
-        const sceneColorFramebufferHandle = useFinalFramebufferAsIntermediate ? undefined : builder.createFramebuffer({
-            label: 'SceneColorFramebuffer',
-            width: ctx.renderWidth,
-            height: ctx.renderHeight,
-            colorAttachments: sceneColorHandle,
-            depthAttachment: renderDepthAttachment
-        });
-        builder.setExecute((rgCtx)=>{
-            const sceneColorTex = rgCtx.getTexture(sceneColorHandle);
-            const sceneColorCopyTex = sceneColorCopyHandle ? rgCtx.getTexture(sceneColorCopyHandle) : null;
-            // Resolve MRT products into the DrawContext bridge fields that scene
-            // rendering and apply()-based effects still read.
-            ctx.SSRRoughnessTexture = ssrRoughnessHandle ? rgCtx.getTexture(ssrRoughnessHandle) : null;
-            ctx.SSRNormalTexture = ssrNormalHandle ? rgCtx.getTexture(ssrNormalHandle) : null;
-            if (sssProfileResult) {
-                ctx.SSSProfileTexture = rgCtx.getTexture(sssProfileResult.profileHandle);
-                ctx.SSSParamTexture = rgCtx.getTexture(sssProfileResult.paramHandle);
-                if (sssProfileResult.normalHandle) {
-                    ctx.SSRNormalTexture = rgCtx.getTexture(sssProfileResult.normalHandle);
-                }
+        const opaquePassResult = graph.addPass('LightPass', (builder)=>{
+            builder.read(blackboard.expect(FrameResources.LinearDepth));
+            builder.read(depthPassResult.depthFramebufferHandle);
+            if (shadowMaskHandle) {
+                builder.read(shadowMaskHandle);
+            }
+            if (preLightTransmissionDepthToken) {
+                builder.read(preLightTransmissionDepthToken);
+            }
+            if (hiZHandle) {
+                builder.read(hiZHandle);
+            }
+            for (const binding of lightHistoryReadBindings){
+                builder.read(binding.handle);
+            }
+            // Direct rendering writes the backbuffer; otherwise create a texture.
+            const sceneColorHandle = useFinalFramebufferAsIntermediate ? builder.write(backbuffer) : builder.createTexture({
+                format: ctx.colorFormat,
+                label: 'sceneColor',
+                allocationKey: 'ForwardPlus.SceneColor'
+            });
+            if (sceneColorCopyHandle) {
+                builder.read(sceneColorCopyHandle);
+            }
+            if (sssProfileHandle) {
+                builder.read(sssProfileHandle);
             }
-            ctx.SSSDiffuseTexture = sssDiffuseHandle ? rgCtx.getTexture(sssDiffuseHandle) : null;
-            ctx.SSSTransmissionTexture = sssTransmissionHandle ? rgCtx.getTexture(sssTransmissionHandle) : null;
-            ctx.SkinSSSTexture = skinSSSHandle ? rgCtx.getTexture(skinSSSHandle) : null;
-            const renderLightPass = ()=>renderOpaqueScenePass(frame, sceneColorTex, sceneColorCopyTex, rgCtx, sceneColorFramebufferHandle);
-            if (historyManager && lightHistoryReadBindings.length > 0) {
-                historyManager.beginReadScope(lightHistoryReadBindings.map((binding)=>({
-                        name: binding.name,
-                        texture: rgCtx.getTexture(binding.handle)
-                    })));
-                try {
+            if (sssParamHandle) {
+                builder.read(sssParamHandle);
+            }
+            const surfaceAttachmentCount = Number(options.sceneRoughness) + Number(options.sceneNormal);
+            // Surface MRT products are exposed through blackboard handles.
+            const sceneRoughnessHandle = options.sceneRoughness ? builder.createTexture({
+                format: getSurfaceTextureFormat(ctx),
+                label: 'sceneRoughness',
+                allocationKey: 'ForwardPlus.SceneRoughness'
+            }) : undefined;
+            const sceneNormalHandle = options.sceneNormal ? builder.createTexture({
+                format: getSurfaceTextureFormat(ctx),
+                label: 'sceneNormal',
+                allocationKey: 'ForwardPlus.SceneNormal'
+            }) : undefined;
+            const writeSSSDiffuse = options.sss && shouldStoreSSSDiffuse(ctx);
+            let writeSSSTransmission = options.sss && shouldStoreSSSTransmission(ctx);
+            if (writeSSSDiffuse && writeSSSTransmission && surfaceAttachmentCount > 0 && getSSSLightingTextureFormat(ctx, 2, surfaceAttachmentCount) !== ctx.colorFormat) {
+                writeSSSTransmission = false;
+            }
+            const writeSkinSSS = options.skinSSS;
+            const sssLightingAttachmentCount = (writeSSSDiffuse ? 1 : 0) + (writeSSSTransmission ? 1 : 0) + (writeSkinSSS ? 1 : 0);
+            const sssLightingFormat = getSSSLightingTextureFormat(ctx, sssLightingAttachmentCount, surfaceAttachmentCount);
+            const sssDiffuseHandle = writeSSSDiffuse ? builder.createTexture({
+                format: sssLightingFormat,
+                label: 'sssDiffuse',
+                allocationKey: 'ForwardPlus.SSSDiffuse'
+            }) : undefined;
+            const sssTransmissionHandle = writeSSSTransmission ? builder.createTexture({
+                format: sssLightingFormat,
+                label: 'sssTransmission',
+                allocationKey: 'ForwardPlus.SSSTransmission'
+            }) : undefined;
+            const skinSSSHandle = writeSkinSSS ? builder.createTexture({
+                format: sssLightingFormat,
+                label: 'skinSSS',
+                allocationKey: 'ForwardPlus.SkinSSS'
+            }) : undefined;
+            const sceneColorFramebufferHandle = useFinalFramebufferAsIntermediate ? undefined : builder.createFramebuffer({
+                label: 'SceneColorFramebuffer',
+                width: ctx.renderWidth,
+                height: ctx.renderHeight,
+                colorAttachments: sceneColorHandle,
+                depthAttachment: renderDepthAttachment
+            });
+            builder.setExecute((rgCtx)=>{
+                const sceneColorTex = rgCtx.getTexture(sceneColorHandle);
+                const sceneColorCopyTex = sceneColorCopyHandle ? rgCtx.getTexture(sceneColorCopyHandle) : null;
+                // Legacy effects still read resolved MRT textures from DrawContext.
+                ctx.shadowMaskTexture = shadowMaskHandle ? rgCtx.getTexture(shadowMaskHandle) : null;
+                ctx.HiZTexture = hiZHandle ? rgCtx.getTexture(hiZHandle) : null;
+                ctx.SceneRoughnessTexture = sceneRoughnessHandle ? rgCtx.getTexture(sceneRoughnessHandle) : null;
+                ctx.SceneNormalTexture = sceneNormalHandle ? rgCtx.getTexture(sceneNormalHandle) : null;
+                ctx.SSSProfileTexture = sssProfileHandle ? rgCtx.getTexture(sssProfileHandle) : null;
+                ctx.SSSParamTexture = sssParamHandle ? rgCtx.getTexture(sssParamHandle) : null;
+                ctx.SSSDiffuseTexture = sssDiffuseHandle ? rgCtx.getTexture(sssDiffuseHandle) : null;
+                ctx.SSSTransmissionTexture = sssTransmissionHandle ? rgCtx.getTexture(sssTransmissionHandle) : null;
+                ctx.SkinSSSTexture = skinSSSHandle ? rgCtx.getTexture(skinSSSHandle) : null;
+                const renderLightPass = ()=>renderOpaqueScenePass(frame, sceneColorTex, sceneColorCopyTex, rgCtx, sceneColorFramebufferHandle);
+                if (historyManager && lightHistoryReadBindings.length > 0) {
+                    const ssgiIrradianceBinding = lightHistoryReadBindings.find((binding)=>binding.name === RGHistoryResources.SSGI_IRRADIANCE);
+                    const ssgiSurfaceBinding = lightHistoryReadBindings.find((binding)=>binding.name === RGHistoryResources.SSGI_SURFACE);
+                    ctx.SSGIIrradianceHistoryTexture = ssgiIrradianceBinding ? rgCtx.getTexture(ssgiIrradianceBinding.handle) : null;
+                    ctx.SSGISurfaceHistoryTexture = ssgiSurfaceBinding ? rgCtx.getTexture(ssgiSurfaceBinding.handle) : null;
+                    historyManager.beginReadScope(lightHistoryReadBindings.map((binding)=>({
+                            name: binding.name,
+                            texture: rgCtx.getTexture(binding.handle)
+                        })));
+                    try {
+                        renderLightPass();
+                    } finally{
+                        historyManager.endReadScope();
+                        ctx.SSGIIrradianceHistoryTexture = null;
+                        ctx.SSGISurfaceHistoryTexture = null;
+                    }
+                } else {
                     renderLightPass();
-                } finally{
-                    historyManager.endReadScope();
                 }
-            } else {
-                renderLightPass();
-            }
+            });
+            return {
+                sceneColorHandle,
+                sceneColorFramebufferHandle,
+                sceneRoughnessHandle,
+                sceneNormalHandle,
+                sssDiffuseHandle,
+                sssTransmissionHandle,
+                skinSSSHandle
+            };
         });
-        return {
-            sceneColorHandle,
-            sceneColorCopyHandle,
-            sceneColorFramebufferHandle,
-            ssrRoughnessHandle,
-            ssrNormalHandle,
-            sssDiffuseHandle,
-            sssTransmissionHandle,
-            skinSSSHandle
-        };
-    });
-    // Register the LightPass MRT products so effects can look them up by name.
-    if (lightPassResult.ssrRoughnessHandle) {
-        blackboard.set(FrameResources.SSRRoughness, lightPassResult.ssrRoughnessHandle);
-    }
-    if (lightPassResult.ssrNormalHandle) {
-        blackboard.set(FrameResources.SSRNormal, lightPassResult.ssrNormalHandle);
-    } else if (sssProfileResult?.normalHandle) {
-        blackboard.set(FrameResources.SSRNormal, sssProfileResult.normalHandle);
-    }
-    if (lightPassResult.sssDiffuseHandle) {
-        blackboard.set(FrameResources.SSSDiffuse, lightPassResult.sssDiffuseHandle);
-    }
-    if (lightPassResult.sssTransmissionHandle) {
-        blackboard.set(FrameResources.SSSTransmission, lightPassResult.sssTransmissionHandle);
-    }
-    if (lightPassResult.skinSSSHandle) {
-        blackboard.set(FrameResources.SkinSSS, lightPassResult.skinSSSHandle);
-    }
-    // 7d. Opaque-layer post effects (SAO/SSR/SSS/SkinSSS). They read the opaque
-    // scene color and must complete before transparent geometry renders on top
-    // of their output. Never direct-write: the chain output becomes the
-    // transparent pass's render target. In final-framebuffer-as-intermediate
-    // mode the scene color handle is the LightPass's backbuffer write version,
-    // so the data flow is real either way — no keep-alive reads needed.
-    const opaqueChainInput = lightPassResult.sceneColorHandle;
-    // Data dependencies for every effect pass: frame textures the effects sample
-    // through DrawContext fields (linear depth, HiZ, scene color copy, SSS MRT
-    // outputs) rather than through declared require* hooks.
-    const opaqueChainDeps = [
-        depthHandle
-    ];
-    if (hiZHandle) {
-        opaqueChainDeps.push(hiZHandle);
-    }
-    if (lightPassResult.sceneColorFramebufferHandle) {
-        opaqueChainDeps.push(lightPassResult.sceneColorFramebufferHandle);
-    }
-    if (grabResult) {
-        opaqueChainDeps.push(grabResult.copyHandle);
-    }
-    if (sssProfileResult) {
-        opaqueChainDeps.push(sssProfileResult.profileHandle, sssProfileResult.paramHandle);
-        if (sssProfileResult.normalHandle) {
-            opaqueChainDeps.push(sssProfileResult.normalHandle);
+        const lightPassResult = opaquePassResult;
+        fg.state.lightPass = lightPassResult;
+        blackboard.set(FrameResources.SceneColor, lightPassResult.sceneColorHandle);
+        if (lightPassResult.sceneRoughnessHandle) {
+            blackboard.set(FrameResources.SceneRoughness, lightPassResult.sceneRoughnessHandle);
         }
-    }
-    for (const handle of [
-        lightPassResult.ssrRoughnessHandle,
-        lightPassResult.ssrNormalHandle,
-        lightPassResult.sssDiffuseHandle,
-        lightPassResult.sssTransmissionHandle,
-        lightPassResult.skinSSSHandle
-    ]){
-        if (handle) {
-            opaqueChainDeps.push(handle);
+        if (lightPassResult.sceneNormalHandle) {
+            blackboard.set(FrameResources.SceneNormal, lightPassResult.sceneNormalHandle);
         }
-    }
-    const opaqueChainResult = ctx.compositor ? ctx.compositor.buildLayer({
-        graph,
-        ctx,
-        layer: PostEffectLayer.opaque,
-        blackboard,
-        input: opaqueChainInput,
-        finalOutput: null,
-        sceneDepthAttachment: renderDepthAttachment,
-        dependencies: opaqueChainDeps,
-        historyReads: lightHistoryReadBindings,
-        history: historyManager
-    }) : {
-        color: opaqueChainInput,
-        wroteFinal: false
-    };
-    const opaqueChainRan = opaqueChainResult.color !== opaqueChainInput;
-    // 7e. Transparent scene geometry (transmission/transparent lists + OIT).
-    // Renders on top of the opaque-chain output; graph-wise an in-place write
-    // producing a new version of the current scene color.
-    const sceneColorHandle = graph.addPass('TransparentPass', (builder)=>{
-        builder.read(depthHandle);
-        builder.read(depthPassResult.depthFramebufferHandle);
-        if (hiZHandle) {
-            // Transparent-phase materials may ray-march HiZ (e.g. water SSR)
-            builder.read(hiZHandle);
+        if (lightPassResult.sssDiffuseHandle) {
+            blackboard.set(FrameResources.SSSDiffuse, lightPassResult.sssDiffuseHandle);
         }
-        if (lightPassResult.sceneColorFramebufferHandle) {
-            builder.read(lightPassResult.sceneColorFramebufferHandle);
+        if (lightPassResult.sssTransmissionHandle) {
+            blackboard.set(FrameResources.SSSTransmission, lightPassResult.sssTransmissionHandle);
         }
-        if (lightPassResult.sceneColorCopyHandle) {
-            builder.read(lightPassResult.sceneColorCopyHandle);
+        if (lightPassResult.skinSSSHandle) {
+            blackboard.set(FrameResources.SkinSSS, lightPassResult.skinSSSHandle);
         }
-        builder.read(opaqueChainResult.color);
-        const out = builder.write(opaqueChainResult.color);
-        builder.setExecute((rgCtx)=>{
-            renderTransparentScenePass(frame, rgCtx, opaqueChainRan ? opaqueChainResult.color : null, lightPassResult.sceneColorFramebufferHandle);
-        });
-        return out;
-    });
-    blackboard.set(FrameResources.SceneColor, sceneColorHandle);
-    if (lightPassResult.sceneColorCopyHandle) {
-        blackboard.set(FrameResources.SceneColorCopy, lightPassResult.sceneColorCopyHandle);
     }
-    if (sssProfileResult) {
-        blackboard.set(FrameResources.SSSProfile, sssProfileResult.profileHandle);
-        blackboard.set(FrameResources.SSSParam, sssProfileResult.paramHandle);
-    }
-    // 8. Post effect chains + transmission depth.
-    //
-    // Chain input: the TransparentPass output version — the authoritative scene
-    // color regardless of whether it physically lives in a texture or in the
-    // backbuffer (final framebuffer used as intermediate, no opaque effects).
-    const chainInput = sceneColorHandle;
-    // When the scene color still physically resides in the final framebuffer,
-    // the Present blit must be skipped if no effect moved it to a texture.
-    // (Opaque-layer effects disable final-as-intermediate mode, so the scene
-    // color is backbuffer-resident whenever that mode is active.)
-    const backbufferResidentHandle = useFinalFramebufferAsIntermediate ? sceneColorHandle : null;
-    // No extra chain dependencies: the effect chains link to the scene color
-    // through their inputs, and per-effect texture needs are declared via the
-    // require* hooks in AbstractPostEffect.setup().
-    const chainDependencies = [];
-    const finalOutput = {
-        handle: backbuffer,
-        isScreen: !ctx.finalFramebuffer
-    };
-    const endLayerHasEffects = !!ctx.compositor?.layerHasEnabledEffect(PostEffectLayer.end);
-    // 8a. Transparent-layer effects (bloom, tonemap, FXAA, ...). They run right
-    // after the light pass and must sample the pre-transmission linear depth, so
-    // they carry no transmissionDepthToken dependency; TransmissionDepth is
-    // instead ordered after this chain (see 8b).
-    const transparentChainResult = ctx.compositor ? ctx.compositor.buildLayer({
-        graph,
-        ctx,
-        layer: PostEffectLayer.transparent,
-        blackboard,
-        input: chainInput,
-        finalOutput: endLayerHasEffects ? null : finalOutput,
-        inputResidesInFinalTarget: !!backbufferResidentHandle,
-        sceneDepthAttachment: renderDepthAttachment,
-        dependencies: chainDependencies,
-        history: historyManager
-    }) : {
-        color: chainInput,
-        wroteFinal: false
-    };
-    // 8b. Transmission depth pass (optional). Mutates the linear depth texture;
-    // the mutation is modeled as a graph write: the WAR hazard orders this pass
-    // after every pre-transmission depth reader (the transparent-layer chain),
-    // and re-registering the post-write version in the blackboard gives
-    // end-layer effects (TAA) a real data dependency on the transmission depth.
-    let transmissionDepthToken;
-    if (options.needSceneColor && !options.needsTransmissionDepthForSSR) {
-        const transmissionDepthResult = graph.addPass('TransmissionDepth', (builder)=>{
+};
+/** @internal */ const SkyPassModule = {
+    type: 'SkyPass',
+    reads: [
+        {
+            resource: FrameResources.SceneColor,
+            version: 'current'
+        }
+    ],
+    writes: [
+        FrameResources.SceneColor,
+        FrameResources.SceneColorNoFog
+    ],
+    prepare: ()=>({
+            enabled: true
+        }),
+    setup (fg) {
+        const { graph, ctx, frame, blackboard, options } = fg;
+        const depthPassResult = requireBuildState(fg, 'depth', 'DepthPrepass', 'SkyPass');
+        const lightPassResult = requireBuildState(fg, 'lightPass', 'LightPass', 'SkyPass');
+        const sceneColorCopyHandle = blackboard.get(FrameResources.SceneColorCopy);
+        const sceneColorHandle = blackboard.expect(FrameResources.SceneColor);
+        // Screen-space passes must not read fog as surface radiance. Snapshot the lit
+        // scene with sky but before fog, and only when fog is actually present and a
+        // consumer exists, so fog-free scenes allocate nothing extra. The refraction
+        // background path already baked sky and fog into the copy, so no fog-free
+        // version can be recovered there and consumers keep their existing input.
+        const captureNoFog = !sceneColorCopyHandle && (options.ssgi || options.ssr) && options.fogPresents;
+        const skyPassResult = graph.addPass('SkyPass', (builder)=>{
             builder.read(sceneColorHandle);
-            if (transparentChainResult.color !== sceneColorHandle) {
-                builder.read(transparentChainResult.color);
-            }
-            builder.read(depthHandle);
             builder.read(depthPassResult.depthFramebufferHandle);
-            const depthOut = builder.write(depthHandle);
-            const done = builder.createToken('TransmissionDepthDone');
-            builder.sideEffect();
+            if (lightPassResult.sceneColorFramebufferHandle) {
+                builder.read(lightPassResult.sceneColorFramebufferHandle);
+            }
+            const noFog = captureNoFog ? builder.createTexture({
+                format: ctx.colorFormat,
+                label: 'sceneColorNoFog',
+                allocationKey: 'ForwardPlus.SceneColorNoFog'
+            }) : null;
+            const out = builder.write(sceneColorHandle);
             builder.setExecute((rgCtx)=>{
-                renderTransmissionDepthPass(frame, rgCtx);
+                // The refraction background already contains sky and fog.
+                if (!sceneColorCopyHandle) {
+                    renderSkyScenePass(frame, rgCtx, lightPassResult.sceneColorFramebufferHandle, noFog ? rgCtx.getTexture(noFog) : null);
+                }
             });
             return {
-                done,
-                depthOut
+                color: out,
+                noFog
             };
         });
-        transmissionDepthToken = transmissionDepthResult.done;
-        depthHandle = transmissionDepthResult.depthOut;
-        // The transparent-layer chain above read the pre-transmission version;
-        // everything built from here on (end-layer chain) reads this one.
-        blackboard.set(FrameResources.LinearDepth, depthHandle);
+        lightPassResult.sceneColorHandle = skyPassResult.color;
+        blackboard.set(FrameResources.SceneColor, skyPassResult.color);
+        if (skyPassResult.noFog) {
+            blackboard.set(FrameResources.SceneColorNoFog, skyPassResult.noFog);
+        }
     }
-    // 9. End-layer effects (TAA). Ordered after TransmissionDepth.
-    const endChainDependencies = transmissionDepthToken ? [
-        ...chainDependencies,
-        transmissionDepthToken
-    ] : chainDependencies;
-    const chainResult = ctx.compositor ? ctx.compositor.buildLayer({
-        graph,
-        ctx,
-        layer: PostEffectLayer.end,
-        blackboard,
-        input: transparentChainResult.color,
-        finalOutput,
-        // Still backbuffer-resident if the transparent-layer chain ran no effect
-        inputResidesInFinalTarget: !!backbufferResidentHandle && transparentChainResult.color === chainInput,
-        sceneDepthAttachment: renderDepthAttachment,
-        dependencies: endChainDependencies,
-        history: historyManager
-    }) : {
-        color: transparentChainResult.color,
-        wroteFinal: false
-    };
-    const finalWroteFinal = chainResult.wroteFinal || transparentChainResult.wroteFinal;
-    // 10. Present + frame cleanup.
-    let presentedBackbuffer;
-    if (finalWroteFinal) {
-        // The last effect wrote the final target directly; only cleanup remains.
-        presentedBackbuffer = chainResult.color;
-        graph.addPass('FrameCleanup', (builder)=>{
-            builder.read(presentedBackbuffer);
-            for (const dep of endChainDependencies){
-                builder.read(dep);
+};
+/** @internal */ const CompositeTailModule = {
+    type: 'CompositeTail',
+    writes: [
+        FrameResources.SceneColor,
+        FrameResources.LinearDepth,
+        FrameResources.PresentedColor
+    ],
+    prepare: ()=>({
+            enabled: true
+        }),
+    setup (fg) {
+        const { graph, ctx, frame, blackboard, options, backbuffer } = fg;
+        const depthPassResult = requireBuildState(fg, 'depth', 'DepthPrepass', 'CompositeTail');
+        const hiZHandle = blackboard.get(FrameResources.HiZ);
+        const sceneColorCopyHandle = blackboard.get(FrameResources.SceneColorCopy);
+        const lightPassResult = requireBuildState(fg, 'lightPass', 'LightPass', 'CompositeTail');
+        const renderDepthAttachment = fg.state.renderDepthAttachment;
+        const useFinalFramebufferAsIntermediate = fg.state.useFinalFramebufferAsIntermediate;
+        const lightHistoryReadBindings = fg.state.lightHistoryReadBindings;
+        const historyManager = fg.history;
+        // Opaque effects finish before transparent geometry uses their output.
+        const opaqueChainInput = blackboard.expect(FrameResources.SceneColor);
+        // Include textures sampled indirectly through DrawContext.
+        const opaqueChainDeps = [
+            blackboard.expect(FrameResources.LinearDepth)
+        ];
+        if (hiZHandle) {
+            opaqueChainDeps.push(hiZHandle);
+        }
+        if (lightPassResult.sceneColorFramebufferHandle) {
+            opaqueChainDeps.push(lightPassResult.sceneColorFramebufferHandle);
+        }
+        if (sceneColorCopyHandle) {
+            opaqueChainDeps.push(sceneColorCopyHandle);
+        }
+        for (const handle of [
+            blackboard.get(FrameResources.SSSProfile),
+            blackboard.get(FrameResources.SSSParam),
+            blackboard.get(FrameResources.SceneRoughness),
+            blackboard.get(FrameResources.SceneNormal),
+            blackboard.get(FrameResources.SSSDiffuse),
+            blackboard.get(FrameResources.SSSTransmission),
+            blackboard.get(FrameResources.SkinSSS)
+        ]){
+            if (handle) {
+                opaqueChainDeps.push(handle);
             }
-            builder.sideEffect();
-            builder.setExecute(()=>{
-                finishFrame(frame);
-            });
-        });
-    } else {
-        presentedBackbuffer = graph.addPass('Present', (builder)=>{
-            builder.read(chainResult.color);
-            for (const dep of endChainDependencies){
-                builder.read(dep);
+        }
+        const opaqueChainResult = ctx.compositor ? ctx.compositor.buildLayer({
+            graph,
+            ctx,
+            layer: PostEffectLayer.opaque,
+            blackboard,
+            input: opaqueChainInput,
+            finalOutput: null,
+            sceneDepthAttachment: renderDepthAttachment,
+            dependencies: opaqueChainDeps,
+            historyReads: lightHistoryReadBindings,
+            history: historyManager
+        }) : {
+            color: opaqueChainInput,
+            wroteFinal: false
+        };
+        const opaqueChainRan = opaqueChainResult.color !== opaqueChainInput;
+        // Transparent geometry writes a new version of the opaque-chain output.
+        const sceneColorHandle = graph.addPass('TransparentPass', (builder)=>{
+            builder.read(blackboard.expect(FrameResources.LinearDepth));
+            builder.read(depthPassResult.depthFramebufferHandle);
+            if (hiZHandle) {
+                // Transparent materials may ray-march HiZ.
+                builder.read(hiZHandle);
+            }
+            if (lightPassResult.sceneColorFramebufferHandle) {
+                builder.read(lightPassResult.sceneColorFramebufferHandle);
             }
-            const outputBackbuffer = builder.write(backbuffer);
-            // Skip the blit when the chain output already lives in the final target
-            // (final framebuffer used as intermediate and no end-layer effect ran).
-            const needsBlit = chainResult.color !== backbufferResidentHandle;
+            if (sceneColorCopyHandle) {
+                builder.read(sceneColorCopyHandle);
+            }
+            builder.read(opaqueChainResult.color);
+            const out = builder.write(opaqueChainResult.color);
             builder.setExecute((rgCtx)=>{
-                const sourceTex = needsBlit ? rgCtx.getTexture(chainResult.color) : null;
-                if (sourceTex) {
-                    const blitter = new CopyBlitter();
-                    blitter.srgbOut = !ctx.finalFramebuffer;
-                    blitter.blit(sourceTex, ctx.finalFramebuffer ?? null, fetchSampler('clamp_nearest_nomip'));
-                }
-                finishFrame(frame);
+                renderTransparentScenePass(frame, rgCtx, opaqueChainRan ? opaqueChainResult.color : null, lightPassResult.sceneColorFramebufferHandle);
             });
-            return outputBackbuffer;
+            return out;
         });
+        blackboard.set(FrameResources.SceneColor, sceneColorHandle);
+        const chainInput = sceneColorHandle;
+        // Track whether the chain input still resides in the final target.
+        const backbufferResidentHandle = useFinalFramebufferAsIntermediate ? sceneColorHandle : null;
+        const chainDependencies = [];
+        const finalOutput = {
+            handle: backbuffer,
+            isScreen: !ctx.finalFramebuffer
+        };
+        const endLayerHasEffects = !!ctx.compositor?.layerHasEnabledEffect(PostEffectLayer.end);
+        // Transparent-layer effects read depth before its transmission mutation.
+        const transparentChainResult = ctx.compositor ? ctx.compositor.buildLayer({
+            graph,
+            ctx,
+            layer: PostEffectLayer.transparent,
+            blackboard,
+            input: chainInput,
+            finalOutput: endLayerHasEffects ? null : finalOutput,
+            inputResidesInFinalTarget: !!backbufferResidentHandle,
+            sceneDepthAttachment: renderDepthAttachment,
+            dependencies: chainDependencies,
+            history: historyManager
+        }) : {
+            color: chainInput,
+            wroteFinal: false
+        };
+        // WAR orders this depth mutation after pre-transmission readers.
+        let transmissionDepthToken;
+        if (options.needSceneColor && !options.needsTransmissionDepthForSSR) {
+            const transmissionDepthResult = graph.addPass('TransmissionDepth', (builder)=>{
+                const currentDepth = blackboard.expect(FrameResources.LinearDepth);
+                builder.read(sceneColorHandle);
+                if (transparentChainResult.color !== sceneColorHandle) {
+                    builder.read(transparentChainResult.color);
+                }
+                builder.read(currentDepth);
+                builder.read(depthPassResult.depthFramebufferHandle);
+                const depthOut = builder.write(currentDepth);
+                const done = builder.createToken('TransmissionDepthDone');
+                builder.sideEffect();
+                builder.setExecute((rgCtx)=>{
+                    renderTransmissionDepthPass(frame, rgCtx);
+                });
+                return {
+                    done,
+                    depthOut
+                };
+            });
+            transmissionDepthToken = transmissionDepthResult.done;
+            blackboard.set(FrameResources.LinearDepth, transmissionDepthResult.depthOut);
+        }
+        const endChainDependencies = transmissionDepthToken ? [
+            ...chainDependencies,
+            transmissionDepthToken
+        ] : chainDependencies;
+        const chainResult = ctx.compositor ? ctx.compositor.buildLayer({
+            graph,
+            ctx,
+            layer: PostEffectLayer.end,
+            blackboard,
+            input: transparentChainResult.color,
+            finalOutput,
+            inputResidesInFinalTarget: !!backbufferResidentHandle && transparentChainResult.color === chainInput,
+            sceneDepthAttachment: renderDepthAttachment,
+            dependencies: endChainDependencies,
+            history: historyManager
+        }) : {
+            color: transparentChainResult.color,
+            wroteFinal: false
+        };
+        const finalWroteFinal = chainResult.wroteFinal || transparentChainResult.wroteFinal;
+        let presentedBackbuffer;
+        if (finalWroteFinal) {
+            presentedBackbuffer = chainResult.color;
+        } else {
+            presentedBackbuffer = graph.addPass('Blit', (builder)=>{
+                builder.read(chainResult.color);
+                for (const dep of endChainDependencies){
+                    builder.read(dep);
+                }
+                const outputBackbuffer = builder.write(backbuffer);
+                // Skip copies when the output already resides in the final target.
+                const needsBlit = chainResult.color !== backbufferResidentHandle;
+                builder.setExecute((rgCtx)=>{
+                    const sourceTex = needsBlit ? rgCtx.getTexture(chainResult.color) : null;
+                    if (sourceTex) {
+                        const blitter = new CopyBlitter();
+                        blitter.srgbOut = !ctx.finalFramebuffer;
+                        blitter.blit(sourceTex, ctx.finalFramebuffer ?? null, fetchSampler('clamp_nearest_nomip'));
+                    }
+                });
+                return outputBackbuffer;
+            });
+        }
+        fg.state.presentedBackbuffer = presentedBackbuffer;
+        // Downstream modules may replace this sink registration.
+        blackboard.set(FrameResources.PresentedColor, presentedBackbuffer);
     }
+};
+/** Built-in Forward+ modules addressable by pipeline anchors. @public */ const ForwardPlusModules = {
+    SkyUpdate: SkyUpdateModule,
+    ClusterLights: ClusterLightsModule,
+    GPUPicking: GPUPickingModule,
+    ShadowMaps: ShadowMapsModule,
+    DepthPrepass: DepthPrepassModule,
+    ShadowMask: ShadowMaskModule,
+    TransmissionDepthForSSR: TransmissionDepthForSSRModule,
+    HiZ: HiZModule,
+    SSSProfile: SSSProfileModule,
+    SceneColorGrab: SceneColorGrabModule,
+    LightPass: LightPassModule,
+    SkyPass: SkyPassModule,
+    CompositeTail: CompositeTailModule
+};
+/** The default module order assembled by {@link createForwardPlusPipeline}. */ const DEFAULT_FORWARD_PLUS_MODULES = [
+    SkyUpdateModule,
+    ClusterLightsModule,
+    GPUPickingModule,
+    ShadowMapsModule,
+    DepthPrepassModule,
+    ShadowMaskModule,
+    TransmissionDepthForSSRModule,
+    HiZModule,
+    SSSProfileModule,
+    SceneColorGrabModule,
+    LightPassModule,
+    SkyPassModule,
+    CompositeTailModule
+];
+/** @internal */ let _defaultForwardPlusPipeline = null;
+/** Create an independent pipeline with the built-in Forward+ modules. @public */ function createForwardPlusPipeline() {
+    return new RenderPipeline(DEFAULT_FORWARD_PLUS_MODULES);
+}
+/** Return the shared default pipeline. Mutations affect cameras using it. @public */ function getDefaultForwardPlusPipeline() {
+    if (!_defaultForwardPlusPipeline) {
+        _defaultForwardPlusPipeline = createForwardPlusPipeline();
+    }
+    return _defaultForwardPlusPipeline;
+}
+/** Build the Forward+ render graph and return its backbuffer output. @public */ function buildForwardPlusGraph(graph, ctx, renderQueue, options) {
+    return buildForwardPlusGraphInternal(graph, ctx, renderQueue, options).backbuffer;
+}
+function buildForwardPlusGraphInternal(graph, ctx, renderQueue, options) {
+    const backbuffer = graph.importTexture('backbuffer');
+    // Irradiance, moments and surface history require renderable half-float
+    // targets. Keep ordinary IBL active on devices that cannot provide them.
+    options.ssgi &&= supportsSSGIRenderTargets(ctx);
+    ctx.SSS = !!options.sss;
+    ctx.SSGI = !!options.ssgi;
+    ctx.SSGIIrradianceHistoryTexture = null;
+    ctx.SSGISurfaceHistoryTexture = null;
+    ctx.SkinSSSTexture = null;
+    // ShadowMask sets this only when it produces a texture.
+    ctx.shadowMaskTexture = null;
+    const blackboard = new RGBlackboard();
+    const frame = {
+        ctx,
+        renderQueue,
+        depthFramebuffer: null,
+        sunLightColor: null,
+        options,
+        renderQueueDisposed: false,
+        clusteredLightReleased: false,
+        sunLightRestored: false
+    };
+    const ordering = new OrderingScope();
+    const fg = {
+        graph,
+        ctx,
+        finalFramebuffer: ctx.finalFramebuffer,
+        renderQueue,
+        blackboard,
+        frame,
+        history: ctx.camera?.getHistoryResourceManager?.() ?? null,
+        options,
+        ordering,
+        backbuffer,
+        state: {
+            renderDepthAttachment: null,
+            useFinalFramebufferAsIntermediate: false,
+            lightHistoryReadBindings: []
+        }
+    };
+    const pipeline = ctx.camera?.renderPipeline ?? getDefaultForwardPlusPipeline();
+    const requirements = ctx.compositor?.collectRequirements(ctx) ?? {};
+    mergeFrameResourceRequirements(requirements, pipeline.collectRequirements(fg));
+    resolveFrameResourceRequirements(ctx, options, requirements);
+    pipeline.build(fg);
+    validateProducedFrameResources(blackboard, options, renderQueue);
+    const presented = blackboard.get(FrameResources.PresentedColor) ?? fg.state.presentedBackbuffer;
+    const depth = fg.state.depth;
+    const externalDepthImport = depth?.externalDepthAttachmentHandle && depth.externalDepthAttachment ? {
+        handle: depth.externalDepthAttachmentHandle,
+        texture: depth.externalDepthAttachment
+    } : undefined;
     return {
-        backbuffer: presentedBackbuffer,
-        frame
+        backbuffer: presented,
+        frame,
+        externalDepthImport
     };
 }
-// ─── Pass Implementation Helpers ────────────────────────────────────
-// These wrap the existing SceneRenderer static methods, adapted to work
-// with the FrameState pattern. They contain the same logic as the
-// original methods but read/write through FrameState.
 /** @internal */ function renderShadowMaps(ctx, lights) {
     ctx.renderPass = _shadowMapPass;
     ctx.device.pushDeviceStates();
@@ -1021,20 +1314,17 @@ function renderForwardSSSProfile(frame, profileFramebuffer, profileTexture, para
     const savedCommandBufferReuse = ctx.camera.commandBufferReuse;
     const savedProfileTexture = ctx.SSSProfileTexture;
     const savedParamTexture = ctx.SSSParamTexture;
-    const savedNormalTexture = ctx.SSRNormalTexture;
+    const savedNormalTexture = ctx.SceneNormalTexture;
     let profileFlags = MaterialVaryingFlags.SSS_STORE_PROFILE;
-    if (normalTexture) {
-        profileFlags |= MaterialVaryingFlags.SSS_STORE_NORMAL;
-    }
     device.pushDeviceStates();
     try {
         device.setFramebuffer(profileFramebuffer);
         ctx.SSSProfileTexture = profileTexture;
         ctx.SSSParamTexture = paramTexture;
-        ctx.SSRNormalTexture = normalTexture;
+        ctx.SceneNormalTexture = normalTexture;
         ctx.compositor = null;
         ctx.camera.commandBufferReuse = false;
-        ctx.materialFlags = ctx.materialFlags & ~(MaterialVaryingFlags.SSR_STORE_ROUGHNESS | MaterialVaryingFlags.SSS_STORE_PROFILE | MaterialVaryingFlags.SSS_STORE_NORMAL | MaterialVaryingFlags.SSS_STORE_DIFFUSE | MaterialVaryingFlags.SSS_STORE_TRANSMISSION | MaterialVaryingFlags.SKIN_SSS_STORE) | profileFlags;
+        ctx.materialFlags = ctx.materialFlags & ~(MaterialVaryingFlags.SCENE_STORE_ROUGHNESS | MaterialVaryingFlags.SSS_STORE_PROFILE | MaterialVaryingFlags.SCENE_STORE_NORMAL | MaterialVaryingFlags.SSS_STORE_DIFFUSE | MaterialVaryingFlags.SSS_STORE_TRANSMISSION | MaterialVaryingFlags.SKIN_SSS_STORE) | profileFlags;
         _scenePass.transmission = false;
         _scenePass.renderOpaque = true;
         _scenePass.renderTransparent = false;
@@ -1054,14 +1344,13 @@ function renderForwardSSSProfile(frame, profileFramebuffer, profileTexture, para
         ctx.compositor = savedCompositor;
         ctx.SSSProfileTexture = savedProfileTexture;
         ctx.SSSParamTexture = savedParamTexture;
-        ctx.SSRNormalTexture = savedNormalTexture;
+        ctx.SceneNormalTexture = savedNormalTexture;
         device.popDeviceStates();
         sssRenderQueue.dispose();
     }
 }
 function releaseIntermediateFramebuffer(frame) {
-    // Device state is contained within each pass now (LightPass/TransparentPass
-    // push/pop their own framebuffer bindings); only the context field remains.
+    // Each pass owns device state; only clear the shared context field.
     frame.ctx.intermediateFramebuffer = null;
 }
 function releaseDepthFramebuffer(frame) {
@@ -1087,6 +1376,13 @@ function restoreSunLight(frame) {
     }
 }
 function cleanupFrame(frame) {
+    const { ctx } = frame;
+    ctx.materialFlags &= ~MaterialVaryingFlags.SCENE_STORE_ROUGHNESS;
+    ctx.materialFlags &= ~MaterialVaryingFlags.SSS_STORE_PROFILE;
+    ctx.materialFlags &= ~MaterialVaryingFlags.SSS_STORE_DIFFUSE;
+    ctx.materialFlags &= ~MaterialVaryingFlags.SCENE_STORE_NORMAL;
+    ctx.materialFlags &= ~MaterialVaryingFlags.SSS_STORE_TRANSMISSION;
+    ctx.materialFlags &= ~MaterialVaryingFlags.SKIN_SSS_STORE;
     releaseIntermediateFramebuffer(frame);
     releaseDepthFramebuffer(frame);
     releaseClusteredLight(frame);
@@ -1098,10 +1394,10 @@ function cleanupFrame(frame) {
     const renderQueue = frame.renderQueue;
     const transmission = transmissionOverride ?? !!existingDepthFb;
     let depthFramebuffer = existingDepthFb;
+    // Current callers must provide the graph-managed prepass framebuffer.
+    console.assert(!!existingDepthFb, 'renderSceneDepth: called without an existing depth framebuffer; the ' + 'self-allocating fallback path is untested in the forward+ pipeline.');
     if (!depthFramebuffer) {
-        // Use RenderGraph-allocated textures if provided
         {
-            // Allocate through RenderGraph so framebuffer lifetime is owned by the executor.
             const format = ctx.device.type === 'webgl' ? ctx.SSRCalcThickness ? 'rgba16f' : 'rgba8unorm' : ctx.SSRCalcThickness ? 'rg32f' : 'r32f';
             const mvFormat = 'rgba16f';
             if (!ctx.finalFramebuffer) {
@@ -1151,7 +1447,7 @@ function cleanupFrame(frame) {
         ctx.device.setFramebuffer(depthFramebuffer);
         _depthPass.encodeDepth = depthFramebuffer.getColorAttachments()[0].format === 'rgba8unorm';
         _depthPass.clearColor = transmission ? null : _depthPass.encodeDepth ? new Vector4(0, 0, 0, 1) : new Vector4(1, 1, 1, 1);
-        _depthPass.clearDepth = transmission ? null : 1;
+        _depthPass.clearDepth = transmission ? null : DEPTH_CLEAR_VALUE;
         _depthPass.clearStencil = null;
         _depthPass.transmission = transmission;
         if (ctx.SSRCalcThickness && !transmission) {
@@ -1183,11 +1479,9 @@ function cleanupFrame(frame) {
         ctx.linearDepthTexture = depthFramebuffer.getColorAttachments()[0];
         ctx.depthTexture = depthFramebuffer.getDepthAttachment();
         ctx.depthPrepassAttachment = ctx.depthTexture;
-    // HiZ is now built in the dedicated HiZ pass
     }
     return depthFramebuffer;
 }
-// ─── Sky Motion Vector State ────────────────────────────────────────
 let _skyMVProgram = null;
 let _skyMVBindGroup = null;
 let _skyMVBox = null;
@@ -1213,7 +1507,7 @@ let _skyMVBox = null;
                     this.$l.prevWorldPos = pb.add(this.$inputs.pos, this.prevCameraPos);
                     this.$l.clipPos = pb.mul(this.VPMatrix, pb.vec4(this.worldPos, 1));
                     this.$l.prevClipPos = pb.mul(this.prevVPMatrix, pb.vec4(this.prevWorldPos, 1));
-                    this.clipPos.z = this.clipPos.w;
+                    this.clipPos.z = ShaderHelper.farthestClipZ(this, this.clipPos.w);
                     this.$builtins.position = this.clipPos;
                     this.$outputs.currentPos = this.clipPos;
                     this.$outputs.prevPos = this.prevClipPos;
@@ -1246,7 +1540,7 @@ let _skyMVBox = null;
     device.pushDeviceStates();
     device.setProgram(_skyMVProgram);
     device.setBindGroup(0, _skyMVBindGroup);
-    device.setRenderStates(AbstractPostEffect.getDefaultRenderState(ctx, 'le'));
+    device.setRenderStates(AbstractPostEffect.getDefaultRenderState(ctx, DEPTH_COMPARE_DEFAULT));
     device.setFramebuffer(fb);
     _skyMVBox.draw();
     device.popDeviceStates();
@@ -1256,11 +1550,7 @@ function blitToCurrentColorAttachment(ctx, source) {
     const destination = framebuffer?.getColorAttachment(0) ?? null;
     new CopyBlitter().blit(source, destination, fetchSampler('clamp_nearest_nomip'));
 }
-/**
- * Renders the full scene (no transmission) into the scene-color copy texture
- * used as refraction background. Runs as its own graph pass before LightPass.
- * @internal
- */ function renderSceneColorGrab(frame, rgCtx, copyHandle, copyFramebufferHandle) {
+/** Render the refraction background before LightPass. @internal */ function renderSceneColorGrab(frame, rgCtx, copyHandle, copyFramebufferHandle) {
     const { ctx, renderQueue } = frame;
     const device = ctx.device;
     const depthTex = frame.depthFramebuffer?.getDepthAttachment();
@@ -1270,7 +1560,7 @@ function blitToCurrentColorAttachment(ctx, source) {
     const isolateSceneColorDepth = frame.options.needsTransmissionDepthForSSR;
     const savedDepthPrepassAttachment = ctx.depthPrepassAttachment;
     const savedMaterialFlags = ctx.materialFlags;
-    // MRT store flags never apply to the background copy
+    // The background copy has no surface MRT attachments.
     const sceneColorMaterialFlags = ctx.materialFlags & ~SURFACE_MRT_FLAGS;
     const sceneColorFramebuffer = copyFramebufferHandle ? rgCtx.getFramebuffer(copyFramebufferHandle) : rgCtx.createFramebuffer({
         width: copyTex.width,
@@ -1287,10 +1577,10 @@ function blitToCurrentColorAttachment(ctx, source) {
         _scenePass.transmission = false;
         if (isolateSceneColorDepth) {
             ctx.depthPrepassAttachment = undefined;
-            _scenePass.clearDepth = 1;
+            _scenePass.clearDepth = DEPTH_CLEAR_VALUE;
             _scenePass.clearStencil = 0;
         } else {
-            _scenePass.clearDepth = depthTex ? null : 1;
+            _scenePass.clearDepth = depthTex ? null : DEPTH_CLEAR_VALUE;
             _scenePass.clearStencil = depthTex ? null : 0;
         }
         ctx.materialFlags = sceneColorMaterialFlags;
@@ -1308,11 +1598,13 @@ function blitToCurrentColorAttachment(ctx, source) {
 }
 /** @internal */ function renderOpaqueScenePass(frame, sceneColorTex, sceneColorCopyTex, rgCtx, sceneColorFramebufferHandle) {
     const { ctx, renderQueue } = frame;
-    // Use RenderGraph-allocated scene color texture
     const depthTex = frame.depthFramebuffer?.getDepthAttachment();
-    ctx.materialFlags &= ~(MaterialVaryingFlags.SSR_STORE_ROUGHNESS | MaterialVaryingFlags.SSS_STORE_PROFILE | MaterialVaryingFlags.SSS_STORE_DIFFUSE | MaterialVaryingFlags.SSS_STORE_NORMAL | MaterialVaryingFlags.SSS_STORE_TRANSMISSION | MaterialVaryingFlags.SKIN_SSS_STORE);
-    if (ctx.SSR) {
-        ctx.materialFlags |= MaterialVaryingFlags.SSR_STORE_ROUGHNESS;
+    ctx.materialFlags &= ~(MaterialVaryingFlags.SCENE_STORE_ROUGHNESS | MaterialVaryingFlags.SSS_STORE_PROFILE | MaterialVaryingFlags.SSS_STORE_DIFFUSE | MaterialVaryingFlags.SCENE_STORE_NORMAL | MaterialVaryingFlags.SSS_STORE_TRANSMISSION | MaterialVaryingFlags.SKIN_SSS_STORE);
+    if (ctx.SceneRoughnessTexture) {
+        ctx.materialFlags |= MaterialVaryingFlags.SCENE_STORE_ROUGHNESS;
+    }
+    if (ctx.SceneNormalTexture) {
+        ctx.materialFlags |= MaterialVaryingFlags.SCENE_STORE_NORMAL;
     }
     if (ctx.SSS) {
         if (ctx.SSSDiffuseTexture) {
@@ -1325,11 +1617,7 @@ function blitToCurrentColorAttachment(ctx, source) {
     if (ctx.SkinSSSTexture) {
         ctx.materialFlags |= MaterialVaryingFlags.SKIN_SSS_STORE;
     }
-    // The graph scene color framebuffer takes priority: it is absent only when
-    // the graph was built in final-framebuffer-as-intermediate mode (external
-    // depth shared with the final framebuffer AND no opaque-layer effects).
-    // Checking the shared depth first would wrongly route the MRT/opaque-effect
-    // case into the single-color final framebuffer.
+    // Prefer the graph framebuffer; final-target mode has no graph framebuffer.
     if (sceneColorFramebufferHandle && !hasSurfaceMRT(ctx)) {
         ctx.intermediateFramebuffer = rgCtx.getFramebuffer(sceneColorFramebufferHandle);
     } else if (!sceneColorFramebufferHandle && depthTex === ctx.finalFramebuffer?.getDepthAttachment()) {
@@ -1342,32 +1630,23 @@ function blitToCurrentColorAttachment(ctx, source) {
             depthAttachment: depthTex
         });
     }
-    // The scene target is bound explicitly and the device state is restored at
-    // the end of this pass: graph passes never communicate through leftover
-    // device state. TransparentPass re-binds the same target (or the opaque
-    // chain output) explicitly.
+    // Graph passes do not communicate through leftover device state.
     ctx.device.pushDeviceStates();
     try {
-        // setFramebuffer() no-ops when the target is unchanged, so reset the
-        // viewport/scissor explicitly to cover that case.
+        // setFramebuffer may no-op, so reset viewport and scissor explicitly.
         ctx.device.setFramebuffer(ctx.intermediateFramebuffer);
         ctx.device.setViewport(null);
         ctx.device.setScissor(null);
         _scenePass.transmission = false;
-        _scenePass.clearDepth = depthTex ? null : 1;
+        _scenePass.renderSky = false;
+        _scenePass.clearDepth = depthTex ? null : DEPTH_CLEAR_VALUE;
         _scenePass.clearStencil = depthTex ? null : 0;
         if (renderQueue.needSceneColor() && sceneColorCopyTex) {
-            // Background copy was produced by the SceneColorGrab pass; seed the main
-            // color attachment with it and render only transmission/transparent on top.
+            // Seed the main target with the refraction background.
             ctx.sceneColorTexture = sceneColorCopyTex;
             blitToCurrentColorAttachment(ctx, ctx.sceneColorTexture);
             if (hasSurfaceMRT(ctx)) {
-                // The background copy carries no surface MRT attachments, so opaque
-                // geometry exists only there without roughness/normal (and SSS
-                // lighting) data. Re-render the opaque lists into the MRT scene
-                // target: early-z against the prepass depth keeps this cheap, and the
-                // color output matches the blitted copy on opaque pixels while the
-                // MRT attachments receive the surface data SSR/SSS require.
+                // Re-render opaque lists to populate MRT data missing from the copy.
                 _scenePass.clearColor = null;
                 _scenePass.clearDepth = null;
                 _scenePass.clearStencil = null;
@@ -1384,28 +1663,49 @@ function blitToCurrentColorAttachment(ctx, source) {
         _scenePass.renderTransparent = false;
         _scenePass.render(ctx, null, null, renderQueue);
     } finally{
-        // Restore the shared _scenePass flags so no state leaks to the next pass:
-        // the transparent pass sets transmission/renderOpaque/renderTransparent
-        // itself rather than inheriting whatever this pass happened to leave.
+        // Restore shared pass flags before the next graph pass.
         _scenePass.renderTransparent = true;
+        _scenePass.renderSky = true;
         _scenePass.transmission = false;
         ctx.device.popDeviceStates();
     }
 }
-/**
- * Renders the transmission/transparent geometry lists (including OIT) on top
- * of the opaque result. The target framebuffer is always bound explicitly:
- * the opaque chain output when opaque-layer effects ran, otherwise the same
- * scene target the light pass rendered into. OIT implementations composite
- * into the currently bound framebuffer, which this pass guarantees.
- * @internal
- */ function renderTransparentScenePass(frame, rgCtx, opaqueChainOutput, sceneColorFramebufferHandle) {
+/** Render sky and fog after opaque geometry. @internal */ function renderSkyScenePass(frame, rgCtx, sceneColorFramebufferHandle, sceneColorNoFog) {
+    const { ctx } = frame;
+    const framebuffer = sceneColorFramebufferHandle ? rgCtx.getFramebuffer(sceneColorFramebufferHandle) : ctx.finalFramebuffer;
+    const device = ctx.device;
+    device.pushDeviceStates();
+    try {
+        device.setFramebuffer(framebuffer);
+        device.setViewport(null);
+        device.setScissor(null);
+        ctx.scene.env.sky.renderSky(ctx);
+        if (ctx.scene.env.sky.fogPresents) {
+            // Snapshot between sky and fog. Sky belongs in the copy - a ray that hits
+            // the sky should read the sky - while fog does not, because the fog a
+            // screen-space pass would sample lies along the camera ray rather than the
+            // path it integrates.
+            if (sceneColorNoFog) {
+                const source = framebuffer?.getColorAttachment(0) ?? null;
+                if (source) {
+                    new CopyBlitter().blit(source, sceneColorNoFog, fetchSampler('clamp_nearest_nomip'));
+                    device.setFramebuffer(framebuffer);
+                    device.setViewport(null);
+                    device.setScissor(null);
+                }
+            }
+            ctx.scene.env.sky.renderFog(ctx.camera);
+        }
+    } finally{
+        device.popDeviceStates();
+    }
+}
+/** Render transmission, transparency, and OIT over the opaque result. @internal */ function renderTransparentScenePass(frame, rgCtx, opaqueChainOutput, sceneColorFramebufferHandle) {
     const { ctx, renderQueue } = frame;
     const device = ctx.device;
     let framebuffer;
     if (opaqueChainOutput) {
-        // Opaque-layer effects redirected the scene color into their chain output;
-        // transparent geometry renders on top of it with the scene depth attached.
+        // Opaque effects redirect transparent rendering to their chain output.
         const chainTex = rgCtx.getTexture(opaqueChainOutput);
         const depthTex = frame.depthFramebuffer?.getDepthAttachment();
         framebuffer = rgCtx.createFramebuffer({
@@ -1414,39 +1714,34 @@ function blitToCurrentColorAttachment(ctx, source) {
             colorAttachments: chainTex,
             depthAttachment: depthTex
         });
-        // The chain output is single-color: surface MRT stores no longer apply.
+        // The chain output has no surface MRT attachments.
         ctx.materialFlags &= ~SURFACE_MRT_FLAGS;
     } else if (sceneColorFramebufferHandle) {
-        // No opaque-layer effect ran (thus no surface MRT either): continue in the
-        // graph scene color framebuffer the light pass rendered into.
+        // Continue in the light pass target when no opaque effect ran.
         framebuffer = rgCtx.getFramebuffer(sceneColorFramebufferHandle);
     } else {
-        // Final framebuffer used as scene intermediate.
+        // Scene color already resides in the final framebuffer.
         framebuffer = ctx.finalFramebuffer;
     }
     device.pushDeviceStates();
     try {
-        // setFramebuffer() no-ops when the target is unchanged, so reset the
-        // viewport/scissor explicitly to cover that case.
+        // setFramebuffer may no-op, so reset viewport and scissor explicitly.
         device.setFramebuffer(framebuffer);
         device.setViewport(null);
         device.setScissor(null);
-        // Derive transmission mode from the same single source of truth the opaque
-        // pass used (renderQueue.needSceneColor()) instead of inheriting leftover
-        // _scenePass state. When scene color is needed the opaque pass seeded the
-        // refraction background and drew the transmission-opaque list, so here we
-        // draw transmission_trans + transparent; otherwise just the transparent
-        // list. Never clear: the opaque result is already in the target.
+        // Derive transmission mode instead of inheriting shared pass state.
         _scenePass.transmission = renderQueue.needSceneColor();
         _scenePass.clearColor = null;
         _scenePass.clearDepth = null;
         _scenePass.clearStencil = null;
         _scenePass.renderOpaque = false;
         _scenePass.renderTransparent = true;
+        _scenePass.renderSky = false;
         try {
             _scenePass.render(ctx, null, null, renderQueue);
         } finally{
             _scenePass.renderOpaque = true;
+            _scenePass.renderSky = true;
         }
     } finally{
         device.popDeviceStates();
@@ -1455,38 +1750,7 @@ function blitToCurrentColorAttachment(ctx, source) {
 /** @internal */ function renderTransmissionDepthPass(frame, rgCtx) {
     renderSceneDepth(frame, frame.depthFramebuffer, rgCtx);
 }
-/**
- * Frame-tail housekeeping shared by the Present and FrameCleanup passes.
- *
- * The end-layer post effect chain and the final blit are graph passes now
- * (see buildForwardPlusGraphInternal step 9/10); this only releases per-frame
- * state. The compositor's scene ping-pong is flushed back to the intermediate
- * framebuffer by compositor.end() at the tail of the light pass.
- *
- * @internal
- */ function finishFrame(frame) {
-    const { ctx } = frame;
-    disposeRenderQueue(frame);
-    ctx.materialFlags &= ~MaterialVaryingFlags.SSR_STORE_ROUGHNESS;
-    ctx.materialFlags &= ~MaterialVaryingFlags.SSS_STORE_PROFILE;
-    ctx.materialFlags &= ~MaterialVaryingFlags.SSS_STORE_DIFFUSE;
-    ctx.materialFlags &= ~MaterialVaryingFlags.SSS_STORE_NORMAL;
-    ctx.materialFlags &= ~MaterialVaryingFlags.SSS_STORE_TRANSMISSION;
-    ctx.materialFlags &= ~MaterialVaryingFlags.SKIN_SSS_STORE;
-    releaseIntermediateFramebuffer(frame);
-    releaseDepthFramebuffer(frame);
-    releaseClusteredLight(frame);
-    restoreSunLight(frame);
-}
-// ─── Convenience: Execute Full Pipeline ─────────────────────────────
-/**
- * Build, compile, and execute the forward+ pipeline as a render graph.
- *
- * This is the drop-in replacement for `SceneRenderer._renderScene`.
- *
- * @param ctx - The draw context for this frame.
- * @public
- */ function executeForwardPlusGraph(ctx) {
+/** Build and execute the Forward+ graph for one frame. @public */ function executeForwardPlusGraph(ctx) {
     const device = ctx.device;
     const graph = new RenderGraph();
     let renderQueue = null;
@@ -1494,34 +1758,55 @@ function blitToCurrentColorAttachment(ctx, source) {
     let executor = null;
     let historyManager = null;
     let historyFrameStarted = false;
+    let motionVectorFramePrepared = false;
+    let motionVectorFrameCommitted = false;
     try {
-        // Cull scene first (needed to derive options)
         renderQueue = _scenePass.cullScene(ctx, ctx.camera);
         const options = deriveForwardPlusOptions(ctx.scene, ctx.camera, device.type, renderQueue);
+        options.ssgi &&= supportsSSGIRenderTargets(ctx);
         ctx.SSS = options.sss;
-        // Ensure the camera has a history resource manager for temporal effects (TAA, motion blur)
         historyManager = ctx.camera.getHistoryResourceManager();
         if (!historyManager) {
             historyManager = new HistoryResourceManager(_devicePoolAllocator);
             ctx.camera.setHistoryResourceManager(historyManager);
         }
+        if (!options.ssgi) {
+            historyManager.invalidate(RGHistoryResources.SSGI_SCENE_COLOR);
+            historyManager.invalidate(RGHistoryResources.SSGI_IRRADIANCE);
+            historyManager.invalidate(RGHistoryResources.SSGI_SURFACE);
+            historyManager.invalidate(RGHistoryResources.SSGI_MOMENTS);
+        }
         historyManager.beginFrame();
         historyFrameStarted = true;
         const buildResult = buildForwardPlusGraphInternal(graph, ctx, renderQueue, options);
         frame = buildResult.frame;
+        if (options.motionVectors) {
+            ctx.camera.prepareMotionVectorFrame(ctx.camera.TAA, ctx.renderWidth, ctx.renderHeight);
+            motionVectorFramePrepared = true;
+        } else {
+            ctx.camera.clearMotionVectorFrame();
+        }
         const compiled = graph.compile([
             buildResult.backbuffer
         ]);
-        // Use RenderGraphExecutor for automatic resource management
-        executor = new RenderGraphExecutor(_devicePoolAllocator, ctx.renderWidth, ctx.renderHeight);
-        // Register imported backbuffer (if using finalFramebuffer)
+        executor = new RenderGraphExecutor(_devicePoolAllocator, ctx.renderWidth, ctx.renderHeight, {
+            textureAffinityCache: getTextureAffinityCache(ctx.camera, device)
+        });
         if (ctx.finalFramebuffer) {
             const backbufferTex = ctx.finalFramebuffer.getColorAttachments()[0];
             executor.setImportedTexture(buildResult.backbuffer, backbufferTex);
         }
+        if (buildResult.externalDepthImport) {
+            executor.setImportedTexture(buildResult.externalDepthImport.handle, buildResult.externalDepthImport.texture);
+        }
         historyManager.bindImportedTextures(executor);
         executor.execute(compiled);
         historyManager.commitFrame();
+        historyFrameStarted = false;
+        if (motionVectorFramePrepared) {
+            ctx.camera.commitMotionVectorFrame();
+            motionVectorFrameCommitted = true;
+        }
     } finally{
         if (historyFrameStarted) {
             historyManager?.discardFrame();
@@ -1532,8 +1817,11 @@ function blitToCurrentColorAttachment(ctx, source) {
             renderQueue?.dispose();
         }
         executor?.reset();
+        if (motionVectorFramePrepared && !motionVectorFrameCommitted) {
+            ctx.camera.clearMotionVectorFrame();
+        }
     }
 }
 
-export { buildForwardPlusGraph, deriveForwardPlusOptions, executeForwardPlusGraph };
+export { ForwardPlusModules, buildForwardPlusGraph, createForwardPlusPipeline, deriveForwardPlusOptions, executeForwardPlusGraph, getDefaultForwardPlusPipeline, renderOpaqueScenePass, renderSkyScenePass, renderTransparentScenePass };
 //# sourceMappingURL=forward_plus_builder.js.map