text: /// <reference path="../../../dist/preview release/babylon.d.ts"/>
  
  (function (BABYLON) {
      /**
       * Class reading and parsing the MTL file bundled with the obj file.
       */
      var MTLFileLoader = (function () {
          function MTLFileLoader() {
              // All material loaded from the mtl will be set here
              this.materials = [];
              /**
               * This function will read the mtl file and create each material described inside
               * This function could be improve by adding :
               * -some component missing (Ni, Tf...)
               * -including the specific options available
               *
               * @param scene
               * @param data
               * @param rootUrl
               */
              this.parseMTL = function (scene, data, rootUrl) {
                  //Split the lines from the file
                  var lines = data.split('\n');
                  //Space char
                  var delimiter_pattern = /\s+/;
                  //Array with RGB colors
                  var color;
                  //New material
                  var material;
                  //Look at each line
                  for (var i = 0; i < lines.length; i++) {
                      var line = lines[i].trim();
                      // Blank line or comment
                      if (line.length === 0 || line.charAt(0) === '#') {
                          continue;
                      }
                      //Get the first parameter (keyword)
                      var pos = line.indexOf(' ');
                      var key = (pos >= 0) ? line.substring(0, pos) : line;
                      key = key.toLowerCase();
                      //Get the data following the key
                      var value = (pos >= 0) ? line.substring(pos + 1).trim() : "";
                      //This mtl keyword will create the new material
                      if (key === "newmtl") {
                          //Check if it is the first material.
                          // Materials specifications are described after this keyword.
                          if (material) {
                              //Add the previous material in the material array.
                              this.materials.push(material);
                          }
                          //Create a new material.
                          // value is the name of the material read in the mtl file
                          material = new BABYLON.StandardMaterial(value, scene);
                      }
                      else if (key === "kd") {
                          // Diffuse color (color under white light) using RGB values
                          //value  = "r g b"
                          color = value.split(delimiter_pattern, 3);
                          //color = [r,g,b]
                          //Set tghe color into the material
                          material.diffuseColor = BABYLON.Color3.FromArray([1,1,1]);
                          material.specularColor = BABYLON.Color3.FromArray([0,0,0]);
                      }
                      else if (key === "ka") {
                          // Ambient color (color under shadow) using RGB values
                          //value = "r g b"
                          color = value.split(delimiter_pattern, 3);
                          //color = [r,g,b]
                          //Set tghe color into the material
                          material.ambientColor = BABYLON.Color3.FromArray(color);
                      }
                      else if (key === "ke") {
                          // Ambient color (color under shadow) using RGB values
                          //value = "r g b"
                          color = value.split(delimiter_pattern, 3);
                          //color = [r,g,b]
                          //Set tghe color into the material
                          material.emissiveColor = BABYLON.Color3.FromArray(color);
                      }
                      else if (key === "ks") {
                          // Specular color (color when light is reflected from shiny surface) using RGB values
                          //value = "r g b"
                          color = value.split(delimiter_pattern, 3);
                          //color = [r,g,b]
                          //Set the color into the material
                      }
                      else if (key === "ns") {
                          //value = "Integer"
                          material.specularPower = value;
                      }
                      else if (key === "d") {
                          //d is dissolve for current material. It mean alpha for BABYLON
                          material.alpha = value;
                      }
                      else if (key === "map_ka") {
                          // ambient texture map with a loaded image
                          //We must first get the folder of the image
                          //material.ambientTexture = MTLFileLoader._getTexture(rootUrl, value, scene);
                      }
                      else if (key === "map_kd") {
                          // Diffuse texture map with a loaded image
                          material.diffuseTexture = MTLFileLoader._getTexture(rootUrl, value, scene);
                      }
                      else if (key === "map_ks") {
                          // Specular texture map with a loaded image
                          //We must first get the folder of the image
                          //material.specularTexture = MTLFileLoader._getTexture(rootUrl, value, scene);
                      }
                      else if (key === "map_ns") {
                      }
                      else if (key === "map_bump") {
                          //The bump texture
                          material.bumpTexture = MTLFileLoader._getTexture(rootUrl, value, scene);
                      }
                      else if (key === "map_d") {
                          // The dissolve of the material
                          material.opacityTexture = MTLFileLoader._getTexture(rootUrl, value, scene);
                      }
                      else if (key === "illum") {
                          //Illumination
                          if (value === "0") {
                          }
                          else if (value === "1") {
                          }
                          else if (value === "2") {
                          }
                          else if (value === "3") {
                          }
                          else if (value === "4") {
                          }
                          else if (value === "5") {
                          }
                          else if (value === "6") {
                          }
                          else if (value === "7") {
                          }
                          else if (value === "8") {
                          }
                          else if (value === "9") {
                          }
                          else if (value === "10") {
                          }
                      }
                      else {
                      }
                  }
                  //At the end of the file, add the last material
                  this.materials.push(material);
              };
          }
          /**
           * Gets the texture for the material.
           *
           * If the material is imported from input file,
           * We sanitize the url to ensure it takes the textre from aside the material.
           *
           * @param rootUrl The root url to load from
           * @param value The value stored in the mtl
           * @return The Texture
           */
          MTLFileLoader._getTexture = function (rootUrl, value, scene) {
              var url = rootUrl;
              // Load from input file.
              if (rootUrl === "file:") {
                  var lastDelimiter = value.lastIndexOf("\\");
                  if (lastDelimiter === -1) {
                      lastDelimiter = value.lastIndexOf("/");
                  }
                  if (lastDelimiter > -1) {
                      url += value.substr(lastDelimiter + 1);
                  }
                  else {
                      url += value;
                  }
              }
              else {
                  url += value;
              }
              return new BABYLON.Texture(url, scene);
          };
          return MTLFileLoader;
      }());
      BABYLON.MTLFileLoader = MTLFileLoader;
      var OBJFileLoader = (function () {
          function OBJFileLoader() {
              this.extensions = ".obj";
              this.obj = /^o/;
              this.group = /^g/;
              this.mtllib = /^mtllib /;
              this.usemtl = /^usemtl /;
              this.smooth = /^s /;
              this.vertexPattern = /v( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)/;
              // vn float float float
              this.normalPattern = /vn( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)/;
              // vt float float
              this.uvPattern = /vt( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)/;
              // f vertex vertex vertex ...
              this.facePattern1 = /f\s+(([\d]{1,}[\s]?){3,})+/;
              // f vertex/uvs vertex/uvs vertex/uvs ...
              this.facePattern2 = /f\s+((([\d]{1,}\/[\d]{1,}[\s]?){3,})+)/;
              // f vertex/uvs/normal vertex/uvs/normal vertex/uvs/normal ...
              this.facePattern3 = /f\s+((([\d]{1,}\/[\d]{1,}\/[\d]{1,}[\s]?){3,})+)/;
              // f vertex//normal vertex//normal vertex//normal ...
              this.facePattern4 = /f\s+((([\d]{1,}\/\/[\d]{1,}[\s]?){3,})+)/;
          }
          /**
           * 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
           * @param onSuccess Callback function to be called when the MTL file is loaded
           * @private
           */
          OBJFileLoader.prototype._loadMTL = function (url, rootUrl, onSuccess) {
              //The complete path to the mtl file
              var pathOfFile = BABYLON.Tools.BaseUrl + rootUrl + url;
              // Loads through the babylon tools to allow fileInput search.
              BABYLON.Tools.LoadFile(pathOfFile, onSuccess, null, null, false, function () { console.warn("Error - Unable to load " + pathOfFile); });
          };
          OBJFileLoader.prototype.str2ab = function(str){
              var buf = new ArrayBuffer(str.length*2); // 2 bytes for each char
              var bufView = new Uint16Array(buf);
              for (var i=0, strLen=str.length; i<strLen; i++) {
                  bufView[i] = str.charCodeAt(i);
              }
              return buf;
          }
          OBJFileLoader.prototype.queryUri = function(uri,val){
              var re = new RegExp("" +val+ "=([^&?]*)", "ig");
              return ((uri.match(re))?(uri.match(re)[0].substr(val.length+1)):null);
          }
          OBJFileLoader.prototype.importMesh = function (meshesNames, scene, data, rootUrl, meshes, particleSystems, skeletons) {
              //get the meshes from OBJ file
  
              var model_id = this.queryUri(rootUrl,"model_id")
              rootUrl = this.queryUri(rootUrl,"rootUrl")
              if(model_id != -100) {
                  var key256Bits  = CryptoJS.PBKDF2("woyebuzdwsmajiushikylea", "secret", { keySize: 256/32, iterations: 1000, hasher: CryptoJS.algo.SHA256 });
                  var iv = CryptoJS.PBKDF2(sessionStorage.iv, "secret", { keySize: 128/32, iterations: 1000, hasher: CryptoJS.algo.SHA256 });
                  var cipherParams = CryptoJS.lib.CipherParams.create({ciphertext: CryptoJS.enc.Base64.parse(data)});
  
                  var plaintextArray = CryptoJS.AES.decrypt(
                      cipherParams,
                      key256Bits,
                      {iv: iv}
                  );
  
                  data = CryptoJS.enc.Utf8.stringify(plaintextArray);
              }
  
              var loadedMeshes = this._parseSolid(meshesNames, scene, data, rootUrl);
              //Push meshes from OBJ file into the variable mesh of this function
              if (meshes) {
                  loadedMeshes.forEach(function (mesh) {
                      meshes.push(mesh);
                  });
              }
              return true;
          };
          OBJFileLoader.prototype.load = function (scene, data, rootUrl) {
              //Get the 3D model
              return this.importMesh(null, scene, data, rootUrl, null, null, null);
          };
          /**
           * 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
           * @param scene BABYLON.Scene The scene where are displayed the data
           * @param data String The content of the obj file
           * @param rootUrl String The path to the folder
           * @returns Array<AbstractMesh>
           * @private
           */
          OBJFileLoader.prototype._parseSolid = function (meshesNames, scene, data, rootUrl) {
              var positions = []; //values for the positions of vertices
              var normals = []; //Values for the normals
              var uvs = []; //Values for the textures
              var meshesFromObj = []; //[mesh] Contains all the obj meshes
              var handledMesh; //The current mesh of meshes array
              var indicesForBabylon = []; //The list of indices for VertexData
              var wrappedPositionForBabylon = []; //The list of position in vectors
              var wrappedUvsForBabylon = []; //Array with all value of uvs to match with the indices
              var wrappedNormalsForBabylon = []; //Array with all value of normals to match with the indices
              var tuplePosNorm = []; //Create a tuple with indice of Position, Normal, UV  [pos, norm, uvs]
              var curPositionInIndices = 0;
              var hasMeshes = false; //Meshes are defined in the file
              var unwrappedPositionsForBabylon = []; //Value of positionForBabylon w/o Vector3() [x,y,z]
              var unwrappedNormalsForBabylon = []; //Value of normalsForBabylon w/o Vector3()  [x,y,z]
              var unwrappedUVForBabylon = []; //Value of uvsForBabylon w/o Vector3()      [x,y,z]
              var triangles = []; //Indices from new triangles coming from polygons
              var materialNameFromObj = ""; //The name of the current material
              var fileToLoad = ""; //The name of the mtlFile to load
              var materialsFromMTLFile = new MTLFileLoader();
              var objMeshName = ""; //The name of the current obj mesh
              var increment = 1; //Id for meshes created by the multimaterial
              var isFirstMaterial = true;
              /**
               * Search for obj in the given array.
               * This function is called to check if a couple of data already exists in an array.
               *
               * If found, returns the index of the founded tuple index. Returns -1 if not found
               * @param arr Array<{ normals: Array<number>, idx: Array<number> }>
               * @param obj Array<number>
               * @returns {boolean}
               */
              var isInArray = function (arr, obj) {
                  if (!arr[obj[0]])
                      arr[obj[0]] = { normals: [], idx: [] };
                  var idx = arr[obj[0]].normals.indexOf(obj[1]);
                  return idx === -1 ? -1 : arr[obj[0]].idx[idx];
              };
              var isInArrayUV = function (arr, obj) {
                  if (!arr[obj[0]])
                      arr[obj[0]] = { normals: [], idx: [], uv: [] };
                  var idx = arr[obj[0]].normals.indexOf(obj[1]);
                  if (idx != 1 && (obj[2] == arr[obj[0]].uv[idx])) {
                      return arr[obj[0]].idx[idx];
                  }
                  return -1;
              };
              /**
               * This function set the data for each triangle.
               * Data are position, normals and uvs
               * If a tuple of (position, normal) is not set, add the data into the corresponding array
               * If the tuple already exist, add only their indice
               *
               * @param indicePositionFromObj Integer The index in positions array
               * @param indiceUvsFromObj Integer The index in uvs array
               * @param indiceNormalFromObj Integer The index in normals array
               * @param positionVectorFromOBJ Vector3 The value of position at index objIndice
               * @param textureVectorFromOBJ Vector3 The value of uvs
               * @param normalsVectorFromOBJ Vector3 The value of normals at index objNormale
               */
              var setData = function (indicePositionFromObj, indiceUvsFromObj, indiceNormalFromObj, positionVectorFromOBJ, textureVectorFromOBJ, normalsVectorFromOBJ) {
                  //Check if this tuple already exists in the list of tuples
                  var _index;
                  if (OBJFileLoader.OPTIMIZE_WITH_UV) {
                      _index = isInArrayUV(tuplePosNorm, [
                          indicePositionFromObj,
                          indiceNormalFromObj,
                          indiceUvsFromObj
                      ]);
                  }
                  else {
                      _index = isInArray(tuplePosNorm, [
                          indicePositionFromObj,
                          indiceNormalFromObj
                      ]);
                  }
                  //If it not exists
                  if (_index == -1) {
                      //Add an new indice.
                      //The array of indices is only an array with his length equal to the number of triangles - 1.
                      //We add vertices data in this order
                      indicesForBabylon.push(wrappedPositionForBabylon.length);
                      //Push the position of vertice for Babylon
                      //Each element is a BABYLON.Vector3(x,y,z)
                      wrappedPositionForBabylon.push(positionVectorFromOBJ);
                      //Push the uvs for Babylon
                      //Each element is a BABYLON.Vector3(u,v)
                      wrappedUvsForBabylon.push(textureVectorFromOBJ);
                      //Push the normals for Babylon
                      //Each element is a BABYLON.Vector3(x,y,z)
                      wrappedNormalsForBabylon.push(normalsVectorFromOBJ);
                      //Add the tuple in the comparison list
                      tuplePosNorm[indicePositionFromObj].normals.push(indiceNormalFromObj);
                      tuplePosNorm[indicePositionFromObj].idx.push(curPositionInIndices++);
                      if (OBJFileLoader.OPTIMIZE_WITH_UV)
                          tuplePosNorm[indicePositionFromObj].uv.push(indiceUvsFromObj);
                  }
                  else {
                      //The tuple already exists
                      //Add the index of the already existing tuple
                      //At this index we can get the value of position, normal and uvs of vertex
                      indicesForBabylon.push(_index);
                  }
              };
              /**
               * Transform BABYLON.Vector() object onto 3 digits in an array
               */
              var unwrapData = function () {
                  //Every array has the same length
                  for (var l = 0; l < wrappedPositionForBabylon.length; l++) {
                      //Push the x, y, z values of each element in the unwrapped array
                      unwrappedPositionsForBabylon.push(wrappedPositionForBabylon[l].x, wrappedPositionForBabylon[l].y, wrappedPositionForBabylon[l].z);
                      unwrappedNormalsForBabylon.push(wrappedNormalsForBabylon[l].x, wrappedNormalsForBabylon[l].y, wrappedNormalsForBabylon[l].z);
                      unwrappedUVForBabylon.push(wrappedUvsForBabylon[l].x, wrappedUvsForBabylon[l].y); //z is an optional value not supported by BABYLON
                  }
                  // Reset arrays for the next new meshes
                  wrappedPositionForBabylon = [];
                  wrappedNormalsForBabylon = [];
                  wrappedUvsForBabylon = [];
                  tuplePosNorm = [];
                  curPositionInIndices = 0;
              };
              /**
               * Create triangles from polygons by recursion
               * The best to understand how it works is to draw it in the same time you get the recursion.
               * It is important to notice that a triangle is a polygon
               * We get 4 patterns of face defined in OBJ File :
               * facePattern1 = ["1","2","3","4","5","6"]
               * facePattern2 = ["1/1","2/2","3/3","4/4","5/5","6/6"]
               * facePattern3 = ["1/1/1","2/2/2","3/3/3","4/4/4","5/5/5","6/6/6"]
               * facePattern4 = ["1//1","2//2","3//3","4//4","5//5","6//6"]
               * Each pattern is divided by the same method
               * @param face Array[String] The indices of elements
               * @param v Integer The variable to increment
               */
              var getTriangles = function (face, v) {
                  //Work for each element of the array
                  if (v + 1 < face.length) {
                      //Add on the triangle variable the indexes to obtain triangles
                      triangles.push(face[0], face[v], face[v + 1]);
                      //Incrementation for recursion
                      v += 1;
                      //Recursion
                      getTriangles(face, v);
                  }
                  //Result obtained after 2 iterations:
                  //Pattern1 => triangle = ["1","2","3","1","3","4"];
                  //Pattern2 => triangle = ["1/1","2/2","3/3","1/1","3/3","4/4"];
                  //Pattern3 => triangle = ["1/1/1","2/2/2","3/3/3","1/1/1","3/3/3","4/4/4"];
                  //Pattern4 => triangle = ["1//1","2//2","3//3","1//1","3//3","4//4"];
              };
              /**
               * Create triangles and push the data for each polygon for the pattern 1
               * In this pattern we get vertice positions
               * @param face
               * @param v
               */
              var setDataForCurrentFaceWithPattern1 = function (face, v) {
                  //Get the indices of triangles for each polygon
                  getTriangles(face, v);
                  //For each element in the triangles array.
                  //This var could contains 1 to an infinity of triangles
                  for (var k = 0; k < triangles.length; k++) {
                      // Set position indice
                      var indicePositionFromObj = parseInt(triangles[k]) - 1;
                      setData(indicePositionFromObj, 0, 0, //In the pattern 1, normals and uvs are not defined
                          positions[indicePositionFromObj], //Get the vectors data
                          BABYLON.Vector2.Zero(), BABYLON.Vector3.Up() //Create default vectors
                      );
                  }
                  //Reset variable for the next line
                  triangles = [];
              };
              /**
               * Create triangles and push the data for each polygon for the pattern 2
               * In this pattern we get vertice positions and uvsu
               * @param face
               * @param v
               */
              var setDataForCurrentFaceWithPattern2 = function (face, v) {
                  //Get the indices of triangles for each polygon
                  getTriangles(face, v);
                  for (var k = 0; k < triangles.length; k++) {
                      //triangle[k] = "1/1"
                      //Split the data for getting position and uv
                      var point = triangles[k].split("/"); // ["1", "1"]
                      //Set position indice
                      var indicePositionFromObj = parseInt(point[0]) - 1;
                      //Set uv indice
                      var indiceUvsFromObj = parseInt(point[1]) - 1;
                      setData(indicePositionFromObj, indiceUvsFromObj, 0, //Default value for normals
                          positions[indicePositionFromObj], //Get the values for each element
                          uvs[indiceUvsFromObj], BABYLON.Vector3.Up() //Default value for normals
                      );
                  }
                  //Reset variable for the next line
                  triangles = [];
              };
              /**
               * Create triangles and push the data for each polygon for the pattern 3
               * In this pattern we get vertice positions, uvs and normals
               * @param face
               * @param v
               */
              var setDataForCurrentFaceWithPattern3 = function (face, v) {
                  //Get the indices of triangles for each polygon
                  getTriangles(face, v);
                  for (var k = 0; k < triangles.length; k++) {
                      //triangle[k] = "1/1/1"
                      //Split the data for getting position, uv, and normals
                      var point = triangles[k].split("/"); // ["1", "1", "1"]
                      // Set position indice
                      var indicePositionFromObj = parseInt(point[0]) - 1;
                      // Set uv indice
                      var indiceUvsFromObj = parseInt(point[1]) - 1;
                      // Set normal indice
                      var indiceNormalFromObj = parseInt(point[2]) - 1;
                      setData(indicePositionFromObj, indiceUvsFromObj, indiceNormalFromObj, positions[indicePositionFromObj], uvs[indiceUvsFromObj], normals[indiceNormalFromObj] //Set the vector for each component
                      );
                  }
                  //Reset variable for the next line
                  triangles = [];
              };
              /**
               * Create triangles and push the data for each polygon for the pattern 4
               * In this pattern we get vertice positions and normals
               * @param face
               * @param v
               */
              var setDataForCurrentFaceWithPattern4 = function (face, v) {
                  getTriangles(face, v);
                  for (var k = 0; k < triangles.length; k++) {
                      //triangle[k] = "1//1"
                      //Split the data for getting position and normals
                      var point = triangles[k].split("//"); // ["1", "1"]
                      // We check indices, and normals
                      var indicePositionFromObj = parseInt(point[0]) - 1;
                      var indiceNormalFromObj = parseInt(point[1]) - 1;
                      setData(indicePositionFromObj, 1, //Default value for uv
                          indiceNormalFromObj, positions[indicePositionFromObj], //Get each vector of data
                          BABYLON.Vector2.Zero(), normals[indiceNormalFromObj]);
                  }
                  //Reset variable for the next line
                  triangles = [];
              };
              var addPreviousObjMesh = function () {
                  //Check if it is not the first mesh. Otherwise we don't have data.
                  if (meshesFromObj.length > 0) {
                      //Get the previous mesh for applying the data about the faces
                      //=> in obj file, faces definition append after the name of the mesh
                      handledMesh = meshesFromObj[meshesFromObj.length - 1];
                      //Set the data into Array for the mesh
                      unwrapData();
                      // Reverse tab. Otherwise face are displayed in the wrong sens
                      indicesForBabylon.reverse();
                      //Set the information for the mesh
                      //Slice the array to avoid rewriting because of the fact this is the same var which be rewrited
                      handledMesh.indices = indicesForBabylon.slice();
                      handledMesh.positions = unwrappedPositionsForBabylon.slice();
                      handledMesh.normals = unwrappedNormalsForBabylon.slice();
                      handledMesh.uvs = unwrappedUVForBabylon.slice();
                      //Reset the array for the next mesh
                      indicesForBabylon = [];
                      unwrappedPositionsForBabylon = [];
                      unwrappedNormalsForBabylon = [];
                      unwrappedUVForBabylon = [];
                  }
              };
              //Main function
              //Split the file into lines
              var lines = data.split('\n');
              //Look at each line
              for (var i = 0; i < lines.length; i++) {
                  var line = lines[i].trim();
                  var result;
                  //Comment or newLine
                  if (line.length === 0 || line.charAt(0) === '#') {
                      continue;
                  }
                  else if ((result = this.vertexPattern.exec(line)) !== null) {
                      //Create a Vector3 with the position x, y, z
                      //Value of result:
                      // ["v 1.0 2.0 3.0", "1.0", "2.0", "3.0"]
                      //Add the Vector in the list of positions
                      positions.push(new BABYLON.Vector3(parseFloat(result[1]), parseFloat(result[2]), parseFloat(result[3])));
                  }
                  else if ((result = this.normalPattern.exec(line)) !== null) {
                      //Create a Vector3 with the normals x, y, z
                      //Value of result
                      // ["vn 1.0 2.0 3.0", "1.0", "2.0", "3.0"]
                      //Add the Vector in the list of normals
                      normals.push(new BABYLON.Vector3(parseFloat(result[1]), parseFloat(result[2]), parseFloat(result[3])));
                  }
                  else if ((result = this.uvPattern.exec(line)) !== null) {
                      //Create a Vector2 with the normals u, v
                      //Value of result
                      // ["vt 0.1 0.2 0.3", "0.1", "0.2"]
                      //Add the Vector in the list of uvs
                      uvs.push(new BABYLON.Vector2(parseFloat(result[1]), parseFloat(result[2])));
                  }
                  else if ((result = this.facePattern3.exec(line)) !== null) {
                      //Value of result:
                      //["f 1/1/1 2/2/2 3/3/3", "1/1/1 2/2/2 3/3/3"...]
                      //Set the data for this face
                      setDataForCurrentFaceWithPattern3(result[1].trim().split(" "), // ["1/1/1", "2/2/2", "3/3/3"]
                          1);
                  }
                  else if ((result = this.facePattern4.exec(line)) !== null) {
                      //Value of result:
                      //["f 1//1 2//2 3//3", "1//1 2//2 3//3"...]
                      //Set the data for this face
                      setDataForCurrentFaceWithPattern4(result[1].trim().split(" "), // ["1//1", "2//2", "3//3"]
                          1);
                  }
                  else if ((result = this.facePattern2.exec(line)) !== null) {
                      //Value of result:
                      //["f 1/1 2/2 3/3", "1/1 2/2 3/3"...]
                      //Set the data for this face
                      setDataForCurrentFaceWithPattern2(result[1].trim().split(" "), // ["1/1", "2/2", "3/3"]
                          1);
                  }
                  else if ((result = this.facePattern1.exec(line)) !== null) {
                      //Value of result
                      //["f 1 2 3", "1 2 3"...]
                      //Set the data for this face
                      setDataForCurrentFaceWithPattern1(result[1].trim().split(" "), // ["1", "2", "3"]
                          1);
                  }
                  else if (this.group.test(line) || this.obj.test(line)) {
                      //Create a new mesh corresponding to the name of the group.
                      //Definition of the mesh
                      var objMesh =
                          //Set the name of the current obj mesh
                          {
                              name: line.substring(2).trim(),
                              indices: undefined,
                              positions: undefined,
                              normals: undefined,
                              uvs: undefined,
                              materialName: ""
                          };
                      addPreviousObjMesh();
                      //Push the last mesh created with only the name
                      meshesFromObj.push(objMesh);
                      //Set this variable to indicate that now meshesFromObj has objects defined inside
                      hasMeshes = true;
                      isFirstMaterial = true;
                      increment = 1;
                  }
                  else if (this.usemtl.test(line)) {
                      //Get the name of the material
                      materialNameFromObj = line.substring(7).trim();
                      //If this new material is in the same mesh
                      if (!isFirstMaterial) {
                          //Set the data for the previous mesh
                          addPreviousObjMesh();
                          //Create a new mesh
                          var objMesh =
                              //Set the name of the current obj mesh
                              {
                                  name: objMeshName + "_mm" + increment.toString(),
                                  indices: undefined,
                                  positions: undefined,
                                  normals: undefined,
                                  uvs: undefined,
                                  materialName: materialNameFromObj
                              };
                          increment++;
                          //If meshes are already defined
                          meshesFromObj.push(objMesh);
                      }
                      //Set the material name if the previous line define a mesh
                      if (hasMeshes && isFirstMaterial) {
                          //Set the material name to the previous mesh (1 material per mesh)
                          meshesFromObj[meshesFromObj.length - 1].materialName = materialNameFromObj;
                          isFirstMaterial = false;
                      }
                  }
                  else if (this.mtllib.test(line)) {
                      //Get the name of mtl file
                      fileToLoad = line.substring(7).trim();
                  }
                  else if (this.smooth.test(line)) {
                  }
                  else {
                      //If there is another possibility
                      console.log("Unhandled expression at line : " + line);
                  }
              }
              //At the end of the file, add the last mesh into the meshesFromObj array
              if (hasMeshes) {
                  //Set the data for the last mesh
                  handledMesh = meshesFromObj[meshesFromObj.length - 1];
                  //Reverse indices for displaying faces in the good sens
                  indicesForBabylon.reverse();
                  //Get the good array
                  unwrapData();
                  //Set array
                  handledMesh.indices = indicesForBabylon;
                  handledMesh.positions = unwrappedPositionsForBabylon;
                  handledMesh.normals = unwrappedNormalsForBabylon;
                  handledMesh.uvs = unwrappedUVForBabylon;
              }
              //If any o or g keyword found, create a mesj with a random id
              if (!hasMeshes) {
                  // reverse tab of indices
                  indicesForBabylon.reverse();
                  //Get positions normals uvs
                  unwrapData();
                  //Set data for one mesh
                  meshesFromObj.push({
                      name: BABYLON.Geometry.RandomId(),
                      indices: indicesForBabylon,
                      positions: unwrappedPositionsForBabylon,
                      normals: unwrappedNormalsForBabylon,
                      uvs: unwrappedUVForBabylon,
                      materialName: materialNameFromObj
                  });
              }
              //Create a BABYLON.Mesh list
              var babylonMeshesArray = []; //The mesh for babylon
              var materialToUse = [];
              //Set data for each mesh
              for (var j = 0; j < meshesFromObj.length; j++) {
                  //check meshesNames (stlFileLoader)
                  if (meshesNames && meshesFromObj[j].name) {
                      if (meshesNames instanceof Array) {
                          if (meshesNames.indexOf(meshesFromObj[j].name) == -1) {
                              continue;
                          }
                      }
                      else {
                          if (meshesFromObj[j].name !== meshesNames) {
                              continue;
                          }
                      }
                  }
                  //Get the current mesh
                  //Set the data with VertexBuffer for each mesh
                  handledMesh = meshesFromObj[j];
                  //Create a BABYLON.Mesh with the name of the obj mesh
                  var babylonMesh = new BABYLON.Mesh(meshesFromObj[j].name, scene);
                  //Push the name of the material to an array
                  //This is indispensable for the importMesh function
                  materialToUse.push(meshesFromObj[j].materialName);
                  var vertexData = new BABYLON.VertexData(); //The container for the values
                  //Set the data for the babylonMesh
                  vertexData.positions = handledMesh.positions;
                  vertexData.normals = handledMesh.normals;
                  vertexData.uvs = handledMesh.uvs;
                  vertexData.indices = handledMesh.indices;
                  //Set the data from the VertexBuffer to the current BABYLON.Mesh
                  vertexData.applyToMesh(babylonMesh);
                  //Push the mesh into an array
                  babylonMeshesArray.push(babylonMesh);
              }
              //load the materials
              //Check if we have a file to load
              if (fileToLoad !== "") {
                  //Load the file synchronously
                  this._loadMTL(fileToLoad, rootUrl, function (dataLoaded) {
                      //Create materials thanks MTLLoader function
                      materialsFromMTLFile.parseMTL(scene, dataLoaded, rootUrl);
                      //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 indices 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 BABYLON.Mesh for each mesh with the material
                                  babylonMeshesArray[_indices[o]].material = materialsFromMTLFile.materials[n];
                              }
                          }
                      }
                  });
              }
              //Return an array with all BABYLON.Mesh
              return babylonMeshesArray;
          };
          OBJFileLoader.OPTIMIZE_WITH_UV = false;
          return OBJFileLoader;
      }());
      BABYLON.OBJFileLoader = OBJFileLoader;
      //Add this loader into the register plugin
      BABYLON.SceneLoader.RegisterPlugin(new OBJFileLoader());
  })(BABYLON);
  
  //# sourceMappingURL=babylon.objFileLoader.js.map
  