/// <summary>
        /// 回收一个资源,针对SceneMgr
        /// </summary>
        protected void DestoryResourceItemScene(ResourceItem item, bool destoryCache = true)
        {
            if (item == null || item.RefCount > 0)
            {
                ZLogger.Error("针对场景的释放,不应该有引用大于0的情况");
                return;
            }
            if (!SceneAssetDic.Remove(item.m_Crc))
            {
                return;
            }
            //释放assetbundel引用
            AssetBundleMgr.Instance.ReleaseAsset(item);
            if (item.m_Obj != null)
            {
                item.m_Obj = null;
#if UNITY_EDITOR
                Resources.UnloadUnusedAssets();
#endif
            }
        }
示例#2
0
        /// <summary>
        /// 根据路径的CRC加载中间类resourceItem
        /// </summary>
        /// <param name="crc"></param>
        /// <returns></returns>
        public ResourceItem LoadResourceAssetBundle(uint crc)
        {
            ResourceItem item = null;

            if (!m_ResourceItemDic.TryGetValue(crc, out item) || item == null)
            {
                ZLogger.Error("LoadResourceAssetBundle can not find crc {0}  in assetbundleconfig", crc.ToString());
                return(item);
            }
            if (item.m_AssetBundel != null)
            {
                return(item);
            }
            item.m_AssetBundel = LoadAssetBundle(item.m_ABName);

            if (item.m_DependenAssetBundle != null)
            {
                for (int i = 0; i < item.m_DependenAssetBundle.Count; i++)
                {
                    LoadAssetBundle(item.m_DependenAssetBundle[i]);
                }
            }
            return(item);
        }
        /// <summary>
        /// 异步加载
        /// </summary>
        IEnumerator AsyncLoadCor()
        {
            List <ResMgrAsyncCallBack> callBackList = null;
            //上一次yield的时间
            long lastYieldTime = System.DateTime.Now.Ticks;

            while (true)
            {
                bool haveYieldBoo = false;
                for (int i = 0; i < (int)LoadResPriority.RES_NUM; i++)
                {
                    if (m_LoadingAssetList[(int)LoadResPriority.RES_HIGHT].Count > 0)
                    {
                        i = (int)LoadResPriority.RES_HIGHT;
                    }
                    else if (m_LoadingAssetList[(int)LoadResPriority.RES_MIDDLE].Count > 0)
                    {
                        i = (int)LoadResPriority.RES_MIDDLE;
                    }

                    List <AsynvLoadResParam> loadingList = m_LoadingAssetList[i];
                    if (loadingList.Count <= 0)
                    {
                        continue;
                    }
                    AsynvLoadResParam loadingItem = loadingList[0];
                    loadingList.RemoveAt(0);
                    callBackList = loadingItem.m_CallBackList;

                    Object       obj  = null;
                    ResourceItem item = null;
#if UNITY_EDITOR
                    if (AppConst.DebugMode)
                    {
                        if (loadingItem.m_SpriteBoo)
                        {
                            obj = LoadAssetByEditor <Sprite>(loadingItem.m_Path);
                        }
                        else
                        {
                            obj = LoadAssetByEditor <Object>(loadingItem.m_Path);
                        }
                        //模拟异步加载
                        yield return(new WaitForSeconds(0.5f));

                        item = AssetBundleMgr.Instance.FindResourceItem(loadingItem.m_Crc);
                        if (item == null)
                        {
                            item       = new ResourceItem();
                            item.m_Crc = loadingItem.m_Crc;
                        }
                    }
#endif
                    if (obj == null)
                    {
                        item = AssetBundleMgr.Instance.LoadResourceAssetBundle(loadingItem.m_Crc);
                        if (item != null && item.m_AssetBundel != null)
                        {
                            AssetBundleRequest abRequest = null;
                            if (loadingItem.m_SpriteBoo)
                            {
                                abRequest = item.m_AssetBundel.LoadAssetAsync <Sprite>(item.m_AssetName);
                            }
                            else
                            {
                                abRequest = item.m_AssetBundel.LoadAssetAsync(item.m_AssetName);
                            }
                            yield return(abRequest);

                            if (abRequest.isDone)
                            {
                                obj = abRequest.asset;
                            }
                            lastYieldTime = System.DateTime.Now.Ticks;
                        }
                    }
                    CacheResource(loadingItem.m_Path, ref item, loadingItem.m_Crc, obj, callBackList.Count);

                    for (int j = 0; j < callBackList.Count; j++)
                    {
                        ResMgrAsyncCallBack callBack = callBackList[j];

                        if (callBack != null && callBack.m_ObjDealFinish != null && callBack.m_ResObj != null)
                        {
                            ResourceObj tempResObj = callBack.m_ResObj;
                            tempResObj.m_ResItem = item;
                            callBack.m_ObjDealFinish(loadingItem.m_Path, tempResObj, tempResObj.m_Param1, tempResObj.m_Param2, tempResObj.m_Param3);
                            callBack.m_ObjDealFinish = null;
                            tempResObj = null;
                        }

                        if (callBack != null && callBack.m_ResDealFinish != null)
                        {
                            callBack.m_ResDealFinish(loadingItem.m_Path, obj, callBack.m_Param1, callBack.m_Param2, callBack.m_Param3);
                            callBack.m_ResDealFinish = null;
                        }
                        callBack.Reset();
                        m_AsyncCallBackPool.Recycle(callBack);
                    }

                    obj = null;
                    callBackList.Clear();
                    m_LodingAssetDic.Remove(loadingItem.m_Crc);

                    loadingItem.Reset();
                    m_AsyncLoadResParamPool.Recycle(loadingItem);

                    if (System.DateTime.Now.Ticks - lastYieldTime > MAXLOADRESTIME)
                    {
                        yield return(null);

                        lastYieldTime = System.DateTime.Now.Ticks;
                        haveYieldBoo  = true;
                    }
                }

                if (!haveYieldBoo || System.DateTime.Now.Ticks - lastYieldTime > MAXLOADRESTIME)
                {
                    lastYieldTime = System.DateTime.Now.Ticks;
                    yield return(null);
                }
            }
        }