在Unity3D的网络游戏中实现资源动态加载

用Unity3D制作基于web的网络游戏,不可避免的会用到一个技术-资源动态加载。比如想加载一个大场景的资源,不应该在游戏的开始让用户长时间等待全部资源的加载完毕。应该优先加载用户附近的场景资源,在游戏的过程中,不影响操作的情况下,后台加载剩余的资源,直到所有加载完毕。 

本文包含一些代码片段讲述实现这个技术的一种方法。本方法不一定是最好的,希望能抛砖引玉。代码是C#写的,用到了Json,还有C#的事件机制。 

在讲述代码之前,先想象这样一个网络游戏的开发流程。首先美工制作场景资源的3D建模,游戏设计人员把3D建模导进Unity3D,托托拽拽编辑场景,完成后把每个gameobject导出成XXX.unity3d格式的资源文件(参看BuildPipeline),并且把整个场景的信息生成一个配置文件,xml或者Json格式(本文使用Json)。最后还要把资源文件和场景配置文件上传到服务器,最好使用CMS管理。客户端运行游戏时,先读取服务器的场景配置文件,再根据玩家的位置从服务器下载相应的资源文件并加载,然后开始游戏,注意这里并不是下载所有的场景资源。在游戏的过程中,后台继续加载资源直到所有加载完毕。 

一个简单的场景配置文件的例子: 
MyDemoSence.txt 
Json代码  收藏代码
  1. {  
  2.     "AssetList" : [{  
  3.         "Name" : "Chair 1",  
  4.         "Source" : "Prefabs/Chair001.unity3d",  
  5.         "Position" : [2,0,-5],  
  6.         "Rotation" : [0.0,60.0,0.0]  
  7.     },  
  8.     {  
  9.         "Name" : "Chair 2",  
  10.         "Source" : "Prefabs/Chair001.unity3d",  
  11.         "Position" : [1,0,-5],  
  12.         "Rotation" : [0.0,0.0,0.0]  
  13.     },  
  14.     {  
  15.         "Name" : "Vanity",  
  16.         "Source" : "Prefabs/vanity001.unity3d",  
  17.         "Position" : [0,0,-4],  
  18.         "Rotation" : [0.0,0.0,0.0]  
  19.     },  
  20.     {  
  21.         "Name" : "Writing Table",  
  22.         "Source" : "Prefabs/writingTable001.unity3d",  
  23.         "Position" : [0,0,-7],  
  24.         "Rotation" : [0.0,0.0,0.0],  
  25.         "AssetList" : [{  
  26.             "Name" : "Lamp",  
  27.             "Source" : "Prefabs/lamp001.unity3d",  
  28.             "Position" : [-0.5,0.7,-7],  
  29.             "Rotation" : [0.0,0.0,0.0]  
  30.         }]  
  31.     }]  
  32. }  

AssetList:场景中资源的列表,每一个资源都对应一个unity3D的gameobject 
Name:gameobject的名字,一个场景中不应该重名 
Source:资源的物理路径及文件名 
Position:gameobject的坐标 
Rotation:gameobject的旋转角度 
你会注意到Writing Table里面包含了Lamp,这两个对象是父子的关系。配置文件应该是由程序生成的,手工也可以修改。另外在游戏上线后,客户端接收到的配置文件应该是加密并压缩过的。 

主程序: 
C#代码  收藏代码
  1. 。。。  
  2. public class MainMonoBehavior : MonoBehaviour {  
  3.   
  4.     public delegate void MainEventHandler(GameObject dispatcher);  
  5.   
  6.     public event MainEventHandler StartEvent;  
  7.     public event MainEventHandler UpdateEvent;  
  8.   
  9.     public void Start() {  
  10.         ResourceManager.getInstance().LoadSence("Scenes/MyDemoSence.txt");  
  11.   
  12.         if(StartEvent != null){  
  13.             StartEvent(this.gameObject);  
  14.         }  
  15.     }  
  16.   
  17.     public void Update() {  
  18.         if (UpdateEvent != null) {  
  19.             UpdateEvent(this.gameObject);  
  20.         }  
  21.     }  
  22. }  
  23. 。。。  
  24. }  

这里面用到了C#的事件机制,大家可以看看我以前翻译过的国外一个牛人的文章。C# 事件和Unity3D 
在start方法里调用ResourceManager,先加载配置文件。每一次调用update方法,MainMonoBehavior会把update事件分发给ResourceManager,因为ResourceManager注册了MainMonoBehavior的update事件。 

ResourceManager.cs 
C#代码  收藏代码
  1. 。。。  
  2. private MainMonoBehavior mainMonoBehavior;  
  3. private string mResourcePath;  
  4. private Scene mScene;  
  5. private Asset mSceneAsset;  
  6.   
  7. private ResourceManager() {  
  8.     mainMonoBehavior = GameObject.Find("Main Camera").GetComponent<MainMonoBehavior>();  
  9.     mResourcePath = PathUtil.getResourcePath();  
  10. }  
  11.   
  12. public void LoadSence(string fileName) {  
  13.     mSceneAsset = new Asset();  
  14.     mSceneAsset.Type = Asset.TYPE_JSON;  
  15.     mSceneAsset.Source = fileName;  
  16.   
  17.     mainMonoBehavior.UpdateEvent += OnUpdate;  
  18. }  
  19. 。。。  

在LoadSence方法里先创建一个Asset的对象,这个对象是对应于配置文件的,设置type是Json,source是传进来的“Scenes/MyDemoSence.txt”。然后注册MainMonoBehavior的update事件。 
C#代码  收藏代码
  1. public void OnUpdate(GameObject dispatcher) {  
  2.     if (mSceneAsset != null) {  
  3.         LoadAsset(mSceneAsset);  
  4.         if (!mSceneAsset.isLoadFinished) {  
  5.             return;  
  6.         }  
  7.   
  8.         //clear mScene and mSceneAsset for next LoadSence call  
  9.         mScene = null;  
  10.         mSceneAsset = null;  
  11.     }  
  12.   
  13.     mainMonoBehavior.UpdateEvent -= OnUpdate;  
  14. }  

OnUpdate方法里调用LoadAsset加载配置文件对象及所有资源对象。每一帧都要判断是否加载结束,如果结束清空mScene和mSceneAsset对象为下一次加载做准备,并且取消update事件的注册。 

最核心的LoadAsset方法: 
C#代码  收藏代码
  1. private Asset LoadAsset(Asset asset) {  
  2.   
  3.     string fullFileName = mResourcePath + "/" + asset.Source;  
  4.       
  5.     //if www resource is new, set into www cache  
  6.     if (!wwwCacheMap.ContainsKey(fullFileName)) {  
  7.         if (asset.www == null) {  
  8.             asset.www = new WWW(fullFileName);  
  9.             return null;  
  10.         }  
  11.   
  12.         if (!asset.www.isDone) {  
  13.             return null;  
  14.         }  
  15.         wwwCacheMap.Add(fullFileName, asset.www);  
  16.     }  
  17. 。。。  

传进来的是要加载的资源对象,先得到它的物理地址,mResourcePath是个全局变量保存资源服务器的网址,得到fullFileName类似http://www.mydemogame.com/asset/Prefabs/xxx.unity3d。然后通过wwwCacheMap判断资源是否已经加载完毕,如果加载完毕把加载好的www对象放到Map里缓存起来。看看前面Json配置文件,Chair 1和Chair 2用到了同一个资源Chair001.unity3d,加载Chair 2的时候就不需要下载了。如果当前帧没有加载完毕,返回null等到下一帧再做判断。这就是WWW类的特点,刚开始用WWW下载资源的时候是不能马上使用的,要等待诺干帧下载完成以后才可以使用。可以用yield返回www,这样代码简单,但是C#要求调用yield的方法返回IEnumerator类型,这样限制太多不灵活。 

继续LoadAsset方法: 
C#代码  收藏代码
  1. 。。。  
  2.     if (asset.Type == Asset.TYPE_JSON) { //Json  
  3.         if (mScene == null) {  
  4.             string jsonTxt = mSceneAsset.www.text;  
  5.             mScene = JsonMapper.ToObject<Scene>(jsonTxt);  
  6.         }  
  7.           
  8.         //load scene  
  9.         foreach (Asset sceneAsset in mScene.AssetList) {  
  10.             if (sceneAsset.isLoadFinished) {  
  11.                 continue;  
  12.             } else {  
  13.                 LoadAsset(sceneAsset);  
  14.                 if (!sceneAsset.isLoadFinished) {  
  15.                     return null;  
  16.                 }  
  17.             }  
  18.         }  
  19.     }   
  20. 。。。  

代码能够运行到这里,说明资源都已经下载完毕了。现在开始加载处理资源了。第一次肯定是先加载配置文件,因为是Json格式,用JsonMapper类把它转换成C#对象,我用的是LitJson开源类库。然后循环递归处理场景中的每一个资源。如果没有完成,返回null,等待下一帧处理。 

继续LoadAsset方法: 
C#代码  收藏代码
  1. 。。。  
  2.     else if (asset.Type == Asset.TYPE_GAMEOBJECT) { //Gameobject  
  3.         if (asset.gameObject == null) {  
  4.             wwwCacheMap[fullFileName].assetBundle.LoadAll();  
  5.             GameObject go = (GameObject)GameObject.Instantiate(wwwCacheMap[fullFileName].assetBundle.mainAsset);  
  6.             UpdateGameObject(go, asset);  
  7.             asset.gameObject = go;  
  8.         }  
  9.   
  10.         if (asset.AssetList != null) {  
  11.             foreach (Asset assetChild in asset.AssetList) {  
  12.                 if (assetChild.isLoadFinished) {  
  13.                     continue;  
  14.                 } else {  
  15.                     Asset assetRet = LoadAsset(assetChild);  
  16.                     if (assetRet != null) {  
  17.                         assetRet.gameObject.transform.parent = asset.gameObject.transform;  
  18.                     } else {  
  19.                         return null;  
  20.                     }  
  21.                 }  
  22.             }  
  23.         }  
  24.     }  
  25.   
  26.     asset.isLoadFinished = true;  
  27.     return asset;  
  28. }  

终于开始处理真正的资源了,从缓存中找到www对象,调用Instantiate方法实例化成Unity3D的gameobject。UpdateGameObject方法设置gameobject各个属性,如位置和旋转角度。然后又是一个循环递归为了加载子对象,处理gameobject的父子关系。注意如果LoadAsset返回null,说明www没有下载完毕,等到下一帧处理。最后设置加载完成标志返回asset对象。 

UpdateGameObject方法: 
C#代码  收藏代码
  1. private void UpdateGameObject(GameObject go, Asset asset) {  
  2.     //name  
  3.     go.name = asset.Name;  
  4.   
  5.     //position  
  6.     Vector3 vector3 = new Vector3((float)asset.Position[0], (float)asset.Position[1], (float)asset.Position[2]);  
  7.     go.transform.position = vector3;  
  8.   
  9.     //rotation  
  10.     vector3 = new Vector3((float)asset.Rotation[0], (float)asset.Rotation[1], (float)asset.Rotation[2]);  
  11.     go.transform.eulerAngles = vector3;  
  12. }  

这里只设置了gameobject的3个属性,眼力好的同学一定会发现这些对象都是“死的”,因为少了脚本属性,它们不会和玩家交互。设置脚本属性要复杂的多,编译好的脚本随着主程序下载到本地,它们也应该通过配置文件加载,再通过C#的反射创建脚本对象,赋给相应的gameobject。 

最后是Scene和asset代码: 
C#代码  收藏代码
  1. public class Scene {  
  2.     public List<Asset> AssetList {  
  3.         get;  
  4.         set;  
  5.     }  
  6. }  
  7.   
  8. public class Asset {  
  9.   
  10.     public const byte TYPE_JSON = 1;  
  11.     public const byte TYPE_GAMEOBJECT = 2;  
  12.   
  13.     public Asset() {  
  14.         //default type is gameobject for json load  
  15.         Type = TYPE_GAMEOBJECT;  
  16.     }  
  17.   
  18.     public byte Type {  
  19.         get;  
  20.         set;  
  21.     }  
  22.   
  23.     public string Name {  
  24.         get;  
  25.         set;  
  26.     }  
  27.   
  28.     public string Source {  
  29.         get;  
  30.         set;  
  31.     }  
  32.   
  33.     public double[] Bounds {  
  34.         get;  
  35.         set;  
  36.     }  
  37.       
  38.     public double[] Position {  
  39.         get;  
  40.         set;  
  41.     }  
  42.   
  43.     public double[] Rotation {  
  44.         get;  
  45.         set;  
  46.     }  
  47.   
  48.     public List<Asset> AssetList {  
  49.         get;  
  50.         set;  
  51.     }  
  52.   
  53.     public bool isLoadFinished {  
  54.         get;  
  55.         set;  
  56.     }  
  57.   
  58.     public WWW www {  
  59.         get;  
  60.         set;  
  61.     }  
  62.   
  63.     public GameObject gameObject {  
  64.         get;  
  65.         set;  
  66.     }  
  67. }  


代码就讲完了,在我实际测试中,会看到gameobject一个个加载并显示在屏幕中,并不会影响到游戏操作。代码还需要进一步完善适合更多的资源类型,如动画资源,文本,字体,图片和声音资源。 

动态加载资源除了网络游戏必需,对于大公司的游戏开发也是必须的。它可以让游戏策划(负责场景设计),美工和程序3个角色独立出来,极大提高开发效率。试想如果策划改变了什么NPC的位置,美工改变了某个动画,或者改变了某个程序,大家都要重新倒入一遍资源是多么低效和麻烦的一件事。
阅读更多
个人分类: Unity3D
上一篇C# 事件和Unity3D
下一篇分享一个简单易用的RPC开源项目—Tatala
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭