Addressable资源加载框架

代码:

using unityengine.addressableassets;
using unityengine.addressableassets.initialization;
using unityengine.resourcemanagement.asyncoperations;
using unityengine;
using system.collections.generic;
using system;

class baseloader
{
    protected string name = string.empty;

    private asyncoperationhandle handle;

    private bool isload = false;
    public baseloader(string name)
    {
        this.name = name;
        this.isload = false;
    }

    /// <summary>
    /// 加载资源
    /// </summary>
    /// <param name="name">资源名称</param>
    /// <param name="parent">加载完成之后存放的父节点</param>
    /// <param name="oncomplete">加载完成之后的回调</param>
    public virtual void load<t>(action<t> oncomplete) where t : unityengine.object
    {
        if (this.isload)
        {
            if (handle.isdone)
            {
                if (oncomplete != null)
                {
                    oncomplete(handle.result as t);
                }
            }
            else
            {
                handle.completed += (result) =>
                {
                    if (result.status == unityengine.resourcemanagement.asyncoperations.asyncoperationstatus.succeeded)
                    {
                        var obj = result.result as t;
                        if (oncomplete != null)
                        {
                            oncomplete(obj);
                        }
                    }
                    else
                    {
                        if (oncomplete != null)
                        {
                            oncomplete(null);
                        }
                        debug.logerror("load name = " + name + " tpye = " + typeof(t).tostring() + " failed!  ");
                    }
                };
            }
        }
        else
        {
            this.isload = true;
            this.handle = addressables.loadassetasync<t>(name);
            handle.completed += (result) =>
            {
                if (result.status == unityengine.resourcemanagement.asyncoperations.asyncoperationstatus.succeeded)
                {
                    var obj = result.result as t;
                    if (oncomplete != null)
                    {
                        oncomplete(obj);
                    }
                }
                else
                {
                    if (oncomplete != null)
                    {
                        oncomplete(null);
                    }
                    debug.logerror("load name = " + name + " tpye = " + typeof(t).tostring() + " failed!  ");
                }
            };
        }
    }

    /// <summary>
    /// 同步方法加载资源
    /// </summary>
    /// <typeparam name="t"></typeparam>
    /// <returns></returns>
    public virtual t load<t>() where t : unityengine.object
    {
        this.isload = true;
        this.handle = addressables.loadassetasync<t>(name);
        t obj = this.handle.waitforcompletion() as t;
        this.isload = false;
        return obj;
    }

    /// <summary>
    /// 同时加载多个资源
    /// </summary>
    /// <typeparam name="t"></typeparam>
    public virtual list<t> loads<t>() where t : unityengine.object
    {
        this.isload = true;
        this.handle = addressables.loadassetsasync<t>(name, (obj) => { });
        list<t> objs = this.handle.waitforcompletion() as list<t>;
        return objs;
    }

    public virtual void release()
    {
        if (this.isload)
        {
            this.isload = false;
            addressables.release(handle);
        }
    }
}

using system.collections;
using system.collections.generic;
using unityengine;
/// <summary>
/// 预制类资源加载器
/// </summary>
class gameobjectloader : baseloader
{
    /// <summary>
    /// 资源缓存列表
    /// </summary>
    private stack<gameobject> caches = new stack<gameobject>();

    /// <summary>
    /// 正在使用的列表
    /// </summary>
    private hashset<gameobject> references = new hashset<gameobject>();


    public gameobject prefab;

    public gameobjectloader(string name) : base(name)
    {
        this.prefab = null;
    }

    public gameobjectloader(gameobject obj) : base(obj.name)
    {
        this.prefab = obj;
    }
    /// <summary>
    /// 同步方法，确保已经加载好了
    /// </summary>
    /// <param name="parent"></param>
    /// <returns></returns>
    public gameobject instantiate(transform parent)
    {
        gameobject obj = null;
        if (caches.count > 0)
        {
            obj = caches.pop();
        }
        else
        {
            obj = gameobject.instantiate(this.prefab) as gameobject;
            obj.name = this.name;
        }
        this.references.add(obj);
        return obj;
    }

    /// <summary>
    /// 同步方法实例化对象
    /// </summary>
    /// <returns></returns>
    public gameobject instantiate()
    {
        if (caches.count > 0)
        {
            var obj = caches.pop();
            this.references.add(obj);
            return obj;
        }
        else
        {
            if (this.prefab != null)
            {
                var obj = gameobject.instantiate(this.prefab) as gameobject;
                obj.name = this.name;
                this.references.add(obj);
                return obj;
            }
            else
            {
                this.prefab = base.load<gameobject>();
                var obj = gameobject.instantiate(this.prefab) as gameobject;
                obj.name = this.name;
                base.release();
                this.references.add(obj);
                return obj;
            }
        }
    }

    public void free(gameobject obj)
    {
        this.caches.push(obj);
        this.references.remove(obj);
        obj.transform.setparent(assetmanager.instance.poolroot);
    }


    public override void release()
    {
        foreach (var obj in this.caches)
        {
            gameobject.destroy(obj.gameobject);
        }
        if (this.references.count <= 0)
        {
            base.release();
            assetmanager.instance.removepools(this.name);
        }
    }

}

using system.collections;
using system.collections.generic;
using unityengine;
using unityengine.addressableassets;
using unityengine.addressableassets.initialization;
/// <summary>
/// 全局单例资源管理器
/// 所有的资源加载最终都走此类入口
/// </summary>
public class assetmanager
{
    private static assetmanager assetmanager;
    public static assetmanager instance
    {
        get
        {
            if (assetmanager == null)
            {
                assetmanager = new assetmanager();
            }
            return assetmanager;
        }
    }

    #region prefab 预制加载管理
    /// <summary>
    /// 缓存对象根节点
    /// </summary>
    public unityengine.transform poolroot;

    private dictionary<string, gameobjectloader> pools = new dictionary<string, gameobjectloader>();
    /// <summary>
    /// 缓存查找表
    /// </summary>  
    private dictionary<gameobject, gameobjectloader> lookup = new dictionary<gameobject, gameobjectloader>();

    public assetmanager()
    {
        unityengine.transform poolnode = new gameobject("[asset pool]").transform;
        poolnode.transform.localposition = vector3.zero;
        poolnode.transform.localscale = vector3.one;
        poolnode.transform.localrotation = quaternion.identity;
        gameobject.dontdestroyonload(poolnode);
        //启动定时器，定时清理缓存池里的缓存
    }

    /// <summary>
    /// 同步实例化gameobject
    /// </summary>
    /// <param name="name"></param>
    /// <returns></returns>
    public gameobject instantiate(string name)
    {
        gameobjectloader loader;
        if (this.pools.trygetvalue(name, out loader))
        {
            var obj = loader.instantiate();
            this.lookup.add(obj, loader);
            return obj;
        }
        else
        {
            loader = new gameobjectloader(name);
            var obj = loader.instantiate();
            //添加缓存池
            this.pools.add(name, loader);
            //添加缓存查找表
            this.lookup.add(obj, loader);
            return obj;
        }
    }

    /// <summary>
    ///获取模板信息
    /// </summary>
    /// <param name="name"></param>
    /// <returns></returns>
    public gameobject gettemplete(string name)
    {
        gameobjectloader loader;
        if (this.pools.trygetvalue(name, out loader))
        {
            return loader.prefab;
        }
        return null;
    }

    /// <summary>
    /// 将资源释放回缓存池
    /// </summary>
    /// <param name="obj"></param>
    public void freegameobject(gameobject obj)
    {
        gameobjectloader loader;
        if (this.lookup.trygetvalue(obj, out loader))
        {
            loader.free(obj);
            //释放后从缓存查找表中移除
            this.lookup.remove(obj);
        }
    }

    public void removepools(string name)
    {
        this.pools.remove(name);
    }
    ///由定时器调用，定时清理缓存，一般设计为10分钟清理一次
    public void releaseall()
    {
        foreach (var item in this.pools.values)
        {
            item.release();
        }
    }

    #endregion
}

转载自:https://blog.csdn.net/qq_19428987/article/details/119353314