public void CreateCustomLocator_RetrunsLocatorWithUniqueId()
{
ContentCatalogData ccd = new ContentCatalogData();
ccd.SetData(new List <ContentCatalogDataEntry>());
ResourceLocationMap map = ccd.CreateCustomLocator("test");
Assert.AreEqual("test", map.LocatorId);
}
public void AssetBundleRequestOptionsTest()
{
var options = new AssetBundleRequestOptions
{
ChunkedTransfer = true,
Crc = 123,
Hash = new Hash128(1, 2, 3, 4).ToString(),
RedirectLimit = 4,
RetryCount = 7,
Timeout = 12,
AssetLoadMode = AssetLoadMode.AllPackedAssetsAndDependencies
};
var dataEntry = new ContentCatalogDataEntry(typeof(ContentCatalogData), "internalId", "provider", new object[] { 1 }, null, options);
var entries = new List <ContentCatalogDataEntry>();
entries.Add(dataEntry);
var ccData = new ContentCatalogData("TestCatalog");
ccData.SetData(entries, false);
var locator = ccData.CreateLocator();
IList <IResourceLocation> locations;
if (!locator.Locate(1, typeof(object), out locations))
{
Assert.Fail("Unable to locate resource location");
}
var loc = locations[0];
var locOptions = loc.Data as AssetBundleRequestOptions;
Assert.IsNotNull(locOptions);
Assert.AreEqual(locOptions.ChunkedTransfer, options.ChunkedTransfer);
Assert.AreEqual(locOptions.Crc, options.Crc);
Assert.AreEqual(locOptions.Hash, options.Hash);
Assert.AreEqual(locOptions.RedirectLimit, options.RedirectLimit);
Assert.AreEqual(locOptions.RetryCount, options.RetryCount);
Assert.AreEqual(locOptions.Timeout, options.Timeout);
Assert.AreEqual(locOptions.AssetLoadMode, options.AssetLoadMode);
}
TResult DoBuild <TResult>(AddressablesDataBuilderInput builderInput, AddressableAssetSettings aaSettings, AddressableAssetsBuildContext aaContext) where TResult : IDataBuilderResult
{
if (m_AllBundleInputDefinitions.Count > 0)
{
if (!BuildUtility.CheckModifiedScenesAndAskToSave())
{
return(AddressableAssetBuildResult.CreateResult <TResult>(null, 0, "Unsaved scenes"));
}
var buildTarget = builderInput.Target;
var buildTargetGroup = builderInput.TargetGroup;
var buildParams = new AddressableAssetsBundleBuildParameters(aaSettings, aaContext.bundleToAssetGroup, buildTarget, buildTargetGroup, aaSettings.buildSettings.bundleBuildPath);
var builtinShaderBundleName = aaSettings.DefaultGroup.Name.ToLower().Replace(" ", "").Replace('\\', '/').Replace("//", "/") + "_unitybuiltinshaders.bundle";
var buildTasks = RuntimeDataBuildTasks(aaSettings.buildSettings.compileScriptsInVirtualMode, builtinShaderBundleName);
ExtractDataTask extractData = new ExtractDataTask();
buildTasks.Add(extractData);
string aaPath = aaSettings.AssetPath;
IBundleBuildResults results;
var exitCode = ContentPipeline.BuildAssetBundles(buildParams, new BundleBuildContent(m_AllBundleInputDefinitions), out results, buildTasks, aaContext);
if (exitCode < ReturnCode.Success)
{
return(AddressableAssetBuildResult.CreateResult <TResult>(null, 0, "SBP Error" + exitCode));
}
if (aaSettings == null && !string.IsNullOrEmpty(aaPath))
{
aaSettings = AssetDatabase.LoadAssetAtPath <AddressableAssetSettings>(aaPath);
}
}
var bundledAssets = new Dictionary <object, HashSet <string> >();
foreach (var loc in aaContext.locations)
{
if (loc.Dependencies != null && loc.Dependencies.Count > 0)
{
for (int i = 0; i < loc.Dependencies.Count; i++)
{
var dep = loc.Dependencies[i];
HashSet <string> assetsInBundle;
if (!bundledAssets.TryGetValue(dep, out assetsInBundle))
{
bundledAssets.Add(dep, assetsInBundle = new HashSet <string>());
}
if (i == 0 && !assetsInBundle.Contains(loc.InternalId)) //only add the asset to the first bundle...
{
assetsInBundle.Add(loc.InternalId);
}
}
}
}
foreach (var bd in bundledAssets)
{
AddressableAssetGroup group = aaSettings.DefaultGroup;
string groupGuid;
if (aaContext.bundleToAssetGroup.TryGetValue(bd.Key as string, out groupGuid))
{
group = aaSettings.FindGroup(g => g.Guid == groupGuid);
}
var schema = group.GetSchema <BundledAssetGroupSchema>();
if (schema != null)
{
var bundleLocData = aaContext.locations.First(s => s.Keys[0] == bd.Key);
var isLocalBundle = IsInternalIdLocal(bundleLocData.InternalId);
uint crc = (uint)UnityEngine.Random.Range(0, int.MaxValue);
var hash = Guid.NewGuid().ToString();
string originalBundleName = bd.Key as string;
string newBundleName = BuildUtility.GetNameWithHashNaming(schema.BundleNaming, hash, originalBundleName);
bundleLocData.InternalId = bundleLocData.InternalId.Remove(bundleLocData.InternalId.Length - originalBundleName.Length) + newBundleName;
var virtualBundleName = AddressablesRuntimeProperties.EvaluateString(bundleLocData.InternalId);
var bundleData = new VirtualAssetBundle(virtualBundleName, isLocalBundle, crc, hash);
long dataSize = 0;
long headerSize = 0;
foreach (var a in bd.Value)
{
var size = ComputeSize(a);
bundleData.Assets.Add(new VirtualAssetBundleEntry(a, size));
dataSize += size;
headerSize += a.Length * 5; //assume 5x path length overhead size per item, probably much less
}
if (bd.Value.Count == 0)
{
dataSize = 100 * 1024;
headerSize = 1024;
}
bundleData.SetSize(dataSize, headerSize);
var requestOptions = new VirtualAssetBundleRequestOptions
{
Crc = schema.UseAssetBundleCrc ? crc : 0,
Hash = schema.UseAssetBundleCache ? hash : "",
ChunkedTransfer = schema.ChunkedTransfer,
RedirectLimit = schema.RedirectLimit,
RetryCount = schema.RetryCount,
Timeout = schema.Timeout,
BundleName = Path.GetFileName(bundleLocData.InternalId),
BundleSize = dataSize + headerSize
};
bundleLocData.Data = requestOptions;
var bundleProviderId = schema.GetBundleCachedProviderId();
var virtualBundleRuntimeData = m_CreatedProviderIds[bundleProviderId];
virtualBundleRuntimeData.AssetBundles.Add(bundleData);
}
}
foreach (var kvp in m_CreatedProviderIds)
{
if (kvp.Value != null)
{
var bundleProviderData = ObjectInitializationData.CreateSerializedInitializationData <VirtualAssetBundleProvider>(kvp.Key, kvp.Value);
m_ResourceProviderData.Add(bundleProviderData);
}
}
var contentCatalog = new ContentCatalogData(ResourceManagerRuntimeData.kCatalogAddress);
contentCatalog.SetData(aaContext.locations, aaContext.Settings.OptimizeCatalogSize);
contentCatalog.ResourceProviderData.AddRange(m_ResourceProviderData);
foreach (var t in aaContext.providerTypes)
{
contentCatalog.ResourceProviderData.Add(ObjectInitializationData.CreateSerializedInitializationData(t));
}
contentCatalog.InstanceProviderData = ObjectInitializationData.CreateSerializedInitializationData(instanceProviderType.Value);
contentCatalog.SceneProviderData = ObjectInitializationData.CreateSerializedInitializationData(sceneProviderType.Value);
//save catalog
WriteFile(string.Format(m_PathFormat, "", "catalog"), JsonUtility.ToJson(contentCatalog), builderInput.Registry);
foreach (var io in aaSettings.InitializationObjects)
{
if (io is IObjectInitializationDataProvider)
{
aaContext.runtimeData.InitializationObjects.Add((io as IObjectInitializationDataProvider).CreateObjectInitializationData());
}
}
var settingsPath = string.Format(m_PathFormat, "", "settings");
WriteFile(settingsPath, JsonUtility.ToJson(aaContext.runtimeData), builderInput.Registry);
//inform runtime of the init data path
var runtimeSettingsPath = string.Format(m_PathFormat, "file://{UnityEngine.Application.dataPath}/../", "settings");
PlayerPrefs.SetString(Addressables.kAddressablesRuntimeDataPath, runtimeSettingsPath);
var result = AddressableAssetBuildResult.CreateResult <TResult>(settingsPath, aaContext.locations.Count);
return(result);
}
public void VerifySerialization()
{
var sw = Stopwatch.StartNew();
sw.Start();
var catalog = new ContentCatalogData();
var entries = new List <ContentCatalogDataEntry>();
var availableKeys = new List <object>();
for (int i = 0; i < 1000; i++)
{
var internalId = "Assets/TestPath/" + GUID.Generate() + ".asset";
var eKeys = GetRandomSubset(m_Keys, Random.Range(1, 5));
object data;
if (i % 2 == 0)
{
data = new EvenData {
index = i, path = internalId
}
}
;
else
{
data = new OddData {
index = i, path = internalId
}
};
var e = new ContentCatalogDataEntry(typeof(ContentCatalogData), internalId, m_Providers[Random.Range(0, m_Providers.Count)].FullName, eKeys, GetRandomSubset(availableKeys, Random.Range(0, 1)), data);
availableKeys.Add(eKeys[0]);
entries.Add(e);
}
catalog.SetData(entries);
sw.Stop();
var t = sw.Elapsed.TotalMilliseconds;
sw.Reset();
sw.Start();
var locMap = catalog.CreateLocator();
sw.Stop();
Debug.LogFormat("Create: {0}ms, Load: {1}ms", t, sw.Elapsed.TotalMilliseconds);
foreach (var k in locMap.Locations)
{
foreach (var loc in k.Value)
{
var entry = entries.Find(e => e.InternalId == loc.InternalId);
Assert.AreEqual(entry.Provider, loc.ProviderId);
var deps = loc.Dependencies;
if (deps != null)
{
foreach (var ed in entry.Dependencies)
{
IList <IResourceLocation> depList;
Assert.IsTrue(locMap.Locate(ed, typeof(object), out depList));
for (int i = 0; i < depList.Count; i++)
{
Assert.AreEqual(depList[i].InternalId, deps[i].InternalId);
}
}
}
}
}
}