@fps-games/editor 0.1.4-beta.4 → 0.1.4-beta.5

package/node_modules/@fps-games/babylon-renderer/dist/shadows/static-projected-shadow-system.js

@@ -0,0 +1,717 @@
+import { Camera } from '@babylonjs/core/Cameras/camera.js';
+import { FreeCamera } from '@babylonjs/core/Cameras/freeCamera.js';
+import { Constants } from '@babylonjs/core/Engines/constants.js';
+import { DirectionalLight } from '@babylonjs/core/Lights/directionalLight.js';
+import { Color3, Color4 } from '@babylonjs/core/Maths/math.color.js';
+import { Vector2, Vector3 } from '@babylonjs/core/Maths/math.vector.js';
+import { Effect } from '@babylonjs/core/Materials/effect.js';
+import { Material } from '@babylonjs/core/Materials/material.js';
+import { ShaderMaterial } from '@babylonjs/core/Materials/shaderMaterial.js';
+import { StandardMaterial } from '@babylonjs/core/Materials/standardMaterial.js';
+import { RenderTargetTexture } from '@babylonjs/core/Materials/Textures/renderTargetTexture.js';
+import { Texture } from '@babylonjs/core/Materials/Textures/texture.js';
+import { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh.js';
+import { InstancedMesh } from '@babylonjs/core/Meshes/instancedMesh.js';
+import { Mesh } from '@babylonjs/core/Meshes/mesh.js';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode.js';
+import { VertexBuffer } from '@babylonjs/core/Buffers/buffer.js';
+import { VertexData } from '@babylonjs/core/Meshes/mesh.vertexData.js';
+import { DEFAULT_STATIC_PROJECTED_SHADOW_OPTIONS, } from './types.js';
+const STATIC_PROJECTED_SHADOW_ALPHA_INDEX = 2;
+const STATIC_PROJECTED_BAKE_LAYER_MASK = 0x10000000;
+const STATIC_PROJECTED_SHADOW_SHADER_NAME = 'fpsStaticProjectedShadow';
+const DEFAULT_SHADOW_DIRECTION = new Vector3(-0.3, -1, -0.2).normalize();
+export function createStaticProjectedShadowSystem(scene, directionalLight, options = {}) {
+    return new BabylonStaticProjectedShadowSystem(scene, directionalLight, options);
+}
+class BabylonStaticProjectedShadowSystem {
+    constructor(scene, directionalLight, options) {
+        this.scene = scene;
+        this.directionalLight = directionalLight;
+        this.casters = new Map();
+        this.meshAddedObserver = null;
+        this.initialized = false;
+        this.casterPatterns = [];
+        this.options = resolveStaticProjectedShadowOptions(options);
+        this.casterPatterns = [...this.options.casters.includePatterns];
+    }
+    initialize() {
+        if (this.initialized || !this.options.enabled)
+            return;
+        this.initialized = true;
+        this.refresh();
+    }
+    addCaster(mesh) {
+        const root = this.findCasterRoot(mesh);
+        if (!this.initialized || this.casters.has(root))
+            return;
+        if (!this.isValidCasterRoot(root))
+            return;
+        const caster = this.createCaster(root);
+        if (caster)
+            this.casters.set(root, caster);
+    }
+    removeCaster(mesh) {
+        this.disposeCaster(this.findCasterRoot(mesh));
+    }
+    invalidateCaster(mesh) {
+        const root = this.findCasterRoot(mesh);
+        const wasTracked = this.casters.has(root);
+        this.disposeCaster(root);
+        if (wasTracked)
+            this.addCaster(root);
+    }
+    enableCasterAutoDetection(patterns) {
+        this.options = {
+            ...this.options,
+            casters: {
+                ...this.options.casters,
+                autoDetectAll: false,
+                includePatterns: normalizeStringList(patterns),
+            },
+        };
+        this.casterPatterns = [...this.options.casters.includePatterns];
+        this.refresh();
+        this.ensureMeshObserver();
+    }
+    enableAutoDetectionForAll() {
+        this.options = {
+            ...this.options,
+            casters: {
+                ...this.options.casters,
+                autoDetectAll: true,
+            },
+        };
+        this.casterPatterns = [];
+        this.refresh();
+        this.ensureMeshObserver();
+    }
+    refresh() {
+        if (!this.initialized)
+            return;
+        this.pruneDisposedCasters();
+        for (const mesh of this.scene.meshes)
+            this.tryAutoAddCaster(mesh);
+        if (this.options.casters.autoDetectAll || this.casterPatterns.length > 0) {
+            this.ensureMeshObserver();
+        }
+    }
+    setOptions(options) {
+        const wasEnabled = this.options.enabled;
+        this.options = resolveStaticProjectedShadowOptions(options, this.options);
+        this.casterPatterns = [...this.options.casters.includePatterns];
+        if (!wasEnabled && this.options.enabled)
+            this.initialize();
+        else if (wasEnabled && !this.options.enabled)
+            this.dispose();
+        else
+            this.rebuildCasters();
+    }
+    getOptions() {
+        return cloneResolvedOptions(this.options);
+    }
+    getCasterInfo(mesh) {
+        const caster = this.casters.get(this.findCasterRoot(mesh));
+        if (!caster)
+            return null;
+        return {
+            source: caster.source,
+            shadow: caster.shadow,
+        };
+    }
+    getCasterCount() {
+        return this.casters.size;
+    }
+    dispose() {
+        if (this.meshAddedObserver) {
+            this.scene.onNewMeshAddedObservable.remove(this.meshAddedObserver);
+            this.meshAddedObserver = null;
+        }
+        for (const root of [...this.casters.keys()])
+            this.disposeCaster(root);
+        this.initialized = false;
+    }
+    rebuildCasters() {
+        const roots = [...this.casters.keys()].filter((root) => !root.isDisposed());
+        for (const root of roots)
+            this.disposeCaster(root);
+        for (const root of roots)
+            this.addCaster(root);
+        this.refresh();
+    }
+    createCaster(root) {
+        const meshes = collectNodeMeshes(root).filter((mesh) => this.isValidShadowSource(mesh));
+        if (meshes.length === 0)
+            return null;
+        const bounds = buildProjectedBounds(meshes, {
+            lightDir: this.resolveShadowDirection(),
+            planeY: this.options.plane.height + this.options.plane.yOffset,
+            padding: this.options.bake.padding,
+            maxSize: this.options.bake.maxSize,
+        });
+        if (!bounds)
+            return null;
+        const planeY = this.options.plane.height + this.options.plane.yOffset;
+        const lightDir = this.resolveShadowDirection();
+        const baked = createBakedShadowMask(meshes, {
+            scene: this.scene,
+            name: root.name,
+            bounds,
+            lightDir,
+            planeY,
+            resolution: this.options.bake.resolution,
+        });
+        if (!baked)
+            return null;
+        const material = this.createShadowMaterial(root.name, baked.texture);
+        const shadow = this.createShadowRoot(root.name, bounds);
+        baked.mesh.name = `${root.name}_staticProjectedShape_0`;
+        baked.mesh.material = material;
+        baked.mesh.parent = shadow;
+        baked.mesh.alphaIndex = STATIC_PROJECTED_SHADOW_ALPHA_INDEX;
+        return {
+            source: root,
+            shadow,
+            material,
+            texture: baked.texture,
+            shadowMeshes: [baked.mesh],
+        };
+    }
+    createShadowMaterial(name, texture) {
+        registerStaticProjectedShadowShaders();
+        const material = new ShaderMaterial(`${name}_staticProjectedShadowMaterial`, this.scene, { vertex: STATIC_PROJECTED_SHADOW_SHADER_NAME, fragment: STATIC_PROJECTED_SHADOW_SHADER_NAME }, {
+            needAlphaBlending: true,
+            needAlphaTesting: false,
+            attributes: ['position', 'uv'],
+            uniforms: ['worldViewProjection', 'u_shadowColor', 'u_texelSize', 'u_blurRadius'],
+            samplers: ['shadowSampler'],
+        });
+        const color = this.options.appearance.color;
+        material.backFaceCulling = false;
+        material.disableDepthWrite = true;
+        material.depthFunction = Constants.LEQUAL;
+        material.transparencyMode = Material.MATERIAL_ALPHABLEND;
+        material.alphaMode = Constants.ALPHA_COMBINE;
+        material.needAlphaBlending = () => true;
+        material.setTexture('shadowSampler', texture);
+        material.setColor4('u_shadowColor', new Color4(clamp01(color.r), clamp01(color.g), clamp01(color.b), clamp01(color.a)));
+        material.setVector2('u_texelSize', new Vector2(1 / texture.getSize().width, 1 / texture.getSize().height));
+        material.setFloat('u_blurRadius', clamp(this.options.bake.blur, 0, 32));
+        return material;
+    }
+    createShadowRoot(name, bounds) {
+        const shadow = new Mesh(`${name}_staticProjectedShadow`, this.scene);
+        const vertexData = new VertexData();
+        vertexData.positions = [bounds.center.x, bounds.center.y, bounds.center.z];
+        vertexData.indices = [];
+        vertexData.applyToMesh(shadow);
+        shadow.isPickable = false;
+        shadow.receiveShadows = false;
+        shadow.alphaIndex = STATIC_PROJECTED_SHADOW_ALPHA_INDEX;
+        shadow.renderOutline = false;
+        shadow.renderOverlay = false;
+        shadow.metadata = {
+            ...(shadow.metadata && typeof shadow.metadata === 'object' ? shadow.metadata : {}),
+            disableStaticProjectedShadow: true,
+            staticProjectedShadowInternal: true,
+        };
+        return shadow;
+    }
+    disposeCaster(root) {
+        const caster = this.casters.get(root);
+        if (!caster)
+            return;
+        for (const mesh of caster.shadowMeshes) {
+            if (!mesh.isDisposed())
+                mesh.dispose();
+        }
+        caster.shadow.dispose();
+        const targetIndex = this.scene.customRenderTargets.indexOf(caster.texture);
+        if (targetIndex >= 0)
+            this.scene.customRenderTargets.splice(targetIndex, 1);
+        caster.texture.dispose();
+        caster.material.dispose();
+        this.casters.delete(root);
+    }
+    tryAutoAddCaster(mesh) {
+        if (!this.initialized || this.casters.has(mesh))
+            return;
+        if (!this.isValidShadowSource(mesh))
+            return;
+        if (!this.options.casters.autoDetectAll && !this.matchesCasterPattern(mesh))
+            return;
+        const root = this.findCasterRoot(mesh);
+        if (this.isAlreadyCoveredByCaster(root))
+            return;
+        this.addCaster(root);
+    }
+    ensureMeshObserver() {
+        if (this.meshAddedObserver)
+            return;
+        this.meshAddedObserver = this.scene.onNewMeshAddedObservable.add((mesh) => {
+            queueMicrotask(() => {
+                if (!this.initialized || mesh.isDisposed())
+                    return;
+                this.tryAutoAddCaster(mesh);
+            });
+        });
+    }
+    pruneDisposedCasters() {
+        for (const [root, caster] of [...this.casters]) {
+            if (root.isDisposed() || caster.shadow.isDisposed())
+                this.disposeCaster(root);
+        }
+    }
+    resolveShadowDirection() {
+        const direction = this.directionalLight.direction;
+        if (direction?.lengthSquared?.() > 1e-6)
+            return direction.clone().normalize();
+        return DEFAULT_SHADOW_DIRECTION.clone();
+    }
+    isValidShadowSource(mesh) {
+        if (mesh.isDisposed() || !mesh.isEnabled(false))
+            return false;
+        if (!(mesh instanceof Mesh) && !(mesh instanceof InstancedMesh))
+            return false;
+        const geometrySource = mesh instanceof InstancedMesh ? mesh.sourceMesh : mesh;
+        if (!geometrySource.geometry)
+            return false;
+        if (!mesh.isVisible)
+            return false;
+        if (this.isInternalMesh(mesh))
+            return false;
+        if (this.matchesExcludedPattern(mesh))
+            return false;
+        mesh.computeWorldMatrix(true);
+        const bounds = mesh.getHierarchyBoundingVectors(true);
+        const size = bounds.max.subtract(bounds.min);
+        const volume = Math.abs(size.x * size.y * size.z);
+        return Number.isFinite(volume) && volume >= this.options.casters.minVolume;
+    }
+    isValidCasterRoot(mesh) {
+        if (mesh.isDisposed() || !mesh.isEnabled(false))
+            return false;
+        if (this.isInternalMesh(mesh))
+            return false;
+        if (this.matchesExcludedPattern(mesh))
+            return false;
+        return true;
+    }
+    matchesCasterPattern(mesh) {
+        return this.matchesAnyPattern(mesh, this.casterPatterns);
+    }
+    matchesExcludedPattern(mesh) {
+        return this.matchesAnyPattern(mesh, this.options.casters.excludePatterns);
+    }
+    matchesAnyPattern(mesh, patterns) {
+        if (patterns.length === 0)
+            return false;
+        const names = this.collectMeshNames(mesh);
+        return patterns.some((pattern) => {
+            const normalized = pattern.trim().toLowerCase();
+            return normalized.length > 0 && names.some((name) => name.includes(normalized));
+        });
+    }
+    collectMeshNames(mesh) {
+        const names = new Set();
+        let cursor = mesh;
+        while (cursor && typeof cursor === 'object') {
+            const name = typeof cursor.name === 'string' ? cursor.name : '';
+            if (name)
+                names.add(name.toLowerCase());
+            cursor = cursor.parent;
+        }
+        return [...names];
+    }
+    isInternalMesh(mesh) {
+        const metadata = mesh.metadata;
+        return !!metadata
+            && typeof metadata === 'object'
+            && (metadata.disableStaticProjectedShadow === true
+                || metadata.staticProjectedShadowInternal === true
+                || metadata.disableBlobShadow === true
+                || metadata.blobShadowInternal === true
+                || metadata.disablePlanarShadow === true
+                || metadata.planarShadowInternal === true);
+    }
+    findCasterRoot(mesh) {
+        let cursor = mesh;
+        let parent = mesh.parent;
+        while (parent instanceof AbstractMesh || parent instanceof TransformNode) {
+            if (parent instanceof AbstractMesh && this.matchesAnyPattern(parent, this.options.casters.rootBoundaryPatterns)) {
+                return parent;
+            }
+            if (parent instanceof AbstractMesh)
+                cursor = parent;
+            parent = parent.parent;
+        }
+        return cursor;
+    }
+    isAlreadyCoveredByCaster(root) {
+        if (this.casters.has(root))
+            return true;
+        for (const caster of this.casters.keys()) {
+            if (root.isDescendantOf(caster) || caster.isDescendantOf(root))
+                return true;
+        }
+        return false;
+    }
+}
+export function resolveStaticProjectedShadowOptions(options = {}, fallback = DEFAULT_STATIC_PROJECTED_SHADOW_OPTIONS) {
+    return {
+        enabled: readBoolean(options.enabled, fallback.enabled),
+        plane: {
+            height: readFiniteNumber(options.plane?.height, fallback.plane.height),
+            yOffset: readFiniteNumber(options.plane?.yOffset, fallback.plane.yOffset),
+        },
+        appearance: {
+            color: {
+                r: readClampedNumber(options.appearance?.color?.r, fallback.appearance.color.r, 0, 1),
+                g: readClampedNumber(options.appearance?.color?.g, fallback.appearance.color.g, 0, 1),
+                b: readClampedNumber(options.appearance?.color?.b, fallback.appearance.color.b, 0, 1),
+                a: readClampedNumber(options.appearance?.color?.a, fallback.appearance.color.a, 0, 1),
+            },
+        },
+        direction: {
+            mode: 'follow-light',
+        },
+        bake: {
+            resolution: readPositiveNumber(options.bake?.resolution, fallback.bake.resolution),
+            padding: readNonNegativeNumber(options.bake?.padding, fallback.bake.padding),
+            blur: readNonNegativeNumber(options.bake?.blur, fallback.bake.blur),
+            maxSize: readPositiveNumber(options.bake?.maxSize, fallback.bake.maxSize),
+        },
+        casters: {
+            autoDetectAll: readBoolean(options.casters?.autoDetectAll, fallback.casters.autoDetectAll),
+            includePatterns: normalizeStringList(options.casters?.includePatterns ?? fallback.casters.includePatterns),
+            excludePatterns: normalizeStringList(options.casters?.excludePatterns ?? fallback.casters.excludePatterns),
+            rootBoundaryPatterns: normalizeStringList(options.casters?.rootBoundaryPatterns ?? fallback.casters.rootBoundaryPatterns),
+            minVolume: readNonNegativeNumber(options.casters?.minVolume, fallback.casters.minVolume),
+        },
+        debug: readBoolean(options.debug, fallback.debug),
+    };
+}
+function buildProjectedBounds(meshes, options) {
+    const lightDir = options.lightDir.clone().normalize();
+    if (Math.abs(lightDir.y) < 1e-5)
+        return null;
+    const points = [];
+    for (const mesh of meshes) {
+        const geometrySource = mesh instanceof InstancedMesh ? mesh.sourceMesh : mesh;
+        if (!(geometrySource instanceof Mesh))
+            continue;
+        const positions = geometrySource.getVerticesData(VertexBuffer.PositionKind);
+        if (!positions || positions.length < 3)
+            continue;
+        mesh.computeWorldMatrix(true);
+        const matrix = mesh.getWorldMatrix();
+        for (let index = 0; index < positions.length; index += 3) {
+            const point = Vector3.TransformCoordinates(new Vector3(Number(positions[index]), Number(positions[index + 1]), Number(positions[index + 2])), matrix);
+            const t = (options.planeY - point.y) / lightDir.y;
+            if (t < -1e-4)
+                continue;
+            points.push(point.add(lightDir.scale(Math.max(0, t))));
+        }
+    }
+    if (points.length === 0)
+        return null;
+    let minX = Infinity;
+    let maxX = -Infinity;
+    let minZ = Infinity;
+    let maxZ = -Infinity;
+    for (const point of points) {
+        minX = Math.min(minX, point.x);
+        maxX = Math.max(maxX, point.x);
+        minZ = Math.min(minZ, point.z);
+        maxZ = Math.max(maxZ, point.z);
+    }
+    if (![minX, maxX, minZ, maxZ].every(Number.isFinite))
+        return null;
+    const paddingX = Math.max(options.padding, (maxX - minX) * options.padding);
+    const paddingZ = Math.max(options.padding, (maxZ - minZ) * options.padding);
+    minX -= paddingX;
+    maxX += paddingX;
+    minZ -= paddingZ;
+    maxZ += paddingZ;
+    const centerX = (minX + maxX) * 0.5;
+    const centerZ = (minZ + maxZ) * 0.5;
+    let width = maxX - minX;
+    let depth = maxZ - minZ;
+    if (width > options.maxSize) {
+        width = options.maxSize;
+        minX = centerX - width * 0.5;
+        maxX = centerX + width * 0.5;
+    }
+    if (depth > options.maxSize) {
+        depth = options.maxSize;
+        minZ = centerZ - depth * 0.5;
+        maxZ = centerZ + depth * 0.5;
+    }
+    return {
+        center: new Vector3((minX + maxX) * 0.5, options.planeY, (minZ + maxZ) * 0.5),
+        width,
+        depth,
+        minX,
+        maxX,
+        minZ,
+        maxZ,
+    };
+}
+function collectNodeMeshes(root) {
+    const meshes = new Set();
+    meshes.add(root);
+    for (const child of root.getChildMeshes(false))
+        meshes.add(child);
+    return [...meshes];
+}
+function createBakedShadowMask(meshes, options) {
+    const resolution = clamp(Math.round(options.resolution), 16, 2048);
+    const bakeMeshes = createProjectedBakeMeshes(meshes, {
+        scene: options.scene,
+        name: options.name,
+        lightDir: options.lightDir,
+        planeY: options.planeY,
+    });
+    if (bakeMeshes.length === 0)
+        return null;
+    const bakeCamera = createBakeCamera(`${options.name}_staticProjectedBakeCamera`, options.scene, options.bounds);
+    const bakeMaterial = createBakeMaterial(`${options.name}_staticProjectedBakeMaterial`, options.scene);
+    const texture = new RenderTargetTexture(`${options.name}_staticProjectedShadowMask`, resolution, options.scene, false, false);
+    texture.clearColor = new Color4(0, 0, 0, 0);
+    texture.hasAlpha = true;
+    texture.wrapU = Texture.CLAMP_ADDRESSMODE;
+    texture.wrapV = Texture.CLAMP_ADDRESSMODE;
+    texture.updateSamplingMode(Texture.BILINEAR_SAMPLINGMODE);
+    texture.renderList = bakeMeshes;
+    texture.activeCamera = bakeCamera;
+    texture.cameraForLOD = bakeCamera;
+    texture.disableImageProcessing = true;
+    texture.renderParticles = false;
+    texture.renderSprites = false;
+    texture.enableOutlineRendering = false;
+    texture.refreshRate = RenderTargetTexture.REFRESHRATE_RENDER_ONCE;
+    texture.setMaterialForRendering(bakeMeshes, bakeMaterial);
+    try {
+        texture.render(false);
+    }
+    catch {
+        for (const mesh of bakeMeshes)
+            mesh.dispose();
+        const targetIndex = options.scene.customRenderTargets.indexOf(texture);
+        if (targetIndex >= 0)
+            options.scene.customRenderTargets.splice(targetIndex, 1);
+        texture.dispose();
+        bakeCamera.dispose();
+        bakeMaterial.dispose();
+        return null;
+    }
+    texture.renderList = [];
+    texture.activeCamera = null;
+    texture.cameraForLOD = null;
+    for (const mesh of bakeMeshes)
+        mesh.dispose();
+    bakeCamera.dispose();
+    bakeMaterial.dispose();
+    const mesh = createShadowQuad(`${options.name}_staticProjectedShadowBake`, options.scene, options.bounds);
+    return { mesh, texture };
+}
+function createProjectedBakeMeshes(meshes, options) {
+    const lightDir = options.lightDir.clone().normalize();
+    if (Math.abs(lightDir.y) < 1e-5)
+        return [];
+    const bakeMeshes = [];
+    meshes.forEach((mesh, meshIndex) => {
+        const geometrySource = mesh instanceof InstancedMesh ? mesh.sourceMesh : mesh;
+        if (!(geometrySource instanceof Mesh))
+            return;
+        const positions = geometrySource.getVerticesData(VertexBuffer.PositionKind);
+        const indices = geometrySource.getIndices();
+        if (!positions || positions.length < 3 || !indices || indices.length < 3)
+            return;
+        mesh.computeWorldMatrix(true);
+        const matrix = mesh.getWorldMatrix();
+        const projectedPositions = [];
+        for (let index = 0; index < positions.length; index += 3) {
+            const point = Vector3.TransformCoordinates(new Vector3(Number(positions[index]), Number(positions[index + 1]), Number(positions[index + 2])), matrix);
+            const t = (options.planeY - point.y) / lightDir.y;
+            const projected = point.add(lightDir.scale(Math.max(0, t)));
+            projectedPositions.push(projected.x, options.planeY, projected.z);
+        }
+        const bakeMesh = new Mesh(`${options.name}_staticProjectedBakeProjection_${meshIndex}`, options.scene);
+        const vertexData = new VertexData();
+        vertexData.positions = projectedPositions;
+        vertexData.indices = [...indices];
+        vertexData.applyToMesh(bakeMesh);
+        bakeMesh.isPickable = false;
+        bakeMesh.receiveShadows = false;
+        bakeMesh.alphaIndex = STATIC_PROJECTED_SHADOW_ALPHA_INDEX;
+        bakeMesh.layerMask = STATIC_PROJECTED_BAKE_LAYER_MASK;
+        bakeMesh.metadata = {
+            ...(bakeMesh.metadata && typeof bakeMesh.metadata === 'object' ? bakeMesh.metadata : {}),
+            disableStaticProjectedShadow: true,
+            staticProjectedShadowInternal: true,
+        };
+        bakeMeshes.push(bakeMesh);
+    });
+    return bakeMeshes;
+}
+function createBakeCamera(name, scene, bounds) {
+    const cameraHeight = Math.max(bounds.width, bounds.depth, 1) + 10;
+    const camera = new FreeCamera(name, new Vector3(bounds.center.x, bounds.center.y + cameraHeight, bounds.center.z), scene);
+    camera.mode = Camera.ORTHOGRAPHIC_CAMERA;
+    camera.orthoLeft = -Math.max(bounds.width, 1e-4) * 0.5;
+    camera.orthoRight = Math.max(bounds.width, 1e-4) * 0.5;
+    camera.orthoBottom = -Math.max(bounds.depth, 1e-4) * 0.5;
+    camera.orthoTop = Math.max(bounds.depth, 1e-4) * 0.5;
+    camera.minZ = 0.01;
+    camera.maxZ = cameraHeight + 1;
+    camera.layerMask = STATIC_PROJECTED_BAKE_LAYER_MASK;
+    camera.upVector = Vector3.Forward();
+    camera.setTarget(bounds.center);
+    return camera;
+}
+function createBakeMaterial(name, scene) {
+    const material = new StandardMaterial(name, scene);
+    material.diffuseColor = Color3.White();
+    material.emissiveColor = Color3.White();
+    material.alpha = 1;
+    material.backFaceCulling = false;
+    material.disableLighting = true;
+    material.disableDepthWrite = true;
+    material.transparencyMode = Material.MATERIAL_OPAQUE;
+    return material;
+}
+function registerStaticProjectedShadowShaders() {
+    const vertexKey = `${STATIC_PROJECTED_SHADOW_SHADER_NAME}VertexShader`;
+    if (Effect.ShadersStore[vertexKey])
+        return;
+    Effect.ShadersStore[vertexKey] = `
+precision highp float;
+
+attribute vec3 position;
+attribute vec2 uv;
+
+uniform mat4 worldViewProjection;
+
+varying vec2 v_uv;
+
+void main() {
+  v_uv = uv;
+  gl_Position = worldViewProjection * vec4(position, 1.0);
+}
+`;
+    Effect.ShadersStore[`${STATIC_PROJECTED_SHADOW_SHADER_NAME}FragmentShader`] = `
+precision highp float;
+
+uniform sampler2D shadowSampler;
+uniform vec4 u_shadowColor;
+uniform vec2 u_texelSize;
+uniform float u_blurRadius;
+
+varying vec2 v_uv;
+
+float sampleMask(vec2 uv) {
+  vec4 mask = texture2D(shadowSampler, clamp(uv, vec2(0.0), vec2(1.0)));
+  return max(max(mask.r, mask.g), max(mask.b, mask.a));
+}
+
+void main() {
+  float radius = clamp(u_blurRadius, 0.0, 32.0);
+  float alpha = 0.0;
+  if (radius < 0.5) {
+    alpha = sampleMask(v_uv);
+  } else {
+    vec2 stepSize = u_texelSize * radius;
+    alpha += sampleMask(v_uv) * 0.24;
+    alpha += sampleMask(v_uv + vec2(stepSize.x, 0.0)) * 0.12;
+    alpha += sampleMask(v_uv - vec2(stepSize.x, 0.0)) * 0.12;
+    alpha += sampleMask(v_uv + vec2(0.0, stepSize.y)) * 0.12;
+    alpha += sampleMask(v_uv - vec2(0.0, stepSize.y)) * 0.12;
+    alpha += sampleMask(v_uv + stepSize) * 0.07;
+    alpha += sampleMask(v_uv - stepSize) * 0.07;
+    alpha += sampleMask(v_uv + vec2(stepSize.x, -stepSize.y)) * 0.07;
+    alpha += sampleMask(v_uv + vec2(-stepSize.x, stepSize.y)) * 0.07;
+  }
+  alpha *= u_shadowColor.a;
+  if (alpha <= 0.001) discard;
+  gl_FragColor = vec4(u_shadowColor.rgb, alpha);
+}
+`;
+}
+function createShadowQuad(name, scene, bounds) {
+    const mesh = new Mesh(name, scene);
+    const vertexData = new VertexData();
+    vertexData.positions = [
+        bounds.minX, bounds.center.y, bounds.minZ,
+        bounds.maxX, bounds.center.y, bounds.minZ,
+        bounds.maxX, bounds.center.y, bounds.maxZ,
+        bounds.minX, bounds.center.y, bounds.maxZ,
+    ];
+    vertexData.indices = [0, 1, 2, 0, 2, 3];
+    vertexData.normals = [
+        0, 1, 0,
+        0, 1, 0,
+        0, 1, 0,
+        0, 1, 0,
+    ];
+    vertexData.uvs = [
+        0, 0,
+        1, 0,
+        1, 1,
+        0, 1,
+    ];
+    vertexData.applyToMesh(mesh);
+    mesh.isPickable = false;
+    mesh.metadata = {
+        ...(mesh.metadata && typeof mesh.metadata === 'object' ? mesh.metadata : {}),
+        disableStaticProjectedShadow: true,
+        staticProjectedShadowInternal: true,
+    };
+    return mesh;
+}
+function cloneResolvedOptions(options) {
+    return {
+        enabled: options.enabled,
+        plane: { ...options.plane },
+        appearance: {
+            color: { ...options.appearance.color },
+        },
+        direction: { ...options.direction },
+        bake: { ...options.bake },
+        casters: {
+            autoDetectAll: options.casters.autoDetectAll,
+            includePatterns: [...options.casters.includePatterns],
+            excludePatterns: [...options.casters.excludePatterns],
+            rootBoundaryPatterns: [...options.casters.rootBoundaryPatterns],
+            minVolume: options.casters.minVolume,
+        },
+        debug: options.debug,
+    };
+}
+function normalizeStringList(value) {
+    return [...new Set((value ?? []).map((item) => item.trim()).filter(Boolean))];
+}
+function readBoolean(value, fallback) {
+    return typeof value === 'boolean' ? value : fallback;
+}
+function readFiniteNumber(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+function readNonNegativeNumber(value, fallback) {
+    const next = readFiniteNumber(value, fallback);
+    return next >= 0 ? next : fallback;
+}
+function readPositiveNumber(value, fallback) {
+    const next = readFiniteNumber(value, fallback);
+    return next > 0 ? next : fallback;
+}
+function readClampedNumber(value, fallback, min, max) {
+    return clamp(readFiniteNumber(value, fallback), min, max);
+}
+function clamp01(value) {
+    return clamp(value, 0, 1);
+}
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+//# sourceMappingURL=static-projected-shadow-system.js.map