@babylonjs/core 5.0.0-beta.3 → 5.0.0-beta.7

package/Loading/Plugins/babylonFileLoader.js

@@ -44,13 +44,14 @@ var BabylonFileLoaderConfiguration = /** @class */ (function () {
 }());
 export { BabylonFileLoaderConfiguration };
 var tempIndexContainer = {};
-var parseMaterialById = function (id, parsedData, scene, rootUrl) {
+var tempMaterialIndexContainer = {};
+var parseMaterialByPredicate = function (predicate, parsedData, scene, rootUrl) {
     if (!parsedData.materials) {
         return null;
     }
     for (var index = 0, cache = parsedData.materials.length; index < cache; index++) {
         var parsedMaterial = parsedData.materials[index];
-        if (parsedMaterial.id === id) {
+        if (predicate(parsedMaterial)) {
             return Material.Parse(parsedMaterial, scene, rootUrl);
         }
     }
@@ -114,6 +115,12 @@ var findParent = function (parentId, scene) {
     var parent = tempIndexContainer[parentId];
     return parent;
 };
+var findMaterial = function (materialId, scene) {
+    if (typeof materialId !== "number") {
+        return scene.getLastMaterialById(materialId, true);
+    }
+    return tempMaterialIndexContainer[materialId];
+};
 var loadAssetContainer = function (scene, data, rootUrl, onError, addToScene) {
     if (addToScene === void 0) { addToScene = false; }
     var container = new AssetContainer(scene);
@@ -214,6 +221,7 @@ var loadAssetContainer = function (scene, data, rootUrl, onError, addToScene) {
                 var parsedMaterial = parsedData.materials[index];
                 var mat = Material.Parse(parsedMaterial, scene, rootUrl);
                 if (mat) {
+                    tempMaterialIndexContainer[parsedMaterial.uniqueId || parsedMaterial.id] = mat;
                     container.materials.push(mat);
                     mat._parentContainer = container;
                     log += (index === 0 ? "\n\tMaterials:" : "");
@@ -233,6 +241,7 @@ var loadAssetContainer = function (scene, data, rootUrl, onError, addToScene) {
             for (index = 0, cache = parsedData.multiMaterials.length; index < cache; index++) {
                 var parsedMultiMaterial = parsedData.multiMaterials[index];
                 var mmat = MultiMaterial.ParseMultiMaterial(parsedMultiMaterial, scene);
+                tempMaterialIndexContainer[parsedMultiMaterial.uniqueId || parsedMultiMaterial.id] = mmat;
                 container.multiMaterials.push(mmat);
                 mmat._parentContainer = container;
                 log += (index === 0 ? "\n\tMultiMaterials:" : "");
@@ -384,6 +393,20 @@ var loadAssetContainer = function (scene, data, rootUrl, onError, addToScene) {
                 loadDetailLevels(scene, mesh);
             }
         }
+        // link multimats with materials
+        scene.multiMaterials.forEach(function (multimat) {
+            multimat._waitingSubMaterialsUniqueIds.forEach(function (subMaterial) {
+                multimat.subMaterials.push(findMaterial(subMaterial, scene));
+            });
+            multimat._waitingSubMaterialsUniqueIds = [];
+        });
+        // link meshes with materials
+        scene.meshes.forEach(function (mesh) {
+            if (mesh._waitingMaterialId !== null) {
+                mesh.material = findMaterial(mesh._waitingMaterialId, scene);
+                mesh._waitingMaterialId = null;
+            }
+        });
         // link skeleton transform nodes
         for (index = 0, cache = scene.skeletons.length; index < cache; index++) {
             var skeleton = scene.skeletons[index];
@@ -485,6 +508,7 @@ SceneLoader.RegisterPlugin({
         return false;
     },
     importMesh: function (meshesNames, scene, data, rootUrl, meshes, particleSystems, skeletons, onError) {
+        var _a;
         // Entire method running in try block, so ALWAYS logs as far as it got, only actually writes details
         // when SceneLoader.debugLogging = true (default), or exception encountered.
         // Everything stored in var log instead of writing separate lines to support only writing in exception,
@@ -501,13 +525,23 @@ SceneLoader.RegisterPlugin({
                 meshesNames = [meshesNames];
             }
             var hierarchyIds = new Array();
+            // Transform nodes (the overall idea is to load all of them as this is super fast and then get rid of the ones we don't need)
+            var loadedTransformNodes = [];
+            if (parsedData.transformNodes !== undefined && parsedData.transformNodes !== null) {
+                for (index = 0, cache = parsedData.transformNodes.length; index < cache; index++) {
+                    var parsedTransformNode = parsedData.transformNodes[index];
+                    loadedTransformNodes.push(TransformNode.Parse(parsedTransformNode, scene, rootUrl));
+                }
+            }
             if (parsedData.meshes !== undefined && parsedData.meshes !== null) {
                 var loadedSkeletonsIds = [];
                 var loadedMaterialsIds = [];
+                var loadedMaterialsUniqueIds = [];
+                var loadedMorphTargetsIds = [];
                 var index;
                 var cache;
-                for (index = 0, cache = parsedData.meshes.length; index < cache; index++) {
-                    var parsedMesh = parsedData.meshes[index];
+                var _loop_1 = function () {
+                    parsedMesh = parsedData.meshes[index];
                     if (meshesNames === null || isDescendantOf(parsedMesh, meshesNames, hierarchyIds)) {
                         if (meshesNames !== null) {
                             // Remove found mesh name from list.
@@ -518,7 +552,7 @@ SceneLoader.RegisterPlugin({
                             //does the file contain geometries?
                             if (parsedData.geometries !== undefined && parsedData.geometries !== null) {
                                 //find the correct geometry and add it to the scene
-                                var found = false;
+                                found = false;
                                 ["boxes", "spheres", "cylinders", "toruses", "grounds", "planes", "torusKnots", "vertexData"].forEach(function (geometryType) {
                                     if (found === true || !parsedData.geometries[geometryType] || !(Array.isArray(parsedData.geometries[geometryType]))) {
                                         return;
@@ -542,22 +576,31 @@ SceneLoader.RegisterPlugin({
                             }
                         }
                         // Material ?
-                        if (parsedMesh.materialId) {
-                            var materialFound = (loadedMaterialsIds.indexOf(parsedMesh.materialId) !== -1);
+                        if (parsedMesh.materialUniqueId || parsedMesh.materialId) {
+                            // if we have a unique ID, look up and store in loadedMaterialsUniqueIds, else use loadedMaterialsIds
+                            var materialArray_1 = parsedMesh.materialUniqueId ? loadedMaterialsUniqueIds : loadedMaterialsIds;
+                            materialFound = (materialArray_1.indexOf(parsedMesh.materialUniqueId || parsedMesh.materialId) !== -1);
                             if (materialFound === false && parsedData.multiMaterials !== undefined && parsedData.multiMaterials !== null) {
+                                // Loads a submaterial of a multimaterial
+                                var loadSubMaterial_1 = function (subMatId, predicate) {
+                                    materialArray_1.push(subMatId);
+                                    var mat = parseMaterialByPredicate(predicate, parsedData, scene, rootUrl);
+                                    if (mat) {
+                                        log += "\n\tMaterial " + mat.toString(fullDetails);
+                                    }
+                                };
                                 for (var multimatIndex = 0, multimatCache = parsedData.multiMaterials.length; multimatIndex < multimatCache; multimatIndex++) {
                                     var parsedMultiMaterial = parsedData.multiMaterials[multimatIndex];
-                                    if (parsedMultiMaterial.id === parsedMesh.materialId) {
-                                        for (var matIndex = 0, matCache = parsedMultiMaterial.materials.length; matIndex < matCache; matIndex++) {
-                                            var subMatId = parsedMultiMaterial.materials[matIndex];
-                                            loadedMaterialsIds.push(subMatId);
-                                            var mat = parseMaterialById(subMatId, parsedData, scene, rootUrl);
-                                            if (mat) {
-                                                log += "\n\tMaterial " + mat.toString(fullDetails);
-                                            }
+                                    if ((parsedMesh.materialUniqueId && parsedMultiMaterial.uniqueId === parsedMesh.materialUniqueId) || parsedMultiMaterial.id === parsedMesh.materialId) {
+                                        if (parsedMultiMaterial.materialsUniqueIds) { // if the materials inside the multimat are stored by unique id
+                                            parsedMultiMaterial.materialsUniqueIds.forEach(function (subMatId) { return loadSubMaterial_1(subMatId, function (parsedMaterial) { return parsedMaterial.uniqueId === subMatId; }); });
+                                        }
+                                        else { // if the mats are stored by id instead
+                                            parsedMultiMaterial.materials.forEach(function (subMatId) { return loadSubMaterial_1(subMatId, function (parsedMaterial) { return parsedMaterial.id === subMatId; }); });
                                         }
-                                        loadedMaterialsIds.push(parsedMultiMaterial.id);
-                                        var mmat = MultiMaterial.ParseMultiMaterial(parsedMultiMaterial, scene);
+                                        materialArray_1.push(parsedMultiMaterial.uniqueId || parsedMultiMaterial.id);
+                                        mmat = MultiMaterial.ParseMultiMaterial(parsedMultiMaterial, scene);
+                                        tempMaterialIndexContainer[parsedMultiMaterial.uniqueId || parsedMultiMaterial.id] = mmat;
                                         if (mmat) {
                                             materialFound = true;
                                             log += "\n\tMulti-Material " + mmat.toString(fullDetails);
@@ -567,8 +610,8 @@ SceneLoader.RegisterPlugin({
                                 }
                             }
                             if (materialFound === false) {
-                                loadedMaterialsIds.push(parsedMesh.materialId);
-                                var mat = parseMaterialById(parsedMesh.materialId, parsedData, scene, rootUrl);
+                                materialArray_1.push(parsedMesh.materialUniqueId || parsedMesh.materialId);
+                                mat = parseMaterialByPredicate(function (parsedMaterial) { return (parsedMesh.MaterialUniqueId && parsedMaterial.uniqueId === parsedMesh.materialUniqueId || parsedMaterial.id === parsedMesh.materialId); }, parsedData, scene, rootUrl);
                                 if (!mat) {
                                     Logger.Warn("Material not found for mesh " + parsedMesh.id);
                                 }
@@ -579,12 +622,12 @@ SceneLoader.RegisterPlugin({
                         }
                         // Skeleton ?
                         if (parsedMesh.skeletonId > -1 && parsedData.skeletons !== undefined && parsedData.skeletons !== null) {
-                            var skeletonAlreadyLoaded = (loadedSkeletonsIds.indexOf(parsedMesh.skeletonId) > -1);
-                            if (skeletonAlreadyLoaded === false) {
+                            skeletonAlreadyLoaded = (loadedSkeletonsIds.indexOf(parsedMesh.skeletonId) > -1);
+                            if (!skeletonAlreadyLoaded) {
                                 for (var skeletonIndex = 0, skeletonCache = parsedData.skeletons.length; skeletonIndex < skeletonCache; skeletonIndex++) {
-                                    var parsedSkeleton = parsedData.skeletons[skeletonIndex];
+                                    parsedSkeleton = parsedData.skeletons[skeletonIndex];
                                     if (parsedSkeleton.id === parsedMesh.skeletonId) {
-                                        var skeleton = Skeleton.Parse(parsedSkeleton, scene);
+                                        skeleton = Skeleton.Parse(parsedSkeleton, scene);
                                         skeletons.push(skeleton);
                                         loadedSkeletonsIds.push(parsedSkeleton.id);
                                         log += "\n\tSkeleton " + skeleton.toString(fullDetails);
@@ -593,29 +636,72 @@ SceneLoader.RegisterPlugin({
                             }
                         }
                         // Morph targets ?
-                        if (parsedData.morphTargetManagers !== undefined && parsedData.morphTargetManagers !== null) {
-                            for (var _i = 0, _a = parsedData.morphTargetManagers; _i < _a.length; _i++) {
-                                var managerData = _a[_i];
-                                MorphTargetManager.Parse(managerData, scene);
+                        if (parsedMesh.morphTargetManagerId > -1 && parsedData.morphTargetManagers !== undefined && parsedData.morphTargetManagers !== null) {
+                            morphTargetAlreadyLoaded = (loadedMorphTargetsIds.indexOf(parsedMesh.morphTargetManagerId) > -1);
+                            if (!morphTargetAlreadyLoaded) {
+                                for (var morphTargetIndex = 0, morphTargetCache = parsedData.morphTargetManagers.length; morphTargetIndex < morphTargetCache; morphTargetIndex++) {
+                                    parsedMorphTarget = parsedData.morphTargetManagers[morphTargetIndex];
+                                    if (parsedMorphTarget.id === parsedMesh.morphTargetManagerId) {
+                                        morphTarget = MorphTargetManager.Parse(parsedMorphTarget, scene);
+                                        loadedMorphTargetsIds.push(morphTarget.uniqueId);
+                                        log += "\n\Morph target " + morphTarget.toString();
+                                    }
+                                }
                             }
                         }
-                        var mesh = Mesh.Parse(parsedMesh, scene, rootUrl);
+                        mesh = Mesh.Parse(parsedMesh, scene, rootUrl);
                         meshes.push(mesh);
                         log += "\n\tMesh " + mesh.toString(fullDetails);
                     }
+                };
+                var parsedMesh, found, materialFound, mmat, mat, skeletonAlreadyLoaded, parsedSkeleton, skeleton, morphTargetAlreadyLoaded, parsedMorphTarget, morphTarget, mesh;
+                for (index = 0, cache = parsedData.meshes.length; index < cache; index++) {
+                    _loop_1();
                 }
+                // link multimats with materials
+                scene.multiMaterials.forEach(function (multimat) {
+                    multimat._waitingSubMaterialsUniqueIds.forEach(function (subMaterial) {
+                        multimat.subMaterials.push(findMaterial(subMaterial, scene));
+                    });
+                    multimat._waitingSubMaterialsUniqueIds = [];
+                });
+                // link meshes with materials
+                scene.meshes.forEach(function (mesh) {
+                    if (mesh._waitingMaterialId !== null) {
+                        mesh.material = findMaterial(mesh._waitingMaterialId, scene);
+                        mesh._waitingMaterialId = null;
+                    }
+                });
                 // Connecting parents and lods
+                for (index = 0, cache = scene.transformNodes.length; index < cache; index++) {
+                    var transformNode = scene.transformNodes[index];
+                    if (transformNode._waitingParentId !== null) {
+                        transformNode.parent = scene.getLastEntryById(transformNode._waitingParentId);
+                        transformNode._waitingParentId = null;
+                    }
+                }
                 var currentMesh;
                 for (index = 0, cache = scene.meshes.length; index < cache; index++) {
                     currentMesh = scene.meshes[index];
-                    if (currentMesh._waitingParentId !== null) {
+                    if (currentMesh._waitingParentId) {
                         currentMesh.parent = scene.getLastEntryById(currentMesh._waitingParentId);
+                        if (((_a = currentMesh.parent) === null || _a === void 0 ? void 0 : _a.getClassName()) === "TransformNode") {
+                            var loadedTransformNodeIndex = loadedTransformNodes.indexOf(currentMesh.parent);
+                            if (loadedTransformNodeIndex > -1) {
+                                loadedTransformNodes.splice(loadedTransformNodeIndex, 1);
+                            }
+                        }
                         currentMesh._waitingParentId = null;
                     }
                     if (currentMesh._waitingData.lods) {
                         loadDetailLevels(scene, currentMesh);
                     }
                 }
+                // Remove unused transform nodes
+                for (var _i = 0, loadedTransformNodes_1 = loadedTransformNodes; _i < loadedTransformNodes_1.length; _i++) {
+                    var transformNode_1 = loadedTransformNodes_1[_i];
+                    transformNode_1.dispose();
+                }
                 // link skeleton transform nodes
                 for (index = 0, cache = scene.skeletons.length; index < cache; index++) {
                     var skeleton = scene.skeletons[index];