Liubing\LB
3d8d4d18f3
先修复一下，错误的场景 删除不必要的钓场资产 修复into场景 update:更新meta文件，修复报错 update:修复资源 修复第一章节建造 修复建造第三章 update:删除多余内容 update:更新README.md update:还原图标 update:更新README update:更新配置
732 lines
32 KiB
C#
732 lines
32 KiB
C#
using System;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using UnityEditor;
|
|
using UnityEditor.AddressableAssets;
|
|
using UnityEditor.AddressableAssets.Settings;
|
|
using UnityEngine;
|
|
using inspector.ext;
|
|
using UnityEditor.AddressableAssets.Settings.GroupSchemas;
|
|
using System.Collections.Generic;
|
|
using UnityEngine.AddressableAssets;
|
|
using System.Text.RegularExpressions;
|
|
|
|
namespace addressables.helper
|
|
{
|
|
[Serializable]
|
|
public class GroupDefine
|
|
{
|
|
public string name;
|
|
[inspector.ext.Folder]
|
|
public string folder;
|
|
public string folderPath => folder.ToFolderInfo().path;
|
|
public AddressableAssetGroupTemplate template;
|
|
public AssetLabelReference[] labels;
|
|
|
|
public void CopyToStreamingAssets()
|
|
{
|
|
var addrSettings = AddressableAssetSettingsDefaultObject.Settings;
|
|
var group = addrSettings.FindGroup(name);
|
|
var buildPath = group.Settings.RemoteCatalogBuildPath;
|
|
var schema = group.GetSchema<BundledAssetGroupSchema>();
|
|
if (schema != null)
|
|
{
|
|
if (schema.BundleMode == BundledAssetGroupSchema.BundlePackingMode.PackSeparately)
|
|
{
|
|
foreach (var entry in group.entries)
|
|
{
|
|
if (entry.labels.Any(x => x == "pack"))
|
|
{
|
|
if (Directory.Exists(buildPath.GetValue(addrSettings)) == false)
|
|
{
|
|
Debug.LogError($"{group.name} {entry.address} {buildPath.GetValue(addrSettings)}");
|
|
continue;
|
|
}
|
|
string bundleName = Path.GetFileName(entry.BundleFileId);
|
|
if (string.IsNullOrEmpty(bundleName))
|
|
{
|
|
Debug.LogError($"{group.name} {entry.address}");
|
|
continue;
|
|
}
|
|
var bunldes = Directory.GetFiles(buildPath.GetValue(addrSettings), bundleName);
|
|
|
|
if (bunldes.Length != 1)
|
|
{
|
|
Debug.LogError($"{group.name} {entry.address} {bunldes.Length} {bundleName}");
|
|
continue;
|
|
}
|
|
|
|
//copy bundle
|
|
var dest = Path.Combine(Application.streamingAssetsPath, Path.GetFileName(bunldes[0]));
|
|
File.Copy(bunldes[0], dest, true);
|
|
}
|
|
}
|
|
}
|
|
else if (schema.BundleMode == BundledAssetGroupSchema.BundlePackingMode.PackTogether)
|
|
{
|
|
foreach (var entry in group.entries)
|
|
{
|
|
if (entry.labels.Any(x => x == "pack"))
|
|
{
|
|
if (Directory.Exists(buildPath.GetValue(addrSettings)) == false)
|
|
{
|
|
Debug.LogError($"{group.name} {entry.address} {buildPath.GetValue(addrSettings)}");
|
|
continue;
|
|
}
|
|
string bundleName = Path.GetFileName(entry.BundleFileId);
|
|
if (string.IsNullOrEmpty(bundleName))
|
|
{
|
|
Debug.LogError($"{group.name} {entry.address}");
|
|
continue;
|
|
}
|
|
var bunldes = Directory.GetFiles(buildPath.GetValue(addrSettings), bundleName);
|
|
|
|
if (bunldes.Length != 1)
|
|
{
|
|
Debug.LogError($"{group.name} {entry.address} {bunldes.Length} {bundleName}");
|
|
continue;
|
|
}
|
|
|
|
//copy bundle
|
|
var dest = Path.Combine(Application.streamingAssetsPath, Path.GetFileName(bunldes[0]));
|
|
File.Copy(bunldes[0], dest, true);
|
|
return;
|
|
}
|
|
}
|
|
|
|
}
|
|
else if (schema.BundleMode == BundledAssetGroupSchema.BundlePackingMode.PackTogetherByLabel)
|
|
{
|
|
List<string> names = new List<string>();
|
|
foreach (var entry in group.entries)
|
|
{
|
|
if (entry.labels.Any(x => x == "pack"))
|
|
{
|
|
if (Directory.Exists(buildPath.GetValue(addrSettings)) == false)
|
|
{
|
|
Debug.LogError($"{group.name} {entry.address} {buildPath.GetValue(addrSettings)}");
|
|
continue;
|
|
}
|
|
string bundleName = Path.GetFileName(entry.BundleFileId);
|
|
if (string.IsNullOrEmpty(bundleName))
|
|
{
|
|
Debug.LogError($"{group.name} {entry.address}");
|
|
continue;
|
|
}
|
|
if (names.Contains(bundleName))
|
|
{
|
|
continue;
|
|
}
|
|
var bunldes = Directory.GetFiles(buildPath.GetValue(addrSettings), bundleName);
|
|
|
|
if (bunldes.Length != 1)
|
|
{
|
|
Debug.LogError($"{group.name} {entry.address} {bunldes.Length} {bundleName}");
|
|
continue;
|
|
}
|
|
names.Add(bundleName);
|
|
//copy bundle
|
|
var dest = Path.Combine(Application.streamingAssetsPath, Path.GetFileName(bunldes[0]));
|
|
File.Copy(bunldes[0], dest, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
public class GroupFolderDefine
|
|
{
|
|
public string name;
|
|
[inspector.ext.Folder]
|
|
public string folder;
|
|
public string folderPath => folder.ToFolderInfo().path;
|
|
public AddressableAssetGroupTemplate template;
|
|
public AssetLabelReference[] labels;
|
|
}
|
|
|
|
public class AddressableHelperSetting : ScriptableObject
|
|
{
|
|
public string[] MamualGroupNames;
|
|
public string[] MamualGroupNamePrefixs;
|
|
public GroupDefine[] GroupDefines;
|
|
public GroupFolderDefine[] GroupFolderDefines;
|
|
}
|
|
|
|
public class AddressableHelper
|
|
{
|
|
private const string helperSettingPath = "Assets/Settings/AddressableHelperSetting.asset";
|
|
public static bool IsSettingExists() => File.Exists(helperSettingPath);
|
|
|
|
[MenuItem("Window/Asset Management/Helper/Create Setting", true)]
|
|
static bool ValidateCreateSetting() => !IsSettingExists();
|
|
|
|
[MenuItem("Window/Asset Management/Helper/Create Setting")]
|
|
static void CreateSetting()
|
|
{
|
|
var instance = ScriptableObject.CreateInstance<AddressableHelperSetting>();
|
|
AssetDatabase.CreateAsset(instance, helperSettingPath);
|
|
}
|
|
|
|
//[MenuItem("Window/Asset Management/Helper/Sync Groups", true)]
|
|
//static bool ValidateSyncGroups() => IsSettingExists();
|
|
|
|
//[MenuItem("Window/Asset Management/Helper/Sync Groups &#F")]
|
|
public static void SyncGroups()
|
|
{
|
|
var helperSetting = AssetDatabase.LoadAssetAtPath<AddressableHelperSetting>(helperSettingPath);
|
|
var defines = helperSetting.GroupDefines;
|
|
var addrSettings = AddressableAssetSettingsDefaultObject.Settings;
|
|
|
|
var manualGroupNames = helperSetting.MamualGroupNames;
|
|
var MamualGroupNamePrefixs = helperSetting.MamualGroupNamePrefixs;
|
|
// Debug.Log($"[AddressableHelper] {addrSettings.groups.Select(x => x.Name)}");
|
|
var dbt = addrSettings.groups;
|
|
foreach (var x in dbt)
|
|
{
|
|
Debug.Log(x);
|
|
}
|
|
|
|
// Debug.Log($"[AddressableHelper] {addrSettings.groups.Select(x => x.Name).ToList()}");
|
|
var existsGroupNames = addrSettings.groups.Select(x => x.Name).ToList();
|
|
var newGroupNames = helperSetting.GroupDefines.Select(x => x.name)
|
|
.Concat(helperSetting.GroupFolderDefines.Select(x => x.name))
|
|
.ToList();
|
|
|
|
var allGroupNames = manualGroupNames.Concat(newGroupNames).ToList();
|
|
|
|
for(int i = 0; i < MamualGroupNamePrefixs.Length;i++)
|
|
{
|
|
var prefix = MamualGroupNamePrefixs[i];
|
|
if (string.IsNullOrEmpty(prefix))
|
|
continue;
|
|
var manualGroups = existsGroupNames.Where(x => x.StartsWith(prefix)).ToList();
|
|
if (manualGroups.Count > 0)
|
|
{
|
|
Debug.Log($"[AddressableHelper] add manual group {prefix}");
|
|
allGroupNames.AddRange(manualGroups);
|
|
}
|
|
}
|
|
|
|
// remove groups not defined in helper setting
|
|
for (int i = existsGroupNames.Count - 1; i >= 0; i--)
|
|
{
|
|
|
|
var group = existsGroupNames[i];
|
|
|
|
if (!allGroupNames.Contains(group))
|
|
{
|
|
Debug.Log($"[AddressableHelper] remove group {group}");
|
|
addrSettings.RemoveGroup(addrSettings.FindGroup(group));
|
|
existsGroupNames.RemoveAt(i);
|
|
}
|
|
}
|
|
|
|
foreach (var groupDefine in defines)
|
|
{
|
|
var groupName = groupDefine.name;
|
|
var group = addrSettings.FindGroup(groupName);
|
|
|
|
if (null == group)
|
|
{
|
|
Debug.Log($"[AddressableHelper] create group {groupDefine.name}");
|
|
group = CreateGroup(groupDefine, addrSettings);
|
|
groupDefine.template.ApplyToAddressableAssetGroup(group);
|
|
}
|
|
else
|
|
{
|
|
var entries = group.entries.ToList();
|
|
Debug.Log($"[AddressableHelper] clean group {groupDefine.name} {entries.Count}");
|
|
foreach (var entry in entries)
|
|
{
|
|
group.RemoveAssetEntry(entry);
|
|
}
|
|
}
|
|
Debug.Log($"[AddressableHelper] sync group {groupDefine.name}");
|
|
SyncEntries(groupDefine, group, addrSettings);
|
|
|
|
EditorUtility.SetDirty(group);
|
|
}
|
|
|
|
var folderDefines = helperSetting.GroupFolderDefines;
|
|
foreach (var folderDefine in folderDefines)
|
|
{
|
|
var groupName = folderDefine.name;
|
|
var group = addrSettings.FindGroup(groupName);
|
|
|
|
if (null == group)
|
|
{
|
|
Debug.Log($"[AddressableHelper] create group {folderDefine.name}");
|
|
group = CreateGroupByFolder(groupName, folderDefine, addrSettings);
|
|
folderDefine.template.ApplyToAddressableAssetGroup(group);
|
|
}
|
|
else
|
|
{
|
|
var entries = group.entries.ToList();
|
|
Debug.Log($"[AddressableHelper] clean group {folderDefine.name} {entries.Count}");
|
|
foreach (var entry in entries)
|
|
{
|
|
group.RemoveAssetEntry(entry);
|
|
}
|
|
}
|
|
|
|
Debug.Log($"[AddressableHelper] sync group {folderDefine.name}");
|
|
SyncEntriesByFolder(folderDefine, group, addrSettings);
|
|
EditorUtility.SetDirty(group);
|
|
}
|
|
|
|
EditorUtility.SetDirty(addrSettings);
|
|
AssetDatabase.SaveAssets();
|
|
}
|
|
|
|
private static AddressableAssetGroup CreateGroupByFolder(string groupName, GroupFolderDefine groupDefine, AddressableAssetSettings addrSettings)
|
|
{
|
|
var template = groupDefine.template;
|
|
var group = addrSettings.CreateGroup(groupName, false, false, true, null, template.GetTypes());
|
|
return group;
|
|
}
|
|
|
|
private static void SyncEntriesByFolder(GroupFolderDefine groupDefine, AddressableAssetGroup group, AddressableAssetSettings addrSettings)
|
|
{
|
|
var folder = new string[] { groupDefine.folderPath };
|
|
|
|
//获取文件夹下的所有文件夹
|
|
var assetsGUIDs = AssetDatabase.FindAssets("", folder);
|
|
var assetPaths = assetsGUIDs.Select(_ => AssetDatabase.GUIDToAssetPath(_)).ToArray();
|
|
var count = assetsGUIDs.Length;
|
|
Regex regexA = new Regex(groupDefine.folderPath + "/(.*?)/");
|
|
Regex regexB = new Regex(".*?/([^/]+)$");
|
|
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
var guid = assetsGUIDs[i];
|
|
var entry = group.GetAssetEntry(guid);
|
|
string address = Path.GetFileNameWithoutExtension(assetPaths[i]);
|
|
string folderName = Path.GetFileName(assetPaths[i]);
|
|
if (folderName.Contains("."))
|
|
{
|
|
if (entry == null || entry.address != address)
|
|
{
|
|
entry = addrSettings.CreateOrMoveEntry(guid, group);
|
|
entry.address = address;
|
|
//获取文件所在一级目录
|
|
string directoryPath = assetPaths[i];
|
|
//int startIndex = 1 + directoryPath.IndexOf(groupDefine.folderPath) + groupDefine.folderPath.Length;
|
|
//int endIndex = directoryPath.IndexOf("/", startIndex);
|
|
//directoryPath = directoryPath.Substring(startIndex, endIndex - startIndex);
|
|
|
|
//directoryPath = assetPaths[i];
|
|
Match match = regexA.Match(directoryPath);
|
|
if (match.Groups.Count > 1)
|
|
{
|
|
directoryPath = match.Groups[1].Value;
|
|
}
|
|
else
|
|
{
|
|
match = regexB.Match(groupDefine.folderPath);
|
|
directoryPath = match.Groups[1].Value;
|
|
}
|
|
|
|
entry.SetLabel(directoryPath, true, true);
|
|
for (int j = 0; j < groupDefine.labels.Length; j++)
|
|
{
|
|
if (!string.IsNullOrEmpty(groupDefine.labels[j].labelString))
|
|
{
|
|
entry.SetLabel(groupDefine.labels[j].labelString, true);
|
|
}
|
|
}
|
|
EditorUtility.SetDirty(group);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void SyncEntries(GroupDefine groupDefine, AddressableAssetGroup group, AddressableAssetSettings addrSettings)
|
|
{
|
|
var folder = new string[] { groupDefine.folderPath };
|
|
var assetsGUIDs = AssetDatabase.FindAssets("", folder);
|
|
var assetPaths = assetsGUIDs.Select(_ => AssetDatabase.GUIDToAssetPath(_)).ToArray();
|
|
var count = assetsGUIDs.Length;
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
if (Directory.Exists(assetPaths[i]))
|
|
continue;
|
|
var guid = assetsGUIDs[i];
|
|
var entry = group.GetAssetEntry(guid);
|
|
string address = Path.GetFileNameWithoutExtension(assetPaths[i]);
|
|
|
|
if (entry == null || entry.address != address)
|
|
{
|
|
entry = addrSettings.CreateOrMoveEntry(guid, group);
|
|
entry.address = address;
|
|
for (int j = 0; j < groupDefine.labels.Length; j++)
|
|
{
|
|
if (!string.IsNullOrEmpty(groupDefine.labels[j].labelString))
|
|
{
|
|
entry.SetLabel(groupDefine.labels[j].labelString, true);
|
|
}
|
|
}
|
|
EditorUtility.SetDirty(group);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static AddressableAssetGroup CreateGroup(GroupDefine groupDefine, AddressableAssetSettings addrSettings)
|
|
{
|
|
var template = groupDefine.template;
|
|
var group = addrSettings.CreateGroup(groupDefine.name, false, false, true, null, template.GetTypes());
|
|
return group;
|
|
}
|
|
|
|
|
|
[MenuItem("Window/Asset Management/Helper/Clean StreamingAssets")]
|
|
public static void CleanStreamingAssets()
|
|
{
|
|
// delete all file with ext .bundle in StreamingAssets fold
|
|
string streamingAssetsPath = Application.streamingAssetsPath;
|
|
string[] bundleFiles = Directory.GetFiles(streamingAssetsPath, "*.bundle");
|
|
string[] bundleMetaFiles = Directory.GetFiles(streamingAssetsPath, "*.bundle.meta");
|
|
|
|
foreach (string bundleFile in bundleFiles)
|
|
{
|
|
File.Delete(bundleFile);
|
|
}
|
|
|
|
foreach (string metaFile in bundleMetaFiles)
|
|
{
|
|
File.Delete(metaFile);
|
|
}
|
|
AssetDatabase.Refresh();
|
|
}
|
|
|
|
[MenuItem("Window/Asset Management/Helper/Copy To StreamingAssets")]
|
|
public static void CopyToStreamingAssets()
|
|
{
|
|
//load helper setting
|
|
//var helperSetting = AssetDatabase.LoadAssetAtPath<AddressableHelperSetting>(helperSettingPath);
|
|
//foreach (var groupDefine in helperSetting.GroupDefines)
|
|
//{
|
|
// groupDefine.CopyToStreamingAssets();
|
|
//}
|
|
AddressableAssetSettings addrSettings = AddressableAssetSettingsDefaultObject.Settings;
|
|
var groups = addrSettings.groups;
|
|
foreach (var group in groups)
|
|
{
|
|
if (group.Settings.BuildRemoteCatalog)
|
|
{
|
|
CopyToStreamingAssets(group, addrSettings);
|
|
}
|
|
}
|
|
AssetDatabase.Refresh();
|
|
}
|
|
|
|
private static void CopyToStreamingAssets(AddressableAssetGroup group, AddressableAssetSettings addrSettings)
|
|
{
|
|
var buildPath = group.Settings.RemoteCatalogBuildPath;
|
|
var schema = group.GetSchema<BundledAssetGroupSchema>();
|
|
if (schema != null)
|
|
{
|
|
if (schema.BundleMode == BundledAssetGroupSchema.BundlePackingMode.PackSeparately)
|
|
{
|
|
foreach (var entry in group.entries)
|
|
{
|
|
if (entry.labels.Any(x => x == "pack"))
|
|
{
|
|
if (Directory.Exists(buildPath.GetValue(addrSettings)) == false)
|
|
{
|
|
Debug.LogError($"{group.name} {entry.address} {buildPath.GetValue(addrSettings)}");
|
|
continue;
|
|
}
|
|
string bundleName = Path.GetFileName(entry.BundleFileId);
|
|
if (string.IsNullOrEmpty(bundleName))
|
|
{
|
|
Debug.LogError($"{group.name} {entry.address}");
|
|
continue;
|
|
}
|
|
var bunldes = Directory.GetFiles(buildPath.GetValue(addrSettings), bundleName);
|
|
|
|
if (bunldes.Length != 1)
|
|
{
|
|
Debug.LogError($"{group.name} {entry.address} {bunldes.Length} {bundleName}");
|
|
continue;
|
|
}
|
|
|
|
//copy bundle
|
|
var dest = Path.Combine(Application.streamingAssetsPath, Path.GetFileName(bunldes[0]));
|
|
File.Copy(bunldes[0], dest, true);
|
|
}
|
|
}
|
|
}
|
|
else if (schema.BundleMode == BundledAssetGroupSchema.BundlePackingMode.PackTogether)
|
|
{
|
|
foreach (var entry in group.entries)
|
|
{
|
|
if (entry.labels.Any(x => x == "pack"))
|
|
{
|
|
if (Directory.Exists(buildPath.GetValue(addrSettings)) == false)
|
|
{
|
|
Debug.LogError($"{group.name} {entry.address} {buildPath.GetValue(addrSettings)}");
|
|
continue;
|
|
}
|
|
string bundleName = Path.GetFileName(entry.BundleFileId);
|
|
if (string.IsNullOrEmpty(bundleName))
|
|
{
|
|
Debug.LogError($"{group.name} {entry.address}");
|
|
continue;
|
|
}
|
|
var bunldes = Directory.GetFiles(buildPath.GetValue(addrSettings), bundleName);
|
|
|
|
if (bunldes.Length != 1)
|
|
{
|
|
Debug.LogError($"{group.name} {entry.address} {bunldes.Length} {bundleName}");
|
|
continue;
|
|
}
|
|
|
|
//copy bundle
|
|
var dest = Path.Combine(Application.streamingAssetsPath, Path.GetFileName(bunldes[0]));
|
|
File.Copy(bunldes[0], dest, true);
|
|
return;
|
|
}
|
|
}
|
|
|
|
}
|
|
else if (schema.BundleMode == BundledAssetGroupSchema.BundlePackingMode.PackTogetherByLabel)
|
|
{
|
|
List<string> names = new List<string>();
|
|
foreach (var entry in group.entries)
|
|
{
|
|
if (entry.labels.Any(x => x == "pack"))
|
|
{
|
|
if (Directory.Exists(buildPath.GetValue(addrSettings)) == false)
|
|
{
|
|
Debug.LogError($"{group.name} {entry.address} {buildPath.GetValue(addrSettings)}");
|
|
continue;
|
|
}
|
|
string bundleName = Path.GetFileName(entry.BundleFileId);
|
|
if (string.IsNullOrEmpty(bundleName))
|
|
{
|
|
Debug.LogError($"{group.name} {entry.address}");
|
|
continue;
|
|
}
|
|
if (names.Contains(bundleName))
|
|
{
|
|
continue;
|
|
}
|
|
var bunldes = Directory.GetFiles(buildPath.GetValue(addrSettings), bundleName);
|
|
|
|
if (bunldes.Length != 1)
|
|
{
|
|
Debug.LogError($"{group.name} {entry.address} {bunldes.Length} {bundleName}");
|
|
continue;
|
|
}
|
|
names.Add(bundleName);
|
|
//copy bundle
|
|
var dest = Path.Combine(Application.streamingAssetsPath, Path.GetFileName(bunldes[0]));
|
|
File.Copy(bunldes[0], dest, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static HashSet<string> GetPackFileNames()
|
|
{
|
|
var names = new HashSet<string>();
|
|
AddressableAssetSettings addrSettings = AddressableAssetSettingsDefaultObject.Settings;
|
|
var groups = addrSettings.groups;
|
|
foreach (var group in groups)
|
|
{
|
|
if (group.Settings.BuildRemoteCatalog)
|
|
{
|
|
GetPackFileNames(group, addrSettings, names);
|
|
}
|
|
}
|
|
return names;
|
|
}
|
|
|
|
private static void GetPackFileNames(AddressableAssetGroup group, AddressableAssetSettings addrSettings, HashSet<string> names)
|
|
{
|
|
var buildPath = group.Settings.RemoteCatalogBuildPath;
|
|
var schema = group.GetSchema<BundledAssetGroupSchema>();
|
|
if (schema != null)
|
|
{
|
|
if (schema.BundleMode == BundledAssetGroupSchema.BundlePackingMode.PackSeparately)
|
|
{
|
|
foreach (var entry in group.entries)
|
|
{
|
|
if (entry.labels.Any(x => x == "pack"))
|
|
{
|
|
if (Directory.Exists(buildPath.GetValue(addrSettings)) == false)
|
|
{
|
|
Debug.LogError($"{group.name} {entry.address} {buildPath.GetValue(addrSettings)}");
|
|
continue;
|
|
}
|
|
string bundleName = Path.GetFileName(entry.BundleFileId);
|
|
names.Add(bundleName);
|
|
}
|
|
}
|
|
}
|
|
else if (schema.BundleMode == BundledAssetGroupSchema.BundlePackingMode.PackTogether)
|
|
{
|
|
foreach (var entry in group.entries)
|
|
{
|
|
if (entry.labels.Any(x => x == "pack"))
|
|
{
|
|
if (Directory.Exists(buildPath.GetValue(addrSettings)) == false)
|
|
{
|
|
Debug.LogError($"{group.name} {entry.address} {buildPath.GetValue(addrSettings)}");
|
|
continue;
|
|
}
|
|
string bundleName = Path.GetFileName(entry.BundleFileId);
|
|
names.Add(bundleName);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if (schema.BundleMode == BundledAssetGroupSchema.BundlePackingMode.PackTogetherByLabel)
|
|
{
|
|
foreach (var entry in group.entries)
|
|
{
|
|
if (entry.labels.Any(x => x == "pack"))
|
|
{
|
|
if (Directory.Exists(buildPath.GetValue(addrSettings)) == false)
|
|
{
|
|
Debug.LogError($"{group.name} {entry.address} {buildPath.GetValue(addrSettings)}");
|
|
continue;
|
|
}
|
|
string bundleName = Path.GetFileName(entry.BundleFileId);
|
|
if (names.Contains(bundleName))
|
|
{
|
|
continue;
|
|
}
|
|
names.Add(bundleName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[MenuItem("Window/Asset Management/Helper/Copy All To StreamingAssets")]
|
|
public static void CopyALLToStreamingAssets()
|
|
{
|
|
var addrSettings = AddressableAssetSettingsDefaultObject.Settings;
|
|
var bundle_dir = addrSettings.RemoteCatalogBuildPath.GetValue(addrSettings);
|
|
var bunldes = Directory.GetFiles(bundle_dir, $"*.bundle");
|
|
foreach (var bunlde in bunldes)
|
|
{
|
|
File.Copy(bunlde, bunlde.Replace(bundle_dir, Application.streamingAssetsPath), true);
|
|
}
|
|
AssetDatabase.Refresh();
|
|
}
|
|
|
|
public static string ExportAssetsFile()
|
|
{
|
|
var addrSettings = AddressableAssetSettingsDefaultObject.Settings;
|
|
var bundle_dir = addrSettings.RemoteCatalogBuildPath.GetValue(addrSettings);
|
|
if(!string.IsNullOrEmpty(bundle_dir) && !Directory.Exists(bundle_dir))
|
|
Directory.CreateDirectory(bundle_dir);
|
|
var allFileNames = new HashSet<string>(Directory.GetFiles(bundle_dir, $"*.bundle").Select(p => Path.GetFileName(p)));
|
|
var packFileNanes = GetPackFileNames();
|
|
var downloadFileNames = allFileNames.Except(packFileNanes);
|
|
var bundles = new Dictionary<string, List<string>>();
|
|
bundles["pack"] = packFileNanes.ToList();
|
|
bundles["download"] = downloadFileNames.ToList();
|
|
return Newtonsoft.Json.JsonConvert.SerializeObject(bundles, Newtonsoft.Json.Formatting.Indented);
|
|
}
|
|
|
|
//public static void SyncGroups()
|
|
//{
|
|
//var helperSetting = AssetDatabase.LoadAssetAtPath<AddressableHelperSetting>(helperSettingPath);
|
|
//var defines = helperSetting.GroupDefines;
|
|
//var addrSettings = AddressableAssetSettingsDefaultObject.Settings;
|
|
|
|
//foreach (var groupDefine in defines)
|
|
//{
|
|
//var groupName = groupDefine.name;
|
|
//var group = addrSettings.FindGroup(groupName);
|
|
|
|
//if (null == group)
|
|
//{
|
|
//group = CreateGroup(groupDefine, addrSettings);
|
|
//}
|
|
//groupDefine.template.ApplyToAddressableAssetGroup(group);
|
|
//SyncEntries(groupDefine, group, addrSettings);
|
|
//EditorUtility.SetDirty(addrSettings);
|
|
//AssetDatabase.SaveAssets();
|
|
//}
|
|
|
|
//var folderDefines = helperSetting.GroupFolderDefines;
|
|
//foreach (var folderDefine in folderDefines)
|
|
//{
|
|
//var groupName = folderDefine.name;
|
|
//var group = addrSettings.FindGroup(groupName);
|
|
|
|
//if (null == group)
|
|
//{
|
|
//group = CreateGroupByFolder(groupName, folderDefine, addrSettings);
|
|
//}
|
|
//folderDefine.template.ApplyToAddressableAssetGroup(group);
|
|
//SyncEntriesByFolder(folderDefine, group, addrSettings);
|
|
//EditorUtility.SetDirty(addrSettings);
|
|
//AssetDatabase.SaveAssets();
|
|
//}
|
|
//}
|
|
|
|
//[MenuItem("Window/Asset Management/Helper/Sync Groups PreloadOrPack", true)]
|
|
//static bool ValidateSyncGroupsPRLabel() => IsSettingExists();
|
|
|
|
//[MenuItem("Window/Asset Management/Helper/Sync Groups PreloadOrPack")]
|
|
//public static void SyncGroupsPRLabel()
|
|
//{
|
|
//var helperSetting = AssetDatabase.LoadAssetAtPath<AddressableHelperSetting>(helperSettingPath);
|
|
//var defines = helperSetting.GroupDefines;
|
|
//var addrSettings = AddressableAssetSettingsDefaultObject.Settings;
|
|
|
|
//foreach (var groupDefine in defines)
|
|
//{
|
|
//var groupName = groupDefine.name;
|
|
//var group = addrSettings.FindGroup(groupName);
|
|
|
|
//if (null != group)
|
|
//{
|
|
//foreach (var item in groupDefine.labels)
|
|
//{
|
|
//group.entries.ToList().ForEach(x => x.SetLabel(item.labelString, true, true));
|
|
//}
|
|
//}
|
|
//}
|
|
//EditorUtility.SetDirty(addrSettings);
|
|
//AssetDatabase.SaveAssets();
|
|
//}
|
|
|
|
//[MenuItem("Window/Asset Management/Helper/Sync Groups RewardLabel", true)]
|
|
//static bool ValidateSyncGroupsRewardLabel() => IsSettingExists();
|
|
|
|
//[MenuItem("Window/Asset Management/Helper/Sync Groups RewardLabel")]
|
|
//public static void SyncGroupsRewardLabel()
|
|
//{
|
|
//var helperSetting = AssetDatabase.LoadAssetAtPath<AddressableHelperSetting>(helperSettingPath);
|
|
//var defines = helperSetting.GroupDefines;
|
|
//var addrSettings = AddressableAssetSettingsDefaultObject.Settings;
|
|
|
|
//foreach (var groupDefine in defines)
|
|
//{
|
|
//var groupName = groupDefine.name;
|
|
//var group = addrSettings.FindGroup(groupName);
|
|
|
|
//if (null != group)
|
|
//{
|
|
//foreach (var item in groupDefine.rewardLabels)
|
|
//{
|
|
//group.entries.ToList().ForEach(x => x.SetLabel(item.labelString, false, true));
|
|
//}
|
|
//}
|
|
//}
|
|
//EditorUtility.SetDirty(addrSettings);
|
|
//AssetDatabase.SaveAssets();
|
|
//}
|
|
|
|
}
|
|
}
|