public void Init(string assetPackageFile, string assetPackagePackage, string assetWeigthFile, string assetWeightPackage, GameObject resourceLoader, Manifest manifest) { /* * public void Init (ResourceLoader resourceLoader, Manifest manifest) * { */ Debug.Log("AssetPriManager Init"); _initialzed = InializedState.Initializing; isStartCoroutine = false; this._resourceLoaderObj = resourceLoader; this._manifest = manifest; this._assetPackageFile = ToAssetPriPath(assetPackageFile); this._assetPackagePackage = assetPackagePackage; this._assetWeightFile = ToAssetPriPath(assetWeigthFile); this._assetWeightPackage = assetWeightPackage; ResourceLoader resDl = _resourceLoaderObj.AddComponent <ResourceLoader> (); _assetPackageLoader = AssetLoaderManager.CreateLoader(_assetPackageFile, _assetPackagePackage); _assetWeightLoader = AssetLoaderManager.CreateLoader(_assetWeightFile, _assetWeightPackage); resDl.AddAssetLoader(_assetPackageLoader); resDl.AddAssetLoader(_assetWeightLoader); resDl.SetProgressDelegate(InitCallBack, null, true); }
public Callback <AssetBundle[], int> LoadUI(string module) { string bytesAbPath = AssetFileBook.GetUIPath(string.Format("{0}_fgui", module)); string textureAbPath = AssetFileBook.GetUIPath(string.Format("{0}_altas", module)); var callback = Callback <AssetBundle[], int> .GetOrNew(); AssetLoaderManager.GetInstance().LoadAssetSync <AssetBundle>(bytesAbPath, (bytesAb) => { AssetLoaderManager.GetInstance().LoadAssetSync <AssetBundle>(textureAbPath, (altasAb) => { callback?.onSuccess?.Invoke(new AssetBundle[] { bytesAb, altasAb }); }, (altasBytes) => { if (bytesAb != null) { callback?.onSuccess?.Invoke(new AssetBundle[] { bytesAb, null }); } else { callback?.onFailed?.Invoke(altasBytes); } }); }, (reasonBytes) => { callback?.onFailed?.Invoke(reasonBytes); }); return(callback); }
public static void Init() { AssetLoaderMgr = UnitySingleton <AssetLoaderManager> .Ins; NetMgr = UnitySingleton <NetworkManager> .Ins; UIMgr = UnitySingleton <UIManager> .Ins; AudioMgr = UnitySingleton <AudioManager> .Ins; LuaMgr = UnitySingleton <LuaManager> .Ins; }
/// <summary> /// 加载技能预制体 /// </summary> /// <param name="prefabName"></param> /// <returns></returns> private GameObject LoadPrefab(string prefabName) { //加载到预制体 var prefab = AssetLoaderManager.LoadAsset <GameObject>("uis/effect", prefabName); //通过对象池进行创建 var skillGO = GameObjectPool.Instance.CreateObject(prefabName, prefab, Vector3.zero, Quaternion.identity); //回收物体 GameObjectPool.Instance.CollectObject(skillGO); return(prefab); }
/// <summary> /// Releases all resource used by the <see cref="ResourceManager"/> object. /// </summary> /// <remarks> /// Call <see cref="Dispose"/> when you are finished using the <see cref="ResourceManager"/>. The <see cref="Dispose"/> /// method leaves the <see cref="ResourceManager"/> in an unusable state. After calling <see cref="Dispose"/>, you must /// release all references to the <see cref="ResourceManager"/> so the garbage collector can reclaim the memory that /// the <see cref="ResourceManager"/> was occupying. /// </remarks> public static void Dispose() { _initialzed = EInializedState.NotInitialized; GameObject.Destroy(_downloadObject); _manifest = null; _manifestFile = ""; _manifestPackage = ""; //_assetPriFile = ""; //_assetPriPackage = ""; // _assetPri = null; _pendingTask.Clear(); AssetLoaderManager.DestroyAllLoaders(); }
public Callback <GameObject, int> LoadSprite(string uid) { string assetPath = AssetFileBook.GetSpritePath(uid); var callback = Callback <GameObject, int> .GetOrNew(); AssetLoaderManager.GetInstance().LoadAssetAsync <GameObject>(assetPath, (obj) => { callback.onSuccess?.Invoke(obj); }, (reason) => { callback.onFailed?.Invoke(reason); }); return(callback); }
public string LoadConfig(string fileName) { string content = null; string assetPath = AssetFileBook.GetConfigPath(fileName); var callback = Callback <string, int> .GetOrNew(); AssetLoaderManager.GetInstance().LoadAssetSync <TextAsset>(assetPath, (textAsset) => { content = textAsset.text; }, (reason) => { callback.onFailed?.Invoke(reason); }); return(content); }
IEnumerator InvokeDelegate(float progress) { _isCoroutineRun = true; yield return(new WaitForSeconds(0.1f)); _progressDelegate(progress, _prgDlgtUserData); yield return(new WaitForSeconds(0.1f)); foreach (AssetLoader assetLoader in _assetLoaders.Values) { AssetLoaderManager.DestroyLoader(assetLoader); } GameObject.Destroy(this); }
/// <summary> /// Load the specified asset object. /// The Load Method will be invoke in update thread /// </summary> /// <param name='assetFile'> /// Asset file. /// </param> public static void Load(string assetFile, out float progress, out Object loadObj, out bool isDone) { if (_initialzed != EInializedState.Initialized) { progress = 0F; loadObj = null; isDone = false; return; } /* * if (assetFile.StartsWith ("resources/")) { * assetFile = PathUtil.RemoveLocalFlag (assetFile); * progress =1.0F; * loadObj = Resources.Load (assetFile); * return; * } */ progress = 0F; loadObj = null; isDone = false; if (_assetLoader != null) { /* * if (_assetLoader.Progress >= 1.0F) { * loadObj = _assetLoader.Load (); * _assetLoader = null; * }else{ * loadObj = null; * } * progress = _assetLoader.Progress; */ progress = _assetLoader.Progress; isDone = _assetLoader.IsDone; if (isDone) { loadObj = _assetLoader.Load(); _assetLoader = null; } } else { assetFile = PathUtil.UnifyPath(assetFile); _assetLoader = AssetLoaderManager.CreateLoader(ToManifestPath(assetFile), _manifest); } }
public static Object LoadAfterDownLoad(string assetFile) { if (_initialzed != EInializedState.Initialized) { return(null); } assetFile = PathUtil.UnifyPath(assetFile); AssetLoader assetLoader = AssetLoaderManager.CreateLoader(ToManifestPath(assetFile), _manifest); if (assetLoader.Progress >= 1.0F) { return(assetLoader.Load()); } else { return(null); } }
/// <summary> /// Initialize the manager with pecified basePath, manifestPackage and manifestFile. /// Before download asset, manager needs to be initialzed firstly. /// /// </summary> /// <param name='basePath'> /// Game resources base url path. /// </param> /// <param name='manifestPackage'> /// Manifest package file name. /// </param> /// <param name='manifestFile'> /// Manifest file name. /// </param> public static void Initialize(string basePath, string manifestFile, string manifestPackage, string assetPackageFile, string assetPackagePackage, string assetWeightFile, string assetWeightPackage) { Debug.Log("Resource Manager Init "); if (_initialzed != EInializedState.NotInitialized) { return; } //PlayerPrefs.DeleteAll(); //PlayerPrefs.SetInt("PlayerLevel",1); _initialzed = EInializedState.Initializing; WwwLoaderManager.BasePath = basePath; _manifestFile = ToManifestPath(manifestFile); _manifestPackage = manifestPackage; _assetPackageFile = assetPackageFile; _assetPackagePackage = assetPackagePackage; _assetWeightFile = assetWeightFile; _assetWeightPackage = assetWeightPackage; //_assetPriFile = ToManifestPath (assetPriFile); //_assetPriPackage = assetPriPackage; _downloadObject = new GameObject("ResourceLoader"); _resourceLoader = _downloadObject.AddComponent <ResourceLoader> (); AssetLoader assetLoaderManifest = AssetLoaderManager.CreateLoader(_manifestFile, _manifestPackage); //AssetLoader assetLoaderAssetPri = AssetLoaderManager.CreateLoader (_assetPriFile, _assetPriPackage); List <AssetLoader> assetLoaderList = new List <AssetLoader>(); assetLoaderList.Add(assetLoaderManifest); //assetLoaderList.Add(assetLoaderAssetPri); _resourceLoader.SetProgressDelegate(InitializeCallback, assetLoaderList, true); _resourceLoader.AddAssetLoader(AssetLoaderManager.CreateLoader(_manifestFile, _manifestPackage)); //_resourceLoader.AddAssetLoader (AssetLoaderManager.CreateLoader (_assetPriFile, _assetPriPackage)); }
/// <summary> /// Download the specified assets. /// </summary> /// <param name='dlObject'> /// The download object which affact the downloading task. /// The task can be canceled by destroying this download object. /// </param> /// <param name='prgDelegate'> /// Prgogress delegate to be callback after downloaded. /// </param> /// <param name='prgUserData'> /// Prgogress delegate user data. /// </param> /// <param name='assetFiles'> /// Asset files. /// </param> public static void Download(GameObject dlObject, DownloadDelegate prgDelegate, System.Object prgUserData, bool isReturnPerFrame, params string [] assetFiles) { if (assetFiles.Length == 0) { return; } if (_initialzed != EInializedState.Initialized) { DownloadTask dlTask = new DownloadTask(); dlTask.DownloadObect = dlObject; dlTask.ProgressFunction = prgDelegate; dlTask.ProgressUserData = prgUserData; foreach (string assetFile in assetFiles) { dlTask.AssetFiles.Add(assetFile); } _pendingTask.Add(dlTask); return; } if (dlObject == null) { dlObject = _downloadObject; } ResourceLoader resDl = dlObject.AddComponent <ResourceLoader> (); resDl.SetProgressDelegate(prgDelegate, prgUserData, isReturnPerFrame); foreach (string assetFile in assetFiles) { resDl.AddAssetLoader(AssetLoaderManager.CreateLoader(ToManifestPath(assetFile), _manifest)); } }
static int _m_LoadAsset_xlua_st_(RealStatePtr L) { try { ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); { string _bundleName = LuaAPI.lua_tostring(L, 1); string _assetName = LuaAPI.lua_tostring(L, 2); System.Type _type = (System.Type)translator.GetObject(L, 3, typeof(System.Type)); UnityEngine.Object gen_ret = AssetLoaderManager.LoadAsset(_bundleName, _assetName, _type); translator.Push(L, gen_ret); return(1); } } catch (System.Exception gen_e) { return(LuaAPI.luaL_error(L, "c# exception:" + gen_e)); } }
private void Start() { string assetPath = AssetFileBook.GetBundleMainfest(); AssetLoaderManager.GetInstance().LoadBundleMainfest(assetPath); }