@onerjs/core 8.48.4 → 8.48.5

package/Rendering/IBLShadows/iblShadowsVoxelRenderer.js

@@ -3,13 +3,13 @@ import { ShaderMaterial } from "../../Materials/shaderMaterial.js";
 import { MultiRenderTarget } from "../../Materials/Textures/multiRenderTarget.js";
 import { RenderTargetTexture } from "../../Materials/Textures/renderTargetTexture.js";
 import { Color4 } from "../../Maths/math.color.js";
-import { Matrix, Vector3, Vector4 } from "../../Maths/math.vector.js";
+import { Matrix, Vector3 } from "../../Maths/math.vector.js";
 import { Texture } from "../../Materials/Textures/texture.js";
 import { Logger } from "../../Misc/logger.js";
 import { Observable } from "../../Misc/observable.js";
-import { PostProcess } from "../../PostProcesses/postProcess.js";
 import { ProceduralTexture } from "../../Materials/Textures/Procedurals/proceduralTexture.js";
 import { EffectRenderer, EffectWrapper } from "../../Materials/effectRenderer.js";
+import "../../Engines/Extensions/engine.multiRender.js";
 /**
  * Voxel-based shadow rendering for IBL's.
  * This should not be instanciated directly, as it is part of a scene component
@@ -33,14 +33,19 @@ export class _IblShadowsVoxelRenderer {
         }
     }
     /**
-     * The debug pass post process
-     * @returns The debug pass post process
+     * Return the voxel render target used during voxelization.
+     * @returns The voxel render target.
      */
-    getDebugPassPP() {
-        if (!this._voxelDebugPass) {
-            this._createDebugPass();
+    getRT() {
+        if (this._engine.isWebGPU) {
+            return this._voxelGridRT;
+        }
+        else if (this._triPlanarVoxelization) {
+            return this._combinedVoxelGridPT;
+        }
+        else {
+            return this._voxelGridZaxis;
         }
-        return this._voxelDebugPass;
     }
     /**
      * Whether to use tri-planar voxelization. More expensive, but can help with artifacts.
@@ -95,121 +100,6 @@ export class _IblShadowsVoxelRenderer {
         this._disposeVoxelTextures();
         this._createTextures();
     }
-    /**
-     * Shows only the voxels that were rendered along a particular axis (while using triPlanarVoxelization).
-     * If not set, the combined voxel grid will be shown.
-     * Note: This only works when the debugMipNumber is set to 0 because we don't generate mips for each axis.
-     * @param axis The axis to show (0 = x, 1 = y, 2 = z)
-     */
-    set voxelDebugAxis(axis) {
-        this._voxelDebugAxis = axis;
-    }
-    get voxelDebugAxis() {
-        return this._voxelDebugAxis;
-    }
-    /**
-     * Sets params that control the position and scaling of the debug display on the screen.
-     * @param x Screen X offset of the debug display (0-1)
-     * @param y Screen Y offset of the debug display (0-1)
-     * @param widthScale X scale of the debug display (0-1)
-     * @param heightScale Y scale of the debug display (0-1)
-     */
-    setDebugDisplayParams(x, y, widthScale, heightScale) {
-        this._debugSizeParams.set(x, y, widthScale, heightScale);
-    }
-    /**
-     * The mip level to show in the debug display
-     * @param mipNum The mip level to show in the debug display
-     */
-    setDebugMipNumber(mipNum) {
-        this._debugMipNumber = mipNum;
-    }
-    /**
-     * Sets the name of the debug pass
-     */
-    get debugPassName() {
-        return this._debugPassName;
-    }
-    /**
-     * Enable or disable the debug view for this pass
-     */
-    get voxelDebugEnabled() {
-        return this._voxelDebugEnabled;
-    }
-    set voxelDebugEnabled(enabled) {
-        if (this._voxelDebugEnabled === enabled) {
-            return;
-        }
-        this._voxelDebugEnabled = enabled;
-        if (enabled) {
-            this._voxelSlabDebugRT = new RenderTargetTexture("voxelSlabDebug", { width: this._engine.getRenderWidth(), height: this._engine.getRenderHeight() }, this._scene, {
-                generateDepthBuffer: true,
-                generateMipMaps: false,
-                type: 0,
-                format: 5,
-                samplingMode: 1,
-            });
-            this._voxelSlabDebugRT.noPrePassRenderer = true;
-        }
-        if (this._voxelSlabDebugRT) {
-            this._removeVoxelRTs([this._voxelSlabDebugRT]);
-        }
-        // Add the slab debug RT if needed.
-        if (this._voxelDebugEnabled) {
-            this._addRTsForRender([this._voxelSlabDebugRT], this._includedMeshes, this._voxelDebugAxis, 1, true);
-            this._setDebugBindingsBound = this._setDebugBindings.bind(this);
-            this._scene.onBeforeRenderObservable.add(this._setDebugBindingsBound);
-        }
-        else {
-            this._scene.onBeforeRenderObservable.removeCallback(this._setDebugBindingsBound);
-        }
-    }
-    /**
-     * Creates the debug post process effect for this pass
-     */
-    _createDebugPass() {
-        const isWebGPU = this._engine.isWebGPU;
-        if (!this._voxelDebugPass) {
-            const debugOptions = {
-                width: this._engine.getRenderWidth(),
-                height: this._engine.getRenderHeight(),
-                textureFormat: 5,
-                textureType: 0,
-                samplingMode: 1,
-                uniforms: ["sizeParams", "mipNumber"],
-                samplers: ["voxelTexture", "voxelSlabTexture"],
-                engine: this._engine,
-                reusable: false,
-                shaderLanguage: isWebGPU ? 1 /* ShaderLanguage.WGSL */ : 0 /* ShaderLanguage.GLSL */,
-                extraInitializations: (useWebGPU, list) => {
-                    if (useWebGPU) {
-                        list.push(import("../../ShadersWGSL/iblVoxelGrid3dDebug.fragment.js"));
-                    }
-                    else {
-                        list.push(import("../../Shaders/iblVoxelGrid3dDebug.fragment.js"));
-                    }
-                },
-            };
-            this._voxelDebugPass = new PostProcess(this.debugPassName, "iblVoxelGrid3dDebug", debugOptions);
-            this._voxelDebugPass.onApplyObservable.add((effect) => {
-                if (this._voxelDebugAxis === 0) {
-                    effect.setTexture("voxelTexture", this._voxelGridXaxis);
-                }
-                else if (this._voxelDebugAxis === 1) {
-                    effect.setTexture("voxelTexture", this._voxelGridYaxis);
-                }
-                else if (this._voxelDebugAxis === 2) {
-                    effect.setTexture("voxelTexture", this._voxelGridZaxis);
-                }
-                else {
-                    effect.setTexture("voxelTexture", this.getVoxelGrid());
-                }
-                effect.setTexture("voxelSlabTexture", this._voxelSlabDebugRT);
-                effect.setVector4("sizeParams", this._debugSizeParams);
-                effect.setFloat("mipNumber", this._debugMipNumber);
-            });
-        }
-    }
     /**
      * Instanciates the voxel renderer
      * @param scene Scene to attach to
@@ -233,13 +123,8 @@ export class _IblShadowsVoxelRenderer {
         this._invWorldScaleMatrix = Matrix.Identity();
         this._voxelResolution = 64;
         this._voxelResolutionExp = 6;
+        this._copyMipLayer = 0;
         this._mipArray = [];
-        this._voxelDebugEnabled = false;
-        this._voxelDebugAxis = -1;
-        this._debugSizeParams = new Vector4(0.0, 0.0, 0.0, 0.0);
-        this._includedMeshes = [];
-        this._debugMipNumber = 0;
-        this._debugPassName = "Voxelization Debug Pass";
         this._scene = scene;
         this._engine = scene.getEngine();
         this._triPlanarVoxelization = this._engine.isWebGPU || triPlanarVoxelization;
@@ -249,8 +134,11 @@ export class _IblShadowsVoxelRenderer {
         const isWebGPU = this._engine.isWebGPU;
         // Round down to a power of 2 so it evenly divides the power-of-2 voxel resolution,
         // preventing out-of-bounds layer indices in the last MRT slab.
+        // This shader implementation writes up to 16 MRT outputs, so clamp to 16 to keep
+        // active draw buffers aligned with declared/written fragment outputs.
         const rawMaxDrawBuffers = this._engine.getCaps().maxDrawBuffers || 0;
-        this._maxDrawBuffers = rawMaxDrawBuffers >= 1 ? 1 << Math.floor(Math.log2(rawMaxDrawBuffers)) : 0;
+        const cappedMaxDrawBuffers = Math.min(rawMaxDrawBuffers, 16);
+        this._maxDrawBuffers = cappedMaxDrawBuffers >= 1 ? 1 << Math.floor(Math.log2(cappedMaxDrawBuffers)) : 0;
         this._copyMipEffectRenderer = new EffectRenderer(this._engine);
         this._copyMipEffectWrapper = new EffectWrapper({
             engine: this._engine,
@@ -268,6 +156,14 @@ export class _IblShadowsVoxelRenderer {
                 }
             },
         });
+        this._copyMipEffectWrapper.onApplyObservable.add(() => {
+            const effect = this._copyMipEffectWrapper.effect;
+            if (!effect || !this._copyMipSourceTexture) {
+                return;
+            }
+            effect.setTexture("textureSampler", this._copyMipSourceTexture);
+            effect.setInt("layerNum", this._copyMipLayer);
+        });
         this.voxelResolutionExp = resolutionExp;
     }
     _generateMipMaps() {
@@ -293,7 +189,6 @@ export class _IblShadowsVoxelRenderer {
     }
     _copyMipMap(lodLevel) {
         // Now, copy this mip into the mip chain of the voxel grid.
-        // TODO - this currently isn't working. "textureSampler" isn't being properly set to mipTarget.
         const mipTarget = this._mipArray[lodLevel - 1];
         if (!mipTarget) {
             return;
@@ -308,16 +203,48 @@ export class _IblShadowsVoxelRenderer {
         }
         if (rt) {
             this._copyMipEffectRenderer.saveStates();
+            const previousColorWrite = this._engine.getColorWrite();
+            const previousDepthBuffer = this._engine.getDepthBuffer();
+            const previousDepthWrite = this._engine.getDepthWrite();
+            const previousAlphaMode = this._engine.getAlphaMode();
+            this._engine.setColorWrite(true);
+            this._engine.setDepthBuffer(false);
+            this._engine.setDepthWrite(false);
+            this._engine.setAlphaMode(0);
             const bindSize = mipTarget.getSize().width;
-            // Render to each layer of the voxel grid.
-            for (let layer = 0; layer < bindSize; layer++) {
-                this._engine.bindFramebuffer(rt, 0, bindSize, bindSize, true, lodLevel, layer);
-                this._copyMipEffectRenderer.applyEffectWrapper(this._copyMipEffectWrapper);
-                this._copyMipEffectWrapper.effect.setTexture("textureSampler", mipTarget);
-                this._copyMipEffectWrapper.effect.setInt("layerNum", layer);
-                this._copyMipEffectRenderer.draw();
-                this._engine.unBindFramebuffer(rt, true);
+            let sourceDepth = mipTarget.getInternalTexture()?.depth;
+            sourceDepth = Math.max(1, sourceDepth || bindSize);
+            const destinationMipDepth = Math.max(1, this._voxelResolution >> lodLevel);
+            const layersToCopy = Math.min(sourceDepth, destinationMipDepth);
+            const destinationTexture = rt.texture;
+            const previousGenerateMipMaps = destinationTexture?.generateMipMaps;
+            if (destinationTexture) {
+                destinationTexture.generateMipMaps = false;
+            }
+            try {
+                // Render to each layer of the voxel grid.
+                for (let layer = 0; layer < layersToCopy; layer++) {
+                    this._engine.bindFramebuffer(rt, 0, bindSize, bindSize, true, lodLevel, layer);
+                    this._copyMipSourceTexture = mipTarget;
+                    this._copyMipLayer = layer;
+                    this._copyMipEffectRenderer.applyEffectWrapper(this._copyMipEffectWrapper);
+                    this._copyMipEffectRenderer.draw();
+                    this._engine.unBindFramebuffer(rt, true);
+                }
+                if (!this._engine.isWebGPU) {
+                    this._engine.unbindAllTextures();
+                }
             }
+            finally {
+                if (destinationTexture && previousGenerateMipMaps !== undefined) {
+                    destinationTexture.generateMipMaps = previousGenerateMipMaps;
+                }
+                this._engine.setAlphaMode(previousAlphaMode);
+                this._engine.setDepthWrite(previousDepthWrite);
+                this._engine.setDepthBuffer(previousDepthBuffer);
+                this._engine.setColorWrite(previousColorWrite);
+            }
+            this._copyMipSourceTexture = undefined;
             this._copyMipEffectRenderer.restoreStates();
         }
     }
@@ -335,7 +262,7 @@ export class _IblShadowsVoxelRenderer {
             generateDepthBuffer: false,
             generateMipMaps: false,
             type: 0,
-            format: 5,
+            format: 6,
             samplingMode: 1,
         };
         // We can render up to maxDrawBuffers voxel slices of the grid per render.
@@ -360,7 +287,7 @@ export class _IblShadowsVoxelRenderer {
         if (this._engine.isWebGPU) {
             this._voxelGrid = new RenderTargetTexture("voxelGrid", size, this._scene, {
                 ...voxelCombinedOptions,
-                format: 5,
+                format: 6,
                 creationFlags: 1,
             });
             this._voxelGridRT = new RenderTargetTexture("voxelGridRT", { width: Math.min(size.width * 2.0, 2048), height: Math.min(size.height * 2.0, 2048) }, this._scene, voxelAxisOptions);
@@ -470,7 +397,6 @@ export class _IblShadowsVoxelRenderer {
             mip.dispose();
         }
         this._voxelMaterial?.dispose();
-        this._voxelSlabDebugMaterial?.dispose();
         this._mipArray = [];
         this._voxelMrtsXaxis = [];
         this._voxelMrtsYaxis = [];
@@ -494,23 +420,6 @@ export class _IblShadowsVoxelRenderer {
         this._voxelMaterial.cullBackFaces = false;
         this._voxelMaterial.backFaceCulling = false;
         this._voxelMaterial.depthFunction = 519;
-        this._voxelSlabDebugMaterial = new ShaderMaterial("voxelSlabDebug", this._scene, "iblVoxelSlabDebug", {
-            uniforms: ["world", "viewMatrix", "cameraViewMatrix", "projection", "invWorldScale", "nearPlane", "farPlane", "stepSize"],
-            defines: ["MAX_DRAW_BUFFERS " + this._maxDrawBuffers],
-            shaderLanguage: isWebGPU ? 1 /* ShaderLanguage.WGSL */ : 0 /* ShaderLanguage.GLSL */,
-            extraInitializationsAsync: async () => {
-                if (isWebGPU) {
-                    await Promise.all([import("../../ShadersWGSL/iblVoxelSlabDebug.fragment.js"), import("../../ShadersWGSL/iblVoxelSlabDebug.vertex.js")]);
-                }
-                else {
-                    await Promise.all([import("../../Shaders/iblVoxelSlabDebug.fragment.js"), import("../../Shaders/iblVoxelSlabDebug.vertex.js")]);
-                }
-            },
-        });
-    }
-    _setDebugBindings() {
-        this._voxelSlabDebugMaterial.setMatrix("projection", this._scene.activeCamera.getProjectionMatrix());
-        this._voxelSlabDebugMaterial.setMatrix("cameraViewMatrix", this._scene.activeCamera.getViewMatrix());
     }
     /**
      * Checks if the voxel renderer is ready to voxelize scene
@@ -564,13 +473,13 @@ export class _IblShadowsVoxelRenderer {
     /**
      * Renders voxel grid of scene for IBL shadows
      * @param includedMeshes
+     * @param registerAfterRenderObservable Whether to register scene onAfterRender callback (legacy path).
      */
-    updateVoxelGrid(includedMeshes) {
+    updateVoxelGrid(includedMeshes, registerAfterRenderObservable = true) {
         if (this._voxelizationInProgress) {
             return;
         }
         this._stopVoxelization();
-        this._includedMeshes = includedMeshes;
         this._voxelizationInProgress = true;
         if (this._engine.isWebGPU) {
             this._voxelGridRT.renderList = includedMeshes;
@@ -584,11 +493,17 @@ export class _IblShadowsVoxelRenderer {
         else {
             this._addRTsForRender(this._voxelMrtsZaxis, includedMeshes, 2);
         }
-        if (this._voxelDebugEnabled) {
-            this._addRTsForRender([this._voxelSlabDebugRT], includedMeshes, this._voxelDebugAxis, 1, true);
+        if (registerAfterRenderObservable) {
+            this._renderVoxelGridBound = this._renderVoxelGrid.bind(this);
+            this._scene.onAfterRenderObservable.add(this._renderVoxelGridBound);
         }
-        this._renderVoxelGridBound = this._renderVoxelGrid.bind(this);
-        this._scene.onAfterRenderObservable.add(this._renderVoxelGridBound);
+    }
+    /**
+     * Advances voxelization work when running in custom render loops (for example FrameGraph tasks)
+     * where scene onAfterRender timing may differ from classic pipeline flow.
+     */
+    processVoxelization() {
+        this._renderVoxelGrid();
     }
     _renderVoxelGrid() {
         if (this._voxelizationInProgress) {
@@ -601,49 +516,62 @@ export class _IblShadowsVoxelRenderer {
                 const rttReady = this._renderTargets[i].isReadyForRendering();
                 allReady && (allReady = rttReady);
             }
-            if (allReady) {
-                if (this._engine.isWebGPU) {
-                    // Clear the voxel grid storage texture.
-                    // Need to clear each layer individually.
-                    // Would a compute shader be faster here to clear all layers in one go?
-                    if (this._voxelGrid && this._voxelGrid.renderTarget) {
-                        for (let layer = 0; layer < this._voxelResolution; layer++) {
-                            this._engine.bindFramebuffer(this._voxelGrid.renderTarget, 0, undefined, undefined, true, 0, layer);
-                            this._engine.clear(this._voxelClearColor, true, false, false);
-                            this._engine.unBindFramebuffer(this._voxelGrid.renderTarget, true);
-                        }
+            if (!allReady) {
+                return;
+            }
+            const copyMipEffect = this._copyMipEffectWrapper.effect;
+            if (!copyMipEffect.isReady()) {
+                return;
+            }
+            if (this._engine.isWebGPU) {
+                // Clear the voxel grid storage texture.
+                // Need to clear each layer individually.
+                // Would a compute shader be faster here to clear all layers in one go?
+                if (this._voxelGrid && this._voxelGrid.renderTarget) {
+                    for (let layer = 0; layer < this._voxelResolution; layer++) {
+                        this._engine.bindFramebuffer(this._voxelGrid.renderTarget, 0, undefined, undefined, true, 0, layer);
+                        this._engine.clear(this._voxelClearColor, true, false, false);
+                        this._engine.unBindFramebuffer(this._voxelGrid.renderTarget, true);
                     }
                 }
-                for (const rt of this._renderTargets) {
-                    rt.render();
-                }
-                this._stopVoxelization();
-                if (this._triPlanarVoxelization && !this._engine.isWebGPU) {
-                    this._combinedVoxelGridPT.render();
-                }
-                this._generateMipMaps();
-                // eslint-disable-next-line @typescript-eslint/no-floating-promises, github/no-then
-                this._copyMipEffectWrapper.effect.whenCompiledAsync().then(() => {
-                    this._copyMipMaps();
-                    this._scene.onAfterRenderObservable.removeCallback(this._renderVoxelGridBound);
-                    this._voxelizationInProgress = false;
-                    this.onVoxelizationCompleteObservable.notifyObservers();
-                });
             }
+            for (const rt of this._renderTargets) {
+                rt.render();
+            }
+            this._stopVoxelization();
+            if (this._triPlanarVoxelization && !this._engine.isWebGPU) {
+                this._combinedVoxelGridPT.render();
+            }
+            this._generateMipMaps();
+            this._copyMipMaps();
+            this._scene.onAfterRenderObservable.removeCallback(this._renderVoxelGridBound);
+            this._voxelizationInProgress = false;
+            this.onVoxelizationCompleteObservable.notifyObservers();
         }
     }
-    _addRTsForRender(mrts, includedMeshes, axis, shaderType = 0, continuousRender = false) {
+    _addRTsForRender(mrts, includedMeshes, axis) {
         const slabSize = 1.0 / this._computeNumberOfSlabs();
-        let voxelMaterial;
-        if (shaderType === 0) {
-            voxelMaterial = this._voxelMaterial;
-        }
-        else {
-            voxelMaterial = this._voxelSlabDebugMaterial;
-        }
+        const voxelMaterial = this._voxelMaterial;
         // We need to update the world scale uniform for every mesh being rendered to the voxel grid.
         for (let mrtIndex = 0; mrtIndex < mrts.length; mrtIndex++) {
             const mrt = mrts[mrtIndex];
+            mrt._disableEngineStages = true;
+            mrt.useCameraPostProcesses = false;
+            mrt.renderParticles = false;
+            mrt.renderSprites = false;
+            mrt.enableOutlineRendering = false;
+            mrt.customRenderFunction = (opaqueSubMeshes, alphaTestSubMeshes, transparentSubMeshes, depthOnlySubMeshes) => {
+                const buckets = [depthOnlySubMeshes, opaqueSubMeshes, alphaTestSubMeshes, transparentSubMeshes];
+                for (const bucket of buckets) {
+                    for (let index = 0; index < bucket.length; index++) {
+                        const subMesh = bucket.data[index];
+                        if (subMesh.getMaterial() !== voxelMaterial) {
+                            continue;
+                        }
+                        subMesh.render(false);
+                    }
+                }
+            };
             mrt.renderList = [];
             const nearPlane = mrtIndex * slabSize;
             const farPlane = (mrtIndex + 1) * slabSize;
@@ -692,36 +620,17 @@ export class _IblShadowsVoxelRenderer {
                 }
             }
         }
-        // Add the MRT's to render.
-        if (continuousRender) {
-            for (const mrt of mrts) {
-                if (this._scene.customRenderTargets.indexOf(mrt) === -1) {
-                    this._scene.customRenderTargets.push(mrt);
-                }
-            }
-        }
-        else {
-            this._renderTargets = this._renderTargets.concat(mrts);
-        }
+        this._renderTargets = this._renderTargets.concat(mrts);
     }
     /**
      * Called by the pipeline to resize resources.
      */
-    resize() {
-        this._voxelSlabDebugRT?.resize({ width: this._scene.getEngine().getRenderWidth(), height: this._scene.getEngine().getRenderHeight() });
-    }
+    resize() { }
     /**
      * Disposes the voxel renderer and associated resources
      */
     dispose() {
         this._disposeVoxelTextures();
-        if (this._voxelSlabDebugRT) {
-            this._removeVoxelRTs([this._voxelSlabDebugRT]);
-            this._voxelSlabDebugRT.dispose();
-        }
-        if (this._voxelDebugPass) {
-            this._voxelDebugPass.dispose();
-        }
         // TODO - dispose all created voxel materials.
     }
 }