View difference between Paste ID: 7sLteqNw and K6Y9MD31

 public enum SaveFormat {
 	OBJ,
 	QMO
 }
 public enum LoadFormat {
 	Auto,
 	OBJ,
 	QMO
 }
 
 public static class ImportExport {
 
-	public static string SaveToText (this Mesh mesh, SaveFormat sFormat = SaveFormat.OBJ) {
+// NEW CODE (more complex but can load .obj from "anywhere" (normally) and generated files are lighter)
 	/// <summary>
 	/// Save a Mesh to a file.
 	/// path : the path were the mesh will be created WITHOUT THE EXTENSION.
 	/// format : format of the file (obj/qmo).
-
+	/// overwrite : if the file already exists, should it overwrite ?
 	/// </summary>
 	public static void SaveToFile (this Mesh mesh, string path, SaveFormat format, bool overwrite) {
 		path = path + '.' + format.ToString ().ToLower ();
 
 		try {
 			if (!File.Exists (path) || overwrite) {
-			foreach (Vector3 u in mesh.uv) {
+				File.WriteAllText (path, mesh.SaveToText (format));
 			}
 			else {
 				Debug.LogWarning ("This file already exists, can't save mesh : " + mesh.name + ", or set overwrite to true.\n@" + path);
 			}
 		}
 		catch (Exception ex) {
 			Debug.LogWarning ("Exception while saving mesh : " + mesh.name + "\n@ " + path + "\nex: " + ex);
 		}
-
+
-			text.Append ("\ns off\n\n"); // smoothing group, but unity doesn't support it
+
-
+	/// <summary>
 	/// Save a Mesh to a text.
 	/// </summary>
 	public static string SaveToText (this Mesh mesh, SaveFormat format) {
 		StringBuilder text = new StringBuilder ();
 
 		if (format == SaveFormat.OBJ) {
 			text.AppendFormat ("# ModelisaTools exported obj file\n\no {0}\n\n", mesh.name);
 
 			List<Vector3> vertices = new List<Vector3> ();
 			List<int> veIndex = new List<int> ();
 			List<Vector3> uv = new List<Vector3> ();
 			List<int> uvIndex = new List<int> ();
-	// path = the path where the file will be created, WITHOUT THE EXTENSION
+			List<Vector3> normals = new List<Vector3> ();
-	public static void SaveToFile (this Mesh mesh, string path, SaveFormat sFormat = SaveFormat.OBJ, bool overwrite = false) {
+			List<int> noIndex = new List<int> ();
 
 			Vector3 tempV3;
 			Vector2 tempV2;
 
-				File.WriteAllText (path, mesh.SaveToText (sFormat));
+			for (int i = 0; i < mesh.vertices.Length; i++) {
 				if (!vertices.Contains (mesh.vertices[i])) {
 					vertices.Add (mesh.vertices[i]);
 					veIndex.Add (vertices.Count - 1);
 				}
 				else {
 					veIndex.Add (vertices.IndexOf (mesh.vertices[i]));
 				}
 			}
 
 			for (int i = 0; i < mesh.uv.Length; i++) {
-	// path = the path were the mesh will be loaded, WITH THE EXTENSION if lFormat is AUTO, and WITHOUT if lFormat is : OBJ, QMO
+				if (!uv.Contains (mesh.uv[i])) {
-	public static void LoadFromFile (this Mesh mesh, string path, LoadFormat lFormat = LoadFormat.Auto) {
+					uv.Add (mesh.uv[i]);
 					uvIndex.Add (uv.Count - 1);
 				}
 				else {
 					uvIndex.Add (uv.IndexOf (mesh.uv[i]));
 				}
 			}
 
 			for (int i = 0; i < mesh.normals.Length; i++) {
 				if (!normals.Contains (mesh.normals[i])) {
 					normals.Add (mesh.normals[i]);
 					noIndex.Add (normals.Count - 1);
 				}
 				else {
 					noIndex.Add (normals.IndexOf (mesh.normals[i]));
 				}
 			}
 
 			for (int i = 0; i < vertices.Count; i++) {
 				tempV3 = vertices[i];
 				text.AppendFormat ("v {0} {1} {2}\n", tempV3.x, tempV3.y, tempV3.z);
 			}
 
 			text.Append ("\n");
 
 			for (int i = 0; i < uv.Count; i++) {
 				tempV2 = uv[i];
 				text.AppendFormat ("vt {0} {1}\n", tempV2.x, tempV2.y);
 			}
-	public static void LoadFromStream (this Mesh mesh, TextReader reader, LoadFormat lFormat) {
+
 			text.Append ("\n");
 
 			for (int i = 0; i < normals.Count; i++) {
 				tempV3 = normals[i];
 				text.AppendFormat ("vn {0} {1} {2}\n", tempV3.x, tempV3.y, tempV3.z);
 			}
 
 			text.Append ("\ns off\n\n"); // smoothing group, but unity doesn't support it :/
 
 			for (int i = 0; i < mesh.triangles.Length; i += 3) {
 				text.AppendFormat ("f {0}/{1}/{2} {3}/{4}/{5} {6}/{7}/{8}\n",
 									veIndex[ mesh.triangles[ i ] ] + 1,
 									uvIndex[ mesh.triangles[ i ] ] + 1,
 									noIndex[ mesh.triangles[ i ] ] + 1,
 
 									veIndex[ mesh.triangles[ i + 1 ] ] + 1,
 									uvIndex[ mesh.triangles[ i + 1 ] ] + 1,
 									noIndex[ mesh.triangles[ i + 1 ] ] + 1,
 
 									veIndex[ mesh.triangles[ i + 2 ] ] + 1,
 									uvIndex[ mesh.triangles[ i + 2 ] ] + 1,
 									noIndex[ mesh.triangles[ i + 2 ] ] + 1
 									);
 			}
 		}
 
-				else if (line.StartsWith ("v ")) {
+		if (format == SaveFormat.QMO) {
 			throw new NotImplementedException ();
 		}
 
 		return text.ToString ();
-
+
 
 	/// <summary>
 	/// Load a Mesh from a file.
 	/// path : the path were the mesh will be loaded, WITHOUT THE EXTENSION.
 	/// format : format of mesh (obj/qmo).
 	/// </summary>
 
 	public static void LoadFromFile (this Mesh mesh, string path, LoadFormat format) {
 		path = path + '.' + format.ToString ().ToLower ();
-				else if (line.StartsWith ("vt")) {
+
 		try {
 			if (File.Exists (path)) {
 				mesh.LoadFromStream (File.OpenText (path), format);
-
+
 			else {
 				Debug.LogWarning ("This file doesn't exists, can't load mesh @ " + path);
 			}
 		}
 		catch (Exception ex) {
 			Debug.LogWarning ("Exception while loading mesh : " + ((mesh == null) ? "NULL_MESH" : mesh.name) + "\n@ " + path + "\nex: " + ex);
 		}
 	}
 
-				else if (line.StartsWith ("vn")) {
+	/// <summary>
 	/// Load a Mesh from a TextReader (StringReader or StreamReader).
 	/// </summary>
 
 	public static void LoadFromStream (this Mesh mesh, TextReader reader, LoadFormat format) {
-
+
 		int lineNumber = 0;
 
 		string[] datas;
 		string[] v0Datas;
 		string[] v1Datas;
 		string[] v2Datas;
 		string[] v3Datas;
 
 		Vector3 tempV3;
-				else if (line.StartsWith ("f")) {
+		Vector2 tempV2;
 
 		// "raw" data
 		List<Vector3> tempVertices = new List<Vector3> ();
 		List<Vector2> tempUV = new List<Vector2> ();
 		List<Vector3> tempNormals = new List<Vector3> ();
 
 		// ordered data
 		List<Vector3> vertices = new List<Vector3> ();
 		List<Vector2> uv = new List<Vector2> ();
-						triangles.Add (3); // beurk beurk mais je vois pas comment faire autrement :/
+
 		List<int> triangles = new List<int> ();
 
 		if (format == LoadFormat.OBJ) {
 			while ((line = reader.ReadLine()) != null) {
 				lineNumber++;
 				line = line.Replace ('\t', ' ');
 				datas = line.Split (' ');
 
 				if (datas.Length == 0) continue;
 
 				// mesh name
 				if (datas[0] == "o") {
 					try {
 						mesh.name = datas[1];
 					}
 					catch (Exception ex) {
 						mesh.name = "undefined";
 						Debug.LogWarning ("PARSE ERROR (name) : line " + lineNumber + " while loading mesh : " + mesh.name + "\n" + ex);
 					}
 				}
 
 				// vertex
 				if (datas[0] == "v") {
 					try {
 						tempV3.x = float.Parse (datas[1]);
-	public static void LoadFromText (this Mesh mesh, string text, LoadFormat lFormat) {
+						tempV3.y = float.Parse (datas[2]);
-		mesh.LoadFromStream (new StringReader (text), lFormat);
+						tempV3.z = float.Parse (datas[3]);
 
 						tempVertices.Add (tempV3);
 					}
 					catch (Exception ex) {
 						tempVertices.Add (Vector3.zero);
 						Debug.LogWarning ("PARSE ERROR (vertex) : line " + lineNumber + " while loading mesh : " + mesh.name + "\n" + ex);
 					}
 				}
 
 				// uv (vt = vertex texture)
 				if (datas[0] == "vt") {
 					try  {
 						tempV2.x = float.Parse (datas[1]);
 						tempV2.y = float.Parse (datas[2]);
 
 						tempUV.Add (tempV2);
 					}
 					catch (Exception ex) {
 						tempUV.Add (Vector2.zero);
 						Debug.LogWarning ("PARSE ERROR (uv) : line " + lineNumber + " while loading mesh : " + mesh.name + "\n" + ex);
 					}
 				}
 
 				// normal
 				if (datas[0] == "vn") {
 					try {
 						tempV3.x = float.Parse (datas[1]);
 						tempV3.y = float.Parse (datas[2]);
 						tempV3.z = float.Parse (datas[3]);
 
 						tempNormals.Add (tempV3);
 					}
 					catch (Exception ex) {
 						tempNormals.Add (Vector3.zero);
 						Debug.LogWarning ("PARSE ERROR (normal) : line " + lineNumber + " while loading mesh : " + mesh.name + "\n" + ex);
 					}
 				}
 
 				// face
 				if (datas[0] == "f") {
 
 					// triangle or quad
 					if (datas.Length >= 4) {
 						try {
 							v0Datas = datas[1].Split ('/');
 							v1Datas = datas[2].Split ('/');
 							v2Datas = datas[3].Split ('/');
 
 							vertices.Add ( tempVertices[ int.Parse (v0Datas[0]) - 1 ] );
 							vertices.Add ( tempVertices[ int.Parse (v1Datas[0]) - 1 ] );
 							vertices.Add ( tempVertices[ int.Parse (v2Datas[0]) - 1 ] );
 
 							uv.Add ( tempUV[ int.Parse (v0Datas[1]) - 1 ] );
 							uv.Add ( tempUV[ int.Parse (v1Datas[1]) - 1 ] );
 							uv.Add ( tempUV[ int.Parse (v2Datas[1]) - 1 ] );
 
 							normals.Add ( tempNormals[ int.Parse (v0Datas[2]) - 1 ] );
 							normals.Add ( tempNormals[ int.Parse (v1Datas[2]) - 1 ] );
 							normals.Add ( tempNormals[ int.Parse (v2Datas[2]) - 1 ] );
 
 							int i = triangles.Count;
 							triangles.Add (i);
 							triangles.Add (i + 1);
 							triangles.Add (i + 2);
 
 							if (datas.Length >= 5) {
 								v3Datas = datas[4].Split ('/');
 
 								vertices.Add ( tempVertices[ int.Parse (v3Datas[0]) ] );
 								uv.Add ( tempUV[ int.Parse (v3Datas[1]) ] );
 								normals.Add ( tempNormals[ int.Parse (v3Datas[2]) ] );
 
 								triangles.Add (i + 1);
 								triangles.Add (i + 2);
 								triangles.Add (i + 3);
 							}
 						}
 						catch (Exception ex) {
 							Debug.LogWarning ("PARSE ERROR (face:" + (datas.Length-1) + ") : line " + lineNumber + " while loading mesh : " + mesh.name + "\n" + ex);
 						}
 					}
 				}
 
 				// else it's :
 				// - a comment (#)
 				// - a smoothing group (s on or s off), but unity doesn't support it
 				// - a unsupported instruction (ex : mtl)
 			}
 
 			mesh.Clear ();
 			mesh.vertices = vertices.ToArray ();
 			mesh.uv = uv.ToArray ();
 			mesh.normals = normals.ToArray ();
 			mesh.triangles = triangles.ToArray ();
 		}
 
 		if (format == LoadFormat.QMO) {
 			throw new NotImplementedException ();
 		}
 
 		reader.Close ();
 	}
 // NEW CODE
 
 // OLD CODE (simpler but surely faster, WARNING : can load only .obj saved with this code (can have issue when loading .obj from other softwares))
 	public static string SimpleSaveToText (this Mesh mesh) { return mesh.SimpleSaveToText (SaveFormat.OBJ); }
 
 	/// <summary>
 	/// Save a Mesh to a text.
 	/// sFormat : format of the text (obj/qmo). Optional : default .obj.
 	/// </summary>
 
 	public static string SimpleSaveToText (this Mesh mesh, SaveFormat sFormat) {
 		StringBuilder text = new StringBuilder ();
 
 		if (sFormat == SaveFormat.OBJ) {
 			text.AppendFormat("# ModelisaTools exported obj file\n\no {0}\n\n", mesh.name);
 
 			foreach (Vector3 v in mesh.vertices) {
 				text.AppendFormat ("v {0} {1} {2}\n", v.x, v.y, v.z);
 			}
 
 			text.Append ("\n");
 
 			foreach (Vector2 u in mesh.uv) {
 				text.AppendFormat ("vt {0} {1}\n", u.x, u.y);
 			}
 
 			text.Append ("\n");
 
 			foreach (Vector3 n in mesh.normals) {
 				text.AppendFormat ("vn {0} {1} {2}\n", n.x, n.y, n.z);
 			}
 
 			text.Append ("\ns off\n\n"); // smoothing group, but unity doesn't support it :/
 
 			for (int i = 0; i < mesh.triangles.Length; i += 3) {
 				text.AppendFormat ("f {0}/{0}/{0} {1}/{1}/{1} {2}/{2}/{2}\n", mesh.triangles[i]+1, mesh.triangles[i+1]+1, mesh.triangles[i+2]+1);
 			}
 		}
 
 		if (sFormat == SaveFormat.QMO) {
 			throw new NotImplementedException ();
 		}
 
 		return text.ToString ();
 	}
 
 	public static void SimpleSaveToFile (this Mesh mesh, string path) { mesh.SimpleSaveToFile (path, SaveFormat.OBJ, false); }
 	public static void SimpleSaveToFile (this Mesh mesh, string path, SaveFormat sFormat) { mesh.SimpleSaveToFile (path, sFormat, false); }
 	public static void SimpleSaveToFile (this Mesh mesh, string path, bool overwrite) { mesh.SimpleSaveToFile (path, SaveFormat.OBJ, overwrite); }
 
 	/// <summary>
 	/// Save a Mesh to a file.
 	/// path : the path were the mesh will be created WITHOUT THE EXTENSION.
 	/// sFormat : format of the file (obj/qmo). Optional : default .obj.
 	/// overwrite : if the file already exists, should it overwrite ? Optional : default false.
 	/// </summary>
 
 	public static void SimpleSaveToFile (this Mesh mesh, string path, SaveFormat sFormat, bool overwrite) {
 		path = path + '.' + sFormat.ToString ().ToLower ();
 
 		try {
 			if (!File.Exists (path) || overwrite) {
 				File.WriteAllText (path, mesh.SimpleSaveToText (sFormat));
 			}
 			else {
 				Debug.LogWarning ("This file already exists, can't save mesh : " + mesh.name + ", or set overwrite to true.\n@" + path);
 			}
 		}
 		catch (Exception ex) {
 			Debug.LogWarning ("Exception while saving mesh : " + mesh.name + "\n@ " + path + "\nex: " + ex);
 		}
 	}
 
 	public static void SimpleLoadFromFile (this Mesh mesh, string path) { mesh.SimpleLoadFromFile (path, LoadFormat.Auto); }
 
 	/// <summary>
 	/// Load a Mesh from a file.
 	/// path : the path were the mesh will be loaded, WITH THE EXTENSION if lFormat is AUTO, and WITHOUT if lFormat is : OBJ, QMO.
 	/// lFormat : format of mesh (obj/qmo). Optional : default AUTO
 	/// </summary>
 
 	public static void SimpleLoadFromFile (this Mesh mesh, string path, LoadFormat lFormat) {
 		if (lFormat != LoadFormat.Auto) {
 			path = path + '.' + lFormat.ToString ().ToLower ();
 		}
 
 		try {
 			if (File.Exists (path)) {
 				string extension = Path.GetExtension (path);
 				LoadFormat format;
 				if (extension == ".obj") {
 					format = LoadFormat.OBJ;
 				}
 				else if (extension == ".qmo") {
 					format = LoadFormat.QMO;
 				}
 				else {
 					format = LoadFormat.Auto;
 				}
 				mesh.SimpleLoadFromStream (File.OpenText (path), format);
 			}
 			else {
 				Debug.LogWarning ("This file doesn't exists, can't load mesh @ " + path);
 			}
 		}
 		catch (Exception ex) {
 			Debug.LogWarning ("Exception while loading mesh : " + mesh.name + "\n@ " + path + "\nex: " + ex);
 		}
 	}
 
 	/// <summary>
 	/// Load a Mesh from a TextReader (StringReader or StreamReader).
 	/// </summary>
 
 	public static void SimpleLoadFromStream (this Mesh mesh, TextReader reader, LoadFormat lFormat) {
 		string line;
 		int lineNumber = 0;
 		string[] datas;
 		Vector3 tempVector3;
 		Vector2 tempVector2;
 		List<Vector3> vertices = new List<Vector3> ();
 		List<Vector2> uv = new List<Vector2> ();
 		List<Vector3> normals = new List<Vector3> ();
 		List<int> triangles = new List<int> ();
 
 		if (lFormat == LoadFormat.Auto) {
 			Debug.LogWarning ("Can't load mesh : " + mesh.name + ", format is not supported.");
 			return;
 		}
 
 		if (lFormat == LoadFormat.OBJ) {
 			while ((line = reader.ReadLine()) != null) {
 
 				datas = line.Split (' '); // so datas[0] == o || v || vt || vn || f || ...
 
 				// mesh name
 				if (line.StartsWith ("o")) {
 					mesh.name = datas[1];
 				}
 
 				// vertex
 				if (line.StartsWith ("v ")) {
 					try {
 						tempVector3.x = float.Parse (datas[1]);
 						tempVector3.y = float.Parse (datas[2]);
 						tempVector3.z = float.Parse (datas[3]);
 
 						vertices.Add (tempVector3);
 					}
 					catch (Exception ex) {
 						Debug.LogWarning ("PARSE ERROR (vertex) : line " + lineNumber + " while loading mesh : " + mesh.name + "\n" + ex);
 						vertices.Add (Vector3.zero);
 					}
 				}
 
 				// uv - texture coordinate
 				if (line.StartsWith ("vt")) {
 					try {
 						tempVector2.x = float.Parse (datas[1]);
 						tempVector2.y = float.Parse (datas[2]);
 
 						uv.Add (tempVector2);
 					}
 					catch (Exception ex) {
 						Debug.LogWarning ("PARSE ERROR (uv) : line " + lineNumber + " while loading mesh : " + mesh.name + "\n" + ex);
 						uv.Add (Vector2.zero);
 					}
 				}
 
 				// normal
 				if (line.StartsWith ("vn")) {
 					try {
 						tempVector3.x = float.Parse (datas[1]);
 						tempVector3.y = float.Parse (datas[2]);
 						tempVector3.z = float.Parse (datas[3]);
 
 						normals.Add (tempVector3);
 					}
 					catch (Exception ex) {
 						Debug.LogWarning ("PARSE ERROR (normal) : line " + lineNumber + " while loading mesh : " + mesh.name + "\n" + ex);
 						normals.Add (Vector3.zero);
 					}
 				}
 
 				// triangle (face)
 				if (line.StartsWith ("f")) {
 					try {
 						triangles.Add (int.Parse (datas[1].Split ('/')[0]) - 1);
 						triangles.Add (int.Parse (datas[2].Split ('/')[0]) - 1);
 						triangles.Add (int.Parse (datas[3].Split ('/')[0]) - 1);
 					}
 					catch (Exception ex) {
 						Debug.LogWarning ("PARSE ERROR (triangle) : line " + lineNumber + " while loading mesh : " + mesh.name + "\n" + ex);
 						triangles.Add (1);
 						triangles.Add (2);
 						triangles.Add (3);
 						// beurk beurk, but we preserve vertex/face order
 					}
 				}
 
 				// else it's :
 				//	_ a comment (#...)
 				//	_ a smoothing group, but unity doesn't support it (s on/s off)
 				//	_ a unsupported operation (ex : mtl)
 
 				lineNumber++;
 			}
 
 			mesh.Clear ();
 			mesh.vertices = vertices.ToArray ();
 			mesh.uv = uv.ToArray ();
 			mesh.normals = normals.ToArray ();
 			mesh.triangles = triangles.ToArray ();
 		}
 
 		if (lFormat == LoadFormat.QMO) {
 			//
 		}
 
 		reader.Close ();
 	}
 
 	/// <summary>
 	/// Load a Mesh from a String (internally convert into a StringReader and call LoadFromStream).
 	/// lFormat : format of mesh (obj/qmo)
 	/// </summary>
 
 	public static void SimpleLoadFromText (this Mesh mesh, string text, LoadFormat lFormat) {
 		mesh.SimpleLoadFromStream (new StringReader (text), lFormat);
 	}
 // OLD CODE
 }