@zephyr3d/scene 0.1.0

package/dist/shadow/esm.js

@@ -0,0 +1,235 @@
+import { ShadowImpl } from './shadow_impl.js';
+import '@zephyr3d/base';
+import { Application } from '../app.js';
+import { ShaderFramework } from '../shaders/framework.js';
+import { decodeNormalizedFloatFromRGBA, encodeNormalizedFloatToRGBA } from '../shaders/misc.js';
+import { GaussianBlurBlitter } from '../blitter/gaussianblur.js';
+import { computeShadowMapDepth, filterShadowESM } from '../shaders/shadow.js';
+import '../scene/octree.js';
+import { LIGHT_TYPE_POINT } from '../values.js';
+import '../material/material.js';
+import '@zephyr3d/device';
+import '../render/scatteringlut.js';
+import '../material/lambert.js';
+import '../material/blinn.js';
+import '../material/unlit.js';
+import '../material/lightmodel.js';
+import '../render/forward.js';
+import '../render/sky.js';
+import '../render/clipmap.js';
+import { TemporalCache } from '../render/temporalcache.js';
+import '../render/watermesh.js';
+
+class BlurBlitter extends GaussianBlurBlitter {
+    _packFloat;
+    get packFloat() {
+        return this._packFloat;
+    }
+    set packFloat(b) {
+        if (this._packFloat !== !!b) {
+            this._packFloat = !!b;
+            this.invalidateHash();
+        }
+    }
+    readTexel(scope, type, srcTex, srcUV, srcLayer, sampleType) {
+        const pb = scope.$builder;
+        const texel = super.readTexel(scope, type, srcTex, srcUV, srcLayer, sampleType);
+        if (this.packFloat) {
+            return pb.vec4(decodeNormalizedFloatFromRGBA(scope, texel), 0, 0, 1);
+        } else {
+            return texel;
+        }
+    }
+    writeTexel(scope, type, srcUV, texel) {
+        const outTexel = super.writeTexel(scope, type, srcUV, texel);
+        if (this.packFloat) {
+            return encodeNormalizedFloatToRGBA(scope, outTexel.r);
+        } else {
+            return outTexel;
+        }
+    }
+    calcHash() {
+        return `${super.calcHash()}-${Number(this.packFloat)}`;
+    }
+}
+/** @internal */ class ESM extends ShadowImpl {
+    /** @internal */ _depthScale;
+    /** @internal */ _blur;
+    /** @internal */ _kernelSize;
+    /** @internal */ _blurSize;
+    /** @internal */ _logSpace;
+    /** @internal */ _blitterH;
+    /** @internal */ _blitterV;
+    /** @internal */ _mipmap;
+    constructor(kernelSize, blurSize, depthScale){
+        super();
+        this._blur = true;
+        this._depthScale = depthScale ?? 500;
+        this._kernelSize = kernelSize ?? 5;
+        this._blurSize = blurSize ?? 1;
+        this._logSpace = true;
+        this._mipmap = true;
+        this._blitterH = new BlurBlitter('horizonal', this._kernelSize, 4, 1 / 1024);
+        this._blitterV = new BlurBlitter('vertical', this._kernelSize, 4, 1 / 1024);
+    }
+    resourceDirty() {
+        return this._resourceDirty;
+    }
+    get blur() {
+        return this._blur;
+    }
+    set blur(val) {
+        if (this._blur !== !!val) {
+            this._blur = !!val;
+            this._resourceDirty = true;
+        }
+    }
+    get mipmap() {
+        return this._mipmap;
+    }
+    set mipmap(b) {
+        if (this._mipmap !== !!b) {
+            this._mipmap = !!b;
+            if (this._blur) {
+                this._resourceDirty = true;
+            }
+        }
+    }
+    get kernelSize() {
+        return this._kernelSize;
+    }
+    set kernelSize(val) {
+        this._kernelSize = val;
+    }
+    get blurSize() {
+        return this._blurSize;
+    }
+    set blurSize(val) {
+        this._blurSize = val;
+    }
+    get logSpace() {
+        return this._logSpace;
+    }
+    set logSpace(val) {
+        this._logSpace = !!val;
+    }
+    getType() {
+        return 'esm';
+    }
+    getShadowMapBorder(shadowMapParams) {
+        return this._blur ? Math.ceil((this._kernelSize + 1) / 2 * this._blurSize) : 0;
+    }
+    getShadowMap(shadowMapParams) {
+        const implData = shadowMapParams.implData;
+        return implData ? implData.blurFramebuffer2.getColorAttachments()[0] : shadowMapParams.shadowMapFramebuffer.getColorAttachments()[0];
+    }
+    doUpdateResources(shadowMapParams) {
+        const implData = {
+            blurFramebuffer: null,
+            blurFramebuffer2: null
+        };
+        shadowMapParams.implData = implData;
+        const colorFormat = this.getShadowMapColorFormat(shadowMapParams);
+        const target = shadowMapParams.shadowMapFramebuffer.getColorAttachments()[0].target;
+        const shadowMapWidth = shadowMapParams.shadowMapFramebuffer.getColorAttachments()[0].width;
+        const shadowMapHeight = shadowMapParams.shadowMapFramebuffer.getColorAttachments()[0].height;
+        if (this._blur) {
+            shadowMapParams.implData = {
+                blurFramebuffer: TemporalCache.getFramebufferFixedSize(shadowMapWidth, shadowMapHeight, shadowMapParams.numShadowCascades, colorFormat, null, target, null, false),
+                blurFramebuffer2: TemporalCache.getFramebufferFixedSize(shadowMapWidth, shadowMapHeight, shadowMapParams.numShadowCascades, colorFormat, null, target, null, this._mipmap)
+            };
+        }
+        shadowMapParams.shadowMap = this.getShadowMap(shadowMapParams);
+        shadowMapParams.shadowMapSampler = shadowMapParams.shadowMap?.getDefaultSampler(false) ?? null;
+    }
+    postRenderShadowMap(shadowMapParams) {
+        if (shadowMapParams.implData) {
+            const implData = shadowMapParams.implData;
+            const colorAttachment = shadowMapParams.shadowMapFramebuffer.getColorAttachments()[0];
+            this._blitterH.blurSize = this._blurSize / colorAttachment.width;
+            this._blitterH.kernelSize = this._kernelSize;
+            this._blitterH.logSpace = this._logSpace;
+            this._blitterH.packFloat = colorAttachment.format === 'rgba8unorm';
+            this._blitterV.blurSize = this._blurSize / colorAttachment.height;
+            this._blitterV.kernelSize = this._kernelSize;
+            this._blitterV.logSpace = this._logSpace;
+            this._blitterV.packFloat = colorAttachment.format === 'rgba8unorm';
+            this._blitterH.blit(colorAttachment, implData.blurFramebuffer);
+            this._blitterV.blit(implData.blurFramebuffer.getColorAttachments()[0], implData.blurFramebuffer2);
+        }
+    }
+    releaseTemporalResources(shadowMapParams) {
+        const implData = shadowMapParams.implData;
+        if (implData) {
+            TemporalCache.releaseFramebuffer(implData.blurFramebuffer);
+            TemporalCache.releaseFramebuffer(implData.blurFramebuffer2);
+        }
+    }
+    getDepthScale() {
+        return this._depthScale;
+    }
+    setDepthScale(val) {
+        this._depthScale = val;
+    }
+    getShaderHash() {
+        return '';
+    }
+    getShadowMapColorFormat(shadowMapParams) {
+        const device = Application.instance.device;
+        return device.getDeviceCaps().textureCaps.supportHalfFloatColorBuffer ? device.type === 'webgl' ? 'rgba16f' : 'r16f' : device.getDeviceCaps().textureCaps.supportFloatColorBuffer ? device.type === 'webgl' ? 'rgba32f' : 'r32f' : 'rgba8unorm';
+    }
+    getShadowMapDepthFormat(shadowMapParams) {
+        return 'd24s8';
+    }
+    computeShadowMapDepth(shadowMapParams, scope) {
+        return computeShadowMapDepth(scope, shadowMapParams.shadowMap.format);
+    }
+    computeShadowCSM(shadowMapParams, scope, shadowVertex, NdotL, split) {
+        const funcNameComputeShadowCSM = 'lib_computeShadowCSM';
+        const pb = scope.$builder;
+        pb.func(funcNameComputeShadowCSM, [
+            pb.vec4('shadowVertex'),
+            pb.float('NdotL'),
+            pb.int('split')
+        ], function() {
+            this.$l.shadowCoord = pb.div(this.shadowVertex, this.shadowVertex.w);
+            this.$l.shadowCoord = pb.add(pb.mul(this.shadowCoord, 0.5), 0.5);
+            this.$l.inShadow = pb.all(pb.bvec2(pb.all(pb.bvec4(pb.greaterThanEqual(this.shadowCoord.x, 0), pb.lessThanEqual(this.shadowCoord.x, 1), pb.greaterThanEqual(this.shadowCoord.y, 0), pb.lessThanEqual(this.shadowCoord.y, 1))), pb.lessThanEqual(this.shadowCoord.z, 1)));
+            this.$l.shadow = pb.float(1);
+            this.$if(this.inShadow, function() {
+                this.shadow = filterShadowESM(this, shadowMapParams.lightType, shadowMapParams.shadowMap.format, this.shadowCoord, this.split);
+            });
+            this.$return(this.shadow);
+        });
+        return pb.getGlobalScope()[funcNameComputeShadowCSM](shadowVertex, NdotL, split);
+    }
+    computeShadow(shadowMapParams, scope, shadowVertex, NdotL) {
+        const funcNameComputeShadow = 'lib_computeShadow';
+        const pb = scope.$builder;
+        pb.func(funcNameComputeShadow, [
+            pb.vec4('shadowVertex'),
+            pb.float('NdotL')
+        ], function() {
+            if (shadowMapParams.lightType === LIGHT_TYPE_POINT) {
+                this.$l.dir = pb.sub(this.shadowVertex.xyz, ShaderFramework.getLightPositionAndRangeForShadow(this).xyz);
+                this.$return(filterShadowESM(this, LIGHT_TYPE_POINT, shadowMapParams.shadowMap.format, this.dir));
+            } else {
+                this.$l.shadowCoord = pb.div(this.shadowVertex, this.shadowVertex.w);
+                this.$l.shadowCoord = pb.add(pb.mul(this.shadowCoord, 0.5), 0.5);
+                this.$l.inShadow = pb.all(pb.bvec2(pb.all(pb.bvec4(pb.greaterThanEqual(this.shadowCoord.x, 0), pb.lessThanEqual(this.shadowCoord.x, 1), pb.greaterThanEqual(this.shadowCoord.y, 0), pb.lessThanEqual(this.shadowCoord.y, 1))), pb.lessThanEqual(this.shadowCoord.z, 1)));
+                this.$l.shadow = pb.float(1);
+                this.$if(this.inShadow, function() {
+                    this.shadow = filterShadowESM(this, shadowMapParams.lightType, shadowMapParams.shadowMap.format, this.shadowCoord);
+                });
+                this.$return(this.shadow);
+            }
+        });
+        return pb.getGlobalScope()[funcNameComputeShadow](shadowVertex, NdotL);
+    }
+    useNativeShadowMap(shadowMapParams) {
+        return false;
+    }
+}
+
+export { ESM };
+//# sourceMappingURL=esm.js.map

package/dist/shadow/esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"esm.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/shadow/pcf_opt.js

@@ -0,0 +1,182 @@
+import { ShadowImpl } from './shadow_impl.js';
+import { linearDepthToNonLinear, decodeNormalizedFloatFromRGBA } from '../shaders/misc.js';
+import { computeShadowMapDepth, computeReceiverPlaneDepthBias, filterShadowPCF } from '../shaders/shadow.js';
+import { ShadowMapper } from './shadowmapper.js';
+import { ShaderFramework } from '../shaders/framework.js';
+import { Application } from '../app.js';
+import { LIGHT_TYPE_POINT } from '../values.js';
+
+/** @internal */ class PCFOPT extends ShadowImpl {
+    _kernelSize;
+    _shadowSampler;
+    constructor(kernelSize){
+        super();
+        this._kernelSize = kernelSize ?? 5;
+        this._shadowSampler = null;
+    }
+    get kernelSize() {
+        return this._kernelSize;
+    }
+    set kernelSize(val) {
+        val = val !== 3 && val !== 5 && val !== 7 ? 5 : val;
+        this._kernelSize = val;
+    }
+    getType() {
+        return 'pcf-opt';
+    }
+    dispose() {
+        this._shadowSampler = null;
+    }
+    resourceDirty() {
+        return false;
+    }
+    getShadowMapBorder(shadowMapParams) {
+        return this._kernelSize;
+    }
+    getShadowMap(shadowMapParams) {
+        return this.useNativeShadowMap(shadowMapParams) ? shadowMapParams.shadowMapFramebuffer.getDepthAttachment() : shadowMapParams.shadowMapFramebuffer.getColorAttachments()[0];
+    }
+    doUpdateResources(shadowMapParams) {
+        shadowMapParams.shadowMap = this.getShadowMap(shadowMapParams);
+        shadowMapParams.shadowMapSampler = shadowMapParams.shadowMap?.getDefaultSampler(this.useNativeShadowMap(shadowMapParams)) || null;
+    }
+    postRenderShadowMap() {}
+    releaseTemporalResources(shadowMapParams) {}
+    getDepthScale() {
+        return 1;
+    }
+    setDepthScale(val) {}
+    getShaderHash() {
+        return `${this._kernelSize}`;
+    }
+    getShadowMapColorFormat(shadowMapParams) {
+        return this.useNativeShadowMap(shadowMapParams) ? null : 'rgba8unorm';
+    }
+    getShadowMapDepthFormat(shadowMapParams) {
+        return Application.instance.device.type === 'webgl' ? 'd24s8' : 'd32f';
+    }
+    computeShadowMapDepth(shadowMapParams, scope) {
+        return computeShadowMapDepth(scope, shadowMapParams.shadowMap.format);
+    }
+    computeShadowCSM(shadowMapParams, scope, shadowVertex, NdotL, split) {
+        const funcNameComputeShadowCSM = 'lib_computeShadowCSM';
+        const pb = scope.$builder;
+        const that = this;
+        pb.func(funcNameComputeShadowCSM, [
+            pb.vec4('shadowVertex'),
+            pb.float('NdotL'),
+            pb.int('split')
+        ], function() {
+            this.$l.shadowCoord = pb.div(this.shadowVertex, this.shadowVertex.w);
+            this.$l.shadowCoord = pb.add(pb.mul(this.shadowCoord, 0.5), 0.5);
+            this.$l.inShadow = pb.all(pb.bvec2(pb.all(pb.bvec4(pb.greaterThanEqual(this.shadowCoord.x, 0), pb.lessThanEqual(this.shadowCoord.x, 1), pb.greaterThanEqual(this.shadowCoord.y, 0), pb.lessThanEqual(this.shadowCoord.y, 1))), pb.lessThanEqual(this.shadowCoord.z, 1)));
+            this.$l.shadow = pb.float(1);
+            this.$l.receiverPlaneDepthBias = computeReceiverPlaneDepthBias(this, this.shadowCoord);
+            this.$if(this.inShadow, function() {
+                this.$l.shadowBias = ShadowMapper.computeShadowBiasCSM(shadowMapParams, this, this.NdotL, this.split);
+                this.shadowCoord.z = pb.sub(this.shadowCoord.z, this.shadowBias);
+                this.shadow = filterShadowPCF(this, shadowMapParams.lightType, shadowMapParams.shadowMap.format, that._kernelSize, this.shadowCoord, this.receiverPlaneDepthBias, this.split);
+            });
+            this.$return(this.shadow);
+        });
+        return pb.getGlobalScope()[funcNameComputeShadowCSM](shadowVertex, NdotL, split);
+    }
+    computeShadow(shadowMapParams, scope, shadowVertex, NdotL) {
+        const funcNameComputeShadow = 'lib_computeShadow';
+        const pb = scope.$builder;
+        const that = this;
+        pb.func(funcNameComputeShadow, [
+            pb.vec4('shadowVertex'),
+            pb.float('NdotL')
+        ], function() {
+            if (shadowMapParams.lightType === LIGHT_TYPE_POINT) {
+                this.$l.dir = pb.sub(this.shadowVertex.xyz, ShaderFramework.getLightPositionAndRangeForShadow(this).xyz);
+                if (that.useNativeShadowMap(shadowMapParams)) {
+                    this.$l.nearFar = ShaderFramework.getShadowCameraParams(this).xy;
+                    this.$l.maxZ = pb.max(pb.max(pb.abs(this.dir.x), pb.abs(this.dir.y)), pb.abs(this.dir.z));
+                    this.$l.distance = linearDepthToNonLinear(this, this.maxZ, this.nearFar);
+                    this.$l.shadowBias = ShadowMapper.computeShadowBias(shadowMapParams, this, pb.div(this.maxZ, ShaderFramework.getLightPositionAndRangeForShadow(this).w), this.NdotL, true);
+                    this.$return(that.sampleShadowMap(shadowMapParams, this, this.dir, this.distance, this.shadowBias));
+                } else {
+                    this.$l.distance = pb.div(pb.length(this.dir), ShaderFramework.getLightPositionAndRangeForShadow(this).w);
+                    this.$l.shadowBias = ShadowMapper.computeShadowBias(shadowMapParams, this, this.distance, this.NdotL, true);
+                    this.$return(that.sampleShadowMap(shadowMapParams, this, this.dir, this.distance, this.shadowBias));
+                }
+            } else {
+                this.$l.shadowCoord = pb.div(this.shadowVertex, this.shadowVertex.w);
+                this.$l.shadowCoord = pb.add(pb.mul(this.shadowCoord, 0.5), 0.5);
+                this.$l.inShadow = pb.all(pb.bvec2(pb.all(pb.bvec4(pb.greaterThanEqual(this.shadowCoord.x, 0), pb.lessThanEqual(this.shadowCoord.x, 1), pb.greaterThanEqual(this.shadowCoord.y, 0), pb.lessThanEqual(this.shadowCoord.y, 1))), pb.lessThanEqual(this.shadowCoord.z, 1)));
+                this.$l.shadow = pb.float(1);
+                this.$l.receiverPlaneDepthBias = computeReceiverPlaneDepthBias(this, this.shadowCoord);
+                this.$if(this.inShadow, function() {
+                    this.$l.shadowBias = ShadowMapper.computeShadowBias(shadowMapParams, this, this.shadowCoord.z, this.NdotL, false);
+                    this.shadowCoord.z = pb.sub(this.shadowCoord.z, this.shadowBias);
+                    this.shadow = filterShadowPCF(this, shadowMapParams.lightType, shadowMapParams.shadowMap.format, that._kernelSize, this.shadowCoord, this.receiverPlaneDepthBias);
+                });
+                this.$return(this.shadow);
+            }
+        });
+        return pb.getGlobalScope()[funcNameComputeShadow](shadowVertex, NdotL);
+    }
+    useNativeShadowMap(shadowMapParams) {
+        return Application.instance.device.type !== 'webgl';
+    }
+    /** @internal */ sampleShadowMap(shadowMapParams, scope, coords, z, bias) {
+        const funcNameSampleShadowMap = `lib_sampleShadowMap`;
+        const pb = scope.$builder;
+        const that = this;
+        pb.func(funcNameSampleShadowMap, [
+            pb.vec3('coords'),
+            pb.float('z'),
+            pb.float('bias')
+        ], function() {
+            const floatDepthTexture = shadowMapParams.shadowMap.format !== 'rgba8unorm';
+            if (that.useNativeShadowMap(shadowMapParams)) {
+                this.$return(pb.clamp(pb.textureSampleCompareLevel(this.shadowMap, this.coords, pb.sub(this.z, this.bias)), 0, 1));
+            } else {
+                this.$l.shadowTex = pb.textureSampleLevel(this.shadowMap, this.coords, 0);
+                if (!floatDepthTexture) {
+                    this.shadowTex.x = decodeNormalizedFloatFromRGBA(this, this.shadowTex);
+                }
+                this.$l.distance = pb.sub(this.z, this.bias);
+                this.$return(pb.step(this.distance, this.shadowTex.x));
+            }
+        });
+        return pb.getGlobalScope()[funcNameSampleShadowMap](coords, z, bias);
+    }
+    /** @internal */ sampleShadowMapCSM(shadowMapParams, scope, coords, split, z, bias) {
+        const funcNameSampleShadowMapCSM = 'lib_sampleShadowMapCSM';
+        const pb = scope.$builder;
+        const that = this;
+        pb.func(funcNameSampleShadowMapCSM, [
+            pb.vec4('coords'),
+            pb.int('split'),
+            pb.float('z'),
+            pb.float('bias')
+        ], function() {
+            const floatDepthTexture = shadowMapParams.shadowMap.format !== 'rgba8unorm';
+            this.$l.distance = pb.sub(this.z, this.bias);
+            if (that.useNativeShadowMap(shadowMapParams)) {
+                if (shadowMapParams.shadowMap.isTexture2DArray()) {
+                    this.$return(pb.clamp(pb.textureArraySampleCompareLevel(this.shadowMap, this.coords.xy, this.split, this.distance), 0, 1));
+                } else {
+                    this.$return(pb.clamp(pb.textureSampleCompareLevel(this.shadowMap, this.coords.xy, this.distance), 0, 1));
+                }
+            } else {
+                if (shadowMapParams.shadowMap.isTexture2DArray()) {
+                    this.$l.shadowTex = pb.textureArraySampleLevel(this.shadowMap, this.coords.xy, this.split, 0);
+                } else {
+                    this.$l.shadowTex = pb.textureSampleLevel(this.shadowMap, this.coords.xy, 0);
+                }
+                if (!floatDepthTexture) {
+                    this.shadowTex.x = decodeNormalizedFloatFromRGBA(this, this.shadowTex);
+                }
+                this.$return(pb.step(this.distance, this.shadowTex.x));
+            }
+        });
+        return pb.getGlobalScope()[funcNameSampleShadowMapCSM](coords, split, z, bias);
+    }
+}
+
+export { PCFOPT };
+//# sourceMappingURL=pcf_opt.js.map

package/dist/shadow/pcf_opt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pcf_opt.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/shadow/pcf_pd.js

@@ -0,0 +1,190 @@
+import { ShadowImpl } from './shadow_impl.js';
+import { computeShadowMapDepth, computeReceiverPlaneDepthBias, filterShadowPoissonDisc } from '../shaders/shadow.js';
+import { ShadowMapper } from './shadowmapper.js';
+import { linearDepthToNonLinear, decodeNormalizedFloatFromRGBA } from '../shaders/misc.js';
+import { ShaderFramework } from '../shaders/framework.js';
+import { Application } from '../app.js';
+import { LIGHT_TYPE_POINT } from '../values.js';
+
+/** @internal */ class PCFPD extends ShadowImpl {
+    _tapCount;
+    _sampleRadius;
+    _shadowSampler;
+    constructor(tapCount, sampleRadius){
+        super();
+        this._tapCount = tapCount ?? 3;
+        this._sampleRadius = sampleRadius ?? 1;
+        this._shadowSampler = null;
+    }
+    get tapCount() {
+        return this._tapCount;
+    }
+    set tapCount(val) {
+        this._tapCount = val;
+    }
+    getType() {
+        return 'pcf-pd';
+    }
+    dispose() {
+        this._shadowSampler = null;
+    }
+    resourceDirty() {
+        return false;
+    }
+    getShadowMapBorder(shadowMapParams) {
+        return this._sampleRadius + 1;
+    }
+    getShadowMap(shadowMapParams) {
+        return this.useNativeShadowMap(shadowMapParams) ? shadowMapParams.shadowMapFramebuffer.getDepthAttachment() : shadowMapParams.shadowMapFramebuffer.getColorAttachments()[0];
+    }
+    doUpdateResources(shadowMapParams) {
+        shadowMapParams.shadowMap = this.getShadowMap(shadowMapParams);
+        shadowMapParams.shadowMapSampler = shadowMapParams.shadowMap?.getDefaultSampler(this.useNativeShadowMap(shadowMapParams)) || null;
+    }
+    postRenderShadowMap() {}
+    releaseTemporalResources(shadowMapParams) {}
+    getDepthScale() {
+        return this._sampleRadius;
+    }
+    setDepthScale(val) {
+        this._sampleRadius = val;
+    }
+    getShaderHash() {
+        return `${this._tapCount}`;
+    }
+    getShadowMapColorFormat(shadowMapParams) {
+        if (this.useNativeShadowMap(shadowMapParams)) {
+            return null;
+        } else {
+            const device = Application.instance.device;
+            return device.getDeviceCaps().textureCaps.supportHalfFloatColorBuffer ? device.type === 'webgl' ? 'rgba16f' : 'r16f' : device.getDeviceCaps().textureCaps.supportFloatColorBuffer ? device.type === 'webgl' ? 'rgba32f' : 'r32f' : 'rgba8unorm';
+        }
+    }
+    getShadowMapDepthFormat(shadowMapParams) {
+        return Application.instance.device.type === 'webgl' ? 'd24s8' : 'd32f';
+    }
+    computeShadowMapDepth(shadowMapParams, scope) {
+        return computeShadowMapDepth(scope, shadowMapParams.shadowMap.format);
+    }
+    computeShadowCSM(shadowMapParams, scope, shadowVertex, NdotL, split) {
+        const funcNameComputeShadowCSM = 'lib_computeShadowCSM';
+        const pb = scope.$builder;
+        const that = this;
+        pb.func(funcNameComputeShadowCSM, [
+            pb.vec4('shadowVertex'),
+            pb.float('NdotL'),
+            pb.int('split')
+        ], function() {
+            this.$l.shadowCoord = pb.div(this.shadowVertex, this.shadowVertex.w);
+            this.$l.shadowCoord = pb.add(pb.mul(this.shadowCoord, 0.5), 0.5);
+            this.$l.inShadow = pb.all(pb.bvec2(pb.all(pb.bvec4(pb.greaterThanEqual(this.shadowCoord.x, 0), pb.lessThanEqual(this.shadowCoord.x, 1), pb.greaterThanEqual(this.shadowCoord.y, 0), pb.lessThanEqual(this.shadowCoord.y, 1))), pb.lessThanEqual(this.shadowCoord.z, 1)));
+            this.$l.shadow = pb.float(1);
+            this.$l.receiverPlaneDepthBias = computeReceiverPlaneDepthBias(this, this.shadowCoord);
+            this.$if(this.inShadow, function() {
+                this.$l.shadowBias = ShadowMapper.computeShadowBiasCSM(shadowMapParams, this, this.NdotL, this.split);
+                this.shadowCoord.z = pb.sub(this.shadowCoord.z, this.shadowBias);
+                this.shadow = filterShadowPoissonDisc(this, shadowMapParams.lightType, shadowMapParams.shadowMap.format, that._tapCount, this.shadowCoord, this.receiverPlaneDepthBias, this.split);
+            });
+            this.$return(this.shadow);
+        });
+        return pb.getGlobalScope()[funcNameComputeShadowCSM](shadowVertex, NdotL, split);
+    }
+    computeShadow(shadowMapParams, scope, shadowVertex, NdotL) {
+        const funcNameComputeShadow = 'lib_computeShadow';
+        const pb = scope.$builder;
+        const that = this;
+        pb.func(funcNameComputeShadow, [
+            pb.vec4('shadowVertex'),
+            pb.float('NdotL')
+        ], function() {
+            if (shadowMapParams.lightType === LIGHT_TYPE_POINT) {
+                this.$l.dir = pb.sub(this.shadowVertex.xyz, ShaderFramework.getLightPositionAndRangeForShadow(this).xyz);
+                if (that.useNativeShadowMap(shadowMapParams)) {
+                    this.$l.nearFar = ShaderFramework.getShadowCameraParams(this).xy;
+                    this.$l.maxZ = pb.max(pb.max(pb.abs(this.dir.x), pb.abs(this.dir.y)), pb.abs(this.dir.z));
+                    this.$l.distance = linearDepthToNonLinear(this, this.maxZ, this.nearFar);
+                    this.$l.shadowBias = ShadowMapper.computeShadowBias(shadowMapParams, this, pb.div(this.maxZ, ShaderFramework.getLightPositionAndRangeForShadow(this).w), this.NdotL, true);
+                    this.$return(that.sampleShadowMap(shadowMapParams, this, this.dir, this.distance, this.shadowBias));
+                } else {
+                    this.$l.distance = pb.div(pb.length(this.dir), ShaderFramework.getLightPositionAndRangeForShadow(this).w);
+                    this.$l.shadowBias = ShadowMapper.computeShadowBias(shadowMapParams, this, this.distance, this.NdotL, true);
+                    this.$return(that.sampleShadowMap(shadowMapParams, this, this.dir, this.distance, this.shadowBias));
+                }
+            } else {
+                this.$l.shadowCoord = pb.div(this.shadowVertex, this.shadowVertex.w);
+                this.$l.shadowCoord = pb.add(pb.mul(this.shadowCoord, 0.5), 0.5);
+                this.$l.inShadow = pb.all(pb.bvec2(pb.all(pb.bvec4(pb.greaterThanEqual(this.shadowCoord.x, 0), pb.lessThanEqual(this.shadowCoord.x, 1), pb.greaterThanEqual(this.shadowCoord.y, 0), pb.lessThanEqual(this.shadowCoord.y, 1))), pb.lessThanEqual(this.shadowCoord.z, 1)));
+                this.$l.shadow = pb.float(1);
+                this.$l.receiverPlaneDepthBias = computeReceiverPlaneDepthBias(this, this.shadowCoord);
+                this.$if(this.inShadow, function() {
+                    this.$l.shadowBias = ShadowMapper.computeShadowBias(shadowMapParams, this, this.shadowCoord.z, this.NdotL, false);
+                    this.shadowCoord.z = pb.sub(this.shadowCoord.z, this.shadowBias);
+                    this.shadow = filterShadowPoissonDisc(this, shadowMapParams.lightType, shadowMapParams.shadowMap.format, that._tapCount, this.shadowCoord, this.receiverPlaneDepthBias);
+                });
+                this.$return(this.shadow);
+            }
+        });
+        return pb.getGlobalScope()[funcNameComputeShadow](shadowVertex, NdotL);
+    }
+    useNativeShadowMap(shadowMapParams) {
+        return Application.instance.device.type !== 'webgl';
+    }
+    /** @internal */ sampleShadowMap(shadowMapParams, scope, coords, z, bias) {
+        const funcNameSampleShadowMap = 'lib_sampleShadowMap';
+        const pb = scope.$builder;
+        const that = this;
+        pb.func(funcNameSampleShadowMap, [
+            pb.vec3('coords'),
+            pb.float('z'),
+            pb.float('bias')
+        ], function() {
+            const floatDepthTexture = shadowMapParams.shadowMap.format !== 'rgba8unorm';
+            if (that.useNativeShadowMap(shadowMapParams)) {
+                this.$return(pb.clamp(pb.textureSampleCompareLevel(this.shadowMap, this.coords, pb.sub(this.z, this.bias)), 0, 1));
+            } else {
+                this.$l.shadowTex = pb.textureSampleLevel(this.shadowMap, this.coords, 0);
+                if (!floatDepthTexture) {
+                    this.shadowTex.x = decodeNormalizedFloatFromRGBA(this, this.shadowTex);
+                }
+                this.$l.distance = pb.sub(this.z, this.bias);
+                this.$return(pb.step(this.distance, this.shadowTex.x));
+            }
+        });
+        return pb.getGlobalScope()[funcNameSampleShadowMap](coords, z, bias);
+    }
+    /** @internal */ sampleShadowMapCSM(shadowMapParams, scope, coords, split, z, bias) {
+        const funcNameSampleShadowMapCSM = 'lib_sampleShadowMapCSM';
+        const pb = scope.$builder;
+        const that = this;
+        pb.func(funcNameSampleShadowMapCSM, [
+            pb.vec4('coords'),
+            pb.int('split'),
+            pb.float('z'),
+            pb.float('bias')
+        ], function() {
+            const floatDepthTexture = shadowMapParams.shadowMap.format !== 'rgba8unorm';
+            this.$l.distance = pb.sub(this.z, this.bias);
+            if (that.useNativeShadowMap(shadowMapParams)) {
+                if (shadowMapParams.shadowMap.isTexture2DArray()) {
+                    this.$return(pb.clamp(pb.textureArraySampleCompareLevel(this.shadowMap, this.coords.xy, this.split, this.distance), 0, 1));
+                } else {
+                    this.$return(pb.clamp(pb.textureSampleCompareLevel(this.shadowMap, this.coords.xy, this.distance), 0, 1));
+                }
+            } else {
+                if (shadowMapParams.shadowMap.isTexture2DArray()) {
+                    this.$l.shadowTex = pb.textureArraySampleLevel(this.shadowMap, this.coords.xy, this.split, 0);
+                } else {
+                    this.$l.shadowTex = pb.textureSampleLevel(this.shadowMap, this.coords.xy, 0);
+                }
+                if (!floatDepthTexture) {
+                    this.shadowTex.x = decodeNormalizedFloatFromRGBA(this, this.shadowTex);
+                }
+                this.$return(pb.step(this.distance, this.shadowTex.x));
+            }
+        });
+        return pb.getGlobalScope()[funcNameSampleShadowMapCSM](coords, split, z, bias);
+    }
+}
+
+export { PCFPD };
+//# sourceMappingURL=pcf_pd.js.map

package/dist/shadow/pcf_pd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pcf_pd.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/shadow/shadow_impl.js

@@ -0,0 +1,15 @@
+/** @internal */ class ShadowImpl {
+    _resourceDirty;
+    constructor(){
+        this._resourceDirty = true;
+    }
+    invalidateResource() {
+        this._resourceDirty = true;
+    }
+    updateResources(shadowMapParams) {
+        this.doUpdateResources(shadowMapParams);
+    }
+}
+
+export { ShadowImpl };
+//# sourceMappingURL=shadow_impl.js.map

package/dist/shadow/shadow_impl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadow_impl.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;"}