public void StartCaching(IList <ContentManifest.BundleEntry> sortedBundles, PrecacheComplete callback, bool cacheInBackground = false)
{
caching = true;
background = cacheInBackground;
completeCallback = callback;
CoroutineRunner.StartPersistent(CacheBundles(sortedBundles), this, "BundlePrecacheManager.cacheBundles()");
}
private AssetRequest <TAsset> loadAsync <TAsset>(string key, AssetLoadedHandler <TAsset> handler = null) where TAsset : class
{
ContentManifest.AssetEntry entry = getAssetEntry(key);
TAsset indexedAsset = getIndexedAsset <TAsset>(entry.Key);
AssetRequest <TAsset> assetRequest;
CoroutineReturn value;
if (indexedAsset != null)
{
assetRequest = new IndexedAssetRequest <TAsset>(entry.Key, indexedAsset);
if (handler != null)
{
CoroutineRunner.StartPersistent(waitOneFrameBeforeCallingHandler(key, indexedAsset, handler), this, "waitOneFrameBeforeCallingHandler");
}
}
else if (!activeRequests.TryGetValue(entry.Key, out value))
{
activeRequestHandlers.Add(entry.Key, new List <object>());
assetRequest = loadAsyncEntry(ref entry, handler);
activeRequests.Add(entry.Key, assetRequest);
}
else
{
if (handler != null)
{
activeRequestHandlers[entry.Key].Add(handler);
}
assetRequest = (AssetRequest <TAsset>)value;
}
if (assetRequest == null)
{
Log.LogError(this, "Failed to load " + key);
}
return(assetRequest);
}
public override AssetRequest <TAsset> LoadAsync <TAsset>(string deviceList, ref ContentManifest.AssetEntry entry, AssetLoadedHandler <TAsset> handler = null)
{
if (bundleManager.IsUnmounting(entry.BundleKey))
{
bundleManager.CancelUnmount(entry.BundleKey);
}
AssetRequest <TAsset> assetRequest;
if (bundleManager.IsMounted(entry.BundleKey))
{
BundleMount bundle = bundleManager.GetBundle(entry.BundleKey);
if (entry.Extension.Equals("unity"))
{
assetRequest = new SceneAssetBundleRequest <TAsset>(entry.Key, entry.BundleKey, null);
assetRequest.Finished = true;
}
else
{
assetRequest = bundle.LoadAsync(entry.Key, entry.AssetPath, handler);
}
}
else
{
AsyncAssetBundleRequest <TAsset> asyncAssetBundleRequest = ((!entry.Extension.Equals("unity")) ? new AsyncAssetBundleRequest <TAsset>(entry.Key, null) : new SceneAssetBundleRequest <TAsset>(entry.Key, entry.BundleKey, null));
assetRequest = asyncAssetBundleRequest;
CoroutineRunner.StartPersistent(loadBundleAndDependenciesAsync(deviceList, entry, asyncAssetBundleRequest, handler), this, "loadBundleAndDependenciesAsync");
}
return(assetRequest);
}
public override AssetRequest <TAsset> LoadAsync <TAsset>(string deviceList, ref ContentManifest.AssetEntry entry, AssetLoadedHandler <TAsset> handler = null)
{
AssetBundleCreateWrapper assetBundleCreateWrapper = new AssetBundleCreateWrapper(null);
AsyncBundleCreateRequest <TAsset> result = new AsyncBundleCreateRequest <TAsset>(entry.Key, assetBundleCreateWrapper);
CoroutineRunner.StartPersistent(waitForBundleToCreate(entry.Key, assetBundleCreateWrapper, handler), this, "waitForBundleToCreate");
return(result);
}
public override AssetRequest <TAsset> LoadAsync <TAsset>(string deviceList, ref ContentManifest.AssetEntry entry, AssetLoadedHandler <TAsset> handler = null)
{
AssetRequestWrapper <TAsset> request = new AssetRequestWrapper <TAsset>(null);
AsyncAssetRequest <TAsset> asyncAssetRequest = new AsyncAssetRequest <TAsset>(entry.Key, request);
CoroutineRunner.StartPersistent(waitForFileStreamAssetToLoad(asyncAssetRequest, entry.AssetPath, handler), this, "waitForFileStreamAssetToLoad");
return(asyncAssetRequest);
}
public void StartCaching(PrecacheComplete callback, bool cacheInBackground = false)
{
completeRatio = 0f;
caching = true;
background = cacheInBackground;
completeCallback = callback;
CoroutineRunner.StartPersistent(CacheBundles(), this, "BundlePrecacheManager.cacheBundles()");
}
public override AssetRequest <TAsset> LoadAsync <TAsset>(string deviceList, ref ContentManifest.AssetEntry entry, AssetLoadedHandler <TAsset> handler = null)
{
StreamingAssetBundleWrapper streamingAssetBundleWrapper = new StreamingAssetBundleWrapper();
AsyncStreamingAssetBundleRequest <TAsset> result = new AsyncStreamingAssetBundleRequest <TAsset>(entry.Key, streamingAssetBundleWrapper);
CoroutineRunner.StartPersistent(loadBundleFromStreamingAssets(entry, streamingAssetBundleWrapper, handler), this, "loadBundleFromStreamingAssets");
return(result);
}
public static void SetMouseButton(int index, bool?isPressed, Vector3?position)
{
if (isPressed.HasValue && isPressed != instance.fakeLeftMouseButtonDown)
{
CoroutineRunner.StartPersistent(fakeMouseButtonStateChange(), instance, "mouseButtonChange");
}
instance.fakeLeftMouseButtonDown = isPressed;
instance.fakeMousePosition = position;
}
public override AssetRequest <TAsset> LoadAsync <TAsset>(string deviceList, ref ContentManifest.AssetEntry entry, AssetLoadedHandler <TAsset> handler = null)
{
gcsAccessTokenService = Service.Get <IGcsAccessTokenService>();
string bundlePath = UriUtil.Combine(baseUri, entry.Key);
AssetBundleWwwWrapper assetBundleWwwWrapper = new AssetBundleWwwWrapper(bundlePath, gcsAccessTokenService);
AsyncBundleWwwRequest <TAsset> result = new AsyncBundleWwwRequest <TAsset>(entry.Key, assetBundleWwwWrapper);
CoroutineRunner.StartPersistent(waitForBundleToLoad(assetBundleWwwWrapper, handler, entry.IsCacheOnly), this, "Local_waitForBundleToLoad");
return(result);
}
public ICoroutine StartAndAddPersistent(IEnumerator enumerator, object owner, string debugName)
{
ICoroutine coroutine = CoroutineRunner.StartPersistent(enumerator, owner, debugName);
if (!coroutine.Disposed)
{
Add(coroutine);
}
return(coroutine);
}
public override AssetRequest <TAsset> LoadAsync <TAsset>(string deviceList, ref ContentManifest.AssetEntry entry, AssetLoadedHandler <TAsset> handler = null)
{
string bundlePath = UriUtil.Combine(baseUri, entry.Key);
AssetBundleWwwWrapper assetBundleWwwWrapper = new AssetBundleWwwWrapper(bundlePath, gcsAccessTokenService);
AsyncBundleWwwRequest <TAsset> result = new AsyncBundleWwwRequest <TAsset>(entry.Key, assetBundleWwwWrapper);
uint result2 = 0u;
if (entry.UserData != null && entry.UserData is ContentManifest.BundleEntry && !uint.TryParse(((ContentManifest.BundleEntry)entry.UserData).Crc, out result2))
{
result2 = 0u;
}
CoroutineRunner.StartPersistent(waitForBundleToLoad(assetBundleWwwWrapper, result2, handler), this, "waitForBundleToLoad");
return(result);
}
public static AssetRequest <TAsset> Load(ref ContentManifest.AssetEntry entry, AssetLoadedHandler <TAsset> handler = null)
{
ResourceRequest resourceRequest = Resources.LoadAsync(entry.Key, typeof(TAsset));
if (resourceRequest.isDone && resourceRequest.asset == null)
{
throw new ArgumentException("Asset could not be loaded. Is the key correct? Key = " + entry.Key);
}
AsyncAssetResourceRequest <TAsset> asyncAssetResourceRequest = new AsyncAssetResourceRequest <TAsset>(entry.Key, resourceRequest);
if (handler != null)
{
CoroutineRunner.StartPersistent(waitForLoadToFinish(entry.Key, asyncAssetResourceRequest, handler), typeof(AsycnResourceLoader <TAsset>), "waitForLoadToFinish");
}
return(asyncAssetResourceRequest);
}
public AsyncAssetBundleRequest <TAsset> LoadAsync <TAsset>(string key, string assetPath, AssetLoadedHandler <TAsset> handler = null) where TAsset : class
{
AsyncAssetBundleRequest <TAsset> asyncAssetBundleRequest;
if (activeRequests.TryGetValue(key, out var value))
{
asyncAssetBundleRequest = (AsyncAssetBundleRequest <TAsset>)value;
}
else
{
asyncAssetBundleRequest = new AsyncAssetBundleRequest <TAsset>(key, null);
activeRequests[key] = asyncAssetBundleRequest;
CoroutineRunner.StartPersistent(waitForAssetToLoad(key, assetPath, asyncAssetBundleRequest, handler), this, "waitForAssetToLoad");
}
LastLoadFrame = Time.frameCount;
return(asyncAssetBundleRequest);
}
private AssetRequest <TAsset> loadAsyncEntry <TAsset>(ref ContentManifest.AssetEntry entry, AssetLoadedHandler <TAsset> handler = null) where TAsset : class
{
bool flag = entry.Extension.Equals("unity");
if (!flag)
{
assetIndex.Reserve(entry.Key);
}
try
{
AssetRequest <TAsset> assetRequest = deviceManager.LoadAsync(entry.DeviceList, ref entry, handler);
CoroutineRunner.StartPersistent(waitForLoadToFinish(assetRequest, flag), this, "waitForLoadToFinish");
return(assetRequest);
}
catch (Exception)
{
assetIndex.Remove(entry.Key);
throw;
}
}
private IEnumerator cacheBundles(IList <ContentManifest.BundleEntry> sortedBundles, bool ignorePriority)
{
for (int i = 0; i < sortedBundles.Count; i++)
{
completeRatio = (float)(i - numCurrentDownloads) / (float)sortedBundles.Count;
uint maxConcurrentDownloads = (background ? config.MaxConcurrentBackgroundDownloads : config.MaxConcurrentForegroundDownloads);
while (numCurrentDownloads >= maxConcurrentDownloads)
{
maxConcurrentDownloads = (background ? config.MaxConcurrentBackgroundDownloads : config.MaxConcurrentForegroundDownloads);
yield return(null);
}
if (!caching)
{
break;
}
ContentManifest.BundleEntry bundle = sortedBundles[i];
if (ignorePriority || bundle.Priority > 0)
{
CoroutineRunner.StartPersistent(downloadBundle(bundle), this, "BundlePrecacheManager.downloadBundle()");
continue;
}
break;
}
if (sortedBundles.Count > 0)
{
while (numCurrentDownloads > 0)
{
completeRatio = (float)(sortedBundles.Count - numCurrentDownloads) / (float)sortedBundles.Count;
yield return(null);
}
completeRatio = (float)(sortedBundles.Count - numCurrentDownloads) / (float)sortedBundles.Count;
}
if (caching && completeCallback != null)
{
completeCallback();
}
yield return(null);
}
public BundlePrecacheManager(ContentManifest contentManifest)
{
SetManifest(contentManifest);
CoroutineRunner.StartPersistent(loadConfig(), this, "BundlePrecacheManager.loadConfig()");
}
