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); }