FrameGraph: better support for autoCalcDepthBounds in cascaded shadow generator task (#16734)

Improved fix for #16710:
* The depth texture to use for min/max reduction is now an input of the
CSM task. This means that this depth texture can be shared by multiple
tasks. In the previous PR, a new depth texture was always generated
internally when `autoCalcDepthBounds` was **true**
* The textures used for min/max reduction are created as part of the
frame graph, which means that these textures can be optimized and reused
by the graph

I have also added support for “normalized view depth” as an output of
the geometry renderer task, as this is the most optimal type for min/max
depth reduction when used in CSM.

Author: Popov72

packages/dev/core/src/Engines/constants.ts

@@ -744,6 +744,11 @@ export class Constants {
      */
     public static readonly PREPASS_ALBEDO_TEXTURE_TYPE = 12;
 
+    /**
+     * Constant used to retrieve normalized camera view depth geometry texture
+     */
+    public static readonly PREPASS_NORMALIZED_VIEW_DEPTH_TEXTURE_TYPE = 13;
+
     /** Flag to create a readable buffer (the buffer can be the source of a copy) */
     public static readonly BUFFER_CREATIONFLAG_READ = 1;
     /** Flag to create a writable buffer (the buffer can be the destination of a copy) */

packages/dev/core/src/FrameGraph/Node/Blocks/Rendering/baseShadowGeneratorBlock.ts

@@ -39,8 +39,10 @@ export class NodeRenderGraphBaseShadowGeneratorBlock extends NodeRenderGraphBloc
         this.registerInput("light", NodeRenderGraphBlockConnectionPointTypes.ShadowLight);
         this.registerInput("objects", NodeRenderGraphBlockConnectionPointTypes.ObjectList);
         this.registerInput("camera", NodeRenderGraphBlockConnectionPointTypes.Camera);
-        this._addDependenciesInput();
+    }
 
+    protected _finalizeInputOutputRegistering() {
+        this._addDependenciesInput();
         this.registerOutput("generator", NodeRenderGraphBlockConnectionPointTypes.ShadowGenerator);
         this.registerOutput("output", NodeRenderGraphBlockConnectionPointTypes.Texture);
     }

packages/dev/core/src/FrameGraph/Node/Blocks/Rendering/csmShadowGeneratorBlock.ts

@@ -1,9 +1,11 @@
 // eslint-disable-next-line import/no-internal-modules
-import type { Scene, FrameGraph } from "core/index";
+import type { Scene, FrameGraph, NodeRenderGraphConnectionPoint, FrameGraphTextureHandle, NodeRenderGraphBuildState } from "core/index";
 import { NodeRenderGraphBaseShadowGeneratorBlock } from "./baseShadowGeneratorBlock";
 import { RegisterClass } from "../../../../Misc/typeStore";
 import { editableInPropertyPage, PropertyTypeForEdition } from "../../../../Decorators/nodeDecorator";
 import { FrameGraphCascadedShadowGeneratorTask } from "../../../Tasks/Rendering/csmShadowGeneratorTask";
+import { NodeRenderGraphBlockConnectionPointTypes } from "../../Types/nodeRenderGraphTypes";
+import { DepthTextureType } from "core/Misc/thinMinMaxReducer";
 
 /**
  * Block that generates shadows through a shadow generator
@@ -27,6 +29,16 @@ export class NodeRenderGraphCascadedShadowGeneratorBlock extends NodeRenderGraph
     public constructor(name: string, frameGraph: FrameGraph, scene: Scene) {
         super(name, frameGraph, scene);
 
+        this.registerInput("geomDepth", NodeRenderGraphBlockConnectionPointTypes.AutoDetect, true);
+
+        this.geomDepth.addExcludedConnectionPointFromAllowedTypes(
+            NodeRenderGraphBlockConnectionPointTypes.TextureNormalizedViewDepth |
+                NodeRenderGraphBlockConnectionPointTypes.TextureViewDepth |
+                NodeRenderGraphBlockConnectionPointTypes.TextureScreenDepth
+        );
+
+        this._finalizeInputOutputRegistering();
+
         this._frameGraphTask = new FrameGraphCascadedShadowGeneratorTask(this.name, frameGraph, scene);
     }
 
@@ -134,6 +146,33 @@ export class NodeRenderGraphCascadedShadowGeneratorBlock extends NodeRenderGraph
         return "NodeRenderGraphCascadedShadowGeneratorBlock";
     }
 
+    /**
+     * Gets the geometry (view / normalized view) depth component
+     */
+    public get geomDepth(): NodeRenderGraphConnectionPoint {
+        return this._inputs[3];
+    }
+
+    protected override _buildBlock(state: NodeRenderGraphBuildState) {
+        super._buildBlock(state);
+
+        this._frameGraphTask.depthTexture = this.geomDepth.connectedPoint?.value as FrameGraphTextureHandle;
+
+        if (this.geomDepth.connectedPoint) {
+            switch (this.geomDepth.connectedPoint.type) {
+                case NodeRenderGraphBlockConnectionPointTypes.TextureScreenDepth:
+                    this._frameGraphTask.depthTextureType = DepthTextureType.ScreenDepth;
+                    break;
+                case NodeRenderGraphBlockConnectionPointTypes.TextureNormalizedViewDepth:
+                    this._frameGraphTask.depthTextureType = DepthTextureType.NormalizedViewDepth;
+                    break;
+                case NodeRenderGraphBlockConnectionPointTypes.TextureViewDepth:
+                    this._frameGraphTask.depthTextureType = DepthTextureType.ViewDepth;
+                    break;
+            }
+        }
+    }
+
     protected override _dumpPropertiesCode() {
         const codes: string[] = [];
         codes.push(`${this._codeVariableName}.numCascades = ${this.numCascades};`);

packages/dev/core/src/FrameGraph/Node/Blocks/Rendering/geometryRendererBlock.ts

@@ -39,6 +39,7 @@ export class NodeRenderGraphGeometryRendererBlock extends NodeRenderGraphBlock {
 
         this.registerOutput("outputDepth", NodeRenderGraphBlockConnectionPointTypes.BasedOnInput);
         this.registerOutput("geomViewDepth", NodeRenderGraphBlockConnectionPointTypes.TextureViewDepth);
+        this.registerOutput("geomNormViewDepth", NodeRenderGraphBlockConnectionPointTypes.TextureNormalizedViewDepth);
         this.registerOutput("geomScreenDepth", NodeRenderGraphBlockConnectionPointTypes.TextureScreenDepth);
         this.registerOutput("geomViewNormal", NodeRenderGraphBlockConnectionPointTypes.TextureViewNormal);
         this.registerOutput("geomWorldNormal", NodeRenderGraphBlockConnectionPointTypes.TextureWorldNormal);
@@ -177,6 +178,13 @@ export class NodeRenderGraphGeometryRendererBlock extends NodeRenderGraphBlock {
     @editableInPropertyPage("View depth type", PropertyTypeForEdition.TextureType, "GEOMETRY BUFFERS")
     public viewDepthType = Constants.TEXTURETYPE_FLOAT;
 
+    // Normalized view depth
+    @editableInPropertyPage("Normalized view depth format", PropertyTypeForEdition.TextureFormat, "GEOMETRY BUFFERS")
+    public normalizedViewDepthFormat = Constants.TEXTUREFORMAT_RED;
+
+    @editableInPropertyPage("Normalized view depth type", PropertyTypeForEdition.TextureType, "GEOMETRY BUFFERS")
+    public normalizedViewDepthType = Constants.TEXTURETYPE_HALF_FLOAT;
+
     // Screen depth
     @editableInPropertyPage("Screen depth format", PropertyTypeForEdition.TextureFormat, "GEOMETRY BUFFERS")
     public screenDepthFormat = Constants.TEXTUREFORMAT_RED;
@@ -283,74 +291,82 @@ export class NodeRenderGraphGeometryRendererBlock extends NodeRenderGraphBlock {
         return this._outputs[1];
     }
 
+    /**
+     * Gets the geometry normalized view depth component
+     */
+    public get geomNormViewDepth(): NodeRenderGraphConnectionPoint {
+        return this._outputs[2];
+    }
+
     /**
      * Gets the geometry screen depth component
      */
     public get geomScreenDepth(): NodeRenderGraphConnectionPoint {
-        return this._outputs[2];
+        return this._outputs[3];
     }
 
     /**
      * Gets the geometry view normal component
      */
     public get geomViewNormal(): NodeRenderGraphConnectionPoint {
-        return this._outputs[3];
+        return this._outputs[4];
     }
 
     /**
      * Gets the world geometry normal component
      */
     public get geomWorldNormal(): NodeRenderGraphConnectionPoint {
-        return this._outputs[4];
+        return this._outputs[5];
     }
 
     /**
      * Gets the geometry local position component
      */
     public get geomLocalPosition(): NodeRenderGraphConnectionPoint {
-        return this._outputs[5];
+        return this._outputs[6];
     }
 
     /**
      * Gets the geometry world position component
      */
     public get geomWorldPosition(): NodeRenderGraphConnectionPoint {
-        return this._outputs[6];
+        return this._outputs[7];
     }
 
     /**
      * Gets the geometry albedo component
      */
     public get geomAlbedo(): NodeRenderGraphConnectionPoint {
-        return this._outputs[7];
+        return this._outputs[8];
     }
 
     /**
      * Gets the geometry reflectivity component
      */
     public get geomReflectivity(): NodeRenderGraphConnectionPoint {
-        return this._outputs[8];
+        return this._outputs[9];
     }
 
     /**
      * Gets the geometry velocity component
      */
     public get geomVelocity(): NodeRenderGraphConnectionPoint {
-        return this._outputs[9];
+        return this._outputs[10];
     }
 
     /**
      * Gets the geometry linear velocity component
      */
     public get geomLinearVelocity(): NodeRenderGraphConnectionPoint {
-        return this._outputs[10];
+        return this._outputs[11];
     }
 
     protected override _buildBlock(state: NodeRenderGraphBuildState) {
         super._buildBlock(state);
 
         const textureActivation = [
             this.geomViewDepth.isConnected,
+            this.geomNormViewDepth.isConnected,
             this.geomScreenDepth.isConnected,
             this.geomViewNormal.isConnected,
             this.geomWorldNormal.isConnected,
@@ -368,6 +384,7 @@ export class NodeRenderGraphGeometryRendererBlock extends NodeRenderGraphBlock {
 
         this.outputDepth.value = this._frameGraphTask.outputDepthTexture;
         this.geomViewDepth.value = this._frameGraphTask.geometryViewDepthTexture;
+        this.geomNormViewDepth.value = this._frameGraphTask.geometryNormViewDepthTexture;
         this.geomScreenDepth.value = this._frameGraphTask.geometryScreenDepthTexture;
         this.geomViewNormal.value = this._frameGraphTask.geometryViewNormalTexture;
         this.geomWorldNormal.value = this._frameGraphTask.geometryWorldNormalTexture;
@@ -386,6 +403,7 @@ export class NodeRenderGraphGeometryRendererBlock extends NodeRenderGraphBlock {
 
         const textureFormats = [
             this.viewDepthFormat,
+            this.normalizedViewDepthFormat,
             this.screenDepthFormat,
             this.viewNormalFormat,
             this.worldNormalFormat,
@@ -398,6 +416,7 @@ export class NodeRenderGraphGeometryRendererBlock extends NodeRenderGraphBlock {
         ];
         const textureTypes = [
             this.viewDepthType,
+            this.normalizedViewDepthType,
             this.screenDepthType,
             this.viewNormalType,
             this.worldNormalType,
@@ -410,6 +429,7 @@ export class NodeRenderGraphGeometryRendererBlock extends NodeRenderGraphBlock {
         ];
         const bufferTypes = [
             Constants.PREPASS_DEPTH_TEXTURE_TYPE,
+            Constants.PREPASS_NORMALIZED_VIEW_DEPTH_TEXTURE_TYPE,
             Constants.PREPASS_SCREENSPACE_DEPTH_TEXTURE_TYPE,
             Constants.PREPASS_NORMAL_TEXTURE_TYPE,
             Constants.PREPASS_WORLD_NORMAL_TEXTURE_TYPE,
@@ -441,6 +461,8 @@ export class NodeRenderGraphGeometryRendererBlock extends NodeRenderGraphBlock {
         codes.push(`${this._codeVariableName}.dontRenderWhenMaterialDepthWriteIsDisabled = ${this.dontRenderWhenMaterialDepthWriteIsDisabled};`);
         codes.push(`${this._codeVariableName}.viewDepthFormat = ${this.viewDepthFormat};`);
         codes.push(`${this._codeVariableName}.viewDepthType = ${this.viewDepthType};`);
+        codes.push(`${this._codeVariableName}.normalizedViewDepthFormat = ${this.normalizedViewDepthFormat};`);
+        codes.push(`${this._codeVariableName}.normalizedViewDepthType = ${this.normalizedViewDepthType};`);
         codes.push(`${this._codeVariableName}.screenDepthFormat = ${this.screenDepthFormat};`);
         codes.push(`${this._codeVariableName}.screenDepthType = ${this.screenDepthType};`);
         codes.push(`${this._codeVariableName}.localPositionFormat = ${this.localPositionFormat};`);
@@ -471,6 +493,8 @@ export class NodeRenderGraphGeometryRendererBlock extends NodeRenderGraphBlock {
         serializationObject.dontRenderWhenMaterialDepthWriteIsDisabled = this.dontRenderWhenMaterialDepthWriteIsDisabled;
         serializationObject.viewDepthFormat = this.viewDepthFormat;
         serializationObject.viewDepthType = this.viewDepthType;
+        serializationObject.normalizedViewDepthFormat = this.normalizedViewDepthFormat;
+        serializationObject.normalizedViewDepthType = this.normalizedViewDepthType;
         serializationObject.screenDepthFormat = this.screenDepthFormat;
         serializationObject.screenDepthType = this.screenDepthType;
         serializationObject.localPositionFormat = this.localPositionFormat;
@@ -501,6 +525,8 @@ export class NodeRenderGraphGeometryRendererBlock extends NodeRenderGraphBlock {
         this.dontRenderWhenMaterialDepthWriteIsDisabled = serializationObject.dontRenderWhenMaterialDepthWriteIsDisabled;
         this.viewDepthFormat = serializationObject.viewDepthFormat;
         this.viewDepthType = serializationObject.viewDepthType;
+        this.normalizedViewDepthFormat = serializationObject.normalizedViewDepthFormat ?? Constants.TEXTUREFORMAT_RED;
+        this.normalizedViewDepthType = serializationObject.normalizedViewDepthType ?? Constants.TEXTURETYPE_UNSIGNED_BYTE;
         this.screenDepthFormat = serializationObject.screenDepthFormat;
         this.screenDepthType = serializationObject.screenDepthType;
         this.localPositionFormat = serializationObject.localPositionFormat;

packages/dev/core/src/FrameGraph/Node/Blocks/Rendering/shadowGeneratorBlock.ts

@@ -17,6 +17,8 @@ export class NodeRenderGraphShadowGeneratorBlock extends NodeRenderGraphBaseShad
     public constructor(name: string, frameGraph: FrameGraph, scene: Scene) {
         super(name, frameGraph, scene);
 
+        this._finalizeInputOutputRegistering();
+
         this._frameGraphTask = new FrameGraphShadowGeneratorTask(this.name, frameGraph, scene);
     }
 

packages/dev/core/src/FrameGraph/Node/Blocks/inputBlock.ts

@@ -72,6 +72,7 @@ export class NodeRenderGraphInputBlock extends NodeRenderGraphBlock {
             case NodeRenderGraphBlockConnectionPointTypes.Texture:
             case NodeRenderGraphBlockConnectionPointTypes.TextureViewDepth:
             case NodeRenderGraphBlockConnectionPointTypes.TextureScreenDepth:
+            case NodeRenderGraphBlockConnectionPointTypes.TextureNormalizedViewDepth:
             case NodeRenderGraphBlockConnectionPointTypes.TextureViewNormal:
             case NodeRenderGraphBlockConnectionPointTypes.TextureWorldNormal:
             case NodeRenderGraphBlockConnectionPointTypes.TextureAlbedo:

packages/dev/core/src/FrameGraph/Node/Types/nodeRenderGraphTypes.ts

@@ -66,6 +66,8 @@ export enum NodeRenderGraphBlockConnectionPointTypes {
     TextureLocalPosition = 0x00004000,
     /** Linear velocity geometry texture */
     TextureLinearVelocity = 0x00008000,
+    /** Normalied depth (in view space) geometry texture */
+    TextureNormalizedViewDepth = 0x00010000,
 
     /** Bit field for all textures but back buffer depth/stencil */
     TextureAllButBackBufferDepthStencil = 0x000ffffb,