Make node materials compatible with prepass

packages/dev/core/src/Engines/WebGL/webGLHardwareTexture.ts

@@ -52,6 +52,10 @@ export class WebGLHardwareTexture implements HardwareTextureWrapper {
         }
     }
 
+    public getMSAARenderBuffer(index = 0) {
+        return this._MSAARenderBuffers?.[index] ?? null;
+    }
+
     public release() {
         this.releaseMSAARenderBuffers();
 

packages/dev/core/src/Engines/WebGL/webGLRenderTargetWrapper.ts

@@ -80,13 +80,13 @@ export class WebGLRenderTargetWrapper extends RenderTargetWrapper {
         const depthbuffer = this._depthStencilBuffer;
         const framebuffer = renderTarget._MSAAFramebuffer || renderTarget._framebuffer;
 
-        if (renderTarget._depthStencilBuffer) {
+        if (renderTarget._depthStencilBuffer && renderTarget._depthStencilBuffer !== depthbuffer) {
             gl.deleteRenderbuffer(renderTarget._depthStencilBuffer);
         }
-        renderTarget._depthStencilBuffer = this._depthStencilBuffer;
-
+        renderTarget._depthStencilBuffer = depthbuffer;
+        const attachment = renderTarget._generateStencilBuffer ? gl.DEPTH_STENCIL_ATTACHMENT : gl.DEPTH_ATTACHMENT;
         this._engine._bindUnboundFramebuffer(framebuffer);
-        gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, depthbuffer);
+        gl.framebufferRenderbuffer(gl.FRAMEBUFFER, attachment, gl.RENDERBUFFER, depthbuffer);
         this._engine._bindUnboundFramebuffer(null);
     }
 

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

@@ -198,6 +198,10 @@ export class RenderTargetWrapper {
         if (!this._textures) {
             this._textures = [];
         }
+        if (this._textures[index] === texture) {
+            return;
+        }
+
         if (this._textures[index] && disposePrevious) {
             this._textures[index].dispose();
         }

packages/dev/core/src/Materials/Node/Blocks/Dual/textureBlock.ts

@@ -19,6 +19,7 @@ import "../../../../Shaders/ShadersInclude/helperFunctions";
 import { ImageSourceBlock } from "./imageSourceBlock";
 import { NodeMaterialConnectionPointCustomObject } from "../../nodeMaterialConnectionPointCustomObject";
 import { EngineStore } from "../../../../Engines/engineStore";
+import type { PrePassTextureBlock } from "../Input/prePassTextureBlock";
 
 /**
  * Block used to read a texture from a sampler
@@ -35,7 +36,7 @@ export class TextureBlock extends NodeMaterialBlock {
     private _mainUVName: string;
     private _mainUVDefineName: string;
     private _fragmentOnly: boolean;
-    private _imageSource: Nullable<ImageSourceBlock>;
+    private _imageSource: Nullable<ImageSourceBlock | PrePassTextureBlock>;
 
     protected _texture: Nullable<Texture>;
     /**
@@ -70,12 +71,25 @@ export class TextureBlock extends NodeMaterialBlock {
         }
     }
 
+    private static _IsPrePassTextureBlock(block: Nullable<ImageSourceBlock | PrePassTextureBlock>): block is PrePassTextureBlock {
+        return block?.getClassName() === "PrePassTextureBlock";
+    }
+
+    private get _isSourcePrePass() {
+        return TextureBlock._IsPrePassTextureBlock(this._imageSource);
+    }
+
     /**
      * Gets the sampler name associated with this texture
      */
     public get samplerName(): string {
         if (this._imageSource) {
-            return this._imageSource.samplerName;
+            if (!TextureBlock._IsPrePassTextureBlock(this._imageSource)) {
+                return this._imageSource.samplerName;
+            }
+            if (this.source.connectedPoint) {
+                return this._imageSource.getSamplerName(this.source.connectedPoint);
+            }
         }
         return this._samplerName;
     }
@@ -370,6 +384,10 @@ export class TextureBlock extends NodeMaterialBlock {
     }
 
     public isReady() {
+        if (this._isSourcePrePass) {
+            return true;
+        }
+
         if (this.texture && !this.texture.isReadyOrNotBlocking()) {
             return false;
         }
@@ -378,6 +396,10 @@ export class TextureBlock extends NodeMaterialBlock {
     }
 
     public bind(effect: Effect) {
+        if (this._isSourcePrePass) {
+            effect.setFloat(this._textureInfoName, 1);
+        }
+
         if (!this.texture) {
             return;
         }

packages/dev/core/src/Materials/Node/Blocks/Fragment/fragmentOutputBlock.ts

@@ -6,11 +6,9 @@ import type { NodeMaterialConnectionPoint } from "../../nodeMaterialBlockConnect
 import { RegisterClass } from "../../../../Misc/typeStore";
 import type { Scene } from "../../../../scene";
 import type { AbstractMesh } from "../../../../Meshes/abstractMesh";
-import type { NodeMaterialDefines } from "../../nodeMaterial";
+import type { NodeMaterialDefines, NodeMaterial } from "../../nodeMaterial";
 import { editableInPropertyPage, PropertyTypeForEdition } from "../../../../Decorators/nodeDecorator";
 import { MaterialHelper } from "../../../materialHelper";
-
-import type { NodeMaterial } from "../../nodeMaterial";
 import type { Effect } from "../../../effect";
 import type { Mesh } from "../../../../Meshes/mesh";
 
@@ -31,7 +29,6 @@ export class FragmentOutputBlock extends NodeMaterialBlock {
         this.registerInput("rgba", NodeMaterialBlockConnectionPointTypes.Color4, true);
         this.registerInput("rgb", NodeMaterialBlockConnectionPointTypes.AutoDetect, true);
         this.registerInput("a", NodeMaterialBlockConnectionPointTypes.Float, true);
-
         this.rgb.addExcludedConnectionPointFromAllowedTypes(
             NodeMaterialBlockConnectionPointTypes.Color3 | NodeMaterialBlockConnectionPointTypes.Vector3 | NodeMaterialBlockConnectionPointTypes.Float
         );
@@ -152,6 +149,10 @@ export class FragmentOutputBlock extends NodeMaterialBlock {
             state.compilationString += `gl_FragDepthEXT = log2(vFragmentDepth) * logarithmicDepthConstant * 0.5;\n`;
         }
 
+        state.compilationString += `#if defined(PREPASS)\r\n`;
+        state.compilationString += `gl_FragData[0] = gl_FragColor;\r\n`;
+        state.compilationString += `#endif\r\n`;
+
         return this;
     }
 

packages/dev/core/src/Materials/Node/Blocks/Fragment/index.ts

@@ -12,3 +12,4 @@ export * from "./TBNBlock";
 export * from "./heightToNormalBlock";
 export * from "./fragDepthBlock";
 export * from "./shadowMapBlock";
+export * from "./prePassOutputBlock";

packages/dev/core/src/Materials/Node/Blocks/Fragment/prePassOutputBlock.ts

@@ -0,0 +1,103 @@
+import { NodeMaterialBlock } from "../../nodeMaterialBlock";
+import { NodeMaterialBlockConnectionPointTypes } from "../../Enums/nodeMaterialBlockConnectionPointTypes";
+import type { NodeMaterialBuildState } from "../../nodeMaterialBuildState";
+import { NodeMaterialBlockTargets } from "../../Enums/nodeMaterialBlockTargets";
+import type { NodeMaterialConnectionPoint } from "../../nodeMaterialBlockConnectionPoint";
+import { RegisterClass } from "../../../../Misc/typeStore";
+
+/**
+ * Block used to output values on the prepass textures
+ */
+export class PrePassOutputBlock extends NodeMaterialBlock {
+    /**
+     * Create a new PrePassOutputBlock
+     * @param name defines the block name
+     */
+    public constructor(name: string) {
+        super(name, NodeMaterialBlockTargets.Fragment, true);
+
+        this.registerInput("viewDepth", NodeMaterialBlockConnectionPointTypes.Float, true);
+        this.registerInput("worldPosition", NodeMaterialBlockConnectionPointTypes.AutoDetect, true);
+        this.registerInput("viewNormal", NodeMaterialBlockConnectionPointTypes.AutoDetect, true);
+
+        this.inputs[1].addExcludedConnectionPointFromAllowedTypes(NodeMaterialBlockConnectionPointTypes.Vector3 | NodeMaterialBlockConnectionPointTypes.Vector4);
+        this.inputs[2].addExcludedConnectionPointFromAllowedTypes(NodeMaterialBlockConnectionPointTypes.Vector3 | NodeMaterialBlockConnectionPointTypes.Vector4);
+    }
+
+    /**
+     * Gets the current class name
+     * @returns the class name
+     */
+    public getClassName() {
+        return "PrePassOutputBlock";
+    }
+
+    /**
+     * Gets the view depth component
+     */
+    public get viewDepth(): NodeMaterialConnectionPoint {
+        return this._inputs[0];
+    }
+
+    /**
+     * Gets the world position component
+     */
+    public get worldPosition(): NodeMaterialConnectionPoint {
+        return this._inputs[1];
+    }
+
+    /**
+     * Gets the view normal component
+     */
+    public get viewNormal(): NodeMaterialConnectionPoint {
+        return this._inputs[2];
+    }
+
+    protected _buildBlock(state: NodeMaterialBuildState) {
+        super._buildBlock(state);
+
+        const worldPosition = this.worldPosition;
+        const viewNormal = this.viewNormal;
+        const viewDepth = this.viewDepth;
+
+        state.sharedData.blocksWithDefines.push(this);
+
+        const comments = `//${this.name}`;
+        state._emitFunctionFromInclude("helperFunctions", comments);
+
+        state.compilationString += `#if defined(PREPASS)\r\n`;
+        state.compilationString += `#ifdef PREPASS_DEPTH\r\n`;
+        if (viewDepth.connectedPoint) {
+            state.compilationString += ` gl_FragData[PREPASS_DEPTH_INDEX] = vec4(${viewDepth.associatedVariableName}, 0.0, 0.0, 1.0);\r\n`;
+        } else {
+            // We have to write something on the viewDepth output or it will raise a gl error
+            state.compilationString += ` gl_FragData[PREPASS_DEPTH_INDEX] = vec4(0.0, 0.0, 0.0, 0.0);\r\n`;
+        }
+        state.compilationString += `#endif\r\n`;
+        state.compilationString += `#ifdef PREPASS_POSITION\r\n`;
+        if (worldPosition.connectedPoint) {
+            state.compilationString += ` gl_FragData[PREPASS_POSITION_INDEX] = vec4(${worldPosition.associatedVariableName}.rgb, ${
+                worldPosition.connectedPoint.type === NodeMaterialBlockConnectionPointTypes.Vector4 ? worldPosition.associatedVariableName + ".a" : "1.0"
+            });\r\n`;
+        } else {
+            // We have to write something on the position output or it will raise a gl error
+            state.compilationString += ` gl_FragData[PREPASS_POSITION_INDEX] = vec4(0.0, 0.0, 0.0, 0.0);\r\n`;
+        }
+        state.compilationString += `#endif\r\n`;
+        state.compilationString += `#ifdef PREPASS_NORMAL\r\n`;
+        if (viewNormal.connectedPoint) {
+            state.compilationString += ` gl_FragData[PREPASS_NORMAL_INDEX] = vec4(${viewNormal.associatedVariableName}.rgb, ${
+                viewNormal.connectedPoint.type === NodeMaterialBlockConnectionPointTypes.Vector4 ? viewNormal.associatedVariableName + ".a" : "1.0"
+            });\r\n`;
+        } else {
+            // We have to write something on the normal output or it will raise a gl error
+            state.compilationString += ` gl_FragData[PREPASS_NORMAL_INDEX] = vec4(0.0, 0.0, 0.0, 0.0);\r\n`;
+        }
+        state.compilationString += `#endif\r\n`;
+        state.compilationString += `#endif\r\n`;
+
+        return this;
+    }
+}
+
+RegisterClass("BABYLON.PrePassOutputBlock", PrePassOutputBlock);

packages/dev/core/src/Materials/Node/Blocks/Input/index.ts

@@ -1,2 +1,3 @@
 export * from "./inputBlock";
 export * from "./animatedInputBlockTypes";
+export * from "./prePassTextureBlock";