/// <summary>
    /// 加载bundle
    /// </summary>
    /// <param name="loadBundleInfo"></param>
    private static void LoadAssetBundle(LoadBundleInfo loadBundleInfo)
    {
        EnterLoading(loadBundleInfo);
        AssetBundleCreateRequest abRequest = AssetBundle.LoadFromFileAsync(ResourceUtils.bundleRootPath + loadBundleInfo.bundleName);

        loadBundleInfo.request = abRequest;
    }
    /// <summary>
    /// 检测加载是否完成
    /// </summary>
    private static void CheckLoad()
    {
        List <LoadBundleInfo> loadingLoadBundleInfoList = GetLoadBundleStateList(LoadBundleStep.Loading);

        // 反向检测 依赖先检测
        for (int i = loadingLoadBundleInfoList.Count - 1; i >= 0; i--)
        {
            LoadBundleInfo loadBundleInfo = loadingLoadBundleInfoList[i];
            if (!loadBundleInfo.request.isDone)
            {
                continue;
            }

            if (loadBundleInfo.assetBundle == null)
            {
                AssetBundle assetBundle = loadBundleInfo.request.assetBundle;
                loadBundleInfo.assetBundle = assetBundle;
                ReferenceBundle.AddBundle(loadBundleInfo.bundleName, assetBundle);
            }

            // 递归检测依赖是否加载完成
            if (RecursiveCheckLoad(loadBundleInfo.bundleName))
            {
                EnterWaitCall(loadBundleInfo);
                // 加载成功一个bundle之后 从等待列表中释放一个 维持每帧加载上线
                List <LoadBundleInfo> loadWaitBundleInfoList = GetLoadBundleStateList(LoadBundleStep.LoadWait);
                if (loadWaitBundleInfoList.Count > 0)
                {
                    LoadAssetBundle(loadWaitBundleInfoList[0]);
                }
            }
        }
    }
    /// <summary>
    /// 获取某状态的列表
    /// </summary>
    /// <param name="step">状态</param>
    /// <returns></returns>
    private static List <LoadBundleInfo> GetLoadBundleStateList(LoadBundleStep step, bool isDelete = false)
    {
        List <string> indexList = new List <string>();

        foreach (string bundleName in _loadBundleInfoList.Keys)
        {
            LoadBundleInfo loadBundleInfo = _loadBundleInfoList[bundleName];
            if (loadBundleInfo.step == step)
            {
                indexList.Add(bundleName);
            }
        }

        List <LoadBundleInfo> list = new List <LoadBundleInfo>();

        foreach (string bundleName in indexList)
        {
            list.Add(_loadBundleInfoList[bundleName]);
            if (isDelete)
            {
                _loadBundleInfoList.Remove(bundleName);
            }
        }

        return(list);
    }
 /// <summary>
 /// 加载成功后回调状态
 /// </summary>
 /// <param name="loadBundleInfo"></param>
 private static void EnterWaitCall(LoadBundleInfo loadBundleInfo)
 {
     loadBundleInfo.step = LoadBundleStep.WaitCall;
     if (ResourceManager.isLog)
     {
         Debug.Log("[load assetbundle] step 3 EnterWaitCall : " + loadBundleInfo.bundleName);
     }
 }
 /// <summary>
 /// 进入加载状态 包括依赖加载
 /// </summary>
 /// <param name="loadBundleInfo"></param>
 private static void EnterLoading(LoadBundleInfo loadBundleInfo)
 {
     loadBundleInfo.step = LoadBundleStep.Loading;
     if (ResourceManager.isLog)
     {
         Debug.Log("[load assetbundle] step 2 EnterLoading : " + loadBundleInfo.bundleName);
     }
 }
예제 #6
0
 /// <summary>
 /// 进入加载等待状态
 /// </summary>
 /// <param name="loadBundleInfo"></param>
 private static void EnterLoadWait(LoadBundleInfo loadBundleInfo)
 {
     loadBundleInfo.step = LoadBundleStep.LoadWait;
     if (ResourceUtil.isLog)
     {
         Debug.Log("[load assetbundle] step 1 EnterLoadWait : " + loadBundleInfo.bundleName);
     }
 }
    /// <summary>
    /// 加载成功会回调
    /// </summary>
    private static void CheckWaitCall()
    {
        List <LoadBundleInfo> waitCallLoadBundleInfoList = GetLoadBundleStateList(LoadBundleStep.WaitCall, true);

        // 反向操作 依赖先回调
        for (int i = waitCallLoadBundleInfoList.Count - 1; i >= 0; i--)
        {
            LoadBundleInfo loadBundleInfo = waitCallLoadBundleInfoList[i];
            loadBundleInfo.CallCreateAssetBundle();
            RecoveryLoadBundleInfo(loadBundleInfo);
        }
    }
    private static void RecoveryLoadBundleInfo(LoadBundleInfo loadBundleInfo)
    {
        if (loadBundleInfo == null)
        {
            return;
        }

        if (_loadBundleInfoList.ContainsKey(loadBundleInfo.bundleName))
        {
            _loadBundleInfoList.Remove(loadBundleInfo.bundleName);
        }

        loadBundleInfo.Clear();
        _freeLoadBundleInfoList.Add(loadBundleInfo);
    }
    private static LoadBundleInfo GetTempLoadBundleInfo()
    {
        LoadBundleInfo loadBundleInfo;

        if (_freeLoadBundleInfoList.Count > 0)
        {
            loadBundleInfo = _freeLoadBundleInfoList[0];
            _freeLoadBundleInfoList.RemoveAt(0);
        }
        else
        {
            loadBundleInfo = new LoadBundleInfo();
        }

        return(loadBundleInfo);
    }
    /// <summary>
    /// 异步加载bundle
    /// </summary>
    /// <param name="bundleName">bundle路径</param>
    /// <param name="onCreateAssetBundle">加载成功后的回调 取消加载后将回调将失效</param>
    /// <returns></returns>
    public static int CreateAssetBundleAsync(int requestId, string bundleName, OnCreateAssetBundle onCreateAssetBundle)
    {
        // 回调不存在不允加载
        if (onCreateAssetBundle == null)
        {
            return(0);
        }

        LoadBundleInfo loadBundleInfo = GetLoadBundleInfo(bundleName);

        if (loadBundleInfo == null)
        {
            loadBundleInfo = GetTempLoadBundleInfo();
            _loadBundleInfoList.Add(bundleName, loadBundleInfo);
            loadBundleInfo.bundleName = bundleName;
            EnterLoadWait(loadBundleInfo);
        }

        requestId = loadBundleInfo.CreateBundleRequest(requestId, onCreateAssetBundle);
        // 未请求
        if (loadBundleInfo.step == LoadBundleStep.LoadWait)
        {
            // 1 获取依赖列表
            List <string> dependencies = BundleDependencies.GetAssetBundleDependencies(bundleName);
            // 2 递归请求加载
            if (dependencies != null && dependencies.Count > 0)
            {
                foreach (string tempBundleName in dependencies)
                {
                    CreateAssetBundleAsync(requestId, tempBundleName, (string tBundleName, AssetBundle tAssetBundle, int tRequestId) => {
                        // 回调返回会增加引用 所以这里直接释放
                        ReferenceBundle.ReleaseBundle(tBundleName);
                    });
                }
            }
            // 3 正加载列表
            List <LoadBundleInfo> loadingBundleInfoList = GetLoadBundleStateList(LoadBundleStep.Loading);
            if (loadingBundleInfoList.Count < _frameLoadMaxCount)
            {
                LoadAssetBundle(loadBundleInfo);
            }
        }

        return(requestId);
    }
 /// <summary>
 /// 加载成功后回调状态
 /// </summary>
 /// <param name="loadBundleInfo"></param>
 private static void EnterWaitCall(LoadBundleInfo loadBundleInfo)
 {
     loadBundleInfo.step = LoadBundleStep.WaitCall;
     Debug.Log("[load assetbundle] step 3 EnterWaitCall : " + loadBundleInfo.bundleName);
 }
 /// <summary>
 /// 进入加载状态 包括依赖加载
 /// </summary>
 /// <param name="loadBundleInfo"></param>
 private static void EnterLoading(LoadBundleInfo loadBundleInfo)
 {
     loadBundleInfo.step = LoadBundleStep.Loading;
     Debug.Log("[load assetbundle] step 2 EnterLoading : " + loadBundleInfo.bundleName);
 }
 /// <summary>
 /// 进入加载等待状态
 /// </summary>
 /// <param name="loadBundleInfo"></param>
 private static void EnterLoadWait(LoadBundleInfo loadBundleInfo)
 {
     loadBundleInfo.step = LoadBundleStep.LoadWait;
     Debug.Log("[load assetbundle] step 1 EnterLoadWait : " + loadBundleInfo.bundleName);
 }
 private static void RecoveryLoadBundleInfo(LoadBundleInfo loadBundleInfo)
 {
     loadBundleInfo.Clear();
     _freeLoadBundleInfoList.Add(loadBundleInfo);
 }