From 6eb915c129fc90c6f4c82ae097dd6ffad5239efc Mon Sep 17 00:00:00 2001 From: chai Date: Mon, 25 Jan 2021 14:28:30 +0800 Subject: +scripts --- .../Assets/Scripts/XUtliPoolLib/AssetBundleInfo.cs | 341 +++++++++++++++++++++ 1 file changed, 341 insertions(+) create mode 100644 Client/Assets/Scripts/XUtliPoolLib/AssetBundleInfo.cs (limited to 'Client/Assets/Scripts/XUtliPoolLib/AssetBundleInfo.cs') 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.singleton.ABManager != null; + if (flag4) + { + XSingleton.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 deps = null; + + private List depChildren = null; + + private List references = new List(); + + 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(); + } + bool flag3 = this.deps.Add(target); + if (flag3) + { + target.Retain(); + bool flag4 = target.depChildren == null; + if (flag4) + { + target.depChildren = new List(); + } + 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); + 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, 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.singleton.ABManager != null; + if (flag3) + { + XSingleton.singleton.ABManager.AddUnloadBundleQueue(this); + } + } + } + } + + private T LoadAsset(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.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.singleton.ABManager != null; + if (flag2) + { + XSingleton.singleton.ABManager.DeleteBundleCount(); + } + } + this.bundle = null; + } + } +} -- cgit v1.1-26-g67d0