@babylonjs/core 7.32.3 → 7.32.5

package/Rendering/IBLShadows/iblShadowsRenderPipeline.js

@@ -1,9 +1,7 @@
 
 import { EngineStore } from "../../Engines/engineStore.js";
 import { Matrix, Vector3, Vector4, Quaternion } from "../../Maths/math.vector.js";
-import { Mesh } from "../../Meshes/mesh.js";
 import { Texture } from "../../Materials/Textures/texture.js";
-import { PrePassRenderer } from "../prePassRenderer.js";
 import { Logger } from "../../Misc/logger.js";
 import { _IblShadowsVoxelRenderer } from "./iblShadowsVoxelRenderer.js";
 import { _IblShadowsVoxelTracingPass } from "./iblShadowsVoxelTracingPass.js";
@@ -11,61 +9,56 @@ import { PostProcess } from "../../PostProcesses/postProcess.js";
 import { _IblShadowsImportanceSamplingRenderer } from "./iblShadowsImportanceSamplingRenderer.js";
 import { _IblShadowsSpatialBlurPass } from "./iblShadowsSpatialBlurPass.js";
 import { _IblShadowsAccumulationPass } from "./iblShadowsAccumulationPass.js";
-import { ArcRotateCamera } from "../../Cameras/arcRotateCamera.js";
-import { FreeCamera } from "../../Cameras/freeCamera.js";
 import { PostProcessRenderPipeline } from "../../PostProcesses/RenderPipeline/postProcessRenderPipeline.js";
 import { PostProcessRenderEffect } from "../../PostProcesses/RenderPipeline/postProcessRenderEffect.js";
-class IblShadowsPrepassConfiguration {
-    constructor() {
-        /**
-         * Is this effect enabled
-         */
-        this.enabled = true;
-        /**
-         * Name of the configuration
-         */
-        this.name = "iblShadows";
-        /**
-         * Textures that should be present in the MRT for this effect to work
-         */
-        this.texturesRequired = [
-            5,
-            10,
-            8,
-            // 6, // TODO - don't need this for IBL shadows
-            11,
-            // Local positions used for shadow accumulation pass
-            1,
-            9,
-        ];
-    }
-}
+import { GeometryBufferRenderer } from "../geometryBufferRenderer.js";
+import { RawTexture } from "../../Materials/Textures/rawTexture.js";
+import { RawTexture3D } from "../../Materials/Textures/rawTexture3D.js";
+import { Engine } from "../../Engines/engine.js";
+import { IBLShadowsPluginMaterial } from "./iblShadowsPluginMaterial.js";
+import { PBRBaseMaterial } from "../../Materials/PBR/pbrBaseMaterial.js";
+import { StandardMaterial } from "../../Materials/standardMaterial.js";
+import { Observable } from "../../Misc/observable.js";
 /**
  * Voxel-based shadow rendering for IBL's.
  * This should not be instanciated directly, as it is part of a scene component
  */
 export class IblShadowsRenderPipeline extends PostProcessRenderPipeline {
     /**
-     * How dark the shadows appear. 1.0 is full opacity, 0.0 is no shadows.
+     * Reset the shadow accumulation.
      */
-    get shadowOpacity() {
-        return this._shadowOpacity;
+    resetAccumulation() {
+        this._accumulationPass.reset = true;
     }
     /**
      * How dark the shadows appear. 1.0 is full opacity, 0.0 is no shadows.
      */
+    get shadowOpacity() {
+        return this._shadowOpacity;
+    }
     set shadowOpacity(value) {
         this._shadowOpacity = value;
+        this._setPluginParameters();
     }
     /**
-     * How dark the voxel shadows appear. 1.0 is full opacity, 0.0 is no shadows.
+     * A multiplier for the render size of the shadows. Used for rendering lower-resolution shadows.
      */
-    get voxelShadowOpacity() {
-        return this._voxelTracingPass?.voxelShadowOpacity;
+    get shadowRenderSizeFactor() {
+        return this._renderSizeFactor;
+    }
+    set shadowRenderSizeFactor(value) {
+        this._renderSizeFactor = Math.max(Math.min(value, 1.0), 0.0);
+        this._voxelTracingPass.resize(value);
+        this._spatialBlurPass.resize(value);
+        this._accumulationPass.resize(value);
+        this._setPluginParameters();
     }
     /**
      * How dark the voxel shadows appear. 1.0 is full opacity, 0.0 is no shadows.
      */
+    get voxelShadowOpacity() {
+        return this._voxelTracingPass?.voxelShadowOpacity;
+    }
     set voxelShadowOpacity(value) {
         if (!this._voxelTracingPass)
             return;
@@ -77,9 +70,6 @@ export class IblShadowsRenderPipeline extends PostProcessRenderPipeline {
     get ssShadowOpacity() {
         return this._voxelTracingPass?.ssShadowOpacity;
     }
-    /**
-     * How dark the screen-space shadows appear. 1.0 is full opacity, 0.0 is no shadows.
-     */
     set ssShadowOpacity(value) {
         if (!this._voxelTracingPass)
             return;
@@ -91,9 +81,6 @@ export class IblShadowsRenderPipeline extends PostProcessRenderPipeline {
     get ssShadowSamples() {
         return this._voxelTracingPass?.sssSamples;
     }
-    /**
-     * The number of samples used in the screen space shadow pass.
-     */
     set ssShadowSamples(value) {
         if (!this._voxelTracingPass)
             return;
@@ -105,43 +92,31 @@ export class IblShadowsRenderPipeline extends PostProcessRenderPipeline {
     get ssShadowStride() {
         return this._voxelTracingPass?.sssStride;
     }
-    /**
-     * The stride of the screen-space shadow pass. This controls the distance between samples.
-     */
     set ssShadowStride(value) {
         if (!this._voxelTracingPass)
             return;
         this._voxelTracingPass.sssStride = value;
     }
     /**
-     * The maximum distance a shadow can be cast in screen space. This should usually be kept small
-     * as screenspace shadows are mostly useful for small details.
+     * A scale for the maximum distance a shadow can be cast in screen space.
+     * The absolute distance for SS shadows is derived from the voxel size and this scalar.
      */
-    get ssShadowMaxDist() {
-        return this._voxelTracingPass?.sssMaxDist;
+    get ssShadowDistanceScale() {
+        return this._sssMaxDistScale;
     }
-    /**
-     * The maximum distance a shadow can be cast in screen space. This should usually be kept small
-     * as screenspace shadows are mostly useful for small details.
-     */
-    set ssShadowMaxDist(value) {
-        if (!this._voxelTracingPass)
-            return;
-        this._voxelTracingPass.sssMaxDist = value;
+    set ssShadowDistanceScale(value) {
+        this._sssMaxDistScale = value;
+        this._updateSSShadowParams();
     }
     /**
      * Screen-space shadow thickness. This value controls the perceived thickness of the SS shadows.
      */
-    get ssShadowThickness() {
-        return this._voxelTracingPass?.sssThickness;
+    get ssShadowThicknessScale() {
+        return this._sssThicknessScale;
     }
-    /**
-     * Screen-space shadow thickness. This value controls the perceived thickness of the SS shadows.
-     */
-    set ssShadowThickness(value) {
-        if (!this._voxelTracingPass)
-            return;
-        this._voxelTracingPass.sssThickness = value;
+    set ssShadowThicknessScale(value) {
+        this._sssThicknessScale = value;
+        this._updateSSShadowParams();
     }
     /**
      * Set the IBL image to be used for shadowing. It can be either a cubemap
@@ -156,23 +131,86 @@ export class IblShadowsRenderPipeline extends PostProcessRenderPipeline {
     /**
      * Returns the texture containing the voxel grid data
      * @returns The texture containing the voxel grid data
+     * @internal
      */
-    getVoxelGridTexture() {
-        return this._voxelRenderer?.getVoxelGrid();
+    _getVoxelGridTexture() {
+        const tex = this._voxelRenderer?.getVoxelGrid();
+        if (tex && tex.isReady()) {
+            return tex;
+        }
+        return this._dummyTexture3d;
     }
     /**
      * Returns the texture containing the importance sampling CDF data for the IBL shadow pipeline
      * @returns The texture containing the importance sampling CDF data for the IBL shadow pipeline
+     * @internal
      */
-    getIcdfyTexture() {
-        return this._importanceSamplingRenderer.getIcdfyTexture();
+    _getIcdfyTexture() {
+        const tex = this._importanceSamplingRenderer.getIcdfyTexture();
+        if (tex && tex.isReady()) {
+            return tex;
+        }
+        return this._dummyTexture2d;
     }
     /**
      * Returns the texture containing the importance sampling CDF data for the IBL shadow pipeline
      * @returns The texture containing the importance sampling CDF data for the IBL shadow pipeline
+     * @internal
      */
-    getIcdfxTexture() {
-        return this._importanceSamplingRenderer.getIcdfxTexture();
+    _getIcdfxTexture() {
+        const tex = this._importanceSamplingRenderer.getIcdfxTexture();
+        if (tex && tex.isReady()) {
+            return tex;
+        }
+        return this._dummyTexture2d;
+    }
+    /**
+     * Returns the noise texture.
+     * @returns The noise texture.
+     * @internal
+     */
+    _getNoiseTexture() {
+        const tex = this._noiseTexture;
+        if (tex && tex.isReady()) {
+            return tex;
+        }
+        return this._dummyTexture2d;
+    }
+    /**
+     * Returns the voxel-tracing texture.
+     * @returns The voxel-tracing texture.
+     * @internal
+     */
+    _getVoxelTracingTexture() {
+        const tex = this._voxelTracingPass?.getOutputTexture();
+        if (tex && tex.isReady()) {
+            return tex;
+        }
+        return this._dummyTexture2d;
+    }
+    /**
+     * Returns the spatial blur texture.
+     * @returns The spatial blur texture.
+     * @internal
+     */
+    _getSpatialBlurTexture() {
+        const tex = this._spatialBlurPass.getOutputTexture();
+        if (tex && tex.isReady()) {
+            return tex;
+        }
+        return this._dummyTexture2d;
+    }
+    /**
+     * Returns the accumulated shadow texture.
+     * @returns The accumulated shadow texture.
+     * @internal
+     */
+    _getAccumulatedTexture() {
+        const tex = this._accumulationPass?.getOutputTexture();
+        if (tex && tex.isReady()) {
+            return tex;
+        }
+        return this._dummyTexture2d;
     }
     /**
      * Is the debug view of the G-Buffer enabled?
@@ -300,7 +338,7 @@ export class IblShadowsRenderPipeline extends PostProcessRenderPipeline {
      * Display the debug view for the spatial blur pass
      */
     get spatialBlurPassDebugEnabled() {
-        return this._spatialBlurPass?.debugEnabled;
+        return this._spatialBlurPass.debugEnabled;
     }
     /**
      * Display the debug view for the spatial blur pass
@@ -349,22 +387,41 @@ export class IblShadowsRenderPipeline extends PostProcessRenderPipeline {
         }
     }
     /**
-     * Add a mesh in the exclusion list to prevent it to be handled by the IBL shadow pipeline
-     * @param mesh The mesh to exclude from the IBL shadow pipeline
+     * Add a mesh to be used for shadow casting in the IBL shadow pipeline
+     * @param mesh A mesh or list of meshes that you want to cast shadows
      */
-    addExcludedMesh(mesh) {
-        if (this._excludedMeshes.indexOf(mesh.uniqueId) === -1) {
-            this._excludedMeshes.push(mesh.uniqueId);
+    addShadowCastingMesh(mesh) {
+        if (Array.isArray(mesh)) {
+            for (const m of mesh) {
+                if (m && this._shadowCastingMeshes.indexOf(m) === -1) {
+                    this._shadowCastingMeshes.push(m);
+                }
+            }
+        }
+        else {
+            if (mesh && this._shadowCastingMeshes.indexOf(mesh) === -1) {
+                this._shadowCastingMeshes.push(mesh);
+            }
         }
     }
     /**
-     * Remove a mesh from the exclusion list of the IBL shadow pipeline
-     * @param mesh The mesh to remove
+     * Remove a mesh from the shadow-casting list.
+     * @param mesh The mesh or list of meshes that you don't want to cast shadows.
      */
-    removeExcludedMesh(mesh) {
-        const index = this._excludedMeshes.indexOf(mesh.uniqueId);
-        if (index !== -1) {
-            this._excludedMeshes.splice(index, 1);
+    removeShadowCastingMesh(mesh) {
+        if (Array.isArray(mesh)) {
+            for (const m of mesh) {
+                const index = this._shadowCastingMeshes.indexOf(m);
+                if (index !== -1) {
+                    this._shadowCastingMeshes.splice(index, 1);
+                }
+            }
+        }
+        else {
+            const index = this._shadowCastingMeshes.indexOf(mesh);
+            if (index !== -1) {
+                this._shadowCastingMeshes.splice(index, 1);
+            }
         }
     }
     /**
@@ -388,7 +445,6 @@ export class IblShadowsRenderPipeline extends PostProcessRenderPipeline {
             return;
         }
         this._voxelRenderer.voxelResolutionExp = newResolution;
-        this.updateVoxelization();
         this._accumulationPass.reset = true;
     }
     /**
@@ -432,6 +488,7 @@ export class IblShadowsRenderPipeline extends PostProcessRenderPipeline {
         if (!this._voxelTracingPass)
             return;
         this._voxelTracingPass.envRotation = value;
+        this._accumulationPass.reset = true;
     }
     /**
      * Allow debug passes to be enabled. Default is false.
@@ -478,70 +535,93 @@ export class IblShadowsRenderPipeline extends PostProcessRenderPipeline {
      */
     constructor(name, scene, options = {}, cameras) {
         super(scene.getEngine(), name);
-        this._voxelizationDirty = true;
-        this._boundsNeedUpdate = true;
         this._allowDebugPasses = false;
         this._debugPasses = [];
-        this._excludedMeshes = [];
-        this._shadowOpacity = 0.75;
+        this._shadowCastingMeshes = [];
+        this._shadowOpacity = 0.8;
         this._enabled = true;
+        this._materialsWithRenderPlugin = [];
+        /**
+         * Observable that triggers when the shadow renderer is ready
+         */
+        this.onShadowTextureReadyObservable = new Observable();
+        /**
+         * Observable that triggers when a new IBL is set and the importance sampling is ready
+         */
+        this.onNewIblReadyObservable = new Observable();
         /**
          * The current world-space size of that the voxel grid covers in the scene.
          */
         this.voxelGridSize = 1.0;
+        this._renderSizeFactor = 1.0;
         this._gbufferDebugEnabled = false;
         this._gBufferDebugSizeParams = new Vector4(0.0, 0.0, 0.0, 0.0);
         this.scene = scene;
-        //  We need a depth texture for opaque
-        if (!scene.enablePrePassRenderer()) {
-            Logger.Warn("IBL Shadows Render Pipeline could not enable PrePass, aborting.");
-            return;
-        }
-        this.shadowOpacity = options.shadowOpacity || 0.75;
-        this._prePassEffectConfiguration = new IblShadowsPrepassConfiguration();
+        this._cameras = cameras || [scene.activeCamera];
+        // Create the dummy textures to be used when the pipeline is not ready
+        const blackPixels = new Uint8Array([0, 0, 0, 255]);
+        this._dummyTexture2d = new RawTexture(blackPixels, 1, 1, Engine.TEXTUREFORMAT_RGBA, scene, false);
+        this._dummyTexture3d = new RawTexture3D(blackPixels, 1, 1, 1, Engine.TEXTUREFORMAT_RGBA, scene, false);
+        // Setup the geometry buffer target formats
+        const textureTypesAndFormats = {};
+        textureTypesAndFormats[GeometryBufferRenderer.SCREENSPACE_DEPTH_TEXTURE_TYPE] = {
+            textureFormat: 6,
+            textureType: 1,
+        };
+        textureTypesAndFormats[GeometryBufferRenderer.VELOCITY_LINEAR_TEXTURE_TYPE] = {
+            textureFormat: 7,
+            textureType: 2,
+        };
+        textureTypesAndFormats[GeometryBufferRenderer.POSITION_TEXTURE_TYPE] = {
+            textureFormat: 5,
+            textureType: 2,
+        };
+        textureTypesAndFormats[GeometryBufferRenderer.NORMAL_TEXTURE_TYPE] = {
+            textureFormat: 5,
+            textureType: 2,
+        };
+        const geometryBufferRenderer = scene.enableGeometryBufferRenderer(undefined, 14, textureTypesAndFormats);
+        if (!geometryBufferRenderer) {
+            Logger.Error("Geometry buffer renderer is required for IBL shadows to work.");
+            return;
+        }
+        this._geometryBufferRenderer = geometryBufferRenderer;
+        this._geometryBufferRenderer.enableScreenspaceDepth = true;
+        this._geometryBufferRenderer.enableVelocityLinear = true;
+        this._geometryBufferRenderer.enablePosition = true;
+        this._geometryBufferRenderer.enableNormal = true;
+        this._geometryBufferRenderer.generateNormalsInWorldSpace = true;
+        this.shadowOpacity = options.shadowOpacity || 0.8;
         this._voxelRenderer = new _IblShadowsVoxelRenderer(this.scene, this, options ? options.resolutionExp : 6, options.triPlanarVoxelization !== undefined ? options.triPlanarVoxelization : true);
         this._importanceSamplingRenderer = new _IblShadowsImportanceSamplingRenderer(this.scene);
         this._voxelTracingPass = new _IblShadowsVoxelTracingPass(this.scene, this);
+        this._spatialBlurPass = new _IblShadowsSpatialBlurPass(this.scene, this);
+        this._accumulationPass = new _IblShadowsAccumulationPass(this.scene, this);
+        this._accumulationPass.onReadyObservable.addOnce(() => {
+            this.onShadowTextureReadyObservable.notifyObservers();
+        });
         this.sampleDirections = options.sampleDirections || 2;
-        this.voxelShadowOpacity = options.voxelShadowOpacity || 1.0;
+        this.voxelShadowOpacity = options.voxelShadowOpacity ?? 1.0;
+        this.shadowRenderSizeFactor = options.shadowRenderSizeFactor || 1.0;
         this.ssShadowOpacity = options.ssShadowsEnabled === undefined || options.ssShadowsEnabled ? 1.0 : 0.0;
-        this.ssShadowMaxDist = options.ssShadowMaxDist || 0.05;
+        this.ssShadowDistanceScale = options.ssShadowDistanceScale || 1.25;
         this.ssShadowSamples = options.ssShadowSampleCount || 16;
         this.ssShadowStride = options.ssShadowStride || 8;
-        this.ssShadowThickness = options.ssShadowThickness || 0.5;
-        this._spatialBlurPass = new _IblShadowsSpatialBlurPass(this.scene);
-        this._accumulationPass = new _IblShadowsAccumulationPass(this.scene);
-        this.shadowRemenance = options.shadowRemenance || 0.75;
+        this.ssShadowThicknessScale = options.ssShadowThicknessScale || 1.0;
+        this.shadowRemenance = options.shadowRemenance ?? 0.75;
         this._noiseTexture = new Texture("https://assets.babylonjs.com/textures/blue_noise/blue_noise_rgb.png", this.scene, false, true, 1);
         if (this.scene.environmentTexture) {
             this._importanceSamplingRenderer.iblSource = this.scene.environmentTexture;
         }
-        // Create post process that applies the shadows to the scene
-        this._createShadowCombinePostProcess();
         scene.postProcessRenderPipelineManager.addPipeline(this);
-        this.scene.onNewMeshAddedObservable.add(this.updateSceneBounds.bind(this));
-        this.scene.onMeshRemovedObservable.add(this.updateSceneBounds.bind(this));
         this.scene.onActiveCameraChanged.add(this._listenForCameraChanges.bind(this));
         this.scene.onBeforeRenderObservable.add(this._updateBeforeRender.bind(this));
         this._listenForCameraChanges();
         this.scene.getEngine().onResizeObservable.add(this._handleResize.bind(this));
-        // Only turn on the pipeline when the importance sampling RT's are ready
-        this._importanceSamplingRenderer.onReadyObservable.addOnce(() => {
-            this._createEffectPasses(cameras);
-            const checkVoxelRendererReady = () => {
-                if (this._voxelRenderer.isReady()) {
-                    this.toggleShadow(this._enabled);
-                    if (this._enabled) {
-                        this._voxelizationDirty = true;
-                    }
-                }
-                else {
-                    setTimeout(() => {
-                        checkVoxelRendererReady();
-                    }, 16);
-                }
-            };
-            checkVoxelRendererReady();
+        // Assigning the shadow texture to the materials needs to be done after the RT's are created.
+        this._importanceSamplingRenderer.onReadyObservable.add(() => {
+            this._setPluginParameters();
+            this.onNewIblReadyObservable.notifyObservers();
         });
     }
     /**
@@ -550,85 +630,30 @@ export class IblShadowsRenderPipeline extends PostProcessRenderPipeline {
      */
     toggleShadow(enabled) {
         this._enabled = enabled;
-        if (enabled) {
-            this._enableEffect("IBLShadowVoxelTracingPass", this.cameras);
-            this._enableEffect("IBLShadowSpatialBlurPass", this.cameras);
-            this._enableEffect("IBLShadowAccumulationBlurPass", this.cameras);
-            this._enableEffect("IBLShadowCompositePass", this.cameras);
-        }
-        else {
-            this._disableEffect("IBLShadowVoxelTracingPass", null);
-            this._disableEffect("IBLShadowSpatialBlurPass", null);
-            this._disableEffect("IBLShadowAccumulationBlurPass", null);
-            this._disableEffect("IBLShadowCompositePass", null);
-        }
+        this._voxelTracingPass.enabled = enabled;
+        this._spatialBlurPass.enabled = enabled;
+        this._accumulationPass.enabled = enabled;
+        this._materialsWithRenderPlugin.forEach((mat) => {
+            if (mat.pluginManager) {
+                const plugin = mat.pluginManager.getPlugin(IBLShadowsPluginMaterial.Name);
+                plugin.isEnabled = enabled;
+            }
+        });
+        this._setPluginParameters();
     }
     _handleResize() {
         this._voxelRenderer.resize();
-        this._accumulationPass?.resize();
-    }
-    _createShadowCombinePostProcess() {
-        const isWebGPU = this.engine.isWebGPU;
-        const compositeOptions = {
-            width: this.scene.getEngine().getRenderWidth(),
-            height: this.scene.getEngine().getRenderHeight(),
-            uniforms: ["shadowOpacity"],
-            samplers: ["sceneTexture"],
-            samplingMode: 2,
-            engine: this.scene.getEngine(),
-            textureType: 0,
-            reusable: false,
-            shaderLanguage: isWebGPU ? 1 /* ShaderLanguage.WGSL */ : 0 /* ShaderLanguage.GLSL */,
-            extraInitializations: (useWebGPU, list) => {
-                if (useWebGPU) {
-                    list.push(import("../../ShadersWGSL/iblShadowsCombine.fragment.js"));
-                }
-                else {
-                    list.push(import("../../Shaders/iblShadowsCombine.fragment.js"));
-                }
-            },
-        };
-        this._shadowCompositePP = new PostProcess("iblShadowsCombine", "iblShadowsCombine", compositeOptions);
-        this._shadowCompositePP.autoClear = false;
-        this._shadowCompositePP.onApplyObservable.add((effect) => {
-            // Setting the input of the tracing pass because this is the scene RT that we want to apply the shadows to.
-            effect.setTextureFromPostProcess("sceneTexture", this._voxelTracingPass.getPassPP());
-            effect.setFloat("shadowOpacity", this._shadowOpacity);
-            if (this._importanceSamplingRenderer?.isReady() &&
-                this._voxelRenderer?.isReady() &&
-                this._voxelTracingPass?.isReady() &&
-                this._spatialBlurPass?.isReady() &&
-                this._accumulationPass?.isReady()) {
-                this.update();
-            }
-        });
-        this._shadowCompositePP._prePassEffectConfiguration = this._prePassEffectConfiguration;
-    }
-    _createEffectPasses(cameras) {
-        this.addEffect(new PostProcessRenderEffect(this.scene.getEngine(), "IBLShadowVoxelTracingPass", () => {
-            return this._voxelTracingPass.getPassPP();
-        }, true));
-        this.addEffect(new PostProcessRenderEffect(this.scene.getEngine(), "IBLShadowSpatialBlurPass", () => {
-            return this._spatialBlurPass.getPassPP();
-        }, true));
-        this.addEffect(new PostProcessRenderEffect(this.scene.getEngine(), "IBLShadowAccumulationBlurPass", () => {
-            return this._accumulationPass.getPassPP();
-        }, true));
-        this.addEffect(new PostProcessRenderEffect(this.scene.getEngine(), "IBLShadowCompositePass", () => {
-            return this._shadowCompositePP;
-        }, true));
-        if (cameras) {
-            this.scene.postProcessRenderPipelineManager.attachCamerasToRenderPipeline(this.name, cameras);
-        }
-        this.toggleShadow(false);
-        this._enabled = true;
+        this._voxelTracingPass.resize(this.shadowRenderSizeFactor);
+        this._spatialBlurPass.resize(this.shadowRenderSizeFactor);
+        this._accumulationPass.resize(this.shadowRenderSizeFactor);
+        this._setPluginParameters();
     }
     _getGBufferDebugPass() {
         if (this._gbufferDebugPass) {
             return this._gbufferDebugPass;
         }
         const isWebGPU = this.engine.isWebGPU;
-        const textureNames = this._prePassEffectConfiguration.texturesRequired.map((type) => PrePassRenderer.TextureFormats[type].name.toString());
+        const textureNames = ["depthSampler", "normalSampler", "positionSampler", "velocitySampler"];
         const options = {
             width: this.scene.getEngine().getRenderWidth(),
             height: this.scene.getEngine().getRenderHeight(),
@@ -652,16 +677,14 @@ export class IblShadowsRenderPipeline extends PostProcessRenderPipeline {
         this._gbufferDebugPass = new PostProcess("iblShadowGBufferDebug", "iblShadowGBufferDebug", options);
         this._gbufferDebugPass.autoClear = false;
         this._gbufferDebugPass.onApplyObservable.add((effect) => {
-            this._prePassEffectConfiguration.texturesRequired.forEach((type) => {
-                const prePassRenderer = this.scene.prePassRenderer;
-                if (!prePassRenderer) {
-                    Logger.Error("Can't enable G-Buffer debug rendering since prepassRenderer doesn't exist.");
-                    return;
-                }
-                const index = prePassRenderer.getIndex(type);
-                if (index >= 0)
-                    effect.setTexture(PrePassRenderer.TextureFormats[type].name, prePassRenderer.getRenderTarget().textures[index]);
-            });
+            const depthIndex = this._geometryBufferRenderer.getTextureIndex(GeometryBufferRenderer.SCREENSPACE_DEPTH_TEXTURE_TYPE);
+            effect.setTexture("depthSampler", this._geometryBufferRenderer.getGBuffer().textures[depthIndex]);
+            const normalIndex = this._geometryBufferRenderer.getTextureIndex(GeometryBufferRenderer.NORMAL_TEXTURE_TYPE);
+            effect.setTexture("normalSampler", this._geometryBufferRenderer.getGBuffer().textures[normalIndex]);
+            const positionIndex = this._geometryBufferRenderer.getTextureIndex(GeometryBufferRenderer.POSITION_TEXTURE_TYPE);
+            effect.setTexture("positionSampler", this._geometryBufferRenderer.getGBuffer().textures[positionIndex]);
+            const velocityIndex = this._geometryBufferRenderer.getTextureIndex(GeometryBufferRenderer.VELOCITY_LINEAR_TEXTURE_TYPE);
+            effect.setTexture("velocitySampler", this._geometryBufferRenderer.getGBuffer().textures[velocityIndex]);
             effect.setVector4("sizeParams", this._gBufferDebugSizeParams);
             if (this.scene.activeCamera) {
                 effect.setFloat("maxDepth", this.scene.activeCamera.maxZ);
@@ -671,11 +694,11 @@ export class IblShadowsRenderPipeline extends PostProcessRenderPipeline {
     }
     _createDebugPasses() {
         this._debugPasses = [
-            { pass: this._importanceSamplingRenderer?.getDebugPassPP(), enabled: this.importanceSamplingDebugEnabled },
-            { pass: this._voxelRenderer?.getDebugPassPP(), enabled: this.voxelDebugEnabled },
-            { pass: this._voxelTracingPass?.getDebugPassPP(), enabled: this.voxelTracingDebugEnabled },
-            { pass: this._spatialBlurPass?.getDebugPassPP(), enabled: this.spatialBlurPassDebugEnabled },
-            { pass: this._accumulationPass?.getDebugPassPP(), enabled: this.accumulationPassDebugEnabled },
+            { pass: this._importanceSamplingRenderer.getDebugPassPP(), enabled: this.importanceSamplingDebugEnabled },
+            { pass: this._voxelRenderer.getDebugPassPP(), enabled: this.voxelDebugEnabled },
+            { pass: this._voxelTracingPass.getDebugPassPP(), enabled: this.voxelTracingDebugEnabled },
+            { pass: this._spatialBlurPass.getDebugPassPP(), enabled: this.spatialBlurPassDebugEnabled },
+            { pass: this._accumulationPass.getDebugPassPP(), enabled: this.accumulationPassDebugEnabled },
             { pass: this._getGBufferDebugPass(), enabled: this.gbufferDebugEnabled },
         ];
         for (let i = 0; i < this._debugPasses.length; i++) {
@@ -701,10 +724,6 @@ export class IblShadowsRenderPipeline extends PostProcessRenderPipeline {
     }
     _disposeEffectPasses() {
         this.scene.postProcessRenderPipelineManager.detachCamerasFromRenderPipeline(this.name, this.cameras);
-        this._disableEffect("IBLShadowVoxelTracingPass", this.cameras);
-        this._disableEffect("IBLShadowSpatialBlurPass", this.cameras);
-        this._disableEffect("IBLShadowAccumulationBlurPass", this.cameras);
-        this._disableEffect("IBLShadowCompositePass", this.cameras);
         this._disposeDebugPasses();
         this._reset();
     }
@@ -736,11 +755,6 @@ export class IblShadowsRenderPipeline extends PostProcessRenderPipeline {
         let x = 0;
         let y = 0;
         if (this.gbufferDebugEnabled) {
-            const prePassRenderer = this.scene.prePassRenderer;
-            if (!prePassRenderer) {
-                Logger.Error("Can't enable G-Buffer debug rendering since prepassRenderer doesn't exist.");
-                return;
-            }
             this._gBufferDebugSizeParams.set(x, y, cols, rows);
             x -= width;
             if (x <= -1) {
@@ -793,60 +807,136 @@ export class IblShadowsRenderPipeline extends PostProcessRenderPipeline {
      * Trigger the scene to be re-voxelized. This is useful when the scene has changed and the voxel grid needs to be updated.
      */
     updateVoxelization() {
-        this._voxelizationDirty = true;
+        if (this._shadowCastingMeshes.length === 0) {
+            Logger.Warn("IBL Shadows: updateVoxelization called with no shadow-casting meshes to voxelize.");
+            return;
+        }
+        this._voxelRenderer.updateVoxelGrid(this._shadowCastingMeshes);
+        this._updateSSShadowParams();
     }
     /**
      * Trigger the scene bounds of shadow-casters to be updated. This is useful when the scene has changed and the bounds need
      * to be recalculated. This will also trigger a re-voxelization.
      */
     updateSceneBounds() {
-        this._voxelizationDirty = true;
-        this._boundsNeedUpdate = true;
+        const bounds = {
+            min: new Vector3(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE),
+            max: new Vector3(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE),
+        };
+        this._shadowCastingMeshes.forEach((mesh) => {
+            const localBounds = mesh.getHierarchyBoundingVectors(true);
+            bounds.min = Vector3.Minimize(bounds.min, localBounds.min);
+            bounds.max = Vector3.Maximize(bounds.max, localBounds.max);
+        });
+        const size = bounds.max.subtract(bounds.min);
+        this.voxelGridSize = Math.max(size.x, size.y, size.z);
+        if (this._shadowCastingMeshes.length === 0 || !isFinite(this.voxelGridSize) || this.voxelGridSize === 0) {
+            Logger.Warn("IBL Shadows: Scene size is invalid. Can't update bounds.");
+            this.voxelGridSize = 1.0;
+            return;
+        }
+        const halfSize = this.voxelGridSize / 2.0;
+        const centre = bounds.max.add(bounds.min).multiplyByFloats(-0.5, -0.5, -0.5);
+        const invWorldScaleMatrix = Matrix.Compose(new Vector3(1.0 / halfSize, 1.0 / halfSize, 1.0 / halfSize), new Quaternion(), new Vector3(0, 0, 0));
+        const invTranslationMatrix = Matrix.Compose(new Vector3(1.0, 1.0, 1.0), new Quaternion(), centre);
+        invTranslationMatrix.multiplyToRef(invWorldScaleMatrix, invWorldScaleMatrix);
+        this._voxelTracingPass.setWorldScaleMatrix(invWorldScaleMatrix);
+        this._voxelRenderer.setWorldScaleMatrix(invWorldScaleMatrix);
+        // Set world scale for spatial blur.
+        this._spatialBlurPass.setWorldScale(halfSize * 2.0);
+        this._updateSSShadowParams();
     }
-    _updateBeforeRender() {
-        this._updateDebugPasses();
+    /**
+     * Update the SS shadow max distance and thickness based on the voxel grid size and resolution.
+     * The max distance should be just a little larger than the world size of a single voxel.
+     */
+    _updateSSShadowParams() {
+        this._voxelTracingPass.sssMaxDist = (this._sssMaxDistScale * this.voxelGridSize) / (1 << this.resolutionExp);
+        this._voxelTracingPass.sssThickness = this._sssThicknessScale * 0.005 * this.voxelGridSize;
     }
-    _listenForCameraChanges() {
-        // We want to listen for camera changes and change settings while the camera is moving.
-        if (this.scene.activeCamera instanceof ArcRotateCamera) {
-            this.scene.onBeforeCameraRenderObservable.add((camera) => {
-                let isMoving = false;
-                if (camera instanceof ArcRotateCamera) {
-                    isMoving =
-                        camera.inertialAlphaOffset !== 0 ||
-                            camera.inertialBetaOffset !== 0 ||
-                            camera.inertialRadiusOffset !== 0 ||
-                            camera.inertialPanningX !== 0 ||
-                            camera.inertialPanningY !== 0;
-                }
-                else if (camera instanceof FreeCamera) {
-                    isMoving =
-                        camera.cameraDirection.x !== 0 ||
-                            camera.cameraDirection.y !== 0 ||
-                            camera.cameraDirection.z !== 0 ||
-                            camera.cameraRotation.x !== 0 ||
-                            camera.cameraRotation.y !== 0;
-                }
-                if (this._accumulationPass) {
-                    if (isMoving) {
-                        // this._accumulationPass.reset = true;
-                        // this._accumulationPass.remenance = 1.0;
-                    }
-                    else {
-                        // this._accumulationPass.reset = false;
-                        // this._accumulationPass.remenance = 0.9;
-                    }
-                }
+    /**
+     * Apply the shadows to a material or array of materials.
+     * @param material Material that will be affected by the shadows. If not provided, all materials of the scene will be affected.
+     */
+    addShadowReceivingMaterial(material) {
+        if (material) {
+            if (Array.isArray(material)) {
+                material.forEach((m) => {
+                    this._addShadowSupportToMaterial(m);
+                });
+            }
+            else {
+                this._addShadowSupportToMaterial(material);
+            }
+        }
+        else {
+            this.scene.materials.forEach((mat) => {
+                this._addShadowSupportToMaterial(mat);
             });
         }
     }
     /**
-     * Links to the prepass renderer
-     * @param prePassRenderer The scene PrePassRenderer
-     * @returns true if the pre pass is setup
+     * Remove a material from receiving shadows
+     * @param material The material that will no longer receive shadows
      */
-    setPrePassRenderer(prePassRenderer) {
-        return !!prePassRenderer.addEffectConfiguration(this._prePassEffectConfiguration);
+    removeShadowReceivingMaterial(material) {
+        if (Array.isArray(material)) {
+            material.forEach((m) => {
+                const matIndex = this._materialsWithRenderPlugin.indexOf(m);
+                if (matIndex !== -1) {
+                    this._materialsWithRenderPlugin.splice(matIndex, 1);
+                    const plugin = m.pluginManager?.getPlugin(IBLShadowsPluginMaterial.Name);
+                    plugin.isEnabled = false;
+                }
+            });
+        }
+        else {
+            const matIndex = this._materialsWithRenderPlugin.indexOf(material);
+            if (matIndex !== -1) {
+                this._materialsWithRenderPlugin.splice(matIndex, 1);
+                const plugin = material.pluginManager.getPlugin(IBLShadowsPluginMaterial.Name);
+                plugin.isEnabled = false;
+            }
+        }
+    }
+    _addShadowSupportToMaterial(material) {
+        if (!(material instanceof PBRBaseMaterial) && !(material instanceof StandardMaterial)) {
+            return;
+        }
+        let plugin = material.pluginManager?.getPlugin(IBLShadowsPluginMaterial.Name);
+        if (!plugin) {
+            plugin = new IBLShadowsPluginMaterial(material);
+        }
+        if (this._materialsWithRenderPlugin.indexOf(material) !== -1) {
+            return;
+        }
+        if (this._enabled) {
+            plugin.iblShadowsTexture = this._getAccumulatedTexture().getInternalTexture();
+            plugin.shadowOpacity = this.shadowOpacity;
+        }
+        plugin.isEnabled = this._enabled;
+        this._materialsWithRenderPlugin.push(material);
+    }
+    _setPluginParameters() {
+        if (!this._enabled) {
+            return;
+        }
+        this._materialsWithRenderPlugin.forEach((mat) => {
+            if (mat.pluginManager) {
+                const plugin = mat.pluginManager.getPlugin(IBLShadowsPluginMaterial.Name);
+                plugin.iblShadowsTexture = this._getAccumulatedTexture().getInternalTexture();
+                plugin.shadowOpacity = this.shadowOpacity;
+            }
+        });
+    }
+    _updateBeforeRender() {
+        this._updateDebugPasses();
+    }
+    _listenForCameraChanges() {
+        // We want to listen for camera changes and change settings while the camera is moving.
+        this.scene.activeCamera?.onViewMatrixChangedObservable.add(() => {
+            this._accumulationPass.isMoving = true;
+        });
     }
     /**
      * Checks if the IBL shadow pipeline is ready to render shadows
@@ -860,54 +950,6 @@ export class IblShadowsRenderPipeline extends PostProcessRenderPipeline {
             (!this._spatialBlurPass || this._spatialBlurPass.isReady()) &&
             (!this._accumulationPass || this._accumulationPass.isReady()));
     }
-    /**
-     * Renders accumulated shadows for IBL
-     */
-    update() {
-        // This is called for every MRT in the customRenderTargets structure during voxelization. That doesn't make
-        // sense. We only want this to run after voxelization so we should put in some state logic here to return
-        // if voxelization is happening.
-        if (this._voxelRenderer.isVoxelizationInProgress()) {
-            return;
-        }
-        if (this._boundsNeedUpdate) {
-            const bounds = this.scene.getWorldExtends((mesh) => {
-                return mesh instanceof Mesh && this._excludedMeshes.indexOf(mesh.uniqueId) === -1;
-            });
-            const size = bounds.max.subtract(bounds.min);
-            this.voxelGridSize = Math.max(size.x, Math.max(size.y, size.z));
-            if (!isFinite(this.voxelGridSize) || this.voxelGridSize === 0) {
-                Logger.Warn("IBL Shadows: Scene size is invalid. Can't update bounds.");
-                this._boundsNeedUpdate = false;
-                this.voxelGridSize = 1.0;
-                return;
-            }
-            const halfSize = this.voxelGridSize / 2.0;
-            const centre = bounds.max.add(bounds.min).multiplyByFloats(-0.5, -0.5, -0.5);
-            const invWorldScaleMatrix = Matrix.Compose(new Vector3(1.0 / halfSize, 1.0 / halfSize, 1.0 / halfSize), new Quaternion(), new Vector3(0, 0, 0));
-            const invTranslationMatrix = Matrix.Compose(new Vector3(1.0, 1.0, 1.0), new Quaternion(), centre);
-            invTranslationMatrix.multiplyToRef(invWorldScaleMatrix, invWorldScaleMatrix);
-            this._voxelTracingPass?.setWorldScaleMatrix(invWorldScaleMatrix);
-            this._voxelRenderer.setWorldScaleMatrix(invWorldScaleMatrix);
-            // Set world scale for spatial blur.
-            this._spatialBlurPass?.setWorldScale(halfSize * 2.0);
-            this._boundsNeedUpdate = false;
-            // Logger.Log("IBL Shadows: Scene size: " + size);
-            // Logger.Log("Half size: " + halfSize);
-            // Logger.Log("Centre translation: " + centre);
-            // Update the SS shadow max distance based on the voxel grid size and resolution.
-            // The max distance should be just a little larger than the world size of a single voxel.
-            this.ssShadowMaxDist = (1.1 * this.voxelGridSize) / (1 << this.resolutionExp);
-        }
-        // If update is needed, render voxels
-        if (this._voxelizationDirty) {
-            this._voxelRenderer.updateVoxelGrid(this._excludedMeshes);
-            this._voxelizationDirty = false;
-            // Update the SS shadow max distance based on the voxel grid size and resolution.
-            // The max distance should be just a little larger than the world size of a single voxel.
-            this.ssShadowMaxDist = (1.1 * this.voxelGridSize) / (1 << this.resolutionExp);
-        }
-    }
     /**
      * Get the class name
      * @returns "IBLShadowsRenderPipeline"
@@ -919,13 +961,19 @@ export class IblShadowsRenderPipeline extends PostProcessRenderPipeline {
      * Disposes the IBL shadow pipeline and associated resources
      */
     dispose() {
+        const materials = this._materialsWithRenderPlugin.splice(0);
+        materials.forEach((mat) => {
+            this.removeShadowReceivingMaterial(mat);
+        });
         this._disposeEffectPasses();
         this._noiseTexture.dispose();
         this._voxelRenderer.dispose();
         this._importanceSamplingRenderer.dispose();
-        this._voxelTracingPass?.dispose();
-        this._spatialBlurPass?.dispose();
-        this._accumulationPass?.dispose();
+        this._voxelTracingPass.dispose();
+        this._spatialBlurPass.dispose();
+        this._accumulationPass.dispose();
+        this._dummyTexture2d.dispose();
+        this._dummyTexture3d.dispose();
         super.dispose();
     }
 }