RoApp/Assets/Src/Core/Resource/ResourceMgr.cs

using UnityEngine;
using System.IO;
using System.Collections.Generic;
using UnityEngine.Playables;
using UnityEngine.Video;
using LuaInterface;

public delegate void ResourceLoadCallback<T>(T o, string assetPath, params string[] assetNames);

public delegate void ResourceLoadCallbackWithSeqId<T>(T o, long seqId,string assetPath,object[] userdatas, params string[] assetNames);

public class ResourceInfo
{
    private string path;
    private string name;
    private Object asset;
    private float lastUsedTime;

    public string Path
    {
        get { return path; }
    }

    public string Name
    {
        get { return name; }
    }

    public Object Asset
    {
        get { return asset; }
    }

    public float LastUsedTime
    {
        get { return lastUsedTime; }
        set
        {
            lastUsedTime = value;
        }
    }

    public ResourceInfo(string path_, string name_, Object asset_)
    {
        path = path_;
        name = name_;
        asset = asset_;
        lastUsedTime = Time.time;
    }

    public Object Reuse()
    {
        lastUsedTime = Time.time;
        return asset;
    }

    public void Dispose()
    {
        asset = null;
    }
}

public class LoadingResourceInfo
{
    System.Type delegateType;
    public System.Type DelegateType
    {
        get { return delegateType; }
    }

    System.Delegate callback;
    public System.Delegate Callback
    {
        get { return callback; }
    }

    string assetPath;
    public string AssetPath
    {
        get { return assetPath; }
    }

    string assetName;
    public string AssetName
    {
        get { return assetName; }
    }

    string[] assetNames;
    public string[] AssetNames
    {
        get { return assetNames; }
    }

    long mSeqId = 0;
    public long SeqId
    {
        get { return mSeqId; }
    }

    bool mReturnSeqId = false;
    public bool ReturnSeqId
    {
        get { return mReturnSeqId; }
    }

    int mLoadNum = 0;
    public int LoadCBNum
    {
        get { return mLoadNum; }
        set { mLoadNum = value; }
    }

    public object[] userDatas;

    public LoadingResourceInfo(long seqId, string path_, System.Delegate callback_, System.Type delegateType_, bool returnSeq,params string[] assetNames_)
    {
        mSeqId = seqId;
        assetPath = path_;
        callback = callback_;
        assetNames = assetNames_;
        delegateType = delegateType_;
        mReturnSeqId = returnSeq;
    }

    public void Dispose()
    {
        callback = null;
        assetNames = null;
    }
}

public class ResourceMgr : Singleton<ResourceMgr>
{
    long loadingSeqId = 0;

    //对象池
   Dictionary<string, Dictionary<string, GameObjectPool<GameObject>> > assetsPool = new Dictionary<string, Dictionary<string, GameObjectPool<GameObject>>>();

    //已加载的资源列表
    List<ResourceInfo> loadedResources = new List<ResourceInfo>();

    //正在加载的资源
    List<LoadingResourceInfo> loadingResources = new List<LoadingResourceInfo>();

    const float check_internal = 60;

    const float cache_Time = 300;

    float lastCheckTime = 0;

    [NoToLua]
    public override void Init()
    {
        lastCheckTime = Time.time;
    }

    [NoToLua]
    public override void UnInit()
    {
        ClearAllResource();
    }

    private GameObject mPoolGo = null;
    public Transform PoolNode
    {
        get
        {

            if (mPoolGo == null)
            {
                mPoolGo = new GameObject("PoolRoot");
                if (GameMgr.Instance != null) { 
                    mPoolGo.transform.SetParent(GameMgr.Instance.transform);
                }
                mPoolGo.SetActive(false);
            }

            return mPoolGo.transform;
        }
    }
    #region outer_methods
    //已经在的资源个数
    [NoToLua]
    public int LoadedResourceCnt
    {
        get { return loadedResources.Count; }
    }

    //正在加载的资源个数
    [NoToLua]
    public int LoadingResourceCnt
    {
        get { return loadingResources.Count; }
    }

    [NoToLua]
    public GameObject GetGOFromResources(string assetName)
    {
        GameObject prefab = LoadObjFromResources<GameObject>(assetName);
        if (prefab == null) return null;
        //DebugHelper.LogError("AssetName " + assetName);
        return GameObject.Instantiate(prefab);
    }

    [NoToLua]
    public T LoadObjFromResources<T>(string assetName) where T : UnityEngine.Object
    {
        return AssetsMgr.Instance.GetAssetFromResources<T>(assetName);
    }

    [NoToLua]
    public void LoadLuaAsset(ResourceLoadCallback<List<TextAsset>> cb, string pathName)
    {
        loadingSeqId++;
        LoadingResourceInfo lri = new LoadingResourceInfo(loadingSeqId, pathName, cb as System.Delegate, typeof(List<TextAsset>), false, null);
        loadingResources.Add(lri);

        lri.LoadCBNum =  AssetsMgr.Instance.GetAsset<List<TextAsset>>(OnLoadDirAssetallback, ELoadType.OTHER, loadingSeqId, pathName);
    }

    [NoToLua]
    public void LoadDirAsset<T>(ResourceLoadCallback<T> cb, string pathName, ELoadType type = ELoadType.OTHER)
    {
        if (string.IsNullOrEmpty(pathName)) return;

        if (ExistAssetPath(pathName))
        {
            FinishResourceLoad(cb, typeof(T), pathName, null,false,0,null);
            return;
        }

        loadingSeqId++;
        LoadingResourceInfo lri = new LoadingResourceInfo(loadingSeqId, pathName, cb as System.Delegate, typeof(T), false,null);
        loadingResources.Add(lri);

        lri.LoadCBNum = AssetsMgr.Instance.GetAsset<T>(OnLoadDirAssetallback, type, loadingSeqId, pathName);
    }

    #region methods_for_lua
    public long LoadAssetSprite(string pathName, ELoadType type, ResourceLoadCallbackWithSeqId<Sprite> cb, params string[] assetNames)
    {
        return LoadAsset(cb, pathName, type, null,assetNames);
    }

    public long LoadAssetSprites(string pathName, ELoadType type, ResourceLoadCallbackWithSeqId<List<Sprite>> cb, params string[] assetNames)
    {
        return LoadAsset(cb, pathName, type, null, assetNames);
    }

    public long LoadAssetSpriteWithUserData(string pathName, ELoadType type,object[] userDatas, ResourceLoadCallbackWithSeqId<Sprite> cb, params string[] assetNames)
    {
        return LoadAsset(cb, pathName, type, userDatas,assetNames);
    }

    public long LoadAssetGameObject(string pathName, ELoadType type, ResourceLoadCallbackWithSeqId<GameObject> cb, params string[] assetNames)
    {
        return LoadAsset(cb, pathName, type, null,assetNames);
    }

    public long LoadAssetGameObjectWithUserData(string pathName, ELoadType type, object[] userDatas, ResourceLoadCallbackWithSeqId<GameObject> cb, params string[] assetNames)
    {
        return LoadAsset(cb, pathName, type,userDatas ,assetNames);
    }

    public long LoadAssetGameObjects(string pathName, ELoadType type, ResourceLoadCallbackWithSeqId<List<GameObject>> cb, params string[] assetNames)
    {
        return LoadAsset(cb, pathName, type,null, assetNames);
    }

    public long LoadAssetGameObjectsWithUserData(string pathName, ELoadType type, object[] userDatas, ResourceLoadCallbackWithSeqId<List<GameObject>> cb, params string[] assetNames)
    {
        return LoadAsset(cb, pathName, type, userDatas, assetNames);
    }

    public long LoadAssetRuntimeAnimatorControllers(string pathName, ELoadType type, ResourceLoadCallbackWithSeqId<List<RuntimeAnimatorController>> cb, params string[] assetNames)
    {
        return LoadAsset(cb, pathName, type,null, assetNames);
    }

    public long LoadAssetRuntimeAnimatorControllersWithUserData(string pathName, ELoadType type, object[] userDatas, ResourceLoadCallbackWithSeqId<List<RuntimeAnimatorController>> cb, params string[] assetNames)
    {
        return LoadAsset(cb, pathName, type, userDatas,assetNames);
    }

    public long LoadAssetMaterial(string pathName, ELoadType type, ResourceLoadCallbackWithSeqId<Material> cb, params string[] assetNames)
    {
        return LoadAsset(cb, pathName, type, null,assetNames);
    }

    public long LoadAssetMaterialWithUserData(string pathName, ELoadType type, object[] userDatas, ResourceLoadCallbackWithSeqId<Material> cb, params string[] assetNames)
    {
        return LoadAsset(cb, pathName, type, userDatas, assetNames);
    }

    public long LoadAssetTexture(string pathName, ELoadType type, ResourceLoadCallbackWithSeqId<Texture2D> cb, params string[] assetNames)
    {
        return LoadAsset(cb, pathName, type, null, assetNames);
    }

    public long LoadAssetTextureWithUserData(string pathName, ELoadType type, object[] userDatas, ResourceLoadCallbackWithSeqId<Texture2D> cb, params string[] assetNames)
    {
        return LoadAsset(cb, pathName, type, userDatas, assetNames);
    }

    public long LoadAsset<T>(ResourceLoadCallbackWithSeqId<T> cb, string pathName, ELoadType type, object[] userDatas, params string[] assetNames)
    {
        return Inner_LoadAsset(cb, pathName, assetNames, type, userDatas);
    }

    public Sprite FindSpriteByPathAndName(string pathName, string assetName)
    {
        return FindAssetByPathAndName<Sprite>(pathName, assetName);
    }

    #endregion

    public long LoadAsset<T>(ResourceLoadCallback<T> cb, string pathName, ELoadType type, params string[] assetNames)
    {
        return Inner_LoadAsset(cb, pathName, assetNames, type);
    }

    public long LoadAsset<T>(ResourceLoadCallback<T> cb, string pathName, params string[] assetNames)
    {
        return Inner_LoadAsset(cb, pathName, assetNames, ELoadType.OTHER);
    }

    public Object[] LoadABSync(string pathName, params string[] assetNames)
    {
        return AssetsMgr.Instance.LoadABSync(pathName, assetNames);
    }

    public T LoadAssetSync<T>(string assetPath, string assetName) where T : UnityEngine.Object
    {
        T ret = null;
        Object obj = FindAssetByPathAndName(assetPath, assetName);
        if (obj == null)
        {
            ret = AssetsMgr.Instance.LoadAssetSync<T>(assetPath, assetName);
            ResourceInfo ri = new ResourceInfo(assetPath, assetName, ret);
            loadedResources.Add(ri);
        }
        else
        {
            ret = obj as T;
        }

        return ret;
    }

    /// <summary>
    /// 从对象池中获取对象
    /// </summary>
    /// <param name="assetsPath"></param>
    /// <param name="assetsName"></param>
    /// <param name="action"></param>
    public long GetGOFromPool(string assetsPath, string assetsName, System.Action<GameObject> action = null)
    {
        if (action == null || string.IsNullOrEmpty(assetsName)) return 0;

        if(!string.IsNullOrEmpty(assetsPath))
        {
            Dictionary<string, GameObjectPool<GameObject>> mDirGoPool;
            if (assetsPool.TryGetValue(assetsPath, out mDirGoPool))
            {
                GameObjectPool<GameObject> curPool = null;
                mDirGoPool.TryGetValue(assetsName, out curPool);
                if (curPool == null)
                {
                    curPool = new GameObjectPool<GameObject>();
                    mDirGoPool.Add(assetsName, curPool);
                }
                GameObject go = curPool.Spawn();
                if (go != null)
                {
                    action(go);
                    return 0;
                }
            }
        }

        ResourceLoadCallback<GameObject> callBack = (prefab, path_, assetName_) =>
        {
            if (null == prefab)
            {
                if (action != null)
                    action(null);
                return;
            }


            if (action != null)
            {
                GameObject goInst = GameObject.Instantiate(prefab);
                goInst.transform.localPosition = Vector3.zero;
                goInst.transform.localScale = Vector3.one;
                goInst.name = assetsName;
                action(goInst);
            }
        };
        return LoadAsset<GameObject>(callBack, assetsPath, assetsName);
    }

    
    public long GetGoesFromPool(string assetsPath,string[] assetsNames, ResourceLoadCallback<List<GameObject>> cb)
    {
        if (cb == null || string.IsNullOrEmpty(assetsPath) || assetsNames == null || assetsNames.Length == 0) return 0;

        Dictionary<string, GameObjectPool<GameObject>> mDirGoPool;
        if (assetsPool.TryGetValue(assetsPath, out mDirGoPool))
        {
            List<GameObject> goList = new List<GameObject>();
            int cnt = 0;
            GameObjectPool<GameObject> curPool = null;
            for(int idx =0; idx < assetsNames.Length;idx++)
            {
                mDirGoPool.TryGetValue(assetsNames[idx], out curPool);
                if (curPool == null)
                {
                    curPool = new GameObjectPool<GameObject>();
                    mDirGoPool.Add(assetsNames[idx], curPool);
                }
                GameObject go = curPool.Spawn();
                if (go != null)
                {
                    goList.Add(go);
                }
                else
                {
                    cnt = idx;
                    break;
                }
            }
            if(goList.Count == assetsNames.Length)
            {
                cb(goList, assetsPath, assetsNames);
                return 0;
            }
            else
            {
                for(int idx =0; idx <cnt;idx++)
                {
                    RecycleGO(assetsPath, assetsNames[idx],goList[idx]);
                }
                goList.Clear();
                goList = null;
            }
        }

        ResourceLoadCallback<List<GameObject>> callBack = (prefabs, path_, assetName_) =>
        {
            if (null == prefabs)
            {
                if (cb != null)
                    cb(null, path_, assetName_);
                return;
            }


            if (cb != null)
            {
                List<GameObject> goInstList = new List<GameObject>();
                for(int idx =0;idx < prefabs.Count;idx++)
                {
                    GameObject goInst = GameObject.Instantiate(prefabs[idx]);
                    goInst.transform.localPosition = Vector3.zero;
                    goInst.transform.localScale = Vector3.one;
                    goInst.name = assetName_[idx];
                    goInstList.Add(goInst);
                }
                cb(goInstList, path_, assetName_);
            }
        };
        return LoadAsset<List<GameObject>>(callBack, assetsPath, assetsNames);
    }

    public GameObject GetGoFromPool(string assetPath, string assetName)
    {
        if (string.IsNullOrEmpty(assetName))
            return null;

        GameObject go = null;
        if (!string.IsNullOrEmpty(assetPath))
        {
            Dictionary<string, GameObjectPool<GameObject>> mDirGoPool;
            if (assetsPool.TryGetValue(assetPath, out mDirGoPool))
            {
                GameObjectPool<GameObject> curPool = null;
                mDirGoPool.TryGetValue(assetName, out curPool);
                if (curPool == null)
                {
                    curPool = new GameObjectPool<GameObject>();
                    mDirGoPool.Add(assetName, curPool);
                }
                go = curPool.Spawn();
                if (go != null)
                {
                    return go;
                }
            }
        }
        
       
        GameObject prefab = (GameObject)FindAssetByPathAndName(assetPath, assetName);
        if(prefab == null)
        {
            prefab = ResourceMgr.Instance.LoadAssetSync<GameObject>(assetPath, assetName);
        }
        if(prefab != null)
        {
            go = GameObject.Instantiate(prefab);
        }
        return go;
    }

    public GameObject GetUIGoFromPool(string assetPath, string assetName)
    {
        if (string.IsNullOrEmpty(assetName))
            return null;

        if (!string.IsNullOrEmpty(assetPath))
        {
            Dictionary<string, GameObjectPool<GameObject>> mDirGoPool;
            if (assetsPool.TryGetValue(assetPath, out mDirGoPool))
            {
                GameObjectPool<GameObject> curPool = null;
                mDirGoPool.TryGetValue(assetName, out curPool);
                if (curPool == null)
                {
                    curPool = new GameObjectPool<GameObject>();
                    mDirGoPool.Add(assetName, curPool);
                }
                GameObject go = curPool.Spawn();
                if (go != null)
                {
                    return go;
                }
            }
        }
        return null;
    }

    public void SetGoPoolMaxCacheNum(string assetPath, string assetName,int num)
    {
        if (string.IsNullOrEmpty(assetPath) || string.IsNullOrEmpty(assetName)) return;
        
        Dictionary<string, GameObjectPool<GameObject>> mDirGoPool;
        if(assetsPool.TryGetValue(assetPath,out mDirGoPool))
        {
            GameObjectPool<GameObject> curPool = null;
            mDirGoPool.TryGetValue(assetName, out curPool);
            if (curPool == null)
            {
                curPool = new GameObjectPool<GameObject>();
                mDirGoPool.Add(assetName, curPool);
            }
            curPool.SetMaxCacheNum(num);
        }
        else
        {
            mDirGoPool = new Dictionary<string, GameObjectPool<GameObject>>();
            GameObjectPool<GameObject> curPool = new GameObjectPool<GameObject>();
            curPool.SetMaxCacheNum(num);
            mDirGoPool.Add(assetName, curPool);
            assetsPool.Add(assetPath, mDirGoPool);
        }
    }

    public Object GetAsset(string assetPath,string assetName)
    {
        if(string.IsNullOrEmpty(assetName))
        {
            return null;
        }
        return FindAssetByPathAndName(assetPath, assetName);
    }

    public void RecycleUIGO(string assetPath, string assetName, GameObject go)
    {
        if (go == null) return;

        if (string.IsNullOrEmpty(assetName) || string.IsNullOrEmpty(assetPath))
        {
            GameObject.Destroy(go);
            go = null;
            return;
        }

        Dictionary<string, GameObjectPool<GameObject>> mDirGoPool = null;
        if (assetsPool.TryGetValue(assetPath, out mDirGoPool))
        {
            GameObjectPool<GameObject> curPool = null;
            if (mDirGoPool.TryGetValue(assetName, out curPool))
            {
                go.transform.SetParent(UIMgr.Instance.UIRootTrans);
                //CommonUtil.SetGameObjectLayer(go, "Hide");
                go.SetActive(false);
                curPool.Recycle(go);
                return;
            }
            else
            {
                curPool = new GameObjectPool<GameObject>();
                mDirGoPool.Add(assetName, curPool);
                go.transform.SetParent(UIMgr.Instance.UIRootTrans);
                //CommonUtil.SetGameObjectLayer(go, "Hide");
                go.SetActive(false);
                curPool.Recycle(go);
            }
        }
        else
        {
            mDirGoPool = new Dictionary<string, GameObjectPool<GameObject>>();
            GameObjectPool<GameObject> curPool = new GameObjectPool<GameObject>();
            mDirGoPool.Add(assetName, curPool);
            assetsPool.Add(assetPath, mDirGoPool);

            go.transform.SetParent(UIMgr.Instance.UIRootTrans);
            //CommonUtil.SetGameObjectLayer(go, "Hide");
            go.SetActive(false);
            curPool.Recycle(go);
        }
    }

    public void RecycleGO(string assetPath,string assetName, GameObject go)
    {
        if (go == null) return;

        if (string.IsNullOrEmpty(assetName) || string.IsNullOrEmpty(assetPath))
        {
            GameObject.Destroy(go);
            go = null;
            return;
        }

        Dictionary<string, GameObjectPool<GameObject>> mDirGoPool = null;
        if(assetsPool.TryGetValue(assetPath, out mDirGoPool))
        {
            GameObjectPool<GameObject> curPool = null;
            if (mDirGoPool.TryGetValue(assetName, out curPool))
            {
                go.transform.SetParent(PoolNode);
                curPool.Recycle(go);
                return;
            }
            else
            {
                curPool = new GameObjectPool<GameObject>();
                mDirGoPool.Add(assetName, curPool);
                go.transform.SetParent(PoolNode);
                curPool.Recycle(go);
            }
        }
        else
        {
            mDirGoPool = new Dictionary<string, GameObjectPool<GameObject>>();
            GameObjectPool<GameObject> curPool = new GameObjectPool<GameObject>();
            mDirGoPool.Add(assetName, curPool);
            assetsPool.Add(assetPath, mDirGoPool);

            go.transform.SetParent(PoolNode);
            curPool.Recycle(go);
        }
    }

    public void UnloadAssetBySeqId(long seqId)
    {
        RemoveLoadingCb(seqId);
    }

    [NoToLua]
    public void CleanGOPool()
    {
        foreach (var p in assetsPool)
        {
            Dictionary<string, GameObjectPool<GameObject>> poolDic = p.Value;
            foreach(var list in poolDic)
            {
                GameObjectPool<GameObject> goPool = list.Value;
                goPool.Dispose();
            }
        }
        assetsPool.Clear();
    }

    public Shader FindShader(string shaderName,string shaderPath)
    {
        return AssetsMgr.Instance.FindShader(shaderName, shaderPath);
    }
    #endregion

    [NoToLua]
    public void Update()
    {
        //if (LoadedResourceCnt == 0) return;

        //float curTime = Time.time;
        //if (curTime - lastCheckTime >= check_internal)
        //{
        //    ClearLongTimeUnusedResource(curTime);
        //    lastCheckTime = curTime;
        //}
    }


    #region inner_methods
    void RemoveLoadingCb(long seqId)
    {
        LoadingResourceInfo lri = FindLoadingResourceInfoBySeqId(seqId);
        if (lri != null)
        {
            AssetsMgr.Instance.CancelLoadAsset(seqId);
            lri.Dispose();
            loadingResources.Remove(lri);
        }
    }

    LoadingResourceInfo FindLoadingResourceInfoBySeqId(long seqId)
    {
        for (int idx = 0; idx < loadingResources.Count; idx++)
        {
            LoadingResourceInfo lri = loadingResources[idx];
            if (lri.SeqId == seqId) return lri;
        }

        return null;
    }

    public bool HasAsset(string path,string assetName)
    {
        if (string.IsNullOrEmpty(assetName)) return false;

        Object obj = FindAssetByPathAndName(path, assetName);
        return obj != null;
    }

    bool ExistAssets(string path, string[] assetNames)
    {
        if (assetNames == null || assetNames.Length == 0) return false;

        bool find = false;

        for (int idx = 0; idx < assetNames.Length; idx++)
        {
            Object obj = FindAssetByPathAndName(path, assetNames[idx]);
            if (obj == null) return false;
            find = true;
        }

        return find;
    }

    bool ExistAssetPath(string path)
    {
        for (int idx = 0; idx < loadedResources.Count; idx++)
        {
            ResourceInfo ri = loadedResources[idx];
            if (ri.Path == path)
            {
                return true;
            }
        }
        return false;
    }

    Object FindAssetByPathAndName(string pathName, string assetName)
    {
        for (int idx = 0; idx < loadedResources.Count; idx++)
        {
            ResourceInfo ri = loadedResources[idx];
            if (ri.Path == pathName && ri.Name == assetName)
            {
                return ri.Asset;
            }
        }
        return null;
    }

    T FindAssetByPathAndName<T>(string pathName, string assetName) where T : Object
    {
        for (int idx = 0; idx < loadedResources.Count; idx++)
        {
            ResourceInfo ri = loadedResources[idx];
            if (ri.Path == pathName && ri.Name == assetName)
            {
                T ret = ri.Reuse() as T;
                return ret;
            }
        }
        return null;
    }

    long Inner_LoadAsset<T>(ResourceLoadCallbackWithSeqId<T> cb, string pathName, string[] assetNames, ELoadType type, object[] userDatas)
    {
        if (string.IsNullOrEmpty(pathName) && (assetNames == null || assetNames.Length == 0)) return 0;

        for (int idx = 0; idx < assetNames.Length; idx++)
        {
            if (assetNames[idx] == "Null" || string.IsNullOrEmpty(assetNames[idx]))
            {
                DebugHelper.LogError("加载的资源存在Null，请检查配置");
                return 0;
            }
        }

        if (assetNames == null || assetNames.Length == 0)
        {
            if (cb != null)
                cb.DynamicInvoke(null, 0, pathName, userDatas, assetNames);
            return 0;
        }

        if (ExistAssets(pathName, assetNames))
        {
            FinishResourceLoad(cb, typeof(T), pathName, assetNames,true,0, userDatas);
            return 0;
        }

        loadingSeqId++;
        LoadingResourceInfo lri = new LoadingResourceInfo(loadingSeqId, pathName, cb as System.Delegate, typeof(T), true,assetNames);
        lri.userDatas = userDatas;
        loadingResources.Add(lri);

        lri.LoadCBNum =  AssetsMgr.Instance.GetAsset<T>(OnLoadAssetallback, type, loadingSeqId, pathName, assetNames);
        if (lri.LoadCBNum == 0)
        {
            if (cb != null)
                cb.DynamicInvoke(null, loadingSeqId,pathName, userDatas, assetNames);
            RemoveLoadingCb(loadingSeqId);
        }
        return loadingSeqId;
    }

    private long Inner_LoadAsset<T>(ResourceLoadCallback<T> cb, string pathName, string[] assetNames, ELoadType type)
    {
        if (string.IsNullOrEmpty(pathName) && (assetNames == null || assetNames.Length == 0)) return 0;

        for (int idx = 0; idx < assetNames.Length; idx++)
        {
            if (assetNames[idx] == "Null" || string.IsNullOrEmpty(assetNames[idx]))
            {
                DebugHelper.LogError("加载的资源存在Null，请检查配置");
                return 0;
            }
        }

        if (assetNames == null || assetNames.Length == 0)
        {
            if (cb != null)
                cb.DynamicInvoke(null, pathName, assetNames);
            return 0;
        }
        
        if (ExistAssets(pathName, assetNames))
        {
            FinishResourceLoad(cb, typeof(T), pathName, assetNames,false,0,null);
            return 0;
        }

        loadingSeqId++;
        LoadingResourceInfo lri = new LoadingResourceInfo(loadingSeqId, pathName, cb as System.Delegate, typeof(T), false,assetNames);
        loadingResources.Add(lri);

        lri.LoadCBNum = AssetsMgr.Instance.GetAsset<T>(OnLoadAssetallback, type, loadingSeqId, pathName, assetNames);
        if (lri.LoadCBNum == 0)
        {
            if (cb != null)
                cb.DynamicInvoke(null, pathName, assetNames);
            RemoveLoadingCb(loadingSeqId);
        }
        return loadingSeqId;
    }


    void OnLoadDirAssetallback<T>(T result, long seqId, string assetPath, params string[] assetNames)
    {
        LoadingResourceInfo lri = FindLoadingResourceInfoBySeqId(seqId);
        if (lri != null)
        {
            System.Delegate cb = lri.Callback;
            if(cb!=null)
                cb.DynamicInvoke(result, assetPath, assetNames);

            RemoveLoadingCb(seqId);
        }
        else
        {
            DebugHelper.Log("Load " + seqId + " Failed LoadingCnt:" + LoadingResourceCnt);
        }
    }

    void OnLoadAssetallback<T>(T result, long seqId, string assetPath, params string[] assetNames)
    {
        var t = typeof(T);
        if (t.Equals(typeof(List<GameObject>)))
        {
            List<GameObject> objList = result as List<GameObject>;
            if (assetNames.Length > 0)
            {
                for (int idx = 0; idx < assetNames.Length; idx++)
                {
                    ResourceInfo ri = new ResourceInfo(assetPath, assetNames[idx], objList[idx]);
                    loadedResources.Add(ri);
                }
            }
            else
            {
                for (int idx = 0; idx < objList.Count; idx++)
                {
                    string objName = objList[idx] != null ? objList[idx].name : null;
                    ResourceInfo ri = new ResourceInfo(assetPath, objName, objList[idx]);
                    loadedResources.Add(ri);
                }
            }
        }
        else if (t.Equals(typeof(List<Texture2D>)))
        {
            List<Texture2D> objList = result as List<Texture2D>;
            if (assetNames.Length > 0)
            {
                for (int idx = 0; idx < assetNames.Length; idx++)
                {
                    ResourceInfo ri = new ResourceInfo(assetPath, assetNames[idx], objList[idx]);
                    loadedResources.Add(ri);
                }
            }
            else
            {
                for (int idx = 0; idx < objList.Count; idx++)
                {
                    ResourceInfo ri = new ResourceInfo(assetPath, null, objList[idx]);
                    loadedResources.Add(ri);
                }
            }
        }
        else if (t.Equals(typeof(List<Sprite>)))
        {
            List<Sprite> objList = result as List<Sprite>;
            if (assetNames.Length > 0)
            {
                for (int idx = 0; idx < assetNames.Length; idx++)
                {
                    ResourceInfo ri = new ResourceInfo(assetPath, assetNames[idx], objList[idx]);
                    loadedResources.Add(ri);
                }
            }
            else
            {
                for (int idx = 0; idx < objList.Count; idx++)
                {
                    ResourceInfo ri = new ResourceInfo(assetPath, null, objList[idx]);
                    loadedResources.Add(ri);
                }
            }
        }
        else if (t.Equals(typeof(List<TextAsset>)))
        {
            List<TextAsset> objList = result as List<TextAsset>;
            if (assetNames.Length > 0)
            {
                for (int idx = 0; idx < assetNames.Length; idx++)
                {
                    ResourceInfo ri = new ResourceInfo(assetPath, assetNames[idx], objList[idx]);
                    loadedResources.Add(ri);
                }
            }
            else
            {
                for (int idx = 0; idx < objList.Count; idx++)
                {
                    ResourceInfo ri = new ResourceInfo(assetPath, null, objList[idx]);
                    loadedResources.Add(ri);
                }
            }

        }
        else if (t.Equals(typeof(List<PlayableAsset>)))
        {
            List<PlayableAsset> objList = result as List<PlayableAsset>;
            if (assetNames.Length > 0)
            {
                for (int idx = 0; idx < assetNames.Length; idx++)
                {
                    ResourceInfo ri = new ResourceInfo(assetPath, assetNames[idx], objList[idx]);
                    loadedResources.Add(ri);
                }
            }
            else
            {
                for (int idx = 0; idx < objList.Count; idx++)
                {
                    ResourceInfo ri = new ResourceInfo(assetPath, null, objList[idx]);
                    loadedResources.Add(ri);
                }
            }
        }
        else if (t.Equals(typeof(List<AudioClip>)))
        {
            List<AudioClip> objList = result as List<AudioClip>;
            if (assetNames.Length > 0)
            {
                for (int idx = 0; idx < assetNames.Length; idx++)
                {
                    ResourceInfo ri = new ResourceInfo(assetPath, assetNames[idx], objList[idx]);
                    loadedResources.Add(ri);
                }
            }
            else
            {
                for (int idx = 0; idx < objList.Count; idx++)
                {
                    ResourceInfo ri = new ResourceInfo(assetPath, null, objList[idx]);
                    loadedResources.Add(ri);
                }
            }

        }
        else if (t.Equals(typeof(List<VideoClip>)))
        {
            List<VideoClip> objList = result as List<VideoClip>;
            if (assetNames.Length > 0)
            {
                for (int idx = 0; idx < assetNames.Length; idx++)
                {
                    ResourceInfo ri = new ResourceInfo(assetPath, assetNames[idx], objList[idx]);
                    loadedResources.Add(ri);
                }
            }
            else
            {
                for (int idx = 0; idx < objList.Count; idx++)
                {
                    ResourceInfo ri = new ResourceInfo(assetPath, null, objList[idx]);
                    loadedResources.Add(ri);
                }
            }
        }
        else if (t.Equals(typeof(List<AnimationClip>)))
        {
            List<AnimationClip> objList = result as List<AnimationClip>;
            if (assetNames.Length > 0)
            {
                for (int idx = 0; idx < assetNames.Length; idx++)
                {
                    ResourceInfo ri = new ResourceInfo(assetPath, assetNames[idx], objList[idx]);
                    loadedResources.Add(ri);
                }
            }
            else
            {
                for (int idx = 0; idx < objList.Count; idx++)
                {
                    ResourceInfo ri = new ResourceInfo(assetPath, null, objList[idx]);
                    loadedResources.Add(ri);
                }
            }
        }
        else if (t.Equals(typeof(List<RuntimeAnimatorController>)))
        {
            List<RuntimeAnimatorController> objList = result as List<RuntimeAnimatorController>;
            if (assetNames.Length > 0)
            {
                for (int idx = 0; idx < assetNames.Length; idx++)
                {
                    ResourceInfo ri = new ResourceInfo(assetPath, assetNames[idx], objList[idx]);
                    loadedResources.Add(ri);
                }
            }
            else
            {
                for (int idx = 0; idx < objList.Count; idx++)
                {
                    ResourceInfo ri = new ResourceInfo(assetPath, null, objList[idx]);
                    loadedResources.Add(ri);
                }
            }
        }
        else if (t.Equals(typeof(ScriptableObject)) ||
              t.Equals(typeof(GameObject)) ||
              t.Equals(typeof(AudioClip)) ||
              t.Equals(typeof(VideoClip)) ||
              t.Equals(typeof(Texture2D)) ||
              t.Equals(typeof(Sprite)) ||
              t.Equals(typeof(Material)) ||
              t.Equals(typeof(AnimationClip)) ||
              t.Equals(typeof(RuntimeAnimatorController)))
        {
            Object obj = result as Object;
            ResourceInfo ri = new ResourceInfo(assetPath, assetNames[0], obj);
            loadedResources.Add(ri);
        }

        LoadingResourceInfo lri = FindLoadingResourceInfoBySeqId(seqId);
        if (lri != null)
        {
            lri.LoadCBNum = lri.LoadCBNum - 1;
            if(lri.LoadCBNum <= 0)
            {
                System.Delegate cb = lri.Callback;
                FinishResourceLoad(cb, lri.DelegateType, lri.AssetPath, lri.AssetNames, lri.ReturnSeqId, lri.SeqId,lri.userDatas);
                RemoveLoadingCb(seqId);
            }
        }
        else
        {
            DebugHelper.Log("Load " + seqId + " Failed LoadingCnt:" + LoadingResourceCnt);
        }
    }

    void FinishResourceLoad(System.Delegate cb, System.Type delegateType, string pathName, string[] assetNames,bool returnSeq,long seqId,object[] userdatas)
    {
        if (cb == null) return;

        if (delegateType.Equals(typeof(List<GameObject>)))
        {
            FinishLoad<GameObject>(cb, pathName, assetNames, false, returnSeq,seqId, userdatas);
        }
        else if (delegateType.Equals(typeof(List<Texture2D>)))
        {
            FinishLoad<Texture2D>(cb, pathName, assetNames, false, returnSeq, seqId, userdatas);
        }
        else if (delegateType.Equals(typeof(List<Sprite>)))
        {
            FinishLoad<Sprite>(cb, pathName, assetNames, false, returnSeq, seqId, userdatas);
        }
        else if (delegateType.Equals(typeof(List<TextAsset>)))
        {
            FinishLoad<TextAsset>(cb, pathName, assetNames, false, returnSeq, seqId, userdatas);
        }
        else if (delegateType.Equals(typeof(List<PlayableAsset>)))
        {
            FinishLoad<PlayableAsset>(cb, pathName, assetNames, false, returnSeq, seqId, userdatas);
        }
        else if (delegateType.Equals(typeof(List<AudioClip>)))
        {
            FinishLoad<AudioClip>(cb, pathName, assetNames, false, returnSeq, seqId, userdatas);
        }
        else if (delegateType.Equals(typeof(List<VideoClip>)))
        {
            FinishLoad<VideoClip>(cb, pathName, assetNames, false, returnSeq, seqId, userdatas);
        }
        else if (delegateType.Equals(typeof(List<AnimationClip>)))
        {
            FinishLoad<AnimationClip>(cb, pathName, assetNames, false, returnSeq, seqId, userdatas);
        }
        else if (delegateType.Equals(typeof(List<RuntimeAnimatorController>)))
        {
            FinishLoad<RuntimeAnimatorController>(cb, pathName, assetNames, false, returnSeq, seqId, userdatas);
        }
        else if (delegateType.Equals(typeof(GameObject)))
        {
            FinishLoad<GameObject>(cb, pathName, assetNames, true, returnSeq, seqId, userdatas);
        }
        else if (delegateType.Equals(typeof(Texture2D)))
        {
            FinishLoad<Texture2D>(cb, pathName, assetNames, true, returnSeq, seqId, userdatas);
        }
        else if (delegateType.Equals(typeof(Sprite)))
        {
            FinishLoad<Sprite>(cb, pathName, assetNames, true, returnSeq, seqId, userdatas);
        }
        else if (delegateType.Equals(typeof(TextAsset)))
        {
            FinishLoad<TextAsset>(cb, pathName, assetNames, true, returnSeq, seqId, userdatas);
        }
        else if (delegateType.Equals(typeof(PlayableAsset)))
        {
            FinishLoad<PlayableAsset>(cb, pathName, assetNames, true, returnSeq, seqId, userdatas);
        }
        else if (delegateType.Equals(typeof(AudioClip)))
        {
            FinishLoad<AudioClip>(cb, pathName, assetNames, true, returnSeq, seqId, userdatas);
        }
        else if (delegateType.Equals(typeof(VideoClip)))
        {
            FinishLoad<VideoClip>(cb, pathName, assetNames, true, returnSeq, seqId, userdatas);
        }
        else if (delegateType.Equals(typeof(AnimationClip)))
        {
            FinishLoad<AnimationClip>(cb, pathName, assetNames, true, returnSeq, seqId, userdatas);
        }
        else if (delegateType.Equals(typeof(Sprite)))
        {
            FinishLoad<Sprite>(cb, pathName, assetNames, true, returnSeq, seqId, userdatas);
        }
        else if (delegateType.Equals(typeof(Material)))
        {
            FinishLoad<Material>(cb, pathName, assetNames, true, returnSeq, seqId, userdatas);
        }
        else if (delegateType.Equals(typeof(RuntimeAnimatorController)))
        {
            FinishLoad<RuntimeAnimatorController>(cb, pathName, assetNames, true, returnSeq, seqId, userdatas);
        }
    }

    void FinishLoad<T>(System.Delegate cb, string pathName, string[] assetNames, bool single, bool returnSeq, long seqId, object[] userdatas) where T : Object
    {
        if (single)
        {
            T go = FindAssetByPathAndName<T>(pathName, assetNames[0]);
            try
            {
                if (returnSeq)
                {
                    cb.DynamicInvoke(go, seqId, pathName, userdatas,assetNames);
                }
                else
                {
                    
                    cb.DynamicInvoke(go, pathName, assetNames);
                }
            }
            catch(System.Exception e)
            {
                DebugHelper.LogError(e.StackTrace);
            }
         
        }
        else
        {
            List<T> assetList = new List<T>();
            if (assetNames != null && assetNames.Length > 0)
            {
                for (int idx = 0; idx < assetNames.Length; idx++)
                {
                    assetList.Add(FindAssetByPathAndName<T>(pathName, assetNames[idx]));
                }
            }
            else
            {
                for (int idx = 0; idx < loadedResources.Count; idx++)
                {
                    ResourceInfo ri = loadedResources[idx];
                    if (ri.Path == pathName)
                    {
                        T asset = ri.Reuse() as T;
                        assetList.Add(asset);
                    }
                }
            }

            if(returnSeq)
            {
                cb.DynamicInvoke(assetList,seqId, pathName, userdatas, assetNames);
            }
            else
            {
                cb.DynamicInvoke(assetList, pathName, assetNames);
            }
        }
        ClearNullResource();
    }

    void ClearNullResource()
    {
        for (int idx = loadedResources.Count - 1; idx >= 0; idx--)
        {
            ResourceInfo ri = loadedResources[idx];
            if (ri.Asset == null)
            {
                loadedResources.RemoveAt(idx);
            }
        }
    }

    public void RemoveLoadedResource(string path,string assetName)
    {
        for (int idx = loadedResources.Count-1; idx >= 0; idx--)
        {
            var ri = loadedResources[idx];
            if(ri.Path == path && ri.Name == assetName)
            {
                ri.Dispose();
                loadedResources.RemoveAt(idx);
            }
        }
    }

    List<string> mResidentDirList = new List<string>();
    List<string> mResidentResList = new List<string>();

    public void ReadResidentResCfg()
    {
        mResidentDirList.Clear();
        mResidentResList.Clear();
        Dictionary<string, Dictionary<string, string>> tab =  ConfigMgr.Instance.getTable(Config.ResidentResCfg);
        if (tab == null) return;

        foreach(var p in tab)
        {
            var key = p.Key;
            var dic = p.Value;


            int kVal = 0;
            if (int.TryParse(key, out kVal))
            {
                string resName = dic["name"];
                int type = 0;
                if (dic.ContainsKey("type"))
                {
                    int.TryParse(dic["type"], out type);
                }

                if (!string.IsNullOrEmpty(resName) && type > 0)
                {
                    if (type == 1)
                    {
                        if (!mResidentDirList.Contains(resName))
                            mResidentDirList.Add(resName);
                    }
                    else if (type == 2)
                    {
                        if (!mResidentResList.Contains(resName))
                        {
                            mResidentResList.Add(resName);
                        }
                    }
                }
            }   
        }
    }

    public bool IsResidentRes(string assetPath,string assetName)
    {
        string path = assetPath + "/" + assetName;
        return IsResidentRes(path);
    }

    public bool IsResidentRes(string assetFullPath)
    {
        for (int idx = 0; idx < mResidentResList.Count; idx++)
        {
            if (mResidentResList[idx] == assetFullPath) return true;
        }

        string pathDir;
        FileUtils.ExtractParent(assetFullPath, out pathDir);
        if (!string.IsNullOrEmpty(pathDir))
        {
            for (int idx = 0; idx < mResidentDirList.Count; idx++)
            {
                if (mResidentDirList[idx] == pathDir) return true;
            }
        }

        return false;
    }

    public void ClearAllResource()
    {
        for(int idx = loadedResources.Count -1; idx>=0; idx--)
        {
            ResourceInfo ri = loadedResources[idx];
            if (IsResidentRes(ri.Path, ri.Name))
            {
                continue;
            }

            ri.Dispose();
            loadedResources.RemoveAt(idx);
        }

        CleanGOPool();
    }

    void ClearLongTimeUnusedResource(float curTime)
    {
        for (int idx = loadedResources.Count - 1; idx >= 0; idx--)
        {
            ResourceInfo ri = loadedResources[idx];
            float passedTime = curTime - ri.LastUsedTime;
            if (passedTime >= cache_Time && !IsResidentRes(ri.Path,ri.Name) && HasGoInPool(ri.Path,ri.Name))
            {
                ri.Dispose();
                loadedResources.RemoveAt(idx);
            }
        }
    }

    bool HasGoInPool(string assetPath,string assetName)
    {
        if (string.IsNullOrEmpty(assetPath)) return false;
        
        if (assetsPool == null) return false;

        Dictionary<string, GameObjectPool<GameObject>> mDirGoPool;
        if (assetsPool.TryGetValue(assetPath, out mDirGoPool))
        {
            GameObjectPool<GameObject> curPool = null;
            mDirGoPool.TryGetValue(assetName, out curPool);
            if (curPool != null && curPool.Count > 0)
            {
                return true;
            }
        }
        return false;
    }
    #endregion

}