@zephyr3d/scene 0.9.19 → 0.9.21

package/dist/render/rendergraph/forward_plus_builder.js

@@ -4,6 +4,7 @@ import { LightPass } from '../lightpass.js';
 import { ShadowMapPass } from '../shadowmap_pass.js';
 import { DepthPass } from '../depthpass.js';
 import { ClusteredLight } from '../cluster_light.js';
+import { ShadowMaskRenderer } from '../shadow_mask_pass.js';
 import { buildHiZ } from '../hzb.js';
 import '../primitive.js';
 import '@zephyr3d/device';
@@ -31,6 +32,7 @@ const _scenePass = new LightPass();
 const _depthPass = new DepthPass();
 const _shadowMapPass = new ShadowMapPass();
 const _clusters = [];
+const _shadowMaskRenderer = new ShadowMaskRenderer();
 const _devicePoolAllocator = new DevicePoolAllocator();
 let _backDepthColorState = null;
 let _frontDepthColorState = null;
@@ -385,6 +387,64 @@ function buildForwardPlusGraphInternal(graph, ctx, renderQueue, options) {
     if (depthPassResult.graphDepthAttachmentHandle) {
         blackboard.set(FrameResources.SceneDepthAttachment, depthPassResult.graphDepthAttachmentHandle);
     }
+    // ── 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) {
+        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;
+            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.
+            const maskHandle = builder.createTexture({
+                format: 'rgba8unorm',
+                label: 'shadowMask',
+                arrayLayers: numLayers
+            });
+            builder.setExecute((rgCtx)=>{
+                const depthTex = rgCtx.getTexture(maskDepthHandle);
+                const maskTex = rgCtx.getTexture(maskHandle);
+                _shadowMaskRenderer.render(ctx, depthTex, renderQueue.shadowedLights, (layer)=>rgCtx.createFramebuffer({
+                        width: maskTex.width,
+                        height: maskTex.height,
+                        colorAttachments: maskTex,
+                        depthAttachment: null,
+                        attachmentLayer: layer
+                    }));
+                ctx.shadowMaskTexture = maskTex;
+            });
+            return {
+                maskHandle
+            };
+        });
+        shadowMaskHandle = maskPassResult.maskHandle;
+        blackboard.set(FrameResources.ShadowMask, shadowMaskHandle);
+    }
     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
@@ -573,6 +633,9 @@ function buildForwardPlusGraphInternal(graph, ctx, renderQueue, options) {
     const lightPassResult = graph.addPass('LightPass', (builder)=>{
         builder.read(depthHandle);
         builder.read(depthPassResult.depthFramebufferHandle);
+        if (shadowMaskHandle) {
+            builder.read(shadowMaskHandle);
+        }
         if (preLightTransmissionDepthToken) {
             builder.read(preLightTransmissionDepthToken);
         }
@@ -1320,8 +1383,12 @@ function blitToCurrentColorAttachment(ctx, source) {
         _scenePass.renderOpaque = true;
         _scenePass.renderTransparent = false;
         _scenePass.render(ctx, null, null, renderQueue);
-        _scenePass.renderTransparent = true;
     } 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.
+        _scenePass.renderTransparent = true;
+        _scenePass.transmission = false;
         ctx.device.popDeviceStates();
     }
 }
@@ -1364,9 +1431,13 @@ function blitToCurrentColorAttachment(ctx, source) {
         device.setFramebuffer(framebuffer);
         device.setViewport(null);
         device.setScissor(null);
-        // _scenePass.transmission carries over from the opaque phase (true when the
-        // scene color copy seeded the background, false otherwise). Never clear:
-        // the opaque result is already in the target.
+        // 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.
+        _scenePass.transmission = renderQueue.needSceneColor();
         _scenePass.clearColor = null;
         _scenePass.clearDepth = null;
         _scenePass.clearStencil = null;