Export presets, wrap uv's, bugfixes and formatting.

[MA_TextureAtlas] Updated export window to use scriptable asset export presets. The option to wrap uv's (default = true). Bigfixes and code formatting.

MA_ToolBox/MA_TextureAtlasserPro/Scripts/Data/MA_TextureAtlasserProAtlas.cs

@@ -16,7 +16,7 @@ namespace MA_TextureAtlasserPro
 		public MA_TextureAtlasserProQuad selectedTextureQuad;
 		private Rect editorWorkRect;
 		public bool showTextures = false;
-
+        public MA_TextureAtlasserProExportSettings exportSettings;
 
 		//Data
 		public Vector2 textureAtlasSize;
@@ -36,7 +36,8 @@ namespace MA_TextureAtlasserPro
 			editorWorkRect = new Rect(Vector2.zero - zoomCoordsOrigin, textureAtlasSize);
 
 			GUI.backgroundColor = new Color(0, 0, 0, 0.1f);
-			GUI.Box(editorWorkRect, this.name);
+			GUI.Box(editorWorkRect, "");
+			GUI.Box(new Rect(editorWorkRect.x, editorWorkRect.y - 25, editorWorkRect.width, 20), this.name);
 			GUI.backgroundColor = Color.white;
 
 			MA_Editor.Grid.Grid.DrawZoomableGrid(editorWorkRect, 64, new Color(0, 0, 0, 0.1f), zoomCoordsOrigin);

MA_ToolBox/MA_TextureAtlasserPro/Scripts/Data/MA_TextureAtlasserProExportSettings.cs

@@ -0,0 +1,63 @@
+using UnityEngine;
+using System.Collections;
+using MA_Texture;
+
+namespace MA_TextureAtlasserPro
+{
+    [System.Serializable]
+    public class MA_TextureAtlasserProExportSettings : ScriptableObject
+    {
+        [HideInInspector]
+        public bool canModify = true;
+
+        public ModelExportSettings modelExportSettings = new ModelExportSettings();
+        public TextureExportSettings textureExportSettings = new TextureExportSettings();
+    }
+
+    [System.Serializable]
+    public class ModelExportSettings
+    {
+        [Header("Model settings:")]
+        public ModelFormat modelFormat = ModelFormat.Obj;
+        public bool replaceModel = false;
+        public bool uvFlipY = true;
+        public int uvChannel = 0;
+        public bool uvWrap = true;
+    }
+
+    [System.Serializable]
+    public class TextureExportSettings
+    {
+        [Header("Texture settings:")]
+        public TextureFormat textureFormat = TextureFormat.Png;
+        public TextureType textureType = TextureType.Default;
+        public MA_TextureUtils.TextureScaleMode textureScaleMode = MA_TextureUtils.TextureScaleMode.Bilinear;
+    }
+
+    public enum ExportPreset
+    {
+        Custom,
+        Default,
+        Sprites,
+        ReplaceObjMeshes
+    }
+
+    public enum ModelFormat
+    {
+        None,
+        Obj
+    }
+
+    public enum TextureFormat
+    {
+        None,
+        Png
+    }
+
+    public enum TextureType
+    {
+        Default,
+        Sprite,
+        SpriteSliced
+    }
+}

MA_ToolBox/MA_TextureAtlasserPro/Scripts/Data/MA_TextureAtlasserProQuad.cs

@@ -25,7 +25,6 @@ namespace MA_TextureAtlasserPro
 		public Rect dragRectPos;
 
 		//Data
-		public Texture texture;						//Replace this with texture groups
 		public List<MA_TextureGroup> textureGroups;
 		public List<Mesh> meshes;
 
@@ -43,7 +42,7 @@ namespace MA_TextureAtlasserPro
 			//Clamp and snap the guiRect
 			guiRect = new Rect(Mathf.RoundToInt(rect.x / 32) * 32, Mathf.RoundToInt(rect.y / 32) * 32, Mathf.RoundToInt(rect.width / 32) * 32, Mathf.RoundToInt(rect.height / 32) * 32);
 
-			//Draw the sqaud background
+			//Draw the quad background
 			if(showTexture && textureGroups != null && textureGroups.Count > 0 && textureGroups[0].texture != null)
 				GUI.DrawTexture(new Rect(guiRect.x - zoomCoordsOrigin.x, guiRect.y - zoomCoordsOrigin.y, guiRect.width, guiRect.height), textureGroups[0].texture, ScaleMode.StretchToFill);
 			else
@@ -53,7 +52,10 @@ namespace MA_TextureAtlasserPro
 
 			GUILayout.BeginHorizontal();
 			GUILayout.FlexibleSpace();
-			GUILayout.Label(this.name);		
+			var tempColor = GUI.backgroundColor;
+			GUI.backgroundColor = new Color(1, 1, 1, 0.7f);
+			GUILayout.Label(" " + this.name + " ", GUI.skin.box);
+			GUI.backgroundColor = tempColor;
 			GUILayout.FlexibleSpace();
 			GUILayout.EndHorizontal();
 

MA_ToolBox/MA_TextureAtlasserPro/Scripts/Data/MA_TextureAtlasserProSettings.cs

@@ -10,18 +10,31 @@ namespace MA_TextureAtlasserPro
 	[System.Serializable]
 	public class MA_TextureAtlasserProSettings : ScriptableObject
 	{
-		[Header("Selection")]
-		public bool autoFocus = false;
-
-		[Header("Duplication:")]
-		public bool copySelectedQuadData = false;
-		public string duplicatedQuadNamePrefix = "new ";
-
 		[Header("Hotkeys:")]
 		public bool useHotkeys = false;
+		public EventModifiers modifierKey = EventModifiers.Alt;
 		public KeyCode addQuadHotKey = KeyCode.Q;
 		public KeyCode removeQuadHotKey = KeyCode.R;
 		public KeyCode duplicateHotKey = KeyCode.D;
+		public KeyCode zoomInHotKey = KeyCode.Equals;
+		public KeyCode zoomOutHotKey = KeyCode.Minus;
+
+		[Header("Duplication:")]
+		public bool copySelectedQuadData = true;
+		public string duplicatedQuadNamePrefix = "new ";
+
+		[Header("Selection")]
+		public bool autoFocus = true;
+
+		public bool GetHotKey(Event e, KeyCode shortKey)
+		{
+			if (e.type == EventType.KeyDown && e.modifiers == modifierKey && e.keyCode == shortKey)
+			{
+				return true;
+			}
+
+			return false;
+		}
 	}
 }
 #endif

MA_ToolBox/MA_TextureAtlasserPro/Scripts/Editor/Utils/MA_TextureAtlasserProUtils.cs

@@ -8,10 +8,13 @@ using MA_Texture;
 
 namespace MA_TextureAtlasserPro
 {
+
+
 	public static class MA_TextureAtlasserProUtils
 	{
 		public const string SETTINGSASSETPATH = "Assets/MA_ToolBox/MA_TextureAtlasserPro/Settings/";
-		public const string SAVEASSETPATH = "Assets/MA_ToolBox/MA_TextureAtlasserPro/Atlasses/"; 
+        public const string EXPORTSETTINGSASSETPATH = "Assets/MA_ToolBox/MA_TextureAtlasserPro/Settings/ExportSettings/";
+        public const string SAVEASSETPATH = "Assets/MA_ToolBox/MA_TextureAtlasserPro/Atlasses/"; 
 		public const string LOADASSETPATH = "Assets/MA_ToolBox/MA_TextureAtlasserPro/Atlasses/";
 		public const string EXPORTASSETPATH = "Assets/MA_ToolBox/MA_TextureAtlasserPro/Exports/"; 
 		public const float VIEWOFFSET = 20;
@@ -19,7 +22,7 @@ namespace MA_TextureAtlasserPro
 
 		public static MA_TextureAtlasserProSettings CreateSettings()
 		{
-			MA_TextureAtlasserProSettings _settings = (MA_TextureAtlasserProSettings)ScriptableObject.CreateInstance<MA_TextureAtlasserProSettings>();
+			MA_TextureAtlasserProSettings _settings = ScriptableObject.CreateInstance<MA_TextureAtlasserProSettings>();
 
 			if(_settings != null)
 			{
@@ -47,9 +50,41 @@ namespace MA_TextureAtlasserPro
 			return _settings;
 		}
 
-		public static MA_TextureAtlasserProAtlas CreateTextureAtlas(string name, Vector2 size)
+        public static MA_TextureAtlasserProExportSettings CreateExportSettings(string name, bool canModify = true)
+        {
+            MA_TextureAtlasserProExportSettings _settings = ScriptableObject.CreateInstance<MA_TextureAtlasserProExportSettings>();
+            _settings.canModify = canModify;
+
+            if (_settings != null)
+            {
+                AssetDatabase.CreateAsset(_settings, EXPORTSETTINGSASSETPATH + name + ".asset");
+                AssetDatabase.SaveAssets();
+                AssetDatabase.Refresh();
+
+                return _settings;
+            }
+            else
+            {
+                return null;
+            }
+        }
+
+        public static MA_TextureAtlasserProExportSettings LoadExportSettings()
+        {
+            string name = "MA_DefaultExportSettings";
+            MA_TextureAtlasserProExportSettings _settings = AssetDatabase.LoadAssetAtPath(EXPORTSETTINGSASSETPATH + name + ".asset", typeof(MA_TextureAtlasserProExportSettings)) as MA_TextureAtlasserProExportSettings;
+
+            if (_settings == null)
+            {
+                _settings = CreateExportSettings(name, false);
+            }
+
+            return _settings;
+        }
+
+        public static MA_TextureAtlasserProAtlas CreateTextureAtlas(string name, Vector2 size)
 		{
-			MA_TextureAtlasserProAtlas _atlas = (MA_TextureAtlasserProAtlas)ScriptableObject.CreateInstance<MA_TextureAtlasserProAtlas>();
+			MA_TextureAtlasserProAtlas _atlas = ScriptableObject.CreateInstance<MA_TextureAtlasserProAtlas>();
 
 			if(_atlas != null)
 			{
@@ -104,8 +139,10 @@ namespace MA_TextureAtlasserPro
 			{
 				atlas.textureGroupRegistration = new List<MA_TextureGroupRegistration>();
 
-				MA_TextureGroupRegistration groupRegistration = new MA_TextureGroupRegistration();
-				groupRegistration.name = DEFAULTTEXTUREGROUPNAME;
+				MA_TextureGroupRegistration groupRegistration = new MA_TextureGroupRegistration
+				{
+					name = DEFAULTTEXTUREGROUPNAME
+				};
 
 				atlas.textureGroupRegistration.Add(groupRegistration);
 			}
@@ -143,9 +180,14 @@ namespace MA_TextureAtlasserPro
 					}
 				}
 			}
+
+            if(atlas.exportSettings == null)
+            {
+                atlas.exportSettings = LoadExportSettings();
+            }
 		}
 
-		public static void CreateTextureQuad(MA_TextureAtlasserProAtlas atlas, string name, Rect rect, bool focus = true)
+		public static MA_TextureAtlasserProQuad CreateTextureQuad(MA_TextureAtlasserProAtlas atlas, string name, Rect rect, bool focus = true)
 		{
 			if(atlas != null)
 			{
@@ -156,7 +198,7 @@ namespace MA_TextureAtlasserPro
 				}
 
 				//Create new quad
-				MA_TextureAtlasserProQuad _quad = (MA_TextureAtlasserProQuad)ScriptableObject.CreateInstance("MA_TextureAtlasserProQuad");
+				MA_TextureAtlasserProQuad _quad = ScriptableObject.CreateInstance<MA_TextureAtlasserProQuad>();
 
 				//Add quad to asset
 				if(_quad != null)
@@ -167,7 +209,7 @@ namespace MA_TextureAtlasserPro
 
 					SetTextureGroups(atlas, _quad);
 					
-					atlas.textureQuads.Add((MA_TextureAtlasserProQuad)_quad);
+					atlas.textureQuads.Add(_quad);
 
 					AssetDatabase.AddObjectToAsset(_quad, atlas);
 					AssetDatabase.SaveAssets();
@@ -177,6 +219,8 @@ namespace MA_TextureAtlasserPro
 					{
 						atlas.selectedTextureQuad = atlas.textureQuads[atlas.textureQuads.Count - 1];
 					}
+
+					return _quad;
 				}
 				else
 				{
@@ -187,6 +231,8 @@ namespace MA_TextureAtlasserPro
 			{
 				Debug.LogError("CreateTextureQuad Failed: textureAtlas");
 			}
+
+			return null;
 		}
 
 		public static void RemoveTextureQuad(MA_TextureAtlasserProAtlas atlas, bool focus = true)
@@ -196,7 +242,7 @@ namespace MA_TextureAtlasserPro
 				int _index = atlas.textureQuads.IndexOf(atlas.selectedTextureQuad);
 
 				atlas.textureQuads.RemoveAt(_index);
-				GameObject.DestroyImmediate(atlas.selectedTextureQuad, true);
+				Object.DestroyImmediate(atlas.selectedTextureQuad, true);
 				AssetDatabase.SaveAssets();
 				AssetDatabase.Refresh();
 
@@ -212,18 +258,29 @@ namespace MA_TextureAtlasserPro
 		{
 			if(atlas != null && atlas.selectedTextureQuad != null)
 			{
-				CreateTextureQuad(atlas, namePrefix + atlas.selectedTextureQuad.name, atlas.selectedTextureQuad.rect, false);
+				MA_TextureAtlasserProQuad q = CreateTextureQuad(atlas, namePrefix + atlas.selectedTextureQuad.name, atlas.selectedTextureQuad.rect, false);
 
-				if(copyData)
+				if (copyData)
 				{
-					atlas.textureQuads[atlas.textureQuads.Count - 1].meshes = atlas.selectedTextureQuad.meshes;
-					atlas.textureQuads[atlas.textureQuads.Count - 1].textureGroups = atlas.selectedTextureQuad.textureGroups;
+					q.meshes = new List<Mesh>();
+					for (int i = 0; i < atlas.selectedTextureQuad.meshes.Count; i++)
+					{
+						q.meshes.Add(atlas.selectedTextureQuad.meshes[i]);
+					}
+
+					for (int i = 0; i < atlas.selectedTextureQuad.textureGroups.Count; i++)
+					{
+						q.textureGroups[i].texture = atlas.selectedTextureQuad.textureGroups[i].texture;
+					}
 				}
 
 				if(focus)
 				{
-					atlas.selectedTextureQuad = atlas.textureQuads[atlas.textureQuads.Count - 1];
+					atlas.selectedTextureQuad = q;
 				}
+
+				AssetDatabase.SaveAssets();
+				AssetDatabase.Refresh();
 			}
 		}
 
@@ -237,22 +294,28 @@ namespace MA_TextureAtlasserPro
 			//Add texture groups
 			foreach (MA_TextureGroupRegistration tgr in atlas.textureGroupRegistration)
 			{
-				MA_TextureGroup textureGroup = new MA_TextureGroup();
-				textureGroup.name = tgr.name;
+				MA_TextureGroup textureGroup = new MA_TextureGroup
+				{
+					name = tgr.name
+				};
 				quad.textureGroups.Add(textureGroup);
 			}
 		}
 
 		public static void CreateTextureGroup(MA_TextureAtlasserProAtlas atlas, string name)
 		{
-			MA_TextureGroupRegistration _textureGroupRegistration = new MA_TextureGroupRegistration();
-			_textureGroupRegistration.name = name;
+			MA_TextureGroupRegistration _textureGroupRegistration = new MA_TextureGroupRegistration
+			{
+				name = name
+			};
 			atlas.textureGroupRegistration.Add(_textureGroupRegistration);
 
 			foreach (MA_TextureAtlasserProQuad q in atlas.textureQuads)
 			{
-				MA_TextureGroup _textureGroup = new MA_TextureGroup();
-				_textureGroup.name = name;
+				MA_TextureGroup _textureGroup = new MA_TextureGroup
+				{
+					name = name
+				};
 				q.textureGroups.Add(_textureGroup);
 			}
 		}
@@ -276,164 +339,6 @@ namespace MA_TextureAtlasserPro
 			curWindow.Close();
 		}
 
-		public static void ExportAtlas(MA_TextureAtlasserProAtlas atlas, string savePath = EXPORTASSETPATH)
-		{
-			if(atlas != null && atlas.textureQuads != null)
-			{
-				ExportAtlasMeshesObj(atlas);
-				ExportAtlasTexturesPNG(atlas);
-
-				AssetDatabase.Refresh();
-			}
-		}
-
-		public static void ExportAtlasMeshesObj(MA_TextureAtlasserProAtlas atlas, string savePath = EXPORTASSETPATH)
-		{
-			if(atlas != null && atlas.textureQuads != null)
-			{
-				foreach (MA_TextureAtlasserProQuad ta in atlas.textureQuads)
-				{
-					//Export Mesh
-					if(ta.meshes != null)
-					{
-						for (int m = 0; m < ta.meshes.Count; m++)
-						{
-							if(ta.meshes[m] != null)
-							{
-								//Create new mesh
-								Mesh newMesh = new Mesh();
-								//Duplicate it from the current one
-								newMesh = MA_MeshUtils.MA_DuplicateMesh(ta.meshes[m]);
-								//Remap uvs
-								newMesh = MA_MeshUtils.MA_UVReMap(newMesh, atlas.textureAtlasSize, ta.guiRect);
-								//Save it
-								MA_MeshUtils.MeshToFile(newMesh, "MA_" + ta.name, savePath);
-							}
-						}
-					}
-				}
-			}
-		}
-
-		// public static void ExportAtlasTexturePNG(MA_TextureAtlasserProAtlas atlas, string savePath = EXPORTASSETPATH)
-		// {
-		// 	if(atlas != null && atlas.textureQuads != null)
-		// 	{
-		// 		//Create new Texture Atlas
-		// 		Texture2D newTexture = new Texture2D((int)atlas.textureAtlasSize.x, (int)atlas.textureAtlasSize.y);
-		// 		newTexture.name = atlas.name;
-
-		// 		foreach (MA_TextureAtlasserProQuad ta in atlas.textureQuads)
-		// 		{
-		// 			//Export Texture Atlas
-		// 			//TODO: Replace with texture groups (foreacht ...)
-		// 			if(ta.texture != null)
-		// 			{
-		// 				//Create new texture part
-		// 				Texture2D newTexturePart = (Texture2D)MA_Texture.MA_TextureUtils.ConvertToReadableTexture(ta.texture);
-		// 				//Scale it
-		// 				newTexturePart = newTexturePart.MA_Scale2D((int)ta.guiRect.width, (int)ta.guiRect.height);
-		// 				//Add it
-		// 				newTexture = newTexture.MA_Combine2D(newTexturePart, (int)ta.guiRect.x, (int)ta.guiRect.y);
-		// 			}
-		// 		}
-
-		// 		//Save it
-		// 		newTexture.MA_Save2D("MA_" + newTexture.name, savePath);
-		// 		//Refresh
-		// 		AssetDatabase.Refresh();
-		// 	}
-		// }
-
-		public static void ExportAtlasTexturesPNG(MA_TextureAtlasserProAtlas atlas, string savePath = EXPORTASSETPATH)
-		{
-			if(atlas != null && atlas.textureQuads != null && atlas.textureGroupRegistration != null)
-			{
-				//Foreach texture group
-				for (int i = 0; i < atlas.textureGroupRegistration.Count; i++)
-				{
-					//Create new Texture Atlas
-					Texture2D newTexture = new Texture2D((int)atlas.textureAtlasSize.x, (int)atlas.textureAtlasSize.y);
-					newTexture.name = atlas.name + "_" + atlas.textureGroupRegistration[i].name;
-
-					foreach (MA_TextureAtlasserProQuad q in atlas.textureQuads)
-					{
-						if(q.textureGroups != null && q.textureGroups[i].texture != null)
-						{
-							//Create new texture part
-							Texture2D newTexturePart = (Texture2D)MA_Texture.MA_TextureUtils.ConvertToReadableTexture(q.textureGroups[i].texture);
-							//Scale it
-							newTexturePart = newTexturePart.MA_Scale32D((int)q.guiRect.width, (int)q.guiRect.height);
-							//Add it
-							newTexture = newTexture.MA_Combine2D(newTexturePart, (int)q.guiRect.x, (int)q.guiRect.y);
-						}
-					}
-
-					//Save it
-					newTexture.MA_Save2D("MA_" + newTexture.name, savePath);
-
-					TextureImporter textureImporter = (TextureImporter)AssetImporter.GetAtPath(savePath + "MA_" + newTexture.name + ".png");
-					textureImporter.textureType = TextureImporterType.Default;
-					textureImporter.SaveAndReimport();
-				}
-
-				//Refresh
-				AssetDatabase.Refresh();
-			}
-		}
-
-		public static void ExportAtlasSpritesPNG(MA_TextureAtlasserProAtlas atlas, bool sliceSprites = true, string savePath = EXPORTASSETPATH)
-		{
-			if (atlas != null && atlas.textureQuads != null && atlas.textureGroupRegistration != null)
-			{
-				ExportAtlasTexturesPNG(atlas, savePath);
-
-				//Foreach texture group
-				for (int i = 0; i < atlas.textureGroupRegistration.Count; i++)
-				{
-					//Convert
-					string textureName = "MA_" + atlas.name + "_" + atlas.textureGroupRegistration[i].name + ".png";
-					TextureImporter textureImporter = (TextureImporter)AssetImporter.GetAtPath(savePath + textureName);
-					textureImporter.textureType = TextureImporterType.Sprite;
-					textureImporter.alphaIsTransparency = true;
-
-					//Slice sprites.
-					if (sliceSprites)
-					{
-						textureImporter.spriteImportMode = SpriteImportMode.None; //Reset it to update?
-						textureImporter.spriteImportMode = SpriteImportMode.Multiple;
-						List<SpriteMetaData> spriteMetaData = new List<SpriteMetaData>();
-
-						foreach (MA_TextureAtlasserProQuad q in atlas.textureQuads)
-						{
-							if (q.textureGroups != null && q.textureGroups[i].texture != null)
-							{
-								//Create new SpriteMetaData.
-								SpriteMetaData smd = new SpriteMetaData();
-
-								smd.name = q.name;
-								smd.rect = new Rect(q.guiRect.x, atlas.textureAtlasSize.y - q.guiRect.y - q.guiRect.height, q.guiRect.width, q.guiRect.height);
-
-								spriteMetaData.Add(smd);
-							}
-						}
-
-						textureImporter.spritesheet = spriteMetaData.ToArray();
-					}
-					else
-					{
-						textureImporter.spriteImportMode = SpriteImportMode.Single;
-					}
-
-
-					textureImporter.SaveAndReimport();
-				}
-
-				//Refresh
-				AssetDatabase.Refresh();
-			}
-		}
-
 		public static bool IsPowerOfTwo(int value)
 		{
 			//While x is even and > 1
@@ -444,6 +349,180 @@ namespace MA_TextureAtlasserPro
 
 			return (value == 1);
 		}
+
+        #region Export
+        public static void ExportAtlasModels(MA_TextureAtlasserProAtlas atlas, ModelExportSettings modelExportSettings, string savePath = EXPORTASSETPATH)
+        {
+            switch(modelExportSettings.modelFormat)
+            {
+                case ModelFormat.None:
+                    break;
+                case ModelFormat.Obj:
+                    ExportAtlasObj(atlas, modelExportSettings, savePath);
+                    break;
+                default:
+                    break;
+            }
+        }
+
+		private static void ExportAtlasObj(MA_TextureAtlasserProAtlas atlas, ModelExportSettings modelExportSettings, string savePath = EXPORTASSETPATH)
+		{
+            if (atlas == null || atlas.textureQuads == null)
+                return;
+
+            if(modelExportSettings.replaceModel)
+            {
+                var quads = atlas.textureQuads;
+
+                for (var index = 0; index < quads.Count; index++)
+                {
+                    var quad = quads[index];
+                    if (quad.meshes == null)
+                        continue;
+
+                    var meshes = quad.meshes;
+                    for (var meshIndex = 0; meshIndex < quad.meshes.Count; meshIndex++)
+                    {
+                        if (meshes[meshIndex] == null)
+                            continue;
+
+                        MA_MeshUtils.MA_UVReMap(meshes[meshIndex], atlas.textureAtlasSize, quad.guiRect, modelExportSettings.uvChannel, modelExportSettings.uvFlipY, modelExportSettings.uvWrap);
+                        EditorUtility.SetDirty(meshes[meshIndex]);
+                    }
+                }
+
+                AssetDatabase.SaveAssets();
+            }
+            else
+            {
+                foreach (MA_TextureAtlasserProQuad quad in atlas.textureQuads)
+                {
+                    //Export Mesh
+                    if (quad.meshes != null)
+                    {
+                        for (int m = 0; m < quad.meshes.Count; m++)
+                        {
+                            if (quad.meshes[m] != null)
+                            {
+                                //Create new mesh
+                                Mesh newMesh = new Mesh();
+                                //Duplicate it from the current one
+                                newMesh = MA_MeshUtils.MA_DuplicateMesh(quad.meshes[m]);
+                                //Remap UV's
+                                newMesh = MA_MeshUtils.MA_UVReMap(newMesh, atlas.textureAtlasSize, quad.guiRect, modelExportSettings.uvChannel, modelExportSettings.uvFlipY, modelExportSettings.uvWrap);
+                                //Save it
+                                string modelName = string.IsNullOrEmpty(quad.name) ? "" : quad.name + "-";
+                                modelName += quad.meshes[m].name;
+                                int n = m + 1;
+                                modelName += "_" + n.ToString("#000");
+
+                                MA_MeshUtils.MeshToFile(newMesh, modelName, savePath);
+                            }
+                        }
+                    }
+                }
+            }	
+		}
+
+		public static void ExportAtlasTextures(MA_TextureAtlasserProAtlas atlas, TextureExportSettings textureExportSettings, string savePath = EXPORTASSETPATH)
+		{
+            switch (textureExportSettings.textureFormat)
+            {
+                case TextureFormat.None:
+                    break;
+                case TextureFormat.Png:
+			        ExportAtlasPNG(atlas, textureExportSettings, savePath);
+                    break;
+                default:
+                    break;
+            }
+		}
+
+		private static void ExportAtlasPNG(MA_TextureAtlasserProAtlas atlas, TextureExportSettings textureExportSettings, string savePath = EXPORTASSETPATH)
+		{
+			if (atlas == null || atlas.textureQuads == null || atlas.textureGroupRegistration == null)
+				return;
+
+			//Foreach texture group
+			for (int i = 0; i < atlas.textureGroupRegistration.Count; i++)
+			{
+				//Create new Texture Atlas
+				Texture2D newTexture = new Texture2D((int)atlas.textureAtlasSize.x, (int)atlas.textureAtlasSize.y)
+				{
+					name = atlas.name + "_" + atlas.textureGroupRegistration[i].name
+				};
+
+				foreach (MA_TextureAtlasserProQuad q in atlas.textureQuads)
+				{
+					if (q.textureGroups != null && q.textureGroups[i].texture != null)
+					{
+						//Create new texture part
+						Texture2D newTexturePart = (Texture2D)MA_TextureUtils.ConvertToReadableTexture(q.textureGroups[i].texture);
+						//Scale it
+						newTexturePart = newTexturePart.MA_Scale2D((int)q.guiRect.width, (int)q.guiRect.height, textureExportSettings.textureScaleMode);
+						//Add it
+						newTexture = newTexture.MA_Combine2D(newTexturePart, (int)q.guiRect.x, (int)q.guiRect.y);
+					}
+				}
+
+				//Save it
+				newTexture.MA_Save2D(newTexture.name, savePath);
+
+				TextureImporter textureImporter = (TextureImporter)AssetImporter.GetAtPath(savePath + newTexture.name + ".png");
+				textureImporter.textureType = TextureImporterType.Default;
+				textureImporter.SaveAndReimport();
+			}
+
+			SetAtlasPNGSpriteSettings(atlas, textureExportSettings, savePath);
+
+			//Refresh
+			AssetDatabase.Refresh();
+		}
+
+		private static void SetAtlasPNGSpriteSettings(MA_TextureAtlasserProAtlas atlas, TextureExportSettings textureExportSettings, string savePath = EXPORTASSETPATH)
+		{
+			//Foreach texture group
+			for (int i = 0; i < atlas.textureGroupRegistration.Count; i++)
+			{
+				//Convert
+				string textureName = atlas.name + "_" + atlas.textureGroupRegistration[i].name + ".png";
+				TextureImporter textureImporter = (TextureImporter)AssetImporter.GetAtPath(savePath + textureName);
+				textureImporter.textureType = TextureImporterType.Sprite;
+				textureImporter.alphaIsTransparency = true;
+
+				//Slice sprites.
+				if (textureExportSettings.textureType == TextureType.SpriteSliced)
+				{
+					textureImporter.spriteImportMode = SpriteImportMode.None; //Reset it to update?
+					textureImporter.spriteImportMode = SpriteImportMode.Multiple;
+					List<SpriteMetaData> spriteMetaData = new List<SpriteMetaData>();
+
+					foreach (MA_TextureAtlasserProQuad q in atlas.textureQuads)
+					{
+						if (q.textureGroups != null && q.textureGroups[i].texture != null)
+						{
+							//Create new SpriteMetaData.
+							SpriteMetaData smd = new SpriteMetaData
+							{
+								name = q.name,
+								rect = new Rect(q.guiRect.x, atlas.textureAtlasSize.y - q.guiRect.y - q.guiRect.height, q.guiRect.width, q.guiRect.height)
+							};
+
+							spriteMetaData.Add(smd);
+						}
+					}
+
+					textureImporter.spritesheet = spriteMetaData.ToArray();
+				}
+				else
+				{
+					textureImporter.spriteImportMode = SpriteImportMode.Single;
+				}
+
+				textureImporter.SaveAndReimport();
+			}
+		}
+		#endregion
 	}
 }
 #endif

MA_ToolBox/MA_TextureAtlasserPro/Scripts/Editor/Views/MA_TextureAtlasserProDebugView.cs

@@ -33,7 +33,7 @@ namespace MA_TextureAtlasserPro
 					curWindow.workView.ResetWindow();
 				}
 
-				if(curWindow.textureAtlas != null)
+				if (curWindow.textureAtlas != null)
 				{
 					GUILayout.FlexibleSpace();
 					//GUILayout.Label(curWindow.textureAtlas.textureAtlasSize.ToString());

MA_ToolBox/MA_TextureAtlasserPro/Scripts/Editor/Views/MA_TextureAtlasserProWorkView.cs

@@ -19,7 +19,7 @@ namespace MA_TextureAtlasserPro
         private const float kZoomMax = 2.0f;
 		private Rect zoomArea;
 		private float zoom = 1.0f;
-        public float Zoom { get { return zoom; } }
+        public float Zoom { get { return zoom; } set { zoom = Mathf.Clamp(value, kZoomMin, kZoomMax); } }
         private Vector2 zoomCoordsOrigin = Vector2.zero;
 
 		public override void UpdateView(Event e, Rect editorViewRect)
@@ -96,21 +96,32 @@ namespace MA_TextureAtlasserPro
 			{
 				if(curWindow.textureAtlas != null)
 				{
-					if (e.type == EventType.KeyDown && e.keyCode == curWindow.settings.addQuadHotKey)
+					if (curWindow.settings.GetHotKey(e, curWindow.settings.addQuadHotKey))
 					{
 						MA_TextureAtlasserProUtils.CreateTextureQuad(curWindow.textureAtlas, "new Quad", new Rect(0, 0, 128, 128), curWindow.settings.autoFocus);
 						e.Use();
 					}
 
+					if(curWindow.settings.GetHotKey(e, curWindow.settings.zoomInHotKey))
+					{
+						Zoom += 0.25f;
+						e.Use();
+					}
+					if(curWindow.settings.GetHotKey(e, curWindow.settings.zoomOutHotKey))
+					{
+						Zoom -= 0.25f;
+						e.Use();
+					}
+
 					if (curWindow.textureAtlas.selectedTextureQuad != null)
 					{
-						if (e.type == EventType.KeyDown && e.keyCode == curWindow.settings.removeQuadHotKey)
+						if (curWindow.settings.GetHotKey(e, curWindow.settings.removeQuadHotKey))
 						{
 							MA_TextureAtlasserProUtils.RemoveTextureQuad(curWindow.textureAtlas, curWindow.settings.autoFocus);
 							e.Use();
 						}
 
-						if (e.type == EventType.KeyDown && e.keyCode == curWindow.settings.duplicateHotKey)
+						if (curWindow.settings.GetHotKey(e, curWindow.settings.duplicateHotKey))
 						{
 							MA_TextureAtlasserProUtils.DuplicateTextureQuad(curWindow.textureAtlas, curWindow.settings.autoFocus, curWindow.settings.copySelectedQuadData, curWindow.settings.duplicatedQuadNamePrefix);
 							e.Use();

MA_ToolBox/MA_TextureAtlasserPro/Scripts/Editor/Windows/MA_TextureAtlasserProCreateExportWindow.cs

@@ -0,0 +1,88 @@
+#if UNITY_EDITOR
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+using MA_Editor;
+using MA_Texture;
+
+namespace MA_TextureAtlasserPro
+{
+    public class MA_TextureAtlasserProCreateExportWindow : EditorWindow
+    {
+        private const int windowHeight = 97;
+        private const int windowWidth = 320;
+
+        //Editor
+        private static MA_TextureAtlasserProCreateExportWindow thisWindow;
+        public static MA_TextureAtlasserProWindow curWindow;
+
+        //Data
+        string settingsName = "Settings name";
+        bool nameError = true;
+
+        [MenuItem("MA_ToolKit/MA_TextureAtlasserPro/New Export Settings")]
+        public static void Init()
+        {
+            InitWindow(null);
+        }
+
+        public static void InitWindow(MA_TextureAtlasserProWindow currentEditorWindow)
+        {
+            curWindow = currentEditorWindow;
+
+            GetCurrentWindow();
+
+            thisWindow.minSize = new Vector2(windowWidth, windowHeight);
+            thisWindow.maxSize = new Vector2(windowWidth, windowHeight);
+            thisWindow.titleContent.text = "MA_CreateExportSettings";
+
+            thisWindow.Show();
+        }
+
+        private static void GetCurrentWindow()
+        {
+            thisWindow = (MA_TextureAtlasserProCreateExportWindow)EditorWindow.GetWindow<MA_TextureAtlasserProCreateExportWindow>();
+        }
+
+        void OnGUI()
+        {
+            GUILayout.BeginArea(new Rect(MA_TextureAtlasserProUtils.VIEWOFFSET, MA_TextureAtlasserProUtils.VIEWOFFSET, position.width - (MA_TextureAtlasserProUtils.VIEWOFFSET * 2), position.height - (MA_TextureAtlasserProUtils.VIEWOFFSET * 2)));
+            GUILayout.BeginVertical();
+
+            //Input options
+            settingsName = EditorGUILayout.TextField("Settings name", settingsName, GUILayout.ExpandWidth(true));
+            if (settingsName == "Settings name" || string.IsNullOrEmpty(settingsName))
+            {
+                nameError = true;
+                GUI.backgroundColor = Color.red;
+                GUILayout.Box("Error: Enter a valid settings name!", EditorStyles.helpBox);
+                GUI.backgroundColor = Color.white;
+            }
+            else
+            {
+                nameError = false;
+            }
+
+            //Create
+            if (!nameError)
+            {
+                if (GUILayout.Button("Create!", GUILayout.ExpandWidth(true), GUILayout.Height(37)))
+                {
+                    MA_TextureAtlasserProExportSettings exportSettings = MA_TextureAtlasserProUtils.CreateExportSettings(settingsName, true);
+
+                    if (curWindow != null && curWindow.textureAtlas != null)
+                    {
+                        curWindow.textureAtlas.exportSettings = exportSettings;
+                    }
+
+                    this.Close();
+                }
+            }
+
+            GUILayout.EndVertical();
+            GUILayout.EndArea();
+        }
+    }
+}
+#endif

MA_ToolBox/MA_TextureAtlasserPro/Scripts/Editor/Windows/MA_TextureAtlasserProExportWindow.cs

@@ -4,35 +4,32 @@ using System.Collections.Generic;
 using UnityEngine;
 using UnityEditor;
 using MA_Editor;
+using MA_Texture;
 
 namespace MA_TextureAtlasserPro
 {
-	public class MA_TextureAtlasserProExportWindow : EditorWindow 
-	{
-		//Editor
-		private static MA_TextureAtlasserProExportWindow thisWindow;
-		public static MA_TextureAtlasserProWindow curWindow;
+    public class MA_TextureAtlasserProExportWindow : EditorWindow
+    {
+        private const int windowHeight = 300;
+        private const int windowWidth = 320;
 
-		//Data
-		private static bool isLoaded = false;       //Make sure we wait a frame at the start to setup and don't draw.
+        //Editor
+        private static MA_TextureAtlasserProExportWindow thisWindow;
+        public static MA_TextureAtlasserProWindow curWindow;
 
-		private bool exportObjDefault = false;
-		private bool exportPngDefault = false;
-		private bool exportSprite = false;
-		private bool exportSliceSprite = false;
+        //Data
+        private static bool isLoaded = false;       //Make sure we wait a frame at the start to setup and don't draw.
 
-		[MenuItem("MA_ToolKit/MA_TextureAtlasserPro/Export Atlas")]	
+        [MenuItem("MA_ToolKit/MA_TextureAtlasserPro/Export Atlas")]	
 		private static void Init()
         {
-			GetCurrentWindow();
+            GetCurrentWindow();
 
-			thisWindow.minSize = new Vector2(420, 200);
-			thisWindow.maxSize = new Vector2(420, 200);
+            thisWindow.minSize = new Vector2(windowWidth, windowHeight);
+            thisWindow.titleContent.text = "MA_ExportTextureAtlas";
 
-			thisWindow.titleContent.text = "MA_ExportTextureAtlas";
-
-			thisWindow.Show();
-		}
+            thisWindow.Show();
+        }
 
 		public static void InitEditorWindow(MA_TextureAtlasserProWindow currentEditorWindow)
 		{
@@ -40,9 +37,7 @@ namespace MA_TextureAtlasserPro
 
 			GetCurrentWindow();
 
-			thisWindow.minSize = new Vector2(420, 200);
-			thisWindow.maxSize = new Vector2(420, 200);
-
+			thisWindow.minSize = new Vector2(windowWidth, windowHeight);
 			thisWindow.titleContent.text = "MA_ExportTextureAtlas";
 
 			thisWindow.Show();
@@ -101,66 +96,15 @@ namespace MA_TextureAtlasserPro
 				{
 					//Export
 					GUILayout.BeginVertical();
-					GUILayout.BeginHorizontal(EditorStyles.helpBox);
+                    DrawExportMenu();
 
-					if (GUILayout.Button("3D", GUILayout.ExpandWidth(false)))
-					{
-						exportObjDefault = true;
-						exportPngDefault = true;
-						exportSprite = false;
-						exportSliceSprite = false;
-					}
+                    curWindow.textureAtlas.exportSettings = (MA_TextureAtlasserProExportSettings)EditorGUILayout.ObjectField(curWindow.textureAtlas.exportSettings, typeof(MA_TextureAtlasserProExportSettings), false);
 
-					if (GUILayout.Button("2D", GUILayout.ExpandWidth(false)))
-					{
-						exportObjDefault = false;
-						exportPngDefault = true;
-						exportSprite = true;
-						exportSliceSprite = true;
-					}
+                    if(curWindow.textureAtlas.exportSettings != null)
+                    {
+                        DrawExportAdvancedOptions();
+                    }
 
-					GUILayout.EndHorizontal();
-
-					GUILayout.Label("Meshes:");
-					exportObjDefault = GUILayout.Toggle(exportObjDefault, "OBJ default.");
-
-					GUILayout.Label("Textures:");
-					GUILayout.BeginHorizontal();
-					exportPngDefault = GUILayout.Toggle(exportPngDefault, "PNG default.");
-					if(exportPngDefault)
-					{
-						exportSprite = GUILayout.Toggle(exportSprite, "Sprite.");
-						if (exportSprite)
-						{
-							exportSliceSprite = GUILayout.Toggle(exportSliceSprite, "Slice sprites.");
-						}
-					}
-					GUILayout.FlexibleSpace();
-					GUILayout.EndHorizontal();
-
-					GUILayout.BeginHorizontal(EditorStyles.helpBox);
-
-					if (GUILayout.Button("Export", GUILayout.ExpandWidth(true), GUILayout.Height(37)))
-					{
-						if(exportObjDefault)
-						{
-							MA_TextureAtlasserProUtils.ExportAtlasMeshesObj(curWindow.textureAtlas);
-						}
-
-						if(exportPngDefault)
-						{
-							if(exportSprite)
-							{
-								MA_TextureAtlasserProUtils.ExportAtlasSpritesPNG(curWindow.textureAtlas, exportSliceSprite);
-							}
-							else
-							{
-								MA_TextureAtlasserProUtils.ExportAtlasTexturesPNG(curWindow.textureAtlas);
-							}
-						}
-					}
-
-					GUILayout.EndHorizontal();
 					GUILayout.EndVertical();
 				}
 				else if(curWindow == null)
@@ -187,6 +131,69 @@ namespace MA_TextureAtlasserPro
 			if(e.type == EventType.Repaint)
 				isLoaded = true;
 		}
+
+		private void DrawExportMenu()
+		{
+			GUILayout.BeginHorizontal(EditorStyles.helpBox, GUILayout.Height(44));
+
+            if (GUILayout.Button(MA_TextureAtlasserProIcons.createAtlasIcon, GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true)))
+            {
+                MA_TextureAtlasserProCreateExportWindow.InitWindow(curWindow);
+            }
+
+            bool wasEnabled = GUI.enabled;
+
+            if (curWindow.textureAtlas.exportSettings != null)
+            {
+                GUI.enabled = true;
+            }
+            else
+            {
+                GUI.enabled = false;
+            }
+
+            if (GUILayout.Button("Export", GUILayout.ExpandWidth(true), GUILayout.Height(37)))
+            {
+                MA_TextureAtlasserProUtils.ExportAtlasModels(curWindow.textureAtlas, curWindow.textureAtlas.exportSettings.modelExportSettings);
+                MA_TextureAtlasserProUtils.ExportAtlasTextures(curWindow.textureAtlas, curWindow.textureAtlas.exportSettings.textureExportSettings);
+            }
+
+            GUI.enabled = wasEnabled;
+
+            GUILayout.EndHorizontal();
+		}
+
+		private void DrawExportAdvancedOptions()
+		{
+			bool wasEnabled = GUI.enabled;
+
+            if (curWindow.textureAtlas.exportSettings.canModify)
+            {
+                GUI.enabled = true;
+            }
+            else
+            {
+                GUI.enabled = false;
+            }
+
+            EditorGUILayout.BeginVertical(EditorStyles.helpBox);
+
+            GUILayout.Label("Models:", EditorStyles.miniBoldLabel);
+            curWindow.textureAtlas.exportSettings.modelExportSettings.modelFormat = (ModelFormat)EditorGUILayout.EnumPopup("ModelFormat:", curWindow.textureAtlas.exportSettings.modelExportSettings.modelFormat);
+            curWindow.textureAtlas.exportSettings.modelExportSettings.replaceModel = EditorGUILayout.Toggle("ReplaceModels:", curWindow.textureAtlas.exportSettings.modelExportSettings.replaceModel);
+            curWindow.textureAtlas.exportSettings.modelExportSettings.uvFlipY = EditorGUILayout.Toggle("UV FlipY:", curWindow.textureAtlas.exportSettings.modelExportSettings.uvFlipY);
+            curWindow.textureAtlas.exportSettings.modelExportSettings.uvChannel = EditorGUILayout.IntField("UV Channel:", curWindow.textureAtlas.exportSettings.modelExportSettings.uvChannel);
+            curWindow.textureAtlas.exportSettings.modelExportSettings.uvWrap = EditorGUILayout.Toggle("UV Wrap:", curWindow.textureAtlas.exportSettings.modelExportSettings.uvWrap);
+
+            GUILayout.Label("Textures:", EditorStyles.miniBoldLabel);
+            curWindow.textureAtlas.exportSettings.textureExportSettings.textureFormat = (TextureFormat)EditorGUILayout.EnumPopup("TextureFormat:", curWindow.textureAtlas.exportSettings.textureExportSettings.textureFormat);
+            curWindow.textureAtlas.exportSettings.textureExportSettings.textureType = (TextureType)EditorGUILayout.EnumPopup("TextureType:", curWindow.textureAtlas.exportSettings.textureExportSettings.textureType);
+            curWindow.textureAtlas.exportSettings.textureExportSettings.textureScaleMode = (MA_TextureUtils.TextureScaleMode)EditorGUILayout.EnumPopup("TextureScaleMode:", curWindow.textureAtlas.exportSettings.textureExportSettings.textureScaleMode);
+
+            EditorGUILayout.EndVertical();
+
+			GUI.enabled = wasEnabled;
+		}
 	}
 }
 #endif

MA_ToolBox/MA_TextureAtlasserPro/Settings/ExportSettings/ExportSettings.txt

@@ -0,0 +1 @@
+Export settigns are supposed to be here.

MA_ToolBox/MA_TextureAtlasserPro/Settings/ExportSettings/MA_DefaultExportSettings.asset

@@ -0,0 +1,25 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 81466035f9fafc64db33b9e6114d774b, type: 3}
+  m_Name: MA_DefaultExportSettings
+  m_EditorClassIdentifier: 
+  canModify: 0
+  modelExportSettings:
+    modelFormat: 1
+    replaceModel: 0
+    uvFlipY: 1
+    uvChannel: 0
+    uvWrap: 1
+  textureExportSettings:
+    textureFormat: 1
+    textureType: 0
+    textureScaleMode: 0

MA_ToolBox/MA_TextureAtlasserPro/Settings/ExportSettings/MA_DefaultSpriteExportSettings.asset

@@ -0,0 +1,25 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 81466035f9fafc64db33b9e6114d774b, type: 3}
+  m_Name: MA_DefaultSpriteExportSettings
+  m_EditorClassIdentifier: 
+  canModify: 0
+  modelExportSettings:
+    modelFormat: 1
+    replaceModel: 0
+    uvFlipY: 1
+    uvChannel: 0
+    uvWrap: 1
+  textureExportSettings:
+    textureFormat: 1
+    textureType: 0
+    textureScaleMode: 0

MA_ToolBox/MA_TextureAtlasserPro/Settings/MA_TextureAtlasserProSettings.asset

@@ -0,0 +1,24 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 73f5e66553c13034e9b894ef2cc31b66, type: 3}
+  m_Name: MA_TextureAtlasserProSettings
+  m_EditorClassIdentifier: 
+  useHotkeys: 1
+  modifierKey: 1
+  addQuadHotKey: 113
+  removeQuadHotKey: 114
+  duplicateHotKey: 100
+  zoomInHotKey: 61
+  zoomOutHotKey: 45
+  copySelectedQuadData: 1
+  duplicatedQuadNamePrefix: 'new '
+  autoFocus: 1

MA_ToolBox/MA_Utilities/MeshUtils/MA_MeshUtils.cs

@@ -9,6 +9,7 @@ using System.IO;
 using System.Text;
 using System.Collections;
 using System.Collections.Generic;
+using System.Linq;
 using UnityEngine;
 using UnityEditor;
 
@@ -38,7 +39,13 @@ namespace MA_Mesh
 
 		public static Mesh MA_DuplicateMesh(Mesh mesh)
 		{
-			Mesh newMesh = new Mesh();
+			Mesh newMesh = new Mesh
+			{
+				name = mesh.name,
+				bounds = mesh.bounds,
+				colors = mesh.colors,
+				subMeshCount = mesh.subMeshCount
+			};
 
 			newMesh.SetVertices(new List<Vector3>(mesh.vertices));
 			for (int i = 0; i < mesh.subMeshCount; i++)
@@ -81,27 +88,41 @@ namespace MA_Mesh
 			return mesh;
 		}
 
-		public static Mesh MA_UVReMap(this Mesh mesh, Vector2 atlasSize, Rect textureRect, int uvChannel = 0, bool flipY = true)
-		{
-			List<Vector2> uvs = new List<Vector2>();
-			
+		public static Mesh MA_UVReMap(this Mesh mesh, Vector2 atlasSize, Rect textureRect, int uvChannel = 0, bool flipY = true, bool wrap = true)
+		{	
 			//Get UV's
+			List<Vector2> uvs = new List<Vector2>();
 			mesh.GetUVs(uvChannel, uvs);
 
+			//Min and max bounds in 0-1 space.
+			float xMin, xMax, yMin, yMax;
+			xMin = (1f / atlasSize.x * textureRect.width);
+			xMax = (1f / atlasSize.x * textureRect.x);
+			yMin = (1f / atlasSize.y * textureRect.height);
+
+			//Flip uv's if needed.
+			if (flipY)
+			{
+				yMax = (1f / atlasSize.y * (atlasSize.y - textureRect.height - textureRect.y));
+			}
+			else
+			{
+				yMax = (1f / atlasSize.y * textureRect.y);
+			}
+
 			for (int i = 0; i < uvs.Count; i++)
 			{
-				if(flipY)
+				float newX = uvs[i].x * xMin + xMax;
+				float newY = uvs[i].y * yMin + yMax;
+
+				//Wrap the verts outside of the uv space around back into the uv space.
+				if (wrap)
 				{
-					//Debug.Log("01" + uvs[i].x);
-					uvs[i] = new Vector2((uvs[i].x / atlasSize.x * textureRect.width) + (1 / atlasSize.x * textureRect.x), (uvs[i].y / atlasSize.y * textureRect.height) + (1 / atlasSize.y * (atlasSize.y - textureRect.height - textureRect.y)));
-					//Debug.Log("02" + uvs[i].x);
-				}
-				else
-				{			
-					//Debug.Log("01" + uvs[i].x);
-					uvs[i] = new Vector2((uvs[i].x / atlasSize.x * textureRect.width) + (1 / atlasSize.x * textureRect.x), (uvs[i].y / atlasSize.y * textureRect.height) + (1 / atlasSize.y * textureRect.y));
-					//Debug.Log("02" + uvs[i].x);
+					newX = Wrap(newX, xMax, xMin + xMax);
+					newY = Wrap(newY, yMax, yMin + yMax);
 				}
+
+				uvs[i] = new Vector2(newX, newY);
 			}
 
 			mesh.SetUVs(uvChannel, uvs);
@@ -109,6 +130,14 @@ namespace MA_Mesh
 			return mesh;
 		}
 
+		public static float Wrap(float val, float min, float max)
+		{
+			val -= (float)Math.Round((val - min) / (max - min)) * (max - min);
+			if (val < min)
+				val = val + max - min;
+			return val;
+		}
+
 		//Start http://wiki.unity3d.com/index.php?title=ObjExporter
 		public static string MeshToString(Mesh mesh) 
 		{
@@ -116,7 +145,6 @@ namespace MA_Mesh
 			int normalOffset = 0;
 			int uvOffset = 0;
 
-
 			Material material = new Material(Shader.Find("Standard"));
 	
 			StringBuilder sb = new StringBuilder();
@@ -164,9 +192,9 @@ namespace MA_Mesh
 				}
 			}
 
-			vertexOffset += mesh.vertices.Length;
-			normalOffset += mesh.normals.Length;
-			uvOffset += mesh.uv.Length;
+			//vertexOffset += mesh.vertices.Length;
+			//normalOffset += mesh.normals.Length;
+			//uvOffset += mesh.uv.Length;
 
 			return sb.ToString();
 		}
@@ -176,16 +204,15 @@ namespace MA_Mesh
 			using (StreamWriter sw = new StreamWriter(savePath + filename + ".obj")) 
 			{
 				sw.Write(MeshToString(mesh));
-				Debug.Log(savePath + filename);
 			}			
 		}
 		//End
 	}
 
-	struct ObjMaterial
-	{
-		public string name;
-		public string textureName;
-	}
+	//struct ObjMaterial
+	//{
+	//	public string name;
+	//	public string textureName;
+	//}
 }
 #endif

MA_ToolBox/MA_Utilities/TextureUtils/MA_TextureUtils.cs

@@ -5,6 +5,7 @@
 //https://forum.unity3d.com/threads/contribution-texture2d-blur-in-c.185694/
 //http://orbcreation.com/orbcreation/page.orb?1180
 //https://support.unity3d.com/hc/en-us/articles/206486626-How-can-I-get-pixels-from-unreadable-textures-
+//https://github.com/maxartz15/MA_TextureAtlasser/commit/9f5240967a51692fa2a17a6b3c8d124dd5dc60f9
 
 #if UNITY_EDITOR
 using UnityEngine;
@@ -12,6 +13,7 @@ using UnityEditor;
 using System.IO;
 using System.Collections;
 using System.Collections.Generic;
+using System;
 
 namespace MA_Texture
 {
@@ -44,6 +46,7 @@ namespace MA_Texture
             // Copy the pixels from the RenderTexture to the new Texture
             myTexture2D.ReadPixels(new Rect(0, 0, tmp.width, tmp.height), 0, 0);
             myTexture2D.Apply();
+            myTexture2D.name = texture.name;
 
             // Reset the active RenderTexture
             RenderTexture.active = previous;
@@ -68,8 +71,6 @@ namespace MA_Texture
             bw.Close();
             fs.Close();
 
-            Debug.Log("Saved texture: " + texture.name);
-
             AssetDatabase.Refresh();
 
             return texture;
@@ -85,104 +86,110 @@ namespace MA_Texture
 
             return texture;
         }
-        #endregion
+		#endregion
 
-        #region Scale
-        public static Texture2D MA_Scale2D(this Texture2D texture, int newWidth, int newHeight)
-        {
-            Texture2D texture2D = new Texture2D(newWidth, newHeight);
-            float ratioWidth = texture.width / newWidth;
-            float ratioHeight = texture.height / newHeight;
-
-            for (int x = 0; x < texture.width; x++)
-            {
-                for (int y = 0; y < texture.height; y++)
-                {
-                    Color pixel = texture.GetPixel(x, y);
-                    int posX = Mathf.FloorToInt(x / ratioWidth);
-                    int posY = Mathf.FloorToInt(y / ratioHeight);
-                    texture2D.SetPixel(posX, posY, new Color(pixel.r, pixel.g, pixel.b, pixel.a));
-                }
-            }
-            texture2D.Apply();
-
-            return texture2D;
-        }
-
-        public static Texture MA_Scale(this Texture texture, int newWidth, int newHeight)
-        {
-            Texture2D texture2D = (Texture2D)MA_TextureUtils.ConvertToReadableTexture(texture);
-
-            texture2D.MA_Scale2D(newWidth, newHeight);
-
-            texture = texture2D;
-
-            return texture;
-        }
-
-        public static Texture2D MA_Scale22D(this Texture2D texture, float width, float height)
-        {
-            float ratioWidth = width / texture.width;
-            float ratioHeight = height / texture.height;
-
-            int newWidth = Mathf.RoundToInt(texture.width * ratioWidth);
-            int newHeight = Mathf.RoundToInt(texture.height * ratioHeight);
-
-            Texture2D newTexture = new Texture2D(newWidth, newHeight);
-
-            for (int x = 0; x < texture.width; x++)
-            {
-                for (int y = 0; y < texture.height; y++)
-                {
-                    Color pixel = texture.GetPixel(x, y);
-                    int posX = Mathf.RoundToInt(x * ratioWidth);
-                    int posY = Mathf.RoundToInt(y * ratioHeight);
-                    newTexture.SetPixel(posX, posY, new Color(pixel.r, pixel.g, pixel.b, pixel.a));
-                }
-            }
-
-            newTexture.name = texture.name;
-
-            newTexture.Apply();
-            return newTexture;
-        }
-
-        public static Texture MA_Scale2(this Texture texture, float newWidth, float newHeight)
-        {
-            Texture2D texture2D = (Texture2D)MA_TextureUtils.ConvertToReadableTexture(texture);
-
-            texture = texture2D.MA_Scale22D(newWidth, newHeight);
-
-            return texture;
-        }
-
-		public static Texture2D MA_Scale32D(this Texture2D texture, int width, int height)
+		#region Scale
+		public enum TextureScaleMode
 		{
-			float ratioWidth = (float)width / texture.width;
-			float ratioHeight = (float)height / texture.height;
+			Bilinear,
+			Point
+		}
 
-			Texture2D newTexture = new Texture2D(width, height);
+        public static Texture MA_Scale(this Texture texture, int width, int height, TextureScaleMode scaleMode)
+        {
+			Texture2D texture2D = (Texture2D)MA_TextureUtils.ConvertToReadableTexture(texture);
 
-			for (int x = 0; x < width; x++)
+			texture2D.MA_Scale2D(width, height, scaleMode);
+
+			texture = texture2D;
+
+            return texture;
+        }
+
+		public static Texture2D MA_Scale2D(this Texture2D texture, int newWidth, int newHeight, TextureScaleMode scaleMode)
+		{
+			Color[] curColors = texture.GetPixels();
+			Color[] newColors = new Color[newWidth * newHeight];
+
+			switch (scaleMode)
 			{
-				int posX = Mathf.FloorToInt(x / ratioWidth);
-				for (int y = 0; y < height; y++)
+				case TextureScaleMode.Bilinear:
+					newColors = MA_BilinearScale(curColors, texture.width, texture.height, newWidth, newHeight);
+					break;
+				case TextureScaleMode.Point:
+					newColors = MA_PointScale(curColors, texture.width, texture.height, newWidth, newHeight);
+					break;
+
+			}
+
+			texture.Resize(newWidth, newHeight);
+			texture.SetPixels(newColors);
+			texture.Apply();
+
+			return texture;
+		}
+
+		private static Color[] MA_BilinearScale(Color[] curColors, int curWidth, int curHeight, int newWidth, int newHeight)
+		{
+			Color[] newColors = new Color[newWidth * newHeight];
+
+			float ratioX = 1.0f / ((float)newWidth / (curWidth - 1));
+			float ratioY = 1.0f / ((float)newHeight / (curHeight - 1));
+
+			for (int y = 0; y < newHeight; y++)
+			{
+				int yFloor = Mathf.FloorToInt(y * ratioY);
+				var y1 = yFloor * curWidth;
+				var y2 = (yFloor + 1) * curWidth;
+				var yw = y * newWidth;
+
+				for (int x = 0; x < newWidth; x++)
 				{
-					int posY = Mathf.FloorToInt(y / ratioHeight);
-					Color pixel = texture.GetPixel(posX, posY);
-					newTexture.SetPixel(x, y, new Color(pixel.r, pixel.g, pixel.b, pixel.a));
+					int xFloor = Mathf.FloorToInt(x * ratioX);
+					var xLerp = x * ratioX - xFloor;
+
+					newColors[yw + x] = ColorLerpUnclamped(ColorLerpUnclamped(curColors[y1 + xFloor], curColors[y1 + xFloor + 1], xLerp),
+														ColorLerpUnclamped(curColors[y2 + xFloor], curColors[y2 + xFloor + 1], xLerp),
+														y * ratioY - yFloor);
 				}
 			}
 
-			newTexture.name = texture.name;
-
-			newTexture.Apply();
-			return newTexture;
+			return newColors;
 		}
-        #endregion
 
-        #region combine
-        public static Texture2D MA_Combine2D(this Texture2D texture, Texture2D combineTexture, int offsetX, int offsetY, bool flipY = true)
+		private static Color[] MA_PointScale(Color[] curColors, int curWidth, int curHeight, int newWidth, int newHeight)
+		{
+			Color[] newColors = new Color[newWidth * newHeight];
+
+			float ratioX = ((float)curWidth) / newWidth;
+			float ratioY = ((float)curHeight) / newHeight;
+
+			for (int y = 0; y < newHeight; y++)
+			{
+				var thisY = Mathf.RoundToInt((ratioY * y) * curWidth);
+				var yw = y * newWidth;
+
+				for (int x = 0; x < newWidth; x++)
+				{
+					newColors[yw + x] = curColors[Mathf.RoundToInt(thisY + ratioX * x)];
+				}
+			}
+
+			return newColors;
+		}
+
+		private static Color ColorLerpUnclamped(Color c1, Color c2, float value)
+		{
+			return new Color(c1.r + (c2.r - c1.r) * value,
+							  c1.g + (c2.g - c1.g) * value,
+							  c1.b + (c2.b - c1.b) * value,
+							  c1.a + (c2.a - c1.a) * value);
+		}
+
+		#endregion
+
+		#region combine
+		public static Texture2D MA_Combine2D(this Texture2D texture, Texture2D combineTexture, int offsetX, int offsetY, bool flipY = true)
         {
             for (int x = 0; x < combineTexture.width; x++)
             {
@@ -191,7 +198,7 @@ namespace MA_Texture
                     //Y is 'flipped' because textures are made from left to right, bottom to top. We want to draw from left to right and top to bottom.
                     for (int y = combineTexture.height; y > 0; y--)
                     {
-                        texture.SetPixel(x + offsetX, texture.height - y - offsetY, combineTexture.GetPixel(x, texture.height - y));
+                        texture.SetPixel(x + offsetX, y + (texture.height - offsetY - combineTexture.height), combineTexture.GetPixel(x, y));
                     }
                 }
                 else
@@ -211,7 +218,7 @@ namespace MA_Texture
         public static Texture MA_Combine(this Texture texture, Texture combineTexture, int offsetX, int offsetY)
         {
             Texture2D texture2D = (Texture2D)MA_TextureUtils.ConvertToReadableTexture(texture);
-            Texture2D combineTexture2D = (Texture2D)MA_TextureUtils.ConvertToReadableTexture(texture);
+            Texture2D combineTexture2D = (Texture2D)MA_TextureUtils.ConvertToReadableTexture(combineTexture);
 
             texture = texture2D.MA_Combine2D(combineTexture2D, offsetX, offsetY);
 

README.md

@@ -18,4 +18,4 @@ Download the UnityPackage here: https://github.com/maxartz15/MA_TextureAtlasser/
 
 [![Github All Releases](https://img.shields.io/github/downloads/maxartz15/MA_TextureAtlasser/total.svg)]()
 
-For more information: https://maxartz15.com/ma_textureatlas/
+For more information: https://maxartz15.com/ma-textureatlasser/