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

package/dist/babylon/renderer-controller.js

@@ -0,0 +1,706 @@
+import { createFpsAssetResourceResolver } from '../asset-resource.js';
+import { createFpsRuntimeDataSnapshot } from '../runtime-data.js';
+import { FPS_SHADOW_MAP_EXPERIMENT_PLUGIN_ID, createShadowMapExperimentPlanSnapshot, normalizeEditorSceneRenderingProfile, shadowMapExperimentDarknessFromStrength, } from '../rendering/index.js';
+import { defineFpsPluginEntry, defineFpsPluginManifest, } from '@fps-games/plugin-sdk';
+import { FPS_ASSET_RESOURCE_RESOLVER, FPS_ASSET_CATALOG_SOURCE, FPS_BABYLON_RENDERER_PLUGIN_ID, FPS_BABYLON_RENDERER_CONTEXT, FPS_BABYLON_RENDERER_DATA, FPS_BABYLON_RENDERER_SERVICE, } from './plugin-contract.js';
+import { waitForBabylonSceneBrdfTextures } from './renderer/brdf-texture-settlement.js';
+import { createBabylonEnvironmentTextureController } from './renderer/environment/environment-texture-controller.js';
+import { createBabylonDefaultPostProcessPipelineController, readBabylonDefaultPostProcessPipelineControllerCleanup, } from './renderer/post-process/babylon-default-pipeline.js';
+import { createBabylonShadowMapExperimentSystem, readBabylonShadowMapExperimentSystemCleanup, resolveBabylonDirectionalLight, } from './renderer/shadows/shadow-map-experiment-system.js';
+import { normalizeDirectionVector, } from './renderer/lighting/directional-light-angles.js';
+export { FPS_BABYLON_RENDERER_PLUGIN_ID } from './plugin-contract.js';
+const fpsBabylonRendererSceneOwners = new WeakMap();
+export const pluginEntry = defineFpsPluginEntry({
+    pluginId: FPS_BABYLON_RENDERER_PLUGIN_ID,
+    environment: 'renderer',
+    register(context) {
+        const rendererContext = context.services.get(FPS_BABYLON_RENDERER_CONTEXT);
+        const runtimeData = context.services.get(FPS_BABYLON_RENDERER_DATA);
+        const assetResources = createFpsAssetResourceResolver(context.services.get(FPS_ASSET_CATALOG_SOURCE).catalog);
+        context.add(context.services.register(FPS_ASSET_RESOURCE_RESOLVER, assetResources));
+        const releaseSceneOwnership = reserveFpsBabylonRendererScene(rendererContext.scene);
+        let createdService;
+        try {
+            createdService = createFpsBabylonRendererService(runtimeData, rendererContext, assetResources, diagnostic => context.report(diagnostic), releaseSceneOwnership);
+        }
+        catch (error) {
+            const recoverConstruction = readFpsBabylonRendererConstructionCleanup(error)
+                ?? readBabylonShadowMapExperimentSystemCleanup(error)
+                ?? readBabylonDefaultPostProcessPipelineControllerCleanup(error);
+            if (recoverConstruction) {
+                context.add(() => {
+                    const cleanupErrors = [...recoverConstruction()];
+                    if (cleanupErrors.length > 0) {
+                        throw Object.assign(new Error('Babylon renderer construction cleanup failed.'), { cleanupErrors: Object.freeze(cleanupErrors) });
+                    }
+                    releaseSceneOwnership();
+                });
+            }
+            else {
+                try {
+                    releaseSceneOwnership();
+                }
+                catch (cleanupError) {
+                    const recoverRelease = createFpsBabylonRendererConstructionCleanup([releaseSceneOwnership]);
+                    context.add(() => throwCleanupResult(recoverRelease()));
+                    throw createFailureWithMetadata(error, 'Babylon renderer construction failed.', {
+                        cleanupErrors: Object.freeze([cleanupError]),
+                        fpsBabylonRendererConstructionCleanup: recoverRelease,
+                    });
+                }
+            }
+            throw error;
+        }
+        context.add(context.services.register(FPS_BABYLON_RENDERER_SERVICE, createdService));
+        context.add(() => createdService.dispose());
+    },
+    async start(context) {
+        await getFpsBabylonRendererInternalService(context).initialize();
+    },
+    async dispose(context) {
+        await context.services.getOptional(FPS_BABYLON_RENDERER_SERVICE)?.dispose();
+    },
+});
+export function createFpsBabylonRendererPlugin(options) {
+    const manifest = defineFpsPluginManifest({
+        id: FPS_BABYLON_RENDERER_PLUGIN_ID,
+        version: options.pluginVersion,
+        apiVersion: 1,
+        requires: {},
+        provides: { features: ['fps.renderer.babylon'] },
+        entries: { renderer: './renderer' },
+        environmentContracts: {
+            renderer: {
+                requires: {
+                    services: [
+                        FPS_BABYLON_RENDERER_CONTEXT.id,
+                        FPS_BABYLON_RENDERER_DATA.id,
+                        FPS_ASSET_CATALOG_SOURCE.id,
+                    ],
+                },
+                provides: {
+                    services: [
+                        FPS_ASSET_RESOURCE_RESOLVER.id,
+                        FPS_BABYLON_RENDERER_SERVICE.id,
+                    ],
+                },
+                scopes: ['application'],
+            },
+        },
+        deploymentConstraints: {
+            allowedTargets: ['editor', 'game-development', 'game-test', 'game-production'],
+        },
+    });
+    return Object.freeze({ manifest, renderer: pluginEntry });
+}
+function createFpsBabylonRendererService(initialData, context, assetResources, report, releaseSceneOwnership) {
+    const initialPrepared = prepareFpsBabylonRendererUpdate(initialData, assetResources, report);
+    let data = initialPrepared.data;
+    let disposed = false;
+    let acceptingUpdates = true;
+    let activeAbort = null;
+    let queue = Promise.resolve();
+    let disposePromise = null;
+    const originalEnvironmentTexture = context.scene.environmentTexture;
+    const sceneEnvironmentState = context.scene;
+    const originalEnvironmentIntensity = sceneEnvironmentState.environmentIntensity;
+    const restoreOriginalSceneEnvironment = () => {
+        context.scene.environmentTexture = originalEnvironmentTexture;
+        if (originalEnvironmentIntensity === undefined)
+            delete sceneEnvironmentState.environmentIntensity;
+        else
+            sceneEnvironmentState.environmentIntensity = originalEnvironmentIntensity;
+    };
+    for (const camera of context.cameras) {
+        assertFpsBabylonRendererCameraScene(camera, context.scene);
+    }
+    const postProcess = createBabylonDefaultPostProcessPipelineController(context.scene, [...context.cameras], null);
+    let cameraRegistry;
+    try {
+        cameraRegistry = createFpsBabylonRendererCameraRegistry(postProcess, context.scene, context.cameras, () => acceptingUpdates && !disposed);
+    }
+    catch (error) {
+        throwFpsBabylonRendererConstructionFailure(error, [
+            () => postProcess.dispose(),
+            restoreOriginalSceneEnvironment,
+        ]);
+    }
+    let environment;
+    try {
+        environment = createBabylonEnvironmentTextureController(context.scene, {
+            createTexture: context.createEnvironmentTexture,
+        });
+    }
+    catch (error) {
+        throwFpsBabylonRendererConstructionFailure(error, [
+            () => cameraRegistry.dispose(),
+            () => postProcess.dispose(),
+            restoreOriginalSceneEnvironment,
+        ]);
+    }
+    let shadowMapExperiment;
+    try {
+        shadowMapExperiment = createBabylonShadowMapExperimentSystem(context.scene);
+    }
+    catch (error) {
+        const shadowCleanup = readBabylonShadowMapExperimentSystemCleanup(error);
+        throwFpsBabylonRendererConstructionFailure(error, [
+            ...(shadowCleanup ? [() => throwCleanupResult(shadowCleanup())] : []),
+            () => environment.dispose(),
+            () => cameraRegistry.dispose(),
+            () => postProcess.dispose(),
+            restoreOriginalSceneEnvironment,
+        ]);
+    }
+    const assertAcceptingShadowOwnership = () => {
+        if (!acceptingUpdates || disposed) {
+            throw new Error('Babylon renderer service is disposed.');
+        }
+    };
+    const shadows = Object.freeze({
+        registerRuntimeShadowObjects: (input) => {
+            assertAcceptingShadowOwnership();
+            return shadowMapExperiment.registerRuntimeShadowObjects(input);
+        },
+        registerActivitySource: (input) => {
+            assertAcceptingShadowOwnership();
+            return shadowMapExperiment.registerCasterActivitySource(input);
+        },
+        getRuntimeSnapshot: () => shadowMapExperiment.getRuntimeSnapshot(),
+        getEvidence: () => shadowMapExperiment.getEvidence(),
+        getAppearance: () => {
+            const evidence = shadowMapExperiment.getEvidence();
+            const appearance = evidence.appearance;
+            const qualityProfileId = evidence.effectivePlan?.qualityProfileId;
+            return appearance && qualityProfileId
+                ? Object.freeze({ ...appearance, qualityProfileId })
+                : null;
+        },
+        previewAppearance: (input) => {
+            assertAcceptingShadowOwnership();
+            const appearance = validateShadowAppearancePreview(input);
+            return shadowMapExperiment.previewAppearance({
+                darkness: shadowMapExperimentDarknessFromStrength(appearance.strength),
+                softness: appearance.softness,
+            });
+        },
+    });
+    const cameras = Object.freeze({
+        register: (camera) => {
+            if (!acceptingUpdates || disposed) {
+                throw new Error('Babylon renderer service is disposed.');
+            }
+            return cameraRegistry.register(camera);
+        },
+    });
+    const lightingPreviewStates = new Map();
+    const lighting = Object.freeze({
+        previewDirectionalLight(input) {
+            if (!acceptingUpdates || disposed) {
+                throw new Error('Babylon renderer service is disposed.');
+            }
+            const preview = validateDirectionalLightPreview(input);
+            const light = resolveBabylonDirectionalLight(context.scene, preview.entityId);
+            if (!light) {
+                throw Object.assign(new Error(`Babylon renderer DirectionalLight "${preview.entityId}" was not found.`), { code: 'babylon.renderer.directionalLightMissing', entityId: preview.entityId });
+            }
+            let state = lightingPreviewStates.get(light);
+            if (!state) {
+                state = {
+                    enabled: light.isEnabled(),
+                    intensity: light.intensity,
+                    diffuse: light.diffuse.clone(),
+                    direction: light.direction.clone(),
+                    directionOwnedDirectly: false,
+                };
+                lightingPreviewStates.set(light, state);
+            }
+            const previous = {
+                enabled: light.isEnabled(),
+                intensity: light.intensity,
+                diffuse: light.diffuse.clone(),
+            };
+            try {
+                if (preview.enabled !== undefined)
+                    light.setEnabled(preview.enabled);
+                if (preview.intensity !== undefined)
+                    light.intensity = preview.intensity;
+                if (preview.diffuseColor) {
+                    light.diffuse.set(preview.diffuseColor.r, preview.diffuseColor.g, preview.diffuseColor.b);
+                }
+                if (preview.direction) {
+                    const normalized = normalizeDirectionVector(preview.direction);
+                    const handledByShadowMap = shadowMapExperiment.previewLightDirection(preview.entityId, [normalized.x, normalized.y, normalized.z]);
+                    if (!handledByShadowMap) {
+                        light.direction.set(normalized.x, normalized.y, normalized.z);
+                        state.directionOwnedDirectly = true;
+                    }
+                }
+            }
+            catch (error) {
+                light.setEnabled(previous.enabled);
+                light.intensity = previous.intensity;
+                light.diffuse.copyFrom(previous.diffuse);
+                throw error;
+            }
+        },
+    });
+    const rendering = Object.freeze({
+        getEnvironmentAppearance() {
+            const profile = environment.getProfile();
+            const texture = environment.getTexture();
+            if (!profile?.texture || !texture)
+                return null;
+            return Object.freeze({
+                iblIntensity: Number.isFinite(texture.level)
+                    ? texture.level
+                    : profile.intensity,
+                iblRotationY: Number.isFinite(texture.rotationY)
+                    ? texture.rotationY
+                    : profile.rotationY,
+            });
+        },
+        previewEnvironmentAppearance(input) {
+            if (!acceptingUpdates || disposed) {
+                throw new Error('Babylon renderer service is disposed.');
+            }
+            const appearance = validateEnvironmentAppearancePreview(input);
+            const profile = environment.getProfile();
+            const texture = environment.getTexture();
+            if (!profile?.texture || !texture)
+                return false;
+            const previousLevel = texture.level;
+            const previousRotationY = texture.rotationY;
+            try {
+                texture.level = appearance.iblIntensity;
+                texture.rotationY = appearance.iblRotationY;
+            }
+            catch (error) {
+                texture.level = previousLevel;
+                texture.rotationY = previousRotationY;
+                throw error;
+            }
+            return true;
+        },
+    });
+    const cleanup = () => {
+        const cleanupErrors = [];
+        for (const [light, state] of lightingPreviewStates) {
+            try {
+                if (!light.isDisposed()) {
+                    light.setEnabled(state.enabled);
+                    light.intensity = state.intensity;
+                    light.diffuse.copyFrom(state.diffuse);
+                    if (state.directionOwnedDirectly)
+                        light.direction.copyFrom(state.direction);
+                }
+                lightingPreviewStates.delete(light);
+            }
+            catch (error) {
+                cleanupErrors.push(error);
+            }
+        }
+        try {
+            shadowMapExperiment.dispose();
+        }
+        catch (error) {
+            cleanupErrors.push(error);
+        }
+        try {
+            environment.dispose();
+        }
+        catch (error) {
+            cleanupErrors.push(error);
+        }
+        try {
+            cameraRegistry.dispose();
+        }
+        catch (error) {
+            cleanupErrors.push(error);
+        }
+        try {
+            postProcess.dispose();
+        }
+        catch (error) {
+            cleanupErrors.push(error);
+        }
+        try {
+            restoreOriginalSceneEnvironment();
+        }
+        catch (error) {
+            cleanupErrors.push(error);
+        }
+        if (cleanupErrors.length === 0) {
+            try {
+                releaseSceneOwnership();
+            }
+            catch (error) {
+                cleanupErrors.push(error);
+            }
+        }
+        if (cleanupErrors.length > 0) {
+            const error = new Error('Babylon renderer cleanup failed.');
+            Object.assign(error, { cleanupErrors });
+            throw error;
+        }
+    };
+    const commit = async (prepared, signal) => {
+        const previousEnvironment = environment.getProfile();
+        const previousControllerTexture = environment.getTexture();
+        const previousSceneTexture = context.scene.environmentTexture;
+        const previousPostProcess = postProcess.getProfile();
+        const previousShadowMapExperimentPlan = shadowMapExperiment.getPlan();
+        try {
+            shadowMapExperiment.setPlan(prepared.shadowMapExperimentPlan);
+            postProcess.setProfile(prepared.postProcess);
+            await environment.applyProfile(prepared.environment, signal);
+            if (signal.aborted)
+                throw createFpsBabylonRendererAbortError();
+            data = prepared.data;
+        }
+        catch (error) {
+            const rollbackErrors = [];
+            try {
+                await environment.applyProfile(previousEnvironment);
+            }
+            catch (rollbackError) {
+                rollbackErrors.push(rollbackError);
+            }
+            try {
+                if (previousSceneTexture !== previousControllerTexture) {
+                    context.scene.environmentTexture = previousSceneTexture;
+                }
+            }
+            catch (rollbackError) {
+                rollbackErrors.push(rollbackError);
+            }
+            try {
+                postProcess.setProfile(previousPostProcess);
+            }
+            catch (rollbackError) {
+                rollbackErrors.push(rollbackError);
+            }
+            try {
+                shadowMapExperiment.setPlan(previousShadowMapExperimentPlan);
+            }
+            catch (rollbackError) {
+                rollbackErrors.push(rollbackError);
+            }
+            if (rollbackErrors.length > 0) {
+                throw createFailureWithMetadata(error, 'Babylon renderer update failed.', { rollbackErrors: Object.freeze(rollbackErrors) });
+            }
+            throw error;
+        }
+    };
+    const enqueue = (prepared) => {
+        const operation = queue.then(async () => {
+            if (!acceptingUpdates || disposed)
+                throw new Error('Babylon renderer service is disposed.');
+            const abort = new AbortController();
+            activeAbort = abort;
+            try {
+                await commit(prepared, abort.signal);
+            }
+            finally {
+                if (activeAbort === abort)
+                    activeAbort = null;
+            }
+        });
+        queue = operation.then(() => undefined, () => undefined);
+        return operation;
+    };
+    const service = {
+        environment,
+        postProcess,
+        cameras,
+        lighting,
+        rendering,
+        shadows,
+        shadowMapExperimentSystem: shadowMapExperiment,
+        getRuntimeData: () => data,
+        async initialize() {
+            await enqueue(initialPrepared);
+            await waitForBabylonSceneBrdfTextures(context.scene);
+        },
+        async update(nextData) {
+            if (!acceptingUpdates || disposed)
+                throw new Error('Babylon renderer service is disposed.');
+            await enqueue(prepareFpsBabylonRendererUpdate(nextData, assetResources, report));
+        },
+        async dispose() {
+            if (disposePromise)
+                return disposePromise;
+            acceptingUpdates = false;
+            activeAbort?.abort();
+            const operation = (async () => {
+                await queue;
+                if (disposed)
+                    return;
+                await waitForBabylonSceneBrdfTextures(context.scene);
+                cleanup();
+                disposed = true;
+            })();
+            disposePromise = operation.catch(error => {
+                disposePromise = null;
+                throw error;
+            });
+            return disposePromise;
+        },
+    };
+    return service;
+}
+function createFpsBabylonRendererCameraRegistry(postProcess, scene, initialCameras, isOpen) {
+    const registrations = new Map();
+    for (const camera of initialCameras) {
+        if (registrations.has(camera)) {
+            throw createFpsBabylonRendererCameraRegistrationConflict(camera);
+        }
+        registrations.set(camera, { initial: true });
+    }
+    let disposed = false;
+    return {
+        register(camera) {
+            if (disposed || !isOpen())
+                throw new Error('Babylon renderer camera service is disposed.');
+            assertFpsBabylonRendererCameraScene(camera, scene);
+            if (registrations.has(camera)) {
+                throw createFpsBabylonRendererCameraRegistrationConflict(camera);
+            }
+            postProcess.addCamera(camera);
+            registrations.set(camera, { initial: false });
+            let registrationDisposed = false;
+            return Object.freeze({
+                dispose() {
+                    if (registrationDisposed)
+                        return;
+                    const registration = registrations.get(camera);
+                    if (!registration || registration.initial) {
+                        registrationDisposed = true;
+                        return;
+                    }
+                    postProcess.removeCamera(camera);
+                    registrations.delete(camera);
+                    registrationDisposed = true;
+                },
+            });
+        },
+        dispose() {
+            if (disposed)
+                return;
+            const cleanupErrors = [];
+            for (const camera of registrations.keys()) {
+                try {
+                    postProcess.removeCamera(camera);
+                    registrations.delete(camera);
+                }
+                catch (error) {
+                    cleanupErrors.push(error);
+                }
+            }
+            if (cleanupErrors.length > 0) {
+                throw Object.assign(new Error('Babylon renderer camera registration cleanup failed.'), { cleanupErrors: Object.freeze(cleanupErrors) });
+            }
+            disposed = true;
+        },
+    };
+}
+function assertFpsBabylonRendererCameraScene(camera, scene) {
+    if (camera.getScene() === scene)
+        return;
+    throw Object.assign(new Error(`Babylon renderer Camera "${camera.name}" belongs to a different Scene.`), {
+        code: 'babylon.renderer.cameraSceneMismatch',
+        cameraName: camera.name,
+    });
+}
+function createFpsBabylonRendererCameraRegistrationConflict(camera) {
+    return Object.assign(new Error(`Babylon renderer Camera "${camera.name}" is already registered.`), {
+        code: 'babylon.renderer.cameraRegistrationConflict',
+        cameraName: camera.name,
+    });
+}
+function validateDirectionalLightPreview(input) {
+    if (!input || typeof input !== 'object') {
+        throw new Error('Babylon renderer directional light preview input is required.');
+    }
+    if (typeof input.entityId !== 'string' || !input.entityId.trim()) {
+        throw new Error('Babylon renderer directional light preview entityId is required.');
+    }
+    if (input.enabled !== undefined && typeof input.enabled !== 'boolean') {
+        throw new Error('Babylon renderer directional light preview enabled must be boolean.');
+    }
+    if (input.intensity !== undefined
+        && (!Number.isFinite(input.intensity) || input.intensity < 0)) {
+        throw new Error('Babylon renderer directional light preview intensity must be finite and non-negative.');
+    }
+    if (input.direction) {
+        const { x, y, z } = input.direction;
+        if (![x, y, z].every(Number.isFinite) || Math.hypot(x, y, z) <= 1e-6) {
+            throw new Error('Babylon renderer directional light preview direction must be finite and non-zero.');
+        }
+    }
+    if (input.diffuseColor) {
+        const { r, g, b } = input.diffuseColor;
+        if (![r, g, b].every(value => Number.isFinite(value) && value >= 0)) {
+            throw new Error('Babylon renderer directional light preview diffuseColor must be finite and non-negative.');
+        }
+    }
+    return input;
+}
+function validateShadowAppearancePreview(input) {
+    if (!input || typeof input !== 'object') {
+        throw new Error('Babylon renderer shadow appearance preview input is required.');
+    }
+    for (const [field, value] of [
+        ['strength', input.strength],
+        ['softness', input.softness],
+    ]) {
+        if (!Number.isFinite(value) || value < 0 || value > 1) {
+            throw new Error(`Babylon renderer shadow appearance preview ${field} must be finite in 0..1.`);
+        }
+    }
+    return input;
+}
+function validateEnvironmentAppearancePreview(input) {
+    if (!input || typeof input !== 'object') {
+        throw new Error('Babylon renderer environment appearance preview input is required.');
+    }
+    if (!Number.isFinite(input.iblIntensity) || input.iblIntensity < 0) {
+        throw new Error('Babylon renderer environment appearance preview iblIntensity must be finite and non-negative.');
+    }
+    if (!Number.isFinite(input.iblRotationY)) {
+        throw new Error('Babylon renderer environment appearance preview iblRotationY must be finite.');
+    }
+    return input;
+}
+function throwFpsBabylonRendererConstructionFailure(failure, operations) {
+    const cleanup = createFpsBabylonRendererConstructionCleanup(operations);
+    const cleanupErrors = cleanup();
+    if (cleanupErrors.length === 0)
+        throw failure;
+    throw createFailureWithMetadata(failure, 'Babylon renderer construction failed.', {
+        cleanupErrors,
+        fpsBabylonRendererConstructionCleanup: cleanup,
+    });
+}
+function createFpsBabylonRendererConstructionCleanup(operations) {
+    let pending = [...operations];
+    return () => {
+        const cleanupErrors = [];
+        const retry = [];
+        for (const operation of pending) {
+            try {
+                operation();
+            }
+            catch (error) {
+                cleanupErrors.push(error);
+                retry.push(operation);
+            }
+        }
+        pending = retry;
+        return Object.freeze(cleanupErrors);
+    };
+}
+function readFpsBabylonRendererConstructionCleanup(error) {
+    if (!error || (typeof error !== 'object' && typeof error !== 'function'))
+        return null;
+    const cleanup = error
+        .fpsBabylonRendererConstructionCleanup;
+    return typeof cleanup === 'function' ? cleanup : null;
+}
+function throwCleanupResult(cleanupErrors) {
+    if (cleanupErrors.length === 0)
+        return;
+    if (cleanupErrors.length === 1)
+        throw cleanupErrors[0];
+    throw Object.assign(new Error('Babylon renderer construction cleanup failed.'), {
+        cleanupErrors: Object.freeze([...cleanupErrors]),
+    });
+}
+function createFailureWithMetadata(failure, fallbackMessage, metadata) {
+    if (failure && (typeof failure === 'object' || typeof failure === 'function')) {
+        try {
+            Object.assign(failure, metadata);
+            if (Object.entries(metadata).every(([key, value]) => (failure[key] === value)))
+                return failure;
+        }
+        catch {
+            // A non-extensible primary error is wrapped so recovery metadata remains reachable.
+        }
+    }
+    return Object.assign(new Error(failure instanceof Error ? failure.message : fallbackMessage), { cause: failure, ...metadata });
+}
+function reserveFpsBabylonRendererScene(scene) {
+    if (fpsBabylonRendererSceneOwners.has(scene)) {
+        throw new Error('Babylon renderer Scene already has an active owner.');
+    }
+    const owner = Object.freeze({});
+    fpsBabylonRendererSceneOwners.set(scene, owner);
+    let released = false;
+    return () => {
+        if (released)
+            return;
+        if (fpsBabylonRendererSceneOwners.get(scene) !== owner) {
+            throw new Error('Babylon renderer Scene ownership was replaced before cleanup completed.');
+        }
+        fpsBabylonRendererSceneOwners.delete(scene);
+        released = true;
+    };
+}
+function getFpsBabylonRendererInternalService(context) {
+    return context.services.get(FPS_BABYLON_RENDERER_SERVICE);
+}
+function createFpsBabylonRendererAbortError() {
+    return Object.assign(new Error('Babylon renderer update aborted.'), { name: 'AbortError' });
+}
+function prepareFpsBabylonRendererUpdate(input, assetResources, report) {
+    const data = createFpsRuntimeDataSnapshot(input);
+    const profile = normalizeEditorSceneRenderingProfile(data.rendering);
+    const textureRef = profile.environment.texture;
+    const textureResolution = textureRef
+        ? assetResources.resolve({
+            assetId: textureRef.textureAssetId,
+            url: textureRef.url,
+        })
+        : null;
+    if (textureResolution && !textureResolution.ok) {
+        const diagnostic = {
+            code: textureResolution.diagnostic.code,
+            severity: 'error',
+            pluginId: FPS_BABYLON_RENDERER_PLUGIN_ID,
+            message: createAssetResourceResolutionMessage(textureResolution.diagnostic),
+            details: { ...textureResolution.diagnostic },
+        };
+        report(diagnostic);
+        throw Object.assign(new Error(diagnostic.message), {
+            code: diagnostic.code,
+            diagnostic: Object.freeze(diagnostic),
+        });
+    }
+    const shadowMapExperimentEntry = data.plugins?.find(entry => entry.pluginId === FPS_SHADOW_MAP_EXPERIMENT_PLUGIN_ID);
+    return Object.freeze({
+        data,
+        environment: Object.freeze({
+            texture: textureResolution?.resource ?? null,
+            intensity: profile.environment.iblIntensity,
+            rotationY: profile.environment.rotationY,
+        }),
+        postProcess: profile.postProcess,
+        shadowMapExperimentPlan: shadowMapExperimentEntry
+            ? createShadowMapExperimentPlanSnapshot(shadowMapExperimentEntry.data)
+            : null,
+    });
+}
+function createAssetResourceResolutionMessage(diagnostic) {
+    const identity = diagnostic.assetId ? ` asset ${diagnostic.assetId}` : ' external resource';
+    if (diagnostic.code === 'asset.resource.not-found') {
+        return `Environment texture${identity} was not found in the generated asset catalog.`;
+    }
+    if (diagnostic.code === 'asset.resource.format-missing') {
+        return `Environment texture${identity} has no resolvable source format.`;
+    }
+    if (diagnostic.code === 'asset.resource.format-unsupported') {
+        return `Environment texture${identity} uses unsupported format ${diagnostic.format ?? '<unknown>'}.`;
+    }
+    return `Environment texture${identity} reference is invalid.`;
+}
+//# sourceMappingURL=renderer-controller.js.map