@zephyr3d/scene 0.9.5 → 0.9.7

package/dist/render/rendergraph/forward_plus_builder.js

@@ -1,4 +1,5 @@
 import { Vector4 } from '@zephyr3d/base';
+import { RenderQueue } from '../render_queue.js';
 import { LightPass } from '../lightpass.js';
 import { ShadowMapPass } from '../shadowmap_pass.js';
 import { DepthPass } from '../depthpass.js';
@@ -32,47 +33,184 @@ const _clusters = [];
 const _devicePoolAllocator = new DevicePoolAllocator();
 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;
 function getClusteredLight() {
     return _clusters.length > 0 ? _clusters.pop() : new ClusteredLight();
 }
 function freeClusteredLight(cl) {
     _clusters.push(cl);
 }
+function getCoreMaterial(material) {
+    return material?.coreMaterial ?? material ?? null;
+}
+function hasSSSMaterialCore(material) {
+    return !!getCoreMaterial(material)?.subsurfaceProfile;
+}
+function renderQueueHasActiveSSS(renderQueue) {
+    const itemList = renderQueue.itemList;
+    if (!itemList) {
+        return false;
+    }
+    const lists = [
+        ...itemList.opaque.lit,
+        ...itemList.opaque.unlit
+    ];
+    for (const list of lists){
+        for (const material of list.materialList){
+            if (hasSSSMaterialCore(material)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function filterActualSSSItemList(items) {
+    return items.filter((item)=>hasSSSMaterialCore(item.drawable.getMaterial?.()));
+}
+function filterActualSSSMaterialList(materialList) {
+    const filtered = new Set();
+    materialList.forEach((mat)=>{
+        if (hasSSSMaterialCore(mat)) {
+            filtered.add(mat);
+        }
+    });
+    return filtered;
+}
+function cloneActualSSSListInfo(source, _targetQueue) {
+    return {
+        itemList: filterActualSSSItemList(source.itemList),
+        skinItemList: filterActualSSSItemList(source.skinItemList),
+        morphItemList: filterActualSSSItemList(source.morphItemList),
+        skinAndMorphItemList: filterActualSSSItemList(source.skinAndMorphItemList),
+        instanceItemList: filterActualSSSItemList(source.instanceItemList),
+        materialList: filterActualSSSMaterialList(source.materialList),
+        instanceList: {},
+        renderQueue: source.renderQueue
+    };
+}
+function cloneActualSSSBundle(source, targetQueue) {
+    return {
+        lit: source.lit.map((info)=>cloneActualSSSListInfo(info)),
+        unlit: source.unlit.map((info)=>cloneActualSSSListInfo(info))
+    };
+}
+function hasAnyActualSSSItems(renderItems) {
+    return renderItems.some((info)=>info.itemList.length > 0 || info.skinItemList.length > 0 || info.morphItemList.length > 0 || info.skinAndMorphItemList.length > 0 || info.instanceItemList.length > 0);
+}
+function createActualSSSRenderQueue(renderQueue) {
+    const itemList = renderQueue.itemList;
+    if (!itemList) {
+        return null;
+    }
+    const queue = new RenderQueue(_scenePass);
+    const sssOpaque = cloneActualSSSBundle(itemList.opaque);
+    if (!hasAnyActualSSSItems([
+        ...sssOpaque.lit,
+        ...sssOpaque.unlit
+    ])) {
+        queue.dispose();
+        return null;
+    }
+    const emptyBundle = {
+        lit: [],
+        unlit: []
+    };
+    const target = queue;
+    target._itemList = {
+        opaque: sssOpaque,
+        transmission: emptyBundle,
+        transparent: emptyBundle,
+        transmission_trans: emptyBundle
+    };
+    target._shadowedLightList = renderQueue.shadowedLights;
+    target._unshadowedLightList = renderQueue.unshadowedLights;
+    target._sunLight = renderQueue.sunLight;
+    target._primaryDirectionalLight = renderQueue.primaryDirectionalLight;
+    target._primaryTransmissionLight = renderQueue.primaryTransmissionLight;
+    target._needSceneColor = false;
+    target._needSceneDepth = false;
+    target._needSceneColorWithDepth = false;
+    target._drawTransparent = false;
+    return queue;
+}
+function getSurfaceTextureFormat(ctx) {
+    const caps = ctx.device.getDeviceCaps?.();
+    return caps?.textureCaps.supportHalfFloatColorBuffer ? 'rgba16f' : 'rgba8unorm';
+}
+function getTextureFormatBytes(ctx, format) {
+    return ctx.device.getDeviceCaps().textureCaps.getTextureFormatInfo(format).size;
+}
+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) {
+    const colorFormat = ctx.colorFormat;
+    if (!includeSSRSurfaceMRT || attachmentCount === 0) {
+        return colorFormat;
+    }
+    const caps = ctx.device.getDeviceCaps();
+    const roughnessFormat = ctx.SSRRoughnessTexture?.format ?? colorFormat;
+    const normalFormat = ctx.SSRNormalTexture?.format ?? colorFormat;
+    const colorBytes = getTextureFormatBytes(ctx, colorFormat) + getTextureFormatBytes(ctx, roughnessFormat) + getTextureFormatBytes(ctx, normalFormat);
+    const fullPrecisionBytes = colorBytes + getTextureFormatBytes(ctx, colorFormat) * attachmentCount;
+    if (fullPrecisionBytes <= caps.framebufferCaps.maxColorAttachmentBytesPerSample) {
+        return colorFormat;
+    }
+    return 'rgba8unorm';
+}
+function getFullMipLevelCount(width, height) {
+    return Math.max(1, Math.floor(Math.log2(Math.max(1, width, height))) + 1);
+}
+function hasSurfaceMRT(ctx) {
+    return !!(ctx.materialFlags & SURFACE_MRT_FLAGS);
+}
+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.SSS_STORE_PROFILE) {
+        attachments.push(ctx.SSSProfileTexture, ctx.SSSParamTexture);
+    }
+    if (ctx.materialFlags & MaterialVaryingFlags.SSS_STORE_DIFFUSE) {
+        attachments.push(ctx.SSSDiffuseTexture);
+    }
+    if (ctx.materialFlags & MaterialVaryingFlags.SSS_STORE_TRANSMISSION) {
+        attachments.push(ctx.SSSTransmissionTexture);
+    }
+    return attachments.length === 1 ? attachments[0] : attachments;
+}
 /**
  * Derive pipeline options from the current scene/camera state.
  * @internal
  */ function deriveForwardPlusOptions(scene, camera, deviceType, renderQueue) {
     const ssr = camera.SSR && scene.env.light.envLight && scene.env.light.envLight.hasRadiance();
+    const sss = camera.SSS && renderQueueHasActiveSSS(renderQueue);
+    const needSceneColor = renderQueue.needSceneColor();
+    const needSceneColorWithDepth = renderQueue.needSceneColorWithDepth();
     return {
         depthPrepass: true,
-        motionVectors: deviceType !== 'webgl' && (camera.TAA || camera.motionBlur),
+        motionVectors: deviceType !== 'webgl' && (camera.TAA || camera.motionBlur || !!ssr && camera.ssrTemporal),
         hiZ: camera.HiZ && deviceType !== 'webgl',
         ssr: !!ssr,
         ssrCalcThickness: !!ssr && camera.ssrCalcThickness,
         gpuPicking: !!camera.getPickResultResolveFunc(),
-        needSceneColor: renderQueue.needSceneColor()
+        needSceneColor,
+        needSceneColorWithDepth,
+        needsTransmissionDepthForSSR: !!ssr && needSceneColor && !needSceneColorWithDepth,
+        sss: !!sss
     };
 }
-// ─── 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 buildForwardPlusGraphInternal(graph, ctx, renderQueue, options) {
     const backbuffer = graph.importTexture('backbuffer');
+    ctx.SSS = !!options.sss;
     // Shared mutable frame state
     const frame = {
         ctx,
@@ -192,16 +330,31 @@ function buildForwardPlusGraphInternal(graph, ctx, renderQueue, options) {
     const depthHandle = depthPassResult.depthHandle;
     const motionVectorHandle = depthPassResult.motionVectorHandle;
     const renderDepthAttachment = depthPassResult.graphDepthAttachmentHandle ?? depthPassResult.externalDepthAttachment ?? null;
+    let preLightTransmissionDepthToken;
+    if (options.needsTransmissionDepthForSSR) {
+        preLightTransmissionDepthToken = graph.addPass('TransmissionDepthForSSR', (builder)=>{
+            builder.read(depthPassResult.depthFramebufferHandle);
+            const done = builder.createToken('TransmissionDepthForSSRDone');
+            builder.sideEffect();
+            builder.setExecute((rgCtx)=>{
+                renderTransmissionDepthPass(frame, rgCtx);
+            });
+            return done;
+        });
+    }
     // ── 6. Hi-Z (optional) ───────────────────────────────────────────
     let hiZHandle;
     if (options.hiZ) {
         graph.addPass('HiZ', (builder)=>{
             builder.read(depthHandle);
             builder.read(depthPassResult.depthFramebufferHandle);
+            if (preLightTransmissionDepthToken) {
+                builder.read(preLightTransmissionDepthToken);
+            }
             hiZHandle = builder.createTexture({
                 format: 'r32f',
                 label: 'hiZ',
-                mipLevels: 10
+                mipLevels: getFullMipLevelCount(ctx.renderWidth, ctx.renderHeight)
             });
             const hiZFramebufferHandle = builder.createFramebuffer({
                 label: 'HiZFramebuffer',
@@ -223,12 +376,120 @@ function buildForwardPlusGraphInternal(graph, ctx, renderQueue, options) {
         });
     }
     // ── 7. Main Light Pass ────────────────────────────────────────────
+    const historyManager = ctx.camera?.getHistoryResourceManager?.() ?? null;
+    const lightHistoryReadBindings = [];
+    const compositeHistoryReadBindings = [];
+    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
+            });
+        }
+    }
+    if (historyManager && ctx.camera?.TAA && options.motionVectors) {
+        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) {
+            compositeHistoryReadBindings.push({
+                name: RGHistoryResources.TAA_COLOR,
+                handle: colorHistoryHandle
+            }, {
+                name: RGHistoryResources.TAA_MOTION_VECTOR,
+                handle: motionVectorHistoryHandle
+            });
+        }
+    }
+    let sssProfileResult;
+    if (options.sss) {
+        sssProfileResult = graph.addPass('SSSProfile', (builder)=>{
+            builder.read(depthHandle);
+            builder.read(depthPassResult.depthFramebufferHandle);
+            if (preLightTransmissionDepthToken) {
+                builder.read(preLightTransmissionDepthToken);
+            }
+            const profileHandle = builder.createTexture({
+                format: 'rgba16f',
+                label: 'sssProfile'
+            });
+            const paramHandle = builder.createTexture({
+                format: 'rgba8unorm',
+                label: 'sssParam'
+            });
+            const normalHandle = options.ssr ? undefined : builder.createTexture({
+                format: getSurfaceTextureFormat(ctx),
+                label: 'sssNormal'
+            });
+            const colorAttachments = normalHandle ? [
+                ctx.colorFormat,
+                normalHandle,
+                profileHandle,
+                paramHandle
+            ] : [
+                ctx.colorFormat,
+                profileHandle,
+                paramHandle
+            ];
+            const framebufferHandle = builder.createFramebuffer({
+                label: 'SSSProfileFramebuffer',
+                width: ctx.renderWidth,
+                height: ctx.renderHeight,
+                colorAttachments,
+                depthAttachment: renderDepthAttachment,
+                ignoreDepthStencil: false
+            });
+            builder.setExecute((rgCtx)=>{
+                renderForwardSSSProfile(frame, rgCtx.getFramebuffer(framebufferHandle), rgCtx.getTexture(profileHandle), rgCtx.getTexture(paramHandle), normalHandle ? rgCtx.getTexture(normalHandle) : null);
+            });
+            return {
+                profileHandle,
+                paramHandle,
+                normalHandle,
+                framebufferHandle
+            };
+        });
+    }
     const lightPassResult = graph.addPass('LightPass', (builder)=>{
         builder.read(depthHandle);
         builder.read(depthPassResult.depthFramebufferHandle);
+        if (preLightTransmissionDepthToken) {
+            builder.read(preLightTransmissionDepthToken);
+        }
         if (hiZHandle) {
             builder.read(hiZHandle);
         }
+        for (const binding of lightHistoryReadBindings){
+            builder.read(binding.handle);
+        }
         // Create scene color texture (intermediate render target)
         const sceneColorHandle = builder.createTexture({
             format: ctx.colorFormat,
@@ -242,6 +503,29 @@ function buildForwardPlusGraphInternal(graph, ctx, renderQueue, options) {
                 label: 'sceneColorCopy'
             });
         }
+        if (sssProfileResult) {
+            builder.read(sssProfileResult.profileHandle);
+            builder.read(sssProfileResult.paramHandle);
+            if (sssProfileResult.normalHandle) {
+                builder.read(sssProfileResult.normalHandle);
+            }
+        }
+        const includeSSRSurfaceMRT = !!options.ssr;
+        const writeSSSDiffuse = options.sss && shouldStoreSSSDiffuse(ctx);
+        let writeSSSTransmission = options.sss && shouldStoreSSSTransmission(ctx);
+        if (writeSSSDiffuse && writeSSSTransmission && includeSSRSurfaceMRT && getSSSLightingTextureFormat(ctx, 2, includeSSRSurfaceMRT) !== ctx.colorFormat) {
+            writeSSSTransmission = false;
+        }
+        const sssLightingAttachmentCount = (writeSSSDiffuse ? 1 : 0) + (writeSSSTransmission ? 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 useFinalFramebufferAsIntermediate = !!depthPassResult.externalDepthAttachment && depthPassResult.externalDepthAttachment === ctx.finalFramebuffer?.getDepthAttachment();
         const sceneColorFramebufferHandle = useFinalFramebufferAsIntermediate ? undefined : builder.createFramebuffer({
             label: 'SceneColorFramebuffer',
@@ -250,7 +534,10 @@ function buildForwardPlusGraphInternal(graph, ctx, renderQueue, options) {
             colorAttachments: sceneColorHandle,
             depthAttachment: renderDepthAttachment
         });
-        const sceneColorCopyFramebufferHandle = sceneColorCopyHandle ? builder.createFramebuffer({
+        // 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 color they are about to sample.
+        const sceneColorCopyFramebufferHandle = sceneColorCopyHandle && !options.needsTransmissionDepthForSSR ? builder.createFramebuffer({
             label: 'SceneColorCopyFramebuffer',
             width: ctx.renderWidth,
             height: ctx.renderHeight,
@@ -261,7 +548,29 @@ function buildForwardPlusGraphInternal(graph, ctx, renderQueue, options) {
         builder.setExecute((rgCtx)=>{
             const sceneColorTex = rgCtx.getTexture(sceneColorHandle);
             const sceneColorCopyTex = sceneColorCopyHandle ? rgCtx.getTexture(sceneColorCopyHandle) : null;
-            renderMainLightPass(frame, sceneColorTex, sceneColorCopyTex, rgCtx, sceneColorFramebufferHandle, sceneColorCopyFramebufferHandle);
+            if (sssProfileResult) {
+                ctx.SSSProfileTexture = rgCtx.getTexture(sssProfileResult.profileHandle);
+                ctx.SSSParamTexture = rgCtx.getTexture(sssProfileResult.paramHandle);
+                if (sssProfileResult.normalHandle) {
+                    ctx.SSRNormalTexture = rgCtx.getTexture(sssProfileResult.normalHandle);
+                }
+            }
+            ctx.SSSDiffuseTexture = sssDiffuseHandle ? rgCtx.getTexture(sssDiffuseHandle) : null;
+            ctx.SSSTransmissionTexture = sssTransmissionHandle ? rgCtx.getTexture(sssTransmissionHandle) : null;
+            const renderLightPass = ()=>renderMainLightPass(frame, sceneColorTex, sceneColorCopyTex, rgCtx, sceneColorFramebufferHandle, sceneColorCopyFramebufferHandle);
+            if (historyManager && lightHistoryReadBindings.length > 0) {
+                historyManager.beginReadScope(lightHistoryReadBindings.map((binding)=>({
+                        name: binding.name,
+                        texture: rgCtx.getTexture(binding.handle)
+                    })));
+                try {
+                    renderLightPass();
+                } finally{
+                    historyManager.endReadScope();
+                }
+            } else {
+                renderLightPass();
+            }
         });
         return {
             sceneColorHandle,
@@ -270,38 +579,9 @@ function buildForwardPlusGraphInternal(graph, ctx, renderQueue, options) {
         };
     });
     const sceneColorHandle = lightPassResult.sceneColorHandle;
-    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) {
+    if (options.needSceneColor && !options.needsTransmissionDepthForSSR) {
         transmissionDepthToken = graph.addPass('TransmissionDepth', (builder)=>{
             builder.read(sceneColorHandle);
             builder.read(depthPassResult.depthFramebufferHandle);
@@ -329,13 +609,13 @@ function buildForwardPlusGraphInternal(graph, ctx, renderQueue, options) {
         if (transmissionDepthToken) {
             builder.read(transmissionDepthToken);
         }
-        for (const binding of historyReadBindings){
+        for (const binding of compositeHistoryReadBindings){
             builder.read(binding.handle);
         }
         const outputBackbuffer = builder.write(backbuffer);
         builder.setExecute((rgCtx)=>{
-            if (historyManager && historyReadBindings.length > 0) {
-                historyManager.beginReadScope(historyReadBindings.map((binding)=>({
+            if (historyManager && compositeHistoryReadBindings.length > 0) {
+                historyManager.beginReadScope(compositeHistoryReadBindings.map((binding)=>({
                         name: binding.name,
                         texture: rgCtx.getTexture(binding.handle)
                     })));
@@ -370,6 +650,65 @@ function buildForwardPlusGraphInternal(graph, ctx, renderQueue, options) {
         ctx.device.popDeviceStates();
     }
 }
+function renderForwardSSSProfile(frame, profileFramebuffer, profileTexture, paramTexture, normalTexture) {
+    const { ctx, renderQueue } = frame;
+    if (!ctx.SSS || !ctx.depthTexture) {
+        return;
+    }
+    const sssRenderQueue = createActualSSSRenderQueue(renderQueue);
+    if (!sssRenderQueue) {
+        return;
+    }
+    const device = ctx.device;
+    const savedMaterialFlags = ctx.materialFlags;
+    const savedCompositor = ctx.compositor;
+    const savedTransmission = _scenePass.transmission;
+    const savedRenderOpaque = _scenePass.renderOpaque;
+    const savedRenderTransparent = _scenePass.renderTransparent;
+    const savedClearColor = _scenePass.clearColor;
+    const savedClearDepth = _scenePass.clearDepth;
+    const savedClearStencil = _scenePass.clearStencil;
+    const savedCommandBufferReuse = ctx.camera.commandBufferReuse;
+    const savedProfileTexture = ctx.SSSProfileTexture;
+    const savedParamTexture = ctx.SSSParamTexture;
+    const savedNormalTexture = ctx.SSRNormalTexture;
+    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.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) | profileFlags;
+        _scenePass.transmission = false;
+        _scenePass.renderOpaque = true;
+        _scenePass.renderTransparent = false;
+        _scenePass.clearColor = Vector4.zero();
+        _scenePass.clearDepth = null;
+        _scenePass.clearStencil = null;
+        _scenePass.render(ctx, null, null, sssRenderQueue);
+    } finally{
+        _scenePass.clearColor = savedClearColor;
+        _scenePass.clearDepth = savedClearDepth;
+        _scenePass.clearStencil = savedClearStencil;
+        _scenePass.renderTransparent = savedRenderTransparent;
+        _scenePass.renderOpaque = savedRenderOpaque;
+        _scenePass.transmission = savedTransmission;
+        ctx.camera.commandBufferReuse = savedCommandBufferReuse;
+        ctx.materialFlags = savedMaterialFlags;
+        ctx.compositor = savedCompositor;
+        ctx.SSSProfileTexture = savedProfileTexture;
+        ctx.SSSParamTexture = savedParamTexture;
+        ctx.SSRNormalTexture = savedNormalTexture;
+        device.popDeviceStates();
+        sssRenderQueue.dispose();
+    }
+}
 function releaseIntermediateFramebuffer(frame) {
     const { ctx } = frame;
     if (frame.intermediateDeviceStatePushed) {
@@ -496,6 +835,7 @@ function cleanupFrame(frame) {
         ctx.motionVectorTexture = ctx.motionVectors ? depthFramebuffer.getColorAttachments()[1] : null;
         ctx.linearDepthTexture = depthFramebuffer.getColorAttachments()[0];
         ctx.depthTexture = depthFramebuffer.getDepthAttachment();
+        ctx.depthPrepassAttachment = ctx.depthTexture;
     // HiZ is now built in the dedicated HiZ pass
     }
     return depthFramebuffer;
@@ -564,20 +904,37 @@ let _skyMVBox = null;
     _skyMVBox.draw();
     device.popDeviceStates();
 }
+function blitToCurrentColorAttachment(ctx, source) {
+    const framebuffer = ctx.device.getFramebuffer();
+    const destination = framebuffer?.getColorAttachment(0) ?? null;
+    new CopyBlitter().blit(source, destination, fetchSampler('clamp_nearest_nomip'));
+}
 /** @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();
+    ctx.materialFlags &= ~(MaterialVaryingFlags.SSR_STORE_ROUGHNESS | MaterialVaryingFlags.SSS_STORE_PROFILE | MaterialVaryingFlags.SSS_STORE_DIFFUSE | MaterialVaryingFlags.SSS_STORE_NORMAL | MaterialVaryingFlags.SSS_STORE_TRANSMISSION);
+    if (ctx.SSR) {
+        ctx.materialFlags |= MaterialVaryingFlags.SSR_STORE_ROUGHNESS;
+    }
+    if (ctx.SSS) {
+        if (ctx.SSSDiffuseTexture) {
+            ctx.materialFlags |= MaterialVaryingFlags.SSS_STORE_DIFFUSE;
+        }
+        if (ctx.SSSTransmissionTexture) {
+            ctx.materialFlags |= MaterialVaryingFlags.SSS_STORE_TRANSMISSION;
+        }
+    }
     if (depthTex === ctx.finalFramebuffer?.getDepthAttachment()) {
         ctx.intermediateFramebuffer = ctx.finalFramebuffer;
-    } else if (sceneColorFramebufferHandle) {
+    } else if (sceneColorFramebufferHandle && !hasSurfaceMRT(ctx)) {
         ctx.intermediateFramebuffer = rgCtx.getFramebuffer(sceneColorFramebufferHandle);
     } else {
         ctx.intermediateFramebuffer = rgCtx.createFramebuffer({
             width: sceneColorTex.width,
             height: sceneColorTex.height,
-            colorAttachments: sceneColorTex,
+            colorAttachments: getLightPassColorAttachments(ctx, sceneColorTex),
             depthAttachment: depthTex
         });
     }
@@ -592,23 +949,22 @@ let _skyMVBox = null;
     _scenePass.transmission = false;
     _scenePass.clearDepth = depthTex ? null : 1;
     _scenePass.clearStencil = depthTex ? null : 0;
-    if (ctx.SSR && !renderQueue.needSceneColor()) {
-        ctx.materialFlags |= MaterialVaryingFlags.SSR_STORE_ROUGHNESS;
-    }
     ctx.compositor?.begin(ctx);
     if (renderQueue.needSceneColor() && sceneColorCopyTex) {
         const compositor = ctx.compositor;
         ctx.compositor = null;
+        const isolateSceneColorDepth = frame.options.needsTransmissionDepthForSSR;
+        const savedDepthPrepassAttachment = ctx.depthPrepassAttachment;
+        const savedClearDepth = _scenePass.clearDepth;
+        const savedClearStencil = _scenePass.clearStencil;
+        const savedMaterialFlags = ctx.materialFlags;
         // Use RenderGraph-allocated sceneColorCopy texture
-        const sceneColorFramebuffer = sceneColorCopyFramebufferHandle && !(ctx.materialFlags & MaterialVaryingFlags.SSR_STORE_ROUGHNESS) ? rgCtx.getFramebuffer(sceneColorCopyFramebufferHandle) : rgCtx.createFramebuffer({
+        const sceneColorMaterialFlags = ctx.materialFlags & ~SURFACE_MRT_FLAGS;
+        const sceneColorFramebuffer = sceneColorCopyFramebufferHandle ? 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,
+            colorAttachments: sceneColorCopyTex,
+            depthAttachment: isolateSceneColorDepth ? ctx.depthFormat : depthTex,
             ignoreDepthStencil: false
         });
         let sceneColorStatePushed = false;
@@ -617,15 +973,27 @@ let _skyMVBox = null;
             sceneColorStatePushed = true;
             device.setFramebuffer(sceneColorFramebuffer);
             _scenePass.transmission = false;
+            if (isolateSceneColorDepth) {
+                ctx.depthPrepassAttachment = undefined;
+                _scenePass.clearDepth = 1;
+                _scenePass.clearStencil = 0;
+            }
+            ctx.materialFlags = sceneColorMaterialFlags;
             _scenePass.render(ctx, null, null, renderQueue);
         } finally{
+            ctx.materialFlags = savedMaterialFlags;
+            if (isolateSceneColorDepth) {
+                ctx.depthPrepassAttachment = savedDepthPrepassAttachment;
+                _scenePass.clearDepth = savedClearDepth;
+                _scenePass.clearStencil = savedClearStencil;
+            }
             if (sceneColorStatePushed) {
                 device.popDeviceStates();
             }
             ctx.compositor = compositor;
         }
         ctx.sceneColorTexture = sceneColorCopyTex;
-        new CopyBlitter().blit(ctx.sceneColorTexture, device.getFramebuffer() ?? null, fetchSampler('clamp_nearest_nomip'));
+        blitToCurrentColorAttachment(ctx, ctx.sceneColorTexture);
         _scenePass.transmission = true;
         _scenePass.clearColor = null;
         _scenePass.clearDepth = null;
@@ -642,6 +1010,10 @@ let _skyMVBox = null;
     ctx.compositor?.end(ctx);
     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;
     if (ctx.intermediateFramebuffer && ctx.intermediateFramebuffer !== ctx.finalFramebuffer) {
         const blitter = new CopyBlitter();
         blitter.srgbOut = !ctx.finalFramebuffer;
@@ -664,37 +1036,51 @@ let _skyMVBox = null;
  */ function executeForwardPlusGraph(ctx) {
     const device = ctx.device;
     const graph = new RenderGraph();
-    // Cull scene first (needed to derive options)
-    const renderQueue = _scenePass.cullScene(ctx, ctx.camera);
-    const options = deriveForwardPlusOptions(ctx.scene, ctx.camera, device.type, renderQueue);
-    // Ensure the camera has a history resource manager for temporal effects (TAA, motion blur)
-    let historyManager = ctx.camera.getHistoryResourceManager();
-    if (!historyManager) {
-        historyManager = new HistoryResourceManager(_devicePoolAllocator);
-        ctx.camera.setHistoryResourceManager(historyManager);
-    }
-    historyManager.beginFrame();
-    const { backbuffer, frame } = buildForwardPlusGraphInternal(graph, ctx, renderQueue, options);
-    const compiled = graph.compile([
-        backbuffer
-    ]);
-    // Use RenderGraphExecutor for automatic resource management
-    const executor = new RenderGraphExecutor(_devicePoolAllocator, ctx.renderWidth, ctx.renderHeight);
-    // Register imported backbuffer (if using finalFramebuffer)
-    if (ctx.finalFramebuffer) {
-        const backbufferTex = ctx.finalFramebuffer.getColorAttachments()[0];
-        executor.setImportedTexture(backbuffer, backbufferTex);
-    }
-    historyManager.bindImportedTextures(executor);
+    let renderQueue = null;
+    let frame = null;
+    let executor = null;
+    let historyManager = null;
+    let historyFrameStarted = 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);
+        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);
+        }
+        historyManager.beginFrame();
+        historyFrameStarted = true;
+        const buildResult = buildForwardPlusGraphInternal(graph, ctx, renderQueue, options);
+        frame = buildResult.frame;
+        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)
+        if (ctx.finalFramebuffer) {
+            const backbufferTex = ctx.finalFramebuffer.getColorAttachments()[0];
+            executor.setImportedTexture(buildResult.backbuffer, backbufferTex);
+        }
+        historyManager.bindImportedTextures(executor);
         executor.execute(compiled);
         historyManager.commitFrame();
     } finally{
-        historyManager.discardFrame();
-        cleanupFrame(frame);
-        executor.reset();
+        if (historyFrameStarted) {
+            historyManager?.discardFrame();
+        }
+        if (frame) {
+            cleanupFrame(frame);
+        } else {
+            renderQueue?.dispose();
+        }
+        executor?.reset();
     }
 }
 
-export { buildForwardPlusGraph, deriveForwardPlusOptions, executeForwardPlusGraph };
+export { deriveForwardPlusOptions, executeForwardPlusGraph };
 //# sourceMappingURL=forward_plus_builder.js.map