public AssetInfo GetAssetInfo(string assetPath, ManageInfo managedInfo = null)
{
assetPath = PathUtility.ConvertPathSeparator(assetPath);
if (IsIgnoreManageAsset(assetPath))
{
return(null);
}
if (managedInfo == null)
{
managedInfo = GetAssetManagedInfo(assetPath);
}
if (managedInfo == null)
{
return(null);
}
var resourcePath = GetAssetLoadPath(assetPath);
var assetInfo = new AssetInfo(resourcePath, managedInfo.category, managedInfo.tag);
var assetBundleName = GetAssetBundleName(assetPath, managedInfo);
if (!string.IsNullOrEmpty(assetBundleName))
{
var assetBundleInfo = new AssetBundleInfo(assetBundleName);
assetInfo.SetAssetBundleInfo(assetBundleInfo);
}
return(assetInfo);
}
public void ReleaseAtlas(string altasFolder)
{
if (string.IsNullOrEmpty(altasFolder))
{
return;
}
altasFolder = PathUtility.ConvertPathSeparator(altasFolder);
altasFolder = altasFolder.TrimEnd(PathUtility.PathSeparator);
var atlasCache = atlasCacheByAtlasFolder.GetValueOrDefault(altasFolder);
if (atlasCache == null)
{
return;
}
atlasCache.ReleaseReference();
if (atlasCache.RefCount <= 0)
{
atlasCacheByAtlasFolder.Remove(altasFolder);
}
}
public async UniTask LoadAtlas(string altasFolder, bool force = false)
{
if (string.IsNullOrEmpty(altasFolder))
{
return;
}
altasFolder = PathUtility.ConvertPathSeparator(altasFolder);
altasFolder = altasFolder.TrimEnd(PathUtility.PathSeparator);
var atlasCache = atlasCacheByAtlasFolder.GetValueOrDefault(altasFolder);
if (!force && atlasCache != null)
{
return;
}
var atlas = await atlasLoader.Load(altasFolder);
if (atlas != null)
{
var atlasPath = atlasLoader.GetAtlasPath(altasFolder);
atlasCache = new AtlasCache(atlasPath, atlas);
atlasCacheByAtlasFolder[altasFolder] = atlasCache;
if (onLoadAtlas != null)
{
onLoadAtlas.OnNext(Unit.Default);
}
}
}
private static SheetData[] LoadSheetData(FileLoader.Format fileFormat, string recordDirectory)
{
var extension = FileLoader.GetFileExtension(fileFormat);
if (!Directory.Exists(recordDirectory))
{
Debug.LogErrorFormat("Directory {0} not found.", recordDirectory);
return(null);
}
var sheetFiles = Directory.EnumerateFiles(recordDirectory, "*.*", SearchOption.TopDirectoryOnly)
.Where(x => Path.GetExtension(x) == extension)
.Select(x => PathUtility.ConvertPathSeparator(x))
.ToArray();
var list = new List <SheetData>();
foreach (var sheetFile in sheetFiles)
{
var sheetData = FileLoader.LoadFile <SheetData>(sheetFile, fileFormat);
if (sheetData != null)
{
list.Add(sheetData);
}
}
return(list.OrderBy(x => x.index).ToArray());
}
/// <summary> キャッシュ済みアセットバンドルファイルのハッシュ値を取得 </summary>
public static Dictionary <string, string> GetCachedAssetBundleHash()
{
var assetBundlePath = GetAssetBundleOutputPath();
var assetBundleNames = AssetDatabase.GetAllAssetBundleNames()
.Select(x => PathUtility.ConvertPathSeparator(x))
.ToArray();
var allFiles = Directory.GetFiles(assetBundlePath, "*.*", SearchOption.AllDirectories);
var dictionary = new Dictionary <string, string>();
foreach (var file in allFiles)
{
var path = PathUtility.ConvertPathSeparator(file);
if (assetBundleNames.All(x => !path.EndsWith(x)))
{
continue;
}
var hash = FileUtility.GetHash(path);
dictionary.Add(path, hash);
}
return(dictionary);
}
//----- method -----
public AssetInfo(string resourcePath, string category, string tag)
{
this.resourcePath = PathUtility.ConvertPathSeparator(resourcePath);
this.category = category;
this.tag = tag;
SetFileName();
}
//----- method -----
public AssetInfo(string resourcePath, string groupName, string tag)
{
this.resourcePath = PathUtility.ConvertPathSeparator(resourcePath);
this.groupName = groupName;
this.tag = tag;
SetFileName();
}
private string[] GetAllVersionFilePaths()
{
var directoryInfo = new DirectoryInfo(InstallDirectory);
var files = directoryInfo.GetFiles("*" + AssetInfoManifest.VersionFileExtension, SearchOption.AllDirectories);
return(files.Select(x => PathUtility.ConvertPathSeparator(x.FullName)).ToArray());
}
public string GetFilePath(AssetInfo assetInfo)
{
var path = installPath;
if (assetInfo != null && !string.IsNullOrEmpty(assetInfo.FileName))
{
path = PathUtility.Combine(installPath, assetInfo.FileName) + PackageExtension;
}
return(PathUtility.ConvertPathSeparator(path));
}
public string GetFilePath(AssetInfo assetInfo)
{
var path = installPath;
if (assetInfo != null)
{
path = PathUtility.Combine(installPath, assetInfo.FileName);
}
return(PathUtility.ConvertPathSeparator(path));
}
/// <summary> 不要になったアセットバンドルを削除 </summary>
public static void CleanUnUseAssetBundleFiles()
{
var assetBundlePath = GetAssetBundleOutputPath();
var assetBundleNames = AssetDatabase.GetAllAssetBundleNames()
.Select(x => PathUtility.ConvertPathSeparator(x))
.ToArray();
var allFiles = Directory.GetFiles(assetBundlePath, "*.*", SearchOption.AllDirectories);
foreach (var file in allFiles)
{
var extension = Path.GetExtension(file);
if (extension == ManifestFileExtension)
{
continue;
}
if (extension == AssetBundleManager.PackageExtension)
{
continue;
}
var path = PathUtility.ConvertPathSeparator(file);
if (assetBundleNames.Any(x => path.EndsWith(x)))
{
continue;
}
if (File.Exists(path))
{
File.Delete(path);
}
var manifestFilePath = Path.ChangeExtension(path, ManifestFileExtension);
if (File.Exists(manifestFilePath))
{
File.Delete(manifestFilePath);
}
}
// 空フォルダ削除.
if (!string.IsNullOrEmpty(assetBundlePath))
{
DirectoryUtility.DeleteEmpty(assetBundlePath);
}
}
//----- params -----
//----- field -----
//----- property -----
//----- method -----
/// <summary> 全キャッシュ削除. </summary>
public IObservable <Unit> DeleteAllCache()
{
ReleaseManagedAssets();
UnloadAllAssetBundles(false);
ClearVersion();
var cacheFiles = Directory.GetFiles(InstallDirectory, "*", SearchOption.AllDirectories)
.Select(x => PathUtility.ConvertPathSeparator(x))
.ToArray();
return(Observable.FromMicroCoroutine(() => DeleteCacheFiles(InstallDirectory, cacheFiles)));
}
/// <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());
}
//----- method -----
public async Task <bool> Execute(string folderPath, string bucketFolder)
{
this.folderPath = folderPath;
this.bucketFolder = bucketFolder;
// ファイルパス : オブジェクトパスのディクショナリ作成.
files = Directory.GetFiles(folderPath)
.Select(x => PathUtility.ConvertPathSeparator(x))
.ToArray();
using (new DisableStackTraceScope())
{
s3Client = CreateS3Client();
AssetBundle.UnloadAllAssetBundles(true);
try
{
//------- アップロードファイル情報作成 -------
var fileInfos = BuildUploadFileInfos();
//------- S3のファイル一覧取得 -------
var s3Objects = await GetUploadedObjects();
//------- S3内の全ファイル削除 -------
// 対象のパス以下のファイル削除.
await DeleteAllPackageFromS3(s3Objects);
// 全削除したので空にする.
s3Objects = new S3Object[0];
//------- S3にアップロード -------
await UploadMasterFilesToS3(fileInfos);
}
catch (Exception e)
{
Debug.LogError(e.Message);
return(false);
}
}
return(true);
}
/// <summary> 不要になったアセットバンドルを削除 </summary>
public void CleanUnUseAssetBundleFiles(BuildResult buildResult)
{
var assetBundlePath = GetAssetBundleOutputPath();
var assetBundleNames = buildResult.BundleBuildResults.BundleInfos
.Select(x => x.Key)
.Select(x => PathUtility.ConvertPathSeparator(x))
.ToArray();
var allFiles = Directory.GetFiles(assetBundlePath, "*.*", SearchOption.AllDirectories)
.Select(x => PathUtility.ConvertPathSeparator(x))
.ToArray();
foreach (var file in allFiles)
{
var extension = Path.GetExtension(file);
if (extension == AssetBundleManager.PackageExtension)
{
continue;
}
if (assetBundleNames.Any(x => file.EndsWith(x)))
{
continue;
}
if (File.Exists(file))
{
File.Delete(file);
}
var packageFilePath = Path.ChangeExtension(file, AssetBundleManager.PackageExtension);
if (File.Exists(packageFilePath))
{
File.Delete(packageFilePath);
}
}
// 空フォルダ削除.
if (!string.IsNullOrEmpty(assetBundlePath))
{
DirectoryUtility.DeleteEmpty(assetBundlePath);
}
}
private Dictionary <string, ImportData> LoadImportData(BehaviorControlSetting setting, FileLoader.Format fileFormat)
{
var extension = FileLoader.GetFileExtension(fileFormat);
if (!Directory.Exists(selectionDirectory))
{
return(null);
}
var files = Directory.EnumerateFiles(selectionDirectory, "*.*", SearchOption.AllDirectories)
.Where(x => Path.GetExtension(x) == extension)
.Select(x => PathUtility.ConvertPathSeparator(x))
.ToArray();
var dictionary = new Dictionary <string, ImportData>();
foreach (var file in files)
{
var assetPath = ConvertDataPathToAssetPath(setting, file);
var behaviorControlAsset = AssetDatabase.LoadMainAssetAtPath(assetPath) as BehaviorControlAsset;
if (behaviorControlAsset != null && behaviorControlAsset.LastUpdate.HasValue)
{
var fileLastUpdate = File.GetLastWriteTimeUtc(file);
var assetLastUpdate = behaviorControlAsset.LastUpdate.Value;
if (fileLastUpdate <= assetLastUpdate)
{
continue;
}
}
var data = FileLoader.LoadFile <ImportData>(file, fileFormat);
if (data != null)
{
dictionary.Add(file, data);
}
}
return(dictionary);
}
/// <summary> キャッシュ済みアセットバンドルファイルの最終更新日テーブルを取得 </summary>
public async Task <Dictionary <string, DateTime> > GetCachedFileLastWriteTimeTable()
{
var assetBundlePath = GetAssetBundleOutputPath();
var assetBundleNames = AssetDatabase.GetAllAssetBundleNames()
.Select(x => PathUtility.ConvertPathSeparator(x))
.ToArray();
var allFiles = Directory.GetFiles(assetBundlePath, "*.*", SearchOption.AllDirectories)
.Where(x => Path.GetExtension(x) == string.Empty)
.Select(x => PathUtility.ConvertPathSeparator(x))
.ToArray();
var dictionary = new Dictionary <string, DateTime>();
var tasks = new List <Task>();
foreach (var file in allFiles)
{
var path = PathUtility.ConvertPathSeparator(file);
var task = Task.Run(() =>
{
if (assetBundleNames.All(x => !path.EndsWith(x)))
{
return;
}
var lastWriteTime = File.GetLastWriteTime(path);
lock (dictionary)
{
dictionary.Add(path, lastWriteTime);
}
});
tasks.Add(task);
}
await Task.WhenAll(tasks);
return(dictionary);
}
public static bool IsFolderItem(string assetPath, Object[] folders, string[] ignoreFolders)
{
assetPath = PathUtility.ConvertPathSeparator(assetPath);
ignoreFolders = ignoreFolders.Select(x => PathUtility.ConvertPathSeparator(x)).ToArray();
var targetPaths = folders.Where(x => x != null).Select(x => AssetDatabase.GetAssetPath(x));
var pathSeparatorStr = PathUtility.PathSeparator.ToString();
foreach (var targetPath in targetPaths)
{
var path = PathUtility.ConvertPathSeparator(targetPath);
if (assetPath.StartsWith(path + pathSeparatorStr))
{
// フォルダパスで除外.
var ignoreFolderPaths = ignoreFolders.Where(x => x.EndsWith(pathSeparatorStr)).ToArray();
if (ignoreFolderPaths.Any(x => assetPath.Contains(x)))
{
continue;
}
// フォルダ名で除外.
var parts = assetPath.Substring(path.Length).Split(PathUtility.PathSeparator);
if (parts.Any(x => ignoreFolders.Contains(x)))
{
continue;
}
return(true);
}
}
return(false);
}
public static bool IsFolderItem(string assetPath, Object[] folders, string[] ignoreFolderNames)
{
assetPath = PathUtility.ConvertPathSeparator(assetPath);
var targetPaths = folders.Where(x => x != null).Select(x => AssetDatabase.GetAssetPath(x));
foreach (var targetPath in targetPaths)
{
var path = PathUtility.ConvertPathSeparator(targetPath);
if (assetPath.StartsWith(path + PathUtility.PathSeparator))
{
var parts = assetPath.Substring(path.Length).Split(PathUtility.PathSeparator);
if (parts.All(x => !ignoreFolderNames.Contains(x)))
{
return(true);
}
}
}
return(false);
}
private IEnumerator LoadTextureInfos(IObserver <TextureInfo[]> observer)
{
var config = TextureViewerConfig.Instance;
var ignoreFolderPaths = config.IgnoreFolderPaths;
var ignoreFolderNames = config.IgnoreFolderNames;
var infos = new List <TextureInfo>();
var textureGuids = AssetDatabase.FindAssets("t:texture").ToArray();
var index = 0;
var total = textureGuids.Length;
var chunk = textureGuids.Chunk(100).ToArray();
Action displayProgress = () =>
{
EditorUtility.DisplayProgressBar("Progress", "Loading texture infos in project", (float)index / total);
};
foreach (var guids in chunk)
{
displayProgress.Invoke();
foreach (var guid in guids)
{
index++;
var assetPath = PathUtility.ConvertPathSeparator(AssetDatabase.GUIDToAssetPath(guid));
// Assets以外のファイル除外.
if (!assetPath.StartsWith(UnityEditorUtility.AssetsFolderName))
{
continue;
}
// 除外フォルダ以下のファイル除外.
if (ignoreFolderPaths.Any(y => assetPath.StartsWith(y)))
{
continue;
}
// 除外フォルダ名を含むファイル除外.
var assetFolderPath = PathUtility.ConvertPathSeparator(Path.GetDirectoryName(assetPath));
var folders = assetFolderPath.Split(PathUtility.PathSeparator);
if (folders.Any(x => ignoreFolderNames.Contains(x)))
{
continue;
}
// 生成.
var info = new TextureInfo(index, guid, assetPath);
// TextureImporterが取得できない場合は除外.
if (info.TextureImporter == null)
{
continue;
}
// 追加.
infos.Add(info);
}
yield return(null);
}
displayProgress.Invoke();
observer.OnNext(infos.ToArray());
observer.OnCompleted();
}
private static string[] FindAllFiles(string assetPath, string searchPattern)
{
return(Directory.GetFiles(assetPath, searchPattern, SearchOption.AllDirectories)
.Select(x => PathUtility.ConvertPathSeparator(x))
.ToArray());
}
/// <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);
}
}
}
//----- method -----
public async Task <string> Execute(string folderPath, string bucketFolder)
{
var versionHash = string.Empty;
this.folderPath = folderPath;
// ファイルパス : オブジェクトパスのディクショナリ作成.
files = Directory.GetFiles(folderPath)
.Select(x => PathUtility.ConvertPathSeparator(x))
.ToArray();
using (new DisableStackTraceScope(LogType.Log))
{
AssetBundle.UnloadAllAssetBundles(true);
try
{
//------- AssetInfoManifest.package読み込み -------
await LoadAssetInfoManifest();
if (assetInfoManifest == null)
{
Debug.LogError("AssetInfoManifest.package file load error.");
return(null);
}
versionHash = assetInfoManifest.VersionHash;
if (string.IsNullOrEmpty(versionHash))
{
throw new InvalidDataException("VersionHash is empty.");
}
this.bucketFolder = PathUtility.Combine(bucketFolder, versionHash);
//------- アップロードファイル情報作成 -------
var fileInfos = BuildUploadFileInfos();
//------- S3クライアント作成 -------
s3Client = CreateS3Client();
//------- S3のファイル一覧取得 -------
var s3Objects = await GetUploadedObjects();
//------- S3ファイル情報作成 -------
var s3FileInfos = await BuildUploadedObjectInfos(s3Objects);
//------- 削除対象のファイルをS3から削除 -------
await DeleteDeletedPackageFromS3(fileInfos, s3FileInfos);
//------- 新規・更新対象のファイルをS3にアップロード -------
await UploadPackagesToS3(fileInfos, s3FileInfos);
}
catch (Exception e)
{
Debug.LogErrorFormat("S3 upload process error. \n{0}", e.Message);
return(null);
}
}
return(versionHash);
}
public static void Generate(string[] sceneFolders, string scriptPath)
{
var enums = new StringBuilder();
var contents = new StringBuilder();
// 最も一致率の高いパスから検索する為長さで並べ替え.
var sceneFolderPaths = sceneFolders.OrderBy(x => x.Length);
var scenes = EditorBuildSettings.scenes;
for (var i = 0; i < scenes.Length; ++i)
{
var scene = scenes[i];
if (!scene.enabled)
{
continue;
}
var path = PathUtility.ConvertPathSeparator(scene.path);
var enumName = string.Empty;
foreach (var item in sceneFolderPaths)
{
var sceneFolderPath = item;
// フォルダで'/'が付いていない時.
if (AssetDatabase.IsValidFolder(sceneFolderPath) && sceneFolderPath.LastOrDefault() != PathUtility.PathSeparator)
{
sceneFolderPath = sceneFolderPath + PathUtility.PathSeparator;
}
// シーンフォルダまでのパスを除外したEnum名を作成.
if (path.StartsWith(sceneFolderPath))
{
var scenePath = path.SafeSubstring(sceneFolderPath.Length).Replace(PathUtility.PathSeparator, '_');
enumName = Path.GetFileNameWithoutExtension(scenePath);
break;
}
}
if (string.IsNullOrEmpty(enumName))
{
enumName = Path.GetFileNameWithoutExtension(path);
}
enums.Append("\t\t").AppendFormat("{0},", enumName);
contents.Append("\t\t\t").AppendFormat("{{ Scenes.{0}, \"{1}\" }},", enumName, path);
// 最終行は改行しない.
if (i < scenes.Length - 1)
{
enums.AppendLine();
contents.AppendLine();
}
}
var script = ScriptTemplate;
script = Regex.Replace(script, "#ENUMS#", enums.ToString());
script = Regex.Replace(script, "#CONTENTS#", contents.ToString());
script = script.FixLineEnd();
var folderPath = PathUtility.Combine(scriptPath, @"Constants");
ScriptGenerateUtility.GenerateScript(folderPath, @"Scenes.cs", script);
}
private string GetAssetBundleName(string assetPath, ManageInfo manageInfo)
{
//-------------------------------------------------------------------------------------
// ※ nullを返すと再インポート時に無限ループになるので未設定の場合はstring.Emptyを返す.
//-------------------------------------------------------------------------------------
var assetBundleName = string.Empty;
if (manageInfo == null)
{
return(string.Empty);
}
if (string.IsNullOrEmpty(manageInfo.guid))
{
return(string.Empty);
}
if (!manageInfo.isAssetBundle)
{
return(string.Empty);
}
// カテゴリ名設定.
var category = manageInfo.category;
if (!string.IsNullOrEmpty(category))
{
assetBundleName += category + PathUtility.PathSeparator;
}
// 管理アセットの親フォルダパス.
var managePath = AssetDatabase.GUIDToAssetPath(manageInfo.guid);
var parentDir = PathUtility.ConvertPathSeparator(Directory.GetParent(managePath).ToString() + PathUtility.PathSeparator);
var resourcesDir = string.Empty;
if (assetPath.StartsWith(externalResourcesPath))
{
resourcesDir = externalResourcesPath + PathUtility.PathSeparator;
}
else if (assetPath.StartsWith(shareResourcesPath))
{
resourcesDir = shareResourcesPath + PathUtility.PathSeparator;
}
var folder = parentDir.Substring(resourcesDir.Length);
assetBundleName += folder.Replace(PathUtility.PathSeparator.ToString(), AssetNameSeparator);
switch (manageInfo.assetBundleNamingRule)
{
case AssetBundleNamingRule.ManageAssetName:
assetBundleName += Path.GetFileNameWithoutExtension(managePath);
break;
case AssetBundleNamingRule.ChildAssetName:
case AssetBundleNamingRule.PrefixAndChildAssetName:
{
assetBundleName += Path.GetFileNameWithoutExtension(managePath) + AssetNameSeparator;
if (AssetDatabase.IsValidFolder(managePath))
{
folder += Path.GetFileNameWithoutExtension(managePath) + AssetNameSeparator;
}
var resourcePath = assetPath.Substring((resourcesDir + folder).Length);
var targetName = resourcePath.Split(PathUtility.PathSeparator).FirstOrDefault(x => !string.IsNullOrEmpty(x));
switch (manageInfo.assetBundleNamingRule)
{
case AssetBundleNamingRule.ChildAssetName:
assetBundleName += Path.GetFileNameWithoutExtension(targetName);
break;
case AssetBundleNamingRule.PrefixAndChildAssetName:
assetBundleName += manageInfo.assetBundleNameStr + AssetNameSeparator + Path.GetFileNameWithoutExtension(targetName);
break;
}
}
break;
case AssetBundleNamingRule.Specified:
{
assetBundleName += Path.GetFileNameWithoutExtension(managePath) + AssetNameSeparator;
assetBundleName += manageInfo.assetBundleNameStr;
}
break;
}
if (string.IsNullOrEmpty(assetBundleName))
{
return(string.Empty);
}
// アセットバンドル名は小文字しか設定出来ないので小文字に変換.
return(assetBundleName.ToLower());
}
private string GetAssetBundleName(string assetPath, ManageInfo manageInfo)
{
//-------------------------------------------------------------------------------------
// ※ nullを返すと再インポート時に無限ループになるので未設定の場合はstring.Emptyを返す.
//-------------------------------------------------------------------------------------
var assetBundleName = string.Empty;
if (manageInfo == null)
{
return(string.Empty);
}
if (manageInfo.assetObject == null)
{
return(string.Empty);
}
if (!manageInfo.isAssetBundle)
{
return(string.Empty);
}
// グループ名設定.
var assetGroupName = GetAssetGroupName(manageInfo);
if (!string.IsNullOrEmpty(assetGroupName))
{
assetBundleName = assetGroupName + PathUtility.PathSeparator;
}
// 管理アセットの親フォルダパス.
var managePath = AssetDatabase.GetAssetPath(manageInfo.assetObject);
var parentDir = PathUtility.ConvertPathSeparator(Directory.GetParent(managePath).ToString() + PathUtility.PathSeparator);
var externalResourcesDir = externalResourcesPath + PathUtility.PathSeparator;
var folder = parentDir.Substring(externalResourcesDir.Length);
assetBundleName += folder.Replace(PathUtility.PathSeparator.ToString(), AssetNameSeparator);
switch (manageInfo.assetBundleNameType)
{
case ManageInfo.NameType.ManageAssetName:
assetBundleName += Path.GetFileNameWithoutExtension(managePath);
break;
case ManageInfo.NameType.ChildAssetName:
case ManageInfo.NameType.PrefixAndChildAssetName:
{
assetBundleName += Path.GetFileNameWithoutExtension(managePath) + AssetNameSeparator;
if (AssetDatabase.IsValidFolder(managePath))
{
folder += Path.GetFileNameWithoutExtension(managePath) + AssetNameSeparator;
}
var resourcePath = assetPath.Substring((externalResourcesDir + folder).Length);
switch (manageInfo.assetBundleNameType)
{
case ManageInfo.NameType.ChildAssetName:
assetBundleName += Path.GetFileNameWithoutExtension(resourcePath);
break;
case ManageInfo.NameType.PrefixAndChildAssetName:
assetBundleName += manageInfo.assetBundleNameStr + AssetNameSeparator + Path.GetFileNameWithoutExtension(resourcePath);
break;
}
}
break;
case ManageInfo.NameType.Specified:
{
assetBundleName += Path.GetFileNameWithoutExtension(managePath) + AssetNameSeparator;
assetBundleName += manageInfo.assetBundleNameStr;
}
break;
}
if (string.IsNullOrEmpty(assetBundleName))
{
return(string.Empty);
}
// アセットバンドル名は小文字しか設定出来ないので小文字に変換.
return(assetBundleName.ToLower());
}
private void CustomInspector()
{
var managedFolders = instance.ManagedFolders.ToList();
var contentHeight = 16f;
EditorLayoutTools.SetLabelWidth(100f);
// Style.
var pathTextStyle = GUI.skin.GetStyle("TextArea");
pathTextStyle.alignment = TextAnchor.MiddleLeft;
EditorGUILayout.Separator();
// InitialScene.
using (new EditorGUILayout.HorizontalScope())
{
GUILayout.Label("Initial Scene", GUILayout.Width(80f), GUILayout.Height(contentHeight));
GUILayout.Label(instance.InitialScene, pathTextStyle, GUILayout.Height(contentHeight));
if (GUILayout.Button("Select", GUILayout.Width(60f), GUILayout.Height(contentHeight)))
{
UnityEditorUtility.RegisterUndo("SceneImporterConfigInspector-Undo", instance);
var initialScenePath = EditorUtility.OpenFilePanelWithFilters("Select Initial Scene", "Assets", new string[] { "SceneFile", "unity" });
initialScenePath = initialScenePath.Replace(Application.dataPath, "Assets");
Reflection.SetPrivateField(instance, "initialScene", initialScenePath);
}
}
EditorGUILayout.Separator();
// AutoAdditionFolders.
EditorLayoutTools.Title("Managed Folders");
var change = false;
using (new ContentsScope())
{
var scrollViewHeight = System.Math.Min(contentHeight * managedFolders.Count + 5f, 300f);
using (var scrollViewScope = new EditorGUILayout.ScrollViewScope(scrollPosition, GUILayout.Height(scrollViewHeight)))
{
for (var i = 0; i < managedFolders.Count; ++i)
{
var folder = managedFolders[i];
using (new EditorGUILayout.HorizontalScope())
{
var label = string.IsNullOrEmpty(folder) ? folder : folder + "/";
GUILayout.Label(label, pathTextStyle, GUILayout.Height(contentHeight));
if (GUILayout.Button("-", EditorStyles.miniButton, GUILayout.Width(24f), GUILayout.Height(contentHeight)))
{
managedFolders.RemoveAt(i);
change = true;
}
}
}
scrollPosition = scrollViewScope.scrollPosition;
}
using (new EditorGUILayout.HorizontalScope())
{
GUILayout.FlexibleSpace();
if (GUILayout.Button("+", EditorStyles.miniButton, GUILayout.Width(40f)))
{
var folderPath = EditorUtility.OpenFolderPanel("Select Auto Addition Scene Folder", "Assets", "");
if (folderPath.Contains(Application.dataPath))
{
folderPath = folderPath.Replace(Application.dataPath, "Assets");
if (folderPath != "Assets" && !managedFolders.Contains(folderPath))
{
managedFolders.Add(folderPath);
change = true;
}
}
}
}
if (change)
{
Func <string, int> sortFunc = x =>
{
var path = PathUtility.ConvertPathSeparator(x);
var separatorCount = path.Split(PathUtility.PathSeparator).Length;
return(separatorCount);
};
var folders = managedFolders
.OrderBy(x => sortFunc.Invoke(x))
.ThenBy(x => x.Length)
.ToList();
Reflection.SetPrivateField(instance, "managedFolders", folders);
UnityEditorUtility.RegisterUndo("SceneImporterSettingsObject Undo", instance);
}
}
}
/// <summary> 除外対象のパスか検証 </summary>
public IgnoreType?GetIgnoreType(string assetPath)
{
var manageConfig = ManageConfig.Instance;
if (manageConfig == null)
{
return(null);
}
if (ignoreManagePaths == null)
{
ignoreManagePaths = manageConfig.IgnoreManage
.Select(x => AssetDatabase.GetAssetPath(x))
.OrderByDescending(x => x.Length)
.ToArray();
}
if (ignoreAssetBundlePaths == null)
{
ignoreAssetBundlePaths = manageConfig.IgnoreAssetBundle
.Select(x => AssetDatabase.GetAssetPath(x))
.OrderByDescending(x => x.Length)
.ToArray();
}
assetPath = PathUtility.ConvertPathSeparator(assetPath);
foreach (var item in ignoreManagePaths)
{
if (assetPath.StartsWith(item))
{
return(IgnoreType.IgnoreManage);
}
}
foreach (var item in ignoreAssetBundlePaths)
{
if (assetPath.StartsWith(item))
{
return(IgnoreType.IgnoreAssetBundle);
}
}
foreach (var item in manageConfig.IgnoreFolder)
{
if (assetPath.Split('/').Contains(item))
{
return(IgnoreType.IgnoreFolder);
}
}
foreach (var item in manageConfig.IgnoreExtension)
{
if (Path.GetExtension(assetPath) == item)
{
return(IgnoreType.IgnoreExtension);
}
}
return(null);
}
private static void OpenDirectory(string path)
{
path = PathUtility.ConvertPathSeparator(path);
EditorUtility.RevealInFinder(path);
}