@babylonjs/loaders 5.0.0-rc.0 → 5.0.0-rc.11

package/OBJ/objFileLoader.js

@@ -1,301 +1,297 @@
-import { Vector2 } from "@babylonjs/core/Maths/math.vector.js";
-import { Tools } from "@babylonjs/core/Misc/tools.js";
-import { SceneLoader } from "@babylonjs/core/Loading/sceneLoader.js";
-import { AssetContainer } from "@babylonjs/core/assetContainer.js";
-import { MTLFileLoader } from './mtlFileLoader.js';
-import { SolidParser } from "./solidParser.js";
-/**
- * OBJ file type loader.
- * This is a babylon scene loader plugin.
- */
-var OBJFileLoader = /** @class */ (function () {
-    /**
-     * Creates loader for .OBJ files
-     *
-     * @param loadingOptions options for loading and parsing OBJ/MTL files.
-     */
-    function OBJFileLoader(loadingOptions) {
-        /**
-         * Defines the name of the plugin.
-         */
-        this.name = "obj";
-        /**
-         * Defines the extension the plugin is able to load.
-         */
-        this.extensions = ".obj";
-        this._assetContainer = null;
-        this._loadingOptions = loadingOptions || OBJFileLoader.DefaultLoadingOptions;
-    }
-    Object.defineProperty(OBJFileLoader, "INVERT_TEXTURE_Y", {
-        /**
-         * Invert Y-Axis of referenced textures on load
-         */
-        get: function () {
-            return MTLFileLoader.INVERT_TEXTURE_Y;
-        },
-        set: function (value) {
-            MTLFileLoader.INVERT_TEXTURE_Y = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(OBJFileLoader, "DefaultLoadingOptions", {
-        get: function () {
-            return {
-                computeNormals: OBJFileLoader.COMPUTE_NORMALS,
-                optimizeNormals: OBJFileLoader.OPTIMIZE_NORMALS,
-                importVertexColors: OBJFileLoader.IMPORT_VERTEX_COLORS,
-                invertY: OBJFileLoader.INVERT_Y,
-                invertTextureY: OBJFileLoader.INVERT_TEXTURE_Y,
-                UVScaling: OBJFileLoader.UV_SCALING,
-                materialLoadingFailsSilently: OBJFileLoader.MATERIAL_LOADING_FAILS_SILENTLY,
-                optimizeWithUV: OBJFileLoader.OPTIMIZE_WITH_UV,
-                skipMaterials: OBJFileLoader.SKIP_MATERIALS
-            };
-        },
-        enumerable: false,
-        configurable: true
-    });
-    /**
-     * Calls synchronously the MTL file attached to this obj.
-     * Load function or importMesh function don't enable to load 2 files in the same time asynchronously.
-     * Without this function materials are not displayed in the first frame (but displayed after).
-     * In consequence it is impossible to get material information in your HTML file
-     *
-     * @param url The URL of the MTL file
-     * @param rootUrl defines where to load data from
-     * @param onSuccess Callback function to be called when the MTL file is loaded
-     */
-    OBJFileLoader.prototype._loadMTL = function (url, rootUrl, onSuccess, onFailure) {
-        //The complete path to the mtl file
-        var pathOfFile = rootUrl + url;
-        // Loads through the babylon tools to allow fileInput search.
-        Tools.LoadFile(pathOfFile, onSuccess, undefined, undefined, false, function (request, exception) {
-            onFailure(pathOfFile, exception);
-        });
-    };
-    /**
-     * Instantiates a OBJ file loader plugin.
-     * @returns the created plugin
-     */
-    OBJFileLoader.prototype.createPlugin = function () {
-        return new OBJFileLoader(OBJFileLoader.DefaultLoadingOptions);
-    };
-    /**
-     * If the data string can be loaded directly.
-     *
-     * @param data string containing the file data
-     * @returns if the data can be loaded directly
-     */
-    OBJFileLoader.prototype.canDirectLoad = function (data) {
-        return false;
-    };
-    /**
-     * Imports one or more meshes from the loaded OBJ data and adds them to the scene
-     * @param meshesNames a string or array of strings of the mesh names that should be loaded from the file
-     * @param scene the scene the meshes should be added to
-     * @param data the OBJ data to load
-     * @param rootUrl root url to load from
-     * @param onProgress event that fires when loading progress has occured
-     * @param fileName Defines the name of the file to load
-     * @returns a promise containg the loaded meshes, particles, skeletons and animations
-     */
-    OBJFileLoader.prototype.importMeshAsync = function (meshesNames, scene, data, rootUrl, onProgress, fileName) {
-        //get the meshes from OBJ file
-        return this._parseSolid(meshesNames, scene, data, rootUrl).then(function (meshes) {
-            return {
-                meshes: meshes,
-                particleSystems: [],
-                skeletons: [],
-                animationGroups: [],
-                transformNodes: [],
-                geometries: [],
-                lights: []
-            };
-        });
-    };
-    /**
-     * Imports all objects from the loaded OBJ data and adds them to the scene
-     * @param scene the scene the objects should be added to
-     * @param data the OBJ data to load
-     * @param rootUrl root url to load from
-     * @param onProgress event that fires when loading progress has occured
-     * @param fileName Defines the name of the file to load
-     * @returns a promise which completes when objects have been loaded to the scene
-     */
-    OBJFileLoader.prototype.loadAsync = function (scene, data, rootUrl, onProgress, fileName) {
-        //Get the 3D model
-        return this.importMeshAsync(null, scene, data, rootUrl, onProgress).then(function () {
-            // return void
-        });
-    };
-    /**
-     * Load into an asset container.
-     * @param scene The scene to load into
-     * @param data The data to import
-     * @param rootUrl The root url for scene and resources
-     * @param onProgress The callback when the load progresses
-     * @param fileName Defines the name of the file to load
-     * @returns The loaded asset container
-     */
-    OBJFileLoader.prototype.loadAssetContainerAsync = function (scene, data, rootUrl, onProgress, fileName) {
-        var _this = this;
-        var container = new AssetContainer(scene);
-        this._assetContainer = container;
-        return this.importMeshAsync(null, scene, data, rootUrl).then(function (result) {
-            result.meshes.forEach(function (mesh) { return container.meshes.push(mesh); });
-            result.meshes.forEach(function (mesh) {
-                var material = mesh.material;
-                if (material) {
-                    // Materials
-                    if (container.materials.indexOf(material) == -1) {
-                        container.materials.push(material);
-                        // Textures
-                        var textures = material.getActiveTextures();
-                        textures.forEach(function (t) {
-                            if (container.textures.indexOf(t) == -1) {
-                                container.textures.push(t);
-                            }
-                        });
-                    }
-                }
-            });
-            _this._assetContainer = null;
-            return container;
-        }).catch(function (ex) {
-            _this._assetContainer = null;
-            throw ex;
-        });
-    };
-    /**
-     * Read the OBJ file and create an Array of meshes.
-     * Each mesh contains all information given by the OBJ and the MTL file.
-     * i.e. vertices positions and indices, optional normals values, optional UV values, optional material
-     * @param meshesNames defines a string or array of strings of the mesh names that should be loaded from the file
-     * @param scene defines the scene where are displayed the data
-     * @param data defines the content of the obj file
-     * @param rootUrl defines the path to the folder
-     * @returns the list of loaded meshes
-     */
-    OBJFileLoader.prototype._parseSolid = function (meshesNames, scene, data, rootUrl) {
-        var _this = this;
-        var fileToLoad = ""; //The name of the mtlFile to load
-        var materialsFromMTLFile = new MTLFileLoader();
-        var materialToUse = new Array();
-        var babylonMeshesArray = []; //The mesh for babylon
-        // Main function
-        var solidParser = new SolidParser(materialToUse, babylonMeshesArray, this._loadingOptions);
-        solidParser.parse(meshesNames, data, scene, this._assetContainer, function (fileName) {
-            fileToLoad = fileName;
-        });
-        // load the materials
-        var mtlPromises = [];
-        // Check if we have a file to load
-        if (fileToLoad !== "" && !this._loadingOptions.skipMaterials) {
-            //Load the file synchronously
-            mtlPromises.push(new Promise(function (resolve, reject) {
-                _this._loadMTL(fileToLoad, rootUrl, function (dataLoaded) {
-                    try {
-                        //Create materials thanks MTLLoader function
-                        materialsFromMTLFile.parseMTL(scene, dataLoaded, rootUrl, _this._assetContainer);
-                        //Look at each material loaded in the mtl file
-                        for (var n = 0; n < materialsFromMTLFile.materials.length; n++) {
-                            //Three variables to get all meshes with the same material
-                            var startIndex = 0;
-                            var _indices = [];
-                            var _index;
-                            //The material from MTL file is used in the meshes loaded
-                            //Push the indice in an array
-                            //Check if the material is not used for another mesh
-                            while ((_index = materialToUse.indexOf(materialsFromMTLFile.materials[n].name, startIndex)) > -1) {
-                                _indices.push(_index);
-                                startIndex = _index + 1;
-                            }
-                            //If the material is not used dispose it
-                            if (_index === -1 && _indices.length === 0) {
-                                //If the material is not needed, remove it
-                                materialsFromMTLFile.materials[n].dispose();
-                            }
-                            else {
-                                for (var o = 0; o < _indices.length; o++) {
-                                    //Apply the material to the Mesh for each mesh with the material
-                                    var mesh = babylonMeshesArray[_indices[o]];
-                                    var material = materialsFromMTLFile.materials[n];
-                                    mesh.material = material;
-                                    if (!mesh.getTotalIndices()) {
-                                        // No indices, we need to turn on point cloud
-                                        material.pointsCloud = true;
-                                    }
-                                }
-                            }
-                        }
-                        resolve();
-                    }
-                    catch (e) {
-                        Tools.Warn("Error processing MTL file: '".concat(fileToLoad, "'"));
-                        if (_this._loadingOptions.materialLoadingFailsSilently) {
-                            resolve();
-                        }
-                        else {
-                            reject(e);
-                        }
-                    }
-                }, function (pathOfFile, exception) {
-                    Tools.Warn("Error downloading MTL file: '".concat(fileToLoad, "'"));
-                    if (_this._loadingOptions.materialLoadingFailsSilently) {
-                        resolve();
-                    }
-                    else {
-                        reject(exception);
-                    }
-                });
-            }));
-        }
-        //Return an array with all Mesh
-        return Promise.all(mtlPromises).then(function () {
-            return babylonMeshesArray;
-        });
-    };
-    /**
-     * Defines if UVs are optimized by default during load.
-     */
-    OBJFileLoader.OPTIMIZE_WITH_UV = true;
-    /**
-     * Invert model on y-axis (does a model scaling inversion)
-     */
-    OBJFileLoader.INVERT_Y = false;
-    /**
-     * Include in meshes the vertex colors available in some OBJ files.  This is not part of OBJ standard.
-     */
-    OBJFileLoader.IMPORT_VERTEX_COLORS = false;
-    /**
-     * Compute the normals for the model, even if normals are present in the file.
-     */
-    OBJFileLoader.COMPUTE_NORMALS = false;
-    /**
-     * Optimize the normals for the model. Lighting can be uneven if you use OptimizeWithUV = true because new vertices can be created for the same location if they pertain to different faces.
-     * Using OptimizehNormals = true will help smoothing the lighting by averaging the normals of those vertices.
-     */
-    OBJFileLoader.OPTIMIZE_NORMALS = false;
-    /**
-     * Defines custom scaling of UV coordinates of loaded meshes.
-     */
-    OBJFileLoader.UV_SCALING = new Vector2(1, 1);
-    /**
-     * Skip loading the materials even if defined in the OBJ file (materials are ignored).
-     */
-    OBJFileLoader.SKIP_MATERIALS = false;
-    /**
-     * When a material fails to load OBJ loader will silently fail and onSuccess() callback will be triggered.
-     *
-     * Defaults to true for backwards compatibility.
-     */
-    OBJFileLoader.MATERIAL_LOADING_FAILS_SILENTLY = true;
-    return OBJFileLoader;
-}());
-export { OBJFileLoader };
-if (SceneLoader) {
-    //Add this loader into the register plugin
-    SceneLoader.RegisterPlugin(new OBJFileLoader());
-}
+import { Vector2 } from "@babylonjs/core/Maths/math.vector.js";
+import { Tools } from "@babylonjs/core/Misc/tools.js";
+import { SceneLoader } from "@babylonjs/core/Loading/sceneLoader.js";
+import { AssetContainer } from "@babylonjs/core/assetContainer.js";
+import { MTLFileLoader } from "./mtlFileLoader";
+import { SolidParser } from "./solidParser";
+/**
+ * OBJ file type loader.
+ * This is a babylon scene loader plugin.
+ */
+var OBJFileLoader = /** @class */ (function () {
+    /**
+     * Creates loader for .OBJ files
+     *
+     * @param loadingOptions options for loading and parsing OBJ/MTL files.
+     */
+    function OBJFileLoader(loadingOptions) {
+        /**
+         * Defines the name of the plugin.
+         */
+        this.name = "obj";
+        /**
+         * Defines the extension the plugin is able to load.
+         */
+        this.extensions = ".obj";
+        this._assetContainer = null;
+        this._loadingOptions = loadingOptions || OBJFileLoader._DefaultLoadingOptions;
+    }
+    Object.defineProperty(OBJFileLoader, "INVERT_TEXTURE_Y", {
+        /**
+         * Invert Y-Axis of referenced textures on load
+         */
+        get: function () {
+            return MTLFileLoader.INVERT_TEXTURE_Y;
+        },
+        set: function (value) {
+            MTLFileLoader.INVERT_TEXTURE_Y = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(OBJFileLoader, "_DefaultLoadingOptions", {
+        get: function () {
+            return {
+                computeNormals: OBJFileLoader.COMPUTE_NORMALS,
+                optimizeNormals: OBJFileLoader.OPTIMIZE_NORMALS,
+                importVertexColors: OBJFileLoader.IMPORT_VERTEX_COLORS,
+                invertY: OBJFileLoader.INVERT_Y,
+                invertTextureY: OBJFileLoader.INVERT_TEXTURE_Y,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                UVScaling: OBJFileLoader.UV_SCALING,
+                materialLoadingFailsSilently: OBJFileLoader.MATERIAL_LOADING_FAILS_SILENTLY,
+                optimizeWithUV: OBJFileLoader.OPTIMIZE_WITH_UV,
+                skipMaterials: OBJFileLoader.SKIP_MATERIALS,
+            };
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Calls synchronously the MTL file attached to this obj.
+     * Load function or importMesh function don't enable to load 2 files in the same time asynchronously.
+     * Without this function materials are not displayed in the first frame (but displayed after).
+     * In consequence it is impossible to get material information in your HTML file
+     *
+     * @param url The URL of the MTL file
+     * @param rootUrl defines where to load data from
+     * @param onSuccess Callback function to be called when the MTL file is loaded
+     * @param onFailure
+     */
+    OBJFileLoader.prototype._loadMTL = function (url, rootUrl, onSuccess, onFailure) {
+        //The complete path to the mtl file
+        var pathOfFile = rootUrl + url;
+        // Loads through the babylon tools to allow fileInput search.
+        Tools.LoadFile(pathOfFile, onSuccess, undefined, undefined, false, function (request, exception) {
+            onFailure(pathOfFile, exception);
+        });
+    };
+    /**
+     * Instantiates a OBJ file loader plugin.
+     * @returns the created plugin
+     */
+    OBJFileLoader.prototype.createPlugin = function () {
+        return new OBJFileLoader(OBJFileLoader._DefaultLoadingOptions);
+    };
+    /**
+     * If the data string can be loaded directly.
+     * @returns if the data can be loaded directly
+     */
+    OBJFileLoader.prototype.canDirectLoad = function () {
+        return false;
+    };
+    /**
+     * Imports one or more meshes from the loaded OBJ data and adds them to the scene
+     * @param meshesNames a string or array of strings of the mesh names that should be loaded from the file
+     * @param scene the scene the meshes should be added to
+     * @param data the OBJ data to load
+     * @param rootUrl root url to load from
+     * @returns a promise containing the loaded meshes, particles, skeletons and animations
+     */
+    OBJFileLoader.prototype.importMeshAsync = function (meshesNames, scene, data, rootUrl) {
+        //get the meshes from OBJ file
+        return this._parseSolid(meshesNames, scene, data, rootUrl).then(function (meshes) {
+            return {
+                meshes: meshes,
+                particleSystems: [],
+                skeletons: [],
+                animationGroups: [],
+                transformNodes: [],
+                geometries: [],
+                lights: [],
+            };
+        });
+    };
+    /**
+     * Imports all objects from the loaded OBJ data and adds them to the scene
+     * @param scene the scene the objects should be added to
+     * @param data the OBJ data to load
+     * @param rootUrl root url to load from
+     * @returns a promise which completes when objects have been loaded to the scene
+     */
+    OBJFileLoader.prototype.loadAsync = function (scene, data, rootUrl) {
+        //Get the 3D model
+        return this.importMeshAsync(null, scene, data, rootUrl).then(function () {
+            // return void
+        });
+    };
+    /**
+     * Load into an asset container.
+     * @param scene The scene to load into
+     * @param data The data to import
+     * @param rootUrl The root url for scene and resources
+     * @returns The loaded asset container
+     */
+    OBJFileLoader.prototype.loadAssetContainerAsync = function (scene, data, rootUrl) {
+        var _this = this;
+        var container = new AssetContainer(scene);
+        this._assetContainer = container;
+        return this.importMeshAsync(null, scene, data, rootUrl)
+            .then(function (result) {
+            result.meshes.forEach(function (mesh) { return container.meshes.push(mesh); });
+            result.meshes.forEach(function (mesh) {
+                var material = mesh.material;
+                if (material) {
+                    // Materials
+                    if (container.materials.indexOf(material) == -1) {
+                        container.materials.push(material);
+                        // Textures
+                        var textures = material.getActiveTextures();
+                        textures.forEach(function (t) {
+                            if (container.textures.indexOf(t) == -1) {
+                                container.textures.push(t);
+                            }
+                        });
+                    }
+                }
+            });
+            _this._assetContainer = null;
+            return container;
+        })
+            .catch(function (ex) {
+            _this._assetContainer = null;
+            throw ex;
+        });
+    };
+    /**
+     * Read the OBJ file and create an Array of meshes.
+     * Each mesh contains all information given by the OBJ and the MTL file.
+     * i.e. vertices positions and indices, optional normals values, optional UV values, optional material
+     * @param meshesNames defines a string or array of strings of the mesh names that should be loaded from the file
+     * @param scene defines the scene where are displayed the data
+     * @param data defines the content of the obj file
+     * @param rootUrl defines the path to the folder
+     * @returns the list of loaded meshes
+     */
+    OBJFileLoader.prototype._parseSolid = function (meshesNames, scene, data, rootUrl) {
+        var _this = this;
+        var fileToLoad = ""; //The name of the mtlFile to load
+        var materialsFromMTLFile = new MTLFileLoader();
+        var materialToUse = new Array();
+        var babylonMeshesArray = []; //The mesh for babylon
+        // Main function
+        var solidParser = new SolidParser(materialToUse, babylonMeshesArray, this._loadingOptions);
+        solidParser.parse(meshesNames, data, scene, this._assetContainer, function (fileName) {
+            fileToLoad = fileName;
+        });
+        // load the materials
+        var mtlPromises = [];
+        // Check if we have a file to load
+        if (fileToLoad !== "" && !this._loadingOptions.skipMaterials) {
+            //Load the file synchronously
+            mtlPromises.push(new Promise(function (resolve, reject) {
+                _this._loadMTL(fileToLoad, rootUrl, function (dataLoaded) {
+                    try {
+                        //Create materials thanks MTLLoader function
+                        materialsFromMTLFile.parseMTL(scene, dataLoaded, rootUrl, _this._assetContainer);
+                        //Look at each material loaded in the mtl file
+                        for (var n = 0; n < materialsFromMTLFile.materials.length; n++) {
+                            //Three variables to get all meshes with the same material
+                            var startIndex = 0;
+                            var _indices = [];
+                            var _index = void 0;
+                            //The material from MTL file is used in the meshes loaded
+                            //Push the indice in an array
+                            //Check if the material is not used for another mesh
+                            while ((_index = materialToUse.indexOf(materialsFromMTLFile.materials[n].name, startIndex)) > -1) {
+                                _indices.push(_index);
+                                startIndex = _index + 1;
+                            }
+                            //If the material is not used dispose it
+                            if (_index === -1 && _indices.length === 0) {
+                                //If the material is not needed, remove it
+                                materialsFromMTLFile.materials[n].dispose();
+                            }
+                            else {
+                                for (var o = 0; o < _indices.length; o++) {
+                                    //Apply the material to the Mesh for each mesh with the material
+                                    var mesh = babylonMeshesArray[_indices[o]];
+                                    var material = materialsFromMTLFile.materials[n];
+                                    mesh.material = material;
+                                    if (!mesh.getTotalIndices()) {
+                                        // No indices, we need to turn on point cloud
+                                        material.pointsCloud = true;
+                                    }
+                                }
+                            }
+                        }
+                        resolve();
+                    }
+                    catch (e) {
+                        Tools.Warn("Error processing MTL file: '".concat(fileToLoad, "'"));
+                        if (_this._loadingOptions.materialLoadingFailsSilently) {
+                            resolve();
+                        }
+                        else {
+                            reject(e);
+                        }
+                    }
+                }, function (pathOfFile, exception) {
+                    Tools.Warn("Error downloading MTL file: '".concat(fileToLoad, "'"));
+                    if (_this._loadingOptions.materialLoadingFailsSilently) {
+                        resolve();
+                    }
+                    else {
+                        reject(exception);
+                    }
+                });
+            }));
+        }
+        //Return an array with all Mesh
+        return Promise.all(mtlPromises).then(function () {
+            return babylonMeshesArray;
+        });
+    };
+    /**
+     * Defines if UVs are optimized by default during load.
+     */
+    OBJFileLoader.OPTIMIZE_WITH_UV = true;
+    /**
+     * Invert model on y-axis (does a model scaling inversion)
+     */
+    OBJFileLoader.INVERT_Y = false;
+    /**
+     * Include in meshes the vertex colors available in some OBJ files.  This is not part of OBJ standard.
+     */
+    OBJFileLoader.IMPORT_VERTEX_COLORS = false;
+    /**
+     * Compute the normals for the model, even if normals are present in the file.
+     */
+    OBJFileLoader.COMPUTE_NORMALS = false;
+    /**
+     * Optimize the normals for the model. Lighting can be uneven if you use OptimizeWithUV = true because new vertices can be created for the same location if they pertain to different faces.
+     * Using OptimizehNormals = true will help smoothing the lighting by averaging the normals of those vertices.
+     */
+    OBJFileLoader.OPTIMIZE_NORMALS = false;
+    /**
+     * Defines custom scaling of UV coordinates of loaded meshes.
+     */
+    OBJFileLoader.UV_SCALING = new Vector2(1, 1);
+    /**
+     * Skip loading the materials even if defined in the OBJ file (materials are ignored).
+     */
+    OBJFileLoader.SKIP_MATERIALS = false;
+    /**
+     * When a material fails to load OBJ loader will silently fail and onSuccess() callback will be triggered.
+     *
+     * Defaults to true for backwards compatibility.
+     */
+    OBJFileLoader.MATERIAL_LOADING_FAILS_SILENTLY = true;
+    return OBJFileLoader;
+}());
+export { OBJFileLoader };
+if (SceneLoader) {
+    //Add this loader into the register plugin
+    SceneLoader.RegisterPlugin(new OBJFileLoader());
+}
 //# sourceMappingURL=objFileLoader.js.map