com.alicizax.unity.editor.e.../Editor/Postprocessor/Atlas/EditorSpriteSaveInfo.cs
2025-03-14 19:58:50 +08:00

398 lines
12 KiB
C#

#if UNITY_EDITOR
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using UnityEditor;
using UnityEditor.U2D;
using UnityEngine;
using UnityEngine.U2D;
public static class EditorSpriteSaveInfo
{
private static readonly HashSet<string> _dirtyAtlasNames = new HashSet<string>();
private static readonly Dictionary<string, List<string>> _atlasMap = new Dictionary<string, List<string>>();
private static bool _initialized;
private static AtlasConfiguration Config => AtlasConfiguration.Instance;
static EditorSpriteSaveInfo()
{
EditorApplication.update += OnUpdate;
Initialize();
}
private static void Initialize()
{
if (_initialized) return;
ScanExistingSprites();
_initialized = true;
}
public static void OnImportSprite(string assetPath)
{
if (!ShouldProcess(assetPath)) return;
var atlasName = GetAtlasName(assetPath);
if (string.IsNullOrEmpty(atlasName)) return;
if (!_atlasMap.TryGetValue(atlasName, out var list))
{
list = new List<string>();
_atlasMap[atlasName] = list;
}
if (!list.Contains(assetPath))
{
list.Add(assetPath);
MarkDirty(atlasName);
MarkParentAtlasesDirty(assetPath);
}
}
public static void OnDeleteSprite(string assetPath)
{
if (!ShouldProcess(assetPath)) return;
var atlasName = GetAtlasName(assetPath);
if (string.IsNullOrEmpty(atlasName)) return;
if (_atlasMap.TryGetValue(atlasName, out var list))
{
if (list.Remove(assetPath))
{
MarkDirty(atlasName);
MarkParentAtlasesDirty(assetPath);
}
}
}
[MenuItem("Tools/图集工具/ForceGenerateAll")]
public static void ForceGenerateAll()
{
_atlasMap.Clear();
ScanExistingSprites();
_dirtyAtlasNames.UnionWith(_atlasMap.Keys);
ProcessDirtyAtlases(true);
}
public static void ClearCache()
{
_dirtyAtlasNames.Clear();
_atlasMap.Clear();
AssetDatabase.Refresh();
}
public static void MarkParentAtlasesDirty(string assetPath)
{
var currentPath = Path.GetDirectoryName(assetPath);
var rootPath = Config.sourceAtlasRoot.Replace("\\", "/").TrimEnd('/');
while (currentPath != null && currentPath.StartsWith(rootPath))
{
var parentAtlasName = GetAtlasNameForDirectory(currentPath);
if (!string.IsNullOrEmpty(parentAtlasName))
{
MarkDirty(parentAtlasName);
}
currentPath = Path.GetDirectoryName(currentPath);
}
}
private static void OnUpdate()
{
if (_dirtyAtlasNames.Count > 0)
{
ProcessDirtyAtlases();
}
}
private static void ProcessDirtyAtlases(bool force = false)
{
try
{
AssetDatabase.StartAssetEditing();
foreach (var atlasName in _dirtyAtlasNames.ToList())
{
if (force || ShouldUpdateAtlas(atlasName))
{
GenerateAtlas(atlasName);
}
_dirtyAtlasNames.Remove(atlasName);
}
}
finally
{
AssetDatabase.StopAssetEditing();
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
}
private static void GenerateAtlas(string atlasName)
{
var outputPath = $"{Config.outputAtlasDir}/{atlasName}.spriteatlas";
SpriteAtlasAsset spriteAtlasAsset = default;
SpriteAtlas atlas = new SpriteAtlas();
if (Config.enableV2)
{
outputPath = $"{Config.outputAtlasDir}/{atlasName}.spriteatlasv2";
if (!File.Exists(outputPath))
{
spriteAtlasAsset = new SpriteAtlasAsset();
}
else
{
spriteAtlasAsset = SpriteAtlasAsset.Load(outputPath);
atlas = AssetDatabase.LoadAssetAtPath<SpriteAtlas>(outputPath);
if (atlas != null)
{
var olds = atlas.GetPackables();
if (olds != null) spriteAtlasAsset.Remove(olds);
}
}
}
var sprites = LoadValidSprites(atlasName);
EnsureOutputDirectory();
if (sprites.Count == 0)
{
DeleteAtlas(outputPath);
return;
}
if (Config.enableV2)
{
spriteAtlasAsset.Add(sprites.ToArray());
SpriteAtlasAsset.Save(spriteAtlasAsset, outputPath);
AssetDatabase.Refresh();
EditorApplication.delayCall += () =>
{
#if UNITY_2022_1_OR_NEWER
SpriteAtlasImporter sai = (SpriteAtlasImporter)AssetImporter.GetAtPath(outputPath);
ConfigureAtlasV2Settings(sai);
#else
ConfigureAtlasV2Settings(spriteAtlasAsset);
SpriteAtlasAsset.Save(spriteAtlasAsset, outputPath);
#endif
AssetDatabase.WriteImportSettingsIfDirty(outputPath);
AssetDatabase.Refresh();
};
}
else
{
ConfigureAtlasSettings(atlas);
atlas.Add(sprites.ToArray());
atlas.SetIsVariant(false);
AssetDatabase.CreateAsset(atlas, outputPath);
}
if (Config.enableLogging)
Debug.Log($"Generated atlas: {atlasName} ({sprites.Count} sprites)");
}
private static List<Sprite> LoadValidSprites(string atlasName)
{
return _atlasMap[atlasName]
.Where(File.Exists)
.Select(p => AssetDatabase.LoadAssetAtPath<Sprite>(p))
.Where(s => s != null)
.ToList();
}
#if UNITY_2022_1_OR_NEWER
private static void ConfigureAtlasV2Settings(SpriteAtlasImporter atlasImporter)
{
void SetPlatform(string platform, TextureImporterFormat format)
{
var settings = atlasImporter.GetPlatformSettings(platform);
if (settings == null) return;
;
settings.overridden = true;
settings.format = format;
settings.compressionQuality = Config.compressionQuality;
atlasImporter.SetPlatformSettings(settings);
}
SetPlatform("Android", Config.androidFormat);
SetPlatform("iPhone", Config.iosFormat);
SetPlatform("WebGL", Config.webglFormat);
var packingSettings = new SpriteAtlasPackingSettings
{
padding = Config.padding,
enableRotation = Config.enableRotation,
blockOffset = Config.blockOffset,
enableTightPacking = Config.tightPacking,
enableAlphaDilation = true
};
atlasImporter.packingSettings = packingSettings;
}
#else
private static void ConfigureAtlasV2Settings(SpriteAtlasAsset spriteAtlasAsset)
{
void SetPlatform(string platform, TextureImporterFormat format)
{
var settings = spriteAtlasAsset.GetPlatformSettings(platform);
if (settings == null) return;
;
settings.overridden = true;
settings.format = format;
settings.compressionQuality = Config.compressionQuality;
spriteAtlasAsset.SetPlatformSettings(settings);
}
SetPlatform("Android", Config.androidFormat);
SetPlatform("iPhone", Config.iosFormat);
SetPlatform("WebGL", Config.webglFormat);
var packingSettings = new SpriteAtlasPackingSettings
{
padding = Config.padding,
enableRotation = Config.enableRotation,
blockOffset = Config.blockOffset,
enableTightPacking = Config.tightPacking,
enableAlphaDilation = true
};
spriteAtlasAsset.SetPackingSettings(packingSettings);
}
#endif
private static void ConfigureAtlasSettings(SpriteAtlas atlas)
{
void SetPlatform(string platform, TextureImporterFormat format)
{
var settings = atlas.GetPlatformSettings(platform);
settings.overridden = true;
settings.format = format;
settings.compressionQuality = Config.compressionQuality;
atlas.SetPlatformSettings(settings);
}
SetPlatform("Android", Config.androidFormat);
SetPlatform("iPhone", Config.iosFormat);
SetPlatform("WebGL", Config.webglFormat);
var packingSettings = new SpriteAtlasPackingSettings
{
padding = Config.padding,
enableRotation = Config.enableRotation,
blockOffset = Config.blockOffset,
enableTightPacking = Config.tightPacking,
};
atlas.SetPackingSettings(packingSettings);
}
private static string GetAtlasName(string assetPath)
{
var normalizedPath = assetPath.Replace("\\", "/");
var rootPath = Config.sourceAtlasRoot.Replace("\\", "/").TrimEnd('/');
if (!normalizedPath.StartsWith(rootPath + "/")) return null;
var relativePath = normalizedPath
.Substring(rootPath.Length + 1)
.Split('/');
if (relativePath.Length < 2) return null;
var directories = relativePath.Take(relativePath.Length - 1);
var atlasNamePart = string.Join("_", directories);
var rootFolderName = Path.GetFileName(rootPath);
return $"{rootFolderName}_{atlasNamePart}";
}
private static bool ShouldProcess(string assetPath)
{
return IsImageFile(assetPath) && !IsExcluded(assetPath);
}
private static bool IsExcluded(string path)
{
return path.StartsWith(Config.excludeFolder) ||
Config.excludeKeywords.Any(k => path.IndexOf(k, StringComparison.OrdinalIgnoreCase) >= 0);
}
private static bool IsImageFile(string path)
{
var ext = Path.GetExtension(path).ToLower();
return ext == ".png" || ext == ".jpg" || ext == ".jpeg";
}
private static void MarkDirty(string atlasName)
{
_dirtyAtlasNames.Add(atlasName);
}
private static bool ShouldUpdateAtlas(string atlasName)
{
// var outputPath = $"{Config.outputAtlasDir}/{atlasName}.spriteatlas";
return true;
}
private static DateTime GetLatestSpriteTime(string atlasName)
{
return _atlasMap[atlasName]
.Select(p => new FileInfo(p).LastWriteTime)
.DefaultIfEmpty()
.Max();
}
private static void DeleteAtlas(string path)
{
if (File.Exists(path))
{
AssetDatabase.DeleteAsset(path);
if (Config.enableLogging)
Debug.Log($"Deleted empty atlas: {Path.GetFileName(path)}");
}
}
private static void EnsureOutputDirectory()
{
if (!Directory.Exists(Config.outputAtlasDir))
{
Directory.CreateDirectory(Config.outputAtlasDir);
AssetDatabase.Refresh();
}
}
private static void ScanExistingSprites()
{
var guids = AssetDatabase.FindAssets("t:Sprite", new[] { Config.sourceAtlasRoot });
foreach (var guid in guids)
{
var path = AssetDatabase.GUIDToAssetPath(guid);
if (ShouldProcess(path))
{
OnImportSprite(path);
}
}
}
private static string GetAtlasNameForDirectory(string directoryPath)
{
var normalizedPath = directoryPath.Replace("\\", "/");
var rootPath = Config.sourceAtlasRoot.Replace("\\", "/").TrimEnd('/');
if (!normalizedPath.StartsWith(rootPath + "/")) return null;
var relativePath = normalizedPath
.Substring(rootPath.Length + 1)
.Split('/');
var atlasNamePart = string.Join("_", relativePath);
var rootFolderName = Path.GetFileName(rootPath);
return $"{rootFolderName}_{atlasNamePart}";
}
}
#endif