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

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

@@ -22,6 +22,14 @@ export const EDITOR_SCENE_DEFAULT_PLANAR_SHADOW_EXCLUDE_PATTERNS = [
     '_shadow',
     '_planarShadow',
 ];
+export const EDITOR_SCENE_DEFAULT_BLOB_SHADOW_EXCLUDE_PATTERNS = [
+    ...EDITOR_SCENE_DEFAULT_PLANAR_SHADOW_EXCLUDE_PATTERNS,
+    '_blobShadow',
+];
+export const EDITOR_SCENE_DEFAULT_STATIC_PROJECTED_SHADOW_EXCLUDE_PATTERNS = [
+    ...EDITOR_SCENE_DEFAULT_BLOB_SHADOW_EXCLUDE_PATTERNS,
+    '_staticProjectedShadow',
+];
 export const EDITOR_SCENE_RENDERING_PROFILE_ALLOWED_PATCH_PATHS = [
     'globalVolume.enabled',
     'globalVolume.hdr',
@@ -40,6 +48,31 @@ export const EDITOR_SCENE_RENDERING_PROFILE_ALLOWED_PATCH_PATHS = [
     'globalVolume.postProcessing.bloom.weight',
     'globalVolume.postProcessing.bloom.kernel',
     'globalVolume.postProcessing.bloom.scale',
+    'shadows.defaultMode',
+    'shadows.blob.enabled',
+    'shadows.blob.appearance.color',
+    'shadows.blob.appearance.color.a',
+    'shadows.blob.appearance.edgeSoftness',
+    'shadows.blob.plane.height',
+    'shadows.blob.plane.yOffset',
+    'shadows.blob.size.sizeMultiplier',
+    'shadows.blob.size.minSize',
+    'shadows.blob.size.maxSize',
+    'shadows.staticProjected.enabled',
+    'shadows.staticProjected.appearance.color',
+    'shadows.staticProjected.appearance.color.a',
+    'shadows.staticProjected.plane.height',
+    'shadows.staticProjected.plane.yOffset',
+    'shadows.staticProjected.bake.resolution',
+    'shadows.staticProjected.bake.padding',
+    'shadows.staticProjected.bake.blur',
+    'shadows.staticProjected.bake.maxSize',
+    'shadows.staticProjected.bake.texelsPerMeter',
+    'shadows.staticProjected.bake.atlasSize',
+    'shadows.staticProjected.bake.maxAtlasPages',
+    'shadows.staticProjected.bake.sdfRadiusPx',
+    'shadows.staticProjected.bake.spatialChunkSize',
+    'shadows.staticProjected.bake.targetChunkCount',
     'shadows.planar.enabled',
     'shadows.planar.appearance.color',
     'shadows.planar.appearance.color.a',
@@ -51,22 +84,61 @@ export const EDITOR_SCENE_RENDERING_PROFILE_ALLOWED_PATCH_PATHS = [
     'shadows.planar.casters.rootBoundaryPatterns',
     'shadows.planar.receivers.patterns',
 ];
+export const EDITOR_SCENE_RENDERING_GROUP_IDS = [0, 1, 2, 3];
+export const EDITOR_SCENE_DEFAULT_RENDERING_GROUPS = [{
+        renderingGroupId: 0,
+        name: '普通场景',
+        alphaIndexPresets: [
+            { name: '默认透明顺序', alphaIndex: 0 },
+            { name: '地表贴花', alphaIndex: 100 },
+            { name: '近景覆盖', alphaIndex: 200 },
+        ],
+    }, {
+        renderingGroupId: 1,
+        name: '水面 / 透明地表',
+        alphaIndexPresets: [
+            { name: '水面', alphaIndex: 0 },
+            { name: '透明地表', alphaIndex: 100 },
+            { name: '水面高光', alphaIndex: 200 },
+        ],
+    }, {
+        renderingGroupId: 2,
+        name: '特效',
+        alphaIndexPresets: [
+            { name: '普通特效', alphaIndex: 0 },
+            { name: '前景特效', alphaIndex: 100 },
+            { name: '最前特效', alphaIndex: 200 },
+        ],
+    }, {
+        renderingGroupId: 3,
+        name: '世界空间 UI / 引导箭头',
+        alphaIndexPresets: [
+            { name: '世界空间 UI', alphaIndex: 0 },
+            { name: '引导箭头', alphaIndex: 100 },
+            { name: '顶层提示', alphaIndex: 200 },
+        ],
+    }];
 export function normalizeEditorSceneRenderingProfile(config) {
     const root = readRecord(config);
     const shadows = readRecord(root.shadows);
     const settings = readRecord(shadows.settings);
+    const blob = readRecord(shadows.blob);
     const blobSettings = readRecord(shadows.blobSettings);
+    const normalizedBlob = normalizeEditorSceneBlobShadowProfile(blob, blobSettings, shadows);
+    const normalizedStaticProjected = normalizeEditorSceneStaticProjectedShadowProfile(shadows.staticProjected);
     const shadowRange = readRecord(shadows.shadowRange);
     const shadowOrtho = readRecord(shadows.shadowOrtho);
     const csm = readRecord(shadows.csm);
     const shadowMeshes = readRecord(root.shadowMeshes);
     return {
+        renderingGroups: normalizeEditorSceneRenderingGroupsProfile(root.renderingGroups),
         environment: normalizeEditorSceneEnvironmentProfile(root.globalVolume),
         postProcess: normalizeEditorScenePostProcessProfile(root.globalVolume),
         shadows: {
+            defaultMode: readResolvedShadowMode(shadows.defaultMode, 'none'),
             enabled: readBoolean(shadows.enabled, false),
             useCsm: readBoolean(shadows.useCsm, false),
-            useBlobShadow: readBoolean(shadows.useBlobShadow, false),
+            useBlobShadow: normalizedBlob.enabled,
             settings: {
                 mapSize: readNonNegativeNumber(settings.mapSize, 1024),
                 darkness: readNonNegativeNumber(settings.darkness, 0.3),
@@ -79,11 +151,13 @@ export function normalizeEditorSceneRenderingProfile(config) {
                 shadowColor: readRgb(settings.shadowColor, { r: 0, g: 0, b: 0 }),
             },
             blobSettings: {
-                opacity: readClampedNumber(blobSettings.opacity, 0.2, 0, 1),
-                yOffset: readNonNegativeNumber(blobSettings.yOffset, 0.02),
-                sizeMultiplier: readNonNegativeNumber(blobSettings.sizeMultiplier, 1),
+                opacity: readClampedNumber(blobSettings.opacity, 0.35, 0, 1),
+                yOffset: readNonNegativeNumber(blobSettings.yOffset, 0.08),
+                sizeMultiplier: readNonNegativeNumber(blobSettings.sizeMultiplier, 1.25),
                 minSize: readNonNegativeNumber(blobSettings.minSize, 0.25),
             },
+            blob: normalizedBlob,
+            staticProjected: normalizedStaticProjected,
             shadowRange: {
                 minZ: readNonNegativeNumber(shadowRange.minZ, 1),
                 maxZ: readNonNegativeNumber(shadowRange.maxZ, 60),
@@ -157,6 +231,79 @@ export function createEditorScenePlanarShadowPreviewSettings(profile, input = {}
         },
     };
 }
+export function createEditorSceneBlobShadowPreviewSettings(profile, input = {}) {
+    const blob = profile.shadows.blob;
+    return {
+        enabled: blob.enabled && (input.enabled ?? true),
+        plane: {
+            height: blob.plane.height,
+            yOffset: blob.plane.yOffset,
+        },
+        appearance: {
+            color: blob.appearance.color,
+            edgeSoftness: blob.appearance.edgeSoftness,
+        },
+        size: {
+            sizeMultiplier: blob.size.sizeMultiplier,
+            minSize: blob.size.minSize,
+            maxSize: blob.size.maxSize,
+        },
+        casters: {
+            autoDetectAll: input.autoDetectAllCasters ?? false,
+            includePatterns: [
+                ...(input.additionalCasterIncludePatterns ?? []),
+            ],
+            excludePatterns: [
+                ...EDITOR_SCENE_DEFAULT_BLOB_SHADOW_EXCLUDE_PATTERNS,
+                ...(input.additionalExcludePatterns ?? []),
+            ],
+            rootBoundaryPatterns: [
+                ...(input.additionalRootBoundaryPatterns ?? []),
+            ],
+            minVolume: 0.001,
+        },
+    };
+}
+export function createEditorSceneStaticProjectedShadowPreviewSettings(profile, input = {}) {
+    const staticProjected = profile.shadows.staticProjected;
+    return {
+        enabled: staticProjected.enabled && (input.enabled ?? true),
+        plane: {
+            height: staticProjected.plane.height,
+            yOffset: staticProjected.plane.yOffset,
+        },
+        appearance: {
+            color: staticProjected.appearance.color,
+        },
+        direction: { mode: 'follow-light' },
+        bake: {
+            resolution: staticProjected.bake.resolution,
+            padding: staticProjected.bake.padding,
+            blur: staticProjected.bake.blur,
+            maxSize: staticProjected.bake.maxSize,
+            texelsPerMeter: staticProjected.bake.texelsPerMeter,
+            atlasSize: staticProjected.bake.atlasSize,
+            maxAtlasPages: staticProjected.bake.maxAtlasPages,
+            sdfRadiusPx: staticProjected.bake.sdfRadiusPx,
+            spatialChunkSize: staticProjected.bake.spatialChunkSize,
+            targetChunkCount: staticProjected.bake.targetChunkCount,
+        },
+        casters: {
+            autoDetectAll: input.autoDetectAllCasters ?? false,
+            includePatterns: [
+                ...(input.additionalCasterIncludePatterns ?? []),
+            ],
+            excludePatterns: [
+                ...EDITOR_SCENE_DEFAULT_STATIC_PROJECTED_SHADOW_EXCLUDE_PATTERNS,
+                ...(input.additionalExcludePatterns ?? []),
+            ],
+            rootBoundaryPatterns: [
+                ...(input.additionalRootBoundaryPatterns ?? []),
+            ],
+            minVolume: 0.001,
+        },
+    };
+}
 export function applyEditorSceneRenderingProfilePatch(config, changes) {
     const draft = cloneRecord(config);
     const changedPaths = [];
@@ -180,6 +327,10 @@ export function summarizeEditorSceneRenderingProfile(value) {
         postProcessEnabled: value?.postProcess?.enabled ?? null,
         postProcessExposure: value?.postProcess?.imageProcessing?.exposure ?? null,
         postProcessBloomEnabled: value?.postProcess?.bloom?.enabled ?? null,
+        blobEnabled: value?.shadows?.blob?.enabled ?? null,
+        blobOpacity: value?.shadows?.blob?.appearance?.color?.a ?? null,
+        staticProjectedEnabled: value?.shadows?.staticProjected?.enabled ?? null,
+        staticProjectedOpacity: value?.shadows?.staticProjected?.appearance?.color?.a ?? null,
         planarEnabled: value?.shadows?.planar?.enabled ?? null,
         planarOpacity: value?.shadows?.planar?.appearance?.color?.a ?? null,
         planeHeight: value?.shadows?.planar?.plane?.height ?? null,
@@ -188,7 +339,122 @@ export function summarizeEditorSceneRenderingProfile(value) {
     };
 }
 export function isEditorSceneRenderingProfilePatchPath(path) {
-    return EDITOR_SCENE_RENDERING_PROFILE_ALLOWED_PATCH_PATHS.includes(path);
+    return EDITOR_SCENE_RENDERING_PROFILE_ALLOWED_PATCH_PATHS.includes(path)
+        || parseEditorSceneRenderingGroupNamePatchPath(path) != null
+        || parseEditorSceneRenderingAlphaPresetPatchPath(path) != null;
+}
+export function applyEditorSceneRenderingProfileAction(config, input) {
+    const draft = cloneRecord(config);
+    const changedPaths = [];
+    const renderingGroupId = readRenderingGroupId(input.renderingGroupId);
+    if (renderingGroupId == null) {
+        return {
+            config: draft,
+            changedPaths,
+            normalized: normalizeEditorSceneRenderingProfile(draft),
+        };
+    }
+    if (input.actionId === 'rendering-alpha-preset.add') {
+        const nextIndex = appendEditorSceneRenderingAlphaPreset(draft, renderingGroupId);
+        changedPaths.push(`renderingGroups.slots.${renderingGroupId}.alphaIndexPresets.${nextIndex}`);
+    }
+    else if (input.actionId === 'rendering-alpha-preset.delete') {
+        const presetIndex = readPresetIndex(input.presetIndex);
+        if (presetIndex != null && removeEditorSceneRenderingAlphaPreset(draft, renderingGroupId, presetIndex)) {
+            changedPaths.push(`renderingGroups.slots.${renderingGroupId}.alphaIndexPresets.${presetIndex}`);
+        }
+    }
+    return {
+        config: draft,
+        changedPaths,
+        normalized: normalizeEditorSceneRenderingProfile(draft),
+    };
+}
+export function resolveEditorSceneRenderingAlphaIndexPresetValueMigration(input) {
+    const changePath = input.change?.path;
+    if (!changePath || !input.changedPaths.includes(changePath))
+        return null;
+    const alphaPresetPatch = parseEditorSceneRenderingAlphaPresetPatchPath(changePath);
+    if (!alphaPresetPatch || alphaPresetPatch.field !== 'alphaIndex')
+        return null;
+    const toAlphaIndex = readFiniteNumber(input.change?.value, Number.NaN);
+    if (!Number.isFinite(toAlphaIndex))
+        return null;
+    const previousPreset = input.previousProfile.renderingGroups.slots
+        .find(slot => slot.renderingGroupId === alphaPresetPatch.renderingGroupId)
+        ?.alphaIndexPresets[alphaPresetPatch.presetIndex];
+    if (!previousPreset || !Number.isFinite(previousPreset.alphaIndex))
+        return null;
+    if (previousPreset.alphaIndex === toAlphaIndex)
+        return null;
+    return {
+        renderingGroupId: alphaPresetPatch.renderingGroupId,
+        fromAlphaIndex: previousPreset.alphaIndex,
+        toAlphaIndex,
+    };
+}
+function normalizeEditorSceneBlobShadowProfile(value, legacyBlobSettingsValue, legacyShadowsValue) {
+    const blob = readRecord(value);
+    const plane = readRecord(blob.plane);
+    const appearance = readRecord(blob.appearance);
+    const size = readRecord(blob.size);
+    const legacyBlobSettings = readRecord(legacyBlobSettingsValue);
+    const legacyShadows = readRecord(legacyShadowsValue);
+    const legacyOpacity = legacyBlobSettings.opacity;
+    const colorFallback = readRgba(appearance.color, {
+        r: 0,
+        g: 0,
+        b: 0,
+        a: readClampedNumber(legacyOpacity, 0.35, 0, 1),
+    });
+    return {
+        enabled: readBoolean(blob.enabled, readBoolean(legacyShadows.useBlobShadow, true)),
+        plane: {
+            height: readFiniteNumber(plane.height, 0),
+            yOffset: readNonNegativeNumber(plane.yOffset ?? legacyBlobSettings.yOffset, 0.08),
+        },
+        appearance: {
+            color: readRgba(appearance.color, colorFallback),
+            edgeSoftness: readClampedNumber(appearance.edgeSoftness, 0.55, 0, 0.98),
+        },
+        size: {
+            sizeMultiplier: readNonNegativeNumber(size.sizeMultiplier ?? legacyBlobSettings.sizeMultiplier, 1.25),
+            minSize: readNonNegativeNumber(size.minSize ?? legacyBlobSettings.minSize, 0.25),
+            maxSize: readPositiveNumber(size.maxSize, 20),
+        },
+    };
+}
+function normalizeEditorSceneRenderingGroupsProfile(value) {
+    const root = readRecord(value);
+    const rawSlots = Array.isArray(root.slots) ? root.slots : [];
+    return {
+        slots: EDITOR_SCENE_DEFAULT_RENDERING_GROUPS.map((defaultSlot) => {
+            const rawSlot = rawSlots.find((entry) => (readRenderingGroupId(readRecord(entry).renderingGroupId) === defaultSlot.renderingGroupId));
+            const slot = readRecord(rawSlot);
+            return {
+                renderingGroupId: defaultSlot.renderingGroupId,
+                name: readNonEmptyString(slot.name, defaultSlot.name),
+                alphaIndexPresets: normalizeEditorSceneRenderingAlphaIndexPresets(slot.alphaIndexPresets, defaultSlot.alphaIndexPresets),
+            };
+        }),
+    };
+}
+function normalizeEditorSceneRenderingAlphaIndexPresets(value, fallback) {
+    const source = Array.isArray(value) ? value : fallback;
+    const seen = new Set();
+    const presets = [];
+    source.forEach((entry, index) => {
+        const record = readRecord(entry);
+        const alphaIndex = readFiniteNumber(record.alphaIndex, Number.NaN);
+        if (!Number.isFinite(alphaIndex) || seen.has(alphaIndex))
+            return;
+        seen.add(alphaIndex);
+        presets.push({
+            name: readNonEmptyString(record.name, `Order ${index + 1}`),
+            alphaIndex,
+        });
+    });
+    return presets;
 }
 function normalizeEditorScenePlanarShadowProfile(value) {
     const planar = readRecord(value);
@@ -229,6 +495,35 @@ function normalizeEditorScenePlanarShadowProfile(value) {
         },
     };
 }
+function normalizeEditorSceneStaticProjectedShadowProfile(value) {
+    const staticProjected = readRecord(value);
+    const plane = readRecord(staticProjected.plane);
+    const appearance = readRecord(staticProjected.appearance);
+    const bake = readRecord(staticProjected.bake);
+    const spatialChunkSize = readPositiveNumber(bake.spatialChunkSize ?? bake.maxSize, 16);
+    return {
+        enabled: readBoolean(staticProjected.enabled, false),
+        plane: {
+            height: readFiniteNumber(plane.height, 0),
+            yOffset: readNonNegativeNumber(plane.yOffset, 0.08),
+        },
+        appearance: {
+            color: readRgba(appearance.color, { r: 0, g: 0, b: 0, a: 0.35 }),
+        },
+        bake: {
+            resolution: readPositiveNumber(bake.resolution, 2048),
+            padding: readNonNegativeNumber(bake.padding, 0.15),
+            blur: readNonNegativeNumber(bake.blur, 0),
+            maxSize: spatialChunkSize,
+            texelsPerMeter: readPositiveNumber(bake.texelsPerMeter, 256),
+            atlasSize: readPositiveNumber(bake.atlasSize, 4096),
+            maxAtlasPages: readPositiveNumber(bake.maxAtlasPages, 8),
+            sdfRadiusPx: readNonNegativeNumber(bake.sdfRadiusPx, 8),
+            spatialChunkSize,
+            targetChunkCount: readPositiveNumber(bake.targetChunkCount, 64),
+        },
+    };
+}
 function normalizeEditorSceneEnvironmentProfile(globalVolumeValue) {
     const globalVolume = readRecord(globalVolumeValue);
     const environment = readRecord(globalVolume.environment);
@@ -249,6 +544,27 @@ function normalizeEditorSceneEnvironmentProfile(globalVolumeValue) {
     };
 }
 function applyAllowedRenderingPatch(draft, path, value) {
+    const groupNamePatch = parseEditorSceneRenderingGroupNamePatchPath(path);
+    if (groupNamePatch) {
+        const slot = ensureRenderingGroupSlot(draft, groupNamePatch.renderingGroupId);
+        slot.name = readNonEmptyString(value, slot.name);
+        return;
+    }
+    const alphaPresetPatch = parseEditorSceneRenderingAlphaPresetPatchPath(path);
+    if (alphaPresetPatch) {
+        const slot = ensureRenderingGroupSlot(draft, alphaPresetPatch.renderingGroupId);
+        const preset = slot.alphaIndexPresets[alphaPresetPatch.presetIndex];
+        if (!preset)
+            return;
+        if (alphaPresetPatch.field === 'name') {
+            preset.name = readNonEmptyString(value, preset.name);
+        }
+        else {
+            preset.alphaIndex = readFiniteNumber(value, preset.alphaIndex);
+            slot.alphaIndexPresets = normalizeEditorSceneRenderingAlphaIndexPresets(slot.alphaIndexPresets, []);
+        }
+        return;
+    }
     const globalVolume = ensureObject(draft, 'globalVolume');
     if (path === 'globalVolume.enabled') {
         globalVolume.enabled = value === true;
@@ -345,7 +661,142 @@ function applyAllowedRenderingPatch(draft, path, value) {
         ensureObject(ensureObject(globalVolume, 'postProcessing'), 'bloom').scale = readPositiveNumber(value, 0.5);
         return;
     }
-    const planar = ensureObject(ensureObject(draft, 'shadows'), 'planar');
+    const shadows = ensureObject(draft, 'shadows');
+    if (path === 'shadows.defaultMode') {
+        shadows.defaultMode = readResolvedShadowMode(value, 'none');
+        return;
+    }
+    const blob = ensureObject(shadows, 'blob');
+    if (path === 'shadows.blob.enabled') {
+        blob.enabled = value === true;
+        return;
+    }
+    if (path === 'shadows.blob.appearance.color') {
+        const appearance = ensureObject(blob, 'appearance');
+        const current = readRgba(readRecord(appearance.color), { r: 0, g: 0, b: 0, a: 0.35 });
+        const next = readRecord(value);
+        appearance.color = {
+            r: readClampedNumber(next.r, current.r, 0, 1),
+            g: readClampedNumber(next.g, current.g, 0, 1),
+            b: readClampedNumber(next.b, current.b, 0, 1),
+            a: readClampedNumber(next.a, current.a, 0, 1),
+        };
+        return;
+    }
+    if (path === 'shadows.blob.appearance.color.a') {
+        const appearance = ensureObject(blob, 'appearance');
+        const current = readRgba(readRecord(appearance.color), { r: 0, g: 0, b: 0, a: 0.35 });
+        appearance.color = {
+            ...current,
+            a: readClampedNumber(value, current.a, 0, 1),
+        };
+        return;
+    }
+    if (path === 'shadows.blob.appearance.edgeSoftness') {
+        ensureObject(blob, 'appearance').edgeSoftness = readClampedNumber(value, 0.55, 0, 0.98);
+        return;
+    }
+    if (path === 'shadows.blob.plane.height') {
+        ensureObject(blob, 'plane').height = readFiniteNumber(value, 0);
+        return;
+    }
+    if (path === 'shadows.blob.plane.yOffset') {
+        ensureObject(blob, 'plane').yOffset = readNonNegativeNumber(value, 0.08);
+        return;
+    }
+    if (path === 'shadows.blob.size.sizeMultiplier') {
+        ensureObject(blob, 'size').sizeMultiplier = readNonNegativeNumber(value, 1.25);
+        return;
+    }
+    if (path === 'shadows.blob.size.minSize') {
+        ensureObject(blob, 'size').minSize = readNonNegativeNumber(value, 0.25);
+        return;
+    }
+    if (path === 'shadows.blob.size.maxSize') {
+        ensureObject(blob, 'size').maxSize = readPositiveNumber(value, 20);
+        return;
+    }
+    const staticProjected = ensureObject(shadows, 'staticProjected');
+    if (path === 'shadows.staticProjected.enabled') {
+        staticProjected.enabled = value === true;
+        return;
+    }
+    if (path === 'shadows.staticProjected.appearance.color') {
+        const appearance = ensureObject(staticProjected, 'appearance');
+        const current = readRgba(readRecord(appearance.color), { r: 0, g: 0, b: 0, a: 0.35 });
+        const next = readRecord(value);
+        appearance.color = {
+            r: readClampedNumber(next.r, current.r, 0, 1),
+            g: readClampedNumber(next.g, current.g, 0, 1),
+            b: readClampedNumber(next.b, current.b, 0, 1),
+            a: readClampedNumber(next.a, current.a, 0, 1),
+        };
+        return;
+    }
+    if (path === 'shadows.staticProjected.appearance.color.a') {
+        const appearance = ensureObject(staticProjected, 'appearance');
+        const current = readRgba(readRecord(appearance.color), { r: 0, g: 0, b: 0, a: 0.35 });
+        appearance.color = {
+            ...current,
+            a: readClampedNumber(value, current.a, 0, 1),
+        };
+        return;
+    }
+    if (path === 'shadows.staticProjected.plane.height') {
+        ensureObject(staticProjected, 'plane').height = readFiniteNumber(value, 0);
+        return;
+    }
+    if (path === 'shadows.staticProjected.plane.yOffset') {
+        ensureObject(staticProjected, 'plane').yOffset = readNonNegativeNumber(value, 0.08);
+        return;
+    }
+    if (path === 'shadows.staticProjected.bake.resolution') {
+        ensureObject(staticProjected, 'bake').resolution = readPositiveNumber(value, 2048);
+        return;
+    }
+    if (path === 'shadows.staticProjected.bake.padding') {
+        ensureObject(staticProjected, 'bake').padding = readNonNegativeNumber(value, 0.15);
+        return;
+    }
+    if (path === 'shadows.staticProjected.bake.blur') {
+        ensureObject(staticProjected, 'bake').blur = readNonNegativeNumber(value, 0);
+        return;
+    }
+    if (path === 'shadows.staticProjected.bake.maxSize') {
+        const bake = ensureObject(staticProjected, 'bake');
+        const spatialChunkSize = readPositiveNumber(value, 16);
+        bake.maxSize = spatialChunkSize;
+        bake.spatialChunkSize = spatialChunkSize;
+        return;
+    }
+    if (path === 'shadows.staticProjected.bake.texelsPerMeter') {
+        ensureObject(staticProjected, 'bake').texelsPerMeter = readPositiveNumber(value, 256);
+        return;
+    }
+    if (path === 'shadows.staticProjected.bake.atlasSize') {
+        ensureObject(staticProjected, 'bake').atlasSize = readPositiveNumber(value, 4096);
+        return;
+    }
+    if (path === 'shadows.staticProjected.bake.maxAtlasPages') {
+        ensureObject(staticProjected, 'bake').maxAtlasPages = readPositiveNumber(value, 8);
+        return;
+    }
+    if (path === 'shadows.staticProjected.bake.sdfRadiusPx') {
+        ensureObject(staticProjected, 'bake').sdfRadiusPx = readNonNegativeNumber(value, 8);
+        return;
+    }
+    if (path === 'shadows.staticProjected.bake.spatialChunkSize') {
+        const bake = ensureObject(staticProjected, 'bake');
+        const spatialChunkSize = readPositiveNumber(value, 16);
+        bake.spatialChunkSize = spatialChunkSize;
+        bake.maxSize = spatialChunkSize;
+        return;
+    }
+    if (path === 'shadows.staticProjected.bake.targetChunkCount') {
+        ensureObject(staticProjected, 'bake').targetChunkCount = readPositiveNumber(value, 64);
+        return;
+    }
+    const planar = ensureObject(shadows, 'planar');
     if (path === 'shadows.planar.enabled') {
         planar.enabled = value === true;
         return;
@@ -443,6 +894,54 @@ function ensureObject(target, key) {
     }
     return current;
 }
+function ensureRenderingGroupsProfileDraft(target) {
+    const normalized = normalizeEditorSceneRenderingGroupsProfile(target.renderingGroups);
+    const draft = JSON.parse(JSON.stringify(normalized));
+    target.renderingGroups = draft;
+    return draft;
+}
+function ensureRenderingGroupSlot(target, renderingGroupId) {
+    const renderingGroups = ensureRenderingGroupsProfileDraft(target);
+    return renderingGroups.slots.find((slot) => slot.renderingGroupId === renderingGroupId)
+        ?? renderingGroups.slots[renderingGroupId];
+}
+function appendEditorSceneRenderingAlphaPreset(target, renderingGroupId) {
+    const slot = ensureRenderingGroupSlot(target, renderingGroupId);
+    let alphaIndex = slot.alphaIndexPresets.length > 0
+        ? Math.max(...slot.alphaIndexPresets.map(preset => preset.alphaIndex)) + 100
+        : 0;
+    const used = new Set(slot.alphaIndexPresets.map(preset => preset.alphaIndex));
+    while (used.has(alphaIndex))
+        alphaIndex += 100;
+    slot.alphaIndexPresets.push({
+        name: `新顺序 ${slot.alphaIndexPresets.length + 1}`,
+        alphaIndex,
+    });
+    return slot.alphaIndexPresets.length - 1;
+}
+function removeEditorSceneRenderingAlphaPreset(target, renderingGroupId, presetIndex) {
+    const slot = ensureRenderingGroupSlot(target, renderingGroupId);
+    if (presetIndex < 0 || presetIndex >= slot.alphaIndexPresets.length)
+        return false;
+    slot.alphaIndexPresets.splice(presetIndex, 1);
+    return true;
+}
+function parseEditorSceneRenderingGroupNamePatchPath(path) {
+    const match = path.match(/^renderingGroups\.slots\.(0|1|2|3)\.name$/);
+    if (!match)
+        return null;
+    return { renderingGroupId: Number(match[1]) };
+}
+function parseEditorSceneRenderingAlphaPresetPatchPath(path) {
+    const match = path.match(/^renderingGroups\.slots\.(0|1|2|3)\.alphaIndexPresets\.(\d+)\.(name|alphaIndex)$/);
+    if (!match)
+        return null;
+    return {
+        renderingGroupId: Number(match[1]),
+        presetIndex: Number(match[2]),
+        field: match[3],
+    };
+}
 function readRecord(value) {
     return value && typeof value === 'object' && !Array.isArray(value)
         ? value
@@ -482,9 +981,20 @@ function readStringOrNull(value) {
     const text = typeof value === 'string' ? value.trim() : '';
     return text || null;
 }
+function readNonEmptyString(value, fallback) {
+    const text = typeof value === 'string' ? value.trim() : '';
+    return text || fallback;
+}
 function readBoolean(value, fallback) {
     return typeof value === 'boolean' ? value : fallback;
 }
+function readRenderingGroupId(value) {
+    return value === 0 || value === 1 || value === 2 || value === 3 ? value : null;
+}
+function readPresetIndex(value) {
+    const index = typeof value === 'number' && Number.isInteger(value) ? value : null;
+    return index != null && index >= 0 ? index : null;
+}
 function readToneMappingType(value, fallback) {
     return value === 'standard' || value === 'aces' || value === 'khr-pbr-neutral' ? value : fallback;
 }
@@ -494,6 +1004,11 @@ function readSamples(value, fallback) {
 function readPlaneHeightMode(value, fallback) {
     return value === 'fixed' || value === 'receiver' ? value : fallback;
 }
+function readResolvedShadowMode(value, fallback) {
+    return value === 'none' || value === 'blob' || value === 'static' || value === 'planar' || value === 'dynamic'
+        ? value
+        : fallback;
+}
 function readFiniteNumber(value, fallback) {
     return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
 }