@fps-games/engine 0.0.1-beta.2 → 0.0.1-beta.20

package/dist/babylon/renderer/shadows/dynamic-shadow-system.js

@@ -0,0 +1,659 @@
+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 './shadow-generator-shaders.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 {
+    scene;
+    directionalLight;
+    options;
+    shadowGenerator = null;
+    casters = new Set();
+    receivers = new Map();
+    receiverStates = new Map();
+    renderObserver = null;
+    initialized = false;
+    diagnostics;
+    previousSceneShadowsEnabled = null;
+    previousLightShadowEnabled = null;
+    previousLightAutoUpdateExtends = null;
+    previousLightPosition = null;
+    previousLightFrustum = null;
+    useCsmExplicit = false;
+    constructor(scene, directionalLight, options) {
+        this.scene = scene;
+        this.directionalLight = directionalLight;
+        this.useCsmExplicit = hasExplicitUseCsm(options);
+        this.options = resolveDynamicShadowOptions(options);
+        this.diagnostics = this.createDiagnostics(null, []);
+    }
+    initialize() {
+        if (this.initialized || !this.options.enabled)
+            return;
+        try {
+            this.previousSceneShadowsEnabled = this.scene.shadowsEnabled;
+            this.previousLightShadowEnabled = this.directionalLight.shadowEnabled;
+            this.previousLightAutoUpdateExtends = this.directionalLight.autoUpdateExtends;
+            this.previousLightPosition = this.options.fitStrategy === 'receiver-projected'
+                ? this.directionalLight.position.clone()
+                : null;
+            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();
+        }
+        catch (error) {
+            this.dispose();
+            throw error;
+        }
+    }
+    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 (this.initialized && previous.fitStrategy !== this.options.fitStrategy) {
+            if (this.options.fitStrategy === 'receiver-projected') {
+                this.previousLightPosition = this.directionalLight.position.clone();
+            }
+            else if (this.previousLightPosition) {
+                this.directionalLight.position.copyFrom(this.previousLightPosition);
+                this.previousLightPosition = null;
+            }
+        }
+        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.previousLightPosition) {
+            this.directionalLight.position.copyFrom(this.previousLightPosition);
+            this.previousLightPosition = 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() {
+        if (this.options.fitStrategy === 'receiver-projected') {
+            return this.fitReceiverProjectedDirectionalLightBounds();
+        }
+        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),
+        };
+    }
+    fitReceiverProjectedDirectionalLightBounds() {
+        const params = this.options.params;
+        const direction = readLightDirection(this.directionalLight.getShadowDirection(0));
+        const casterBounds = [...this.casters]
+            .filter(caster => !isDisposed(caster))
+            .map(readMeshWorldBounds);
+        const receiverBounds = [...this.receivers.keys()]
+            .filter(receiver => !isDisposed(receiver))
+            .map(readMeshWorldBounds);
+        const points = [];
+        for (const bounds of casterBounds) {
+            points.push(...createBoundsCorners(bounds.min, bounds.max));
+            for (const receiver of receiverBounds) {
+                points.push(...projectBoundsOntoReceiver(bounds, receiver, direction));
+            }
+        }
+        if (points.length === 0)
+            return null;
+        const worldBounds = boundsFromPoints(points);
+        const center = worldBounds.min.add(worldBounds.max).scale(0.5);
+        const size = worldBounds.max.subtract(worldBounds.min);
+        const maxExtent = Math.max(size.x, size.y, size.z);
+        const padding = readPositiveNumber(this.options.boundsPadding, Math.max(2, maxExtent * 0.25));
+        const halfSize = Math.max(4, maxExtent * 0.5 + padding);
+        const distance = Math.max(16, maxExtent + padding * 3);
+        this.directionalLight.position.copyFrom(center.subtract(direction.scale(distance)));
+        const bounds = {
+            left: -halfSize,
+            right: halfSize,
+            bottom: -halfSize,
+            top: halfSize,
+            minZ: 0.1,
+            maxZ: Math.max(32, distance + maxExtent + padding),
+        };
+        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 = bounds.maxZ;
+        return {
+            world: {
+                min: serializeVec3(worldBounds.min),
+                max: serializeVec3(worldBounds.max),
+            },
+            lightOrtho: bounds,
+            texelSize: (halfSize * 2) / params.resolution,
+            cameraProjection: 'none',
+        };
+    }
+    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,
+        fitStrategy: options.fitStrategy ?? fallback?.fitStrategy ?? 'light-space',
+        boundsPadding: options.boundsPadding ?? fallback?.boundsPadding,
+        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';
+}
+export 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 readMeshWorldBounds(mesh) {
+    mesh.computeWorldMatrix(true);
+    const bounds = mesh.getBoundingInfo().boundingBox;
+    return { min: bounds.minimumWorld.clone(), max: bounds.maximumWorld.clone() };
+}
+function projectBoundsOntoReceiver(caster, receiver, direction) {
+    const receiverY = receiver.max.y;
+    if (Math.abs(direction.y) < 1e-6)
+        return [];
+    return createBoundsCorners(caster.min, caster.max).flatMap(point => {
+        const distance = (receiverY - point.y) / direction.y;
+        if (!Number.isFinite(distance))
+            return [];
+        return [point.add(direction.scale(Math.max(0, distance)))];
+    });
+}
+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