@babylonjs/core 7.22.3 → 7.22.4

package/Rendering/IBLShadows/iblShadowsRenderPipeline.js

@@ -0,0 +1,884 @@
+
+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";
+import "../../Shaders/postprocess.vertex.js";
+import "../../Shaders/iblShadowGBufferDebug.fragment.js";
+import "../../Shaders/iblShadowsCombine.fragment.js";
+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,
+        ];
+    }
+}
+/**
+ * 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.
+     */
+    get shadowOpacity() {
+        return this._shadowOpacity;
+    }
+    /**
+     * How dark the shadows appear. 1.0 is full opacity, 0.0 is no shadows.
+     */
+    set shadowOpacity(value) {
+        this._shadowOpacity = value;
+    }
+    /**
+     * How dark the voxel shadows appear. 1.0 is full opacity, 0.0 is no shadows.
+     */
+    get voxelShadowOpacity() {
+        return this._voxelTracingPass?.voxelShadowOpacity;
+    }
+    /**
+     * How dark the voxel shadows appear. 1.0 is full opacity, 0.0 is no shadows.
+     */
+    set voxelShadowOpacity(value) {
+        if (!this._voxelTracingPass)
+            return;
+        this._voxelTracingPass.voxelShadowOpacity = value;
+    }
+    /**
+     * How dark the screen-space shadows appear. 1.0 is full opacity, 0.0 is no shadows.
+     */
+    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;
+        this._voxelTracingPass.ssShadowOpacity = value;
+    }
+    /**
+     * The number of samples used in the screen space shadow pass.
+     */
+    get ssShadowSamples() {
+        return this._voxelTracingPass?.sssSamples;
+    }
+    /**
+     * The number of samples used in the screen space shadow pass.
+     */
+    set ssShadowSamples(value) {
+        if (!this._voxelTracingPass)
+            return;
+        this._voxelTracingPass.sssSamples = value;
+    }
+    /**
+     * The stride of the screen-space shadow pass. This controls the distance between samples.
+     */
+    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.
+     */
+    get ssShadowMaxDist() {
+        return this._voxelTracingPass?.sssMaxDist;
+    }
+    /**
+     * 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;
+    }
+    /**
+     * Screen-space shadow thickness. This value controls the perceived thickness of the SS shadows.
+     */
+    get ssShadowThickness() {
+        return this._voxelTracingPass?.sssThickness;
+    }
+    /**
+     * 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 the IBL image to be used for shadowing. It can be either a cubemap
+     * or a 2D equirectangular texture.
+     * @param iblSource The texture to use for IBL shadowing
+     */
+    setIblTexture(iblSource) {
+        if (!this._importanceSamplingRenderer)
+            return;
+        this._importanceSamplingRenderer.iblSource = iblSource;
+    }
+    /**
+     * Returns the texture containing the voxel grid data
+     * @returns The texture containing the voxel grid data
+     */
+    getVoxelGridTexture() {
+        return this._voxelRenderer?.getVoxelGrid();
+    }
+    /**
+     * 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
+     */
+    getIcdfyTexture() {
+        return this._importanceSamplingRenderer.getIcdfyTexture();
+    }
+    /**
+     * 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
+     */
+    getIcdfxTexture() {
+        return this._importanceSamplingRenderer.getIcdfxTexture();
+    }
+    /**
+     * Is the debug view of the G-Buffer enabled?
+     */
+    get gbufferDebugEnabled() {
+        return this._gbufferDebugEnabled;
+    }
+    /**
+     * Turn on or off the debug view of the G-Buffer
+     */
+    set gbufferDebugEnabled(enabled) {
+        if (enabled && !this.allowDebugPasses) {
+            Logger.Warn("Can't enable G-Buffer debug view without setting allowDebugPasses to true.");
+            return;
+        }
+        this._gbufferDebugEnabled = enabled;
+        if (enabled) {
+            this._enableEffect(this._getGBufferDebugPass().name, this.cameras);
+        }
+        else {
+            this._disableEffect(this._getGBufferDebugPass().name, this.cameras);
+        }
+    }
+    /**
+     * Turn on or off the debug view of the CDF importance sampling data
+     */
+    get importanceSamplingDebugEnabled() {
+        return this._importanceSamplingRenderer?.debugEnabled;
+    }
+    /**
+     * Turn on or off the debug view of the CDF importance sampling data
+     */
+    set importanceSamplingDebugEnabled(enabled) {
+        if (!this._importanceSamplingRenderer)
+            return;
+        if (enabled && !this.allowDebugPasses) {
+            Logger.Warn("Can't enable importance sampling debug view without setting allowDebugPasses to true.");
+            return;
+        }
+        if (enabled === this._importanceSamplingRenderer.debugEnabled)
+            return;
+        this._importanceSamplingRenderer.debugEnabled = enabled;
+        if (enabled) {
+            this._enableEffect(this._importanceSamplingRenderer.debugPassName, this.cameras);
+        }
+        else {
+            this._disableEffect(this._importanceSamplingRenderer.debugPassName, this.cameras);
+        }
+    }
+    /**
+     * Turn on or off the debug view of the voxel grid
+     */
+    get voxelDebugEnabled() {
+        return this._voxelRenderer?.voxelDebugEnabled;
+    }
+    /**
+     * Turn on or off the debug view of the voxel grid
+     */
+    set voxelDebugEnabled(enabled) {
+        if (!this._voxelRenderer)
+            return;
+        if (enabled && !this.allowDebugPasses) {
+            Logger.Warn("Can't enable voxel debug view without setting allowDebugPasses to true.");
+            return;
+        }
+        this._voxelRenderer.voxelDebugEnabled = enabled;
+        if (enabled) {
+            this._enableEffect(this._voxelRenderer.debugPassName, this.cameras);
+        }
+        else {
+            this._disableEffect(this._voxelRenderer.debugPassName, this.cameras);
+        }
+    }
+    /**
+     * Set the axis to display for the voxel grid debug view
+     * When using tri-axis voxelization, this will display the voxel grid for the specified axis
+     */
+    get voxelDebugAxis() {
+        return this._voxelRenderer?.voxelDebugAxis;
+    }
+    /**
+     * Set the axis to display for the voxel grid debug view
+     * When using tri-axis voxelization, this will display the voxel grid for the specified axis
+     */
+    set voxelDebugAxis(axisNum) {
+        if (!this._voxelRenderer)
+            return;
+        this._voxelRenderer.voxelDebugAxis = axisNum;
+    }
+    /**
+     * Set the mip level to display for the voxel grid debug view
+     */
+    set voxelDebugDisplayMip(mipNum) {
+        if (!this._voxelRenderer)
+            return;
+        this._voxelRenderer.setDebugMipNumber(mipNum);
+    }
+    /**
+     * Display the debug view for the voxel tracing pass
+     */
+    get voxelTracingDebugEnabled() {
+        return this._voxelTracingPass?.debugEnabled;
+    }
+    /**
+     * Display the debug view for the voxel tracing pass
+     */
+    set voxelTracingDebugEnabled(enabled) {
+        if (!this._voxelTracingPass)
+            return;
+        if (enabled && !this.allowDebugPasses) {
+            Logger.Warn("Can't enable voxel tracing debug view without setting allowDebugPasses to true.");
+            return;
+        }
+        if (enabled === this._voxelTracingPass.debugEnabled)
+            return;
+        this._voxelTracingPass.debugEnabled = enabled;
+        if (enabled) {
+            this._enableEffect(this._voxelTracingPass.debugPassName, this.cameras);
+        }
+        else {
+            this._disableEffect(this._voxelTracingPass.debugPassName, this.cameras);
+        }
+    }
+    /**
+     * Display the debug view for the spatial blur pass
+     */
+    get spatialBlurPassDebugEnabled() {
+        return this._spatialBlurPass?.debugEnabled;
+    }
+    /**
+     * Display the debug view for the spatial blur pass
+     */
+    set spatialBlurPassDebugEnabled(enabled) {
+        if (!this._spatialBlurPass)
+            return;
+        if (enabled && !this.allowDebugPasses) {
+            Logger.Warn("Can't enable spatial blur debug view without setting allowDebugPasses to true.");
+            return;
+        }
+        if (enabled === this._spatialBlurPass.debugEnabled)
+            return;
+        this._spatialBlurPass.debugEnabled = enabled;
+        if (enabled) {
+            this._enableEffect(this._spatialBlurPass.debugPassName, this.cameras);
+        }
+        else {
+            this._disableEffect(this._spatialBlurPass.debugPassName, this.cameras);
+        }
+    }
+    /**
+     * Display the debug view for the accumulation pass
+     */
+    get accumulationPassDebugEnabled() {
+        return this._accumulationPass?.debugEnabled;
+    }
+    /**
+     * Display the debug view for the accumulation pass
+     */
+    set accumulationPassDebugEnabled(enabled) {
+        if (!this._accumulationPass)
+            return;
+        if (enabled && !this.allowDebugPasses) {
+            Logger.Warn("Can't enable accumulation pass debug view without setting allowDebugPasses to true.");
+            return;
+        }
+        if (enabled === this._accumulationPass.debugEnabled)
+            return;
+        this._accumulationPass.debugEnabled = enabled;
+        if (enabled) {
+            this._enableEffect(this._accumulationPass.debugPassName, this.cameras);
+        }
+        else {
+            this._disableEffect(this._accumulationPass.debugPassName, this.cameras);
+        }
+    }
+    /**
+     * 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
+     */
+    addExcludedMesh(mesh) {
+        if (this._excludedMeshes.indexOf(mesh.uniqueId) === -1) {
+            this._excludedMeshes.push(mesh.uniqueId);
+        }
+    }
+    /**
+     * Remove a mesh from the exclusion list of the IBL shadow pipeline
+     * @param mesh The mesh to remove
+     */
+    removeExcludedMesh(mesh) {
+        const index = this._excludedMeshes.indexOf(mesh.uniqueId);
+        if (index !== -1) {
+            this._excludedMeshes.splice(index, 1);
+        }
+    }
+    /**
+     * The exponent of the resolution of the voxel shadow grid. Higher resolutions will result in sharper
+     * shadows but are more expensive to compute and require more memory.
+     * The resolution is calculated as 2 to the power of this number.
+     */
+    get resolutionExp() {
+        return this._voxelRenderer.voxelResolutionExp;
+    }
+    /**
+     * The exponent of the resolution of the voxel shadow grid. Higher resolutions will result in sharper
+     * shadows but are more expensive to compute and require more memory.
+     * The resolution is calculated as 2 to the power of this number.
+     */
+    set resolutionExp(newResolution) {
+        if (newResolution === this._voxelRenderer.voxelResolutionExp)
+            return;
+        if (this._voxelRenderer.isVoxelizationInProgress()) {
+            Logger.Warn("Can't change the resolution of the voxel grid while voxelization is in progress.");
+            return;
+        }
+        this._voxelRenderer.voxelResolutionExp = newResolution;
+        this.updateVoxelization();
+        setTimeout(() => {
+            // TODO - why do we need to run this a second time to get the voxel grid to update?
+            this.updateVoxelization();
+        }, 0);
+    }
+    /**
+     * The number of different directions to sample during the voxel tracing pass
+     */
+    get sampleDirections() {
+        return this._voxelTracingPass?.sampleDirections;
+    }
+    /**
+     * The number of different directions to sample during the voxel tracing pass
+     */
+    set sampleDirections(value) {
+        if (!this._voxelTracingPass)
+            return;
+        this._voxelTracingPass.sampleDirections = value;
+    }
+    /**
+     * The decree to which the shadows persist between frames. 0.0 is no persistence, 1.0 is full persistence.
+     **/
+    get shadowRemenance() {
+        return this._accumulationPass?.remenance;
+    }
+    /**
+     * The decree to which the shadows persist between frames. 0.0 is no persistence, 1.0 is full persistence.
+     **/
+    set shadowRemenance(value) {
+        if (!this._accumulationPass)
+            return;
+        this._accumulationPass.remenance = value;
+    }
+    /**
+     * The global rotation of the IBL for shadows
+     */
+    get envRotation() {
+        return this._voxelTracingPass?.envRotation;
+    }
+    /**
+     * The global rotation of the IBL for shadows
+     */
+    set envRotation(value) {
+        if (!this._voxelTracingPass)
+            return;
+        this._voxelTracingPass.envRotation = value;
+    }
+    /**
+     * Allow debug passes to be enabled. Default is false.
+     */
+    get allowDebugPasses() {
+        return this._allowDebugPasses;
+    }
+    /**
+     * Allow debug passes to be enabled. Default is false.
+     */
+    set allowDebugPasses(value) {
+        if (this._allowDebugPasses === value)
+            return;
+        this._allowDebugPasses = value;
+        if (value) {
+            this._createDebugPasses();
+        }
+        else {
+            this._disposeDebugPasses();
+        }
+    }
+    /**
+     *  Support test.
+     */
+    static get IsSupported() {
+        const engine = EngineStore.LastCreatedEngine;
+        if (!engine) {
+            return false;
+        }
+        return engine._features.supportIBLShadows;
+    }
+    /**
+     * @param name The rendering pipeline name
+     * @param scene The scene linked to this pipeline
+     * @param options Options to configure the pipeline
+     * @param cameras Cameras to apply the pipeline to.
+     */
+    constructor(name, scene, options = {}, cameras) {
+        super(scene.getEngine(), name);
+        this._voxelizationDirty = true;
+        this._boundsNeedUpdate = true;
+        this._allowDebugPasses = false;
+        this._debugPasses = [];
+        this._excludedMeshes = [];
+        this._shadowOpacity = 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 || 1.0;
+        this._prePassEffectConfiguration = new IblShadowsPrepassConfiguration();
+        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.sampleDirections = options.sampleDirections || 2;
+        this.ssShadowOpacity = options.ssShadowsEnabled === undefined || options.ssShadowsEnabled ? 1.0 : 0.0;
+        this.ssShadowMaxDist = options.ssShadowMaxDist || 0.05;
+        this.ssShadowSamples = options.ssShadowSampleCount || 16;
+        this.ssShadowStride = options.ssShadowStride || 8;
+        this.ssShadowThickness = options.ssShadowThickness || 0.01;
+        this._spatialBlurPass = new _IblShadowsSpatialBlurPass(this.scene);
+        this._accumulationPass = new _IblShadowsAccumulationPass(this.scene);
+        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._createEffectPasses(cameras);
+        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));
+        this._importanceSamplingRenderer.onReadyObservable.addOnce(() => {
+            if (this._voxelRenderer.isReady()) {
+                this.toggleShadow(true);
+            }
+            else {
+                this._voxelRenderer.onReadyObservable.addOnce(() => {
+                    this.toggleShadow(true);
+                });
+            }
+        });
+    }
+    /**
+     * Toggle the shadow tracing on or off
+     * @param enabled Toggle the shadow tracing on or off
+     */
+    toggleShadow(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);
+        }
+    }
+    _handleResize() {
+        this._voxelRenderer.resize();
+        this._accumulationPass?.resize();
+    }
+    _createShadowCombinePostProcess() {
+        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,
+        };
+        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;
+        setTimeout(() => {
+            this._voxelizationDirty = true;
+        }, 500);
+    }
+    _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);
+        if (this.allowDebugPasses) {
+            this._createDebugPasses();
+        }
+    }
+    _getGBufferDebugPass() {
+        if (this._gbufferDebugPass) {
+            return this._gbufferDebugPass;
+        }
+        const textureNames = this._prePassEffectConfiguration.texturesRequired.map((type) => PrePassRenderer.TextureFormats[type].name.toString());
+        const options = {
+            width: this.scene.getEngine().getRenderWidth(),
+            height: this.scene.getEngine().getRenderHeight(),
+            samplingMode: 1,
+            engine: this.scene.getEngine(),
+            textureType: 0,
+            textureFormat: 5,
+            uniforms: ["sizeParams"],
+            samplers: textureNames,
+            reusable: false,
+        };
+        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]);
+            });
+            effect.setVector4("sizeParams", this._gBufferDebugSizeParams);
+            if (this.scene.activeCamera) {
+                effect.setFloat("maxDepth", this.scene.activeCamera.maxZ);
+            }
+        });
+        return this._gbufferDebugPass;
+    }
+    _createDebugPasses() {
+        this._debugPasses = [
+            this._importanceSamplingRenderer?.getDebugPassPP(),
+            this._voxelRenderer?.getDebugPassPP(),
+            this._voxelTracingPass?.getDebugPassPP(),
+            this._spatialBlurPass?.getDebugPassPP(),
+            this._accumulationPass?.getDebugPassPP(),
+            this._getGBufferDebugPass(),
+        ];
+        for (let i = 0; i < this._debugPasses.length; i++) {
+            if (!this._debugPasses[i])
+                continue;
+            this.addEffect(new PostProcessRenderEffect(this.scene.getEngine(), this._debugPasses[i].name, () => {
+                return this._debugPasses[i];
+            }, true));
+        }
+        const cameras = this.cameras.slice();
+        this.scene.postProcessRenderPipelineManager.detachCamerasFromRenderPipeline(this.name, this.cameras);
+        this.scene.postProcessRenderPipelineManager.attachCamerasToRenderPipeline(this.name, cameras);
+        for (let i = 0; i < this._debugPasses.length; i++) {
+            if (!this._debugPasses[i])
+                continue;
+            this._disableEffect(this._debugPasses[i].name, this.cameras);
+        }
+    }
+    _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();
+    }
+    _disposeDebugPasses() {
+        for (let i = 0; i < this._debugPasses.length; i++) {
+            this._disableEffect(this._debugPasses[i].name, this.cameras);
+            this._debugPasses[i].dispose();
+        }
+        this._debugPasses = [];
+    }
+    _updateDebugPasses() {
+        let count = 0;
+        if (this._gbufferDebugEnabled)
+            count++;
+        if (this.importanceSamplingDebugEnabled)
+            count++;
+        if (this.voxelDebugEnabled)
+            count++;
+        if (this.voxelTracingDebugEnabled)
+            count++;
+        if (this.spatialBlurPassDebugEnabled)
+            count++;
+        if (this.accumulationPassDebugEnabled)
+            count++;
+        const rows = Math.ceil(Math.sqrt(count));
+        const cols = Math.ceil(count / rows);
+        const width = 1.0 / cols;
+        const height = 1.0 / rows;
+        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) {
+                x = 0;
+                y -= height;
+            }
+        }
+        if (this.importanceSamplingDebugEnabled) {
+            this._importanceSamplingRenderer.setDebugDisplayParams(x, y, cols, rows);
+            x -= width;
+            if (x <= -1) {
+                x = 0;
+                y -= height;
+            }
+        }
+        if (this.voxelDebugEnabled) {
+            this._voxelRenderer.setDebugDisplayParams(x, y, cols, rows);
+            x -= width;
+            if (x <= -1) {
+                x = 0;
+                y -= height;
+            }
+        }
+        if (this.voxelTracingDebugEnabled) {
+            this._voxelTracingPass.setDebugDisplayParams(x, y, cols, rows);
+            x -= width;
+            if (x <= -1) {
+                x = 0;
+                y -= height;
+            }
+        }
+        if (this.spatialBlurPassDebugEnabled) {
+            this._spatialBlurPass.setDebugDisplayParams(x, y, cols, rows);
+            x -= width;
+            if (x <= -1) {
+                x = 0;
+                y -= height;
+            }
+        }
+        if (this.accumulationPassDebugEnabled) {
+            this._accumulationPass.setDebugDisplayParams(x, y, cols, rows);
+            x -= width;
+            if (x <= -1) {
+                x = 0;
+                y -= height;
+            }
+        }
+    }
+    /**
+     * 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;
+    }
+    /**
+     * 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;
+    }
+    _updateBeforeRender() {
+        this._updateDebugPasses();
+    }
+    _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;
+                    }
+                }
+            });
+        }
+    }
+    /**
+     * Links to the prepass renderer
+     * @param prePassRenderer The scene PrePassRenderer
+     * @returns true if the pre pass is setup
+     */
+    setPrePassRenderer(prePassRenderer) {
+        return !!prePassRenderer.addEffectConfiguration(this._prePassEffectConfiguration);
+    }
+    /**
+     * Checks if the IBL shadow pipeline is ready to render shadows
+     * @returns true if the IBL shadow pipeline is ready to render the shadows
+     */
+    isReady() {
+        return (this._noiseTexture.isReady() &&
+            this._voxelRenderer.isReady() &&
+            this._importanceSamplingRenderer.isReady() &&
+            (!this._voxelTracingPass || this._voxelTracingPass.isReady()) &&
+            (!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);
+            const halfSize = Math.max(size.x, Math.max(size.y, size.z)) * 0.5;
+            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);
+        }
+        // If update is needed, render voxels
+        if (this._voxelizationDirty) {
+            this._voxelRenderer.updateVoxelGrid(this._excludedMeshes);
+            this._voxelizationDirty = false;
+        }
+    }
+    /**
+     * Get the class name
+     * @returns "IBLShadowsRenderPipeline"
+     */
+    getClassName() {
+        return "IBLShadowsRenderPipeline";
+    }
+    /**
+     * Disposes the IBL shadow pipeline and associated resources
+     */
+    dispose() {
+        this._disposeEffectPasses();
+        this._noiseTexture.dispose();
+        this._voxelRenderer.dispose();
+        this._importanceSamplingRenderer.dispose();
+        this._voxelTracingPass?.dispose();
+        this._spatialBlurPass?.dispose();
+        this._accumulationPass?.dispose();
+        super.dispose();
+    }
+}
+//# sourceMappingURL=iblShadowsRenderPipeline.js.map