/// <summary> アセットのルートハッシュ情報を書き込み </summary>
public void SetAssetInfoHash(AssetInfoManifest assetInfoManifest)
{
// 文字数が大きくなりすぎないように300ファイル分毎に分割.
var chunkInfos = assetInfoManifest.GetAssetInfos()
.Chunk(300)
.ToArray();
var versionHashBuilder = new StringBuilder();
foreach (var assetInfos in chunkInfos)
{
var hashBuilder = new StringBuilder();
foreach (var assetInfo in assetInfos)
{
hashBuilder.AppendLine(assetInfo.Hash);
}
var hash = hashBuilder.ToString().GetHash();
versionHashBuilder.AppendLine(hash);
}
var versionHash = versionHashBuilder.ToString().GetHash();
Reflection.SetPrivateField(assetInfoManifest, "versionHash", versionHash);
}
//----- property -----
//----- method -----
public override void OnInspectorGUI()
{
instance = target as AssetInfoManifest;
if (!initialized)
{
var assetInfos = Reflection.GetPrivateField <AssetInfoManifest, AssetInfo[]>(instance, "assetInfos");
currentInfos = assetInfos.GroupBy(x => x.Category)
.Select(x => new AssetCategoryInfo(x.Key, x.ToArray()))
.OrderBy(x => x.Category, new NaturalComparer())
.ToArray();
asstInfoScrollView = new AsstInfoScrollView();
asstInfoScrollView.Contents = currentInfos;
hashGuiStyle = new GUIStyle(EditorStyles.miniBoldLabel)
{
alignment = TextAnchor.MiddleLeft,
};
totalAssetCountText = string.Format("Total Asset Count : {0}", assetInfos.Length);
initialized = true;
}
DrawInspector();
}
/// <summary> 未登録のアセットバンドル情報追加 </summary>
public void AddUnregisteredAssetInfos(AssetInfoManifest assetInfoManifest, BuildResult buildResult)
{
var assetBundleAssetInfos = assetInfoManifest.GetAssetInfos()
.Where(x => x.IsAssetBundle)
.GroupBy(x => x.AssetBundle.AssetBundleName)
.ToArray();
foreach (var bundleInfo in buildResult.BundleBuildResults.BundleInfos)
{
var assetBundleName = bundleInfo.Key;
// マニフェストファイルは登録しない.
if (AssetInfoManifest.AssetBundleName == assetBundleName)
{
continue;
}
// 既に登録済み.
if (assetBundleAssetInfos.Any(x => x.Key == assetBundleName))
{
continue;
}
var fileName = Path.GetFileName(bundleInfo.Value.FileName);
var assetInfo = new AssetInfo(fileName, "(undefined)", null);
var assetBundleInfo = new AssetBundleInfo(assetBundleName);
assetInfo.SetAssetBundleInfo(assetBundleInfo);
assetInfoManifest.AddAssetInfo(assetInfo);
}
}
public override void OnBegin()
{
assetManageManager = null;
assetInfoManifest = null;
changeAssetInfo = false;
var projectFolders = ProjectFolders.Instance;
var assetManageConfig = AssetManageConfig.Instance;
if (projectFolders != null && assetManageConfig != null)
{
assetManageManager = AssetManageManager.Instance;
externalResourcesPath = projectFolders.ExternalResourcesPath;
assetManageManager.Initialize(externalResourcesPath, assetManageConfig);
var manifestPath = PathUtility.Combine(externalResourcesPath, AssetInfoManifest.ManifestFileName);
assetInfoManifest = AssetDatabase.LoadAssetAtPath <AssetInfoManifest>(manifestPath);
if (assetInfoManifest != null)
{
assetInfos = Reflection.GetPrivateField <AssetInfoManifest, AssetInfo[]>(assetInfoManifest, "assetInfos");
}
}
}
private static void ApplyAssetBundleName(AssetManagement assetManagement, AssetInfoManifest manifest)
{
var projectFolders = ProjectFolders.Instance;
var externalResourcesPath = projectFolders.ExternalResourcesPath;
var shareResourcesPath = projectFolders.ShareResourcesPath;
var assetInfos = manifest.GetAssetInfos().ToArray();
var count = assetInfos.Length;
using (new AssetEditingScope())
{
for (var i = 0; i < count; i++)
{
var assetInfo = assetInfos[i];
var apply = false;
if (assetInfo.IsAssetBundle)
{
var assetPath = ExternalResources.GetAssetPathFromAssetInfo(externalResourcesPath, shareResourcesPath, assetInfo);
apply = assetManagement.SetAssetBundleName(assetPath, assetInfo.AssetBundle.AssetBundleName);
}
if (apply)
{
EditorUtility.DisplayProgressBar("ApplyAssetBundleName", assetInfo.ResourcePath, (float)i / count);
}
}
}
EditorUtility.ClearProgressBar();
}
public static async Task BuildAssetInfoManifestPackage(string exportPath, string assetBundlePath, string aesKey, string aesIv)
{
var assetInfo = AssetInfoManifest.GetManifestAssetInfo();
var cryptoKey = new AesCryptoStreamKey(aesKey, aesIv);
var task = CreateBuildTask(exportPath, assetBundlePath, assetInfo, true, cryptoKey);
await task;
}
/// <summary> アセットバンドルの参照情報を書き込み </summary>
public static void SetDependencies(AssetInfoManifest assetInfoManifest, AssetBundleManifest assetBundleManifest)
{
var assetInfos = assetInfoManifest.GetAssetInfos().Where(x => x.IsAssetBundle).ToArray();
foreach (var assetInfo in assetInfos)
{
var dependencies = assetBundleManifest.GetDirectDependencies(assetInfo.AssetBundle.AssetBundleName);
assetInfo.AssetBundle.SetDependencies(dependencies);
}
}
public void SetManifest(AssetInfoManifest manifest)
{
this.manifest = manifest;
BuildAssetInfoTable();
if (manifest != null)
{
CleanUnuseCache();
}
}
//----- field -----
//----- property -----
//----- method -----
public void Build(string exportPath, string assetBundlePath, AssetInfoManifest assetInfoManifest, string password, Action <int, int> reportProgress)
{
var assetInfos = assetInfoManifest.GetAssetInfos()
.Where(x => x.IsAssetBundle)
.Where(x => !string.IsNullOrEmpty(x.AssetBundle.AssetBundleName))
.GroupBy(x => x.AssetBundle.AssetBundleName)
.Select(x => x.FirstOrDefault())
.ToList();
assetInfos.Add(AssetInfoManifest.GetManifestAssetInfo());
var total = assetInfos.Count;
reportProgress(0, total);
var progress = new Progress();
var events = new List <WaitHandle>();
// スレッドで分割処理.
var workerNo = 0;
var workerPaths = new List <AssetInfo> [MaxWorkerCount];
foreach (var assetInfo in assetInfos)
{
if (workerPaths[workerNo] == null)
{
workerPaths[workerNo] = new List <AssetInfo>();
}
workerPaths[workerNo].Add(assetInfo);
workerNo = (workerNo + 1) % MaxWorkerCount;
}
foreach (var item in workerPaths)
{
if (item == null)
{
continue;
}
events.Add(StartWorker(exportPath, assetBundlePath, password, item.ToArray(), progress));
}
while (!WaitHandle.WaitAll(events.ToArray(), 100))
{
reportProgress(progress.count, total);
}
reportProgress(progress.count, total);
}
public AssetInfo[] GetAllTargetAssetInfo(AssetInfoManifest assetInfoManifest)
{
var assetInfos = assetInfoManifest.GetAssetInfos()
.Where(x => x.IsAssetBundle)
.Where(x => !string.IsNullOrEmpty(x.AssetBundle.AssetBundleName))
.GroupBy(x => x.AssetBundle.AssetBundleName)
.Select(x => x.FirstOrDefault())
.ToList();
assetInfos.Add(AssetInfoManifest.GetManifestAssetInfo());
return(assetInfos.ToArray());
}
public static async Task SetCriAssetFileInfo(string exportPath, AssetInfoManifest assetInfoManifest)
{
var assetInfos = Reflection.GetPrivateField <AssetInfoManifest, AssetInfo[]>(assetInfoManifest, "assetInfos");
var tasks = new List <Task>();
for (var i = 0; i < assetInfos.Length; i++)
{
var assetInfo = assetInfos[i];
if (assetInfo.IsAssetBundle)
{
continue;
}
var extension = Path.GetExtension(assetInfo.FileName);
if (CriAssetDefinition.AssetAllExtensions.Any(x => x == extension))
{
var filePath = PathUtility.Combine(new string[] { exportPath, assetInfo.FileName });
var task = Task.Run(() =>
{
if (!File.Exists(filePath))
{
return;
}
var fileInfo = new FileInfo(filePath);
var size = fileInfo.Exists ? fileInfo.Length : -1;
var crc = FileUtility.GetCRC(filePath);
var hash = FileUtility.GetHash(filePath);
assetInfo.SetFileInfo(size, crc, hash);
});
tasks.Add(task);
}
}
await Task.WhenAll(tasks);
Reflection.SetPrivateField(assetInfoManifest, "assetInfos", assetInfos);
UnityEditorUtility.SaveAsset(assetInfoManifest);
assetInfoManifest.BuildCache(true);
EditorUtility.ClearProgressBar();
}
/// <summary>
/// マニフェストファイルに存在しないキャッシュファイルを破棄.
/// </summary>
public string[] GetDisUsedFilePaths()
{
if (simulateMode)
{
return(null);
}
if (manifest == null)
{
return(null);
}
var installDir = GetFilePath(null);
if (string.IsNullOrEmpty(installDir))
{
return(null);
}
if (!Directory.Exists(installDir))
{
return(null);
}
var directory = Path.GetDirectoryName(installDir);
if (!Directory.Exists(directory))
{
return(null);
}
var cacheFiles = Directory.GetFiles(installDir, "*", SearchOption.AllDirectories);
var allAssetInfos = manifest.GetAssetInfos().ToList();
allAssetInfos.Add(AssetInfoManifest.GetManifestAssetInfo());
var managedFiles = allAssetInfos
.Select(x => GetFilePath(x))
.Distinct()
.ToHashSet();
return(cacheFiles
.Select(x => PathUtility.ConvertPathSeparator(x))
.Where(x => Path.GetExtension(x) == PackageExtension)
.Where(x => !managedFiles.Contains(x))
.ToArray());
}
/// <summary>
/// アセット情報ファイルを更新.
/// </summary>
public IObservable <Unit> UpdateAssetInfoManifest()
{
if (simulateMode)
{
return(Observable.ReturnUnit());
}
if (localMode)
{
return(Observable.ReturnUnit());
}
var manifestAssetInfo = AssetInfoManifest.GetManifestAssetInfo();
return(Observable.FromMicroCoroutine(() => UpdateAssetBundleInternal(manifestAssetInfo)));
}
/// <summary> アセットバンドルをパッケージ化 </summary>
public static void BuildPackage(string exportPath, AssetInfoManifest assetInfoManifest, string password)
{
var assetBundlePath = GetAssetBundleOutputPath();
var assetbundlePackageBuilder = new BuildAssetbundlePackage();
Action <int, int> reportProgress = (current, total) =>
{
var title = "Build AssetbundlePackage";
var info = string.Format("Build progress ({0}/{1})", current, total);
EditorUtility.DisplayProgressBar(title, info, current / (float)total);
};
assetbundlePackageBuilder.Build(exportPath, assetBundlePath, assetInfoManifest, password, reportProgress);
EditorUtility.ClearProgressBar();
}
private void BuildAssetInfoTable()
{
assetInfosByAssetBundleName.Clear();
if (manifest != null)
{
assetInfosByAssetBundleName = manifest.GetAssetInfos()
.Where(x => x.IsAssetBundle)
.GroupBy(x => x.AssetBundle.AssetBundleName)
.ToDictionary(x => x.Key, x => x.ToArray());
}
// ※ アセット管理情報内にAssetInfoManifestの情報は入っていないので明示的に追加する.
var manifestAssetInfo = AssetInfoManifest.GetManifestAssetInfo();
assetInfosByAssetBundleName[manifestAssetInfo.AssetBundle.AssetBundleName] = new AssetInfo[] { manifestAssetInfo };
}
/// <summary> 更新されたアセット情報取得 </summary>
public async Task <AssetInfo[]> GetUpdateTargetAssetInfo(AssetInfoManifest assetInfoManifest, Dictionary <string, DateTime> lastWriteTimeTable)
{
var assetBundlePath = GetAssetBundleOutputPath();
var assetInfos = GetAllTargetAssetInfo(assetInfoManifest);
var list = new List <AssetInfo>();
var tasks = new List <Task>();
foreach (var item in assetInfos)
{
var assetInfo = item;
var task = Task.Run(() =>
{
// アセットバンドルファイルパス.
var assetBundleFilePath = PathUtility.Combine(assetBundlePath, assetInfo.AssetBundle.AssetBundleName);
// 最終更新日を比較.
var prevLastWriteTime = lastWriteTimeTable.GetValueOrDefault(assetBundleFilePath, DateTime.MinValue);
var currentLastWriteTime = File.GetLastWriteTime(assetBundleFilePath);
// ビルド前と後で更新日時が変わっていたら更新対象.
if (currentLastWriteTime != prevLastWriteTime)
{
lock (list)
{
list.Add(assetInfo);
}
}
});
tasks.Add(task);
}
await Task.WhenAll(tasks);
return(list.ToArray());
}
//----- property -----
//----- method -----
public override void OnInspectorGUI()
{
instance = target as AssetInfoManifest;
if (!initialized)
{
assetInfos = Reflection.GetPrivateField <AssetInfoManifest, AssetInfo[]>(instance, "assetInfos");
currentAssetInfos = assetInfos;
asstInfoScrollView = new AsstInfoScrollView();
asstInfoScrollView.Contents = currentAssetInfos;
totalAssetCountText = string.Format("Total Asset Count : {0}", assetInfos.Length);
initialized = true;
}
DrawInspector();
}
//----- params -----
//----- field -----
//----- property -----
//----- method -----
/// <summary>
/// CriAssetをアセットバンドルの出力先にコピー.
/// </summary>
public static void Generate(string exportPath, AssetInfoManifest assetInfoManifest)
{
var projectFolders = ProjectFolders.Instance;
if (projectFolders == null)
{
return;
}
var externalResourcesPath = projectFolders.ExternalResourcesPath;
Func <AssetInfo, bool> isCriAssetInfo = x =>
{
if (string.IsNullOrEmpty(x.FileName))
{
return(false);
}
var extension = Path.GetExtension(x.ResourcePath);
return(CriAssetDefinition.AssetAllExtensions.Contains(extension));
};
var assetInfos = assetInfoManifest.GetAssetInfos().Where(x => isCriAssetInfo(x)).ToArray();
foreach (var assetInfo in assetInfos)
{
var source = PathUtility.Combine(new string[] { UnityPathUtility.GetProjectFolderPath(), externalResourcesPath, assetInfo.ResourcePath });
var dest = PathUtility.Combine(new string[] { exportPath, assetInfo.FileName });
var directory = Path.GetDirectoryName(dest);
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
File.Copy(source, dest, true);
}
}
/// <summary> AssetInfoManifest読み込み </summary>
private async Task LoadAssetInfoManifest()
{
Debug.Log("Load AssetInfoManifest.package.");
var projectFolders = ProjectFolders.Instance;
assetInfoManifestFilePath = GetAssetInfoManifestFilePath(files);
var manifestAssetInfo = AssetInfoManifest.GetManifestAssetInfo();
var assetPath = PathUtility.Combine(projectFolders.ExternalResourcesPath, manifestAssetInfo.ResourcePath);
var cryptoKey = GetCryptoKey();
using (var fileStream = new FileStream(assetInfoManifestFilePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
using (var aesStream = new SeekableCryptoStream(fileStream, cryptoKey))
{
var bundleLoadRequest = AssetBundle.LoadFromStreamAsync(aesStream);
while (!bundleLoadRequest.isDone)
{
await Task.Delay(25);
}
var assetBundle = bundleLoadRequest.assetBundle;
var loadAssetAsync = assetBundle.LoadAssetAsync(assetPath, typeof(AssetInfoManifest));
while (!loadAssetAsync.isDone)
{
await Task.Delay(25);
}
assetInfoManifest = loadAssetAsync.asset as AssetInfoManifest;
assetBundle.Unload(false);
}
}
}
//----- property -----
//----- method -----
public override void OnInspectorGUI()
{
instance = target as AssetInfoManifest;
if (!initialized)
{
var assetInfos = Reflection.GetPrivateField <AssetInfoManifest, AssetInfo[]>(instance, "assetInfos");
currentInfos = assetInfos.GroupBy(x => x.GroupName)
.Select(x => new AssetGroupInfo(x.Key, x.ToArray()))
.ToArray();
asstInfoScrollView = new AsstInfoScrollView();
asstInfoScrollView.Contents = currentInfos;
totalAssetCountText = string.Format("Total Asset Count : {0}", assetInfos.Length);
initialized = true;
}
DrawInspector();
}
/// <summary> アセットバンドルの参照情報を書き込み </summary>
public void SetDependencies(AssetInfoManifest assetInfoManifest, BuildResult buildResult)
{
var assetInfos = assetInfoManifest.GetAssetInfos().Where(x => x.IsAssetBundle).ToArray();
foreach (var assetInfo in assetInfos)
{
if (!assetInfo.IsAssetBundle)
{
continue;
}
var assetBundleName = assetInfo.AssetBundle.AssetBundleName;
var detail = buildResult.GetDetails(assetBundleName);
if (!detail.HasValue)
{
throw new InvalidDataException("AssetBundle build info not found. : " + assetBundleName);
}
assetInfo.AssetBundle.SetDependencies(detail.Value.Dependencies);
}
}
//----- params -----
//----- field -----
//----- property -----
//----- method -----
public static AssetInfoManifest Generate()
{
AssetInfoManifest manifest = null;
var assetManagement = AssetManagement.Instance;
assetManagement.Initialize();
using (new AssetEditingScope())
{
DeleteUndefinedAssetBundleNames(assetManagement);
manifest = GenerateManifest(assetManagement);
ApplyAssetBundleName(assetManagement, manifest);
}
AssetDatabase.RemoveUnusedAssetBundleNames();
AssetDatabase.Refresh();
AssetManagement.Prefs.manifestUpdateRequest = false;
return(manifest);
}
/// <summary>
/// マニフェストファイルに存在しないキャッシュファイルを破棄.
/// </summary>
private void CleanUnuseCache()
{
if (simulateMode)
{
return;
}
if (manifest == null)
{
return;
}
var installDir = BuildFilePath(null);
if (string.IsNullOrEmpty(installDir))
{
return;
}
if (!Directory.Exists(installDir))
{
return;
}
var sw = System.Diagnostics.Stopwatch.StartNew();
var builder = new StringBuilder();
var directory = Path.GetDirectoryName(installDir);
if (Directory.Exists(directory))
{
var cacheFiles = Directory.GetFiles(installDir, "*", SearchOption.AllDirectories);
var allAssetInfos = manifest.GetAssetInfos().ToList();
allAssetInfos.Add(AssetInfoManifest.GetManifestAssetInfo());
var managedFiles = allAssetInfos
.Select(x => BuildFilePath(x))
.Select(x => PathUtility.ConvertPathSeparator(x))
.Distinct()
.ToHashSet();
var targets = cacheFiles
.Select(x => PathUtility.ConvertPathSeparator(x))
.Where(x => Path.GetExtension(x) == PackageExtension)
.Where(x => !managedFiles.Contains(x))
.ToArray();
foreach (var target in targets)
{
if (!File.Exists(target))
{
continue;
}
File.SetAttributes(target, FileAttributes.Normal);
File.Delete(target);
builder.AppendLine(target);
}
var deleteDirectorys = DirectoryUtility.DeleteEmpty(installDir);
deleteDirectorys.ForEach(x => builder.AppendLine(x));
sw.Stop();
var log = builder.ToString();
if (!string.IsNullOrEmpty(log))
{
UnityConsole.Info("Delete unuse cached assetbundles ({0}ms)\n{1}", sw.Elapsed.TotalMilliseconds, log);
}
}
}
public static async Task SetAssetBundleFileInfo(string exportPath, AssetInfoManifest assetInfoManifest, BuildResult buildResult)
{
var assetInfos = Reflection.GetPrivateField <AssetInfoManifest, AssetInfo[]>(assetInfoManifest, "assetInfos");
var assetBundleGroups = assetInfos
.Where(x => x.IsAssetBundle)
.GroupBy(x => x.AssetBundle.AssetBundleName);
var tasks = new Dictionary <string, Task>();
foreach (var assetBundleGroup in assetBundleGroups)
{
var assetBundleName = assetBundleGroup.Key;
if (tasks.ContainsKey(assetBundleName))
{
continue;
}
var assetInfo = assetBundleGroup.First();
var detail = buildResult.GetDetails(assetBundleName);
if (!detail.HasValue)
{
throw new InvalidDataException("AssetBundle build info not found. : " + assetBundleName);
}
var filePath = PathUtility.Combine(exportPath, assetBundleName);
// CRC.
assetInfo.AssetBundle.SetCRC(detail.Value.Crc);
// Hash.
var assetBundleHash = detail.Value.Hash.ToString();
// ファイルハッシュ・ファイルサイズ設定.
var packageFilePath = Path.ChangeExtension(filePath, AssetBundleManager.PackageExtension);
var task = Task.Run(() =>
{
if (!File.Exists(packageFilePath))
{
throw new InvalidDataException("Package file not found. : " + packageFilePath);
}
var fileInfo = new FileInfo(packageFilePath);
var size = fileInfo.Exists ? fileInfo.Length : -1;
var crc = FileUtility.GetCRC(packageFilePath);
// 同じアセットバンドル名の全アセット情報を更新.
foreach (var item in assetBundleGroup)
{
item.SetFileInfo(size, crc, assetBundleHash);
}
});
tasks.Add(assetBundleName, task);
}
await Task.WhenAll(tasks.Values);
Reflection.SetPrivateField(assetInfoManifest, "assetInfos", assetInfos);
UnityEditorUtility.SaveAsset(assetInfoManifest);
assetInfoManifest.BuildCache(true);
EditorUtility.ClearProgressBar();
}
public static bool AssetDependenciesValidate(AssetInfoManifest assetInfoManifest)
{
var projectFolders = ProjectFolders.Instance;
var config = ManageConfig.Instance;
var externalResourcesPath = projectFolders.ExternalResourcesPath;
var allAssetInfos = assetInfoManifest.GetAssetInfos().ToArray();
var ignoreValidatePaths = config.IgnoreValidateTarget
.Where(x => x != null)
.Select(x => AssetDatabase.GetAssetPath(x))
.ToArray();
Func <string, bool> checkInvalid = path =>
{
// 除外対象拡張子はチェック対象外.
var extension = Path.GetExtension(path);
if (IgnoreDependentCheckExtensions.Any(y => y == extension))
{
return(false);
}
// 除外対象.
if (ignoreValidatePaths.Any(x => path.StartsWith(x)))
{
return(false);
}
// 外部アセット対象ではない.
if (!path.StartsWith(externalResourcesPath))
{
return(true);
}
return(false);
};
using (new DisableStackTraceScope())
{
foreach (var assetInfo in allAssetInfos)
{
var assetPath = PathUtility.Combine(externalResourcesPath, assetInfo.ResourcePath);
var dependencies = AssetDatabase.GetDependencies(assetPath);
var invalidDependencies = dependencies.Where(x => checkInvalid(x)).ToArray();
if (invalidDependencies.Any())
{
var builder = new StringBuilder();
builder.AppendFormat("Asset: {0}", assetPath).AppendLine();
builder.AppendLine("Invalid Dependencies:");
foreach (var item in invalidDependencies)
{
builder.AppendLine(item);
}
Debug.LogWarningFormat(builder.ToString());
return(false);
}
}
}
return(true);
}
public void SetManifest(AssetInfoManifest manifest)
{
this.manifest = manifest;
}
public void SetManifest(AssetInfoManifest manifest)
{
this.manifest = manifest;
CleanUnuseCache();
}
public static async Task <string> Build(string exportPath, AssetInfoManifest assetInfoManifest, bool openExportFolder = true)
{
if (string.IsNullOrEmpty(exportPath))
{
return(null);
}
if (Directory.Exists(exportPath))
{
Directory.Delete(exportPath, true);
}
var versionHash = string.Empty;
var assetManagement = AssetManagement.Instance;
assetManagement.Initialize();
var buildAssetBundle = new BuildAssetBundle(BundlePipeline);
EditorApplication.LockReloadAssemblies();
try
{
var stopwatch = System.Diagnostics.Stopwatch.StartNew();
var logBuilder = new StringBuilder();
var manageConfig = ManageConfig.Instance;
var cryptoKey = manageConfig.CryptoKey;
var cryptoIv = manageConfig.CryptoIv;
var assetBundlePath = buildAssetBundle.GetAssetBundleOutputPath();
// 暗号化鍵情報の変更チェック.
var cryptoChanged = BuildAssetBundlePackage.CheckCryptoFile(assetBundlePath, cryptoKey, cryptoIv);
using (new DisableStackTraceScope())
{
var processTime = System.Diagnostics.Stopwatch.StartNew();
//------ アセットバンドル名を設定------
using (new BuildLogScope(logBuilder, processTime, "ApplyAllAssetBundleName"))
{
assetManagement.ApplyAllAssetBundleName();
}
//------ キャッシュ済みアセットバンドルの最終更新日時取得 ------
Dictionary <string, DateTime> cachedFileLastWriteTimeTable = null;
using (new BuildLogScope(logBuilder, processTime, "GetCachedFileLastWriteTimeTable"))
{
cachedFileLastWriteTimeTable = await buildAssetBundle.GetCachedFileLastWriteTimeTable();
}
//------ CRIアセットを生成 ------
#if ENABLE_CRIWARE_ADX || ENABLE_CRIWARE_SOFDEC
using (new BuildLogScope(logBuilder, processTime, "GenerateCriAsset"))
{
CriAssetGenerator.Generate(exportPath, assetInfoManifest);
}
#endif
//------ AssetBundleをビルド ------
BuildResult buildResult = null;
using (new BuildLogScope(logBuilder, processTime, "BuildAllAssetBundles"))
{
buildResult = buildAssetBundle.BuildAllAssetBundles();
}
if (!buildResult.IsSuccess)
{
Debug.LogError("Build ExternalResource failed.");
return(null);
}
//------ 未登録のアセットバンドル情報追加 ------
using (new BuildLogScope(logBuilder, processTime, "AddUnregisteredAssetInfos"))
{
buildAssetBundle.AddUnregisteredAssetInfos(assetInfoManifest, buildResult);
}
//------ 不要になった古いAssetBundle削除 ------
using (new BuildLogScope(logBuilder, processTime, "CleanUnUseAssetBundleFiles"))
{
buildAssetBundle.CleanUnUseAssetBundleFiles(buildResult);
}
//------ AssetBundleファイルをパッケージ化 ------
// 暗号化鍵情報の書き込み.
using (new BuildLogScope(logBuilder, processTime, "CreateCryptoFile"))
{
BuildAssetBundlePackage.CreateCryptoFile(assetBundlePath, cryptoKey, cryptoIv);
}
// 更新対象のアセット情報取得.
var assetInfos = new AssetInfo[0];
var updatedAssetInfos = new AssetInfo[0];
using (new BuildLogScope(logBuilder, processTime, "GetUpdateTargetAssetInfo"))
{
assetInfos = buildAssetBundle.GetAllTargetAssetInfo(assetInfoManifest);
// 暗号化キーが変わっていたら全て更新対象.
if (cryptoChanged)
{
updatedAssetInfos = assetInfos;
}
// 差分がある対象だけ抽出.
else
{
updatedAssetInfos = await buildAssetBundle.GetUpdateTargetAssetInfo(assetInfoManifest, cachedFileLastWriteTimeTable);
}
}
// パッケージファイル作成.
using (new BuildLogScope(logBuilder, processTime, "BuildPackage"))
{
await BuildAssetBundlePackage.BuildAllAssetBundlePackage(exportPath, assetBundlePath, assetInfos, updatedAssetInfos, cryptoKey, cryptoIv);
}
//------ ビルド成果物の情報をAssetInfoManifestに書き込み ------
using (new BuildLogScope(logBuilder, processTime, "AssetInfoManifest : SetAssetBundleFileInfo"))
{
await AssetInfoManifestGenerator.SetAssetBundleFileInfo(assetBundlePath, assetInfoManifest, buildResult);
#if ENABLE_CRIWARE_ADX || ENABLE_CRIWARE_SOFDEC
await AssetInfoManifestGenerator.SetCriAssetFileInfo(exportPath, assetInfoManifest);
#endif
}
//------ アセットバンドルの参照情報をAssetInfoManifestに書き込み ------
using (new BuildLogScope(logBuilder, processTime, "AssetInfoManifest : SetAssetBundleDependencies"))
{
buildAssetBundle.SetDependencies(assetInfoManifest, buildResult);
}
//------ バージョンハッシュ情報をAssetInfoManifestに書き込み ------
using (new BuildLogScope(logBuilder, processTime, "AssetInfoManifest : SetAssetInfoHash"))
{
buildAssetBundle.SetAssetInfoHash(assetInfoManifest);
}
//------ 再度AssetInfoManifestだけビルドを実行 ------
using (new BuildLogScope(logBuilder, processTime, "Rebuild AssetInfoManifest"))
{
buildAssetBundle.BuildAssetInfoManifest();
}
//------ AssetInfoManifestファイルをパッケージ化 ------
using (new BuildLogScope(logBuilder, processTime, "BuildPackage AssetInfoManifest"))
{
await BuildAssetBundlePackage.BuildAssetInfoManifestPackage(exportPath, assetBundlePath, cryptoKey, cryptoIv);
}
}
versionHash = assetInfoManifest.VersionHash;
//------ バージョンをファイル出力------
GenerateVersionFile(exportPath, versionHash);
//------ ログ出力------
stopwatch.Stop();
// ビルド情報.
var buildLogText = new StringBuilder();
var totalSeconds = stopwatch.Elapsed.TotalSeconds;
buildLogText.AppendFormat("Build ExternalResource Complete. ({0:F2}sec)", totalSeconds).AppendLine();
buildLogText.AppendLine();
buildLogText.AppendFormat("VersionHash : {0}", versionHash).AppendLine();
buildLogText.AppendLine();
buildLogText.AppendLine(logBuilder.ToString());
buildLogText.AppendLine();
UnityConsole.Event(ExternalResources.ConsoleEventName, ExternalResources.ConsoleEventColor, buildLogText.ToString());
//------ 出力先フォルダを開く------
if (openExportFolder)
{
UnityEditorUtility.OpenFolder(exportPath);
}
}
catch (Exception e)
{
Debug.LogException(e);
throw;
}
finally
{
EditorApplication.UnlockReloadAssemblies();
}
return(versionHash);
}
private static void ApplyAssetBundleName(AssetManageManager assetManageManager, AssetInfoManifest manifest)
{
var assetInfos = manifest.GetAssetInfos().ToArray();
var count = assetInfos.Length;
AssetDatabase.StartAssetEditing();
for (var i = 0; i < count; i++)
{
var assetInfo = assetInfos[i];
EditorUtility.DisplayProgressBar("ApplyAssetBundleName", assetInfo.ResourcePath, (float)i / count);
var assetPath = PathUtility.Combine(assetManageManager.ExternalResourcesPath, assetInfo.ResourcePath);
if (assetInfo.IsAssetBundle)
{
assetManageManager.SetAssetBundleName(assetPath, assetInfo.AssetBundle.AssetBundleName);
}
}
AssetDatabase.StopAssetEditing();
EditorUtility.ClearProgressBar();
}
public void SetManifest(AssetInfoManifest manifest)
{
this.manifest = manifest;
BuildAssetInfoTable();
}
