@fps-games/editor 0.1.7 → 0.1.8-beta.2

package/node_modules/@fps-games/babylon-renderer/dist/shadows/dynamic-shadow-system.d.ts

@@ -0,0 +1,83 @@
+import { Camera } from '@babylonjs/core/Cameras/camera';
+import type { DirectionalLight } from '@babylonjs/core/Lights/directionalLight';
+import { ShadowGenerator } from '@babylonjs/core/Lights/Shadows/shadowGenerator';
+import type { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh';
+import type { Scene } from '@babylonjs/core/scene';
+import '@babylonjs/core/Lights/Shadows/shadowGeneratorSceneComponent.js';
+export interface DynamicShadowParams {
+    opacity: number;
+    softness: number;
+    bias: number;
+    normalBias: number;
+    maxDistance: number;
+    resolution: 512 | 1024 | 2048 | 4096;
+    cascadeCount: 1 | 2 | 4;
+    blurKernel: number;
+}
+export interface DynamicShadowOptions {
+    enabled: boolean;
+    camera?: Camera | null;
+    params: DynamicShadowParams;
+    useCsm?: boolean;
+    boundsPadding?: number;
+    stableSnapping?: boolean;
+    debug?: boolean;
+}
+export interface DynamicShadowLightOrthoBounds {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    minZ: number;
+    maxZ: number;
+}
+export interface DynamicShadowWorldBounds {
+    min: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    max: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+export interface DynamicShadowDiagnostics {
+    enabled: boolean;
+    casterCount: number;
+    receiverCount: number;
+    generator: {
+        className: string | null;
+        mapSize: unknown;
+        darkness: number | null;
+        bias: number | null;
+        normalBias: number | null;
+        blurKernel: number | null;
+        renderListCount: number;
+        useCsm: boolean;
+    } | null;
+    params: DynamicShadowParams;
+    bounds: {
+        world: DynamicShadowWorldBounds;
+        lightOrtho: DynamicShadowLightOrthoBounds;
+        texelSize: number;
+        cameraProjection: 'orthographic' | 'perspective' | 'none';
+    } | null;
+    fallbackReasons: string[];
+}
+export interface DynamicShadowSystem {
+    initialize(): void;
+    addCaster(mesh: AbstractMesh): boolean;
+    removeCaster(mesh: AbstractMesh): void;
+    addReceiver(mesh: AbstractMesh): void;
+    removeReceiver(mesh: AbstractMesh): void;
+    setCamera(camera: Camera | null): void;
+    setOptions(options: Partial<DynamicShadowOptions>): void;
+    refresh(): void;
+    getShadowGenerator(): ShadowGenerator | null;
+    getDiagnostics(): DynamicShadowDiagnostics;
+    dispose(): void;
+}
+export declare function createDynamicShadowSystem(scene: Scene, directionalLight: DirectionalLight, options?: Partial<DynamicShadowOptions>): DynamicShadowSystem;
+//# sourceMappingURL=dynamic-shadow-system.d.ts.map

package/node_modules/@fps-games/babylon-renderer/dist/shadows/dynamic-shadow-system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic-shadow-system.d.ts","sourceRoot":"","sources":["../../src/shadows/dynamic-shadow-system.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,561 @@
+import { Camera } from '@babylonjs/core/Cameras/camera.js';
+import { CascadedShadowGenerator } from '@babylonjs/core/Lights/Shadows/cascadedShadowGenerator.js';
+import { ShadowGenerator } from '@babylonjs/core/Lights/Shadows/shadowGenerator.js';
+import { Matrix, Vector3 } from '@babylonjs/core/Maths/math.vector.js';
+import '@babylonjs/core/Lights/Shadows/shadowGeneratorSceneComponent.js';
+const DEFAULT_DYNAMIC_SHADOW_PARAMS = {
+    opacity: 0.42,
+    softness: 0.4,
+    bias: 0.001,
+    normalBias: 0.01,
+    maxDistance: 48,
+    resolution: 1024,
+    cascadeCount: 2,
+    blurKernel: 4,
+};
+export function createDynamicShadowSystem(scene, directionalLight, options = {}) {
+    return new BabylonDynamicShadowSystem(scene, directionalLight, options);
+}
+class BabylonDynamicShadowSystem {
+    constructor(scene, directionalLight, options) {
+        this.scene = scene;
+        this.directionalLight = directionalLight;
+        this.shadowGenerator = null;
+        this.casters = new Set();
+        this.receivers = new Map();
+        this.receiverStates = new Map();
+        this.renderObserver = null;
+        this.initialized = false;
+        this.previousSceneShadowsEnabled = null;
+        this.previousLightShadowEnabled = null;
+        this.previousLightAutoUpdateExtends = null;
+        this.previousLightFrustum = null;
+        this.useCsmExplicit = false;
+        this.useCsmExplicit = hasExplicitUseCsm(options);
+        this.options = resolveDynamicShadowOptions(options);
+        this.diagnostics = this.createDiagnostics(null, []);
+    }
+    initialize() {
+        if (this.initialized || !this.options.enabled)
+            return;
+        this.previousSceneShadowsEnabled = this.scene.shadowsEnabled;
+        this.previousLightShadowEnabled = this.directionalLight.shadowEnabled;
+        this.previousLightAutoUpdateExtends = this.directionalLight.autoUpdateExtends;
+        this.previousLightFrustum = {
+            left: this.directionalLight.orthoLeft,
+            right: this.directionalLight.orthoRight,
+            top: this.directionalLight.orthoTop,
+            bottom: this.directionalLight.orthoBottom,
+            minZ: this.directionalLight.shadowMinZ,
+            maxZ: this.directionalLight.shadowMaxZ,
+        };
+        this.scene.shadowsEnabled = true;
+        this.directionalLight.shadowEnabled = true;
+        this.directionalLight.autoUpdateExtends = false;
+        this.ensureShadowGenerator();
+        this.renderObserver = this.scene.onBeforeRenderObservable.add(() => this.refresh());
+        this.initialized = true;
+        this.refresh();
+    }
+    addCaster(mesh) {
+        if (isDisposed(mesh))
+            return false;
+        this.casters.add(mesh);
+        if (!this.options.enabled || !this.initialized)
+            return true;
+        this.shadowGenerator?.addShadowCaster(mesh, true);
+        this.refresh();
+        return true;
+    }
+    removeCaster(mesh) {
+        this.casters.delete(mesh);
+        this.shadowGenerator?.removeShadowCaster(mesh, true);
+        this.refresh();
+    }
+    addReceiver(mesh) {
+        if (isDisposed(mesh))
+            return;
+        if (!this.receivers.has(mesh)) {
+            this.receivers.set(mesh, createReceiverInfo(mesh, this.receiverStates));
+        }
+        if (!this.options.enabled || !this.initialized)
+            return;
+        activateReceiverInfo(this.receivers.get(mesh));
+        this.refresh();
+    }
+    removeReceiver(mesh) {
+        const info = this.receivers.get(mesh);
+        if (info)
+            releaseReceiverInfo(info, this.receiverStates);
+        this.receivers.delete(mesh);
+        this.refresh();
+    }
+    setCamera(camera) {
+        this.options = {
+            ...this.options,
+            camera,
+        };
+        if (this.shadowGenerator)
+            this.shadowGenerator.camera = camera;
+        this.refresh();
+    }
+    setOptions(options) {
+        const previous = this.options;
+        if (hasExplicitUseCsm(options))
+            this.useCsmExplicit = true;
+        this.options = resolveDynamicShadowOptions(options, this.options, this.useCsmExplicit);
+        if (previous.enabled && !this.options.enabled) {
+            this.dispose();
+            return;
+        }
+        const generatorNeedsRecreate = previous.params.resolution !== this.options.params.resolution
+            || previous.params.cascadeCount !== this.options.params.cascadeCount
+            || previous.useCsm !== this.options.useCsm;
+        if (generatorNeedsRecreate && this.initialized)
+            this.recreateShadowGenerator();
+        else if (this.shadowGenerator)
+            this.shadowGenerator.camera = this.options.camera ?? null;
+        if (!previous.enabled && this.options.enabled)
+            this.initialize();
+        else
+            this.refresh();
+    }
+    refresh() {
+        if (!this.options.enabled || !this.initialized)
+            return;
+        this.pruneDisposedEntries();
+        const generator = this.ensureShadowGenerator();
+        if (!generator) {
+            this.diagnostics = this.createDiagnostics(null, ['shadow generator unavailable']);
+            return;
+        }
+        this.applyGeneratorParams(this.options.params);
+        this.syncShadowMapRenderList();
+        for (const receiver of this.receivers.values())
+            activateReceiverInfo(receiver);
+        const fit = this.fitDirectionalLightBounds();
+        this.diagnostics = this.createDiagnostics(fit, []);
+    }
+    getShadowGenerator() {
+        return this.shadowGenerator;
+    }
+    getDiagnostics() {
+        return cloneDynamicShadowDiagnostics(this.diagnostics);
+    }
+    dispose() {
+        if (this.renderObserver) {
+            this.scene.onBeforeRenderObservable.remove(this.renderObserver);
+            this.renderObserver = null;
+        }
+        for (const receiver of this.receivers.values())
+            releaseReceiverInfo(receiver, this.receiverStates);
+        this.receiverStates.clear();
+        this.receivers.clear();
+        this.casters.clear();
+        this.shadowGenerator?.dispose();
+        this.shadowGenerator = null;
+        if (this.previousSceneShadowsEnabled !== null) {
+            this.scene.shadowsEnabled = this.previousSceneShadowsEnabled;
+            this.previousSceneShadowsEnabled = null;
+        }
+        if (this.previousLightShadowEnabled !== null) {
+            this.directionalLight.shadowEnabled = this.previousLightShadowEnabled;
+            this.previousLightShadowEnabled = null;
+        }
+        if (this.previousLightAutoUpdateExtends !== null) {
+            this.directionalLight.autoUpdateExtends = this.previousLightAutoUpdateExtends;
+            this.previousLightAutoUpdateExtends = null;
+        }
+        if (this.previousLightFrustum) {
+            this.directionalLight.orthoLeft = this.previousLightFrustum.left;
+            this.directionalLight.orthoRight = this.previousLightFrustum.right;
+            this.directionalLight.orthoTop = this.previousLightFrustum.top;
+            this.directionalLight.orthoBottom = this.previousLightFrustum.bottom;
+            this.directionalLight.shadowMinZ = this.previousLightFrustum.minZ;
+            this.directionalLight.shadowMaxZ = this.previousLightFrustum.maxZ;
+            this.previousLightFrustum = null;
+        }
+        this.initialized = false;
+        this.diagnostics = this.createDiagnostics(null, []);
+    }
+    ensureShadowGenerator() {
+        if (this.shadowGenerator)
+            return this.shadowGenerator;
+        const params = this.options.params;
+        if (this.options.useCsm && params.cascadeCount > 1 && CascadedShadowGenerator.IsSupported) {
+            const generator = new CascadedShadowGenerator(params.resolution, this.directionalLight, undefined, this.options.camera ?? undefined);
+            generator.numCascades = params.cascadeCount;
+            generator.stabilizeCascades = true;
+            this.shadowGenerator = generator;
+        }
+        else {
+            this.shadowGenerator = new ShadowGenerator(params.resolution, this.directionalLight, undefined, this.options.camera ?? undefined);
+        }
+        this.applyGeneratorParams(params);
+        return this.shadowGenerator;
+    }
+    recreateShadowGenerator() {
+        const existingCasters = [...this.casters];
+        this.shadowGenerator?.dispose();
+        this.shadowGenerator = null;
+        const generator = this.ensureShadowGenerator();
+        for (const caster of existingCasters) {
+            generator?.addShadowCaster(caster, true);
+        }
+    }
+    applyGeneratorParams(params) {
+        const generator = this.shadowGenerator;
+        if (!generator)
+            return;
+        generator.useBlurExponentialShadowMap = false;
+        generator.useKernelBlur = false;
+        generator.usePercentageCloserFiltering = true;
+        generator.filteringQuality = ShadowGenerator.QUALITY_HIGH;
+        generator.setDarkness(clamp01(1 - params.opacity));
+        generator.bias = params.bias;
+        generator.normalBias = params.normalBias;
+        if (generator instanceof CascadedShadowGenerator) {
+            generator.numCascades = params.cascadeCount;
+            generator.shadowMaxZ = params.maxDistance;
+        }
+    }
+    syncShadowMapRenderList() {
+        const renderList = this.shadowGenerator?.getShadowMap?.()?.renderList;
+        if (!renderList)
+            return;
+        renderList.length = 0;
+        for (const caster of this.casters) {
+            if (!isDisposed(caster)) {
+                this.shadowGenerator?.addShadowCaster(caster, true);
+            }
+        }
+    }
+    fitDirectionalLightBounds() {
+        const params = this.options.params;
+        const points = this.collectCoveragePoints(params);
+        if (points.length === 0)
+            return null;
+        const worldBounds = boundsFromPoints(points);
+        const viewMatrix = createShadowViewMatrix(this.directionalLight);
+        const lightPoints = points.map(point => Vector3.TransformCoordinates(point, viewMatrix));
+        const lightBounds = boundsFromPoints(lightPoints);
+        const padding = readPositiveNumber(this.options.boundsPadding, Math.max(0.5, params.maxDistance * 0.025));
+        const rawLeft = lightBounds.min.x - padding;
+        const rawRight = lightBounds.max.x + padding;
+        const rawBottom = lightBounds.min.y - padding;
+        const rawTop = lightBounds.max.y + padding;
+        const width = Math.max(1e-4, rawRight - rawLeft);
+        const height = Math.max(1e-4, rawTop - rawBottom);
+        const texelSize = Math.max(width, height) / params.resolution;
+        const bounds = this.options.stableSnapping === false || texelSize <= 0
+            ? {
+                left: rawLeft,
+                right: rawRight,
+                bottom: rawBottom,
+                top: rawTop,
+                minZ: lightBounds.min.z - padding,
+                maxZ: lightBounds.max.z + padding,
+            }
+            : {
+                left: Math.floor(rawLeft / texelSize) * texelSize,
+                right: Math.ceil(rawRight / texelSize) * texelSize,
+                bottom: Math.floor(rawBottom / texelSize) * texelSize,
+                top: Math.ceil(rawTop / texelSize) * texelSize,
+                minZ: Math.floor((lightBounds.min.z - padding) / texelSize) * texelSize,
+                maxZ: Math.ceil((lightBounds.max.z + padding) / texelSize) * texelSize,
+            };
+        this.directionalLight.orthoLeft = bounds.left;
+        this.directionalLight.orthoRight = bounds.right;
+        this.directionalLight.orthoBottom = bounds.bottom;
+        this.directionalLight.orthoTop = bounds.top;
+        this.directionalLight.shadowMinZ = bounds.minZ;
+        this.directionalLight.shadowMaxZ = Math.max(this.directionalLight.shadowMinZ + 1, bounds.maxZ);
+        return {
+            world: {
+                min: serializeVec3(worldBounds.min),
+                max: serializeVec3(worldBounds.max),
+            },
+            lightOrtho: {
+                left: bounds.left,
+                right: bounds.right,
+                bottom: bounds.bottom,
+                top: bounds.top,
+                minZ: this.directionalLight.shadowMinZ,
+                maxZ: this.directionalLight.shadowMaxZ,
+            },
+            texelSize,
+            cameraProjection: readCameraProjection(this.options.camera),
+        };
+    }
+    collectCoveragePoints(params) {
+        const points = [];
+        const lightDirection = readLightDirection(this.directionalLight.getShadowDirection(0));
+        const shadowOffset = lightDirection.scale(params.maxDistance);
+        for (const caster of this.casters) {
+            points.push(...readMeshBoundsCorners(caster));
+            for (const corner of readMeshBoundsCorners(caster))
+                points.push(corner.add(shadowOffset));
+        }
+        for (const receiver of this.receivers.keys())
+            points.push(...readMeshBoundsCorners(receiver));
+        points.push(...readCameraCoveragePoints(this.options.camera, this.scene, params.maxDistance));
+        return points.filter(point => Number.isFinite(point.x) && Number.isFinite(point.y) && Number.isFinite(point.z));
+    }
+    pruneDisposedEntries() {
+        for (const caster of [...this.casters]) {
+            if (isDisposed(caster))
+                this.casters.delete(caster);
+        }
+        for (const [receiver, info] of [...this.receivers]) {
+            if (isDisposed(receiver)) {
+                releaseReceiverInfo(info, this.receiverStates);
+                this.receivers.delete(receiver);
+            }
+        }
+    }
+    createDiagnostics(bounds, fallbackReasons) {
+        const generator = this.shadowGenerator;
+        const renderList = generator?.getShadowMap?.()?.renderList ?? [];
+        return {
+            enabled: this.options.enabled,
+            casterCount: this.casters.size,
+            receiverCount: this.receivers.size,
+            generator: generator
+                ? {
+                    className: generator.getClassName?.() ?? null,
+                    mapSize: generator.getShadowMap?.()?.getSize?.() ?? null,
+                    darkness: generator.getDarkness?.() ?? null,
+                    bias: generator.bias ?? null,
+                    normalBias: generator.normalBias ?? null,
+                    blurKernel: generator.blurKernel ?? null,
+                    renderListCount: renderList.length,
+                    useCsm: generator instanceof CascadedShadowGenerator,
+                }
+                : null,
+            params: { ...this.options.params },
+            bounds,
+            fallbackReasons,
+        };
+    }
+}
+function resolveDynamicShadowOptions(options, fallback, preserveFallbackUseCsm = false) {
+    const params = resolveDynamicShadowParams(options.params, fallback?.params);
+    return {
+        enabled: options.enabled ?? fallback?.enabled ?? true,
+        camera: options.camera ?? fallback?.camera ?? null,
+        params,
+        useCsm: options.useCsm ?? (preserveFallbackUseCsm ? fallback?.useCsm : undefined) ?? params.cascadeCount > 1,
+        boundsPadding: readPositiveNumber(options.boundsPadding, fallback?.boundsPadding ?? Math.max(0.5, params.maxDistance * 0.025)),
+        stableSnapping: options.stableSnapping ?? fallback?.stableSnapping ?? true,
+        debug: options.debug ?? fallback?.debug ?? false,
+    };
+}
+function hasExplicitUseCsm(options) {
+    return Object.prototype.hasOwnProperty.call(options, 'useCsm') && typeof options.useCsm === 'boolean';
+}
+function resolveDynamicShadowParams(params, fallback = DEFAULT_DYNAMIC_SHADOW_PARAMS) {
+    return {
+        opacity: clamp01(readFiniteNumber(params?.opacity, fallback.opacity)),
+        softness: clamp01(readFiniteNumber(params?.softness, fallback.softness)),
+        bias: readFiniteNumber(params?.bias, fallback.bias),
+        normalBias: readFiniteNumber(params?.normalBias, fallback.normalBias),
+        maxDistance: readPositiveNumber(params?.maxDistance, fallback.maxDistance),
+        resolution: readShadowResolution(params?.resolution, fallback.resolution),
+        cascadeCount: readCascadeCount(params?.cascadeCount, fallback.cascadeCount),
+        blurKernel: Math.max(0, Math.round(readFiniteNumber(params?.blurKernel, fallback.blurKernel))),
+    };
+}
+function createReceiverInfo(mesh, receiverStates) {
+    const trackedMeshes = [mesh];
+    const sourceMesh = mesh.sourceMesh;
+    if (sourceMesh && sourceMesh !== mesh)
+        trackedMeshes.push(sourceMesh);
+    for (const trackedMesh of trackedMeshes)
+        acquireReceiverState(trackedMesh, receiverStates);
+    return { mesh, trackedMeshes };
+}
+function activateReceiverInfo(info) {
+    if (!info)
+        return;
+    for (const mesh of info.trackedMeshes)
+        mesh.receiveShadows = true;
+}
+function acquireReceiverState(mesh, receiverStates) {
+    const existing = receiverStates.get(mesh);
+    if (existing) {
+        existing.refCount += 1;
+        return;
+    }
+    receiverStates.set(mesh, {
+        mesh,
+        previousReceiveShadows: mesh.receiveShadows,
+        refCount: 1,
+    });
+}
+function releaseReceiverInfo(info, receiverStates) {
+    for (const mesh of info.trackedMeshes)
+        releaseReceiverState(mesh, receiverStates);
+}
+function releaseReceiverState(mesh, receiverStates) {
+    const state = receiverStates.get(mesh);
+    if (!state)
+        return;
+    state.refCount -= 1;
+    if (state.refCount > 0)
+        return;
+    state.mesh.receiveShadows = state.previousReceiveShadows;
+    receiverStates.delete(mesh);
+}
+function readMeshBoundsCorners(mesh) {
+    if (isDisposed(mesh))
+        return [];
+    mesh.computeWorldMatrix(true);
+    const bounds = mesh.getHierarchyBoundingVectors(true);
+    return createBoundsCorners(bounds.min, bounds.max);
+}
+function readCameraCoveragePoints(camera, scene, maxDistance) {
+    if (!camera)
+        return [];
+    const position = camera.globalPosition ?? camera.position;
+    if (!position)
+        return [];
+    const forward = safeCameraDirection(camera, Vector3.Forward(), new Vector3(0, 0, 1));
+    const right = safeCameraDirection(camera, Vector3.Right(), new Vector3(1, 0, 0));
+    const up = safeCameraDirection(camera, Vector3.Up(), new Vector3(0, 1, 0));
+    const farDistance = Math.max(1, Math.min(maxDistance, readPositiveNumber(camera.maxZ, maxDistance)));
+    const nearDistance = Math.max(0.1, Math.min(farDistance, readPositiveNumber(camera.minZ, 0.1)));
+    const aspect = readSceneAspect(scene);
+    if (camera.mode === Camera.ORTHOGRAPHIC_CAMERA) {
+        const halfHeight = Math.max(0.5, Math.abs(readFiniteNumber(camera.orthoTop, 1) - readFiniteNumber(camera.orthoBottom, -1)) * 0.5);
+        const halfWidth = Math.max(0.5, Math.abs(readFiniteNumber(camera.orthoRight, aspect) - readFiniteNumber(camera.orthoLeft, -aspect)) * 0.5);
+        return [
+            ...createCameraPlaneCorners(position.add(forward.scale(nearDistance)), right, up, halfWidth, halfHeight),
+            ...createCameraPlaneCorners(position.add(forward.scale(farDistance)), right, up, halfWidth, halfHeight),
+        ];
+    }
+    const fov = readPositiveNumber(camera.fov, 0.8);
+    const farHalfHeight = Math.tan(fov * 0.5) * farDistance;
+    const farHalfWidth = farHalfHeight * aspect;
+    const nearHalfHeight = Math.tan(fov * 0.5) * nearDistance;
+    const nearHalfWidth = nearHalfHeight * aspect;
+    return [
+        ...createCameraPlaneCorners(position.add(forward.scale(nearDistance)), right, up, nearHalfWidth, nearHalfHeight),
+        ...createCameraPlaneCorners(position.add(forward.scale(farDistance)), right, up, farHalfWidth, farHalfHeight),
+    ];
+}
+function createCameraPlaneCorners(center, right, up, halfWidth, halfHeight) {
+    return [
+        center.add(right.scale(-halfWidth)).add(up.scale(-halfHeight)),
+        center.add(right.scale(halfWidth)).add(up.scale(-halfHeight)),
+        center.add(right.scale(halfWidth)).add(up.scale(halfHeight)),
+        center.add(right.scale(-halfWidth)).add(up.scale(halfHeight)),
+    ];
+}
+function createShadowViewMatrix(light) {
+    let lightPosition = light.position;
+    if (light.computeTransformedInformation()) {
+        lightPosition = light.transformedPosition;
+    }
+    const lightDirection = readLightDirection(light.getShadowDirection(0));
+    if (Math.abs(Vector3.Dot(lightDirection, Vector3.Up())) === 1) {
+        lightDirection.z = 1e-13;
+    }
+    return Matrix.LookAtLH(lightPosition, lightPosition.add(lightDirection), Vector3.Up());
+}
+function boundsFromPoints(points) {
+    const min = new Vector3(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY);
+    const max = new Vector3(Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY);
+    for (const point of points) {
+        min.minimizeInPlace(point);
+        max.maximizeInPlace(point);
+    }
+    return { min, max };
+}
+function createBoundsCorners(min, max) {
+    return [
+        new Vector3(min.x, min.y, min.z),
+        new Vector3(max.x, min.y, min.z),
+        new Vector3(max.x, max.y, min.z),
+        new Vector3(min.x, max.y, min.z),
+        new Vector3(min.x, min.y, max.z),
+        new Vector3(max.x, min.y, max.z),
+        new Vector3(max.x, max.y, max.z),
+        new Vector3(min.x, max.y, max.z),
+    ];
+}
+function safeCameraDirection(camera, localAxis, fallback) {
+    try {
+        const direction = camera.getDirection(localAxis);
+        if (isFiniteVector(direction) && direction.lengthSquared() > 1e-8)
+            return direction.normalize();
+    }
+    catch {
+        // Camera direction is best-effort diagnostics input; use a stable fallback.
+    }
+    return fallback.clone();
+}
+function readLightDirection(direction) {
+    return isFiniteVector(direction) && direction.lengthSquared() > 1e-8
+        ? direction.clone().normalize()
+        : new Vector3(-0.3, -1, -0.2).normalize();
+}
+function readCameraProjection(camera) {
+    if (!camera)
+        return 'none';
+    return camera.mode === Camera.ORTHOGRAPHIC_CAMERA ? 'orthographic' : 'perspective';
+}
+function readSceneAspect(scene) {
+    const engine = scene.getEngine();
+    const width = Math.max(1, engine.getRenderWidth());
+    const height = Math.max(1, engine.getRenderHeight());
+    return width / height;
+}
+function cloneDynamicShadowDiagnostics(diagnostics) {
+    return {
+        ...diagnostics,
+        generator: diagnostics.generator ? { ...diagnostics.generator } : null,
+        params: { ...diagnostics.params },
+        bounds: diagnostics.bounds
+            ? {
+                world: {
+                    min: { ...diagnostics.bounds.world.min },
+                    max: { ...diagnostics.bounds.world.max },
+                },
+                lightOrtho: { ...diagnostics.bounds.lightOrtho },
+                texelSize: diagnostics.bounds.texelSize,
+                cameraProjection: diagnostics.bounds.cameraProjection,
+            }
+            : null,
+        fallbackReasons: [...diagnostics.fallbackReasons],
+    };
+}
+function serializeVec3(value) {
+    return { x: value.x, y: value.y, z: value.z };
+}
+function isFiniteVector(value) {
+    return Number.isFinite(value.x) && Number.isFinite(value.y) && Number.isFinite(value.z);
+}
+function isDisposed(mesh) {
+    return typeof mesh.isDisposed === 'function' && mesh.isDisposed();
+}
+function readFiniteNumber(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+function readPositiveNumber(value, fallback) {
+    const number = readFiniteNumber(value, fallback);
+    return number > 0 ? number : fallback;
+}
+function clamp01(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    return Math.min(1, Math.max(0, value));
+}
+function readShadowResolution(value, fallback) {
+    return value === 512 || value === 1024 || value === 2048 || value === 4096
+        ? value
+        : fallback;
+}
+function readCascadeCount(value, fallback) {
+    return value === 1 || value === 2 || value === 4 ? value : fallback;
+}
+//# sourceMappingURL=dynamic-shadow-system.js.map