@fps-games/editor 0.1.4-beta.5 → 0.1.5-beta.1

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

@@ -1,363 +1,97 @@
-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 { createStaticProjectedShadowArtifactSystem } from './static-projected-shadow-artifact-system.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 = [];
+/**
+ * @deprecated Static projected shadows are artifact-only at runtime. This shim
+ * is intentionally not exported from the package barrel; use
+ * createStaticProjectedShadowArtifactSystem() instead.
+ */
+export function createStaticProjectedShadowSystem(scene, _directionalLight, options = {}) {
+    return new StaticProjectedShadowArtifactOnlyFacade(scene, options);
+}
+class StaticProjectedShadowArtifactOnlyFacade {
+    constructor(scene, options) {
         this.options = resolveStaticProjectedShadowOptions(options);
-        this.casterPatterns = [...this.options.casters.includePatterns];
+        this.artifactSystem = createStaticProjectedShadowArtifactSystem(scene, options.artifact ?? null, {
+            enabled: this.options.enabled,
+            appearance: this.options.appearance,
+            bake: {
+                blur: this.options.bake.blur,
+            },
+            debug: this.options.debug,
+        });
     }
     initialize() {
-        if (this.initialized || !this.options.enabled)
-            return;
-        this.initialized = true;
-        this.refresh();
+        this.artifactSystem.initialize();
     }
-    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);
+    addCaster(_mesh) {
+        // Static projected shadows are artifact-only at runtime. Use StaticProjectedShadowBaker during authoring.
     }
-    removeCaster(mesh) {
-        this.disposeCaster(this.findCasterRoot(mesh));
+    removeCaster(_mesh) {
+        // Static projected shadows are artifact-only at runtime. Use setArtifact() to replace displayed chunks.
     }
-    invalidateCaster(mesh) {
-        const root = this.findCasterRoot(mesh);
-        const wasTracked = this.casters.has(root);
-        this.disposeCaster(root);
-        if (wasTracked)
-            this.addCaster(root);
+    invalidateCaster(_mesh) {
+        // Runtime invalidation no longer triggers a bake. Re-run the authoring baker and set the artifact instead.
     }
-    enableCasterAutoDetection(patterns) {
+    enableCasterAutoDetection(_patterns) {
         this.options = {
             ...this.options,
             casters: {
                 ...this.options.casters,
                 autoDetectAll: false,
-                includePatterns: normalizeStringList(patterns),
+                includePatterns: [],
             },
         };
-        this.casterPatterns = [...this.options.casters.includePatterns];
-        this.refresh();
-        this.ensureMeshObserver();
     }
     enableAutoDetectionForAll() {
         this.options = {
             ...this.options,
             casters: {
                 ...this.options.casters,
-                autoDetectAll: true,
+                autoDetectAll: false,
+                includePatterns: [],
             },
         };
-        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();
-        }
+        // Artifact chunks are immutable until setArtifact()/setOptions().
+    }
+    setArtifact(artifact) {
+        this.artifactSystem.setArtifact(artifact ?? null);
     }
     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();
+        this.artifactSystem.setOptions({
+            enabled: this.options.enabled,
+            appearance: this.options.appearance,
+            bake: {
+                blur: this.options.bake.blur,
+            },
+            debug: this.options.debug,
+        });
+        if ('artifact' in options)
+            this.artifactSystem.setArtifact(options.artifact ?? null);
     }
     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,
-        };
+    getCasterInfo(_mesh) {
+        return null;
     }
     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];
+        return 0;
     }
-    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);
+    getChunkCount() {
+        return this.artifactSystem.getChunkCount();
     }
-    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;
+    getDiagnostics() {
+        return this.artifactSystem.getDiagnostics();
     }
-    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;
+    dispose() {
+        this.artifactSystem.dispose();
     }
 }
 export function resolveStaticProjectedShadowOptions(options = {}, fallback = DEFAULT_STATIC_PROJECTED_SHADOW_OPTIONS) {
+    const spatialChunkSize = readPositiveNumber(options.bake?.spatialChunkSize ?? options.bake?.maxSize, fallback.bake.spatialChunkSize);
     return {
         enabled: readBoolean(options.enabled, fallback.enabled),
         plane: {
@@ -379,296 +113,24 @@ export function resolveStaticProjectedShadowOptions(options = {}, fallback = DEF
             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),
+            maxSize: spatialChunkSize,
+            texelsPerMeter: readPositiveNumber(options.bake?.texelsPerMeter, fallback.bake.texelsPerMeter),
+            atlasSize: readPositiveNumber(options.bake?.atlasSize, fallback.bake.atlasSize),
+            maxAtlasPages: readPositiveNumber(options.bake?.maxAtlasPages, fallback.bake.maxAtlasPages),
+            sdfRadiusPx: readNonNegativeNumber(options.bake?.sdfRadiusPx, fallback.bake.sdfRadiusPx),
+            spatialChunkSize,
+            targetChunkCount: readPositiveNumber(options.bake?.targetChunkCount, fallback.bake.targetChunkCount),
         },
         casters: {
-            autoDetectAll: readBoolean(options.casters?.autoDetectAll, fallback.casters.autoDetectAll),
-            includePatterns: normalizeStringList(options.casters?.includePatterns ?? fallback.casters.includePatterns),
+            autoDetectAll: false,
+            includePatterns: [],
             excludePatterns: normalizeStringList(options.casters?.excludePatterns ?? fallback.casters.excludePatterns),
-            rootBoundaryPatterns: normalizeStringList(options.casters?.rootBoundaryPatterns ?? fallback.casters.rootBoundaryPatterns),
+            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,
@@ -706,12 +168,6 @@ function readPositiveNumber(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));
+    return Math.min(max, Math.max(min, readFiniteNumber(value, fallback)));
 }
 //# sourceMappingURL=static-projected-shadow-system.js.map