public static void ApplySettings(this SpriteAtlas atlas, SpriteAtlasSettings settings)
{
var textureSettings = settings.ImportSettings.GetTextureImporterSettings();
var atlasTextureSettings = new SpriteAtlasTextureSettings
{
generateMipMaps = textureSettings.mipmapEnabled,
filterMode = textureSettings.filterMode,
readable = textureSettings.readable,
sRGB = textureSettings.sRGBTexture
};
var atlasPackingSettings = new SpriteAtlasPackingSettings
{
padding = settings.Padding,
enableRotation = settings.AllowRotation,
enableTightPacking = settings.TightPacking
};
var platformSettings = settings.ImportSettings.GetTextureImporterPlatformSettings(EditorUserBuildSettings.selectedBuildTargetGroup);
atlas.SetTextureSettings(atlasTextureSettings);
atlas.SetPackingSettings(atlasPackingSettings);
atlas.SetPlatformSettings(platformSettings);
atlas.SetIncludeInBuild(settings.IncludeInBuild);
atlas.SetIsVariant(settings.Type == SpriteAtlasType.Variant);
}
// 设置参数
static void AtlasSetting(SpriteAtlas atlas)
{
atlas.SetIncludeInBuild(false);
SpriteAtlasPackingSettings packSetting = new SpriteAtlasPackingSettings()
{
blockOffset = 2,
enableRotation = false,
enableTightPacking = false,
padding = 2,
};
atlas.SetPackingSettings(packSetting);
SpriteAtlasTextureSettings textureSetting = new SpriteAtlasTextureSettings()
{
readable = false,
generateMipMaps = false,
sRGB = true,
filterMode = FilterMode.Bilinear,
};
atlas.SetTextureSettings(textureSetting);
TextureImporterPlatformSettings platformSetting = new TextureImporterPlatformSettings()
{
maxTextureSize = DefineSpritePacker.kDefaultMaxSprite,
format = TextureImporterFormat.Automatic,
textureCompression = TextureImporterCompression.Compressed,
crunchedCompression = true,
compressionQuality = DefineSpritePacker.kDefaultQuality,
};
atlas.SetPlatformSettings(platformSetting);
}
//static void OnPostprocessAllAssets(string[] importedAssets, string[] deleteAssets, string[] moveAssets, string[] moveFromAssetPaths)
//{
// if (LsyTextureManager.Instance!=null && LsyTextureImporter.Mode == LsyTextureImporterMode.manual)
// return;
// for (int i = 0; i < importedAssets.Length; i++)
// {
// if (importedAssets[i].EndsWith(".spriteatlas")) {
// OnPostprocessSpriteAtlas(importedAssets[i]);
// }
// }
//}
static void OnPostprocessSpriteAtlas(string path)
{
SpriteAtlas sa = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(path);
if (sa != null)
{
sa.SetIncludeInBuild(false);
SpriteAtlasPackingSettings saps = new SpriteAtlasPackingSettings();
saps.enableRotation = false;
saps.enableTightPacking = false;
saps.padding = 4;
saps.blockOffset = 1;
sa.SetPackingSettings(saps);
SpriteAtlasTextureSettings sats = new SpriteAtlasTextureSettings();
sats.readable = false;
sats.generateMipMaps = false;
sats.sRGB = true;
sats.filterMode = FilterMode.Bilinear;
sa.SetTextureSettings(sats);
SettingPlat(sa, "iPhone");
SettingPlat(sa, "Android");
}
}
public static void CreateSpriteAtlas()
{
string folder = GetCurrentFolder();
var path = folder + "/" + "SpriteAtlas.spriteAtlas";
path = AssetDatabase.GenerateUniqueAssetPath(path);
var atlas = new SpriteAtlas();
SpriteAtlasPackingSettings packing = new SpriteAtlasPackingSettings();
packing.enableRotation = false;
packing.enableTightPacking = false;
packing.padding = 4;
packing.blockOffset = 1;
atlas.SetPackingSettings(packing);
SpriteAtlasTextureSettings tex = new SpriteAtlasTextureSettings();
tex.generateMipMaps = false;
tex.filterMode = FilterMode.Point;
tex.sRGB = true;
atlas.SetTextureSettings(tex);
TextureImporterPlatformSettings platform = new TextureImporterPlatformSettings();
platform.maxTextureSize = 2048;
platform.textureCompression = TextureImporterCompression.Uncompressed;
platform.crunchedCompression = false;
atlas.SetPlatformSettings(platform);
AssetDatabase.CreateAsset(atlas, path);
}
private void CreateSpriteAtlas(List <Sprite> sprites)
{
var path = directoryName + "/" + fileName + ".spriteatlas";
var atlas = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(path);
if (atlas == null)
{
atlas = new SpriteAtlas();
AssetDatabase.CreateAsset(atlas, path);
}
var texSetting = new SpriteAtlasTextureSettings();
texSetting.filterMode = FilterMode.Point;
texSetting.generateMipMaps = false;
var packSetting = new SpriteAtlasPackingSettings();
packSetting.padding = 2;
packSetting.enableRotation = false;
packSetting.enableTightPacking = true;
var platformSetting = new TextureImporterPlatformSettings();
platformSetting.textureCompression = TextureImporterCompression.Uncompressed;
atlas.SetTextureSettings(texSetting);
atlas.SetPackingSettings(packSetting);
atlas.SetPlatformSettings(platformSetting);
atlas.Add(sprites.ToArray());
EditorUtility.SetDirty(atlas);
AssetDatabase.SaveAssets();
}
//创建atlas
void _GenerateSpriteAtlas(Dictionary <string, AtlasConf> dictFolders, string output, bool buildin)
{
Dictionary <string, SpriteAtlas> dictSpriteAtlas = new Dictionary <string, SpriteAtlas>();
var files = Directory.GetFiles(output, "*.spriteatlas", SearchOption.AllDirectories);
foreach (var file in files)
{
var assetPath = file.Replace(Application.dataPath, string.Empty);
//Debug.Log($"{assetPath}");
var asset = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(assetPath);
if (asset == null)
{
Debug.LogError($"{assetPath}不存在");
continue;
}
var atlasName = Path.GetFileNameWithoutExtension(assetPath);
if (!dictFolders.ContainsKey(atlasName))
{
XDebug.Log(XUIConst.Tag, $"{atlasName} 目前是多余的 assetPath:{assetPath}");
continue;
}
dictSpriteAtlas.Add(atlasName, asset);
}
//更新或创建图集
foreach (var pairs in dictFolders)
{
var atlasName = pairs.Key;
if (string.IsNullOrEmpty(atlasName))
{
continue;
}
SpriteAtlas atlasAsset = null;
if (dictSpriteAtlas.ContainsKey(atlasName))
{
atlasAsset = dictSpriteAtlas[atlasName];
}
else
{
atlasAsset = new SpriteAtlas();
SpriteAtlasPackingSettings spriteAtlasPackingSettings = new SpriteAtlasPackingSettings()
{
blockOffset = 1,
enableRotation = false,
enableTightPacking = false,
padding = 2,
};
atlasAsset.SetPackingSettings(spriteAtlasPackingSettings);
var savepath = _MakeAtlasPath(output, atlasName);
XUtilities.MakePathExist(savepath);
AssetDatabase.CreateAsset(atlasAsset, savepath);
}
atlasAsset.SetIncludeInBuild(buildin);
//添加文件夹
atlasAsset.Remove(atlasAsset.GetPackables());
atlasAsset.Add(pairs.Value.Folders.ToArray());
pairs.Value.atlas = atlasAsset;
AssetDatabase.SaveAssets();
}
}
public static void GenSpriteAtlas()
{
var addressGroupConfig = AssetDatabase.LoadAssetAtPath <BundleGroups>(BundleGroupConfigPath);
if (addressGroupConfig)
{
var atlasItems = addressGroupConfig.SpriteAtlasItems;
EditorUtility.DisplayProgressBar("图集", "生成图集中", 0);
List <string> spriteAtlasKeys = new List <string>();
foreach (var item in atlasItems)
{
var assets = item.GetAllAssets();
foreach (var path in assets)
{
var atlasFileName = path + ".spriteatlas";
if (Directory.GetDirectories(path).Length == 0)
{
if (!File.Exists(atlasFileName))
{
var obj = AssetDatabase.LoadMainAssetAtPath(path);
if (obj)
{
SpriteAtlas spriteAtlas = new SpriteAtlas();
spriteAtlas.Add(new UnityEngine.Object[] { obj });
AssetDatabase.CreateAsset(spriteAtlas, atlasFileName);
}
}
}
var atlas = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(atlasFileName);
if (atlas)
{
if (!spriteAtlasKeys.Contains(atlasFileName))
{
spriteAtlasKeys.Add(atlasFileName);
}
else
{
Debug.LogError("重复的图集名称，解决办法：文件夹名字不重复，即使在不同的文件夹！");
}
atlas.SetIncludeInBuild(false);
SpriteAtlasPackingSettings settings = SpriteAtlasExtensions.GetPackingSettings(atlas);
settings.enableTightPacking = false;
settings.enableRotation = false;
settings.padding = 2;
SpriteAtlasExtensions.SetPackingSettings(atlas, settings);
}
}
}
EditorUtility.DisplayProgressBar("图集", "Packing sprite atlas", 0.7f);
SpriteAtlasUtility.PackAllAtlases(EditorUserBuildSettings.activeBuildTarget);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
EditorUtility.ClearProgressBar();
}
}
//private static string _atlasPath = "Assets/Atlas/Atlas.spriteatlas";
//private static string _texturePath = "Assets/Texture";
//[MenuItem("Tools/AutoSetAtlas")]
public static void AutoSetAtlasContents(string _atlasPath, string _texturePath)
{
Debug.Log("path:" + _atlasPath + "--" + _texturePath);
SpriteAtlas atlas = new SpriteAtlas();
// 设置参数 可根据项目具体情况进行设置
SpriteAtlasPackingSettings packSetting = new SpriteAtlasPackingSettings()
{
blockOffset = 1,
enableRotation = false,
enableTightPacking = false,
padding = 2,
};
atlas.SetPackingSettings(packSetting);
SpriteAtlasTextureSettings textureSetting = new SpriteAtlasTextureSettings()
{
readable = false,
generateMipMaps = false,
sRGB = true,
filterMode = FilterMode.Bilinear,
};
atlas.SetTextureSettings(textureSetting);
TextureImporterPlatformSettings platformSetting = new TextureImporterPlatformSettings()
{
maxTextureSize = 2048,
format = TextureImporterFormat.Automatic,
crunchedCompression = true,
textureCompression = TextureImporterCompression.Compressed,
compressionQuality = 50,
};
atlas.SetPlatformSettings(platformSetting);
AssetDatabase.CreateAsset(atlas, _atlasPath + "\\New Sprite Atlas.spriteatlas");
// 1、添加文件
DirectoryInfo dir = new DirectoryInfo(_texturePath);
// 这里我使用的是png图片，已经生成Sprite精灵了
FileInfo[] files = dir.GetFiles("*.png");
foreach (FileInfo file in files)
{
Debug.Log("path:" + file.FullName);
atlas.Add(new[] { AssetDatabase.LoadAssetAtPath <Sprite>($"{_texturePath}/{file.Name}") });
}
// 2、添加文件夹
//Object obj = AssetDatabase.LoadAssetAtPath(_texturePath, typeof(Object));
//atlas.Add(new[] { obj });
AssetDatabase.SaveAssets();
}
void AutoSetAtlasContents(string texturePath)
{
// 设置参数 可根据项目具体情况进行设置
SpriteAtlasPackingSettings packSetting = new SpriteAtlasPackingSettings()
{
blockOffset = 1,
enableRotation = false,
enableTightPacking = false,
padding = 2,
};
SpriteAtlasTextureSettings textureSetting = new SpriteAtlasTextureSettings()
{
readable = false,
generateMipMaps = false,
sRGB = true,
filterMode = FilterMode.Bilinear,
};
TextureImporterPlatformSettings platformSetting = new TextureImporterPlatformSettings()
{
maxTextureSize = 2048,
format = TextureImporterFormat.Automatic,
crunchedCompression = true,
textureCompression = TextureImporterCompression.Compressed,
compressionQuality = 50,
};
DirectoryInfo root = new DirectoryInfo(texturePath);
DirectoryInfo[] dirs = root.GetDirectories();
foreach (DirectoryInfo dir in dirs)
{
SpriteAtlas atlas = new SpriteAtlas();
atlas.SetPackingSettings(packSetting);
atlas.SetTextureSettings(textureSetting);
atlas.SetPlatformSettings(platformSetting);
// 这里我使用的是png图片，已经生成Sprite精灵了
FileInfo[] files = dir.GetFiles("*.png");
foreach (FileInfo file in files)
{
string dirName = Path.GetFileName(file.DirectoryName);
string texPath = $"{texturePath}/{dirName}/{file.Name}";
atlas.Add(new[] { AssetDatabase.LoadAssetAtPath <Sprite>(texPath) });
//Debug.Log($"Create sprite {texPath}");
}
string atlasPath = $"{texturePath}/{dir.Name}.spriteatlas";
//Debug.Log($"Create sprite {atlasPath}");
AssetDatabase.CreateAsset(atlas, atlasPath);
AssetDatabase.SaveAssets();
}
// 2、添加文件夹
//Object obj = AssetDatabase.LoadAssetAtPath(texturePath, typeof(Object));
//atlas.Add(new[] {obj});
}
private static SpriteAtlas PackSpritesToAtlas(string packName, Sprite[] sprites)
{
string atlasAssetPath = UIAtlasRootPath + "/" + packName + "_atlas" + ".spriteatlas";
SpriteAtlas packAtlas = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(atlasAssetPath);
if (packAtlas == null)
{
packAtlas = new SpriteAtlas();
AssetDatabase.CreateAsset(packAtlas, atlasAssetPath);
}
packAtlas.Remove(packAtlas.GetPackables());
packAtlas.Add(sprites);
SpriteAtlasTextureSettings sats = packAtlas.GetTextureSettings();
sats.readable = false;
sats.sRGB = true;
sats.generateMipMaps = false;
sats.filterMode = FilterMode.Bilinear;
packAtlas.SetTextureSettings(sats);
SpriteAtlasPackingSettings saps = packAtlas.GetPackingSettings();
saps.enableRotation = false;
saps.padding = 2;
saps.enableTightPacking = false;
packAtlas.SetPackingSettings(saps);
TextureImporterPlatformSettings winTips = packAtlas.GetPlatformSettings("Standalone");
winTips.overridden = true;
winTips.maxTextureSize = 2048;
winTips.format = TextureImporterFormat.DXT5;
packAtlas.SetPlatformSettings(winTips);
TextureImporterPlatformSettings androidTips = packAtlas.GetPlatformSettings("Android");
androidTips.maxTextureSize = 2048;
androidTips.overridden = true;
androidTips.format = TextureImporterFormat.ETC2_RGBA8;
packAtlas.SetPlatformSettings(androidTips);
TextureImporterPlatformSettings iOSTips = packAtlas.GetPlatformSettings("iPhone");
iOSTips.maxTextureSize = 2048;
iOSTips.overridden = true;
iOSTips.format = TextureImporterFormat.ASTC_4x4;
packAtlas.SetPlatformSettings(iOSTips);
AssetDatabase.ImportAsset(atlasAssetPath);
return(packAtlas);
}
/// <summary>
/// 设置SpriteAtlas 的配置参数 Uncompressed 目录的图集不压
/// </summary>
/// <param name="atlas"></param>
/// <param name="_atlasPath"></param>
private static void SetSpriteAtlas(SpriteAtlas atlas, string _atlasPath)
{
TextureImporterFormat _format = TextureImporterFormat.ASTC_6x6;
if (_atlasPath.Contains("Uncompressed"))
{
_format = TextureImporterFormat.RGBA32;
}
// 设置参数 可根据项目具体情况进行设置
SpriteAtlasPackingSettings packSetting = new SpriteAtlasPackingSettings()
{
blockOffset = 1,
enableRotation = false,
enableTightPacking = false,
padding = 2,
};
atlas.SetPackingSettings(packSetting);
SpriteAtlasTextureSettings textureSetting = new SpriteAtlasTextureSettings()
{
readable = false,
generateMipMaps = false,
sRGB = true,
filterMode = FilterMode.Bilinear,
};
atlas.SetTextureSettings(textureSetting);
TextureImporterPlatformSettings platformSetting = new TextureImporterPlatformSettings()
{
name = "Android",
maxTextureSize = 2048,
format = _format,
overridden = true,
};
atlas.SetPlatformSettings(platformSetting);
platformSetting = new TextureImporterPlatformSettings()
{
name = "iPhone",
maxTextureSize = 2048,
format = _format,
overridden = true,
};
atlas.SetPlatformSettings(platformSetting);
}
/// <summary>
/// 重新设置对应目录下的SpriteAtlas
/// </summary>
/// <param name="assetPath"></param>
static private void CheckSpriteAtlas(string assetPath)
{
if (!assetPath.StartsWith(PathTool.ImagesDir) || assetPath.Contains(AssetBundleDefined.NO_PACK_PATH_NAME))
{
return;
}
DirectoryInfo dirInfo = new DirectoryInfo(assetPath); // 资源路径
DirectoryInfo parentDirInfo = dirInfo.Parent; // 资源父路径
if (!parentDirInfo.Exists)
{
return;
}
// 检查当前目录图集是否已存在
foreach (var item in parentDirInfo.GetFileSystemInfos())
{
if (item.Name == "SpriteAtlas.spriteatlas")
{
//unity下的操作的路径
string unityPath = item.FullName.Replace('\\', '/'); //反斜杠替换成斜杠
AssetDatabase.DeleteAsset(unityPath.Substring(unityPath.IndexOf("Assets")));
}
}
SpriteAtlas atlas = new SpriteAtlas();
// 图集设置
SpriteAtlasPackingSettings packingSettings = atlas.GetPackingSettings();
packingSettings.padding = 4; //图片之间的间距
packingSettings.enableTightPacking = false;
atlas.SetPackingSettings(packingSettings);
FileInfo fileInfo = new FileInfo(assetPath);
// 这里我使用的是png图片，已经生成Sprite精灵了
foreach (var item in parentDirInfo.GetFileSystemInfos())
{
FileInfo info = item as FileInfo;
if (info is FileInfo && info.Extension == ".png")
{
//unity下的操作的路径
string unityPath = item.FullName.Replace('\\', '/'); //反斜杠替换成斜杠
Object obj = AssetDatabase.LoadAssetAtPath <Sprite>(unityPath.Substring(unityPath.IndexOf("Assets")));
atlas.Add(new[] { obj });
}
}
AssetDatabase.CreateAsset(atlas, assetPath.Substring(0, assetPath.Length - fileInfo.Name.Length) + AssetBundleDefined.SPRITE_ATLAS_NAME);
}
public SpriteAtlas Create(string fullPath)
{
if (string.IsNullOrEmpty(fullPath))
{
return(null);
}
var atlas = new SpriteAtlas();
var atlasTextureSettings = new SpriteAtlasTextureSettings();
atlasTextureSettings.generateMipMaps = _atlasSettings.GenerateMipMaps;
atlasTextureSettings.filterMode = _atlasSettings.FilterMode;
atlasTextureSettings.readable = _atlasSettings.ReadWriteEnabled;
atlasTextureSettings.sRGB = _atlasSettings.SRgb;
var atlasPackingSettings = new SpriteAtlasPackingSettings();
atlasPackingSettings.padding = _atlasSettings.Padding;
atlasPackingSettings.enableRotation = _atlasSettings.AllowRotation;
atlasPackingSettings.enableTightPacking = _atlasSettings.TightPacking;
var platformSettings = new TextureImporterPlatformSettings();
platformSettings.textureCompression = _atlasSettings.Compression;
platformSettings.maxTextureSize = _atlasSettings.MaxTextureSize;
platformSettings.format = (TextureImporterFormat)_atlasSettings.Format;
platformSettings.crunchedCompression = _atlasSettings.UseCrunchCompression;
platformSettings.compressionQuality = _atlasSettings.CompressionQuality;
atlas.SetTextureSettings(atlasTextureSettings);
atlas.SetPackingSettings(atlasPackingSettings);
atlas.SetPlatformSettings(platformSettings);
atlas.SetIncludeInBuild(_atlasSettings.IncludeInBuild);
atlas.SetIsVariant(_atlasSettings.Type == SpriteAtlasType.Variant);
EditorFileUtils.CreateDirectories(fullPath);
AssetDatabase.CreateAsset(atlas, fullPath);
AssetDatabase.SaveAssets();
AssetDatabase.WriteImportSettingsIfDirty(fullPath);
return(atlas);
}
public static void DoUpdateAtlas()
{
Debug.Log(nameof(DoUpdateAtlas));
for (int i = 0; i < Selection.objects.Length; i++)
{
DefaultAsset pFolderAsset = Selection.objects[i] as DefaultAsset; // 폴더인지 체크
if (pFolderAsset == null)
{
continue;
}
string strFolderAssetPath = AssetDatabase.GetAssetPath(pFolderAsset);
SpriteAtlas pAtlas = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(strFolderAssetPath + const_strSpriteAtlasExtensionName);
if (pAtlas != null)
{
AssetDatabase.DeleteAsset(strFolderAssetPath + const_strSpriteAtlasExtensionName);
}
pAtlas = CreateSpriteAtlas(strFolderAssetPath);
SpriteAtlasPackingSettings pSetting = new SpriteAtlasPackingSettings();
pSetting.blockOffset = 0;
pSetting.padding = 4;
pSetting.enableTightPacking = false;
pSetting.enableRotation = true;
pAtlas.SetPackingSettings(pSetting);
string strCurrentDirectoryPath = Directory.GetCurrentDirectory();
DirectoryInfo pDirectory = new DirectoryInfo(Directory.GetCurrentDirectory() + "/" + strFolderAssetPath);
FileInfo[] arrFile = pDirectory.GetFiles();
List <Object> listFile = new List <Object>();
for (int j = 0; j < arrFile.Length; j++)
{
string strFileAssetPath = strFolderAssetPath + "/" + arrFile[j].Name;
Object pAsset = AssetDatabase.LoadAssetAtPath <Sprite>(strFileAssetPath);
if (pAsset != null)
{
listFile.Add(pAsset);
}
}
UpdateAtlas(pAtlas, listFile);
}
}
public override void Execute()
{
atlas = null;
if (assetPaths != null && assetPaths.Length > 0)
{
string atlasName = AtlasName;
if (string.IsNullOrEmpty(atlasName))
{
atlasName = Path.GetFileName(filter.Folder);
}
atlasName = atlasName.ToLower();
string atlasAssetPath = $"{TargetFolder}/{atlasName}_atlas.spriteatlas";
SpriteAtlas packAtlas = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(atlasAssetPath);
if (packAtlas == null)
{
packAtlas = new SpriteAtlas();
AssetDatabase.CreateAsset(packAtlas, atlasAssetPath);
}
Sprite[] sprites = (from assetPath in assetPaths select AssetDatabase.LoadAssetAtPath <Sprite>(assetPath)).ToArray();
packAtlas.Remove(packAtlas.GetPackables());
packAtlas.Add(sprites);
SpriteAtlasTextureSettings sats = packAtlas.GetTextureSettings();
sats.readable = false;
sats.sRGB = true;
sats.generateMipMaps = false;
sats.filterMode = FilterMode.Bilinear;
packAtlas.SetTextureSettings(sats);
SpriteAtlasPackingSettings saps = packAtlas.GetPackingSettings();
saps.enableRotation = AllowRotation;
saps.padding = Padding;
saps.enableTightPacking = TightPacking;
packAtlas.SetPackingSettings(saps);
atlas = packAtlas;
}
}
private static void CreateAtlas(string name, List <string> importPaths)
{
var filename = Path.Combine(EditorUtil.GetBaumAtlasPath(), name + ".spriteatlas");
var atlas = new SpriteAtlas();
var settings = new SpriteAtlasPackingSettings()
{
padding = 8,
enableTightPacking = false
};
atlas.SetPackingSettings(settings);
var textureSettings = new SpriteAtlasTextureSettings
{
filterMode = FilterMode.Point,
generateMipMaps = false,
sRGB = true
};
atlas.SetTextureSettings(textureSettings);
var textureImporterPlatformSettings = new TextureImporterPlatformSettings {
maxTextureSize = 8192
};
atlas.SetPlatformSettings(textureImporterPlatformSettings);
// iOS用テクスチャ設定
// ASTCに固定してしまいっている これらの設定を記述できるようにしたい
textureImporterPlatformSettings.overridden = true;
textureImporterPlatformSettings.name = "iPhone";
textureImporterPlatformSettings.format = TextureImporterFormat.ASTC_4x4;
atlas.SetPlatformSettings(textureImporterPlatformSettings);
// アセットの生成
AssetDatabase.CreateAsset(atlas, EditorUtil.ToUnityPath(filename));
// ディレクトリを登録する場合
// var iconsDirectory = AssetDatabase.LoadAssetAtPath<Object>("Assets/ExternalAssets/Baum2/CreatedSprites/UIESMessenger");
// atlas.Add(new Object[]{iconsDirectory});
}
/// <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);
}
}
private void createSpriteAltas(string altasFolderPath_, string altasName_)
{
//New altas file.
SpriteAtlas _atlas = new SpriteAtlas();
SpriteAtlasPackingSettings _packSetting = new SpriteAtlasPackingSettings()
{
blockOffset = 1,
enableRotation = true,
enableTightPacking = true,
padding = 2,
};
_atlas.SetPackingSettings(_packSetting);
SpriteAtlasTextureSettings _textureSetting = new SpriteAtlasTextureSettings()
{
readable = false,
generateMipMaps = false,
sRGB = true,
filterMode = FilterMode.Bilinear,
};
_atlas.SetTextureSettings(_textureSetting);
TextureImporterPlatformSettings _platformSetting = new TextureImporterPlatformSettings()
{
maxTextureSize = _maxTextureSize,
format = TextureImporterFormat.Automatic,
crunchedCompression = _crunchedCompression,
textureCompression = TextureImporterCompression.Compressed,
compressionQuality = _compressionQuality,
};
_atlas.SetPlatformSettings(_platformSetting);
//Create altas file.
AssetDatabase.CreateAsset(_atlas, altasFolderPath_ + "/" + altasName_);
//Get folder pack with it.
Object _folderObj = AssetDatabase.LoadAssetAtPath(altasFolderPath_, typeof(Object));
_atlas.Add(new [] { _folderObj });
AssetDatabase.SaveAssets();
}
/// <summary>
/// 刷新所有 同层 的资源 bundle name
/// </summary>
/*
* public void RefreshSetting()
* {
* //Debug.LogError("---------------------------------------------------");
* //D:/HFFramework/HFFramework/Assets
* //Assets/GameResources/Game/Prefab[A]/AssetConfig.asset
* foreach (var assetPath in GetAllAssetInFolder())
* {
* //Debug.LogError("assetPath " + assetPath);
* AssetImporter assetImporter = AssetImporter.GetAtPath(assetPath);
* string bundleName = string.Empty;
* if (assetPath.Contains("AssetConfig.asset"))
* {
* bundleName = string.Empty;
* }
* else
* {
* bundleName = assetbundleName;
* }
*
*
* //Debug.LogError(assetImporter.assetBundleName);
*
* //if (assetImporter.assetBundleName!= bundleName)
* //{
* // assetImporter.assetBundleName = bundleName;
* // assetImporter.SaveAndReimport();
* //}
*
*
* assetImporter.assetBundleName = bundleName;
* assetImporter.SaveAndReimport();
* }
*
*
* AssetDatabase.SaveAssets();
* AssetDatabase.Refresh();
* }
*/
public void RefreshAtlas()
{
if (string.IsNullOrEmpty(atlasName))
{
return;
}
SpriteAtlas atlas = null;
foreach (var assetPath in GetAllAssetInFolder())
{
atlas = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(assetPath);
if (atlas != null)
{
break;
}
}
if (atlas == null)
{
atlas = new SpriteAtlas();
// 设置参数 可根据项目具体情况进行设置
SpriteAtlasPackingSettings packSetting = new SpriteAtlasPackingSettings()
{
blockOffset = 1,
enableRotation = false,
enableTightPacking = false,
padding = 2,
};
atlas.SetPackingSettings(packSetting);
SpriteAtlasTextureSettings textureSetting = new SpriteAtlasTextureSettings()
{
readable = false,
generateMipMaps = false,
sRGB = true,
filterMode = FilterMode.Bilinear,
};
atlas.SetTextureSettings(textureSetting);
TextureImporterPlatformSettings platformSetting = new TextureImporterPlatformSettings()
{
maxTextureSize = 1024,
format = TextureImporterFormat.Automatic,
crunchedCompression = true,
textureCompression = TextureImporterCompression.Compressed,
compressionQuality = 50,
};
atlas.SetPlatformSettings(platformSetting);
AssetDatabase.CreateAsset(atlas, FolderPath + "/" + atlasName + ".spriteatlas");
}
if (atlas != null)
{
UnityEngine.Object obj = AssetDatabase.LoadAssetAtPath <UnityEngine.Object>(FolderPath);
atlas.Remove(atlas.GetPackables());
atlas.Add(new[] { obj });
EditorUtility.SetDirty(atlas);
AssetDatabase.SaveAssets();
}
AssetDatabase.Refresh();
}
static SpriteAtlas mGenAtlas()
{
SpriteAtlasPackingSettings atlasSetting = new SpriteAtlasPackingSettings()
{
blockOffset = 1,
enableRotation = false,
enableTightPacking = false,
padding = 2,
};
SpriteAtlasTextureSettings textureSetting = new SpriteAtlasTextureSettings()
{
readable = false,
generateMipMaps = false,
sRGB = true,
filterMode = FilterMode.Bilinear,
};
//Default
TextureImporterPlatformSettings compressDefault = new TextureImporterPlatformSettings()
{
name = "DefaultTexturePlatform",
overridden = false,
maxTextureSize = 2048,
compressionQuality = 50,
crunchedCompression = true,
format = TextureImporterFormat.Automatic,
textureCompression = TextureImporterCompression.Compressed,
};
//IOS
TextureImporterPlatformSettings compressIOS = new TextureImporterPlatformSettings()
{
name = "iPhone",
overridden = true,
maxTextureSize = 2048,
compressionQuality = 50,
crunchedCompression = true,
format = TextureImporterFormat.RGBA32,
textureCompression = TextureImporterCompression.Compressed,
};
//Android
TextureImporterPlatformSettings compressAndroid = new TextureImporterPlatformSettings()
{
name = "Android",
overridden = true,
maxTextureSize = 2048,
compressionQuality = 50,
crunchedCompression = true,
format = TextureImporterFormat.Automatic,
textureCompression = TextureImporterCompression.Compressed,
};
SpriteAtlas atlas = new SpriteAtlas();
atlas.SetPackingSettings(atlasSetting);
atlas.SetTextureSettings(textureSetting);
atlas.SetPlatformSettings(compressDefault);
atlas.SetPlatformSettings(compressIOS);
atlas.SetPlatformSettings(compressAndroid);
atlas.SetIncludeInBuild(true);
atlas.SetIsVariant(false);
return(atlas);
}
protected virtual void SetPackingSettings(ref SpriteAtlasPackingSettings packingSettings)
{
packingSettings.padding = 2;
packingSettings.enableTightPacking = false;
packingSettings.enableRotation = false;
}
static void AutoSetAtlasContents(string dir)
{
SpriteAtlas atlas = new SpriteAtlas();
// 设置参数 可根据项目具体情况进行设置
SpriteAtlasPackingSettings packSetting = new SpriteAtlasPackingSettings()
{
blockOffset = 1,
enableRotation = false,
enableTightPacking = false,
padding = 2,
};
atlas.SetPackingSettings(packSetting);
SpriteAtlasTextureSettings textureSetting = new SpriteAtlasTextureSettings()
{
readable = false,
generateMipMaps = false,
sRGB = true,
filterMode = FilterMode.Bilinear,
};
atlas.SetTextureSettings(textureSetting);
TextureImporterPlatformSettings platformSetting = new TextureImporterPlatformSettings()
{
maxTextureSize = 1024,
format = TextureImporterFormat.Automatic,
crunchedCompression = true,
textureCompression = TextureImporterCompression.Compressed,
compressionQuality = 50,
};
atlas.SetPlatformSettings(platformSetting);
DirectoryInfo dirInfo = new DirectoryInfo(dir);
string path = $"{dir}/{dirInfo.Name}.spriteatlas";
if (File.Exists(path))
{
File.Delete(path);
}
AssetDatabase.CreateAsset(atlas, path);
//1.添加文件
FileInfo[] files = dirInfo.GetFiles("*.png");
foreach (FileInfo file in files)
{
atlas.Add(new[] { AssetDatabase.LoadAssetAtPath <Sprite>($"{dir}/{file.Name}") });
}
//2.添加子文件夹
DirectoryInfo[] subdirs = dirInfo.GetDirectories();
foreach (DirectoryInfo subdir in subdirs)
{
Object obj = AssetDatabase.LoadAssetAtPath(subdir.FullName, typeof(Object));
atlas.Add(new[] { obj });
}
AssetDatabase.SaveAssets();
Debug.LogFormat("Generate a <b>{0}.spriteatlas</b> success! path=<b>{1}</b>",
dirInfo.Name, path);
}
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();
}
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;
}
}
}
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());
}
public void CreateDirAtlas(string packDir)
{
var atlasDir = Path.GetDirectoryName(packDir);
var atlasName = "atlas_" + Path.GetFileName(packDir).ToLower();
var fullPath = atlasDir + '/' + atlasName + ".spriteatlas";
SpriteAtlas atlas;
if (!File.Exists(fullPath))
{
atlas = new SpriteAtlas();
SpriteAtlasPackingSettings packSetting = new SpriteAtlasPackingSettings()
{
blockOffset = 1,
enableRotation = false,
enableTightPacking = false,
padding = 2,
};
atlas.SetPackingSettings(packSetting);
var textureSetting = new SpriteAtlasTextureSettings()
{
readable = false,
generateMipMaps = false,
sRGB = true,
filterMode = FilterMode.Bilinear,
};
atlas.SetTextureSettings(textureSetting);
var platformSetting = new TextureImporterPlatformSettings()
{
maxTextureSize = 2048,
format = TextureImporterFormat.Automatic,
crunchedCompression = true,
textureCompression = TextureImporterCompression.Compressed,
compressionQuality = 50,
};
atlas.SetPlatformSettings(platformSetting);
AssetDatabase.CreateAsset(atlas, fullPath);
}
else
{
atlas = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(fullPath);
}
if (atlas == null)
{
Debug.LogError($"{fullPath} is not exist");
return;
}
var packes = atlas.GetPackables();
atlas.Remove(packes);
atlas.Add(new[] { AssetDatabase.LoadAssetAtPath <UnityEngine.Object>(packDir) });
ImportTool.SetAssetAddress(fullPath, atlasName);
AssetDatabase.SaveAssets();
// 取消图集图片的Addressable
var assetes = FileUtil.GetDirAllAssetFullPath(packDir);
foreach (var asset in assetes)
{
ImportTool.RemoveAssetAddress(asset);
}
}
