ResMgr

//==========================
// - FileName:      ObjectTool.cs         
// - Created:       true.   
// - CreateTime:    2020/05/22 23:00:26 
// - Email:         1670328571@qq.com       
// - Region:        China WUHAN 
// - Description:   
//==========================
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public interface IPool
{
    GameObject GetObj(string objName);

    void Recycle(GameObject obj, Action resetMethod = null);
}

public class ObjectPool : IPool
{
    private ResFactory<GameObject> mFactory;

    private Stack<GameObject> mCacheStack;
    /// <summary>
    /// 构造方法
    /// </summary>
    /// <param name="resFactory"></param>
    /// <param name="objName"></param>
    /// <param name="initCount"></param>
    public ObjectPool(ResFactory<GameObject> resFactory, string objName, int initCount = 0)
    {
        mFactory = resFactory;
        mCacheStack = new Stack<GameObject>();
        for (int i = 0; i < initCount; i++)
        {
            mCacheStack.Push(GetObj(objName));
        }
    }
    /// <summary>
    /// 获取游戏物体对象
    /// </summary>
    /// <param name="objName"></param>
    /// <returns></returns>
    public GameObject GetObj(string objName)
    {
        GameObject obj;
        if (mCacheStack.Count > 0)
        {
            obj = mCacheStack.Pop();
        }
        else
        {
            obj = GameObject.Instantiate(mFactory.GetRes(objName));
        }
        obj.SetActive(true);
        return obj;
    }
    /// <summary>
    /// 回收不使用的对象到对象池
    /// </summary>
    /// <param name="obj"></param>
    public void Recycle(GameObject obj, Action resetMethod = null)
    {
        if (resetMethod != null)
        {
            resetMethod();
        }
        obj.SetActive(false);
        mCacheStack.Push(obj);
    }
}
public interface IResFactory<T>
{
    void InitFactory(Func<string, T> factoryMehtod);

    T GetRes(string resName);
}

public class ResFactory<T> : IResFactory<T>
{
    public Dictionary<string, T> resDic;

    private Func<string, T> mFactoryMethod;

    public T GetRes(string resName)
    {
        return mFactoryMethod(resName);
        //if (resDic.ContainsKey(resName))
        //{
        //    return resDic[resName];
        //}
        //else
        //{
        //    return Resources.Load<T>(resName);
        //}
    }

    public void InitFactory(Func<string, T> factoryMehtod)
    {
        resDic = new Dictionary<string, T>();
        mFactoryMethod = factoryMehtod;
    }
}

//public interface IResFactory
//{
//    void InitFactory();

//    object GetRes(string resName);
//}

//public class ResFactory : IResFactory
//{
//    public Dictionary<string, object> resDic;

//    public FactoryType factoryType;

//    public object GetRes(string resName)
//    {
//        if (resDic.ContainsKey(resName))
//        {
//            return resDic[resName];
//        }
//        else
//        {
//            //return Resources.Load<object>(resName);
//            return Resources.Load(resName);
//        }
//    }

//    public void InitFactory()
//    {
//        resDic = new Dictionary<string, object>();
//    }
//}

public static class ConstPath
{
    //资源路径
    public const string spritesResPath = "Sprites/";
    public const string prefabsResPath = "Prefabs/";
    public const string audioclipResPath = "AudioClips/";
    //UI
    //Game
    //Sprite
    //AudiClip
}

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class ResSvc : NormalSingleton<ResSvc>
{
    public void InitSvc()
    {
        InitFactory();
        InitPoolDic();
    }

    #region 资源管理
    //资源工厂
    public ResFactory<Sprite> spritesFactory;
    public ResFactory<GameObject> prefabsFactory;
    public ResFactory<AudioClip> audioClipFactory;
    /// <summary>
    /// 初始化资源工厂
    /// </summary>
    public void InitFactory()
    {
        spritesFactory = new ResFactory<Sprite>();
        spritesFactory.InitFactory(
            (resName) =>
            {
                if (spritesFactory.resDic.ContainsKey(resName))
                {
                    return spritesFactory.resDic[resName];
                }
                else
                {
                    return Resources.Load<Sprite>(ConstPath.spritesResPath + resName);
                }
            }
            );
        prefabsFactory = new ResFactory<GameObject>();
        prefabsFactory.InitFactory(
             (resName) =>
             {
                 if (prefabsFactory.resDic.ContainsKey(resName))
                 {
                     return prefabsFactory.resDic[resName];
                 }
                 else
                 {
                     return Resources.Load<GameObject>(ConstPath.prefabsResPath + resName);
                 }
             }
            );
        audioClipFactory = new ResFactory<AudioClip>();
        audioClipFactory.InitFactory(
           (resName) =>
           {
               if (audioClipFactory.resDic.ContainsKey(resName))
               {
                   return audioClipFactory.resDic[resName];
               }
               else
               {
                   return Resources.Load<AudioClip>(ConstPath.audioclipResPath + resName);
               }
           }
            );
    }
    /// <summary>
    /// 获取相应资源
    /// </summary>
    /// <param name="resName"></param>
    /// <returns></returns>
    public Sprite GetSpriteRes(string resName)
    {
        return spritesFactory.GetRes(resName);
    }
    public AudioClip GetAudioclipRes(string resName)
    {
        return audioClipFactory.GetRes(resName);
    }
    public GameObject GetPrefabRes(string resName)
    {
        return prefabsFactory.GetRes(resName);
    }
    #endregion

    #region 对象池
    //对象池字典
    public Dictionary<string, ObjectPool> poolDic;
    /// <summary>
    /// 对象池字典的初始化方法
    /// </summary>
    public void InitPoolDic()
    {
        poolDic = new Dictionary<string, ObjectPool>();
    }
    /// <summary>
    /// 获取对象
    /// </summary>
    /// <returns></returns>
    public GameObject GetObj(string objName, int initCount = 0)
    {
        if (!poolDic.ContainsKey(objName))
        {
            Debug.Log("获取对象");
            poolDic.Add(objName, new ObjectPool(prefabsFactory, objName, initCount));
        }
        return poolDic[objName].GetObj(objName);
    }
    /// <summary>
    /// 回收对象
    /// </summary>
    public void RecycleObj(string objName, GameObject obj, Action resetMethod = null)
    {
        if (!poolDic.ContainsKey(objName))
        {
            Debug.Log("没有该类型的游戏物体对象池");
            return;
        }
        poolDic[objName].Recycle(obj, resetMethod);
    }
    #endregion
}