@zephyr3d/scene 0.9.5 → 0.9.7

package/dist/shadow/shadowmapper.js

@@ -1,4 +1,4 @@
-import { Matrix4x4, Frustum, Vector3, AABB, Vector4, retainObject, CubeFace } from '@zephyr3d/base';
+import { Matrix4x4, Frustum, Disposable, Vector3, AABB, Vector4, retainObject, CubeFace } from '@zephyr3d/base';
 import { Camera } from '../camera/camera.js';
 import { SSM } from './ssm.js';
 import { ESM } from './esm.js';
@@ -8,6 +8,7 @@ import { PCFOPT } from './pcf_opt.js';
 import { LIGHT_TYPE_NONE, LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_POINT } from '../values.js';
 import { ShaderHelper } from '../material/shader/helper.js';
 import { getDevice } from '../app/api.js';
+import { ShadowRegion } from './shadow_region.js';
 
 const tmpMatrix = new Matrix4x4();
 const tmpFrustum = new Frustum(Matrix4x4.identity());
@@ -15,7 +16,7 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
 /**
  * The shadow map generator
  * @public
- */ class ShadowMapper {
+ */ class ShadowMapper extends Disposable {
     /** @internal */ static _snapMatrix = new Matrix4x4();
     /** @internal */ static _target = new Vector3();
     /** @internal */ static _up = new Vector3();
@@ -37,63 +38,45 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
     /** @internal */ _vsmBlurRadius;
     /** @internal */ _vsmDarkness;
     /** @internal */ _esmBlur;
+    /** @internal */ _esmLogSpace;
     /** @internal */ _esmBlurKernelSize;
     /** @internal */ _esmBlurRadius;
     /** @internal */ _esmDepthScale;
+    /** @internal */ _shadowStrength;
     /** @internal */ _shadowRegion;
-    /** @internal */ _autoShadowRegion;
     /**
    * Creates an instance of ShadowMapper
    * @param light - The light that is used to generate shadow map
    */ constructor(light){
+        super();
         this._light = light;
         this._config = {
             shadowMapSize: 1024,
             numCascades: 1,
             splitLambda: 0.5,
-            depthBias: 0.5,
+            depthBias: 0.003,
             normalBias: 0.2,
             nearClip: 1
         };
         this._resourceDirty = true;
-        this._shadowMode = 'hard';
+        this._shadowMode = 'pcf-pd';
         this._shadowDistance = 2000;
         this._impl = null;
-        this._pdSampleCount = 12;
-        this._pdSampleRadius = 4;
-        this._pcfKernelSize = 5;
+        this._pdSampleCount = 24;
+        this._pdSampleRadius = 3;
+        this._pcfKernelSize = 7;
         this._vsmBlurKernelSize = 5;
         this._vsmBlurRadius = 4;
         this._vsmDarkness = 0.3;
         this._esmBlur = true;
+        this._esmLogSpace = true;
         this._esmBlurKernelSize = 5;
         this._esmBlurRadius = 4;
         this._esmDepthScale = 200;
-        this._shadowRegion = null;
-        this._autoShadowRegion = false;
+        this._shadowStrength = 1;
+        this._shadowRegion = new ShadowRegion();
         this.applyMode(this._shadowMode);
     }
-    copyFrom(other) {
-        this.shadowMapSize = other.shadowMapSize;
-        this.shadowRegion = other.shadowRegion ? new AABB(other.shadowRegion) : null;
-        this.shadowDistance = other.shadowDistance;
-        this.numShadowCascades = other.numShadowCascades;
-        this.splitLambda = other.splitLambda;
-        this.depthBias = other.depthBias;
-        this.normalBias = other.normalBias;
-        this.nearClip = other.nearClip;
-        this.mode = other.mode;
-        this.pdSampleCount = other.pdSampleCount;
-        this.pdSampleRadius = other.pdSampleRadius;
-        this.pcfKernelSize = other.pcfKernelSize;
-        this.vsmBlurKernelSize = other.vsmBlurKernelSize;
-        this.vsmBlurRadius = other.vsmBlurRadius;
-        this.vsmDarkness = other.vsmDarkness;
-        this.esmBlur = other.esmBlur;
-        this.esmBlurKernelSize = other.esmBlurKernelSize;
-        this.esmBlurRadius = other.esmBlurRadius;
-        this.esmDepthScale = other.esmDepthScale;
-    }
     /** The light that is used to generate shadow map */ get light() {
         return this._light;
     }
@@ -113,21 +96,25 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
     /** Shadow region for directional light */ get shadowRegion() {
         return this._shadowRegion;
     }
-    set shadowRegion(region) {
-        this._shadowRegion = region;
-        this._autoShadowRegion = false;
-    }
     /** @internal */ updateDirectionalShadowRegion(force = false) {
         if (!this._light.isDirectionLight()) {
             return;
         }
-        if (!force && !this._autoShadowRegion) {
+        if (!force) {
             return;
         }
         const scene = this._light.scene;
         if (!scene) {
             return;
         }
+        this._shadowRegion.clear();
+        scene.rootNode.iterate((child)=>{
+            if ((child.isMesh() || child.isClipmapTerrain()) && child.castShadow) {
+                this._shadowRegion.addDynamicCaster(child);
+            }
+        });
+    }
+    /** @internal */ computeDirectionalShadowRegion(scene) {
         const aabb = new AABB();
         aabb.beginExtend();
         scene.rootNode.iterate((child)=>{
@@ -139,8 +126,7 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
                 }
             }
         });
-        this._shadowRegion = aabb.isValid() ? aabb : null;
-        this._autoShadowRegion = true;
+        return aabb.isValid() ? aabb : null;
     }
     /** Maximum distance from the camera, shadow will not be rendered beyond this range */ get shadowDistance() {
         return this._shadowDistance;
@@ -193,6 +179,12 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
             this._config.nearClip = val;
         }
     }
+    /** Shadow strength, 0 means no shadowing and 1 means full shadowing */ get shadowStrength() {
+        return this._shadowStrength;
+    }
+    set shadowStrength(val) {
+        this._shadowStrength = Math.min(1, Math.max(0, Number(val) || 0));
+    }
     /** Shadow map mode */ get mode() {
         return this._shadowMode;
     }
@@ -213,7 +205,7 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
             this.shadowMapSize = 2048;
             this.shadowDistance = 120;
             this.splitLambda = 0.75;
-            this.depthBias = 0.18;
+            this.depthBias = 0.005;
             this.normalBias = 0.3;
             this.nearClip = 0.2;
             this.pcfKernelSize = 5;
@@ -224,7 +216,7 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
         this.shadowMapSize = 2048;
         this.shadowDistance = 800;
         this.splitLambda = 0.6;
-        this.depthBias = 0.35;
+        this.depthBias = 0.0035;
         this.normalBias = 0.22;
         this.nearClip = 1;
         this.pcfKernelSize = 3;
@@ -317,6 +309,18 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
             }
         }
     }
+    /** Whether to enable log space ESM blur */ get esmLogSpace() {
+        return this._esmLogSpace;
+    }
+    set esmLogSpace(val) {
+        if (!!val !== this.esmLogSpace) {
+            this._esmLogSpace = !!val;
+            const esm = this.asESM();
+            if (esm) {
+                esm.logSpace = this._esmLogSpace;
+            }
+        }
+    }
     /** Kernel size for ESM */ get esmBlurKernelSize() {
         return this._esmBlurKernelSize;
     }
@@ -480,17 +484,15 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
         lightCamera.position.set(this._light.positionAndRange.xyz());
     }
     /** @internal */ createLightCameraSpot(lightCamera) {
-        lightCamera.parent = this._light;
-        lightCamera.position.setXYZ(0, 0, 0);
-        lightCamera.rotation.identity();
+        this._light.worldMatrix.decompose(null, lightCamera.rotation, lightCamera.position);
+        lightCamera.parent = this._light.scene?.rootNode ?? null;
         lightCamera.scale.setXYZ(1, 1, 1);
         lightCamera.setPerspective(2 * Math.acos(this._light.cutoff), 1, this._config.nearClip, Math.min(this._shadowDistance, this._light.range));
     }
     /** @internal */ createLightCameraRect(lightCamera) {
         const rect = this._light;
-        lightCamera.parent = this._light;
-        lightCamera.position.setXYZ(0, 0, 0);
-        lightCamera.rotation.identity();
+        this._light.worldMatrix.decompose(null, lightCamera.rotation, lightCamera.position);
+        lightCamera.parent = this._light.scene?.rootNode ?? null;
         lightCamera.scale.setXYZ(1, 1, 1);
         const halfW = rect.width * 0.5;
         const halfH = rect.height * 0.5;
@@ -506,8 +508,9 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
             tmpFrustum.initWithMatrix(tmpMatrix);
             frustum = tmpFrustum;
         }
-        border = border || 0;
-        const expand = (this.shadowMapSize - 2 * border) / this.shadowMapSize;
+        const borderSize = Number.isFinite(border ?? 0) ? Math.max(0, border ?? 0) : 0;
+        const clampedBorderSize = Math.min(borderSize, (this.shadowMapSize - 1) * 0.5);
+        const paddingScale = this.shadowMapSize / (this.shadowMapSize - 2 * clampedBorderSize);
         //const frustum = sceneCamera.frustum;
         const frustumMin = ShadowMapper._frustumMin;
         const frustumMax = ShadowMapper._frustumMax;
@@ -521,10 +524,10 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
             frustumMin.inplaceMin(p);
             frustumMax.inplaceMax(p);
         });
-        let radius = Vector3.distance(frustumMin, frustumMax) * 0.5 * expand;
+        let radius = Vector3.distance(frustumMin, frustumMax) * 0.5 * paddingScale;
         const center = sceneCamera.thisToWorld(Vector3.add(frustumMin, frustumMax, frustumCenter).scaleBy(0.5), frustumCenter);
-        // Bounding sphere of the shadow camera should not be larger than bounding sphere of the scene.
-        const sceneRadius = sceneAABB.diagonalLength * 0.5 * expand;
+        // Clamp to the scene bounds first, then apply the filter border.
+        const sceneRadius = sceneAABB.diagonalLength * 0.5 * paddingScale;
         if (sceneRadius < radius) {
             radius = sceneRadius;
             Vector3.add(sceneAABB.minPoint, sceneAABB.maxPoint, center).scaleBy(0.5);
@@ -607,6 +610,9 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
       cropMatrix.m13 = offsetY;
     }
     */ }
+    /** {@inheritDoc Disposable.onDispose} */ onDispose() {
+        this._shadowRegion.dispose();
+    }
     /** @internal */ static fetchShadowMapParams() {
         if (this._shadowMapParams.length > 0) {
             return this._shadowMapParams.pop();
@@ -701,16 +707,14 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
         const device = getDevice();
         const fb = shadowMapParams.shadowMapFramebuffer;
         shadowMapParams.depthClampEnabled = false;
-        renderPass.clearColor = fb.getColorAttachments()[0] ? fb.getColorAttachments()[0].isFloatFormat() ? new Vector4(1, 1, 1, 1) : new Vector4(0, 0, 0, 1) : null;
+        renderPass.clearColor = this._impl.getShadowMapClearColor(shadowMapParams);
         const depthScale = this._impl.getDepthScale();
-        if (this._light.isDirectionLight() && this._autoShadowRegion) {
-            this.updateDirectionalShadowRegion();
-        }
-        const shadowRegion = this._light.isDirectionLight() && this._shadowRegion && this._shadowRegion.isValid() ? this._shadowRegion : scene.boundingBox;
+        const directionalShadowRegion = this._shadowRegion.region;
+        const shadowRegion = this._light.isDirectionLight() && directionalShadowRegion?.isValid() ? directionalShadowRegion : scene.boundingBox;
         if (this._light.isPointLight()) {
             const shadowMapRenderCamera = ShadowMapper.fetchCameraForScene(scene);
             this.createLightCameraPoint(shadowMapRenderCamera);
-            this.calcDepthBiasParams(camera, this._config.shadowMapSize, this._config.depthBias, this._config.normalBias, depthScale, shadowMapParams.depthBiasValues[0]);
+            this.calcDepthBiasParams(shadowMapRenderCamera, this._config.shadowMapSize, this._config.depthBias, this._config.normalBias, depthScale, shadowMapParams.depthBiasValues[0]);
             shadowMapParams.cameraParams.setXYZW(shadowMapRenderCamera.getNearPlane(), shadowMapRenderCamera.getFarPlane(), this._config.shadowMapSize, this._shadowDistance);
             device.setFramebuffer(fb);
             shadowMapParams.shadowMatrices.set(Matrix4x4.transpose(shadowMapRenderCamera.viewMatrix));
@@ -744,7 +748,7 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
                     const border = shadowMapParams.impl.getShadowMapBorder(shadowMapParams); //20 / this._config.shadowMapSize;
                     this.createLightCameraDirectional(shadowRegion, cascadeCamera, shadowMapRenderCamera, snapMatrix, border);
                     this.createLightCameraDirectional(shadowRegion, cascadeCamera, shadowMapCullCamera, null, border);
-                    this.calcDepthBiasParams(camera, this._config.shadowMapSize, this._config.depthBias, this._config.normalBias, depthScale, shadowMapParams.depthBiasValues[split]);
+                    this.calcDepthBiasParams(shadowMapRenderCamera, this._config.shadowMapSize, this._config.depthBias, this._config.normalBias, depthScale, shadowMapParams.depthBiasValues[split]);
                     shadowMapParams.depthBiasScales[split] = shadowMapParams.depthBiasValues[0].x !== 0 ? shadowMapParams.depthBiasValues[split].x / shadowMapParams.depthBiasValues[0].x : 1;
                     shadowMapParams.cameraParams.setXYZW(shadowMapRenderCamera.getNearPlane(), shadowMapRenderCamera.getFarPlane(), this._config.shadowMapSize, this._shadowDistance);
                     let scissor = null;
@@ -791,6 +795,7 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
             } else {
                 const shadowMapRenderCamera = ShadowMapper.fetchCameraForScene(scene);
                 const snapMatrix = ShadowMapper._snapMatrix;
+                snapMatrix.identity();
                 shadowMapRenderCamera.clipMask = AABB.ClipLeft | AABB.ClipRight | AABB.ClipBottom | AABB.ClipTop;
                 if (this._light.isDirectionLight()) {
                     this.createLightCameraDirectional(shadowRegion, camera, shadowMapRenderCamera, snapMatrix, shadowMapParams.impl.getShadowMapBorder(shadowMapParams));
@@ -799,7 +804,7 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
                 } else {
                     this.createLightCameraSpot(shadowMapRenderCamera);
                 }
-                this.calcDepthBiasParams(camera, this._config.shadowMapSize, this._config.depthBias, this._config.normalBias, depthScale, shadowMapParams.depthBiasValues[0]);
+                this.calcDepthBiasParams(shadowMapRenderCamera, this._config.shadowMapSize, this._config.depthBias, this._config.normalBias, depthScale, shadowMapParams.depthBiasValues[0]);
                 shadowMapParams.cameraParams.setXYZW(shadowMapRenderCamera.getNearPlane(), shadowMapRenderCamera.getFarPlane(), this._config.shadowMapSize, this._shadowDistance);
                 device.setFramebuffer(fb);
                 shadowMapRenderCamera.setProjectionMatrix(Matrix4x4.multiply(snapMatrix, shadowMapRenderCamera.getProjectionMatrix()));
@@ -822,6 +827,9 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
             this._impl = new VSM(this._vsmBlurKernelSize, this._vsmBlurRadius, this._vsmDarkness);
         } else if (mode === 'esm') {
             this._impl = new ESM(this._esmBlurKernelSize, this._esmBlurRadius, this._esmDepthScale);
+            const esm = this._impl;
+            esm.blur = this._esmBlur;
+            esm.logSpace = this._esmLogSpace;
         } else if (mode === 'pcf-pd') {
             this._impl = new PCFPD(this._pdSampleCount, this._pdSampleRadius);
         } else if (mode === 'pcf-opt') {