@zephyr3d/scene 0.9.1 → 0.9.3

package/dist/render/rendergraph/forward_plus_builder.js

@@ -14,6 +14,7 @@ import { RenderGraph } from './rendergraph.js';
 import { RenderGraphExecutor } from './executor.js';
 import { DevicePoolAllocator } from './device_pool_allocator.js';
 import { HistoryResourceManager } from './history_resource_manager.js';
+import { RGHistoryResources } from './history_resources.js';
 import { renderObjectColors } from '../gpu_picking.js';
 import { BoxShape } from '../../shapes/box.js';
 import '../../shapes/capsule.js';
@@ -58,7 +59,7 @@ function freeClusteredLight(cl) {
  *
  * Each step in the existing `SceneRenderer._renderScene` becomes a graph pass.
  * Execute callbacks delegate to the existing rendering code, sharing a mutable
- * {@link FrameState}.
+ * `FrameState`.
  *
  * @param graph - The render graph to populate.
  * @param ctx - The draw context for this frame.
@@ -68,6 +69,9 @@ function freeClusteredLight(cl) {
  *
  * @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');
     // Shared mutable frame state
     const frame = {
@@ -75,26 +79,37 @@ function freeClusteredLight(cl) {
         renderQueue,
         depthFramebuffer: null,
         sunLightColor: null,
-        options
+        options,
+        intermediateDeviceStatePushed: false,
+        renderQueueDisposed: false,
+        clusteredLightReleased: false,
+        sunLightRestored: false
     };
     // ── 1. Sky Update ─────────────────────────────────────────────────
-    graph.addPass('SkyUpdate', (builder)=>{
+    let orderToken = graph.addPass('SkyUpdate', (builder)=>{
+        const done = builder.createToken('SkyUpdateDone');
         builder.sideEffect();
         builder.setExecute(()=>{
             frame.sunLightColor = ctx.scene.env.sky.update(ctx);
         });
+        return done;
     });
     // ── 2. Clustered Light Setup ──────────────────────────────────────
-    graph.addPass('ClusterLights', (builder)=>{
+    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);
         });
+        return done;
     });
     // ── 3. GPU Picking (optional, sideEffect) ─────────────────────────
     if (options.gpuPicking) {
-        graph.addPass('GPUPicking', (builder)=>{
+        orderToken = graph.addPass('GPUPicking', (builder)=>{
+            builder.read(orderToken);
+            const done = builder.createToken('GPUPickingDone');
             builder.sideEffect();
             builder.setExecute(()=>{
                 const pickResolveFunc = ctx.camera.getPickResultResolveFunc();
@@ -102,21 +117,26 @@ function freeClusteredLight(cl) {
                     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) {
-        graph.addPass('ShadowMaps', (builder)=>{
+        orderToken = graph.addPass('ShadowMaps', (builder)=>{
+            builder.read(orderToken);
+            const done = builder.createToken('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({
@@ -127,28 +147,67 @@ function freeClusteredLight(cl) {
             format: mvFormat,
             label: 'motionVector'
         }) : undefined;
-        builder.setExecute((rgCtx)=>{
-            const depthTex = rgCtx.getTexture(depthHandle);
-            const mvTex = motionVectorHandle ? rgCtx.getTexture(motionVectorHandle) : null;
-            frame.depthFramebuffer = renderSceneDepth(frame, null, depthTex, mvTex);
+        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 ? [
+                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
+            motionVectorHandle,
+            graphDepthAttachmentHandle,
+            externalDepthAttachment,
+            depthFramebufferHandle
         };
     });
     const depthHandle = depthPassResult.depthHandle;
     const motionVectorHandle = depthPassResult.motionVectorHandle;
+    const renderDepthAttachment = depthPassResult.graphDepthAttachmentHandle ?? depthPassResult.externalDepthAttachment ?? null;
     // ── 6. Hi-Z (optional) ───────────────────────────────────────────
     let hiZHandle;
     if (options.hiZ) {
         graph.addPass('HiZ', (builder)=>{
             builder.read(depthHandle);
+            builder.read(depthPassResult.depthFramebufferHandle);
             hiZHandle = builder.createTexture({
                 format: 'r32f',
                 label: 'hiZ',
                 mipLevels: 10
             });
+            const hiZFramebufferHandle = builder.createFramebuffer({
+                label: 'HiZFramebuffer',
+                colorAttachments: hiZHandle,
+                depthAttachment: null
+            });
             builder.setExecute((rgCtx)=>{
                 const ctx = frame.ctx;
                 // Use the depth texture from the framebuffer (which contains the RenderGraph texture)
@@ -156,12 +215,9 @@ function freeClusteredLight(cl) {
                 if (depthTex) {
                     // Get the HiZ texture allocated by the executor
                     const hiZTex = rgCtx.getTexture(hiZHandle);
-                    const w = hiZTex.width;
-                    const h = hiZTex.height;
-                    const HiZFrameBuffer = ctx.device.pool.fetchTemporalFramebuffer(false, w, h, hiZTex, null, false);
+                    const HiZFrameBuffer = rgCtx.getFramebuffer(hiZFramebufferHandle);
                     buildHiZ(depthTex, HiZFrameBuffer);
                     ctx.HiZTexture = hiZTex;
-                    ctx.device.pool.releaseFrameBuffer(HiZFrameBuffer);
                 }
             });
         });
@@ -169,6 +225,7 @@ function freeClusteredLight(cl) {
     // ── 7. Main Light Pass ────────────────────────────────────────────
     const lightPassResult = graph.addPass('LightPass', (builder)=>{
         builder.read(depthHandle);
+        builder.read(depthPassResult.depthFramebufferHandle);
         if (hiZHandle) {
             builder.read(hiZHandle);
         }
@@ -185,29 +242,118 @@ function freeClusteredLight(cl) {
                 label: 'sceneColorCopy'
             });
         }
+        const useFinalFramebufferAsIntermediate = !!depthPassResult.externalDepthAttachment && depthPassResult.externalDepthAttachment === ctx.finalFramebuffer?.getDepthAttachment();
+        const sceneColorFramebufferHandle = useFinalFramebufferAsIntermediate ? undefined : builder.createFramebuffer({
+            label: 'SceneColorFramebuffer',
+            width: ctx.renderWidth,
+            height: ctx.renderHeight,
+            colorAttachments: sceneColorHandle,
+            depthAttachment: renderDepthAttachment
+        });
+        const sceneColorCopyFramebufferHandle = sceneColorCopyHandle ? builder.createFramebuffer({
+            label: 'SceneColorCopyFramebuffer',
+            width: ctx.renderWidth,
+            height: ctx.renderHeight,
+            colorAttachments: sceneColorCopyHandle,
+            depthAttachment: renderDepthAttachment,
+            ignoreDepthStencil: false
+        }) : undefined;
         builder.setExecute((rgCtx)=>{
             const sceneColorTex = rgCtx.getTexture(sceneColorHandle);
             const sceneColorCopyTex = sceneColorCopyHandle ? rgCtx.getTexture(sceneColorCopyHandle) : null;
-            renderMainLightPass(frame, sceneColorTex, sceneColorCopyTex);
+            renderMainLightPass(frame, sceneColorTex, sceneColorCopyTex, rgCtx, sceneColorFramebufferHandle, sceneColorCopyFramebufferHandle);
         });
         return {
             sceneColorHandle,
-            sceneColorCopyHandle
+            sceneColorCopyHandle,
+            sceneColorFramebufferHandle
         };
     });
     const sceneColorHandle = lightPassResult.sceneColorHandle;
-    // ── 8. Post Effects + Final Composite ─────────────────────────────
-    graph.addPass('Composite', (builder)=>{
+    const historyManager = ctx.camera?.getHistoryResourceManager?.() ?? null;
+    const historyReadBindings = [];
+    if (historyManager && ctx.camera?.TAA && options.motionVectors) {
+        const historySize = {
+            width: ctx.renderWidth,
+            height: ctx.renderHeight
+        };
+        const colorHistoryHandle = historyManager.importPreviousIfCompatible(graph, RGHistoryResources.TAA_COLOR, {
+            format: ctx.colorFormat,
+            sizeMode: 'absolute',
+            width: ctx.renderWidth,
+            height: ctx.renderHeight
+        }, historySize);
+        const motionVectorHistoryHandle = historyManager.importPreviousIfCompatible(graph, RGHistoryResources.TAA_MOTION_VECTOR, {
+            format: 'rgba16f',
+            sizeMode: 'absolute',
+            width: ctx.renderWidth,
+            height: ctx.renderHeight
+        }, historySize);
+        if (colorHistoryHandle && motionVectorHistoryHandle) {
+            historyReadBindings.push({
+                name: RGHistoryResources.TAA_COLOR,
+                handle: colorHistoryHandle
+            }, {
+                name: RGHistoryResources.TAA_MOTION_VECTOR,
+                handle: motionVectorHistoryHandle
+            });
+        }
+    }
+    // 8. Transmission depth pass (optional)
+    let transmissionDepthToken;
+    if (options.needSceneColor) {
+        transmissionDepthToken = graph.addPass('TransmissionDepth', (builder)=>{
+            builder.read(sceneColorHandle);
+            builder.read(depthPassResult.depthFramebufferHandle);
+            const done = builder.createToken('TransmissionDepthDone');
+            builder.sideEffect();
+            builder.setExecute((rgCtx)=>{
+                renderTransmissionDepthPass(frame, rgCtx);
+            });
+            return done;
+        });
+    }
+    // 9. Post effects + final composite
+    const presentedBackbuffer = graph.addPass('Composite', (builder)=>{
         builder.read(sceneColorHandle);
+        builder.read(depthHandle);
+        if (hiZHandle) {
+            builder.read(hiZHandle);
+        }
         if (motionVectorHandle) {
             builder.read(motionVectorHandle);
         }
-        builder.write(backbuffer);
-        builder.setExecute(()=>{
-            renderComposite(frame);
+        if (lightPassResult.sceneColorFramebufferHandle) {
+            builder.read(lightPassResult.sceneColorFramebufferHandle);
+        }
+        if (transmissionDepthToken) {
+            builder.read(transmissionDepthToken);
+        }
+        for (const binding of historyReadBindings){
+            builder.read(binding.handle);
+        }
+        const outputBackbuffer = builder.write(backbuffer);
+        builder.setExecute((rgCtx)=>{
+            if (historyManager && historyReadBindings.length > 0) {
+                historyManager.beginReadScope(historyReadBindings.map((binding)=>({
+                        name: binding.name,
+                        texture: rgCtx.getTexture(binding.handle)
+                    })));
+                try {
+                    renderComposite(frame);
+                } finally{
+                    historyManager.endReadScope();
+                }
+            } else {
+                renderComposite(frame);
+            }
         });
+        return outputBackbuffer;
     });
-    return backbuffer;
+    return {
+        backbuffer: presentedBackbuffer,
+        frame
+    };
 }
 // ─── Pass Implementation Helpers ────────────────────────────────────
 // These wrap the existing SceneRenderer static methods, adapted to work
@@ -216,82 +362,140 @@ function freeClusteredLight(cl) {
 /** @internal */ function renderShadowMaps(ctx, lights) {
     ctx.renderPass = _shadowMapPass;
     ctx.device.pushDeviceStates();
-    for (const light of lights){
-        light.shadow.render(ctx, _shadowMapPass);
+    try {
+        for (const light of lights){
+            light.shadow.render(ctx, _shadowMapPass);
+        }
+    } finally{
+        ctx.device.popDeviceStates();
+    }
+}
+function releaseIntermediateFramebuffer(frame) {
+    const { ctx } = frame;
+    if (frame.intermediateDeviceStatePushed) {
+        ctx.device.popDeviceStates();
+        frame.intermediateDeviceStatePushed = false;
     }
-    ctx.device.popDeviceStates();
+    ctx.intermediateFramebuffer = null;
 }
-/** @internal */ function renderSceneDepth(frame, existingDepthFb, depthTex, motionVectorTex) {
+function releaseDepthFramebuffer(frame) {
+    frame.depthFramebuffer = null;
+}
+function disposeRenderQueue(frame) {
+    if (!frame.renderQueueDisposed) {
+        frame.renderQueue.dispose();
+        frame.renderQueueDisposed = true;
+    }
+}
+function releaseClusteredLight(frame) {
+    if (!frame.clusteredLightReleased && frame.ctx.clusteredLight) {
+        freeClusteredLight(frame.ctx.clusteredLight);
+        frame.ctx.clusteredLight = undefined;
+        frame.clusteredLightReleased = true;
+    }
+}
+function restoreSunLight(frame) {
+    if (!frame.sunLightRestored && frame.sunLightColor && frame.ctx.sunLight) {
+        frame.ctx.sunLight.color = frame.sunLightColor;
+        frame.sunLightRestored = true;
+    }
+}
+function cleanupFrame(frame) {
+    releaseIntermediateFramebuffer(frame);
+    releaseDepthFramebuffer(frame);
+    releaseClusteredLight(frame);
+    disposeRenderQueue(frame);
+    restoreSunLight(frame);
+}
+/** @internal */ function renderSceneDepth(frame, existingDepthFb, rgCtx, depthTex, motionVectorTex, transmissionOverride) {
     const ctx = frame.ctx;
     const renderQueue = frame.renderQueue;
-    const transmission = !!existingDepthFb;
+    const transmission = transmissionOverride ?? !!existingDepthFb;
     let depthFramebuffer = existingDepthFb;
     if (!depthFramebuffer) {
         // Use RenderGraph-allocated textures if provided
-        if (depthTex) {
-            const colorAttachments = motionVectorTex ? [
-                depthTex,
-                motionVectorTex
-            ] : depthTex;
-            const depthAttachment = ctx.finalFramebuffer?.getDepthAttachment();
-            const depthTexOrFormat = depthAttachment?.isTexture2D() ? depthAttachment : ctx.depthFormat;
-            depthFramebuffer = ctx.device.pool.fetchTemporalFramebuffer(true, depthTex.width, depthTex.height, colorAttachments, depthTexOrFormat, false);
-        } else {
-            // Fallback: allocate from pool (legacy path)
+        {
+            // 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) {
-                depthFramebuffer = ctx.device.pool.fetchTemporalFramebuffer(true, ctx.renderWidth, ctx.renderHeight, ctx.motionVectors ? [
-                    format,
-                    mvFormat
-                ] : format, ctx.depthFormat, false);
+                depthFramebuffer = rgCtx.createFramebuffer({
+                    width: ctx.renderWidth,
+                    height: ctx.renderHeight,
+                    colorAttachments: ctx.motionVectors ? [
+                        format,
+                        mvFormat
+                    ] : format,
+                    depthAttachment: ctx.depthFormat,
+                    ignoreDepthStencil: false
+                });
             } else {
                 const originDepth = ctx.finalFramebuffer?.getDepthAttachment();
-                depthFramebuffer = originDepth?.isTexture2D() ? ctx.device.pool.fetchTemporalFramebuffer(true, originDepth.width, originDepth.height, ctx.motionVectors ? [
-                    format,
-                    mvFormat
-                ] : format, originDepth, false) : ctx.device.pool.fetchTemporalFramebuffer(true, ctx.renderWidth, ctx.renderHeight, ctx.motionVectors ? [
-                    format,
-                    mvFormat
-                ] : format, ctx.depthFormat, false);
+                if (originDepth?.isTexture2D()) {
+                    depthFramebuffer = rgCtx.createFramebuffer({
+                        width: originDepth.width,
+                        height: originDepth.height,
+                        colorAttachments: ctx.motionVectors ? [
+                            format,
+                            mvFormat
+                        ] : format,
+                        depthAttachment: originDepth,
+                        ignoreDepthStencil: false
+                    });
+                } else {
+                    depthFramebuffer = rgCtx.createFramebuffer({
+                        width: ctx.renderWidth,
+                        height: ctx.renderHeight,
+                        colorAttachments: ctx.motionVectors ? [
+                            format,
+                            mvFormat
+                        ] : format,
+                        depthAttachment: ctx.depthFormat,
+                        ignoreDepthStencil: false
+                    });
+                }
             }
         }
     }
+    if (!transmission) {
+        frame.depthFramebuffer = depthFramebuffer;
+    }
     ctx.device.pushDeviceStates();
-    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.clearStencil = null;
-    _depthPass.transmission = transmission;
-    if (ctx.SSRCalcThickness && !transmission) {
-        if (!_backDepthColorState) {
-            _backDepthColorState = ctx.device.createColorState().setColorMask(false, true, false, false);
-        }
-        if (!_frontDepthColorState) {
-            _frontDepthColorState = ctx.device.createColorState().setColorMask(true, false, false, false);
+    try {
+        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.clearStencil = null;
+        _depthPass.transmission = transmission;
+        if (ctx.SSRCalcThickness && !transmission) {
+            if (!_backDepthColorState) {
+                _backDepthColorState = ctx.device.createColorState().setColorMask(false, true, false, false);
+            }
+            if (!_frontDepthColorState) {
+                _frontDepthColorState = ctx.device.createColorState().setColorMask(true, false, false, false);
+            }
+            ctx.forceColorState = _backDepthColorState;
+            ctx.forceCullMode = 'front';
+            _depthPass.renderBackface = true;
+            _depthPass.transmission = false;
+            _depthPass.render(ctx, null, null, renderQueue);
+            _depthPass.clearColor = null;
+            _depthPass.renderBackface = false;
+            ctx.forceColorState = _frontDepthColorState;
+            ctx.forceCullMode = null;
         }
-        ctx.forceColorState = _backDepthColorState;
-        ctx.forceCullMode = 'front';
-        _depthPass.renderBackface = true;
-        _depthPass.transmission = false;
         _depthPass.render(ctx, null, null, renderQueue);
-        _depthPass.clearColor = null;
-        _depthPass.renderBackface = false;
-        ctx.forceColorState = _frontDepthColorState;
+    } finally{
+        ctx.forceColorState = null;
         ctx.forceCullMode = null;
+        _depthPass.renderBackface = false;
+        ctx.device.popDeviceStates();
     }
-    _depthPass.render(ctx, null, null, renderQueue);
-    ctx.forceColorState = null;
-    ctx.device.popDeviceStates();
     if (!transmission) {
         ctx.motionVectorTexture = ctx.motionVectors ? depthFramebuffer.getColorAttachments()[1] : null;
         ctx.linearDepthTexture = depthFramebuffer.getColorAttachments()[0];
         ctx.depthTexture = depthFramebuffer.getDepthAttachment();
-        if (ctx.motionVectorTexture) {
-            // Sky motion vectors rendering is handled inline
-            renderSkyMotionVectors(ctx);
-        }
     // HiZ is now built in the dedicated HiZ pass
     }
     return depthFramebuffer;
@@ -300,12 +504,15 @@ function freeClusteredLight(cl) {
 let _skyMVProgram = null;
 let _skyMVBindGroup = null;
 let _skyMVBox = null;
-/** @internal */ function renderSkyMotionVectors(ctx) {
+/** @internal */ function renderSkyMotionVectors(ctx, rgCtx, framebufferHandle) {
     if (!ctx.motionVectorTexture) {
         return;
     }
     const device = ctx.device;
-    const fb = device.pool.fetchTemporalFramebuffer(false, 0, 0, ctx.motionVectorTexture, ctx.depthTexture);
+    const fb = framebufferHandle ? rgCtx.getFramebuffer(framebufferHandle) : rgCtx.createFramebuffer({
+        colorAttachments: ctx.motionVectorTexture,
+        depthAttachment: ctx.depthTexture
+    });
     if (!_skyMVProgram) {
         _skyMVProgram = device.buildRenderProgram({
             vertex (pb) {
@@ -356,20 +563,27 @@ let _skyMVBox = null;
     device.setFramebuffer(fb);
     _skyMVBox.draw();
     device.popDeviceStates();
-    device.pool.releaseFrameBuffer(fb);
 }
-/** @internal */ function renderMainLightPass(frame, sceneColorTex, sceneColorCopyTex) {
+/** @internal */ function renderMainLightPass(frame, sceneColorTex, sceneColorCopyTex, rgCtx, sceneColorFramebufferHandle, sceneColorCopyFramebufferHandle) {
     const { ctx, renderQueue } = frame;
     const device = ctx.device;
     // Use RenderGraph-allocated scene color texture
     const depthTex = frame.depthFramebuffer?.getDepthAttachment();
     if (depthTex === ctx.finalFramebuffer?.getDepthAttachment()) {
         ctx.intermediateFramebuffer = ctx.finalFramebuffer;
+    } else if (sceneColorFramebufferHandle) {
+        ctx.intermediateFramebuffer = rgCtx.getFramebuffer(sceneColorFramebufferHandle);
     } else {
-        ctx.intermediateFramebuffer = device.pool.fetchTemporalFramebuffer(false, sceneColorTex.width, sceneColorTex.height, sceneColorTex, depthTex);
+        ctx.intermediateFramebuffer = rgCtx.createFramebuffer({
+            width: sceneColorTex.width,
+            height: sceneColorTex.height,
+            colorAttachments: sceneColorTex,
+            depthAttachment: depthTex
+        });
     }
     if (ctx.intermediateFramebuffer && ctx.intermediateFramebuffer !== ctx.finalFramebuffer) {
         device.pushDeviceStates();
+        frame.intermediateDeviceStatePushed = true;
         device.setFramebuffer(ctx.intermediateFramebuffer);
     } else {
         device.setViewport(null);
@@ -386,48 +600,58 @@ let _skyMVBox = null;
         const compositor = ctx.compositor;
         ctx.compositor = null;
         // Use RenderGraph-allocated sceneColorCopy texture
-        const sceneColorFramebuffer = device.pool.fetchTemporalFramebuffer(true, sceneColorCopyTex.width, sceneColorCopyTex.height, ctx.materialFlags & MaterialVaryingFlags.SSR_STORE_ROUGHNESS ? [
-            sceneColorCopyTex,
-            device.getFramebuffer().getColorAttachments()[1],
-            device.getFramebuffer().getColorAttachments()[2]
-        ] : sceneColorCopyTex, depthTex, false);
-        device.pushDeviceStates();
-        device.setFramebuffer(sceneColorFramebuffer);
-        _scenePass.transmission = false;
-        _scenePass.render(ctx, null, null, renderQueue);
-        device.popDeviceStates();
+        const sceneColorFramebuffer = sceneColorCopyFramebufferHandle && !(ctx.materialFlags & MaterialVaryingFlags.SSR_STORE_ROUGHNESS) ? rgCtx.getFramebuffer(sceneColorCopyFramebufferHandle) : rgCtx.createFramebuffer({
+            width: sceneColorCopyTex.width,
+            height: sceneColorCopyTex.height,
+            colorAttachments: ctx.materialFlags & MaterialVaryingFlags.SSR_STORE_ROUGHNESS ? [
+                sceneColorCopyTex,
+                device.getFramebuffer().getColorAttachments()[1],
+                device.getFramebuffer().getColorAttachments()[2]
+            ] : sceneColorCopyTex,
+            depthAttachment: depthTex,
+            ignoreDepthStencil: false
+        });
+        let sceneColorStatePushed = false;
+        try {
+            device.pushDeviceStates();
+            sceneColorStatePushed = true;
+            device.setFramebuffer(sceneColorFramebuffer);
+            _scenePass.transmission = false;
+            _scenePass.render(ctx, null, null, renderQueue);
+        } finally{
+            if (sceneColorStatePushed) {
+                device.popDeviceStates();
+            }
+            ctx.compositor = compositor;
+        }
         ctx.sceneColorTexture = sceneColorCopyTex;
         new CopyBlitter().blit(ctx.sceneColorTexture, device.getFramebuffer() ?? null, fetchSampler('clamp_nearest_nomip'));
         _scenePass.transmission = true;
         _scenePass.clearColor = null;
         _scenePass.clearDepth = null;
         _scenePass.clearStencil = null;
-        ctx.compositor = compositor;
     }
     _scenePass.render(ctx, null, null, renderQueue);
-    if (renderQueue.needSceneColor()) {
-        renderSceneDepth(frame, frame.depthFramebuffer);
-    }
+}
+/** @internal */ function renderTransmissionDepthPass(frame, rgCtx) {
+    renderSceneDepth(frame, frame.depthFramebuffer, rgCtx);
 }
 /** @internal */ function renderComposite(frame) {
-    const { ctx, renderQueue } = frame;
-    const device = ctx.device;
+    const { ctx } = frame;
     ctx.compositor?.drawPostEffects(ctx, PostEffectLayer.end, ctx.linearDepthTexture);
     ctx.compositor?.end(ctx);
-    renderQueue.dispose();
+    disposeRenderQueue(frame);
     ctx.materialFlags &= ~MaterialVaryingFlags.SSR_STORE_ROUGHNESS;
     if (ctx.intermediateFramebuffer && ctx.intermediateFramebuffer !== ctx.finalFramebuffer) {
         const blitter = new CopyBlitter();
         blitter.srgbOut = !ctx.finalFramebuffer;
         const srcTex = ctx.intermediateFramebuffer.getColorAttachments()[0];
         blitter.blit(srcTex, ctx.finalFramebuffer ?? null, fetchSampler('clamp_nearest_nomip'));
-        device.popDeviceStates();
-        device.pool.releaseFrameBuffer(ctx.intermediateFramebuffer);
-    }
-    freeClusteredLight(ctx.clusteredLight);
-    if (frame.sunLightColor) {
-        ctx.sunLight.color = frame.sunLightColor;
     }
+    releaseIntermediateFramebuffer(frame);
+    releaseDepthFramebuffer(frame);
+    releaseClusteredLight(frame);
+    restoreSunLight(frame);
 }
 // ─── Convenience: Execute Full Pipeline ─────────────────────────────
 /**
@@ -449,7 +673,8 @@ let _skyMVBox = null;
         historyManager = new HistoryResourceManager(_devicePoolAllocator);
         ctx.camera.setHistoryResourceManager(historyManager);
     }
-    const backbuffer = buildForwardPlusGraph(graph, ctx, renderQueue, options);
+    historyManager.beginFrame();
+    const { backbuffer, frame } = buildForwardPlusGraphInternal(graph, ctx, renderQueue, options);
     const compiled = graph.compile([
         backbuffer
     ]);
@@ -460,10 +685,15 @@ let _skyMVBox = null;
         const backbufferTex = ctx.finalFramebuffer.getColorAttachments()[0];
         executor.setImportedTexture(backbuffer, backbufferTex);
     }
-    executor.execute(compiled);
-    executor.reset();
-    // Swap history buffers at frame end (ping-pong)
-    historyManager.swap();
+    historyManager.bindImportedTextures(executor);
+    try {
+        executor.execute(compiled);
+        historyManager.commitFrame();
+    } finally{
+        historyManager.discardFrame();
+        cleanupFrame(frame);
+        executor.reset();
+    }
 }
 
 export { buildForwardPlusGraph, deriveForwardPlusOptions, executeForwardPlusGraph };