@fps-games/editor 0.1.3-beta.4 → 0.1.4-beta.2

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

@@ -1,4 +1,7 @@
-import { applyArtistMaterialProfileToRuntimeMaterial } from './material-property-adapter';
+import { combineEditorTransforms, toEditorLocalTransformFromWorld, } from '@fps-games/editor-core';
+import { applyBabylonDefaultOutline } from '@fps-games/babylon-renderer';
+import { applyArtistMaterialProfileToRuntimeMaterial } from './material-property-adapter.js';
+const ASSET_MESH_SELECTION_SEPARATOR = '::assetMesh::';
 function requireBabylonCtor(value, name) {
     if (!value)
         throw new Error(`Babylon runtime missing ${name}`);
@@ -6,6 +9,7 @@ function requireBabylonCtor(value, name) {
 }
 export function createBabylonEditorProjection(options) {
     const projections = new Map();
+    const projectionParentIds = new Map();
     let nextBatchId = 1;
     let projectionGeneration = 0;
     const createBatch = (nodeIds) => {
@@ -44,6 +48,9 @@ export function createBabylonEditorProjection(options) {
             batch.pendingNodeIds.delete(node.id);
             batch.settledNodeIds.add(node.id);
             if (projections.get(node.id) === projection && !projection.root.isDisposed?.()) {
+                delete projection.loadPromise;
+                applyProjectionOutline(node, projection);
+                prewarmProjectionSelectionEdges(projection);
                 options.onProjectionReady?.({ nodeId: node.id, async: true });
             }
             scheduleBatchSettled(batch);
@@ -64,6 +71,18 @@ export function createBabylonEditorProjection(options) {
             disposeProjectedNode(projection);
         }
         projections.clear();
+        projectionParentIds.clear();
+    };
+    const syncProjectionHierarchy = () => {
+        for (const [nodeId, projection] of projections) {
+            const parentId = projectionParentIds.get(nodeId) ?? null;
+            const parent = parentId && parentId !== nodeId
+                ? projections.get(parentId)?.root ?? null
+                : null;
+            if (projection.root.parent !== parent) {
+                projection.root.parent = parent;
+            }
+        }
     };
     const projectNodeInBatch = (node, batch) => {
         removeNode(node.id);
@@ -78,23 +97,25 @@ export function createBabylonEditorProjection(options) {
             runtimeObjects: [],
         };
         projections.set(node.id, projection);
+        projectionParentIds.set(node.id, node.parentId ?? null);
         root.setEnabled?.(node.active !== false);
         if (node.transform)
             applyProjectionTransform(options.babylon, root, node.transform);
-        if (node.helperKind === 'root') {
-            attachRootProjection(options.babylon, options.scene, node, projection);
-        }
-        else if (!attachRuntimeProjection(options.babylon, options.scene, node, projection)) {
+        if (node.helperKind !== 'root' && !attachRuntimeProjection(options.babylon, options.scene, node, projection)) {
             if (node.asset && options.importModel) {
                 projection.loadPromise = trackAsyncProjection(batch, node, projection);
             }
             else if (node.primitive) {
-                attachPrimitiveProjection(options.babylon, options.scene, node, projection);
+                attachPrimitiveProjection(options, node, projection);
             }
-            else {
-                attachFallbackProjection(options.babylon, options.scene, node, projection, !!node.asset);
+            else if (node.asset) {
+                attachFallbackProjection(options.babylon, options.scene, node, projection, true);
             }
         }
+        if (!projection.loadPromise) {
+            applyProjectionOutline(node, projection);
+            prewarmProjectionSelectionEdges(projection);
+        }
         if (!projection.loadPromise)
             batch.settledNodeIds.add(node.id);
         return projection;
@@ -102,6 +123,7 @@ export function createBabylonEditorProjection(options) {
     const projectNode = (node) => {
         const batch = createBatch([node.id]);
         const projection = projectNodeInBatch(node, batch);
+        syncProjectionHierarchy();
         scheduleBatchSettled(batch);
         return projection;
     };
@@ -110,6 +132,8 @@ export function createBabylonEditorProjection(options) {
         if (!existing)
             return;
         projections.delete(nodeId);
+        projectionParentIds.delete(nodeId);
+        syncProjectionHierarchy();
         disposeProjectedNode(existing);
     };
     return {
@@ -119,6 +143,7 @@ export function createBabylonEditorProjection(options) {
             const batch = createBatch(nodeList.map(node => node.id));
             for (const node of nodeList)
                 projectNodeInBatch(node, batch);
+            syncProjectionHierarchy();
             scheduleBatchSettled(batch);
         },
         projectNode,
@@ -143,7 +168,9 @@ export function createBabylonEditorProjection(options) {
             const projection = projections.get(nodeId);
             if (!projection?.root)
                 return;
-            applyProjectionTransform(options.babylon, projection.root, transform);
+            if (!applyProjectionWorldTransform(options.babylon, projection.root, transform)) {
+                options.logger?.warn?.(`[BabylonEditorProjection] Failed to preview non-representable world transform for "${nodeId}"`);
+            }
         },
         setNodeTransformsPreview(transforms) {
             for (const [nodeId, transform] of Object.entries(transforms)) {
@@ -182,8 +209,11 @@ export function createBabylonEditorProjection(options) {
             for (const runtimeObject of projection.runtimeObjects) {
                 runtimeObject.setEnabled?.(node.active !== false);
             }
+            projectionParentIds.set(node.id, node.parentId ?? null);
+            syncProjectionHierarchy();
             if (node.transform)
                 applyProjectionTransform(options.babylon, projection.root, node.transform);
+            prewarmProjectionSelectionEdges(projection);
         },
         syncSelection(selection) {
             syncProjectionSelection(options.babylon, projections, selection);
@@ -191,6 +221,9 @@ export function createBabylonEditorProjection(options) {
         resolveProjectionNodeId(target) {
             return resolveProjectionNodeId(target);
         },
+        resolvePickSelectionNodeId(target) {
+            return resolvePickSelectionNodeId(target);
+        },
         pickNodeIdAt(clientX, clientY) {
             return pickProjectionNodeIdAt(options.scene, clientX, clientY);
         },
@@ -287,6 +320,18 @@ function readProjectionBounds(root) {
     };
 }
 export function readProjectionTransform(node) {
+    return readProjectionWorldTransform(node);
+}
+function readProjectionWorldTransform(node, seen = new Set()) {
+    const local = readProjectionLocalTransform(node);
+    const parent = node?.parent ?? null;
+    if (!parent || seen.has(node))
+        return local;
+    seen.add(node);
+    const parentWorld = readProjectionWorldTransform(parent, seen);
+    return combineEditorTransforms(parentWorld, local) ?? local;
+}
+function readProjectionLocalTransform(node) {
     const rotation = node?.rotationQuaternion?.toEulerAngles?.() ?? node?.rotation;
     return {
         position: readVector3(node?.position, { x: 0, y: 0, z: 0 }),
@@ -316,6 +361,7 @@ async function loadModelProjection(options, node, projection) {
     const asset = node.asset;
     if (!asset || !options.importModel) {
         attachFallbackProjection(options.babylon, options.scene, node, projection, !!asset);
+        applyProjectionOutline(node, projection);
         return;
     }
     try {
@@ -328,22 +374,26 @@ async function loadModelProjection(options, node, projection) {
         });
         if (!result) {
             attachFallbackProjection(options.babylon, options.scene, node, projection, true);
+            applyProjectionOutline(node, projection);
             return;
         }
         if (projection.root.isDisposed?.()) {
             disposeImportedProjectionResult(result);
             return;
         }
-        attachImportedProjectionResult(options.babylon, options.scene, node, asset, projection, result);
+        attachImportedProjectionResult(options, node, asset, projection, result);
+        applyProjectionOutline(node, projection);
     }
     catch (error) {
         options.logger?.warn?.(`[BabylonEditorProjection] Failed to project model "${asset.sourceId ?? asset.id ?? node.id}"`, error);
         if (!projection.root.isDisposed?.()) {
             attachFallbackProjection(options.babylon, options.scene, node, projection, true);
+            applyProjectionOutline(node, projection);
         }
     }
 }
-function attachImportedProjectionResult(babylon, scene, node, asset, projection, result) {
+function attachImportedProjectionResult(options, node, asset, projection, result) {
+    const { babylon, scene } = options;
     const TransformNode = babylon.TransformNode;
     if (!TransformNode)
         return;
@@ -379,8 +429,23 @@ function attachImportedProjectionResult(babylon, scene, node, asset, projection,
         }
         for (const mesh of result.meshes ?? []) {
             mesh.isPickable = true;
+            const ownerNodePath = buildProjectionOwnerNodePath(mesh, modelRoot);
+            if (ownerNodePath) {
+                const selectionKey = resolveProjectionAssetMeshSelectionKey(asset, ownerNodePath);
+                mesh.metadata = {
+                    ...(mesh.metadata ?? {}),
+                    editorProjection: {
+                        nodeId: createAssetMeshProjectionNodeId(node.id, selectionKey),
+                        rootNodeId: node.id,
+                        sourceId: asset.sourceId,
+                        ownerNodePath,
+                        ...(selectionKey !== ownerNodePath ? { slotSelectionKey: selectionKey } : {}),
+                        runtimeKind: 'assetMesh',
+                    },
+                };
+            }
         }
-        projection.runtimeObjects.push(...applyProjectionArtistMaterialProfilesToMeshes(babylon, scene, node, modelRoot, result.meshes ?? []));
+        projection.runtimeObjects.push(...applyProjectionArtistMaterialProfilesToMeshes(options, node, modelRoot, result.meshes ?? []));
         for (const animationGroup of result.animationGroups ?? []) {
             animationGroup.stop?.();
         }
@@ -478,126 +543,6 @@ function attachDirectionalLightProjection(babylon, scene, node, projection) {
         arrow.isPickable = false;
     }
 }
-function attachRootProjection(babylon, scene, node, projection) {
-    const MeshBuilder = babylon.MeshBuilder;
-    const StandardMaterial = babylon.StandardMaterial;
-    const Color3 = requireBabylonCtor(babylon.Color3, 'Color3');
-    if (!MeshBuilder?.CreateSphere || !StandardMaterial)
-        return;
-    const sphere = MeshBuilder.CreateSphere(`${node.id}.rootMarker`, {
-        diameter: 0.28,
-        segments: 24,
-    }, scene);
-    sphere.parent = projection.root;
-    sphere.isPickable = false;
-    sphere.metadata = {
-        ...createProjectionMetadata(node.id, {
-            helperKind: 'root',
-            helper: 'anchor',
-        }),
-        disablePlanarShadow: true,
-    };
-    const sphereMaterial = new StandardMaterial(`${node.id}.rootMarker.material`, scene);
-    sphereMaterial.diffuseColor = new Color3(0.25, 0.64, 1);
-    sphereMaterial.emissiveColor = new Color3(0.08, 0.28, 0.45);
-    sphereMaterial.specularColor = new Color3(0.1, 0.16, 0.2);
-    sphere.material = sphereMaterial;
-    projection.runtimeObjects.push(sphereMaterial);
-    projection.outlineMeshes = [sphere];
-    const label = createRootLabelProjection(babylon, scene, node);
-    if (label) {
-        label.parent = projection.root;
-        label.isPickable = false;
-        label.position.y = 0.42;
-        projection.runtimeObjects.push(...(label.metadata?.editorProjectionRuntimeObjects ?? []));
-    }
-}
-function createRootLabelProjection(babylon, scene, node) {
-    const MeshBuilder = babylon.MeshBuilder;
-    const StandardMaterial = babylon.StandardMaterial;
-    const DynamicTexture = babylon.DynamicTexture;
-    const Vector3 = requireBabylonCtor(babylon.Vector3, 'Vector3');
-    const Color3 = requireBabylonCtor(babylon.Color3, 'Color3');
-    if (!MeshBuilder?.CreatePlane || !StandardMaterial || !DynamicTexture)
-        return null;
-    let texture;
-    try {
-        texture = new DynamicTexture(`${node.id}.rootLabel.texture`, {
-            width: 256,
-            height: 96,
-        }, scene, false);
-    }
-    catch {
-        return null;
-    }
-    texture.hasAlpha = true;
-    drawRootLabelTexture(texture);
-    const material = new StandardMaterial(`${node.id}.rootLabel.material`, scene);
-    material.diffuseTexture = texture;
-    material.emissiveTexture = texture;
-    material.opacityTexture = texture;
-    material.diffuseColor = new Color3(1, 1, 1);
-    material.emissiveColor = new Color3(1, 1, 1);
-    material.specularColor = new Color3(0, 0, 0);
-    material.backFaceCulling = false;
-    const label = MeshBuilder.CreatePlane(`${node.id}.rootLabel`, {
-        width: 0.9,
-        height: 0.34,
-    }, scene);
-    label.material = material;
-    label.billboardMode = babylon.Mesh?.BILLBOARDMODE_ALL ?? 7;
-    label.metadata = {
-        ...createProjectionMetadata(node.id, {
-            helperKind: 'root',
-            helper: 'label',
-            text: 'Root',
-        }),
-        disablePlanarShadow: true,
-        editorProjectionRuntimeObjects: [texture, material],
-    };
-    label.position = new Vector3(0, 0.42, 0);
-    return label;
-}
-function drawRootLabelTexture(texture) {
-    const context = texture.getContext?.();
-    if (!context) {
-        texture.drawText?.('Root', null, 58, 'bold 44px sans-serif', '#f8fbff', 'transparent', true, true);
-        return;
-    }
-    context.clearRect?.(0, 0, 256, 96);
-    context.fillStyle = 'rgba(10, 18, 28, 0.76)';
-    roundRectPath(context, 14, 18, 228, 56, 18);
-    context.fill?.();
-    context.strokeStyle = 'rgba(100, 190, 255, 0.9)';
-    context.lineWidth = 3;
-    roundRectPath(context, 14, 18, 228, 56, 18);
-    context.stroke?.();
-    context.fillStyle = '#f8fbff';
-    context.font = 'bold 42px sans-serif';
-    context.textAlign = 'center';
-    context.textBaseline = 'middle';
-    context.fillText?.('Root', 128, 47);
-    texture.update?.();
-}
-function roundRectPath(context, x, y, width, height, radius) {
-    if (context.roundRect) {
-        context.beginPath?.();
-        context.roundRect(x, y, width, height, radius);
-        return;
-    }
-    const right = x + width;
-    const bottom = y + height;
-    context.beginPath?.();
-    context.moveTo?.(x + radius, y);
-    context.lineTo?.(right - radius, y);
-    context.quadraticCurveTo?.(right, y, right, y + radius);
-    context.lineTo?.(right, bottom - radius);
-    context.quadraticCurveTo?.(right, bottom, right - radius, bottom);
-    context.lineTo?.(x + radius, bottom);
-    context.quadraticCurveTo?.(x, bottom, x, bottom - radius);
-    context.lineTo?.(x, y + radius);
-    context.quadraticCurveTo?.(x, y, x + radius, y);
-}
 function attachFallbackProjection(babylon, scene, node, projection, rendererFallback) {
     const mesh = createFallbackProjectionMesh(babylon, scene, node, rendererFallback);
     if (!mesh)
@@ -605,8 +550,9 @@ function attachFallbackProjection(babylon, scene, node, projection, rendererFall
     mesh.parent = projection.root;
     projection.outlineMeshes = [mesh];
 }
-function attachPrimitiveProjection(babylon, scene, node, projection) {
-    const mesh = createPrimitiveProjectionMesh(babylon, scene, node);
+function attachPrimitiveProjection(options, node, projection) {
+    const { babylon, scene } = options;
+    const mesh = createPrimitiveProjectionMesh(babylon, scene, node, options);
     if (!mesh) {
         attachFallbackProjection(babylon, scene, node, projection, true);
         return;
@@ -617,7 +563,30 @@ function attachPrimitiveProjection(babylon, scene, node, projection) {
         projection.runtimeObjects.push(mesh.material);
     projection.outlineMeshes = [mesh];
 }
-function createPrimitiveProjectionMesh(babylon, scene, node) {
+function applyProjectionOutline(node, projection) {
+    const options = createBabylonDefaultOutlineOptions(node.outline);
+    if (!options)
+        return;
+    for (const mesh of projection.outlineMeshes) {
+        applyBabylonDefaultOutline(mesh, options);
+    }
+}
+function createBabylonDefaultOutlineOptions(outline) {
+    if (!outline)
+        return null;
+    const options = {};
+    if (typeof outline.renderOutline === 'boolean')
+        options.enabled = outline.renderOutline;
+    if (typeof outline.outlineWidth === 'number' && Number.isFinite(outline.outlineWidth)) {
+        options.width = outline.outlineWidth;
+    }
+    if (outline.outlineColor) {
+        const color = outline.outlineColor;
+        options.color = { r: color.r, g: color.g, b: color.b };
+    }
+    return Object.keys(options).length > 0 ? options : null;
+}
+function createPrimitiveProjectionMesh(babylon, scene, node, options) {
     const MeshBuilder = babylon.MeshBuilder;
     const StandardMaterial = babylon.StandardMaterial;
     const PBRMaterial = babylon.PBRMaterial;
@@ -650,7 +619,7 @@ function createPrimitiveProjectionMesh(babylon, scene, node) {
         material.roughness = 1;
     if (shape === 'plane')
         material.backFaceCulling = false;
-    applyProjectionArtistMaterialProfile(babylon, scene, material, node.artistMaterialProfile);
+    applyProjectionArtistMaterialProfile({ babylon, scene, resolveTextureUrl: options?.resolveTextureUrl }, material, node.artistMaterialProfile);
     mesh.material = material;
     mesh.metadata = createProjectionMetadata(node.id, {
         runtimeKind: 'primitive',
@@ -658,7 +627,7 @@ function createPrimitiveProjectionMesh(babylon, scene, node) {
     });
     return mesh;
 }
-function applyProjectionArtistMaterialProfilesToMeshes(babylon, scene, node, modelRoot, meshes) {
+function applyProjectionArtistMaterialProfilesToMeshes(options, node, modelRoot, meshes) {
     const slotProfiles = node.artistMaterialSlotProfiles ?? {};
     const hasRootProfile = !!node.artistMaterialProfile;
     const hasSlotProfiles = Object.keys(slotProfiles).length > 0;
@@ -673,7 +642,7 @@ function applyProjectionArtistMaterialProfilesToMeshes(babylon, scene, node, mod
                 materials.add(material);
         }
         for (const material of materials) {
-            applyProjectionArtistMaterialProfile(babylon, scene, material, node.artistMaterialProfile);
+            applyProjectionArtistMaterialProfile(options, material, node.artistMaterialProfile);
         }
     }
     if (!hasSlotProfiles)
@@ -692,14 +661,17 @@ function applyProjectionArtistMaterialProfilesToMeshes(babylon, scene, node, mod
             continue;
         if (slotMaterial !== material)
             clonedMaterials.push(slotMaterial);
-        applyProjectionArtistMaterialProfile(babylon, scene, slotMaterial, slotProfile);
+        applyProjectionArtistMaterialProfile(options, slotMaterial, slotProfile);
     }
     return clonedMaterials;
 }
-function applyProjectionArtistMaterialProfile(babylon, scene, material, profile) {
+function applyProjectionArtistMaterialProfile(options, material, profile) {
     if (!profile)
         return;
-    applyArtistMaterialProfileToRuntimeMaterial(material, scene, profile, { babylon });
+    applyArtistMaterialProfileToRuntimeMaterial(material, options.scene, profile, {
+        babylon: options.babylon,
+        resolveTextureUrl: options.resolveTextureUrl,
+    });
 }
 function resolveProjectionSlotProfile(slotProfiles, ownerNodePath) {
     if (ownerNodePath == null)
@@ -710,11 +682,18 @@ function resolveProjectionSlotProfile(slotProfiles, ownerNodePath) {
     const normalized = normalizeProjectionOwnerNodePath(ownerNodePath);
     if (normalized !== ownerNodePath && slotProfiles[normalized])
         return slotProfiles[normalized];
+    let descendantMatch = null;
     for (const [candidatePath, profile] of Object.entries(slotProfiles)) {
-        if (normalizeProjectionOwnerNodePath(candidatePath) === normalized)
+        const normalizedCandidate = normalizeProjectionOwnerNodePath(candidatePath);
+        if (normalizedCandidate === normalized)
             return profile;
+        if (isProjectionOwnerPathDescendant(normalized, normalizedCandidate)) {
+            if (!descendantMatch || normalizedCandidate.length > descendantMatch.path.length) {
+                descendantMatch = { path: normalizedCandidate, profile };
+            }
+        }
     }
-    return null;
+    return descendantMatch?.profile ?? null;
 }
 function buildProjectionOwnerNodePath(node, rootNode) {
     if (!node || !rootNode || node === rootNode)
@@ -744,10 +723,81 @@ function stableProjectionNodeSegment(node) {
     return null;
 }
 function normalizeProjectionOwnerNodePath(path) {
-    return path
+    const segments = path
         .split('/')
-        .map(segment => segment.includes(':') ? segment.slice(segment.lastIndexOf(':') + 1) : segment)
-        .join('/');
+        .map(normalizeProjectionOwnerPathSegment)
+        .filter(Boolean);
+    while (segments.length > 0 && isSyntheticProjectionOwnerRootSegment(segments[0])) {
+        segments.shift();
+    }
+    return segments.join('/');
+}
+function normalizeProjectionOwnerPathSegment(segment) {
+    const trimmed = segment.trim();
+    return trimmed.includes(':') ? trimmed.slice(trimmed.lastIndexOf(':') + 1) : trimmed;
+}
+function isSyntheticProjectionOwnerRootSegment(segment) {
+    return segment === '__root__';
+}
+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)}`;
+}
+function resolveProjectionAssetMeshSelectionKey(asset, ownerNodePath) {
+    const normalizedOwnerPath = normalizeProjectionOwnerNodePath(ownerNodePath);
+    let bestSlot = null;
+    for (const slot of readProjectionAssetMaterialSlots(asset)) {
+        if (!isProjectionOwnerPathSlotMatch(normalizedOwnerPath, slot.path))
+            continue;
+        if (!bestSlot || slot.path.length > bestSlot.path.length) {
+            bestSlot = slot;
+        }
+    }
+    return bestSlot?.key ?? ownerNodePath;
+}
+function readProjectionAssetMaterialSlots(asset) {
+    const rawSlots = asset.metadata?.materialSlots;
+    if (!Array.isArray(rawSlots))
+        return [];
+    const slots = [];
+    for (const rawSlot of rawSlots) {
+        const slot = readProjectionAssetMaterialSlot(rawSlot);
+        if (slot)
+            slots.push(slot);
+    }
+    return slots;
+}
+function readProjectionAssetMaterialSlot(value) {
+    if (typeof value === 'string') {
+        const path = normalizeProjectionOwnerNodePath(value);
+        return path ? { key: path, path } : null;
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const record = value;
+    const rawOwnerPath = readProjectionAssetMaterialSlotString(record.ownerNodePath)
+        || readProjectionAssetMaterialSlotString(record.path)
+        || readProjectionAssetMaterialSlotString(record.name);
+    const path = normalizeProjectionOwnerNodePath(rawOwnerPath);
+    if (!path)
+        return null;
+    const slotId = readProjectionAssetMaterialSlotString(record.slotId);
+    return {
+        key: slotId || path,
+        path,
+    };
+}
+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();
@@ -771,11 +821,24 @@ function detachProjectionSlotMaterial(mesh, materialCounts, ownerNodePath) {
         : null;
     if (!clone)
         return null;
+    cloneProjectionSubMaterials(clone, material, ownerNodePath);
     mesh.material = clone;
     materialCounts.set(material, materialUseCount - 1);
     materialCounts.set(clone, 1);
     return clone;
 }
+function cloneProjectionSubMaterials(clone, source, ownerNodePath) {
+    if (!Array.isArray(clone?.subMaterials) || !Array.isArray(source?.subMaterials))
+        return;
+    clone.subMaterials = source.subMaterials.map((subMaterial, index) => {
+        if (!subMaterial || typeof subMaterial !== 'object')
+            return subMaterial;
+        if (typeof subMaterial.clone !== 'function')
+            return subMaterial;
+        const clonedSubMaterial = subMaterial.clone(createProjectionSlotSubMaterialName(subMaterial, ownerNodePath, index));
+        return clonedSubMaterial ?? subMaterial;
+    });
+}
 function createProjectionSlotMaterialName(material, ownerNodePath) {
     const baseName = String(material?.name ?? material?.id ?? 'material');
     const suffix = ownerNodePath?.trim()
@@ -783,6 +846,9 @@ function createProjectionSlotMaterialName(material, ownerNodePath) {
         : 'root';
     return `${baseName}.projectionSlot.${suffix}`;
 }
+function createProjectionSlotSubMaterialName(material, ownerNodePath, index) {
+    return `${createProjectionSlotMaterialName(material, ownerNodePath)}.sub${index}`;
+}
 function createFallbackProjectionMesh(babylon, scene, node, rendererFallback) {
     const MeshBuilder = babylon.MeshBuilder;
     const StandardMaterial = babylon.StandardMaterial;
@@ -1103,6 +1169,14 @@ export function applyProjectionTransform(babylon, node, transform) {
     const scale = transform.scale ?? { x: 1, y: 1, z: 1 };
     node.scaling = new Vector3(scale.x, scale.y, scale.z);
 }
+function applyProjectionWorldTransform(babylon, node, transform) {
+    const parent = node?.parent ?? null;
+    const local = parent ? toEditorLocalTransformFromWorld(readProjectionWorldTransform(parent), transform) : transform;
+    if (!local)
+        return false;
+    applyProjectionTransform(babylon, node, local);
+    return true;
+}
 function applyAssetDefaultsTransform(babylon, node, transform) {
     if (!transform)
         return;
@@ -1131,6 +1205,21 @@ function resolveProjectionNodeId(target) {
     }
     return null;
 }
+function resolvePickSelectionNodeId(target) {
+    let current = target;
+    while (current) {
+        const projection = current.metadata?.editorProjection;
+        const rootNodeId = projection?.rootNodeId;
+        if (projection?.runtimeKind === 'assetMesh' && typeof rootNodeId === 'string' && rootNodeId.length > 0) {
+            return rootNodeId;
+        }
+        const nodeId = projection?.nodeId;
+        if (typeof nodeId === 'string' && nodeId.length > 0)
+            return nodeId;
+        current = current.parent ?? null;
+    }
+    return null;
+}
 function pickProjectionNodeIdAt(scene, clientX, clientY) {
     const canvas = scene.getEngine?.().getRenderingCanvas?.();
     if (!canvas || typeof scene.pick !== 'function')
@@ -1140,7 +1229,7 @@ function pickProjectionNodeIdAt(scene, clientX, clientY) {
     const y = clientY - rect.top;
     const pick = scene.pick(x, y);
     const pickedNode = pick?.pickedMesh ?? pick?.pickedPoint?.mesh ?? null;
-    return resolveProjectionNodeId(pickedNode);
+    return resolvePickSelectionNodeId(pickedNode);
 }
 function getProjectionNodeIdsInScreenRect(babylon, scene, projections, rect) {
     const canvas = scene.getEngine?.().getRenderingCanvas?.();
@@ -1201,16 +1290,19 @@ function syncProjectionSelection(babylon, projections, selection) {
     const Color4 = babylon.Color4;
     const selectedIds = new Set(selection.selectedIds);
     for (const [nodeId, projection] of projections) {
-        const selected = selectedIds.has(nodeId);
-        const active = selection.activeId === nodeId;
+        const rootSelected = selectedIds.has(nodeId);
+        const rootActive = selection.activeId === nodeId;
         for (const mesh of projection.outlineMeshes) {
+            const meshNodeId = typeof mesh?.metadata?.editorProjection?.nodeId === 'string'
+                ? mesh.metadata.editorProjection.nodeId
+                : nodeId;
+            const selected = rootSelected || selectedIds.has(meshNodeId);
+            const active = rootActive || selection.activeId === meshNodeId;
             syncProjectionMeshSelection(mesh, selected, active, Color4);
         }
     }
 }
 function syncProjectionMeshSelection(mesh, selected, active, Color4) {
-    mesh.renderOutline = false;
-    mesh.outlineWidth = 0;
     if (!selected) {
         mesh.disableEdgesRendering?.();
         return;
@@ -1223,4 +1315,19 @@ function syncProjectionMeshSelection(mesh, selected, active, Color4) {
             : new Color4(0.35, 0.65, 1, 1);
     }
 }
+function prewarmProjectionSelectionEdges(projection) {
+    for (const mesh of projection.outlineMeshes) {
+        if (mesh?.metadata?.editorProjectionSelectionEdgesPrewarmed)
+            continue;
+        try {
+            mesh.enableEdgesRendering?.(0.997);
+            mesh.disableEdgesRendering?.();
+            mesh.metadata = {
+                ...(mesh.metadata ?? {}),
+                editorProjectionSelectionEdgesPrewarmed: true,
+            };
+        }
+        catch { }
+    }
+}
 //# sourceMappingURL=projection.js.map