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

package/dist/playable-babylon-rendering.js

@@ -1,6 +1,8 @@
-import { applyEditorSceneRenderingProfilePatch, createEditorScenePlanarShadowPreviewSettings, createEditorSceneRenderingPanelState, normalizeEditorSceneRenderingProfile, } from '@fps-games/editor-playable-sdk';
-import { createBabylonDefaultPostProcessPipelineController, createBabylonEnvironmentTextureController, createPlanarShadowSystem, resolveBabylonDefaultPostProcessVolumeStack, } from '@fps-games/babylon-renderer';
+import { applyEditorSceneRenderingProfileAction, applyEditorSceneRenderingProfilePatch, createEditorSceneBlobShadowPreviewSettings, createEditorScenePlanarShadowPreviewSettings, createEditorSceneRenderingPanelState, createEditorSceneStaticShadowArtifactDiagnostic, createEditorSceneStaticProjectedShadowPreviewSettings, normalizeEditorSceneRenderingProfile, } from '@fps-games/editor-playable-sdk';
+import { createBabylonDefaultPostProcessPipelineController, createBabylonEnvironmentTextureController, createBlobShadowSystem, createPlanarShadowSystem, createStaticProjectedShadowBaker, createStaticProjectedShadowArtifactSystem, createStaticProjectedShadowBakeHashes, createStaticProjectedShadowProfileHash, resolveBabylonDefaultPostProcessVolumeStack, } from '@fps-games/babylon-renderer';
+import { createStaticProjectedShadowCpuWorkerProcessor } from './static-shadow-cpu-worker.js';
 const PLAYABLE_BABYLON_RENDERING_ALLOWED_SECTIONS = new Set([
+    'rendering-groups',
     'environment',
     'post-process',
     'shadows',
@@ -11,8 +13,8 @@ export function createPlayableBabylonRenderingCapability(options) {
         getWorldRendering(document) {
             return createPlayableBabylonWorldRendering(document, options);
         },
-        getRenderingPanelState(document) {
-            return createPlayableBabylonRenderingPanelState(document, options);
+        getRenderingPanelState(document, sceneContext) {
+            return createPlayableBabylonRenderingPanelState(document, options, sceneContext);
         },
         async onRenderingAction(input) {
             return handlePlayableBabylonRenderingAction(input, options);
@@ -22,20 +24,20 @@ export function createPlayableBabylonRenderingCapability(options) {
         },
     };
 }
-export function createPlayableBabylonWorldRendering(document, options) {
+export function createPlayableBabylonWorldRendering(document, options, sceneContext = {}) {
     const context = createPlayableBabylonRenderingContext(document, options);
     const postProcess = resolvePlayableBabylonRenderingPostProcess(context, options);
     return {
         environment: createPlayableBabylonEnvironmentTextureProfile(context.profile, options.getTextureAssets?.({ document }) ?? []),
         postProcess: postProcess.profile,
-        shadowPreview: createPlayableBabylonShadowPreviewOptions(context, options),
+        shadowPreview: createPlayableBabylonShadowPreviewOptions(context, options, sceneContext),
     };
 }
-export function createPlayableBabylonRenderingDiagnostics(document, options) {
+export function createPlayableBabylonRenderingDiagnostics(document, options, sceneContext = {}) {
     const context = createPlayableBabylonRenderingContext(document, options);
     const textureAssets = options.getTextureAssets?.({ document }) ?? [];
     const postProcess = resolvePlayableBabylonRenderingPostProcess(context, options);
-    const shadowPreview = createPlayableBabylonShadowPreviewOptions(context, options);
+    const shadowPreview = createPlayableBabylonShadowPreviewOptions(context, options, sceneContext);
     return {
         config: context.config,
         profile: context.profile,
@@ -45,6 +47,7 @@ export function createPlayableBabylonRenderingDiagnostics(document, options) {
             shadowPreview,
         },
         environmentTexture: resolvePlayableBabylonRenderingEnvironmentTextureDiagnostic(context.profile.environment.texture, textureAssets),
+        staticShadowArtifact: createPlayableBabylonStaticShadowArtifactDiagnostic(context, options, sceneContext),
         postProcess,
         shadowPreview,
     };
@@ -124,18 +127,192 @@ export function createPlayableBabylonPlanarShadowOptions(profile, input = {}) {
 export function createPlayableBabylonPlanarShadowSystem(scene, directionalLight, profile, input = {}) {
     return createPlanarShadowSystem(scene, directionalLight, createPlayableBabylonPlanarShadowOptions(profile, input));
 }
-export function createPlayableBabylonRenderingPanelState(document, options) {
+export function createPlayableBabylonBlobShadowOptions(profile, input = {}) {
+    const includeProfileShadowMeshes = input.includeProfileShadowMeshes !== false;
+    const shadowMeshes = profile.shadowMeshes;
+    return createEditorSceneBlobShadowPreviewSettings(profile, {
+        ...input,
+        additionalCasterIncludePatterns: mergePlayableBabylonPlanarShadowPatterns(...(includeProfileShadowMeshes ? shadowMeshes.shadowCasters : []), ...(input.additionalCasterIncludePatterns ?? [])),
+        additionalExcludePatterns: mergePlayableBabylonPlanarShadowPatterns(...(includeProfileShadowMeshes ? shadowMeshes.excludeFromShadow : []), ...(input.additionalExcludePatterns ?? [])),
+        additionalRootBoundaryPatterns: mergePlayableBabylonPlanarShadowPatterns(...(input.additionalRootBoundaryPatterns ?? [])),
+    });
+}
+export function createPlayableBabylonStaticProjectedShadowOptions(profile, input = {}) {
+    const includeProfileShadowMeshes = input.includeProfileShadowMeshes !== false;
+    const shadowMeshes = profile.shadowMeshes;
+    return {
+        ...createEditorSceneStaticProjectedShadowPreviewSettings(profile, {
+            ...input,
+            additionalCasterIncludePatterns: mergePlayableBabylonPlanarShadowPatterns(...(includeProfileShadowMeshes ? shadowMeshes.shadowCasters : []), ...(input.additionalCasterIncludePatterns ?? [])),
+            additionalExcludePatterns: mergePlayableBabylonPlanarShadowPatterns(...(includeProfileShadowMeshes ? shadowMeshes.excludeFromShadow : []), ...(input.additionalExcludePatterns ?? [])),
+            additionalRootBoundaryPatterns: mergePlayableBabylonPlanarShadowPatterns(...(input.additionalRootBoundaryPatterns ?? [])),
+        }),
+        ...(input.artifact === undefined ? {} : { artifact: input.artifact }),
+        ...(input.expectedHashes === undefined ? {} : { expectedHashes: input.expectedHashes }),
+    };
+}
+export function createPlayableBabylonStaticProjectedShadowArtifactSystem(scene, directionalLight, profile, input = {}) {
+    const staticProjected = createPlayableBabylonStaticProjectedShadowOptions(profile, input);
+    const expectedHashes = staticProjected.expectedHashes ?? createStaticProjectedShadowBakeHashes({
+        scene: scene,
+        directionalLight: directionalLight,
+        options: staticProjected,
+    });
+    return createStaticProjectedShadowArtifactSystem(scene, staticProjected.artifact ?? null, {
+        enabled: staticProjected.enabled,
+        appearance: staticProjected.appearance,
+        bake: {
+            blur: staticProjected.bake?.blur,
+        },
+        expectedHashes,
+        debug: staticProjected.debug,
+    });
+}
+export function createPlayableBabylonBlobShadowSystem(scene, profile, input = {}) {
+    return createBlobShadowSystem(scene, createPlayableBabylonBlobShadowOptions(profile, input));
+}
+export function createPlayableBabylonRenderingPanelState(document, options, sceneContext = {}) {
     const context = createPlayableBabylonRenderingContext(document, options);
     const baseState = options.getPanelState?.({ document }) ?? {};
     const dirty = baseState.dirty ?? options.isDirty?.({ document });
+    const language = options.getLanguage?.({ document }) ?? 'en';
+    const renderingAction = readPlayableBabylonRenderingActionProgress(sceneContext.renderingAction);
+    const staticShadowBake = renderingAction?.actionId === 'bake-static-shadows'
+        ? createPlayableBabylonBakingStaticShadowLifecycleState(renderingAction, language)
+        : baseState.staticShadowBake
+            ?? createPlayableBabylonStaticShadowBakeLifecycleState(context, options, dirty === true, sceneContext);
     return createEditorSceneRenderingPanelState(context.profile, {
         ...baseState,
         ...(dirty === undefined ? {} : { dirty }),
+        staticShadowBake,
     }, {
-        language: options.getLanguage?.({ document }) ?? 'en',
+        language,
         textureAssets: options.getTextureAssets?.({ document }) ?? [],
     });
 }
+function createPlayableBabylonBakingStaticShadowLifecycleState(progress, language) {
+    const stats = readStaticShadowBakeStats(progress.details);
+    const label = progress.label
+        ?? (language === 'zh' ? '正在烘焙静态阴影' : 'Baking static shadows');
+    return {
+        status: 'baking',
+        chunkCount: stats?.chunkCount ?? 0,
+        reason: progress.status ?? label,
+        stats,
+        progress: {
+            label,
+            ...(typeof progress.value === 'number' && Number.isFinite(progress.value)
+                ? { value: Math.max(0, Math.min(1, progress.value)) }
+                : {}),
+            indeterminate: progress.indeterminate !== false && typeof progress.value !== 'number',
+        },
+    };
+}
+function createPlayableBabylonStaticShadowBakeLifecycleState(context, options, dirty, sceneContext) {
+    const staticOptions = createPlayableBabylonStaticProjectedShadowOptions(context.profile, (resolvePlayableBabylonRenderingValue(options.shadowPreview === false ? undefined : options.shadowPreview?.staticProjected, context) ?? {}));
+    if (!staticOptions.enabled) {
+        return {
+            status: 'disabled',
+            chunkCount: 0,
+            reason: 'Static Baked Shadow is disabled.',
+        };
+    }
+    const artifact = options.getStaticShadowArtifact?.({ document: context.document }) ?? null;
+    if (!artifact) {
+        return {
+            status: 'missing',
+            chunkCount: 0,
+            reason: 'No static shadow bake artifact is available.',
+        };
+    }
+    const diagnostic = createEditorSceneStaticShadowArtifactDiagnostic(artifact, createPlayableBabylonStaticShadowExpectedHashes(context, options, staticOptions, sceneContext));
+    if (diagnostic.status === 'invalid') {
+        return {
+            status: 'invalid',
+            chunkCount: 0,
+            reason: diagnostic.reason,
+        };
+    }
+    if (diagnostic.status === 'out-of-date') {
+        return {
+            status: 'out-of-date',
+            chunkCount: diagnostic.chunkCount,
+            reason: diagnostic.reason,
+            generatedAt: artifact.generatedAt ?? null,
+            stats: createEditorSceneStaticShadowBakeStatsFromArtifact(artifact),
+        };
+    }
+    if (dirty) {
+        return {
+            status: 'preview-unsaved',
+            chunkCount: diagnostic.chunkCount,
+            reason: 'Static shadow preview has not been saved yet.',
+            generatedAt: artifact.generatedAt ?? null,
+            stats: createEditorSceneStaticShadowBakeStatsFromArtifact(artifact),
+        };
+    }
+    return {
+        status: 'up-to-date',
+        chunkCount: diagnostic.chunkCount,
+        reason: null,
+        generatedAt: artifact.generatedAt ?? null,
+        stats: createEditorSceneStaticShadowBakeStatsFromArtifact(artifact),
+    };
+}
+function createEditorSceneStaticShadowBakeStatsFromArtifact(artifact) {
+    const isV2 = artifact.version === 2;
+    const pageCount = isV2 ? artifact.pages.length : undefined;
+    return {
+        sourceRootCount: artifact.stats?.sourceRootCount ?? uniqueStaticShadowSourceNodeIds(artifact).length,
+        sourceMeshCount: artifact.stats?.sourceMeshCount,
+        attemptedChunkCount: artifact.stats?.attemptedChunkCount ?? artifact.chunks.length,
+        chunkCount: artifact.stats?.chunkCount ?? artifact.chunks.length,
+        textureCount: artifact.stats?.textureCount ?? pageCount ?? artifact.chunks.length,
+        skippedChunkCount: artifact.stats?.skippedChunkCount,
+        pageCount: artifact.stats?.pageCount ?? pageCount,
+        resolution: artifact.stats?.resolution,
+        chunkSize: artifact.stats?.chunkSize,
+        atlasSize: artifact.stats?.atlasSize,
+        atlasUsedPixels: artifact.stats?.atlasUsedPixels,
+        atlasAllocatedPixels: artifact.stats?.atlasAllocatedPixels,
+        atlasOccupancy: artifact.stats?.atlasOccupancy,
+        texelsPerMeter: artifact.stats?.texelsPerMeter,
+        effectiveTexelsPerMeter: artifact.stats?.effectiveTexelsPerMeter,
+        maxAtlasPages: artifact.stats?.maxAtlasPages,
+        sdfRadiusPx: artifact.stats?.sdfRadiusPx,
+        spatialChunkSize: artifact.stats?.spatialChunkSize,
+        effectiveSpatialChunkSize: artifact.stats?.effectiveSpatialChunkSize,
+        targetChunkCount: artifact.stats?.targetChunkCount,
+        bakedChunkCount: artifact.stats?.bakedChunkCount,
+        reusedChunkCount: artifact.stats?.reusedChunkCount,
+        durationMs: artifact.stats?.durationMs,
+    };
+}
+function uniqueStaticShadowSourceNodeIds(artifact) {
+    return [...new Set(artifact.chunks.flatMap(chunk => chunk.sourceNodeIds))];
+}
+function createPlayableBabylonStaticShadowArtifactDiagnostic(context, options, sceneContext) {
+    const artifact = options.getStaticShadowArtifact?.({ document: context.document }) ?? null;
+    const staticOptions = createPlayableBabylonStaticProjectedShadowOptions(context.profile, (resolvePlayableBabylonRenderingValue(options.shadowPreview === false ? undefined : options.shadowPreview?.staticProjected, context) ?? {}));
+    return createEditorSceneStaticShadowArtifactDiagnostic(artifact, createPlayableBabylonStaticShadowExpectedHashes(context, options, staticOptions, sceneContext));
+}
+function createPlayableBabylonStaticShadowExpectedHashes(context, options, staticOptions, sceneContext) {
+    if (staticOptions.expectedHashes)
+        return staticOptions.expectedHashes;
+    const scene = readBabylonScene(sceneContext.scene);
+    const shadowPreview = options.shadowPreview === false ? {} : options.shadowPreview ?? {};
+    const directionalLightNodeId = resolvePlayableBabylonRenderingValue(shadowPreview.directionalLightNodeId, context);
+    if (scene) {
+        return createStaticProjectedShadowBakeHashes({
+            scene,
+            directionalLight: resolveBabylonDirectionalLight(sceneContext.projection, directionalLightNodeId ?? null),
+            options: staticOptions,
+        });
+    }
+    return {
+        profileHash: createStaticProjectedShadowProfileHash(staticOptions),
+    };
+}
 export function createPlayableBabylonEnvironmentTextureProfile(profile, textureAssets = []) {
     return {
         textureUrl: resolvePlayableBabylonRenderingEnvironmentTextureUrl(profile.environment.texture, textureAssets),
@@ -256,18 +433,51 @@ function createPlayableBabylonRenderingContext(document, options) {
 function resolvePlayableBabylonRenderingPostProcess(context, options) {
     return resolveBabylonDefaultPostProcessVolumeStack(context.config, options.getPostProcessResolveInput?.(context));
 }
-function createPlayableBabylonShadowPreviewOptions(context, options) {
+function createPlayableBabylonShadowPreviewOptions(context, options, sceneContext = {}) {
     if (options.shadowPreview === false)
         return null;
     const shadowPreview = options.shadowPreview ?? {};
+    const blobInput = resolvePlayableBabylonRenderingValue(shadowPreview.blob, context) ?? {};
+    const staticInput = resolvePlayableBabylonRenderingValue(shadowPreview.staticProjected, context) ?? {};
     const planarInput = resolvePlayableBabylonRenderingValue(shadowPreview.planar, context) ?? {};
+    const staticArtifact = staticInput.artifact === undefined
+        ? options.getStaticShadowArtifact?.({ document: context.document }) ?? null
+        : staticInput.artifact;
     const enabled = resolvePlayableBabylonRenderingValue(shadowPreview.enabled, context);
     const directionalLightNodeId = resolvePlayableBabylonRenderingValue(shadowPreview.directionalLightNodeId, context);
-    return createPlayableBabylonPlanarShadowPreviewOptions(context.profile, {
+    const planarPreview = createPlayableBabylonPlanarShadowPreviewOptions(context.profile, {
         ...planarInput,
         ...(enabled === undefined ? {} : { enabled }),
         ...(directionalLightNodeId === undefined ? {} : { directionalLightNodeId }),
     });
+    const blobPreview = createPlayableBabylonBlobShadowOptions(context.profile, {
+        ...blobInput,
+        ...(enabled === undefined ? {} : { enabled }),
+    });
+    const staticPreview = createPlayableBabylonStaticProjectedShadowOptions(context.profile, {
+        ...staticInput,
+        artifact: staticArtifact,
+        ...(enabled === undefined ? {} : { enabled }),
+    });
+    const expectedHashes = createPlayableBabylonStaticShadowExpectedHashes(context, options, staticPreview, sceneContext);
+    const filteredStaticArtifact = resolvePlayableBabylonStaticShadowArtifactForExpectedHashes(staticPreview.artifact ?? null, expectedHashes);
+    return {
+        defaultMode: context.profile.shadows.defaultMode,
+        blob: blobPreview,
+        staticProjected: {
+            ...staticPreview,
+            artifact: filteredStaticArtifact,
+            ...(readBabylonScene(sceneContext.scene) ? { expectedHashes } : {}),
+            ...(directionalLightNodeId === undefined ? {} : { directionalLightNodeId }),
+        },
+        planar: planarPreview.planar ?? null,
+    };
+}
+function resolvePlayableBabylonStaticShadowArtifactForExpectedHashes(artifact, expectedHashes) {
+    if (!artifact)
+        return null;
+    const diagnostic = createEditorSceneStaticShadowArtifactDiagnostic(artifact, expectedHashes);
+    return diagnostic.status === 'up-to-date' ? artifact : null;
 }
 async function handlePlayableBabylonRenderingPropertyChange(input, options) {
     const sectionId = typeof input.sectionId === 'string' ? input.sectionId : '';
@@ -288,21 +498,54 @@ async function handlePlayableBabylonRenderingPropertyChange(input, options) {
             statusTone: 'warning',
         });
     }
-    await options.setConfig({
+    const setConfigResult = await options.setConfig({
         document: input.document,
         config: patch.config,
         changedPaths: patch.changedPaths,
         profile: patch.normalized,
+        change: {
+            path,
+            value: input.value,
+        },
     });
     const dirty = options.isDirty?.({ document: input.document });
     return createPlayableBabylonRenderingResult(true, {
         dirty,
         status: `Rendering draft updated: ${patch.changedPaths.join(', ')}`,
         statusTone: dirty === false ? 'success' : 'warning',
+        documentPatch: readPlayableBabylonRenderingDocumentPatch(setConfigResult),
     });
 }
 async function handlePlayableBabylonRenderingAction(input, options) {
     const actionId = typeof input.actionId === 'string' ? input.actionId : '';
+    if (actionId === 'bake-static-shadows') {
+        return bakePlayableBabylonStaticShadows(input, options);
+    }
+    if (actionId === 'rendering-alpha-preset.add' || actionId === 'rendering-alpha-preset.delete') {
+        const actionInput = createPlayableBabylonRenderingProfileActionInput(actionId, input);
+        const currentConfig = options.getConfig({ document: input.document });
+        const patch = applyEditorSceneRenderingProfileAction(currentConfig, actionInput);
+        if (patch.changedPaths.length === 0) {
+            return createPlayableBabylonRenderingResult(false, {
+                status: `Unsupported rendering action: ${actionId}`,
+                statusTone: 'warning',
+            });
+        }
+        const setConfigResult = await options.setConfig({
+            document: input.document,
+            config: patch.config,
+            changedPaths: patch.changedPaths,
+            profile: patch.normalized,
+            action: actionInput,
+        });
+        const dirty = options.isDirty?.({ document: input.document });
+        return createPlayableBabylonRenderingResult(true, {
+            dirty,
+            status: `Rendering draft updated: ${patch.changedPaths.join(', ')}`,
+            statusTone: dirty === false ? 'success' : 'warning',
+            documentPatch: readPlayableBabylonRenderingDocumentPatch(setConfigResult),
+        });
+    }
     if (actionId !== 'revert-rendering') {
         return createPlayableBabylonRenderingResult(false, {
             status: `Unsupported rendering action: ${actionId || '(unknown)'}`,
@@ -328,6 +571,207 @@ async function handlePlayableBabylonRenderingAction(input, options) {
         statusTone: 'success',
     });
 }
+async function bakePlayableBabylonStaticShadows(input, options) {
+    if (!options.setStaticShadowArtifact) {
+        return createPlayableBabylonRenderingResult(false, {
+            status: 'Static shadow artifact storage is not available for this project.',
+            statusTone: 'warning',
+        });
+    }
+    const scene = readBabylonScene(input.scene);
+    if (!scene) {
+        return createPlayableBabylonRenderingResult(false, {
+            status: 'Static shadow bake requires the active Babylon scene.',
+            statusTone: 'warning',
+        });
+    }
+    const context = createPlayableBabylonRenderingContext(input.document, options);
+    const shadowPreview = options.shadowPreview === false ? {} : options.shadowPreview ?? {};
+    const staticInput = resolvePlayableBabylonRenderingValue(shadowPreview.staticProjected, context) ?? {};
+    const directionalLightNodeId = resolvePlayableBabylonRenderingValue(shadowPreview.directionalLightNodeId, context);
+    const staticOptions = createPlayableBabylonStaticProjectedShadowOptions(context.profile, {
+        ...staticInput,
+        ...(staticInput.enabled === undefined ? {} : { enabled: staticInput.enabled }),
+    });
+    if (!staticOptions.enabled) {
+        return createPlayableBabylonRenderingResult(false, {
+            status: 'Static Baked Shadow is disabled.',
+            statusTone: 'warning',
+        });
+    }
+    const reportProgress = readPlayableBabylonRenderingProgressReporter(input.reportProgress);
+    const previousArtifact = options.getStaticShadowArtifact?.({ document: input.document }) ?? null;
+    const workerProcessor = options.processStaticShadowSdfTile ? null : createStaticProjectedShadowCpuWorkerProcessor();
+    let artifact;
+    try {
+        artifact = await createStaticProjectedShadowBaker({
+            scene,
+            directionalLight: resolveBabylonDirectionalLight(input.projection, directionalLightNodeId ?? null),
+            options: staticOptions,
+            previousArtifact,
+            readMaskTexturePixels: options.readStaticShadowMaskTexturePixels,
+            processSdfTile: options.processStaticShadowSdfTile ?? workerProcessor?.processSdfTile,
+            encodeAtlasTexture: options.encodeStaticShadowAtlasTexture,
+            yieldToMainThread: async (progress) => {
+                await reportProgress?.(createPlayableBabylonStaticShadowBakeProgress(progress, staticOptions));
+            },
+            onProgress: async (progress) => {
+                await reportProgress?.(createPlayableBabylonStaticShadowBakeProgress(progress, staticOptions));
+            },
+        }).bake();
+    }
+    finally {
+        workerProcessor?.dispose();
+    }
+    await reportProgress?.({
+        actionId: 'bake-static-shadows',
+        label: 'Writing static shadow artifact',
+        status: 'Writing static shadow artifact...',
+        value: 0.98,
+        indeterminate: false,
+        details: createStaticShadowArtifactStatsDetails(artifact),
+    });
+    await options.setStaticShadowArtifact({
+        document: input.document,
+        artifact,
+        profile: context.profile,
+    });
+    const statusDetails = formatStaticShadowBakeResultDetails(artifact);
+    return createPlayableBabylonRenderingResult(true, {
+        dirty: options.isDirty?.({ document: input.document }),
+        status: `Baked ${artifact.chunks.length} static shadow chunk${artifact.chunks.length === 1 ? '' : 's'} from ${artifact.stats?.sourceRootCount ?? 0} static caster${artifact.stats?.sourceRootCount === 1 ? '' : 's'}.`,
+        statusTone: 'success',
+        statusDetails,
+    });
+}
+function readPlayableBabylonRenderingProgressReporter(value) {
+    return typeof value === 'function'
+        ? value
+        : null;
+}
+function createPlayableBabylonStaticShadowBakeProgress(progress, options) {
+    const total = Math.max(0, progress.totalChunkCount);
+    const completed = Math.max(0, progress.completedChunkCount);
+    const chunkProgress = total > 0 ? completed / total : 1;
+    const atlasPageCount = Math.max(0, progress.atlasPageCount ?? 0);
+    const encodedPageCount = Math.max(0, progress.encodedTextureCount);
+    const value = progress.phase === 'collect'
+        ? 0.08
+        : progress.phase === 'pack'
+            ? 0.92
+            : progress.phase === 'encode'
+                ? 0.92 + (atlasPageCount > 0 ? Math.min(encodedPageCount / atlasPageCount, 1) * 0.05 : 0.03)
+                : progress.phase === 'complete'
+                    ? 0.96
+                    : 0.12 + chunkProgress * 0.78;
+    const status = progress.phase === 'collect'
+        ? `Collecting ${progress.sourceRootCount} static shadow casters...`
+        : progress.phase === 'reuse'
+            ? `Reusing ${progress.reusedChunkCount ?? 0} unchanged static shadow chunks...`
+            : progress.phase === 'sdf'
+                ? `Generating static shadow SDF ${Math.min(completed + 1, total)} of ${total}...`
+                : progress.phase === 'pack'
+                    ? `Packing ${progress.encodedTextureCount} static shadow chunks into ${atlasPageCount} atlas page${atlasPageCount === 1 ? '' : 's'}...`
+                    : progress.phase === 'encode'
+                        ? `Encoding static shadow atlas page ${Math.min(encodedPageCount + 1, atlasPageCount || encodedPageCount + 1)} of ${atlasPageCount || encodedPageCount + 1}...`
+                        : progress.phase === 'complete'
+                            ? `Finishing ${encodedPageCount} static shadow atlas page${encodedPageCount === 1 ? '' : 's'}...`
+                            : `Baking static shadow chunk ${Math.min(completed + 1, total)} of ${total}...`;
+    return {
+        actionId: 'bake-static-shadows',
+        label: total > 0
+            ? `Static shadow bake ${Math.min(completed, total)} / ${total}`
+            : 'Static shadow bake',
+        status,
+        value,
+        indeterminate: total === 0 && progress.phase !== 'complete',
+        details: {
+            phase: progress.phase,
+            sourceRootCount: progress.sourceRootCount,
+            sourceMeshCount: progress.sourceMeshCount,
+            attemptedChunkCount: progress.totalChunkCount,
+            chunkCount: progress.completedChunkCount,
+            textureCount: progress.encodedTextureCount,
+            pageCount: progress.atlasPageCount,
+            resolution: options.bake?.resolution,
+            chunkSize: options.bake?.maxSize,
+            atlasSize: options.bake?.atlasSize,
+            texelsPerMeter: options.bake?.texelsPerMeter,
+            effectiveTexelsPerMeter: progress.effectiveTexelsPerMeter,
+            maxAtlasPages: options.bake?.maxAtlasPages,
+            sdfRadiusPx: options.bake?.sdfRadiusPx,
+            spatialChunkSize: options.bake?.spatialChunkSize,
+            effectiveSpatialChunkSize: progress.effectiveSpatialChunkSize,
+            targetChunkCount: options.bake?.targetChunkCount,
+            bakedChunkCount: progress.bakedChunkCount,
+            reusedChunkCount: progress.reusedChunkCount,
+            ...(progress.currentChunkId ? { currentChunkId: progress.currentChunkId } : {}),
+        },
+    };
+}
+function createStaticShadowArtifactStatsDetails(artifact) {
+    const isV2 = artifact.version === 2;
+    const pageCount = isV2 ? artifact.pages.length : undefined;
+    return {
+        phase: 'complete',
+        sourceRootCount: artifact.stats?.sourceRootCount ?? 0,
+        sourceMeshCount: artifact.stats?.sourceMeshCount ?? 0,
+        attemptedChunkCount: artifact.stats?.attemptedChunkCount ?? artifact.chunks.length,
+        chunkCount: artifact.stats?.chunkCount ?? artifact.chunks.length,
+        textureCount: artifact.stats?.textureCount ?? pageCount ?? artifact.chunks.length,
+        skippedChunkCount: artifact.stats?.skippedChunkCount ?? 0,
+        pageCount: artifact.stats?.pageCount ?? pageCount,
+        resolution: artifact.stats?.resolution,
+        chunkSize: artifact.stats?.chunkSize,
+        atlasSize: artifact.stats?.atlasSize,
+        atlasUsedPixels: artifact.stats?.atlasUsedPixels,
+        atlasAllocatedPixels: artifact.stats?.atlasAllocatedPixels,
+        atlasOccupancy: artifact.stats?.atlasOccupancy,
+        texelsPerMeter: artifact.stats?.texelsPerMeter,
+        effectiveTexelsPerMeter: artifact.stats?.effectiveTexelsPerMeter,
+        maxAtlasPages: artifact.stats?.maxAtlasPages,
+        sdfRadiusPx: artifact.stats?.sdfRadiusPx,
+        spatialChunkSize: artifact.stats?.spatialChunkSize,
+        effectiveSpatialChunkSize: artifact.stats?.effectiveSpatialChunkSize,
+        targetChunkCount: artifact.stats?.targetChunkCount,
+        bakedChunkCount: artifact.stats?.bakedChunkCount,
+        reusedChunkCount: artifact.stats?.reusedChunkCount,
+        durationMs: artifact.stats?.durationMs,
+    };
+}
+function formatStaticShadowBakeResultDetails(artifact) {
+    const stats = artifact.stats;
+    const sourceRootCount = stats?.sourceRootCount ?? 0;
+    const sourceMeshCount = stats?.sourceMeshCount ?? 0;
+    const chunkCount = stats?.chunkCount ?? artifact.chunks.length;
+    const atlasPageCount = stats?.pageCount ?? (artifact.version === 2 ? artifact.pages.length : stats?.textureCount ?? artifact.chunks.length);
+    const effectiveTexelsPerMeter = stats?.effectiveTexelsPerMeter;
+    const atlasSize = stats?.atlasSize;
+    const atlasOccupancy = stats?.atlasOccupancy;
+    const sdfRadiusPx = stats?.sdfRadiusPx;
+    const duration = typeof stats?.durationMs === 'number' ? `, ${Math.round(stats.durationMs)}ms` : '';
+    const parts = [
+        `Static casters: ${sourceRootCount}`,
+        `Bake meshes: ${sourceMeshCount}`,
+        `Chunks: ${chunkCount}`,
+        `Atlas pages: ${atlasPageCount}${duration}`,
+    ];
+    if (typeof effectiveTexelsPerMeter === 'number')
+        parts.push(`Effective texels/m: ${formatNumberForStatus(effectiveTexelsPerMeter)}`);
+    if (typeof atlasSize === 'number')
+        parts.push(`Atlas: ${atlasSize}px`);
+    if (typeof atlasOccupancy === 'number')
+        parts.push(`Atlas occupancy: ${formatNumberForStatus(Math.max(0, Math.min(1, atlasOccupancy)) * 100)}%`);
+    if (typeof sdfRadiusPx === 'number')
+        parts.push(`SDF radius: ${formatNumberForStatus(sdfRadiusPx)}px`);
+    if (typeof stats?.bakedChunkCount === 'number' || typeof stats?.reusedChunkCount === 'number') {
+        parts.push(`Baked/reused: ${stats?.bakedChunkCount ?? 0}/${stats?.reusedChunkCount ?? 0}`);
+    }
+    return parts.join(' · ');
+}
+function formatNumberForStatus(value) {
+    return Number.isInteger(value) ? String(value) : value.toFixed(2).replace(/\.?0+$/, '');
+}
 function createPlayableBabylonRenderingResult(changed, input) {
     return {
         changed,
@@ -335,13 +779,123 @@ function createPlayableBabylonRenderingResult(changed, input) {
         ...(input.dirty === undefined ? {} : { dirty: input.dirty }),
         status: input.status,
         statusTone: input.statusTone,
+        ...(input.statusDetails ? { statusDetails: input.statusDetails } : {}),
+        ...(input.documentPatch === undefined ? {} : { documentPatch: input.documentPatch }),
+    };
+}
+function createPlayableBabylonRenderingProfileActionInput(actionId, input) {
+    const params = readRecord(input.params);
+    return {
+        actionId,
+        renderingGroupId: params.renderingGroupId ?? input.renderingGroupId,
+        presetIndex: params.presetIndex ?? input.presetIndex,
     };
 }
+function readPlayableBabylonRenderingDocumentPatch(value) {
+    return value && typeof value === 'object' ? value.documentPatch : undefined;
+}
+function readRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
 function resolvePlayableBabylonRenderingValue(value, context) {
     return typeof value === 'function'
         ? value(context)
         : value;
 }
+function readPlayableBabylonRenderingActionProgress(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const record = value;
+    return {
+        ...(typeof record.actionId === 'string' ? { actionId: record.actionId } : {}),
+        ...(typeof record.label === 'string' ? { label: record.label } : {}),
+        ...(typeof record.status === 'string' ? { status: record.status } : {}),
+        ...(isEditorSceneRenderingStatusTone(record.statusTone) ? { statusTone: record.statusTone } : {}),
+        ...(typeof record.statusDetails === 'string' ? { statusDetails: record.statusDetails } : {}),
+        ...(typeof record.value === 'number' && Number.isFinite(record.value) ? { value: record.value } : {}),
+        ...(typeof record.indeterminate === 'boolean' ? { indeterminate: record.indeterminate } : {}),
+        ...(record.details && typeof record.details === 'object' && !Array.isArray(record.details)
+            ? { details: record.details }
+            : {}),
+    };
+}
+function isEditorSceneRenderingStatusTone(value) {
+    return value === 'default' || value === 'success' || value === 'warning' || value === 'error';
+}
+function readStaticShadowBakeStats(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const record = value;
+    const stats = {};
+    if (typeof record.phase === 'string' && record.phase.trim()) {
+        stats.phase = record.phase.trim();
+    }
+    setOptionalNonNegativeNumber(stats, 'sourceRootCount', record.sourceRootCount);
+    setOptionalNonNegativeNumber(stats, 'sourceMeshCount', record.sourceMeshCount);
+    setOptionalNonNegativeNumber(stats, 'attemptedChunkCount', record.attemptedChunkCount);
+    setOptionalNonNegativeNumber(stats, 'chunkCount', record.chunkCount);
+    setOptionalNonNegativeNumber(stats, 'textureCount', record.textureCount);
+    setOptionalNonNegativeNumber(stats, 'skippedChunkCount', record.skippedChunkCount);
+    setOptionalNonNegativeNumber(stats, 'pageCount', record.pageCount);
+    setOptionalPositiveNumber(stats, 'resolution', record.resolution);
+    setOptionalPositiveNumber(stats, 'chunkSize', record.chunkSize);
+    setOptionalPositiveNumber(stats, 'atlasSize', record.atlasSize);
+    setOptionalNonNegativeNumber(stats, 'atlasUsedPixels', record.atlasUsedPixels);
+    setOptionalNonNegativeNumber(stats, 'atlasAllocatedPixels', record.atlasAllocatedPixels);
+    setOptionalRatio(stats, 'atlasOccupancy', record.atlasOccupancy);
+    setOptionalPositiveNumber(stats, 'texelsPerMeter', record.texelsPerMeter);
+    setOptionalPositiveNumber(stats, 'effectiveTexelsPerMeter', record.effectiveTexelsPerMeter);
+    setOptionalPositiveNumber(stats, 'maxAtlasPages', record.maxAtlasPages);
+    setOptionalNonNegativeNumber(stats, 'sdfRadiusPx', record.sdfRadiusPx);
+    setOptionalPositiveNumber(stats, 'spatialChunkSize', record.spatialChunkSize);
+    setOptionalPositiveNumber(stats, 'effectiveSpatialChunkSize', record.effectiveSpatialChunkSize);
+    setOptionalPositiveNumber(stats, 'targetChunkCount', record.targetChunkCount);
+    setOptionalNonNegativeNumber(stats, 'bakedChunkCount', record.bakedChunkCount);
+    setOptionalNonNegativeNumber(stats, 'reusedChunkCount', record.reusedChunkCount);
+    setOptionalNonNegativeNumber(stats, 'durationMs', record.durationMs);
+    if (typeof record.currentChunkId === 'string' && record.currentChunkId.trim()) {
+        stats.currentChunkId = record.currentChunkId.trim();
+    }
+    return Object.keys(stats).length > 0 ? stats : null;
+}
+function setOptionalNonNegativeNumber(target, key, value) {
+    if (typeof value === 'number' && Number.isFinite(value) && value >= 0) {
+        target[key] = value;
+    }
+}
+function setOptionalPositiveNumber(target, key, value) {
+    if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
+        target[key] = value;
+    }
+}
+function setOptionalRatio(target, key, value) {
+    if (typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 1) {
+        target[key] = value;
+    }
+}
+function readBabylonScene(value) {
+    return value && typeof value === 'object' && Array.isArray(value.meshes)
+        ? value
+        : null;
+}
+function resolveBabylonDirectionalLight(projectionValue, directionalLightNodeId) {
+    if (!directionalLightNodeId)
+        return null;
+    const projection = projectionValue;
+    const projected = projection?.getProjectedNode?.(directionalLightNodeId);
+    const candidates = [
+        projected?.root,
+        ...(Array.isArray(projected?.runtimeObjects) ? projected.runtimeObjects : []),
+    ];
+    for (const candidate of candidates) {
+        if (candidate && typeof candidate === 'object' && candidate.getClassName?.() === 'DirectionalLight') {
+            return candidate;
+        }
+    }
+    return null;
+}
 function mergePlayableBabylonPlanarShadowPolicyInput(base, input) {
     const merged = {
         additionalCasterIncludePatterns: mergePlayableBabylonPlanarShadowPatterns(...(base.additionalCasterIncludePatterns ?? []), ...(input?.additionalCasterIncludePatterns ?? [])),