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

package/node_modules/@fps-games/editor-playable-sdk/dist/scene-compiler/compiler.js

@@ -1,10 +1,18 @@
-import { findEditorSceneModelRenderer, findEditorSceneTransform, isEditorScenePrefabAsset, mergeEditorSceneMaterialBindingOverrides, mergeEditorScenePrefabOverrides, readEditorSceneNodeKind, readEditorScenePrefabNodes, readEditorScenePrefabRootNodeId, resolveEditorSceneGameObjectRendering, resolveEditorScenePrefabInstanceRelation, } from '../document/index.js';
-import { resolveEditorSceneMaterialAssetIntegrity, resolveEditorSceneMaterialSlotReimportDiff, } from '../material-binding/index.js';
-import { mergeEditorShadowSettings, readEditorShadowSettingsWithLegacy, resolveEditorShadowPlan, } from '../shadow-system/index.js';
+import { findEditorSceneModelRenderer, findEditorSceneTransform, EDITOR_SCENE_PREFAB_COMPOSITION_VERSION, isEditorScenePrefabAsset, mergeEditorSceneMaterialBindingOverrides, mergeEditorScenePrefabOverrides, readEditorSceneNodeKind, readEditorScenePrefabNodes, readEditorScenePrefabRootNodeId, resolveEditorSceneGameObjectRendering, resolveEditorScenePrefabInstanceRelation, } from '../document/index.js';
+import { resolveEditorSceneMaterialAssetIntegrity, } from '../material-binding/index.js';
+import { resolveEditorShadowPlan, } from '../shadow-system/index.js';
+import { mergeEditorShadowSettings, readEditorShadowSettingsResult, } from '@fps-games/playable-rendering';
 import { getEditorSceneAuthoringSourceRef, } from '../authoring/index.js';
+import { assertPlayableEditorSceneDocumentContract } from './validation.js';
+import { assertEditorSceneStaticShadowArtifactContract } from '../static-shadows/index.js';
 export const PLAYABLE_EDITOR_SCENE_COMPILER_ID = '@fps-games/editor.playable-sdk.scene-compiler';
-export const PLAYABLE_EDITOR_SCENE_COMPILER_VERSION = '1';
-export function compileEditorSceneDocumentToSceneConfig(editorDocument, baseSceneConfig) {
+export const PLAYABLE_EDITOR_SCENE_COMPILER_VERSION = '2';
+export function compileEditorSceneDocumentToSceneConfig(editorDocument, baseSceneConfig, options = {}) {
+    assertPlayableEditorSceneDocumentContract(editorDocument);
+    const baseSceneRecord = baseSceneConfig;
+    if (Object.prototype.hasOwnProperty.call(baseSceneRecord, 'staticShadows') && baseSceneRecord.staticShadows != null) {
+        assertEditorSceneStaticShadowArtifactContract(baseSceneRecord.staticShadows, '$.staticShadows');
+    }
     const nextSceneConfig = structuredClone(baseSceneConfig);
     const previousScene = isRecord(nextSceneConfig.scene)
         ? nextSceneConfig.scene
@@ -16,7 +24,7 @@ export function compileEditorSceneDocumentToSceneConfig(editorDocument, baseScen
         compilerVersion: PLAYABLE_EDITOR_SCENE_COMPILER_VERSION,
         compiledAt: new Date().toISOString(),
     };
-    nextSceneConfig.schemaVersion = 2;
+    nextSceneConfig.schemaVersion = 3;
     nextSceneConfig.meta = {
         ...(nextSceneConfig.meta ?? {}),
         generatedFrom,
@@ -24,7 +32,7 @@ export function compileEditorSceneDocumentToSceneConfig(editorDocument, baseScen
     const rootId = previousScene?.rootId || 'root';
     const compiledGameObjects = editorDocument.scene.gameObjects
         .filter((gameObject) => gameObject.id !== rootId);
-    const materialAssets = resolveCompiledEditorSceneMaterialAssets(editorDocument, previousScene?.materialAssets);
+    const materialAssets = resolveCompiledEditorSceneMaterialAssets(editorDocument);
     const documentWithResolvedMaterialAssets = {
         ...editorDocument,
         scene: {
@@ -32,7 +40,7 @@ export function compileEditorSceneDocumentToSceneConfig(editorDocument, baseScen
             materialAssets,
         },
     };
-    const compiledNodes = compiledGameObjects.flatMap(gameObject => compileGameObjectToRuntimeNodes(gameObject, sourceRef, documentWithResolvedMaterialAssets));
+    const compiledNodes = compiledGameObjects.flatMap(gameObject => compileGameObjectToRuntimeNodes(gameObject, sourceRef, documentWithResolvedMaterialAssets, options));
     const compiledScene = {
         rootId,
         assets: documentWithResolvedMaterialAssets.assets
@@ -53,21 +61,11 @@ export function compileEditorSceneDocumentToSceneConfig(editorDocument, baseScen
         },
     };
 }
-function resolveCompiledEditorSceneMaterialAssets(editorDocument, previousMaterialAssets) {
-    const materialAssets = editorDocument.scene.materialAssets
-        ? structuredClone(editorDocument.scene.materialAssets)
-        : (previousMaterialAssets ?? []).map(materialAsset => structuredClone(materialAsset));
-    const materialAssetIds = new Set(materialAssets.map(materialAsset => materialAsset.id));
-    const previousMaterialAssetById = new Map((previousMaterialAssets ?? []).map(materialAsset => [materialAsset.id, materialAsset]));
+function resolveCompiledEditorSceneMaterialAssets(editorDocument) {
+    const materialAssets = structuredClone(editorDocument.scene.materialAssets ?? []);
     const integrity = resolveEditorSceneMaterialAssetIntegrity(createEditorSceneCompilerMaterialIntegrityDocument(editorDocument, materialAssets));
-    for (const materialAssetId of integrity.missingMaterialAssetIds) {
-        if (materialAssetIds.has(materialAssetId))
-            continue;
-        const previousMaterialAsset = previousMaterialAssetById.get(materialAssetId);
-        if (!previousMaterialAsset)
-            continue;
-        materialAssetIds.add(materialAssetId);
-        materialAssets.push(structuredClone(previousMaterialAsset));
+    if (!integrity.ok) {
+        throw new Error(`editor_scene_material_assets_missing: ${integrity.missingMaterialAssetIds.join(', ')}`);
     }
     return materialAssets;
 }
@@ -144,14 +142,6 @@ function createEditorSceneCompilerPrefabCompositionMaterialIntegrityGameObjects(
                 }));
                 continue;
             }
-            const legacyChildGameObject = createEditorSceneCompilerPrefabLegacyChildMaterialIntegrityGameObject({
-                editorDocument: input.editorDocument,
-                hostGameObject: input.hostGameObject,
-                node,
-                childPrefab,
-            });
-            if (legacyChildGameObject)
-                gameObjects.push(legacyChildGameObject);
             continue;
         }
         const syntheticGameObject = createEditorSceneCompilerPrefabCompositionMaterialGameObject(input.hostGameObject, node);
@@ -179,50 +169,90 @@ function createEditorSceneCompilerPrefabCompositionMaterialIntegrityGameObjects(
     input.visitedPrefabIds.delete(input.prefabAsset.id);
     return gameObjects;
 }
-function createEditorSceneCompilerPrefabLegacyChildMaterialIntegrityGameObject(input) {
-    const sourceAssetId = input.childPrefab?.prefab?.sourceAssetId;
-    if (!input.childPrefab || !sourceAssetId)
-        return null;
-    const sourceAsset = input.editorDocument.assets.find(asset => asset.id === sourceAssetId);
-    const syntheticGameObject = createEditorSceneCompilerPrefabModelGameObject(input.hostGameObject, input.node, sourceAssetId);
-    const overrides = compileEditorScenePrefabLegacyChildVisualOverrides({
-        node: input.node,
-        childPrefab: input.childPrefab,
-        sourceAsset,
-        editorDocument: input.editorDocument,
-        hostGameObject: syntheticGameObject,
-    });
-    return overrides
-        ? {
-            ...syntheticGameObject,
-            overrides,
-        }
-        : null;
-}
 function isEditorSceneModelAsset(asset) {
     return asset.type === 'glb';
 }
 function compileAsset(asset) {
+    const url = readEditorSceneRuntimeAssetUrl(asset);
+    const materialSlots = compileEditorSceneRuntimeMaterialSlots(asset);
     return {
         id: asset.id,
         type: asset.type,
         ...(asset.guid ? { guid: asset.guid } : {}),
-        ...(asset.displayName ? { displayName: asset.displayName } : {}),
-        ...(asset.category ? { category: asset.category } : {}),
+        ...(url ? { url } : {}),
+        ...(typeof asset.warmupCount === 'number' && Number.isInteger(asset.warmupCount) && asset.warmupCount >= 0
+            ? { warmupCount: asset.warmupCount }
+            : {}),
+        ...(typeof asset.singleton === 'boolean' ? { singleton: asset.singleton } : {}),
         ...(typeof asset.materialMode === 'string' ? { materialMode: asset.materialMode } : {}),
         ...(asset.defaults ? { defaults: structuredClone(asset.defaults) } : {}),
         ...(asset.external ? { external: structuredClone(asset.external) } : {}),
-        ...(asset.metadata ? { metadata: structuredClone(asset.metadata) } : {}),
+        ...(materialSlots.length > 0 ? { materialSlots } : {}),
     };
 }
-function compileGameObjectToRuntimeNodes(gameObject, sourceRef, editorDocument) {
+function readEditorSceneRuntimeAssetUrl(asset) {
+    const metadata = isRecord(asset.metadata) ? asset.metadata : undefined;
+    const external = isRecord(asset.external) ? asset.external : undefined;
+    return readNonEmptyString(metadata?.url)
+        ?? readNonEmptyString(external?.assetUrl)
+        ?? undefined;
+}
+function compileEditorSceneRuntimeMaterialSlots(asset) {
+    const metadata = isRecord(asset.metadata) ? asset.metadata : undefined;
+    const rawSlots = Array.isArray(metadata?.materialSlots) ? metadata.materialSlots : [];
+    const sourceMeshNames = readEditorSceneAssetAnalysisMeshNames(metadata?.assetAnalysis);
+    return rawSlots.flatMap((rawSlot) => {
+        if (!isRecord(rawSlot))
+            return [];
+        const slotId = readNonEmptyString(rawSlot.slotId);
+        const ownerNodePath = readNonEmptyString(rawSlot.ownerNodePath);
+        if (!slotId || !ownerNodePath)
+            return [];
+        const meshIndex = readNonNegativeInteger(rawSlot.meshIndex);
+        const primitiveIndex = readNonNegativeInteger(rawSlot.primitiveIndex);
+        const sourceMaterialIndices = readUniqueNonNegativeIntegerArray([
+            ...(Array.isArray(rawSlot.sourceMaterialIndices) ? rawSlot.sourceMaterialIndices : []),
+            rawSlot.sourceMaterialIndex,
+        ]);
+        const label = readNonEmptyString(rawSlot.label);
+        const sourceMeshName = readNonEmptyString(rawSlot.sourceMeshName)
+            ?? (meshIndex == null ? undefined : sourceMeshNames.get(meshIndex));
+        return [{
+                slotId,
+                ownerNodePath,
+                ...(label ? { label } : {}),
+                ...(meshIndex == null ? {} : { meshIndex }),
+                ...(primitiveIndex == null ? {} : { primitiveIndex }),
+                ...(sourceMaterialIndices.length > 0 ? { sourceMaterialIndices } : {}),
+                ...(sourceMeshName ? { sourceMeshName } : {}),
+            }];
+    });
+}
+function readEditorSceneAssetAnalysisMeshNames(value) {
+    const analysis = isRecord(value) ? value : undefined;
+    const meshes = Array.isArray(analysis?.meshes) ? analysis.meshes : [];
+    return new Map(meshes.flatMap((mesh) => {
+        if (!isRecord(mesh))
+            return [];
+        const meshIndex = readNonNegativeInteger(mesh.meshIndex);
+        const name = readNonEmptyString(mesh.name);
+        return meshIndex == null || !name ? [] : [[meshIndex, name]];
+    }));
+}
+function readUniqueNonNegativeIntegerArray(values) {
+    return [...new Set(values.filter((value) => (typeof value === 'number' && Number.isInteger(value) && value >= 0)))];
+}
+function readNonNegativeInteger(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 0 ? value : undefined;
+}
+function compileGameObjectToRuntimeNodes(gameObject, sourceRef, editorDocument, options) {
     const relation = resolveEditorScenePrefabInstanceRelation(editorDocument, gameObject.id);
     if (relation.definition && isExplicitEditorScenePrefabCompositionAsset(relation.definition)) {
         return compileEditorScenePrefabCompositionInstance(gameObject, relation.definition, sourceRef, editorDocument, new Set());
     }
-    return [compileGameObject(gameObject, sourceRef, editorDocument)];
+    return [compileGameObject(gameObject, sourceRef, editorDocument, options)];
 }
-function compileGameObject(gameObject, sourceRef, editorDocument) {
+function compileGameObject(gameObject, sourceRef, editorDocument, options = {}) {
     const transform = findEditorSceneTransform(gameObject);
     const modelRenderer = findEditorSceneModelRenderer(gameObject);
     const primitiveRenderer = findEditorScenePrimitiveRenderer(gameObject);
@@ -242,7 +272,6 @@ function compileGameObject(gameObject, sourceRef, editorDocument) {
         ...(gameObject.name ? { name: gameObject.name } : {}),
         ...(gameObject.parentId ? { parentId: gameObject.parentId } : {}),
         ...(gameObject.active === false ? { enabled: false } : {}),
-        ...(gameObject.shadowMode ? { shadowMode: gameObject.shadowMode } : {}),
         ...(gameObject.shadow ? { shadow: structuredClone(gameObject.shadow) } : {}),
         ...compileEditorSceneGameObjectShadowPlan(editorDocument, gameObject),
         ...(rendering ? { rendering } : {}),
@@ -281,7 +310,7 @@ function compileGameObject(gameObject, sourceRef, editorDocument) {
                         ...structuredClone(gameObject.marker),
                     },
                 } : {}),
-                ...(gameObject.groundDecal ? { groundDecal: structuredClone(gameObject.groundDecal) } : {}),
+                ...readEditorSceneCompilerCustomTransformRuntimeData(gameObject, options),
                 ...(visualOverrides ? { overrides: visualOverrides } : {}),
             };
         }
@@ -310,7 +339,6 @@ function compileEditorScenePrefabCompositionInstance(gameObject, prefabAsset, so
         rootName: gameObject.name ?? prefabAsset.displayName ?? prefabAsset.id,
         rootTransform: findEditorSceneTransform(gameObject) ?? undefined,
         rootActive: gameObject.active,
-        rootShadowMode: gameObject.shadowMode,
         rootShadow: gameObject.shadow,
         instanceOverrides: gameObject.overrides,
         propertyPathPrefix: `assets.${prefabAsset.id}.prefab.nodes`,
@@ -363,6 +391,7 @@ function compileEditorScenePrefabCompositionNodes(input) {
         if (node.kind === 'prefabInstance' && node.childPrefabId) {
             const childPrefab = input.editorDocument.assets.find(asset => asset.id === node.childPrefabId);
             if (childPrefab && isExplicitEditorScenePrefabCompositionAsset(childPrefab)) {
+                const isRootPrefabInstance = node.id === rootNode.id;
                 compiledNodes.push(...compileEditorScenePrefabCompositionNodes({
                     prefabAsset: childPrefab,
                     sourceRef: input.sourceRef,
@@ -370,25 +399,33 @@ function compileEditorScenePrefabCompositionNodes(input) {
                     hostGameObject: input.hostGameObject,
                     rootRuntimeId: runtimeId,
                     rootParentId: parentId,
-                    rootName: node.name ?? childPrefab.displayName ?? childPrefab.id,
-                    rootTransform: node.transform,
-                    rootActive: node.defaults?.active,
-                    rootShadowMode: node.defaults?.shadowMode,
-                    rootShadow: node.defaults?.shadow,
-                    instanceOverrides: node.overrides,
+                    rootName: isRootPrefabInstance
+                        ? (input.rootName ?? node.name ?? childPrefab.displayName ?? childPrefab.id)
+                        : (node.name ?? childPrefab.displayName ?? childPrefab.id),
+                    rootTransform: isRootPrefabInstance ? (input.rootTransform ?? node.transform) : node.transform,
+                    rootActive: isRootPrefabInstance
+                        ? (input.rootActive ?? node.defaults?.active ?? input.prefabAsset.prefab?.defaults?.active)
+                        : node.defaults?.active,
+                    rootShadow: isRootPrefabInstance
+                        ? mergeEditorShadowSettings(input.prefabAsset.prefab?.defaults?.shadow, node.defaults?.shadow, input.rootShadow)
+                        : node.defaults?.shadow,
+                    instanceOverrides: isRootPrefabInstance
+                        ? mergeEditorSceneCompilerVisualOverrides(mergeEditorSceneCompilerVisualOverrides(readEditorSceneCompilerVisualOverrides(input.prefabAsset.prefab?.overrides), readEditorSceneCompilerVisualOverrides(node.overrides)), readEditorSceneCompilerVisualOverrides(input.instanceOverrides))
+                        : node.overrides,
                     propertyPathPrefix: `${input.propertyPathPrefix}.${node.id}.childPrefab.nodes`,
                     visitedPrefabIds: new Set(input.visitedPrefabIds),
                 }));
                 continue;
             }
-            compiledNodes.push(compileEditorScenePrefabLegacyChildInstanceNode({
-                node,
-                runtimeId,
+            compiledNodes.push(compileEditorScenePrefabPlaceholderNode({
+                id: runtimeId,
+                name: node.name ?? node.childPrefabId ?? 'Prefab Instance',
                 parentId,
-                childPrefab,
-                editorDocument: input.editorDocument,
+                transform: node.transform,
                 sourceRef: input.sourceRef,
+                editorDocument: input.editorDocument,
                 hostGameObject: input.hostGameObject,
+                component: 'UnsupportedPrefabInstance',
                 propertyPath: `${input.propertyPathPrefix}.${node.id}`,
             }));
             continue;
@@ -405,7 +442,6 @@ function compileEditorScenePrefabCompositionNodes(input) {
             rootRuntimeName: input.rootName,
             rootRuntimeTransform: input.rootTransform,
             rootRuntimeActive: input.rootActive,
-            rootRuntimeShadowMode: input.rootShadowMode,
             rootRuntimeShadow: input.rootShadow,
             instanceOverrides: node.id === primaryModelNodeId ? input.instanceOverrides : undefined,
             propertyPath: `${input.propertyPathPrefix}.${node.id}`,
@@ -436,9 +472,6 @@ function compileEditorScenePrefabCompositionNode(input) {
         active: isRoot
             ? (input.rootRuntimeActive ?? input.node.defaults?.active ?? input.prefabAsset.prefab?.defaults?.active)
             : input.node.defaults?.active,
-        shadowMode: isRoot
-            ? (input.rootRuntimeShadowMode ?? input.node.defaults?.shadowMode ?? input.prefabAsset.prefab?.defaults?.shadowMode)
-            : (input.node.defaults?.shadowMode ?? input.prefabAsset.prefab?.defaults?.shadowMode),
         shadow: isRoot
             ? mergeEditorShadowSettings(input.prefabAsset.prefab?.defaults?.shadow, input.node.defaults?.shadow, input.rootRuntimeShadow)
             : mergeEditorShadowSettings(input.prefabAsset.prefab?.defaults?.shadow, input.node.defaults?.shadow),
@@ -506,52 +539,6 @@ function compileEditorScenePrefabCompositionNode(input) {
         kind: 'group',
     };
 }
-function compileEditorScenePrefabLegacyChildInstanceNode(input) {
-    const sourceAssetId = input.childPrefab?.prefab?.sourceAssetId;
-    if (!sourceAssetId || !input.childPrefab) {
-        return compileEditorScenePrefabPlaceholderNode({
-            id: input.runtimeId,
-            name: input.node.name ?? input.node.childPrefabId ?? 'Prefab Instance',
-            parentId: input.parentId,
-            transform: input.node.transform,
-            sourceRef: input.sourceRef,
-            editorDocument: input.editorDocument,
-            hostGameObject: input.hostGameObject,
-            component: 'PrefabInstance',
-            propertyPath: input.propertyPath,
-        });
-    }
-    const sourceAsset = input.editorDocument.assets.find(asset => asset.id === sourceAssetId);
-    const visualOverrides = compileEditorScenePrefabLegacyChildVisualOverrides({
-        node: input.node,
-        childPrefab: input.childPrefab,
-        sourceAsset,
-        editorDocument: input.editorDocument,
-        hostGameObject: createEditorSceneCompilerPrefabModelGameObject(input.hostGameObject, input.node, sourceAssetId),
-    });
-    return {
-        ...compileEditorScenePrefabRuntimeNodeBase({
-            id: input.runtimeId,
-            name: input.node.name ?? input.childPrefab?.displayName ?? input.node.childPrefabId,
-            parentId: input.parentId,
-            transform: input.node.transform,
-            active: input.node.defaults?.active ?? input.childPrefab?.prefab?.defaults?.active,
-            shadowMode: input.node.defaults?.shadowMode ?? input.childPrefab?.prefab?.defaults?.shadowMode,
-            shadow: mergeEditorShadowSettings(input.childPrefab?.prefab?.defaults?.shadow, input.node.defaults?.shadow),
-            sourceAsset,
-            sourceRef: input.sourceRef,
-            editorDocument: input.editorDocument,
-            hostGameObject: input.hostGameObject,
-            component: 'PrefabInstance',
-            propertyPath: input.propertyPath,
-        }),
-        kind: 'instance',
-        instance: {
-            assetId: sourceAssetId,
-        },
-        ...(visualOverrides ? { overrides: visualOverrides } : {}),
-    };
-}
 function compileEditorScenePrefabPlaceholderNode(input) {
     return {
         ...compileEditorScenePrefabRuntimeNodeBase({
@@ -568,13 +555,18 @@ function compileEditorScenePrefabPlaceholderNode(input) {
         kind: 'group',
     };
 }
+function readEditorSceneCompilerCustomTransformRuntimeData(gameObject, options) {
+    const data = options.readCustomTransformRuntimeData?.(gameObject);
+    return data && typeof data === 'object' && !Array.isArray(data)
+        ? structuredClone(data)
+        : {};
+}
 function compileEditorScenePrefabRuntimeNodeBase(input) {
     return {
         id: input.id,
         ...(input.name ? { name: input.name } : {}),
         ...(input.parentId ? { parentId: input.parentId } : {}),
         ...(input.active === false ? { enabled: false } : {}),
-        ...(input.shadowMode ? { shadowMode: input.shadowMode } : {}),
         ...(input.shadow ? { shadow: structuredClone(input.shadow) } : {}),
         ...compileEditorScenePrefabRuntimeShadowPlan(input),
         source: {
@@ -602,19 +594,16 @@ function compileEditorSceneGameObjectShadowPlan(editorDocument, gameObject) {
         document: editorDocument,
         casterId: gameObject.id,
     });
-    return shouldEmitEditorSceneRuntimeShadowPlan(plan, !!gameObject.shadowMode || !!gameObject.shadow)
+    return shouldEmitEditorSceneRuntimeShadowPlan(plan, !!gameObject.shadow)
         ? { shadowPlan: plan }
         : {};
 }
 function compileEditorScenePrefabRuntimeShadowPlan(input) {
     if (!input.editorDocument)
         return {};
-    const readable = readEditorShadowSettingsWithLegacy({
-        shadowMode: input.shadowMode,
-        shadow: input.shadow,
-    });
+    const readable = readEditorShadowSettingsResult(input.shadow);
     const source = readEditorSceneCompilerAssetShadowSettings(input.sourceAsset);
-    const hasAuthoringShadow = !!input.shadowMode || !!input.shadow || !!readable.shadow || !!source.shadow;
+    const hasAuthoringShadow = !!input.shadow || !!readable.shadow || !!source.shadow;
     if (!hasAuthoringShadow && readable.diagnostics.length === 0 && source.diagnostics.length === 0)
         return {};
     const plan = resolveEditorShadowPlan({
@@ -651,10 +640,7 @@ function readEditorSceneCompilerAssetShadowSettings(asset) {
         : undefined;
     if (!defaults)
         return { diagnostics: [] };
-    const result = readEditorShadowSettingsWithLegacy({
-        shadow: defaults.shadow,
-        shadowMode: defaults.shadowMode,
-    });
+    const result = readEditorShadowSettingsResult(defaults.shadow);
     return {
         shadow: result.shadow,
         diagnostics: result.diagnostics.map(diagnostic => ({
@@ -698,7 +684,7 @@ function compileEditorScenePrefabScopedShadowPlans(input) {
             explicitReceiverIds: internalReceiverIds,
             ...(internalLightId ? { defaultLightId: internalLightId } : {}),
         });
-        const hasAuthoringShadow = !!node.shadowMode || !!node.shadow;
+        const hasAuthoringShadow = !!node.shadow;
         if (!shouldEmitEditorSceneRuntimeShadowPlan(plan, hasAuthoringShadow)) {
             if (!node.shadowPlan)
                 return node;
@@ -734,14 +720,12 @@ function createEditorSceneGameObjectFromRuntimeNode(node) {
         kind: node.kind,
         ...(node.parentId ? { parentId: node.parentId } : {}),
         ...(node.enabled === false ? { active: false } : {}),
-        ...(node.shadowMode ? { shadowMode: node.shadowMode } : {}),
         ...(node.shadow ? { shadow: structuredClone(node.shadow) } : {}),
         ...(node.kind === 'primitive' ? { primitive: { shape: node.primitive.shape } } : {}),
         ...(node.kind === 'transform' && node.transformType ? { transformType: node.transformType } : {}),
         ...(node.kind === 'transform' && node.light ? { light: node.light } : {}),
         ...(node.kind === 'transform' && node.camera ? { camera: node.camera } : {}),
         ...(node.kind === 'transform' && node.marker ? { marker: structuredClone(node.marker) } : {}),
-        ...(node.kind === 'transform' && node.groundDecal ? { groundDecal: node.groundDecal } : {}),
         components,
     };
 }
@@ -749,28 +733,37 @@ function compileEditorScenePrefabCompositionVisualOverrides(input) {
     const materialHostGameObject = input.node.kind === 'model' && input.node.sourceAssetId
         ? createEditorSceneCompilerPrefabModelGameObject(input.hostGameObject, input.node, input.node.sourceAssetId)
         : input.hostGameObject;
+    const targetAssetId = input.asset?.id;
     const prefabOverrides = mergeEditorScenePrefabOverrideList([
-        input.prefabAsset.prefab?.overrides,
-        input.rootNode.overrides,
-        input.node.id === input.rootNode.id ? undefined : input.node.overrides,
+        filterEditorSceneCompilerOverrideLayer(readEditorSceneCompilerVisualOverrides(input.prefabAsset.prefab?.overrides), input.prefabAsset.prefab?.sourceAssetId, input.asset),
+        filterEditorSceneCompilerOverrideLayer(readEditorSceneCompilerVisualOverrides(input.rootNode.overrides), input.rootNode.kind === 'model' ? input.rootNode.sourceAssetId : input.prefabAsset.prefab?.sourceAssetId, input.asset),
+        input.node.id === input.rootNode.id
+            ? undefined
+            : filterEditorSceneCompilerOverrideLayer(readEditorSceneCompilerVisualOverrides(input.node.overrides), input.node.kind === 'model' ? input.node.sourceAssetId : targetAssetId, input.asset),
     ]);
     const instanceOverrides = readEditorSceneCompilerVisualOverrides(input.instanceOverrides);
-    const compiledPrefabOverrides = prefabOverrides
-        ? migrateSceneMaterialSlotBindings(prefabOverrides, input.asset, input.editorDocument, materialHostGameObject)
-        : undefined;
-    const compiledInstanceOverrides = instanceOverrides
-        ? migrateSceneMaterialSlotBindings(instanceOverrides, input.asset, input.editorDocument, materialHostGameObject)
-        : undefined;
-    let next = mergeEditorScenePrefabOverrides(compiledPrefabOverrides, compiledInstanceOverrides);
-    if (instanceOverrides) {
-        for (const [key, value] of Object.entries(instanceOverrides)) {
-            if (isEditorScenePrefabMaterialOverrideKey(key) || value === undefined)
-                continue;
-            next ?? (next = {});
-            next[key] = value;
-        }
-    }
-    return next && Object.keys(next).length > 0 ? next : undefined;
+    return filterEditorSceneCompilerMaterialSlotBindings(mergeEditorSceneCompilerVisualOverrides(prefabOverrides, instanceOverrides), input.asset);
+}
+function filterEditorSceneCompilerOverrideLayer(overrides, ownerAssetId, targetAsset) {
+    return filterEditorSceneCompilerMaterialSlotBindings(overrides, ownerAssetId && ownerAssetId === targetAsset?.id ? targetAsset : undefined);
+}
+function filterEditorSceneCompilerMaterialSlotBindings(overrides, asset) {
+    if (!overrides?.materialSlotBindings)
+        return overrides;
+    const materialSlots = isRecord(asset?.metadata) && Array.isArray(asset.metadata.materialSlots)
+        ? asset.metadata.materialSlots
+        : [];
+    const allowedSlotIds = new Set(materialSlots.flatMap((slot) => {
+        const slotId = isRecord(slot) && typeof slot.slotId === 'string' ? slot.slotId.trim() : '';
+        return slotId ? [slotId] : [];
+    }));
+    const materialSlotBindings = Object.fromEntries(Object.entries(overrides.materialSlotBindings).filter(([slotId]) => allowedSlotIds.has(slotId)));
+    const next = structuredClone(overrides);
+    if (Object.keys(materialSlotBindings).length > 0)
+        next.materialSlotBindings = materialSlotBindings;
+    else
+        delete next.materialSlotBindings;
+    return Object.keys(next).length > 0 ? next : undefined;
 }
 function createEditorSceneCompilerPrefabModelGameObject(hostGameObject, node, assetId) {
     return {
@@ -806,22 +799,13 @@ function createEditorSceneCompilerPrefabCompositionMaterialGameObject(hostGameOb
     }
     return null;
 }
-function compileEditorScenePrefabLegacyChildVisualOverrides(input) {
-    const prefabOverrides = mergeEditorScenePrefabOverrideList([
-        input.childPrefab.prefab?.overrides,
-        input.node.overrides,
-    ]);
-    return prefabOverrides
-        ? migrateSceneMaterialSlotBindings(prefabOverrides, input.sourceAsset, input.editorDocument, input.hostGameObject)
-        : undefined;
-}
 function mergeEditorScenePrefabOverrideList(overridesList) {
     let next;
     for (const overrides of overridesList) {
         const readable = readEditorSceneCompilerVisualOverrides(overrides);
         if (!readable)
             continue;
-        next = mergeEditorScenePrefabOverrides(next, readable);
+        next = mergeEditorSceneCompilerVisualOverrides(next, readable);
     }
     return next;
 }
@@ -857,7 +841,11 @@ function findEditorScenePrefabPrimaryModelNodeId(nodes, prefabAsset) {
         ?? nodes.find(node => node.kind === 'model')?.id;
 }
 function isExplicitEditorScenePrefabCompositionAsset(asset) {
-    return isEditorScenePrefabAsset(asset) && Array.isArray(asset.prefab?.nodes) && asset.prefab.nodes.length > 0;
+    return isEditorScenePrefabAsset(asset)
+        && asset.prefab.compositionVersion === EDITOR_SCENE_PREFAB_COMPOSITION_VERSION
+        && Array.isArray(asset.prefab.nodes)
+        && asset.prefab.nodes.length > 0
+        && !!readEditorScenePrefabRootNodeId(asset);
 }
 function findEditorScenePrimitiveRenderer(gameObject) {
     return gameObject.primitive ?? null;
@@ -874,19 +862,18 @@ function resolveEditorSceneCompileVisualOverrides(gameObject, editorDocument, as
     const instanceOverrides = readEditorSceneCompilerVisualOverrides(gameObject.overrides);
     const relation = resolveEditorScenePrefabInstanceRelation(editorDocument, gameObject.id);
     const prefabOverrides = readEditorSceneCompilerVisualOverrides(relation.definition?.prefab?.overrides);
-    const compiledPrefabOverrides = prefabOverrides
-        ? migrateSceneMaterialSlotBindings(prefabOverrides, asset, editorDocument, gameObject)
-        : undefined;
-    const compiledInstanceOverrides = instanceOverrides
-        ? migrateSceneMaterialSlotBindings(instanceOverrides, asset, editorDocument, gameObject)
-        : undefined;
-    let next = mergeEditorScenePrefabOverrides(compiledPrefabOverrides, compiledInstanceOverrides);
-    if (instanceOverrides) {
-        for (const [key, value] of Object.entries(instanceOverrides)) {
+    return mergeEditorSceneCompilerVisualOverrides(prefabOverrides, instanceOverrides);
+}
+function mergeEditorSceneCompilerVisualOverrides(base, override) {
+    let next = mergeEditorScenePrefabOverrides(base, override);
+    for (const source of [base, override]) {
+        if (!source)
+            continue;
+        for (const [key, value] of Object.entries(source)) {
             if (isEditorScenePrefabMaterialOverrideKey(key) || value === undefined)
                 continue;
             next ?? (next = {});
-            next[key] = value;
+            next[key] = structuredClone(value);
         }
     }
     return next && Object.keys(next).length > 0 ? next : undefined;
@@ -899,94 +886,15 @@ function readEditorSceneCompilerVisualOverrides(value) {
 }
 function isEditorScenePrefabMaterialOverrideKey(key) {
     return key === 'materialBinding'
-        || key === 'materialSlotBindings'
-        || key === 'childMaterialBindings';
-}
-function migrateSceneMaterialSlotBindings(overrides, asset, editorDocument, gameObject) {
-    const gameObjectWithCompiledOverrides = {
-        ...gameObject,
-        overrides,
-    };
-    const reimportDiff = resolveEditorSceneMaterialSlotReimportDiff(editorDocument, gameObjectWithCompiledOverrides);
-    if (reimportDiff.bindingRemaps.length > 0 && overrides.materialSlotBindings) {
-        for (const remap of reimportDiff.bindingRemaps) {
-            const sourceBinding = overrides.materialSlotBindings[remap.fromSlotId];
-            if (!sourceBinding || overrides.materialSlotBindings[remap.toSlotId])
-                continue;
-            overrides.materialSlotBindings[remap.toSlotId] = structuredClone(sourceBinding);
-            delete overrides.materialSlotBindings[remap.fromSlotId];
-        }
-        if (Object.keys(overrides.materialSlotBindings).length === 0) {
-            delete overrides.materialSlotBindings;
-        }
-    }
-    const materialSlots = collectCompiledEditorSceneMaterialSlots(asset);
-    if (materialSlots.length === 0 || !overrides.childMaterialBindings)
-        return overrides;
-    const materialSlotBindings = {
-        ...(overrides.materialSlotBindings ?? {}),
-    };
-    const childMaterialBindings = {
-        ...overrides.childMaterialBindings,
-    };
-    const migratedLegacyOwnerPaths = new Set();
-    for (const slot of materialSlots) {
-        const legacy = findLegacySceneMaterialSlotBinding(overrides.childMaterialBindings, slot.ownerNodePath);
-        const legacyBinding = legacy?.binding;
-        if (!legacyBinding)
-            continue;
-        materialSlotBindings[slot.slotId] = mergeEditorSceneMaterialBindingOverrides(materialSlotBindings[slot.slotId], legacyBinding);
-        migratedLegacyOwnerPaths.add(legacy.ownerNodePath);
-    }
-    for (const ownerNodePath of migratedLegacyOwnerPaths) {
-        delete childMaterialBindings[ownerNodePath];
-    }
-    if (Object.keys(materialSlotBindings).length > 0)
-        overrides.materialSlotBindings = materialSlotBindings;
-    if (Object.keys(childMaterialBindings).length > 0)
-        overrides.childMaterialBindings = childMaterialBindings;
-    else
-        delete overrides.childMaterialBindings;
-    return overrides;
-}
-function collectCompiledEditorSceneMaterialSlots(asset) {
-    const rawSlots = Array.isArray(asset?.metadata?.materialSlots) ? asset.metadata.materialSlots : [];
-    const slots = [];
-    for (const rawSlot of rawSlots) {
-        if (!rawSlot || typeof rawSlot !== 'object' || Array.isArray(rawSlot))
-            continue;
-        const record = rawSlot;
-        const slotId = typeof record.slotId === 'string' ? record.slotId.trim() : '';
-        const ownerNodePath = normalizeSceneMaterialSlotMigrationOwnerPath(typeof record.ownerNodePath === 'string'
-            ? record.ownerNodePath
-            : typeof record.path === 'string'
-                ? record.path
-                : '');
-        if (slotId && ownerNodePath)
-            slots.push({ slotId, ownerNodePath });
-    }
-    return slots;
-}
-function findLegacySceneMaterialSlotBinding(childMaterialBindings, ownerNodePath) {
-    const exact = childMaterialBindings[ownerNodePath];
-    if (exact)
-        return { ownerNodePath, binding: exact };
-    const normalizedOwnerNodePath = normalizeSceneMaterialSlotMigrationOwnerPath(ownerNodePath);
-    for (const [legacyOwnerNodePath, binding] of Object.entries(childMaterialBindings)) {
-        if (!binding)
-            continue;
-        if (normalizeSceneMaterialSlotMigrationOwnerPath(legacyOwnerNodePath) === normalizedOwnerNodePath) {
-            return { ownerNodePath: legacyOwnerNodePath, binding };
-        }
-    }
-    return null;
-}
-function normalizeSceneMaterialSlotMigrationOwnerPath(ownerNodePath) {
-    return String(ownerNodePath ?? '').split('/').filter(Boolean).join('/');
+        || key === 'materialSlotBindings';
 }
 function isRecord(value) {
     return !!value && typeof value === 'object' && !Array.isArray(value);
 }
+function readNonEmptyString(value) {
+    const trimmed = typeof value === 'string' ? value.trim() : '';
+    return trimmed || undefined;
+}
 function compileEditorSceneCamera(camera) {
     const compiled = structuredClone(camera);
     delete compiled.inspectorLanguage;