public static void CopySpriteAtlasSetting(SpriteAtlas target, SpriteAtlas template)
{
// 注意：默认设置为False
target.SetIncludeInBuild(false);
// 通用属性
target.SetPackingSettings(template.GetPackingSettings());
target.SetTextureSettings(template.GetTextureSettings());
// 平台设置
target.SetPlatformSettings(template.GetPlatformSettings("Standalone"));
target.SetPlatformSettings(template.GetPlatformSettings("iPhone"));
target.SetPlatformSettings(template.GetPlatformSettings("Android"));
}
protected virtual void OnFirstImport(SpriteAtlas spriteAtlas)
{
spriteAtlas.SetIncludeInBuild(false);
//------- PackingSettings -------
var packingSettings = spriteAtlas.GetPackingSettings();
SetPackingSettings(ref packingSettings);
spriteAtlas.SetPackingSettings(packingSettings);
//------- TextureSettings -------
var textureSettings = spriteAtlas.GetTextureSettings();
SetTextureSettings(ref textureSettings);
spriteAtlas.SetTextureSettings(textureSettings);
//------ PlatformSettings ------
foreach (var platformName in DefaultTargetPlatforms)
{
var platformSetting = spriteAtlas.GetPlatformSettings(platformName.ToString());
SetTexturePlatformSettings(ref platformSetting);
spriteAtlas.SetPlatformSettings(platformSetting);
}
}
public Dictionary <string, string> GetDefaultFields()
{
var defaultSetting = spriteAtlas.GetTextureSettings();
var packingSetting = spriteAtlas.GetPackingSettings();
var platformSetting = spriteAtlas.GetPlatformSettings("Default");
var fieldMap = new Dictionary <string, string>
{
// Basic
["Path/Name"] = Importer.assetPath,
["Atlas Type"] = spriteAtlas.isVariant ? "Variant" : "Master",
// Packing
["Allow Rotation"] = packingSetting.enableRotation.ToString(),
["Tight Packing"] = packingSetting.enableTightPacking.ToString(),
["Padding"] = packingSetting.padding.ToString(),
// Texture
["Read/Write Enabled"] = defaultSetting.readable.ToString(),
["Generate Mip Maps"] = defaultSetting.generateMipMaps.ToString(),
["sRGB (Color Texture)"] = defaultSetting.sRGB.ToString(),
["Max size"] = platformSetting.maxTextureSize.ToString(),
};
if (Editor.EnableLog)
{
UnityEngine.Debug.Log(fieldMap.ToJson());
}
return(fieldMap);
}
private void SetPlatformSetting(SpriteAtlas spriteAtlas)
{
TextureImporterPlatformSettings tips = spriteAtlas.GetPlatformSettings(Platform);
tips.overridden = true;
tips.maxTextureSize = MaxSize;
tips.format = (TextureImporterFormat)(Format);
spriteAtlas.SetPlatformSettings(tips);
}
private void Initialize()
{
spriteAtlas = EditorResources.Load <SpriteAtlas>(Importer.assetPath);
foreach (var platform in Platforms)
{
platformMap[platform] = spriteAtlas.GetPlatformSettings(platform);
}
}
/// <summary>
/// 复制图集设置
/// </summary>
public static void CopySpriteAtlasSetting(SpriteAtlas target, SpriteAtlas template)
{
#if UNITY_2018_4_OR_NEWER
// 注意：默认设置为False
target.SetIncludeInBuild(false);
// 通用属性
target.SetPackingSettings(template.GetPackingSettings());
target.SetTextureSettings(template.GetTextureSettings());
// 平台设置
target.SetPlatformSettings(template.GetPlatformSettings("Standalone"));
target.SetPlatformSettings(template.GetPlatformSettings("iPhone"));
target.SetPlatformSettings(template.GetPlatformSettings("Android"));
#else
Debug.LogWarning($"{Application.unityVersion} is not support copy sprite atlas setting. Please upgrade to unity2018.4 or newer.");
#endif
}
private static bool CheckPlatformSettings(SpriteAtlas atlas, SpriteAtlasSettings settings, BuildTargetGroup buildTargetGroup)
{
var atlasPlatformSettings = atlas.GetPlatformSettings(buildTargetGroup.ToString());
var platformSettings = settings.ImportSettings.GetTextureImporterPlatformSettings(buildTargetGroup);
return(atlasPlatformSettings.textureCompression == platformSettings.textureCompression &&
atlasPlatformSettings.maxTextureSize == platformSettings.maxTextureSize &&
atlasPlatformSettings.format == platformSettings.format &&
atlasPlatformSettings.crunchedCompression == platformSettings.crunchedCompression &&
atlasPlatformSettings.compressionQuality == platformSettings.compressionQuality);
}
static void SetPlatformSettings(string platform, SpriteAtlas spriteAtlas, SoSpriteAtlasPostprocessor so)
{
var soPlatformSettings = so.GetPlatformSettings(platform);
var platformSettings = spriteAtlas.GetPlatformSettings(platform);
platformSettings.overridden = soPlatformSettings.overridden;
platformSettings.format = (TextureImporterFormat)soPlatformSettings.format;
platformSettings.maxTextureSize = soPlatformSettings.maxTextureSize;
platformSettings.compressionQuality = (int)soPlatformSettings.compressionQuality;
spriteAtlas.SetPlatformSettings(platformSettings);
}
public static string[] Export(SpriteAtlas atlas, string dirPath)
{
string platformName = "Standalone";
if (EditorUserBuildSettings.activeBuildTarget == BuildTarget.Android)
{
platformName = "Android";
}
else if (EditorUserBuildSettings.activeBuildTarget == BuildTarget.iOS)
{
platformName = "iPhone";
}
TextureImporterPlatformSettings tips = atlas.GetPlatformSettings(platformName);
TextureImporterPlatformSettings cachedTips = new TextureImporterPlatformSettings();
tips.CopyTo(cachedTips);
tips.overridden = true;
tips.format = TextureImporterFormat.RGBA32;
//tips.maxTextureSize = 1024;
atlas.SetPlatformSettings(tips);
List <string> texturePathList = new List <string>();
SpriteAtlasUtility.PackAtlases(new SpriteAtlas[] { atlas }, EditorUserBuildSettings.activeBuildTarget);
MethodInfo getPreviewTextureMI = typeof(SpriteAtlasExtensions).GetMethod("GetPreviewTextures", BindingFlags.Static | BindingFlags.NonPublic);
Texture2D[] atlasTextures = (Texture2D[])getPreviewTextureMI.Invoke(null, new SystemObject[] { atlas });
if (atlasTextures != null && atlasTextures.Length > 0)
{
for (int i = 0; i < atlasTextures.Length; i++)
{
Texture2D packTexture = atlasTextures[i];
byte[] rawBytes = packTexture.GetRawTextureData();
Texture2D nTexture = new Texture2D(packTexture.width, packTexture.height, packTexture.format, false, false);
nTexture.LoadRawTextureData(rawBytes);
nTexture.Apply();
string textPath = string.Format("{0}/{1}_{2}.png", dirPath, atlas.name, i);
File.WriteAllBytes(textPath, nTexture.EncodeToPNG());
texturePathList.Add(textPath);
}
}
atlas.SetPlatformSettings(cachedTips);
return(texturePathList.ToArray());
}
static void SettingPlat(SpriteAtlas sa, string plat)
{
//设置iphone平台的贴图压缩
TextureImporterPlatformSettings setting = sa.GetPlatformSettings(plat);
if (setting == null)
{
setting = new TextureImporterPlatformSettings();
}
setting.overridden = true;
setting.format = TextureImporterFormat.ASTC_RGBA_4x4;
setting.compressionQuality = 100;
sa.SetPlatformSettings(setting);
}
static bool ComparePlatformSetting(string platform, SoSpriteAtlasPostprocessor texturePostprocessorBase, SpriteAtlas spriteAtlas, ref string message)
{
var so = texturePostprocessorBase.GetPlatformSettings(platform);
var texturePlatformSettings = spriteAtlas.GetPlatformSettings(platform);
var same = true;
var sameInfo = string.Empty;
if (so.overridden != texturePlatformSettings.overridden)
{
same = false;
sameInfo = StringUtil.Contact(sameInfo, "\n", "overridden");
}
if (so.overridden && texturePlatformSettings.overridden)
{
if (so.format != (int)texturePlatformSettings.format)
{
same = false;
sameInfo = StringUtil.Contact(sameInfo, "\n", "format");
}
if ((int)so.compressionQuality != texturePlatformSettings.compressionQuality)
{
same = false;
sameInfo = StringUtil.Contact(sameInfo, "\n", "compressionQuality");
}
if (so.maxTextureSize != texturePlatformSettings.maxTextureSize)
{
same = false;
sameInfo = StringUtil.Contact(sameInfo, "\n", "maxTextureSize");
}
}
if (!same)
{
message = StringUtil.Contact(message, "\n", "<b>platform: ", platform, "</b>", sameInfo);
}
return(same);
}
protected virtual void OnFirstImport(SpriteAtlas spriteAtlas)
{
spriteAtlas.SetIncludeInBuild(false);
//------- PackingSettings -------
var packingSettings = spriteAtlas.GetPackingSettings();
packingSettings.padding = 2;
packingSettings.enableTightPacking = false;
packingSettings.enableRotation = false;
spriteAtlas.SetPackingSettings(packingSettings);
//------- TextureSettings -------
var textureSettings = spriteAtlas.GetTextureSettings();
textureSettings.readable = false;
textureSettings.generateMipMaps = false;
spriteAtlas.SetTextureSettings(textureSettings);
//------ PlatformSettings ------
foreach (var platformName in DefaultTargetPlatforms)
{
var platformSetting = spriteAtlas.GetPlatformSettings(platformName.ToString());
platformSetting.overridden = true;
platformSetting.format = TextureImporterFormat.ASTC_RGBA_4x4;
platformSetting.maxTextureSize = 1024;
spriteAtlas.SetPlatformSettings(platformSetting);
}
}
static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
{
for (int i = 0; i < importedAssets.Length; i++)
{
string assetPath = importedAssets[i].Replace("\\", "/");
if (!assetPath.StartsWith("Assets/Localization/") && !assetPath.StartsWith("Assets/Res/"))
{
continue;
}
if (!AssetDatabase.IsValidFolder(assetPath))
{
continue; //非文件夹文件
}
DirectoryInfo dirAssetInfo = new DirectoryInfo(assetPath);
for (int j = 0; j < _atlasRuleDir.Length; j++)
{
AtlasInfo atlasInfo_Rule = _atlasRuleDir[j];
if (!assetPath.Equals(atlasInfo_Rule.dir) && !assetPath.StartsWith(atlasInfo_Rule.dir + "/"))
{
continue;
}
//命中目标文件夹
if (dirAssetInfo.Parent.FullName.Equals(atlasInfo_Rule.fullName))
{
FileInfo[] atlasFiles = dirAssetInfo.GetFiles("*.spriteatlas", SearchOption.AllDirectories);
FileInfo targetAtlas = null; //文件夹下直属Atlas
for (int k = 0; k < atlasFiles.Length; k++)
{
FileInfo file = atlasFiles[k];
if (targetAtlas == null)
{
if (file.Directory.FullName.Equals(dirAssetInfo.FullName))
{
targetAtlas = file;
}
}
else
{
file.Delete(); //删除其他的Atlas
}
}
string targetName = atlasInfo_Rule.prefix_name + "_" + dirAssetInfo.Name + "_Atlas.spriteatlas";
if (targetAtlas == null) //没有找到直属Atlas
{
AssetDatabase.CreateAsset(new SpriteAtlas(), assetPath + "/" + targetName);
targetAtlas = new FileInfo(dirAssetInfo.FullName + "/" + targetName);
}
else
{
AssetDatabase.RenameAsset(assetPath + "/" + targetAtlas.Name, targetName); //改名
targetAtlas = new FileInfo(dirAssetInfo.FullName + "/" + targetName);
}
//对Atlas进行设置
SpriteAtlas atlas = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(assetPath + "/" + targetAtlas.Name);
SpriteAtlasPackingSettings packingSettings = atlas.GetPackingSettings();
packingSettings.enableRotation = atlasInfo_Rule.isRotation;
packingSettings.enableTightPacking = atlasInfo_Rule.isTight;
packingSettings.padding = 2;
atlas.SetPackingSettings(packingSettings);
TextureImporterPlatformSettings platformSettings = atlas.GetPlatformSettings("iPhone");
platformSettings.overridden = true;
if (platformSettings.maxTextureSize > 2048)
{
platformSettings.maxTextureSize = 2048;
}
platformSettings.format = TextureImporterFormat.ASTC_RGBA_6x6;
atlas.SetPlatformSettings(platformSettings);
atlas.Remove(atlas.GetPackables());
atlas.Add(new [] { AssetDatabase.LoadAssetAtPath <Object>(assetPath) });
}
break;
}
}
}
//================================================================================
// 関数
//================================================================================
/// <summary>
/// 指定された TextureImporter に設定を適用します
/// </summary>
public void Apply(SpriteAtlas spriteAtlas)
{
var packingSettings = spriteAtlas.GetPackingSettings();
if (m_enableRotation.IsOverride)
{
packingSettings.enableRotation = m_enableRotation.Value;
}
if (m_enableTightPacking.IsOverride)
{
packingSettings.enableTightPacking = m_enableTightPacking.Value;
}
if (m_padding.IsOverride)
{
packingSettings.padding = m_padding.Value;
}
spriteAtlas.SetPackingSettings(packingSettings);
var textureSettings = spriteAtlas.GetTextureSettings();
if (m_readable.IsOverride)
{
textureSettings.readable = m_readable.Value;
}
if (m_generateMipMaps.IsOverride)
{
textureSettings.generateMipMaps = m_generateMipMaps.Value;
}
if (m_sRGB.IsOverride)
{
textureSettings.sRGB = m_sRGB.Value;
}
if (m_filterMode.IsOverride)
{
textureSettings.filterMode = m_filterMode.Value;
}
if (m_anisoLevel.IsOverride)
{
textureSettings.anisoLevel = m_anisoLevel.Value;
}
spriteAtlas.SetTextureSettings(textureSettings);
if (m_defaultSettings != null)
{
var platformSettings = spriteAtlas.GetPlatformSettings("DefaultTexturePlatform");
m_defaultSettings.Apply(platformSettings);
spriteAtlas.SetPlatformSettings(platformSettings);
}
if (m_standaloneSettings != null)
{
var platformSettings = spriteAtlas.GetPlatformSettings("Standalone");
m_standaloneSettings.Apply(platformSettings);
spriteAtlas.SetPlatformSettings(platformSettings);
}
if (m_iPhoneSettings != null)
{
var platformSettings = spriteAtlas.GetPlatformSettings("iPhone");
platformSettings.overridden = true;
m_iPhoneSettings.Apply(platformSettings);
spriteAtlas.SetPlatformSettings(platformSettings);
}
if (m_androidSettings != null)
{
var platformSettings = spriteAtlas.GetPlatformSettings("Android");
m_androidSettings.Apply(platformSettings);
spriteAtlas.SetPlatformSettings(platformSettings);
}
if (m_webGLSettings != null)
{
var platformSettings = spriteAtlas.GetPlatformSettings("WebGL");
m_webGLSettings.Apply(platformSettings);
spriteAtlas.SetPlatformSettings(platformSettings);
}
}
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}个图片");
}
private static void ExportAltas()
{
if (Selection.objects == null || Selection.objects.Length == 0)
{
return;
}
string platformName = "Standalone";
if (EditorUserBuildSettings.activeBuildTarget == BuildTarget.Android)
{
platformName = "Android";
}
else if (EditorUserBuildSettings.activeBuildTarget == BuildTarget.iOS)
{
platformName = "iPhone";
}
List <SpriteAtlas> atlasList = new List <SpriteAtlas>();
Dictionary <SpriteAtlas, TextureImporterPlatformSettings> tipsDic = new Dictionary <SpriteAtlas, TextureImporterPlatformSettings>();
foreach (UnityObject uObj in Selection.objects)
{
SpriteAtlas atlas = uObj as SpriteAtlas;
if (atlas != null)
{
atlasList.Add(atlas);
TextureImporterPlatformSettings tips = atlas.GetPlatformSettings(platformName);
TextureImporterPlatformSettings ntips = new TextureImporterPlatformSettings();
tips.CopyTo(ntips);
tipsDic.Add(atlas, ntips);
tips.overridden = true;
tips.format = TextureImporterFormat.RGBA32;
atlas.SetPlatformSettings(tips);
}
}
if (atlasList.Count == 0)
{
EditorUtility.DisplayDialog("Warning", "Can't Found Sprite Atlas In Selection", "OK");
return;
}
UnityEditor.U2D.SpriteAtlasUtility.PackAtlases(atlasList.ToArray(), EditorUserBuildSettings.activeBuildTarget);
string outputDirPath = EditorUtility.OpenFolderPanel("Save Atlas To", "D:/", "");
if (string.IsNullOrEmpty(outputDirPath))
{
EditorUtility.DisplayDialog("Warning", "Please Choose a Folder", "OK");
return;
}
MethodInfo getPreviewTextureMI = typeof(SpriteAtlasExtensions).GetMethod("GetPreviewTextures", BindingFlags.Static | BindingFlags.NonPublic);
foreach (SpriteAtlas atlas in atlasList)
{
Texture2D[] atlasTextures = (Texture2D[])getPreviewTextureMI.Invoke(null, new SystemObject[] { atlas });
if (atlasTextures != null && atlasTextures.Length > 0)
{
for (int i = 0; i < atlasTextures.Length; i++)
{
Texture2D packTexture = atlasTextures[i];
byte[] rawBytes = packTexture.GetRawTextureData();
Texture2D nTexture = new Texture2D(packTexture.width, packTexture.height, packTexture.format, false, false);
nTexture.LoadRawTextureData(rawBytes);
nTexture.Apply();
string textPath = string.Format("{0}/{1}_{2}.png", outputDirPath, atlas.name, i);
File.WriteAllBytes(textPath, nTexture.EncodeToPNG());
}
}
}
foreach (var kvp in tipsDic)
{
kvp.Key.SetPlatformSettings(kvp.Value);
}
}
