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

package/node_modules/@fps-games/editor-babylon/dist/projection.js

@@ -3,6 +3,7 @@ import { applyBabylonDefaultOutline } from '@fps-games/babylon-renderer';
 import { applyArtistMaterialProfileToRuntimeMaterial } from './material-property-adapter.js';
 import { pickBabylonProjectionNodeIdAt, resolveBabylonPickSelectionNodeId, resolveBabylonProjectionNodeId, } from './projection-pick-resolver.js';
 import { normalizeProjectionOwnerNodePath, readProjectionSourceNodeSegment, } from './projection-source-owner-path.js';
+import { createMaterialSlotOwnerPathMatchKey, isMaterialSlotOwnerPathMatch, } from './material-slot-source-resolver.js';
 const LARGE_SELECTION_EDGE_LIMIT = 200;
 const PROJECTION_LOCAL_MATRIX_METADATA_KEY = 'editorLocalTransformMatrix';
 const ASSET_MESH_SELECTION_SEPARATOR = '::assetMesh::';
@@ -14,6 +15,9 @@ function requireBabylonCtor(value, name) {
 export function createBabylonEditorProjection(options) {
     const projections = new Map();
     const projectionParentIds = new Map();
+    const projectionAuthoredActive = new Map();
+    const previewVisibilityOverrides = new Map();
+    const shadowDebugOverlayObjects = [];
     const selectionEdgesPrewarm = options.selectionEdgesPrewarm ?? 'eager';
     const activeBatches = new Set();
     const idleWaiters = new Set();
@@ -114,6 +118,7 @@ export function createBabylonEditorProjection(options) {
             batch.settledNodeIds.add(node.id);
             if (projections.get(node.id) === projection && !projection.root.isDisposed?.()) {
                 delete projection.loadPromise;
+                applyProjectionPreviewVisibility(node.id);
                 applyProjectionOutline(node, projection);
                 scheduleProjectionSelectionEdgesPrewarm(projection);
                 options.onProjectionReady?.({ nodeId: node.id, async: true });
@@ -124,6 +129,7 @@ export function createBabylonEditorProjection(options) {
     const disposeProjectedNode = (projection) => {
         projection.selectionEdgesPrewarmCancel?.();
         projection.selectionEdgesPrewarmCancel = null;
+        projection.importStructure = null;
         for (const animationGroup of projection.animationGroups) {
             animationGroup.dispose?.();
         }
@@ -135,11 +141,42 @@ export function createBabylonEditorProjection(options) {
     const disposeAll = () => {
         markActiveBatchesStale();
         projectionGeneration += 1;
+        clearShadowDebugOverlayObjects();
         for (const projection of projections.values()) {
             disposeProjectedNode(projection);
         }
         projections.clear();
         projectionParentIds.clear();
+        projectionAuthoredActive.clear();
+        previewVisibilityOverrides.clear();
+    };
+    const createPreviewVisibilityEntry = (nodeId, visible) => {
+        const authoredActive = projectionAuthoredActive.get(nodeId) !== false;
+        return {
+            nodeId,
+            visible,
+            authoredActive,
+            effectiveVisible: authoredActive && visible !== false,
+        };
+    };
+    const applyProjectionPreviewVisibility = (nodeId) => {
+        const projection = projections.get(nodeId);
+        if (!projection)
+            return;
+        const authoredActive = projectionAuthoredActive.get(nodeId) !== false;
+        const override = previewVisibilityOverrides.get(nodeId);
+        const effectiveVisible = authoredActive && override !== false;
+        projection.root?.setEnabled?.(effectiveVisible);
+        for (const runtimeObject of projection.runtimeObjects) {
+            runtimeObject.setEnabled?.(effectiveVisible);
+        }
+    };
+    const clearShadowDebugOverlayObjects = () => {
+        const hadObjects = shadowDebugOverlayObjects.length > 0;
+        for (const object of shadowDebugOverlayObjects.splice(0)) {
+            object.dispose?.();
+        }
+        return hadObjects;
     };
     const scheduleProjectionSelectionEdgesPrewarm = (projection) => {
         projection.selectionEdgesPrewarmCancel?.();
@@ -177,7 +214,8 @@ export function createBabylonEditorProjection(options) {
         };
         projections.set(node.id, projection);
         projectionParentIds.set(node.id, node.parentId ?? null);
-        root.setEnabled?.(node.active !== false);
+        projectionAuthoredActive.set(node.id, node.active !== false);
+        applyProjectionPreviewVisibility(node.id);
         if (node.transform)
             applyProjectionTransform(options.babylon, root, node.transform);
         if (node.helperKind !== 'root' && !attachRuntimeProjection(options.babylon, options.scene, node, projection)) {
@@ -212,6 +250,8 @@ export function createBabylonEditorProjection(options) {
             return;
         projections.delete(nodeId);
         projectionParentIds.delete(nodeId);
+        projectionAuthoredActive.delete(nodeId);
+        previewVisibilityOverrides.delete(nodeId);
         syncProjectionHierarchy();
         disposeProjectedNode(existing);
     };
@@ -262,6 +302,9 @@ export function createBabylonEditorProjection(options) {
             }
             return transforms;
         },
+        readNodeImportStructure(nodeId) {
+            return cloneProjectionImportStructureSnapshot(projections.get(nodeId)?.importStructure ?? null);
+        },
         setNodeTransformPreview(nodeId, transform) {
             const projection = projections.get(nodeId);
             if (!projection?.root)
@@ -303,15 +346,28 @@ export function createBabylonEditorProjection(options) {
             const projection = projections.get(node.id);
             if (!projection)
                 return;
-            projection.root?.setEnabled?.(node.active !== false);
-            for (const runtimeObject of projection.runtimeObjects) {
-                runtimeObject.setEnabled?.(node.active !== false);
-            }
+            projectionAuthoredActive.set(node.id, node.active !== false);
+            applyProjectionPreviewVisibility(node.id);
+            projectionParentIds.set(node.id, node.parentId ?? null);
+            syncProjectionHierarchy();
+            if (node.transform)
+                applyProjectionTransform(options.babylon, projection.root, node.transform);
+            scheduleProjectionSelectionEdgesPrewarm(projection);
+        },
+        syncRuntimeNode(node) {
+            const projection = projections.get(node.id);
+            if (!projection || node.runtimeKind !== 'light')
+                return false;
+            projectionAuthoredActive.set(node.id, node.active !== false);
+            applyProjectionPreviewVisibility(node.id);
             projectionParentIds.set(node.id, node.parentId ?? null);
             syncProjectionHierarchy();
             if (node.transform)
                 applyProjectionTransform(options.babylon, projection.root, node.transform);
+            if (!syncRuntimeLightProjection(options.babylon, options.scene, node, projection))
+                return false;
             scheduleProjectionSelectionEdgesPrewarm(projection);
+            return true;
         },
         syncNodeMetadata(node) {
             const projection = projections.get(node.id);
@@ -337,6 +393,55 @@ export function createBabylonEditorProjection(options) {
         getProjectedNode(nodeId) {
             return projections.get(nodeId) ?? null;
         },
+        getProjectedNodeIds() {
+            return [...projections.keys()];
+        },
+        getProjectionParentIds(nodeId) {
+            const parentIds = [];
+            const seen = new Set([nodeId]);
+            let currentId = nodeId;
+            while (currentId) {
+                const parentId = projectionParentIds.get(currentId) ?? null;
+                if (!parentId || parentId === currentId || seen.has(parentId))
+                    break;
+                seen.add(parentId);
+                parentIds.push(parentId);
+                currentId = parentId;
+            }
+            return parentIds;
+        },
+        getPreviewVisibilityOverrides() {
+            return [...previewVisibilityOverrides.entries()]
+                .map(([nodeId, visible]) => createPreviewVisibilityEntry(nodeId, visible));
+        },
+        setPreviewVisibilityOverrides(overrides) {
+            for (const [nodeId, visible] of Object.entries(overrides)) {
+                if (!projections.has(nodeId))
+                    continue;
+                previewVisibilityOverrides.set(nodeId, visible !== false);
+                applyProjectionPreviewVisibility(nodeId);
+            }
+            return this.getPreviewVisibilityOverrides();
+        },
+        clearPreviewVisibilityOverrides() {
+            const changedNodeIds = [...previewVisibilityOverrides.keys()];
+            previewVisibilityOverrides.clear();
+            for (const nodeId of changedNodeIds)
+                applyProjectionPreviewVisibility(nodeId);
+            return [];
+        },
+        setShadowDebugOverlay(items) {
+            clearShadowDebugOverlayObjects();
+            for (const item of items) {
+                const object = createShadowDebugOverlayObject(options.babylon, options.scene, item);
+                if (object)
+                    shadowDebugOverlayObjects.push(object);
+            }
+            return items.map(item => item.id);
+        },
+        clearShadowDebugOverlay() {
+            return clearShadowDebugOverlayObjects();
+        },
         dispose() {
             disposeAll();
         },
@@ -349,6 +454,156 @@ function readVector3(value, fallback) {
         z: Number.isFinite(value?.z) ? Number(value.z) : fallback.z,
     };
 }
+function createShadowDebugOverlayObject(babylon, scene, item) {
+    if (item.kind === 'light-direction')
+        return createShadowDebugDirectionOverlay(babylon, scene, item);
+    const bounds = item.bounds ?? createBoundsFromCenterSize(item.center, item.size);
+    if (!bounds)
+        return null;
+    const MeshBuilder = babylon.MeshBuilder;
+    const StandardMaterial = babylon.StandardMaterial;
+    if (!MeshBuilder?.CreateBox || !StandardMaterial)
+        return null;
+    const size = {
+        x: Math.max(Math.abs(bounds.size.x), 0.01),
+        y: Math.max(Math.abs(bounds.size.y), item.kind === 'footprint' ? 0.015 : 0.01),
+        z: Math.max(Math.abs(bounds.size.z), 0.01),
+    };
+    const mesh = MeshBuilder.CreateBox(`${item.id}.shadowDebugOverlay`, {
+        width: size.x,
+        height: size.y,
+        depth: size.z,
+    }, scene);
+    if (!mesh)
+        return null;
+    mesh.id = item.id;
+    mesh.name = item.id;
+    mesh.isPickable = false;
+    mesh.renderingGroupId = 3;
+    mesh.metadata = createShadowDebugOverlayMetadata();
+    mesh.position = createBabylonVector3(babylon, bounds.center);
+    const material = new StandardMaterial(`${item.id}.shadowDebugOverlay.material`, scene);
+    const color = readShadowDebugOverlayColor(babylon, item.kind);
+    if (color) {
+        material.diffuseColor = color;
+        material.emissiveColor = color;
+    }
+    material.alpha = item.kind === 'receiver-surface' ? 0.14 : item.kind === 'footprint' ? 0.32 : 0.5;
+    material.wireframe = item.kind !== 'footprint' && item.kind !== 'receiver-surface';
+    material.disableLighting = true;
+    mesh.material = material;
+    const disposeMaterial = material.dispose?.bind(material);
+    const disposeMesh = mesh.dispose?.bind(mesh);
+    mesh.dispose = (...args) => {
+        disposeMaterial?.();
+        return disposeMesh?.(...args);
+    };
+    return mesh;
+}
+function createShadowDebugDirectionOverlay(babylon, scene, item) {
+    const MeshBuilder = babylon.MeshBuilder;
+    if (!MeshBuilder?.CreateLineSystem)
+        return null;
+    const center = item.center ?? item.bounds?.center;
+    const direction = normalizeDebugVec3(item.direction ?? { x: -0.3, y: -1, z: -0.2 });
+    if (!center || !direction)
+        return null;
+    const length = Math.max(item.size?.x ?? item.bounds?.size.x ?? 2, item.size?.y ?? item.bounds?.size.y ?? 2, item.size?.z ?? item.bounds?.size.z ?? 2, 2);
+    const start = createBabylonVector3(babylon, {
+        x: center.x - direction.x * length * 0.5,
+        y: center.y - direction.y * length * 0.5,
+        z: center.z - direction.z * length * 0.5,
+    });
+    const end = createBabylonVector3(babylon, {
+        x: center.x + direction.x * length * 0.5,
+        y: center.y + direction.y * length * 0.5,
+        z: center.z + direction.z * length * 0.5,
+    });
+    const arrowLeft = createBabylonVector3(babylon, {
+        x: end.x - direction.x * length * 0.18 + direction.z * length * 0.08,
+        y: end.y - direction.y * length * 0.18,
+        z: end.z - direction.z * length * 0.18 - direction.x * length * 0.08,
+    });
+    const arrowRight = createBabylonVector3(babylon, {
+        x: end.x - direction.x * length * 0.18 - direction.z * length * 0.08,
+        y: end.y - direction.y * length * 0.18,
+        z: end.z - direction.z * length * 0.18 + direction.x * length * 0.08,
+    });
+    const line = MeshBuilder.CreateLineSystem(`${item.id}.shadowDebugOverlay`, {
+        lines: [
+            [start, end],
+            [end, arrowLeft],
+            [end, arrowRight],
+        ],
+    }, scene);
+    if (!line)
+        return null;
+    line.id = item.id;
+    line.name = item.id;
+    line.isPickable = false;
+    line.renderingGroupId = 3;
+    line.metadata = createShadowDebugOverlayMetadata();
+    const color = readShadowDebugOverlayColor(babylon, item.kind);
+    if (color)
+        line.color = color;
+    return line;
+}
+function createShadowDebugOverlayMetadata() {
+    return {
+        shadowDebugOverlayInternal: true,
+        disablePlanarShadow: true,
+        disableBlobShadow: true,
+        disableStaticProjectedShadow: true,
+    };
+}
+function createBoundsFromCenterSize(center, size) {
+    if (!center || !size)
+        return null;
+    return {
+        center,
+        size,
+        min: {
+            x: center.x - size.x / 2,
+            y: center.y - size.y / 2,
+            z: center.z - size.z / 2,
+        },
+        max: {
+            x: center.x + size.x / 2,
+            y: center.y + size.y / 2,
+            z: center.z + size.z / 2,
+        },
+    };
+}
+function createBabylonVector3(babylon, value) {
+    const Vector3 = babylon.Vector3;
+    return Vector3 ? new Vector3(value.x, value.y, value.z) : { x: value.x, y: value.y, z: value.z };
+}
+function normalizeDebugVec3(value) {
+    const length = Math.hypot(value.x, value.y, value.z);
+    if (!Number.isFinite(length) || length <= 0.0001)
+        return null;
+    return {
+        x: value.x / length,
+        y: value.y / length,
+        z: value.z / length,
+    };
+}
+function readShadowDebugOverlayColor(babylon, kind) {
+    const Color3 = babylon.Color3;
+    if (!Color3)
+        return null;
+    if (kind === 'caster-bounds')
+        return new Color3(1, 0.78, 0.1);
+    if (kind === 'receiver-bounds')
+        return new Color3(0.1, 0.75, 1);
+    if (kind === 'receiver-surface')
+        return new Color3(0.05, 0.55, 1);
+    if (kind === 'light-direction')
+        return new Color3(1, 0.95, 0.2);
+    if (kind === 'footprint')
+        return new Color3(0.1, 1, 0.42);
+    return new Color3(1, 0.25, 0.25);
+}
 function addVec3(left, right) {
     return {
         x: left.x + right.x,
@@ -478,7 +733,7 @@ function createProjectionRoot(babylon, scene, node) {
         editorProjection: {
             nodeId: node.id,
             ...(node.runtimeKind ? { runtimeKind: node.runtimeKind } : {}),
-            ...(node.shadowMode ? { shadowMode: node.shadowMode } : {}),
+            ...createProjectionShadowMetadata(node),
         },
     };
     return root;
@@ -531,7 +786,7 @@ function attachImportedProjectionResult(options, node, asset, projection, result
             editorProjection: {
                 nodeId: node.id,
                 sourceId: asset.sourceId,
-                ...(node.shadowMode ? { shadowMode: node.shadowMode } : {}),
+                ...createProjectionShadowMetadata(node),
             },
         };
         applyAssetDefaultsTransform(babylon, modelRoot, asset.transform);
@@ -551,7 +806,7 @@ function attachImportedProjectionResult(options, node, asset, projection, result
                 editorProjection: {
                     nodeId: node.id,
                     sourceId: asset.sourceId,
-                    ...(node.shadowMode ? { shadowMode: node.shadowMode } : {}),
+                    ...createProjectionShadowMetadata(node),
                 },
             };
         }
@@ -570,7 +825,7 @@ function attachImportedProjectionResult(options, node, asset, projection, result
                         ownerNodePath,
                         ...(selectionKey !== ownerNodePath ? { slotSelectionKey: selectionKey } : {}),
                         runtimeKind: 'assetMesh',
-                        ...(node.shadowMode ? { shadowMode: node.shadowMode } : {}),
+                        ...createProjectionShadowMetadata(node),
                     },
                 };
             }
@@ -581,12 +836,215 @@ function attachImportedProjectionResult(options, node, asset, projection, result
         }
         projection.animationGroups = result.animationGroups ?? [];
         projection.outlineMeshes = (result.meshes ?? []).filter((mesh) => mesh.getTotalVertices?.() > 0);
+        projection.importStructure = createProjectionImportStructureSnapshot(node, asset, modelRoot, result);
     }
     catch (error) {
         disposeImportedProjectionResult(result);
         throw error;
     }
 }
+function createProjectionImportStructureSnapshot(node, asset, modelRoot, result) {
+    const runtimeNodes = collectProjectionImportRuntimeNodes(modelRoot, result);
+    const nodeIdByRuntimeNode = new Map();
+    const materialIdByRuntimeMaterial = new Map();
+    const textureIdByRuntimeTexture = new Map();
+    const materialNodeIds = new Map();
+    const materialTextureIds = new Map();
+    const rootSnapshotId = 'root';
+    const snapshots = [{
+            id: rootSnapshotId,
+            parentId: null,
+            name: readProjectionRuntimeName(modelRoot, node.name ?? node.id),
+            kind: 'root',
+        }];
+    for (const runtimeNode of runtimeNodes) {
+        const snapshotId = createProjectionImportRuntimeNodeId(runtimeNode, nodeIdByRuntimeNode.size);
+        nodeIdByRuntimeNode.set(runtimeNode, snapshotId);
+    }
+    for (const runtimeNode of runtimeNodes) {
+        const snapshotId = nodeIdByRuntimeNode.get(runtimeNode);
+        if (!snapshotId)
+            continue;
+        const materialIds = readProjectionRuntimeNodeMaterials(runtimeNode)
+            .map(runtimeMaterial => getProjectionImportMaterialSnapshotId(runtimeMaterial, materialIdByRuntimeMaterial))
+            .filter((materialId) => !!materialId);
+        for (const materialId of materialIds) {
+            const nodeIds = materialNodeIds.get(materialId) ?? new Set();
+            nodeIds.add(snapshotId);
+            materialNodeIds.set(materialId, nodeIds);
+            const textureIds = readProjectionRuntimeMaterialTextures(readProjectionRuntimeNodeMaterialById(runtimeNode, runtimeNode, materialId, materialIdByRuntimeMaterial))
+                .map(runtimeTexture => getProjectionImportTextureSnapshotId(runtimeTexture, textureIdByRuntimeTexture))
+                .filter((textureId) => !!textureId);
+            const materialTextures = materialTextureIds.get(materialId) ?? new Set();
+            for (const textureId of textureIds)
+                materialTextures.add(textureId);
+            materialTextureIds.set(materialId, materialTextures);
+        }
+        snapshots.push({
+            id: snapshotId,
+            parentId: resolveProjectionImportRuntimeParentId(runtimeNode, modelRoot, nodeIdByRuntimeNode, rootSnapshotId),
+            name: readProjectionRuntimeName(runtimeNode, snapshotId),
+            kind: isProjectionRuntimeMeshLike(runtimeNode) ? 'mesh' : 'transform',
+            ...readProjectionRuntimeSourceName(runtimeNode),
+            ...readProjectionRuntimeOwnerNodePath(runtimeNode),
+            ...(materialIds.length > 0 ? { materialIds } : {}),
+        });
+    }
+    const materials = [...materialIdByRuntimeMaterial.entries()].map(([runtimeMaterial, id]) => ({
+        id,
+        name: readProjectionRuntimeName(runtimeMaterial, id),
+        ...readProjectionRuntimeKind(runtimeMaterial),
+        nodeIds: [...(materialNodeIds.get(id) ?? [])],
+        textureIds: [...(materialTextureIds.get(id) ?? [])],
+    }));
+    const textures = [...textureIdByRuntimeTexture.entries()].map(([runtimeTexture, id]) => ({
+        id,
+        name: readProjectionRuntimeName(runtimeTexture, id),
+        ...readProjectionRuntimeKind(runtimeTexture),
+        ...readProjectionRuntimeTextureUrl(runtimeTexture),
+    }));
+    const animations = createProjectionImportAnimationSnapshots(result.animationGroups ?? []);
+    return {
+        projectionNodeId: node.id,
+        ...(asset.id ? { assetId: asset.id } : {}),
+        ...(asset.sourceId ? { sourceId: asset.sourceId } : {}),
+        nodes: snapshots,
+        materials,
+        textures,
+        animations,
+    };
+}
+function collectProjectionImportRuntimeNodes(modelRoot, result) {
+    const known = new Set([
+        ...(result.transformNodes ?? []),
+        ...(result.meshes ?? []),
+    ].filter(Boolean));
+    const ordered = [];
+    const visit = (runtimeNode) => {
+        for (const child of readProjectionRuntimeChildren(runtimeNode)) {
+            if (!known.has(child) || ordered.includes(child))
+                continue;
+            ordered.push(child);
+            visit(child);
+        }
+    };
+    visit(modelRoot);
+    for (const runtimeNode of known) {
+        if (!ordered.includes(runtimeNode))
+            ordered.push(runtimeNode);
+    }
+    return ordered;
+}
+function readProjectionRuntimeChildren(runtimeNode) {
+    const children = runtimeNode?.getChildren?.();
+    return Array.isArray(children) ? children : [];
+}
+function createProjectionImportRuntimeNodeId(runtimeNode, index) {
+    const sourceName = readProjectionSourceNodeSegment(runtimeNode);
+    const rawName = sourceName || runtimeNode?.name || runtimeNode?.id || `node-${index + 1}`;
+    return `${isProjectionRuntimeMeshLike(runtimeNode) ? 'mesh' : 'node'}:${sanitizeProjectionImportSnapshotId(rawName)}:${index + 1}`;
+}
+function resolveProjectionImportRuntimeParentId(runtimeNode, modelRoot, nodeIdByRuntimeNode, rootSnapshotId) {
+    const parent = runtimeNode?.parent ?? null;
+    if (!parent || parent === modelRoot)
+        return rootSnapshotId;
+    return nodeIdByRuntimeNode.get(parent) ?? rootSnapshotId;
+}
+function isProjectionRuntimeMeshLike(runtimeNode) {
+    return typeof runtimeNode?.getTotalVertices === 'function';
+}
+function readProjectionRuntimeNodeMaterials(runtimeNode) {
+    const material = runtimeNode?.material;
+    if (!material)
+        return [];
+    const subMaterials = material.subMaterials;
+    if (Array.isArray(subMaterials) && subMaterials.length > 0) {
+        return subMaterials.filter(Boolean);
+    }
+    return [material];
+}
+function readProjectionRuntimeNodeMaterialById(runtimeNode, _fallbackNode, materialId, materialIdByRuntimeMaterial) {
+    for (const material of readProjectionRuntimeNodeMaterials(runtimeNode)) {
+        if (materialIdByRuntimeMaterial.get(material) === materialId)
+            return material;
+    }
+    return null;
+}
+function getProjectionImportMaterialSnapshotId(runtimeMaterial, materialIdByRuntimeMaterial) {
+    if (!runtimeMaterial)
+        return null;
+    const existing = materialIdByRuntimeMaterial.get(runtimeMaterial);
+    if (existing)
+        return existing;
+    const id = `material:${sanitizeProjectionImportSnapshotId(readProjectionRuntimeName(runtimeMaterial, 'material'))}:${materialIdByRuntimeMaterial.size + 1}`;
+    materialIdByRuntimeMaterial.set(runtimeMaterial, id);
+    return id;
+}
+function readProjectionRuntimeMaterialTextures(runtimeMaterial) {
+    if (!runtimeMaterial)
+        return [];
+    const textures = runtimeMaterial.getActiveTextures?.();
+    return Array.isArray(textures) ? textures.filter(Boolean) : [];
+}
+function getProjectionImportTextureSnapshotId(runtimeTexture, textureIdByRuntimeTexture) {
+    if (!runtimeTexture)
+        return null;
+    const existing = textureIdByRuntimeTexture.get(runtimeTexture);
+    if (existing)
+        return existing;
+    const name = readProjectionRuntimeTextureUrl(runtimeTexture).url
+        ?? readProjectionRuntimeName(runtimeTexture, 'texture');
+    const id = `texture:${sanitizeProjectionImportSnapshotId(name)}:${textureIdByRuntimeTexture.size + 1}`;
+    textureIdByRuntimeTexture.set(runtimeTexture, id);
+    return id;
+}
+function createProjectionImportAnimationSnapshots(animationGroups) {
+    return animationGroups.filter(Boolean).map((animationGroup, index) => ({
+        id: `animation:${sanitizeProjectionImportSnapshotId(readProjectionRuntimeName(animationGroup, 'animation'))}:${index + 1}`,
+        name: readProjectionRuntimeName(animationGroup, `Animation ${index + 1}`),
+    }));
+}
+function readProjectionRuntimeName(runtimeObject, fallback) {
+    const name = runtimeObject?.name ?? runtimeObject?.id;
+    return typeof name === 'string' && name.trim() ? name.trim() : fallback;
+}
+function readProjectionRuntimeKind(runtimeObject) {
+    const kind = runtimeObject?.getClassName?.();
+    return typeof kind === 'string' && kind.trim() ? { kind: kind.trim() } : {};
+}
+function readProjectionRuntimeTextureUrl(runtimeTexture) {
+    const url = runtimeTexture?.url ?? runtimeTexture?.name;
+    return typeof url === 'string' && url.trim() ? { url: url.trim() } : {};
+}
+function readProjectionRuntimeSourceName(runtimeNode) {
+    const sourceName = readProjectionSourceNodeSegment(runtimeNode);
+    return sourceName ? { sourceName } : {};
+}
+function readProjectionRuntimeOwnerNodePath(runtimeNode) {
+    const ownerNodePath = runtimeNode?.metadata?.editorProjection?.ownerNodePath;
+    return typeof ownerNodePath === 'string' && ownerNodePath.trim() ? { ownerNodePath: ownerNodePath.trim() } : {};
+}
+function sanitizeProjectionImportSnapshotId(value) {
+    return value.trim().toLowerCase().replace(/[^a-z0-9_.:-]+/gi, '-').replace(/^-+|-+$/g, '') || 'item';
+}
+function cloneProjectionImportStructureSnapshot(snapshot) {
+    if (!snapshot)
+        return null;
+    return {
+        ...snapshot,
+        nodes: snapshot.nodes.map(item => ({
+            ...item,
+            ...(item.materialIds ? { materialIds: [...item.materialIds] } : {}),
+        })),
+        materials: snapshot.materials.map(item => ({
+            ...item,
+            nodeIds: [...item.nodeIds],
+            textureIds: [...item.textureIds],
+        })),
+        textures: snapshot.textures.map(item => ({ ...item })),
+        animations: snapshot.animations.map(item => ({ ...item })),
+    };
+}
 function disposeImportedProjectionResult(result) {
     for (const animationGroup of result.animationGroups ?? []) {
         animationGroup.dispose?.();
@@ -655,6 +1113,8 @@ function attachDirectionalLightProjection(babylon, scene, node, projection) {
         light.setEnabled?.(node.active !== false);
         projection.runtimeObjects.push(light);
     }
+    if (!settings.helperVisible)
+        return;
     const helper = MeshBuilder.CreateBox(`${node.id}.lightHelper`, {
         size: 0.28,
     }, scene);
@@ -755,14 +1215,14 @@ function createPrimitiveProjectionMesh(babylon, scene, node, options) {
     mesh.metadata = createProjectionMetadata(node.id, {
         runtimeKind: 'primitive',
         primitiveShape: shape,
-        ...(node.shadowMode ? { shadowMode: node.shadowMode } : {}),
+        ...createProjectionShadowMetadata(node),
     });
     return mesh;
 }
 function applyProjectionArtistMaterialProfilesToMeshes(options, node, modelRoot, meshes) {
-    const slotProfiles = node.artistMaterialSlotProfiles ?? {};
+    const slotBindings = createProjectionMaterialSlotBindings(node);
     const hasRootProfile = !!node.artistMaterialProfile;
-    const hasSlotProfiles = Object.keys(slotProfiles).length > 0;
+    const hasSlotProfiles = slotBindings.length > 0;
     if (!hasRootProfile && !hasSlotProfiles)
         return [];
     const clonedMaterials = [];
@@ -785,15 +1245,15 @@ function applyProjectionArtistMaterialProfilesToMeshes(options, node, modelRoot,
         if (!material)
             continue;
         const ownerNodePath = buildProjectionOwnerNodePath(mesh, modelRoot, node.id);
-        const slotProfile = resolveProjectionSlotProfile(slotProfiles, ownerNodePath, node.id);
-        if (!slotProfile)
+        const slotBinding = resolveProjectionSlotBinding(slotBindings, ownerNodePath, node.id);
+        if (!slotBinding)
             continue;
         const slotMaterial = detachProjectionSlotMaterial(mesh, materialCounts, ownerNodePath);
         if (!slotMaterial)
             continue;
         if (slotMaterial !== material)
             clonedMaterials.push(slotMaterial);
-        applyProjectionArtistMaterialProfile(options, slotMaterial, slotProfile);
+        applyProjectionArtistMaterialProfile(options, slotMaterial, slotBinding.profile);
     }
     return clonedMaterials;
 }
@@ -805,27 +1265,85 @@ function applyProjectionArtistMaterialProfile(options, material, profile) {
         resolveTextureUrl: options.resolveTextureUrl,
     });
 }
-function resolveProjectionSlotProfile(slotProfiles, ownerNodePath, projectionNodeId) {
+function createProjectionMaterialSlotBindings(node) {
+    const bindings = [];
+    const occupiedOwnerPaths = new Set();
+    for (const binding of node.artistMaterialSlotBindings ?? []) {
+        const profile = binding?.profile;
+        const slot = createProjectionMaterialSlotDescriptor(binding?.slot, node.id);
+        if (!profile || !slot)
+            continue;
+        bindings.push({ slot, profile });
+        occupiedOwnerPaths.add(slot.matchKey);
+    }
+    for (const [ownerNodePath, profile] of Object.entries(node.artistMaterialSlotProfiles ?? {})) {
+        const slot = createProjectionMaterialSlotDescriptor({ ownerNodePath }, node.id);
+        if (!profile || !slot || occupiedOwnerPaths.has(slot.matchKey))
+            continue;
+        bindings.push({ slot, profile });
+        occupiedOwnerPaths.add(slot.matchKey);
+    }
+    return bindings;
+}
+function createProjectionMaterialSlotDescriptor(value, projectionNodeId) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const ownerNodePath = typeof value.ownerNodePath === 'string'
+        ? normalizeProjectionOwnerNodePath(value.ownerNodePath, { projectionNodeId })
+        : '';
+    if (!ownerNodePath)
+        return null;
+    const slotId = typeof value.slotId === 'string' && value.slotId.trim() ? value.slotId.trim() : '';
+    const label = typeof value.label === 'string' && value.label.trim() ? value.label.trim() : '';
+    const nodeIndex = Number.isInteger(value.nodeIndex) ? value.nodeIndex : undefined;
+    const nodeIndexPath = Array.isArray(value.nodeIndexPath)
+        ? value.nodeIndexPath.filter((item) => Number.isInteger(item))
+        : undefined;
+    const meshIndex = Number.isInteger(value.meshIndex) ? value.meshIndex : undefined;
+    const primitiveIndex = Number.isInteger(value.primitiveIndex) ? value.primitiveIndex : undefined;
+    const sourceMaterialIndex = Number.isInteger(value.sourceMaterialIndex) ? value.sourceMaterialIndex : undefined;
+    const sourceMaterialIndices = Array.isArray(value.sourceMaterialIndices)
+        ? value.sourceMaterialIndices.filter((item) => Number.isInteger(item))
+        : undefined;
+    const materialName = typeof value.materialName === 'string' && value.materialName.trim() ? value.materialName.trim() : '';
+    const materialNames = Array.isArray(value.materialNames)
+        ? value.materialNames.filter((item) => typeof item === 'string' && !!item.trim()).map(item => item.trim())
+        : undefined;
+    return {
+        ...(slotId ? { slotId } : {}),
+        ownerNodePath,
+        ...(label ? { label } : {}),
+        ...(nodeIndex != null ? { nodeIndex } : {}),
+        ...(nodeIndexPath && nodeIndexPath.length > 0 ? { nodeIndexPath } : {}),
+        ...(meshIndex != null ? { meshIndex } : {}),
+        ...(primitiveIndex != null ? { primitiveIndex } : {}),
+        ...(sourceMaterialIndex != null ? { sourceMaterialIndex } : {}),
+        ...(sourceMaterialIndices && sourceMaterialIndices.length > 0
+            ? { sourceMaterialIndices }
+            : {}),
+        ...(materialName ? { materialName } : {}),
+        ...(materialNames && materialNames.length > 0 ? { materialNames } : {}),
+        key: slotId || ownerNodePath,
+        normalizedOwnerNodePath: ownerNodePath,
+        matchKey: createMaterialSlotOwnerPathMatchKey(ownerNodePath, { projectionNodeId }),
+    };
+}
+function resolveProjectionSlotBinding(slotBindings, ownerNodePath, projectionNodeId) {
     if (ownerNodePath == null)
         return null;
-    const direct = slotProfiles[ownerNodePath];
-    if (direct)
-        return direct;
     const normalized = normalizeProjectionOwnerNodePath(ownerNodePath, { projectionNodeId });
-    if (normalized !== ownerNodePath && slotProfiles[normalized])
-        return slotProfiles[normalized];
+    const normalizedMatchKey = createMaterialSlotOwnerPathMatchKey(normalized, { projectionNodeId });
     let descendantMatch = null;
-    for (const [candidatePath, profile] of Object.entries(slotProfiles)) {
-        const normalizedCandidate = normalizeProjectionOwnerNodePath(candidatePath, { projectionNodeId });
-        if (normalizedCandidate === normalized)
-            return profile;
-        if (isProjectionOwnerPathDescendant(normalized, normalizedCandidate)) {
-            if (!descendantMatch || normalizedCandidate.length > descendantMatch.path.length) {
-                descendantMatch = { path: normalizedCandidate, profile };
+    for (const binding of slotBindings) {
+        if (binding.slot.matchKey === normalizedMatchKey)
+            return binding;
+        if (isMaterialSlotOwnerPathMatch(normalized, binding.slot.normalizedOwnerNodePath, { projectionNodeId })) {
+            if (!descendantMatch || binding.slot.matchKey.length > descendantMatch.slot.matchKey.length) {
+                descendantMatch = binding;
             }
         }
     }
-    return descendantMatch?.profile ?? null;
+    return descendantMatch;
 }
 function buildProjectionOwnerNodePath(node, rootNode, projectionNodeId) {
     if (!node || !rootNode || node === rootNode)
@@ -857,11 +1375,6 @@ function stableProjectionNodeSegment(node) {
     }
     return null;
 }
-function isProjectionOwnerPathDescendant(ownerNodePath, candidateAncestorPath) {
-    if (!ownerNodePath || !candidateAncestorPath)
-        return false;
-    return ownerNodePath.startsWith(`${candidateAncestorPath}/`);
-}
 function createAssetMeshProjectionNodeId(rootNodeId, ownerNodePath) {
     return `${rootNodeId}${ASSET_MESH_SELECTION_SEPARATOR}${encodeURIComponent(ownerNodePath)}`;
 }
@@ -869,9 +1382,9 @@ function resolveProjectionAssetMeshSelectionKey(asset, ownerNodePath, projection
     const normalizedOwnerPath = normalizeProjectionOwnerNodePath(ownerNodePath, { projectionNodeId });
     let bestSlot = null;
     for (const slot of readProjectionAssetMaterialSlots(asset, projectionNodeId)) {
-        if (!isProjectionOwnerPathSlotMatch(normalizedOwnerPath, slot.path))
+        if (!isMaterialSlotOwnerPathMatch(normalizedOwnerPath, slot.normalizedOwnerNodePath, { projectionNodeId }))
             continue;
-        if (!bestSlot || slot.path.length > bestSlot.path.length) {
+        if (!bestSlot || slot.matchKey.length > bestSlot.matchKey.length) {
             bestSlot = slot;
         }
     }
@@ -891,8 +1404,7 @@ function readProjectionAssetMaterialSlots(asset, projectionNodeId) {
 }
 function readProjectionAssetMaterialSlot(value, projectionNodeId) {
     if (typeof value === 'string') {
-        const path = normalizeProjectionOwnerNodePath(value, { projectionNodeId });
-        return path ? { key: path, path } : null;
+        return createProjectionMaterialSlotDescriptor({ ownerNodePath: value }, projectionNodeId);
     }
     if (!value || typeof value !== 'object' || Array.isArray(value))
         return null;
@@ -900,23 +1412,11 @@ function readProjectionAssetMaterialSlot(value, projectionNodeId) {
     const rawOwnerPath = readProjectionAssetMaterialSlotString(record.ownerNodePath)
         || readProjectionAssetMaterialSlotString(record.path)
         || readProjectionAssetMaterialSlotString(record.name);
-    const path = normalizeProjectionOwnerNodePath(rawOwnerPath, { projectionNodeId });
-    if (!path)
-        return null;
-    const slotId = readProjectionAssetMaterialSlotString(record.slotId);
-    return {
-        key: slotId || path,
-        path,
-    };
+    return createProjectionMaterialSlotDescriptor({ ...record, ownerNodePath: rawOwnerPath }, projectionNodeId);
 }
 function readProjectionAssetMaterialSlotString(value) {
     return typeof value === 'string' ? value.trim() : '';
 }
-function isProjectionOwnerPathSlotMatch(ownerNodePath, slotOwnerPath) {
-    if (!ownerNodePath || !slotOwnerPath)
-        return false;
-    return ownerNodePath === slotOwnerPath || isProjectionOwnerPathDescendant(ownerNodePath, slotOwnerPath);
-}
 function countProjectionMeshMaterials(meshes) {
     const counts = new Map();
     for (const mesh of meshes) {
@@ -992,7 +1492,7 @@ function createFallbackProjectionMesh(babylon, scene, node, rendererFallback) {
         editorProjection: {
             nodeId: node.id,
             fallback: true,
-            ...(node.shadowMode ? { shadowMode: node.shadowMode } : {}),
+            ...createProjectionShadowMetadata(node),
         },
     };
     return mesh;
@@ -1112,6 +1612,8 @@ function attachHemisphericLightProjection(babylon, scene, node, projection) {
         light.setEnabled?.(node.active !== false);
         projection.runtimeObjects.push(light);
     }
+    if (!settings.helperVisible)
+        return;
     const helper = MeshBuilder.CreateSphere?.(`${node.id}.hemisphericLightHelper`, {
         diameter: 0.32,
         segments: 18,
@@ -1134,6 +1636,76 @@ function attachHemisphericLightProjection(babylon, scene, node, projection) {
     projection.runtimeObjects.push(material);
     projection.outlineMeshes = [helper];
 }
+function syncRuntimeLightProjection(babylon, scene, node, projection) {
+    if (node.light?.type === 'hemispheric') {
+        return syncRuntimeHemisphericLightProjection(babylon, scene, node, projection);
+    }
+    return syncRuntimeDirectionalLightProjection(babylon, scene, node, projection);
+}
+function syncRuntimeDirectionalLightProjection(babylon, scene, node, projection) {
+    const settings = readProjectionDirectionalLightSettings(node.light?.type === 'directional' ? node.light : undefined);
+    const light = findProjectionRuntimeLight(projection, node.id, 'directional');
+    if (!light)
+        return false;
+    const hasHelper = !!scene.getMeshByName?.(`${node.id}.lightHelper`);
+    if (settings.helperVisible !== hasHelper)
+        return false;
+    const Vector3 = requireBabylonCtor(babylon.Vector3, 'Vector3');
+    const Color3 = requireBabylonCtor(babylon.Color3, 'Color3');
+    copyOrAssignBabylonVec3(light, 'direction', new Vector3(settings.direction.x, settings.direction.y, settings.direction.z));
+    light.intensity = settings.intensity;
+    copyOrAssignBabylonColor(light, 'diffuse', new Color3(settings.diffuseColor?.r ?? 1, settings.diffuseColor?.g ?? 1, settings.diffuseColor?.b ?? 1));
+    light.setEnabled?.(node.active !== false);
+    if (settings.helperVisible)
+        refreshLightDirectionLines(babylon, scene, node, projection, settings.direction);
+    return true;
+}
+function syncRuntimeHemisphericLightProjection(babylon, scene, node, projection) {
+    const settings = readProjectionHemisphericLightSettings(node.light?.type === 'hemispheric' ? node.light : undefined);
+    const light = findProjectionRuntimeLight(projection, node.id, 'hemispheric');
+    if (!light)
+        return false;
+    const hasHelper = !!scene.getMeshByName?.(`${node.id}.hemisphericLightHelper`);
+    if (settings.helperVisible !== hasHelper)
+        return false;
+    const Color3 = requireBabylonCtor(babylon.Color3, 'Color3');
+    light.intensity = settings.intensity;
+    copyOrAssignBabylonColor(light, 'diffuse', new Color3(settings.diffuseColor?.r ?? 1, settings.diffuseColor?.g ?? 1, settings.diffuseColor?.b ?? 1));
+    copyOrAssignBabylonColor(light, 'groundColor', new Color3(settings.groundColor?.r ?? 0.48, settings.groundColor?.g ?? 0.52, settings.groundColor?.b ?? 0.62));
+    light.setEnabled?.(node.active !== false);
+    return true;
+}
+function findProjectionRuntimeLight(projection, nodeId, lightType) {
+    return projection.runtimeObjects.find(runtimeObject => {
+        const metadata = runtimeObject?.metadata?.editorProjection;
+        return metadata?.nodeId === nodeId
+            && metadata?.runtimeKind === 'light'
+            && metadata?.lightType === lightType;
+    }) ?? null;
+}
+function refreshLightDirectionLines(babylon, scene, node, projection, direction) {
+    const existing = scene.getMeshByName?.(`${node.id}.lightDirection`);
+    existing?.dispose?.();
+    const arrow = createLightDirectionLines(babylon, scene, node, direction);
+    if (!arrow)
+        return;
+    arrow.parent = projection.root;
+    arrow.isPickable = false;
+}
+function copyOrAssignBabylonVec3(target, key, value) {
+    if (target?.[key]?.copyFrom) {
+        target[key].copyFrom(value);
+        return;
+    }
+    target[key] = value;
+}
+function copyOrAssignBabylonColor(target, key, value) {
+    if (target?.[key]?.copyFrom) {
+        target[key].copyFrom(value);
+        return;
+    }
+    target[key] = value;
+}
 export function normalizeBabylonEditorProjectionCameraSettings(settings) {
     const targetOffset = readOptionalProjectionVec3(settings?.targetOffset);
     const targetScreenOffset = readOptionalProjectionVec2(settings?.targetScreenOffset);
@@ -1258,6 +1830,7 @@ function readProjectionDirectionalLightSettings(settings) {
         intensity: Math.max(0, readFiniteNumber(settings?.intensity, 2)),
         direction: readVector3(settings?.direction, { x: -0.3, y: -1, z: -0.2 }),
         diffuseColor: readProjectionColor(settings?.diffuseColor, { r: 1, g: 1, b: 1 }),
+        helperVisible: settings?.helperVisible !== false,
     };
 }
 function readProjectionHemisphericLightSettings(settings) {
@@ -1266,6 +1839,7 @@ function readProjectionHemisphericLightSettings(settings) {
         intensity: Math.max(0, readFiniteNumber(settings?.intensity, 0.8)),
         diffuseColor: readProjectionColor(settings?.diffuseColor, { r: 1, g: 1, b: 1 }),
         groundColor: readProjectionColor(settings?.groundColor, { r: 0.48, g: 0.52, b: 0.62 }),
+        helperVisible: settings?.helperVisible !== false,
     };
 }
 function readProjectionColor(value, fallback) {
@@ -1304,6 +1878,13 @@ function createProjectionMetadata(nodeId, extra = {}) {
         },
     };
 }
+function createProjectionShadowMetadata(node) {
+    return {
+        ...(node.shadowMode ? { shadowMode: node.shadowMode } : {}),
+        ...(node.shadow ? { shadow: structuredClone(node.shadow) } : {}),
+        ...(node.shadowPlan ? { shadowPlan: structuredClone(node.shadowPlan) } : {}),
+    };
+}
 function syncProjectionNodeMetadata(projection, node) {
     walkProjectionRuntimeNodes(projection.root, (runtimeNode) => {
         syncProjectionRuntimeNodeMetadata(runtimeNode, node);
@@ -1332,6 +1913,14 @@ function syncProjectionRuntimeNodeMetadata(runtimeNode, node) {
         nextEditorProjection.shadowMode = node.shadowMode;
     else
         delete nextEditorProjection.shadowMode;
+    if (node.shadow)
+        nextEditorProjection.shadow = structuredClone(node.shadow);
+    else
+        delete nextEditorProjection.shadow;
+    if (node.shadowPlan)
+        nextEditorProjection.shadowPlan = structuredClone(node.shadowPlan);
+    else
+        delete nextEditorProjection.shadowPlan;
     runtimeNode.metadata = {
         ...(metadata ?? {}),
         editorProjection: nextEditorProjection,