@fps-games/editor 0.1.5-beta.5 → 0.1.7-beta.1

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

@@ -0,0 +1,996 @@
+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 { getEditorSceneAuthoringSourceRef, } from '../authoring/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) {
+    const nextSceneConfig = structuredClone(baseSceneConfig);
+    const previousScene = isRecord(nextSceneConfig.scene)
+        ? nextSceneConfig.scene
+        : undefined;
+    const sourceRef = getEditorSceneAuthoringSourceRef(editorDocument);
+    const generatedFrom = {
+        ...sourceRef,
+        compilerId: PLAYABLE_EDITOR_SCENE_COMPILER_ID,
+        compilerVersion: PLAYABLE_EDITOR_SCENE_COMPILER_VERSION,
+        compiledAt: new Date().toISOString(),
+    };
+    nextSceneConfig.schemaVersion = 2;
+    nextSceneConfig.meta = {
+        ...(nextSceneConfig.meta ?? {}),
+        generatedFrom,
+    };
+    const rootId = previousScene?.rootId || 'root';
+    const compiledGameObjects = editorDocument.scene.gameObjects
+        .filter((gameObject) => gameObject.id !== rootId);
+    const materialAssets = resolveCompiledEditorSceneMaterialAssets(editorDocument, previousScene?.materialAssets);
+    const documentWithResolvedMaterialAssets = {
+        ...editorDocument,
+        scene: {
+            ...editorDocument.scene,
+            materialAssets,
+        },
+    };
+    const compiledNodes = compiledGameObjects.flatMap(gameObject => compileGameObjectToRuntimeNodes(gameObject, sourceRef, documentWithResolvedMaterialAssets));
+    const compiledScene = {
+        rootId,
+        assets: documentWithResolvedMaterialAssets.assets
+            .filter(isEditorSceneModelAsset)
+            .map(compileAsset),
+        nodes: compiledNodes,
+        materialAssets,
+        materials: previousScene?.materials ?? [],
+        textures: previousScene?.textures ?? [],
+    };
+    nextSceneConfig.scene = compiledScene;
+    return {
+        sceneConfig: nextSceneConfig,
+        summary: {
+            assetCount: compiledScene.assets.length,
+            gameObjectCount: editorDocument.scene.gameObjects.length,
+            nodeCount: compiledScene.nodes.length,
+        },
+    };
+}
+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]));
+    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));
+    }
+    return materialAssets;
+}
+function createEditorSceneCompilerMaterialIntegrityDocument(editorDocument, materialAssets) {
+    const documentWithMaterialAssets = {
+        ...editorDocument,
+        scene: {
+            ...editorDocument.scene,
+            materialAssets,
+        },
+    };
+    return {
+        ...documentWithMaterialAssets,
+        scene: {
+            ...documentWithMaterialAssets.scene,
+            gameObjects: [
+                ...documentWithMaterialAssets.scene.gameObjects.map((gameObject) => {
+                    const visualOverrides = compileEditorSceneVisualOverrides(gameObject, documentWithMaterialAssets);
+                    if (visualOverrides) {
+                        return {
+                            ...gameObject,
+                            overrides: visualOverrides,
+                        };
+                    }
+                    if (!('overrides' in gameObject))
+                        return gameObject;
+                    const next = { ...gameObject };
+                    delete next.overrides;
+                    return next;
+                }),
+                ...createEditorSceneCompilerPrefabMaterialIntegrityGameObjects(documentWithMaterialAssets),
+            ],
+        },
+    };
+}
+function createEditorSceneCompilerPrefabMaterialIntegrityGameObjects(editorDocument) {
+    const gameObjects = [];
+    for (const gameObject of editorDocument.scene.gameObjects) {
+        const relation = resolveEditorScenePrefabInstanceRelation(editorDocument, gameObject.id);
+        if (!relation.definition || !isExplicitEditorScenePrefabCompositionAsset(relation.definition))
+            continue;
+        gameObjects.push(...createEditorSceneCompilerPrefabCompositionMaterialIntegrityGameObjects({
+            editorDocument,
+            prefabAsset: relation.definition,
+            hostGameObject: gameObject,
+            instanceOverrides: gameObject.overrides,
+            visitedPrefabIds: new Set(),
+        }));
+    }
+    return gameObjects;
+}
+function createEditorSceneCompilerPrefabCompositionMaterialIntegrityGameObjects(input) {
+    if (input.visitedPrefabIds.has(input.prefabAsset.id))
+        return [];
+    input.visitedPrefabIds.add(input.prefabAsset.id);
+    const nodes = orderEditorScenePrefabNodesForCompile(readEditorScenePrefabNodes(input.prefabAsset), readEditorScenePrefabRootNodeId(input.prefabAsset) ?? '');
+    const rootNode = nodes.find(node => node.id === readEditorScenePrefabRootNodeId(input.prefabAsset));
+    if (!rootNode) {
+        input.visitedPrefabIds.delete(input.prefabAsset.id);
+        return [];
+    }
+    const primaryModelNodeId = findEditorScenePrefabPrimaryModelNodeId(nodes, input.prefabAsset);
+    const gameObjects = [];
+    for (const node of nodes) {
+        if (node.kind === 'prefabInstance' && node.childPrefabId) {
+            const childPrefab = input.editorDocument.assets.find(asset => asset.id === node.childPrefabId);
+            if (childPrefab && isExplicitEditorScenePrefabCompositionAsset(childPrefab)) {
+                gameObjects.push(...createEditorSceneCompilerPrefabCompositionMaterialIntegrityGameObjects({
+                    editorDocument: input.editorDocument,
+                    prefabAsset: childPrefab,
+                    hostGameObject: input.hostGameObject,
+                    instanceOverrides: node.overrides,
+                    visitedPrefabIds: new Set(input.visitedPrefabIds),
+                }));
+                continue;
+            }
+            const legacyChildGameObject = createEditorSceneCompilerPrefabLegacyChildMaterialIntegrityGameObject({
+                editorDocument: input.editorDocument,
+                hostGameObject: input.hostGameObject,
+                node,
+                childPrefab,
+            });
+            if (legacyChildGameObject)
+                gameObjects.push(legacyChildGameObject);
+            continue;
+        }
+        const syntheticGameObject = createEditorSceneCompilerPrefabCompositionMaterialGameObject(input.hostGameObject, node);
+        if (!syntheticGameObject)
+            continue;
+        const asset = node.kind === 'model' && node.sourceAssetId
+            ? input.editorDocument.assets.find(asset => asset.id === node.sourceAssetId)
+            : undefined;
+        const overrides = compileEditorScenePrefabCompositionVisualOverrides({
+            hostGameObject: syntheticGameObject,
+            prefabAsset: input.prefabAsset,
+            rootNode,
+            node,
+            asset,
+            editorDocument: input.editorDocument,
+            instanceOverrides: node.id === primaryModelNodeId ? input.instanceOverrides : undefined,
+        });
+        if (!overrides)
+            continue;
+        gameObjects.push({
+            ...syntheticGameObject,
+            overrides,
+        });
+    }
+    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) {
+    return {
+        id: asset.id,
+        type: asset.type,
+        ...(asset.guid ? { guid: asset.guid } : {}),
+        ...(asset.displayName ? { displayName: asset.displayName } : {}),
+        ...(asset.category ? { category: asset.category } : {}),
+        ...(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) } : {}),
+    };
+}
+function compileGameObjectToRuntimeNodes(gameObject, sourceRef, editorDocument) {
+    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)];
+}
+function compileGameObject(gameObject, sourceRef, editorDocument) {
+    const transform = findEditorSceneTransform(gameObject);
+    const modelRenderer = findEditorSceneModelRenderer(gameObject);
+    const primitiveRenderer = findEditorScenePrimitiveRenderer(gameObject);
+    const nodeKind = readEditorSceneNodeKind(gameObject);
+    const visualOverrides = compileEditorSceneVisualOverrides(gameObject, editorDocument);
+    const rendering = resolveEditorSceneGameObjectRendering(gameObject);
+    const source = {
+        sourceId: sourceRef.sourceId,
+        sourceType: sourceRef.sourceType,
+        revision: sourceRef.revision,
+        ...(gameObject.guid ? { objectGuid: gameObject.guid } : {}),
+        objectId: gameObject.id,
+        component: modelRenderer ? 'ModelRenderer' : (primitiveRenderer || nodeKind === 'primitive') ? 'PrimitiveRenderer' : nodeKind === 'transform' ? 'Transform' : 'GameObject',
+    };
+    const base = {
+        id: gameObject.id,
+        ...(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 } : {}),
+        source,
+        ...(transform && 'position' in transform
+            ? {
+                transform: {
+                    position: transform.position,
+                    rotation: transform.rotation,
+                    ...(transform.scale ? { scale: transform.scale } : {}),
+                },
+            }
+            : {}),
+    };
+    if (nodeKind === 'primitive') {
+        return {
+            ...base,
+            kind: 'primitive',
+            primitive: {
+                shape: primitiveRenderer?.shape ?? 'cube',
+            },
+            ...(visualOverrides ? { overrides: visualOverrides } : {}),
+        };
+    }
+    if (!modelRenderer) {
+        if (nodeKind === 'transform') {
+            return {
+                ...base,
+                kind: 'transform',
+                ...(typeof gameObject.transformType === 'string' ? { transformType: gameObject.transformType } : {}),
+                ...(gameObject.camera ? { camera: compileEditorSceneCamera(gameObject.camera) } : {}),
+                ...(gameObject.light ? { light: compileEditorSceneLight(gameObject.light) } : {}),
+                ...(gameObject.marker ? {
+                    marker: {
+                        label: gameObject.name || gameObject.id,
+                        ...structuredClone(gameObject.marker),
+                    },
+                } : {}),
+                ...(gameObject.groundDecal ? { groundDecal: structuredClone(gameObject.groundDecal) } : {}),
+                ...(visualOverrides ? { overrides: visualOverrides } : {}),
+            };
+        }
+        return {
+            ...base,
+            kind: 'group',
+        };
+    }
+    return {
+        ...base,
+        kind: 'instance',
+        instance: {
+            assetId: modelRenderer.assetId,
+        },
+        ...(visualOverrides ? { overrides: visualOverrides } : {}),
+    };
+}
+function compileEditorScenePrefabCompositionInstance(gameObject, prefabAsset, sourceRef, editorDocument, visitedPrefabIds) {
+    return compileEditorScenePrefabCompositionNodes({
+        prefabAsset,
+        sourceRef,
+        editorDocument,
+        hostGameObject: gameObject,
+        rootRuntimeId: gameObject.id,
+        rootParentId: gameObject.parentId,
+        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`,
+        visitedPrefabIds,
+    });
+}
+function compileEditorScenePrefabCompositionNodes(input) {
+    if (input.visitedPrefabIds.has(input.prefabAsset.id)) {
+        return [compileEditorScenePrefabPlaceholderNode({
+                id: input.rootRuntimeId,
+                name: input.rootName ?? input.prefabAsset.displayName ?? input.prefabAsset.id,
+                parentId: input.rootParentId,
+                transform: input.rootTransform,
+                editorDocument: input.editorDocument,
+                sourceRef: input.sourceRef,
+                hostGameObject: input.hostGameObject,
+                component: 'PrefabCycle',
+                propertyPath: input.propertyPathPrefix,
+            })];
+    }
+    input.visitedPrefabIds.add(input.prefabAsset.id);
+    const prefabNodes = readEditorScenePrefabNodes(input.prefabAsset);
+    const rootNodeId = readEditorScenePrefabRootNodeId(input.prefabAsset);
+    const rootNode = rootNodeId
+        ? prefabNodes.find(node => node.id === rootNodeId)
+        : null;
+    if (!rootNode || prefabNodes.length === 0) {
+        input.visitedPrefabIds.delete(input.prefabAsset.id);
+        return [compileEditorScenePrefabPlaceholderNode({
+                id: input.rootRuntimeId,
+                name: input.rootName ?? input.prefabAsset.displayName ?? input.prefabAsset.id,
+                parentId: input.rootParentId,
+                transform: input.rootTransform,
+                editorDocument: input.editorDocument,
+                sourceRef: input.sourceRef,
+                hostGameObject: input.hostGameObject,
+                component: 'Prefab',
+                propertyPath: input.propertyPathPrefix,
+            })];
+    }
+    const runtimeIdForNode = (node) => node.id === rootNode.id ? input.rootRuntimeId : `${input.rootRuntimeId}:${node.id}`;
+    const orderedNodes = orderEditorScenePrefabNodesForCompile(prefabNodes, rootNode.id);
+    const primaryModelNodeId = findEditorScenePrefabPrimaryModelNodeId(orderedNodes, input.prefabAsset);
+    const compiledNodes = [];
+    for (const node of orderedNodes) {
+        const runtimeId = runtimeIdForNode(node);
+        const parentId = node.id === rootNode.id
+            ? input.rootParentId
+            : runtimeIdForNode(prefabNodes.find(candidate => candidate.id === node.parentId) ?? rootNode);
+        if (node.kind === 'prefabInstance' && node.childPrefabId) {
+            const childPrefab = input.editorDocument.assets.find(asset => asset.id === node.childPrefabId);
+            if (childPrefab && isExplicitEditorScenePrefabCompositionAsset(childPrefab)) {
+                compiledNodes.push(...compileEditorScenePrefabCompositionNodes({
+                    prefabAsset: childPrefab,
+                    sourceRef: input.sourceRef,
+                    editorDocument: input.editorDocument,
+                    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,
+                    propertyPathPrefix: `${input.propertyPathPrefix}.${node.id}.childPrefab.nodes`,
+                    visitedPrefabIds: new Set(input.visitedPrefabIds),
+                }));
+                continue;
+            }
+            compiledNodes.push(compileEditorScenePrefabLegacyChildInstanceNode({
+                node,
+                runtimeId,
+                parentId,
+                childPrefab,
+                editorDocument: input.editorDocument,
+                sourceRef: input.sourceRef,
+                hostGameObject: input.hostGameObject,
+                propertyPath: `${input.propertyPathPrefix}.${node.id}`,
+            }));
+            continue;
+        }
+        compiledNodes.push(compileEditorScenePrefabCompositionNode({
+            node,
+            rootNode,
+            prefabAsset: input.prefabAsset,
+            runtimeId,
+            parentId,
+            sourceRef: input.sourceRef,
+            editorDocument: input.editorDocument,
+            hostGameObject: input.hostGameObject,
+            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}`,
+        }));
+    }
+    input.visitedPrefabIds.delete(input.prefabAsset.id);
+    return compileEditorScenePrefabScopedShadowPlans({
+        compiledNodes,
+        editorDocument: input.editorDocument,
+        hostGameObject: input.hostGameObject,
+    });
+}
+function compileEditorScenePrefabCompositionNode(input) {
+    const isRoot = input.node.id === input.rootNode.id;
+    const transform = isRoot
+        ? (input.rootRuntimeTransform ?? input.node.transform)
+        : input.node.transform;
+    const sourceAsset = input.node.kind === 'model' && input.node.sourceAssetId
+        ? input.editorDocument.assets.find(asset => asset.id === input.node.sourceAssetId)
+        : undefined;
+    const base = compileEditorScenePrefabRuntimeNodeBase({
+        id: input.runtimeId,
+        name: isRoot
+            ? (input.rootRuntimeName ?? input.node.name ?? input.prefabAsset.displayName ?? input.prefabAsset.id)
+            : input.node.name,
+        parentId: input.parentId,
+        transform,
+        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),
+        sourceAsset,
+        editorDocument: input.editorDocument,
+        sourceRef: input.sourceRef,
+        hostGameObject: input.hostGameObject,
+        component: input.node.kind === 'model'
+            ? 'PrefabModel'
+            : input.node.kind === 'primitive'
+                ? 'PrefabPrimitive'
+                : input.node.kind === 'light'
+                    ? 'PrefabLight'
+                    : 'PrefabNode',
+        propertyPath: input.propertyPath,
+    });
+    if (input.node.kind === 'model' && input.node.sourceAssetId) {
+        const visualOverrides = compileEditorScenePrefabCompositionVisualOverrides({
+            hostGameObject: input.hostGameObject,
+            prefabAsset: input.prefabAsset,
+            rootNode: input.rootNode,
+            node: input.node,
+            asset: sourceAsset,
+            editorDocument: input.editorDocument,
+            instanceOverrides: input.instanceOverrides,
+        });
+        return {
+            ...base,
+            kind: 'instance',
+            instance: {
+                assetId: input.node.sourceAssetId,
+            },
+            ...(visualOverrides ? { overrides: visualOverrides } : {}),
+        };
+    }
+    if (input.node.kind === 'primitive') {
+        const visualOverrides = compileEditorScenePrefabCompositionVisualOverrides({
+            hostGameObject: input.hostGameObject,
+            prefabAsset: input.prefabAsset,
+            rootNode: input.rootNode,
+            node: input.node,
+            asset: undefined,
+            editorDocument: input.editorDocument,
+            instanceOverrides: input.instanceOverrides,
+        });
+        return {
+            ...base,
+            kind: 'primitive',
+            primitive: {
+                shape: input.node.primitive?.shape ?? 'cube',
+            },
+            ...(visualOverrides ? { overrides: visualOverrides } : {}),
+        };
+    }
+    if (input.node.kind === 'light') {
+        return {
+            ...base,
+            kind: 'transform',
+            transformType: 'light',
+            ...(input.node.light ? { light: compileEditorSceneLight(input.node.light) } : {}),
+        };
+    }
+    return {
+        ...base,
+        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({
+            id: input.id,
+            name: input.name,
+            parentId: input.parentId,
+            transform: input.transform,
+            editorDocument: input.editorDocument,
+            sourceRef: input.sourceRef,
+            hostGameObject: input.hostGameObject,
+            component: input.component,
+            propertyPath: input.propertyPath,
+        }),
+        kind: 'group',
+    };
+}
+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: {
+            sourceId: input.sourceRef.sourceId,
+            sourceType: input.sourceRef.sourceType,
+            revision: input.sourceRef.revision,
+            ...(input.hostGameObject.guid ? { objectGuid: input.hostGameObject.guid } : {}),
+            objectId: input.hostGameObject.id,
+            component: input.component,
+            propertyPath: input.propertyPath,
+        },
+        ...(input.transform && 'position' in input.transform
+            ? {
+                transform: {
+                    position: input.transform.position,
+                    rotation: input.transform.rotation,
+                    ...(input.transform.scale ? { scale: input.transform.scale } : {}),
+                },
+            }
+            : {}),
+    };
+}
+function compileEditorSceneGameObjectShadowPlan(editorDocument, gameObject) {
+    const plan = resolveEditorShadowPlan({
+        document: editorDocument,
+        casterId: gameObject.id,
+    });
+    return shouldEmitEditorSceneRuntimeShadowPlan(plan, !!gameObject.shadowMode || !!gameObject.shadow)
+        ? { shadowPlan: plan }
+        : {};
+}
+function compileEditorScenePrefabRuntimeShadowPlan(input) {
+    if (!input.editorDocument)
+        return {};
+    const readable = readEditorShadowSettingsWithLegacy({
+        shadowMode: input.shadowMode,
+        shadow: input.shadow,
+    });
+    const source = readEditorSceneCompilerAssetShadowSettings(input.sourceAsset);
+    const hasAuthoringShadow = !!input.shadowMode || !!input.shadow || !!readable.shadow || !!source.shadow;
+    if (!hasAuthoringShadow && readable.diagnostics.length === 0 && source.diagnostics.length === 0)
+        return {};
+    const plan = resolveEditorShadowPlan({
+        document: input.editorDocument,
+        casterId: input.hostGameObject.id,
+        settings: {
+            source: source.shadow,
+            instance: readable.shadow,
+        },
+    });
+    const remappedPlan = {
+        ...plan,
+        casterId: input.id,
+        diagnostics: [
+            ...source.diagnostics,
+            ...readable.diagnostics,
+            ...plan.diagnostics,
+        ].map(diagnostic => ({
+            ...diagnostic,
+            casterId: diagnostic.casterId === input.hostGameObject.id || !diagnostic.casterId
+                ? input.id
+                : diagnostic.casterId,
+        })),
+    };
+    return shouldEmitEditorSceneRuntimeShadowPlan(remappedPlan, hasAuthoringShadow)
+        ? { shadowPlan: remappedPlan }
+        : {};
+}
+function readEditorSceneCompilerAssetShadowSettings(asset) {
+    if (!asset)
+        return { diagnostics: [] };
+    const defaults = asset?.defaults && typeof asset.defaults === 'object' && !Array.isArray(asset.defaults)
+        ? asset.defaults
+        : undefined;
+    if (!defaults)
+        return { diagnostics: [] };
+    const result = readEditorShadowSettingsWithLegacy({
+        shadow: defaults.shadow,
+        shadowMode: defaults.shadowMode,
+    });
+    return {
+        shadow: result.shadow,
+        diagnostics: result.diagnostics.map(diagnostic => ({
+            ...diagnostic,
+            details: {
+                ...(diagnostic.details ?? {}),
+                source: 'asset',
+                assetId: asset.id,
+            },
+        })),
+    };
+}
+function shouldEmitEditorSceneRuntimeShadowPlan(plan, hasAuthoringShadow) {
+    return hasAuthoringShadow || plan.backend !== 'none' || plan.diagnostics.length > 0;
+}
+function compileEditorScenePrefabScopedShadowPlans(input) {
+    if (input.compiledNodes.length === 0)
+        return input.compiledNodes;
+    const compiledNodeIds = new Set(input.compiledNodes.map(node => node.id));
+    const shadowDocument = {
+        ...input.editorDocument,
+        scene: {
+            ...input.editorDocument.scene,
+            gameObjects: [
+                ...input.editorDocument.scene.gameObjects.filter(gameObject => !compiledNodeIds.has(gameObject.id)),
+                ...input.compiledNodes.map(node => createEditorSceneGameObjectFromRuntimeNode(node)),
+            ],
+        },
+    };
+    const internalReceiverIds = input.compiledNodes
+        .filter((node) => node.shadow?.receive === 'enabled')
+        .map(node => node.id);
+    const internalLightId = input.compiledNodes
+        .map(node => createEditorSceneGameObjectFromRuntimeNode(node))
+        .find(gameObject => gameObject.light?.type === 'directional' && gameObject.active !== false)
+        ?.id;
+    return input.compiledNodes.map((node) => {
+        const plan = resolveEditorShadowPlan({
+            document: shadowDocument,
+            casterId: node.id,
+            explicitReceiverIds: internalReceiverIds,
+            ...(internalLightId ? { defaultLightId: internalLightId } : {}),
+        });
+        const hasAuthoringShadow = !!node.shadowMode || !!node.shadow;
+        if (!shouldEmitEditorSceneRuntimeShadowPlan(plan, hasAuthoringShadow)) {
+            if (!node.shadowPlan)
+                return node;
+            const next = { ...node };
+            delete next.shadowPlan;
+            return next;
+        }
+        return {
+            ...node,
+            shadowPlan: plan,
+        };
+    });
+}
+function createEditorSceneGameObjectFromRuntimeNode(node) {
+    const components = [];
+    if (node.transform) {
+        components.push({
+            type: 'Transform',
+            position: node.transform.position,
+            rotation: node.transform.rotation,
+            ...(node.transform.scale ? { scale: node.transform.scale } : {}),
+        });
+    }
+    if (node.kind === 'instance') {
+        components.push({
+            type: 'ModelRenderer',
+            assetId: node.instance.assetId,
+        });
+    }
+    return {
+        id: node.id,
+        ...(node.name ? { name: node.name } : {}),
+        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,
+    };
+}
+function compileEditorScenePrefabCompositionVisualOverrides(input) {
+    const materialHostGameObject = input.node.kind === 'model' && input.node.sourceAssetId
+        ? createEditorSceneCompilerPrefabModelGameObject(input.hostGameObject, input.node, input.node.sourceAssetId)
+        : input.hostGameObject;
+    const prefabOverrides = mergeEditorScenePrefabOverrideList([
+        input.prefabAsset.prefab?.overrides,
+        input.rootNode.overrides,
+        input.node.id === input.rootNode.id ? undefined : input.node.overrides,
+    ]);
+    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;
+}
+function createEditorSceneCompilerPrefabModelGameObject(hostGameObject, node, assetId) {
+    return {
+        id: `${hostGameObject.id}:${node.id}`,
+        ...(node.name ? { name: node.name } : {}),
+        kind: 'instance',
+        components: [
+            ...(node.transform ? [node.transform] : []),
+            {
+                type: 'ModelRenderer',
+                assetId,
+            },
+        ],
+    };
+}
+function createEditorSceneCompilerPrefabPrimitiveGameObject(hostGameObject, node) {
+    return {
+        id: `${hostGameObject.id}:${node.id}`,
+        ...(node.name ? { name: node.name } : {}),
+        kind: 'primitive',
+        primitive: { shape: node.primitive?.shape ?? 'cube' },
+        components: [
+            ...(node.transform ? [node.transform] : []),
+        ],
+    };
+}
+function createEditorSceneCompilerPrefabCompositionMaterialGameObject(hostGameObject, node) {
+    if (node.kind === 'model' && node.sourceAssetId) {
+        return createEditorSceneCompilerPrefabModelGameObject(hostGameObject, node, node.sourceAssetId);
+    }
+    if (node.kind === 'primitive') {
+        return createEditorSceneCompilerPrefabPrimitiveGameObject(hostGameObject, node);
+    }
+    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);
+    }
+    return next;
+}
+function orderEditorScenePrefabNodesForCompile(nodes, rootNodeId) {
+    const byParentId = new Map();
+    for (const node of nodes) {
+        if (!node.parentId)
+            continue;
+        const children = byParentId.get(node.parentId) ?? [];
+        children.push(node);
+        byParentId.set(node.parentId, children);
+    }
+    const ordered = [];
+    const visited = new Set();
+    const visit = (node) => {
+        if (visited.has(node.id))
+            return;
+        visited.add(node.id);
+        ordered.push(node);
+        for (const child of byParentId.get(node.id) ?? [])
+            visit(child);
+    };
+    const root = nodes.find(node => node.id === rootNodeId);
+    if (root)
+        visit(root);
+    for (const node of nodes)
+        visit(node);
+    return ordered;
+}
+function findEditorScenePrefabPrimaryModelNodeId(nodes, prefabAsset) {
+    const sourceAssetId = prefabAsset.prefab?.sourceAssetId;
+    return nodes.find(node => node.kind === 'model' && node.sourceAssetId === sourceAssetId)?.id
+        ?? nodes.find(node => node.kind === 'model')?.id;
+}
+function isExplicitEditorScenePrefabCompositionAsset(asset) {
+    return isEditorScenePrefabAsset(asset) && Array.isArray(asset.prefab?.nodes) && asset.prefab.nodes.length > 0;
+}
+function findEditorScenePrimitiveRenderer(gameObject) {
+    return gameObject.primitive ?? null;
+}
+function compileEditorSceneVisualOverrides(gameObject, editorDocument) {
+    const nodeKind = readEditorSceneNodeKind(gameObject);
+    if (nodeKind !== 'instance' && nodeKind !== 'transform' && nodeKind !== 'primitive')
+        return undefined;
+    const modelRenderer = findEditorSceneModelRenderer(gameObject);
+    const asset = modelRenderer ? editorDocument.assets.find((entry) => entry.id === modelRenderer.assetId) : undefined;
+    return resolveEditorSceneCompileVisualOverrides(gameObject, editorDocument, asset);
+}
+function resolveEditorSceneCompileVisualOverrides(gameObject, editorDocument, asset) {
+    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)) {
+            if (isEditorScenePrefabMaterialOverrideKey(key) || value === undefined)
+                continue;
+            next ?? (next = {});
+            next[key] = value;
+        }
+    }
+    return next && Object.keys(next).length > 0 ? next : undefined;
+}
+function readEditorSceneCompilerVisualOverrides(value) {
+    if (!isRecord(value))
+        return undefined;
+    const next = structuredClone(value);
+    return Object.keys(next).length > 0 ? next : undefined;
+}
+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,
+    };
+    for (const slot of materialSlots) {
+        const legacy = findLegacySceneMaterialSlotBinding(childMaterialBindings, slot.ownerNodePath);
+        const legacyBinding = legacy?.binding;
+        if (!legacyBinding)
+            continue;
+        materialSlotBindings[slot.slotId] = mergeEditorSceneMaterialBindingOverrides(materialSlotBindings[slot.slotId], legacyBinding);
+        delete childMaterialBindings[legacy.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('/');
+}
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function compileEditorSceneCamera(camera) {
+    const compiled = structuredClone(camera);
+    delete compiled.inspectorLanguage;
+    return compiled;
+}
+function compileEditorSceneLight(light) {
+    const compiled = structuredClone(light);
+    delete compiled.inspectorLanguage;
+    return compiled;
+}
+//# sourceMappingURL=compiler.js.map