Bugfixes: Texture point scale.

Bugfixes: Texture point scale.
Test Unity2019.3.

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/MA_TextureAtlasserProExportSettings.cs

@@ -1,4 +1,5 @@
-using UnityEngine;
+#if UNITY_EDITOR
+using UnityEngine;
 using System.Collections;
 using MA_Texture;
 using System.Collections.Generic;
@@ -67,3 +68,4 @@ namespace MA_TextureAtlasserPro
         SpriteSliced
     }
 }
+#endif

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

@@ -8,50 +8,48 @@ using MA_Texture;
 
 namespace MA_TextureAtlasserPro
 {
-
-
-	public static class MA_TextureAtlasserProUtils
-	{
+    public static class MA_TextureAtlasserProUtils
+    {
         public const string TEXTURE_ATLASSER_PATH = "Assets/MA_ToolBox/MA_TextureAtlasserPro/";
         public const string SETTINGS_ASSET_PATH = "Assets/MA_ToolBox/MA_TextureAtlasserPro/Settings/";
         public const string SAVE_ASSET_PATH = "Assets/MA_ToolBox/MA_TextureAtlasserPro/Atlasses/";
-		public const string LOAD_ASSET_PATH = "Assets/MA_ToolBox/MA_TextureAtlasserPro/Atlasses/";
-		public const string EXPORT_ASSET_PATH = "Assets/MA_ToolBox/MA_TextureAtlasserPro/Exports/";
+        public const string LOAD_ASSET_PATH = "Assets/MA_ToolBox/MA_TextureAtlasserPro/Atlasses/";
+        public const string EXPORT_ASSET_PATH = "Assets/MA_ToolBox/MA_TextureAtlasserPro/Exports/";
         public const string TEMP_ASSET_PATH = "Assets/MA_ToolBox/MA_TextureAtlasserPro/Temp/";
 
-		public const string DEFAULT_TEXTURE_GROUP_NAME = "Albedo";
+        public const string DEFAULT_TEXTURE_GROUP_NAME = "Albedo";
         public const float VIEW_OFFSET = 20;
 
-		public static MA_TextureAtlasserProSettings CreateSettings()
-		{
-			MA_TextureAtlasserProSettings _settings = ScriptableObject.CreateInstance<MA_TextureAtlasserProSettings>();
+        public static MA_TextureAtlasserProSettings CreateSettings()
+        {
+            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");
-				AssetDatabase.SaveAssets();
-				AssetDatabase.Refresh();
+                AssetDatabase.SaveAssets();
+                AssetDatabase.Refresh();
 
-				return _settings;
-			}
-			else
-			{
-				return null;
-			}
-		}
+                return _settings;
+            }
+            else
+            {
+                return null;
+            }
+        }
 
-		public static MA_TextureAtlasserProSettings LoadSettings()
-		{
-			MA_TextureAtlasserProSettings _settings = AssetDatabase.LoadAssetAtPath(SETTINGS_ASSET_PATH + "MA_TextureAtlasserProSettings.asset", typeof(MA_TextureAtlasserProSettings)) as MA_TextureAtlasserProSettings;
+        public static MA_TextureAtlasserProSettings LoadSettings()
+        {
+            MA_TextureAtlasserProSettings _settings = AssetDatabase.LoadAssetAtPath(SETTINGS_ASSET_PATH + "MA_TextureAtlasserProSettings.asset", typeof(MA_TextureAtlasserProSettings)) as MA_TextureAtlasserProSettings;
 
-			if (_settings == null)
-			{
-				_settings = CreateSettings();
-			}
+            if (_settings == null)
+            {
+                _settings = CreateSettings();
+            }
 
-			return _settings;
-		}
+            return _settings;
+        }
 
         public static MA_TextureAtlasserProExportSettings CreateExportSettings(string name, bool canModify = true)
         {
@@ -89,273 +87,273 @@ namespace MA_TextureAtlasserPro
         }
 
         public static MA_TextureAtlasserProAtlas CreateTextureAtlas(string name, Vector2 size)
-		{
-			MA_TextureAtlasserProAtlas _atlas = ScriptableObject.CreateInstance<MA_TextureAtlasserProAtlas>();
+        {
+            MA_TextureAtlasserProAtlas _atlas = ScriptableObject.CreateInstance<MA_TextureAtlasserProAtlas>();
 
-			if(_atlas != null)
-			{
-				_atlas.CreateAtlas(name, size);
-				MA_CheckTextureAtlas(_atlas);
+            if (_atlas != null)
+            {
+                _atlas.CreateAtlas(name, size);
+                MA_CheckTextureAtlas(_atlas);
 
                 CreateFolder(SAVE_ASSET_PATH);
                 AssetDatabase.CreateAsset(_atlas, SAVE_ASSET_PATH + name + ".asset");
-				AssetDatabase.SaveAssets();
-				AssetDatabase.Refresh();
+                AssetDatabase.SaveAssets();
+                AssetDatabase.Refresh();
 
-				return _atlas;
-			}
-			else
-			{
-				return null;
-			}
-		}
+                return _atlas;
+            }
+            else
+            {
+                return null;
+            }
+        }
 
-		public static MA_TextureAtlasserProAtlas LoadTextureAtlas()
-		{
-			MA_TextureAtlasserProAtlas _atlas = null;
-			string absPath = EditorUtility.OpenFilePanel("Select Texture Atlas", LOAD_ASSET_PATH, "");
+        public static MA_TextureAtlasserProAtlas LoadTextureAtlas()
+        {
+            MA_TextureAtlasserProAtlas _atlas = null;
+            string absPath = EditorUtility.OpenFilePanel("Select Texture Atlas", LOAD_ASSET_PATH, "");
 
-			if(absPath.StartsWith(Application.dataPath))
-			{
-				string relPath = absPath.Substring(Application.dataPath.Length - "Assets".Length);
-				_atlas = AssetDatabase.LoadAssetAtPath(relPath, typeof(MA_TextureAtlasserProAtlas)) as MA_TextureAtlasserProAtlas;
+            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);
+                MA_CheckTextureAtlas(_atlas);
 
-				if(_atlas)
-				{
-					EditorPrefs.SetString("AtlasPath", null);
-				}
-			}
+                if (_atlas)
+                {
+                    EditorPrefs.SetString("AtlasPath", null);
+                }
+            }
 
-			if(_atlas != null)
-			{
-				if(_atlas.selectedTextureQuad != null)
-				{
-					_atlas.selectedTextureQuad.isSelected = false;
-				}
-				_atlas.selectedTextureQuad = null;
-			}
+            if (_atlas != null)
+            {
+                if (_atlas.selectedTextureQuad != null)
+                {
+                    _atlas.selectedTextureQuad.isSelected = false;
+                }
+                _atlas.selectedTextureQuad = null;
+            }
 
-			return _atlas;
-		}
+            return _atlas;
+        }
 
-		public static void MA_CheckTextureAtlas(MA_TextureAtlasserProAtlas atlas)
-		{
-			if(atlas.textureGroupRegistration == null)
-			{
-				atlas.textureGroupRegistration = new List<MA_TextureGroupRegistration>();
+        public static void MA_CheckTextureAtlas(MA_TextureAtlasserProAtlas atlas)
+        {
+            if (atlas.textureGroupRegistration == null)
+            {
+                atlas.textureGroupRegistration = new List<MA_TextureGroupRegistration>();
 
-				MA_TextureGroupRegistration groupRegistration = new MA_TextureGroupRegistration
-				{
-					name = DEFAULT_TEXTURE_GROUP_NAME
-				};
+                MA_TextureGroupRegistration groupRegistration = new MA_TextureGroupRegistration
+                {
+                    name = DEFAULT_TEXTURE_GROUP_NAME
+                };
 
-				atlas.textureGroupRegistration.Add(groupRegistration);
-			}
+                atlas.textureGroupRegistration.Add(groupRegistration);
+            }
 
-			if(atlas.textureQuads == null)
-			{
-				atlas.textureQuads = new List<MA_TextureAtlasserProQuad>();
-			}
-			else
-			{
-				bool _sameCount = true;
-				foreach (MA_TextureAtlasserProQuad q in atlas.textureQuads)
-				{
-					if(q.textureGroups.Count != atlas.textureGroupRegistration.Count)
-					{
-						_sameCount = false;
-						Debug.LogWarning("TextureAtlasser: " + q.name + " doesn't have the right amount of texture groups!");
-					}
-				}
+            if (atlas.textureQuads == null)
+            {
+                atlas.textureQuads = new List<MA_TextureAtlasserProQuad>();
+            }
+            else
+            {
+                bool _sameCount = true;
+                foreach (MA_TextureAtlasserProQuad q in atlas.textureQuads)
+                {
+                    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)
-				{
-					foreach (MA_TextureAtlasserProQuad q in atlas.textureQuads)
-					{
-						for (int i = 0; i < atlas.textureQuads.Count; i++)
-						{
-							for (int j = 0; j < atlas.textureGroupRegistration.Count; j++)
-							{
-								if(atlas.textureQuads[i].textureGroups[j].name != atlas.textureGroupRegistration[j].name)
-								{
-									Debug.LogWarning("TextureAtlasser: " + q.name + " doesn't have the right texture group name!");
-								}
-							}
-						}
-					}
-				}
-			}
+                if (_sameCount)
+                {
+                    foreach (MA_TextureAtlasserProQuad q in atlas.textureQuads)
+                    {
+                        for (int i = 0; i < atlas.textureQuads.Count; i++)
+                        {
+                            for (int j = 0; j < atlas.textureGroupRegistration.Count; j++)
+                            {
+                                if (atlas.textureQuads[i].textureGroups[j].name != atlas.textureGroupRegistration[j].name)
+                                {
+                                    Debug.LogWarning("TextureAtlasser: " + q.name + " doesn't have the right texture group name!");
+                                }
+                            }
+                        }
+                    }
+                }
+            }
 
-            if(atlas.exportSettings == null)
+            if (atlas.exportSettings == null)
             {
                 atlas.exportSettings = LoadExportSettings();
             }
-		}
+        }
 
-		public static MA_TextureAtlasserProQuad CreateTextureQuad(MA_TextureAtlasserProAtlas atlas, string name, Rect rect, bool focus = true)
-		{
-			if(atlas != null)
-			{
-				//Create new list if we haven't one already
-				if(atlas.textureQuads == null)
-				{
-					atlas.textureQuads = new List<MA_TextureAtlasserProQuad>();
-				}
+        public static MA_TextureAtlasserProQuad CreateTextureQuad(MA_TextureAtlasserProAtlas atlas, string name, Rect rect, bool focus = true)
+        {
+            if (atlas != null)
+            {
+                //Create new list if we haven't one already
+                if (atlas.textureQuads == null)
+                {
+                    atlas.textureQuads = new List<MA_TextureAtlasserProQuad>();
+                }
 
-				//Create new quad
-				MA_TextureAtlasserProQuad _quad = ScriptableObject.CreateInstance<MA_TextureAtlasserProQuad>();
+                //Create new quad
+                MA_TextureAtlasserProQuad _quad = ScriptableObject.CreateInstance<MA_TextureAtlasserProQuad>();
 
-				//Add quad to asset
-				if(_quad != null)
-				{
-					//Set quad settings
-					_quad.name = name;
-					_quad.rect = rect;
+                //Add quad to asset
+                if (_quad != null)
+                {
+                    //Set quad settings
+                    _quad.name = name;
+                    _quad.rect = rect;
 
-					SetTextureGroups(atlas, _quad);
+                    SetTextureGroups(atlas, _quad);
 
-					atlas.textureQuads.Add(_quad);
+                    atlas.textureQuads.Add(_quad);
 
-					AssetDatabase.AddObjectToAsset(_quad, atlas);
-					AssetDatabase.SaveAssets();
-					AssetDatabase.Refresh();
+                    AssetDatabase.AddObjectToAsset(_quad, atlas);
+                    AssetDatabase.SaveAssets();
+                    AssetDatabase.Refresh();
 
-					if(focus)
-					{
-						atlas.selectedTextureQuad = atlas.textureQuads[atlas.textureQuads.Count - 1];
-					}
+                    if (focus)
+                    {
+                        atlas.selectedTextureQuad = atlas.textureQuads[atlas.textureQuads.Count - 1];
+                    }
 
-					return _quad;
-				}
-				else
-				{
-					Debug.LogError("CreateTextureQuad Failed: _TextureQuad");
-				}
-			}
-			else
-			{
-				Debug.LogError("CreateTextureQuad Failed: textureAtlas");
-			}
+                    return _quad;
+                }
+                else
+                {
+                    Debug.LogError("CreateTextureQuad Failed: _TextureQuad");
+                }
+            }
+            else
+            {
+                Debug.LogError("CreateTextureQuad Failed: textureAtlas");
+            }
 
-			return null;
-		}
+            return null;
+        }
 
-		public static void RemoveTextureQuad(MA_TextureAtlasserProAtlas atlas, bool focus = true)
-		{
-			if(atlas != null && atlas.selectedTextureQuad != null)
-			{
-				int _index = atlas.textureQuads.IndexOf(atlas.selectedTextureQuad);
+        public static void RemoveTextureQuad(MA_TextureAtlasserProAtlas atlas, bool focus = true)
+        {
+            if (atlas != null && atlas.selectedTextureQuad != null)
+            {
+                int _index = atlas.textureQuads.IndexOf(atlas.selectedTextureQuad);
 
-				atlas.textureQuads.RemoveAt(_index);
-				Object.DestroyImmediate(atlas.selectedTextureQuad, true);
-				AssetDatabase.SaveAssets();
-				AssetDatabase.Refresh();
+                atlas.textureQuads.RemoveAt(_index);
+                Object.DestroyImmediate(atlas.selectedTextureQuad, true);
+                AssetDatabase.SaveAssets();
+                AssetDatabase.Refresh();
 
-				if (focus && atlas.textureQuads.Count > 0)
-				{
-					_index = Mathf.Clamp(_index, 0, atlas.textureQuads.Count - 1);
-					atlas.selectedTextureQuad = atlas.textureQuads[_index];
-				}
-			}
-		}
+                if (focus && atlas.textureQuads.Count > 0)
+                {
+                    _index = Mathf.Clamp(_index, 0, atlas.textureQuads.Count - 1);
+                    atlas.selectedTextureQuad = atlas.textureQuads[_index];
+                }
+            }
+        }
 
-		public static void DuplicateTextureQuad(MA_TextureAtlasserProAtlas atlas, bool focus = true, bool copyData = false, string namePrefix = "new ")
-		{
-			if(atlas != null && atlas.selectedTextureQuad != null)
-			{
-				MA_TextureAtlasserProQuad q = CreateTextureQuad(atlas, namePrefix + atlas.selectedTextureQuad.name, atlas.selectedTextureQuad.rect, false);
+        public static void DuplicateTextureQuad(MA_TextureAtlasserProAtlas atlas, bool focus = true, bool copyData = false, string namePrefix = "new ")
+        {
+            if (atlas != null && atlas.selectedTextureQuad != null)
+            {
+                MA_TextureAtlasserProQuad q = CreateTextureQuad(atlas, namePrefix + atlas.selectedTextureQuad.name, atlas.selectedTextureQuad.rect, false);
 
-				if (copyData)
-				{
-					q.meshes = new List<Mesh>();
-					for (int i = 0; i < atlas.selectedTextureQuad.meshes.Count; i++)
-					{
-						q.meshes.Add(atlas.selectedTextureQuad.meshes[i]);
-					}
+                if (copyData)
+                {
+                    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;
-					}
-				}
+                    for (int i = 0; i < atlas.selectedTextureQuad.textureGroups.Count; i++)
+                    {
+                        q.textureGroups[i].texture = atlas.selectedTextureQuad.textureGroups[i].texture;
+                    }
+                }
 
-				if(focus)
-				{
-					atlas.selectedTextureQuad = q;
-				}
+                if (focus)
+                {
+                    atlas.selectedTextureQuad = q;
+                }
 
-				AssetDatabase.SaveAssets();
-				AssetDatabase.Refresh();
-			}
-		}
+                AssetDatabase.SaveAssets();
+                AssetDatabase.Refresh();
+            }
+        }
 
-		public static void SetTextureGroups(MA_TextureAtlasserProAtlas atlas, MA_TextureAtlasserProQuad quad)
-		{
-			if(quad.textureGroups == null)
-			{
-				quad.textureGroups = new List<MA_TextureGroup>();
-			}
+        public static void SetTextureGroups(MA_TextureAtlasserProAtlas atlas, MA_TextureAtlasserProQuad quad)
+        {
+            if (quad.textureGroups == null)
+            {
+                quad.textureGroups = new List<MA_TextureGroup>();
+            }
 
-			//Add texture groups
-			foreach (MA_TextureGroupRegistration tgr in atlas.textureGroupRegistration)
-			{
-				MA_TextureGroup textureGroup = new MA_TextureGroup
-				{
-					name = tgr.name
-				};
-				quad.textureGroups.Add(textureGroup);
-			}
-		}
+            //Add texture groups
+            foreach (MA_TextureGroupRegistration tgr in atlas.textureGroupRegistration)
+            {
+                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
-			{
-				name = name
-			};
-			atlas.textureGroupRegistration.Add(_textureGroupRegistration);
+        public static void CreateTextureGroup(MA_TextureAtlasserProAtlas atlas, string 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
-				{
-					name = name
-				};
-				q.textureGroups.Add(_textureGroup);
-			}
-		}
+            foreach (MA_TextureAtlasserProQuad q in atlas.textureQuads)
+            {
+                MA_TextureGroup _textureGroup = new MA_TextureGroup
+                {
+                    name = name
+                };
+                q.textureGroups.Add(_textureGroup);
+            }
+        }
 
-		public static void RemoveTextureGroup(MA_TextureAtlasserProAtlas atlas, int index)
-		{
-			atlas.textureGroupRegistration.RemoveAt(index);
+        public static void RemoveTextureGroup(MA_TextureAtlasserProAtlas atlas, int index)
+        {
+            atlas.textureGroupRegistration.RemoveAt(index);
 
-			foreach (MA_TextureAtlasserProQuad q in atlas.textureQuads)
-			{
-				q.textureGroups.RemoveAt(index);
-			}
-		}
+            foreach (MA_TextureAtlasserProQuad q in atlas.textureQuads)
+            {
+                q.textureGroups.RemoveAt(index);
+            }
+        }
 
-		public static void CloseWindow(MA_TextureAtlasserProWindow curWindow)
-		{
-			if(curWindow == null)
-			{
-				Debug.LogError("Closing window Failed: curWindow == null");
-			}
-			curWindow.Close();
-		}
+        public static void CloseWindow(MA_TextureAtlasserProWindow curWindow)
+        {
+            if (curWindow == null)
+            {
+                Debug.LogError("Closing window Failed: curWindow == null");
+            }
+            curWindow.Close();
+        }
 
-		public static bool IsPowerOfTwo(int value)
-		{
-			//While x is even and > 1
-			while (((value % 2) == 0) && value > 1)
-			{
-				value /= 2;
-			}
+        public static bool IsPowerOfTwo(int value)
+        {
+            //While x is even and > 1
+            while (((value % 2) == 0) && value > 1)
+            {
+                value /= 2;
+            }
 
-			return (value == 1);
-		}
+            return (value == 1);
+        }
 
         public static void CreateFolder(string folderPath)
         {
@@ -391,7 +389,7 @@ namespace MA_TextureAtlasserPro
         #region Export
         public static string[] ExportAtlasModels(MA_TextureAtlasserProAtlas atlas, ModelExportSettings modelExportSettings, string material = null, string savePath = EXPORT_ASSET_PATH)
         {
-            switch(modelExportSettings.modelFormat)
+            switch (modelExportSettings.modelFormat)
             {
                 case ModelFormat.None:
                     break;
@@ -457,13 +455,14 @@ namespace MA_TextureAtlasserPro
                             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
+                            //Set name
                             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);
+                            newMesh.name = meshName;
+                            //Save it
+                            string asset = MA_MeshUtils.MA_SaveMeshPrefab(newMesh, meshName, savePath, materialPath: material);
                             assetPaths.Add(asset);
                         }
                     }
@@ -473,8 +472,8 @@ namespace MA_TextureAtlasserPro
             return assetPaths.ToArray();
         }
 
-		private static string[] ExportAtlasObj(MA_TextureAtlasserProAtlas atlas, ModelExportSettings modelExportSettings, string savePath = EXPORT_ASSET_PATH)
-		{
+        private static string[] ExportAtlasObj(MA_TextureAtlasserProAtlas atlas, ModelExportSettings modelExportSettings, string savePath = EXPORT_ASSET_PATH)
+        {
             if (atlas == null || atlas.textureQuads == null)
                 return null;
 
@@ -509,27 +508,27 @@ namespace MA_TextureAtlasserPro
             }
 
             return assetPaths.ToArray();
-		}
+        }
 
-		public static string[] ExportAtlasTextures(MA_TextureAtlasserProAtlas atlas, TextureExportSettings textureExportSettings, string savePath = EXPORT_ASSET_PATH, string tempPath = TEXTURE_ATLASSER_PATH)
-		{
+        public static string[] ExportAtlasTextures(MA_TextureAtlasserProAtlas atlas, TextureExportSettings textureExportSettings, string savePath = EXPORT_ASSET_PATH, string tempPath = TEXTURE_ATLASSER_PATH)
+        {
             switch (textureExportSettings.textureFormat)
             {
                 case TextureFormat.None:
                     break;
                 case TextureFormat.Png:
-			        return ExportAtlasPNG(atlas, textureExportSettings, savePath);
+                    return ExportAtlasPNG(atlas, textureExportSettings, savePath);
                 default:
                     break;
             }
 
             return null;
-		}
+        }
 
-		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;
+        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];
 
@@ -538,17 +537,17 @@ namespace MA_TextureAtlasserPro
 
             //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
-				};
+            {
+                //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)
-					{
+                foreach (MA_TextureAtlasserProQuad q in atlas.textureQuads)
+                {
+                    if (q.textureGroups != null && q.textureGroups[i].texture != null)
+                    {
                         //Make temp copy
                         string orginalTexturePath = AssetDatabase.GetAssetPath(q.textureGroups[i].texture);
                         string orginalTextureExtension = System.IO.Path.GetExtension(orginalTexturePath);
@@ -575,15 +574,15 @@ namespace MA_TextureAtlasserPro
                         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);
+                        newTexture = newTexture.MA_Combine2D(newTexturePart, (int)q.guiRect.x, (int)q.guiRect.y);
 
                         //Delete temp copy
                         AssetDatabase.DeleteAsset(tempTextureImporter.assetPath);
                     }
-				}
+                }
 
-				//Save it
-				newTexture.MA_Save2D(newTexture.name, savePath);
+                //Save it
+                newTexture.MA_Save2D(newTexture.name, savePath);
 
                 assetPaths[i] = (savePath + newTexture.name + '.' + textureExportSettings.textureFormat.ToString());
 
@@ -606,7 +605,7 @@ namespace MA_TextureAtlasserPro
                     default:
                         break;
                 }
-			}
+            }
 
             //Delete temp folder
             DeleteFolder(tempPath);
@@ -615,51 +614,51 @@ namespace MA_TextureAtlasserPro
             AssetDatabase.Refresh();
 
             return assetPaths;
-		}
+        }
 
-		private static void SetAtlasSpriteSettings(MA_TextureAtlasserProAtlas atlas, TextureExportSettings textureExportSettings, string savePath = EXPORT_ASSET_PATH)
-		{
-			//Foreach texture group
-			for (int i = 0; i < atlas.textureGroupRegistration.Count; i++)
-			{
-				//Convert
-				string textureName = atlas.name + "_" + atlas.textureGroupRegistration[i].name + '.' + textureExportSettings.textureFormat.ToString();
-				TextureImporter textureImporter = (TextureImporter)AssetImporter.GetAtPath(savePath + textureName);
-				textureImporter.textureType = TextureImporterType.Sprite;
-				textureImporter.alphaIsTransparency = true;
+        private static void SetAtlasSpriteSettings(MA_TextureAtlasserProAtlas atlas, TextureExportSettings textureExportSettings, string savePath = EXPORT_ASSET_PATH)
+        {
+            //Foreach texture group
+            for (int i = 0; i < atlas.textureGroupRegistration.Count; i++)
+            {
+                //Convert
+                string textureName = atlas.name + "_" + atlas.textureGroupRegistration[i].name + '.' + textureExportSettings.textureFormat.ToString();
+                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>();
+                //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)
-							};
+                    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);
-						}
-					}
+                            spriteMetaData.Add(smd);
+                        }
+                    }
 
-					textureImporter.spritesheet = spriteMetaData.ToArray();
-				}
-				else
-				{
-					textureImporter.spriteImportMode = SpriteImportMode.Single;
-				}
+                    textureImporter.spritesheet = spriteMetaData.ToArray();
+                }
+                else
+                {
+                    textureImporter.spriteImportMode = SpriteImportMode.Single;
+                }
 
-				textureImporter.SaveAndReimport();
-			}
-		}
+                textureImporter.SaveAndReimport();
+            }
+        }
 
         public static string ExportAtlasMaterial(MA_TextureAtlasserProAtlas atlas, MaterialExportSettings materialExportSettings, string[] textures = null, string savePath = EXPORT_ASSET_PATH)
         {
@@ -676,7 +675,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++)
                     {

Assets/MA_ToolBox/MA_Utilities/MeshUtils/MA_MeshUtils.cs

@@ -15,91 +15,102 @@ using UnityEditor;
 
 namespace MA_Mesh
 {
-	public static class MA_MeshUtils
-	{
-		public static string MA_SaveMeshAsset(Mesh mesh, string meshName, string savePath)
-		{
-            Mesh newMesh = mesh;
+    public static class MA_MeshUtils
+    {
+        public static string MA_SaveMeshAsset(Mesh mesh, string savePath)
+        {
+            if (string.IsNullOrEmpty(mesh.name))
+            {
+                mesh.name = UnityEngine.Random.Range(11111, 99999).ToString();
+            }
 
-			if(meshName == "")
-			{
-				newMesh.name = mesh.name;
-			}
-			else
-			{
-				newMesh.name = meshName;
-			}
+            string assetPath = savePath + mesh.name + ".asset";
 
-            string assetPath = savePath + newMesh.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";
+                if (string.IsNullOrEmpty(prefabName))
+                {
+                    prefabName = UnityEngine.Random.Range(11111, 99999).ToString();
+                }
+
+                assetPath = savePath + prefabName + ".prefab";
+
+#if UNITY_2018_3_OR_NEWER
+
                 PrefabUtility.SaveAsPrefabAsset(gameObject, assetPath);
 
+#else
+
+                GameObject go = AssetDatabase.LoadAssetAtPath<GameObject>(assetPath);
+                if (go != null)
+                {
+                    PrefabUtility.ReplacePrefab(gameObject, go, ReplacePrefabOptions.ReplaceNameBased);
+                }
+                else
+                {
+                    PrefabUtility.CreatePrefab(assetPath, gameObject, ReplacePrefabOptions.ReplaceNameBased);
+                }
+
+#endif
+
                 UnityEngine.GameObject.DestroyImmediate(gameObject);
             }
 
             return assetPath;
         }
 
-		public static Mesh MA_DuplicateMesh(Mesh mesh)
-		{
-			Mesh newMesh = new Mesh
-			{
-				name = mesh.name,
-				bounds = mesh.bounds,
-				subMeshCount = mesh.subMeshCount
-			};
+        public static Mesh MA_DuplicateMesh(Mesh mesh)
+        {
+            Mesh newMesh = new Mesh
+            {
+                name = mesh.name,
+                bounds = mesh.bounds,
+                subMeshCount = mesh.subMeshCount
+            };
 
-			newMesh.SetVertices(new List<Vector3>(mesh.vertices));
-			for (int i = 0; i < mesh.subMeshCount; i++)
-			{
-				newMesh.SetTriangles(mesh.GetTriangles(i), i);
-			}
-			newMesh.SetNormals(new List<Vector3>(mesh.normals));
-			newMesh.SetUVs(0, new List<Vector2>(mesh.uv));
-			newMesh.SetTangents(new List<Vector4>(mesh.tangents));
+            newMesh.SetVertices(new List<Vector3>(mesh.vertices));
+            for (int i = 0; i < mesh.subMeshCount; i++)
+            {
+                newMesh.SetTriangles(mesh.GetTriangles(i), i);
+            }
+            newMesh.SetNormals(new List<Vector3>(mesh.normals));
+            newMesh.SetUVs(0, new List<Vector2>(mesh.uv));
+            newMesh.SetTangents(new List<Vector4>(mesh.tangents));
             newMesh.SetColors(new List<Color>(mesh.colors));
 
-			return newMesh;
-		}
+            return newMesh;
+        }
 
-		public static Mesh MA_ReMapUV(this Mesh mesh, Vector2 atlasSize, Vector2 textureSize, Vector2 texturePosition, int uvChannel = 0)
-		{
-			/*
+        public static Mesh MA_ReMapUV(this Mesh mesh, Vector2 atlasSize, Vector2 textureSize, Vector2 texturePosition, int uvChannel = 0)
+        {
+            /*
 			 0     1
 			512 x 512
 
@@ -109,154 +120,154 @@ namespace MA_Mesh
 			+ pos
 			*/
 
-			List<Vector2> uvs = new List<Vector2>();
+            List<Vector2> uvs = new List<Vector2>();
 
-			//Get UV's
-			mesh.GetUVs(uvChannel, uvs);
+            //Get UV's
+            mesh.GetUVs(uvChannel, uvs);
 
-			foreach (Vector2 uvCordinate in uvs)
-			{
-				float x = (uvCordinate.x / atlasSize.x * textureSize.x) + texturePosition.x;
-				float y = (uvCordinate.y / atlasSize.y * textureSize.y) + texturePosition.y;
-				uvCordinate.Set(x, y);
-			}
+            foreach (Vector2 uvCordinate in uvs)
+            {
+                float x = (uvCordinate.x / atlasSize.x * textureSize.x) + texturePosition.x;
+                float y = (uvCordinate.y / atlasSize.y * textureSize.y) + texturePosition.y;
+                uvCordinate.Set(x, y);
+            }
 
-			mesh.SetUVs(uvChannel, uvs);
+            mesh.SetUVs(uvChannel, uvs);
 
-			return mesh;
-		}
+            return mesh;
+        }
 
-		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);
+        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);
+            //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);
-			}
+            //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++)
-			{
-				float newX = uvs[i].x * xMin + xMax;
-				float newY = uvs[i].y * yMin + yMax;
+            for (int i = 0; i < uvs.Count; i++)
+            {
+                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)
-				{
-					newX = Wrap(newX, xMax, xMin + xMax);
-					newY = Wrap(newY, yMax, yMin + yMax);
-				}
+                //Wrap the verts outside of the uv space around back into the uv space.
+                if (wrap)
+                {
+                    newX = Wrap(newX, xMax, xMin + xMax);
+                    newY = Wrap(newY, yMax, yMin + yMax);
+                }
 
-				uvs[i] = new Vector2(newX, newY);
-			}
+                uvs[i] = new Vector2(newX, newY);
+            }
 
-			mesh.SetUVs(uvChannel, uvs);
+            mesh.SetUVs(uvChannel, uvs);
 
-			return 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;
-		}
+        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) 
-		{
-			int vertexOffset = 0;
-			int normalOffset = 0;
-			int uvOffset = 0;
+        //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"));
+            Material material = new Material(Shader.Find("Standard"));
 
-			StringBuilder sb = new StringBuilder();
+            StringBuilder sb = new StringBuilder();
 
-			sb.Append("g ").Append(mesh.name).Append("\n");
+            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));
-			}
+            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");
+            sb.Append("\n");
 
-			foreach(Vector3 v in mesh.normals) 
-			{
-				sb.Append(string.Format("vn {0} {1} {2}\n", -v.x, v.y, v.z));
-			}
+            foreach (Vector3 v in mesh.normals)
+            {
+                sb.Append(string.Format("vn {0} {1} {2}\n", -v.x, v.y, v.z));
+            }
 
-			sb.Append("\n");
+            sb.Append("\n");
 
-			foreach(Vector3 v in mesh.uv) 
-			{
-				sb.Append(string.Format("vt {0} {1}\n", v.x, v.y));
-			}
+            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");
+            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)
+                // {
+                // 	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));
-				}
-			}
+                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;
+            //vertexOffset += mesh.vertices.Length;
+            //normalOffset += mesh.normals.Length;
+            //uvOffset += mesh.uv.Length;
 
-			return sb.ToString();
-		}
+            return sb.ToString();
+        }
 
-		public static string MeshToFile(Mesh mesh, string filename, string savePath) 
-		{
+        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));
-			}
+            {
+                sw.Write(MeshToString(mesh));
+            }
 
             AssetDatabase.Refresh();
 
             return assetPath;
-		}
-		//End
-	}
+        }
+        //End
+    }
 
-	//struct ObjMaterial
-	//{
-	//	public string name;
-	//	public string textureName;
-	//}
+    //struct ObjMaterial
+    //{
+    //	public string name;
+    //	public string textureName;
+    //}
 }
 #endif

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++)
+            for (int y = 0; y < newHeight; y++)
 			{
-				var thisY = Mathf.RoundToInt((ratioY * y) * curWidth);
-				var yw = y * newWidth;
+                int yFloor = Mathf.FloorToInt(y * ratioY);
+                var y1 = (yFloor + 1) * curWidth;
+                var yw = y * newWidth;
 
-				for (int x = 0; x < newWidth; x++)
+                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)];
 				}
 			}
 

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,28 @@
-# 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.
-
+# MA_TextureAtlasser
+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 the UnityPackage here: https://github.com/maxartz15/MA_TextureAtlasser/releases
 
+### Download unitypackage
+https://github.com/maxartz15/MA_TextureAtlasser/releases <br>
 [![Github All Releases](https://img.shields.io/github/downloads/maxartz15/MA_TextureAtlasser/total.svg)]() 
 
-For more information: https://maxartz15.com/ma-textureatlasser/
+### Tested Unity versions
+[![Image](https://img.shields.io/badge/Unity-2017.4-green)]() [![Image](https://img.shields.io/badge/Unity-2018.4-green)]() [![Image](https://img.shields.io/badge/Unity-2019.2-green)]()
+
+## Export options
+### Meshes
+- UnityMesh (with prefab setup)
+- OBJ
+- Replace orginal (this will replace the orginal model, make sure to backup before doing this!)
+### Textures
+- PNG
+- PNG (sliced) sprite sheet
+### Materials
+- Material (with assigned textures and selected shader)
+
+## Resources
+[Youtube video](https://youtu.be/PBRKlopkZP0) <br>
+[Website](https://maxartz15.com/ma-textureatlasser/)