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

看到这篇文章，解决了一个一直困挠我的大问题,感谢小唐帮我找到了这篇文章。

如果真能实现，空间无限延展

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

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

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

一个简单的场景配置文件的例子：

MyDemoSence.txt

复制代码

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" : "WritingTable",

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，这两个对象是父子的关系。配置文件应该是由程序生成的，手工也可以修改。另外在游戏上线后，客户端接收到的配置文件应该是加密并压缩过的。

主程序：

复制代码

1. 。。。

2. publicclass MainMonoBehavior : MonoBehaviour {

4. public delegate voidMainEventHandler(GameObject dispatcher);

6. public event MainEventHandler StartEvent;

7. public event MainEventHandler UpdateEvent;

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

复制代码

1. 。。。

2. privateMainMonoBehavior mainMonoBehavior;

3. privatestring mResourcePath;

4. privateScene mScene;

5. privateAsset mSceneAsset;

7. privateResourceManager() {

8. mainMonoBehavior =GameObject.Find("MainCamera").GetComponent<MainMonoBehavior>();

9. mResourcePath = PathUtil.getResourcePath();

10. }

11.

12. publicvoid 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事件。

复制代码

1. publicvoid OnUpdate(GameObject dispatcher) {

2. if (mSceneAsset != null) {

3. LoadAsset(mSceneAsset);

4. if (!mSceneAsset.isLoadFinished) {

5. return;

6. }

8. //clear mScene and mSceneAsset for nextLoadSence call

9. mScene = null;

10. mSceneAsset = null;

11. }

12.

13. mainMonoBehavior.UpdateEvent -=OnUpdate;14. }

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

最核心的LoadAsset方法：

复制代码

1. privateAsset LoadAsset(Asset asset) {

3. string fullFileName = mResourcePath +"/" + asset.Source;

5. //if www resource is new, set into wwwcache

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方法：

复制代码

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. }

8. //load scene

9. foreach (Asset sceneAsset inmScene.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方法：

复制代码

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. }

10. if (asset.AssetList != null) {

11. foreach (Asset assetChild inasset.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方法：

复制代码

1. privatevoid UpdateGameObject(GameObject go, Asset asset) {

2. //name

3. go.name = asset.Name;

5. //position

6. Vector3 vector3 = newVector3((float)asset.Position[0], (float)asset.Position[1],(float)asset.Position[2]);

7. go.transform.position = vector3;

9. //rotation

10. vector3 = newVector3((float)asset.Rotation[0], (float)asset.Rotation[1],(float)asset.Rotation[2]);

11. go.transform.eulerAngles = vector3;12. }

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

最后是Scene和asset代码：

复制代码

1. publicclass Scene {

2. public List<Asset> AssetList {

3. get;

4. set;

5. }

6. }

8. publicclass Asset {

10. public const byte TYPE_JSON = 1;

11. public const byte TYPE_GAMEOBJECT = 2;

12.

13. public Asset() {

14. //default type is gameobject for jsonload

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的位置，美工改变了某个动画，或者改变了某个程序，大家都要重新倒入一遍资源是多么低效和麻烦的一件事。

糨糊Jack

导航

公告