internal override void Setup(AddressableAssetSettings settings, string tempAssetFolder)
{
AddressableAssetGroup regGroup = settings.CreateGroup("localNoUWRGroup", false, false, true,
new List <AddressableAssetGroupSchema>(), typeof(BundledAssetGroupSchema));
regGroup.GetSchema <BundledAssetGroupSchema>().BundleNaming = BundledAssetGroupSchema.BundleNamingStyle.OnlyHash;
AddressableAssetGroup forceUWRGroup = settings.CreateGroup("ForceUWRGroup", false, false, true,
new List <AddressableAssetGroupSchema>(), typeof(BundledAssetGroupSchema));
forceUWRGroup.GetSchema <BundledAssetGroupSchema>().UseUnityWebRequestForLocalBundles = true;
forceUWRGroup.GetSchema <BundledAssetGroupSchema>().BundleMode = BundledAssetGroupSchema.BundlePackingMode.PackSeparately;
forceUWRGroup.GetSchema <BundledAssetGroupSchema>().BundleNaming = BundledAssetGroupSchema.BundleNamingStyle.OnlyHash;
settings.MaxConcurrentWebRequests = kMaxConcurrentRequests;
for (int i = 0; i < kForceUWRBundleCount; i++)
{
string s = GetForceUWRAddrName(i);
string guid = CreatePrefab(tempAssetFolder + $"/{s}.prefab");
AddressableAssetEntry entry = settings.CreateOrMoveEntry(guid, forceUWRGroup);
entry.address = s;
}
{
string guid = CreatePrefab(tempAssetFolder + $"/testprefab.prefab");
AddressableAssetEntry entry = settings.CreateOrMoveEntry(guid, regGroup);
entry.address = "testprefab";
}
}
internal override void Setup(AddressableAssetSettings settings, string tempAssetFolder)
{
GameObject testObject = new GameObject("TestObject");
GameObject testObject2 = new GameObject("TestObject2");
string path = tempAssetFolder + "/test.prefab";
string path2 = tempAssetFolder + "/test2.prefab";
PrefabUtility.SaveAsPrefabAsset(testObject, path);
PrefabUtility.SaveAsPrefabAsset(testObject2, path2);
string guid = AssetDatabase.AssetPathToGUID(path);
string guid2 = AssetDatabase.AssetPathToGUID(path2);
AddressableAssetEntry entry = settings.CreateOrMoveEntry(guid, settings.DefaultGroup);
entry.address = k_ValidKey;
entry = settings.CreateOrMoveEntry(guid2, settings.DefaultGroup);
entry.address = k_InvalidKey;
bool currentIgnoreState = LogAssert.ignoreFailingMessages;
LogAssert.ignoreFailingMessages = false;
LogAssert.Expect(LogType.Error, $"Address '{entry.address}' cannot contain '[ ]'.");
LogAssert.ignoreFailingMessages = currentIgnoreState;
}
internal override void Setup(AddressableAssetSettings settings, string tempAssetFolder)
{
AddressableAssetGroup group = settings.CreateGroup("SceneGroup", true, false, false, null, typeof(BundledAssetGroupSchema));
group.GetSchema <BundledAssetGroupSchema>().BundleNaming = BundledAssetGroupSchema.BundleNamingStyle.OnlyHash;
// Create prefab
string prefabPath = CreateAssetPath(tempAssetFolder, prefabKey, ".prefab");
string prefabGuid = CreatePrefab(prefabPath);
AddressableAssetEntry prefabEntry = settings.CreateOrMoveEntry(prefabGuid, group, false, false);
prefabEntry.address = Path.GetFileNameWithoutExtension(prefabEntry.AssetPath);
// Create scenes
for (int i = 0; i < numScenes; i++)
{
string scenePath = CreateAssetPath(tempAssetFolder, sceneKeys[i], ".unity");
string sceneGuid = CreateScene(scenePath);
AddressableAssetEntry sceneEntry = settings.CreateOrMoveEntry(sceneGuid, group, false, false);
sceneEntry.address = Path.GetFileNameWithoutExtension(sceneEntry.AssetPath);
}
{
string scenePath = CreateAssetPath(tempAssetFolder, kEmbeddedSceneName, ".unity");
var scene = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Additive);
new GameObject("EmbededMeshGameObject").AddComponent <MeshFilter>().mesh = new Mesh();
EditorSceneManager.SaveScene(scene, scenePath);
string sceneGuid = AssetDatabase.AssetPathToGUID(scene.path);
AddressableAssetEntry sceneEntry = settings.CreateOrMoveEntry(sceneGuid, group, false, false);
sceneEntry.address = Path.GetFileNameWithoutExtension(sceneEntry.AssetPath);
}
}
string MakeAddressable(AddressableAssetGroup group, string guid, string address = null)
{
var entry = m_Settings.CreateOrMoveEntry(guid, group, false, false);
entry.address = address == null?Path.GetFileNameWithoutExtension(entry.AssetPath) : address;
return(guid);
}
private static void CreateBuiltInData(AddressableAssetSettings aa)
{
var playerData = aa.CreateGroup(PlayerDataGroupName, false, true, false, null, typeof(ContentUpdateGroupSchema), typeof(BundledAssetGroupSchema), typeof(PlayerDataGroupSchema));
var resourceEntry = aa.CreateOrMoveEntry(ResourcesName, playerData);
resourceEntry.IsInResources = true;
resourceEntry.SetLabel("default", true);
var sceneEntry = aa.CreateOrMoveEntry(EditorSceneListName, playerData);
sceneEntry.SetLabel("default", true);
}
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();
}
public override void FixIssues(AddressableAssetSettings settings)
{
if (m_implicitAssets == null)
{
CheckForDuplicateDependencies(settings);
}
if (m_implicitAssets.Count == 0)
{
return;
}
var group = AddressablesUtility.GetOrCreateGroup(BuildScenesPreprocessor.ScenesDependenciesAddressablesGroupName);
group.GetSchema <ContentUpdateGroupSchema>().StaticContent = true;
foreach (var asset in m_implicitAssets)
{
var guidString = asset.ToString();
var entry = settings.CreateOrMoveEntry(guidString, group, false, false);
entry.address = $"{Path.GetFileNameWithoutExtension(AssetDatabase.GUIDToAssetPath(guidString))}_{guidString}";
}
settings.SetDirty(AddressableAssetSettings.ModificationEvent.BatchModification, null, true, true);
}
/// <summary>
/// Fix duplicates by moving them to new groups.
/// </summary>
/// <param name="settings">The current Addressables settings object</param>
/// <remarks>Duplicates referenced by the same groups will be moved to the same new group.</remarks>
public override void FixIssues(AddressableAssetSettings settings)
{
if (CheckDupeResults == null)
{
CheckForDuplicateDependencies(settings);
}
Dictionary <GUID, List <AddressableAssetGroup> > implicitAssetsToGroup = GetImplicitAssetsToGroup(CheckDupeResults);
var groupsToAssets = new Dictionary <List <AddressableAssetGroup>, List <GUID> >(new GroupComparator());
foreach (KeyValuePair <GUID, List <AddressableAssetGroup> > pair in implicitAssetsToGroup)
{
if (!groupsToAssets.TryGetValue(pair.Value, out List <GUID> assets))
{
assets = new List <GUID>();
groupsToAssets.Add(pair.Value, assets);
}
groupsToAssets[pair.Value].Add(pair.Key);
}
foreach (KeyValuePair <List <AddressableAssetGroup>, List <GUID> > pair in groupsToAssets)
{
var group = settings.CreateGroup("Duplicate Asset Isolation", false, false, false, null, typeof(BundledAssetGroupSchema), typeof(ContentUpdateGroupSchema));
group.GetSchema <ContentUpdateGroupSchema>().StaticContent = true;
foreach (GUID asset in pair.Value)
{
settings.CreateOrMoveEntry(asset.ToString(), group, false, false);
}
}
settings.SetDirty(AddressableAssetSettings.ModificationEvent.BatchModification, null, true, true);
}
internal override void Setup(AddressableAssetSettings settings, string rootFolder)
{
var group = settings.CreateGroup("Legacy", true, false, false, null, typeof(PlayerDataGroupSchema));
var schema = group.GetSchema <PlayerDataGroupSchema>();
schema.IncludeResourcesFolders = true;
schema.IncludeBuildSettingsScenes = false;
var resourceEntry = settings.CreateOrMoveEntry(AddressableAssetEntry.ResourcesName, group);
resourceEntry.IsInResources = true;
string resourceDirectory = Path.Combine(rootFolder, "Resources");
Directory.CreateDirectory(resourceDirectory + "/subfolder");
var spritePath = Path.Combine(resourceDirectory, kSpriteResourceName + ".png");
CreateSpriteOnPath(spritePath);
string spriteGuid = AssetDatabase.AssetPathToGUID(spritePath);
SessionState.SetString("spriteGuid", spriteGuid);
CreateScriptableObjectOnPath(Path.Combine(resourceDirectory, kObjectResourceName + ".asset"));
var atlasPath = Path.Combine(resourceDirectory, kSpriteAtlasResourceName + ".spriteatlas");
CreateSpriteAtlas(atlasPath, new string[] { spritePath });
}
static List <AddressableAssetEntry> SetEntries(AddressableAssetSettings aaSettings, Object[] targets)
{
if (aaSettings.DefaultGroup.ReadOnly)
{
Debug.LogError("Current default group is ReadOnly. Cannot add addressable assets to it");
return(null);
}
Undo.RecordObject(aaSettings, "AddressableAssetSettings");
string path;
var guid = string.Empty;
var entriesAdded = new List <AddressableAssetEntry>();
var result = new List <AddressableAssetEntry>();
var modifiedGroups = new HashSet <AddressableAssetGroup>();
AddressableAssetGroup modified = new AddressableAssetGroup();
Type mainAssetType;
foreach (var o in targets)
{
if (AddressableAssetUtility.GetPathAndGUIDFromTarget(o, out path, ref guid, out mainAssetType))
{
var entry = aaSettings.FindAssetEntry(guid);
if (entry == null)
{
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
{
result.Add(entry);
}
}
}
foreach (var g in modifiedGroups)
{
g.SetDirty(AddressableAssetSettings.ModificationEvent.EntryMoved, entriesAdded, false, true);
}
aaSettings.SetDirty(AddressableAssetSettings.ModificationEvent.EntryMoved, entriesAdded, true, false);
result.AddRange(entriesAdded);
return(result);
}
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);
}
}
static AddressableAssetEntry CreateOrUpdateAddressableAssetEntry(
AddressableAssetSettings settings,
AddressableImportSettings importSettings,
AddressableImportRule rule,
string assetPath)
{
// Set group
AddressableAssetGroup group;
var groupName = rule.ParseGroupReplacement(assetPath);
bool newGroup = false;
if (!TryGetGroup(settings, groupName, out group))
{
if (importSettings.allowGroupCreation)
{
//TODO Specify on editor which type to create.
group = CreateAssetGroup <BundledAssetGroupSchema>(settings, groupName);
newGroup = true;
}
else
{
Debug.LogErrorFormat("[AddressableImporter] Failed to find group {0} when importing {1}. Please check if the group exists, then reimport the asset.", rule.groupName, assetPath);
return(null);
}
}
// Set group settings from template if necessary
if (rule.groupTemplate != null && (newGroup || rule.groupTemplateApplicationMode == GroupTemplateApplicationMode.AlwaysOverwriteGroupSettings))
{
rule.groupTemplate.ApplyToAddressableAssetGroup(group);
}
var guid = AssetDatabase.AssetPathToGUID(assetPath);
var entry = settings.CreateOrMoveEntry(guid, group);
if (entry != null)
{
// Apply address replacement if address is empty or path.
if (string.IsNullOrEmpty(entry.address) ||
entry.address.StartsWith("Assets/") ||
rule.simplified ||
!string.IsNullOrWhiteSpace(rule.addressReplacement))
{
entry.address = rule.ParseAddressReplacement(assetPath);
}
// Add labels
if (rule.LabelMode == LabelWriteMode.Replace)
{
entry.labels.Clear();
}
foreach (var label in rule.labels)
{
entry.labels.Add(label);
}
}
return(entry);
}
static void CreateFolderEntryAssets(string RootFolder, AddressableAssetSettings settings, AddressableAssetGroup group)
{
AssetDatabase.CreateFolder(RootFolder, "folderEntry");
string folderPath = RootFolder + "/folderEntry";
{
var texture = new Texture2D(32, 32);
var data = ImageConversion.EncodeToPNG(texture);
UnityEngine.Object.DestroyImmediate(texture);
AssetDatabase.GenerateUniqueAssetPath(RootFolder);
var spritePath = folderPath + "/spritesheet.png";
File.WriteAllBytes(spritePath, data);
AssetDatabase.ImportAsset(spritePath, ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate);
var spriteGuid = AssetDatabase.AssetPathToGUID(spritePath);
var importer = (TextureImporter)AssetImporter.GetAtPath(spritePath);
importer.textureType = TextureImporterType.Sprite;
importer.spriteImportMode = SpriteImportMode.Multiple;
importer.spritesheet = new SpriteMetaData[] { new SpriteMetaData()
{
name = "topleft", pivot = Vector2.zero, rect = new Rect(0, 0, 16, 16)
},
new SpriteMetaData()
{
name = "botright", pivot = Vector2.zero, rect = new Rect(16, 16, 16, 16)
} };
importer.SaveAndReimport();
}
{
var texture = new Texture2D(32, 32);
var data = ImageConversion.EncodeToPNG(texture);
UnityEngine.Object.DestroyImmediate(texture);
var spritePath = folderPath + "/sprite.png";
File.WriteAllBytes(spritePath, data);
AssetDatabase.ImportAsset(spritePath, ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate);
var spriteGuid = AssetDatabase.AssetPathToGUID(spritePath);
var importer = (TextureImporter)AssetImporter.GetAtPath(spritePath);
importer.textureType = TextureImporterType.Sprite;
importer.SaveAndReimport();
string atlasPath = folderPath + "/atlas.spriteatlas";
var sa = new SpriteAtlas();
AssetDatabase.CreateAsset(sa, atlasPath);
sa.Add(new UnityEngine.Object[]
{
AssetDatabase.LoadAssetAtPath <UnityEngine.Object>(AssetDatabase.GUIDToAssetPath(spriteGuid))
});
SpriteAtlasUtility.PackAtlases(new SpriteAtlas[] { sa }, EditorUserBuildSettings.activeBuildTarget, false);
}
var folderEntry = settings.CreateOrMoveEntry(AssetDatabase.AssetPathToGUID(folderPath), group, false, false);
folderEntry.address = "folderEntry";
}
internal static void CreateOrMoveAsset(MyAsset config)
{
var assetGroup = TryGetAssetGroup(config.groupName);
if (assetGroup == null)
{
Debug.LogError($"不存在名为 {config.groupName} 的资源组");
return;
}
var patternArray = config.pattern;
var search = config.searchChild ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly;
var filePaths = new List <string>(5);
if (!Directory.Exists(config.folderPath))
{
Debug.LogError($"路径不存在: {config.folderPath}");
return;
}
foreach (var pattern in patternArray)
{
filePaths.AddRange(Directory.GetFiles(config.folderPath, $"*.{pattern}", search));
}
AddLabelToSetting(config.groupName);
foreach (var path in filePaths)
{
var filePath = path.Replace("\\", "/");
if (!File.Exists(filePath))
{
Debug.LogError($"文件不存在: {filePath}");
continue;
}
filePath = filePath.Replace("./", "");
var guid = AssetDatabase.AssetPathToGUID(filePath);
var entry = addressableSettings.CreateOrMoveEntry(guid, assetGroup);
if (entry == null)
{
continue;
}
entry.address = $"{Path.GetFileNameWithoutExtension(filePath)}";
AddLabelToSetting(Path.GetFileNameWithoutExtension(filePath));
var labelArray = new string[] { Path.GetFileNameWithoutExtension(filePath), config.groupName };
foreach (var label in labelArray)
{
if (!entry.SetLabel(label, true))
{
entry.SetLabel(label, true, true);
}
}
}
}
internal override void Setup(AddressableAssetSettings settings, string tempAssetFolder)
{
AddressableAssetGroup syncGroup = settings.CreateGroup("SyncAddressables", false, false, true,
new List <AddressableAssetGroupSchema>(), typeof(BundledAssetGroupSchema));
syncGroup.GetSchema <BundledAssetGroupSchema>().BundleNaming = BundledAssetGroupSchema.BundleNamingStyle.OnlyHash;
//Create prefab
string guid = CreatePrefab(tempAssetFolder + "/synctest.prefab");
AddressableAssetEntry entry = settings.CreateOrMoveEntry(guid, syncGroup);
entry.address = m_PrefabKey;
//Create Scenes
string sceneGuid = CreateScene($"{tempAssetFolder}/SyncTestScene.unity");
AddressableAssetEntry sceneEntry = settings.CreateOrMoveEntry(sceneGuid, syncGroup);
sceneEntry.address = m_SceneKey;
}
private static void ProcessAssetGroup(string assetPath)
{
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;
}
string groupName = string.Empty;
string dirName = Path.GetDirectoryName(assetPath);
string assetBundleName = EditorUtils.AssetPath2ReltivePath(dirName).ToLower();
assetBundleName = assetBundleName.Replace("addressableres/", "");
if (assetPath.Contains("FolderMode"))
{
groupName = assetBundleName;
}
else
{
groupName = setting.DefaultGroup.name;
}
groupName = groupName.Replace("/", "-");
var group = setting.FindGroup(groupName);
if (group == null)
{
//Debug.LogError("ProcessAssetGroup:" + groupName);
group = setting.CreateGroup(groupName, false, false, false, new List <AddressableAssetGroupSchema> {
setting.DefaultGroup.Schemas[0]
}, typeof(SchemaType));
}
if (group == null)
{
return;
}
var guid = AssetDatabase.AssetPathToGUID(assetPath);
var entry = setting.CreateOrMoveEntry(guid, group);
entry.SetAddress(PathHelper.FileNameWithoutSuffix(Path.GetFileName(assetPath)), true);
//EditorUtility.SetDirty(setting);
}
internal override void Setup(AddressableAssetSettings settings, string tempAssetFolder)
{
var group = settings.CreateGroup("TestGroup", true, false, false, null, typeof(BundledAssetGroupSchema));
// Create prefab
var prefabGuid = CreatePrefab(Path.Combine(tempAssetFolder, String.Concat(prefabKey, ".prefab")));
var prefabEntry = settings.CreateOrMoveEntry(prefabGuid, group, false, false);
prefabEntry.address = Path.GetFileNameWithoutExtension(prefabEntry.AssetPath);
// Create scenes
for (int i = 0; i < numScenes; i++)
{
var scene = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Additive);
EditorSceneManager.SaveScene(scene, Path.Combine(tempAssetFolder, String.Concat(sceneKeys[i], ".unity")));
var guid = AssetDatabase.AssetPathToGUID(scene.path);
var entry = settings.CreateOrMoveEntry(guid, group, false, false);
entry.address = Path.GetFileNameWithoutExtension(entry.AssetPath);
}
}
static void SetObjectAddressable(Object go, string guid)
{
AddressableAssetSettings aaSettings = AddressableAssetSettingsDefaultObject.Settings;
AddressableAssetGroup group = aaSettings.DefaultGroup;
AddressableAssetEntry entry = aaSettings.FindAssetEntry(guid);
if (entry == null)
{
entry = aaSettings.CreateOrMoveEntry(guid, group, readOnly: false, postEvent: false);
}
}
static void Add()
{
AddressableAssetSettings setting = AssetDatabase.LoadAssetAtPath <AddressableAssetSettings>("Assets/AddressableAssetsData/AddressableAssetSettings.asset");
foreach (GameObject o in Selection.gameObjects)
{
AddressableAssetEntry entry = setting.CreateOrMoveEntry(AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(o)), setting.DefaultGroup);
string[] s = AssetDatabase.GetAssetPath(o).Split('/');
entry.SetAddress(s[s.Length - 1]);
}
}
AddressableAssetEntry CreateEntry(string filePath, string groupName, string labelName)
{
string path = AssetDatabase.GUIDToAssetPath(AssetDatabase.FindAssets("t:AddressableAssetSettings").FirstOrDefault());
AddressableAssetSettings settings = AssetDatabase.LoadAssetAtPath <AddressableAssetSettings>(path);
AddressableAssetGroup target = settings.groups.Find(c => c.name == groupName);
string guid = AssetDatabase.AssetPathToGUID(filePath);
AddressableAssetEntry entry = settings.CreateOrMoveEntry(guid, target, false, true);
entry.SetAddress(filePath, true);
entry.SetLabel(labelName, true, true);
return(entry);
}
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);
}
}
}
internal override void Setup(AddressableAssetSettings settings, string tempAssetFolder)
{
AddressableAssetGroup group = settings.CreateGroup("SceneGroup", true, false, false, null, typeof(BundledAssetGroupSchema));
group.GetSchema <BundledAssetGroupSchema>().BundleNaming = BundledAssetGroupSchema.BundleNamingStyle.OnlyHash;
// Create prefab
string prefabPath = CreateAssetPath(tempAssetFolder, prefabKey, ".prefab");
string prefabGuid = CreatePrefab(prefabPath);
AddressableAssetEntry prefabEntry = settings.CreateOrMoveEntry(prefabGuid, group, false, false);
prefabEntry.address = Path.GetFileNameWithoutExtension(prefabEntry.AssetPath);
// Create scenes
for (int i = 0; i < numScenes; i++)
{
string scenePath = CreateAssetPath(tempAssetFolder, sceneKeys[i], ".unity");
string sceneGuid = CreateScene(scenePath);
AddressableAssetEntry sceneEntry = settings.CreateOrMoveEntry(sceneGuid, group, false, false);
sceneEntry.address = Path.GetFileNameWithoutExtension(sceneEntry.AssetPath);
}
}
internal override void Setup(AddressableAssetSettings settings, string tempAssetFolder)
{
var group = settings.CreateGroup("TestStuff", true, false, false, null, typeof(BundledAssetGroupSchema));
Directory.CreateDirectory(tempAssetFolder);
var texturePath = Path.Combine(tempAssetFolder, string.Concat(GetBuildScriptTypeFromMode(BuildScriptMode), textureName, ".png"));
CreateTextureOnPath(texturePath);
var texEntry = settings.CreateOrMoveEntry(AssetDatabase.AssetPathToGUID(texturePath), group, false, false);
texEntry.address = textureName;
texEntry.SetLabel(allowedLabels[0], true, false);
}
internal override void Setup(AddressableAssetSettings settings, string tempAssetFolder)
{
var group = settings.CreateGroup("TestStuff", true, false, false, null, typeof(BundledAssetGroupSchema));
string resourceDirectory = Path.Combine(tempAssetFolder, "Resources");
Directory.CreateDirectory(resourceDirectory);
var spritePath = Path.Combine(resourceDirectory, string.Concat(GetBuildScriptTypeFromMode(BuildScriptMode), spriteName, ".png"));
CreateSpriteOnPath(spritePath);
var spriteEntry = settings.CreateOrMoveEntry(AssetDatabase.AssetPathToGUID(spritePath), group, false, false);
spriteEntry.address = spriteName;
}
public static AssetReference SetObjectAddressable(Object go)
{
string guid = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(go));
AddressableAssetSettings aaSettings = AddressableAssetSettingsDefaultObject.Settings;
AddressableAssetGroup group = aaSettings.DefaultGroup;
AddressableAssetEntry entry = aaSettings.FindAssetEntry(guid);
if (entry == null)
{
entry = aaSettings.CreateOrMoveEntry(guid, group, readOnly: false, postEvent: false);
}
return(new AssetReference(guid));
}
static void CreateOrUpdateAddressableAssetEntry(AddressableAssetGroup group, string subPath, string fileName)
{
string filePath = subPath + "/" + fileName;
string guid = AssetDatabase.AssetPathToGUID(filePath);
AddressableAssetEntry entry = settings.CreateOrMoveEntry(guid, group);
if (entry != null)
{
entry.address = fileName;
entry.SetLabel(group.Name, true, true);
}
}
internal static void MoveAssetsFromResources(Dictionary <string, string> guidToNewPath, AddressableAssetGroup targetParent, AddressableAssetSettings settings)
{
if (guidToNewPath == null)
{
return;
}
var entries = new List <AddressableAssetEntry>();
AssetDatabase.StartAssetEditing();
foreach (var item in guidToNewPath)
{
var dirInfo = new FileInfo(item.Value).Directory;
if (dirInfo != null && !dirInfo.Exists)
{
dirInfo.Create();
AssetDatabase.StopAssetEditing();
AssetDatabase.Refresh();
AssetDatabase.StartAssetEditing();
}
var oldPath = AssetDatabase.GUIDToAssetPath(item.Key);
var errorStr = AssetDatabase.MoveAsset(oldPath, item.Value);
if (!string.IsNullOrEmpty(errorStr))
{
DebugUtility.LogError(LoggerTags.Engine, "Error moving asset:{0} ", errorStr);
}
else
{
AddressableAssetEntry e = settings.FindAssetEntry(item.Key);
if (e != null)
{
e.IsInResources = false;
}
var newEntry = settings.CreateOrMoveEntry(item.Key, targetParent, false, false);
var index = oldPath.ToLower().LastIndexOf("resources/");
if (index >= 0)
{
var newAddress = Path.GetFileNameWithoutExtension(oldPath.Substring(index + 10));
if (!string.IsNullOrEmpty(newAddress))
{
newEntry.address = newAddress;
}
}
entries.Add(newEntry);
}
}
AssetDatabase.StopAssetEditing();
AssetDatabase.Refresh();
settings.SetDirty(AddressableAssetSettings.ModificationEvent.EntryMoved, entries, true, true);
}
/// <summary>
/// 将assetpath路径的内容放入assetgroup中
/// </summary>
/// <param name="setting"></param>
/// <param name="group"></param>
/// <param name="assetPaths"></param>
/// <param name="label"></param>
public static void SetGroupAddress(AddressableAssetSettings setting, AddressableAssetGroup group, List <string> assetPaths, string label = null)
{
foreach (var str in assetPaths)
{
var guid = AssetDatabase.AssetPathToGUID(str); //获得GUID
var entry = setting.CreateOrMoveEntry(guid, group); //通过GUID创建entry
entry.SetAddress(System.IO.Path.GetFileNameWithoutExtension(str));
if (!string.IsNullOrEmpty(label))
{
entry.SetLabel(label, true);
}
}
}
private void CreateAddressable(string objGuid)
{
AddressableAssetSettings assetSettings = UnityEditor.AddressableAssets.AddressableAssetSettingsDefaultObject.Settings;
AddressableAssetGroup addressableAssetGroup = assetSettings.groups[groupIndex];
if (!addressableAssetGroup.entries.Any(p => p.guid == objGuid))
{
AddressableAssetEntry addressableAssetEntry = assetSettings.CreateOrMoveEntry(objGuid, addressableAssetGroup);
foreach (string label in labels.Where(p => p.Value).Select(q => q.Key))
{
addressableAssetEntry.labels.Add(label);
}
}
}
public override void FixIssues(AddressableAssetSettings settings)
{
// If we have no duplicate data, run the check again
if (duplicateAssetsAndParents == null || duplicateAssetsAndParents.Count == 0)
{
CheckForDuplicateDependencies(settings);
}
// If we have found no duplicates, return
if (duplicateAssetsAndParents.Count == 0)
{
return;
}
// Setup Addressables Group to store all our duplicate assets
string desiredGroupName = "Duplicate Assets Sorted By Label";
AddressableAssetGroup group = settings.FindGroup(desiredGroupName);
if (group == null)
{
group = settings.CreateGroup(desiredGroupName, false, false, false, null, typeof(BundledAssetGroupSchema), typeof(ContentUpdateGroupSchema));
var bundleSchema = group.GetSchema <BundledAssetGroupSchema>();
// Set to pack by label so that assets with the same label are put in the same AssetBundle
bundleSchema.BundleMode = BundledAssetGroupSchema.BundlePackingMode.PackTogetherByLabel;
}
EditorUtility.DisplayProgressBar("Setting up De-Duplication Group...", "", 0f / duplicateAssetsAndParents.Count);
// Iterate through each duplicate asset
int bundleNumber = 1;
foreach (var entry in duplicateAssetsAndParents)
{
EditorUtility.DisplayProgressBar("Setting up De-Duplication Group...", "Creating Label Group", ((float)bundleNumber) / duplicateAssetsAndParents.Count);
string desiredLabelName = "Bundle" + bundleNumber;
List <AddressableAssetEntry> entriesToAdd = new List <AddressableAssetEntry>();
// Put each asset in the shared Group
foreach (string assetPath in entry.Value)
{
entriesToAdd.Add(settings.CreateOrMoveEntry(AssetDatabase.AssetPathToGUID(assetPath).ToString(), group, false, false));
}
// Set the label for this selection of assets so they get packed into the same AssetBundle
settings.AddLabel(desiredLabelName);
SetLabelValueForEntries(settings, entriesToAdd, desiredLabelName, true);
bundleNumber++;
}
settings.SetDirty(AddressableAssetSettings.ModificationEvent.BatchModification, null, true, true);
}
