@fps-games/editor 0.1.8 → 0.2.0-beta.2

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

@@ -1,1027 +0,0 @@
-export const EDITOR_SCENE_DEFAULT_PLANAR_SHADOW_RECEIVER_PATTERNS = [
-    'ground',
-    'Ground',
-    'plane',
-    'Plane',
-    '地面',
-    '地块',
-    '地台',
-];
-export const EDITOR_SCENE_DEFAULT_PLANAR_SHADOW_EXCLUDE_PATTERNS = [
-    'editor',
-    'grid',
-    'gizmo',
-    'helper',
-    'camera',
-    'light',
-    'decal',
-    'texture',
-    'trigger',
-    'collision',
-    'ui',
-    '_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',
-    'globalVolume.environment.texture.textureAssetId',
-    'globalVolume.environment.texture.url',
-    'globalVolume.environment.textureUrl',
-    'globalVolume.environment.iblIntensity',
-    'globalVolume.environment.rotationY',
-    'globalVolume.imageProcessing.exposure',
-    'globalVolume.imageProcessing.contrast',
-    'globalVolume.toneMapping.enabled',
-    'globalVolume.toneMapping.type',
-    'globalVolume.antialiasing.samples',
-    'globalVolume.postProcessing.bloom.enabled',
-    'globalVolume.postProcessing.bloom.threshold',
-    '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',
-    'shadows.planar.plane.height',
-    'shadows.planar.plane.bias',
-    'shadows.planar.projection.footprintScale',
-    'shadows.planar.stencil.enabled',
-    'shadows.planar.casters.excludePatterns',
-    '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: normalizedBlob.enabled,
-            settings: {
-                mapSize: readNonNegativeNumber(settings.mapSize, 1024),
-                darkness: readNonNegativeNumber(settings.darkness, 0.3),
-                blurKernel: readNonNegativeNumber(settings.blurKernel, 16),
-                bias: readNonNegativeNumber(settings.bias, 0.00005),
-                normalBias: readNonNegativeNumber(settings.normalBias, 0.02),
-                useBlurExponentialShadowMap: readBoolean(settings.useBlurExponentialShadowMap, true),
-                shadowMinZ: readNonNegativeNumber(settings.shadowMinZ, 1),
-                shadowMaxZ: readNonNegativeNumber(settings.shadowMaxZ, 60),
-                shadowColor: readRgb(settings.shadowColor, { r: 0, g: 0, b: 0 }),
-            },
-            blobSettings: {
-                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),
-            },
-            shadowOrtho: {
-                left: readFiniteNumber(shadowOrtho.left, -20),
-                right: readFiniteNumber(shadowOrtho.right, 20),
-                top: readFiniteNumber(shadowOrtho.top, 20),
-                bottom: readFiniteNumber(shadowOrtho.bottom, -20),
-            },
-            csm: {
-                numCascades: readNonNegativeNumber(csm.numCascades, 2),
-                lambda: readClampedNumber(csm.lambda, 0.5, 0, 1),
-                cascadeBlendPercentage: readClampedNumber(csm.cascadeBlendPercentage, 0.1, 0, 1),
-                stabilizeCascades: readBoolean(csm.stabilizeCascades, true),
-            },
-            planar: normalizeEditorScenePlanarShadowProfile(shadows.planar),
-        },
-        shadowMeshes: {
-            shadowReceivers: readStringList(shadowMeshes.shadowReceivers),
-            shadowCasters: readStringList(shadowMeshes.shadowCasters),
-            excludeFromShadow: readStringList(shadowMeshes.excludeFromShadow),
-        },
-    };
-}
-export function createEditorScenePlanarShadowPreviewSettings(profile, input = {}) {
-    const planar = profile.shadows.planar;
-    return {
-        enabled: planar.enabled && (input.enabled ?? true),
-        plane: {
-            normal: planar.plane.normal,
-            height: planar.plane.height,
-            heightMode: planar.plane.heightMode,
-            bias: planar.plane.bias,
-        },
-        appearance: {
-            color: planar.appearance.color,
-        },
-        projection: {
-            footprintScale: planar.projection.footprintScale,
-        },
-        direction: { mode: 'follow-light' },
-        stencil: {
-            enabled: planar.stencil.enabled,
-            receiverRenderingGroup: planar.stencil.receiverRenderingGroup,
-            shadowRenderingGroup: planar.stencil.shadowRenderingGroup,
-        },
-        casters: {
-            autoDetectAll: input.autoDetectAllCasters ?? planar.casters.autoDetectAll,
-            includePatterns: [
-                ...(input.additionalCasterIncludePatterns ?? []),
-                ...planar.casters.includePatterns,
-            ],
-            excludePatterns: [
-                ...EDITOR_SCENE_DEFAULT_PLANAR_SHADOW_EXCLUDE_PATTERNS,
-                ...(input.additionalExcludePatterns ?? []),
-                ...planar.casters.excludePatterns,
-            ],
-            rootBoundaryPatterns: [
-                ...(input.additionalRootBoundaryPatterns ?? []),
-                ...planar.casters.rootBoundaryPatterns,
-            ],
-            minVolume: planar.casters.minVolume,
-        },
-        receivers: {
-            patterns: [
-                ...EDITOR_SCENE_DEFAULT_PLANAR_SHADOW_RECEIVER_PATTERNS,
-                ...(input.additionalReceiverPatterns ?? []),
-                ...planar.receivers.patterns,
-            ],
-        },
-    };
-}
-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 = [];
-    for (const [path, value] of Object.entries(changes)) {
-        if (!isEditorSceneRenderingProfilePatchPath(path))
-            continue;
-        applyAllowedRenderingPatch(draft, path, value);
-        changedPaths.push(path);
-    }
-    return {
-        config: draft,
-        changedPaths,
-        normalized: normalizeEditorSceneRenderingProfile(draft),
-    };
-}
-export function summarizeEditorSceneRenderingProfile(value) {
-    return {
-        environmentTextureAssetId: value?.environment?.texture?.textureAssetId ?? null,
-        environmentTextureUrl: value?.environment?.texture?.url ?? null,
-        environmentIblIntensity: value?.environment?.iblIntensity ?? null,
-        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,
-        planeBias: value?.shadows?.planar?.plane?.bias ?? null,
-        stencilEnabled: value?.shadows?.planar?.stencil?.enabled ?? null,
-    };
-}
-export function isEditorSceneRenderingProfilePatchPath(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);
-    const plane = readRecord(planar.plane);
-    const appearance = readRecord(planar.appearance);
-    const projection = readRecord(planar.projection);
-    const stencil = readRecord(planar.stencil);
-    const casters = readRecord(planar.casters);
-    const receivers = readRecord(planar.receivers);
-    return {
-        enabled: readBoolean(planar.enabled, true),
-        plane: {
-            normal: readVec3(plane.normal, { x: 0, y: 1, z: 0 }),
-            height: readFiniteNumber(plane.height, 0),
-            heightMode: readPlaneHeightMode(plane.heightMode, 'receiver'),
-            bias: readNonNegativeNumber(plane.bias, 0.4),
-        },
-        appearance: {
-            color: readRgba(appearance.color, { r: 0, g: 0, b: 0, a: 0.35 }),
-        },
-        projection: {
-            footprintScale: readClampedNumber(projection.footprintScale, 1, 0, 2),
-        },
-        stencil: {
-            enabled: readBoolean(stencil.enabled, true),
-            receiverRenderingGroup: readNonNegativeNumber(stencil.receiverRenderingGroup, 0),
-            shadowRenderingGroup: readNonNegativeNumber(stencil.shadowRenderingGroup, 1),
-        },
-        casters: {
-            autoDetectAll: readBoolean(casters.autoDetectAll, true),
-            includePatterns: readStringList(casters.includePatterns),
-            excludePatterns: readStringList(casters.excludePatterns),
-            rootBoundaryPatterns: readStringList(casters.rootBoundaryPatterns),
-            minVolume: readNonNegativeNumber(casters.minVolume, 0.001),
-        },
-        receivers: {
-            patterns: readStringList(receivers.patterns),
-        },
-    };
-}
-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);
-    const texture = readRecord(environment.texture);
-    const textureAssetId = readStringOrNull(texture.textureAssetId)
-        ?? readStringOrNull(environment.textureAssetId);
-    const textureUrl = readStringOrNull(texture.url)
-        ?? readStringOrNull(environment.textureUrl);
-    return {
-        texture: textureAssetId || textureUrl
-            ? {
-                ...(textureAssetId ? { textureAssetId } : {}),
-                ...(textureUrl ? { url: textureUrl } : {}),
-            }
-            : null,
-        iblIntensity: readNonNegativeNumber(environment.iblIntensity ?? environment.intensity, 1),
-        rotationY: readFiniteNumber(environment.rotationY, 0),
-    };
-}
-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;
-        return;
-    }
-    if (path === 'globalVolume.hdr') {
-        globalVolume.hdr = value === true;
-        return;
-    }
-    if (path === 'globalVolume.environment.texture.textureAssetId') {
-        const textureAssetId = typeof value === 'string' ? value.trim() : '';
-        const environment = ensureObject(globalVolume, 'environment');
-        if (!textureAssetId) {
-            environment.texture = null;
-            delete environment.textureAssetId;
-            delete environment.textureUrl;
-            return;
-        }
-        const texture = ensureObject(environment, 'texture');
-        texture.textureAssetId = textureAssetId;
-        delete texture.url;
-        delete environment.textureUrl;
-        delete environment.textureAssetId;
-        return;
-    }
-    if (path === 'globalVolume.environment.texture.url') {
-        const textureUrl = typeof value === 'string' ? value.trim() : '';
-        const environment = ensureObject(globalVolume, 'environment');
-        if (!textureUrl) {
-            environment.texture = null;
-            delete environment.textureUrl;
-            delete environment.textureAssetId;
-            return;
-        }
-        const texture = ensureObject(environment, 'texture');
-        texture.url = textureUrl;
-        delete texture.textureAssetId;
-        delete environment.textureUrl;
-        return;
-    }
-    if (path === 'globalVolume.environment.textureUrl') {
-        const textureUrl = typeof value === 'string' ? value.trim() : '';
-        const environment = ensureObject(globalVolume, 'environment');
-        environment.textureUrl = textureUrl || null;
-        environment.texture = textureUrl ? { url: textureUrl } : null;
-        delete environment.textureAssetId;
-        return;
-    }
-    if (path === 'globalVolume.environment.iblIntensity') {
-        ensureObject(globalVolume, 'environment').iblIntensity = readNonNegativeNumber(value, 1);
-        return;
-    }
-    if (path === 'globalVolume.environment.rotationY') {
-        ensureObject(globalVolume, 'environment').rotationY = readFiniteNumber(value, 0);
-        return;
-    }
-    if (path === 'globalVolume.imageProcessing.exposure') {
-        ensureObject(globalVolume, 'imageProcessing').exposure = readFiniteNumber(value, 1);
-        return;
-    }
-    if (path === 'globalVolume.imageProcessing.contrast') {
-        ensureObject(globalVolume, 'imageProcessing').contrast = readFiniteNumber(value, 1);
-        return;
-    }
-    if (path === 'globalVolume.toneMapping.enabled') {
-        ensureObject(globalVolume, 'toneMapping').enabled = value === true;
-        return;
-    }
-    if (path === 'globalVolume.toneMapping.type') {
-        ensureObject(globalVolume, 'toneMapping').type = readToneMappingType(value, 'aces');
-        return;
-    }
-    if (path === 'globalVolume.antialiasing.samples') {
-        ensureObject(globalVolume, 'antialiasing').samples = readSamples(value, 4);
-        return;
-    }
-    if (path === 'globalVolume.postProcessing.bloom.enabled') {
-        ensureObject(ensureObject(globalVolume, 'postProcessing'), 'bloom').enabled = value === true;
-        return;
-    }
-    if (path === 'globalVolume.postProcessing.bloom.threshold') {
-        ensureObject(ensureObject(globalVolume, 'postProcessing'), 'bloom').threshold = readNonNegativeNumber(value, 0.9);
-        return;
-    }
-    if (path === 'globalVolume.postProcessing.bloom.weight') {
-        ensureObject(ensureObject(globalVolume, 'postProcessing'), 'bloom').weight = readNonNegativeNumber(value, 0.2);
-        return;
-    }
-    if (path === 'globalVolume.postProcessing.bloom.kernel') {
-        ensureObject(ensureObject(globalVolume, 'postProcessing'), 'bloom').kernel = readNonNegativeNumber(value, 64);
-        return;
-    }
-    if (path === 'globalVolume.postProcessing.bloom.scale') {
-        ensureObject(ensureObject(globalVolume, 'postProcessing'), 'bloom').scale = readPositiveNumber(value, 0.5);
-        return;
-    }
-    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;
-    }
-    if (path === 'shadows.planar.appearance.color') {
-        const appearance = ensureObject(planar, '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.planar.appearance.color.a') {
-        const appearance = ensureObject(planar, '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.planar.plane.height') {
-        ensureObject(planar, 'plane').height = readFiniteNumber(value, 0);
-        return;
-    }
-    if (path === 'shadows.planar.plane.bias') {
-        ensureObject(planar, 'plane').bias = readNonNegativeNumber(value, 0.4);
-        return;
-    }
-    if (path === 'shadows.planar.projection.footprintScale') {
-        ensureObject(planar, 'projection').footprintScale = readClampedNumber(value, 1, 0, 2);
-        return;
-    }
-    if (path === 'shadows.planar.stencil.enabled') {
-        ensureObject(planar, 'stencil').enabled = value === true;
-        return;
-    }
-    if (path === 'shadows.planar.casters.excludePatterns') {
-        ensureObject(planar, 'casters').excludePatterns = readStringList(value);
-        return;
-    }
-    if (path === 'shadows.planar.casters.rootBoundaryPatterns') {
-        ensureObject(planar, 'casters').rootBoundaryPatterns = readStringList(value);
-        return;
-    }
-    if (path === 'shadows.planar.receivers.patterns') {
-        ensureObject(planar, 'receivers').patterns = readStringList(value);
-    }
-}
-function normalizeEditorScenePostProcessProfile(value) {
-    const globalVolume = readRecord(value);
-    const imageProcessing = readRecord(globalVolume.imageProcessing);
-    const toneMapping = readRecord(globalVolume.toneMapping);
-    const antialiasing = readRecord(globalVolume.antialiasing);
-    const postProcessing = readRecord(globalVolume.postProcessing);
-    const bloom = readRecord(postProcessing.bloom);
-    return {
-        enabled: readBoolean(globalVolume.enabled, true),
-        hdr: readBoolean(globalVolume.hdr, true),
-        imageProcessing: {
-            exposure: readFiniteNumber(imageProcessing.exposure, 1),
-            contrast: readFiniteNumber(imageProcessing.contrast, 1),
-        },
-        toneMapping: {
-            enabled: readBoolean(toneMapping.enabled, true),
-            type: readToneMappingType(toneMapping.type, 'aces'),
-        },
-        antialiasing: {
-            samples: readSamples(antialiasing.samples ?? globalVolume.samples, 4),
-        },
-        bloom: {
-            enabled: readBoolean(bloom.enabled, false),
-            threshold: readNonNegativeNumber(bloom.threshold, 0.9),
-            weight: readNonNegativeNumber(bloom.weight, 0.2),
-            kernel: readNonNegativeNumber(bloom.kernel, 64),
-            scale: readPositiveNumber(bloom.scale, 0.5),
-        },
-    };
-}
-function cloneRecord(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return {};
-    return JSON.parse(JSON.stringify(value));
-}
-function ensureObject(target, key) {
-    const current = target[key];
-    if (!current || typeof current !== 'object' || Array.isArray(current)) {
-        const next = {};
-        target[key] = next;
-        return next;
-    }
-    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
-        : {};
-}
-function readVec3(value, fallback) {
-    const record = readRecord(value);
-    return {
-        x: readFiniteNumber(record.x, fallback.x),
-        y: readFiniteNumber(record.y, fallback.y),
-        z: readFiniteNumber(record.z, fallback.z),
-    };
-}
-function readRgb(value, fallback) {
-    const record = readRecord(value);
-    return {
-        r: readClampedNumber(record.r, fallback.r, 0, 1),
-        g: readClampedNumber(record.g, fallback.g, 0, 1),
-        b: readClampedNumber(record.b, fallback.b, 0, 1),
-    };
-}
-function readRgba(value, fallback) {
-    const record = readRecord(value);
-    return {
-        ...readRgb(record, fallback),
-        a: readClampedNumber(record.a, fallback.a, 0, 1),
-    };
-}
-function readStringList(value) {
-    return Array.isArray(value)
-        ? value
-            .map(entry => typeof entry === 'string' ? entry.trim() : '')
-            .filter((entry, index, list) => entry.length > 0 && list.indexOf(entry) === index)
-        : [];
-}
-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;
-}
-function readSamples(value, fallback) {
-    return value === 1 || value === 2 || value === 4 || value === 8 ? 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;
-}
-function readNonNegativeNumber(value, fallback) {
-    const resolved = readFiniteNumber(value, fallback);
-    return Math.max(0, resolved);
-}
-function readPositiveNumber(value, fallback) {
-    const resolved = readFiniteNumber(value, fallback);
-    return resolved > 0 ? resolved : fallback;
-}
-function readClampedNumber(value, fallback, min, max) {
-    const resolved = readFiniteNumber(value, fallback);
-    return Math.min(max, Math.max(min, resolved));
-}
-//# sourceMappingURL=profile.js.map