一、读取AssetBundle 依赖关系清单文件’
/***
*
* Title: "AssetBundle简单框架"项目
* 辅助类：
* 读取AssetBundle 依赖关系清单文件。（Windows.Manifest）
*
* Description:
* 功能：
*
* Author: Liuguozhu
*
* Date: 2017.10
*
* Modify：
*
*/
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace ABFW
{
public class ABManifestLoader : System.IDisposable
{
//本类实例
private static ABManifestLoader _Instance;
//Assetbundle (清单文件) 系统类
private AssetBundleManifest _ManifestObj;
//AssetBundle 清单文件的路径
private string _StrManifestPath;
//读取AB清单文件的AssetBundel
private AssetBundle _ABReadManifest;
//是否加载（Manifest ）完成
private bool _IsLoadFinish;
/* 只读属性*/
public bool IsLoadFinish
{
get { return _IsLoadFinish; }
}
//构造函数
private ABManifestLoader()
{
//确定清单文件WWW下载路径
_StrManifestPath = PathTools.GetWWWPath() + "/" + PathTools.GetPlatformName();
_ManifestObj = null;
_ABReadManifest = null;
_IsLoadFinish = false;
}
/// <summary>
/// 获取本类实例
/// </summary>
/// <returns></returns>
public static ABManifestLoader GetInstance()
{
if (_Instance==null)
{
_Instance = new ABManifestLoader();
}
return _Instance;
}
//加载Manifest 清单文件
public IEnumerator LoadMainifestFile()
{
using (WWW www=new WWW(_StrManifestPath))
{
yield return www;
if (www.progress >= 1)
{
//加载完成，获取AssetBundle 实例
AssetBundle abObj = www.assetBundle;
if (abObj != null)
{
_ABReadManifest = abObj;
//读取清单文件资源。（读取到系统类的实例中。）
_ManifestObj = _ABReadManifest.LoadAsset(ABDefine.ASSETBUNDLE_MANIFEST) as AssetBundleManifest;
//本次加载与读取清单文件完毕。
_IsLoadFinish = true;
}
else {
Debug.Log(GetType()+ "/LoadMainifestFile()/WWW下载出错，请检查！ _StrManifestPath="+ _StrManifestPath+" 错误信息： "+www.error);
}
}
}
}
/// <summary>
/// 获取AssetBundleManifest 系统类实例
/// </summary>
/// <returns></returns>
public AssetBundleManifest GetABManifest()
{
if (_IsLoadFinish)
{
if (_ManifestObj != null)
{
return _ManifestObj;
}
else
{
Debug.Log(GetType() + "/GetABManifest()/_ManifestObj==null ! 请检查");
}
}
else {
Debug.Log(GetType() + "/GetABManifest()/_IsLoadFinish==false , Manifest没有加载完毕，请检查！");
}
return null;
}
/// <summary>
/// 获取AssetBundleManifest（系统类) 指定包名称依赖项
/// </summary>
/// <param name="abName">AB包名称</param>
/// <returns></returns>
public string[] RetrivalDependce(string abName)
{
if (_ManifestObj!=null && !string.IsNullOrEmpty(abName))
{
return _ManifestObj.GetAllDependencies(abName);
}
return null;
}
/// <释放本类资源summary>
/// 释放本类资源
/// </summary>
public void Dispose()
{
if (_ABReadManifest!=null)
{
_ABReadManifest.Unload(true);
}
}
}
}
二、AssetBundle 关系类
/***
*
* Title: "AssetBundle简单框架"项目
* 工具辅助类：
* AssetBundle 关系类
*
* Description:
* 功能：
* 1: 存储指定AB包的所有依赖关系包
* 2: 存储指定AB包所有的引用关系包
*
* Author: Liuguozhu
*
* Date: 2017.10
*
* Modify：
*
*/
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace ABFW
{
public class ABRelation
{
//当前AsseetBundel 名称
private string _ABName;
//本包所有的依赖包集合
private List<string> _LisAllDependenceAB;
//本包所有的引用包集合
private List<string> _lisAllReferenceAB;
/// <summary>
/// 构造函数
/// </summary>
/// <param name="abName"></param>
public ABRelation(string abName)
{
if (!string.IsNullOrEmpty(abName))
{
_ABName = abName;
}
_LisAllDependenceAB = new List<string>();
_lisAllReferenceAB = new List<string>();
}
/* 依赖关系 */
/// <summary>
/// 增加依赖关系
/// </summary>
/// <param name="abName">AssetBundle 包名称</param>
public void AddDependence(string abName)
{
if (!_LisAllDependenceAB.Contains(abName))
{
_LisAllDependenceAB.Add(abName);
}
}
/// <summary>
/// 移除依赖关系
/// </summary>
/// <param name="abName">移除的包名称</param>
/// <returns>
/// true； 此AssetBundel 没有依赖项
/// false; 此AssetBundel 还有其他的依赖项
///
/// </returns>
public bool RemoveDependece(string abName)
{
if (_LisAllDependenceAB.Contains(abName))
{
_LisAllDependenceAB.Remove(abName);
}
if (_LisAllDependenceAB.Count > 0)
{
return false;
}
else {
return true;
}
}
//获取所有依赖关系
public List<string> GetAllDependence()
{
return _LisAllDependenceAB;
}
/* 引用关系 */
/// <summary>
/// 引用依赖关系
/// </summary>
/// <param name="abName">AssetBundle 包名称</param>
public void AddReference(string abName)
{
if (!_lisAllReferenceAB.Contains(abName))
{
_lisAllReferenceAB.Add(abName);
}
}
/// <summary>
/// 移除引用关系
/// </summary>
/// <param name="abName">移除的包名称</param>
/// <returns>
/// true； 此AssetBundel 没有引用项
/// false; 此AssetBundel 还有其他的引用项
///
/// </returns>
public bool RemoveReference(string abName)
{
if (_lisAllReferenceAB.Contains(abName))
{
_lisAllReferenceAB.Remove(abName);
}
if (_lisAllReferenceAB.Count > 0)
{
return false;
}
else
{
return true;
}
}
//获取所有引用关系
public List<string> GetAllReference()
{
return _lisAllReferenceAB;
}
}
}
三、所有“场景”的AssetBundle 管理
/***
*
* Title: "AssetBundle简单框架"项目
* 框架主流程(第4层): 所有“场景”的AssetBundle 管理。
*
* Description:
* 功能：
* 1: 提取“Menifest 清单文件”，缓存本脚本。
* 2：以“场景”为单位，管理整个项目中所有的AssetBundle 包。
*
* Author: Liuguozhu
*
* Date: 2017.10
*
* Modify：
*
*/
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace ABFW
{
public class AssetBundleMgr:MonoBehaviour
{
//本类实例
private static AssetBundleMgr _Instance;
//场景集合
private Dictionary<string, MultiABMgr> _DicAllScenes = new Dictionary<string, MultiABMgr>();
//AssetBundle （清单文件） 系统类
private AssetBundleManifest _ManifestObj = null;
private AssetBundleMgr(){}
//得到本类实例
public static AssetBundleMgr GetInstance()
{
if (_Instance==null)
{
_Instance = new GameObject("_AssetBundleMgr").AddComponent<AssetBundleMgr>();
}
return _Instance;
}
void Awake()
{
//加载Manifest清单文件
StartCoroutine(ABManifestLoader.GetInstance().LoadMainifestFile());
}
/// <summary>
/// 下载AssetBundel 指定包
/// </summary>
/// <param name="scenesName">场景名称</param>
/// <param name="abName">AssetBundle 包名称</param>
/// <param name="loadAllCompleteHandle">委托： 调用是否完成</param>
/// <returns></returns>
public IEnumerator LoadAssetBundlePack(string scenesName, string abName, DelLoadComplete loadAllCompleteHandle)
{
//参数检查
if (string.IsNullOrEmpty(scenesName) || string.IsNullOrEmpty(abName))
{
Debug.LogError(GetType()+ "/LoadAssetBundlePack()/ScenesName Or abName is null ,请检查！");
yield return null;
}
//等待Manifest清单文件加载完成
while (!ABManifestLoader.GetInstance().IsLoadFinish)
{
yield return null;
}
_ManifestObj = ABManifestLoader.GetInstance().GetABManifest();
if (_ManifestObj==null)
{
Debug.LogError(GetType() + "/LoadAssetBundlePack()/_ManifestObj is null ,请先确保加载Manifest清单文件！");
yield return null;
}
//把当前场景加入集合中。
if (!_DicAllScenes.ContainsKey(scenesName))
{
MultiABMgr multiMgrObj = new MultiABMgr(scenesName,abName, loadAllCompleteHandle);
_DicAllScenes.Add(scenesName, multiMgrObj);
}
//调用下一层（“多包管理类”）
MultiABMgr tmpMultiMgrObj = _DicAllScenes[scenesName];
if (tmpMultiMgrObj==null)
{
Debug.LogError(GetType() + "/LoadAssetBundlePack()/tmpMultiMgrObj is null ,请检查！");
}
//调用“多包管理类”的加载指定AB包。
yield return tmpMultiMgrObj.LoadAssetBundeler(abName);
}//Method_end
/// <summary>
/// 加载(AB 包中)资源
/// </summary>
/// <param name="scenesName">场景名称</param>
/// <param name="abName">AssetBundle 包名称</param>
/// <param name="assetName">资源名称</param>
/// <param name="isCache">是否使用缓存</param>
/// <returns></returns>
public UnityEngine.Object LoadAsset(string scenesName, string abName, string assetName ,bool isCache)
{
if (_DicAllScenes.ContainsKey(scenesName))
{
MultiABMgr multObj = _DicAllScenes[scenesName];
return multObj.LoadAsset(abName, assetName, isCache);
}
Debug.LogError(GetType()+ "/LoadAsset()/找不到场景名称，无法加载（AB包中）资源,请检查！ scenesName="+ scenesName);
return null;
}
/// <summary>
/// 释放资源。
/// </summary>
/// <param name="scenesName">场景名称</param>
public void DisposeAllAssets(string scenesName)
{
if (_DicAllScenes.ContainsKey(scenesName))
{
MultiABMgr multObj = _DicAllScenes[scenesName];
multObj.DisposeAllAsset();
}
else {
Debug.LogError(GetType() + "/DisposeAllAssets()/找不到场景名称，无法释放资源，请检查！ scenesName=" + scenesName);
}
}
}//Class_end
}
四、AB（AssetBundle）资源加载类
/***
*
* Title: "AssetBundle简单框架"项目
* 框架主流程：
* 第1层： AB（AssetBundle）资源加载类
*
*
* Description:
* 功能：
* 1： 管理与加载指定AB的资源。
* 2： 加载具有“缓存功能”的资源，带选用参数。
* 3： 卸载、释放AB资源。
* 4： 查看当前AB资源。
*
* Author: Liuguozhu
*
* Date: 2017.10
*
* Modify：
*
*/
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace ABFW
{
public class AssetLoader : System.IDisposable
{
//当前Assetbundle
private AssetBundle _CurrentAssetBundle;
//缓存容器集合
private Hashtable _Ht;
/// <summary>
/// 构造函数
/// </summary>
/// <param name="abObj">给定WWW加载的AssetBundle 实例</param>
public AssetLoader(AssetBundle abObj)
{
if (abObj != null)
{
_CurrentAssetBundle = abObj;
_Ht = new Hashtable();
}
else {
Debug.Log(GetType()+"/ 构造函数 AssetBundle()/ 参数 abObj==null! ,请检查");
}
}
/// <summary>
/// 加载当前包中指定的资源
/// </summary>
/// <param name="assetName">资源的名称</param>
/// <param name="isCache">是否开启缓存</param>
/// <returns></returns>
public UnityEngine.Object LoadAsset(string assetName,bool isCache=false)
{
return LoadResource<UnityEngine.Object>(assetName, isCache);
}
/// <summary>
/// 加载当前AB包的资源，带缓存
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="assetName">资源的名称</param>
/// <param name="isCache">是否需要缓存处理</param>
/// <returns></returns>
private T LoadResource<T>(string assetName,bool isCache) where T : UnityEngine.Object
{
//是否缓存集合已经存在
if (_Ht.Contains(assetName))
{
return _Ht[assetName] as T;
}
//正式加载
T tmpTResource=_CurrentAssetBundle.LoadAsset<T>(assetName);
//加入缓存集合
if (tmpTResource != null && isCache)
{
_Ht.Add(assetName, tmpTResource);
} else if (tmpTResource==null)
{
Debug.LogError(GetType()+ "/LoadResource<T>()/参数 tmpTResources==null, 请检查！");
}
return tmpTResource;
}
/// <summary>
/// 卸载指定的资源
/// </summary>
/// <param name="asset">资源名称</param>
/// <returns></returns>
public bool UnLoadAsset(UnityEngine.Object asset)
{
if(asset!=null)
{
Resources.UnloadAsset(asset);
return true;
}
Debug.LogError(GetType()+ "/UnLoadAsset()/参数 asset==null ,请检查！");
return false;
}
/// <summary>
/// 释放当前AssetBundle内存镜像资源
/// </summary>
public void Dispose()
{
_CurrentAssetBundle.Unload(false);
}
/// <summary>
/// 释放当前AssetBundle内存镜像资源,且释放内存资源。
/// </summary>
public void DisposeALL()
{
_CurrentAssetBundle.Unload(true);
}
/// <summary>
/// 查询当前AssetBundle中包含的所有资源名称。
/// </summary>
/// <returns></returns>
public string[] RetriveAllAssetName()
{
return _CurrentAssetBundle.GetAllAssetNames();
}
}
}
五、(一个场景中)多个AssetBundle 包管理
/***
*
* Title: "AssetBundle简单框架"项目
* 主流程（3层）：(一个场景中)多个AssetBundle 包管理
*
* Description:
* 功能：
* 1： 获取AB包之间的依赖与引用关系。
* 2： 管理AssetBundle包之间的自动连锁（递归）加载机制
*
* Author: Liuguozhu
*
* Date: 2017.10
*
* Modify：
*
*/
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace ABFW
{
public class MultiABMgr
{
//（下层）引用类： "单个AB包加载实现类"
private SingleABLoader _CurrentSinglgABLoader;
//“AB包实现类”缓存集合（作用： 缓存AB包，防止重复加载，即： “AB包缓存集合”）
private Dictionary<string, SingleABLoader> _DicSingleABLoaderCache;
//当前场景(调试使用)
private string _CurrentScenesName;
//当前AssetBundle 名称
private string _CurrentABName;
//AB包与对应依赖关系集合
private Dictionary<string, ABRelation> _DicABRelation;
//委托： 所有AB包加载完成。
private DelLoadComplete _LoadAllABPackageCompleteHandel;
/// <summary>
/// 构造函数
/// </summary>
/// <param name="scenesName">场景名称</param>
/// <param name="abName">AB包名称</param>
/// <param name="loadAllABPackCompleteHandle">（委托）是否调用完成</param>
public MultiABMgr(string scenesName,string abName,DelLoadComplete loadAllABPackCompleteHandle)
{
_CurrentScenesName = scenesName;
_CurrentABName = abName;
_DicSingleABLoaderCache = new Dictionary<string, SingleABLoader>();
_DicABRelation = new Dictionary<string, ABRelation>();
//委托
_LoadAllABPackageCompleteHandel = loadAllABPackCompleteHandle;
}
/// <summary>
/// 完成指定AB包调用
/// </summary>
/// <param name="abName">AB包名称</param>
private void CompleteLoadAB(string abName)
{
Debug.Log(GetType() + "/当前完成abName: " + abName + " 包的加载");
if (abName.Equals(_CurrentABName))
{
if (_LoadAllABPackageCompleteHandel!=null)
{
_LoadAllABPackageCompleteHandel(abName);
}
}
}
/// <summary>
/// 加载AB包
/// </summary>
/// <param name="abName">AssetBundle 名称</param>
/// <returns></returns>
public IEnumerator LoadAssetBundeler(string abName)
{
//AB包关系的建立
if (!_DicABRelation.ContainsKey(abName))
{
ABRelation abRelationObj = new ABRelation(abName);
_DicABRelation.Add(abName, abRelationObj);
}
ABRelation tmpABRelationObj = _DicABRelation[abName];
//得到指定AB包所有的依赖关系（查询Manifest清单文件）
string[] strDependeceArray = ABManifestLoader.GetInstance().RetrivalDependce(abName);
foreach (string item_Depence in strDependeceArray)
{
//添加“依赖”项
tmpABRelationObj.AddDependence(item_Depence);
//添加“引用”项 （递归调用）
yield return LoadReference(item_Depence, abName);
}
//真正加载AB包
if (_DicSingleABLoaderCache.ContainsKey(abName))
{
yield return _DicSingleABLoaderCache[abName].LoadAssetBundle();
}
else {
_CurrentSinglgABLoader = new SingleABLoader(abName, CompleteLoadAB);
_DicSingleABLoaderCache.Add(abName, _CurrentSinglgABLoader);
yield return _CurrentSinglgABLoader.LoadAssetBundle();
}
}//Method_end
/// <summary>
/// 加载引用AB包
/// </summary>
/// <param name="abName">AB包名称</param>
/// <param name="refABName">被引用AB包名称</param>
/// <returns></returns>
private IEnumerator LoadReference(string abName,string refABName)
{
//AB包已经加载
if (_DicABRelation.ContainsKey(abName))
{
ABRelation tmpABRelationObj = _DicABRelation[abName];
//添加AB包引用关系（被依赖）
tmpABRelationObj.AddReference(refABName);
}
else {
ABRelation tmpABRelationObj = new ABRelation(abName);
tmpABRelationObj.AddReference(refABName);
_DicABRelation.Add(abName, tmpABRelationObj);
//开始加载依赖的包(这是一个递归调用)
yield return LoadAssetBundeler(abName);
}
}
/// <summary>
/// 加载（AB包中）资源
/// </summary>
/// <param name="abName">AssetBunlde 名称</param>
/// <param name="assetName">资源名称</param>
/// <param name="isCache">是否使用（资源）缓存</param>
/// <returns></returns>
public UnityEngine.Object LoadAsset(string abName, string assetName, bool isCache)
{
foreach (string item_abName in _DicSingleABLoaderCache.Keys)
{
if (abName== item_abName)
{
return _DicSingleABLoaderCache[item_abName].LoadAsset(assetName, isCache);
}
}
Debug.LogError(GetType()+ "/LoadAsset()/找不到AsetBunder包，无法加载资源，请检查！ abName="+ abName+ " assetName="+ assetName);
return null;
}
/// <summary>
/// 释放本场景中所有的资源
/// </summary>
public void DisposeAllAsset()
{
try
{
//逐一释放所有加载过的AssetBundel 包中的资源
foreach (SingleABLoader item_sABLoader in _DicSingleABLoaderCache.Values)
{
item_sABLoader.DisposeALL();
}
}
finally
{
_DicSingleABLoaderCache.Clear();
_DicSingleABLoaderCache = null;
//释放其他对象占用资源
_DicABRelation.Clear();
_DicABRelation = null;
_CurrentABName = null;
_CurrentScenesName = null;
_LoadAllABPackageCompleteHandel = null;
//卸载没有使用到的资源
Resources.UnloadUnusedAssets();
//强制垃圾收集
System.GC.Collect();
}
}
}
}
六、WWW 加载AssetBundel
/***
*
* Title: "AssetBundle简单框架"项目
* 框架主流程：
* 第2层： WWW 加载AssetBundel
*
* Description:
* 功能：
*
* Author: Liuguozhu
*
* Date: 2017.10
*
* Modify：
*
*/
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace ABFW
{
public class SingleABLoader: System.IDisposable
{
//引用类： 资源加载类
private AssetLoader _AssetLoader;
//委托：
private DelLoadComplete _LoadCompleteHandle;
//AssetBundle 名称
private string _ABName;
//AssetBundle 下载路径
private string _ABDownLoadPath;
//构造函数
public SingleABLoader(string abName,DelLoadComplete loadComplete)
{
_AssetLoader = null;
_ABName = abName;
//委托初始化
_LoadCompleteHandle = loadComplete;
//AB包下载路径（初始化）
_ABDownLoadPath = PathTools.GetWWWPath() + "/" + _ABName;
}
//加载AssetBundle 资源包
public IEnumerator LoadAssetBundle()
{
using (WWW www=new WWW(_ABDownLoadPath))
{
yield return www;
//WWW下载AB包完成
if (www.progress>=1)
{
//获取AssetBundle的实例
AssetBundle abObj = www.assetBundle;
if (abObj!=null)
{
//实例化引用类
_AssetLoader = new AssetLoader(abObj);
//AssetBundle 下载完毕，调用委托
if (_LoadCompleteHandle!=null)
{
_LoadCompleteHandle(_ABName);
}
}
else {
Debug.LogError(GetType()+ "/LoadAssetBundle()/WWW 下载出错，请检查！ AssetBundle URL: "+ _ABDownLoadPath+" 错误信息： "+www.error);
}
}
}//using_end
}
/// <summary>
/// 加载（AB包内）资源
/// </summary>
/// <param name="assetName"></param>
/// <param name="isCache"></param>
/// <returns></returns>
public UnityEngine.Object LoadAsset(string assetName,bool isCache)
{
if (_AssetLoader!=null)
{
return _AssetLoader.LoadAsset(assetName,isCache);
}
Debug.LogError(GetType()+ "/LoadAsset()/ 参数_AssetLoader==null ,请检查！");
return null;
}
/// <summary>
/// 卸载（AB包中）资源
/// </summary>
/// <param name="asset"></param>
public void UnLoadAsset(UnityEngine.Object asset)
{
if (_AssetLoader != null)
{
_AssetLoader.UnLoadAsset(asset);
}
else {
Debug.LogError(GetType()+ "/UnLoadAsset()/参数 _AssetLoader==Null , 请检查！");
}
}
/// <summary>
/// 释放资源
/// </summary>
public void Dispose()
{
if (_AssetLoader != null)
{
_AssetLoader.Dispose();
_AssetLoader = null;
}
else
{
Debug.LogError(GetType() + "/Dispose()/参数 _AssetLoader==Null , 请检查！");
}
}
/// <summary>
/// 释放当前AssetBundle资源包,且卸载所有资源
/// </summary>
public void DisposeALL()
{
if (_AssetLoader != null)
{
_AssetLoader.DisposeALL();
_AssetLoader = null;
}
else
{
Debug.LogError(GetType() + "/DisposeALL()/参数 _AssetLoader==Null , 请检查！");
}
}
/// <summary>
/// 查询当前AssetBundle包中所有的资源
/// </summary>
/// <returns></returns>
public string[] RetrivalAllAssetName()
{
if (_AssetLoader != null)
{
return _AssetLoader.RetriveAllAssetName();
}
Debug.LogError(GetType() + "/RetrivalAllAssetName()/参数 _AssetLoader==Null , 请检查！");
return null;
}
}
}
七、框架整体验证测试脚本
/***
*
* Title: "AssetBundle简单框架"项目
* 框架内部验证测试
*
* Description:
* 功能：
* 框架整体验证测试脚本
*
* Author: Liuguozhu
*
* Date: 2017.10
*
* Modify：
*
*/
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace ABFW
{
public class TestClass_ABToolFramework:MonoBehaviour
{
//场景名称
private string _ScenesName = "prefabs";
//AB包名称
private string _AssetBundelName = "prefabs/prefabs.ab";
//资源名称
private string _AssetName = "_Eviromens.prefab";
private void Start()
{
Debug.Log(GetType() + "开始'ABFW'框架测试 ");
//调用AB包（连锁智能调用AB包【集合】）
StartCoroutine(AssetBundleMgr.GetInstance().LoadAssetBundlePack(_ScenesName, _AssetBundelName, LoadAllABComplete));
}
//回调函数： 所有的AB包都已经加载完毕了
private void LoadAllABComplete(string abName)
{
Debug.Log(GetType() + "所有的AB包都已经加载完毕了");
UnityEngine.Object tmpObj = null;
//提取资源
tmpObj=(UnityEngine.Object)AssetBundleMgr.GetInstance().LoadAsset(_ScenesName, _AssetBundelName, _AssetName,false);
if (tmpObj!=null)
{
Instantiate(tmpObj);
}
}
//测试销毁资源
private void Update()
{
if (Input.GetKeyDown(KeyCode.A))
{
Debug.Log(GetType()+" 测试销毁资源");
AssetBundleMgr.GetInstance().DisposeAllAssets(_ScenesName);
}
}
}
}
6927
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
