@onerjs/core 9.0.1 → 9.0.3

package/Lights/Shadows/cascadedShadowGenerator.pure.js

@@ -8,6 +8,7 @@ import { DepthReducer } from "../../Misc/depthReducer.js";
 import { Logger } from "../../Misc/logger.js";
 import { EngineStore } from "../../Engines/engineStore.js";
 import { FloatingOriginCurrentScene, GetOffsetTransformMatrices } from "../../Materials/floatingOriginMatrixOverrides.js";
+import { UniformBuffer } from "../../Materials/uniformBuffer.js";
 // eslint-disable-next-line @typescript-eslint/naming-convention
 const UpDir = /*#__PURE__*/ Vector3.Up();
 // eslint-disable-next-line @typescript-eslint/naming-convention
@@ -15,6 +16,8 @@ const ZeroVec = /*#__PURE__*/ Vector3.Zero();
 const Tmpv1 = /*#__PURE__*/ new Vector3();
 const Tmpv2 = /*#__PURE__*/ new Vector3();
 const TmpMatrix = /*#__PURE__*/ new Matrix();
+// The cascades a receiving shader can read (vPositionFromLight{X}_0 to _3): the size of the arrays in the cascades buffer
+const CascadesUboSize = 4;
 /**
  * A CSM implementation allowing casting shadows on large scenes.
  * Documentation : https://doc.babylonjs.com/babylon101/cascadedShadows
@@ -28,6 +31,16 @@ export class CascadedShadowGenerator extends ShadowGenerator {
         Logger.Error('Unsupported filter "' + filter + '"!');
         return ShadowGenerator.FILTER_NONE;
     }
+    /**
+     * Gets or sets the actual darkness of the soft shadows while using PCSS filtering (value between 0. and 1.)
+     */
+    get penumbraDarkness() {
+        return this._penumbraDarkness;
+    }
+    set penumbraDarkness(value) {
+        this._penumbraDarkness = value;
+        this._updateCascadesSettings();
+    }
     /**
      * Gets or set the number of cascades used by the CSM.
      */
@@ -208,6 +221,7 @@ export class CascadedShadowGenerator extends ShadowGenerator {
     set cascadeBlendPercentage(value) {
         this._cascadeBlendPercentage = value;
         this._light._markMeshesAsLightDirty();
+        this._updateCascadesSettings();
     }
     /**
      * Gets or set the lambda parameter.
@@ -530,13 +544,20 @@ export class CascadedShadowGenerator extends ShadowGenerator {
             throw new Error("CascadedShadowMap is not supported by the current engine.");
         }
         super(mapSize, light, usefulFloatFirst, camera, useRedTextureType);
+        // WGSL receivers read the cascades from a buffer owned by this generator, one per camera its shadow map renders for, written
+        // once each time the cascades are computed: every receiver shares it, and a FAST snapshot replay reads the current values.
+        // In floating origin mode the light matrices are also offset by the eye the receivers are rendered for, and a mirror or a
+        // reflection probe renders them for another eye than the camera's: each eye gets its own buffer (_getCascadesBufferForEye)
+        this._cascadesUbos = null;
+        this._cascadesBuffers = null;
+        this._cascadesMatrices = new Float32Array(16 * CascadesUboSize);
         // Without comparison samplers, PCF would fall back to Poisson sampling, which CSM does not support.
         if (this._scene.getEngine()._features.supportShadowSamplers) {
             this.usePercentageCloserFiltering = true;
         }
     }
     _initializeGenerator() {
-        this.penumbraDarkness = this.penumbraDarkness ?? 1.0;
+        this._penumbraDarkness = this._penumbraDarkness ?? 1.0;
         this._numCascades = this._numCascades ?? CascadedShadowGenerator.DEFAULT_CASCADES_COUNT;
         this.stabilizeCascades = this.stabilizeCascades ?? false;
         this._freezeShadowCastersBoundingInfoObservable = this._freezeShadowCastersBoundingInfoObservable ?? null;
@@ -629,6 +650,9 @@ export class CascadedShadowGenerator extends ShadowGenerator {
                 this._splitFrustum();
             }
             this._computeMatrices();
+            if (this._cascadesUbos) {
+                this._updateCascadesUbo();
+            }
         });
         this._splitFrustum();
     }
@@ -683,40 +707,43 @@ export class CascadedShadowGenerator extends ShadowGenerator {
             return;
         }
         const width = shadowMap.getSize().width;
-        const transform = this._transformMatricesAsArray;
-        // Doing the check for floatingOrigin here to avoid unnecessary matrix operations when offset is 0
-        const lightMatrix = scene.floatingOriginMode
-            ? GetOffsetTransformMatrices(this._scene.floatingOriginOffset, this._viewMatrices, this._projectionMatrices, this._numCascades, this._tempTransformMatricesAsArray)
-            : transform;
-        effect.setMatrices("lightMatrix" + lightIndex, lightMatrix);
-        effect.setArray("viewFrustumZ" + lightIndex, this._viewSpaceFrustumsZ);
-        effect.setFloat("cascadeBlendFactor" + lightIndex, this.cascadeBlendPercentage === 0 ? 10000 : 1 / this.cascadeBlendPercentage);
-        effect.setArray("frustumLengths" + lightIndex, this._frustumLengths);
+        // WGSL receivers compiled with the cascades buffer (SHADOWCSMUBO{X}, when it fits within the device's uniform buffers
+        // per stage); the others get the cascades as effect uniforms
+        if (effect.shaderLanguage === 1 /* ShaderLanguage.WGSL */ && effect._uniformBuffersNames["cascades" + lightIndex] !== undefined) {
+            if (!this._cascadesBuffers) {
+                this._cascadesUbos = this._cascadesUbos || new Map();
+                this._updateCascadesUbo();
+            }
+            const cascades = this._cascadesBuffers;
+            const cascadesUbo = (scene.floatingOriginMode ? this._getCascadesBufferForEye(cascades, scene.floatingOriginOffset) : cascades.buffers[0]).ubo;
+            cascadesUbo.bindToEffect(effect, "cascades" + lightIndex);
+            cascadesUbo.bindUniformBuffer();
+        }
+        else {
+            const transform = this._transformMatricesAsArray;
+            // Doing the check for floatingOrigin here to avoid unnecessary matrix operations when offset is 0
+            const lightMatrix = scene.floatingOriginMode
+                ? GetOffsetTransformMatrices(this._scene.floatingOriginOffset, this._viewMatrices, this._projectionMatrices, this._numCascades, this._tempTransformMatricesAsArray)
+                : transform;
+            effect.setMatrices("lightMatrix" + lightIndex, lightMatrix);
+            effect.setArray("viewFrustumZ" + lightIndex, this._viewSpaceFrustumsZ);
+            effect.setFloat("cascadeBlendFactor" + lightIndex, this.cascadeBlendPercentage === 0 ? 10000 : 1 / this.cascadeBlendPercentage);
+            effect.setArray("frustumLengths" + lightIndex, this._frustumLengths);
+            if (this._filter === ShadowGenerator.FILTER_PCSS) {
+                this._computePCSSCorrections();
+                effect.setArray2("lightSizeUVCorrection" + lightIndex, this._lightSizeUVCorrection);
+                effect.setArray("depthCorrection" + lightIndex, this._depthCorrection);
+                effect.setFloat("penumbraDarkness" + lightIndex, this.penumbraDarkness);
+            }
+        }
         // Only PCF uses depth stencil texture.
         if (this._filter === ShadowGenerator.FILTER_PCF) {
             effect.setDepthStencilTexture("shadowTexture" + lightIndex, shadowMap);
             light._uniformBuffer.updateFloat4("shadowsInfo", this.getDarkness(), width, 1 / width, this.frustumEdgeFalloff, lightIndex);
         }
         else if (this._filter === ShadowGenerator.FILTER_PCSS) {
-            for (let cascadeIndex = 0; cascadeIndex < this._numCascades; ++cascadeIndex) {
-                this._lightSizeUVCorrection[cascadeIndex * 2 + 0] =
-                    cascadeIndex === 0
-                        ? 1
-                        : (this._cascadeMaxExtents[0].x - this._cascadeMinExtents[0].x) / (this._cascadeMaxExtents[cascadeIndex].x - this._cascadeMinExtents[cascadeIndex].x); // x correction
-                this._lightSizeUVCorrection[cascadeIndex * 2 + 1] =
-                    cascadeIndex === 0
-                        ? 1
-                        : (this._cascadeMaxExtents[0].y - this._cascadeMinExtents[0].y) / (this._cascadeMaxExtents[cascadeIndex].y - this._cascadeMinExtents[cascadeIndex].y); // y correction
-                this._depthCorrection[cascadeIndex] =
-                    cascadeIndex === 0
-                        ? 1
-                        : (this._cascadeMaxExtents[cascadeIndex].z - this._cascadeMinExtents[cascadeIndex].z) / (this._cascadeMaxExtents[0].z - this._cascadeMinExtents[0].z);
-            }
             effect.setDepthStencilTexture("shadowTexture" + lightIndex, shadowMap);
             effect.setTexture("depthTexture" + lightIndex, shadowMap);
-            effect.setArray2("lightSizeUVCorrection" + lightIndex, this._lightSizeUVCorrection);
-            effect.setArray("depthCorrection" + lightIndex, this._depthCorrection);
-            effect.setFloat("penumbraDarkness" + lightIndex, this.penumbraDarkness);
             light._uniformBuffer.updateFloat4("shadowsInfo", this.getDarkness(), 1 / width, this._contactHardeningLightSizeUVRatio * width, this.frustumEdgeFalloff, lightIndex);
         }
         else {
@@ -725,6 +752,144 @@ export class CascadedShadowGenerator extends ShadowGenerator {
         }
         light._uniformBuffer.updateFloat2("depthValues", this.getLight().getDepthMinZ(camera), this.getLight().getDepthMinZ(camera) + this.getLight().getDepthMaxZ(camera), lightIndex);
     }
+    _computePCSSCorrections() {
+        for (let cascadeIndex = 0; cascadeIndex < this._numCascades; ++cascadeIndex) {
+            this._lightSizeUVCorrection[cascadeIndex * 2 + 0] =
+                cascadeIndex === 0
+                    ? 1
+                    : (this._cascadeMaxExtents[0].x - this._cascadeMinExtents[0].x) / (this._cascadeMaxExtents[cascadeIndex].x - this._cascadeMinExtents[cascadeIndex].x); // x correction
+            this._lightSizeUVCorrection[cascadeIndex * 2 + 1] =
+                cascadeIndex === 0
+                    ? 1
+                    : (this._cascadeMaxExtents[0].y - this._cascadeMinExtents[0].y) / (this._cascadeMaxExtents[cascadeIndex].y - this._cascadeMinExtents[cascadeIndex].y); // y correction
+            this._depthCorrection[cascadeIndex] =
+                cascadeIndex === 0
+                    ? 1
+                    : (this._cascadeMaxExtents[cascadeIndex].z - this._cascadeMinExtents[cascadeIndex].z) / (this._cascadeMaxExtents[0].z - this._cascadeMinExtents[0].z);
+        }
+    }
+    /**
+     * Writes the cascades just computed in the buffer of the camera they were computed for, and makes it the one receivers bind
+     */
+    _updateCascadesUbo() {
+        const scene = this._scene;
+        const camera = this._getCamera();
+        let cascades = this._cascadesUbos.get(camera);
+        if (!cascades) {
+            cascades = { buffers: [], computeId: 0, observer: camera ? camera.onDisposeObservable.addOnce(() => this._releaseCascadesUbo(camera)) : null };
+            this._cascadesUbos.set(camera, cascades);
+        }
+        cascades.computeId++;
+        if (scene.floatingOriginMode) {
+            this._getCascadesBufferForEye(cascades, scene.floatingOriginOffset);
+        }
+        else {
+            this._writeCascades(cascades, cascades.buffers[0] ?? this._createCascadesBuffer(cascades), Vector3.ZeroReadOnly);
+        }
+        this._cascadesBuffers = cascades;
+    }
+    /**
+     * In floating origin mode, the light matrices are offset by the eye the receivers are rendered for, which a mirror or a
+     * reflection probe moves (scene._forcedViewPosition). Receivers rendered for the same eye share a buffer. Another eye in the
+     * same frame gets another buffer, since the commands of every view run after all the writes of the frame, and a buffer no
+     * view bound in this frame is the one rewritten for a new eye.
+     * @param cascades the cascades buffers of the camera the cascades were last computed for
+     * @param origin the floating origin offset of the eye
+     * @returns the buffer holding the last computed cascades for that eye
+     */
+    _getCascadesBufferForEye(cascades, origin) {
+        const frameId = this._scene.getEngine().frameId;
+        let unused = null;
+        for (const buffer of cascades.buffers) {
+            if (buffer.computeId === cascades.computeId && buffer.origin.equals(origin)) {
+                buffer.frameId = frameId;
+                return buffer;
+            }
+            if (!unused && buffer.frameId !== frameId) {
+                unused = buffer;
+            }
+        }
+        const buffer = unused ?? this._createCascadesBuffer(cascades);
+        this._writeCascades(cascades, buffer, origin);
+        return buffer;
+    }
+    _createCascadesBuffer(cascades) {
+        const ubo = new UniformBuffer(this._scene.getEngine(), undefined, false, "CascadedShadowGenerator", false, false);
+        ubo.addUniform("viewFrustumZ", 4);
+        ubo.addUniform("frustumLengths", 4);
+        ubo.addUniform("cascadeBlendFactor", 1);
+        ubo.addUniform("penumbraDarkness", 1);
+        ubo.addUniform("depthCorrection", 4);
+        ubo.addUniform("lightSizeUVCorrection", 2, CascadesUboSize);
+        ubo.addUniform("lightMatrix", 16, CascadesUboSize);
+        ubo.create();
+        const buffer = { ubo, computeId: 0, origin: new Vector3(), frameId: -1 };
+        cascades.buffers.push(buffer);
+        return buffer;
+    }
+    /**
+     * Writes the cascades last computed in a buffer, with the light matrices offset by the given floating origin offset
+     * @param cascades the cascades buffers the buffer belongs to
+     * @param buffer the buffer to write
+     * @param origin the floating origin offset of the eye the buffer is for (zero outside of floating origin mode)
+     */
+    _writeCascades(cascades, buffer, origin) {
+        const ubo = buffer.ubo;
+        const z = this._viewSpaceFrustumsZ;
+        const lengths = this._frustumLengths;
+        this._cascadesMatrices.set(this._scene.floatingOriginMode
+            ? GetOffsetTransformMatrices(origin, this._viewMatrices, this._projectionMatrices, this._numCascades, this._tempTransformMatricesAsArray)
+            : this._transformMatricesAsArray);
+        ubo.updateFloat4("viewFrustumZ", z[0] ?? 0, z[1] ?? 0, z[2] ?? 0, z[3] ?? 0);
+        ubo.updateFloat4("frustumLengths", lengths[0] ?? 0, lengths[1] ?? 0, lengths[2] ?? 0, lengths[3] ?? 0);
+        ubo.updateFloat("cascadeBlendFactor", this._getCascadeBlendFactor());
+        // the PCSS values are written whatever the filter, so that switching to PCSS does not wait for the shadow map to render
+        this._computePCSSCorrections();
+        const depth = this._depthCorrection;
+        ubo.updateFloat("penumbraDarkness", this._penumbraDarkness);
+        ubo.updateFloat4("depthCorrection", depth[0] ?? 0, depth[1] ?? 0, depth[2] ?? 0, depth[3] ?? 0);
+        ubo.updateArray("lightSizeUVCorrection", this._lightSizeUVCorrection);
+        ubo.updateMatrices("lightMatrix", this._cascadesMatrices);
+        // written outside of any draw: the last receiver bound must not get this buffer bound again
+        ubo.unbindEffect();
+        ubo.update();
+        buffer.computeId = cascades.computeId;
+        buffer.origin.copyFrom(origin);
+        buffer.frameId = this._scene.getEngine().frameId;
+    }
+    /**
+     * cascadeBlendPercentage and penumbraDarkness only matter to the receivers, and the shadow map may not render again
+     * (refreshRate 0): they are written in the cascades buffers when they change, not for each receiver
+     */
+    _updateCascadesSettings() {
+        if (!this._cascadesUbos) {
+            return;
+        }
+        for (const cascades of this._cascadesUbos.values()) {
+            for (const { ubo } of cascades.buffers) {
+                ubo.updateFloat("cascadeBlendFactor", this._getCascadeBlendFactor());
+                ubo.updateFloat("penumbraDarkness", this._penumbraDarkness);
+                ubo.unbindEffect();
+                ubo.update();
+            }
+        }
+    }
+    _getCascadeBlendFactor() {
+        return this.cascadeBlendPercentage === 0 ? 10000 : 1 / this.cascadeBlendPercentage;
+    }
+    _releaseCascadesUbo(camera) {
+        const cascades = this._cascadesUbos?.get(camera);
+        if (!cascades) {
+            return;
+        }
+        for (const { ubo } of cascades.buffers) {
+            ubo.dispose();
+        }
+        this._cascadesUbos.delete(camera);
+        if (this._cascadesBuffers === cascades) {
+            this._cascadesBuffers = null;
+        }
+    }
     /**
      * Gets the transformation matrix of the first cascade used to project the meshes into the map from the light point of view.
      * (eq to view projection * shadow projection matrices)
@@ -747,6 +912,16 @@ export class CascadedShadowGenerator extends ShadowGenerator {
             this._depthReducer.dispose();
             this._depthReducer = null;
         }
+        if (this._cascadesUbos) {
+            for (const [camera, cascades] of this._cascadesUbos) {
+                for (const { ubo } of cascades.buffers) {
+                    ubo.dispose();
+                }
+                camera?.onDisposeObservable.remove(cascades.observer);
+            }
+            this._cascadesUbos = null;
+            this._cascadesBuffers = null;
+        }
     }
     /**
      * Serializes the shadow generator setup to a json object.