+scripts

1 files changed, 341 insertions, 0 deletions

diff --git a/Client/Assets/Scripts/XUtliPoolLib/AssetBundleInfo.cs b/Client/Assets/Scripts/XUtliPoolLib/AssetBundleInfo.cs
new file mode 100644
index 00000000..7ac6f887
--- /dev/null
+++ b/Client/Assets/Scripts/XUtliPoolLib/AssetBundleInfo.cs
@@ -0,0 +1,341 @@
+using System;

+using System.Collections.Generic;

+using UnityEngine;

+using XUpdater;

+

+namespace XUtliPoolLib

+{

+	public class AssetBundleInfo

+	{

+		[SerializeField]

+		public int refCount { get; private set; }

+

+		public bool isUnused

+		{

+			get

+			{

+				return this._isReady && Time.time - this._readyTime > this.minLifeTime && this.refCount <= 0 && this.UpdateReference() == 0;

+			}

+		}

+

+		public bool isReady

+		{

+			get

+			{

+				return this._isReady;

+			}

+			set

+			{

+				this._isReady = value;

+			}

+		}

+

+		public virtual UnityEngine.Object mainObject

+		{

+			get

+			{

+				bool flag = this._mainObject == null && this._isReady;

+				if (flag)

+				{

+					this._mainObject = this.bundle.LoadAsset(this.bundle.GetAllAssetNames()[0]);

+					bool flag2 = this._mainObject != null;

+					if (flag2)

+					{

+						bool flag3 = this.data.compositeType == AssetBundleExportType.Root;

+						if (flag3)

+						{

+							bool flag4 = XSingleton<XUpdater.XUpdater>.singleton.ABManager != null;

+							if (flag4)

+							{

+								XSingleton<XUpdater.XUpdater>.singleton.ABManager.AddUnloadBundleQueue(this);

+							}

+						}

+					}

+				}

+				return this._mainObject;

+			}

+		}

+

+		public AssetBundleInfo.OnUnloadedHandler onUnloaded;

+

+		internal AssetBundle bundle;

+

+		public uint bundleName;

+

+		public AssetBundleData data;

+

+		public float minLifeTime = 2f;

+

+		private float _readyTime;

+

+		private bool _isReady;

+

+		private UnityEngine.Object _mainObject;

+

+		private HashSet<AssetBundleInfo> deps = null;

+

+		private List<uint> depChildren = null;

+

+		private List<WeakReference> references = new List<WeakReference>();

+

+		public delegate void OnUnloadedHandler(AssetBundleInfo abi);

+

+		public void AddDependency(AssetBundleInfo target)

+		{

+			bool flag = target != null;

+			if (flag)

+			{

+				bool flag2 = this.deps == null;

+				if (flag2)

+				{

+					this.deps = new HashSet<AssetBundleInfo>();

+				}

+				bool flag3 = this.deps.Add(target);

+				if (flag3)

+				{

+					target.Retain();

+					bool flag4 = target.depChildren == null;

+					if (flag4)

+					{

+						target.depChildren = new List<uint>();

+					}

+					target.depChildren.Add(this.bundleName);

+				}

+			}

+		}

+

+		public void ResetLifeTime()

+		{

+			bool isReady = this._isReady;

+			if (isReady)

+			{

+				this._readyTime = Time.time;

+			}

+		}

+

+		public void Retain()

+		{

+			int refCount = this.refCount;

+			this.refCount = refCount + 1;

+		}

+

+		public void Release()

+		{

+			int refCount = this.refCount;

+			this.refCount = refCount - 1;

+		}

+

+		public void Retain(UnityEngine.Object owner)

+		{

+			bool flag = owner == null;

+			if (flag)

+			{

+				throw new Exception("Please set the user!");

+			}

+			for (int i = 0; i < this.references.Count; i++)

+			{

+				bool flag2 = owner.Equals(this.references[i].Target);

+				if (flag2)

+				{

+					return;

+				}

+			}

+			WeakReference item = new WeakReference(owner);

+			this.references.Add(item);

+		}

+

+		public void Release(object owner)

+		{

+			for (int i = 0; i < this.references.Count; i++)

+			{

+				bool flag = this.references[i].Target == owner;

+				if (flag)

+				{

+					this.references.RemoveAt(i);

+					break;

+				}

+			}

+		}

+

+		public virtual GameObject Instantiate()

+		{

+			return this.Instantiate(true);

+		}

+

+		public virtual GameObject Instantiate(bool enable)

+		{

+			bool flag = this.mainObject != null;

+			if (flag)

+			{

+				bool flag2 = this.mainObject is GameObject;

+				if (flag2)

+				{

+					GameObject gameObject = this.mainObject as GameObject;

+					gameObject.SetActive(enable);

+					GameObject gameObject2 = XCommon.Instantiate<GameObject>(gameObject);

+					gameObject2.name = gameObject.name;

+					this.Retain(gameObject2);

+					return gameObject2;

+				}

+			}

+			return null;

+		}

+

+		public virtual GameObject Instantiate(Vector3 position, Quaternion rotation, bool enable = true)

+		{

+			bool flag = this.mainObject != null;

+			if (flag)

+			{

+				bool flag2 = this.mainObject is GameObject;

+				if (flag2)

+				{

+					GameObject gameObject = this.mainObject as GameObject;

+					gameObject.SetActive(enable);

+					GameObject gameObject2 = UnityEngine.Object.Instantiate<GameObject>(gameObject, position, rotation, null);

+					gameObject2.name = gameObject.name;

+					this.Retain(gameObject2);

+					return gameObject2;

+				}

+			}

+			return null;

+		}

+

+		public UnityEngine.Object Require(UnityEngine.Object user)

+		{

+			this.Retain(user);

+			return this.mainObject;

+		}

+

+		public UnityEngine.Object Require(Component c, bool autoBindGameObject)

+		{

+			bool flag = autoBindGameObject && c && c.gameObject;

+			UnityEngine.Object result;

+			if (flag)

+			{

+				result = this.Require(c.gameObject);

+			}

+			else

+			{

+				result = this.Require(c);

+			}

+			return result;

+		}

+

+		private int UpdateReference()

+		{

+			for (int i = 0; i < this.references.Count; i++)

+			{

+				UnityEngine.Object @object = (UnityEngine.Object)this.references[i].Target;

+				bool flag = !@object;

+				if (flag)

+				{

+					this.references.RemoveAt(i);

+					i--;

+				}

+			}

+			return this.references.Count;

+		}

+

+		public virtual void Dispose()

+		{

+			this.UnloadBundle();

+			bool flag = this.deps != null;

+			if (flag)

+			{

+				foreach (AssetBundleInfo assetBundleInfo in this.deps)

+				{

+					bool flag2 = assetBundleInfo.depChildren != null;

+					if (flag2)

+					{

+						assetBundleInfo.depChildren.Remove(this.bundleName);

+					}

+					assetBundleInfo.Release();

+				}

+				this.deps.Clear();

+			}

+			this.references.Clear();

+			bool flag3 = this.onUnloaded != null;

+			if (flag3)

+			{

+				this.onUnloaded(this);

+			}

+			bool flag4 = !(this._mainObject is GameObject) && !(this._mainObject is ScriptableObject) && !(this._mainObject is Material);

+			if (flag4)

+			{

+				Resources.UnloadAsset(this._mainObject);

+			}

+			else

+			{

+				UnityEngine.Object.Destroy(this._mainObject);

+			}

+			this._mainObject = null;

+		}

+

+		public AsyncOperation LoadAsync(string name, Type t)

+		{

+			bool flag = this._mainObject == null && this._isReady;

+			AsyncOperation result;

+			if (flag)

+			{

+				result = this.bundle.LoadAssetAsync(name, t);

+			}

+			else

+			{

+				result = null;

+			}

+			return result;

+		}

+

+		public void AsyncLoadFinish(UnityEngine.Object asset)

+		{

+			bool flag = this._mainObject == null && this._isReady;

+			if (flag)

+			{

+				this.Release();

+				this._mainObject = asset;

+				bool flag2 = this.data.compositeType == AssetBundleExportType.Root;

+				if (flag2)

+				{

+					bool flag3 = XSingleton<XUpdater.XUpdater>.singleton.ABManager != null;

+					if (flag3)

+					{

+						XSingleton<XUpdater.XUpdater>.singleton.ABManager.AddUnloadBundleQueue(this);

+					}

+				}

+			}

+		}

+

+		private T LoadAsset<T>(string name) where T : UnityEngine.Object

+		{

+			return this.bundle.LoadAsset(name, typeof(T)) as T;

+		}

+

+		public void UnloadBundle()

+		{

+			bool flag = this.bundle != null;

+			if (flag)

+			{

+				bool enableLog = AssetBundleManager.enableLog;

+				if (enableLog)

+				{

+					XSingleton<XDebug>.singleton.AddLog((string.Concat(new object[]

+					{

+						"Unload : ",

+						this.data.compositeType,

+						" >> ",

+						this.bundleName,

+						"(",

+						this.data.debugName

+					}) != null) ? this.data.debugName : ")", null, null, null, null, null, XDebugColor.XDebug_None);

+				}

+				this.bundle.Unload(false);

+				bool flag2 = XSingleton<XUpdater.XUpdater>.singleton.ABManager != null;

+				if (flag2)

+				{

+					XSingleton<XUpdater.XUpdater>.singleton.ABManager.DeleteBundleCount();

+				}

+			}

+			this.bundle = null;

+		}

+	}

+}