Exemplo n.º 1
0
    /// <summary>
    /// 载入资源
    /// </summary>
    private Resource LoadResource(string resPath, bool isDontUnload, bool isSprite = false, bool isAtlas = false)
    {
        Resource res;

        // 尝试获取已加载过的资源, 如果资源还没有加载过则直接加载
        if (!ResourceMap.TryGetValue(resPath, out res))
        {
            // 新建资源
            res = new Resource(resPath, isDontUnload);

            ResourceMap.Add(res.Path, res);
        }

        // 如果资源已经被成功载入了,直接返回资源
        if (res.State == Resource.STATE.LOADED)
        {
            res.LoadSuccessed();
            return(res);
        }

        // 判断是否是ab资源,如果不在版本树上则表示需要本地加载
        string bundle = VersionMgr.GetAssetBundleName(resPath);

        // 尝试载入资源
        try
        {
            // 如果是内部资源
            if (string.IsNullOrEmpty(bundle))
            {
                // 尝试载入资源,如果是编辑器模式则通过UnityEditor.AssetDatabase.LoadAssetAtPath载入
                // 否则通过Resources.Load载入
                if (Platform.IsEditor)
                {
                    // 编辑器测试阶段,直接加载即可
                    // 不是Sprite资源默认UnityEngine.Object
                    if (isSprite)
                    {
                        res.MainAsset = UnityEditor.AssetDatabase.LoadAssetAtPath <UnityEngine.Sprite>(resPath);
                    }
                    else if (isAtlas)
                    {
                        res.MainAsset = UnityEditor.AssetDatabase.LoadAssetAtPath <UIAtlas>(resPath);
                    }
                    else
                    {
                        res.MainAsset = UnityEditor.AssetDatabase.LoadAssetAtPath <UnityEngine.Object>(resPath);
                    }
                }
                else
                {
                    // 默认资源路径Assets/Prefabs/Model/m1011_d.prefab
                    // 最终的目标路径为Prefabs/Model/m1011_d.prefab
                    resPath = resPath.Replace(Path.GetExtension(resPath), string.Empty).Replace("Assets/", string.Empty);

                    // 编辑器测试阶段,直接加载即可
                    // 不是Sprite资源默认UnityEngine.Object
                    if (isSprite)
                    {
                        res.MainAsset = Resources.Load <UnityEngine.Sprite>(resPath);
                    }
                    else if (isAtlas)
                    {
                        res.MainAsset = Resources.Load <UIAtlas>(resPath);
                    }
                    else
                    {
                        res.MainAsset = Resources.Load(resPath);
                    }
                }
            }
            else
            {
                // 获取该bundle依赖资源
                AssetBundle ab;
                string[]    dependentBundles = GetDependentBundle(bundle);
                foreach (string name in dependentBundles)
                {
                    // 载入依赖ab资源
                    ab = LoadAssetBundle(name);

                    // 载入资源成功
                    if (ab == null)
                    {
                        continue;
                    }

                    // 添加资源管理列表
                    if (AB2ResourceMap.ContainsKey(name))
                    {
                        AB2ResourceMap[name].Add(res);
                    }
                    else
                    {
                        AB2ResourceMap[name] = new List <Resource>()
                        {
                            res
                        }
                    };

                    // 添加到资源依赖列表中
                    res.AssetBundles.Add(name);
                }

                // 载入AssetBundle资源
                ab = LoadAssetBundle(bundle);

                // 载入载入成功
                if (ab != null)
                {
                    // 添加资源管理列表
                    if (AB2ResourceMap.ContainsKey(bundle))
                    {
                        AB2ResourceMap[bundle].Add(res);
                    }
                    else
                    {
                        AB2ResourceMap[bundle] = new List <Resource>()
                        {
                            res
                        }
                    };

                    // 通过AssetBundle载入资源
                    if (isSprite)
                    {
                        res.MainAsset = ab.LoadAsset <UnityEngine.Sprite>(resPath);
                    }
                    else if (isAtlas)
                    {
                        res.MainAsset = ab.LoadAsset <UIAtlas>(resPath);
                    }
                    else
                    {
                        res.MainAsset = ab.LoadAsset(resPath);
                    }

                    // 添加到资源依赖列表中
                    res.AssetBundles.Add(bundle);
                }
            }
        }
        catch (Exception e)
        {
            // 给出异常提示信息
            NIDebug.LogException(e);
        }

        // 执行资源载入结果
        if (res.MainAsset != null)
        {
            res.LoadSuccessed();
        }
        else
        {
            res.LoadFaild();
        }

        // 返回资源
        return(res);
    }
Exemplo n.º 2
0
    /// <summary>
    /// 异步加载资源
    /// </summary>
    public IEnumerator LoadAsync(string resPath, bool isDontUnload = false, bool isSprite = false)
    {
        Resource res;

        // 尝试获取已加载过的资源, 如果资源还没有加载过则直接加载
        if (!ResourceMap.TryGetValue(resPath, out res))
        {
            // 新建资源
            res = new Resource(resPath, isDontUnload);
            ResourceMap.Add(res.Path, res);
        }

        // 如果资源已经被成功载入了,直接返回资源
        if (res.State == Resource.STATE.LOADED)
        {
            // 资源载入成功
            res.LoadSuccessed();
            yield break;
        }

        // 判断是否是ab资源,如果不在版本树上则表示需要本地加载
        string bundle = VersionMgr.GetAssetBundleName(resPath);

        // 如果是内部资源
        if (string.IsNullOrEmpty(bundle))
        {
            // 尝试载入资源,如果是编辑器模式则通过UnityEditor.AssetDatabase.LoadAssetAtPath载入
            // 否则通过Resources.Load载入
            if (Platform.IsEditor)
            {
                // 编辑器测试阶段,直接加载即可
                // 不是Sprite资源默认UnityEngine.Object
                if (!isSprite)
                {
                    res.MainAsset = UnityEditor.AssetDatabase.LoadAssetAtPath <UnityEngine.Object>(resPath);
                }
                else
                {
                    res.MainAsset = UnityEditor.AssetDatabase.LoadAssetAtPath <UnityEngine.Sprite>(resPath);
                }
            }
            else
            {
                // 资源异步加载
                ResourceRequest request = null;

                // 默认资源路径Assets/Prefabs/Model/m1011_d.prefab
                // 最终的目标路径为Prefabs/Model/m1011_d
                resPath = resPath.Replace(Path.GetExtension(resPath), string.Empty).Replace("Assets/", string.Empty);

                // 编辑器测试阶段,直接加载即可
                // 不是Sprite资源默认UnityEngine.Object
                if (!isSprite)
                {
                    request = Resources.LoadAsync(resPath);
                }
                else
                {
                    request = Resources.LoadAsync <UnityEngine.Sprite>(resPath);
                }

                // 等待资源加载完成
                yield return(request);

                // 获取asset资源对象
                res.MainAsset = request.asset;
            }
        }
        else
        {
            // 获取该bundle依赖资源
            AssetBundle ab;
            string[]    dependentBundles = GetDependentBundle(bundle);
            foreach (string name in dependentBundles)
            {
                // 载入依赖ab资源
                ab = LoadAssetBundle(name);

                // 载入资源成功
                if (ab == null)
                {
                    continue;
                }

                // 添加资源管理列表
                if (AB2ResourceMap.ContainsKey(name))
                {
                    AB2ResourceMap[name].Add(res);
                }
                else
                {
                    AB2ResourceMap[name] = new List <Resource>()
                    {
                        res
                    }
                };

                // 添加到资源依赖列表中
                res.AssetBundles.Add(name);
            }

            // 载入AssetBundle资源
            ab = LoadAssetBundle(bundle);

            // 载入载入成功
            if (ab != null)
            {
                // 添加资源管理列表
                if (AB2ResourceMap.ContainsKey(bundle))
                {
                    AB2ResourceMap[bundle].Add(res);
                }
                else
                {
                    AB2ResourceMap[bundle] = new List <Resource>()
                    {
                        res
                    }
                };

                // 添加到资源依赖列表中
                if (!res.AssetBundles.Contains(bundle))
                {
                    res.AssetBundles.Add(bundle);
                }

                // 异步载入资源
                AssetBundleRequest assetLoadRequest = null;
                if (!isSprite)
                {
                    assetLoadRequest = ab.LoadAssetAsync(resPath);
                }
                else
                {
                    assetLoadRequest = ab.LoadAssetAsync <UnityEngine.Sprite>(resPath);
                }

                // 等待资源载入完成
                yield return(assetLoadRequest);

                // 记录主要资源
                res.MainAsset = assetLoadRequest.asset;
            }
        }

        // 执行资源载入结果
        if (res.MainAsset != null)
        {
            res.LoadSuccessed();
        }
        else
        {
            res.LoadFaild();
        }
    }

    #endregion
}