#if UNITY_EDITOR
using System;
using System.Collections.Generic;
using UnityEditor;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.ResourceManagement.Exceptions;
using UnityEngine.ResourceManagement.ResourceLocations;
using UnityEngine.ResourceManagement.Util;
using UnityEngine.Serialization;
namespace UnityEngine.ResourceManagement.ResourceProviders.Simulation
{
abstract class VBAsyncOperation
{
public abstract DownloadStatus GetDownloadStatus();
public abstract bool WaitForCompletion();
}
class VBAsyncOperation<TObject> : VBAsyncOperation
{
protected TObject m_Result;
protected AsyncOperationStatus m_Status;
protected Exception m_Error;
protected object m_Context;
DelegateList<VBAsyncOperation<TObject>> m_CompletedAction;
Action<VBAsyncOperation<TObject>> m_OnDestroyAction;
public override DownloadStatus GetDownloadStatus() => default;
public override bool WaitForCompletion() => true;
public override string ToString()
{
var instId = "";
var or = m_Result as Object;
if (or != null)
instId = "(" + or.GetInstanceID() + ")";
return string.Format("{0}, result='{1}', status='{2}', location={3}.", base.ToString(), (m_Result + instId), m_Status, m_Context);
}
public event Action<VBAsyncOperation<TObject>> Completed
{
add
{
if (IsDone)
{
DelayedActionManager.AddAction(value, 0, this);
}
else
{
if (m_CompletedAction == null)
m_CompletedAction = DelegateList<VBAsyncOperation<TObject>>.CreateWithGlobalCache();
m_CompletedAction.Add(value);
}
}
remove { m_CompletedAction.Remove(value); }
}
public AsyncOperationStatus Status
{
get { return m_Status; }
protected set { m_Status = value; }
}
/// <inheritdoc />
public Exception OperationException
{
get { return m_Error; }
protected set
{
m_Error = value;
if (m_Error != null && ResourceManager.ExceptionHandler != null)
ResourceManager.ExceptionHandler(new AsyncOperationHandle(null), value);
}
}
public TObject Result
{
get { return m_Result; }
}
public virtual bool IsDone
{
get { return Status == AsyncOperationStatus.Failed || Status == AsyncOperationStatus.Succeeded; }
}
/// <inheritdoc />
public virtual float PercentComplete
{
get { return IsDone ? 1f : 0f; }
}
/// <inheritdoc />
public object Context
{
get { return m_Context; }
set { m_Context = value; }
}
public void InvokeCompletionEvent()
{
if (m_CompletedAction != null)
{
m_CompletedAction.Invoke(this);
m_CompletedAction.Clear();
}
}
public virtual void SetResult(TObject result)
{
m_Result = result;
m_Status = (m_Result == null) ? AsyncOperationStatus.Failed : AsyncOperationStatus.Succeeded;
}
public VBAsyncOperation<TObject> StartCompleted(object context, object key, TObject val, Exception error = null)
{
Context = context;
OperationException = error;
m_Result = val;
m_Status = (m_Result == null) ? AsyncOperationStatus.Failed : AsyncOperationStatus.Succeeded;
DelayedActionManager.AddAction((Action)InvokeCompletionEvent);
return this;
}
}
/// <summary>
/// Contains data needed to simulate a bundled asset
/// </summary>
[Serializable]
public class VirtualAssetBundleEntry
{
[FormerlySerializedAs("m_name")]
[SerializeField]
string m_Name;
/// <summary>
/// The name of the asset.
/// </summary>
public string Name
{
get { return m_Name; }
}
[FormerlySerializedAs("m_size")]
[SerializeField]
long m_Size;
/// <summary>
/// The file size of the asset, in bytes.
/// </summary>
public long Size
{
get { return m_Size; }
}
[SerializeField]
internal string m_AssetPath;
/// <summary>
/// Construct a new VirtualAssetBundleEntry
/// </summary>
public VirtualAssetBundleEntry()
{
}
/// <summary>
/// Construct a new VirtualAssetBundleEntry
/// </summary>
/// <param name="name">The name of the asset.</param>
/// <param name="size">The size of the asset, in bytes.</param>
public VirtualAssetBundleEntry(string name, long size)
{
m_Name = name;
m_Size = size;
}
}
/// <summary>
/// Contains data need to simulate an asset bundle.
/// </summary>
[Serializable]
public class VirtualAssetBundle : ISerializationCallbackReceiver, IAssetBundleResource
{
[FormerlySerializedAs("m_name")]
[SerializeField]
string m_Name;
[FormerlySerializedAs("m_isLocal")]
[SerializeField]
bool m_IsLocal;
[FormerlySerializedAs("m_dataSize")]
[SerializeField]
long m_DataSize;
[FormerlySerializedAs("m_headerSize")]
[SerializeField]
long m_HeaderSize;
[FormerlySerializedAs("m_latency")]
[SerializeField]
float m_Latency;
[SerializeField]
uint m_Crc;
[SerializeField]
string m_Hash;
[FormerlySerializedAs("m_serializedAssets")]
[SerializeField]
List<VirtualAssetBundleEntry> m_SerializedAssets = new List<VirtualAssetBundleEntry>();
long m_HeaderBytesLoaded;
long m_DataBytesLoaded;
LoadAssetBundleOp m_BundleLoadOperation;
List<IVirtualLoadable> m_AssetLoadOperations = new List<IVirtualLoadable>();
Dictionary<string, VirtualAssetBundleEntry> m_AssetMap;
/// <summary>
/// The name of the bundle.
/// </summary>
public string Name
{
get { return m_Name; }
}
/// <summary>
/// The assets contained in the bundle.
/// </summary>
public List<VirtualAssetBundleEntry> Assets
{
get { return m_SerializedAssets; }
}
const long k_SynchronousBytesPerSecond = (long)1024 * 1024 * 1024 * 10; // 10 Gb/s
/// <summary>
/// Construct a new VirtualAssetBundle object.
/// </summary>
public VirtualAssetBundle()
{
}
/// <summary>
/// The percent of data that has been loaded.
/// </summary>
public float PercentComplete
{
get
{
if (m_HeaderSize + m_DataSize <= 0)
return 1;
return (float)(m_HeaderBytesLoaded + m_DataBytesLoaded) / (m_HeaderSize + m_DataSize);
}
}
/// <summary>
/// Construct a new VirtualAssetBundle
/// </summary>
/// <param name="name">The name of the bundle.</param>
/// <param name="local">Is the bundle local or remote. This is used to determine which bandwidth value to use when simulating loading.</param>
public VirtualAssetBundle(string name, bool local, uint crc, string hash)
{
m_Latency = .1f;
m_Name = name;
m_IsLocal = local;
m_HeaderBytesLoaded = 0;
m_DataBytesLoaded = 0;
m_Crc = crc;
m_Hash = hash;
}
/// <summary>
/// Set the size of the bundle.
/// </summary>
/// <param name="dataSize">The size of the data.</param>
/// <param name="headerSize">The size of the header.</param>
public void SetSize(long dataSize, long headerSize)
{
m_HeaderSize = headerSize;
m_DataSize = dataSize;
}
/// <summary>
/// Not used
/// </summary>
public void OnBeforeSerialize()
{
}
/// <summary>
/// Load serialized data into runtime structures.
/// </summary>
public void OnAfterDeserialize()
{
m_AssetMap = new Dictionary<string, VirtualAssetBundleEntry>();
foreach (var a in m_SerializedAssets)
m_AssetMap.Add(a.Name, a);
}
class LoadAssetBundleOp : VBAsyncOperation<VirtualAssetBundle>
{
VirtualAssetBundle m_Bundle;
float m_TimeInLoadingState;
bool m_crcHashValidated;
public LoadAssetBundleOp(IResourceLocation location, VirtualAssetBundle bundle)
{
Context = location;
m_Bundle = bundle;
m_TimeInLoadingState = 0.0f;
}
public override bool WaitForCompletion()
{
SetResult(m_Bundle);
InvokeCompletionEvent();
return true;
}
public override DownloadStatus GetDownloadStatus()
{
if (m_Bundle.m_IsLocal)
return new DownloadStatus() {IsDone = IsDone};
return new DownloadStatus() {DownloadedBytes = m_Bundle.m_DataBytesLoaded, TotalBytes = m_Bundle.m_DataSize, IsDone = IsDone};
}
public override float PercentComplete
{
get
{
if (IsDone)
return 1f;
return m_Bundle.PercentComplete;
}
}
public void Update(long localBandwidth, long remoteBandwidth, float unscaledDeltaTime)
{
if (m_Result != null)
return;
if (!m_crcHashValidated)
{
var location = Context as IResourceLocation;
var reqOptions = location.Data as AssetBundleRequestOptions;
if (reqOptions != null)
{
if (reqOptions.Crc != 0 && m_Bundle.m_Crc != reqOptions.Crc)
{
var err = string.Format("Error while downloading Asset Bundle: CRC Mismatch. Provided {0}, calculated {1} from data. Will not load Asset Bundle.", reqOptions.Crc,
m_Bundle.m_Crc);
SetResult(null);
OperationException = new Exception(err);
InvokeCompletionEvent();
}
if (!m_Bundle.m_IsLocal)
{
if (!string.IsNullOrEmpty(reqOptions.Hash))
{
if (string.IsNullOrEmpty(m_Bundle.m_Hash) || m_Bundle.m_Hash != reqOptions.Hash)
{
Debug.LogWarningFormat("Mismatched hash in bundle {0}.", m_Bundle.Name);
}
//TODO: implement virtual cache that would persist between runs.
//if(vCache.hashBundle(m_Bundle.Name, reqOptions.Hash))
// m_m_Bundle.IsLocal = true;
}
}
}
m_crcHashValidated = true;
}
m_TimeInLoadingState += unscaledDeltaTime;
if (m_TimeInLoadingState > m_Bundle.m_Latency)
{
long localBytes = (long)Math.Ceiling(unscaledDeltaTime * localBandwidth);
long remoteBytes = (long)Math.Ceiling(unscaledDeltaTime * remoteBandwidth);
if (m_Bundle.LoadData(localBytes, remoteBytes))
{
SetResult(m_Bundle);
InvokeCompletionEvent();
}
}
}
}
bool LoadData(long localBytes, long remoteBytes)
{
if (m_IsLocal)
{
m_HeaderBytesLoaded += localBytes;
if (m_HeaderBytesLoaded < m_HeaderSize)
return false;
m_HeaderBytesLoaded = m_HeaderSize;
return true;
}
else
{
if (m_DataBytesLoaded < m_DataSize)
{
m_DataBytesLoaded += remoteBytes;
if (m_DataBytesLoaded < m_DataSize)
return false;
m_DataBytesLoaded = m_DataSize;
return false;
}
m_HeaderBytesLoaded += localBytes;
if (m_HeaderBytesLoaded < m_HeaderSize)
return false;
m_HeaderBytesLoaded = m_HeaderSize;
return true;
}
}
internal bool Unload()
{
if (m_BundleLoadOperation == null)
Debug.LogWarningFormat("Simulated assetbundle {0} is already unloaded.", m_Name);
m_HeaderBytesLoaded = 0;
m_BundleLoadOperation = null;
return true;
}
internal VBAsyncOperation<VirtualAssetBundle> StartLoad(IResourceLocation location)
{
if (m_BundleLoadOperation != null)
{
if (m_BundleLoadOperation.IsDone)
Debug.LogWarningFormat("Simulated assetbundle {0} is already loaded.", m_Name);
else
Debug.LogWarningFormat("Simulated assetbundle {0} is already loading.", m_Name);
return m_BundleLoadOperation;
}
m_HeaderBytesLoaded = 0;
return (m_BundleLoadOperation = new LoadAssetBundleOp(location, this));
}
/// <summary>
/// Load an asset via its location. The asset will actually be loaded via the AssetDatabase API.
/// </summary>
/// <typeparam name="TObject"></typeparam>
/// <param name="location"></param>
/// <returns></returns>
internal VBAsyncOperation<object> LoadAssetAsync(ProvideHandle provideHandle, IResourceLocation location)
{
if (location == null)
throw new ArgumentException("IResourceLocation location cannot be null.");
if (m_BundleLoadOperation == null)
return new VBAsyncOperation<object>().StartCompleted(location, location, null, new ResourceManagerException("LoadAssetAsync called on unloaded bundle " + m_Name));
if (!m_BundleLoadOperation.IsDone)
return new VBAsyncOperation<object>().StartCompleted(location, location, null, new ResourceManagerException("LoadAssetAsync called on loading bundle " + m_Name));
VirtualAssetBundleEntry assetInfo;
var assetPath = location.InternalId;
if (ResourceManagerConfig.ExtractKeyAndSubKey(assetPath, out string mainPath, out string subKey))
assetPath = mainPath;
//this needs to use the non translated internal id since that was how the table was built.
if (!m_AssetMap.TryGetValue(assetPath, out assetInfo))
return new VBAsyncOperation<object>().StartCompleted(location, location, null,
new ResourceManagerException(string.Format("Unable to load asset {0} from simulated bundle {1}.", location.InternalId, Name)));
var op = new LoadAssetOp(location, assetInfo, provideHandle);
m_AssetLoadOperations.Add(op);
return op;
}
internal void CountBandwidthUsage(ref long localCount, ref long remoteCount)
{
if (m_BundleLoadOperation != null && m_BundleLoadOperation.IsDone)
{
localCount += m_AssetLoadOperations.Count;
return;
}
if (m_IsLocal)
{
localCount++;
}
else
{
if (m_DataBytesLoaded < m_DataSize)
remoteCount++;
else
localCount++;
}
}
interface IVirtualLoadable
{
bool Load(long localBandwidth, long remoteBandwidth, float unscaledDeltaTime);
}
// TODO: This is only needed internally. We can change this to not derive off of AsyncOperationBase and simplify the code
class LoadAssetOp : VBAsyncOperation<object>, IVirtualLoadable
{
long m_BytesLoaded;
float m_LastUpdateTime;
VirtualAssetBundleEntry m_AssetInfo;
ProvideHandle m_provideHandle;
public LoadAssetOp(IResourceLocation location, VirtualAssetBundleEntry assetInfo, ProvideHandle ph)
{
m_provideHandle = ph;
Context = location;
m_AssetInfo = assetInfo;
m_LastUpdateTime = Time.realtimeSinceStartup;
}
public override bool WaitForCompletion()
{
//TODO: this needs to just wait on the resourcemanager update loop to ensure proper loading order
while (!IsDone)
{
Load(k_SynchronousBytesPerSecond, k_SynchronousBytesPerSecond, .1f);
System.Threading.Thread.Sleep(100);
}
return true;
}
public override float PercentComplete
{
get { return Mathf.Clamp01(m_BytesLoaded / (float)m_AssetInfo.Size); }
}
public bool Load(long localBandwidth, long remoteBandwidth, float unscaledDeltaTime)
{
if (IsDone)
return false;
var now = m_LastUpdateTime + unscaledDeltaTime;
if (now > m_LastUpdateTime)
{
m_BytesLoaded += (long)Math.Ceiling((now - m_LastUpdateTime) * localBandwidth);
m_LastUpdateTime = now;
}
if (m_BytesLoaded < m_AssetInfo.Size)
return true;
if (!(Context is IResourceLocation))
return false;
var location = Context as IResourceLocation;
var assetPath = m_AssetInfo.m_AssetPath;
object result = null;
var pt = m_provideHandle.Type;
if (pt.IsArray)
result = ResourceManagerConfig.CreateArrayResult(pt, AssetDatabaseProvider.LoadAssetsWithSubAssets(assetPath));
else if (pt.IsGenericType && typeof(IList<>) == pt.GetGenericTypeDefinition())
result = ResourceManagerConfig.CreateListResult(pt, AssetDatabaseProvider.LoadAssetsWithSubAssets(assetPath));
else
{
if (ResourceManagerConfig.ExtractKeyAndSubKey(location.InternalId, out string mainPath, out string subKey))
result = AssetDatabaseProvider.LoadAssetSubObject(assetPath, subKey, pt);
else
result = AssetDatabaseProvider.LoadAssetAtPath(assetPath, m_provideHandle);
}
SetResult(result);
InvokeCompletionEvent();
return false;
}
}
//return true until complete
internal bool UpdateAsyncOperations(long localBandwidth, long remoteBandwidth, float unscaledDeltaTime)
{
if (m_BundleLoadOperation == null)
return false;
if (!m_BundleLoadOperation.IsDone)
{
m_BundleLoadOperation.Update(localBandwidth, remoteBandwidth, unscaledDeltaTime);
return true;
}
foreach (var o in m_AssetLoadOperations)
{
if (!o.Load(localBandwidth, remoteBandwidth, unscaledDeltaTime))
{
m_AssetLoadOperations.Remove(o);
break;
}
}
return m_AssetLoadOperations.Count > 0;
}
/// <summary>
/// Implementation of IAssetBundleResource API
/// </summary>
/// <returns>Always returns null.</returns>
public AssetBundle GetAssetBundle()
{
return null;
}
}
}
#endif