/// <summary>
/// 获取一个UI实例资源对象
/// </summary>
/// <param name="resname">资源名</param>
/// <param name="assetname">Asset名</param>
/// <param name="callback">资源回调</param>
/// <param name="loadtype">资源加载类型</param>
/// <param name="loadmethod">资源加载方式</param>
/// <returns></returns>
public void getUIInstance(string resname, string assetname = null, Action <GameObject> callback = null, ResourceLoadType loadtype = ResourceLoadType.NormalLoad, ResourceLoadMethod loadmethod = ResourceLoadMethod.Sync)
{
if (string.IsNullOrEmpty(assetname))
{
assetname = resname;
}
ResourceModuleManager.Singleton.requstResource(resname,
(abi) =>
{
var uiinstance = abi.instantiateAsset(assetname);
#if UNITY_EDITOR
ResourceUtility.FindMeshRenderShaderBack(uiinstance);
#endif
callback?.Invoke(uiinstance);
},
loadtype,
loadmethod);
}
/// <summary>
/// 获取一个共享的材质
/// </summary>
/// <param name="owner">资源绑定对象</param>
/// <param name="resname">资源名</param>
/// <param name="assetname">Asset名</param>
/// <param name="callback">资源回调</param>
/// <param name="loadtype">资源加载类型</param>
/// <param name="loadmethod">资源加载方式</param>
/// <returns></returns>
public void getShareMaterial(UnityEngine.Object owner, string resname, string assetname = null, Action <Material> callback = null, ResourceLoadType loadtype = ResourceLoadType.NormalLoad, ResourceLoadMethod loadmethod = ResourceLoadMethod.Sync)
{
if (string.IsNullOrEmpty(assetname))
{
assetname = resname;
}
ResourceModuleManager.Singleton.requstResource(resname,
(abi) =>
{
var material = abi.getAsset <Material>(owner, assetname);
#if UNITY_EDITOR
ResourceUtility.FindMaterialShaderBack(material);
#endif
callback?.Invoke(material);
},
loadtype,
loadmethod);
}
/// <summary> /// 真正的请求资源(由不同的资源模块去实现) /// </summary> /// <param name="resname">资源AB名</param> /// <param name="completehandler">加载完成上层回调</param> /// <param name="loadtype">资源加载类型</param> /// <param name="loadmethod">资源加载方式</param> protected abstract void realRequestResource(string resname, LoadResourceCompleteHandler completehandler, ResourceLoadType loadtype = ResourceLoadType.NormalLoad, ResourceLoadMethod loadmethod = ResourceLoadMethod.Sync);
/// <summary>
/// 真正的请求资源
/// </summary>
/// <param name="respath">资源AB路径</param>
/// <param name="completehandler">加载完成上层回调</param>
/// <param name="loadtype">资源加载类型</param>
/// <param name="loadmethod">资源加载方式</param>
protected override void realRequestResource(string respath, LoadResourceCompleteHandler completehandler, ResourceLoadType loadtype = ResourceLoadType.NormalLoad, ResourceLoadMethod loadmethod = ResourceLoadMethod.Sync)
{
// 如果资源已经加载完成，直接返回
if (mAllLoadedResourceInfoMap[ResourceLoadType.NormalLoad].ContainsKey(respath))
{
completehandler(mAllLoadedResourceInfoMap[ResourceLoadType.NormalLoad][respath]);
if (loadtype > ResourceLoadType.NormalLoad)
{
updateLoadedResourceInfoLoadType(respath, ResourceLoadType.NormalLoad, loadtype);
}
}
else if (mAllLoadedResourceInfoMap[ResourceLoadType.Preload].ContainsKey(respath))
{
completehandler(mAllLoadedResourceInfoMap[ResourceLoadType.Preload][respath]);
if (loadtype > ResourceLoadType.Preload)
{
updateLoadedResourceInfoLoadType(respath, ResourceLoadType.Preload, loadtype);
}
}
else if (mAllLoadedResourceInfoMap[ResourceLoadType.PermanentLoad].ContainsKey(respath))
{
completehandler(mAllLoadedResourceInfoMap[ResourceLoadType.PermanentLoad][respath]);
}
else
{
AssetDatabaseLoader adloader = createADLoader(respath);
//暂时默认都当同步加载，不支持异步模拟
adloader.LoadMethod = loadmethod;
adloader.LoadType = loadtype;
adloader.LoadResourceCompleteCallBack = completehandler;
adloader.LoadSelfResourceCompleteNotifier = onResourceLoadCompleteNotifier;
mResourceRequestTaskMap.Add(respath, adloader);
adloader.startLoad();
}
}
/// <summary>
/// 获取一个材质
/// </summary>
/// <param name="owner">资源绑定对象</param>
/// <param name="respath">资源路径</param>
/// <param name="callback">资源回调</param>
/// <param name="loadtype">资源加载类型</param>
/// <param name="loadmethod">资源加载方式</param>
/// <returns></returns>
public void getMaterial(UnityEngine.Object owner, string respath, Action <Material> callback = null, ResourceLoadType loadtype = ResourceLoadType.NormalLoad, ResourceLoadMethod loadmethod = ResourceLoadMethod.Sync)
{
ResourceModuleManager.Singleton.requstResource(respath,
(abi) =>
{
var assetname = Path.GetFileName(respath);
var material = abi.getAsset <Material>(owner, assetname);
#if UNITY_EDITOR
ResourceUtility.FindMaterialShaderBack(material);
#endif
callback?.Invoke(material);
},
loadtype,
loadmethod);
}
/// <summary>
/// 设置Image指定图片(从Sprite Atlas里)
/// </summary>
/// <param name="timg">Image组件</param>
/// <param name="atlasname">图集名</param>
/// <param name="spritename">图片名</param>
/// <param name="loadtype">资源加载类型</param>
/// <param name="loadmethod">资源加载方式</param>
/// <returns></returns>
public void setImageSpriteAtlas(TImage timg, string atlasname, string spritename, ResourceLoadType loadtype = ResourceLoadType.NormalLoad, ResourceLoadMethod loadmethod = ResourceLoadMethod.Sync)
{
DIYLog.Assert(timg == null, "setImageSpriteAtlas不允许传空TImage!");
ResourceModuleManager.Singleton.requstResource(atlasname,
(abi) =>
{
DIYLog.Log("加载SpriteAtlas AB完成!");
// 清除老的资源引用
if (timg.ABI != null && !string.IsNullOrEmpty(timg.AtlasName))
{
timg.ABI.releaseOwner(timg);
}
if (abi != null)
{
DIYLog.Log("加载SpriteAtlas之前!");
var spriteatlas = abi.getAsset <SpriteAtlas>(timg, atlasname);
DIYLog.Log("加载SpriteAtlas之后!");
timg.sprite = spriteatlas.GetSprite(spritename);
DIYLog.Log("SpriteAtlas.GetSprite()之后!");
}
timg.ABI = abi;
timg.AtlasName = atlasname;
timg.SpriteName = spritename;
},
loadtype,
loadmethod);
}
/// <summary>
/// 设置Image指定图片
/// </summary>
/// <param name="img">Image组件</param>
/// <param name="atlasname">图集名</param>
/// <param name="spritename">图片名</param>
/// <param name="loadtype">资源加载类型</param>
/// <param name="loadmethod">资源加载方式</param>
/// <returns></returns>
public void setImageSprite(Image img, string atlasname, string spritename, ResourceLoadType loadtype = ResourceLoadType.NormalLoad, ResourceLoadMethod loadmethod = ResourceLoadMethod.Sync)
{
ResourceModuleManager.Singleton.requstResource(atlasname,
(abi) =>
{
var sprite = abi.getAsset <Sprite>(img, spritename);
img.sprite = sprite;
},
loadtype,
loadmethod);
}
/// <summary>
/// 加载所有Shader
/// </summary>
/// <param name="respath">资源路径</param>
/// <param name="callback">资源会动啊</param>
/// <param name="loadtype">资源加载类型</param>
/// <param name="loadmethod">资源加载方式</param>
public void loadAllShader(string respath, Action callback, ResourceLoadType loadtype = ResourceLoadType.NormalLoad, ResourceLoadMethod loadmethod = ResourceLoadMethod.Sync)
{
ResourceModuleManager.Singleton.requstResource(
respath,
(abi) =>
{
var svc = abi.loadAsset <ShaderVariantCollection>(ResourceConstData.ShaderVariantsAssetName);
// Shader通过预加载ShaderVariantsCollection里指定的Shader来进行预编译
svc?.WarmUp();
// SVC的WarmUp就会触发相关Shader的预编译，触发预编译之后再加载Shader Asset即可
abi.loadAllAsset <Shader>();
callback?.Invoke();
},
loadtype,
loadmethod);
}
/// <summary>
/// 设置Image指定图片(单图的时候)
/// </summary>
/// <param name="img">Image组件</param>
/// <param name="spritepath">Sprite路径</param>
/// <param name="loadtype">资源加载类型</param>
/// <param name="loadmethod">资源加载方式</param>
/// <returns></returns>
public void setImageSingleSprite(Image img, string spritepath, ResourceLoadType loadtype = ResourceLoadType.NormalLoad, ResourceLoadMethod loadmethod = ResourceLoadMethod.Sync)
{
DIYLog.Assert(img == null, "setImageSingleSprite!");
ResourceModuleManager.Singleton.requstResource(spritepath,
(abi) =>
{
// Sprite统一为小写
var spritename = Path.GetFileNameWithoutExtension(spritepath).ToLower();
var sprite = abi.getAsset <Sprite>(img, spritename);
img.sprite = sprite;
},
loadtype,
loadmethod);
}
/// <summary>
/// 加载指定图集
/// </summary>
/// <param name="atlasname">图集名</param>
/// <param name="callback">资源回调</param>
/// <param name="loadtype">资源加载类型</param>
/// <param name="loadmethod">资源加载方式</param>
public void loadAtlas(string atlasname, Action callback, ResourceLoadType loadtype = ResourceLoadType.NormalLoad, ResourceLoadMethod loadmethod = ResourceLoadMethod.Sync)
{
ResourceModuleManager.Singleton.requstResource(
atlasname,
(abi) =>
{
abi.loadAllAsset <Sprite>();
callback?.Invoke();
},
loadtype,
loadmethod);
}
/// <summary>
/// 设置Image指定图片
/// </summary>
/// <param name="trawimg">Image组件</param>
/// <param name="texturepath">纹理路径</param>
/// <param name="loadtype">资源加载类型</param>
/// <param name="loadmethod">资源加载方式</param>
/// <returns></returns>
public void setRawImage(TRawImage trawimg, string texturepath, ResourceLoadType loadtype = ResourceLoadType.NormalLoad, ResourceLoadMethod loadmethod = ResourceLoadMethod.Sync)
{
DIYLog.Assert(trawimg == null, "setRawImage不允许传空TRawImage!");
ResourceModuleManager.Singleton.requstResource(texturepath,
(abi) =>
{
// 清除老的资源引用
if (trawimg.ABI != null && !string.IsNullOrEmpty(trawimg.TextureName))
{
trawimg.ABI.releaseOwner(trawimg);
}
var assetname = Path.GetFileName(texturepath);
if (abi != null)
{
var texture = abi.getAsset <Texture>(trawimg, assetname);
trawimg.texture = texture;
}
trawimg.ABI = abi;
trawimg.TextureName = texturepath;
},
loadtype,
loadmethod);
}
/// <summary>
/// 设置TImage指定图片(单图的时候)
/// </summary>
/// <param name="timg">TImage组件</param>
/// <param name="spritepath">Sprite路径</param>
/// <param name="loadtype">资源加载类型</param>
/// <param name="loadmethod">资源加载方式</param>
/// <returns></returns>
public void setTImageSingleSprite(TImage timg, string spritepath, ResourceLoadType loadtype = ResourceLoadType.NormalLoad, ResourceLoadMethod loadmethod = ResourceLoadMethod.Sync)
{
DIYLog.Assert(timg == null, "setTImageSingleSprite!");
ResourceModuleManager.Singleton.requstResource(spritepath,
(abi) =>
{
// 清除老的资源引用
if (timg.ABI != null && !string.IsNullOrEmpty(timg.AtlasPath))
{
timg.ABI.releaseOwner(timg);
}
if (abi != null)
{
// Sprite统一为小写
var spritename = Path.GetFileNameWithoutExtension(spritepath).ToLower();
var sprite = abi.getAsset <Sprite>(timg, spritename);
timg.sprite = sprite;
timg.ABI = abi;
timg.AtlasPath = spritepath;
timg.SpriteName = spritename;
}
else
{
timg.ABI = null;
timg.AtlasPath = string.Empty;
timg.SpriteName = string.Empty;
}
},
loadtype,
loadmethod);
}
/// <summary>
/// 设置Image指定图片(从Sprite Atlas里)
/// </summary>
/// <param name="timg">Image组件</param>
/// <param name="atlaspath">图集路径</param>
/// <param name="spritename">Sprite名</param>
/// <param name="loadtype">资源加载类型</param>
/// <param name="loadmethod">资源加载方式</param>
/// <returns></returns>
public void setImageSpriteAtlas(TImage timg, string atlaspath, string spritename, ResourceLoadType loadtype = ResourceLoadType.NormalLoad, ResourceLoadMethod loadmethod = ResourceLoadMethod.Sync)
{
DIYLog.Assert(timg == null, "setImageSpriteAtlas不允许传空TImage!");
ResourceModuleManager.Singleton.requstResource(atlaspath,
(abi) =>
{
DIYLog.Log("加载SpriteAtlas AB完成!");
// 清除老的资源引用
if (timg.ABI != null && !string.IsNullOrEmpty(timg.AtlasPath))
{
timg.ABI.releaseOwner(timg);
}
if (abi != null)
{
var atlasname = Path.GetFileNameWithoutExtension(atlaspath);
DIYLog.Log("加载SpriteAtlas之前!");
var spriteatlas = abi.getAsset <SpriteAtlas>(timg, atlasname);
DIYLog.Log("加载SpriteAtlas之后!");
// Sprite统一为小写
spritename = spritename.ToLower();
timg.sprite = spriteatlas.GetSprite(spritename);
DIYLog.Log("SpriteAtlas.GetSprite()之后!");
timg.ABI = abi;
timg.AtlasPath = atlaspath;
timg.SpriteName = spritename;
}
else
{
timg.ABI = null;
timg.AtlasPath = string.Empty;
timg.SpriteName = string.Empty;
}
},
loadtype,
loadmethod);
}
/// <summary>
/// 请求资源
/// 资源加载统一入口
/// </summary>
/// <param name="resname">资源AB名</param>
/// <param name="completehandler">加载完成上层回调</param>
/// <param name="loadtype">资源加载类型</param>
/// <param name="loadmethod">资源加载方式</param>
public void requstResource(string resname, AbstractResourceModule.LoadResourceCompleteHandler completehandler, ResourceLoadType loadtype = ResourceLoadType.NormalLoad, ResourceLoadMethod loadmethod = ResourceLoadMethod.Sync)
{
CurrentResourceModule.requstResource(resname, completehandler, loadtype, loadmethod);
}
/// <summary>
/// 设置Image指定图片
/// </summary>
/// <param name="timg">Image组件</param>
/// <param name="atlasname">图集名</param>
/// <param name="spritename">图片名</param>
/// <param name="loadtype">资源加载类型</param>
/// <param name="loadmethod">资源加载方式</param>
/// <returns></returns>
public void setImageSprite(TImage timg, string atlasname, string spritename, ResourceLoadType loadtype = ResourceLoadType.NormalLoad, ResourceLoadMethod loadmethod = ResourceLoadMethod.Sync)
{
DIYLog.Assert(timg == null, "setImageSprite不允许传空TImage!");
ResourceModuleManager.Singleton.requstResource(atlasname,
(abi) =>
{
// 清除老的资源引用
if (timg.ABI != null)
{
timg.ABI.releaseOwner(timg);
}
if (abi != null)
{
var sprite = abi.getAsset <Sprite>(timg, spritename);
timg.sprite = sprite;
}
timg.ABI = abi;
timg.AtlasName = atlasname;
timg.SpriteName = spritename;
},
loadtype,
loadmethod);
}
/// <summary>
/// 获取指定音效
/// </summary>
/// <param name="owner"></param>
/// <param name="respath"></param>
/// <param name="callback"></param>
/// <param name="loadtype"></param>
/// <param name="loadmethod"></param>
public void getAudioClip(UnityEngine.Object owner, string respath, Action <AudioClip> callback = null, ResourceLoadType loadtype = ResourceLoadType.NormalLoad, ResourceLoadMethod loadmethod = ResourceLoadMethod.Sync)
{
ResourceModuleManager.Singleton.requstResource(respath,
(ari) =>
{
var assetname = Path.GetFileName(respath);
var clip = ari.getAsset <AudioClip>(owner, assetname);
callback?.Invoke(clip);
},
loadtype,
loadmethod);
}
/// <summary>
/// 真正的请求资源
/// </summary>
/// <param name="respath">资源AB路径</param>
/// <param name="completehandler">加载完成上层回调</param>
/// <param name="loadtype">资源加载类型</param>
/// <param name="loadmethod">资源加载方式</param>
protected override void realRequestResource(string respath, LoadResourceCompleteHandler completehandler, ResourceLoadType loadtype = ResourceLoadType.NormalLoad, ResourceLoadMethod loadmethod = ResourceLoadMethod.Sync)
{
// AB运行时统一转成小写,避免和AB打包那方输出的信息不一致
respath = respath.ToLower();
var abpath = string.Empty;
// 因为依赖AB加载也是走统一入口，所以要区分是AB路径还是Asset路径
if (!mAssetBundleBuildInfo.isABPath(respath))
{
// AB依赖信息文件和AB打包
abpath = getAssetPathAssetBundleName(respath);
}
else
{
abpath = respath;
}
// 如果资源已经加载完成，直接返回
if (mAllLoadedResourceInfoMap[ResourceLoadType.NormalLoad].ContainsKey(abpath))
{
completehandler(mAllLoadedResourceInfoMap[ResourceLoadType.NormalLoad][abpath]);
if (loadtype > ResourceLoadType.NormalLoad)
{
updateLoadedResourceInfoLoadType(abpath, ResourceLoadType.NormalLoad, loadtype);
}
}
else if (mAllLoadedResourceInfoMap[ResourceLoadType.Preload].ContainsKey(abpath))
{
completehandler(mAllLoadedResourceInfoMap[ResourceLoadType.Preload][abpath]);
if (loadtype > ResourceLoadType.Preload)
{
updateLoadedResourceInfoLoadType(abpath, ResourceLoadType.Preload, loadtype);
}
}
else if (mAllLoadedResourceInfoMap[ResourceLoadType.PermanentLoad].ContainsKey(abpath))
{
completehandler(mAllLoadedResourceInfoMap[ResourceLoadType.PermanentLoad][abpath]);
}
else
{
// 确保同一个资源加载的Loader是同一个
// 保证同一个资源加载完成时上层所有加载该资源的回调正确
AssetBundleLoader abloader = null;
if (mABRequestTaskMap.ContainsKey(abpath))
{
abloader = mABRequestTaskMap[abpath];
// 之前有请求resname资源，但还未完成
// 比如先异步请求resname，在异步完成前来了一个同步请求resname
// 修改加载方式并添加回调，调用同步加载方式，异步加载会在同步加载完成时一起回调
abloader.LoadMethod = loadmethod;
abloader.LoadType = loadtype;
abloader.LoadABCompleteCallBack += completehandler;
abloader.LoadSelfABCompleteNotifier = onABLoadCompleteNotifier;
if (loadmethod == ResourceLoadMethod.Sync)
{
ResourceLogger.log(string.Format("请求同步加载一个异步加载状态:{0}的资源 : {1}", abloader.LoadState.ToString(), abloader.AssetBundlePath));
//重置AB加载状态，走同步加载模式
abloader.LoadState = ResourceLoadState.None;
abloader.startLoad();
}
}
else
{
abloader = createABLoader(abpath);
abloader.LoadMethod = loadmethod;
abloader.LoadType = loadtype;
abloader.LoadABCompleteCallBack = completehandler;
abloader.LoadSelfABCompleteNotifier = onABLoadCompleteNotifier;
mABRequestTaskMap.Add(abpath, abloader);
abloader.startLoad();
}
}
}
/// <summary>
/// 获取一个实例资源对象
/// </summary>
/// <param name="respath">资源路径</param>
/// <param name="callback">资源回调</param>
/// <param name="loadtype">资源加载类型</param>
/// <param name="loadmethod">资源加载方式</param>
/// <returns></returns>
public void getPrefabInstance(string respath, Action <GameObject> callback = null, ResourceLoadType loadtype = ResourceLoadType.NormalLoad, ResourceLoadMethod loadmethod = ResourceLoadMethod.Sync)
{
ResourceModuleManager.Singleton.requstResource(respath,
(abi) =>
{
var assetname = Path.GetFileName(respath);
var prefabinstance = abi.instantiateAsset(assetname);
#if UNITY_EDITOR
ResourceUtility.FindMeshRenderShaderBack(prefabinstance);
#endif
callback?.Invoke(prefabinstance);
},
loadtype,
loadmethod);
}
/// <summary>
/// 请求资源
/// 上层资源加载统一入口
/// </summary>
/// <param name="resname">资源AB名</param>
/// <param name="completehandler">加载完成上层回调</param>
/// <param name="loadtype">资源加载类型</param>
/// <param name="loadmethod">资源加载方式</param>
public void requstResource(string resname, LoadResourceCompleteHandler completehandler, ResourceLoadType loadtype = ResourceLoadType.NormalLoad, ResourceLoadMethod loadmethod = ResourceLoadMethod.Sync)
{
// 在白名单里的资源一律以预加载形式加载，
// 避免因为上层逻辑错误加载后被频繁加载卸载
if (mResourceWhileListMap.ContainsKey(resname))
{
loadtype = ResourceLoadType.Preload;
}
realRequestResource(resname, completehandler, loadtype, loadmethod);
}
/// <summary>
/// 真正的请求资源
/// </summary>
/// <param name="resname">资源AB名</param>
/// <param name="completehandler">加载完成上层回调</param>
/// <param name="loadtype">资源加载类型</param>
/// <param name="loadmethod">资源加载方式</param>
protected override void realRequestResource(string resname, LoadResourceCompleteHandler completehandler, ResourceLoadType loadtype = ResourceLoadType.NormalLoad, ResourceLoadMethod loadmethod = ResourceLoadMethod.Sync)
{
// 如果资源已经加载完成，直接返回
if (mAllLoadedResourceInfoMap[ResourceLoadType.NormalLoad].ContainsKey(resname))
{
completehandler(mAllLoadedResourceInfoMap[ResourceLoadType.NormalLoad][resname]);
if (loadtype > ResourceLoadType.NormalLoad)
{
updateLoadedResourceInfoLoadType(resname, ResourceLoadType.NormalLoad, loadtype);
}
}
else if (mAllLoadedResourceInfoMap[ResourceLoadType.Preload].ContainsKey(resname))
{
completehandler(mAllLoadedResourceInfoMap[ResourceLoadType.Preload][resname]);
if (loadtype > ResourceLoadType.Preload)
{
updateLoadedResourceInfoLoadType(resname, ResourceLoadType.Preload, loadtype);
}
}
else if (mAllLoadedResourceInfoMap[ResourceLoadType.PermanentLoad].ContainsKey(resname))
{
completehandler(mAllLoadedResourceInfoMap[ResourceLoadType.PermanentLoad][resname]);
}
else
{
// 确保同一个资源加载的Loader是同一个
// 保证同一个资源加载完成时上层所有加载该资源的回调正确
AssetBundleLoader abloader = null;
if (mABRequestTaskMap.ContainsKey(resname))
{
abloader = mABRequestTaskMap[resname];
// 之前有请求resname资源，但还未完成
// 比如先异步请求resname，在异步完成前来了一个同步请求resname
// 修改加载方式并添加回调，调用同步加载方式，异步加载会在同步加载完成时一起回调
abloader.LoadMethod = loadmethod;
abloader.LoadType = loadtype;
abloader.LoadABCompleteCallBack += completehandler;
abloader.LoadSelfABCompleteNotifier = onABLoadCompleteNotifier;
if (loadmethod == ResourceLoadMethod.Sync)
{
ResourceLogger.log(string.Format("请求同步加载一个正在异步加载的资源 : {0}", abloader.AssetBundleName));
//重置AB加载状态，走同步加载模式
abloader.LoadState = ResourceLoadState.None;
abloader.startLoad();
}
}
else
{
abloader = createABLoader(resname);
abloader.LoadMethod = loadmethod;
abloader.LoadType = loadtype;
abloader.LoadABCompleteCallBack = completehandler;
abloader.LoadSelfABCompleteNotifier = onABLoadCompleteNotifier;
mABRequestTaskMap.Add(resname, abloader);
abloader.startLoad();
}
}
}
/// <summary>
/// 获取模型实例对象
/// </summary>
/// <param name="resname"></param>
/// <param name="callback"></param>
/// <param name="loadtype"></param>
/// <param name="loadmethod"></param>
public void getModelInstance(string resname, Action <GameObject> callback, ResourceLoadType loadtype = ResourceLoadType.NormalLoad, ResourceLoadMethod loadmethod = ResourceLoadMethod.Sync)
{
ResourceModuleManager.Singleton.requstResource(
resname,
(abi) =>
{
var modelinstance = abi.instantiateAsset(resname);
#if UNITY_EDITOR
ResourceUtility.FindMeshRenderShaderBack(modelinstance);
#endif
callback(modelinstance);
});
}