Update MA_TextureAtlasserProInspectorView.cs

Fix 2020.2+ mesh input fields.

Assets/MA_ToolBox/MA_TextureAtlasserPro/README.md

@@ -1,21 +1 @@
-# MA_TextureAtlasser
-Texture atlas creator for Unity
-
-[![Image](https://maxartz15.com/wp-content/uploads/2019/04/MA_TextureAtlas.png)]()
-
-You can combine textures and/or remap the UV’s for the 3D models.
-By having full control over the size and position of the textures that are being placed in the atlas you will never stand for surprises when exporting. This will cost some more time than auto-generating your texture atlases but you know whats going on and which models/textures are getting priority. The tool can also be used to make 2D sprite sheets.
-
-- Combine textures/sprites.
-- Automatically adjusts the UV's of the assigned meshes to match the new texture atlas.
-- Exports meshes as OBJ.
-- Exports texture atlas as PNG.
-- Exports texture atlas as a (sliced) sprite sheet.
-
-[Example video](https://youtu.be/PBRKlopkZP0)
-
-Download the UnityPackage here: https://github.com/maxartz15/MA_TextureAtlasser/releases
-
-[![Github All Releases](https://img.shields.io/github/downloads/maxartz15/MA_TextureAtlasser/total.svg)]()
-
-For more information: https://maxartz15.com/ma-textureatlasser/
+README: https://github.com/maxartz15/MA_TextureAtlasser/blob/master/README.md

Assets/MA_ToolBox/MA_TextureAtlasserPro/Scripts/Data/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 34f8bb860cb13ac49ab6602f84a27dfd
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/MA_ToolBox/MA_TextureAtlasserPro/Scripts/Data/Editor/MA_TextureAtlasserProSettingsEditor.cs

@@ -0,0 +1,30 @@
+#if UNITY_EDITOR
+using UnityEditor;
+using UnityEngine;
+
+namespace MA_TextureAtlasserPro
+{
+    [CustomEditor(typeof(MA_TextureAtlasserProSettings))]
+    [CanEditMultipleObjects]
+    public class MA_TextureAtlasserProSettingsEditor : Editor
+    {
+        GUIContent reloadButton = new GUIContent("Reload", "Update the editor with the changes made.");
+
+        public override void OnInspectorGUI()
+        {
+            GUILayout.BeginVertical();
+            DrawDefaultInspector();
+
+            GUILayout.Space(15);
+
+            if(GUILayout.Button(reloadButton, GUILayout.Height(40), GUILayout.ExpandWidth(true)))
+            {
+                //Update necessary systems.
+                MA_TextureAtlasserProGuiLoader.LoadEditorGui((MA_TextureAtlasserProSettings)this.target);
+            }
+
+            GUILayout.EndVertical();
+        }
+    }
+}
+#endif

Assets/MA_ToolBox/MA_TextureAtlasserPro/Scripts/Data/Editor/MA_TextureAtlasserProSettingsEditor.cs.meta

@@ -1,8 +1,7 @@
 fileFormatVersion: 2
-guid: 64b4bb2ec0d18b142b6a5aa0c8dfb5c1
-timeCreated: 1521838249
-licenseType: Free
+guid: 9850f2b069cfb36498e9601e4884071a
 MonoImporter:
+  externalObjects: {}
   serializedVersion: 2
   defaultReferences: []
   executionOrder: 0

Assets/MA_ToolBox/MA_TextureAtlasserPro/Scripts/Data/MA_ModelGroup.cs

@@ -0,0 +1,15 @@
+#if UNITY_EDITOR
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace MA_TextureAtlasserPro
+{
+    [System.Serializable]
+    public class MA_ModelGroup
+    {
+        public string name = "Model";
+        public List<Mesh> meshes = new List<Mesh>();
+    }
+}
+#endif

Assets/MA_ToolBox/MA_TextureAtlasserPro/Scripts/Data/MA_ModelGroup.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1f74ddc7d8c9c30429ec163b4fc801c4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/MA_ToolBox/MA_TextureAtlasserPro/Scripts/Data/MA_TextureAtlasserProAtlas.cs

@@ -15,7 +15,7 @@ namespace MA_TextureAtlasserPro
 		public List<MA_TextureAtlasserProQuad> textureQuads;
 		public MA_TextureAtlasserProQuad selectedTextureQuad;
 		private Rect editorWorkRect;
-		public bool showTextures = false;
+		public bool showTextures = true;
         public MA_TextureAtlasserProExportSettings exportSettings;
 
 		//Data

Assets/MA_ToolBox/MA_TextureAtlasserPro/Scripts/Data/MA_TextureAtlasserProExportSettings.cs

@@ -1,4 +1,5 @@
-using UnityEngine;
+#if UNITY_EDITOR
+using UnityEngine;
 using System.Collections;
 using MA_Texture;
 using System.Collections.Generic;
@@ -49,9 +50,7 @@ namespace MA_TextureAtlasserPro
     public enum ModelFormat
     {
         None,
-        UnityMeshPrefab,
-        ReplaceMesh,
-        Obj
+        UnityMeshPrefab
     }
 
     public enum TextureFormat
@@ -67,3 +66,4 @@ namespace MA_TextureAtlasserPro
         SpriteSliced
     }
 }
+#endif

Assets/MA_ToolBox/MA_TextureAtlasserPro/Scripts/Data/MA_TextureAtlasserProQuad.cs

@@ -11,22 +11,28 @@ namespace MA_TextureAtlasserPro
 	public class MA_TextureAtlasserProQuad : ScriptableObject
 	{
 		//Editor
+		[HideInInspector]
 		public bool isSelected = false;             //Is this thing selected
 		public Rect rect;                           //The internal rect
+		[HideInInspector]
 		public Rect guiRect;                        //The visual clamped and snapped rect
+		[HideInInspector]
 		public bool debugMode = false;              //Are we debugging, for showing some other things (like handles)
 
 		private bool isDragging = false;            //Are we editing the pos or size
 		private bool isDraggingRectHeigt = false;
+		[HideInInspector]
 		public Rect dragRectHeight;
 		private bool isDraggingRectWidth = false;
+		[HideInInspector]
 		public Rect dragRectWidth;
 		private bool isDraggingRectPos = false;
+		[HideInInspector]
 		public Rect dragRectPos;
 
 		//Data
 		public List<MA_TextureGroup> textureGroups;
-		public List<Mesh> meshes;
+		public List<MA_ModelGroup> modelGroups;
 
 		public void UpdateTextureQuad(Event e, Rect editorViewRect, Rect editorWorkRect, Vector2 zoomCoordsOrigin, bool useEvents, bool showTexture)
 		{

Assets/MA_ToolBox/MA_TextureAtlasserPro/Scripts/Data/MA_TextureAtlasserProSettings.cs

@@ -10,7 +10,10 @@ namespace MA_TextureAtlasserPro
 	[System.Serializable]
 	public class MA_TextureAtlasserProSettings : ScriptableObject
 	{
-		[Header("Hotkeys:")]
+		[Header("GUI (requires reload):")]
+		public MA_TextureAtlasserProGuiSettings editorGuiSettings = new MA_TextureAtlasserProGuiSettings();
+
+		[Header("HotKeys:")]
 		public bool useHotkeys = false;
 		public EventModifiers modifierKey = EventModifiers.Alt;
 		public KeyCode addQuadHotKey = KeyCode.Q;
@@ -20,7 +23,6 @@ namespace MA_TextureAtlasserPro
 		public KeyCode zoomOutHotKey = KeyCode.Minus;
 
 		[Header("Duplication:")]
-		public bool copySelectedQuadData = true;
 		public string duplicatedQuadNamePrefix = "new ";
 
 		[Header("Selection")]
@@ -36,5 +38,19 @@ namespace MA_TextureAtlasserPro
 			return false;
 		}
 	}
+
+	[System.Serializable]
+    public class MA_TextureAtlasserProGuiSettings
+    {
+        public MA_EditorGuiMode editorGuiMode = MA_EditorGuiMode.IconAndText;
+        public bool enableToolTips = true;
+    }
+
+    public enum MA_EditorGuiMode
+    {
+        IconAndText = 0,
+        Icon = 1,
+        Text = 2
+    }
 }
 #endif

Assets/MA_ToolBox/MA_TextureAtlasserPro/Scripts/Editor/Utils/MA_TextureAtlasserProGuiLoader.cs

@@ -0,0 +1,115 @@
+#if UNITY_EDITOR
+using UnityEngine;
+using UnityEditor;
+
+namespace MA_TextureAtlasserPro
+{
+    public static class MA_TextureAtlasserProGuiLoader
+	{
+		private const string LOADICONPATH = "Assets/MA_ToolBox/MA_TextureAtlasserPro/Icons/";
+		
+		public static GUIContent createAtlasGC;
+		public static GUIContent loadAtlasGC;
+		public static GUIContent exportAtlasGC;
+		public static GUIContent createQuadGC;
+		public static GUIContent removeQuadGC;
+		public static GUIContent duplicateQuadGC;
+		public static GUIContent showTexturesOnGC;
+		public static GUIContent showTexturesOffGC;
+		public static GUIContent dragHandleGC;
+		public static GUIContent editGC;
+        public static GUIContent createExportSettingsGC;
+
+		public static void LoadEditorGui(MA_TextureAtlasserProSettings settings)
+		{
+            createAtlasGC = new GUIContent();
+            loadAtlasGC = new GUIContent();
+            exportAtlasGC = new GUIContent();
+            createQuadGC = new GUIContent();
+            removeQuadGC = new GUIContent();
+            duplicateQuadGC = new GUIContent();
+            showTexturesOnGC = new GUIContent();
+            showTexturesOffGC = new GUIContent();
+            dragHandleGC = new GUIContent();
+            editGC = new GUIContent();
+            createExportSettingsGC = new GUIContent();
+
+            switch (settings.editorGuiSettings.editorGuiMode)
+			{
+				case MA_EditorGuiMode.IconAndText:
+                    LoadIcons();
+                    LoadText();
+                    break;
+				case MA_EditorGuiMode.Icon:
+                    LoadIcons();
+					break;
+				case MA_EditorGuiMode.Text:
+                    LoadText();
+					break;
+				default:
+                    LoadIcons();
+					break;
+			}
+
+            if(settings.editorGuiSettings.enableToolTips)
+            {
+                LoadToolTips(settings);
+            }
+
+            //Exceptions.
+            dragHandleGC.image = (Texture)EditorGUIUtility.Load(LOADICONPATH + "dragHandleIcon" + ".png");
+            dragHandleGC.text = "";
+            editGC.image = (Texture)EditorGUIUtility.Load(LOADICONPATH + "editIcon" + ".png");
+            editGC.text = "";
+        }
+
+		private static void LoadIcons()
+		{
+			createAtlasGC.image = (Texture)EditorGUIUtility.Load(LOADICONPATH + "createAtlasIcon" + ".png");
+            loadAtlasGC.image = (Texture)EditorGUIUtility.Load(LOADICONPATH + "loadAtlasIcon" + ".png");
+            exportAtlasGC.image = (Texture)EditorGUIUtility.Load(LOADICONPATH + "exportAtlasIcon" + ".png");
+            createQuadGC.image = (Texture)EditorGUIUtility.Load(LOADICONPATH + "createQuadIcon" + ".png");
+            removeQuadGC.image = (Texture)EditorGUIUtility.Load(LOADICONPATH + "removeQuadIcon" + ".png");
+            duplicateQuadGC.image = (Texture)EditorGUIUtility.Load(LOADICONPATH + "duplicateQuadIcon" + ".png");
+            showTexturesOnGC.image = (Texture)EditorGUIUtility.Load(LOADICONPATH + "showTexturesOnIcon" + ".png");
+            showTexturesOffGC.image = (Texture)EditorGUIUtility.Load(LOADICONPATH + "showTexturesOffIcon" + ".png");
+            createExportSettingsGC.image = (Texture)EditorGUIUtility.Load(LOADICONPATH + "createAtlasIcon" + ".png");
+        }
+
+        private static void LoadText()
+        {
+            createAtlasGC.text = "Create Atlas";
+            loadAtlasGC.text = "Load Atlas";
+            exportAtlasGC.text = "Export Atlas";
+            createQuadGC.text = "Create Quad";
+            removeQuadGC.text = "Remove Quad";
+            duplicateQuadGC.text = "Duplicate Quad";
+            showTexturesOnGC.text = "Hide Textures";
+            showTexturesOffGC.text = "Show Textures";
+            createExportSettingsGC.text = "Create Export Settings";
+        }
+        
+        private static void LoadToolTips(MA_TextureAtlasserProSettings settings)
+        {
+            createAtlasGC.tooltip = "Opens the create atlas window.";
+            loadAtlasGC.tooltip = "Load an existing atlas.";
+            exportAtlasGC.tooltip = "Opens the export window.";
+            if (settings.useHotkeys) 
+            {
+                createQuadGC.tooltip = string.Format("({0}+{1}), Creates a new quad.", settings.modifierKey, settings.addQuadHotKey);
+                removeQuadGC.tooltip = string.Format("({0}+{1}), Removes the selected quad.", settings.modifierKey, settings.removeQuadHotKey);
+                duplicateQuadGC.tooltip = string.Format("({0}+{1}), Duplicates the selected quad.", settings.modifierKey, settings.duplicateHotKey);            
+            }
+            else
+            {
+                createQuadGC.tooltip = "Creates a new quad.";
+                removeQuadGC.tooltip = "Removes the selected quad.";
+                duplicateQuadGC.tooltip = "Duplicates the selected quad.";
+            }
+            showTexturesOnGC.tooltip = "Hides the preview of the first texture on the quads.";
+            showTexturesOffGC.tooltip = "Shows a preview of the first texture on the quads.";
+            createExportSettingsGC.tooltip = "Opens the create export settings window.";
+        }
+	}
+}
+#endif

Assets/MA_ToolBox/MA_TextureAtlasserPro/Scripts/Editor/Utils/MA_TextureAtlasserProGuiLoader.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1547329de58c58d4eb6b272309da0c85
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/MA_ToolBox/MA_TextureAtlasserPro/Scripts/Editor/Utils/MA_TextureAtlasserProIcons.cs

@@ -1,37 +0,0 @@
-#if UNITY_EDITOR
-using UnityEngine;
-using UnityEditor;
-
-namespace MA_TextureAtlasserPro
-{
-    public static class MA_TextureAtlasserProIcons
-	{
-		private const string LOADICONPATH = "Assets/MA_ToolBox/MA_TextureAtlasserPro/Icons/";
-		
-		public static GUIContent createAtlasIcon;
-		public static GUIContent loadAtlasIcon;
-		public static GUIContent exportAtlasIcon;
-		public static GUIContent createQuadIcon;
-		public static GUIContent removeQuadIcon;
-		public static GUIContent duplicateQuadIcon;
-		public static GUIContent showTexturesOnIcon;
-		public static GUIContent showTexturesOffIcon;
-		public static GUIContent dragHandleIcon;
-		public static GUIContent editIcon;
-
-		public static void LoadIcons()
-		{
-			createAtlasIcon = new GUIContent("", (Texture)EditorGUIUtility.Load(LOADICONPATH + "createAtlasIcon" + ".png"));
-			loadAtlasIcon = new GUIContent("", (Texture)EditorGUIUtility.Load(LOADICONPATH + "loadAtlasIcon" + ".png"));
-			exportAtlasIcon = new GUIContent("", (Texture)EditorGUIUtility.Load(LOADICONPATH + "exportAtlasIcon" + ".png"));
-			createQuadIcon = new GUIContent("", (Texture)EditorGUIUtility.Load(LOADICONPATH + "createQuadIcon" + ".png"));
-			removeQuadIcon = new GUIContent("", (Texture)EditorGUIUtility.Load(LOADICONPATH + "removeQuadIcon" + ".png"));
-			duplicateQuadIcon = new GUIContent("", (Texture)EditorGUIUtility.Load(LOADICONPATH + "duplicateQuadIcon" + ".png"));
-			showTexturesOnIcon = new GUIContent("", (Texture)EditorGUIUtility.Load(LOADICONPATH + "showTexturesOnIcon" + ".png"));
-			showTexturesOffIcon = new GUIContent("", (Texture)EditorGUIUtility.Load(LOADICONPATH + "showTexturesOffIcon" + ".png"));
-			dragHandleIcon = new GUIContent("", (Texture)EditorGUIUtility.Load(LOADICONPATH + "dragHandleIcon" + ".png"));
-			editIcon = new GUIContent("", (Texture)EditorGUIUtility.Load(LOADICONPATH + "editIcon" + ".png"));
-		}
-	}
-}
-#endif

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

@@ -5,11 +5,11 @@ using UnityEngine;
 using UnityEditor;
 using MA_Mesh;
 using MA_Texture;
+using MA_Toolbox.Utils.Editor;
+using MA_Toolbox.Utils;
 
 namespace MA_TextureAtlasserPro
 {
-
-
     public static class MA_TextureAtlasserProUtils
     {
         public const string TEXTURE_ATLASSER_PATH = "Assets/MA_ToolBox/MA_TextureAtlasserPro/";
@@ -26,7 +26,7 @@ namespace MA_TextureAtlasserPro
         {
             MA_TextureAtlasserProSettings _settings = ScriptableObject.CreateInstance<MA_TextureAtlasserProSettings>();
 
-			if(_settings != null)
+            if (_settings != null)
             {
                 CreateFolder(SETTINGS_ASSET_PATH);
                 AssetDatabase.CreateAsset(_settings, SETTINGS_ASSET_PATH + "MA_TextureAtlasserProSettings.asset");
@@ -92,7 +92,7 @@ namespace MA_TextureAtlasserPro
         {
             MA_TextureAtlasserProAtlas _atlas = ScriptableObject.CreateInstance<MA_TextureAtlasserProAtlas>();
 
-			if(_atlas != null)
+            if (_atlas != null)
             {
                 _atlas.CreateAtlas(name, size);
                 MA_CheckTextureAtlas(_atlas);
@@ -115,22 +115,22 @@ namespace MA_TextureAtlasserPro
             MA_TextureAtlasserProAtlas _atlas = null;
             string absPath = EditorUtility.OpenFilePanel("Select Texture Atlas", LOAD_ASSET_PATH, "");
 
-			if(absPath.StartsWith(Application.dataPath))
+            if (absPath.StartsWith(Application.dataPath))
             {
                 string relPath = absPath.Substring(Application.dataPath.Length - "Assets".Length);
                 _atlas = AssetDatabase.LoadAssetAtPath(relPath, typeof(MA_TextureAtlasserProAtlas)) as MA_TextureAtlasserProAtlas;
 
                 MA_CheckTextureAtlas(_atlas);
 
-				if(_atlas)
+                if (_atlas)
                 {
                     EditorPrefs.SetString("AtlasPath", null);
                 }
             }
 
-			if(_atlas != null)
+            if (_atlas != null)
             {
-				if(_atlas.selectedTextureQuad != null)
+                if (_atlas.selectedTextureQuad != null)
                 {
                     _atlas.selectedTextureQuad.isSelected = false;
                 }
@@ -142,7 +142,7 @@ namespace MA_TextureAtlasserPro
 
         public static void MA_CheckTextureAtlas(MA_TextureAtlasserProAtlas atlas)
         {
-			if(atlas.textureGroupRegistration == null)
+            if (atlas.textureGroupRegistration == null)
             {
                 atlas.textureGroupRegistration = new List<MA_TextureGroupRegistration>();
 
@@ -154,7 +154,7 @@ namespace MA_TextureAtlasserPro
                 atlas.textureGroupRegistration.Add(groupRegistration);
             }
 
-			if(atlas.textureQuads == null)
+            if (atlas.textureQuads == null)
             {
                 atlas.textureQuads = new List<MA_TextureAtlasserProQuad>();
             }
@@ -163,14 +163,14 @@ namespace MA_TextureAtlasserPro
                 bool _sameCount = true;
                 foreach (MA_TextureAtlasserProQuad q in atlas.textureQuads)
                 {
-					if(q.textureGroups.Count != atlas.textureGroupRegistration.Count)
+                    if (q.textureGroups.Count != atlas.textureGroupRegistration.Count)
                     {
                         _sameCount = false;
                         Debug.LogWarning("TextureAtlasser: " + q.name + " doesn't have the right amount of texture groups!");
                     }
                 }
 
-				if(_sameCount)
+                if (_sameCount)
                 {
                     foreach (MA_TextureAtlasserProQuad q in atlas.textureQuads)
                     {
@@ -178,7 +178,7 @@ namespace MA_TextureAtlasserPro
                         {
                             for (int j = 0; j < atlas.textureGroupRegistration.Count; j++)
                             {
-								if(atlas.textureQuads[i].textureGroups[j].name != atlas.textureGroupRegistration[j].name)
+                                if (atlas.textureQuads[i].textureGroups[j].name != atlas.textureGroupRegistration[j].name)
                                 {
                                     Debug.LogWarning("TextureAtlasser: " + q.name + " doesn't have the right texture group name!");
                                 }
@@ -188,7 +188,7 @@ namespace MA_TextureAtlasserPro
                 }
             }
 
-            if(atlas.exportSettings == null)
+            if (atlas.exportSettings == null)
             {
                 atlas.exportSettings = LoadExportSettings();
             }
@@ -196,10 +196,10 @@ namespace MA_TextureAtlasserPro
 
         public static MA_TextureAtlasserProQuad CreateTextureQuad(MA_TextureAtlasserProAtlas atlas, string name, Rect rect, bool focus = true)
         {
-			if(atlas != null)
+            if (atlas != null)
             {
                 //Create new list if we haven't one already
-				if(atlas.textureQuads == null)
+                if (atlas.textureQuads == null)
                 {
                     atlas.textureQuads = new List<MA_TextureAtlasserProQuad>();
                 }
@@ -208,7 +208,7 @@ namespace MA_TextureAtlasserPro
                 MA_TextureAtlasserProQuad _quad = ScriptableObject.CreateInstance<MA_TextureAtlasserProQuad>();
 
                 //Add quad to asset
-				if(_quad != null)
+                if (_quad != null)
                 {
                     //Set quad settings
                     _quad.name = name;
@@ -222,7 +222,7 @@ namespace MA_TextureAtlasserPro
                     AssetDatabase.SaveAssets();
                     AssetDatabase.Refresh();
 
-					if(focus)
+                    if (focus)
                     {
                         atlas.selectedTextureQuad = atlas.textureQuads[atlas.textureQuads.Count - 1];
                     }
@@ -244,7 +244,7 @@ namespace MA_TextureAtlasserPro
 
         public static void RemoveTextureQuad(MA_TextureAtlasserProAtlas atlas, bool focus = true)
         {
-			if(atlas != null && atlas.selectedTextureQuad != null)
+            if (atlas != null && atlas.selectedTextureQuad != null)
             {
                 int _index = atlas.textureQuads.IndexOf(atlas.selectedTextureQuad);
 
@@ -261,27 +261,18 @@ namespace MA_TextureAtlasserPro
             }
         }
 
-		public static void DuplicateTextureQuad(MA_TextureAtlasserProAtlas atlas, bool focus = true, bool copyData = false, string namePrefix = "new ")
+        public static void DuplicateTextureQuad(MA_TextureAtlasserProAtlas atlas, bool focus = true, string namePrefix = "new ")
         {
-			if(atlas != null && atlas.selectedTextureQuad != null)
+            if (atlas != null && atlas.selectedTextureQuad != null)
             {
-				MA_TextureAtlasserProQuad q = CreateTextureQuad(atlas, namePrefix + atlas.selectedTextureQuad.name, atlas.selectedTextureQuad.rect, false);
+                //MA_TextureAtlasserProQuad q = CreateTextureQuad(atlas, namePrefix + atlas.selectedTextureQuad.name, atlas.selectedTextureQuad.rect, false);
+                MA_TextureAtlasserProQuad q = Object.Instantiate(atlas.selectedTextureQuad);
+                q.name = string.Format("{0}{1}", namePrefix, atlas.selectedTextureQuad.name);
+                atlas.textureQuads.Add(q);
 
-				if (copyData)
-				{
-					q.meshes = new List<Mesh>();
-					for (int i = 0; i < atlas.selectedTextureQuad.meshes.Count; i++)
-					{
-						q.meshes.Add(atlas.selectedTextureQuad.meshes[i]);
-					}
+                AssetDatabase.AddObjectToAsset(q, atlas);
 
-					for (int i = 0; i < atlas.selectedTextureQuad.textureGroups.Count; i++)
-					{
-						q.textureGroups[i].texture = atlas.selectedTextureQuad.textureGroups[i].texture;
-					}
-				}
-
-				if(focus)
+                if (focus)
                 {
                     atlas.selectedTextureQuad = q;
                 }
@@ -293,7 +284,7 @@ namespace MA_TextureAtlasserPro
 
         public static void SetTextureGroups(MA_TextureAtlasserProAtlas atlas, MA_TextureAtlasserProQuad quad)
         {
-			if(quad.textureGroups == null)
+            if (quad.textureGroups == null)
             {
                 quad.textureGroups = new List<MA_TextureGroup>();
             }
@@ -339,7 +330,7 @@ namespace MA_TextureAtlasserPro
 
         public static void CloseWindow(MA_TextureAtlasserProWindow curWindow)
         {
-			if(curWindow == null)
+            if (curWindow == null)
             {
                 Debug.LogError("Closing window Failed: curWindow == null");
             }
@@ -367,6 +358,12 @@ namespace MA_TextureAtlasserPro
             if (!AssetDatabase.IsValidFolder(folderPath))
             {
                 string parentPath = folderPath.Substring(0, folderPath.LastIndexOf('/'));
+
+                if(!AssetDatabase.IsValidFolder(parentPath))
+                {
+                    CreateFolder(parentPath);
+                }
+
                 string folderName = folderPath.Substring(folderPath.LastIndexOf('/') + 1);
 
                 AssetDatabase.CreateFolder(parentPath, folderName);
@@ -389,19 +386,16 @@ namespace MA_TextureAtlasserPro
         }
 
         #region Export
-        public static string[] ExportAtlasModels(MA_TextureAtlasserProAtlas atlas, ModelExportSettings modelExportSettings, string material = null, string savePath = EXPORT_ASSET_PATH)
+        public static string[] ExportAtlasModels(MA_TextureAtlasserProAtlas atlas, ModelExportSettings modelExportSettings, string materialPath = null, string savePath = EXPORT_ASSET_PATH)
         {
-            switch(modelExportSettings.modelFormat)
+            switch (modelExportSettings.modelFormat)
             {
                 case ModelFormat.None:
                     break;
-                case ModelFormat.ReplaceMesh:
-                    ReplaceAtlasMesh(atlas, modelExportSettings, savePath: savePath);
-                    break;
                 case ModelFormat.UnityMeshPrefab:
-                    return ExportAtlasUnityMeshPrefab(atlas, modelExportSettings, material: material, savePath: savePath);
-                case ModelFormat.Obj:
-                    return ExportAtlasObj(atlas, modelExportSettings, savePath: savePath);
+                    return ExportAtlasUnityMeshPrefab(atlas, modelExportSettings, materialPath: materialPath, savePath: savePath);
+                //case ModelFormat.Obj:
+                //    return ExportAtlasObj(atlas, modelExportSettings, savePath: savePath);
                 default:
                     break;
             }
@@ -409,102 +403,78 @@ namespace MA_TextureAtlasserPro
             return null;
         }
 
-        private static void ReplaceAtlasMesh(MA_TextureAtlasserProAtlas atlas, ModelExportSettings modelExportSettings, string savePath = EXPORT_ASSET_PATH)
+        private static string[] ExportAtlasUnityMeshPrefab(MA_TextureAtlasserProAtlas atlas, ModelExportSettings modelExportSettings, string materialPath = null, string savePath = EXPORT_ASSET_PATH)
         {
             if (atlas == null || atlas.textureQuads == null)
-                return;
-
-            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();
-        }
-
-        private static string[] ExportAtlasUnityMeshPrefab(MA_TextureAtlasserProAtlas atlas, ModelExportSettings modelExportSettings, string material = null, string savePath = EXPORT_ASSET_PATH)
-        {
-            if (atlas == null || atlas.textureQuads == null)
                 return null;
+            }
 
             List<string> assetPaths = new List<string>();
 
-            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 meshName = string.IsNullOrEmpty(quad.name) ? "" : quad.name + "-";
-                            meshName += quad.meshes[m].name;
-                            int n = m + 1;
-                            meshName += "_" + n.ToString("#000");
-
-                            string asset = MA_MeshUtils.MA_SaveMeshPrefab(newMesh, meshName, savePath, material: material);
-                            assetPaths.Add(asset);
-                        }
-                    }
-                }
-            }
-
-            return assetPaths.ToArray();
-        }
-
-		private static string[] ExportAtlasObj(MA_TextureAtlasserProAtlas atlas, ModelExportSettings modelExportSettings, string savePath = EXPORT_ASSET_PATH)
-		{
-            if (atlas == null || atlas.textureQuads == null)
-                return null;
-
-            List<string> assetPaths = new List<string>();
+            //Directories.
+            string savePathPrefab = savePath + atlas.name + "/";
+            string savePathMeshes = savePathPrefab + "Meshes/";
+            CreateFolder(savePathPrefab);
+            CreateFolder(savePathMeshes);
 
             foreach (MA_TextureAtlasserProQuad quad in atlas.textureQuads)
             {
-                //Export Mesh
-                if (quad.meshes != null)
+                foreach (MA_ModelGroup mg in quad.modelGroups)
                 {
-                    for (int m = 0; m < quad.meshes.Count; m++)
+                    //Validate name.
+                    if (string.IsNullOrEmpty(mg.name) || string.IsNullOrWhiteSpace(mg.name))
                     {
-                        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 meshName = string.IsNullOrEmpty(quad.name) ? "" : quad.name + "-";
-                            meshName += quad.meshes[m].name;
-                            int n = m + 1;
-                            meshName += "_" + n.ToString("#000");
+                        mg.name = MA_StringUtils.RandomAlphabetString(6);
+                        Debug.LogWarning("No valid model name assigned!");
+                    }
 
-                            string asset = MA_MeshUtils.MeshToFile(newMesh, meshName, savePath);
-                            assetPaths.Add(asset);
+                    //Create new prefab asset.
+                    string newPrefabPath = MA_PrefabUtils.CreatePrefab(mg.name, savePathPrefab);
+                    GameObject newPrefab = AssetDatabase.LoadAssetAtPath<GameObject>(newPrefabPath);
+
+                    foreach (Mesh m in mg.meshes)
+                    {
+                        if(m != null)
+                        {
+                            //Validate name.
+                            if (string.IsNullOrEmpty(m.name) || string.IsNullOrWhiteSpace(m.name))
+                            {
+                                m.name = MA_StringUtils.RandomAlphabetString(6);
+                                Debug.LogWarning("No valid mesh name assigned!");
+                            }
+
+                            //Create new mesh.
+                            //Duplicate it from the current one.
+                            Mesh newMesh = MA_MeshUtils.MA_DuplicateMesh(m);
+                            //Remap UV's.
+                            newMesh = MA_MeshUtils.MA_UVReMap(newMesh, atlas.textureAtlasSize, quad.guiRect, modelExportSettings.uvChannel, modelExportSettings.uvFlipY, modelExportSettings.uvWrap);
+                            //Set name.
+                            newMesh.name = string.Format("{0}_{1}", mg.name, m.name);
+                            //Save mesh.
+                            string savedMeshPath = MA_MeshUtils.MA_SaveMeshAsset(newMesh, savePathMeshes);
+
+                            //Load mesh.
+                            Mesh savedMesh = AssetDatabase.LoadAssetAtPath<Mesh>(savedMeshPath);
+                            //Load material.
+                            Material savedMaterial = AssetDatabase.LoadAssetAtPath<Material>(materialPath);
+
+                            //Create gameObject.
+                            GameObject newGameObject = new GameObject(m.name);
+                            //Add mesh filter.
+                            MeshFilter mf = newGameObject.AddComponent<MeshFilter>();
+                            mf.mesh = savedMesh;
+                            //Add mesh renderer.
+                            MeshRenderer mr = newGameObject.AddComponent<MeshRenderer>();
+                            mr.material = savedMaterial;
+
+                            //Add to parent gameObject (prefab).
+                            MA_PrefabUtils.AddChild(newPrefab, newGameObject);
+                            Object.DestroyImmediate(newGameObject);
                         }
                     }
+
+                    assetPaths.Add(newPrefabPath);
                 }
             }
 
@@ -529,10 +499,16 @@ namespace MA_TextureAtlasserPro
         private static string[] ExportAtlasPNG(MA_TextureAtlasserProAtlas atlas, TextureExportSettings textureExportSettings, string savePath = EXPORT_ASSET_PATH, string tempPath = TEMP_ASSET_PATH)
         {
             if (atlas == null || atlas.textureQuads == null || atlas.textureGroupRegistration == null)
+            {
                 return null;
+            }
 
             string[] assetPaths = new string[atlas.textureGroupRegistration.Count];
 
+            //Directories.
+            string savePathTextures = savePath + atlas.name + "/Textures/";
+            CreateFolder(savePathTextures);
+
             //Create temp folder
             CreateFolder(tempPath);
 
@@ -583,25 +559,24 @@ namespace MA_TextureAtlasserPro
                 }
 
                 //Save it
-				newTexture.MA_Save2D(newTexture.name, savePath);
-
-                assetPaths[i] = (savePath + newTexture.name + '.' + textureExportSettings.textureFormat.ToString());
+                newTexture.MA_Save2D(newTexture.name, savePathTextures);
+                assetPaths[i] = (savePathTextures + newTexture.name + '.' + textureExportSettings.textureFormat.ToString());
 
                 //Set settings.
                 switch (textureExportSettings.textureType)
                 {
                     case TextureType.Default:
                         {
-                            TextureImporter textureImporter = (TextureImporter)AssetImporter.GetAtPath(savePath + newTexture.name + '.' + textureExportSettings.textureFormat.ToString());
+                            TextureImporter textureImporter = (TextureImporter)AssetImporter.GetAtPath(savePathTextures + newTexture.name + '.' + textureExportSettings.textureFormat.ToString());
                             textureImporter.textureType = TextureImporterType.Default;
                             textureImporter.SaveAndReimport();
                         }
                         break;
                     case TextureType.Sprite:
-                        SetAtlasSpriteSettings(atlas, textureExportSettings, savePath);
+                        SetAtlasSpriteSettings(atlas, textureExportSettings, savePathTextures);
                         break;
                     case TextureType.SpriteSliced:
-                        SetAtlasSpriteSettings(atlas, textureExportSettings, savePath);
+                        SetAtlasSpriteSettings(atlas, textureExportSettings, savePathTextures);
                         break;
                     default:
                         break;
@@ -617,7 +592,7 @@ namespace MA_TextureAtlasserPro
             return assetPaths;
         }
 
-		private static void SetAtlasSpriteSettings(MA_TextureAtlasserProAtlas atlas, TextureExportSettings textureExportSettings, string savePath = EXPORT_ASSET_PATH)
+        private static void SetAtlasSpriteSettings(MA_TextureAtlasserProAtlas atlas, TextureExportSettings textureExportSettings, string savePath)
         {
             //Foreach texture group
             for (int i = 0; i < atlas.textureGroupRegistration.Count; i++)
@@ -664,9 +639,13 @@ namespace MA_TextureAtlasserPro
         public static string ExportAtlasMaterial(MA_TextureAtlasserProAtlas atlas, MaterialExportSettings materialExportSettings, string[] textures = null, string savePath = EXPORT_ASSET_PATH)
         {
             if (atlas == null || atlas.textureQuads == null || atlas.textureGroupRegistration == null)
+            {
                 return null;
+            }
 
-            string assetPath = "";
+            //Directories.
+            string savePathMaterial = savePath + atlas.name + "/Materials/";
+            CreateFolder(savePathMaterial);
 
             Shader shader = materialExportSettings.shader;
             if (shader)
@@ -676,7 +655,7 @@ namespace MA_TextureAtlasserPro
                     name = atlas.name
                 };
 
-                if(textures != null)
+                if (textures != null)
                 {
                     for (int i = 0; i < (int)Mathf.Min(materialExportSettings.shaderPropertyNames.Count, textures.Length); i++)
                     {
@@ -688,15 +667,17 @@ namespace MA_TextureAtlasserPro
                     }
                 }
 
-                assetPath = savePath + material.name + ".mat";
+                string assetPath = savePathMaterial + material.name + ".mat";
 
                 //Save material
                 AssetDatabase.CreateAsset(material, assetPath);
                 AssetDatabase.Refresh();
-            }
 
                 return assetPath;
             }
+
+            return null;
+        }
         #endregion
     }
 }

Assets/MA_ToolBox/MA_TextureAtlasserPro/Scripts/Editor/Views/MA_TextureAtlasserProInspectorView.cs

@@ -4,18 +4,16 @@ using System.Collections.Generic;
 using UnityEngine;
 using UnityEditor;
 using MA_Editor;
+using MA_Toolbox.Utils;
 
 namespace MA_TextureAtlasserPro
 {
     public class MA_TextureAtlasserProInspectorView : MA_TextureAtlasserProViewBase
     {
         private MA_TextureAtlasserProQuad lastSelectedQuad;
-
         private bool isEditing = false;
-
         private GUIStyle labelStyle = new GUIStyle(GUI.skin.label);
-
-        bool useAddMeshButton = false;
+        private Vector2 scrollPos = Vector2.zero;
         
         public MA_TextureAtlasserProInspectorView(MA_TextureAtlasserProWindow currentEditorWindow, string title) : base(currentEditorWindow, title)
         {
@@ -27,24 +25,11 @@ namespace MA_TextureAtlasserPro
             //Update base derived class
             base.UpdateView(e, editorViewRect);
 
-			if(isLoaded)
+            if (isLoaded)
             {
                 //Draw inspector
-				if(curWindow.textureAtlas != null && curWindow.textureAtlas.selectedTextureQuad != null)
+                if (curWindow.textureAtlas != null && curWindow.textureAtlas.selectedTextureQuad != null)
                 {
-                    //Change layout during layout event to prevent gui errors
-                    if (e.type == EventType.Layout)
-                    {
-                        if (curWindow.textureAtlas.selectedTextureQuad.meshes != null && curWindow.textureAtlas.selectedTextureQuad.meshes.Count == 0)
-                        {
-                            useAddMeshButton = true;
-                        }
-                        else
-                        {
-                            useAddMeshButton = false;
-                        }
-                    }
-
                     //Deselect GUI elements when we are focusing on a new quad
                     if (lastSelectedQuad != curWindow.textureAtlas.selectedTextureQuad)
                     {
@@ -53,6 +38,10 @@ namespace MA_TextureAtlasserPro
                     }
 
                     GUILayout.BeginArea(editorViewRect, EditorStyles.helpBox);
+                    using (var scrollViewScope = new EditorGUILayout.ScrollViewScope(scrollPos, false, false))
+                    {
+                        scrollPos = scrollViewScope.scrollPosition;
+
                         GUILayout.BeginVertical(GUILayout.ExpandWidth(true));
 
                         GUILayout.Label("Quad Name");
@@ -63,21 +52,21 @@ namespace MA_TextureAtlasserPro
                         //Textures
                         GUILayout.BeginHorizontal();
                         GUILayout.Label("Textures", GUILayout.ExpandWidth(true));
-					if(GUILayout.Button(MA_TextureAtlasserProIcons.editIcon, EditorStyles.miniButton, GUILayout.Width(36), GUILayout.Height(15)))
+                        if (GUILayout.Button(MA_TextureAtlasserProGuiLoader.editGC, EditorStyles.miniButton, GUILayout.Width(36), GUILayout.Height(15)))
                         {
                             isEditing = !isEditing;
                         }
                         GUILayout.EndHorizontal();
-					if(curWindow.textureAtlas.textureGroupRegistration == null || curWindow.textureAtlas.textureGroupRegistration.Count == 0)
+                        if (curWindow.textureAtlas.textureGroupRegistration == null || curWindow.textureAtlas.textureGroupRegistration.Count == 0)
                         {
-						if(GUILayout.Button("+", EditorStyles.miniButton, GUILayout.ExpandWidth(true)))
+                            if (GUILayout.Button("+", EditorStyles.miniButton, GUILayout.ExpandWidth(true)))
                             {
                                 MA_TextureAtlasserProUtils.CreateTextureGroup(curWindow.textureAtlas, "New TextureGroup");
                             }
                         }
                         for (int i = 0; i < curWindow.textureAtlas.textureGroupRegistration.Count; i++)
                         {
-						if(isEditing)
+                            if (isEditing)
                             {
                                 curWindow.textureAtlas.textureGroupRegistration[i].name = curWindow.textureAtlas.selectedTextureQuad.textureGroups[i].name = EditorGUILayout.TextField(curWindow.textureAtlas.textureGroupRegistration[i].name);
                             }
@@ -87,11 +76,11 @@ namespace MA_TextureAtlasserPro
                             }
                             GUILayout.BeginHorizontal();
                             curWindow.textureAtlas.selectedTextureQuad.textureGroups[i].texture = (Texture)EditorGUILayout.ObjectField(curWindow.textureAtlas.selectedTextureQuad.textureGroups[i].texture, typeof(Texture), false);
-						if(isEditing && GUILayout.Button("-", EditorStyles.miniButtonLeft, GUILayout.ExpandWidth(false)))
+                            if (isEditing && GUILayout.Button("-", EditorStyles.miniButtonLeft, GUILayout.ExpandWidth(false)))
                             {
                                 MA_TextureAtlasserProUtils.RemoveTextureGroup(curWindow.textureAtlas, i);
                             }
-						if(isEditing && GUILayout.Button("+", EditorStyles.miniButtonRight, GUILayout.ExpandWidth(false)))
+                            if (isEditing && GUILayout.Button("+", EditorStyles.miniButtonRight, GUILayout.ExpandWidth(false)))
                             {
                                 MA_TextureAtlasserProUtils.CreateTextureGroup(curWindow.textureAtlas, "New TextureGroup");
                             }
@@ -100,39 +89,75 @@ namespace MA_TextureAtlasserPro
 
                         GUILayout.Space(MA_TextureAtlasserProUtils.VIEW_OFFSET / 2);
 
-					//Meshes	
-					GUILayout.Label("Meshes");
-                    if (useAddMeshButton)
+                        //Models
+                        GUILayout.Label("Models");
+
+                        SerializedObject serializedObject = new SerializedObject(curWindow.textureAtlas.selectedTextureQuad);
+                        serializedObject.Update();
+
+
+                        if (curWindow.textureAtlas.selectedTextureQuad.modelGroups != null)
                         {
-                        if (GUILayout.Button("+", EditorStyles.miniButton, GUILayout.ExpandWidth(true)))
+                            SerializedProperty modelGroupsSP = serializedObject.FindProperty("modelGroups");
+
+                            for (int i = 0; i < curWindow.textureAtlas.selectedTextureQuad.modelGroups.Count; i++)
                             {
-                            curWindow.textureAtlas.selectedTextureQuad.meshes.Add(null);
+                                using (new GUILayout.VerticalScope(EditorStyles.helpBox))
+                                {
+                                    using (new GUILayout.HorizontalScope())
+                                    {
+                                        curWindow.textureAtlas.selectedTextureQuad.modelGroups[i].name = EditorGUILayout.TextField(curWindow.textureAtlas.selectedTextureQuad.modelGroups[i].name);
+                                        if (GUILayout.Button("-", EditorStyles.miniButton, GUILayout.ExpandWidth(true)))
+                                        {
+                                            curWindow.textureAtlas.selectedTextureQuad.modelGroups.RemoveAt(i);
+                                            break;
                                         }
                                     }
 
-                    if (curWindow.textureAtlas.selectedTextureQuad.meshes != null)
+                                    SerializedProperty meshesSP = modelGroupsSP.GetArrayElementAtIndex(i).FindPropertyRelative("meshes");
+#if UNITY_2020_2_OR_NEWER
+                                    meshesSP.isExpanded = EditorGUILayout.Foldout(meshesSP.isExpanded, "Meshes", true);
+#else
+								EditorGUILayout.PropertyField(meshesSP, false, GUILayout.ExpandWidth(false), GUILayout.MaxWidth(editorViewRect.width * 0.5f));
+#endif
+                                    if (meshesSP.isExpanded)
                                     {
-						for (int i = 0; i < curWindow.textureAtlas.selectedTextureQuad.meshes.Count; i++)
+                                        for (int j = 0; j < curWindow.textureAtlas.selectedTextureQuad.modelGroups[i].meshes.Count; j++)
                                         {
-							GUILayout.BeginHorizontal();
-							curWindow.textureAtlas.selectedTextureQuad.meshes[i] = (Mesh)EditorGUILayout.ObjectField(curWindow.textureAtlas.selectedTextureQuad.meshes[i], typeof(Mesh), false);
-							if(GUILayout.Button("-", EditorStyles.miniButtonLeft, GUILayout.ExpandWidth(false)))
+                                            using (new GUILayout.HorizontalScope())
                                             {
-								curWindow.textureAtlas.selectedTextureQuad.meshes.RemoveAt(i);
+                                                curWindow.textureAtlas.selectedTextureQuad.modelGroups[i].meshes[j] = (Mesh)EditorGUILayout.ObjectField(curWindow.textureAtlas.selectedTextureQuad.modelGroups[i].meshes[j], typeof(Mesh), false);
+                                                if (GUILayout.Button("-", EditorStyles.miniButton, GUILayout.ExpandWidth(true)))
+                                                {
+                                                    curWindow.textureAtlas.selectedTextureQuad.modelGroups[i].meshes.RemoveAt(j);
+                                                    break;
                                                 }
-							if(GUILayout.Button("+", EditorStyles.miniButtonRight, GUILayout.ExpandWidth(false)))
-							{
-								curWindow.textureAtlas.selectedTextureQuad.meshes.Insert(i + 1, null);
                                             }
-							GUILayout.EndHorizontal();
+                                        }
+                                    }
+
+                                    if (GUILayout.Button("+", EditorStyles.miniButton))
+                                    {
+                                        curWindow.textureAtlas.selectedTextureQuad.modelGroups[i].meshes.Add(null);
+                                    }
+                                }
+                            }
+
+                            if (GUILayout.Button("+", EditorStyles.miniButton, GUILayout.ExpandWidth(true)))
+                            {
+                                curWindow.textureAtlas.selectedTextureQuad.modelGroups.Add(new MA_ModelGroup() { name = MA_StringUtils.RandomAlphabetString(6) });
                             }
                         }
                         else
                         {
-						curWindow.textureAtlas.selectedTextureQuad.meshes = new List<Mesh>();
+                            curWindow.textureAtlas.selectedTextureQuad.modelGroups = new List<MA_ModelGroup>();
                         }
 
+                        serializedObject.ApplyModifiedProperties();
 
+                        GUILayout.Space(MA_TextureAtlasserProUtils.VIEW_OFFSET / 2);
+
+                        //x, y, w, h.
                         GUILayout.FlexibleSpace();
                         if (!MA_TextureAtlasserProUtils.IsPowerOfTwo((int)curWindow.textureAtlas.selectedTextureQuad.guiRect.width) || !MA_TextureAtlasserProUtils.IsPowerOfTwo((int)curWindow.textureAtlas.selectedTextureQuad.guiRect.height))
                         {
@@ -140,18 +165,18 @@ namespace MA_TextureAtlasserPro
                         }
                         else
                         {
-                        labelStyle.normal.textColor = Color.black;
+                            labelStyle.normal.textColor = GUI.skin.label.normal.textColor;
                         }
 
                         GUILayout.Label("x " + curWindow.textureAtlas.selectedTextureQuad.guiRect.x.ToString() + ", y " + curWindow.textureAtlas.selectedTextureQuad.guiRect.y.ToString());
                         GUILayout.Label("w " + curWindow.textureAtlas.selectedTextureQuad.guiRect.width.ToString() + ", h " + curWindow.textureAtlas.selectedTextureQuad.guiRect.height.ToString(), labelStyle);
-
+                    }
                     GUILayout.EndVertical();
                     GUILayout.EndArea();
                 }
             }
 
-			if(curWindow.textureAtlas != null && curWindow.textureAtlas.selectedTextureQuad != null)				
+            if (curWindow.textureAtlas != null && curWindow.textureAtlas.selectedTextureQuad != null)
                 ProcessEvents(e, editorViewRect);
         }
 

Assets/MA_ToolBox/MA_TextureAtlasserPro/Scripts/Editor/Views/MA_TextureAtlasserProMenuView.cs

@@ -25,45 +25,45 @@ namespace MA_TextureAtlasserPro
 				GUILayout.BeginArea(editorViewRect, EditorStyles.helpBox);	
 				GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 
-				if(GUILayout.Button(MA_TextureAtlasserProIcons.createAtlasIcon, GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true)))
+				if(GUILayout.Button(MA_TextureAtlasserProGuiLoader.createAtlasGC, GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true)))
 				{
 					MA_TextureAtlasserProCreateWindow.InitEditorWindow(curWindow);
 				}
-				if(GUILayout.Button(MA_TextureAtlasserProIcons.loadAtlasIcon, GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true)))
+				if(GUILayout.Button(MA_TextureAtlasserProGuiLoader.loadAtlasGC, GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true)))
 				{
 					curWindow.textureAtlas = MA_TextureAtlasserProUtils.LoadTextureAtlas();
 				}
 
 				if(curWindow.textureAtlas != null)
 				{
-					if(GUILayout.Button(MA_TextureAtlasserProIcons.exportAtlasIcon, GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true)))
+					if(GUILayout.Button(MA_TextureAtlasserProGuiLoader.exportAtlasGC, GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true)))
 					{
 						MA_TextureAtlasserProExportWindow.InitEditorWindow(curWindow);
 						//MA_TextureAtlasserProUtils.ExportAtlas(curWindow.textureAtlas);
 					}
 					GUILayout.Space(MA_TextureAtlasserProUtils.VIEW_OFFSET);
-					if(curWindow.textureAtlas.showTextures && GUILayout.Button(MA_TextureAtlasserProIcons.showTexturesOnIcon, GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true)))
+					if(curWindow.textureAtlas.showTextures && GUILayout.Button(MA_TextureAtlasserProGuiLoader.showTexturesOnGC, GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true)))
 					{
 						curWindow.textureAtlas.showTextures = false;
 					}
-					else if(!curWindow.textureAtlas.showTextures && GUILayout.Button(MA_TextureAtlasserProIcons.showTexturesOffIcon, GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true)))
+					else if(!curWindow.textureAtlas.showTextures && GUILayout.Button(MA_TextureAtlasserProGuiLoader.showTexturesOffGC, GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true)))
 					{
 						curWindow.textureAtlas.showTextures = true;
 					}
 					GUILayout.Space(MA_TextureAtlasserProUtils.VIEW_OFFSET);
-					if(GUILayout.Button(MA_TextureAtlasserProIcons.createQuadIcon, GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true)))
+					if(GUILayout.Button(MA_TextureAtlasserProGuiLoader.createQuadGC, GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true)))
 					{
 						MA_TextureAtlasserProUtils.CreateTextureQuad(curWindow.textureAtlas, "new Quad", new Rect(0, 0, 128, 128), curWindow.settings.autoFocus);
 					}
-					if(curWindow.textureAtlas.selectedTextureQuad != null && GUILayout.Button(MA_TextureAtlasserProIcons.removeQuadIcon, GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true)))
+					if(curWindow.textureAtlas.selectedTextureQuad != null && GUILayout.Button(MA_TextureAtlasserProGuiLoader.removeQuadGC, GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true)))
 					{
 						if(curWindow.textureAtlas.selectedTextureQuad != null)
 							MA_TextureAtlasserProUtils.RemoveTextureQuad(curWindow.textureAtlas, curWindow.settings.autoFocus);		
 					}
-					if (curWindow.textureAtlas.selectedTextureQuad != null && GUILayout.Button(MA_TextureAtlasserProIcons.duplicateQuadIcon, GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true)))
+					if (curWindow.textureAtlas.selectedTextureQuad != null && GUILayout.Button(MA_TextureAtlasserProGuiLoader.duplicateQuadGC, GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true)))
 					{
 						if (curWindow.textureAtlas.selectedTextureQuad != null)
-							MA_TextureAtlasserProUtils.DuplicateTextureQuad(curWindow.textureAtlas, curWindow.settings.autoFocus, curWindow.settings.copySelectedQuadData, curWindow.settings.duplicatedQuadNamePrefix);
+							MA_TextureAtlasserProUtils.DuplicateTextureQuad(curWindow.textureAtlas, curWindow.settings.autoFocus, curWindow.settings.duplicatedQuadNamePrefix);
 					}
 				}
 

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

@@ -91,7 +91,7 @@ namespace MA_TextureAtlasserPro
                 e.Use();
             }
 
-			//Hotkeys.
+			//HotKeys.
 			if (curWindow.settings.useHotkeys)
 			{
 				if(curWindow.textureAtlas != null)
@@ -123,7 +123,7 @@ namespace MA_TextureAtlasserPro
 
 						if (curWindow.settings.GetHotKey(e, curWindow.settings.duplicateHotKey))
 						{
-							MA_TextureAtlasserProUtils.DuplicateTextureQuad(curWindow.textureAtlas, curWindow.settings.autoFocus, curWindow.settings.copySelectedQuadData, curWindow.settings.duplicatedQuadNamePrefix);
+							MA_TextureAtlasserProUtils.DuplicateTextureQuad(curWindow.textureAtlas, curWindow.settings.autoFocus, curWindow.settings.duplicatedQuadNamePrefix);
 							e.Use();
 						}
 					}
@@ -145,9 +145,9 @@ namespace MA_TextureAtlasserPro
                 {
                     if(q.isSelected)
                     {
-                        GUI.Button(new Rect(q.dragRectPos.x, q.dragRectPos.y, q.dragRectPos.width, q.dragRectPos.height), MA_TextureAtlasserProIcons.dragHandleIcon);
-                        GUI.Button(new Rect(q.dragRectWidth.x, q.dragRectWidth.y, q.dragRectWidth.width, q.dragRectWidth.height), MA_TextureAtlasserProIcons.dragHandleIcon);
-                        GUI.Button(new Rect(q.dragRectHeight.x, q.dragRectHeight.y, q.dragRectHeight.width, q.dragRectHeight.height), MA_TextureAtlasserProIcons.dragHandleIcon);
+                        GUI.Button(new Rect(q.dragRectPos.x, q.dragRectPos.y, q.dragRectPos.width, q.dragRectPos.height), MA_TextureAtlasserProGuiLoader.dragHandleGC);
+                        GUI.Button(new Rect(q.dragRectWidth.x, q.dragRectWidth.y, q.dragRectWidth.width, q.dragRectWidth.height), MA_TextureAtlasserProGuiLoader.dragHandleGC);
+                        GUI.Button(new Rect(q.dragRectHeight.x, q.dragRectHeight.y, q.dragRectHeight.width, q.dragRectHeight.height), MA_TextureAtlasserProGuiLoader.dragHandleGC);
                     }
                 }
             }

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

@@ -136,7 +136,7 @@ namespace MA_TextureAtlasserPro
 		{
 			GUILayout.BeginHorizontal(EditorStyles.helpBox, GUILayout.Height(44));
 
-            if (GUILayout.Button(MA_TextureAtlasserProIcons.createAtlasIcon, GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true)))
+            if (GUILayout.Button(MA_TextureAtlasserProGuiLoader.createExportSettingsGC, GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true)))
             {
                 MA_TextureAtlasserProCreateExportWindow.InitWindow(curWindow);
             }
@@ -153,22 +153,6 @@ namespace MA_TextureAtlasserPro
             }
 
             if (GUILayout.Button("Export", GUILayout.ExpandWidth(true), GUILayout.Height(37)))
-            {
-                bool export = false;
-
-                if(curWindow.textureAtlas.exportSettings.modelExportSettings.modelFormat == ModelFormat.ReplaceMesh)
-                {
-                    if(EditorUtility.DisplayDialog("Replace original models?", "Are you sure you want to replace the original models, this can't be undone!", "Replace", "Cancel"))
-                    {
-                        export = true;
-                    }
-                }
-                else
-                {
-                    export = true;
-                }
-
-                if(export)
             {
                 string[] textures = null;
                 string material = null;
@@ -179,15 +163,14 @@ namespace MA_TextureAtlasserPro
                     textures = MA_TextureAtlasserProUtils.ExportAtlasTextures(curWindow.textureAtlas, curWindow.textureAtlas.exportSettings.textureExportSettings);
                 }
 
-                    if(curWindow.textureAtlas.exportSettings.exportMaterials)
+                if (curWindow.textureAtlas.exportSettings.exportMaterials)
                 {
                     material = MA_TextureAtlasserProUtils.ExportAtlasMaterial(curWindow.textureAtlas, curWindow.textureAtlas.exportSettings.materialExportSettings, textures: textures);
                 }
 
-                    if(curWindow.textureAtlas.exportSettings.exportModels)
+                if (curWindow.textureAtlas.exportSettings.exportModels)
                 {
-                        models = MA_TextureAtlasserProUtils.ExportAtlasModels(curWindow.textureAtlas, curWindow.textureAtlas.exportSettings.modelExportSettings, material: material);
-                    }
+                    models = MA_TextureAtlasserProUtils.ExportAtlasModels(curWindow.textureAtlas, curWindow.textureAtlas.exportSettings.modelExportSettings, materialPath: material);
                 }
             }
 

Assets/MA_ToolBox/MA_TextureAtlasserPro/Scripts/Editor/Windows/MA_TextureAtlasserProWindow.cs

@@ -34,7 +34,7 @@ namespace MA_TextureAtlasserPro
 		private void OnEnable()
 		{
 			//Load the icons
-			MA_TextureAtlasserProIcons.LoadIcons();
+			//MA_TextureAtlasserProGuiLoader.LoadEditorGui(thisWindow.settings.editorGuiSettings);
 		}
 
         private static void GetCurrentWindow()
@@ -59,6 +59,7 @@ namespace MA_TextureAtlasserPro
 			}
 
 			thisWindow.settings = MA_TextureAtlasserProUtils.LoadSettings();
+			MA_TextureAtlasserProGuiLoader.LoadEditorGui(thisWindow.settings);
 			thisWindow.workView = new MA_TextureAtlasserProWorkView(thisWindow, "workView");
 			thisWindow.menuView = new MA_TextureAtlasserProMenuView(thisWindow, "menuView");
 			thisWindow.inspectorView = new MA_TextureAtlasserProInspectorView(thisWindow, "inspectorView");

Assets/MA_ToolBox/MA_Utilities/MeshUtils/MA_MeshUtils.cs

@@ -17,59 +17,53 @@ namespace MA_Mesh
 {
 	public static class MA_MeshUtils
 	{
-		public static string MA_SaveMeshAsset(Mesh mesh, string meshName, string savePath)
+		public static string MA_SaveMeshAsset(Mesh mesh, string savePath)
 		{
-            Mesh newMesh = mesh;
-
-			if(meshName == "")
+			if (string.IsNullOrEmpty(mesh.name))
 			{
-				newMesh.name = mesh.name;
-			}
-			else
-			{
-				newMesh.name = meshName;
+				mesh.name = UnityEngine.Random.Range(11111, 99999).ToString();
 			}
 
-            string assetPath = savePath + newMesh.name + ".asset";
+			string assetPath = savePath + mesh.name + ".asset";
 
-            AssetDatabase.CreateAsset(newMesh, assetPath);
+			AssetDatabase.CreateAsset(mesh, assetPath);
 			AssetDatabase.SaveAssets();
 
 			return assetPath;
 		}
 
-        public static string MA_SaveMeshPrefab(Mesh mesh, string meshName, string savePath, string material)
+		public static string MA_SaveMeshPrefab(Mesh mesh, string prefabName, string savePath, string materialPath)
 		{
-            string assetPath = "";
+			string assetPath = null;
 
-            if (meshName == "")
-            {
-                meshName = mesh.name;
-            }
+			string meshAssetPath = MA_SaveMeshAsset(mesh, savePath);
+			Mesh meshAsset = AssetDatabase.LoadAssetAtPath<Mesh>(meshAssetPath);
 
-            string meshPath = MA_SaveMeshAsset(mesh, meshName, savePath);
-            Mesh curMesh = AssetDatabase.LoadAssetAtPath<Mesh>(meshPath);
-
-            if (curMesh != null)
+			if (meshAsset != null)
 			{
 				GameObject gameObject = new GameObject
 				{
-                    name = meshName
+					name = prefabName
 				};
 
-                gameObject.AddComponent<MeshFilter>().mesh = curMesh;
+				gameObject.AddComponent<MeshFilter>().mesh = meshAsset;
 				gameObject.AddComponent<MeshRenderer>();
 
-                Material curMaterial = AssetDatabase.LoadAssetAtPath<Material>(material);
+				Material curMaterial = AssetDatabase.LoadAssetAtPath<Material>(materialPath);
 				if (curMaterial != null)
 				{
 					gameObject.GetComponent<MeshRenderer>().material = curMaterial;
 				}
 
-                assetPath = savePath + meshName + ".prefab";
-                PrefabUtility.SaveAsPrefabAsset(gameObject, assetPath);
+				if (string.IsNullOrEmpty(prefabName))
+				{
+					prefabName = UnityEngine.Random.Range(11111, 99999).ToString();
+				}
 
-                UnityEngine.GameObject.DestroyImmediate(gameObject);
+				assetPath = savePath + prefabName + ".prefab";
+
+				PrefabUtility.SaveAsPrefabAsset(gameObject, assetPath);
+				UnityEngine.Object.DestroyImmediate(gameObject);
 			}
 
 			return assetPath;
@@ -90,7 +84,12 @@ namespace MA_Mesh
 				newMesh.SetTriangles(mesh.GetTriangles(i), i);
 			}
 			newMesh.SetNormals(new List<Vector3>(mesh.normals));
-			newMesh.SetUVs(0, new List<Vector2>(mesh.uv));
+			for (int i = 0; i < 8; i++)
+			{
+				List<Vector2> uvs = new List<Vector2>();
+				mesh.GetUVs(i, uvs);
+				newMesh.SetUVs(i, uvs);
+			}
 			newMesh.SetTangents(new List<Vector4>(mesh.tangents));
 			newMesh.SetColors(new List<Color>(mesh.colors));
 
@@ -175,88 +174,6 @@ namespace MA_Mesh
 				val = val + max - min;
 			return val;
 		}
-
-		//Start http://wiki.unity3d.com/index.php?title=ObjExporter
-		public static string MeshToString(Mesh mesh) 
-		{
-			int vertexOffset = 0;
-			int normalOffset = 0;
-			int uvOffset = 0;
-
-			Material material = new Material(Shader.Find("Standard"));
-	
-			StringBuilder sb = new StringBuilder();
-	
-			sb.Append("g ").Append(mesh.name).Append("\n");
-
-			foreach(Vector3 v in mesh.vertices) 
-			{
-				//This is sort of ugly - inverting x-component since we're in
-				//a different coordinate system than "everyone" is "used to".
-				sb.Append(string.Format("v {0} {1} {2}\n", -v.x, v.y, v.z));
 	}
-
-			sb.Append("\n");
-
-			foreach(Vector3 v in mesh.normals) 
-			{
-				sb.Append(string.Format("vn {0} {1} {2}\n", -v.x, v.y, v.z));
-			}
-
-			sb.Append("\n");
-
-			foreach(Vector3 v in mesh.uv) 
-			{
-				sb.Append(string.Format("vt {0} {1}\n", v.x, v.y));
-			}
-
-			for (int m = 0 ; m < mesh.subMeshCount; m++) 
-			{
-				sb.Append("\n");
-				sb.Append("usemtl ").Append(material.name + m).Append("\n");
-				sb.Append("usemap ").Append(material.name + m).Append("\n");
-	
-				// int[] triangles = mesh.GetTriangles(m);
-				// for (int i = 0; i < triangles.Length; i += 3)
-				// {
-				// 	sb.Append(string.Format("f {0}/{0}/{0} {1}/{1}/{1} {2}/{2}/{2}\n", triangles[i]+1, triangles[i+1]+1, triangles[i+2]+1));
-				// }
-
-				int[] triangles = mesh.GetTriangles(m);
-				for (int i = 0; i < triangles.Length; i += 3) 
-				{
-					//Because we inverted the x-component, we also needed to alter the triangle winding.
-					sb.Append(string.Format("f {1}/{1}/{1} {0}/{0}/{0} {2}/{2}/{2}\n", triangles[i]+  1 + vertexOffset, triangles[i + 1] + 1 + normalOffset, triangles[i +2 ] + 1 + uvOffset));
-				}
-			}
-
-			//vertexOffset += mesh.vertices.Length;
-			//normalOffset += mesh.normals.Length;
-			//uvOffset += mesh.uv.Length;
-
-			return sb.ToString();
-		}
- 
-		public static string MeshToFile(Mesh mesh, string filename, string savePath) 
-		{
-            string assetPath = savePath + filename + ".obj";
-
-            using (StreamWriter sw = new StreamWriter(assetPath)) 
-			{
-				sw.Write(MeshToString(mesh));
-			}
-
-            AssetDatabase.Refresh();
-
-            return assetPath;
-		}
-		//End
-	}
-
-	//struct ObjMaterial
-	//{
-	//	public string name;
-	//	public string textureName;
-	//}
 }
 #endif

Assets/MA_ToolBox/MA_Utilities/PrefabUtils.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9946d57c8e1c3714183228268fff08a5
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/MA_ToolBox/MA_Utilities/PrefabUtils/MA_PrefabUtils.cs

@@ -0,0 +1,41 @@
+//-
+
+#if UNITY_EDITOR
+using UnityEditor;
+using UnityEngine;
+
+namespace MA_Toolbox.Utils.Editor
+{
+    public static class MA_PrefabUtils
+    {
+        public static string CreatePrefab(string prefabName, string savePath)
+        {
+            if(string.IsNullOrEmpty(prefabName) || string.IsNullOrWhiteSpace(prefabName))
+            {
+                Debug.LogError("Invalid prefab name.");
+                return null;
+            }
+
+            GameObject gameObject = new GameObject
+            {
+                name = prefabName
+            };
+
+            string assetPath = savePath + prefabName + ".prefab";
+
+            PrefabUtility.SaveAsPrefabAsset(gameObject, assetPath);
+            UnityEngine.Object.DestroyImmediate(gameObject);
+
+            return assetPath;
+        }
+
+        public static void AddChild(GameObject prefab, GameObject child)
+        {
+            GameObject p = PrefabUtility.InstantiatePrefab(prefab) as GameObject;
+            child.transform.SetParent(p.transform);
+            PrefabUtility.ApplyPrefabInstance(p, InteractionMode.AutomatedAction);
+            UnityEngine.Object.DestroyImmediate(p);
+        }
+    }
+}
+#endif

Assets/MA_ToolBox/MA_Utilities/PrefabUtils/MA_PrefabUtils.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 04e1a62b7d6bb434eb0314336ac94f8f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/MA_ToolBox/MA_Utilities/StringUtils.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f38cac7c10bd77748ab01c8642751035
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/MA_ToolBox/MA_Utilities/StringUtils/MA_StringUtils.cs

@@ -0,0 +1,28 @@
+//-
+
+using UnityEditor;
+using UnityEngine;
+
+namespace MA_Toolbox.Utils
+{
+    public static class MA_StringUtils
+    {
+        private const string ALPHABET = "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ";
+
+        public static string RandomAlphabetString(int length)
+        {
+            string s = "";
+            for (int i = 0; i < length; i++)
+            {
+                s += RandomAlphabetChar();
+            }
+
+            return s;
+        }
+
+        public static char RandomAlphabetChar()
+        {
+            return ALPHABET[Random.Range(0, ALPHABET.Length)];
+        }
+    }
+}

Assets/MA_ToolBox/MA_Utilities/StringUtils/MA_StringUtils.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fc1a5e241141bb549b81ad11dfdc0962
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/MA_ToolBox/MA_Utilities/TextureUtils/MA_TextureUtils.cs

@@ -41,7 +41,7 @@ namespace MA_Texture
             RenderTexture.active = tmp;
 
             // Create a new readable Texture2D to copy the pixels to it
-            Texture2D myTexture2D = new Texture2D(texture.width, texture.width);
+            Texture2D myTexture2D = new Texture2D(texture.width, texture.height);
 
             // Copy the pixels from the RenderTexture to the new Texture
             myTexture2D.ReadPixels(new Rect(0, 0, tmp.width, tmp.height), 0, 0);
@@ -161,17 +161,20 @@ namespace MA_Texture
 		{
 			Color[] newColors = new Color[newWidth * newHeight];
 
-			float ratioX = ((float)curWidth) / newWidth;
-			float ratioY = ((float)curHeight) / newHeight;
+            float ratioX = 1.0f / ((float)newWidth / (curWidth - 1));
+            float ratioY = 1.0f / ((float)newHeight / (curHeight - 1));
 
             for (int y = 0; y < newHeight; y++)
 			{
-				var thisY = Mathf.RoundToInt((ratioY * y) * curWidth);
+                int yFloor = Mathf.FloorToInt(y * ratioY);
+                var y1 = (yFloor + 1) * curWidth;
                 var yw = y * newWidth;
 
                 for (int x = 0; x < newWidth; x++)
 				{
-					newColors[yw + x] = curColors[Mathf.RoundToInt(thisY + ratioX * x)];
+                    int xFloor = Mathf.FloorToInt(x * ratioX);
+
+                    newColors[yw + x] = curColors[Mathf.RoundToInt(y1 + xFloor)];
 				}
 			}
 
@@ -196,7 +199,7 @@ namespace MA_Texture
                 if(flipY)             
                 {
                     //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--)
+                    for (int y = combineTexture.height - 1; y >= 0; y--)
                     {
                         texture.SetPixel(x + offsetX, y + (texture.height - offsetY - combineTexture.height), combineTexture.GetPixel(x, y));
                     }

Packages/manifest.json

@@ -1,7 +1,11 @@
 {
   "dependencies": {
-    "com.unity.package-manager-ui": "2.1.2",
+    "com.unity.2d.sprite": "1.0.0",
+    "com.unity.ext.nunit": "1.0.0",
+    "com.unity.test-framework": "1.1.9",
+    "com.unity.ugui": "1.0.0",
     "com.unity.modules.ai": "1.0.0",
+    "com.unity.modules.androidjni": "1.0.0",
     "com.unity.modules.animation": "1.0.0",
     "com.unity.modules.assetbundle": "1.0.0",
     "com.unity.modules.audio": "1.0.0",

ProjectSettings/EditorSettings.asset

@@ -3,7 +3,7 @@
 --- !u!159 &1
 EditorSettings:
   m_ObjectHideFlags: 0
-  serializedVersion: 7
+  serializedVersion: 9
   m_ExternalVersionControlSupport: Hidden Meta Files
   m_SerializationMode: 2
   m_LineEndingsForNewScripts: 2
@@ -16,10 +16,20 @@ EditorSettings:
   m_EtcTextureFastCompressor: 1
   m_EtcTextureNormalCompressor: 2
   m_EtcTextureBestCompressor: 4
-  m_ProjectGenerationIncludedExtensions: txt;xml;fnt;cd;asmdef;rsp
+  m_ProjectGenerationIncludedExtensions: txt;xml;fnt;cd;asmdef;rsp;asmref
   m_ProjectGenerationRootNamespace: 
   m_CollabEditorSettings:
     inProgressEnabled: 1
   m_EnableTextureStreamingInEditMode: 1
   m_EnableTextureStreamingInPlayMode: 1
   m_AsyncShaderCompilation: 1
+  m_EnterPlayModeOptionsEnabled: 0
+  m_EnterPlayModeOptions: 3
+  m_ShowLightmapResolutionOverlay: 1
+  m_UseLegacyProbeSampleCount: 1
+  m_AssetPipelineMode: 1
+  m_CacheServerMode: 0
+  m_CacheServerEndpoint: 
+  m_CacheServerNamespacePrefix: default
+  m_CacheServerEnableDownload: 1
+  m_CacheServerEnableUpload: 1

ProjectSettings/ProjectVersion.txt

@@ -1,2 +1,2 @@
-m_EditorVersion: 2019.1.10f1
-m_EditorVersionWithRevision: 2019.1.10f1 (f007ed779b7a)
+m_EditorVersion: 2019.3.0f6
+m_EditorVersionWithRevision: 2019.3.0f6 (27ab2135bccf)

README.md

@@ -1,21 +1,27 @@
+[![Image](https://maxartz15.com/wp-content/uploads/2020/04/MA_TextureAtlas2.png)](https://maxartz15.com/wp-content/uploads/2020/04/MA_TextureAtlas2.png)
+
 # MA_TextureAtlasser
-Texture atlas creator for Unity
-
-[![Image](https://maxartz15.com/wp-content/uploads/2019/04/MA_TextureAtlas.png)]()
-
-You can combine textures and/or remap the UV’s for the 3D models.
-By having full control over the size and position of the textures that are being placed in the atlas you will never stand for surprises when exporting. This will cost some more time than auto-generating your texture atlases but you know whats going on and which models/textures are getting priority. The tool can also be used to make 2D sprite sheets.
-
+Texture atlas creator tool for Unity. <br> This tool is made to combine textures and/or remap the UV’s for 3D models. The tool can also be used to make 2D sprite sheets. The visual editor gives you the ability to set and prioritize the sizes and positions in the texture atlas/sprite sheet.
 - Combine textures/sprites.
 - Automatically adjusts the UV's of the assigned meshes to match the new texture atlas.
-- Exports meshes as OBJ.
-- Exports texture atlas as PNG.
-- Exports texture atlas as a (sliced) sprite sheet.
 
-[Example video](https://youtu.be/PBRKlopkZP0)
+### Download unitypackage
+[![Github All Releases](https://img.shields.io/github/downloads/maxartz15/MA_TextureAtlasser/total.svg)](https://github.com/maxartz15/MA_TextureAtlasser/releases) 
 
-Download the UnityPackage here: https://github.com/maxartz15/MA_TextureAtlasser/releases
+### Unity versions
+- Latest release requires Unity 2018.3 or higher.
+- Releases before 1.8 should work with older Unity versions.
+- Upgrading to 1.8+ will break existing atlasses.
 
-[![Github All Releases](https://img.shields.io/github/downloads/maxartz15/MA_TextureAtlasser/total.svg)]()
+## Export options
+### Meshes
+- UnityMesh (with prefab setup)
+### Textures
+- PNG
+- PNG (sliced) sprite sheet
+### Materials
+- Material (with assigned textures and selected shader)
 
-For more information: https://maxartz15.com/ma-textureatlasser/
+## Resources
+[Youtube video](https://youtu.be/PBRKlopkZP0) <br>
+[Website](https://maxartz15.com/ma_textureatlas/)