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";
}
}
private static AddressableAssetGroup CreateGroup(string groupName)
{
//アドレサブルアセットセッティング取得
AddressableAssetSettings assetSettings = GetSettings();
BundledAssetGroupSchema assetGroupSchema = CreateInstance <BundledAssetGroupSchema>();
if (groupName.IndexOf(REMOTE_GROUP, StringComparison.OrdinalIgnoreCase) >= 0)
{
assetGroupSchema.BuildPath.SetVariableByName(assetSettings, AddressableAssetSettings.kRemoteBuildPath);
assetGroupSchema.LoadPath.SetVariableByName(assetSettings, AddressableAssetSettings.kRemoteLoadPath);
}
//スキーマ生成
List <AddressableAssetGroupSchema> schema = new List <AddressableAssetGroupSchema>()
{
CreateInstance <ContentUpdateGroupSchema>(),
assetGroupSchema,
};
//グループの作成
AddressableAssetGroup assetGroup = assetSettings.groups.Find((g) => g.name == groupName);
return(assetGroup == null
? assetSettings.CreateGroup(groupName, false, false, true, schema)
: assetGroup);
}
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);
}
}
/// <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 AddressableAssetGroup CreateAssetGroup <TSchemaType>(AddressableAssetSettings setting, string groupName)
{
AddressableAssetGroup assetGroup = setting.CreateGroup(groupName, false, false, false, new List <AddressableAssetGroupSchema>
{
setting.DefaultGroup.Schemas[0],
setting.DefaultGroup.Schemas[1]
}, typeof(TSchemaType));
return(assetGroup);
}
public void Setup()
{
m_Manager = new HostingServicesManager();
m_Settings = AddressableAssetSettings.Create(k_TestConfigFolder, k_TestConfigName, false, false);
m_Settings.HostingServicesManager = m_Manager;
var group = m_Settings.CreateGroup("testGroup", false, false, false, null);
group.AddSchema <BundledAssetGroupSchema>();
m_Settings.groups.Add(group);
}
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);
}
/// <summary>
/// Create a new AddressableAssetGroup with the items and mark it as remote.
/// </summary>
/// <param name="settings">The settings object.</param>
/// <param name="items">The items to move.</param>
/// <param name="groupName">The name of the new group.</param>
public static void CreateContentUpdateGroup(AddressableAssetSettings settings, List <AddressableAssetEntry> items, string groupName)
{
var contentGroup = settings.CreateGroup(settings.FindUniqueGroupName(groupName), false, false, true, null);
var schema = contentGroup.AddSchema <BundledAssetGroupSchema>();
schema.BuildPath.SetVariableByName(settings, AddressableAssetSettings.kRemoteBuildPath);
schema.LoadPath.SetVariableByName(settings, AddressableAssetSettings.kRemoteLoadPath);
schema.BundleMode = BundledAssetGroupSchema.BundlePackingMode.PackTogether;
contentGroup.AddSchema <ContentUpdateGroupSchema>().StaticContent = false;
settings.MoveEntries(items, contentGroup);
}
protected virtual AddressableAssetGroup GetGroup(AddressableAssetSettings settings, string groupName, bool create = false)
{
var group = settings.FindGroup(groupName);
if (group == null && create)
{
group = settings.CreateGroup(groupName, false, false, true, null, typeof(BundledAssetGroupSchema));
}
return(group);
}
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);
}
/// <summary>
///创建分组
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="groupName"></param>
/// <returns></returns>
public static AddressableAssetGroup FindOrCreateGroup(string groupName)
{
AddressableAssetSettings Settings = AddressableAssetSettingsDefaultObject.Settings;
AddressableAssetGroup group = Settings.FindGroup(groupName);
if (group == null)
{
group = Settings.CreateGroup(groupName, false, false, false, null);
}
//Settings.AddLabel(groupName, false);
return(group);
}
private static void GenerateWithGroupRule(AddressableAssetSettings settings, GenerateSetting generateSetting, GroupRule groupRule)
{
AddressableAssetGroup oldGroup = settings.FindGroup(groupRule.GroupName);
AddressableAssetGroup group;
if (generateSetting.RecreateGroup)
{
if (oldGroup)
{
settings.RemoveGroup(oldGroup);
oldGroup = null;
}
group = settings.CreateGroup(groupRule.GroupName, false, false, true, groupRule.SchemasToCopy);
}
else
{
if (oldGroup)
{
group = oldGroup;
}
else
{
group = settings.CreateGroup(groupRule.GroupName, false, false, true, groupRule.SchemasToCopy);
}
}
if (generateSetting.ApplyAssetRule)
{
for (int iAssetRule = 0; iAssetRule < groupRule.AssetRules.Length; iAssetRule++)
{
AssetRule iterAssetRule = groupRule.AssetRules[iAssetRule];
GenerateWithAssetRule(settings, generateSetting, group, groupRule, iterAssetRule);
}
}
if (generateSetting.RemoveInvalidAsset)
{
RemoveInvalidAsset(group);
}
}
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);
}
AddressableAssetGroup CreateGroup(string groupName)
{
string guid = AssetDatabase.FindAssets("t:AddressableAssetSettings").FirstOrDefault();
string path = AssetDatabase.GUIDToAssetPath(guid);
AddressableAssetSettings settings = AssetDatabase.LoadAssetAtPath <AddressableAssetSettings>(path);
BundledAssetGroupSchema bundledAssetGroupSchema = ScriptableObject.CreateInstance <BundledAssetGroupSchema>();
ContentUpdateGroupSchema contentUpdateGroupSchema = ScriptableObject.CreateInstance <ContentUpdateGroupSchema>();
var schemas = new List <AddressableAssetGroupSchema> {
bundledAssetGroupSchema, contentUpdateGroupSchema
};
return(settings.CreateGroup(groupName, false, false, true, schemas));
}
/// <summary>
///
/// </summary>
/// <param name="groupName">assetGroup.Name + "_" + pair.label</param>
/// <param name="baseGroup"></param>
/// <param name="settings"></param>
/// <param name="schema"></param>
/// <returns></returns>
AddressableAssetGroup FindOrCopyGroup(string groupName, AddressableAssetGroup baseGroup, AddressableAssetSettings settings, TextureVariationSchema schema)
{
AddressableAssetGroup result;
if (!m_GeneratedGroups.TryGetValue(groupName, out result)) //没有对应的Group就创建
{
List <AddressableAssetGroupSchema> schemas = new List <AddressableAssetGroupSchema>(baseGroup.Schemas); //这个group的所有Schemas
schemas.Remove(schema); //移除自定义这个schema
result = settings.CreateGroup(groupName, false, false, false, schemas); //创建一个新的Group并设置除了自定义schema以为的所有schema
m_GeneratedGroups.Add(groupName, result); //添加这个临时生成的Group
}
return(result);
}
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 AddressableAssetGroupInfo CreateGroup(string groupName, bool setAsDefaultGroup, bool readOnly,
bool postEvent, List <AddressableAssetGroupSchema> schemasToCopy, params Type[] types)
{
if (_settings.FindGroup(groupName) != null)
{
throw new Exception(
$"Failed to create {nameof(AddressableAssetGroup)} (Name:{groupName}) because it is already exists.");
}
var group = _settings.CreateGroup(groupName, setAsDefaultGroup, readOnly, postEvent, schemasToCopy, types);
return(new AddressableAssetGroupInfo(group.Guid, group.Name));
}
IHostingService GetManagedService(out AddressableAssetSettings settings)
{
var m = new HostingServicesManager();
settings = AddressableAssetSettings.Create(k_TestConfigFolder, k_TestConfigName, false, false);
settings.HostingServicesManager = m;
var group = settings.CreateGroup("testGroup", false, false, false, null);
group.AddSchema <BundledAssetGroupSchema>();
settings.groups.Add(group);
m.Initialize(settings);
return(m.AddHostingService(m_Service.GetType(), "test"));
}
AddressableAssetGroup FindOrCopyGroup(string groupName, AddressableAssetGroup baseGroup, AddressableAssetSettings settings, TextureVariationSchema schema)
{
AddressableAssetGroup result;
if (!m_GeneratedGroups.TryGetValue(groupName, out result))
{
List <AddressableAssetGroupSchema> schemas = new List <AddressableAssetGroupSchema>(baseGroup.Schemas);
schemas.Remove(schema);
result = settings.CreateGroup(groupName, false, false, false, schemas);
m_GeneratedGroups.Add(groupName, result);
}
return(result);
}
AddressableAssetGroup CreateTemporaryGroupCopy(string groupName, List <AddressableAssetGroupSchema> schemas, AddressableAssetSettings settings)
{
var variantGroup = settings.CreateGroup(groupName, false, false, false, schemas);
if (variantGroup.HasSchema <PrefabTextureVariantSchema>())
{
variantGroup.RemoveSchema <PrefabTextureVariantSchema>();
}
if (!m_GeneratedGroups.ContainsKey(variantGroup.Name))
{
m_GeneratedGroups.Add(variantGroup.Name, variantGroup);
}
return(variantGroup);
}
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);
}
public static List <AddressableAssetEntry> GetResourcesEntries(AddressableAssetSettings settings,
bool recurseAll, Func <AddressableAssetEntry, bool> filter = null)
{
var group = settings.CreateGroup("FindResources", false, false, false,
new List <AddressableAssetGroupSchema>(), typeof(PlayerDataGroupSchema));
group.GetSchema <PlayerDataGroupSchema>().IncludeResourcesFolders = true;
var entry = settings.CreateEntry("empty", "empty", group, false);
List <AddressableAssetEntry> entries = new List <AddressableAssetEntry>();
entry.GatherResourcesEntries(entries, recurseAll, filter);
group.RemoveAssetEntry(entry);
settings.RemoveGroup(group);
return(entries);
}
/// <summary>
/// リモートグループを生成する
/// </summary>
/// <param name="this"></param>
/// <returns></returns>
private static AddressableAssetGroup CreateRemoteGroup(this AddressableAssetSettings @this)
{
var name = "Remote";
var group = @this.groups.Find(v => v.name == name);
if (group == null)
{
group = @this.CreateGroup(name, false, false, false, null, typeof(ContentUpdateGroupSchema), typeof(BundledAssetGroupSchema));
var schema = group.GetSchema <BundledAssetGroupSchema>();
schema.BuildPath.SetVariableByName(@this, "RemoteBuildPath");
schema.LoadPath.SetVariableByName(@this, "RemoteLoadPath");
schema.BundleMode = BundledAssetGroupSchema.BundlePackingMode.PackSeparately;
}
return(group);
}
static AddressableAssetGroup FindOrCreateGroup(AddressableAssetSettings setting, string gname)
{
var group = setting.FindGroup(gname);
if (group == null)
{
group = setting.CreateGroup(gname, false, false, false, null, typeof(ContentUpdateGroupSchema), typeof(BundledAssetGroupSchema));
var schema = group.GetSchema <BundledAssetGroupSchema>();
schema.BuildPath.SetVariableByName(setting, "LocalBuildPath");
schema.LoadPath.SetVariableByName(setting, "LocalLoadPath");
schema.BundleMode = BundledAssetGroupSchema.BundlePackingMode.PackTogether;
}
return(group);
}
internal static void UpdateWordLibrary()
{
string groupName = "WordLibrary";
UnityEditor.EditorUtility.DisplayCancelableProgressBar("更新词库...", "", 0);
AddressableAssetSettings aaSettings = AddressableAssetSettingsDefaultObject.GetSettings(false);
AddressableAssetGroup group = null;
group = aaSettings.groups.Find(x => x.Name == groupName);
if (group != null)
{
aaSettings.RemoveGroup(group);
group = null;
}
group = aaSettings.CreateGroup(groupName, false, false, false, null);
group.AddSchema <BundledAssetGroupSchema>();
string levelDir = string.Format("{0}/AssetsPackage/AnsycLoad/CodyLevel", Application.dataPath);
if (!Directory.Exists(levelDir))
{
Debug.LogError("路径不存在 " + levelDir);
Directory.CreateDirectory(levelDir);
}
else
{
var files = Directory.GetFiles(levelDir);
var index = 0;
foreach (var item in files)
{
index++;
UnityEditor.EditorUtility.DisplayCancelableProgressBar("更新词库...", Path.GetFileName(item), index / (float)files.Length);
var extention = Path.GetExtension(item);
if (extention.Equals(".txt"))
{
string guid = AssetDatabase.AssetPathToGUID(string.Format("Assets/AssetsPackage/AnsycLoad/CodyLevel/{0}",
Path.GetFileName(item)));
AddressableAssetEntry entity = aaSettings.CreateOrMoveEntry(guid, group);
entity.SetAddress(Path.GetFileName(item));
bool result = entity.SetLabel("WordLibrary", true);
Debug.Log("set label result " + result);
}
}
}
UnityEditor.EditorUtility.ClearProgressBar();
}
private static void BuildGroup(string groupFolder, AddressableAssetSettings settings, List <AddressableAssetGroupSchema> schemas)
{
List <string> assetPaths = Directory.EnumerateFiles(groupFolder, "*.*", SearchOption.AllDirectories)
.Where(p => Path.GetExtension(p) != ".meta")
.Select(p => p.Substring(UnityEngine.Application.dataPath.Length - 6))
.ToList();
if (assetPaths.Count < 1)
{
return;
}
string groupName = groupFolder.Substring(groupFolder.LastIndexOf('/') + 1);
if (groupName.StartsWith("~") || groupName == "Resources")
{
return;
}
AddressableAssetGroup group = settings.FindGroup(groupName);
if (group != null)
{
settings.RemoveGroup(group);
}
group = settings.CreateGroup(groupName, false, false, true, schemas);
foreach (string path in assetPaths)
{
string address = Path.GetFileNameWithoutExtension(path);
if (address.StartsWith("~"))
{
continue;
}
if (address == tempAddress)
{
Log.Info($"Address重复->{address}");
}
var enity = settings.CreateOrMoveEntry(AssetDatabase.AssetPathToGUID(path), group);
enity.SetAddress(address);
enity.SetLabel("default", true);
tempAddress = address;
}
if (groupName == "Default Local Group")
{
settings.DefaultGroup = group;
}
}
//创建组
private static AddressableAssetGroup CreateOrGetNonStaticGroup(AddressableAssetSettings settings, string groupName)
{
var group = settings.FindGroup(groupName);
if (group == null)
{
group = settings.CreateGroup(groupName, false, false, false, null, typeof(BundledAssetGroupSchema), typeof(ContentUpdateGroupSchema));
}
group.GetSchema <ContentUpdateGroupSchema>().StaticContent = false;
BundledAssetGroupSchema groupSchema = group.GetSchema <BundledAssetGroupSchema>();
//groupSchema.UseAssetBundleCrc = false;
//groupSchema.BundleNaming = BundledAssetGroupSchema.BundleNamingStyle.OnlyHash;
groupSchema.BundleMode = BundledAssetGroupSchema.BundlePackingMode.PackSeparately;
groupSchema.BuildPath.SetVariableByName(settings, AddressableAssetSettings.kRemoteBuildPath);
groupSchema.BuildPath.SetVariableByName(settings, AddressableAssetSettings.kRemoteLoadPath);
return(group);
}
internal static AddressableAssetGroup GetOrAddGroup(AddressableAssetSettings settings, string groupName)
{
AddressableAssetGroup group = settings.groups.Find(x => x.Name == groupName);
if (group == null)
{
group = settings.CreateGroup(groupName, false, false, false, new List <AddressableAssetGroupSchema> {
settings.DefaultGroup.Schemas[0]
}, typeof(BundledAssetGroupSchema));
var bundleSchema = group.GetSchema <BundledAssetGroupSchema>();
if (bundleSchema != null)
{
bundleSchema.Compression = BundledAssetGroupSchema.BundleCompressionMode.Uncompressed;
}
}
return(group);
}
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;
}
