@fps-games/editor 0.1.7 → 0.1.8-beta.1

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

@@ -818,6 +818,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 +911,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();
@@ -1296,34 +1432,106 @@ function applyProjectionArtistMaterialProfilesToMeshes(options, node, modelRoot,
     const materials = new Set();
     if (hasRootProfile) {
         for (const mesh of meshes) {
-            const material = mesh?.material;
-            if (material)
-                materials.add(material);
-        }
-        for (const material of materials) {
+            const material = readProjectionWritableMeshMaterial(mesh);
+            const meshOwnerNodePath = buildProjectionOwnerNodePath(mesh, modelRoot, node.id);
+            if (!material) {
+                emitProjectionMaterialProfileDiagnostic(options, {
+                    projectionNodeId: node.id,
+                    source: 'rootProfile',
+                    applied: false,
+                    matchKind: 'root',
+                    targetMaterialStatus: 'missingMaterial',
+                    meshOwnerNodePath,
+                    warningMessage: 'Root material profile was not applied because an imported mesh has no target material.',
+                });
+                continue;
+            }
+            if (materials.has(material))
+                continue;
+            materials.add(material);
             applyProjectionArtistMaterialProfile(options, material, node.artistMaterialProfile);
+            emitProjectionMaterialProfileDiagnostic(options, {
+                projectionNodeId: node.id,
+                source: 'rootProfile',
+                applied: true,
+                matchKind: 'root',
+                targetMaterialStatus: 'material',
+                meshOwnerNodePath,
+                targetMaterialName: readProjectionMaterialName(material),
+                targetMaterialType: readProjectionMaterialType(material),
+            });
+        }
+        if (materials.size === 0 && meshes.length === 0) {
+            emitProjectionMaterialProfileDiagnostic(options, {
+                projectionNodeId: node.id,
+                source: 'rootProfile',
+                applied: false,
+                matchKind: 'root',
+                targetMaterialStatus: 'missingMaterial',
+                meshOwnerNodePath: null,
+                warningMessage: 'Root material profile was not applied because the imported model produced no meshes.',
+            });
         }
     }
     if (!hasSlotProfiles)
         return clonedMaterials;
     const materialCounts = countProjectionMeshMaterials(meshes);
     const assetMaterialSlots = node.asset ? readProjectionAssetMaterialSlots(node.asset, node.id) : [];
+    const unmatchedSlotBindings = new Set(slotBindings);
     for (const mesh of meshes) {
-        const material = mesh?.material;
-        if (!material)
-            continue;
         const ownerNodePath = buildProjectionOwnerNodePath(mesh, modelRoot, node.id);
-        const meshSlotBindings = resolveProjectionSlotBindings(slotBindings, ownerNodePath, node.id);
-        for (const slotBinding of meshSlotBindings) {
-            const target = resolveProjectionSlotMaterialTarget(mesh, materialCounts, slotBinding.slot, ownerNodePath, {
+        const meshSlotBindingMatches = resolveProjectionSlotBindingMatches(slotBindings, ownerNodePath, node.id);
+        for (const { binding: slotBinding, matchKind } of meshSlotBindingMatches) {
+            unmatchedSlotBindings.delete(slotBinding);
+            if (!readProjectionWritableMeshMaterial(mesh)) {
+                emitProjectionSlotMaterialProfileDiagnostic(options, node.id, slotBinding, {
+                    applied: false,
+                    matchKind,
+                    meshOwnerNodePath: ownerNodePath,
+                    targetMaterialStatus: 'missingMaterial',
+                    warningMessage: 'Slot material profile was not applied because the matched mesh has no target material.',
+                });
+                continue;
+            }
+            const resolution = resolveProjectionSlotMaterialTarget(mesh, materialCounts, slotBinding.slot, ownerNodePath, {
+                projectionNodeId: node.id,
                 primitiveSingleMaterialFallbackAllowed: isProjectionSinglePrimitiveMaterialSlot(slotBinding.slot, assetMaterialSlots),
             });
-            if (!target)
+            const targetMaterial = resolution.target?.material ?? readProjectionWritableMeshMaterial(mesh);
+            if (!resolution.target) {
+                emitProjectionSlotMaterialProfileDiagnostic(options, node.id, slotBinding, {
+                    applied: false,
+                    matchKind,
+                    meshOwnerNodePath: ownerNodePath,
+                    targetMaterialStatus: resolution.targetMaterialStatus,
+                    targetMaterialName: readProjectionMaterialName(targetMaterial),
+                    targetMaterialType: readProjectionMaterialType(targetMaterial),
+                    warningMessage: resolution.warningMessage,
+                });
                 continue;
+            }
+            const target = resolution.target;
             clonedMaterials.push(...target.clonedMaterials);
             applyProjectionArtistMaterialProfile(options, target.material, slotBinding.profile);
+            emitProjectionSlotMaterialProfileDiagnostic(options, node.id, slotBinding, {
+                applied: true,
+                matchKind,
+                meshOwnerNodePath: ownerNodePath,
+                targetMaterialStatus: resolution.targetMaterialStatus,
+                targetMaterialName: readProjectionMaterialName(target.material),
+                targetMaterialType: readProjectionMaterialType(target.material),
+            });
         }
     }
+    for (const slotBinding of unmatchedSlotBindings) {
+        emitProjectionSlotMaterialProfileDiagnostic(options, node.id, slotBinding, {
+            applied: false,
+            matchKind: 'none',
+            meshOwnerNodePath: null,
+            targetMaterialStatus: 'missingMeshOwner',
+            warningMessage: 'Slot material profile was not applied because no imported mesh matched its owner path.',
+        });
+    }
     return clonedMaterials;
 }
 function applyProjectionArtistMaterialProfile(options, material, profile) {
@@ -1334,6 +1542,40 @@ function applyProjectionArtistMaterialProfile(options, material, profile) {
         resolveTextureUrl: options.resolveTextureUrl,
     });
 }
+function emitProjectionSlotMaterialProfileDiagnostic(options, projectionNodeId, slotBinding, diagnostic) {
+    emitProjectionMaterialProfileDiagnostic(options, {
+        projectionNodeId,
+        source: slotBinding.source,
+        slotId: slotBinding.slot.slotId,
+        ownerNodePath: slotBinding.slot.ownerNodePath,
+        primitiveIndex: slotBinding.slot.primitiveIndex,
+        ...diagnostic,
+    });
+}
+function emitProjectionMaterialProfileDiagnostic(options, diagnostic) {
+    options.onMaterialProfileDiagnostic?.(diagnostic);
+    if (!diagnostic.warningMessage)
+        return;
+    options.logger?.warn?.('[BabylonEditorProjection] Material profile diagnostic warning', {
+        projectionNodeId: diagnostic.projectionNodeId,
+        source: diagnostic.source,
+        slotId: diagnostic.slotId,
+        ownerNodePath: diagnostic.ownerNodePath,
+        meshOwnerNodePath: diagnostic.meshOwnerNodePath,
+        matchKind: diagnostic.matchKind,
+        targetMaterialStatus: diagnostic.targetMaterialStatus,
+        warningMessage: diagnostic.warningMessage,
+    });
+}
+function readProjectionMaterialName(material) {
+    const name = material?.name;
+    return typeof name === 'string' && name.trim() ? name.trim() : undefined;
+}
+function readProjectionMaterialType(material) {
+    const getClassName = material?.getClassName;
+    const className = typeof getClassName === 'function' ? getClassName.call(material) : null;
+    return typeof className === 'string' && className.trim() ? className.trim() : className;
+}
 function createProjectionMaterialSlotBindings(node) {
     const bindings = [];
     const occupiedOwnerPaths = new Set();
@@ -1342,14 +1584,14 @@ function createProjectionMaterialSlotBindings(node) {
         const slot = createProjectionMaterialSlotDescriptor(binding?.slot, node.id);
         if (!profile || !slot)
             continue;
-        bindings.push({ slot, profile });
+        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 });
+        bindings.push({ slot, profile, source: 'legacySlotProfile' });
         occupiedOwnerPaths.add(slot.matchKey);
     }
     return bindings;
@@ -1422,7 +1664,7 @@ function readProjectionMaterialSlotBoundsTuple(value) {
         return undefined;
     return tuple;
 }
-function resolveProjectionSlotBindings(slotBindings, ownerNodePath, projectionNodeId) {
+function resolveProjectionSlotBindingMatches(slotBindings, ownerNodePath, projectionNodeId) {
     if (ownerNodePath == null)
         return [];
     const normalized = normalizeProjectionOwnerNodePath(ownerNodePath, { projectionNodeId });
@@ -1432,7 +1674,7 @@ function resolveProjectionSlotBindings(slotBindings, ownerNodePath, projectionNo
     let descendantMatchLength = -1;
     for (const binding of slotBindings) {
         if (binding.slot.matchKey === normalizedMatchKey) {
-            exactMatches.push(binding);
+            exactMatches.push({ binding, matchKind: 'exact' });
             continue;
         }
         if (isMaterialSlotOwnerPathMatch(normalized, binding.slot.normalizedOwnerNodePath, { projectionNodeId })) {
@@ -1440,8 +1682,9 @@ function resolveProjectionSlotBindings(slotBindings, ownerNodePath, projectionNo
                 descendantMatches.length = 0;
                 descendantMatchLength = binding.slot.matchKey.length;
             }
-            if (binding.slot.matchKey.length === descendantMatchLength)
-                descendantMatches.push(binding);
+            if (binding.slot.matchKey.length === descendantMatchLength) {
+                descendantMatches.push({ binding, matchKind: 'descendant' });
+            }
         }
     }
     return exactMatches.length > 0 ? exactMatches : descendantMatches;
@@ -1878,7 +2121,7 @@ function readProjectionAssetMaterialSlotString(value) {
 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);
@@ -1900,66 +2143,138 @@ 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;
-    if (!material)
-        return null;
+    const material = readProjectionWritableMeshMaterial(mesh);
+    if (!material) {
+        return {
+            target: null,
+            targetMaterialStatus: 'missingMaterial',
+            warningMessage: 'Slot material profile was not applied because the matched mesh has no target material.',
+        };
+    }
     if (slot.primitiveIndex == null) {
-        const slotMaterial = detachProjectionSlotMaterial(mesh, materialCounts, ownerNodePath);
-        if (!slotMaterial)
-            return null;
+        const detachResult = detachProjectionSlotMaterial(mesh, materialCounts, ownerNodePath);
+        if (!detachResult) {
+            return {
+                target: null,
+                targetMaterialStatus: 'missingTargetMaterial',
+                warningMessage: 'Slot material profile was not applied because the mesh material could not be detached.',
+            };
+        }
         return {
-            material: slotMaterial,
-            clonedMaterials: slotMaterial !== material ? [slotMaterial] : [],
+            target: {
+                material: detachResult.material,
+                clonedMaterials: detachResult.clonedMaterials,
+            },
+            targetMaterialStatus: 'material',
         };
     }
     if (!Array.isArray(material.subMaterials)) {
-        if (slot.primitiveIndex !== 0 || !options.primitiveSingleMaterialFallbackAllowed)
-            return null;
-        const slotMaterial = detachProjectionSlotMaterial(mesh, materialCounts, ownerNodePath);
-        if (!slotMaterial)
-            return null;
+        const isSplitPrimitiveOwner = isProjectionRuntimeSplitPrimitiveOwnerNode(mesh, slot);
+        if (!isSplitPrimitiveOwner && (slot.primitiveIndex !== 0 || !options.primitiveSingleMaterialFallbackAllowed)) {
+            return {
+                target: null,
+                targetMaterialStatus: 'missingSubMaterial',
+                warningMessage: 'Primitive slot material profile was not applied because the target mesh does not expose a matching subMaterial.',
+            };
+        }
+        const detachResult = detachProjectionSlotMaterial(mesh, materialCounts, ownerNodePath);
+        if (!detachResult) {
+            return {
+                target: null,
+                targetMaterialStatus: 'missingTargetMaterial',
+                warningMessage: 'Primitive slot material profile was not applied because the fallback mesh material could not be detached.',
+            };
+        }
+        return {
+            target: {
+                material: detachResult.material,
+                clonedMaterials: detachResult.clonedMaterials,
+            },
+            targetMaterialStatus: 'primitiveFallbackMaterial',
+        };
+    }
+    const detachResult = detachProjectionSlotMaterial(mesh, materialCounts, ownerNodePath);
+    const slotMaterial = detachResult?.material;
+    if (!detachResult || !Array.isArray(slotMaterial.subMaterials)) {
         return {
-            material: slotMaterial,
-            clonedMaterials: slotMaterial !== material ? [slotMaterial] : [],
+            target: null,
+            targetMaterialStatus: 'missingTargetMaterial',
+            warningMessage: 'Primitive slot material profile was not applied because the multi-material target could not be detached.',
         };
     }
-    const slotMaterial = detachProjectionSlotMaterial(mesh, materialCounts, ownerNodePath);
-    if (!slotMaterial || !Array.isArray(slotMaterial.subMaterials))
-        return null;
     const subMaterials = slotMaterial.subMaterials;
     const subMaterial = subMaterials[slot.primitiveIndex];
-    if (!subMaterial || typeof subMaterial !== 'object' || typeof subMaterial.clone !== 'function')
-        return null;
+    if (!subMaterial || typeof subMaterial !== 'object' || typeof subMaterial.clone !== 'function') {
+        return {
+            target: null,
+            targetMaterialStatus: 'missingSubMaterial',
+            warningMessage: 'Primitive slot material profile was not applied because the target subMaterial is missing or cannot be cloned.',
+        };
+    }
     const clonedSubMaterial = subMaterial.clone(createProjectionSlotSubMaterialName(subMaterial, ownerNodePath, slot.primitiveIndex));
-    if (!clonedSubMaterial)
-        return null;
+    if (!clonedSubMaterial) {
+        return {
+            target: null,
+            targetMaterialStatus: 'missingSubMaterial',
+            warningMessage: 'Primitive slot material profile was not applied because the target subMaterial clone failed.',
+        };
+    }
     subMaterials[slot.primitiveIndex] = clonedSubMaterial;
     return {
-        material: clonedSubMaterial,
-        clonedMaterials: [
-            ...(slotMaterial !== material ? [slotMaterial] : []),
-            clonedSubMaterial,
-        ],
+        target: {
+            material: clonedSubMaterial,
+            clonedMaterials: [
+                ...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;