@zephyr3d/editor 0.3.8 → 0.3.9

package/dist/modules/zephyr3d_scene.js

@@ -10182,6 +10182,7 @@ const tmpV3$1 = new Vector3();
     MaterialVaryingFlags[MaterialVaryingFlags["SSS_STORE_DIFFUSE"] = 64] = "SSS_STORE_DIFFUSE";
     MaterialVaryingFlags[MaterialVaryingFlags["SSS_STORE_NORMAL"] = 128] = "SSS_STORE_NORMAL";
     MaterialVaryingFlags[MaterialVaryingFlags["SSS_STORE_TRANSMISSION"] = 256] = "SSS_STORE_TRANSMISSION";
+    MaterialVaryingFlags[MaterialVaryingFlags["SKIN_SSS_STORE"] = 512] = "SKIN_SSS_STORE";
     return MaterialVaryingFlags;
 }({});
 /**
@@ -11392,6 +11393,7 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
         depthBiasValues: new Vector4(),
         shadowCameraParams: new Vector4(),
         depthBiasScales: new Vector4(),
+        implParams: new Vector4(),
         shadowMatrices: new Float32Array(16 * 4),
         shadowStrength: 1,
         envLightStrength: 1,
@@ -11547,6 +11549,7 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
                 pb.vec4('depthBiasValues'),
                 pb.vec4('shadowCameraParams'),
                 pb.vec4('depthBiasScales'),
+                pb.vec4('implParams'),
                 pb.vec4[16]('shadowMatrices'),
                 pb.float('shadowStrength'),
                 pb.float('envLightStrength'),
@@ -12078,6 +12081,7 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
         this._lightUniformShadow.depthBiasValues.set(shadowMapParams.depthBiasValues[0]);
         this._lightUniformShadow.shadowCameraParams.set(shadowMapParams.cameraParams);
         this._lightUniformShadow.depthBiasScales.set(shadowMapParams.depthBiasScales);
+        shadowMapParams.impl.getParams(this._lightUniformShadow.implParams);
         this._lightUniformShadow.shadowMatrices.set(shadowMapParams.shadowMatrices);
         this._lightUniformShadow.shadowStrength = light.shadow.shadowStrength;
         this._lightUniformShadow.envLightStrength = ctx.env?.light.strength ?? 0;
@@ -12326,6 +12330,9 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
     /** @internal */ static getCascadeDistances(scope) {
         return scope.light.cascadeDistances;
     }
+    /** @internal */ static getShadowImplParams(scope) {
+        return scope.light.implParams;
+    }
     /** @internal */ static getDepthBiasValues(scope) {
         return scope.light.depthBiasValues;
     }
@@ -13965,6 +13972,9 @@ let FEATURE_DISABLE_TAA = 0;
                     if (ctx.materialFlags & MaterialVaryingFlags.SSS_STORE_TRANSMISSION) {
                         this.$outputs.zSSSTransmission = pb.vec4();
                     }
+                    if (ctx.materialFlags & MaterialVaryingFlags.SKIN_SSS_STORE) {
+                        this.$outputs.zSkinSSS = pb.vec4();
+                    }
                     if (ctx.renderPass.type === RENDER_PASS_TYPE_DEPTH && ctx.motionVectors) {
                         this.$outputs.zMotionVector = pb.vec4();
                         this.zTAAStrength = pb.float().uniform(2);
@@ -14002,7 +14012,7 @@ let FEATURE_DISABLE_TAA = 0;
    * @param sssDiffuse - Optional diffuse-only lighting color for SSS composition.
    * @param sssTransmission - Optional thin-shell transmission lighting color for SSS composition.
    * @returns void
-   */ outputFragmentColor(scope, worldPos, color, ssrRoughness, ssrNormal, sssProfile, sssParams, sssDiffuse, sssTransmission, sssProfileEnabled = false) {
+   */ outputFragmentColor(scope, worldPos, color, ssrRoughness, ssrNormal, sssProfile, sssParams, sssDiffuse, sssTransmission, sssProfileEnabled = false, skinSSS) {
         const pb = scope.$builder;
         const that = this;
         const funcName = 'Z_outputFragmentColor';
@@ -14174,6 +14184,10 @@ let FEATURE_DISABLE_TAA = 0;
             const disableSSS = that.drawContext.renderPass.type !== RENDER_PASS_TYPE_LIGHT || that.isTransparentPass(that.pass, that.drawContext) && !that.alphaToCoverage || that.needSceneColor();
             scope.$outputs.zSSSTransmission = disableSSS ? pb.vec4(0) : sssTransmission ?? pb.vec4(0);
         }
+        if (that.drawContext.materialFlags & MaterialVaryingFlags.SKIN_SSS_STORE) {
+            const disableSkinSSS = that.drawContext.renderPass.type !== RENDER_PASS_TYPE_LIGHT || that.isTransparentPass(that.pass, that.drawContext) && !that.alphaToCoverage || that.needSceneColor();
+            scope.$outputs.zSkinSSS = disableSkinSSS ? pb.vec4(0) : skinSSS ?? pb.vec4(0);
+        }
     }
 }
 FEATURE_ALPHATEST = MeshMaterial.defineFeature();
@@ -16394,6 +16408,259 @@ const SUBSURFACE_PROFILE_PRESET_RESPONSE = {
     }
 }
 
+/**
+ * Stylized realtime skin material.
+ *
+ * @remarks
+ * This material is designed for the {@link SkinSSS} post effect. It renders a regular lit color,
+ * and when `camera.skinSSS` is enabled it also writes a skin lighting multiplier into the
+ * `SkinSSSTexture` MRT. The post effect blurs that side buffer in screen space to create a soft
+ * character-skin look similar to simple game/anime skin renderers.
+ *
+ * The optional `subsurfaceTexture` uses R as skin mask and G as local softness.
+ *
+ * @public
+ */ class SkinMaterial extends applyMaterialMixins(MeshMaterial, mixinLight, mixinVertexColor, mixinTextureProps('subsurface')) {
+    static FEATURE_VERTEX_NORMAL = this.defineFeature();
+    static FEATURE_VERTEX_TANGENT = this.defineFeature();
+    _shininess;
+    _specularStrength;
+    _diffuseWrap;
+    _diffuseSoftness;
+    _scatterWrap;
+    _scatterStrength;
+    _scatterColor;
+    constructor(){
+        super();
+        this._shininess = 72;
+        this._specularStrength = 0.22;
+        this._diffuseWrap = 0.28;
+        this._diffuseSoftness = 0.45;
+        this._scatterWrap = 0.65;
+        this._scatterStrength = 0.7;
+        this._scatterColor = new Vector4(1, 0.42, 0.28, 1);
+        this.useFeature(SkinMaterial.FEATURE_VERTEX_NORMAL, true);
+    }
+    /** Marker used by the forward render graph to allocate the SkinSSS MRT. */ get skinSSS() {
+        return true;
+    }
+    clone() {
+        const other = new SkinMaterial();
+        other.copyFrom(this);
+        return other;
+    }
+    copyFrom(other) {
+        super.copyFrom(other);
+        this.vertexNormal = other.vertexNormal;
+        this.vertexTangent = other.vertexTangent;
+        this.shininess = other.shininess;
+        this.specularStrength = other.specularStrength;
+        this.diffuseWrap = other.diffuseWrap;
+        this.diffuseSoftness = other.diffuseSoftness;
+        this.scatterWrap = other.scatterWrap;
+        this.scatterStrength = other.scatterStrength;
+        this.scatterColor = other.scatterColor;
+    }
+    /** true if vertex normal attribute presents */ get vertexNormal() {
+        return this.featureUsed(SkinMaterial.FEATURE_VERTEX_NORMAL);
+    }
+    set vertexNormal(val) {
+        this.useFeature(SkinMaterial.FEATURE_VERTEX_NORMAL, !!val);
+    }
+    /** true if vertex tangent attribute presents */ get vertexTangent() {
+        return this.featureUsed(SkinMaterial.FEATURE_VERTEX_TANGENT);
+    }
+    set vertexTangent(val) {
+        this.useFeature(SkinMaterial.FEATURE_VERTEX_TANGENT, !!val);
+    }
+    /** Blinn specular exponent. Higher values produce smaller highlights. */ get shininess() {
+        return this._shininess;
+    }
+    set shininess(val) {
+        const next = Math.max(1, val ?? 1);
+        if (next !== this._shininess) {
+            this._shininess = next;
+            this.uniformChanged();
+        }
+    }
+    /** Direct specular strength. Keep this restrained for soft skin. */ get specularStrength() {
+        return this._specularStrength;
+    }
+    set specularStrength(val) {
+        const next = Math.max(0, val ?? 0);
+        if (next !== this._specularStrength) {
+            this._specularStrength = next;
+            this.uniformChanged();
+        }
+    }
+    /** Wrap amount for visible diffuse lighting. */ get diffuseWrap() {
+        return this._diffuseWrap;
+    }
+    set diffuseWrap(val) {
+        const next = Math.max(0, val ?? 0);
+        if (next !== this._diffuseWrap) {
+            this._diffuseWrap = next;
+            this.uniformChanged();
+        }
+    }
+    /** Blend from hard Lambert lighting to wrapped diffuse lighting. */ get diffuseSoftness() {
+        return this._diffuseSoftness;
+    }
+    set diffuseSoftness(val) {
+        const next = Math.max(0, Math.min(1, val ?? 0));
+        if (next !== this._diffuseSoftness) {
+            this._diffuseSoftness = next;
+            this.uniformChanged();
+        }
+    }
+    /** Wider wrap used only for the post-process scattering source. */ get scatterWrap() {
+        return this._scatterWrap;
+    }
+    set scatterWrap(val) {
+        const next = Math.max(0, val ?? 0);
+        if (next !== this._scatterWrap) {
+            this._scatterWrap = next;
+            this.uniformChanged();
+        }
+    }
+    /** Strength of the multiplier written into the SkinSSS side buffer. */ get scatterStrength() {
+        return this._scatterStrength;
+    }
+    set scatterStrength(val) {
+        const next = Math.max(0, val ?? 0);
+        if (next !== this._scatterStrength) {
+            this._scatterStrength = next;
+            this.uniformChanged();
+        }
+    }
+    /** Warm tint for the blurred skin lighting contribution. */ get scatterColor() {
+        return this._scatterColor;
+    }
+    set scatterColor(val) {
+        if (!val.equalsTo(this._scatterColor)) {
+            this._scatterColor.set(val);
+            this.uniformChanged();
+        }
+    }
+    vertexShader(scope) {
+        super.vertexShader(scope);
+        const pb = scope.$builder;
+        scope.$l.oPos = ShaderHelper.resolveVertexPosition(scope);
+        scope.$outputs.worldPos = pb.mul(ShaderHelper.getWorldMatrix(scope), pb.vec4(scope.oPos, 1)).xyz;
+        ShaderHelper.setClipSpacePosition(scope, pb.mul(ShaderHelper.getViewProjectionMatrix(scope), pb.vec4(scope.$outputs.worldPos, 1)));
+        if (this.vertexNormal) {
+            scope.$l.oNorm = ShaderHelper.resolveVertexNormal(scope);
+            scope.$outputs.wNorm = pb.mul(ShaderHelper.getNormalMatrix(scope), pb.vec4(scope.oNorm, 0)).xyz;
+            if (this.vertexTangent) {
+                scope.$l.oTangent = ShaderHelper.resolveVertexTangent(scope);
+                scope.$outputs.wTangent = pb.mul(ShaderHelper.getNormalMatrix(scope), pb.vec4(scope.oTangent.xyz, 0)).xyz;
+                scope.$outputs.wBinormal = pb.mul(pb.cross(scope.$outputs.wNorm, scope.$outputs.wTangent), scope.oTangent.w);
+            }
+        }
+    }
+    fragmentShader(scope) {
+        super.fragmentShader(scope);
+        const pb = scope.$builder;
+        const that = this;
+        if (this.needFragmentColorInput()) {
+            if (this.drawContext.renderPass.type === RENDER_PASS_TYPE_LIGHT) {
+                scope.zSkinShininess = pb.float().uniform(2);
+                scope.zSkinSpecularStrength = pb.float().uniform(2);
+                scope.zSkinDiffuseWrap = pb.float().uniform(2);
+                scope.zSkinDiffuseSoftness = pb.float().uniform(2);
+                scope.zSkinScatterWrap = pb.float().uniform(2);
+                scope.zSkinScatterStrength = pb.float().uniform(2);
+                scope.zSkinScatterColor = pb.vec4().uniform(2);
+            }
+            scope.$l.albedo = this.calculateAlbedoColor(scope);
+            if (this.vertexColor) {
+                scope.albedo = pb.mul(scope.albedo, this.getVertexColor(scope));
+            }
+            if (this.drawContext.renderPass.type === RENDER_PASS_TYPE_LIGHT) {
+                const baseLightPass = !this.drawContext.lightBlending;
+                scope.$l.normal = this.calculateNormal(scope, scope.$inputs.worldPos, scope.$inputs.wNorm, scope.$inputs.wTangent, scope.$inputs.wBinormal);
+                scope.$l.viewVec = this.calculateViewVector(scope, scope.$inputs.worldPos);
+                scope.$l.roughness = pb.sqrt(pb.div(2, pb.add(scope.zSkinShininess, 2)));
+                scope.$l.skinMask = pb.float(1);
+                scope.$l.skinSoftness = pb.float(0);
+                if (this.subsurfaceTexture) {
+                    scope.$l.subsurfaceTexel = this.sampleSubsurfaceTexture(scope);
+                    scope.skinMask = pb.clamp(scope.subsurfaceTexel.r, 0, 1);
+                    scope.skinSoftness = pb.clamp(scope.subsurfaceTexel.g, 0, 1);
+                }
+                scope.$l.diffuseLighting = pb.vec3(0);
+                scope.$l.scatterLighting = pb.vec3(0);
+                scope.$l.specularLighting = pb.vec3(0);
+                if (this.needCalculateEnvLight() && baseLightPass) {
+                    scope.$l.envDiffuse = this.getEnvLightIrradiance(scope, scope.normal);
+                    scope.diffuseLighting = pb.add(scope.diffuseLighting, scope.envDiffuse);
+                    scope.scatterLighting = pb.add(scope.scatterLighting, pb.mul(scope.envDiffuse, pb.add(0.7, pb.mul(scope.skinSoftness, 0.45))));
+                    scope.$l.reflectVec = this.calculateReflectionVector(scope, scope.normal, scope.viewVec);
+                    scope.specularLighting = pb.add(scope.specularLighting, pb.mul(this.getEnvLightRadiance(scope, scope.reflectVec, scope.roughness), scope.zSkinSpecularStrength));
+                }
+                this.forEachLight(scope, function(type, posRange, dirCutoff, colorIntensity, extra, shadow) {
+                    this.$l.diffuseScale = pb.float(1);
+                    this.$l.specularScale = pb.float(1);
+                    this.$l.sourceRadiusFactor = pb.float(0);
+                    this.$if(pb.equal(type, LIGHT_TYPE_POINT), function() {
+                        this.diffuseScale = extra.x;
+                        this.specularScale = extra.y;
+                        this.sourceRadiusFactor = pb.div(extra.z, pb.max(pb.distance(posRange.xyz, this.$inputs.worldPos), 0.0001));
+                    });
+                    this.$l.lightAtten = that.calculateLightAttenuation(this, type, this.$inputs.worldPos, posRange, dirCutoff);
+                    this.$l.lightDir = that.calculateLightDirection(this, type, this.$inputs.worldPos, posRange, dirCutoff);
+                    this.$l.rawNoL = pb.dot(this.normal, this.lightDir);
+                    this.$l.NoL = pb.clamp(this.rawNoL, 0, 1);
+                    this.$l.NoLWrap = pb.clamp(pb.div(pb.add(this.rawNoL, this.zSkinDiffuseWrap), pb.add(1, this.zSkinDiffuseWrap)), 0, 1);
+                    this.$l.NoLScatter = pb.clamp(pb.div(pb.add(this.rawNoL, this.zSkinScatterWrap), pb.add(1, this.zSkinScatterWrap)), 0, 1);
+                    this.$l.shadowTerm = pb.float(1);
+                    if (shadow) {
+                        this.$if(pb.greaterThan(this.NoLWrap, 0), function() {
+                            this.shadowTerm = that.calculateShadow(this, this.$inputs.worldPos, pb.max(this.NoL, 1e-5));
+                        });
+                    }
+                    this.$l.lightColor = pb.mul(colorIntensity.rgb, colorIntensity.a, this.lightAtten, this.shadowTerm);
+                    this.$l.halfVec = pb.normalize(pb.add(this.viewVec, this.lightDir));
+                    this.$l.NoH = pb.clamp(pb.dot(this.normal, this.halfVec), 0, 1);
+                    this.$l.pointShininess = pb.max(pb.div(this.zSkinShininess, pb.add(1, pb.mul(this.sourceRadiusFactor, 32))), 1);
+                    this.$l.hardDiffuse = pb.mul(this.lightColor, this.NoL, this.diffuseScale, 1 / Math.PI);
+                    this.$l.softDiffuse = pb.mul(this.lightColor, this.NoLWrap, this.diffuseScale, 1 / Math.PI);
+                    this.$l.softness = pb.clamp(pb.add(this.zSkinDiffuseSoftness, pb.mul(this.skinSoftness, 0.35)), 0, 1);
+                    this.diffuseLighting = pb.add(this.diffuseLighting, pb.mix(this.hardDiffuse, this.softDiffuse, this.softness));
+                    this.scatterLighting = pb.add(this.scatterLighting, pb.mul(this.lightColor, this.NoLScatter, pb.add(0.7, pb.mul(this.skinSoftness, 0.55)), this.diffuseScale, 1 / Math.PI));
+                    this.$l.specular = pb.mul(this.lightColor, pb.pow(this.NoH, this.pointShininess), this.zSkinSpecularStrength, this.specularScale, this.NoLWrap);
+                    this.specularLighting = pb.add(this.specularLighting, this.specular);
+                });
+                scope.$l.litColor = pb.add(pb.mul(scope.albedo.rgb, scope.diffuseLighting), scope.specularLighting);
+                scope.$l.scatterMultiplier = pb.add(baseLightPass ? pb.vec3(1) : pb.vec3(0), pb.mul(scope.albedo.rgb, scope.scatterLighting, scope.zSkinScatterColor.rgb, scope.zSkinScatterStrength, pb.add(0.75, pb.mul(scope.skinSoftness, 0.45))));
+                scope.$l.skinSSS = pb.vec4(scope.scatterMultiplier, scope.skinMask);
+                if (this.drawContext.materialFlags & MaterialVaryingFlags.SSR_STORE_ROUGHNESS) {
+                    scope.$l.outRoughness = pb.vec4(pb.mul(scope.albedo.rgb, pb.sub(1, scope.roughness), scope.zSkinSpecularStrength), pb.mul(scope.roughness, ShaderHelper.getCameraRoughnessFactor(scope)));
+                    this.outputFragmentColor(scope, scope.$inputs.worldPos, pb.vec4(scope.litColor, scope.albedo.a), scope.outRoughness, pb.vec4(pb.add(pb.mul(scope.normal, 0.5), pb.vec3(0.5)), 1), undefined, undefined, undefined, undefined, false, scope.skinSSS);
+                } else {
+                    this.outputFragmentColor(scope, scope.$inputs.worldPos, pb.vec4(scope.litColor, scope.albedo.a), undefined, undefined, undefined, undefined, undefined, undefined, false, scope.skinSSS);
+                }
+            } else {
+                this.outputFragmentColor(scope, scope.$inputs.worldPos, scope.albedo);
+            }
+        } else {
+            this.outputFragmentColor(scope, scope.$inputs.worldPos, null);
+        }
+    }
+    applyUniformValues(bindGroup, ctx, pass) {
+        super.applyUniformValues(bindGroup, ctx, pass);
+        if (this.needFragmentColor(ctx) && ctx.renderPass.type === RENDER_PASS_TYPE_LIGHT) {
+            bindGroup.setValue('zSkinShininess', this._shininess);
+            bindGroup.setValue('zSkinSpecularStrength', this._specularStrength);
+            bindGroup.setValue('zSkinDiffuseWrap', this._diffuseWrap);
+            bindGroup.setValue('zSkinDiffuseSoftness', this._diffuseSoftness);
+            bindGroup.setValue('zSkinScatterWrap', this._scatterWrap);
+            bindGroup.setValue('zSkinScatterStrength', this._scatterStrength);
+            bindGroup.setValue('zSkinScatterColor', this._scatterColor);
+        }
+    }
+}
+
 const ggxLut = new Map();
 function getGGXLUT(size) {
     let lut = ggxLut.get(size);
@@ -33134,7 +33401,7 @@ const tmpDrawablePos = new Vector3();
     }
 }
 
-const SURFACE_MRT_FLAGS$1 = MaterialVaryingFlags.SSR_STORE_ROUGHNESS | MaterialVaryingFlags.SSS_STORE_PROFILE | MaterialVaryingFlags.SSS_STORE_DIFFUSE | MaterialVaryingFlags.SSS_STORE_NORMAL | MaterialVaryingFlags.SSS_STORE_TRANSMISSION;
+const SURFACE_MRT_FLAGS$1 = MaterialVaryingFlags.SSR_STORE_ROUGHNESS | MaterialVaryingFlags.SSS_STORE_PROFILE | MaterialVaryingFlags.SSS_STORE_DIFFUSE | MaterialVaryingFlags.SSS_STORE_NORMAL | MaterialVaryingFlags.SSS_STORE_TRANSMISSION | MaterialVaryingFlags.SKIN_SSS_STORE;
 const ADDITIVE_LIGHT_PASS_OMIT_MRT_FLAGS = MaterialVaryingFlags.SSR_STORE_ROUGHNESS | MaterialVaryingFlags.SSS_STORE_PROFILE | MaterialVaryingFlags.SSS_STORE_NORMAL;
 /**
  * Forward render pass
@@ -33186,6 +33453,9 @@ const ADDITIVE_LIGHT_PASS_OMIT_MRT_FLAGS = MaterialVaryingFlags.SSR_STORE_ROUGHN
         if (materialFlags & MaterialVaryingFlags.SSS_STORE_TRANSMISSION) {
             attachments.push(ctx.SSSTransmissionTexture);
         }
+        if (materialFlags & MaterialVaryingFlags.SKIN_SSS_STORE) {
+            attachments.push(ctx.SkinSSSTexture);
+        }
         return attachments.length === 1 ? attachments[0] : attachments;
     }
     /** @internal */ selectTransparentOITShadowLight(ctx, renderQueue) {
@@ -35276,6 +35546,13 @@ const DEFAULT_PROFILING_OPTIONS = {
  *
  * @public
  */ class DevicePoolAllocator {
+    _device;
+    /**
+   * Creates a new instance of the DevicePoolAllocator.
+   * @param device - Optional device instance to use for resource allocation. If not provided, the global device will be used.
+   */ constructor(device){
+        this._device = device ?? null;
+    }
     /**
    * Allocate a transient texture from the device pool.
    *
@@ -35283,7 +35560,7 @@ const DEFAULT_PROFILING_OPTIONS = {
    * @param size - Resolved pixel dimensions.
    * @returns A pooled Texture2D instance.
    */ allocate(desc, size) {
-        const device = getDevice();
+        const device = this._device ?? getDevice();
         const mipmapping = (desc.mipLevels ?? 1) > 1;
         const texture = device.pool.fetchTemporalTexture2D(false, desc.format, size.width, size.height, mipmapping);
         if (desc.mipLevels && texture.mipLevelCount < desc.mipLevels) {
@@ -35297,7 +35574,7 @@ const DEFAULT_PROFILING_OPTIONS = {
    *
    * @param texture - The texture to release.
    */ release(texture) {
-        const device = getDevice();
+        const device = this._device ?? getDevice();
         device.pool.releaseTexture(texture);
     }
     /**
@@ -35305,7 +35582,7 @@ const DEFAULT_PROFILING_OPTIONS = {
    *
    * @param texture - The texture to retain.
    */ retain(texture) {
-        const device = getDevice();
+        const device = this._device ?? getDevice();
         device.pool.retainTexture(texture);
     }
     /**
@@ -35314,7 +35591,7 @@ const DEFAULT_PROFILING_OPTIONS = {
    * @param desc - Framebuffer descriptor from the render graph pass.
    * @returns A pooled FrameBuffer instance.
    */ allocateFramebuffer(desc) {
-        const device = getDevice();
+        const device = this._device ?? getDevice();
         const colors = Array.isArray(desc.colorAttachments) ? desc.colorAttachments : desc.colorAttachments ? [
             desc.colorAttachments
         ] : [];
@@ -35326,7 +35603,7 @@ const DEFAULT_PROFILING_OPTIONS = {
    *
    * @param framebuffer - The framebuffer to release.
    */ releaseFramebuffer(framebuffer) {
-        const device = getDevice();
+        const device = this._device ?? getDevice();
         device.pool.releaseFrameBuffer(framebuffer);
     }
 }
@@ -35754,6 +36031,9 @@ const DEFAULT_PROFILING_OPTIONS = {
         if (ctx.materialFlags & MaterialVaryingFlags.SSS_STORE_TRANSMISSION) {
             attachments.push(ctx.SSSTransmissionTexture);
         }
+        if (ctx.materialFlags & MaterialVaryingFlags.SKIN_SSS_STORE) {
+            attachments.push(ctx.SkinSSSTexture);
+        }
         const tmpFramebuffer = device.pool.fetchTemporalFramebuffer(true, w, h, attachments.length === 1 ? attachments[0] : attachments, depth ?? ctx.depthFormat);
         device.setFramebuffer(tmpFramebuffer);
     }
@@ -38311,10 +38591,8 @@ const FLT_MAX = 32767;
     }
     apply(ctx, inputColorTexture, sceneDepthTexture, srgbOutput) {
         const historyManager = ctx.camera.getHistoryResourceManager();
-        const useGraphHistory = !!historyManager?.frameActive;
-        const data = useGraphHistory ? null : ctx.camera.getHistoryData();
-        const prevColorTex = useGraphHistory ? historyManager.tryGetPrevious(RGHistoryResources.TAA_COLOR) : data.prevColorTex;
-        const prevMotionVectorTex = useGraphHistory ? historyManager.tryGetPrevious(RGHistoryResources.TAA_MOTION_VECTOR) : data.prevMotionVectorTex;
+        const prevColorTex = historyManager.tryGetPrevious(RGHistoryResources.TAA_COLOR);
+        const prevMotionVectorTex = historyManager.tryGetPrevious(RGHistoryResources.TAA_MOTION_VECTOR);
         if (!prevColorTex || !prevMotionVectorTex || prevColorTex.width !== inputColorTexture.width || prevColorTex.height !== inputColorTexture.height) {
             this.passThrough(ctx, inputColorTexture, srgbOutput);
         } else {
@@ -38339,42 +38617,6 @@ const FLT_MAX = 32767;
             ctx.device.setBindGroup(0, this._bindGroup);
             this.drawFullscreenQuad();
         }
-        const currentColorTex = ctx.device.getFramebuffer().getColorAttachments()[0];
-        if (useGraphHistory) {
-            const colorSize = {
-                width: currentColorTex.width,
-                height: currentColorTex.height
-            };
-            historyManager.queueRetainedCommit(RGHistoryResources.TAA_COLOR, {
-                format: currentColorTex.format,
-                sizeMode: 'absolute',
-                width: currentColorTex.width,
-                height: currentColorTex.height
-            }, colorSize, currentColorTex);
-            if (ctx.motionVectorTexture) {
-                const motionVectorSize = {
-                    width: ctx.motionVectorTexture.width,
-                    height: ctx.motionVectorTexture.height
-                };
-                historyManager.queueRetainedCommit(RGHistoryResources.TAA_MOTION_VECTOR, {
-                    format: ctx.motionVectorTexture.format,
-                    sizeMode: 'absolute',
-                    width: ctx.motionVectorTexture.width,
-                    height: ctx.motionVectorTexture.height
-                }, motionVectorSize, ctx.motionVectorTexture);
-            }
-        } else {
-            if (data.prevColorTex) {
-                ctx.device.pool.releaseTexture(data.prevColorTex);
-            }
-            ctx.device.pool.retainTexture(currentColorTex);
-            data.prevColorTex = currentColorTex;
-            if (data.prevMotionVectorTex) {
-                ctx.device.pool.releaseTexture(data.prevMotionVectorTex);
-            }
-            ctx.device.pool.retainTexture(ctx.motionVectorTexture);
-            data.prevMotionVectorTex = ctx.motionVectorTexture;
-        }
     }
     requireLinearDepthTexture(_ctx) {
         return true;
@@ -39398,11 +39640,9 @@ float3 hi_z_trace(float3 p, float3 v, in uint camera, out uint iterations) {
             this.blurPass(ctx, blitterV, intersectTex, 2, blurSizeScale, kernelRadius, stdDev, depthCutoff, pingpongFramebuffer[1], pingpongFramebuffer[0]);
         }
         const historyManager = ctx.camera.getHistoryResourceManager();
-        const useGraphHistory = !!historyManager?.frameActive;
-        const history = useGraphHistory ? null : ctx.camera.getHistoryData();
         let reflectanceTex = pingpongFramebuffer[0].getColorAttachments()[0];
-        const prevSSRReflectTex = useGraphHistory ? historyManager.tryGetPrevious(RGHistoryResources.SSR_REFLECT) : history.prevSSRReflectTex;
-        const prevSSRMotionVectorTex = useGraphHistory ? historyManager.tryGetPrevious(RGHistoryResources.SSR_MOTION_VECTOR) : history.prevSSRMotionVectorTex;
+        const prevSSRReflectTex = historyManager.tryGetPrevious(RGHistoryResources.SSR_REFLECT);
+        const prevSSRMotionVectorTex = historyManager.tryGetPrevious(RGHistoryResources.SSR_MOTION_VECTOR);
         const canTemporal = ctx.camera.ssrTemporal && !!ctx.motionVectorTexture && !!prevSSRReflectTex && !!prevSSRMotionVectorTex && prevSSRReflectTex.width === reflectanceTex.width && prevSSRReflectTex.height === reflectanceTex.height;
         if (canTemporal) {
             this.temporal(ctx, reflectanceTex, sceneDepthTexture, prevSSRReflectTex, prevSSRMotionVectorTex, pingpongFramebuffer[1]);
@@ -39410,51 +39650,29 @@ float3 hi_z_trace(float3 p, float3 v, in uint camera, out uint iterations) {
         }
         device.popDeviceStates();
         this.combine(ctx, inputColorTexture, reflectanceTex, srgbOutput);
-        if (useGraphHistory) {
-            if (ctx.camera.ssrTemporal) {
-                const reflectanceSize = {
-                    width: reflectanceTex.width,
-                    height: reflectanceTex.height
-                };
-                historyManager.queueRetainedCommit(RGHistoryResources.SSR_REFLECT, {
-                    format: reflectanceTex.format,
-                    sizeMode: 'absolute',
-                    width: reflectanceTex.width,
-                    height: reflectanceTex.height
-                }, reflectanceSize, reflectanceTex);
-            }
-            if (ctx.camera.ssrTemporal && ctx.motionVectorTexture) {
-                const motionVectorSize = {
-                    width: ctx.motionVectorTexture.width,
-                    height: ctx.motionVectorTexture.height
-                };
-                historyManager.queueRetainedCommit(RGHistoryResources.SSR_MOTION_VECTOR, {
-                    format: ctx.motionVectorTexture.format,
-                    sizeMode: 'absolute',
-                    width: ctx.motionVectorTexture.width,
-                    height: ctx.motionVectorTexture.height
-                }, motionVectorSize, ctx.motionVectorTexture);
-            }
-        } else {
-            if (history.prevSSRReflectTex) {
-                device.pool.releaseTexture(history.prevSSRReflectTex);
-                history.prevSSRReflectTex = null;
-            }
-            if (history.prevSSRMotionVectorTex) {
-                device.pool.releaseTexture(history.prevSSRMotionVectorTex);
-                history.prevSSRMotionVectorTex = null;
-            }
-            if (ctx.camera.ssrTemporal) {
-                device.pool.retainTexture(reflectanceTex);
-                history.prevSSRReflectTex = reflectanceTex;
-            }
-            if (ctx.camera.ssrTemporal && ctx.motionVectorTexture) {
-                if (history.prevSSRMotionVectorTex) {
-                    device.pool.releaseTexture(history.prevSSRMotionVectorTex);
-                }
-                device.pool.retainTexture(ctx.motionVectorTexture);
-                history.prevSSRMotionVectorTex = ctx.motionVectorTexture;
-            }
+        if (ctx.camera.ssrTemporal) {
+            const reflectanceSize = {
+                width: reflectanceTex.width,
+                height: reflectanceTex.height
+            };
+            historyManager.queueRetainedCommit(RGHistoryResources.SSR_REFLECT, {
+                format: reflectanceTex.format,
+                sizeMode: 'absolute',
+                width: reflectanceTex.width,
+                height: reflectanceTex.height
+            }, reflectanceSize, reflectanceTex);
+        }
+        if (ctx.camera.ssrTemporal && ctx.motionVectorTexture) {
+            const motionVectorSize = {
+                width: ctx.motionVectorTexture.width,
+                height: ctx.motionVectorTexture.height
+            };
+            historyManager.queueRetainedCommit(RGHistoryResources.SSR_MOTION_VECTOR, {
+                format: ctx.motionVectorTexture.format,
+                sizeMode: 'absolute',
+                width: ctx.motionVectorTexture.width,
+                height: ctx.motionVectorTexture.height
+            }, motionVectorSize, ctx.motionVectorTexture);
         }
         device.pool.releaseFrameBuffer(intersectFramebuffer);
         device.pool.releaseFrameBuffer(pingpongFramebuffer[0]);
@@ -40986,6 +41204,174 @@ float3 hi_z_trace(float3 p, float3 v, in uint camera, out uint iterations) {
     }
 }
 
+/**
+ * Stylized screen-space skin scattering pass.
+ *
+ * @remarks
+ * This is intentionally separate from the profile-based {@link SSS} pass. It follows the simpler
+ * depth-aware blur used by many character renderers: a skin material writes a lighting multiplier
+ * into a side buffer, then this pass performs a fixed 9x9 depth-aware blur and composites it back
+ * over the opaque color.
+ *
+ * @public
+ */ class SkinSSS extends AbstractPostEffect {
+    static _program = null;
+    _bindGroup;
+    _strength;
+    _opacity;
+    _sampleStep;
+    _depthScale;
+    _colorBoost;
+    constructor(){
+        super();
+        this._layer = PostEffectLayer.opaque;
+        this._bindGroup = null;
+        this._strength = 1;
+        this._opacity = 0.18;
+        this._sampleStep = 2;
+        this._depthScale = 80;
+        this._colorBoost = 1;
+    }
+    /** Final blend strength. */ get strength() {
+        return this._strength;
+    }
+    set strength(val) {
+        this._strength = Math.max(0, val ?? 0);
+    }
+    /** Bias subtracted from the blurred skin mask before compositing. */ get opacity() {
+        return this._opacity;
+    }
+    set opacity(val) {
+        this._opacity = Math.max(0, Math.min(1, val ?? 0));
+    }
+    /** Pixel spacing between blur taps. The reference shader uses 2. */ get sampleStep() {
+        return this._sampleStep;
+    }
+    set sampleStep(val) {
+        this._sampleStep = Math.max(0.25, val ?? 0.25);
+    }
+    /** Depth rejection scale. The reference shader uses 80. */ get depthScale() {
+        return this._depthScale;
+    }
+    set depthScale(val) {
+        this._depthScale = Math.max(0, val ?? 0);
+    }
+    /** Multiplier applied to the blurred skin lighting multiplier before compositing. */ get colorBoost() {
+        return this._colorBoost;
+    }
+    set colorBoost(val) {
+        this._colorBoost = Math.max(0, val ?? 0);
+    }
+    requireLinearDepthTexture() {
+        return true;
+    }
+    apply(ctx, inputColorTexture, sceneDepthTexture, srgbOutput) {
+        if (!ctx.SkinSSSTexture || this._strength <= 0) {
+            this.passThrough(ctx, inputColorTexture, srgbOutput);
+            return;
+        }
+        const device = ctx.device;
+        let program = SkinSSS._program;
+        if (!program) {
+            program = this.createProgram(ctx);
+            SkinSSS._program = program;
+        }
+        if (!this._bindGroup) {
+            this._bindGroup = device.createBindGroup(program.bindGroupLayouts[0]);
+        }
+        this._bindGroup.setTexture('colorTex', inputColorTexture, fetchSampler('clamp_linear'));
+        this._bindGroup.setTexture('skinTex', ctx.SkinSSSTexture, fetchSampler('clamp_linear'));
+        this._bindGroup.setTexture('depthTex', sceneDepthTexture, fetchSampler('clamp_nearest_nomip'));
+        this._bindGroup.setValue('cameraNearFar', new Vector2(ctx.camera.getNearPlane(), ctx.camera.getFarPlane()));
+        this._bindGroup.setValue('targetSize', new Vector4(inputColorTexture.width, inputColorTexture.height, inputColorTexture.width, inputColorTexture.height));
+        this._bindGroup.setValue('strength', this._strength);
+        this._bindGroup.setValue('opacity', this._opacity);
+        this._bindGroup.setValue('sampleStep', this._sampleStep);
+        this._bindGroup.setValue('depthScale', this._depthScale);
+        this._bindGroup.setValue('colorBoost', this._colorBoost);
+        this._bindGroup.setValue('flip', this.needFlip(device) ? 1 : 0);
+        this._bindGroup.setValue('srgbOut', srgbOutput ? 1 : 0);
+        device.setProgram(program);
+        device.setBindGroup(0, this._bindGroup);
+        this.drawFullscreenQuad();
+    }
+    createProgram(ctx) {
+        const program = ctx.device.buildRenderProgram({
+            vertex (pb) {
+                this.flip = pb.int().uniform(0);
+                this.$inputs.pos = pb.vec2().attrib('position');
+                this.$outputs.uv = pb.vec2();
+                pb.main(function() {
+                    this.$builtins.position = pb.vec4(this.$inputs.pos, 1, 1);
+                    this.$outputs.uv = pb.add(pb.mul(this.$inputs.pos.xy, 0.5), pb.vec2(0.5));
+                    this.$if(pb.notEqual(this.flip, 0), function() {
+                        this.$builtins.position.y = pb.neg(this.$builtins.position.y);
+                    });
+                });
+            },
+            fragment (pb) {
+                this.colorTex = pb.tex2D().uniform(0);
+                this.skinTex = pb.tex2D().uniform(0);
+                this.depthTex = pb.tex2D().uniform(0);
+                this.cameraNearFar = pb.vec2().uniform(0);
+                this.targetSize = pb.vec4().uniform(0);
+                this.strength = pb.float().uniform(0);
+                this.opacity = pb.float().uniform(0);
+                this.sampleStep = pb.float().uniform(0);
+                this.depthScale = pb.float().uniform(0);
+                this.colorBoost = pb.float().uniform(0);
+                this.srgbOut = pb.int().uniform(0);
+                this.$outputs.outColor = pb.vec4();
+                pb.func('readDepth01', [
+                    pb.vec2('uv')
+                ], function() {
+                    this.$return(ShaderHelper.sampleLinearDepth(this, this.depthTex, this.uv, 0));
+                });
+                pb.main(function() {
+                    this.$l.uv = this.$inputs.uv;
+                    this.$l.baseColor = pb.textureSampleLevel(this.colorTex, this.uv, 0);
+                    this.$l.result = this.baseColor.rgb;
+                    this.$l.centerDepth01 = this.readDepth01(this.uv);
+                    this.$if(pb.lessThan(this.centerDepth01, 1), function() {
+                        this.$l.centerDepth = pb.max(pb.mul(this.centerDepth01, this.cameraNearFar.y), 1e-4);
+                        this.$l.sum = pb.vec4(0);
+                        this.$l.weightSum = pb.float(0);
+                        this.$for(pb.int('y'), -4, 5, function() {
+                            this.$for(pb.int('x'), -4, 5, function() {
+                                this.$l.offsetPx = pb.mul(pb.vec2(pb.float(this.x), pb.float(this.y)), this.sampleStep);
+                                this.$l.sampleUV = pb.clamp(pb.add(this.uv, pb.div(this.offsetPx, this.targetSize.xy)), pb.vec2(0), pb.vec2(1));
+                                this.$l.skinSample = pb.textureSampleLevel(this.skinTex, this.sampleUV, 0);
+                                this.$if(pb.lessThanEqual(this.skinSample.a, 1e-4), function() {
+                                    this.skinSample = pb.vec4(0, 0, 0, this.opacity);
+                                });
+                                this.$l.sampleDepth01 = this.readDepth01(this.sampleUV);
+                                this.$l.sampleDepth = pb.max(pb.mul(this.sampleDepth01, this.cameraNearFar.y), 1e-4);
+                                this.$l.depthWeight = pb.clamp(pb.sub(1, pb.div(pb.mul(pb.abs(pb.sub(this.centerDepth, this.sampleDepth)), this.depthScale), this.centerDepth)), 0, 1);
+                                this.depthWeight = pb.mul(this.depthWeight, this.depthWeight, pb.sub(3, pb.mul(this.depthWeight, 2)));
+                                this.sum = pb.add(this.sum, pb.mul(this.skinSample, this.depthWeight));
+                                this.weightSum = pb.add(this.weightSum, this.depthWeight);
+                            });
+                        });
+                        this.$if(pb.greaterThan(this.weightSum, 1e-4), function() {
+                            this.$l.blurredSkin = pb.div(this.sum, this.weightSum);
+                            this.$l.alphaDelta = pb.sub(this.blurredSkin.a, this.opacity);
+                            this.$l.referenceLit = pb.mul(this.baseColor.rgb, pb.add(pb.vec3(pb.sub(1, this.alphaDelta)), pb.mul(this.blurredSkin.rgb, pb.max(pb.sub(1, this.opacity), 0), this.colorBoost)));
+                            this.result = pb.add(this.baseColor.rgb, pb.mul(pb.sub(this.referenceLit, this.baseColor.rgb), this.strength));
+                        });
+                    });
+                    this.$if(pb.equal(this.srgbOut, 0), function() {
+                        this.$outputs.outColor = pb.vec4(this.result, this.baseColor.a);
+                    }).$else(function() {
+                        this.$outputs.outColor = pb.vec4(linearToGamma(this, this.result), this.baseColor.a);
+                    });
+                });
+            }
+        });
+        program.name = '@SkinSSS';
+        return program;
+    }
+}
+
 /**
  * The tonemap post effect
  * @public
@@ -43274,6 +43660,13 @@ const SSS_QUALITY_PRESET_SETTINGS = {
     /** @internal SSS multi-scatter energy compensation. */ _sssMultiScatter;
     /** @internal Cached runtime SSS settings after applying the quality preset. */ _sssResolvedSettings;
     /** @internal SSS debug visualization mode. */ _sssDebugView;
+    /** @internal Skin SSS enable flag (via post effect). */ _skinSSS;
+    /** @internal Skin SSS post effect reference. */ _postEffectSkinSSS;
+    /** @internal Skin SSS final blend strength. */ _skinSSSStrength;
+    /** @internal Skin SSS mask opacity bias. */ _skinSSSOpacity;
+    /** @internal Skin SSS blur tap spacing in pixels. */ _skinSSSSampleStep;
+    /** @internal Skin SSS depth rejection scale. */ _skinSSSDepthScale;
+    /** @internal Skin SSS blurred multiplier boost. */ _skinSSSColorBoost;
     /** @internal SSAO enable flag (via post effect). */ _SSAO;
     /** @internal SSAO post effect reference. */ _postEffectSSAO;
     /** @internal SSAO scale (sampling radius multiplier). */ _SSAOScale;
@@ -43390,6 +43783,13 @@ const SSS_QUALITY_PRESET_SETTINGS = {
         };
         this.updateSSSResolvedSettings();
         this._sssDebugView = 'none';
+        this._skinSSS = false;
+        this._postEffectSkinSSS = new DRef();
+        this._skinSSSStrength = 1;
+        this._skinSSSOpacity = 0.18;
+        this._skinSSSSampleStep = 2;
+        this._skinSSSDepthScale = 80;
+        this._skinSSSColorBoost = 1;
         this._SSAO = false;
         this._postEffectSSAO = new DRef();
         this._SSAOScale = 10;
@@ -43842,6 +44242,57 @@ const SSS_QUALITY_PRESET_SETTINGS = {
     set sssDebugView(val) {
         this._sssDebugView = val ?? 'none';
     }
+    /** Gets whether the dedicated Skin SSS post effect is enabled. */ get skinSSS() {
+        return this._postEffectSkinSSS.get().enabled;
+    }
+    set skinSSS(val) {
+        this._postEffectSkinSSS.get().enabled = !!val;
+    }
+    /** Final blend strength for the dedicated Skin SSS post effect. */ get skinSSSStrength() {
+        return this._skinSSSStrength;
+    }
+    set skinSSSStrength(val) {
+        this._skinSSSStrength = Math.max(0, val ?? 0);
+        if (this._postEffectSkinSSS.get()) {
+            this._postEffectSkinSSS.get().strength = this._skinSSSStrength;
+        }
+    }
+    /** Bias subtracted from the blurred skin mask before compositing. */ get skinSSSOpacity() {
+        return this._skinSSSOpacity;
+    }
+    set skinSSSOpacity(val) {
+        this._skinSSSOpacity = Math.max(0, Math.min(1, val ?? 0));
+        if (this._postEffectSkinSSS.get()) {
+            this._postEffectSkinSSS.get().opacity = this._skinSSSOpacity;
+        }
+    }
+    /** Pixel spacing between blur taps. The reference shader uses 2. */ get skinSSSSampleStep() {
+        return this._skinSSSSampleStep;
+    }
+    set skinSSSSampleStep(val) {
+        this._skinSSSSampleStep = Math.max(0.25, val ?? 0.25);
+        if (this._postEffectSkinSSS.get()) {
+            this._postEffectSkinSSS.get().sampleStep = this._skinSSSSampleStep;
+        }
+    }
+    /** Depth rejection scale. The reference shader uses 80. */ get skinSSSDepthScale() {
+        return this._skinSSSDepthScale;
+    }
+    set skinSSSDepthScale(val) {
+        this._skinSSSDepthScale = Math.max(0, val ?? 0);
+        if (this._postEffectSkinSSS.get()) {
+            this._postEffectSkinSSS.get().depthScale = this._skinSSSDepthScale;
+        }
+    }
+    /** Multiplier applied to the blurred skin lighting multiplier before compositing. */ get skinSSSColorBoost() {
+        return this._skinSSSColorBoost;
+    }
+    set skinSSSColorBoost(val) {
+        this._skinSSSColorBoost = Math.max(0, val ?? 0);
+        if (this._postEffectSkinSSS.get()) {
+            this._postEffectSkinSSS.get().colorBoost = this._skinSSSColorBoost;
+        }
+    }
     /** @internal */ get ssrParams() {
         return this._ssrParams;
     }
@@ -44254,6 +44705,11 @@ const SSS_QUALITY_PRESET_SETTINGS = {
             }
             Camera._historyData.delete(this);
         }
+        const historyResourceManager = Camera._historyResourceManager.get(this);
+        if (historyResourceManager) {
+            historyResourceManager.dispose();
+            Camera._historyResourceManager.delete(this);
+        }
         this._prevVPMatrix = null;
         this._prevPosition = null;
         this._prevJitteredVPMatrix = null;
@@ -44273,6 +44729,17 @@ const SSS_QUALITY_PRESET_SETTINGS = {
             this._postEffectSSS.set(sss);
             this._compositor.appendPostEffect(sss);
         }
+        if (!this._postEffectSkinSSS.get()) {
+            const skinSSS = new SkinSSS();
+            skinSSS.enabled = false;
+            skinSSS.strength = this._skinSSSStrength;
+            skinSSS.opacity = this._skinSSSOpacity;
+            skinSSS.sampleStep = this._skinSSSSampleStep;
+            skinSSS.depthScale = this._skinSSSDepthScale;
+            skinSSS.colorBoost = this._skinSSSColorBoost;
+            this._postEffectSkinSSS.set(skinSSS);
+            this._compositor.appendPostEffect(skinSSS);
+        }
         if (!this._postEffectSSAO.get()) {
             const ssao = new SAO();
             ssao.enabled = false;
@@ -44468,6 +44935,10 @@ const SSS_QUALITY_PRESET_SETTINGS = {
    *
    * @internal
    */ setHistoryResourceManager(manager) {
+        const current = Camera._historyResourceManager.get(this);
+        if (current && current !== manager) {
+            current.dispose();
+        }
         Camera._historyResourceManager.set(this, manager);
     }
     /** @internal */ setController(controller) {
@@ -44512,6 +44983,7 @@ const SSS_QUALITY_PRESET_SETTINGS = {
         this._postEffectMotionBlur.dispose();
         this._postEffectSSAO.dispose();
         this._postEffectSSS.dispose();
+        this._postEffectSkinSSS.dispose();
         this._postEffectSSR.dispose();
         this._postEffectTAA.dispose();
         this._postEffectTonemap.dispose();
@@ -44766,7 +45238,7 @@ const _clusters = [];
 const _devicePoolAllocator = new DevicePoolAllocator();
 let _backDepthColorState = null;
 let _frontDepthColorState = null;
-const SURFACE_MRT_FLAGS = MaterialVaryingFlags.SSR_STORE_ROUGHNESS | MaterialVaryingFlags.SSS_STORE_PROFILE | MaterialVaryingFlags.SSS_STORE_DIFFUSE | MaterialVaryingFlags.SSS_STORE_NORMAL | MaterialVaryingFlags.SSS_STORE_TRANSMISSION;
+const SURFACE_MRT_FLAGS = MaterialVaryingFlags.SSR_STORE_ROUGHNESS | MaterialVaryingFlags.SSS_STORE_PROFILE | MaterialVaryingFlags.SSS_STORE_DIFFUSE | MaterialVaryingFlags.SSS_STORE_NORMAL | MaterialVaryingFlags.SSS_STORE_TRANSMISSION | MaterialVaryingFlags.SKIN_SSS_STORE;
 function getClusteredLight() {
     return _clusters.length > 0 ? _clusters.pop() : new ClusteredLight();
 }
@@ -44779,6 +45251,9 @@ function getCoreMaterial(material) {
 function hasSSSMaterialCore(material) {
     return !!getCoreMaterial(material)?.subsurfaceProfile;
 }
+function hasSkinSSSMaterialCore(material) {
+    return !!getCoreMaterial(material)?.skinSSS;
+}
 function renderQueueHasActiveSSS(renderQueue) {
     const itemList = renderQueue.itemList;
     if (!itemList) {
@@ -44797,6 +45272,24 @@ function renderQueueHasActiveSSS(renderQueue) {
     }
     return false;
 }
+function renderQueueHasActiveSkinSSS(renderQueue) {
+    const itemList = renderQueue.itemList;
+    if (!itemList) {
+        return false;
+    }
+    const lists = [
+        ...itemList.opaque.lit,
+        ...itemList.opaque.unlit
+    ];
+    for (const list of lists){
+        for (const material of list.materialList){
+            if (hasSkinSSSMaterialCore(material)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
 function filterActualSSSItemList(items) {
     return items.filter((item)=>hasSSSMaterialCore(item.drawable.getMaterial?.()));
 }
@@ -44918,6 +45411,9 @@ function getLightPassColorAttachments(ctx, colorAttachment) {
     if (ctx.materialFlags & MaterialVaryingFlags.SSS_STORE_TRANSMISSION) {
         attachments.push(ctx.SSSTransmissionTexture);
     }
+    if (ctx.materialFlags & MaterialVaryingFlags.SKIN_SSS_STORE) {
+        attachments.push(ctx.SkinSSSTexture);
+    }
     return attachments.length === 1 ? attachments[0] : attachments;
 }
 /**
@@ -44926,6 +45422,7 @@ function getLightPassColorAttachments(ctx, colorAttachment) {
  */ function deriveForwardPlusOptions(scene, camera, deviceType, renderQueue) {
     const ssr = camera.SSR && scene.env.light.envLight && scene.env.light.envLight.hasRadiance();
     const sss = camera.SSS && renderQueueHasActiveSSS(renderQueue);
+    const skinSSS = camera.skinSSS && renderQueueHasActiveSkinSSS(renderQueue);
     const needSceneColor = renderQueue.needSceneColor();
     const needSceneColorWithDepth = renderQueue.needSceneColorWithDepth();
     return {
@@ -44938,7 +45435,8 @@ function getLightPassColorAttachments(ctx, colorAttachment) {
         needSceneColor,
         needSceneColorWithDepth,
         needsTransmissionDepthForSSR: !!ssr && needSceneColor && !needSceneColorWithDepth,
-        sss: !!sss
+        sss: !!sss,
+        skinSSS: !!skinSSS
     };
 }
 // ─── Forward+ Graph Builder ─────────────────────────────────────────
@@ -44962,6 +45460,7 @@ function getLightPassColorAttachments(ctx, colorAttachment) {
 function buildForwardPlusGraphInternal(graph, ctx, renderQueue, options) {
     const backbuffer = graph.importTexture('backbuffer');
     ctx.SSS = !!options.sss;
+    ctx.SkinSSSTexture = null;
     // Shared mutable frame state
     const frame = {
         ctx,
@@ -45081,6 +45580,7 @@ function buildForwardPlusGraphInternal(graph, ctx, renderQueue, options) {
     const depthHandle = depthPassResult.depthHandle;
     const motionVectorHandle = depthPassResult.motionVectorHandle;
     const renderDepthAttachment = depthPassResult.graphDepthAttachmentHandle ?? depthPassResult.externalDepthAttachment ?? null;
+    const useFinalFramebufferAsIntermediate = !!depthPassResult.externalDepthAttachment && depthPassResult.externalDepthAttachment === ctx.finalFramebuffer?.getDepthAttachment();
     let preLightTransmissionDepthToken;
     if (options.needsTransmissionDepthForSSR) {
         preLightTransmissionDepthToken = graph.addPass('TransmissionDepthForSSR', (builder)=>{
@@ -45267,7 +45767,8 @@ function buildForwardPlusGraphInternal(graph, ctx, renderQueue, options) {
         if (writeSSSDiffuse && writeSSSTransmission && includeSSRSurfaceMRT && getSSSLightingTextureFormat(ctx, 2, includeSSRSurfaceMRT) !== ctx.colorFormat) {
             writeSSSTransmission = false;
         }
-        const sssLightingAttachmentCount = (writeSSSDiffuse ? 1 : 0) + (writeSSSTransmission ? 1 : 0);
+        const writeSkinSSS = options.skinSSS;
+        const sssLightingAttachmentCount = (writeSSSDiffuse ? 1 : 0) + (writeSSSTransmission ? 1 : 0) + (writeSkinSSS ? 1 : 0);
         const sssLightingFormat = getSSSLightingTextureFormat(ctx, sssLightingAttachmentCount, includeSSRSurfaceMRT);
         const sssDiffuseHandle = writeSSSDiffuse ? builder.createTexture({
             format: sssLightingFormat,
@@ -45277,7 +45778,10 @@ function buildForwardPlusGraphInternal(graph, ctx, renderQueue, options) {
             format: sssLightingFormat,
             label: 'sssTransmission'
         }) : undefined;
-        const useFinalFramebufferAsIntermediate = !!depthPassResult.externalDepthAttachment && depthPassResult.externalDepthAttachment === ctx.finalFramebuffer?.getDepthAttachment();
+        const skinSSSHandle = writeSkinSSS ? builder.createTexture({
+            format: sssLightingFormat,
+            label: 'skinSSS'
+        }) : undefined;
         const sceneColorFramebufferHandle = useFinalFramebufferAsIntermediate ? undefined : builder.createFramebuffer({
             label: 'SceneColorFramebuffer',
             width: ctx.renderWidth,
@@ -45308,6 +45812,7 @@ function buildForwardPlusGraphInternal(graph, ctx, renderQueue, options) {
             }
             ctx.SSSDiffuseTexture = sssDiffuseHandle ? rgCtx.getTexture(sssDiffuseHandle) : null;
             ctx.SSSTransmissionTexture = sssTransmissionHandle ? rgCtx.getTexture(sssTransmissionHandle) : null;
+            ctx.SkinSSSTexture = skinSSSHandle ? rgCtx.getTexture(skinSSSHandle) : null;
             const renderLightPass = ()=>renderMainLightPass(frame, sceneColorTex, sceneColorCopyTex, rgCtx, sceneColorFramebufferHandle, sceneColorCopyFramebufferHandle);
             if (historyManager && lightHistoryReadBindings.length > 0) {
                 historyManager.beginReadScope(lightHistoryReadBindings.map((binding)=>({
@@ -45364,19 +45869,24 @@ function buildForwardPlusGraphInternal(graph, ctx, renderQueue, options) {
             builder.read(binding.handle);
         }
         const outputBackbuffer = builder.write(backbuffer);
+        const taaHistoryColorHandle = useFinalFramebufferAsIntermediate ? outputBackbuffer : sceneColorHandle;
         builder.setExecute((rgCtx)=>{
+            const renderAndCommitComposite = ()=>{
+                renderComposite(frame);
+                queueTAAHistoryCommit(frame, rgCtx, historyManager, taaHistoryColorHandle, motionVectorHandle);
+            };
             if (historyManager && compositeHistoryReadBindings.length > 0) {
                 historyManager.beginReadScope(compositeHistoryReadBindings.map((binding)=>({
                         name: binding.name,
                         texture: rgCtx.getTexture(binding.handle)
                     })));
                 try {
-                    renderComposite(frame);
+                    renderAndCommitComposite();
                 } finally{
                     historyManager.endReadScope();
                 }
             } else {
-                renderComposite(frame);
+                renderAndCommitComposite();
             }
         });
         return outputBackbuffer;
@@ -45435,7 +45945,7 @@ function renderForwardSSSProfile(frame, profileFramebuffer, profileTexture, para
         ctx.SSRNormalTexture = normalTexture;
         ctx.compositor = null;
         ctx.camera.commandBufferReuse = false;
-        ctx.materialFlags = ctx.materialFlags & ~(MaterialVaryingFlags.SSR_STORE_ROUGHNESS | MaterialVaryingFlags.SSS_STORE_PROFILE | MaterialVaryingFlags.SSS_STORE_NORMAL | MaterialVaryingFlags.SSS_STORE_DIFFUSE | MaterialVaryingFlags.SSS_STORE_TRANSMISSION) | profileFlags;
+        ctx.materialFlags = ctx.materialFlags & ~(MaterialVaryingFlags.SSR_STORE_ROUGHNESS | MaterialVaryingFlags.SSS_STORE_PROFILE | MaterialVaryingFlags.SSS_STORE_NORMAL | MaterialVaryingFlags.SSS_STORE_DIFFUSE | MaterialVaryingFlags.SSS_STORE_TRANSMISSION | MaterialVaryingFlags.SKIN_SSS_STORE) | profileFlags;
         _scenePass.transmission = false;
         _scenePass.renderOpaque = true;
         _scenePass.renderTransparent = false;
@@ -45665,7 +46175,7 @@ function blitToCurrentColorAttachment(ctx, source) {
     const device = ctx.device;
     // Use RenderGraph-allocated scene color texture
     const depthTex = frame.depthFramebuffer?.getDepthAttachment();
-    ctx.materialFlags &= ~(MaterialVaryingFlags.SSR_STORE_ROUGHNESS | MaterialVaryingFlags.SSS_STORE_PROFILE | MaterialVaryingFlags.SSS_STORE_DIFFUSE | MaterialVaryingFlags.SSS_STORE_NORMAL | MaterialVaryingFlags.SSS_STORE_TRANSMISSION);
+    ctx.materialFlags &= ~(MaterialVaryingFlags.SSR_STORE_ROUGHNESS | MaterialVaryingFlags.SSS_STORE_PROFILE | MaterialVaryingFlags.SSS_STORE_DIFFUSE | MaterialVaryingFlags.SSS_STORE_NORMAL | MaterialVaryingFlags.SSS_STORE_TRANSMISSION | MaterialVaryingFlags.SKIN_SSS_STORE);
     if (ctx.SSR) {
         ctx.materialFlags |= MaterialVaryingFlags.SSR_STORE_ROUGHNESS;
     }
@@ -45677,6 +46187,9 @@ function blitToCurrentColorAttachment(ctx, source) {
             ctx.materialFlags |= MaterialVaryingFlags.SSS_STORE_TRANSMISSION;
         }
     }
+    if (ctx.SkinSSSTexture) {
+        ctx.materialFlags |= MaterialVaryingFlags.SKIN_SSS_STORE;
+    }
     if (depthTex === ctx.finalFramebuffer?.getDepthAttachment()) {
         ctx.intermediateFramebuffer = ctx.finalFramebuffer;
     } else if (sceneColorFramebufferHandle && !hasSurfaceMRT(ctx)) {
@@ -45755,6 +46268,34 @@ function blitToCurrentColorAttachment(ctx, source) {
 /** @internal */ function renderTransmissionDepthPass(frame, rgCtx) {
     renderSceneDepth(frame, frame.depthFramebuffer, rgCtx);
 }
+function queueTAAHistoryCommit(frame, rgCtx, historyManager, colorHandle, motionVectorHandle) {
+    const { ctx } = frame;
+    if (!historyManager?.frameActive || !ctx.camera.TAA || !frame.options.motionVectors || !motionVectorHandle) {
+        return;
+    }
+    const colorTexture = rgCtx.getTexture(colorHandle);
+    const colorSize = {
+        width: colorTexture.width,
+        height: colorTexture.height
+    };
+    historyManager.queueRetainedCommit(RGHistoryResources.TAA_COLOR, {
+        format: colorTexture.format,
+        sizeMode: 'absolute',
+        width: colorTexture.width,
+        height: colorTexture.height
+    }, colorSize, colorTexture);
+    const motionVectorTexture = rgCtx.getTexture(motionVectorHandle);
+    const motionVectorSize = {
+        width: motionVectorTexture.width,
+        height: motionVectorTexture.height
+    };
+    historyManager.queueRetainedCommit(RGHistoryResources.TAA_MOTION_VECTOR, {
+        format: motionVectorTexture.format,
+        sizeMode: 'absolute',
+        width: motionVectorTexture.width,
+        height: motionVectorTexture.height
+    }, motionVectorSize, motionVectorTexture);
+}
 /** @internal */ function renderComposite(frame) {
     const { ctx } = frame;
     ctx.compositor?.drawPostEffects(ctx, PostEffectLayer.end, ctx.linearDepthTexture);
@@ -45765,6 +46306,7 @@ function blitToCurrentColorAttachment(ctx, source) {
     ctx.materialFlags &= ~MaterialVaryingFlags.SSS_STORE_DIFFUSE;
     ctx.materialFlags &= ~MaterialVaryingFlags.SSS_STORE_NORMAL;
     ctx.materialFlags &= ~MaterialVaryingFlags.SSS_STORE_TRANSMISSION;
+    ctx.materialFlags &= ~MaterialVaryingFlags.SKIN_SSS_STORE;
     if (ctx.intermediateFramebuffer && ctx.intermediateFramebuffer !== ctx.finalFramebuffer) {
         const blitter = new CopyBlitter();
         blitter.srgbOut = !ctx.finalFramebuffer;
@@ -48721,6 +49263,7 @@ class GlobalBindGroupAllocator {
                     SSSParamTexture: null,
                     SSSDiffuseTexture: null,
                     SSSTransmissionTexture: null,
+                    SkinSSSTexture: null,
                     ssrSDFBoxBuffer: null,
                     ssrSDFBoxCount: 0,
                     finalFramebuffer: device.getFramebuffer(),
@@ -49279,6 +49822,321 @@ class GlobalBindGroupAllocator {
     }
 }
 
+/*
+  const PCF_KERNEL_3x3 = [
+    [0.5, 1.0, 0.5],
+    [1.0, 1.0, 1.0],
+    [0.5, 1.0, 0.5]
+  ];
+  const PCF_KERNEL_SUM_3x3 = 7;
+
+  const PCF_KERNEL_5x5 = [
+    [0.0, 0.5, 1.0, 0.5, 0.0],
+    [0.5, 1.0, 1.0, 1.0, 0.5],
+    [1.0, 1.0, 1.0, 1.0, 1.0],
+    [0.5, 1.0, 1.0, 1.0, 0.5],
+    [0.0, 0.5, 1.0, 0.5, 0.0]
+  ];
+  const PCF_KERNEL_SUM_5x5 = 17;
+
+  const PCF_KERNEL_7x7 = [
+    [0.0, 0.0, 0.5, 1.0, 0.5, 0.0, 0.0],
+    [0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0],
+    [0.5, 1.0, 1.0, 1.0, 1.0, 1.0, 0.5],
+    [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0],
+    [0.5, 1.0, 1.0, 1.0, 1.0, 1.0, 0.5],
+    [0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0],
+    [0.0, 0.0, 0.5, 1.0, 0.5, 0.0, 0.0]
+  ];
+  const PCF_KERNEL_SUM_7x7 = 33;
+
+  const PCF_KERNEL_9x9 = [
+    [0.0, 0.0, 0.0, 0.5, 1.0, 0.5, 0.0, 0.0, 0.0],
+    [0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
+    [0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0],
+    [0.5, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.5],
+    [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0],
+    [0.5, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.5],
+    [0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0],
+    [0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
+    [0.0, 0.0, 0.0, 0.5, 1.0, 0.5, 0.0, 0.0, 0.0]
+  ];
+  const PCF_KERNEL_SUM_9x9 = 53;
+  */ const PCF_POISSON_DISC = [
+    [
+        0.511749,
+        0.547686
+    ],
+    [
+        0.58929,
+        0.257224
+    ],
+    [
+        0.165018,
+        0.57663
+    ],
+    [
+        0.407692,
+        0.742285
+    ],
+    [
+        0.707012,
+        0.646523
+    ],
+    [
+        0.31463,
+        0.466825
+    ],
+    [
+        0.801257,
+        0.485186
+    ],
+    [
+        0.418136,
+        0.146517
+    ],
+    [
+        0.579889,
+        0.0368284
+    ],
+    [
+        0.79801,
+        0.140114
+    ],
+    [
+        -0.0413185,
+        0.371455
+    ],
+    [
+        -0.0529108,
+        0.627352
+    ],
+    [
+        0.0821375,
+        0.882071
+    ],
+    [
+        0.17308,
+        0.301207
+    ],
+    [
+        -0.120452,
+        0.867216
+    ],
+    [
+        0.371096,
+        0.916454
+    ],
+    [
+        -0.178381,
+        0.146101
+    ],
+    [
+        -0.276489,
+        0.550525
+    ],
+    [
+        0.12542,
+        0.126643
+    ],
+    [
+        -0.296654,
+        0.286879
+    ],
+    [
+        0.261744,
+        -604975e-8
+    ],
+    [
+        -0.213417,
+        0.715776
+    ],
+    [
+        0.425684,
+        -0.153211
+    ],
+    [
+        -0.480054,
+        0.321357
+    ],
+    [
+        -0.0717878,
+        -0.0250567
+    ],
+    [
+        -0.328775,
+        -0.169666
+    ],
+    [
+        -0.394923,
+        0.130802
+    ],
+    [
+        -0.553681,
+        -0.176777
+    ],
+    [
+        -0.722615,
+        0.120616
+    ],
+    [
+        -0.693065,
+        0.309017
+    ],
+    [
+        0.603193,
+        0.791471
+    ],
+    [
+        -0.0754941,
+        -0.297988
+    ],
+    [
+        0.109303,
+        -0.156472
+    ],
+    [
+        0.260605,
+        -0.280111
+    ],
+    [
+        0.129731,
+        -0.487954
+    ],
+    [
+        -0.537315,
+        0.520494
+    ],
+    [
+        -0.42758,
+        0.800607
+    ],
+    [
+        0.77309,
+        -0.0728102
+    ],
+    [
+        0.908777,
+        0.328356
+    ],
+    [
+        0.985341,
+        0.0759158
+    ],
+    [
+        0.947536,
+        -0.11837
+    ],
+    [
+        -0.103315,
+        -0.610747
+    ],
+    [
+        0.337171,
+        -0.584
+    ],
+    [
+        0.210919,
+        -0.720055
+    ],
+    [
+        0.41894,
+        -0.36769
+    ],
+    [
+        -0.254228,
+        -0.49368
+    ],
+    [
+        -0.428562,
+        -0.404037
+    ],
+    [
+        -0.831732,
+        -0.189615
+    ],
+    [
+        -0.922642,
+        0.0888026
+    ],
+    [
+        -0.865914,
+        0.427795
+    ],
+    [
+        0.706117,
+        -0.311662
+    ],
+    [
+        0.545465,
+        -0.520942
+    ],
+    [
+        -0.695738,
+        0.664492
+    ],
+    [
+        0.389421,
+        -0.899007
+    ],
+    [
+        0.48842,
+        -0.708054
+    ],
+    [
+        0.760298,
+        -0.62735
+    ],
+    [
+        -0.390788,
+        -0.707388
+    ],
+    [
+        -0.591046,
+        -0.686721
+    ],
+    [
+        -0.769903,
+        -0.413775
+    ],
+    [
+        -0.604457,
+        -0.502571
+    ],
+    [
+        -0.557234,
+        0.00451362
+    ],
+    [
+        0.147572,
+        -0.924353
+    ],
+    [
+        -0.0662488,
+        -0.892081
+    ],
+    [
+        0.863832,
+        -0.4072
+    ]
+];
+function getPCSSRotationMatrix(scope, sampleCoord, temporalJitter) {
+    const funcName = `lib_getPCSSRotationMatrix_${temporalJitter ? 1 : 0}`;
+    const pb = scope.$builder;
+    pb.func(funcName, [
+        pb.vec2('sampleCoord')
+    ], function() {
+        if (temporalJitter) {
+            this.$l.frame = pb.mod(pb.float(ShaderHelper.getFramestamp(this)), 64);
+            this.$l.randomAngle = pb.mul(smoothNoise3D(this, pb.vec3(pb.mul(this.sampleCoord, 0.35), pb.mul(this.frame, 0.61803398875))), 2 * Math.PI);
+            this.$l.randomBase = pb.vec2(pb.cos(this.randomAngle), pb.sin(this.randomAngle));
+            this.$return(pb.mat2(this.randomBase.x, this.randomBase.y, pb.neg(this.randomBase.y), this.randomBase.x));
+        } else {
+            this.$return(pb.mat2(0.8660254, 0.5, -0.5, 0.8660254));
+        }
+    });
+    return pb.getGlobalScope()[funcName](sampleCoord);
+}
 function getShadowMapTexelSize(scope) {
     return scope.$builder.div(1, ShaderHelper.getShadowCameraParams(scope).z);
 }
@@ -49359,6 +50217,216 @@ function sampleShadowMapPCF(scope, shadowMapFormat, pos, offset, depth, cascade)
         cascade
     ] : []);
 }
+function sampleShadowDepthPCSS(scope, shadowMapFormat, pos, bounds, cascade) {
+    const funcName = `lib_sampleShadowDepthPCSS_${shadowMapFormat}_${cascade ? 1 : 0}`;
+    const pb = scope.$builder;
+    pb.func(funcName, [
+        pb.vec2('coords'),
+        pb.vec4('bounds'),
+        ...cascade ? [
+            pb.int('cascade')
+        ] : []
+    ], function() {
+        this.$l.depth = pb.float(1);
+        this.$l.sampleInside = pb.all(pb.bvec4(pb.greaterThanEqual(this.coords.x, this.bounds.x), pb.lessThanEqual(this.coords.x, this.bounds.z), pb.greaterThanEqual(this.coords.y, this.bounds.y), pb.lessThanEqual(this.coords.y, this.bounds.w)));
+        this.$if(this.sampleInside, function() {
+            this.$l.boundsPadding = pb.mul(pb.sub(this.bounds.zw, this.bounds.xy), getShadowMapTexelSize(this), 0.5);
+            this.$l.sampleCoord = pb.clamp(this.coords, pb.add(this.bounds.xy, this.boundsPadding), pb.sub(this.bounds.zw, this.boundsPadding));
+            this.$l.shadowTex = cascade && getDevice().type !== 'webgl' ? pb.textureArraySampleLevel(ShaderHelper.getShadowMap(this), this.sampleCoord, this.cascade, 0) : pb.textureSampleLevel(ShaderHelper.getShadowMap(this), this.sampleCoord, 0);
+            this.depth = shadowMapFormat === 'rgba8unorm' ? decodeNormalizedFloatFromRGBA(this, this.shadowTex) : this.shadowTex.x;
+        });
+        this.$return(this.depth);
+    });
+    return pb.getGlobalScope()[funcName](pos, bounds, ...cascade ? [
+        cascade
+    ] : []);
+}
+function samplePointShadowDepthPCSS(scope, shadowMapFormat, dir) {
+    const funcName = `lib_samplePointShadowDepthPCSS_${shadowMapFormat}`;
+    const pb = scope.$builder;
+    pb.func(funcName, [
+        pb.vec3('dir')
+    ], function() {
+        this.$l.shadowTex = pb.textureSampleLevel(ShaderHelper.getShadowMap(this), this.dir, 0);
+        this.$return(shadowMapFormat === 'rgba8unorm' ? decodeNormalizedFloatFromRGBA(this, this.shadowTex) : this.shadowTex.x);
+    });
+    return pb.getGlobalScope()[funcName](dir);
+}
+function compareShadowDepthPCSS(scope, sampleDepth, compareDepth, transitionWidth) {
+    const funcName = 'lib_compareShadowDepthPCSS';
+    const pb = scope.$builder;
+    pb.func(funcName, [
+        pb.float('sampleDepth'),
+        pb.float('compareDepth'),
+        pb.float('transitionWidth')
+    ], function() {
+        this.$l.depthDelta = pb.sub(this.sampleDepth, this.compareDepth);
+        this.$return(pb.smoothStep(pb.neg(this.transitionWidth), this.transitionWidth, this.depthDelta));
+    });
+    return pb.getGlobalScope()[funcName](sampleDepth, compareDepth, transitionWidth);
+}
+function sampleShadowPCFPCSS(scope, shadowMapFormat, pos, bounds, compareDepth, texelSize, receiverPlaneDepthBias, cascade) {
+    const funcName = `lib_sampleShadowPCFPCSS_${shadowMapFormat}_${receiverPlaneDepthBias ? 1 : 0}_${cascade ? 1 : 0}`;
+    const pb = scope.$builder;
+    pb.func(funcName, [
+        pb.vec2('coords'),
+        pb.vec4('bounds'),
+        pb.float('compareDepth'),
+        pb.vec2('texelSize'),
+        ...receiverPlaneDepthBias ? [
+            pb.vec3('receiverPlaneDepthBias')
+        ] : [],
+        ...cascade ? [
+            pb.int('cascade')
+        ] : []
+    ], function() {
+        this.$l.shadow = pb.float(0);
+        this.$l.transitionWidth = receiverPlaneDepthBias ? pb.max(pb.dot(pb.abs(this.receiverPlaneDepthBias.xy), this.texelSize), 1 / 65535) : pb.float(1 / 65535);
+        this.$l.offset = pb.vec2();
+        this.$l.tapCoord = pb.vec2();
+        this.$l.sampleDepth = pb.float();
+        this.$l.tapCompareDepth = pb.float();
+        const offsets = [
+            [
+                -0.35,
+                -0.35
+            ],
+            [
+                0.35,
+                -0.35
+            ],
+            [
+                -0.35,
+                0.35
+            ],
+            [
+                0.35,
+                0.35
+            ]
+        ];
+        for (const [ox, oy] of offsets){
+            this.offset = pb.mul(pb.vec2(ox, oy), this.texelSize);
+            this.tapCoord = pb.add(this.coords, this.offset);
+            this.sampleDepth = sampleShadowDepthPCSS(this, shadowMapFormat, this.tapCoord, this.bounds, this.cascade);
+            this.tapCompareDepth = receiverPlaneDepthBias ? pb.add(this.compareDepth, pb.dot(this.offset, this.receiverPlaneDepthBias.xy)) : this.compareDepth;
+            this.shadow = pb.add(this.shadow, compareShadowDepthPCSS(this, this.sampleDepth, this.tapCompareDepth, this.transitionWidth));
+        }
+        this.$return(pb.mul(this.shadow, 0.25));
+    });
+    return pb.getGlobalScope()[funcName](pos, bounds, compareDepth, texelSize, ...receiverPlaneDepthBias ? [
+        receiverPlaneDepthBias
+    ] : [], ...cascade ? [
+        cascade
+    ] : []);
+}
+function samplePointShadowPCFPCSS(scope, shadowMapFormat, dir, compareDepth, texelSize, tangent, bitangent) {
+    const funcName = `lib_samplePointShadowPCFPCSS_${shadowMapFormat}`;
+    const pb = scope.$builder;
+    pb.func(funcName, [
+        pb.vec3('dir'),
+        pb.float('compareDepth'),
+        pb.float('texelSize'),
+        pb.vec3('tangent'),
+        pb.vec3('bitangent')
+    ], function() {
+        this.$l.shadow = pb.float(0);
+        this.$l.transitionWidth = pb.float(1 / 65535);
+        this.$l.offset = pb.vec2();
+        this.$l.sampleDir = pb.vec3();
+        this.$l.sampleDepth = pb.float();
+        const offsets = [
+            [
+                -0.35,
+                -0.35
+            ],
+            [
+                0.35,
+                -0.35
+            ],
+            [
+                -0.35,
+                0.35
+            ],
+            [
+                0.35,
+                0.35
+            ]
+        ];
+        for (const [ox, oy] of offsets){
+            this.offset = pb.mul(pb.vec2(ox, oy), this.texelSize);
+            this.sampleDir = pb.normalize(pb.add(this.dir, pb.add(pb.mul(this.tangent, this.offset.x), pb.mul(this.bitangent, this.offset.y))));
+            this.sampleDepth = samplePointShadowDepthPCSS(this, shadowMapFormat, this.sampleDir);
+            this.shadow = pb.add(this.shadow, compareShadowDepthPCSS(this, this.sampleDepth, this.compareDepth, this.transitionWidth));
+        }
+        this.$return(pb.mul(this.shadow, 0.25));
+    });
+    return pb.getGlobalScope()[funcName](dir, compareDepth, texelSize, tangent, bitangent);
+}
+function findBlockerPCSS(scope, shadowMapFormat, tapCount, texCoord, bounds, searchRadius, transitionWidth, matrix, cascade) {
+    const funcName = `lib_findBlockerPCSS_${shadowMapFormat}_${cascade ? 1 : 0}`;
+    const pb = scope.$builder;
+    pb.func(funcName, [
+        pb.vec4('texCoord'),
+        pb.vec4('bounds'),
+        pb.vec2('searchRadius'),
+        pb.float('tapCount'),
+        pb.float('transitionWidth'),
+        pb.mat2('matrix'),
+        ...cascade ? [
+            pb.int('cascade')
+        ] : []
+    ], function() {
+        this.$l.blockerDepthSum = pb.float(0);
+        this.$l.blockerCount = pb.float(0);
+        this.$l.duv = pb.vec2();
+        this.$l.sampleCoord = pb.vec2();
+        this.$l.sampleDepth = pb.float();
+        this.$l.blockerWeight = pb.float();
+        this.$for(pb.float('i'), 0, this.tapCount, function() {
+            this.duv = pb.mul(pb.mul(this.matrix, this.PCSSpdSamples.at(pb.mod(pb.mul(pb.int(this.i), 19), PCF_POISSON_DISC.length))), this.searchRadius);
+            this.sampleCoord = pb.add(this.texCoord.xy, this.duv);
+            this.sampleDepth = sampleShadowDepthPCSS(this, shadowMapFormat, this.sampleCoord, this.bounds, this.cascade);
+            this.blockerWeight = pb.sub(1, pb.smoothStep(pb.neg(this.transitionWidth), this.transitionWidth, pb.sub(this.sampleDepth, this.texCoord.z)));
+            this.blockerDepthSum = pb.add(this.blockerDepthSum, pb.mul(this.sampleDepth, this.blockerWeight));
+            this.blockerCount = pb.add(this.blockerCount, this.blockerWeight);
+        });
+        this.$return(pb.vec2(this.$choice(pb.greaterThan(this.blockerCount, 0), pb.div(this.blockerDepthSum, pb.max(this.blockerCount, 0.0001)), -1), this.blockerCount));
+    });
+    return pb.getGlobalScope()[funcName](texCoord, bounds, searchRadius, tapCount, transitionWidth, matrix, ...cascade ? [
+        cascade
+    ] : []);
+}
+function findPointBlockerPCSS(scope, shadowMapFormat, tapCount, dir, compareDepth, searchRadius, transitionWidth, matrix, tangent, bitangent) {
+    const funcName = `lib_findPointBlockerPCSS_${shadowMapFormat}`;
+    const pb = scope.$builder;
+    pb.func(funcName, [
+        pb.vec3('dir'),
+        pb.float('compareDepth'),
+        pb.float('searchRadius'),
+        pb.float('tapCount'),
+        pb.float('transitionWidth'),
+        pb.mat2('matrix'),
+        pb.vec3('tangent'),
+        pb.vec3('bitangent')
+    ], function() {
+        this.$l.blockerDepthSum = pb.float(0);
+        this.$l.blockerCount = pb.float(0);
+        this.$l.duv = pb.vec2();
+        this.$l.sampleDir = pb.vec3();
+        this.$l.sampleDepth = pb.float();
+        this.$l.blockerWeight = pb.float();
+        this.$for(pb.float('i'), 0, this.tapCount, function() {
+            this.duv = pb.mul(pb.mul(this.matrix, this.PCSSpdSamples.at(pb.mod(pb.mul(pb.int(this.i), 19), PCF_POISSON_DISC.length))), this.searchRadius);
+            this.sampleDir = pb.normalize(pb.add(this.dir, pb.add(pb.mul(this.tangent, this.duv.x), pb.mul(this.bitangent, this.duv.y))));
+            this.sampleDepth = samplePointShadowDepthPCSS(this, shadowMapFormat, this.sampleDir);
+            this.blockerWeight = pb.sub(1, pb.smoothStep(pb.neg(this.transitionWidth), this.transitionWidth, pb.sub(this.sampleDepth, this.compareDepth)));
+            this.blockerDepthSum = pb.add(this.blockerDepthSum, pb.mul(this.sampleDepth, this.blockerWeight));
+            this.blockerCount = pb.add(this.blockerCount, this.blockerWeight);
+        });
+        this.$return(pb.vec2(this.$choice(pb.greaterThan(this.blockerCount, 0), pb.div(this.blockerDepthSum, pb.max(this.blockerCount, 0.0001)), -1), this.blockerCount));
+    });
+    return pb.getGlobalScope()[funcName](dir, compareDepth, searchRadius, tapCount, transitionWidth, matrix, tangent, bitangent);
+}
 function chebyshevUpperBound(scope, distance, occluder) {
     const funcNameChebyshevUpperBound = 'lib_chebyshevUpperBound';
     const pb = scope.$builder;
@@ -49539,6 +50607,96 @@ function chebyshevUpperBound(scope, distance, occluder) {
         cascade
     ] : []);
 }
+/** @internal */ function filterShadowPCSS(scope, lightType, shadowMapFormat, texCoord, receiverPlaneDepthBias, cascade, temporalJitter = true, numCascades = 1) {
+    const funcNameFilterShadowPCSS = `lib_filterShadowPCSS_${lightType}_${shadowMapFormat}_${receiverPlaneDepthBias ? 1 : 0}_${cascade ? 1 : 0}_${temporalJitter ? 1 : 0}_${numCascades}`;
+    const pb = scope.$builder;
+    pb.func(funcNameFilterShadowPCSS, [
+        pb.vec4('texCoord'),
+        ...receiverPlaneDepthBias ? [
+            pb.vec3('receiverPlaneDepthBias')
+        ] : [],
+        ...cascade ? [
+            pb.int('cascade')
+        ] : []
+    ], function() {
+        this.$l.PCSSblockerSampleCount = ShaderHelper.getShadowImplParams(this).y;
+        this.$l.PCSSfilterSampleCount = ShaderHelper.getShadowImplParams(this).z;
+        this.$l.PCSSlightRadius = ShaderHelper.getShadowImplParams(this).x;
+        this.$l.PCSSmaxFilterRadius = ShaderHelper.getShadowImplParams(this).w;
+        this.$l.PCSSsearchRadius = this.$choice(pb.greaterThan(this.PCSSlightRadius, 0), pb.max(this.PCSSlightRadius, this.PCSSmaxFilterRadius), 0);
+        if (!pb.getGlobalScope().PCSSpdSamples) {
+            pb.getGlobalScope().PCSSpdSamples = PCF_POISSON_DISC.map((s)=>pb.vec2(s[0], s[1]));
+        }
+        if (lightType === LIGHT_TYPE_POINT) {
+            this.$l.lightDepth = this.texCoord.w;
+            this.$l.sampleDir = pb.normalize(this.texCoord.xyz);
+            this.$l.shadowMapTexelSize = pb.mul(getShadowMapTexelSize(this), 2);
+            this.$l.matrix = getPCSSRotationMatrix(this, pb.mul(this.sampleDir.xy, pb.vec2(getShadowMapSize(this))), temporalJitter);
+            this.$l.searchRadius = pb.mul(pb.clamp(this.PCSSsearchRadius, 0, pb.max(0, this.PCSSmaxFilterRadius)), this.shadowMapTexelSize);
+            this.$l.blockerTransitionWidth = pb.float(1 / 65535);
+            this.$l.up = this.$choice(pb.lessThan(pb.abs(this.sampleDir.y), 0.999), pb.vec3(0, 1, 0), pb.vec3(1, 0, 0));
+            this.$l.tangent = pb.normalize(pb.cross(this.up, this.sampleDir));
+            this.$l.bitangent = pb.cross(this.sampleDir, this.tangent);
+            this.$l.blocker = findPointBlockerPCSS(this, shadowMapFormat, this.PCSSblockerSampleCount, this.sampleDir, this.lightDepth, this.searchRadius, this.blockerTransitionWidth, this.matrix, this.tangent, this.bitangent);
+            this.$if(pb.lessThanEqual(this.blocker.y, 0), function() {
+                this.$return(pb.float(1));
+            });
+            this.$l.penumbra = pb.div(pb.max(pb.sub(this.lightDepth, this.blocker.x), 0), pb.max(this.blocker.x, 0.0001));
+            this.$l.filterRadius = pb.mul(pb.clamp(pb.mul(this.penumbra, this.PCSSlightRadius), 0, pb.max(0, this.PCSSmaxFilterRadius)), this.shadowMapTexelSize);
+            this.$l.shadow = pb.float(0);
+            this.$l.duv = pb.vec2();
+            this.$l.samplePointDir = pb.vec3();
+            this.$for(pb.float('i'), 0, this.PCSSfilterSampleCount, function() {
+                this.duv = pb.mul(pb.mul(this.matrix, this.PCSSpdSamples.at(pb.mod(pb.mul(pb.int(this.i), 19), PCF_POISSON_DISC.length))), this.filterRadius);
+                this.samplePointDir = pb.normalize(pb.add(this.sampleDir, pb.add(pb.mul(this.tangent, this.duv.x), pb.mul(this.bitangent, this.duv.y))));
+                this.shadow = pb.add(this.shadow, samplePointShadowPCFPCSS(this, shadowMapFormat, this.samplePointDir, this.lightDepth, this.shadowMapTexelSize, this.tangent, this.bitangent));
+            });
+            this.shadow = pb.div(this.shadow, this.PCSSfilterSampleCount);
+            this.$return(this.shadow);
+            return;
+        }
+        this.$l.lightDepth = this.texCoord.z;
+        if (receiverPlaneDepthBias) {
+            this.lightDepth = pb.sub(this.lightDepth, this.receiverPlaneDepthBias.z);
+        }
+        this.$l.sampleBounds = pb.vec4(0, 0, 1, 1);
+        if (cascade && getDevice().type === 'webgl' && numCascades > 1) {
+            const numCols = numCascades > 1 ? 2 : 1;
+            const numRows = numCascades > 2 ? 2 : 1;
+            this.$l.cascadeIndex = pb.float(this.cascade);
+            this.$l.cascadeCol = pb.mod(this.cascadeIndex, 2);
+            this.$l.cascadeRow = pb.floor(pb.mul(this.cascadeIndex, 0.5));
+            this.sampleBounds = pb.vec4(pb.mul(this.cascadeCol, 1 / numCols), pb.mul(this.cascadeRow, 1 / numRows), pb.mul(pb.add(this.cascadeCol, 1), 1 / numCols), pb.mul(pb.add(this.cascadeRow, 1), 1 / numRows));
+        }
+        this.$l.shadowMapTexelSize = pb.mul(pb.sub(this.sampleBounds.zw, this.sampleBounds.xy), getShadowMapTexelSize(this));
+        this.$l.matrix = getPCSSRotationMatrix(this, pb.mul(this.texCoord.xy, pb.vec2(getShadowMapSize(this))), temporalJitter);
+        this.$l.searchRadius = pb.mul(pb.clamp(this.PCSSsearchRadius, 0, pb.max(0, this.PCSSmaxFilterRadius)), this.shadowMapTexelSize);
+        this.$l.blockerTransitionWidth = receiverPlaneDepthBias ? pb.max(pb.dot(pb.abs(this.receiverPlaneDepthBias.xy), this.searchRadius), 1 / 65535) : pb.float(1 / 65535);
+        this.$l.blocker = findBlockerPCSS(this, shadowMapFormat, this.PCSSblockerSampleCount, pb.vec4(this.texCoord.xy, this.lightDepth, this.texCoord.w), this.sampleBounds, this.searchRadius, this.blockerTransitionWidth, this.matrix, this.cascade);
+        this.$if(pb.lessThanEqual(this.blocker.y, 0), function() {
+            this.$return(pb.float(1));
+        });
+        this.$l.penumbra = pb.div(pb.max(pb.sub(this.lightDepth, this.blocker.x), 0), pb.max(this.blocker.x, 0.0001));
+        this.$l.filterRadius = pb.mul(pb.clamp(pb.mul(this.penumbra, this.PCSSlightRadius), 0, pb.max(0, this.PCSSmaxFilterRadius)), this.shadowMapTexelSize);
+        this.$l.shadow = pb.float(0);
+        this.$l.duv = pb.vec2();
+        this.$l.sampleCoord = pb.vec2();
+        this.$l.compareDepth = pb.float();
+        this.$for(pb.float('i'), 0, this.PCSSfilterSampleCount, function() {
+            this.duv = pb.mul(pb.mul(this.matrix, this.PCSSpdSamples.at(pb.mod(pb.mul(pb.int(this.i), 19), PCF_POISSON_DISC.length))), this.filterRadius);
+            this.sampleCoord = pb.add(this.texCoord.xy, this.duv);
+            this.compareDepth = receiverPlaneDepthBias ? pb.add(this.lightDepth, pb.dot(this.duv, this.receiverPlaneDepthBias.xy)) : this.lightDepth;
+            this.shadow = pb.add(this.shadow, sampleShadowPCFPCSS(this, shadowMapFormat, this.sampleCoord, this.sampleBounds, this.compareDepth, this.shadowMapTexelSize, this.receiverPlaneDepthBias, this.cascade));
+        });
+        this.shadow = pb.div(this.shadow, this.PCSSfilterSampleCount);
+        this.$return(this.shadow);
+    });
+    return pb.getGlobalScope()[funcNameFilterShadowPCSS](texCoord, ...receiverPlaneDepthBias ? [
+        receiverPlaneDepthBias
+    ] : [], ...cascade ? [
+        cascade
+    ] : []);
+}
 
 function getShadowReceiverBiasFactors(scope) {
     const pb = scope.$builder;
@@ -49624,6 +50782,7 @@ function computeShadowBias(lightType, scope, z, NdotL, linear) {
     getShadowMapBorder(_shadowMapParams) {
         return 0;
     }
+    getParams() {}
     getShadowMap(shadowMapParams) {
         return this.useNativeShadowMap(shadowMapParams) ? shadowMapParams.shadowMapFramebuffer.getDepthAttachment() : shadowMapParams.shadowMapFramebuffer.getColorAttachments()[0];
     }
@@ -50241,6 +51400,7 @@ class BlurBlitter extends GaussianBlurBlitter {
     getShaderHash() {
         return `${this._blur ? 1 : 0}${this._logSpace ? 1 : 0}`;
     }
+    getParams() {}
     getShadowMapColorFormat(_shadowMapParams) {
         const device = getDevice();
         return device.getDeviceCaps().textureCaps.supportFloatColorBuffer && device.getDeviceCaps().textureCaps.supportLinearFloatTexture ? device.type === 'webgl' ? 'rgba32f' : 'rg32f' : device.getDeviceCaps().textureCaps.supportHalfFloatColorBuffer && device.getDeviceCaps().textureCaps.supportLinearHalfFloatTexture ? device.type === 'webgl' ? 'rgba16f' : 'rg16f' : 'rgba8unorm';
@@ -50545,6 +51705,7 @@ class VSMBlitter extends Blitter {
     getShaderHash() {
         return '';
     }
+    getParams() {}
     getShadowMapColorFormat(_shadowMapParams) {
         const device = getDevice();
         return device.getDeviceCaps().textureCaps.supportFloatColorBuffer && device.getDeviceCaps().textureCaps.supportLinearFloatTexture ? 'rgba32f' : device.getDeviceCaps().textureCaps.supportHalfFloatColorBuffer && device.getDeviceCaps().textureCaps.supportLinearHalfFloatTexture ? 'rgba16f' : 'rgba8unorm';
@@ -50617,25 +51778,23 @@ class VSMBlitter extends Blitter {
     }
 }
 
-/** @internal */ class PCFPD extends ShadowImpl {
-    static SHADER_VERSION = 3;
-    _tapCount;
-    _sampleRadius;
+/** @internal */ class PCFOPT extends ShadowImpl {
+    _kernelSize;
     _shadowSampler;
-    constructor(tapCount, sampleRadius){
+    constructor(kernelSize){
         super();
-        this._tapCount = tapCount ?? 3;
-        this._sampleRadius = sampleRadius ?? 1;
+        this._kernelSize = kernelSize ?? 5;
         this._shadowSampler = null;
     }
-    get tapCount() {
-        return this._tapCount;
+    get kernelSize() {
+        return this._kernelSize;
     }
-    set tapCount(val) {
-        this._tapCount = val;
+    set kernelSize(val) {
+        val = val !== 3 && val !== 5 && val !== 7 ? 5 : val;
+        this._kernelSize = val;
     }
     getType() {
-        return 'pcf-pd';
+        return 'pcf-opt';
     }
     dispose() {
         this._shadowSampler = null;
@@ -50643,18 +51802,10 @@ class VSMBlitter extends Blitter {
     resourceDirty() {
         return false;
     }
-    getPCFKernelSize() {
-        if (this._sampleRadius >= 4 || this._tapCount >= 32) {
-            return 7;
-        }
-        if (this._sampleRadius >= 2 || this._tapCount >= 12) {
-            return 5;
-        }
-        return 3;
-    }
     getShadowMapBorder(_shadowMapParams) {
-        return Math.max(this._sampleRadius + 1, this.getPCFKernelSize());
+        return this._kernelSize;
     }
+    getParams() {}
     getShadowMap(shadowMapParams) {
         return this.useNativeShadowMap(shadowMapParams) ? shadowMapParams.shadowMapFramebuffer.getDepthAttachment() : shadowMapParams.shadowMapFramebuffer.getColorAttachments()[0];
     }
@@ -50664,21 +51815,14 @@ class VSMBlitter extends Blitter {
     }
     postRenderShadowMap() {}
     getDepthScale() {
-        return this._sampleRadius;
-    }
-    setDepthScale(val) {
-        this._sampleRadius = val;
+        return 1;
     }
+    setDepthScale(_val) {}
     getShaderHash() {
-        return `${PCFPD.SHADER_VERSION}-${this._tapCount}-${this._sampleRadius}`;
+        return `${this._kernelSize}`;
     }
     getShadowMapColorFormat(shadowMapParams) {
-        if (this.useNativeShadowMap(shadowMapParams)) {
-            return null;
-        } else {
-            const device = getDevice();
-            return device.getDeviceCaps().textureCaps.supportHalfFloatColorBuffer ? device.type === 'webgl' ? 'rgba16f' : 'r16f' : device.getDeviceCaps().textureCaps.supportFloatColorBuffer ? device.type === 'webgl' ? 'rgba32f' : 'r32f' : 'rgba8unorm';
-        }
+        return this.useNativeShadowMap(shadowMapParams) ? null : 'rgba8unorm';
     }
     getShadowMapDepthFormat(_shadowMapParams) {
         return getDevice().type === 'webgl' ? 'd24s8' : 'd32f';
@@ -50689,7 +51833,7 @@ class VSMBlitter extends Blitter {
     computeShadowCSM(shadowMapParams, scope, shadowVertex, NdotL, split) {
         const funcNameComputeShadowCSM = 'lib_computeShadowCSM';
         const pb = scope.$builder;
-        const kernelSize = this.getPCFKernelSize();
+        const that = this;
         pb.func(funcNameComputeShadowCSM, [
             pb.vec4('shadowVertex'),
             pb.float('NdotL'),
@@ -50699,10 +51843,11 @@ class VSMBlitter extends Blitter {
             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 = computeShadowBiasCSM(this, this.NdotL, this.split);
                 this.shadowCoord.z = pb.sub(this.shadowCoord.z, this.shadowBias);
-                this.shadow = filterShadowPCF(this, shadowMapParams.lightType, shadowMapParams.shadowMap.format, kernelSize, this.shadowCoord, undefined, this.split);
+                this.shadow = filterShadowPCF(this, shadowMapParams.lightType, shadowMapParams.shadowMap.format, that._kernelSize, this.shadowCoord, this.receiverPlaneDepthBias, this.split);
             });
             this.$return(this.shadow);
         });
@@ -50712,7 +51857,6 @@ class VSMBlitter extends Blitter {
         const funcNameComputeShadow = 'lib_computeShadow';
         const pb = scope.$builder;
         const that = this;
-        const kernelSize = this.getPCFKernelSize();
         pb.func(funcNameComputeShadow, [
             pb.vec4('shadowVertex'),
             pb.float('NdotL')
@@ -50735,10 +51879,11 @@ class VSMBlitter extends Blitter {
                 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 = computeShadowBias(shadowMapParams.lightType, 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, kernelSize, this.shadowCoord);
+                    this.shadow = filterShadowPCF(this, shadowMapParams.lightType, shadowMapParams.shadowMap.format, that._kernelSize, this.shadowCoord, this.receiverPlaneDepthBias);
                 });
                 this.$return(this.shadow);
             }
@@ -50749,7 +51894,7 @@ class VSMBlitter extends Blitter {
         return getDevice().type !== 'webgl';
     }
     /** @internal */ sampleShadowMap(shadowMapParams, scope, coords, z, bias) {
-        const funcNameSampleShadowMap = 'lib_sampleShadowMapPD';
+        const funcNameSampleShadowMap = `lib_sampleShadowMapOPT`;
         const pb = scope.$builder;
         const that = this;
         pb.func(funcNameSampleShadowMap, [
@@ -50772,7 +51917,7 @@ class VSMBlitter extends Blitter {
         return pb.getGlobalScope()[funcNameSampleShadowMap](coords, z, bias);
     }
     /** @internal */ sampleShadowMapCSM(shadowMapParams, scope, coords, split, z, bias) {
-        const funcNameSampleShadowMapCSM = 'lib_sampleShadowMapCSMPD';
+        const funcNameSampleShadowMapCSM = 'lib_sampleShadowMapCSMOPT';
         const pb = scope.$builder;
         const that = this;
         pb.func(funcNameSampleShadowMapCSM, [
@@ -50805,39 +51950,69 @@ class VSMBlitter extends Blitter {
     }
 }
 
-/** @internal */ class PCFOPT extends ShadowImpl {
-    _kernelSize;
-    _shadowSampler;
-    constructor(kernelSize){
+/** @internal */ class PCSS extends ShadowImpl {
+    _lightRadius;
+    _blockerSampleCount;
+    _filterSampleCount;
+    _maxFilterRadius;
+    _temporalJitter;
+    constructor(lightRadius, blockerSampleCount, filterSampleCount, maxFilterRadius, temporalJitter){
         super();
-        this._kernelSize = kernelSize ?? 5;
-        this._shadowSampler = null;
+        this._lightRadius = lightRadius ?? 8;
+        this._blockerSampleCount = blockerSampleCount ?? 24;
+        this._filterSampleCount = filterSampleCount ?? 32;
+        this._maxFilterRadius = maxFilterRadius ?? 32;
+        this._temporalJitter = temporalJitter ?? true;
     }
-    get kernelSize() {
-        return this._kernelSize;
+    get lightRadius() {
+        return this._lightRadius;
     }
-    set kernelSize(val) {
-        val = val !== 3 && val !== 5 && val !== 7 ? 5 : val;
-        this._kernelSize = val;
+    set lightRadius(val) {
+        this._lightRadius = Math.max(0, Number(val) || 0);
     }
-    getType() {
-        return 'pcf-opt';
+    get blockerSampleCount() {
+        return this._blockerSampleCount;
     }
-    dispose() {
-        this._shadowSampler = null;
+    set blockerSampleCount(val) {
+        this._blockerSampleCount = Math.min(Math.max(1, Number(val) >> 0), 64);
+    }
+    get filterSampleCount() {
+        return this._filterSampleCount;
+    }
+    set filterSampleCount(val) {
+        this._filterSampleCount = Math.min(Math.max(1, Number(val) >> 0), 64);
+    }
+    get maxFilterRadius() {
+        return this._maxFilterRadius;
     }
+    set maxFilterRadius(val) {
+        this._maxFilterRadius = Math.max(1, Number(val) || 1);
+    }
+    get temporalJitter() {
+        return this._temporalJitter;
+    }
+    set temporalJitter(val) {
+        this._temporalJitter = !!val;
+    }
+    getType() {
+        return 'pcss';
+    }
+    dispose() {}
     resourceDirty() {
         return false;
     }
     getShadowMapBorder(_shadowMapParams) {
-        return this._kernelSize;
+        return this._lightRadius > 0 ? Math.ceil(Math.max(this._lightRadius, this._maxFilterRadius) + 2) : 0;
+    }
+    getShadowMapClearColor(_shadowMapParams) {
+        return new Vector4(1, 1, 1, 1);
     }
     getShadowMap(shadowMapParams) {
-        return this.useNativeShadowMap(shadowMapParams) ? shadowMapParams.shadowMapFramebuffer.getDepthAttachment() : shadowMapParams.shadowMapFramebuffer.getColorAttachments()[0];
+        return shadowMapParams.shadowMapFramebuffer.getColorAttachments()[0];
     }
     doUpdateResources(shadowMapParams) {
         shadowMapParams.shadowMap = this.getShadowMap(shadowMapParams);
-        shadowMapParams.shadowMapSampler = shadowMapParams.shadowMap?.getDefaultSampler(this.useNativeShadowMap(shadowMapParams)) || null;
+        shadowMapParams.shadowMapSampler = shadowMapParams.shadowMap?.getDefaultSampler(false) ?? null;
     }
     postRenderShadowMap() {}
     getDepthScale() {
@@ -50845,10 +52020,17 @@ class VSMBlitter extends Blitter {
     }
     setDepthScale(_val) {}
     getShaderHash() {
-        return `${this._kernelSize}`;
+        return `${Number(this._temporalJitter)}`;
     }
-    getShadowMapColorFormat(shadowMapParams) {
-        return this.useNativeShadowMap(shadowMapParams) ? null : 'rgba8unorm';
+    getShadowMapColorFormat(_shadowMapParams) {
+        const device = getDevice();
+        if (device.type === 'webgl') {
+            return device.getDeviceCaps().textureCaps.supportHalfFloatColorBuffer ? 'rgba16f' : device.getDeviceCaps().textureCaps.supportFloatColorBuffer ? 'rgba32f' : 'rgba8unorm';
+        }
+        return device.getDeviceCaps().textureCaps.supportHalfFloatColorBuffer ? 'r16f' : device.getDeviceCaps().textureCaps.supportFloatColorBuffer ? 'r32f' : 'rgba8unorm';
+    }
+    getParams(out) {
+        out.setXYZW(this._lightRadius, this._blockerSampleCount, this._filterSampleCount, this._maxFilterRadius);
     }
     getShadowMapDepthFormat(_shadowMapParams) {
         return getDevice().type === 'webgl' ? 'd24s8' : 'd32f';
@@ -50873,7 +52055,7 @@ class VSMBlitter extends Blitter {
             this.$if(this.inShadow, function() {
                 this.$l.shadowBias = computeShadowBiasCSM(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.shadow = filterShadowPCSS(this, shadowMapParams.lightType, shadowMapParams.shadowMap.format, this.shadowCoord, this.receiverPlaneDepthBias, this.split, that._temporalJitter, shadowMapParams.numShadowCascades);
             });
             this.$return(this.shadow);
         });
@@ -50889,90 +52071,53 @@ class VSMBlitter extends Blitter {
         ], function() {
             if (shadowMapParams.lightType === LIGHT_TYPE_POINT) {
                 this.$l.dir = pb.sub(this.shadowVertex.xyz, ShaderHelper.getLightPositionAndRangeForShadow(this).xyz);
-                if (that.useNativeShadowMap(shadowMapParams)) {
-                    this.$l.nearFar = ShaderHelper.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 = ShaderHelper.linearDepthToNonLinear(this, this.maxZ, this.nearFar);
-                    this.$l.shadowBias = computeShadowBias(shadowMapParams.lightType, this, pb.div(this.maxZ, ShaderHelper.getLightPositionAndRangeForShadow(this).w), this.NdotL, true);
-                    this.$return(that.sampleShadowMap(shadowMapParams, this, this.dir, this.distance, this.shadowBias));
+                this.$l.distance = pb.div(pb.length(this.dir), ShaderHelper.getLightPositionAndRangeForShadow(this).w);
+                this.$l.shadowBias = computeShadowBias(shadowMapParams.lightType, this, this.distance, this.NdotL, true);
+                this.$l.shadowCoord = pb.vec4(this.dir, pb.sub(this.distance, this.shadowBias));
+                this.$return(filterShadowPCSS(this, shadowMapParams.lightType, shadowMapParams.shadowMap.format, this.shadowCoord, undefined, undefined, that._temporalJitter));
+            }
+            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);
+            if (shadowMapParams.lightType === LIGHT_TYPE_SPOT) {
+                this.$l.nearFar = ShaderHelper.getShadowCameraParams(this).xy;
+                this.shadowCoord.z = ShaderHelper.nonLinearDepthToLinearNormalized(this, this.shadowCoord.z, this.nearFar);
+            }
+            this.$l.receiverPlaneDepthBias = computeReceiverPlaneDepthBias(this, this.shadowCoord);
+            this.$if(this.inShadow, function() {
+                if (shadowMapParams.lightType === LIGHT_TYPE_SPOT) {
+                    this.$l.shadowBias = computeShadowBias(shadowMapParams.lightType, this, this.shadowCoord.z, this.NdotL, true);
                 } else {
-                    this.$l.distance = pb.div(pb.length(this.dir), ShaderHelper.getLightPositionAndRangeForShadow(this).w);
-                    this.$l.shadowBias = computeShadowBias(shadowMapParams.lightType, 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 = computeShadowBias(shadowMapParams.lightType, 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);
-            }
+                }
+                this.shadowCoord.z = pb.sub(this.shadowCoord.z, this.shadowBias);
+                this.shadow = filterShadowPCSS(this, shadowMapParams.lightType, shadowMapParams.shadowMap.format, this.shadowCoord, this.receiverPlaneDepthBias, undefined, that._temporalJitter);
+            });
+            this.$return(this.shadow);
         });
         return pb.getGlobalScope()[funcNameComputeShadow](shadowVertex, NdotL);
     }
     useNativeShadowMap(_shadowMapParams) {
-        return getDevice().type !== 'webgl';
+        return false;
     }
-    /** @internal */ sampleShadowMap(shadowMapParams, scope, coords, z, bias) {
-        const funcNameSampleShadowMap = `lib_sampleShadowMapOPT`;
+    /** @internal */ samplePointShadowMap(shadowMapParams, scope, coords, z, bias) {
+        const funcNameSampleShadowMap = 'lib_samplePointShadowMapPCSS';
         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(ShaderHelper.getShadowMap(this), this.coords, pb.sub(this.z, this.bias)), 0, 1));
-            } else {
-                this.$l.shadowTex = pb.textureSampleLevel(ShaderHelper.getShadowMap(this), 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));
+            this.$l.shadowTex = pb.textureSampleLevel(ShaderHelper.getShadowMap(this), this.coords, 0);
+            if (!floatDepthTexture) {
+                this.shadowTex.x = decodeNormalizedFloatFromRGBA(this, this.shadowTex);
             }
-        });
-        return pb.getGlobalScope()[funcNameSampleShadowMap](coords, z, bias);
-    }
-    /** @internal */ sampleShadowMapCSM(shadowMapParams, scope, coords, split, z, bias) {
-        const funcNameSampleShadowMapCSM = 'lib_sampleShadowMapCSMOPT';
-        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(ShaderHelper.getShadowMap(this), this.coords.xy, this.split, this.distance), 0, 1));
-                } else {
-                    this.$return(pb.clamp(pb.textureSampleCompareLevel(ShaderHelper.getShadowMap(this), this.coords.xy, this.distance), 0, 1));
-                }
-            } else {
-                if (shadowMapParams.shadowMap.isTexture2DArray()) {
-                    this.$l.shadowTex = pb.textureArraySampleLevel(ShaderHelper.getShadowMap(this), this.coords.xy, this.split, 0);
-                } else {
-                    this.$l.shadowTex = pb.textureSampleLevel(ShaderHelper.getShadowMap(this), this.coords.xy, 0);
-                }
-                if (!floatDepthTexture) {
-                    this.shadowTex.x = decodeNormalizedFloatFromRGBA(this, this.shadowTex);
-                }
-                this.$return(pb.step(this.distance, this.shadowTex.x));
-            }
+            this.$return(pb.step(this.distance, this.shadowTex.x));
         });
-        return pb.getGlobalScope()[funcNameSampleShadowMapCSM](coords, split, z, bias);
+        return pb.getGlobalScope()[funcNameSampleShadowMap](coords, z, bias);
     }
 }
 
@@ -51204,9 +52349,9 @@ class VSMBlitter extends Blitter {
 const tmpMatrix$1 = new Matrix4x4();
 const tmpFrustum = new Frustum(Matrix4x4.identity());
 // const zeroPosition = Vector3.zero();
-/**
- * The shadow map generator
- * @public
+/**
+ * The shadow map generator
+ * @public
  */ class ShadowMapper extends Disposable {
     /** @internal */ static _snapMatrix = new Matrix4x4();
     /** @internal */ static _target = new Vector3();
@@ -51225,6 +52370,11 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
     /** @internal */ _pdSampleCount;
     /** @internal */ _pdSampleRadius;
     /** @internal */ _pcfKernelSize;
+    /** @internal */ _pcssLightRadius;
+    /** @internal */ _pcssBlockerSampleCount;
+    /** @internal */ _pcssFilterSampleCount;
+    /** @internal */ _pcssMaxFilterRadius;
+    /** @internal */ _pcssTemporalJitter;
     /** @internal */ _vsmBlurKernelSize;
     /** @internal */ _vsmBlurRadius;
     /** @internal */ _vsmDarkness;
@@ -51235,9 +52385,9 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
     /** @internal */ _esmDepthScale;
     /** @internal */ _shadowStrength;
     /** @internal */ _shadowRegion;
-    /**
-   * Creates an instance of ShadowMapper
-   * @param light - The light that is used to generate shadow map
+    /**
+   * Creates an instance of ShadowMapper
+   * @param light - The light that is used to generate shadow map
    */ constructor(light){
         super();
         this._light = light;
@@ -51250,12 +52400,17 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
             nearClip: 1
         };
         this._resourceDirty = true;
-        this._shadowMode = 'pcf-pd';
+        this._shadowMode = 'pcf';
         this._shadowDistance = 2000;
         this._impl = null;
         this._pdSampleCount = 24;
         this._pdSampleRadius = 3;
         this._pcfKernelSize = 7;
+        this._pcssLightRadius = 8;
+        this._pcssBlockerSampleCount = 24;
+        this._pcssFilterSampleCount = 32;
+        this._pcssMaxFilterRadius = 32;
+        this._pcssTemporalJitter = true;
         this._vsmBlurKernelSize = 5;
         this._vsmBlurRadius = 4;
         this._vsmDarkness = 0.3;
@@ -51385,14 +52540,14 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
             this.applyMode(this._shadowMode);
         }
     }
-    /**
-   * Applies a practical shadow preset for common scenarios.
-   *
-   * `character-small`: higher contact quality and tighter distance for character-centric scenes.
-   * `outdoor-large`: longer distance coverage for open scenes.
+    /**
+   * Applies a practical shadow preset for common scenarios.
+   *
+   * `character-small`: higher contact quality and tighter distance for character-centric scenes.
+   * `outdoor-large`: longer distance coverage for open scenes.
    */ applyQualityPreset(preset) {
         if (preset === 'character-small') {
-            this.mode = 'pcf-opt';
+            this.mode = 'pcf';
             this.shadowMapSize = 2048;
             this.shadowDistance = 120;
             this.splitLambda = 0.75;
@@ -51403,7 +52558,7 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
             this.numShadowCascades = this._light.isDirectionLight() ? 3 : 1;
             return;
         }
-        this.mode = 'pcf-opt';
+        this.mode = 'pcf';
         this.shadowMapSize = 2048;
         this.shadowDistance = 800;
         this.splitLambda = 0.6;
@@ -51452,6 +52607,71 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
             }
         }
     }
+    /** Light radius for PCSS shadow, measured in shadow-map texels */ get pcssLightRadius() {
+        return this._pcssLightRadius;
+    }
+    set pcssLightRadius(val) {
+        val = Math.max(0, Number(val) || 0);
+        if (val !== this._pcssLightRadius) {
+            this._pcssLightRadius = val;
+            const pcss = this.asPCSS();
+            if (pcss) {
+                pcss.lightRadius = this._pcssLightRadius;
+            }
+        }
+    }
+    /** Blocker search sample count for PCSS shadow */ get pcssBlockerSampleCount() {
+        return this._pcssBlockerSampleCount;
+    }
+    set pcssBlockerSampleCount(val) {
+        val = Math.min(Math.max(1, Number(val) >> 0), 64);
+        if (val !== this._pcssBlockerSampleCount) {
+            this._pcssBlockerSampleCount = val;
+            const pcss = this.asPCSS();
+            if (pcss) {
+                pcss.blockerSampleCount = this._pcssBlockerSampleCount;
+            }
+        }
+    }
+    /** Filter sample count for PCSS shadow */ get pcssFilterSampleCount() {
+        return this._pcssFilterSampleCount;
+    }
+    set pcssFilterSampleCount(val) {
+        val = Math.min(Math.max(1, Number(val) >> 0), 64);
+        if (val !== this._pcssFilterSampleCount) {
+            this._pcssFilterSampleCount = val;
+            const pcss = this.asPCSS();
+            if (pcss) {
+                pcss.filterSampleCount = this._pcssFilterSampleCount;
+            }
+        }
+    }
+    /** Maximum PCSS filter radius, measured in shadow-map texels */ get pcssMaxFilterRadius() {
+        return this._pcssMaxFilterRadius;
+    }
+    set pcssMaxFilterRadius(val) {
+        val = Math.max(1, Number(val) || 1);
+        if (val !== this._pcssMaxFilterRadius) {
+            this._pcssMaxFilterRadius = val;
+            const pcss = this.asPCSS();
+            if (pcss) {
+                pcss.maxFilterRadius = this._pcssMaxFilterRadius;
+            }
+        }
+    }
+    /** If true, rotates PCSS sampling pattern over frames for TAA accumulation */ get pcssTemporalJitter() {
+        return this._pcssTemporalJitter;
+    }
+    set pcssTemporalJitter(val) {
+        val = !!val;
+        if (val !== this._pcssTemporalJitter) {
+            this._pcssTemporalJitter = val;
+            const pcss = this.asPCSS();
+            if (pcss) {
+                pcss.temporalJitter = this._pcssTemporalJitter;
+            }
+        }
+    }
     /** Kernel size of VSM */ get vsmBlurKernelSize() {
         return this._vsmBlurKernelSize;
     }
@@ -51639,28 +52859,28 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
         const useTextureArray = numCascades > 1 && device.type !== 'webgl';
         const shadowMapWidth = numCascades > 1 && !useTextureArray ? 2 * this._config.shadowMapSize : this._config.shadowMapSize;
         const shadowMapHeight = numCascades > 2 && !useTextureArray ? 2 * this._config.shadowMapSize : this._config.shadowMapSize;
-        /*
-    const colorAttachments = colorFormat
-      ? useTextureArray
-        ? [device.pool.fetchTemporalTexture2DArray(false, colorFormat, shadowMapWidth, shadowMapHeight, numCascades, false)]
-        : this._light.isPointLight()
-          ? [device.pool.fetchTemporalTextureCube(false, colorFormat, shadowMapWidth, false)]
-          : [device.pool.fetchTemporalTexture2D(false, colorFormat, shadowMapWidth, shadowMapHeight, false)]
-      : null;
-    const depthAttachment = depthFormat
-      ? useTextureArray
-        ? device.pool.fetchTemporalTexture2DArray(false, depthFormat, shadowMapWidth, shadowMapHeight, numCascades, false)
-        : device.type !== 'webgl' && this._light.isPointLight()
-          ? device.pool.fetchTemporalTextureCube(false, depthFormat, shadowMapWidth, false)
-          : device.pool.fetchTemporalTexture2D(false, depthFormat, shadowMapWidth, shadowMapHeight, false)
-      : null;
-    shadowMapParams.shadowMapFramebuffer = device.pool.createTemporalFramebuffer(false, colorAttachments, depthAttachment);
-    if (colorAttachments) {
-      device.pool.releaseTexture(colorAttachments[0]);
-    }
-    if (depthAttachment) {
-      device.pool.releaseTexture(depthAttachment);
-    }
+        /*
+    const colorAttachments = colorFormat
+      ? useTextureArray
+        ? [device.pool.fetchTemporalTexture2DArray(false, colorFormat, shadowMapWidth, shadowMapHeight, numCascades, false)]
+        : this._light.isPointLight()
+          ? [device.pool.fetchTemporalTextureCube(false, colorFormat, shadowMapWidth, false)]
+          : [device.pool.fetchTemporalTexture2D(false, colorFormat, shadowMapWidth, shadowMapHeight, false)]
+      : null;
+    const depthAttachment = depthFormat
+      ? useTextureArray
+        ? device.pool.fetchTemporalTexture2DArray(false, depthFormat, shadowMapWidth, shadowMapHeight, numCascades, false)
+        : device.type !== 'webgl' && this._light.isPointLight()
+          ? device.pool.fetchTemporalTextureCube(false, depthFormat, shadowMapWidth, false)
+          : device.pool.fetchTemporalTexture2D(false, depthFormat, shadowMapWidth, shadowMapHeight, false)
+      : null;
+    shadowMapParams.shadowMapFramebuffer = device.pool.createTemporalFramebuffer(false, colorAttachments, depthAttachment);
+    if (colorAttachments) {
+      device.pool.releaseTexture(colorAttachments[0]);
+    }
+    if (depthAttachment) {
+      device.pool.releaseTexture(depthAttachment);
+    }
     */ shadowMapParams.shadowMapFramebuffer = ShadowMapper.fetchTemporalFramebuffer(true, this._light.lightType, numCascades, shadowMapWidth, shadowMapHeight, colorFormat, depthFormat);
         shadowMapParams.impl = this._impl;
         this._impl.updateResources(shadowMapParams);
@@ -51671,14 +52891,14 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
         lightCamera.position.setXYZ(0, 0, 0);
         lightCamera.rotation.identity();
         lightCamera.scale.setXYZ(1, 1, 1);
-        lightCamera.setPerspective(Math.PI / 2, 1, this._config.nearClip, Math.min(this._shadowDistance, this._light.range));
+        lightCamera.setPerspective(Math.PI / 2, 1, this._config.nearClip, Math.min(this._shadowDistance, this._light.positionAndRange.w));
         lightCamera.position.set(this._light.positionAndRange.xyz());
     }
     /** @internal */ createLightCameraSpot(lightCamera) {
         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));
+        lightCamera.setPerspective(2 * Math.acos(this._light.cutoff), 1, this._config.nearClip, Math.min(this._shadowDistance, this._light.positionAndRange.w));
     }
     /** @internal */ createLightCameraRect(lightCamera) {
         const rect = this._light;
@@ -51738,68 +52958,68 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
             center.setXYZ((rx - tx) * 2 / this.shadowMapSize, (ry - ty) * 2 / this.shadowMapSize, 0);
             cropMatrix.translation(center);
         }
-    /*
-    const minx = frustumMin.x;
-    const maxx = frustumMax.x;
-    const miny = frustumMin.y;
-    const maxy = frustumMax.y;
-    const minz = frustumMin.z;
-    const maxz = frustumMax.z;
-    const texelSizeW = (maxx - minx) / this.shadowMapSize;
-    const texelSizeH = (maxy - miny) / this.shadowMapSize;
-    const cx = Math.floor((minx + maxx) / 2 / texelSizeW) * texelSizeW;
-    const cy = Math.floor((miny + maxy) / 2 / texelSizeH) * texelSizeH;
-    const cz = (minz + maxz) / 2;
-    const hx = Math.floor(((maxx - minx) * (expand + 0.5)) / texelSizeW) * texelSizeW;
-    const hy = Math.floor(((maxy - miny) * (expand + 0.5)) / texelSizeH) * texelSizeH;
-    lightCamera.position.setXYZ(cx, cy, cz);
-    lightCamera.setOrtho(
-      -hx,
-      hx,
-      -hy,
-      hy,
-      sceneMax.z - maxz,
-      sceneMax.z - minz + 1
-    );
-    if (cropMatrix) {
-      // compute crop matrix
-      let clipMaxX = 0,
-        clipMaxY = 0;
-      let clipMinX = Number.MAX_VALUE,
-        clipMinY = Number.MAX_VALUE;
-      frustum.corners.forEach((p) => {
-        const clipPos = lightCamera.viewProjectionMatrix.transformPoint(p);
-        clipPos.x = Math.min(1, Math.max(-1, clipPos.x / clipPos.w));
-        clipPos.y = Math.min(1, Math.max(-1, clipPos.y / clipPos.w));
-        if (clipPos.x > clipMaxX) {
-          clipMaxX = clipPos.x;
-        }
-        if (clipPos.x < clipMinX) {
-          clipMinX = clipPos.x;
-        }
-        if (clipPos.y > clipMaxY) {
-          clipMaxY = clipPos.y;
-        }
-        if (clipPos.y < clipMinY) {
-          clipMinY = clipPos.y;
-        }
-      });
-      const clipW = clipMaxX - clipMinX;
-      const clipH = clipMaxY - clipMinY;
-      clipMinX -= expand * clipW;
-      clipMinY -= expand * clipH;
-      clipMaxX += expand * clipW;
-      clipMaxY += expand * clipH;
-      const scaleX = 2 / (clipMaxX - clipMinX);
-      const scaleY = 2 / (clipMaxY - clipMinY);
-      const offsetX = -0.5 * (clipMaxX + clipMinX) * scaleX;
-      const offsetY = -0.5 * (clipMaxY + clipMinY) * scaleY;
-      cropMatrix.identity();
-      cropMatrix.m00 = scaleX;
-      cropMatrix.m11 = scaleY;
-      cropMatrix.m03 = offsetX;
-      cropMatrix.m13 = offsetY;
-    }
+    /*
+    const minx = frustumMin.x;
+    const maxx = frustumMax.x;
+    const miny = frustumMin.y;
+    const maxy = frustumMax.y;
+    const minz = frustumMin.z;
+    const maxz = frustumMax.z;
+    const texelSizeW = (maxx - minx) / this.shadowMapSize;
+    const texelSizeH = (maxy - miny) / this.shadowMapSize;
+    const cx = Math.floor((minx + maxx) / 2 / texelSizeW) * texelSizeW;
+    const cy = Math.floor((miny + maxy) / 2 / texelSizeH) * texelSizeH;
+    const cz = (minz + maxz) / 2;
+    const hx = Math.floor(((maxx - minx) * (expand + 0.5)) / texelSizeW) * texelSizeW;
+    const hy = Math.floor(((maxy - miny) * (expand + 0.5)) / texelSizeH) * texelSizeH;
+    lightCamera.position.setXYZ(cx, cy, cz);
+    lightCamera.setOrtho(
+      -hx,
+      hx,
+      -hy,
+      hy,
+      sceneMax.z - maxz,
+      sceneMax.z - minz + 1
+    );
+    if (cropMatrix) {
+      // compute crop matrix
+      let clipMaxX = 0,
+        clipMaxY = 0;
+      let clipMinX = Number.MAX_VALUE,
+        clipMinY = Number.MAX_VALUE;
+      frustum.corners.forEach((p) => {
+        const clipPos = lightCamera.viewProjectionMatrix.transformPoint(p);
+        clipPos.x = Math.min(1, Math.max(-1, clipPos.x / clipPos.w));
+        clipPos.y = Math.min(1, Math.max(-1, clipPos.y / clipPos.w));
+        if (clipPos.x > clipMaxX) {
+          clipMaxX = clipPos.x;
+        }
+        if (clipPos.x < clipMinX) {
+          clipMinX = clipPos.x;
+        }
+        if (clipPos.y > clipMaxY) {
+          clipMaxY = clipPos.y;
+        }
+        if (clipPos.y < clipMinY) {
+          clipMinY = clipPos.y;
+        }
+      });
+      const clipW = clipMaxX - clipMinX;
+      const clipH = clipMaxY - clipMinY;
+      clipMinX -= expand * clipW;
+      clipMinY -= expand * clipH;
+      clipMaxX += expand * clipW;
+      clipMaxY += expand * clipH;
+      const scaleX = 2 / (clipMaxX - clipMinX);
+      const scaleY = 2 / (clipMaxY - clipMinY);
+      const offsetX = -0.5 * (clipMaxX + clipMinX) * scaleX;
+      const offsetY = -0.5 * (clipMaxY + clipMinY) * scaleY;
+      cropMatrix.identity();
+      cropMatrix.m00 = scaleX;
+      cropMatrix.m11 = scaleY;
+      cropMatrix.m03 = offsetX;
+      cropMatrix.m13 = offsetY;
+    }
     */ }
     /** {@inheritDoc Disposable.onDispose} */ onDispose() {
         this._shadowRegion.dispose();
@@ -52007,7 +53227,7 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
         this.postRenderShadowMap(shadowMapParams);
     }
     /** @internal */ applyMode(mode) {
-        if (mode !== 'hard' && mode !== 'vsm' && mode !== 'esm' && mode !== 'pcf-pd' && mode !== 'pcf-opt') {
+        if (mode !== 'hard' && mode !== 'vsm' && mode !== 'esm' && mode !== 'pcf' && mode !== 'pcf-pd' && mode !== 'pcf-opt' && mode !== 'pcss') {
             console.error(`ShadowMapper.setShadowMode() failed: invalid mode: ${mode}`);
             return;
         }
@@ -52021,10 +53241,10 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
             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') {
+        } else if (mode === 'pcf' || mode === 'pcf-opt' || mode === 'pcf-pd') {
             this._impl = new PCFOPT(this._pcfKernelSize);
+        } else if (mode === 'pcss') {
+            this._impl = new PCSS(this._pcssLightRadius, this._pcssBlockerSampleCount, this._pcssFilterSampleCount, this._pcssMaxFilterRadius, this._pcssTemporalJitter);
         }
     }
     /** @internal */ asVSM() {
@@ -52039,6 +53259,9 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
     /** @internal */ asPCFOPT() {
         return this._impl?.getType() === 'pcf-opt' ? this._impl : null;
     }
+    /** @internal */ asPCSS() {
+        return this._impl?.getType() === 'pcss' ? this._impl : null;
+    }
 }
 
 let _drawableId = 0;
@@ -57694,6 +58917,127 @@ class HeightBoundingGenerator extends RenderMipmap {
                         return this.SSS;
                     }
                 },
+                {
+                    name: 'SkinSSSEnabled',
+                    type: 'bool',
+                    phase: 0,
+                    default: false,
+                    options: {
+                        label: 'Enabled',
+                        group: 'PostProcessing/SkinSSS'
+                    },
+                    get (value) {
+                        value.bool[0] = this.skinSSS;
+                    },
+                    set (value) {
+                        this.skinSSS = value.bool[0];
+                    }
+                },
+                {
+                    name: 'SkinSSSStrength',
+                    type: 'float',
+                    phase: 0,
+                    default: 1,
+                    options: {
+                        label: 'Strength',
+                        group: 'PostProcessing/SkinSSS',
+                        minValue: 0,
+                        maxValue: 4
+                    },
+                    get (value) {
+                        value.num[0] = this.skinSSSStrength;
+                    },
+                    set (value) {
+                        this.skinSSSStrength = value.num[0];
+                    },
+                    isValid () {
+                        return this.skinSSS;
+                    }
+                },
+                {
+                    name: 'SkinSSSOpacity',
+                    type: 'float',
+                    phase: 0,
+                    default: 0.18,
+                    options: {
+                        label: 'Opacity',
+                        group: 'PostProcessing/SkinSSS',
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.skinSSSOpacity;
+                    },
+                    set (value) {
+                        this.skinSSSOpacity = value.num[0];
+                    },
+                    isValid () {
+                        return this.skinSSS;
+                    }
+                },
+                {
+                    name: 'SkinSSSSampleStep',
+                    type: 'float',
+                    phase: 0,
+                    default: 2,
+                    options: {
+                        label: 'SampleStep',
+                        group: 'PostProcessing/SkinSSS',
+                        minValue: 0.25,
+                        maxValue: 8
+                    },
+                    get (value) {
+                        value.num[0] = this.skinSSSSampleStep;
+                    },
+                    set (value) {
+                        this.skinSSSSampleStep = value.num[0];
+                    },
+                    isValid () {
+                        return this.skinSSS;
+                    }
+                },
+                {
+                    name: 'SkinSSSDepthScale',
+                    type: 'float',
+                    phase: 0,
+                    default: 80,
+                    options: {
+                        label: 'DepthScale',
+                        group: 'PostProcessing/SkinSSS',
+                        minValue: 0,
+                        maxValue: 256
+                    },
+                    get (value) {
+                        value.num[0] = this.skinSSSDepthScale;
+                    },
+                    set (value) {
+                        this.skinSSSDepthScale = value.num[0];
+                    },
+                    isValid () {
+                        return this.skinSSS;
+                    }
+                },
+                {
+                    name: 'SkinSSSColorBoost',
+                    type: 'float',
+                    phase: 0,
+                    default: 1,
+                    options: {
+                        label: 'ColorBoost',
+                        group: 'PostProcessing/SkinSSS',
+                        minValue: 0,
+                        maxValue: 4
+                    },
+                    get (value) {
+                        value.num[0] = this.skinSSSColorBoost;
+                    },
+                    set (value) {
+                        this.skinSSSColorBoost = value.num[0];
+                    },
+                    isValid () {
+                        return this.skinSSS;
+                    }
+                },
                 {
                     name: 'SSAOEnabled',
                     type: 'bool',
@@ -57929,9 +59273,9 @@ class HeightBoundingGenerator extends RenderMipmap {
     };
 }
 
-/**
- * Base class for any kind of light node
- * @public
+/**
+ * Base class for any kind of light node
+ * @public
  */ class BaseLight extends GraphNode {
     /** @internal */ _type;
     /** @internal */ _intensity;
@@ -57939,10 +59283,10 @@ class HeightBoundingGenerator extends RenderMipmap {
     /** @internal */ _directionCutoff;
     /** @internal */ _diffuseIntensity;
     /** @internal */ _extraParams;
-    /**
-   * Creates a light node
-   * @param scene - The scene to which the light node belongs
-   * @param type - Type of the light node
+    /**
+   * Creates a light node
+   * @param scene - The scene to which the light node belongs
+   * @param type - Type of the light node
    */ constructor(scene, type){
         super(scene);
         this._intensity = 1;
@@ -57961,66 +59305,66 @@ class HeightBoundingGenerator extends RenderMipmap {
     set intensity(val) {
         this.setIntensity(val);
     }
-    /**
-   * Position and range of the light
-   *
-   * @remarks
-   * Gets the position in world space of the light.
-   * Light range is encoded into the W component.
+    /**
+   * Position and range of the light
+   *
+   * @remarks
+   * Gets the position in world space of the light.
+   * Light range is encoded into the W component.
    */ get positionAndRange() {
         if (!this._positionRange) {
             this.computeUniforms();
         }
         return this._positionRange;
     }
-    /**
-   * Direction and cutoff of the light
-   *
-   * @remarks
-   * Gets the direction in world space of the light
-   * Light cutoff (for spot light only) is encoded into the W component.
+    /**
+   * Direction and cutoff of the light
+   *
+   * @remarks
+   * Gets the direction in world space of the light
+   * Light cutoff (for spot light only) is encoded into the W component.
    */ get directionAndCutoff() {
         if (!this._directionCutoff) {
             this.computeUniforms();
         }
         return this._directionCutoff;
     }
-    /**
-   * Color and intensity of the light
-   *
-   * @remarks
-   * Gets the color of the light.
-   * Light intensity is encoded into the W component.
+    /**
+   * Color and intensity of the light
+   *
+   * @remarks
+   * Gets the color of the light.
+   * Light intensity is encoded into the W component.
    */ get diffuseAndIntensity() {
         if (!this._diffuseIntensity) {
             this.computeUniforms();
         }
         return this._diffuseIntensity;
     }
-    /**
-   * Extra parameters of the light
-   *
-   * @remarks
-   * Custom data for advanced light types.
+    /**
+   * Extra parameters of the light
+   *
+   * @remarks
+   * Custom data for advanced light types.
    */ get extraParams() {
         if (!this._extraParams) {
             this.computeUniforms();
         }
         return this._extraParams;
     }
-    /**
-   * View matrix of the light
-   *
-   * @remarks
-   * The view matrix of the light is used to transform a point
-   * from the world space to the light space.
+    /**
+   * View matrix of the light
+   *
+   * @remarks
+   * The view matrix of the light is used to transform a point
+   * from the world space to the light space.
    */ get viewMatrix() {
         return this.invWorldMatrix;
     }
-    /**
-   * Sets the intensity of the light
-   * @param val - Intensity of the light
-   * @returns self
+    /**
+   * Sets the intensity of the light
+   * @param val - Intensity of the light
+   * @returns self
    */ setIntensity(val) {
         if (this._intensity !== val) {
             this._intensity = val;
@@ -58053,26 +59397,26 @@ class HeightBoundingGenerator extends RenderMipmap {
         return false;
     }
 }
-/*
-export abstract class AmbientLight extends BaseLight {
-  constructor(scene: Scene, type: number) {
-    super(scene, type);
-  }
-  isAmbientLight(): this is AmbientLight {
-    return true;
-  }
-}
-*/ /**
- * Base class for any kind of puncual light
- * @public
+/*
+export abstract class AmbientLight extends BaseLight {
+  constructor(scene: Scene, type: number) {
+    super(scene, type);
+  }
+  isAmbientLight(): this is AmbientLight {
+    return true;
+  }
+}
+*/ /**
+ * Base class for any kind of puncual light
+ * @public
  */ class PunctualLight extends BaseLight {
     /** @internal */ _color;
     /** @internal */ _castShadow;
     /** @internal */ _shadowMapper;
-    /**
-   * Creates an instance of punctual light
-   * @param scene - The scene to which the punctual light belongs
-   * @param type - The light type
+    /**
+   * Creates an instance of punctual light
+   * @param scene - The scene to which the punctual light belongs
+   * @param type - The light type
    */ constructor(scene, type){
         super(scene, type);
         this.ensurePunctualState();
@@ -58095,10 +59439,10 @@ export abstract class AmbientLight extends BaseLight {
     set color(color) {
         this.setColor(color);
     }
-    /**
-   * Sets color of the light
-   * @param color - The color to set
-   * @returns self
+    /**
+   * Sets color of the light
+   * @param color - The color to set
+   * @returns self
    */ setColor(color) {
         this.ensurePunctualState();
         this._color.set(color);
@@ -58112,10 +59456,10 @@ export abstract class AmbientLight extends BaseLight {
     set castShadow(b) {
         this.setCastShadow(b);
     }
-    /**
-   * Sets whether this light casts shadows
-   * @param b - true if the light casts shadows
-   * @returns self
+    /**
+   * Sets whether this light casts shadows
+   * @param b - true if the light casts shadows
+   * @returns self
    */ setCastShadow(b) {
         this.ensurePunctualState();
         if (this._castShadow !== !!b) {
@@ -58130,9 +59474,9 @@ export abstract class AmbientLight extends BaseLight {
         this.ensurePunctualState();
         return this._shadowMapper;
     }
-    /**
-   * {@inheritDoc BaseLight.isPunctualLight}
-   * @override
+    /**
+   * {@inheritDoc BaseLight.isPunctualLight}
+   * @override
    */ isPunctualLight() {
         return true;
     }
@@ -58147,14 +59491,14 @@ export abstract class AmbientLight extends BaseLight {
     }
     /** @internal */ computeUniforms() {}
 }
-/**
- * Directional light
- * @public
+/**
+ * Directional light
+ * @public
  */ class DirectionalLight extends PunctualLight {
     static _currentSunLight = new WeakMap();
-    /**
-   * Creates an instance of directional light
-   * @param scene - The scene to which the light belongs
+    /**
+   * Creates an instance of directional light
+   * @param scene - The scene to which the light belongs
    */ constructor(scene){
         super(scene, LIGHT_TYPE_DIRECTIONAL);
         this.intensity = 10;
@@ -58176,11 +59520,11 @@ export abstract class AmbientLight extends BaseLight {
             ref.set(light);
         }
     }
-    /**
-   * true if the light was defined as sun light
-   *
-   * @remarks
-   * Only one directional light will be marked as sun light.
+    /**
+   * true if the light was defined as sun light
+   *
+   * @remarks
+   * Only one directional light will be marked as sun light.
    **/ get sunLight() {
         return DirectionalLight.getSunLight(this.scene) === this;
     }
@@ -58191,9 +59535,9 @@ export abstract class AmbientLight extends BaseLight {
             DirectionalLight.setSunLight(this.scene, null);
         }
     }
-    /**
-   * {@inheritDoc BaseLight.isDirectionLight}
-   * @override
+    /**
+   * {@inheritDoc BaseLight.isDirectionLight}
+   * @override
    */ isDirectionLight() {
         return true;
     }
@@ -58209,20 +59553,20 @@ export abstract class AmbientLight extends BaseLight {
         this._extraParams = new Vector4(0, 0, 0, this.lightType);
     }
 }
-/**
- * Point light
- * @public
+/**
+ * Point light
+ * @public
  */ class PointLight extends PunctualLight {
     /** @internal */ _range;
     /** @internal */ _diffuseScale;
     /** @internal */ _specularScale;
     /** @internal */ _sourceRadius;
-    /**
-   * Creates an instance of point light
-   * @param scene - The scene to which the light belongs
+    /**
+   * Creates an instance of point light
+   * @param scene - The scene to which the light belongs
    */ constructor(scene){
         super(scene, LIGHT_TYPE_POINT);
-        this._range = 10;
+        this._range = 0;
         this._diffuseScale = 1;
         this._specularScale = 1;
         this._sourceRadius = 0;
@@ -58252,10 +59596,10 @@ export abstract class AmbientLight extends BaseLight {
     set sourceRadius(val) {
         this.setSourceRadius(val);
     }
-    /**
-   * Sets the range of the light
-   * @param val - The value to set
-   * @returns self
+    /**
+   * Sets the range of the light
+   * @param val - The value to set
+   * @returns self
    */ setRange(val) {
         val = val < 0 ? 0 : val;
         if (this._range !== val) {
@@ -58265,10 +59609,10 @@ export abstract class AmbientLight extends BaseLight {
         }
         return this;
     }
-    /**
-   * Sets the diffuse scale of the light
-   * @param val - The value to set
-   * @returns self
+    /**
+   * Sets the diffuse scale of the light
+   * @param val - The value to set
+   * @returns self
    */ setDiffuseScale(val) {
         val = val < 0 ? 0 : val;
         if (this._diffuseScale !== val) {
@@ -58277,10 +59621,10 @@ export abstract class AmbientLight extends BaseLight {
         }
         return this;
     }
-    /**
-   * Sets the specular scale of the light
-   * @param val - The value to set
-   * @returns self
+    /**
+   * Sets the specular scale of the light
+   * @param val - The value to set
+   * @returns self
    */ setSpecularScale(val) {
         val = val < 0 ? 0 : val;
         if (this._specularScale !== val) {
@@ -58289,10 +59633,10 @@ export abstract class AmbientLight extends BaseLight {
         }
         return this;
     }
-    /**
-   * Sets the source radius of the light
-   * @param val - The value to set
-   * @returns self
+    /**
+   * Sets the source radius of the light
+   * @param val - The value to set
+   * @returns self
    */ setSourceRadius(val) {
         val = val < 0 ? 0 : val;
         if (this._sourceRadius !== val) {
@@ -58301,39 +59645,41 @@ export abstract class AmbientLight extends BaseLight {
         }
         return this;
     }
-    /**
-   * {@inheritDoc BaseLight.isPointLight}
-   * @override
+    /**
+   * {@inheritDoc BaseLight.isPointLight}
+   * @override
    */ isPointLight() {
         return true;
     }
     /** @internal */ computeBoundingVolume() {
+        const range = this.positionAndRange.w;
         const bbox = new BoundingBox();
-        bbox.minPoint = new Vector3(-this._range, -this._range, -this._range);
-        bbox.maxPoint = new Vector3(this._range, this._range, this._range);
+        bbox.minPoint = new Vector3(-range, -range, -range);
+        bbox.maxPoint = new Vector3(range, range, range);
         return bbox;
     }
     /** @internal */ computeUniforms() {
         const a = this.worldMatrix.getRow(3);
         const b = this.worldMatrix.getRow(2);
-        this._positionRange = new Vector4(a.x, a.y, a.z, this.range);
+        const range = this.range <= 0 ? 32 * Math.sqrt(Math.max(0.0001, this.intensity * Math.max(this._diffuseScale, this._specularScale))) : this.range;
+        this._positionRange = new Vector4(a.x, a.y, a.z, range);
         this._directionCutoff = new Vector4(b.x, b.y, b.z, -1);
         this._diffuseIntensity = new Vector4(this.color.x, this.color.y, this.color.z, this.intensity);
         this._extraParams = new Vector4(this._diffuseScale, this._specularScale, this._sourceRadius, this.lightType);
     }
 }
-/**
- * Spot light
- * @public
+/**
+ * Spot light
+ * @public
  */ class SpotLight extends PunctualLight {
     /** @internal */ _range;
     /** @internal */ _cutoff;
-    /**
-   * Creates an instance of spot light
-   * @param scene - The scene to which the light belongs
+    /**
+   * Creates an instance of spot light
+   * @param scene - The scene to which the light belongs
    */ constructor(scene){
         super(scene, LIGHT_TYPE_SPOT);
-        this._range = 10;
+        this._range = 0;
         this._cutoff = Math.cos(Math.PI / 4);
         this.invalidateBoundingVolume();
     }
@@ -58343,10 +59689,10 @@ export abstract class AmbientLight extends BaseLight {
     set range(val) {
         this.setRange(val);
     }
-    /**
-   * Sets the range of the light
-   * @param val - The value to set
-   * @returns self
+    /**
+   * Sets the range of the light
+   * @param val - The value to set
+   * @returns self
    */ setRange(val) {
         val = val < 0 ? 0 : val;
         if (this._range !== val) {
@@ -58362,10 +59708,10 @@ export abstract class AmbientLight extends BaseLight {
     set cutoff(val) {
         this.setCutoff(val);
     }
-    /**
-   * Sets the cutoff of the light
-   * @param val - The value to set
-   * @returns self
+    /**
+   * Sets the cutoff of the light
+   * @param val - The value to set
+   * @returns self
    */ setCutoff(val) {
         val = val < 0 ? 0 : val;
         if (this._cutoff !== val) {
@@ -58375,39 +59721,41 @@ export abstract class AmbientLight extends BaseLight {
         }
         return this;
     }
-    /**
-   * {@inheritDoc BaseLight.isSpotLight}
-   * @override
+    /**
+   * {@inheritDoc BaseLight.isSpotLight}
+   * @override
    */ isSpotLight() {
         return true;
     }
     /** @internal */ computeBoundingVolume() {
         const bbox = new BoundingBox();
         const cosCutoff = Math.cos(this._cutoff);
-        const r = this._range / cosCutoff * Math.sqrt(1 - cosCutoff * cosCutoff);
+        const range = this.positionAndRange.w;
+        const r = range / cosCutoff * Math.sqrt(1 - cosCutoff * cosCutoff);
         bbox.minPoint = new Vector3(-r, -r, 0);
-        bbox.maxPoint = new Vector3(r, r, this._range);
+        bbox.maxPoint = new Vector3(r, r, range);
         return bbox;
     }
     /** @internal */ computeUniforms() {
         const a = this.worldMatrix.getRow(3);
         const b = this.worldMatrix.getRow(2).scaleBy(-1);
-        this._positionRange = new Vector4(a.x, a.y, a.z, this.range);
+        const range = this.range <= 0 ? 32 * Math.sqrt(Math.max(0.0001, this.intensity)) : this.range;
+        this._positionRange = new Vector4(a.x, a.y, a.z, range);
         this._directionCutoff = new Vector4(b.x, b.y, b.z, this.cutoff);
         this._diffuseIntensity = new Vector4(this.color.x, this.color.y, this.color.z, this.intensity);
         this._extraParams = new Vector4(0, 0, 0, this.lightType);
     }
 }
-/**
- * Rectangular area light
- * @public
+/**
+ * Rectangular area light
+ * @public
  */ class RectLight extends PunctualLight {
     /** @internal */ _range;
     /** @internal */ _width;
     /** @internal */ _height;
-    /**
-   * Creates an instance of rect light
-   * @param scene - The scene to which the light belongs
+    /**
+   * Creates an instance of rect light
+   * @param scene - The scene to which the light belongs
    */ constructor(scene){
         super(scene, LIGHT_TYPE_RECT);
         this._range = 10;
@@ -58421,10 +59769,10 @@ export abstract class AmbientLight extends BaseLight {
     set range(val) {
         this.setRange(val);
     }
-    /**
-   * Sets the range of the light
-   * @param val - The value to set
-   * @returns self
+    /**
+   * Sets the range of the light
+   * @param val - The value to set
+   * @returns self
    */ setRange(val) {
         val = val < 0 ? 0 : val;
         if (this._range !== val) {
@@ -58440,10 +59788,10 @@ export abstract class AmbientLight extends BaseLight {
     set width(val) {
         this.setWidth(val);
     }
-    /**
-   * Sets the width of the light
-   * @param val - The value to set
-   * @returns self
+    /**
+   * Sets the width of the light
+   * @param val - The value to set
+   * @returns self
    */ setWidth(val) {
         val = val < 0 ? 0 : val;
         if (this._width !== val) {
@@ -58459,10 +59807,10 @@ export abstract class AmbientLight extends BaseLight {
     set height(val) {
         this.setHeight(val);
     }
-    /**
-   * Sets the height of the light
-   * @param val - The value to set
-   * @returns self
+    /**
+   * Sets the height of the light
+   * @param val - The value to set
+   * @returns self
    */ setHeight(val) {
         val = val < 0 ? 0 : val;
         if (this._height !== val) {
@@ -58472,14 +59820,14 @@ export abstract class AmbientLight extends BaseLight {
         }
         return this;
     }
-    /**
-   * {@inheritDoc BaseLight.isRectLight}
-   * @override
+    /**
+   * {@inheritDoc BaseLight.isRectLight}
+   * @override
    */ isRectLight() {
         return true;
     }
-    /**
-   * Rect light supports shadow in current pipeline
+    /**
+   * Rect light supports shadow in current pipeline
    */ /** @internal */ computeBoundingVolume() {
         const bbox = new BoundingBox();
         const r = this._range;
@@ -58567,16 +59915,20 @@ export abstract class AmbientLight extends BaseLight {
                             labels: [
                                 'Hard',
                                 'PCF',
-                                'PCF-PD',
+                                'PCSS',
                                 'VSM',
-                                'ESM'
+                                'ESM',
+                                'PCF-OPT (deprecated)',
+                                'PCF-PD (deprecated)'
                             ],
                             values: [
                                 'hard',
-                                'pcf-opt',
-                                'pcf-pd',
+                                'pcf',
+                                'pcss',
                                 'vsm',
-                                'esm'
+                                'esm',
+                                'pcf-opt',
+                                'pcf-pd'
                             ]
                         }
                     },
@@ -58729,6 +60081,26 @@ export abstract class AmbientLight extends BaseLight {
                         return !!this.castShadow;
                     }
                 },
+                {
+                    name: 'ShadowNearClip',
+                    description: 'Near clip distance for shadow camera',
+                    type: 'float',
+                    phase: 1,
+                    default: 1,
+                    options: {
+                        minValue: 0.01,
+                        maxValue: 10
+                    },
+                    get (value) {
+                        value.num[0] = this.shadow.nearClip;
+                    },
+                    set (value) {
+                        this.shadow.nearClip = value.num[0];
+                    },
+                    isValid () {
+                        return !!this.castShadow && !this.isDirectionLight();
+                    }
+                },
                 {
                     name: 'ShadowStrength',
                     description: 'Shadow strength, 0 means disabled and 1 means full effect',
@@ -58796,47 +60168,103 @@ export abstract class AmbientLight extends BaseLight {
                         this.shadow.pcfKernelSize = value.num[0];
                     },
                     isValid () {
-                        return !!this.castShadow && this.shadow.mode === 'pcf-opt';
+                        return !!this.castShadow && (this.shadow.mode === 'pcf' || this.shadow.mode === 'pcf-opt');
                     }
                 },
                 {
-                    name: 'PCFSampleCount',
-                    description: 'Sample count for PCF shadow',
+                    name: 'PCSSLightRadius',
+                    description: 'Light radius for PCSS shadow',
+                    type: 'float',
+                    phase: 2,
+                    options: {
+                        minValue: 0,
+                        maxValue: 64
+                    },
+                    default: 8,
+                    get (value) {
+                        value.num[0] = this.shadow.pcssLightRadius;
+                    },
+                    set (value) {
+                        this.shadow.pcssLightRadius = value.num[0];
+                    },
+                    isValid () {
+                        return !!this.castShadow && this.shadow.mode === 'pcss';
+                    }
+                },
+                {
+                    name: 'PCSSBlockerSampleCount',
+                    description: 'Blocker search sample count for PCSS shadow',
                     type: 'int',
                     phase: 2,
                     options: {
                         minValue: 1,
-                        maxValue: 128
+                        maxValue: 64
                     },
-                    default: 12,
+                    default: 24,
                     get (value) {
-                        value.num[0] = this.shadow.pdSampleCount;
+                        value.num[0] = this.shadow.pcssBlockerSampleCount;
                     },
                     set (value) {
-                        this.shadow.pdSampleCount = value.num[0];
+                        this.shadow.pcssBlockerSampleCount = value.num[0];
                     },
                     isValid () {
-                        return !!this.castShadow && this.shadow.mode === 'pcf-pd';
+                        return !!this.castShadow && this.shadow.mode === 'pcss';
                     }
                 },
                 {
-                    name: 'PCFSampleRadius',
-                    description: 'Sample radius for PCF shadow',
-                    type: 'float',
+                    name: 'PCSSFilterSampleCount',
+                    description: 'Filter sample count for PCSS shadow',
+                    type: 'int',
                     phase: 2,
                     options: {
-                        minValue: 0,
+                        minValue: 1,
                         maxValue: 64
                     },
-                    default: 4,
+                    default: 32,
+                    get (value) {
+                        value.num[0] = this.shadow.pcssFilterSampleCount;
+                    },
+                    set (value) {
+                        this.shadow.pcssFilterSampleCount = value.num[0];
+                    },
+                    isValid () {
+                        return !!this.castShadow && this.shadow.mode === 'pcss';
+                    }
+                },
+                {
+                    name: 'PCSSMaxFilterRadius',
+                    description: 'Maximum filter radius for PCSS shadow',
+                    type: 'float',
+                    phase: 2,
+                    options: {
+                        minValue: 1,
+                        maxValue: 128
+                    },
+                    default: 32,
                     get (value) {
-                        value.num[0] = this.shadow.pdSampleRadius;
+                        value.num[0] = this.shadow.pcssMaxFilterRadius;
                     },
                     set (value) {
-                        this.shadow.pdSampleRadius = value.num[0];
+                        this.shadow.pcssMaxFilterRadius = value.num[0];
                     },
                     isValid () {
-                        return !!this.castShadow && this.shadow.mode === 'pcf-pd';
+                        return !!this.castShadow && this.shadow.mode === 'pcss';
+                    }
+                },
+                {
+                    name: 'PCSSTemporalJitter',
+                    description: 'If true, rotate PCSS sampling pattern over frames for TAA accumulation',
+                    type: 'bool',
+                    phase: 2,
+                    default: true,
+                    get (value) {
+                        value.bool[0] = this.shadow.pcssTemporalJitter;
+                    },
+                    set (value) {
+                        this.shadow.pcssTemporalJitter = value.bool[0];
+                    },
+                    isValid () {
+                        return !!this.castShadow && this.shadow.mode === 'pcss';
                     }
                 },
                 {
@@ -69081,9 +70509,9 @@ function getLitMaterialProps(manager) {
             name: 'doubleSidedLighting',
             description: 'If true, lighting is evaluated on both sides of the surface',
             type: 'bool',
-            default: false,
+            default: true,
             isValid () {
-                return !this.$isInstance && this.cullMode !== 'back';
+                return !this.$isInstance;
             },
             get (value) {
                 value.bool[0] = this.doubleSidedLighting;
@@ -69092,6 +70520,27 @@ function getLitMaterialProps(manager) {
                 this.doubleSidedLighting = value.bool[0];
             }
         },
+        {
+            name: 'NormalScale',
+            description: 'Scalar applied to the normal texture',
+            type: 'float',
+            phase: 1,
+            default: 1,
+            options: {
+                animatable: true,
+                minValue: 0,
+                maxValue: 2
+            },
+            get (value) {
+                value.num[0] = this.normalScale;
+            },
+            set (value) {
+                this.normalScale = value.num[0];
+            },
+            isValid () {
+                return !this.$isInstance && !!this.normalTexture;
+            }
+        },
         {
             name: 'vertexNormal',
             description: 'If true, uses vertex normals for lighting and normal mapping',
@@ -70183,6 +71632,176 @@ function getMToonMaterialProps(manager) {
         getMeshMaterialInstanceUniformsClass(BlinnMaterial)
     ];
 }
+/** @internal */ function getSkinMaterialClass(manager) {
+    return [
+        {
+            ctor: SkinMaterial,
+            parent: MeshMaterial,
+            name: 'SkinMaterial',
+            getProps () {
+                return defineProps([
+                    {
+                        name: 'Shininess',
+                        description: 'Blinn specular exponent for skin highlights',
+                        type: 'float',
+                        default: 72,
+                        options: {
+                            animatable: true,
+                            minValue: 1,
+                            maxValue: 2048
+                        },
+                        get (value) {
+                            value.num[0] = this.shininess;
+                        },
+                        set (value) {
+                            this.shininess = value.num[0];
+                        },
+                        getDefaultValue () {
+                            return this.$isInstance ? this.coreMaterial.shininess : 72;
+                        }
+                    },
+                    {
+                        name: 'SpecularStrength',
+                        description: 'Direct specular strength for restrained skin highlights',
+                        type: 'float',
+                        default: 0.22,
+                        options: {
+                            animatable: true,
+                            minValue: 0,
+                            maxValue: 4
+                        },
+                        get (value) {
+                            value.num[0] = this.specularStrength;
+                        },
+                        set (value) {
+                            this.specularStrength = value.num[0];
+                        },
+                        getDefaultValue () {
+                            return this.$isInstance ? this.coreMaterial.specularStrength : 0.22;
+                        }
+                    },
+                    {
+                        name: 'DiffuseWrap',
+                        description: 'Wrap amount for visible diffuse lighting',
+                        type: 'float',
+                        default: 0.28,
+                        options: {
+                            animatable: true,
+                            minValue: 0,
+                            maxValue: 2
+                        },
+                        get (value) {
+                            value.num[0] = this.diffuseWrap;
+                        },
+                        set (value) {
+                            this.diffuseWrap = value.num[0];
+                        },
+                        getDefaultValue () {
+                            return this.$isInstance ? this.coreMaterial.diffuseWrap : 0.28;
+                        }
+                    },
+                    {
+                        name: 'DiffuseSoftness',
+                        description: 'Blend from hard Lambert lighting to wrapped diffuse lighting',
+                        type: 'float',
+                        default: 0.45,
+                        options: {
+                            animatable: true,
+                            minValue: 0,
+                            maxValue: 1
+                        },
+                        get (value) {
+                            value.num[0] = this.diffuseSoftness;
+                        },
+                        set (value) {
+                            this.diffuseSoftness = value.num[0];
+                        },
+                        getDefaultValue () {
+                            return this.$isInstance ? this.coreMaterial.diffuseSoftness : 0.45;
+                        }
+                    },
+                    {
+                        name: 'ScatterWrap',
+                        description: 'Wide wrap amount written to the Skin SSS scattering source',
+                        type: 'float',
+                        default: 0.65,
+                        options: {
+                            animatable: true,
+                            minValue: 0,
+                            maxValue: 2
+                        },
+                        get (value) {
+                            value.num[0] = this.scatterWrap;
+                        },
+                        set (value) {
+                            this.scatterWrap = value.num[0];
+                        },
+                        getDefaultValue () {
+                            return this.$isInstance ? this.coreMaterial.scatterWrap : 0.65;
+                        }
+                    },
+                    {
+                        name: 'ScatterStrength',
+                        description: 'Strength of the lighting multiplier written to the Skin SSS side buffer',
+                        type: 'float',
+                        default: 0.7,
+                        options: {
+                            animatable: true,
+                            minValue: 0,
+                            maxValue: 4
+                        },
+                        get (value) {
+                            value.num[0] = this.scatterStrength;
+                        },
+                        set (value) {
+                            this.scatterStrength = value.num[0];
+                        },
+                        getDefaultValue () {
+                            return this.$isInstance ? this.coreMaterial.scatterStrength : 0.7;
+                        }
+                    },
+                    {
+                        name: 'ScatterColor',
+                        description: 'Warm tint for the blurred skin scattering contribution',
+                        type: 'rgba',
+                        default: [
+                            1,
+                            0.42,
+                            0.28,
+                            1
+                        ],
+                        options: {
+                            animatable: true,
+                            minValue: 0,
+                            maxValue: 1
+                        },
+                        get (value) {
+                            value.num[0] = this.scatterColor.x;
+                            value.num[1] = this.scatterColor.y;
+                            value.num[2] = this.scatterColor.z;
+                            value.num[3] = this.scatterColor.w;
+                        },
+                        set (value) {
+                            this.scatterColor = new Vector4(value.num[0], value.num[1], value.num[2], value.num[3]);
+                        },
+                        getDefaultValue () {
+                            const color = this.$isInstance ? this.coreMaterial.scatterColor : new Vector4(1, 0.42, 0.28, 1);
+                            return [
+                                color.x,
+                                color.y,
+                                color.z,
+                                color.w
+                            ];
+                        }
+                    },
+                    ...getTextureProps(manager, 'subsurfaceTexture', '2D', false, 1),
+                    ...getLitMaterialProps(manager)
+                ]);
+            }
+        },
+        getMeshMaterialInstanceUniformsClass(SkinMaterial)
+    ];
+}
 /** @internal */ function getPBRMetallicRoughnessMaterialClass(manager) {
     return [
         {
@@ -80491,6 +82110,7 @@ const defaultValues = {
             ...getMToonMaterialClass(this),
             ...getLambertMaterialClass(this),
             ...getBlinnMaterialClass(this),
+            ...getSkinMaterialClass(this),
             ...getPBRMetallicRoughnessMaterialClass(this),
             ...getPBRSpecularGlossinessMaterialClass(this),
             ...getParticleMaterialClass(this),
@@ -91244,6 +92864,195 @@ class GPUClothWrapBinding {
     }
 }
 
+/** @internal */ class PCFPD extends ShadowImpl {
+    static SHADER_VERSION = 3;
+    _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;
+    }
+    getPCFKernelSize() {
+        if (this._sampleRadius >= 4 || this._tapCount >= 32) {
+            return 7;
+        }
+        if (this._sampleRadius >= 2 || this._tapCount >= 12) {
+            return 5;
+        }
+        return 3;
+    }
+    getParams() {}
+    getShadowMapBorder(_shadowMapParams) {
+        return Math.max(this._sampleRadius + 1, this.getPCFKernelSize());
+    }
+    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() {}
+    getDepthScale() {
+        return this._sampleRadius;
+    }
+    setDepthScale(val) {
+        this._sampleRadius = val;
+    }
+    getShaderHash() {
+        return `${PCFPD.SHADER_VERSION}-${this._tapCount}-${this._sampleRadius}`;
+    }
+    getShadowMapColorFormat(shadowMapParams) {
+        if (this.useNativeShadowMap(shadowMapParams)) {
+            return null;
+        } else {
+            const device = getDevice();
+            return device.getDeviceCaps().textureCaps.supportHalfFloatColorBuffer ? device.type === 'webgl' ? 'rgba16f' : 'r16f' : device.getDeviceCaps().textureCaps.supportFloatColorBuffer ? device.type === 'webgl' ? 'rgba32f' : 'r32f' : 'rgba8unorm';
+        }
+    }
+    getShadowMapDepthFormat(_shadowMapParams) {
+        return getDevice().type === 'webgl' ? 'd24s8' : 'd32f';
+    }
+    computeShadowMapDepth(shadowMapParams, scope, worldPos) {
+        return computeShadowMapDepth(scope, worldPos, shadowMapParams.shadowMap.format);
+    }
+    computeShadowCSM(shadowMapParams, scope, shadowVertex, NdotL, split) {
+        const funcNameComputeShadowCSM = 'lib_computeShadowCSM';
+        const pb = scope.$builder;
+        const kernelSize = this.getPCFKernelSize();
+        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.$l.shadowBias = computeShadowBiasCSM(this, this.NdotL, this.split);
+                this.shadowCoord.z = pb.sub(this.shadowCoord.z, this.shadowBias);
+                this.shadow = filterShadowPCF(this, shadowMapParams.lightType, shadowMapParams.shadowMap.format, kernelSize, this.shadowCoord, undefined, 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;
+        const kernelSize = this.getPCFKernelSize();
+        pb.func(funcNameComputeShadow, [
+            pb.vec4('shadowVertex'),
+            pb.float('NdotL')
+        ], function() {
+            if (shadowMapParams.lightType === LIGHT_TYPE_POINT) {
+                this.$l.dir = pb.sub(this.shadowVertex.xyz, ShaderHelper.getLightPositionAndRangeForShadow(this).xyz);
+                if (that.useNativeShadowMap(shadowMapParams)) {
+                    this.$l.nearFar = ShaderHelper.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 = ShaderHelper.linearDepthToNonLinear(this, this.maxZ, this.nearFar);
+                    this.$l.shadowBias = computeShadowBias(shadowMapParams.lightType, this, pb.div(this.maxZ, ShaderHelper.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), ShaderHelper.getLightPositionAndRangeForShadow(this).w);
+                    this.$l.shadowBias = computeShadowBias(shadowMapParams.lightType, 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.$if(this.inShadow, function() {
+                    this.$l.shadowBias = computeShadowBias(shadowMapParams.lightType, 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, kernelSize, this.shadowCoord);
+                });
+                this.$return(this.shadow);
+            }
+        });
+        return pb.getGlobalScope()[funcNameComputeShadow](shadowVertex, NdotL);
+    }
+    useNativeShadowMap(_shadowMapParams) {
+        return getDevice().type !== 'webgl';
+    }
+    /** @internal */ sampleShadowMap(shadowMapParams, scope, coords, z, bias) {
+        const funcNameSampleShadowMap = 'lib_sampleShadowMapPD';
+        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(ShaderHelper.getShadowMap(this), this.coords, pb.sub(this.z, this.bias)), 0, 1));
+            } else {
+                this.$l.shadowTex = pb.textureSampleLevel(ShaderHelper.getShadowMap(this), 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_sampleShadowMapCSMPD';
+        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(ShaderHelper.getShadowMap(this), this.coords.xy, this.split, this.distance), 0, 1));
+                } else {
+                    this.$return(pb.clamp(pb.textureSampleCompareLevel(ShaderHelper.getShadowMap(this), this.coords.xy, this.distance), 0, 1));
+                }
+            } else {
+                if (shadowMapParams.shadowMap.isTexture2DArray()) {
+                    this.$l.shadowTex = pb.textureArraySampleLevel(ShaderHelper.getShadowMap(this), this.coords.xy, this.split, 0);
+                } else {
+                    this.$l.shadowTex = pb.textureSampleLevel(ShaderHelper.getShadowMap(this), 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);
+    }
+}
+
 /**
  * Named object interface for model loading
  * @public
@@ -95677,7 +97486,8 @@ const DEFAULT_PADDING = 6;
             '/materials/blinnphong.zmtl': BlinnMaterial,
             '/materials/pbr_metallic_roughness.zmtl': PBRMetallicRoughnessMaterial,
             '/materials/pbr_specular_glossiness.zmtl': PBRSpecularGlossinessMaterial,
-            '/materials/sprite_std.zmtl': StandardSpriteMaterial
+            '/materials/sprite_std.zmtl': StandardSpriteMaterial,
+            '/materials/skin.zmtl': SkinMaterial
         };
         for (const [key] of objectEntries(shapeClsMap)){
             const obj = new shapeClsMap[key]();
@@ -95914,5 +97724,5 @@ const DEFAULT_PADDING = 6;
     }
 }
 
-export { AABBTree, ABufferOIT, ATMOSPHERIC_FOG_BIT, AbsNode, AbstractPostEffect, AllConditionNode, AnimationClip, AnimationController, AnimationPlayback, AnimationSet, AnimationTimeline, AnimationTimelineRunner, AnimationTrack, AnyConditionNode, Application, ArcCosNode, ArcSinNode, ArcTan2Node, ArcTanNode, ArccosineHNode, ArcsineHNode, ArctangentHNode, AssetHierarchyNode, AssetManager, AssetScene, AssetSkeleton, AvatarOutfitInstance, AvatarWardrobe, BUILTIN_ASSET_TEST_CUBEMAP, BUILTIN_ASSET_TEXTURE_SHEEN_LUT, BaseCameraController, BaseGraphNode, BaseLight, BaseSprite, BaseTextureNode, BatchGroup, BillboardMatrixNode, BlinnMaterial, Blitter, Bloom, BoundingBox, BoxFilterBlitter, BoxFrameShape, BoxShape, CAMERA_POS_Y, CCDSolver, Camera, CameraNearFarNode, CameraPositionNode, CameraVectorNode, CapsuleShape, CeilNode, ClampNode, Clipmap, ClipmapTerrain, ClipmapTerrainMaterial, ColliderForce, ColorAdjust, CompAddNode, CompComparisonNode, CompDivNode, CompMulNode, CompSubNode, Compositor, ConstantBVec2Node, ConstantBVec3Node, ConstantBVec4Node, ConstantBooleanNode, ConstantScalarNode, ConstantTexture2DArrayNode, ConstantTexture2DNode, ConstantTextureCubeNode, ConstantVec2Node, ConstantVec3Node, ConstantVec4Node, ConstraintType, CopyBlitter, CosHNode, CosNode, CrossProductNode, CubemapSHProjector, CullVisitor, CylinderShape, DDXNode, DDYNode, Degrees2RadiansNode, DepthPass, DevicePoolAllocator, DirectionalLight, DistanceNode, DotProductNode, DracoMeshDecoder, EPSILON$1 as EPSILON, ESM, ElapsedTimeNode, Engine, EnvConstantAmbient, EnvHemisphericAmbient, EnvLightWrapper, EnvShIBL, Environment, EnvironmentLighting, EqualNode, Exp2Node, ExpNode, FABRIKSolver, FBMWaveGenerator, FFTWaveGenerator, FPSCameraController, FWidthNode, FXAA, FaceForwardNode, FixedGeometryCacheTrack, FloorNode, FmaNode, Fog, FontAsset, FractNode, FunctionCallNode, FunctionInputNode, FunctionOutputNode, GPUClothSystem, GaussianBlurBlitter, GenericMathNode, GerstnerWaveGenerator, GraphNode, GrassInstances, GrassLayer, GrassMaterial, GrassQuadtreeNode, GrassRenderer, Grayscale, HEIGHT_FOG_BIT, Hash1Node, Hash2Node, Hash3Node, HistoryResourceManager, HumanoidBodyRig, HumanoidHandRig, IKAngleConstraint, IKChain, IKConstraint, IKModifier, IKSolver, InputManager, InstanceBindGroupAllocator, InstanceIndexNode, InvProjMatrixNode, InvSqrtNode, InvViewProjMatrixNode, JointDynamicsModifier, JointDynamicsSystem, JointDynamicsSystemController, LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_NONE, LIGHT_TYPE_POINT, LIGHT_TYPE_RECT, LIGHT_TYPE_SPOT, LambertMaterial, LengthNode, LightPass, Log2Node, LogNode, LogicallyAndNode, LogicallyOrNode, MAX_CLUSTERED_LIGHTS, MAX_GERSTNER_WAVE_COUNT, MAX_MORPH_ATTRIBUTES, MAX_MORPH_TARGETS, MAX_TERRAIN_MIPMAP_LEVELS, MORPH_ATTRIBUTE_VECTOR_COUNT, MORPH_TARGET_COLOR, MORPH_TARGET_NORMAL, MORPH_TARGET_POSITION, MORPH_TARGET_TANGENT, MORPH_TARGET_TEX0, MORPH_TARGET_TEX1, MORPH_TARGET_TEX2, MORPH_TARGET_TEX3, MORPH_WEIGHTS_VECTOR_COUNT, MSDFText, MSDFTextAtlasManager, MSDFTextSprite, MToonMaterial, MakeVectorNode, Material, MaterialBlueprintIR, MaterialVaryingFlags, MaxNode, Mesh, MeshMaterial, MinNode, MixNode, ModNode, MorphTargetGroupTrack, MorphTargetTrack, MultiChainSpringSystem, NamedObject, NodeEulerRotationTrack, NodeRotationTrack, NodeScaleTrack, NodeTranslationTrack, NormalizeNode, NotEqualNode, Octree, OctreeNode, OctreeNodeChunk, OctreePlacement, OrbitCameraController, OrthoCamera, PBRBlockNode, PBRBluePrintMaterial, PBRMetallicRoughnessMaterial, PBRSpecularGlossinessMaterial, PCAGeometryCacheTrack, PCFOPT, PCFPD, PannerNode, ParticleMaterial, ParticleSystem, PerlinNoise2DNode, PerspectiveCamera, PixelNormalNode, PixelWorldPositionNode, PlaneShape, PointLight, PostEffectLayer, PowNode, Primitive, ProjectionMatrixNode, PropertyTrack, PunctualLight, QUEUE_OPAQUE, QUEUE_TRANSPARENT, RENDER_PASS_TYPE_DEPTH, RENDER_PASS_TYPE_LIGHT, RENDER_PASS_TYPE_OBJECT_COLOR, RENDER_PASS_TYPE_SHADOWMAP, RGHandle, RGHistoryResources, RGSubpass, Radians2DegreesNode, RaycastVisitor, RectLight, ReflectNode, RefractNode, RenderGraph, RenderGraphExecutor, RenderPass, RenderQueue, RenderTarget, ResolveVertexNormalNode, ResolveVertexPositionNode, ResolveVertexTangentNode, ResourceManager, RotateAboutAxisNode, RuntimeScript, SAO, SSS, SaturateNode, Scene, SceneNode, SceneRenderer, ScreenAdapter, ScreenRenderTarget, ScriptAttachment, ScriptRegistry, ScriptingSystem, SelectionNode, ShaderHelper, ShadowMapPass, ShadowMapper, ShadowRegion, Shape, SharedModel, SignNode, SimplexNoise2DNode, SinHNode, SinNode, Skeleton, SkeletonModifier, SkeletonRig, SkinBinding, SkyEnvTextureNode, SkyRenderer, SmoothStepNode, SphereShape, SpotLight, SpringChain, SpringModifier, SpringSystem, Sprite, SpriteBlockNode, SpriteBlueprintMaterial, SpriteMaterial, SqrtNode, StandardSpriteMaterial, StepNode, SubsurfaceProfile, SwizzleNode, TAA, TAA_DEBUG_ALAPH, TAA_DEBUG_CURRENT_COLOR, TAA_DEBUG_EDGE, TAA_DEBUG_HISTORY_COLOR, TAA_DEBUG_MOTION_VECTOR, TAA_DEBUG_NONE, TAA_DEBUG_STRENGTH, TAA_DEBUG_VELOCITY, TanHNode, TanNode, TetrahedronFrameShape, TetrahedronShape, TextSprite, TextureSampleGrad, TextureSampleNode, Tonemap, TorusShape, TransformNode, TwoBoneIKSolver, UnlitMaterial, VSM, VertexBinormalNode, VertexBlockNode, VertexColorNode, VertexIndexNode, VertexNormalNode, VertexOutputNode, VertexPositionNode, VertexTangentNode, VertexUVNode, ViewMatrixNode, ViewProjMatrixNode, Water, WaterShaderImpl, WeightedBlendedOIT, aerialPerspective, aerialPerspectiveLut, appInstance, applyAngleLimits, applyMaterialMixins, applyResult, applyRuntimeScriptConfig, atmosphereLUTRendered, buildConstraints, buildForwardPlusGraph, buildMSDFShape, buildSurfaceFaces, checkSurfaceCollision, collisionDetection, collisionDetectionCapsule, collisionDetectionSphere, computeMaxDepth, computeNearestPoints, copyTexture, createAPLutProgram, createCapsuleCollider, createGPUClothWrapBindingData, createGeometryCacheState, createGradientNoiseTexture, createMultiScatteringLutProgram, createPlaneCollider, createProgramFFT2H, createProgramFFT2V, createProgramH0, createProgramHk, createProgramOcean, createProgramPostFFT2, createRandomNoiseTexture, createSkyViewLutProgram, createSphereCollider, createSpringConstraint, createSpringParticle, createTransformAccess, createTransmittanceLutProgram, debugTexture, decode2HalfFromRGBA, decodeFloatFromRGBA, decodeNormalizedFloatFromRGBA, decodeRGBM, defineProps, encode2HalfToRGBA, encodeFloatToRGBA, encodeNormalizedFloatToRGBA, encodeRGBM, ensureGeometryCacheMeshBinding, executeForwardPlusGraph, extractLocalTwist, fetchNormalizedFloatForDevice, fetchSampler, gammaToLinear, generateMSDF, getAerialPerspectiveLut, getApp, getAtmosphereParamsStruct, getBatchGroupClass, getCameraClass, getDefaultAtmosphereParams, getDefaultTexture2D, getDefaultTexture2DArray, getDefaultTextureCube, getDevice, getDirectionalLightClass, getEngine, getGraphNodeClass, getInput, getMeshClass, getMultiScattering, getMultiScatteringLut, getNodeTypeComponents, getOrthoCameraClass, getParticleNodeClass, getPerspectiveCameraClass, getPointLightClass, getPunctualLightClass, getRectLightClass, getRuntimeScriptProperties, getSceneNodeClass, getSkyView, getSkyViewLut, getSpotLightClass, getTransmittanceLut, gradient, hash11, hash12, hash13, hash21, hash22, hash23, hash31, hash32, hash33, integralMultiScattering, interleavedGradientNoise, isGPUClothSupported, linearToGamma, mieAbsorption, mieCoefficient, miePhase, mixGeometryCacheBoundingBox, mixinAlbedoColor, mixinBlinnPhong, mixinFoliage, mixinLambert, mixinLight, mixinPBRBluePrint, mixinPBRCommon, mixinPBRMetallicRoughness, mixinPBRSpecularGlossness, mixinTextureProps, mixinVertexColor, multiScatteringLut, noise3D, normalizeRuntimeScriptConfig, normalizeScriptAttachmentConfig, normalizeScriptAttachments, ozoneAbsorption, panoramaToCubemap, perlinNoise2D, perlinNoise3D, prefilterCubemap, pushInCollisionDetection, pushInFromCapsule, pushInFromCollider, pushInFromSphere, pushoutFromCapsule, pushoutFromCollider, pushoutFromSphere, rayIntersectSphere, rayleighCoefficient, rayleighPhase, renderAPLut, renderAtmosphereLUTs, renderMultiScatteringLut, renderSkyViewLut, renderTransmittanceLut, resolveCapsuleCollision, resolvePlaneCollision, resolveSphereCollision, restoreGeometryCacheMeshBinding, scattering, scriptProp, setApp, setSceneMeshAssetBinding, simulate, skyBox, skyViewLut, smoothNoise3D, sortRootPointsByProximity, temporalResolve, transmittance, transmittanceLut, transmittanceLutToUV, transmittanceToSky, tryGetApp, uniformSphereSamples, updateColliderFromNode, uvToTransmittanceLut, uvToViewDir, valueNoise, viewDirToUV, whiteNoise, worleyFBM, worleyNoise };
+export { AABBTree, ABufferOIT, ATMOSPHERIC_FOG_BIT, AbsNode, AbstractPostEffect, AllConditionNode, AnimationClip, AnimationController, AnimationPlayback, AnimationSet, AnimationTimeline, AnimationTimelineRunner, AnimationTrack, AnyConditionNode, Application, ArcCosNode, ArcSinNode, ArcTan2Node, ArcTanNode, ArccosineHNode, ArcsineHNode, ArctangentHNode, AssetHierarchyNode, AssetManager, AssetScene, AssetSkeleton, AvatarOutfitInstance, AvatarWardrobe, BUILTIN_ASSET_TEST_CUBEMAP, BUILTIN_ASSET_TEXTURE_SHEEN_LUT, BaseCameraController, BaseGraphNode, BaseLight, BaseSprite, BaseTextureNode, BatchGroup, BillboardMatrixNode, BlinnMaterial, Blitter, Bloom, BoundingBox, BoxFilterBlitter, BoxFrameShape, BoxShape, CAMERA_POS_Y, CCDSolver, Camera, CameraNearFarNode, CameraPositionNode, CameraVectorNode, CapsuleShape, CeilNode, ClampNode, Clipmap, ClipmapTerrain, ClipmapTerrainMaterial, ColliderForce, ColorAdjust, CompAddNode, CompComparisonNode, CompDivNode, CompMulNode, CompSubNode, Compositor, ConstantBVec2Node, ConstantBVec3Node, ConstantBVec4Node, ConstantBooleanNode, ConstantScalarNode, ConstantTexture2DArrayNode, ConstantTexture2DNode, ConstantTextureCubeNode, ConstantVec2Node, ConstantVec3Node, ConstantVec4Node, ConstraintType, CopyBlitter, CosHNode, CosNode, CrossProductNode, CubemapSHProjector, CullVisitor, CylinderShape, DDXNode, DDYNode, Degrees2RadiansNode, DepthPass, DevicePoolAllocator, DirectionalLight, DistanceNode, DotProductNode, DracoMeshDecoder, EPSILON$1 as EPSILON, ESM, ElapsedTimeNode, Engine, EnvConstantAmbient, EnvHemisphericAmbient, EnvLightWrapper, EnvShIBL, Environment, EnvironmentLighting, EqualNode, Exp2Node, ExpNode, FABRIKSolver, FBMWaveGenerator, FFTWaveGenerator, FPSCameraController, FWidthNode, FXAA, FaceForwardNode, FixedGeometryCacheTrack, FloorNode, FmaNode, Fog, FontAsset, FractNode, FunctionCallNode, FunctionInputNode, FunctionOutputNode, GPUClothSystem, GaussianBlurBlitter, GenericMathNode, GerstnerWaveGenerator, GraphNode, GrassInstances, GrassLayer, GrassMaterial, GrassQuadtreeNode, GrassRenderer, Grayscale, HEIGHT_FOG_BIT, Hash1Node, Hash2Node, Hash3Node, HistoryResourceManager, HumanoidBodyRig, HumanoidHandRig, IKAngleConstraint, IKChain, IKConstraint, IKModifier, IKSolver, InputManager, InstanceBindGroupAllocator, InstanceIndexNode, InvProjMatrixNode, InvSqrtNode, InvViewProjMatrixNode, JointDynamicsModifier, JointDynamicsSystem, JointDynamicsSystemController, LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_NONE, LIGHT_TYPE_POINT, LIGHT_TYPE_RECT, LIGHT_TYPE_SPOT, LambertMaterial, LengthNode, LightPass, Log2Node, LogNode, LogicallyAndNode, LogicallyOrNode, MAX_CLUSTERED_LIGHTS, MAX_GERSTNER_WAVE_COUNT, MAX_MORPH_ATTRIBUTES, MAX_MORPH_TARGETS, MAX_TERRAIN_MIPMAP_LEVELS, MORPH_ATTRIBUTE_VECTOR_COUNT, MORPH_TARGET_COLOR, MORPH_TARGET_NORMAL, MORPH_TARGET_POSITION, MORPH_TARGET_TANGENT, MORPH_TARGET_TEX0, MORPH_TARGET_TEX1, MORPH_TARGET_TEX2, MORPH_TARGET_TEX3, MORPH_WEIGHTS_VECTOR_COUNT, MSDFText, MSDFTextAtlasManager, MSDFTextSprite, MToonMaterial, MakeVectorNode, Material, MaterialBlueprintIR, MaterialVaryingFlags, MaxNode, Mesh, MeshMaterial, MinNode, MixNode, ModNode, MorphTargetGroupTrack, MorphTargetTrack, MultiChainSpringSystem, NamedObject, NodeEulerRotationTrack, NodeRotationTrack, NodeScaleTrack, NodeTranslationTrack, NormalizeNode, NotEqualNode, Octree, OctreeNode, OctreeNodeChunk, OctreePlacement, OrbitCameraController, OrthoCamera, PBRBlockNode, PBRBluePrintMaterial, PBRMetallicRoughnessMaterial, PBRSpecularGlossinessMaterial, PCAGeometryCacheTrack, PCFOPT, PCFPD, PCSS, PannerNode, ParticleMaterial, ParticleSystem, PerlinNoise2DNode, PerspectiveCamera, PixelNormalNode, PixelWorldPositionNode, PlaneShape, PointLight, PostEffectLayer, PowNode, Primitive, ProjectionMatrixNode, PropertyTrack, PunctualLight, QUEUE_OPAQUE, QUEUE_TRANSPARENT, RENDER_PASS_TYPE_DEPTH, RENDER_PASS_TYPE_LIGHT, RENDER_PASS_TYPE_OBJECT_COLOR, RENDER_PASS_TYPE_SHADOWMAP, RGHandle, RGHistoryResources, RGSubpass, Radians2DegreesNode, RaycastVisitor, RectLight, ReflectNode, RefractNode, RenderGraph, RenderGraphExecutor, RenderPass, RenderQueue, RenderTarget, ResolveVertexNormalNode, ResolveVertexPositionNode, ResolveVertexTangentNode, ResourceManager, RotateAboutAxisNode, RuntimeScript, SAO, SSS, SaturateNode, Scene, SceneNode, SceneRenderer, ScreenAdapter, ScreenRenderTarget, ScriptAttachment, ScriptRegistry, ScriptingSystem, SelectionNode, ShaderHelper, ShadowMapPass, ShadowMapper, ShadowRegion, Shape, SharedModel, SignNode, SimplexNoise2DNode, SinHNode, SinNode, Skeleton, SkeletonModifier, SkeletonRig, SkinBinding, SkinMaterial, SkinSSS, SkyEnvTextureNode, SkyRenderer, SmoothStepNode, SphereShape, SpotLight, SpringChain, SpringModifier, SpringSystem, Sprite, SpriteBlockNode, SpriteBlueprintMaterial, SpriteMaterial, SqrtNode, StandardSpriteMaterial, StepNode, SubsurfaceProfile, SwizzleNode, TAA, TAA_DEBUG_ALAPH, TAA_DEBUG_CURRENT_COLOR, TAA_DEBUG_EDGE, TAA_DEBUG_HISTORY_COLOR, TAA_DEBUG_MOTION_VECTOR, TAA_DEBUG_NONE, TAA_DEBUG_STRENGTH, TAA_DEBUG_VELOCITY, TanHNode, TanNode, TetrahedronFrameShape, TetrahedronShape, TextSprite, TextureSampleGrad, TextureSampleNode, Tonemap, TorusShape, TransformNode, TwoBoneIKSolver, UnlitMaterial, VSM, VertexBinormalNode, VertexBlockNode, VertexColorNode, VertexIndexNode, VertexNormalNode, VertexOutputNode, VertexPositionNode, VertexTangentNode, VertexUVNode, ViewMatrixNode, ViewProjMatrixNode, Water, WaterShaderImpl, WeightedBlendedOIT, aerialPerspective, aerialPerspectiveLut, appInstance, applyAngleLimits, applyMaterialMixins, applyResult, applyRuntimeScriptConfig, atmosphereLUTRendered, buildConstraints, buildForwardPlusGraph, buildMSDFShape, buildSurfaceFaces, checkSurfaceCollision, collisionDetection, collisionDetectionCapsule, collisionDetectionSphere, computeMaxDepth, computeNearestPoints, copyTexture, createAPLutProgram, createCapsuleCollider, createGPUClothWrapBindingData, createGeometryCacheState, createGradientNoiseTexture, createMultiScatteringLutProgram, createPlaneCollider, createProgramFFT2H, createProgramFFT2V, createProgramH0, createProgramHk, createProgramOcean, createProgramPostFFT2, createRandomNoiseTexture, createSkyViewLutProgram, createSphereCollider, createSpringConstraint, createSpringParticle, createTransformAccess, createTransmittanceLutProgram, debugTexture, decode2HalfFromRGBA, decodeFloatFromRGBA, decodeNormalizedFloatFromRGBA, decodeRGBM, defineProps, encode2HalfToRGBA, encodeFloatToRGBA, encodeNormalizedFloatToRGBA, encodeRGBM, ensureGeometryCacheMeshBinding, executeForwardPlusGraph, extractLocalTwist, fetchNormalizedFloatForDevice, fetchSampler, gammaToLinear, generateMSDF, getAerialPerspectiveLut, getApp, getAtmosphereParamsStruct, getBatchGroupClass, getCameraClass, getDefaultAtmosphereParams, getDefaultTexture2D, getDefaultTexture2DArray, getDefaultTextureCube, getDevice, getDirectionalLightClass, getEngine, getGraphNodeClass, getInput, getMeshClass, getMultiScattering, getMultiScatteringLut, getNodeTypeComponents, getOrthoCameraClass, getParticleNodeClass, getPerspectiveCameraClass, getPointLightClass, getPunctualLightClass, getRectLightClass, getRuntimeScriptProperties, getSceneNodeClass, getSkyView, getSkyViewLut, getSpotLightClass, getTransmittanceLut, gradient, hash11, hash12, hash13, hash21, hash22, hash23, hash31, hash32, hash33, integralMultiScattering, interleavedGradientNoise, isGPUClothSupported, linearToGamma, mieAbsorption, mieCoefficient, miePhase, mixGeometryCacheBoundingBox, mixinAlbedoColor, mixinBlinnPhong, mixinFoliage, mixinLambert, mixinLight, mixinPBRBluePrint, mixinPBRCommon, mixinPBRMetallicRoughness, mixinPBRSpecularGlossness, mixinTextureProps, mixinVertexColor, multiScatteringLut, noise3D, normalizeRuntimeScriptConfig, normalizeScriptAttachmentConfig, normalizeScriptAttachments, ozoneAbsorption, panoramaToCubemap, perlinNoise2D, perlinNoise3D, prefilterCubemap, pushInCollisionDetection, pushInFromCapsule, pushInFromCollider, pushInFromSphere, pushoutFromCapsule, pushoutFromCollider, pushoutFromSphere, rayIntersectSphere, rayleighCoefficient, rayleighPhase, renderAPLut, renderAtmosphereLUTs, renderMultiScatteringLut, renderSkyViewLut, renderTransmittanceLut, resolveCapsuleCollision, resolvePlaneCollision, resolveSphereCollision, restoreGeometryCacheMeshBinding, scattering, scriptProp, setApp, setSceneMeshAssetBinding, simulate, skyBox, skyViewLut, smoothNoise3D, sortRootPointsByProximity, temporalResolve, transmittance, transmittanceLut, transmittanceLutToUV, transmittanceToSky, tryGetApp, uniformSphereSamples, updateColliderFromNode, uvToTransmittanceLut, uvToViewDir, valueNoise, viewDirToUV, whiteNoise, worleyFBM, worleyNoise };
 //# sourceMappingURL=zephyr3d_scene.js.map