protected override void OnInit()
{
var mainSO = ScriptableObject.CreateInstance <TestObject>();
var subSO = ScriptableObject.CreateInstance <TestSubObject>();
subSO.name = "sub";
m_ScriptableObjectPath = Path.Combine(k_TestConfigFolder, "testScriptableObject.asset");
AssetDatabase.CreateAsset(mainSO, m_ScriptableObjectPath);
AssetDatabase.AddObjectToAsset(subSO, m_ScriptableObjectPath);
AssetDatabase.ImportAsset(m_ScriptableObjectPath, ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate);
// create a Sprite atlas, + sprite
m_SpriteAtlasPath = Path.Combine(k_TestConfigFolder, "testAtlas.spriteatlas");
SpriteAtlas spriteAtlas = new SpriteAtlas();
AssetDatabase.CreateAsset(spriteAtlas, m_SpriteAtlasPath);
Texture2D texture = Texture2D.whiteTexture;
byte[] data = texture.EncodeToPNG();
m_TexturePath = Path.Combine(k_TestConfigFolder, "testTexture.png");
File.WriteAllBytes(m_TexturePath, data);
AssetDatabase.ImportAsset(m_TexturePath, ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate);
TextureImporter importer = TextureImporter.GetAtPath(m_TexturePath) as TextureImporter;
importer.textureType = TextureImporterType.Sprite;
importer.spriteImportMode = SpriteImportMode.Single;
importer.SaveAndReimport();
SpriteAtlasExtensions.Add(spriteAtlas, new [] { AssetDatabase.LoadAssetAtPath <Texture>(m_TexturePath) });
SpriteAtlasUtility.PackAtlases(new SpriteAtlas[] { spriteAtlas }, EditorUserBuildSettings.activeBuildTarget, false);
}
string CreateSpriteAtlasWithSprite()
{
// create a Sprite atlas, + sprite
var spriteAtlasPath = GetAssetPath("testAtlas.spriteatlas");
SpriteAtlas spriteAtlas = new SpriteAtlas();
AssetDatabase.CreateAsset(spriteAtlas, spriteAtlasPath);
Texture2D texture = Texture2D.whiteTexture;
byte[] data = texture.EncodeToPNG();
var texturePath = GetAssetPath("testTexture.png");
File.WriteAllBytes(texturePath, data);
AssetDatabase.ImportAsset(texturePath, ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate);
TextureImporter importer = TextureImporter.GetAtPath(texturePath) as TextureImporter;
importer.textureType = TextureImporterType.Sprite;
importer.spriteImportMode = SpriteImportMode.Single;
importer.SaveAndReimport();
SpriteAtlasExtensions.Add(spriteAtlas, new[] { AssetDatabase.LoadAssetAtPath <Texture>(texturePath) });
SpriteAtlasUtility.PackAtlases(new SpriteAtlas[] { spriteAtlas }, EditorUserBuildSettings.activeBuildTarget, false);
return(spriteAtlasPath);
}
public static void CreateAtlas(KeyValuePair <string, AtlasData> atlasData)
{
int atlasNum = 0;
string name;
if (!AssetDatabase.IsValidFolder("Assets/SpriteAtlas"))
{
AssetDatabase.CreateFolder("Assets", "SpriteAtlas");
}
foreach (var group in atlasData.Value.groups)
{
SpriteAtlas spriteAtlas = new SpriteAtlas();
if (group.android.overridden)
{
spriteAtlas.SetPlatformSettings(group.android);
}
if (group.iphone.overridden)
{
spriteAtlas.SetPlatformSettings(group.iphone);
}
// if the group have non-alpha textures, I set RGB24 as a default.
if (!group.hasAlpha)
{
group.normal.format = TextureImporterFormat.RGB24;
}
spriteAtlas.SetPlatformSettings(group.normal);
if (atlasNum > 0)
{
name = atlasData.Key + " (Group " + atlasNum.ToString() + ")";
}
else
{
name = atlasData.Key;
}
AssetDatabase.CreateAsset(spriteAtlas, "Assets/SpriteAtlas/" + name + ".spriteatlas");
foreach (var texturePath in group.textures)
{
Object s = AssetDatabase.LoadAssetAtPath <Object>(texturePath);
if (s != null)
{
SpriteAtlasExtensions.Add(spriteAtlas, new [] { s });
}
}
atlasNum++;
}
AssetDatabase.SaveAssets();
}
public SpriteAtlas SetUpSpriteAtlas(int numAtlasObjects, out List <Object> subAssets)
{
// Setup Sprite data
var texture = new Texture2D(32, 32);
var data = ImageConversion.EncodeToPNG(texture);
UnityEngine.Object.DestroyImmediate(texture);
// Setup Sprites
subAssets = new List <Object>();
Directory.CreateDirectory(ConfigFolder + "/test");
var atlasPath = ConfigFolder + "/test" + "/testAtlas.spriteatlas";
var newAtlas = new SpriteAtlas();
var sprites = new Object[numAtlasObjects];
for (int i = 0; i < numAtlasObjects; i++)
{
// Create Sprite asset
AssetDatabase.GenerateUniqueAssetPath(ConfigFolder);
var newSpritePath = ConfigFolder + "/test" + "/testSprite" + i + ".png";
File.WriteAllBytes(newSpritePath, data);
AssetDatabase.ImportAsset(newSpritePath, ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate);
var importer = (TextureImporter)AssetImporter.GetAtPath(newSpritePath);
importer.textureType = TextureImporterType.Sprite;
importer.spriteImportMode = SpriteImportMode.Multiple;
importer.spritesheet = new SpriteMetaData[] { new SpriteMetaData()
{
name = "topleft", pivot = Vector2.zero, rect = new Rect(0, 0, 16, 16)
},
new SpriteMetaData()
{
name = "testSprite" + i, pivot = Vector2.zero, rect = new Rect(16, 16, 16, 16)
} };
importer.SaveAndReimport();
// Add sprite to subassets
Object spr = AssetDatabase.LoadAssetAtPath(newSpritePath, typeof(Sprite));
spr.name = "testSprite" + i;
sprites[i] = spr;
subAssets.Add(spr);
}
// Setup Atlas
newAtlas.Add(sprites);
AssetDatabase.CreateAsset(newAtlas, atlasPath);
AssetDatabase.Refresh();
SpriteAtlasExtensions.Add(newAtlas, sprites);
SpriteAtlasUtility.PackAtlases(new SpriteAtlas[] { newAtlas }, EditorUserBuildSettings.activeBuildTarget, false);
var atlasGuid = AssetDatabase.AssetPathToGUID(atlasPath);
Settings.CreateOrMoveEntry(atlasGuid, Settings.groups[0]);
return(newAtlas);
}
private void DialogEventEdit(ScenimaticEvent eventData)
{
eventData.text = WithoutSelectAll(() => EditorGUILayout.TextArea(eventData.text));
if (eventData.sprite == null && nodeGraph.spriteAtlas != null)
{
eventData.sprite = nodeGraph.spriteAtlas.GetSprite(eventData.image);
}
Sprite newSprite = (Sprite)EditorGUILayout.ObjectField("", // this space won't go away :/
eventData.sprite, typeof(Sprite), false, GUILayout.MaxWidth(65)); // so's shrinks it I does
if (newSprite != eventData.sprite && newSprite != null)
{
if (nodeGraph.spriteAtlas == null)
{
string path = EditorUtility.OpenFilePanelWithFilters(
"No Sprite Atlas selected. A Sprite Atlas must be selected to continue.",
"", new string[] { "SpriteAtlas", "spriteatlas" });
if (string.IsNullOrEmpty(path))
{
Debug.LogError("Sprite Atlas not set. Sprite Atlas must be set to select images.");
return;
}
nodeGraph.spriteAtlas = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(
path.Substring(path.IndexOf(@"Assets/")));
}
if (nodeGraph.spriteAtlas.GetPackables().Contains(newSprite))
{
eventData.sprite = newSprite;
eventData.image = newSprite.name;
}
else
{
eventData.sprite = newSprite;
// prompt to add sprite to sprite atlas
if (EditorUtility.DisplayDialog("Add to SpriteAtlas?",
"This sprite is not in the selected Sprite Atlas."
+ "\nAdd it to " + nodeGraph.spriteAtlas.name + "?"
+ "\n(If no is selected, the image will not be saved.)",
"Yes", "No"))
{
eventData.image = newSprite.name;
SpriteAtlasExtensions.Add(
nodeGraph.spriteAtlas, new Object[] { eventData.sprite });
// unfortunately the following lines don't seem to have the desired effect
// that is, an automatic push of the "Pack Preview" button
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
}
}
}
private static void AddPackAtlas(SpriteAtlas atlas, Object[] spt)
{
//MethodInfo methodInfo = System.Type
// .GetType("UnityEditor.U2D.SpriteAtlasExtensions, UnityEditor")
// .GetMethod("Add", BindingFlags.Public | BindingFlags.Static);
//if (methodInfo != null)
// methodInfo.Invoke(null, new object[] { atlas, spt });
//else
// Debug.Log("methodInfo is null");
SpriteAtlasExtensions.Add(atlas, spt);
PackAtlas(atlas);
}
//[MenuItem("Assets/SpriteAtlas Migrate")]
public static void SpriteAtlasMigrator()
{
List <string> TexturesList = new List <string>();
List <string> SpriteAtlasList = new List <string>();
Dictionary <string, List <string> > spriteTagMap = new Dictionary <string, List <string> >();
SortedSet <string> SpritesInAtlas = new SortedSet <string>();
foreach (string s in AssetDatabase.GetAllAssetPaths())
{
if (s.StartsWith("Packages") || s.StartsWith("ProjectSettings") || s.Contains("scene"))
{
continue;
}
bool hasSprite = GetTagIfTexture(s, ref spriteTagMap);
if (hasSprite)
{
TexturesList.Add(s);
}
else if (s.Contains("spriteatlas"))
{
bool hasSpriteAtlas = CacheSpriteAtlasSprites(s, ref SpritesInAtlas);
if (hasSpriteAtlas)
{
SpriteAtlasList.Add(s);
}
}
}
foreach (KeyValuePair <string, List <string> > tag in spriteTagMap)
{
bool found = SpriteAtlasList.Contains(tag.Key);
if (!found)
{
string atlasPath = "Assets/" + tag.Key + ".spriteatlas";
SpriteAtlas sa = new SpriteAtlas();
AssetDatabase.CreateAsset(sa, atlasPath);
sa.name = tag.Key;
List <string> ss = tag.Value;
foreach (string s in ss)
{
Object o = GetTexture(s);
SpriteAtlasExtensions.Add(sa, new Object[] { o });
}
AssetDatabase.SaveAssets();
}
}
}
public static void CreateAtlasForSelectedSprites()
{
SpriteAtlas sa = new SpriteAtlas();
AssetDatabase.CreateAsset(sa, "Assets/sample.spriteatlas");
foreach (var obj in Selection.objects)
{
Object o = obj as Sprite;
if (o != null)
{
SpriteAtlasExtensions.Add(sa, new Object[] { o });
}
}
AssetDatabase.SaveAssets();
}
private static Dictionary <string, SpriteAtlas> GenerateAtlases()
{
Dictionary <string, SpriteAtlas> atlasDictionary = new Dictionary <string, SpriteAtlas>();
Dictionary <string, List <Sprite> > spriteDictionary = FindSprites();
foreach (KeyValuePair <string, List <Sprite> > pair in spriteDictionary)
{
string directory = pair.Key;
List <Sprite> sprites = pair.Value;
SpriteAtlas atlas = new SpriteAtlas();
SpriteAtlasExtensions.Add(atlas, sprites.ToArray());
atlasDictionary[directory] = atlas;
}
return(atlasDictionary);
}
/// <summary>
/// 设置图集
/// </summary>
/// <param name="directoryName"></param>
/// <param name="relativePath"></param>
private static void SetSpriteAtlas(string relativePath)
{
string spriteAtlasPath = relativePath + ".spriteatlas";
SpriteAtlas spriteAtlas = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(spriteAtlasPath);
if (spriteAtlas == null)
{
spriteAtlas = new SpriteAtlas();
AssetDatabase.CreateAsset(spriteAtlas, spriteAtlasPath);
SpriteAtlasPackingSettings spriteAtlasPackingSettings = SpriteAtlasExtensions.GetPackingSettings(spriteAtlas);
spriteAtlasPackingSettings.enableTightPacking = false;
spriteAtlasPackingSettings.padding = 2;
SpriteAtlasTextureSettings spriteAtlasTextureSettings = SpriteAtlasExtensions.GetTextureSettings(spriteAtlas);
spriteAtlasTextureSettings.sRGB = true;
var obj = AssetDatabase.LoadMainAssetAtPath(relativePath);
UnityEngine.Object[] objects = new UnityEngine.Object[] { obj };
SpriteAtlasExtensions.Add(spriteAtlas, objects);
}
}
static void CreateSpriteAtlas()
{
Object[] objs = Selection.objects;
string selePath = AssetDatabase.GetAssetPath(objs[0]);
string spriteAtlasName = Directory.GetParent(AssetDatabase.GetAssetPath(objs[0])).Name; //图集名字
if ((AssetDatabase.LoadAssetAtPath(selePath, typeof(Sprite))) == null)
{
Debug.LogError("请选择需要打包的Sprite图片");
return; //返回
}
int index = selePath.LastIndexOf("/");
selePath = selePath.Remove(index, selePath.Length - index);
SpriteAtlas spriteAtlas = new SpriteAtlas();
SpriteAtlasExtensions.Add(spriteAtlas, objs);
AssetDatabase.CreateAsset(spriteAtlas, selePath + "/" + spriteAtlasName + ".spriteatlas");
SpriteAtlasUtility.PackAtlases(new SpriteAtlas[] { spriteAtlas }, EditorUserBuildSettings.activeBuildTarget);
Debug.Log(ColorToolRich.ColorYellow("图集打包成功"));
}
private static void PackedAuto()
{
string uipath = Application.dataPath + "/UI/";
SpriteAtlasPackingSettings setting = new SpriteAtlasPackingSettings();
setting.enableRotation = false;
setting.enableTightPacking = false;
//SpriteAtlasTextureSettings texSetting = new SpriteAtlasTextureSettings();
TextureImporterPlatformSettings texPlatSetting = new TextureImporterPlatformSettings();
texPlatSetting.maxTextureSize = 2048;
texPlatSetting.crunchedCompression = true;
texPlatSetting.compressionQuality = 100;
string[] dirs = Directory.GetDirectories(uipath);
foreach (string dir in dirs)
{
string folderName = dir.Replace(uipath, "");
string sourcePath = dir.Replace(Application.dataPath, "Assets");
string[] guids = AssetDatabase.FindAssets("t:Sprite", new string[] { sourcePath });
if (guids.Length > 0)
{
List <Sprite> listSpite = new List <Sprite>();
foreach (string guid in guids)
{
Sprite s = AssetDatabase.LoadAssetAtPath <Sprite>(AssetDatabase.GUIDToAssetPath(guid)) as Sprite;
listSpite.Add(s);
}
string dest = string.Format("Assets/UIAtlas/{0}.spriteatlas", folderName.ToLower());
SpriteAtlas atlas = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(dest);
if (atlas)
{
SpriteAtlasExtensions.Remove(atlas, atlas.GetPackables());
}
else
{
atlas = new SpriteAtlas();
atlas.SetPackingSettings(setting);
atlas.SetPlatformSettings(texPlatSetting);
AssetDatabase.CreateAsset(atlas, dest);
}
SpriteAtlasExtensions.Add(atlas, listSpite.ToArray());
EditorUtility.SetDirty(atlas);
}
}
EditorUtility.DisplayDialog("提示", "创建图集成功", "确认");
//ICON ATLAS 重icon collection來
//找 iconid to sprite collection
/*string[] iconcollectons = AssetDatabase.FindAssets("t:IconIdToSpriteCollection", new string[]{ "Assets/MainAssets/IconCollection/Auto"});
* foreach (var collectionGuid in iconcollectons)
* {
* IconIdToSpriteCollection iconCollection = AssetDatabase.LoadAssetAtPath<IconIdToSpriteCollection>(AssetDatabase.GUIDToAssetPath(collectionGuid));
*
* if (iconcollectons != null)
* {
* string dest = string.Format("Assets/MainAssets/ArtAssets/BundleAssets/IconCollectionAtlas/atlas_iconcollection_{0}.spriteatlas", iconCollection.name.ToLower());
* SpriteAtlas atlas = AssetDatabase.LoadAssetAtPath<SpriteAtlas>(dest);
* if (atlas)
* {
* SpriteAtlasExtensions.Remove(atlas, atlas.GetPackables());
* }
* else
* {
* atlas = new SpriteAtlas();
* atlas.SetPackingSettings(setting);
* AssetDatabase.CreateAsset(atlas, dest);
* }
*
* Object[] t = iconCollection.GetAllSprites().ToArray();
* SpriteAtlasExtensions.Add(atlas, t);
*
*
* EditorUtility.SetDirty(atlas);
* }
* }*/
AssetDatabase.SaveAssets();
}
static void HandleSpriteAtlasFormat(HashSet <string> atlasFiles)
{
string[] atlasFileArray = new string[ATLAS_TYPE_NUMBER];
SpriteAtlas[] spriteAtlasArray = new SpriteAtlas[ATLAS_TYPE_NUMBER];
SpriteAtlasPackingSettings[] packingSettingsArray = new SpriteAtlasPackingSettings[ATLAS_TYPE_NUMBER];
SpriteAtlasTextureSettings[] textureSettingsArray = new SpriteAtlasTextureSettings[ATLAS_TYPE_NUMBER];
Dictionary <string, TextureImporterPlatformSettings>[] platformSettingsDictArray = new Dictionary <string, TextureImporterPlatformSettings> [ATLAS_TYPE_NUMBER];
platformSettingsDictArray[0] = new Dictionary <string, TextureImporterPlatformSettings>();
platformSettingsDictArray[1] = new Dictionary <string, TextureImporterPlatformSettings>();
foreach (string file in atlasFiles)
{
if (file.EndsWith(LOW_ATLAS_SUFFIX))
{
continue;
}
atlasFileArray[0] = file;
atlasFileArray[1] = file.Replace(EditorResourcePaths.ATLAS_SUFFIX, LOW_ATLAS_SUFFIX);
for (int i = 0; i < ATLAS_TYPE_NUMBER; i++)
{
spriteAtlasArray[i] = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(atlasFileArray[i]);
packingSettingsArray[i] = SpriteAtlasExtensions.GetPackingSettings(spriteAtlasArray[i]);
textureSettingsArray[i] = SpriteAtlasExtensions.GetTextureSettings(spriteAtlasArray[i]);
foreach (string platform in PLATFORMS)
{
platformSettingsDictArray[i][platform] = SpriteAtlasExtensions.GetPlatformSettings(spriteAtlasArray[i], platform);
}
}
HashSet <string> spriteSet = EditorResourcePaths.GetDependencies(atlasFileArray, EditorResourcePaths.PNG_REGEX);
bool containAlpha = false;
foreach (string spriteFile in spriteSet)
{
Texture2D texture = EditorCommonUtils.ReadTexture(spriteFile);
if (ContainAlpha(texture))
{
containAlpha = true;
break;
}
}
for (int i = 0; i < ATLAS_TYPE_NUMBER; i++)
{
packingSettingsArray[i].enableRotation = false;
packingSettingsArray[i].enableTightPacking = false;
SetDefaultTextureSettings(ref textureSettingsArray[i]);
}
if (containAlpha)
{
SetPlatformTextureSettings(platformSettingsDictArray[0]["Default"], "Default", TextureImporterFormat.RGBA32);
SetPlatformTextureSettings(platformSettingsDictArray[0]["Standalone"], "Standalone", TextureImporterFormat.DXT5);
SetPlatformTextureSettings(platformSettingsDictArray[0]["Android"], "Android", TextureImporterFormat.ETC2_RGBA8);
SetPlatformTextureSettings(platformSettingsDictArray[0]["iPhone"], "iPhone", IOS_NEW_RGBA);
SetPlatformTextureSettings(platformSettingsDictArray[1]["Default"], "Default", TextureImporterFormat.RGBA32);
SetPlatformTextureSettings(platformSettingsDictArray[1]["Standalone"], "Standalone", TextureImporterFormat.DXT5Crunched);
SetPlatformTextureSettings(platformSettingsDictArray[1]["Android"], "Android", TextureImporterFormat.ETC2_RGBA8Crunched);
SetPlatformTextureSettings(platformSettingsDictArray[1]["iPhone"], "iPhone", TextureImporterFormat.PVRTC_RGBA4);
}
else
{
SetPlatformTextureSettings(platformSettingsDictArray[0]["Default"], "Default", TextureImporterFormat.RGB24);
SetPlatformTextureSettings(platformSettingsDictArray[0]["Standalone"], "Standalone", TextureImporterFormat.DXT1);
SetPlatformTextureSettings(platformSettingsDictArray[0]["Android"], "Android", TextureImporterFormat.ETC2_RGB4);
SetPlatformTextureSettings(platformSettingsDictArray[0]["iPhone"], "iPhone", TextureImporterFormat.PVRTC_RGB4);
SetPlatformTextureSettings(platformSettingsDictArray[1]["Default"], "Default", TextureImporterFormat.RGB24);
SetPlatformTextureSettings(platformSettingsDictArray[1]["Standalone"], "Standalone", TextureImporterFormat.DXT1Crunched);
SetPlatformTextureSettings(platformSettingsDictArray[1]["Android"], "Android", TextureImporterFormat.ETC_RGB4Crunched);
SetPlatformTextureSettings(platformSettingsDictArray[1]["iPhone"], "iPhone", TextureImporterFormat.PVRTC_RGB4);
}
for (int i = 0; i < ATLAS_TYPE_NUMBER; i++)
{
SpriteAtlasExtensions.SetIncludeInBuild(spriteAtlasArray[i], false);
SpriteAtlasExtensions.SetPackingSettings(spriteAtlasArray[i], packingSettingsArray[i]);
SpriteAtlasExtensions.SetTextureSettings(spriteAtlasArray[i], textureSettingsArray[i]);
foreach (string platform in PLATFORMS)
{
SpriteAtlasExtensions.SetPlatformSettings(spriteAtlasArray[i], platformSettingsDictArray[i][platform]);
}
}
SpriteAtlasExtensions.SetIsVariant(spriteAtlasArray[1], false);
SpriteAtlasExtensions.Remove(spriteAtlasArray[1], SpriteAtlasExtensions.GetPackables(spriteAtlasArray[1]));
SpriteAtlasExtensions.Add(spriteAtlasArray[1], SpriteAtlasExtensions.GetPackables(spriteAtlasArray[0]));
}
AssetDatabase.Refresh();
}
public static void CreateSpriteAtlas(string src_path, string dst_path, string atlas_name, bool includeInBuild = true)
{
if (string.IsNullOrEmpty(src_path) || string.IsNullOrEmpty(dst_path) || string.IsNullOrEmpty(atlas_name))
{
Log.LogError($"无法创建图集,路径为空. src_path={src_path} ,dst_path={dst_path} ,atlas_name={atlas_name}");
return;
}
if (!src_path.EndsWith("/"))
{
src_path = src_path + "/";
}
var full_path = Path.GetFullPath(src_path);
if (!Directory.Exists(full_path))
{
Log.Info($"不创建图集,{src_path}下无atlas文件夹");
return;
}
var assets = Directory.GetFiles(full_path, "*.png"); //这里无法过滤两种类型 *.png|*.jpg
if (assets == null || assets.Length == 0)
{
Log.Info($"{src_path}下无图片，不生成图集");
return;
}
SpriteAtlas spriteAtlas = new SpriteAtlas();
if (!dst_path.EndsWith("/"))
{
dst_path = dst_path + "/";
}
if (!Directory.Exists(dst_path))
{
Directory.CreateDirectory(dst_path);
}
AssetDatabase.CreateAsset(spriteAtlas, dst_path + atlas_name + ".spriteatlas");
foreach (var path in assets)
{
var t = src_path + Path.GetFileName(path);
var o = AssetDatabase.LoadAssetAtPath <Sprite>(t);
if (o != null)
{
SpriteAtlasExtensions.Add(spriteAtlas, new Object[] { o });
}
}
//TODO 根据平台设置图集格式 //EditorUserBuildSettings.activeBuildTarget
var atlasSetting = spriteAtlas.GetPlatformSettings(KResourceModule.GetBuildPlatformName());
atlasSetting.maxTextureSize = 2048;
atlasSetting.textureCompression = TextureImporterCompression.Compressed;
atlasSetting.format = TextureImporterFormat.Automatic;
spriteAtlas.SetIncludeInBuild(includeInBuild);
spriteAtlas.SetPlatformSettings(atlasSetting);
SpriteAtlasUtility.PackAtlases(new SpriteAtlas[] { spriteAtlas }, EditorUserBuildSettings.activeBuildTarget, false);
AssetDatabase.SaveAssets();
Log.Info($"创建图集{spriteAtlas.name}完成，包含{spriteAtlas.spriteCount}个图片");
}
public static void CreateAtlasAsset()
{
var selection = Selection.objects;
string path = string.Empty;
StringBuilder sb = new StringBuilder();
string tagName = string.Empty;
foreach (Object s in selection)
{
if (s is DefaultAsset && (path = AssetDatabase.GetAssetPath(s)) != null && Directory.Exists(path))
{
var ragName = s.name.ToLower() + "_atlas.spriteatlas";
string atlas_path = Path.Combine(path, ragName);
tagName = s.name.ToLower() + "_atlas";
sb.Append("Crate atlas Asset :");
sb.Append(ragName);
sb.Append("\r\n");
var allchildren = EditorUtils.getAllChildFiles(path, @"\.meta$|\.manifest$|\.DS_Store$|\.u$", null, false);
int count = 0;
List <int> names = new List <int>();
List <Sprite> allSprites = new List <Sprite>();
foreach (var f in allchildren)
{
count++;
TextureImporter ti = AssetImporter.GetAtPath(f) as TextureImporter;
if (ti != null)
{
if (ti.textureType != TextureImporterType.Sprite)
{
ti.textureType = TextureImporterType.Sprite;
}
Object[] objs = AssetDatabase.LoadAllAssetRepresentationsAtPath(f);
foreach (var item in objs)
{
if (item is Sprite)
{
sb.AppendLine(item.name);
names.Add(UnityEngine.Animator.StringToHash(item.name));
allSprites.Add((Sprite)item);
}
}
// ti.spritePackingTag = tagName;
// ti.assetBundleName = tagName + Common.CHECK_ASSETBUNDLE_SUFFIX;
EditorUtility.DisplayProgressBar("Processing...", "生成中... (" + count + " / " + allchildren.Count + ")", count / allchildren.Count);
}
else
{
Debug.LogWarningFormat("{0} is not Texture ", f);
}
}
EditorUtility.ClearProgressBar();
//生成或者替换资源
var atlas = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(atlas_path);
if (atlas == null)
{
atlas = new SpriteAtlas();
AssetDatabase.CreateAsset(atlas, atlas_path);
SpriteAtlasPackingSettings packSet = new SpriteAtlasPackingSettings()
{
blockOffset = 1,
enableRotation = false,
enableTightPacking = false,
padding = 2,
};
atlas.SetPackingSettings(packSet);
SpriteAtlasTextureSettings textureSet = new SpriteAtlasTextureSettings()
{
readable = false,
generateMipMaps = false,
sRGB = false,
filterMode = FilterMode.Bilinear,
};
atlas.SetTextureSettings(textureSet);
}
SpriteAtlasExtensions.Add(atlas, allSprites.ToArray());
EditorUtility.SetDirty(atlas);
var groupAssets = new List <string>();
groupAssets.Add(atlas_path);
var atlasGroup = AASEditorUtility.FindGroup(tagName, AASEditorUtility.DefaltGroupSchema[0]);
AASEditorUtility.SetGroupAddress(AASEditorUtility.LoadAASSetting(), atlasGroup, groupAssets);
sb.AppendFormat("build {0} success count = {1} ", ragName, names.Count);
AssetDatabase.SaveAssets();
}
}
sb.AppendLine("\r\nall completed");
Debug.Log(sb.ToString());
EditorUtils.WriteToTmpFile(tagName + ".txt", sb.ToString());
}
