public override void OnPostprocessAllAssets(IAkyuiLoader loader, Object[] importAssets)
{
var spriteAtlasPath = spriteAtlasOutputPath.Replace("{name}", loader.LayoutInfo.Name) + ".spriteatlas";
var spriteAtlas = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(spriteAtlasPath);
if (spriteAtlas == null)
{
Debug.Log($"Create SpriteAtlas: {spriteAtlasPath}");
AkyuiEditorUtil.CreateDirectory(Path.GetDirectoryName(spriteAtlasPath));
spriteAtlas = new SpriteAtlas();
AssetDatabase.CreateAsset(spriteAtlas, spriteAtlasPath);
}
if (spriteAtlasPreset != null)
{
spriteAtlasPreset.ApplyTo(spriteAtlas);
}
spriteAtlas.name = loader.LayoutInfo.Name;
spriteAtlas.Remove(spriteAtlas.GetPackables());
spriteAtlas.Add(importAssets);
SpriteAtlasUtility.PackAtlases(new[] { spriteAtlas }, EditorUserBuildSettings.activeBuildTarget);
// なにかのバグだと思うんだけど、ここでSaveしないとPresetが反映されないことがある Unity 2020.3.18
EditorUtility.SetDirty(spriteAtlas);
AssetDatabase.SaveAssets();
}
public override void OnPostprocessAllAssets(IAkyuiLoader loader, Object[] importAssets)
{
var spriteAtlasPath = spriteAtlasOutputPath.Replace("{name}", loader.LayoutInfo.Name) + ".spriteatlas";
var spriteAtlas = AssetDatabase.LoadAssetAtPath <SpriteAtlas>(spriteAtlasPath);
if (spriteAtlas == null)
{
Debug.Log($"Create SpriteAtlas: {spriteAtlasPath}");
AkyuiEditorUtil.CreateDirectory(Path.GetDirectoryName(spriteAtlasPath));
spriteAtlas = new SpriteAtlas();
AssetDatabase.CreateAsset(spriteAtlas, spriteAtlasPath);
}
if (source != null)
{
EditorUtility.CopySerialized(source, spriteAtlas);
}
spriteAtlas.name = loader.LayoutInfo.Name;
spriteAtlas.Remove(spriteAtlas.GetPackables());
spriteAtlas.Add(importAssets);
SpriteAtlasUtility.PackAtlases(new[] { spriteAtlas }, EditorUserBuildSettings.activeBuildTarget);
}
public override void OnPostprocessPrefab(IAkyuiLoader loader, ref GameObject prefab)
{
foreach (var layoutGroup in prefab.GetComponentsInChildren <LayoutGroup>(true))
{
layoutGroup.enabled = false;
}
}
private static void CheckVersion(IAkyuiLoader loader)
{
var loaderVersion = loader.LayoutInfo.Meta.AkyuiVersion;
if (loaderVersion == Const.FormatVersion)
{
return;
}
throw new Exception($"Cannot load version {loaderVersion} file. (Importer version is {Const.FormatVersion})");
}
public override void OnPostprocessFile(IAkyuiLoader loader, IPathGetter pathGetter)
{
var gitKeepPath = Path.Combine(pathGetter.AssetOutputDirectoryPath, ".gitkeep");
if (File.Exists(gitKeepPath))
{
return;
}
File.Create(gitKeepPath).Close();
}
private static void Import(IAkyuiImportSettings settings, IAkyuiLoader akyuiLoader, AkyuiLogger logger, IAkyuiProgress progress)
{
var stopWatch = Stopwatch.StartNew();
CheckVersion(akyuiLoader);
Settings = settings;
using (Disposable.Create(() => Settings = null))
{
var pathGetter = new PathGetter(settings, akyuiLoader.LayoutInfo.Name);
var prevMetaGameObject = AssetDatabase.LoadAssetAtPath <GameObject>(pathGetter.MetaSavePath);
var prevMeta = prevMetaGameObject != null?prevMetaGameObject.GetComponent <AkyuiMeta>() : null;
var prevAssets = prevMeta != null ? prevMeta.assets : new Object[] { };
if (!settings.ReimportLayout && prevMeta != null && prevMeta.hash == akyuiLoader.LayoutInfo.Hash)
{
logger.Log("Skip", ("hash", akyuiLoader.LayoutInfo.Hash));
return;
}
var assets = ImportAssets(settings, akyuiLoader, pathGetter, logger, progress);
var(gameObject, hash) = ImportLayout(settings, akyuiLoader, pathGetter, logger);
DeleteUnusedAssets(prevAssets, assets, logger);
var metaGameObject = new GameObject(akyuiLoader.LayoutInfo.Name);
gameObject.transform.SetParent(metaGameObject.transform);
var akyuiMeta = metaGameObject.AddComponent <AkyuiMeta>();
akyuiMeta.hash = hash;
akyuiMeta.root = gameObject;
akyuiMeta.assets = assets;
akyuiMeta.userData = akyuiLoader.LayoutInfo.UserData.Select(x => new AkyuiMetaUserData {
key = x.Key, value = x.Value
}).ToArray();
AkyuiEditorUtil.CreateDirectory(Path.GetDirectoryName(pathGetter.PrefabSavePath));
AkyuiEditorUtil.CreateDirectory(Path.GetDirectoryName(pathGetter.MetaSavePath));
PrefabUtility.SaveAsPrefabAssetAndConnect(gameObject, pathGetter.PrefabSavePath, InteractionMode.AutomatedAction);
PrefabUtility.SaveAsPrefabAsset(metaGameObject, pathGetter.MetaSavePath);
foreach (var trigger in settings.Triggers)
{
trigger.OnPostprocessFile(akyuiLoader, pathGetter);
}
Object.DestroyImmediate(metaGameObject);
}
stopWatch.Stop();
logger.Log($"Import Finish", ("time", $"{stopWatch.Elapsed.TotalSeconds:0.00}s"));
}
private static void CheckVersion(IAkyuiLoader loader)
{
var loaderVersionFull = loader.LayoutInfo.Meta.AkyuiVersion;
var e1 = loaderVersionFull.Split('.');
var loaderVersion = $"{e1[0]}.{e1[1]}";
var e2 = Const.AkyuiVersion.Split('.');
var importerVersion = $"{e2[0]}.{e2[1]}";
if (loaderVersion == importerVersion)
{
return;
}
throw new Exception($"Cannot load version {loaderVersionFull} file. (Importer version is {Const.AkyuiVersion})");
}
public override void OnPostprocessPrefab(IAkyuiLoader loader, ref GameObject prefab)
{
foreach (var button in prefab.GetComponentsInChildren <Button>())
{
var image = button.GetComponentsInChildren <Image>()
.Where(x => x.color != Color.clear)
.ToArray();
if (image.Length >= 1)
{
button.targetGraphic = image.First();
}
DestroyImmediate(button.GetComponent <Image>());
}
}
public static byte[] Compress(IAkyuiLoader loader)
{
using (var memoryStream = new MemoryStream())
using (var zipStream = new ZipOutputStream(memoryStream))
{
{
var newEntry = new ZipEntry(Path.Combine(loader.LayoutInfo.Name, "layout.json"));
zipStream.PutNextEntry(newEntry);
var text = Json.Serialize(ToSerializable(loader.LayoutInfo));
var textBytes = System.Text.Encoding.UTF8.GetBytes(text);
zipStream.Write(textBytes, 0, textBytes.Length);
zipStream.CloseEntry();
}
{
var newEntry = new ZipEntry(Path.Combine(loader.LayoutInfo.Name, "assets.json"));
zipStream.PutNextEntry(newEntry);
var text = Json.Serialize(ToSerializable(loader.AssetsInfo));
var textBytes = System.Text.Encoding.UTF8.GetBytes(text);
zipStream.Write(textBytes, 0, textBytes.Length);
zipStream.CloseEntry();
}
foreach (var asset in loader.AssetsInfo.Assets)
{
var newEntry = new ZipEntry(Path.Combine(loader.LayoutInfo.Name, "assets", asset.FileName));
zipStream.PutNextEntry(newEntry);
var bytes = loader.LoadAsset(asset.FileName);
zipStream.Write(bytes, 0, bytes.Length);
zipStream.CloseEntry();
}
zipStream.Close();
return(memoryStream.ToArray());
}
}
public static byte[] Compress(IAkyuiLoader loader)
{
const CompressionLevel compressionLevel = CompressionLevel.Fastest;
using (var memoryStream = new MemoryStream())
{
using (var zipArchive = new ZipArchive(memoryStream, ZipArchiveMode.Create))
{
{
var newEntry = zipArchive.CreateEntry(Path.Combine(loader.LayoutInfo.Name, "layout.json"), compressionLevel);
using (var stream = new BinaryWriter(newEntry.Open()))
{
var text = JsonSerializer.ToJsonString(ToSerializable(loader.LayoutInfo));
var textBytes = System.Text.Encoding.UTF8.GetBytes(text);
stream.Write(textBytes, 0, textBytes.Length);
}
}
{
var newEntry = zipArchive.CreateEntry(Path.Combine(loader.LayoutInfo.Name, "assets.json"), compressionLevel);
using (var stream = new BinaryWriter(newEntry.Open()))
{
var text = JsonSerializer.ToJsonString(ToSerializable(loader.AssetsInfo));
var textBytes = System.Text.Encoding.UTF8.GetBytes(text);
stream.Write(textBytes, 0, textBytes.Length);
}
}
foreach (var asset in loader.AssetsInfo.Assets)
{
var newEntry = zipArchive.CreateEntry(Path.Combine(loader.LayoutInfo.Name, "assets", asset.FileName), compressionLevel);
using (var stream = new BinaryWriter(newEntry.Open()))
{
var bytes = loader.LoadAsset(asset.FileName);
stream.Write(bytes, 0, bytes.Length);
}
}
}
return(memoryStream.ToArray());
}
}
public override void OnPreprocessAsset(IAkyuiLoader loader, ref byte[] bytes, ref IAsset asset, ref Dictionary <string, object> userData)
{
if (!(asset is SpriteAsset spriteAsset))
{
return;
}
var extension = Path.GetExtension(asset.FileName);
if (spriteAsset.Border != null)
{
return;
}
if (extension != ".png" && extension != ".jpg" && extension != ".jpeg")
{
return;
}
var texture = new Texture2D(2, 2);
texture.LoadImage(bytes);
var sliced = Slicer.Slice(texture, options);
if (extension == ".png")
{
bytes = sliced.Texture.EncodeToPNG();
}
if (extension == ".jpg" || extension == ".jpeg")
{
bytes = sliced.Texture.EncodeToJPG();
}
spriteAsset.Border = new Border(
sliced.Border.Top,
sliced.Border.Right,
sliced.Border.Bottom,
sliced.Border.Left
);
}
public override void OnPreprocessAllAssets(IAkyuiLoader akyuiLoader, ref List <IAsset> assets)
{
_map = new Dictionary <string, string>();
var removed = new List <IAsset>();
var cache = new Dictionary <ulong, IAsset>();
foreach (var asset in assets)
{
if (!(asset is SpriteAsset spriteAsset))
{
continue;
}
var hash = FastHash.CalculateHash(akyuiLoader.LoadAsset(spriteAsset.FileName).Select(x => (uint)x).ToArray());
if (!cache.ContainsKey(hash))
{
cache.Add(hash, asset);
continue;
}
var hit = cache[hash];
removed.Add(asset);
_map[asset.FileName] = hit.FileName;
}
foreach (var r in removed)
{
assets.Remove(r);
}
if (removed.Count > 0)
{
Debug.Log($"[SameSpriteDetect] Remove {removed.Count} assets");
}
}
private static (GameObject, long Hash) ImportLayout(IAkyuiImportSettings settings, IAkyuiLoader akyuiLoader, PathGetter pathGetter, AkyuiLogger logger)
{
using (logger.SetCategory("Layout"))
{
logger.Log($"Import Start");
var layoutInfo = akyuiLoader.LayoutInfo;
var triggers = settings.Triggers.Select(x => (IAkyuiGenerateTrigger)x).ToArray();
var(gameObject, hash) = AkyuiGenerator.GenerateGameObject(new EditorAssetLoader(pathGetter, logger, settings.Triggers), layoutInfo, triggers);
foreach (var trigger in settings.Triggers)
{
trigger.OnPostprocessPrefab(akyuiLoader, ref gameObject);
}
logger.Log($"Import Finish");
return(gameObject, hash);
}
}
public override void OnPostprocessPrefab(IAkyuiLoader loader, ref GameObject prefab)
{
var uiCache = prefab.AddComponent <UICache>();
uiCache.CreateCache();
}
private static (GameObject, uint Hash, IDictionary <uint, GameObject> EidMap, ImportLayoutLog) ImportLayout(IAkyuiImportSettings settings, IAkyuiLoader akyuiLoader, PathGetter pathGetter, AkyuiLogger logger)
{
var stopWatch = Stopwatch.StartNew();
var layoutInfo = akyuiLoader.LayoutInfo;
var triggers = settings.Triggers.Select(x => (IAkyuiGenerateTrigger)x).ToArray();
var(gameObject, hash, eidMap) = AkyuiGenerator.GenerateGameObject(new EditorAssetLoader(pathGetter, logger, settings.Triggers), layoutInfo, triggers);
foreach (var trigger in settings.Triggers)
{
trigger.OnPostprocessPrefab(akyuiLoader, ref gameObject);
}
return(gameObject, hash, eidMap, new ImportLayoutLog {
Time = stopWatch.Elapsed.TotalSeconds
});
}
public override void OnPostprocessPrefab(IAkyuiLoader loader, ref GameObject prefab)
{
Debug.Log($"OnPostprocessPrefab: {prefab}");
}
public virtual void OnPreprocessAllAssets(IAkyuiLoader loader, ref List<IAsset> assets) { }
public static void Save(IAkyuiLoader loader, string filePath)
{
var bytes = AkyuiCompressor.Compress(loader);
File.WriteAllBytes(filePath, bytes);
}
private static (GameObject, long Hash) ImportLayout(IAkyuiImportSettings settings, IAkyuiLoader akyuiLoader, PathGetter pathGetter, AkyuiLogger logger)
{
var stopWatch = Stopwatch.StartNew();
using (logger.SetCategory("Layout"))
{
var layoutInfo = akyuiLoader.LayoutInfo;
var triggers = settings.Triggers.Select(x => (IAkyuiGenerateTrigger)x).ToArray();
var(gameObject, hash) = AkyuiGenerator.GenerateGameObject(new EditorAssetLoader(pathGetter, logger, settings.Triggers), layoutInfo, triggers);
foreach (var trigger in settings.Triggers)
{
trigger.OnPostprocessPrefab(akyuiLoader, ref gameObject);
}
logger.Log($"Import Finish", ("time", $"{stopWatch.Elapsed.TotalSeconds:0.00}s"));
return(gameObject, hash);
}
}
private static Object[] ImportAssets(IAkyuiImportSettings settings, IAkyuiLoader akyuiLoader, PathGetter pathGetter, AkyuiLogger logger, IAkyuiProgress progress)
{
var stopWatch = Stopwatch.StartNew();
using (logger.SetCategory("Assets"))
{
var assets = new List <Object>();
var unityAssetsParentPath = Path.GetDirectoryName(Application.dataPath) ?? "";
var assetOutputDirectoryFullPath = Path.Combine(unityAssetsParentPath, pathGetter.AssetOutputDirectoryPath);
if (!Directory.Exists(assetOutputDirectoryFullPath))
{
Directory.CreateDirectory(assetOutputDirectoryFullPath);
}
var importAssetNames = new List <string>();
var skipAssetNames = new List <string>();
var allAssets = akyuiLoader.AssetsInfo.Assets.ToList();
foreach (var trigger in settings.Triggers)
{
trigger.OnPreprocessAllAssets(akyuiLoader, ref allAssets);
}
progress.SetTotal(allAssets.Count);
foreach (var tmp in allAssets)
{
var asset = tmp;
using (progress.TaskStart(asset.FileName))
{
var savePath = Path.Combine(pathGetter.AssetOutputDirectoryPath, asset.FileName);
var saveFullPath = Path.Combine(unityAssetsParentPath, savePath);
if (!settings.ReimportAsset && File.Exists(saveFullPath))
{
var import = AssetImporter.GetAtPath(savePath);
var prevUserData = JsonSerializer.Deserialize <Dictionary <string, object> >(import.userData);
if (prevUserData["hash"].JsonLong() == asset.Hash)
{
skipAssetNames.Add(asset.FileName);
assets.Add(AssetDatabase.LoadAssetAtPath <Object>(import.assetPath));
continue;
}
}
var bytes = akyuiLoader.LoadAsset(asset.FileName); // Hashチェック後に初めて呼ぶ
var userData = new Dictionary <string, object>();
userData["hash"] = asset.Hash;
if (asset is SpriteAsset)
{
var texture = new Texture2D(2, 2);
texture.LoadImage(bytes);
userData["source_width"] = texture.width;
userData["source_height"] = texture.height;
}
foreach (var trigger in settings.Triggers)
{
trigger.OnPreprocessAsset(akyuiLoader, ref bytes, ref asset, ref userData);
}
ImportAsset(asset, savePath, saveFullPath, bytes, userData, settings, logger);
assets.Add(AssetDatabase.LoadAssetAtPath <Object>(savePath));
importAssetNames.Add(asset.FileName);
}
}
var importAssets = assets.ToArray();
foreach (var trigger in settings.Triggers)
{
trigger.OnPostprocessAllAssets(akyuiLoader, importAssets);
}
logger.Log($"Import Finish", ("import", importAssetNames.Count), ("skip", skipAssetNames.Count), ("time", $"{stopWatch.Elapsed.TotalSeconds:0.00}s"));
return(importAssets);
}
}
public virtual void OnPreprocessAsset(IAkyuiLoader loader, ref byte[] bytes, ref IAsset asset, ref Dictionary<string, object> userData) { }
public virtual void OnPostprocessAllAssets(IAkyuiLoader loader, Object[] importAssets) { }
public virtual void OnPostprocessPrefab(IAkyuiLoader loader, ref GameObject prefab) { }
public virtual void OnPostprocessFile(IAkyuiLoader loader, IPathGetter pathGetter) { }
