@fps-games/engine 0.0.1-beta.1 → 0.0.1-beta.10

package/dist/babylon/renderer/shadows/shadow-map-experiment-depth-backend.js

@@ -0,0 +1,829 @@
+import { FreeCamera } from '@babylonjs/core/Cameras/freeCamera.js';
+import { Camera } from '@babylonjs/core/Cameras/camera.js';
+import { DirectionalLight } from '@babylonjs/core/Lights/directionalLight.js';
+import { ShadowGenerator } from '@babylonjs/core/Lights/Shadows/shadowGenerator.js';
+import { Material } from '@babylonjs/core/Materials/material.js';
+import { EffectRenderer, EffectWrapper } from '@babylonjs/core/Materials/effectRenderer.js';
+import { RenderTargetTexture } from '@babylonjs/core/Materials/Textures/renderTargetTexture.js';
+import { Vector3 } from '@babylonjs/core/Maths/math.vector.js';
+import { MeshBuilder } from '@babylonjs/core/Meshes/meshBuilder.js';
+import { DEFAULT_SHADOW_MAP_EXPERIMENT_SOFTNESS, resolveShadowMapExperimentAppearance, } from '../../../rendering/index.js';
+const COMPOSITOR_COMPILE_RETRY_LIMIT = 240;
+const MAX_FULL_FLOAT_SPLIT_DEPTH_TEXELS = 3 * 2048 * 2048;
+const SOFT_BLUR_SCALE = 2;
+const MAX_SOFT_KERNEL_TEXELS = 16;
+export function readBabylonShadowMapExperimentAllocationCleanup(error) {
+    const cleanup = error
+        ?.shadowMapExperimentAllocationCleanup;
+    return typeof cleanup === 'function' ? cleanup : null;
+}
+export function createBabylonShadowMapExperimentDepthBackend(scene, light, plan, options = {}) {
+    const gpuCapability = readGpuCapability(scene.getEngine(), plan);
+    if (plan.generator.backend.mode === 'single') {
+        assertSingleBackendSupported(plan, gpuCapability);
+        return createSingleBackend(light, plan, null, gpuCapability);
+    }
+    const unsupportedReason = readSplitUnsupportedReason(gpuCapability, plan);
+    if (unsupportedReason)
+        return fallbackOrThrow(light, plan, unsupportedReason, gpuCapability);
+    try {
+        return createSplitBackend(scene, light, plan, gpuCapability, options);
+    }
+    catch (error) {
+        const retryCleanup = readBabylonShadowMapExperimentAllocationCleanup(error);
+        if (retryCleanup) {
+            const cleanupErrors = retryCleanup();
+            if (cleanupErrors.length > 0)
+                throw attachAllocationCleanup(error, retryCleanup, cleanupErrors);
+        }
+        return fallbackOrThrow(light, plan, `split-initialization-failed:${errorMessage(error)}`, gpuCapability);
+    }
+}
+export function createBabylonShadowMapExperimentSingleDepthBackend(light, plan, fallbackReason) {
+    const gpuCapability = readGpuCapability(light.getScene().getEngine(), plan);
+    assertSingleBackendSupported(plan, gpuCapability);
+    return createSingleBackend(light, plan, fallbackReason, gpuCapability);
+}
+function createSplitBackend(scene, light, plan, gpuCapability, options) {
+    const resources = [];
+    const existingGenerators = snapshotShadowGenerators(light);
+    const existingSceneMeshes = new Set(scene.meshes);
+    const leakedFacadeSentinels = new Set();
+    const existingSceneCameras = new Set(scene.cameras);
+    const leakedHelperCameras = new Set();
+    const leakedGenerators = new Set();
+    try {
+        const staticCamera = createHelperCamera(scene, 'static');
+        trackDisposable(resources, staticCamera);
+        const dynamicCamera = createHelperCamera(scene, 'dynamic');
+        trackDisposable(resources, dynamicCamera);
+        const staticGenerator = new ShadowGenerator(plan.generator.maps.staticResolution, light, true, staticCamera, true, true);
+        trackDisposable(resources, staticGenerator);
+        const dynamicGenerator = new ShadowGenerator(plan.generator.maps.dynamicResolution, light, true, dynamicCamera, true, true);
+        trackDisposable(resources, dynamicGenerator);
+        const facadeGenerator = new ShadowGenerator(plan.generator.maps.compositeResolution, light, true, null, true, true);
+        trackDisposable(resources, facadeGenerator);
+        configureHardGenerator(staticGenerator, plan);
+        configureHardGenerator(dynamicGenerator, plan);
+        configureSplitFacadeGenerator(facadeGenerator, plan);
+        const staticMap = requireShadowMap(staticGenerator, 'static');
+        const dynamicMap = requireShadowMap(dynamicGenerator, 'dynamic');
+        const compositeMap = requireShadowMap(facadeGenerator, 'composite');
+        configureRenderOnce(staticMap);
+        configureRenderOnce(dynamicMap);
+        configureRenderOnce(compositeMap);
+        staticMap.renderList = [];
+        dynamicMap.renderList = [];
+        const facadeEligibilityMesh = MeshBuilder.CreatePlane('__fps_shadow_facade_eligibility__', { size: 0.001 }, scene);
+        trackDisposable(resources, facadeEligibilityMesh);
+        facadeEligibilityMesh.doNotSerialize = true;
+        scene.removeMesh(facadeEligibilityMesh);
+        compositeMap.renderList = [facadeEligibilityMesh];
+        scene.markAllMaterialsAsDirty(Material.LightDirtyFlag);
+        const compositor = createDepthCompositor(scene.getEngine(), staticMap, dynamicMap, compositeMap, options.onCompositorLifecycleEvent);
+        trackDisposable(resources, compositor);
+        const compositorFailure = compositor.getFailureReason();
+        if (compositorFailure)
+            throw new Error(compositorFailure);
+        compositeMap.customRenderFunction = () => compositor.render();
+        return createOwnedBackend({
+            mode: 'split-static-dynamic',
+            fallbackReason: null,
+            gpuCapability,
+            textureFormat: 'r-full-float',
+            receiverFilter: plan.generator.filter === 'low-pcf'
+                && resolveShadowMapExperimentAppearance(plan.generator).softness > 0
+                ? 'native-soft-kernel'
+                : 'hard',
+            filter: plan.generator.filter,
+            initialAppearance: resolveShadowMapExperimentAppearance(plan.generator),
+            generator: facadeGenerator,
+            staticGenerator,
+            dynamicGenerator,
+            compositor,
+            staticResolution: plan.generator.maps.staticResolution,
+            dynamicResolution: plan.generator.maps.dynamicResolution,
+            compositeResolution: plan.generator.maps.compositeResolution,
+            disposeResources: () => disposeTrackedReverse(resources),
+        });
+    }
+    catch (error) {
+        const nestedCleanup = readBabylonShadowMapExperimentAllocationCleanup(error);
+        const retryCleanup = () => Object.freeze([
+            ...(nestedCleanup?.() ?? []),
+            ...cleanupFailedGeneratorAllocation(light, existingGenerators, resources, leakedGenerators, scene, existingSceneMeshes, leakedFacadeSentinels, existingSceneCameras, leakedHelperCameras),
+        ]);
+        const cleanupErrors = retryCleanup();
+        throw cleanupErrors.length > 0 ? attachAllocationCleanup(error, retryCleanup, cleanupErrors) : error;
+    }
+}
+function createSingleBackend(light, plan, fallbackReason, gpuCapability) {
+    const existingGenerators = snapshotShadowGenerators(light);
+    const resources = [];
+    const leakedGenerators = new Set();
+    try {
+        const generator = new ShadowGenerator(plan.generator.maps.compositeResolution, light);
+        trackDisposable(resources, generator);
+        configureGenerator(generator, plan);
+        const map = requireShadowMap(generator, 'single');
+        configureRenderOnce(map);
+        return createOwnedBackend({
+            mode: fallbackReason ? 'single-map-fallback' : 'single-map',
+            fallbackReason,
+            gpuCapability,
+            textureFormat: 'single-map',
+            receiverFilter: readSingleMapReceiverFilter(generator, plan),
+            filter: plan.generator.filter,
+            initialAppearance: resolveShadowMapExperimentAppearance(plan.generator),
+            generator,
+            staticGenerator: generator,
+            dynamicGenerator: generator,
+            compositor: null,
+            staticResolution: plan.generator.maps.compositeResolution,
+            dynamicResolution: plan.generator.maps.compositeResolution,
+            compositeResolution: plan.generator.maps.compositeResolution,
+            disposeResources: () => generator.dispose(),
+        });
+    }
+    catch (error) {
+        const retryCleanup = () => cleanupFailedGeneratorAllocation(light, existingGenerators, resources, leakedGenerators);
+        const cleanupErrors = retryCleanup();
+        throw cleanupErrors.length > 0 ? attachAllocationCleanup(error, retryCleanup, cleanupErrors) : error;
+    }
+}
+function createOwnedBackend(input) {
+    let disposed = false;
+    let staticCandidateCount = 0;
+    let dynamicCandidateCount = 0;
+    let staticRefreshCount = 0;
+    let dynamicRefreshCount = 0;
+    let compositeRefreshCount = 0;
+    let staticRenderCount = 0;
+    let dynamicRenderCount = 0;
+    let compositeRenderCount = 0;
+    let appearance = input.initialAppearance;
+    let receiverFilter = input.receiverFilter;
+    let staticLastReasons = Object.freeze([]);
+    let dynamicLastReasons = Object.freeze([]);
+    const staticCasters = new Set();
+    const dynamicCasters = new Set();
+    input.staticGenerator.getShadowMap()?.onBeforeRenderObservable.add(() => { staticRenderCount += 1; });
+    input.dynamicGenerator.getShadowMap()?.onBeforeRenderObservable.add(() => { dynamicRenderCount += 1; });
+    input.generator.getShadowMap()?.onBeforeRenderObservable.add(() => { compositeRenderCount += 1; });
+    const assertUsable = () => {
+        if (disposed)
+            throw new Error('shadowMapExperiment.depthBackendDisposed');
+    };
+    const generatorForLayer = (layer) => (layer === 'static' ? input.staticGenerator : input.dynamicGenerator);
+    const casterSetForLayer = (layer) => (layer === 'static' ? staticCasters : dynamicCasters);
+    return {
+        generator: input.generator,
+        mode: input.mode,
+        fallbackReason: input.fallbackReason,
+        getRuntimeFailureReason() {
+            return input.compositor?.getFailureReason() ?? null;
+        },
+        addCaster(mesh, layer) {
+            assertUsable();
+            const target = casterSetForLayer(layer);
+            const other = casterSetForLayer(layer === 'static' ? 'dynamic' : 'static');
+            const wasStatic = staticCasters.has(mesh);
+            const wasDynamic = dynamicCasters.has(mesh);
+            if (target.has(mesh) && !other.has(mesh))
+                return;
+            try {
+                if (isSingleMapMode(input.mode)) {
+                    if (!wasStatic && !wasDynamic)
+                        input.generator.addShadowCaster(mesh, false);
+                }
+                else {
+                    generatorForLayer(layer).addShadowCaster(mesh, false);
+                    if (other.has(mesh)) {
+                        generatorForLayer(layer === 'static' ? 'dynamic' : 'static').removeShadowCaster(mesh, false);
+                    }
+                }
+            }
+            catch (error) {
+                const rollbackErrors = restoreCasterMembership(input, mesh, wasStatic, wasDynamic);
+                throw attachCasterMutationRollback(error, rollbackErrors);
+            }
+            staticCasters.delete(mesh);
+            dynamicCasters.delete(mesh);
+            target.add(mesh);
+        },
+        removeCaster(mesh) {
+            assertUsable();
+            const wasStatic = staticCasters.has(mesh);
+            const wasDynamic = dynamicCasters.has(mesh);
+            if (!wasStatic && !wasDynamic)
+                return;
+            try {
+                if (isSingleMapMode(input.mode)) {
+                    input.generator.removeShadowCaster(mesh, false);
+                }
+                else {
+                    if (wasStatic)
+                        input.staticGenerator.removeShadowCaster(mesh, false);
+                    if (wasDynamic)
+                        input.dynamicGenerator.removeShadowCaster(mesh, false);
+                }
+            }
+            catch (error) {
+                const rollbackErrors = restoreCasterMembership(input, mesh, wasStatic, wasDynamic);
+                throw attachCasterMutationRollback(error, rollbackErrors);
+            }
+            staticCasters.delete(mesh);
+            dynamicCasters.delete(mesh);
+        },
+        hasCaster(mesh, layer) {
+            if (layer)
+                return casterSetForLayer(layer).has(mesh);
+            return staticCasters.has(mesh) || dynamicCasters.has(mesh);
+        },
+        setCandidateCounts(staticCount, dynamicCount) {
+            assertUsable();
+            staticCandidateCount = Math.max(0, Math.floor(staticCount));
+            dynamicCandidateCount = Math.max(0, Math.floor(dynamicCount));
+        },
+        setAppearance(nextAppearance) {
+            assertUsable();
+            const next = resolveShadowMapExperimentAppearance(nextAppearance);
+            const softnessChanged = next.softness !== appearance.softness;
+            input.generator.setDarkness(next.darkness);
+            if (softnessChanged) {
+                receiverFilter = configureReceiverAppearance(input.generator, input.mode, input.filter, input.compositeResolution ?? input.generator.getShadowMap()?.getSize().width ?? 0, next.softness);
+            }
+            appearance = next;
+            return Object.freeze({
+                compositeRefreshRequired: softnessChanged
+                    && input.filter === 'low-pcf'
+                    && input.mode === 'split-static-dynamic',
+            });
+        },
+        refresh(decision) {
+            assertUsable();
+            if (decision.static.shouldRefresh) {
+                input.staticGenerator.getShadowMap()?.resetRefreshCounter();
+                staticRefreshCount += 1;
+                staticLastReasons = decision.static.reasons;
+            }
+            if (decision.dynamic.shouldRefresh) {
+                input.dynamicGenerator.getShadowMap()?.resetRefreshCounter();
+                dynamicRefreshCount += 1;
+                dynamicLastReasons = decision.dynamic.reasons;
+            }
+            if (decision.composite.shouldRefresh) {
+                input.generator.getShadowMap()?.resetRefreshCounter();
+                compositeRefreshCount += 1;
+            }
+        },
+        getEvidence() {
+            const staticRetained = staticCasters.size;
+            const dynamicRetained = dynamicCasters.size;
+            return Object.freeze({
+                backend: input.mode,
+                fallbackReason: input.fallbackReason,
+                receiverFilter,
+                appearance,
+                gpuCapability: input.gpuCapability,
+                textureFormat: input.textureFormat,
+                static: layerEvidence(input.staticResolution ?? input.generator.getShadowMap()?.getSize().width ?? 0, staticCandidateCount, staticRetained, staticRefreshCount, staticRenderCount, staticLastReasons),
+                dynamic: layerEvidence(input.dynamicResolution ?? input.generator.getShadowMap()?.getSize().width ?? 0, dynamicCandidateCount, dynamicRetained, dynamicRefreshCount, dynamicRenderCount, dynamicLastReasons),
+                compositeResolution: input.compositeResolution ?? input.generator.getShadowMap()?.getSize().width ?? 0,
+                compositeRefreshCount,
+                compositeRenderCount,
+                compositorReady: input.compositor?.isReady() ?? true,
+            });
+        },
+        dispose() {
+            if (disposed)
+                return;
+            input.disposeResources();
+            staticCasters.clear();
+            dynamicCasters.clear();
+            disposed = true;
+        },
+    };
+}
+function restoreCasterMembership(input, mesh, wasStatic, wasDynamic) {
+    const rollbackErrors = [];
+    const attempt = (operation) => {
+        try {
+            operation();
+        }
+        catch (error) {
+            rollbackErrors.push(error);
+        }
+    };
+    if (isSingleMapMode(input.mode)) {
+        attempt(() => forceGeneratorCasterMembership(input.generator, mesh, wasStatic || wasDynamic, false));
+    }
+    else {
+        attempt(() => forceGeneratorCasterMembership(input.staticGenerator, mesh, wasStatic, false));
+        attempt(() => forceGeneratorCasterMembership(input.dynamicGenerator, mesh, wasDynamic, false));
+    }
+    return Object.freeze(rollbackErrors);
+}
+function isSingleMapMode(mode) {
+    return mode === 'single-map' || mode === 'single-map-fallback';
+}
+function forceGeneratorCasterMembership(generator, mesh, retained, markFacadeEligibility) {
+    const map = generator.getShadowMap();
+    if (!map)
+        return;
+    const wasEligible = (map.renderList?.length ?? 0) > 0;
+    const renderList = map.renderList ?? (map.renderList = []);
+    const index = renderList.indexOf(mesh);
+    if (retained && index === -1)
+        renderList.push(mesh);
+    if (!retained && index !== -1)
+        renderList.splice(index, 1);
+    const isEligible = renderList.length > 0;
+    if (markFacadeEligibility && wasEligible !== isEligible) {
+        generator.getLight().getScene().markAllMaterialsAsDirty(Material.LightDirtyFlag);
+    }
+}
+function attachCasterMutationRollback(error, rollbackErrors) {
+    if (rollbackErrors.length === 0)
+        return error;
+    if (error && (typeof error === 'object' || typeof error === 'function')) {
+        try {
+            Object.assign(error, { casterMutationRollbackErrors: rollbackErrors });
+            return error;
+        }
+        catch {
+            // Preserve the primary failure as cause when it cannot carry rollback diagnostics.
+        }
+    }
+    return Object.assign(new Error(errorMessage(error)), {
+        cause: error,
+        casterMutationRollbackErrors: rollbackErrors,
+    });
+}
+function createDepthCompositor(engine, staticMap, dynamicMap, compositeMap, onLifecycleEvent) {
+    const renderer = new EffectRenderer(engine);
+    let wrapper = null;
+    let compiled = false;
+    let compileError = null;
+    let runtimeError = null;
+    let pendingRenderAttemptCount = 0;
+    let lifecycleDisposed = false;
+    let readyNotified = false;
+    let failureNotified = false;
+    const notifyLifecycle = (event) => {
+        if (lifecycleDisposed)
+            return;
+        if (event === 'ready') {
+            if (readyNotified || failureNotified)
+                return;
+            readyNotified = true;
+        }
+        else if (event === 'failed') {
+            if (failureNotified)
+                return;
+            failureNotified = true;
+        }
+        else if (readyNotified || failureNotified) {
+            return;
+        }
+        onLifecycleEvent?.(event);
+    };
+    const queueLifecycle = (event) => {
+        queueMicrotask(() => notifyLifecycle(event));
+    };
+    try {
+        wrapper = new EffectWrapper({
+            engine,
+            name: 'fpsShadowDepthMinCompositor',
+            fragmentShader: `
+precision highp float;
+varying vec2 vUV;
+uniform sampler2D staticDepthSampler;
+uniform sampler2D dynamicDepthSampler;
+void main(void) {
+  float staticDepth = texture2D(staticDepthSampler, vUV).r;
+  float dynamicDepth = texture2D(dynamicDepthSampler, vUV).r;
+  float composedDepth = min(staticDepth, dynamicDepth);
+  gl_FragDepth = composedDepth;
+  gl_FragColor = vec4(composedDepth, 1.0, 1.0, 1.0);
+}`,
+            samplerNames: ['staticDepthSampler', 'dynamicDepthSampler'],
+            blockCompilation: true,
+        });
+        const ownedWrapper = wrapper;
+        ownedWrapper.onApplyObservable.add(() => {
+            ownedWrapper.effect.setTexture('staticDepthSampler', staticMap);
+            ownedWrapper.effect.setTexture('dynamicDepthSampler', dynamicMap);
+        });
+        ownedWrapper.updateEffect(null, ['scale'], ['staticDepthSampler', 'dynamicDepthSampler'], undefined, () => {
+            if (lifecycleDisposed)
+                return;
+            compiled = true;
+            pendingRenderAttemptCount = 0;
+            compositeMap.resetRefreshCounter();
+            queueLifecycle('ready');
+        }, (_effect, errors) => {
+            if (lifecycleDisposed)
+                return;
+            compileError = errors || 'unknown';
+            queueLifecycle('failed');
+        });
+    }
+    catch (error) {
+        const cleanupErrors = [];
+        let wrapperDisposed = wrapper === null;
+        let rendererDisposed = false;
+        const retryCleanup = () => {
+            const retryErrors = [];
+            if (!wrapperDisposed && wrapper) {
+                try {
+                    wrapper.dispose();
+                    wrapperDisposed = true;
+                }
+                catch (cleanupError) {
+                    retryErrors.push(cleanupError);
+                }
+            }
+            if (!rendererDisposed) {
+                try {
+                    renderer.dispose();
+                    rendererDisposed = true;
+                }
+                catch (cleanupError) {
+                    retryErrors.push(cleanupError);
+                }
+            }
+            return Object.freeze(retryErrors);
+        };
+        cleanupErrors.push(...retryCleanup());
+        if (cleanupErrors.length > 0) {
+            throw attachAllocationCleanup(error, retryCleanup, cleanupErrors);
+        }
+        throw error;
+    }
+    const ownedWrapper = wrapper;
+    let wrapperDisposed = false;
+    let rendererDisposed = false;
+    const readCompileError = () => {
+        if (compileError)
+            return compileError;
+        const effect = ownedWrapper.effect;
+        const effectError = effect?.getCompilationError() ?? '';
+        if (effectError) {
+            compileError = effectError;
+            queueLifecycle('failed');
+        }
+        return compileError;
+    };
+    return {
+        isReady() {
+            return runtimeError === null && readCompileError() === null && compiled && ownedWrapper.isReady();
+        },
+        getFailureReason() {
+            if (runtimeError)
+                return runtimeError;
+            const currentCompileError = readCompileError();
+            if (currentCompileError)
+                return `compositor-compile-failed:${currentCompileError}`;
+            return null;
+        },
+        render() {
+            if (runtimeError || readCompileError())
+                return;
+            if (!compiled || !ownedWrapper.isReady()) {
+                pendingRenderAttemptCount += 1;
+                if (pendingRenderAttemptCount >= COMPOSITOR_COMPILE_RETRY_LIMIT) {
+                    runtimeError = `compositor-compile-timeout:${COMPOSITOR_COMPILE_RETRY_LIMIT}-render-attempts`;
+                    notifyLifecycle('failed');
+                    return;
+                }
+                compositeMap.resetRefreshCounter();
+                notifyLifecycle('pending');
+                return;
+            }
+            try {
+                const previousDepthWrite = engine.getDepthWrite();
+                renderer.saveStates();
+                try {
+                    renderer.setViewport();
+                    engine.setDepthWrite(true);
+                    renderer.applyEffectWrapper(ownedWrapper, true);
+                    renderer.draw();
+                }
+                finally {
+                    engine.setDepthWrite(previousDepthWrite);
+                    renderer.restoreStates();
+                }
+            }
+            catch (error) {
+                runtimeError = `compositor-render-failed:${errorMessage(error)}`;
+                notifyLifecycle('failed');
+            }
+        },
+        dispose() {
+            lifecycleDisposed = true;
+            const cleanupErrors = [];
+            if (!wrapperDisposed) {
+                try {
+                    ownedWrapper.dispose();
+                    wrapperDisposed = true;
+                }
+                catch (error) {
+                    cleanupErrors.push(error);
+                }
+            }
+            if (!rendererDisposed) {
+                try {
+                    renderer.dispose();
+                    rendererDisposed = true;
+                }
+                catch (error) {
+                    cleanupErrors.push(error);
+                }
+            }
+            if (cleanupErrors.length > 0) {
+                throw Object.assign(new Error('shadowMapExperiment.depthCompositorDisposeFailed'), { cleanupErrors });
+            }
+        },
+    };
+}
+function createHelperCamera(scene, layer) {
+    const camera = new FreeCamera(`__fps_shadow_${layer}_camera__`, Vector3.Zero(), scene, false);
+    camera.doNotSerialize = true;
+    camera.layerMask = 0;
+    camera.minZ = 0.01;
+    camera.maxZ = 10_000;
+    camera.metadata = Object.freeze({ helper: true, shadowMapExperimentLayer: layer });
+    return camera;
+}
+function configureGenerator(generator, plan) {
+    configureGeneratorCommon(generator, plan);
+    configureReceiverAppearance(generator, 'single-map', plan.generator.filter, plan.generator.maps.compositeResolution, resolveShadowMapExperimentAppearance(plan.generator).softness);
+}
+function readSingleMapReceiverFilter(generator, plan) {
+    if (plan.generator.filter !== 'low-pcf')
+        return 'hard';
+    if (generator.useContactHardeningShadow)
+        return 'native-contact-hardening';
+    if (generator.usePercentageCloserFiltering)
+        return 'native-low-pcf';
+    if (generator.usePoissonSampling)
+        return 'poisson-low-pcf';
+    return 'hard';
+}
+function configureGeneratorCommon(generator, plan) {
+    generator.filteringQuality = ShadowGenerator.QUALITY_LOW;
+    generator.bias = plan.generator.bias;
+    generator.normalBias = plan.generator.normalBias;
+    generator.setDarkness(plan.generator.darkness);
+    generator.doNotSerialize = true;
+}
+function configureHardGenerator(generator, plan) {
+    configureGeneratorCommon(generator, plan);
+    generator.filter = ShadowGenerator.FILTER_NONE;
+}
+function configureSplitFacadeGenerator(generator, plan) {
+    configureHardGenerator(generator, plan);
+    configureReceiverAppearance(generator, 'split-static-dynamic', plan.generator.filter, plan.generator.maps.compositeResolution, resolveShadowMapExperimentAppearance(plan.generator).softness);
+}
+function configureReceiverAppearance(generator, mode, filter, compositeResolution, softness) {
+    if (filter !== 'low-pcf' || softness <= 0) {
+        generator.filter = ShadowGenerator.FILTER_NONE;
+        return 'hard';
+    }
+    if (mode === 'split-static-dynamic') {
+        configureSoftKernelGenerator(generator, compositeResolution, softness);
+        return 'native-soft-kernel';
+    }
+    generator.filteringQuality = ShadowGenerator.QUALITY_HIGH;
+    if (Math.abs(softness - DEFAULT_SHADOW_MAP_EXPERIMENT_SOFTNESS) <= 1e-6) {
+        generator.usePercentageCloserFiltering = true;
+        return 'native-low-pcf';
+    }
+    generator.contactHardeningLightSizeUVRatio = Math.max(0.001, softness * 0.1);
+    generator.useContactHardeningShadow = true;
+    return 'native-contact-hardening';
+}
+function configureSoftKernelGenerator(generator, compositeResolution, softness) {
+    generator.blurScale = SOFT_BLUR_SCALE;
+    generator.useKernelBlur = true;
+    generator.blurKernel = Math.max(2, Math.round(softness * MAX_SOFT_KERNEL_TEXELS * compositeResolution / 2048));
+    generator.useBlurCloseExponentialShadowMap = true;
+}
+function configureRenderOnce(map) {
+    map.refreshRate = RenderTargetTexture.REFRESHRATE_RENDER_ONCE;
+    map.renderParticles = false;
+}
+function requireShadowMap(generator, layer) {
+    const map = generator.getShadowMap();
+    if (!map)
+        throw new Error(`shadowMapExperiment.shadowMapUnavailable:${layer}`);
+    return map;
+}
+function readGpuCapability(engine, plan) {
+    const caps = engine.getCaps();
+    const engineKind = engine.isWebGPU ? 'webgpu' : 'webgl';
+    const fragmentDepthSupported = caps.fragmentDepthSupported === true;
+    const nativeShadowComparison = engine._features?.supportShadowSamplers === true;
+    const requiredResolution = Math.max(plan.generator.maps.staticResolution, plan.generator.maps.dynamicResolution, plan.generator.maps.compositeResolution);
+    const fullFloatRender = caps.textureFloatRender === true;
+    const fullFloatLinearFiltering = caps.textureFloatLinearFiltering === true;
+    const halfFloatRender = caps.textureHalfFloatRender === true;
+    const halfFloatLinearFiltering = caps.textureHalfFloatLinearFiltering === true;
+    const splitPreservesSourceResolution = readSplitSourceResolutionMismatch(plan) === null;
+    const splitWithinBudget = readFullFloatSplitDepthTexelCount(plan) <= MAX_FULL_FLOAT_SPLIT_DEPTH_TEXELS;
+    return Object.freeze({
+        engine: engineKind,
+        fragmentDepthSupported,
+        nativeShadowComparison,
+        fullFloatRender,
+        fullFloatLinearFiltering,
+        maxRenderTextureSize: caps.maxRenderTextureSize,
+        halfFloatRender,
+        halfFloatLinearFiltering,
+        splitSupported: engineKind === 'webgl'
+            && fragmentDepthSupported
+            && nativeShadowComparison
+            && caps.maxRenderTextureSize >= requiredResolution
+            && fullFloatRender
+            && fullFloatLinearFiltering
+            && splitPreservesSourceResolution
+            && splitWithinBudget,
+    });
+}
+function readSplitUnsupportedReason(capability, plan) {
+    if (capability.engine === 'webgpu')
+        return 'unsupported-engine:webgpu';
+    const requiredResolution = Math.max(plan.generator.maps.staticResolution, plan.generator.maps.dynamicResolution, plan.generator.maps.compositeResolution);
+    if (capability.maxRenderTextureSize < requiredResolution) {
+        return `insufficient-max-render-texture-size:${capability.maxRenderTextureSize}`;
+    }
+    if (!(capability.fullFloatRender && capability.fullFloatLinearFiltering)) {
+        return 'full-float-render-target-unavailable';
+    }
+    if (!capability.fragmentDepthSupported)
+        return 'fragment-depth-unavailable';
+    if (!capability.nativeShadowComparison)
+        return 'shadow-comparison-sampler-unavailable';
+    const sourceResolutionMismatch = readSplitSourceResolutionMismatch(plan);
+    if (sourceResolutionMismatch)
+        return sourceResolutionMismatch;
+    const splitDepthTexelCount = readFullFloatSplitDepthTexelCount(plan);
+    if (splitDepthTexelCount > MAX_FULL_FLOAT_SPLIT_DEPTH_TEXELS) {
+        return `full-float-split-budget-exceeded:${splitDepthTexelCount}:limit:${MAX_FULL_FLOAT_SPLIT_DEPTH_TEXELS}`;
+    }
+    return null;
+}
+function readSplitSourceResolutionMismatch(plan) {
+    const maps = plan.generator.maps;
+    if (maps.staticResolution < maps.compositeResolution) {
+        return `split-source-resolution-below-composite:static:${maps.staticResolution}:composite:${maps.compositeResolution}`;
+    }
+    if (maps.dynamicResolution < maps.compositeResolution) {
+        return `split-source-resolution-below-composite:dynamic:${maps.dynamicResolution}:composite:${maps.compositeResolution}`;
+    }
+    return null;
+}
+function readFullFloatSplitDepthTexelCount(plan) {
+    const maps = plan.generator.maps;
+    return maps.staticResolution ** 2
+        + maps.dynamicResolution ** 2
+        + maps.compositeResolution ** 2;
+}
+function fallbackOrThrow(light, plan, reason, gpuCapability) {
+    if (plan.generator.backend.fallback === 'disable') {
+        throw new Error(`shadowMapExperiment.splitBackendUnavailable:${reason}`);
+    }
+    assertSingleBackendSupported(plan, gpuCapability);
+    return createSingleBackend(light, plan, reason, gpuCapability);
+}
+function assertSingleBackendSupported(plan, gpuCapability) {
+    const resolution = plan.generator.maps.compositeResolution;
+    if (resolution > gpuCapability.maxRenderTextureSize) {
+        throw new Error(`shadowMapExperiment.singleBackendUnavailable:insufficient-max-render-texture-size:${gpuCapability.maxRenderTextureSize}:required:${resolution}`);
+    }
+}
+function layerEvidence(resolution, candidateMeshCount, retainedMeshCount, refreshCount, renderCount, lastRefreshReasons) {
+    return Object.freeze({
+        resolution,
+        candidateMeshCount,
+        retainedMeshCount,
+        culledMeshCount: Math.max(0, candidateMeshCount - retainedMeshCount),
+        renderListCount: retainedMeshCount,
+        refreshCount,
+        renderCount,
+        lastRefreshReasons,
+    });
+}
+function trackDisposable(resources, resource) {
+    resources.push({ resource, disposed: false });
+    return resource;
+}
+function disposeTrackedReverse(resources) {
+    const errors = [];
+    for (const owner of [...resources].reverse()) {
+        if (owner.disposed)
+            continue;
+        try {
+            owner.resource.dispose();
+            owner.disposed = true;
+        }
+        catch (error) {
+            errors.push(error);
+        }
+    }
+    if (errors.length > 0) {
+        throw Object.assign(new Error('shadowMapExperiment.depthBackendDisposeFailed'), { cleanupErrors: errors });
+    }
+}
+function snapshotShadowGenerators(light) {
+    return new Set(light.getShadowGenerators()?.values() ?? []);
+}
+function cleanupFailedGeneratorAllocation(light, existingGenerators, resources, leakedGenerators, scene, existingSceneMeshes, leakedFacadeSentinels, existingSceneCameras, leakedHelperCameras) {
+    const errors = [];
+    const trackedResources = new Set(resources.map(owner => owner.resource));
+    for (const generator of light.getShadowGenerators()?.values() ?? []) {
+        if (!existingGenerators.has(generator) && !trackedResources.has(generator)) {
+            leakedGenerators.add(generator);
+        }
+    }
+    if (scene && existingSceneCameras && leakedHelperCameras) {
+        for (const camera of scene.cameras) {
+            const helperName = camera.name === '__fps_shadow_static_camera__'
+                || camera.name === '__fps_shadow_dynamic_camera__';
+            if (helperName && !existingSceneCameras.has(camera) && !trackedResources.has(camera)) {
+                leakedHelperCameras.add(camera);
+            }
+        }
+    }
+    for (const generator of [...leakedGenerators].reverse()) {
+        try {
+            generator.dispose();
+            leakedGenerators.delete(generator);
+        }
+        catch (error) {
+            errors.push(error);
+        }
+    }
+    try {
+        disposeTrackedReverse(resources);
+    }
+    catch (error) {
+        errors.push(error);
+    }
+    if (scene && existingSceneMeshes && leakedFacadeSentinels) {
+        for (const mesh of scene.meshes) {
+            if (mesh.name === '__fps_shadow_facade_eligibility__'
+                && !existingSceneMeshes.has(mesh)
+                && !trackedResources.has(mesh)) {
+                leakedFacadeSentinels.add(mesh);
+            }
+        }
+        for (const mesh of [...leakedFacadeSentinels]) {
+            try {
+                mesh.dispose();
+                leakedFacadeSentinels.delete(mesh);
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+    }
+    if (scene && leakedHelperCameras) {
+        for (const camera of [...leakedHelperCameras]) {
+            let removed = false;
+            try {
+                scene.removeCamera(camera);
+                removed = true;
+            }
+            catch (error) {
+                errors.push(error);
+            }
+            if (!removed)
+                continue;
+            try {
+                Camera.prototype.dispose.call(camera);
+                leakedHelperCameras.delete(camera);
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+    }
+    return Object.freeze(errors);
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function attachAllocationCleanup(error, retryCleanup, cleanupErrors) {
+    const metadata = {
+        cleanupErrors: Object.freeze([...cleanupErrors]),
+        shadowMapExperimentAllocationCleanup: retryCleanup,
+    };
+    if (error && typeof error === 'object' && Object.isExtensible(error)) {
+        Object.assign(error, metadata);
+        return error;
+    }
+    return Object.assign(new Error(errorMessage(error)), { cause: error }, metadata);
+}
+//# sourceMappingURL=shadow-map-experiment-depth-backend.js.map