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

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

@@ -4,6 +4,7 @@ import { applyArtistMaterialProfileToRuntimeMaterial } from './material-property
 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';
+import { isBabylonPrimitiveProjectionSharedMaterial, } from './primitive-projection-instancing.js';
 const LARGE_SELECTION_EDGE_LIMIT = 200;
 const PROJECTION_LOCAL_MATRIX_METADATA_KEY = 'editorLocalTransformMatrix';
 const MIN_SELECTION_BOUNDS_PROXY_SIZE = 0.002;
@@ -134,9 +135,13 @@ export function createBabylonEditorProjection(options) {
         for (const animationGroup of projection.animationGroups) {
             animationGroup.dispose?.();
         }
+        let disposedRuntimeLight = false;
         for (const runtimeObject of projection.runtimeObjects) {
+            disposedRuntimeLight = disposedRuntimeLight || isProjectionRuntimeLightObject(runtimeObject);
             runtimeObject.dispose?.();
         }
+        if (disposedRuntimeLight)
+            resyncProjectionSceneLightSources(options.scene);
         projection.root?.dispose?.();
     };
     const disposeAll = () => {
@@ -818,6 +823,7 @@ function attachImportedProjectionResult(options, node, asset, projection, result
             },
         };
         applyAssetDefaultsTransform(babylon, modelRoot, asset.transform);
+        collapseZeroVertexProjectionWrapperMeshes(babylon, scene, result);
         const importedNodes = [
             ...(result.transformNodes ?? []),
             ...(result.meshes ?? []),
@@ -910,6 +916,141 @@ function attachImportedProjectionResult(options, node, asset, projection, result
         throw error;
     }
 }
+function collapseZeroVertexProjectionWrapperMeshes(babylon, scene, result) {
+    const meshes = result.meshes ?? [];
+    if (meshes.length === 0)
+        return;
+    const TransformNode = babylon.TransformNode;
+    if (!TransformNode)
+        return;
+    const sourceMeshes = collectProjectionSourceMeshReferences(meshes);
+    const keptMeshes = [];
+    const replacementTransformNodes = [];
+    for (const mesh of meshes) {
+        if (!canCollapseProjectionWrapperMesh(mesh, sourceMeshes)) {
+            keptMeshes.push(mesh);
+            continue;
+        }
+        const replacement = createProjectionWrapperTransformNode(TransformNode, scene, mesh);
+        if (!replacement) {
+            keptMeshes.push(mesh);
+            continue;
+        }
+        for (const child of readProjectionDirectChildren(mesh)) {
+            child.parent = replacement;
+        }
+        mesh.dispose?.(true, false);
+        replacementTransformNodes.push(replacement);
+    }
+    if (replacementTransformNodes.length === 0)
+        return;
+    result.meshes = keptMeshes;
+    result.transformNodes = [
+        ...(result.transformNodes ?? []),
+        ...replacementTransformNodes,
+    ];
+}
+function collectProjectionSourceMeshReferences(meshes) {
+    const sourceMeshes = new Set();
+    for (const mesh of meshes) {
+        const sourceMesh = mesh?.sourceMesh;
+        if (sourceMesh)
+            sourceMeshes.add(sourceMesh);
+    }
+    return sourceMeshes;
+}
+function canCollapseProjectionWrapperMesh(mesh, sourceMeshes) {
+    if (!mesh || mesh.getClassName?.() !== 'Mesh')
+        return false;
+    if (sourceMeshes.has(mesh))
+        return false;
+    if (mesh.sourceMesh)
+        return false;
+    const vertices = mesh.getTotalVertices?.();
+    if (vertices !== 0)
+        return false;
+    if (Array.isArray(mesh.instances) && mesh.instances.length > 0)
+        return false;
+    if (mesh.skeleton || mesh.morphTargetManager)
+        return false;
+    if (Array.isArray(mesh.subMeshes) && mesh.subMeshes.length > 0)
+        return false;
+    if (mesh.material)
+        return false;
+    const projection = readProjectionObject(mesh.metadata?.editorProjection);
+    const runtimeKind = projection?.runtimeKind;
+    if (runtimeKind === 'assetMeshSelectionProxy'
+        || runtimeKind === 'primitive'
+        || runtimeKind === 'camera'
+        || runtimeKind === 'light'
+        || projection?.primitiveShape != null
+        || projection?.helper != null
+        || projection?.disableStaticProjectedShadow === false) {
+        return false;
+    }
+    return true;
+}
+function createProjectionWrapperTransformNode(TransformNode, scene, mesh) {
+    const name = typeof mesh.name === 'string' ? mesh.name : typeof mesh.id === 'string' ? mesh.id : 'projectionWrapper';
+    const replacement = new TransformNode(name, scene);
+    if (typeof mesh.id === 'string')
+        replacement.id = mesh.id;
+    if (typeof mesh.name === 'string')
+        replacement.name = mesh.name;
+    replacement.parent = mesh.parent ?? null;
+    if (mesh.metadata && typeof mesh.metadata === 'object') {
+        replacement.metadata = { ...mesh.metadata };
+    }
+    if (mesh.reservedDataStore && typeof mesh.reservedDataStore === 'object') {
+        replacement.reservedDataStore = { ...mesh.reservedDataStore };
+    }
+    if (Array.isArray(mesh.animations))
+        replacement.animations = [...mesh.animations];
+    copyProjectionWrapperTransform(mesh, replacement);
+    if (typeof mesh.isEnabled === 'function' && typeof replacement.setEnabled === 'function') {
+        replacement.setEnabled(mesh.isEnabled());
+    }
+    if (typeof mesh.state === 'string')
+        replacement.state = mesh.state;
+    if (typeof mesh.layerMask === 'number')
+        replacement.layerMask = mesh.layerMask;
+    return replacement;
+}
+function copyProjectionWrapperTransform(source, target) {
+    copyBabylonVector3(source.position, target.position);
+    copyBabylonVector3(source.rotation, target.rotation);
+    copyBabylonVector3(source.scaling, target.scaling);
+    if (source.rotationQuaternion?.clone) {
+        target.rotationQuaternion = source.rotationQuaternion.clone();
+    }
+    else {
+        target.rotationQuaternion = null;
+    }
+    const pivotMatrix = source._pivotMatrix?.clone?.() ?? source.getPivotMatrix?.()?.clone?.();
+    if (pivotMatrix) {
+        if (source._usePivotMatrix && typeof target.setPreTransformMatrix === 'function') {
+            target.setPreTransformMatrix(pivotMatrix.clone?.() ?? pivotMatrix);
+        }
+        else if (typeof target.setPivotMatrix === 'function') {
+            target.setPivotMatrix(pivotMatrix.clone?.() ?? pivotMatrix, false);
+        }
+    }
+}
+function copyBabylonVector3(source, target) {
+    if (!source || !target)
+        return;
+    if (typeof target.copyFrom === 'function') {
+        target.copyFrom(source);
+        return;
+    }
+    target.x = source.x;
+    target.y = source.y;
+    target.z = source.z;
+}
+function readProjectionDirectChildren(node) {
+    const children = node?.getChildren?.((candidate) => candidate?.parent === node, true);
+    return Array.isArray(children) ? children.filter(child => child?.parent === node) : [];
+}
 function createProjectionImportStructureSnapshot(node, asset, modelRoot, result) {
     const runtimeNodes = collectProjectionImportRuntimeNodes(modelRoot, result);
     const nodeIdByRuntimeNode = new Map();
@@ -1179,6 +1320,7 @@ function attachDirectionalLightProjection(babylon, scene, node, projection) {
         light.metadata = createProjectionMetadata(node.id, { runtimeKind: 'light', lightType: 'directional' });
         light.setEnabled?.(node.active !== false);
         projection.runtimeObjects.push(light);
+        resyncProjectionSceneLightSources(scene);
     }
     if (!settings.helperVisible)
         return;
@@ -1216,8 +1358,9 @@ function attachPrimitiveProjection(options, node, projection) {
     }
     mesh.parent = projection.root;
     mesh.isPickable = true;
-    if (mesh.material)
+    if (mesh.material && !isBabylonPrimitiveProjectionSharedMaterial(mesh.material)) {
         projection.runtimeObjects.push(mesh.material);
+    }
     projection.outlineMeshes = [mesh];
 }
 function applyProjectionOutline(node, projection) {
@@ -1296,7 +1439,7 @@ function applyProjectionArtistMaterialProfilesToMeshes(options, node, modelRoot,
     const materials = new Set();
     if (hasRootProfile) {
         for (const mesh of meshes) {
-            const material = mesh?.material;
+            const material = readProjectionWritableMeshMaterial(mesh);
             const meshOwnerNodePath = buildProjectionOwnerNodePath(mesh, modelRoot, node.id);
             if (!material) {
                 emitProjectionMaterialProfileDiagnostic(options, {
@@ -1347,7 +1490,7 @@ function applyProjectionArtistMaterialProfilesToMeshes(options, node, modelRoot,
         const meshSlotBindingMatches = resolveProjectionSlotBindingMatches(slotBindings, ownerNodePath, node.id);
         for (const { binding: slotBinding, matchKind } of meshSlotBindingMatches) {
             unmatchedSlotBindings.delete(slotBinding);
-            if (!mesh?.material) {
+            if (!readProjectionWritableMeshMaterial(mesh)) {
                 emitProjectionSlotMaterialProfileDiagnostic(options, node.id, slotBinding, {
                     applied: false,
                     matchKind,
@@ -1361,7 +1504,7 @@ function applyProjectionArtistMaterialProfilesToMeshes(options, node, modelRoot,
                 projectionNodeId: node.id,
                 primitiveSingleMaterialFallbackAllowed: isProjectionSinglePrimitiveMaterialSlot(slotBinding.slot, assetMaterialSlots),
             });
-            const targetMaterial = resolution.target?.material ?? mesh.material;
+            const targetMaterial = resolution.target?.material ?? readProjectionWritableMeshMaterial(mesh);
             if (!resolution.target) {
                 emitProjectionSlotMaterialProfileDiagnostic(options, node.id, slotBinding, {
                     applied: false,
@@ -1442,21 +1585,12 @@ function readProjectionMaterialType(material) {
 }
 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, source: 'slotBinding' });
-        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, source: 'legacySlotProfile' });
-        occupiedOwnerPaths.add(slot.matchKey);
     }
     return bindings;
 }
@@ -1466,9 +1600,9 @@ function createProjectionMaterialSlotDescriptor(value, projectionNodeId) {
     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() : '';
+    if (!slotId || !ownerNodePath)
+        return null;
     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)
@@ -1487,7 +1621,7 @@ function createProjectionMaterialSlotDescriptor(value, projectionNodeId) {
     const triangleCount = Number.isFinite(value.triangleCount) ? value.triangleCount : undefined;
     const boundingBox = readProjectionMaterialSlotBoundingBox(value.boundingBox);
     return {
-        ...(slotId ? { slotId } : {}),
+        slotId,
         ownerNodePath,
         ...(label ? { label } : {}),
         ...(nodeIndex != null ? { nodeIndex } : {}),
@@ -1968,24 +2102,15 @@ function readProjectionAssetMaterialSlots(asset, projectionNodeId) {
     return slots;
 }
 function readProjectionAssetMaterialSlot(value, projectionNodeId) {
-    if (typeof value === 'string') {
-        return createProjectionMaterialSlotDescriptor({ ownerNodePath: value }, projectionNodeId);
-    }
     if (!value || typeof value !== 'object' || Array.isArray(value))
         return null;
     const record = value;
-    const rawOwnerPath = readProjectionAssetMaterialSlotString(record.ownerNodePath)
-        || readProjectionAssetMaterialSlotString(record.path)
-        || readProjectionAssetMaterialSlotString(record.name);
-    return createProjectionMaterialSlotDescriptor({ ...record, ownerNodePath: rawOwnerPath }, projectionNodeId);
-}
-function readProjectionAssetMaterialSlotString(value) {
-    return typeof value === 'string' ? value.trim() : '';
+    return createProjectionMaterialSlotDescriptor(record, projectionNodeId);
 }
 function countProjectionMeshMaterials(meshes) {
     const counts = new Map();
     for (const mesh of meshes) {
-        const material = mesh?.material;
+        const material = readProjectionWritableMeshMaterial(mesh);
         if (!material)
             continue;
         counts.set(material, (counts.get(material) ?? 0) + 1);
@@ -2007,25 +2132,34 @@ function isProjectionMaterialSlotSameMesh(left, right) {
     return true;
 }
 function detachProjectionSlotMaterial(mesh, materialCounts, ownerNodePath) {
-    const material = mesh?.material;
-    if (!material || typeof material !== 'object')
-        return material;
+    const materialOwner = resolveProjectionWritableMaterialOwner(mesh);
+    const material = materialOwner?.material;
+    if (!material)
+        return null;
+    const projectionOwnsMaterialLifecycle = materialOwner === mesh;
+    if (typeof material !== 'object') {
+        return { material, clonedMaterials: [], projectionOwnsMaterialLifecycle };
+    }
     const materialUseCount = materialCounts.get(material) ?? 0;
     if (materialUseCount <= 1)
-        return material;
+        return { material, clonedMaterials: [], projectionOwnsMaterialLifecycle };
     const clone = typeof material.clone === 'function'
         ? material.clone(createProjectionSlotMaterialName(material, ownerNodePath))
         : null;
     if (!clone)
         return null;
     cloneProjectionSubMaterials(clone, material, ownerNodePath);
-    mesh.material = clone;
+    materialOwner.material = clone;
     materialCounts.set(material, materialUseCount - 1);
     materialCounts.set(clone, 1);
-    return clone;
+    return {
+        material: clone,
+        clonedMaterials: projectionOwnsMaterialLifecycle ? [clone] : [],
+        projectionOwnsMaterialLifecycle,
+    };
 }
 function resolveProjectionSlotMaterialTarget(mesh, materialCounts, slot, ownerNodePath, options) {
-    const material = mesh?.material;
+    const material = readProjectionWritableMeshMaterial(mesh);
     if (!material) {
         return {
             target: null,
@@ -2034,8 +2168,8 @@ function resolveProjectionSlotMaterialTarget(mesh, materialCounts, slot, ownerNo
         };
     }
     if (slot.primitiveIndex == null) {
-        const slotMaterial = detachProjectionSlotMaterial(mesh, materialCounts, ownerNodePath);
-        if (!slotMaterial) {
+        const detachResult = detachProjectionSlotMaterial(mesh, materialCounts, ownerNodePath);
+        if (!detachResult) {
             return {
                 target: null,
                 targetMaterialStatus: 'missingTargetMaterial',
@@ -2044,8 +2178,8 @@ function resolveProjectionSlotMaterialTarget(mesh, materialCounts, slot, ownerNo
         }
         return {
             target: {
-                material: slotMaterial,
-                clonedMaterials: slotMaterial !== material ? [slotMaterial] : [],
+                material: detachResult.material,
+                clonedMaterials: detachResult.clonedMaterials,
             },
             targetMaterialStatus: 'material',
         };
@@ -2059,8 +2193,8 @@ function resolveProjectionSlotMaterialTarget(mesh, materialCounts, slot, ownerNo
                 warningMessage: 'Primitive slot material profile was not applied because the target mesh does not expose a matching subMaterial.',
             };
         }
-        const slotMaterial = detachProjectionSlotMaterial(mesh, materialCounts, ownerNodePath);
-        if (!slotMaterial) {
+        const detachResult = detachProjectionSlotMaterial(mesh, materialCounts, ownerNodePath);
+        if (!detachResult) {
             return {
                 target: null,
                 targetMaterialStatus: 'missingTargetMaterial',
@@ -2069,14 +2203,15 @@ function resolveProjectionSlotMaterialTarget(mesh, materialCounts, slot, ownerNo
         }
         return {
             target: {
-                material: slotMaterial,
-                clonedMaterials: slotMaterial !== material ? [slotMaterial] : [],
+                material: detachResult.material,
+                clonedMaterials: detachResult.clonedMaterials,
             },
             targetMaterialStatus: 'primitiveFallbackMaterial',
         };
     }
-    const slotMaterial = detachProjectionSlotMaterial(mesh, materialCounts, ownerNodePath);
-    if (!slotMaterial || !Array.isArray(slotMaterial.subMaterials)) {
+    const detachResult = detachProjectionSlotMaterial(mesh, materialCounts, ownerNodePath);
+    const slotMaterial = detachResult?.material;
+    if (!detachResult || !Array.isArray(slotMaterial.subMaterials)) {
         return {
             target: null,
             targetMaterialStatus: 'missingTargetMaterial',
@@ -2105,13 +2240,30 @@ function resolveProjectionSlotMaterialTarget(mesh, materialCounts, slot, ownerNo
         target: {
             material: clonedSubMaterial,
             clonedMaterials: [
-                ...(slotMaterial !== material ? [slotMaterial] : []),
-                clonedSubMaterial,
+                ...detachResult.clonedMaterials,
+                ...(detachResult.projectionOwnsMaterialLifecycle ? [clonedSubMaterial] : []),
             ],
         },
         targetMaterialStatus: 'subMaterial',
     };
 }
+function readProjectionWritableMeshMaterial(mesh) {
+    return resolveProjectionWritableMaterialOwner(mesh)?.material ?? null;
+}
+function resolveProjectionWritableMaterialOwner(mesh) {
+    if (!mesh || typeof mesh !== 'object')
+        return null;
+    if (isProjectionInstancedMesh(mesh) && mesh.sourceMesh)
+        return mesh.sourceMesh;
+    return mesh;
+}
+function isProjectionInstancedMesh(mesh) {
+    if (!mesh || typeof mesh !== 'object')
+        return false;
+    const className = typeof mesh.getClassName === 'function' ? mesh.getClassName() : undefined;
+    return className === 'InstancedMesh'
+        || (mesh.constructor?.name === 'InstancedMesh' && !!mesh.sourceMesh);
+}
 function cloneProjectionSubMaterials(clone, source, ownerNodePath) {
     if (!Array.isArray(clone?.subMaterials) || !Array.isArray(source?.subMaterials))
         return;
@@ -2278,6 +2430,7 @@ function attachHemisphericLightProjection(babylon, scene, node, projection) {
         light.metadata = createProjectionMetadata(node.id, { runtimeKind: 'light', lightType: 'hemispheric' });
         light.setEnabled?.(node.active !== false);
         projection.runtimeObjects.push(light);
+        resyncProjectionSceneLightSources(scene);
     }
     if (!settings.helperVisible)
         return;
@@ -2323,6 +2476,7 @@ function syncRuntimeDirectionalLightProjection(babylon, scene, node, projection)
     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);
+    resyncProjectionSceneLightSources(scene);
     if (settings.helperVisible)
         refreshLightDirectionLines(babylon, scene, node, projection, settings.direction);
     return true;
@@ -2340,6 +2494,7 @@ function syncRuntimeHemisphericLightProjection(babylon, scene, node, projection)
     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);
+    resyncProjectionSceneLightSources(scene);
     return true;
 }
 function findProjectionRuntimeLight(projection, nodeId, lightType) {
@@ -2350,6 +2505,37 @@ function findProjectionRuntimeLight(projection, nodeId, lightType) {
             && metadata?.lightType === lightType;
     }) ?? null;
 }
+function isProjectionRuntimeLightObject(runtimeObject) {
+    const metadata = runtimeObject?.metadata?.editorProjection;
+    return metadata?.runtimeKind === 'light'
+        && (metadata?.lightType === 'directional' || metadata?.lightType === 'hemispheric');
+}
+function resyncProjectionSceneLightSources(scene) {
+    const meshes = Array.isArray(scene.meshes) ? scene.meshes : [];
+    const sourceMeshes = new Set();
+    const instancedMeshes = new Set();
+    for (const mesh of meshes) {
+        if (!mesh || typeof mesh !== 'object')
+            continue;
+        mesh._resyncLightSources?.();
+        const sourceMesh = mesh.sourceMesh;
+        if (sourceMesh && sourceMesh !== mesh) {
+            sourceMeshes.add(sourceMesh);
+            instancedMeshes.add(mesh);
+        }
+    }
+    for (const sourceMesh of sourceMeshes) {
+        if (sourceMesh?.isDisposed?.())
+            continue;
+        sourceMesh?._resyncLightSources?.();
+    }
+    for (const instancedMesh of instancedMeshes) {
+        if (instancedMesh?.isDisposed?.())
+            continue;
+        instancedMesh?._markSubMeshesAsLightDirty?.();
+    }
+    scene.resetCachedMaterial?.();
+}
 function refreshLightDirectionLines(babylon, scene, node, projection, direction) {
     const existing = scene.getMeshByName?.(`${node.id}.lightDirection`);
     existing?.dispose?.();
@@ -2547,7 +2733,6 @@ 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) } : {}),
     };
@@ -2576,10 +2761,6 @@ function syncProjectionRuntimeNodeMetadata(runtimeNode, node) {
     if (editorProjection.nodeId !== node.id && editorProjection.rootNodeId !== node.id)
         return;
     const nextEditorProjection = { ...editorProjection };
-    if (node.shadowMode)
-        nextEditorProjection.shadowMode = node.shadowMode;
-    else
-        delete nextEditorProjection.shadowMode;
     if (node.shadow)
         nextEditorProjection.shadow = structuredClone(node.shadow);
     else