void RestoreAndCleanup(AddressableAssetSettings settings)
{
//Delete our variant entries
foreach (string guid in variantEntriesToRemove)
{
settings.RemoveAssetEntry(guid, false);
}
variantEntriesToRemove.Clear();
//Delete all our variants.
List <string> failedPaths = new List <string>();
AssetDatabase.DeleteAssets(variantsPrefabsToDelete.ToArray(), failedPaths);
foreach (string path in failedPaths)
{
Debug.LogError("Failed to delete: " + path);
}
variantsPrefabsToDelete.Clear();
//Restore our original addressable entries
foreach (AssetEntry entry in entriesToRestore)
{
var restoredEntry = settings.CreateOrMoveEntry(entry.assetGUID, entry.group, false, false);
restoredEntry.address = entry.address;
foreach (string label in entry.labels)
{
restoredEntry.SetLabel(label, true, false, false);
}
}
entriesToRestore.Clear();
}
void RemoveEntry(string filePath)
{
string path = AssetDatabase.GUIDToAssetPath(AssetDatabase.FindAssets("t:AddressableAssetSettings").FirstOrDefault());
AddressableAssetSettings settings = AssetDatabase.LoadAssetAtPath <AddressableAssetSettings>(path);
string guid = AssetDatabase.AssetPathToGUID(filePath);
settings.RemoveAssetEntry(guid, true);
}
static void SetAaEntry(AddressableAssetSettings aaSettings, Object[] targets, bool create)
{
if (create && aaSettings.DefaultGroup.ReadOnly)
{
Debug.LogError("Current default group is ReadOnly. Cannot add addressable assets to it");
return;
}
Undo.RecordObject(aaSettings, "AddressableAssetSettings");
var targetInfos = new List <TargetInfo>();
foreach (var t in targets)
{
if (AddressableAssetUtility.GetPathAndGUIDFromTarget(t, out var path, out var guid, out var mainAssetType))
{
targetInfos.Add(new TargetInfo()
{
Guid = guid, Path = path, MainAssetType = mainAssetType
});
}
}
if (!create)
{
targetInfos.ForEach(ti =>
{
AddressableAssetGroup group = aaSettings.FindAssetEntry(ti.Guid).parentGroup;
aaSettings.RemoveAssetEntry(ti.Guid);
AddressableAssetUtility.OpenAssetIfUsingVCIntegration(group);
});
}
else
{
var resourceTargets = targetInfos.Where(ti => AddressableAssetUtility.IsInResources(ti.Path));
var resourcePaths = resourceTargets.Select(t => t.Path).ToList();
var resourceGuids = resourceTargets.Select(t => t.Guid).ToList();
AddressableAssetUtility.SafeMoveResourcesToGroup(aaSettings, aaSettings.DefaultGroup, resourcePaths, resourceGuids);
var entriesAdded = new List <AddressableAssetEntry>();
var modifiedGroups = new HashSet <AddressableAssetGroup>();
var otherTargetInfos = targetInfos.Except(resourceTargets);
foreach (var info in otherTargetInfos)
{
var e = aaSettings.CreateOrMoveEntry(info.Guid, aaSettings.DefaultGroup, false, false);
entriesAdded.Add(e);
modifiedGroups.Add(e.parentGroup);
}
foreach (var g in modifiedGroups)
{
g.SetDirty(AddressableAssetSettings.ModificationEvent.EntryMoved, entriesAdded, false, true);
AddressableAssetUtility.OpenAssetIfUsingVCIntegration(g);
}
aaSettings.SetDirty(AddressableAssetSettings.ModificationEvent.EntryMoved, entriesAdded, true, false);
}
}
/// <summary>
/// 处理移动
/// </summary>
/// <param name="assetPath"></param>
/// <param name="moveFromPath"></param>
private static void ProcessAssetGroup(string assetPath, string moveFromPath)
{
AssetImporter ai = AssetImporter.GetAtPath(assetPath);
if (ai == null)
{
Log.e("Not Find Asset:" + assetPath);
return;
}
string fullPath = EditorUtils.AssetsPath2ABSPath(assetPath);
if (Directory.Exists(fullPath))
{
return;
}
if (CheckIsRes4Addresable(assetPath))//如果移动到了另一个资源文件夹
{
ProcessAssetGroup(assetPath);
}
else
{
var guid = AssetDatabase.AssetPathToGUID(assetPath);
setting.RemoveAssetEntry(guid);
}
if (CheckIsRes4Addresable(moveFromPath))
{
//处理移动前的Group
string removeFromGroupName = string.Empty;
string dirName = Path.GetDirectoryName(moveFromPath);
string assetBundleName = EditorUtils.AssetPath2ReltivePath(dirName).ToLower();
assetBundleName = assetBundleName.Replace("addressableres/", "");
if (moveFromPath.Contains("FolderMode"))
{
removeFromGroupName = assetBundleName;
}
else
{
removeFromGroupName = setting.DefaultGroup.name;
}
removeFromGroupName = removeFromGroupName.Replace("/", "-");
//Debug.LogError("removeFromGroupName:" + removeFromGroupName);
var group = setting.FindGroup(removeFromGroupName);
if (group != null)
{
if (group.entries.Count == 0)
{
setting.RemoveGroup(group);
}
}
}
//EditorUtility.SetDirty(setting);
}
public void RemoveAssetEntry(string assetGuid, bool postEvent = true)
{
if (_settings.FindAssetEntry(assetGuid) == null)
{
throw new Exception(
$"Failed to get {nameof(AddressableAssetEntry)} (GUID:{assetGuid}) because it does not exists.");
}
_settings.RemoveAssetEntry(assetGuid, postEvent);
}
internal static void PurgeInvalidAssetEntries(AddressableAssetSettings settings)
{
if (settings == null)
{
return;
}
List <AddressableAssetEntry> entriesToRemove = new List <AddressableAssetEntry>();
foreach (var group in settings.groups)
{
if (group == null)
{
continue;
}
foreach (var assetEntry in group.entries)
{
if (assetEntry == null ||
assetEntry.address == AddressableAssetEntry.EditorSceneListName ||
assetEntry.address == AddressableAssetEntry.ResourcesName)
{
continue;
}
if (!string.IsNullOrEmpty(assetEntry.AssetPath))
{
string path = Path.GetFullPath(assetEntry.AssetPath);
if (!File.Exists(path) && !Directory.Exists(path))
{
entriesToRemove.Add(assetEntry);
}
}
else
{
entriesToRemove.Add(assetEntry);
}
}
}
StringBuilder builder = new StringBuilder(
"Addressables was unable to detect the following assets in the project " +
"but they were still part of an Addressable group. They have been removed " +
"from Addressables.");
foreach (var entry in entriesToRemove)
{
builder.AppendLine($"\n{entry.address} at {entry.AssetPath}");
settings.RemoveAssetEntry(entry, false);
}
if (entriesToRemove.Count > 0)
{
Addressables.Log(builder.ToString());
}
}
static void SetAaEntry(AddressableAssetSettings aaSettings, Object[] targets, bool create)
{
if (create && aaSettings.DefaultGroup.ReadOnly)
{
Debug.LogError("Current default group is ReadOnly. Cannot add addressable assets to it");
return;
}
Undo.RecordObject(aaSettings, "AddressableAssetSettings");
string path;
var guid = string.Empty;
//if (create || EditorUtility.DisplayDialog("Remove Addressable Asset Entries", "Do you want to remove Addressable Asset entries for " + targets.Length + " items?", "Yes", "Cancel"))
{
var entriesAdded = new List <AddressableAssetEntry>();
var modifiedGroups = new HashSet <AddressableAssetGroup>();
Type mainAssetType;
foreach (var t in targets)
{
if (AddressableAssetUtility.GetPathAndGUIDFromTarget(t, out path, ref guid, out mainAssetType))
{
if (create)
{
if (AddressableAssetUtility.IsInResources(path))
{
AddressableAssetUtility.SafeMoveResourcesToGroup(aaSettings, aaSettings.DefaultGroup, new List <string> {
path
});
}
else
{
var e = aaSettings.CreateOrMoveEntry(guid, aaSettings.DefaultGroup, false, false);
entriesAdded.Add(e);
modifiedGroups.Add(e.parentGroup);
}
}
else
{
aaSettings.RemoveAssetEntry(guid);
}
}
}
if (create)
{
foreach (var g in modifiedGroups)
{
g.SetDirty(AddressableAssetSettings.ModificationEvent.EntryMoved, entriesAdded, false, true);
}
aaSettings.SetDirty(AddressableAssetSettings.ModificationEvent.EntryMoved, entriesAdded, true, false);
}
}
}
static bool ApplyImportRule(
string assetPath,
string movedFromAssetPath,
AddressableAssetSettings settings,
AddressableImportSettings importSettings)
{
var dirty = false;
if (TryGetMatchedRule(assetPath, importSettings, out var matchedRule))
{
if (matchedRule.IgnoreDirectory &&
Directory.Exists(assetPath) &&
((File.GetAttributes(assetPath) & FileAttributes.Directory) == FileAttributes.Directory))
{
return(dirty);
}
// Apply the matched rule.
var entry = CreateOrUpdateAddressableAssetEntry(settings, importSettings, matchedRule, assetPath);
if (entry != null)
{
if (matchedRule.HasLabel)
{
Debug.LogFormat("[AddressableImporter] Entry created/updated for {0} with address {1} and labels {2}", assetPath, entry.address, string.Join(", ", entry.labels));
}
else
{
Debug.LogFormat("[AddressableImporter] Entry created/updated for {0} with address {1}", assetPath, entry.address);
}
}
dirty = true;
}
else
{
// If assetPath doesn't match any of the rules, try to remove the entry.
// But only if movedFromAssetPath has the matched rule, because the importer should not remove any unmanaged entries.
if (!string.IsNullOrEmpty(movedFromAssetPath) && TryGetMatchedRule(movedFromAssetPath, importSettings, out matchedRule))
{
var guid = AssetDatabase.AssetPathToGUID(assetPath);
if (settings.RemoveAssetEntry(guid))
{
dirty = true;
Debug.LogFormat("[AddressableImporter] Entry removed for {0}", assetPath);
}
}
}
return(dirty);
}
internal static void ClearAllAssets()
{
var totalCount = groupDic.Count;
var nowIndex = 0.0f;
foreach (var assetGroup in groupDic)
{
var g = assetGroup.Value;
EditorUtility.DisplayProgressBar("Addressable", $"Clear Group: {g.Name}", nowIndex / totalCount);
var guidList = (from e in g.entries select e.guid).ToList();
foreach (var guid in guidList)
{
addressableSettings.RemoveAssetEntry(guid);
}
++nowIndex;
}
EditorUtility.ClearProgressBar();
EditorUtility.DisplayDialog("Addressable", "Clear all assets", "Done");
}
/// <summary>
/// Updates the group the asset should belong to.
/// Assets will be stored in groups for the Locale they are used by unless they are used
/// by more than 1 <see cref="Locale"/>, then they will be moved to the shared group.
/// </summary>
/// <param name="settings"></param>
/// <param name="assetEntry"></param>
/// <param name="createUndo">Used to indicate if an Undo operation should be created.</param>
protected virtual void UpdateAssetGroup(AddressableAssetSettings settings, AddressableAssetEntry assetEntry, bool createUndo)
{
if (settings == null || assetEntry == null)
{
return;
}
// Find all the locales that are using the asset using the Addressable labels.
var localesUsingAsset = ListPool <LocaleIdentifier> .Get();
foreach (var label in assetEntry.labels)
{
if (AddressHelper.TryGetLocaleLabelToId(label, out var id))
{
localesUsingAsset.Add(id);
}
}
// If no Locales depend on this asset then we can just remove it
if (localesUsingAsset.Count == 0)
{
var oldGroup = assetEntry.parentGroup;
settings.RemoveAssetEntry(assetEntry.guid);
if (oldGroup.entries.Count == 0)
{
if (createUndo)
{
// We cant use undo asset deletion so we will leave an empty group instead of deleting it.
Undo.RecordObject(oldGroup, "Remove group");
}
else
{
settings.RemoveGroup(oldGroup);
}
}
ListPool <LocaleIdentifier> .Release(localesUsingAsset);
return;
}
AddressableGroupRules.AddAssetToGroup(assetEntry.MainAsset, localesUsingAsset, settings, createUndo);
}
static void CreateEntry(AddressableAssetSettings setting, AddressableAssetGroup group, string guid, string key, string label = null)
{
var entry = group.GetAssetEntry(guid);
if (entry == null)
{
entry = setting.CreateOrMoveEntry(guid, group);
entry.SetAddress(key);
if (label != null)
{
setting.AddLabel(label, true);
entry.SetLabel(label, true);
}
EditorUtility.SetDirty(setting);
}
else
{
string path = AssetDatabase.GUIDToAssetPath(guid);
if (string.IsNullOrEmpty(path))
{
setting.RemoveAssetEntry(guid);
}
else
{
if (key != entry.address)
{
entry.SetAddress(key);
if (label != null)
{
setting.AddLabel(label, true);
entry.SetLabel(label, true);
}
EditorUtility.SetDirty(setting);
}
}
}
}
public static void BuildAssetPack()
{
Init = true;
AddressableAssetSettings setting = AddressableAssetSettingsDefaultObject.Settings;
AddressableAssetGroup group = setting.FindGroup("AssetGroup");
List <AddressableAssetEntry> temp = group.entries.ToList();
foreach (var item in temp)
{
setting.RemoveAssetEntry(item.guid);
}
string[] p = AssetDatabase.GetAllAssetPaths();
for (int i = 0; i < p.Length; i++)
{
if (CanPack(p[i]))
{
setting.CreateOrMoveEntry(AssetDatabase.AssetPathToGUID(p[i]), group);
}
}
}
static void SetAaEntry(AddressableAssetSettings aaSettings, Object[] targets, bool create)
{
Undo.RecordObject(aaSettings, "AddressableAssetSettings");
string path;
var guid = string.Empty;
//if (create || EditorUtility.DisplayDialog("Remove Addressable Asset Entries", "Do you want to remove Addressable Asset entries for " + targets.Length + " items?", "Yes", "Cancel"))
{
var entriesAdded = new List <AddressableAssetEntry>();
foreach (var t in targets)
{
if (AddressableAssetUtility.GetPathAndGUIDFromTarget(t, out path, ref guid))
{
if (create)
{
if (AddressableAssetUtility.IsInResources(path))
{
AddressableAssetUtility.SafeMoveResourcesToGroup(aaSettings, aaSettings.DefaultGroup, new List <string> {
path
});
}
else
{
entriesAdded.Add(aaSettings.CreateOrMoveEntry(guid, aaSettings.DefaultGroup, false, false));
}
}
else
{
aaSettings.RemoveAssetEntry(guid);
}
}
}
if (create)
{
aaSettings.SetDirty(AddressableAssetSettings.ModificationEvent.EntryMoved, entriesAdded, true);
}
}
}
private static void RemoveAssetFromGroup(string assetGuid)
{
AddressableAssetSettings settings = GetSettings();
settings.RemoveAssetEntry(assetGuid);
}
/// <summary>
/// Updates the group the asset should belong to.
/// Assets will be stored in groups for the Locale they are used by unless they are used
/// by more than 1 <see cref="Locale"/>, then they will be moved to the shared group.
/// </summary>
/// <param name="settings"></param>
/// <param name="assetEntry"></param>
/// <param name="createUndo">Used to indicate if an Undo operation should be created.</param>
protected virtual void UpdateAssetGroup(AddressableAssetSettings settings, AddressableAssetEntry assetEntry, bool createUndo)
{
if (settings == null || assetEntry == null)
{
return;
}
// Find all the locales that are using the asset using the Addressable labels.
var localesUsingAsset = assetEntry.labels.Where(AddressHelper.IsLocaleLabel);
if (localesUsingAsset.Count() == 0)
{
var oldGroup = assetEntry.parentGroup;
settings.RemoveAssetEntry(assetEntry.guid);
if (oldGroup.entries.Count == 0)
{
if (createUndo)
{
// We cant use undo asset deletion so we will leave an empty group instead of deleting it.
Undo.RecordObject(oldGroup, "Remove group");
}
else
{
settings.RemoveGroup(oldGroup);
}
}
return;
}
AddressableAssetGroup newGroup;
if (localesUsingAsset.Count() == 1)
{
// If only 1 locale is using the asset then we will add it to a locale specific group.
var localeId = AddressHelper.LocaleLabelToId(localesUsingAsset.First());
newGroup = LocalizationEditorSettings.Instance.GetGroup(settings, FormatAssetTableCollectionName(localeId), true, createUndo);
}
else
{
// More than one locale uses the asset so it goes to the shared assets group.
newGroup = LocalizationEditorSettings.Instance.GetGroup(settings, LocalizationEditorSettings.SharedAssetGroupName, true, createUndo);
}
// Do we need to change the asset's group?
if (newGroup != assetEntry.parentGroup)
{
if (createUndo)
{
Undo.RecordObject(newGroup, "Update asset group");
Undo.RecordObject(assetEntry.parentGroup, "Update asset group");
}
var oldGroup = assetEntry.parentGroup;
settings.MoveEntry(assetEntry, newGroup, true);
if (oldGroup.entries.Count == 0)
{
// We only delete the asset when not creating an undo as we can not undo asset deletion.
if (!createUndo)
{
settings.RemoveGroup(oldGroup);
}
}
}
}
static void SetAaEntry(AddressableAssetSettings aaSettings, List <TargetInfo> targetInfos, bool create)
{
/*
* if (create && aaSettings.DefaultGroup.ReadOnly)
* {
* Debug.LogError("Current default group is ReadOnly. Cannot add addressable assets to it");
* return;
* }
*/
Undo.RecordObject(aaSettings, "AddressableAssetSettings");
if (!create)
{
List <AddressableAssetEntry> removedEntries = new List <AddressableAssetEntry>(targetInfos.Count);
for (int i = 0; i < targetInfos.Count; ++i)
{
AddressableAssetEntry e = aaSettings.FindAssetEntry(targetInfos[i].Guid);
AddressableAssetUtility.OpenAssetIfUsingVCIntegration(e.parentGroup);
removedEntries.Add(e);
aaSettings.RemoveAssetEntry(removedEntries[i], false);
}
if (removedEntries.Count > 0)
{
aaSettings.SetDirty(AddressableAssetSettings.ModificationEvent.EntryRemoved, removedEntries, true, false);
}
}
else
{
AddressableAssetGroup parentGroup = aaSettings.DefaultGroup;
var resourceTargets = targetInfos.Where(ti => AddressableAssetUtility.IsInResources(ti.Path));
if (resourceTargets.Any())
{
var resourcePaths = resourceTargets.Select(t => t.Path).ToList();
var resourceGuids = resourceTargets.Select(t => t.Guid).ToList();
AddressableAssetUtility.SafeMoveResourcesToGroup(aaSettings, parentGroup, resourcePaths, resourceGuids);
}
var entriesCreated = new List <AddressableAssetEntry>();
var entriesMoved = new List <AddressableAssetEntry>();
var otherTargetInfos = targetInfos.Except(resourceTargets);
foreach (var info in otherTargetInfos)
{
var hook = aaSettings.hook;
AddressableAssetGroup assetGroup = default;
string customAddress = default;
if (hook != null)
{
hook.BeforeSetEntryOnInspectorGUI(info.Path, out assetGroup, out customAddress);
}
if (assetGroup == null)
{
assetGroup = aaSettings.DefaultGroup;
}
string guid = info.Guid;
if (string.IsNullOrEmpty(guid))
{
continue;
}
AddressableAssetEntry e = aaSettings.FindAssetEntry(guid);
if (e != null) //move entry to where it should go...
{
aaSettings.MoveEntry(e, assetGroup, false, false);
}
else //create entry
{
e = aaSettings.CreateAndAddEntryToGroup_Custom(guid, assetGroup, false, false);
}
if (string.IsNullOrEmpty(customAddress) == false)
{
e.SetAddress(customAddress, false);
}
entriesCreated.Add(e);
entriesMoved.Add(e);
}
bool openedInVC = false;
if (entriesMoved.Count > 0)
{
AddressableAssetUtility.OpenAssetIfUsingVCIntegration(parentGroup);
openedInVC = true;
aaSettings.SetDirty(AddressableAssetSettings.ModificationEvent.EntryMoved, entriesMoved, true, false);
}
if (entriesCreated.Count > 0)
{
if (!openedInVC)
{
AddressableAssetUtility.OpenAssetIfUsingVCIntegration(parentGroup);
}
aaSettings.SetDirty(AddressableAssetSettings.ModificationEvent.EntryAdded, entriesCreated, true, false);
}
}
}
public override void FixIssues(AddressableAssetSettings settings)
{
// Load template used for creating new groups
var groupTemplates = settings.GroupTemplateObjects;
AddressableAssetGroupTemplate foundTemplate = null;
foreach (var template in groupTemplates)
{
if (template.name == templateToUse)
{
foundTemplate = template as AddressableAssetGroupTemplate;
break;
}
}
if (foundTemplate == null)
{
Debug.Log("Group template \"" + templateToUse + "\" not found. Aborting!");
return;
}
// Create groups
foreach (var groupName in groupsToCreate)
{
// I don't know enough about schemas, so schemasToCopy is set to null here.
AddressableAssetGroup newGroup = settings.CreateGroup(groupName, false, false, true, null, foundTemplate.GetTypes());
foundTemplate.ApplyToAddressableAssetGroup(newGroup);
}
// Remove groups
foreach (var groupName in groupsToRemove)
{
foreach (var group in settings.groups)
{
if (group.name == groupName)
{
settings.RemoveGroup(group);
break;
}
}
}
// Collect current group names
Dictionary <string, AddressableAssetGroup> groups = new Dictionary <string, AddressableAssetGroup>();
foreach (var group in settings.groups)
{
groups.Add(group.name, group);
}
// Create and remove assets
foreach (var action in assetActions)
{
if (!groups.ContainsKey(action.inGroup))
{
continue;
}
if (action.create)
{
AddressableAssetEntry entry = settings.CreateOrMoveEntry(action.assetGuid, groups[action.inGroup]);
entry.SetAddress(action.addressablePath);
}
else
{
AddressableAssetEntry entry = settings.FindAssetEntry(action.assetGuid);
if (entry != null)
{
settings.RemoveAssetEntry(action.assetGuid);
}
else
{
Debug.Log("Asset guid didn't produce an entry: " + action.assetGuid);
}
}
}
ClearAnalysis();
ClearOurData();
}
static void SetAaEntry(AddressableAssetSettings aaSettings, List <TargetInfo> targetInfos, bool create)
{
if (create && aaSettings.DefaultGroup.ReadOnly)
{
Debug.LogError("Current default group is ReadOnly. Cannot add addressable assets to it");
return;
}
Undo.RecordObject(aaSettings, "AddressableAssetSettings");
if (!create)
{
List <AddressableAssetEntry> removedEntries = new List <AddressableAssetEntry>(targetInfos.Count);
for (int i = 0; i < targetInfos.Count; ++i)
{
AddressableAssetEntry e = aaSettings.FindAssetEntry(targetInfos[i].Guid);
AddressableAssetUtility.OpenAssetIfUsingVCIntegration(e.parentGroup);
removedEntries.Add(e);
aaSettings.RemoveAssetEntry(removedEntries[i], false);
}
if (removedEntries.Count > 0)
{
aaSettings.SetDirty(AddressableAssetSettings.ModificationEvent.EntryRemoved, removedEntries, true, false);
}
}
else
{
AddressableAssetGroup parentGroup = aaSettings.DefaultGroup;
var resourceTargets = targetInfos.Where(ti => AddressableAssetUtility.IsInResources(ti.Path));
if (resourceTargets.Any())
{
var resourcePaths = resourceTargets.Select(t => t.Path).ToList();
var resourceGuids = resourceTargets.Select(t => t.Guid).ToList();
AddressableAssetUtility.SafeMoveResourcesToGroup(aaSettings, parentGroup, resourcePaths, resourceGuids);
}
var otherTargetInfos = targetInfos.Except(resourceTargets);
List <string> otherTargetGuids = new List <string>(targetInfos.Count);
foreach (var info in otherTargetInfos)
{
otherTargetGuids.Add(info.Guid);
}
var entriesCreated = new List <AddressableAssetEntry>();
var entriesMoved = new List <AddressableAssetEntry>();
aaSettings.CreateOrMoveEntries(otherTargetGuids, parentGroup, entriesCreated, entriesMoved, false, false);
bool openedInVC = false;
if (entriesMoved.Count > 0)
{
AddressableAssetUtility.OpenAssetIfUsingVCIntegration(parentGroup);
openedInVC = true;
aaSettings.SetDirty(AddressableAssetSettings.ModificationEvent.EntryMoved, entriesMoved, true, false);
}
if (entriesCreated.Count > 0)
{
if (!openedInVC)
{
AddressableAssetUtility.OpenAssetIfUsingVCIntegration(parentGroup);
}
aaSettings.SetDirty(AddressableAssetSettings.ModificationEvent.EntryAdded, entriesCreated, true, false);
}
}
}
static void SetAaEntry(AddressableAssetSettings aaSettings, Object[] targets, bool create)
{
/*
* if (create && aaSettings.DefaultGroup.ReadOnly)
* {
* Debug.LogError("Current default group is ReadOnly. Cannot add addressable assets to it");
* return;
* }
*/
Undo.RecordObject(aaSettings, "AddressableAssetSettings");
string path;
var guid = string.Empty;
//if (create || EditorUtility.DisplayDialog("Remove Addressable Asset Entries", "Do you want to remove Addressable Asset entries for " + targets.Length + " items?", "Yes", "Cancel"))
{
var entriesAdded = new List <AddressableAssetEntry>();
var modifiedGroups = new HashSet <AddressableAssetGroup>();
Type mainAssetType;
foreach (var t in targets)
{
if (AddressableAssetUtility.GetPathAndGUIDFromTarget(t, out path, ref guid, out mainAssetType))
{
if (create)
{
var ruleSet = aaSettings.assetRegisterRuleSet;
if (!ruleSet.TryResolveRule(path, out var rule))
{
rule = new AddressableAssetRegisterRuleSet.Rule {
AssetGroup = aaSettings.DefaultGroup
}
}
;
var assetGroup = rule.AssetGroup;
if (AddressableAssetUtility.IsInResources(path))
{
AddressableAssetUtility.SafeMoveResourcesToGroup(aaSettings, assetGroup, new List <string> {
path
});
}
else
{
var e = aaSettings.CreateOrMoveEntry(guid, assetGroup, false, false);
if (rule.SimplifyAddress)
{
e.SetAddress(System.IO.Path.GetFileNameWithoutExtension(e.address), false);
}
entriesAdded.Add(e);
modifiedGroups.Add(e.parentGroup);
}
}
else
{
aaSettings.RemoveAssetEntry(guid);
}
}
}
if (create)
{
foreach (var g in modifiedGroups)
{
g.SetDirty(AddressableAssetSettings.ModificationEvent.EntryMoved, entriesAdded, false, true);
}
aaSettings.SetDirty(AddressableAssetSettings.ModificationEvent.EntryMoved, entriesAdded, true, false);
}
}
}
