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

package/node_modules/@fps-games/editor-playable-sdk/dist/rendering-profile/panel.js

@@ -1,9 +1,35 @@
+const SHADOW_RENDERING_GROUP_BLOB = {
+    id: 'shadow-group-moving-object',
+    label: 'Moving Object Shadows',
+    summary: 'Blob: lightweight for moving objects and project-default fallback.',
+};
+const SHADOW_RENDERING_GROUP_STATIC = {
+    id: 'shadow-group-static-scene',
+    label: 'Static Scene Shadows',
+    summary: 'Consumes baked artifacts; update during authoring/build, runtime only displays results.',
+};
+const SHADOW_RENDERING_GROUP_PLANAR = {
+    id: 'shadow-group-directional-planar',
+    label: 'Directional Planar Shadows',
+    summary: 'Real-time planar projection following the directional light.',
+};
+const SHADOW_RENDERING_GROUP_COMPAT = {
+    id: 'shadow-group-compatibility',
+    label: 'Compatibility Shadows',
+    summary: 'Legacy ShadowGenerator / CSM read-only compatibility paths.',
+};
 export function createEditorSceneRenderingPanelState(profile, state = {}, options = {}) {
+    const blob = profile.shadows.blob;
+    const staticProjected = profile.shadows.staticProjected;
     const planar = profile.shadows.planar;
     const environment = profile.environment;
     const postProcess = profile.postProcess;
     const dirty = state.dirty === true;
     const lastError = state.lastError ?? null;
+    const language = options.language ?? 'en';
+    const staticShadowBake = resolveStaticShadowBakeLifecycleState(state.staticShadowBake, staticProjected.enabled);
+    const staticShadowStatus = formatStaticShadowBakeLifecycleStatus(staticShadowBake, language);
+    const staticShadowBakeInProgress = staticShadowBake.status === 'baking';
     const panel = {
         title: 'Rendering',
         summary: 'Project-level rendering settings shared by editor preview and runtime.',
@@ -19,7 +45,7 @@ export function createEditorSceneRenderingPanelState(profile, state = {}, option
                     ? 'Revert rendering settings to the last saved rendering settings.'
                     : 'Rendering settings already match the last saved rendering settings.',
             }],
-        sections: [{
+        sections: [createRenderingGroupsSection(profile.renderingGroups.slots), {
                 id: 'environment',
                 title: 'Environment / IBL',
                 summary: 'World environment texture and reflection lighting shared by editor preview and runtime.',
@@ -220,11 +246,300 @@ export function createEditorSceneRenderingPanelState(profile, state = {}, option
                 id: 'shadows',
                 title: 'Shadows',
                 summary: 'Global shadow systems for editor preview and runtime.',
+                layout: 'list',
+                systemsCollapsible: true,
                 systems: [
+                    {
+                        id: 'blob-shadow',
+                        label: 'Blob Shadow',
+                        kind: 'blob-shadow',
+                        group: { ...SHADOW_RENDERING_GROUP_BLOB },
+                        active: blob.enabled,
+                        summary: 'Default object shadow',
+                        properties: [
+                            {
+                                path: 'shadows.defaultMode',
+                                label: 'Default Mode',
+                                valueType: 'enum',
+                                control: 'enum',
+                                value: profile.shadows.defaultMode,
+                                options: createShadowDefaultModeOptions(options.language ?? 'en'),
+                                tooltip: 'Default shadow mode for GameObjects that use the project default.',
+                                commitMode: 'immediate',
+                            },
+                            {
+                                path: 'shadows.blob.enabled',
+                                label: 'Enabled',
+                                valueType: 'boolean',
+                                control: 'boolean',
+                                value: blob.enabled,
+                                tooltip: 'Enable the shared blob shadow system.',
+                                commitMode: 'immediate',
+                            },
+                            {
+                                path: 'shadows.blob.appearance.color',
+                                label: 'Color',
+                                valueType: 'color',
+                                control: 'color',
+                                value: blob.appearance.color,
+                                tooltip: 'Blob shadow RGB color. Opacity is edited separately.',
+                                commitMode: 'immediate',
+                            },
+                            {
+                                path: 'shadows.blob.appearance.color.a',
+                                label: 'Opacity',
+                                valueType: 'number',
+                                control: 'number',
+                                value: blob.appearance.color.a,
+                                min: 0,
+                                max: 1,
+                                step: 0.01,
+                                tooltip: 'Blob shadow opacity, clamped between 0 and 1.',
+                                commitMode: 'live',
+                            },
+                            {
+                                path: 'shadows.blob.appearance.edgeSoftness',
+                                label: 'Soft Edge',
+                                valueType: 'number',
+                                control: 'number',
+                                value: blob.appearance.edgeSoftness,
+                                min: 0,
+                                max: 0.98,
+                                step: 0.01,
+                                tooltip: 'Blob shadow soft edge start. Higher values keep the center denser before fading out.',
+                                commitMode: 'live',
+                            },
+                            {
+                                path: 'shadows.blob.plane.height',
+                                label: 'Height',
+                                valueType: 'number',
+                                control: 'number',
+                                value: blob.plane.height,
+                                step: 0.01,
+                                unit: 'm',
+                                tooltip: 'Ground plane height used by blob shadows.',
+                                commitMode: 'live',
+                            },
+                            {
+                                path: 'shadows.blob.plane.yOffset',
+                                label: 'Y Offset',
+                                valueType: 'number',
+                                control: 'number',
+                                value: blob.plane.yOffset,
+                                min: 0,
+                                step: 0.01,
+                                unit: 'm',
+                                tooltip: 'Vertical offset above the blob shadow plane to reduce z-fighting.',
+                                commitMode: 'live',
+                            },
+                            {
+                                path: 'shadows.blob.size.sizeMultiplier',
+                                label: 'Size Multiplier',
+                                valueType: 'number',
+                                control: 'number',
+                                value: blob.size.sizeMultiplier,
+                                min: 0,
+                                step: 0.01,
+                                tooltip: 'Scale blob shadow size from each caster bounds.',
+                                commitMode: 'live',
+                            },
+                            {
+                                path: 'shadows.blob.size.minSize',
+                                label: 'Min Size',
+                                valueType: 'number',
+                                control: 'number',
+                                value: blob.size.minSize,
+                                min: 0,
+                                step: 0.01,
+                                unit: 'm',
+                                tooltip: 'Minimum blob shadow size for tiny objects.',
+                                commitMode: 'live',
+                            },
+                            {
+                                path: 'shadows.blob.size.maxSize',
+                                label: 'Max Size',
+                                valueType: 'number',
+                                control: 'number',
+                                value: blob.size.maxSize,
+                                min: 0.01,
+                                step: 0.01,
+                                unit: 'm',
+                                tooltip: 'Maximum blob shadow size for large objects.',
+                                commitMode: 'live',
+                            },
+                        ],
+                    },
+                    {
+                        id: 'static-projected-shadow',
+                        label: 'Static Baked Shadow',
+                        kind: 'static-projected-shadow',
+                        group: { ...SHADOW_RENDERING_GROUP_STATIC },
+                        active: staticProjected.enabled,
+                        summary: staticShadowStatus.summary,
+                        status: staticShadowStatus.status,
+                        details: createStaticShadowBakeDetails(staticShadowBake, language),
+                        progress: staticShadowStatus.progress,
+                        actions: [{
+                                id: 'bake-static-shadows',
+                                label: 'Bake Static Shadows',
+                                icon: 'save',
+                                disabled: !staticProjected.enabled || staticShadowBakeInProgress,
+                                tooltip: staticShadowBakeInProgress
+                                    ? 'Static shadow bake is already running.'
+                                    : staticProjected.enabled
+                                        ? 'Bake static shadow chunks for objects authored as Static Baked Shadow.'
+                                        : 'Enable Static Baked Shadow before baking.',
+                            }],
+                        properties: [
+                            {
+                                path: 'shadows.staticProjected.enabled',
+                                label: 'Enabled',
+                                valueType: 'boolean',
+                                control: 'boolean',
+                                value: staticProjected.enabled,
+                                tooltip: 'Enable the shared static projected shadow system.',
+                                commitMode: 'immediate',
+                            },
+                            {
+                                path: 'shadows.staticProjected.appearance.color',
+                                label: 'Color',
+                                valueType: 'color',
+                                control: 'color',
+                                value: staticProjected.appearance.color,
+                                tooltip: 'Static shadow RGB color. Opacity is edited separately.',
+                                commitMode: 'immediate',
+                            },
+                            {
+                                path: 'shadows.staticProjected.appearance.color.a',
+                                label: 'Opacity',
+                                valueType: 'number',
+                                control: 'number',
+                                value: staticProjected.appearance.color.a,
+                                min: 0,
+                                max: 1,
+                                step: 0.01,
+                                tooltip: 'Static shadow opacity, clamped between 0 and 1.',
+                                commitMode: 'live',
+                            },
+                            {
+                                path: 'shadows.staticProjected.plane.height',
+                                label: 'Height',
+                                valueType: 'number',
+                                control: 'number',
+                                value: staticProjected.plane.height,
+                                step: 0.01,
+                                unit: 'm',
+                                tooltip: 'Ground plane height used by static projected shadows.',
+                                commitMode: 'live',
+                            },
+                            {
+                                path: 'shadows.staticProjected.plane.yOffset',
+                                label: 'Y Offset',
+                                valueType: 'number',
+                                control: 'number',
+                                value: staticProjected.plane.yOffset,
+                                min: 0,
+                                step: 0.01,
+                                unit: 'm',
+                                tooltip: 'Vertical offset above the static shadow plane to reduce z-fighting.',
+                                commitMode: 'live',
+                            },
+                            {
+                                path: 'shadows.staticProjected.bake.texelsPerMeter',
+                                label: 'Texels per Meter',
+                                valueType: 'number',
+                                control: 'number',
+                                value: staticProjected.bake.texelsPerMeter,
+                                min: 1,
+                                step: 1,
+                                tooltip: 'Target SDF atlas texel density for baked static shadows.',
+                                commitMode: 'blur',
+                            },
+                            {
+                                path: 'shadows.staticProjected.bake.atlasSize',
+                                label: 'Atlas Size',
+                                valueType: 'number',
+                                control: 'number',
+                                value: staticProjected.bake.atlasSize,
+                                min: 16,
+                                step: 1,
+                                tooltip: 'Maximum width and height for each static shadow atlas page.',
+                                commitMode: 'blur',
+                            },
+                            {
+                                path: 'shadows.staticProjected.bake.maxAtlasPages',
+                                label: 'Page Budget',
+                                valueType: 'number',
+                                control: 'number',
+                                value: staticProjected.bake.maxAtlasPages,
+                                min: 1,
+                                step: 1,
+                                tooltip: 'Maximum atlas pages allowed before bake lowers the effective texel density.',
+                                commitMode: 'blur',
+                            },
+                            {
+                                path: 'shadows.staticProjected.bake.sdfRadiusPx',
+                                label: 'SDF Radius',
+                                valueType: 'number',
+                                control: 'number',
+                                value: staticProjected.bake.sdfRadiusPx,
+                                min: 0,
+                                step: 1,
+                                tooltip: 'Signed-distance radius in pixels used to preserve crisp controllable edges.',
+                                commitMode: 'blur',
+                            },
+                            {
+                                path: 'shadows.staticProjected.bake.padding',
+                                label: 'Padding',
+                                valueType: 'number',
+                                control: 'number',
+                                value: staticProjected.bake.padding,
+                                min: 0,
+                                step: 0.01,
+                                tooltip: 'Extra projected bounds padding before baking the static shadow.',
+                                commitMode: 'live',
+                            },
+                            {
+                                path: 'shadows.staticProjected.bake.blur',
+                                label: 'Blur',
+                                valueType: 'number',
+                                control: 'number',
+                                value: staticProjected.bake.blur,
+                                min: 0,
+                                step: 0.5,
+                                tooltip: 'Reserved blur radius for static shadow bake softness.',
+                                commitMode: 'live',
+                            },
+                            {
+                                path: 'shadows.staticProjected.bake.spatialChunkSize',
+                                label: 'Spatial Chunk Size',
+                                valueType: 'number',
+                                control: 'number',
+                                value: staticProjected.bake.spatialChunkSize,
+                                min: 0.01,
+                                step: 0.01,
+                                unit: 'm',
+                                tooltip: 'World size of each spatial bake chunk before atlas packing.',
+                                commitMode: 'live',
+                            },
+                            {
+                                path: 'shadows.staticProjected.bake.targetChunkCount',
+                                label: 'Target Chunks',
+                                valueType: 'number',
+                                control: 'number',
+                                value: staticProjected.bake.targetChunkCount,
+                                min: 1,
+                                step: 1,
+                                tooltip: 'Soft chunk-count budget. Large scenes automatically enlarge spatial chunks to stay near this target.',
+                                commitMode: 'blur',
+                            },
+                        ],
+                    },
                     {
                         id: 'planar-main',
                         label: 'Planar Main',
                         kind: 'planar-shadow',
+                        group: { ...SHADOW_RENDERING_GROUP_PLANAR },
                         active: planar.enabled,
                         summary: 'Follow Directional Light',
                         properties: [
@@ -355,6 +670,7 @@ export function createEditorSceneRenderingPanelState(profile, state = {}, option
                         id: 'legacy-shadow',
                         label: 'Legacy Shadow',
                         kind: 'legacy-shadow',
+                        group: { ...SHADOW_RENDERING_GROUP_COMPAT },
                         active: profile.shadows.enabled && !planar.enabled,
                         readOnly: true,
                         summary: profile.shadows.enabled ? 'Compatibility path' : 'Disabled',
@@ -368,6 +684,7 @@ export function createEditorSceneRenderingPanelState(profile, state = {}, option
                         id: 'csm-shadow',
                         label: 'CSM',
                         kind: 'csm-shadow',
+                        group: { ...SHADOW_RENDERING_GROUP_COMPAT },
                         active: profile.shadows.enabled && profile.shadows.useCsm && !planar.enabled,
                         readOnly: true,
                         summary: profile.shadows.useCsm ? 'Compatibility path' : 'Disabled',
@@ -380,7 +697,382 @@ export function createEditorSceneRenderingPanelState(profile, state = {}, option
                 ],
             }],
     };
-    return localizeRenderingPanelState(panel, options.language ?? 'en', dirty);
+    return localizeRenderingPanelState(panel, language, dirty);
+}
+function resolveStaticShadowBakeLifecycleState(state, enabled) {
+    if (!enabled) {
+        return {
+            status: 'disabled',
+            chunkCount: 0,
+        };
+    }
+    return state ?? {
+        status: 'missing',
+        chunkCount: 0,
+    };
+}
+function formatStaticShadowBakeLifecycleStatus(state, language) {
+    const chunkCount = Math.max(0, Math.trunc(state.chunkCount ?? 0));
+    const chunkText = language === 'zh'
+        ? `${chunkCount} 个分块`
+        : `${chunkCount} chunk${chunkCount === 1 ? '' : 's'}`;
+    if (state.status === 'baking') {
+        const progress = state.progress ?? {
+            label: language === 'zh' ? '正在烘焙静态阴影' : 'Baking static shadows',
+            indeterminate: true,
+        };
+        return {
+            summary: language === 'zh' ? '正在烘焙' : 'Baking',
+            status: language === 'zh'
+                ? formatChineseStaticShadowBakingStatus(state)
+                : state.reason ?? 'Baking static shadow artifact.',
+            progress: {
+                ...progress,
+                label: language === 'zh' ? formatChineseStaticShadowProgressLabel(state) : progress.label,
+            },
+        };
+    }
+    if (state.status === 'disabled') {
+        const fallback = 'Static Baked Shadow is disabled.';
+        return {
+            summary: language === 'zh' ? '已禁用' : 'Disabled',
+            status: resolveLocalizedStaticShadowStatusReason(state.reason, fallback, '静态烘焙阴影已禁用。', language),
+        };
+    }
+    if (state.status === 'missing') {
+        const fallback = 'No static shadow bake artifact is available.';
+        return {
+            summary: language === 'zh' ? '缺少烘焙' : 'Missing bake',
+            status: resolveLocalizedStaticShadowStatusReason(state.reason, fallback, '当前没有可用的静态阴影烘焙数据。', language),
+        };
+    }
+    if (state.status === 'preview-unsaved') {
+        const fallback = 'Static shadow preview has not been saved yet.';
+        return {
+            summary: language === 'zh' ? `预览未保存 · ${chunkText}` : `Preview unsaved · ${chunkText}`,
+            status: resolveLocalizedStaticShadowStatusReason(state.reason, fallback, '静态阴影预览尚未保存。', language),
+        };
+    }
+    if (state.status === 'out-of-date') {
+        const fallback = 'Static shadow bake is out of date.';
+        return {
+            summary: language === 'zh' ? `已过期 · ${chunkText}` : `Out of date · ${chunkText}`,
+            status: resolveLocalizedStaticShadowStatusReason(state.reason, fallback, '静态阴影烘焙已过期。', language),
+        };
+    }
+    if (state.status === 'invalid') {
+        const fallback = 'Static shadow bake artifact is invalid.';
+        return {
+            summary: language === 'zh' ? '烘焙无效' : 'Invalid bake',
+            status: resolveLocalizedStaticShadowStatusReason(state.reason, fallback, '静态阴影烘焙数据无效。', language),
+        };
+    }
+    const fallback = 'Static shadow bake artifact is up to date.';
+    if (chunkCount === 0) {
+        return {
+            summary: language === 'zh' ? '无静态投射物' : 'No static casters',
+            status: resolveLocalizedStaticShadowStatusReason(state.reason, fallback, '没有物体被显式设置为静态烘焙阴影。', language),
+        };
+    }
+    return {
+        summary: language === 'zh' ? `最新 · ${chunkText}` : `Up to date · ${chunkText}`,
+        status: resolveLocalizedStaticShadowStatusReason(state.reason, fallback, '静态阴影烘焙数据已是最新。', language),
+    };
+}
+function resolveLocalizedStaticShadowStatusReason(reason, englishFallback, localizedFallback, language) {
+    if (language !== 'zh')
+        return reason ?? englishFallback;
+    return !reason || reason === englishFallback ? localizedFallback : reason;
+}
+function formatChineseStaticShadowBakingStatus(state) {
+    const stats = state.stats ?? null;
+    const phase = stats?.phase;
+    const attempted = stats?.attemptedChunkCount ?? 0;
+    const completed = stats?.chunkCount ?? 0;
+    const atlasPages = stats?.pageCount ?? stats?.textureCount ?? 0;
+    const encodedPages = stats?.textureCount ?? 0;
+    if (phase === 'collect') {
+        if ((stats?.sourceRootCount ?? 0) > 0)
+            return `已收集 ${stats?.sourceRootCount ?? 0} 个静态投射物，正在准备空间分块。`;
+        return '正在收集静态阴影投射物。';
+    }
+    if (phase === 'sdf') {
+        if (attempted > 0)
+            return `正在生成静态阴影 SDF ${Math.min(completed + 1, attempted)} / ${attempted}。`;
+        return '正在生成静态阴影 SDF。';
+    }
+    if (phase === 'pack') {
+        return `正在将 ${completed} 个静态阴影分块打包到 ${atlasPages} 张 Atlas。`;
+    }
+    if (phase === 'encode') {
+        return `正在编码静态阴影 Atlas ${Math.min(encodedPages + 1, atlasPages || encodedPages + 1)} / ${atlasPages || encodedPages + 1}。`;
+    }
+    if (phase === 'complete')
+        return '正在写入静态阴影烘焙数据。';
+    if (attempted > 0)
+        return `正在烘焙静态阴影分块 ${Math.min(completed + 1, attempted)} / ${attempted}。`;
+    if ((stats?.sourceRootCount ?? 0) > 0)
+        return `已收集 ${stats?.sourceRootCount ?? 0} 个静态投射物，正在准备分块。`;
+    return '正在收集静态阴影投射物。';
+}
+function formatChineseStaticShadowProgressLabel(state) {
+    const stats = state.stats ?? null;
+    const phase = stats?.phase;
+    const attempted = stats?.attemptedChunkCount ?? 0;
+    const completed = stats?.chunkCount ?? 0;
+    if (phase === 'collect')
+        return '收集静态投射物';
+    if (phase === 'pack')
+        return '打包静态阴影 Atlas';
+    if (phase === 'encode') {
+        const atlasPages = stats?.pageCount ?? stats?.textureCount ?? 0;
+        const encodedPages = stats?.textureCount ?? 0;
+        return `静态阴影 Atlas ${Math.min(encodedPages, atlasPages)} / ${atlasPages}`;
+    }
+    return attempted > 0
+        ? `静态阴影烘焙 ${Math.min(completed, attempted)} / ${attempted}`
+        : '正在烘焙静态阴影';
+}
+function createStaticShadowBakeDetails(state, language) {
+    const stats = state.stats ?? null;
+    const details = [];
+    const add = (labelEn, labelZh, value, tone) => {
+        if (value == null || value === '')
+            return;
+        details.push({
+            label: language === 'zh' ? labelZh : labelEn,
+            value: String(value),
+            ...(tone ? { tone } : {}),
+        });
+    };
+    const chunkCount = stats?.chunkCount ?? state.chunkCount;
+    const performance = calculateStaticShadowPerformanceDetails(stats, chunkCount);
+    add('Static casters', '静态投射物', formatOptionalCount(stats?.sourceRootCount));
+    add('Bake meshes', '参与 Mesh', formatOptionalCount(stats?.sourceMeshCount));
+    add('Chunks', '分块', formatOptionalCount(chunkCount), chunkCount === 0 ? 'warning' : undefined);
+    add('Atlas pages', 'Atlas 页', formatOptionalCount(stats?.pageCount ?? stats?.textureCount ?? chunkCount));
+    add('Texture memory', '贴图显存', performance.textureMemoryText, performance.textureMemoryTone);
+    add('Texture pixels', '贴图像素', performance.atlasPixelsText);
+    add('Atlas occupancy', 'Atlas 利用率', performance.atlasOccupancyText, performance.atlasOccupancyTone);
+    add('Atlas used', 'Atlas 已用', performance.atlasUsedPixelsText);
+    add('Atlas allocated', 'Atlas 分配', performance.atlasAllocatedPixelsText);
+    add('Runtime draws', '运行时 Draw', performance.drawCallsText);
+    add('Shadow mesh', '阴影 Mesh', performance.meshText);
+    add('Triangles', '三角形', performance.triangleText);
+    add('Vertices', '顶点', performance.vertexText);
+    add('Effective texels / m', '实际每米像素', formatOptionalNumber(stats?.effectiveTexelsPerMeter ?? stats?.texelsPerMeter));
+    if (stats?.effectiveTexelsPerMeter != null
+        && stats?.texelsPerMeter != null
+        && Math.abs(stats.effectiveTexelsPerMeter - stats.texelsPerMeter) > 0.001) {
+        add('Target texels / m', '目标每米像素', formatOptionalNumber(stats.texelsPerMeter), 'warning');
+    }
+    add('Atlas size', 'Atlas 尺寸', stats?.atlasSize ? `${stats.atlasSize}px` : null);
+    add('Page budget', '页预算', formatOptionalCount(stats?.maxAtlasPages));
+    add('SDF radius', 'SDF 半径', stats?.sdfRadiusPx != null ? `${stats.sdfRadiusPx}px` : null);
+    add('Spatial chunk', '空间分块', stats?.spatialChunkSize ? formatMeters(stats.spatialChunkSize) : null);
+    if (stats?.effectiveSpatialChunkSize != null
+        && stats?.spatialChunkSize != null
+        && Math.abs(stats.effectiveSpatialChunkSize - stats.spatialChunkSize) > 0.001) {
+        add('Effective chunk', '实际分块', formatMeters(stats.effectiveSpatialChunkSize), 'warning');
+    }
+    add('Target chunks', '目标分块', formatOptionalCount(stats?.targetChunkCount));
+    add('Baked chunks', '重烘分块', formatOptionalCount(stats?.bakedChunkCount));
+    add('Reused chunks', '复用分块', formatOptionalCount(stats?.reusedChunkCount), stats?.reusedChunkCount ? 'success' : undefined);
+    add('Resolution', '贴图尺寸', stats?.resolution ? `${stats.resolution}px` : null);
+    add('Chunk size', '分块尺寸', stats?.chunkSize ? formatMeters(stats.chunkSize) : null);
+    add('Duration', '耗时', formatDurationMs(stats?.durationMs, language));
+    if (state.status === 'baking') {
+        add('Current chunk', '当前分块', stats?.currentChunkId);
+        const attempted = stats?.attemptedChunkCount;
+        const completed = stats?.chunkCount;
+        if (stats?.phase)
+            add('Stage', '阶段', formatStaticShadowBakePhase(stats.phase, language));
+        if (attempted != null && completed != null) {
+            add('Progress', '进度', language === 'zh' ? `${completed} / ${attempted} 个分块` : `${completed} / ${attempted} chunks`);
+        }
+    }
+    else {
+        add('Skipped chunks', '跳过分块', formatOptionalCount(stats?.skippedChunkCount), stats?.skippedChunkCount ? 'warning' : undefined);
+    }
+    return details;
+}
+function calculateStaticShadowPerformanceDetails(stats, fallbackChunkCount) {
+    if (!stats) {
+        return {
+            textureMemoryText: null,
+            atlasPixelsText: null,
+            atlasUsedPixelsText: null,
+            atlasAllocatedPixelsText: null,
+            atlasOccupancyText: null,
+            drawCallsText: null,
+            meshText: null,
+            triangleText: null,
+            vertexText: null,
+        };
+    }
+    const chunkCount = Math.max(0, Math.trunc(stats.chunkCount ?? fallbackChunkCount ?? 0));
+    const isAtlas = stats.pageCount != null || stats.atlasSize != null || stats.effectiveTexelsPerMeter != null;
+    const textureCount = Math.max(0, Math.trunc(isAtlas
+        ? stats.pageCount ?? stats.textureCount ?? 0
+        : stats.textureCount ?? chunkCount));
+    const textureSize = isAtlas ? stats.atlasSize : stats.resolution;
+    const fallbackTextureBytes = textureCount > 0 && textureSize != null && Number.isFinite(textureSize) && textureSize > 0
+        ? textureCount * textureSize * textureSize * 4
+        : null;
+    const allocatedPixels = isAtlas
+        ? stats.atlasAllocatedPixels ?? (fallbackTextureBytes != null ? fallbackTextureBytes / 4 : null)
+        : (fallbackTextureBytes != null ? fallbackTextureBytes / 4 : null);
+    const usedPixels = isAtlas ? stats.atlasUsedPixels ?? null : null;
+    const textureBytes = allocatedPixels != null ? allocatedPixels * 4 : null;
+    const occupancy = isAtlas
+        ? stats.atlasOccupancy ?? (allocatedPixels != null && allocatedPixels > 0 && usedPixels != null
+            ? usedPixels / allocatedPixels
+            : null)
+        : null;
+    const drawCalls = textureCount > 0 ? textureCount : null;
+    const renderMeshes = isAtlas ? drawCalls : chunkCount || null;
+    const triangles = chunkCount > 0 ? chunkCount * 2 : null;
+    const vertices = chunkCount > 0 ? chunkCount * 4 : null;
+    return {
+        textureMemoryText: formatBytes(textureBytes),
+        textureMemoryTone: textureBytes != null && textureBytes >= 256 * 1024 * 1024 ? 'warning' : undefined,
+        atlasPixelsText: formatPixelCount(allocatedPixels),
+        atlasUsedPixelsText: formatPixelCount(usedPixels),
+        atlasAllocatedPixelsText: formatPixelCount(allocatedPixels),
+        atlasOccupancyText: formatPercentage(occupancy),
+        atlasOccupancyTone: occupancy != null && occupancy < 0.35 ? 'warning' : undefined,
+        drawCallsText: formatOptionalCount(drawCalls),
+        meshText: formatOptionalCount(renderMeshes),
+        triangleText: formatOptionalCount(triangles),
+        vertexText: formatOptionalCount(vertices),
+    };
+}
+function formatStaticShadowBakePhase(phase, language) {
+    if (language !== 'zh')
+        return phase;
+    switch (phase) {
+        case 'collect': return '收集';
+        case 'reuse': return '复用已有分块';
+        case 'chunk': return '烘焙分块';
+        case 'sdf': return '生成 SDF';
+        case 'pack': return '打包 Atlas';
+        case 'encode': return '编码 Atlas';
+        case 'complete': return '写入结果';
+        default: return phase;
+    }
+}
+function formatOptionalCount(value) {
+    if (value == null || !Number.isFinite(value))
+        return null;
+    return String(Math.max(0, Math.trunc(value)));
+}
+function formatOptionalNumber(value) {
+    if (value == null || !Number.isFinite(value))
+        return null;
+    return Number.isInteger(value) ? String(value) : value.toFixed(2).replace(/\.?0+$/, '');
+}
+function formatPixelCount(value) {
+    if (value == null || !Number.isFinite(value))
+        return null;
+    const pixels = Math.max(0, value);
+    if (pixels >= 1000000)
+        return `${formatOptionalNumber(pixels / 1000000)} MP`;
+    if (pixels >= 1000)
+        return `${formatOptionalNumber(pixels / 1000)} KP`;
+    return formatOptionalCount(pixels);
+}
+function formatPercentage(value) {
+    if (value == null || !Number.isFinite(value))
+        return null;
+    return `${formatOptionalNumber(Math.max(0, Math.min(1, value)) * 100)}%`;
+}
+function formatBytes(value) {
+    if (value == null || !Number.isFinite(value))
+        return null;
+    const bytes = Math.max(0, value);
+    if (bytes >= 1024 * 1024 * 1024)
+        return `${formatOptionalNumber(bytes / (1024 * 1024 * 1024))} GiB`;
+    if (bytes >= 1024 * 1024)
+        return `${formatOptionalNumber(bytes / (1024 * 1024))} MiB`;
+    if (bytes >= 1024)
+        return `${formatOptionalNumber(bytes / 1024)} KiB`;
+    return `${formatOptionalCount(bytes)} B`;
+}
+function formatMeters(value) {
+    const text = Number.isInteger(value) ? String(value) : value.toFixed(2).replace(/\.?0+$/, '');
+    return `${text} m`;
+}
+function formatDurationMs(value, language) {
+    if (value == null || !Number.isFinite(value))
+        return null;
+    const duration = Math.max(0, value);
+    if (duration < 1000)
+        return `${Math.round(duration)} ms`;
+    const seconds = duration / 1000;
+    const text = seconds < 10 ? seconds.toFixed(1) : String(Math.round(seconds));
+    return language === 'zh' ? `${text} 秒` : `${text}s`;
+}
+function createRenderingGroupsSection(slots) {
+    return {
+        id: 'rendering-groups',
+        title: 'Rendering Groups / Order Presets',
+        summary: 'Named Babylon rendering groups and alphaIndex presets used by object Inspector dropdowns.',
+        layout: 'list',
+        systems: slots.map((slot) => ({
+            id: `rendering-group-${slot.renderingGroupId}`,
+            label: slot.name,
+            kind: 'rendering-group',
+            active: true,
+            summary: `Babylon group ${slot.renderingGroupId}`,
+            actions: [{
+                    id: 'rendering-alpha-preset.add',
+                    label: 'Add Order Preset',
+                    icon: 'plus',
+                    tooltip: 'Add a named alphaIndex preset for this rendering group.',
+                    params: { renderingGroupId: slot.renderingGroupId },
+                }],
+            properties: [
+                createReadonlyRenderingProperty(`renderingGroups.slots.${slot.renderingGroupId}.renderingGroupId`, 'Group ID', slot.renderingGroupId),
+                {
+                    path: `renderingGroups.slots.${slot.renderingGroupId}.name`,
+                    label: 'Group Name',
+                    valueType: 'string',
+                    control: 'string',
+                    value: slot.name,
+                    tooltip: 'Display name for this fixed Babylon rendering group id.',
+                    commitMode: 'blur',
+                },
+                ...slot.alphaIndexPresets.flatMap((preset, index) => [
+                    {
+                        path: `renderingGroups.slots.${slot.renderingGroupId}.alphaIndexPresets.${index}.name`,
+                        label: `Preset ${index + 1} Name`,
+                        valueType: 'string',
+                        control: 'string',
+                        value: preset.name,
+                        tooltip: 'User-facing name shown in object Inspector dropdowns.',
+                        commitMode: 'blur',
+                        actions: [{
+                                id: 'rendering-alpha-preset.delete',
+                                label: 'Delete',
+                                icon: 'trash',
+                                tooltip: 'Delete this alphaIndex preset. Existing objects keep their numeric alphaIndex.',
+                                params: { renderingGroupId: slot.renderingGroupId, presetIndex: index },
+                            }],
+                    },
+                    {
+                        path: `renderingGroups.slots.${slot.renderingGroupId}.alphaIndexPresets.${index}.alphaIndex`,
+                        label: `Preset ${index + 1} Value`,
+                        valueType: 'number',
+                        control: 'number',
+                        value: preset.alphaIndex,
+                        step: 1,
+                        tooltip: 'Babylon alphaIndex value stored on objects that use this preset.',
+                        commitMode: 'blur',
+                    },
+                ]),
+            ],
+        })),
+    };
 }
 function createReadonlyRenderingProperty(path, label, value) {
     return {
@@ -436,6 +1128,21 @@ function createEnvironmentTexturePickerControlOptions(input) {
         ],
     };
 }
+function createShadowDefaultModeOptions(language) {
+    return language === 'zh'
+        ? [
+            { label: '无阴影', value: 'none' },
+            { label: 'Blob 阴影', value: 'blob' },
+            { label: '静态烘焙阴影', value: 'static' },
+            { label: '主平面阴影', value: 'planar' },
+        ]
+        : [
+            { label: 'None', value: 'none' },
+            { label: 'Blob', value: 'blob' },
+            { label: 'Static Baked', value: 'static' },
+            { label: 'Planar', value: 'planar' },
+        ];
+}
 function isEditorSceneEnvironmentTextureAsset(texture) {
     if (texture.capabilities?.environmentTexture === true)
         return true;
@@ -464,7 +1171,15 @@ const RENDERING_PANEL_TEXT = {
         revert: 'Revert',
         revertDirty: 'Revert rendering settings to the last saved rendering settings.',
         revertClean: 'Rendering settings already match the last saved rendering settings.',
+        bakeStatic: 'Bake Static Shadows',
+        bakeStaticReady: 'Bake static shadow chunks for objects authored as Static Baked Shadow.',
+        bakeStaticDisabled: 'Enable Static Baked Shadow before baking.',
+        bakeStaticRunning: 'Static shadow bake is already running.',
         sections: {
+            'rendering-groups': {
+                title: 'Rendering Groups / Order Presets',
+                summary: 'Named Babylon rendering groups and alphaIndex presets used by object Inspector dropdowns.',
+            },
             environment: {
                 title: 'Environment / IBL',
                 summary: 'World environment texture and reflection lighting shared by editor preview and runtime.',
@@ -478,6 +1193,24 @@ const RENDERING_PANEL_TEXT = {
                 summary: 'Global shadow systems for editor preview and runtime.',
             },
         },
+        groups: {
+            'shadow-group-moving-object': {
+                label: 'Moving Object Shadows',
+                summary: 'Blob: lightweight for moving objects and project-default fallback.',
+            },
+            'shadow-group-static-scene': {
+                label: 'Static Scene Shadows',
+                summary: 'Consumes baked artifacts; update during authoring/build, runtime only displays results.',
+            },
+            'shadow-group-directional-planar': {
+                label: 'Directional Planar Shadows',
+                summary: 'Real-time planar projection following the directional light.',
+            },
+            'shadow-group-compatibility': {
+                label: 'Compatibility Shadows',
+                summary: 'Legacy ShadowGenerator / CSM read-only compatibility paths.',
+            },
+        },
         systems: {
             'environment-global': {
                 label: 'Environment Texture',
@@ -490,6 +1223,14 @@ const RENDERING_PANEL_TEXT = {
                 label: 'Planar Main',
                 summary: 'Follow Directional Light',
             },
+            'blob-shadow': {
+                label: 'Blob Shadow',
+                summary: 'Default object shadow',
+            },
+            'static-projected-shadow': {
+                label: 'Static Baked Shadow',
+                summary: 'Baked object shape',
+            },
             'legacy-shadow': {
                 label: 'Legacy Shadow',
                 disabled: 'Disabled',
@@ -514,6 +1255,106 @@ const RENDERING_PANEL_TEXT = {
                 label: 'IBL Rotation',
                 tooltip: 'Y-axis rotation applied to the environment texture.',
             },
+            'shadows.defaultMode': {
+                label: 'Default Mode',
+                tooltip: 'Default shadow mode for GameObjects that use the project default.',
+            },
+            'shadows.blob.enabled': {
+                label: 'Enabled',
+                tooltip: 'Enable the shared blob shadow system.',
+            },
+            'shadows.blob.appearance.color': {
+                label: 'Color',
+                tooltip: 'Blob shadow RGB color. Opacity is edited separately.',
+            },
+            'shadows.blob.appearance.color.a': {
+                label: 'Opacity',
+                tooltip: 'Blob shadow opacity, clamped between 0 and 1.',
+            },
+            'shadows.blob.appearance.edgeSoftness': {
+                label: 'Soft Edge',
+                tooltip: 'Blob shadow soft edge start. Higher values keep the center denser before fading out.',
+            },
+            'shadows.blob.plane.height': {
+                label: 'Height',
+                tooltip: 'Ground plane height used by blob shadows.',
+            },
+            'shadows.blob.plane.yOffset': {
+                label: 'Y Offset',
+                tooltip: 'Vertical offset above the blob shadow plane to reduce z-fighting.',
+            },
+            'shadows.blob.size.sizeMultiplier': {
+                label: 'Size Multiplier',
+                tooltip: 'Scale blob shadow size from each caster bounds.',
+            },
+            'shadows.blob.size.minSize': {
+                label: 'Min Size',
+                tooltip: 'Minimum blob shadow size for tiny objects.',
+            },
+            'shadows.blob.size.maxSize': {
+                label: 'Max Size',
+                tooltip: 'Maximum blob shadow size for large objects.',
+            },
+            'shadows.staticProjected.enabled': {
+                label: 'Enabled',
+                tooltip: 'Enable the shared static projected shadow system.',
+            },
+            'shadows.staticProjected.appearance.color': {
+                label: 'Color',
+                tooltip: 'Static shadow RGB color. Opacity is edited separately.',
+            },
+            'shadows.staticProjected.appearance.color.a': {
+                label: 'Opacity',
+                tooltip: 'Static shadow opacity, clamped between 0 and 1.',
+            },
+            'shadows.staticProjected.plane.height': {
+                label: 'Height',
+                tooltip: 'Ground plane height used by static projected shadows.',
+            },
+            'shadows.staticProjected.plane.yOffset': {
+                label: 'Y Offset',
+                tooltip: 'Vertical offset above the static shadow plane to reduce z-fighting.',
+            },
+            'shadows.staticProjected.bake.resolution': {
+                label: 'Legacy Resolution',
+                tooltip: 'Legacy v1 mask resolution. v2 SDF atlas bake uses Texels per Meter and Atlas Size.',
+            },
+            'shadows.staticProjected.bake.padding': {
+                label: 'Padding',
+                tooltip: 'Extra projected bounds padding before baking the static shadow.',
+            },
+            'shadows.staticProjected.bake.blur': {
+                label: 'Blur',
+                tooltip: 'Reserved blur radius for static shadow bake softness.',
+            },
+            'shadows.staticProjected.bake.maxSize': {
+                label: 'Legacy Max Size',
+                tooltip: 'Legacy alias for Spatial Chunk Size.',
+            },
+            'shadows.staticProjected.bake.texelsPerMeter': {
+                label: 'Texels per Meter',
+                tooltip: 'Target SDF atlas texel density for baked static shadows.',
+            },
+            'shadows.staticProjected.bake.atlasSize': {
+                label: 'Atlas Size',
+                tooltip: 'Maximum width and height for each static shadow atlas page.',
+            },
+            'shadows.staticProjected.bake.maxAtlasPages': {
+                label: 'Page Budget',
+                tooltip: 'Maximum atlas pages before bake lowers the effective texel density.',
+            },
+            'shadows.staticProjected.bake.sdfRadiusPx': {
+                label: 'SDF Radius',
+                tooltip: 'Signed-distance radius in pixels used for crisp controllable edges.',
+            },
+            'shadows.staticProjected.bake.spatialChunkSize': {
+                label: 'Spatial Chunk Size',
+                tooltip: 'World size of each spatial bake chunk before atlas packing.',
+            },
+            'shadows.staticProjected.bake.targetChunkCount': {
+                label: 'Target Chunks',
+                tooltip: 'Soft chunk-count budget. Large scenes automatically enlarge spatial chunks to stay near this target.',
+            },
         },
     },
     zh: {
@@ -523,7 +1364,15 @@ const RENDERING_PANEL_TEXT = {
         revert: '还原',
         revertDirty: '还原到上一次保存的渲染设置。',
         revertClean: '当前渲染设置已经和上一次保存状态一致。',
+        bakeStatic: '烘焙静态阴影',
+        bakeStaticReady: '为标记为静态烘焙阴影的物体生成分块阴影。',
+        bakeStaticDisabled: '请先启用静态烘焙阴影。',
+        bakeStaticRunning: '静态阴影正在烘焙中。',
         sections: {
+            'rendering-groups': {
+                title: '渲染分组 / 顺序预设',
+                summary: '项目级 Babylon rendering group 名称和 alphaIndex 预设，用于物体 Inspector 下拉选择。',
+            },
             environment: {
                 title: '环境 / IBL',
                 summary: '世界环境贴图与 PBR 环境反射，编辑器预览和运行时共用。',
@@ -537,6 +1386,24 @@ const RENDERING_PANEL_TEXT = {
                 summary: '项目级阴影系统，编辑器预览和运行时共用。',
             },
         },
+        groups: {
+            'shadow-group-moving-object': {
+                label: '移动物体阴影',
+                summary: 'Blob：低成本，适合移动物体，也可作为项目默认阴影。',
+            },
+            'shadow-group-static-scene': {
+                label: '静态场景阴影',
+                summary: '只显示已烘焙 artifact；编辑器/构建期更新，运行时消费结果。',
+            },
+            'shadow-group-directional-planar': {
+                label: '主平面实时阴影',
+                summary: '跟随直射光动态投影，适合需要方向感的物体。',
+            },
+            'shadow-group-compatibility': {
+                label: '兼容阴影',
+                summary: '旧 ShadowGenerator / CSM 只读兼容路径。',
+            },
+        },
         systems: {
             'environment-global': {
                 label: '环境贴图',
@@ -549,6 +1416,14 @@ const RENDERING_PANEL_TEXT = {
                 label: '主平面阴影',
                 summary: '跟随直射光',
             },
+            'blob-shadow': {
+                label: 'Blob 阴影',
+                summary: '默认物体阴影',
+            },
+            'static-projected-shadow': {
+                label: '静态烘焙阴影',
+                summary: '烘焙物体轮廓',
+            },
             'legacy-shadow': {
                 label: '旧版阴影',
                 disabled: '已禁用',
@@ -626,6 +1501,106 @@ const RENDERING_PANEL_TEXT = {
                 label: 'Bloom 缩放',
                 tooltip: 'Bloom 渲染缩放比例。较低数值更省性能，较高数值细节更稳定。',
             },
+            'shadows.defaultMode': {
+                label: '默认模式',
+                tooltip: '使用项目默认阴影的 GameObject 会采用这个模式。',
+            },
+            'shadows.blob.enabled': {
+                label: '启用',
+                tooltip: '启用共用的 Blob 阴影系统。',
+            },
+            'shadows.blob.appearance.color': {
+                label: '颜色',
+                tooltip: 'Blob 阴影颜色。透明度单独编辑。',
+            },
+            'shadows.blob.appearance.color.a': {
+                label: '不透明度',
+                tooltip: 'Blob 阴影不透明度，范围 0 到 1。',
+            },
+            'shadows.blob.appearance.edgeSoftness': {
+                label: '柔边',
+                tooltip: 'Blob 阴影柔边起点。数值越高，中心区域越实，边缘再逐渐淡出。',
+            },
+            'shadows.blob.plane.height': {
+                label: '高度',
+                tooltip: 'Blob 阴影所在的地面高度。',
+            },
+            'shadows.blob.plane.yOffset': {
+                label: 'Y 偏移',
+                tooltip: 'Blob 阴影相对地面的垂直偏移，用于避免 z-fighting。',
+            },
+            'shadows.blob.size.sizeMultiplier': {
+                label: '尺寸倍率',
+                tooltip: '根据投射物包围盒计算 Blob 阴影尺寸时使用的倍率。',
+            },
+            'shadows.blob.size.minSize': {
+                label: '最小尺寸',
+                tooltip: '很小物体使用的最小 Blob 阴影尺寸。',
+            },
+            'shadows.blob.size.maxSize': {
+                label: '最大尺寸',
+                tooltip: '大型物体使用的最大 Blob 阴影尺寸。',
+            },
+            'shadows.staticProjected.enabled': {
+                label: '启用',
+                tooltip: '启用共用的静态烘焙阴影系统。',
+            },
+            'shadows.staticProjected.appearance.color': {
+                label: '颜色',
+                tooltip: '静态烘焙阴影颜色。透明度单独编辑。',
+            },
+            'shadows.staticProjected.appearance.color.a': {
+                label: '不透明度',
+                tooltip: '静态烘焙阴影不透明度，范围 0 到 1。',
+            },
+            'shadows.staticProjected.plane.height': {
+                label: '高度',
+                tooltip: '静态烘焙阴影所在的地面高度。',
+            },
+            'shadows.staticProjected.plane.yOffset': {
+                label: 'Y 偏移',
+                tooltip: '静态烘焙阴影相对地面的垂直偏移，用于避免 z-fighting。',
+            },
+            'shadows.staticProjected.bake.resolution': {
+                label: '旧版贴图尺寸',
+                tooltip: '旧版 v1 mask 分辨率。v2 SDF atlas 烘焙使用每米像素和 Atlas 尺寸。',
+            },
+            'shadows.staticProjected.bake.padding': {
+                label: '留白',
+                tooltip: '烘焙静态阴影前给投影范围增加的留白。',
+            },
+            'shadows.staticProjected.bake.blur': {
+                label: '模糊',
+                tooltip: '静态阴影烘焙柔化预留半径。',
+            },
+            'shadows.staticProjected.bake.maxSize': {
+                label: '旧版最大尺寸',
+                tooltip: '旧版字段，作为空间分块尺寸的兼容别名。',
+            },
+            'shadows.staticProjected.bake.texelsPerMeter': {
+                label: '每米像素',
+                tooltip: '静态阴影 SDF atlas 的目标像素密度。',
+            },
+            'shadows.staticProjected.bake.atlasSize': {
+                label: 'Atlas 尺寸',
+                tooltip: '每张静态阴影 atlas 页的最大宽高。',
+            },
+            'shadows.staticProjected.bake.maxAtlasPages': {
+                label: '页预算',
+                tooltip: '超过该 atlas 页数时，烘焙会降低实际每米像素以保护运行时成本。',
+            },
+            'shadows.staticProjected.bake.sdfRadiusPx': {
+                label: 'SDF 半径',
+                tooltip: '用于重建清晰可控边缘的有符号距离半径，单位像素。',
+            },
+            'shadows.staticProjected.bake.spatialChunkSize': {
+                label: '空间分块尺寸',
+                tooltip: '进入 atlas packing 前，每个空间烘焙分块覆盖的世界尺寸。',
+            },
+            'shadows.staticProjected.bake.targetChunkCount': {
+                label: '目标分块数',
+                tooltip: '分块数量软预算。大场景会自动放大空间分块，尽量接近该数量。',
+            },
             'shadows.planar.enabled': {
                 label: '启用',
                 tooltip: '启用共用的平面阴影系统。运行时和编辑器预览会使用同一套参数。',
@@ -712,10 +1687,7 @@ function localizeRenderingPanelState(panel, language, dirty) {
     if (panel.status === RENDERING_PANEL_TEXT.en.dirtyStatus)
         panel.status = text.dirtyStatus;
     for (const action of panel.actions ?? []) {
-        if (action.id !== 'revert-rendering')
-            continue;
-        action.label = text.revert;
-        action.tooltip = dirty ? text.revertDirty : text.revertClean;
+        localizeRenderingAction(action, text, dirty);
     }
     for (const section of panel.sections) {
         const sectionText = text.sections[section.id];
@@ -725,10 +1697,18 @@ function localizeRenderingPanelState(panel, language, dirty) {
             section.summary = sectionText.summary;
         for (const system of section.systems) {
             const systemText = text.systems[system.id];
+            if (system.group) {
+                const groupText = text.groups[system.group.id];
+                if (groupText?.label)
+                    system.group.label = groupText.label;
+                if (groupText?.summary)
+                    system.group.summary = groupText.summary;
+            }
             if (systemText?.label)
                 system.label = systemText.label;
-            if (systemText?.summary)
+            if (systemText?.summary && !(system.id === 'static-projected-shadow' && system.status)) {
                 system.summary = systemText.summary;
+            }
             if (language === 'zh' && system.id === 'environment-global' && system.summary === 'No IBL texture') {
                 system.summary = '未设置 IBL 贴图';
             }
@@ -736,12 +1716,28 @@ function localizeRenderingPanelState(panel, language, dirty) {
                 system.summary = systemText.disabled;
             if (systemText?.compatibility && system.summary === RENDERING_PANEL_TEXT.en.systems[system.id]?.compatibility)
                 system.summary = systemText.compatibility;
+            for (const action of system.actions ?? [])
+                localizeRenderingAction(action, text, dirty);
             for (const property of system.properties)
                 localizeRenderingProperty(property, text);
         }
     }
     return panel;
 }
+function localizeRenderingAction(action, text, dirty) {
+    if (action.id === 'revert-rendering') {
+        action.label = text.revert;
+        action.tooltip = dirty ? text.revertDirty : text.revertClean;
+    }
+    if (action.id === 'bake-static-shadows') {
+        action.label = text.bakeStatic;
+        action.tooltip = action.disabled
+            ? action.tooltip === RENDERING_PANEL_TEXT.en.bakeStaticRunning
+                ? text.bakeStaticRunning
+                : text.bakeStaticDisabled
+            : text.bakeStaticReady;
+    }
+}
 function localizeRenderingProperty(property, text) {
     const propertyText = text.properties[property.path];
     if (!propertyText)