|
|
@@ -1,872 +0,0 @@
|
|
|
-/// <reference path="../../dist/preview release/babylon.d.ts"/>
|
|
|
-
|
|
|
-module BABYLON {
|
|
|
-
|
|
|
- /**
|
|
|
- * Class reading and parsing the MTL file bundled with the obj file.
|
|
|
- */
|
|
|
- export class MTLFileLoader {
|
|
|
-
|
|
|
- // All material loaded from the mtl will be set here
|
|
|
- public materials: BABYLON.StandardMaterial[] = [];
|
|
|
-
|
|
|
- /**
|
|
|
- * 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
|
|
|
- */
|
|
|
- public parseMTL = function (scene: BABYLON.Scene, data: string, rootUrl: string) {
|
|
|
- //Split the lines from the file
|
|
|
- var lines = data.split('\n');
|
|
|
- //Space char
|
|
|
- var delimiter_pattern = /\s+/;
|
|
|
- //Array with RGB colors
|
|
|
- var color: number[];
|
|
|
- //New material
|
|
|
- var material: BABYLON.StandardMaterial;
|
|
|
-
|
|
|
- //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: any = (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 = <number[]>value.split(delimiter_pattern, 3);
|
|
|
- //color = [r,g,b]
|
|
|
- //Set tghe color into the material
|
|
|
- material.diffuseColor = BABYLON.Color3.FromArray(color);
|
|
|
- } else if (key === "ka") {
|
|
|
- // Ambient color (color under shadow) using RGB values
|
|
|
-
|
|
|
- //value = "r g b"
|
|
|
- color = <number[]>value.split(delimiter_pattern, 3);
|
|
|
- //color = [r,g,b]
|
|
|
- //Set tghe color into the material
|
|
|
- material.ambientColor = 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 = <number[]>value.split(delimiter_pattern, 3);
|
|
|
- //color = [r,g,b]
|
|
|
- //Set the color into the material
|
|
|
- material.specularColor = BABYLON.Color3.FromArray(color);
|
|
|
- } 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;
|
|
|
-
|
|
|
- //Texture
|
|
|
- //This part can be improved by adding the possible options of texture
|
|
|
- } 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") {
|
|
|
- //Specular
|
|
|
- //Specular highlight component
|
|
|
- //We must first get the folder of the image
|
|
|
- //
|
|
|
- //Not supported by BABYLON
|
|
|
- //
|
|
|
- // continue;
|
|
|
- } 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);
|
|
|
-
|
|
|
-
|
|
|
- //Options for illumination
|
|
|
- } else if (key === "illum") {
|
|
|
- //Illumination
|
|
|
- if (value === "0") {
|
|
|
- //That mean Kd == Kd
|
|
|
- } else if (value === "1") {
|
|
|
- //Color on and Ambient on
|
|
|
- } else if (value === "2") {
|
|
|
- //Highlight on
|
|
|
- } else if (value === "3") {
|
|
|
- //Reflection on and Ray trace on
|
|
|
- } else if (value === "4") {
|
|
|
- //Transparency: Glass on, Reflection: Ray trace on
|
|
|
- } else if (value === "5") {
|
|
|
- //Reflection: Fresnel on and Ray trace on
|
|
|
- } else if (value === "6") {
|
|
|
- //Transparency: Refraction on, Reflection: Fresnel off and Ray trace on
|
|
|
- } else if (value === "7") {
|
|
|
- //Transparency: Refraction on, Reflection: Fresnel on and Ray trace on
|
|
|
- } else if (value === "8") {
|
|
|
- //Reflection on and Ray trace off
|
|
|
- } else if (value === "9") {
|
|
|
- //Transparency: Glass on, Reflection: Ray trace off
|
|
|
- } else if (value === "10") {
|
|
|
- //Casts shadows onto invisible surfaces
|
|
|
- }
|
|
|
- } else {
|
|
|
- // console.log("Unhandled expression at line : " + i +'\n' + "with value : " + line);
|
|
|
- }
|
|
|
- }
|
|
|
- //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
|
|
|
- */
|
|
|
- private static _getTexture(rootUrl: string, value: string, scene: Scene): Texture {
|
|
|
- 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;
|
|
|
- }
|
|
|
- }
|
|
|
- // Not from input file.
|
|
|
- else {
|
|
|
- url += value;
|
|
|
- }
|
|
|
-
|
|
|
- return new BABYLON.Texture(url, scene);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- export class OBJFileLoader implements ISceneLoaderPlugin {
|
|
|
-
|
|
|
- public static OPTIMIZE_WITH_UV = false;
|
|
|
-
|
|
|
- public extensions = ".obj";
|
|
|
- public obj = /^o/;
|
|
|
- public group = /^g/;
|
|
|
- public mtllib = /^mtllib /;
|
|
|
- public usemtl = /^usemtl /;
|
|
|
- public smooth = /^s /;
|
|
|
- public vertexPattern = /v( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)/;
|
|
|
- // vn float float float
|
|
|
- public normalPattern = /vn( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)/;
|
|
|
- // vt float float
|
|
|
- public uvPattern = /vt( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)/;
|
|
|
- // f vertex vertex vertex ...
|
|
|
- public facePattern1 = /f\s+(([\d]{1,}[\s]?){3,})+/;
|
|
|
- // f vertex/uvs vertex/uvs vertex/uvs ...
|
|
|
- public facePattern2 = /f\s+((([\d]{1,}\/[\d]{1,}[\s]?){3,})+)/;
|
|
|
- // f vertex/uvs/normal vertex/uvs/normal vertex/uvs/normal ...
|
|
|
- public facePattern3 = /f\s+((([\d]{1,}\/[\d]{1,}\/[\d]{1,}[\s]?){3,})+)/;
|
|
|
- // f vertex//normal vertex//normal vertex//normal ...
|
|
|
- public 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
|
|
|
- */
|
|
|
- private _loadMTL(url: string, rootUrl: string, onSuccess: (response: string) => any) {
|
|
|
- //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,
|
|
|
- () => { console.warn("Error - Unable to load " + pathOfFile); });
|
|
|
- }
|
|
|
-
|
|
|
- public importMesh(meshesNames: any, scene: Scene, data: any, rootUrl: string, meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[]): boolean {
|
|
|
- //get the meshes from OBJ file
|
|
|
- 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;
|
|
|
- }
|
|
|
-
|
|
|
- public load(scene: Scene, data: string, rootUrl: string): boolean {
|
|
|
- //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
|
|
|
- */
|
|
|
- private _parseSolid(meshesNames: any, scene: BABYLON.Scene, data: string, rootUrl: string): Array<AbstractMesh> {
|
|
|
-
|
|
|
- var positions: Array<BABYLON.Vector3> = []; //values for the positions of vertices
|
|
|
- var normals: Array<BABYLON.Vector3> = []; //Values for the normals
|
|
|
- var uvs: Array<BABYLON.Vector2> = []; //Values for the textures
|
|
|
- var meshesFromObj: Array<any> = []; //[mesh] Contains all the obj meshes
|
|
|
- var handledMesh: any; //The current mesh of meshes array
|
|
|
- var indicesForBabylon: Array<number> = []; //The list of indices for VertexData
|
|
|
- var wrappedPositionForBabylon: Array<BABYLON.Vector3> = []; //The list of position in vectors
|
|
|
- var wrappedUvsForBabylon: Array<BABYLON.Vector2> = []; //Array with all value of uvs to match with the indices
|
|
|
- var wrappedNormalsForBabylon: Array<BABYLON.Vector3> = []; //Array with all value of normals to match with the indices
|
|
|
- var tuplePosNorm: Array<{ normals: Array<number>; idx: Array<number>; uv: Array<number> }> = []; //Create a tuple with indice of Position, Normal, UV [pos, norm, uvs]
|
|
|
- var curPositionInIndices = 0;
|
|
|
- var hasMeshes: Boolean = false; //Meshes are defined in the file
|
|
|
- var unwrappedPositionsForBabylon: Array<number> = []; //Value of positionForBabylon w/o Vector3() [x,y,z]
|
|
|
- var unwrappedNormalsForBabylon: Array<number> = []; //Value of normalsForBabylon w/o Vector3() [x,y,z]
|
|
|
- var unwrappedUVForBabylon: Array<number> = []; //Value of uvsForBabylon w/o Vector3() [x,y,z]
|
|
|
- var triangles: Array<string> = []; //Indices from new triangles coming from polygons
|
|
|
- var materialNameFromObj: string = ""; //The name of the current material
|
|
|
- var fileToLoad: string = ""; //The name of the mtlFile to load
|
|
|
- var materialsFromMTLFile: MTLFileLoader = new MTLFileLoader();
|
|
|
- var objMeshName: string = ""; //The name of the current obj mesh
|
|
|
- var increment: number = 1; //Id for meshes created by the multimaterial
|
|
|
- var isFirstMaterial: boolean = 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 = (arr: Array<{ normals: Array<number>; idx: Array<number> }>, obj: Array<number>) => {
|
|
|
- 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 = (arr: Array<{ normals: Array<number>; idx: Array<number>; uv: Array<number> }>, obj: Array<number>) => {
|
|
|
- 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 = (indicePositionFromObj: number, indiceUvsFromObj: number, indiceNormalFromObj: number, positionVectorFromOBJ: BABYLON.Vector3, textureVectorFromOBJ: BABYLON.Vector2, normalsVectorFromOBJ: BABYLON.Vector3) => {
|
|
|
- //Check if this tuple already exists in the list of tuples
|
|
|
- var _index: number;
|
|
|
- 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 = () => {
|
|
|
- //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 = (face: Array<string>, v: number) => {
|
|
|
- //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 = (face: Array<string>, v: number) => {
|
|
|
- //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 = (face: Array<string>, v: number) => {
|
|
|
- //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 = (face: Array<string>, v: number) => {
|
|
|
- //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 = (face: Array<string>, v: number) => {
|
|
|
- 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 = () => {
|
|
|
-
|
|
|
- //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;
|
|
|
-
|
|
|
- //Get information about one position possible for the vertices
|
|
|
- } 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])
|
|
|
- ));
|
|
|
-
|
|
|
-
|
|
|
- //Identify patterns of faces
|
|
|
- //Face could be defined in different type of pattern
|
|
|
- } 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
|
|
|
- );
|
|
|
-
|
|
|
- //Define a mesh or an object
|
|
|
- //Each time this keyword is analysed, create a new Object with all data for creating a babylonMesh
|
|
|
- } 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: {
|
|
|
- name: string;
|
|
|
- indices: Array<number>;
|
|
|
- positions: Array<number>;
|
|
|
- normals: Array<number>;
|
|
|
- uvs: Array<number>;
|
|
|
- materialName: string;
|
|
|
- } =
|
|
|
- //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;
|
|
|
- //Keyword for applying a material
|
|
|
- } 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: {
|
|
|
- name: string;
|
|
|
- indices: Array<number>;
|
|
|
- positions: Array<number>;
|
|
|
- normals: Array<number>;
|
|
|
- uvs: Array<number>;
|
|
|
- materialName: string;
|
|
|
- } =
|
|
|
- //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;
|
|
|
- }
|
|
|
- //Keyword for loading the mtl file
|
|
|
- } else if (this.mtllib.test(line)) {
|
|
|
- //Get the name of mtl file
|
|
|
- fileToLoad = line.substring(7).trim();
|
|
|
-
|
|
|
- //Apply smoothing
|
|
|
- } else if (this.smooth.test(line)) {
|
|
|
- // smooth shading => apply smoothing
|
|
|
- //Toda y I don't know it work with babylon and with obj.
|
|
|
- //With the obj file an integer is set
|
|
|
- } 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: Array<BABYLON.Mesh> = []; //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: 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 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 BABYLON.Mesh for each mesh with the material
|
|
|
- babylonMeshesArray[_indices[o]].material = materialsFromMTLFile.materials[n];
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- });
|
|
|
- }
|
|
|
- //Return an array with all BABYLON.Mesh
|
|
|
- return babylonMeshesArray;
|
|
|
- }
|
|
|
-
|
|
|
- }
|
|
|
- //Add this loader into the register plugin
|
|
|
- BABYLON.SceneLoader.RegisterPlugin(new OBJFileLoader());
|
|
|
-}
|
sevan