【轉】unity3d動態加載及生成配置文件

本文大部分轉載，作者做了關於配置文件生成工作，但是很遺憾，關於position和rotation信息目前尚未自動生成，運行本例的朋友，需要自己手動添加位置和角度信息，否則程序會報錯。
標准的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. }

用Unity3D制作基於web的網絡 游戲，不可避免的會用到一個技術-資源動態加載。比如想加載一個大場景的資源，不應該在游戲的開始讓用戶長時間等待全部資源的加載完畢。應該優先加載用戶附近的場景資源，在游戲的過程中，不影響操作的情況下，后台加載剩余的資源，直到所有加載完畢。

在講述代碼之前，先想象這樣一個網絡游戲的開發流程。首先美工制作場景資源的3D建模，游戲設計人員把3D建模導進Unity3D，托托拽拽編輯場景，完成后把每個gameobject導出成XXX.unity3d格式的資源文件（參看BuildPipeline），並且把整個場景的 信息生成一個配置文件，xml或者Json格式（本文使用Json）。最后還要把資源文件和場景配置文件上傳到服務器，最好使用CMS管理。客戶端運行游戲時，先讀取服務器的場景配置文件，再根據玩家的位置從服務器 下載相應的資源文件並加載，然后開始游戲，注意這里並不是下載所有的場景資源。在游戲的過程中，后台繼續加載資源直到所有加載完畢。
json.txt:（ 注：當生成的json無法讀取時，記得改一下編碼格式 改成 ANSI）
{"AssetList":[{"Name":"Sphere","Source":"Prefabs/Sphere.unity3d"},{"Name":"cube","Source":"Prefabs/cube.unity3d"},{"Name":"Sphere","Source":"Prefabs/Sphere.unity3d"},{"Name":"cube","Source":"Prefabs/cube.unity3d"}]}

主程序：

using UnityEngine;
using System.Collections;

public class MainMonoBehavior : MonoBehaviour {

    public delegate void MainEventHandler(GameObject dispatcher);
    public event MainEventHandler StartEvent;
    public event MainEventHandler UpdateEvent;
    public void Start()
    {
        ResourceManager.getInstance().LoadSence("Scenes/json.txt");//json配置文件
        if(StartEvent != null)
        {
            StartEvent(this.gameObject);
        }
    }
    public void Update()
    {
        if (UpdateEvent != null)
        {
            UpdateEvent(this.gameObject);
        }
    }
}

 

這里面用到了C#的事件機制，大家可以看看我以前 翻譯過的 國外一個牛人的文章。 C# 事件和Unity3D
在 start方法里調用ResourceManager，先加載配置文件。每一次調用update方法，MainMonoBehavior會把update 事件分發給ResourceManager，因為ResourceManager注冊了MainMonoBehavior的update事件。

輔助類：

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using LitJson;
using System.Net;
public class ResourceManager
{

// Use this for initialization
        private MainMonoBehavior mainMonoBehavior;
        private   string mResourcePath;
        private Scene mScene;
        private Asset mSceneAsset;
        private static ResourceManager resourceManager=new ResourceManager();//如果沒有new 會出現沒有實例化的錯誤
        private Dictionary<string ,WWW > wwwCacheMap=new Dictionary<string,WWW>();//這個新添加的原文代碼中沒有定義它 應該是個字典
       public static  ResourceManager getInstance( )
        {
                return resourceManager;//靜態函數中不能使用非靜態成員
        }
        public  ResourceManager()
        {
                mainMonoBehavior = GameObject.Find("Main Camera").GetComponent<MainMonoBehavior>();
                mResourcePath ="file://"+Application.dataPath+"/..";
        }
       
        public void LoadSence(string fileName)
        {
                //Debug.Log(fileName);
                mSceneAsset = new Asset();
                mSceneAsset.Type = Asset.TYPE_JSON;//后面類型判斷有用
                mSceneAsset.Source = fileName;
                mainMonoBehavior.UpdateEvent += OnUpdate;//添加監聽函數
        }



        public void OnUpdate(GameObject dispatcher)//該函數是監聽函數，每幀都會被調用（它的添加是在MainMonoBehavior的start函數中通過調用本地LoadSence函數）
        {
                if (mSceneAsset != null)//表示已經通過了new操作分配類內存空間但是資源還沒有加載完
                {
                        LoadAsset(mSceneAsset);//這個函數里面會通過判斷，使www的new操作只執行一次
                        if (!mSceneAsset.isLoadFinished)//C#中 bool類型默認是false
                        {
                               return;
                        }
                        mScene = null;
                        mSceneAsset = null;
                }
                mainMonoBehavior.UpdateEvent -= OnUpdate;//當所有資源被加載后，刪除監聽函數。
        }
        //最核心的函數
     private Asset LoadAsset(Asset asset)
        {
                string fullFileName =mResourcePath+"/"+ asset.Source;// mResourcePath + "/" + asset.Source;
                Debug.Log("fullFileName=" + fullFileName);
                //if www resource is new, set into www cache
                if (!wwwCacheMap.ContainsKey(fullFileName))
                {//自定義字典 查看開頭的定義
                        if (asset.www == null)
                        {//表示www還沒有new操作
                                asset.www = new WWW(fullFileName);
                                return null;
                        }
                        if (!asset.www.isDone)
                        {
                                return null;
                        }
                        wwwCacheMap.Add(fullFileName, asset.www); //該字典是作為緩存的作用，如果之前已經加載過同樣的Unity3D格式文件，那么不需要在加載，直接拿來用就行了。  
                }  
                if (asset.Type == Asset.TYPE_JSON)
                { //Json 表示當txt文件被首次加載時的處理
                        if (mScene == null)
                        {        
                            string jsonTxt = mSceneAsset.www.text;
                            Debug.Log("jsonTxt=" + jsonTxt);
                            mScene = JsonMapper.ToObject<Scene>(jsonTxt);//mScene是個Asset對象列表，也就是Json文件需要一個AssetList列表對象，注意名字的統一，列表中Asset對象中的成員名稱要和txt                //文件中的相關名稱統一 不然JsonMapper無法找到
                         }
                        //load scene
                        foreach (Asset sceneAsset in mScene.AssetList)
                        {
                                if (sceneAsset.isLoadFinished)
                                {
                                        continue;
                                }
                                else
                                {
                                        LoadAsset(sceneAsset);//這里的處理就是 下面 Asset.TYPE_GAMEOBJECT的處理方式，注意是遞歸函數的調用
                                        if (!sceneAsset.isLoadFinished)
                                        {
                                            return null;
                                         }
                                 }
                        }
                }
                else if (asset.Type == Asset.TYPE_GAMEOBJECT)//處理文件中具體信息，嵌套關系或者直接是一個GameObject對象，與上面的代碼有聯系，Asset創建時候的構造函數中設置成
                //TYPE_GAMEOBJECT類型
                { //Gameobject
                        if (asset.gameObject == null)//如果不為null 表示已經通過wwwCacheMap加載了資源包中所包含的資源（fullFileName僅僅是一個文件，資源包中資源是分散的GameObject對象），不需要在重新加載
                        {
                                wwwCacheMap[fullFileName].assetBundle.LoadAll();//已經通過new WWW操作完成了加載，該函數用來加載包含着資源包中的資源
                                GameObject go = (GameObject)GameObject.Instantiate(wwwCacheMap[fullFileName].assetBundle.mainAsset);
                                UpdateGameObject(go, asset);
                                asset.gameObject = go;
                        }
                        if (asset.AssetList != null)//有嵌套關系
                        {
                                foreach (Asset assetChild in asset.AssetList)
                                {
                                        if (assetChild.isLoadFinished)
                                        {
                                                continue;
                                        }
                                        else
                                        {
                                                Asset assetRet = LoadAsset(assetChild);
                                                if (assetRet != null)//這個if else 語句是為了防止你的配置文件中的GameObject對象路徑不正確，導致訪問空指針。
                                                {
                                                        assetRet.gameObject.transform.parent = asset.gameObject.transform;
                                                }
                                                else
                                                {
                                                        return null;
                                                }
                                        }
                                }
                        }
                }
                asset.isLoadFinished = true;
                return asset;
        }
        private void UpdateGameObject(GameObject go, Asset asset)
        {
                //name
                go.name = asset.Name;
                //position
                Vector3 vector3 = new Vector3((float)asset.Position[0], (float)asset.Position[1], (float)asset.Position[2]);
                go.transform.position = vector3;
                //rotation
               vector3 = new Vector3((float)asset.Rotation[0], (float)asset.Rotation[1], (float)asset.Rotation[2]);
                go.transform.eulerAngles = vector3;
        }
}

Asset.cs類：
using UnityEngine;
using System.Collections.Generic;
public class Asset
{
        public const byte TYPE_JSON = 1;
        public const byte TYPE_GAMEOBJECT = 2;
        public Asset()
        {
            //default type is gameobject for json load
            Type = TYPE_GAMEOBJECT;
        }
        public byte Type
        {
            get;
            set;
        }
        public string Name
        {
            get;
            set;
        }
        public string Source
        {
            get;
            set;
        }
        public double[] Bounds
        {
            get;
            set;
        }
       
        public double[] Position
        {
            get;
            set;
        }
        public double[] Rotation
        {
            get;
            set;
        }
        public List<Asset> AssetList
        {
            get;
            set;
        }
        public bool isLoadFinished
        {
            get;
            set;
        }
        public WWW www
        {
            get;
            set;
        }
        public GameObject gameObject
        {
            get;
            set;
        }
}
Scene.cs類：
using System.Collections.Generic;

public class Scene
{
        public List<Asset> AssetList
        {
            get;
            set;
        }
}

生成.unity3d代碼：

using UnityEngine;
using UnityEditor;
using System.IO;
using System;
using System.Text;
using System.Collections.Generic;
using LitJson;
public class BuildAssetBundlesFromDirectory
{
      static List<JsonResource> config=new List<JsonResource>();
      static Dictionary<string, List<JsonResource>> assetList=new Dictionary<string, List<JsonResource>>();
        [@MenuItem("Asset/Build AssetBundles From Directory of Files")]//這里不知道為什么用"@"，添加菜單
        static void ExportAssetBundles ()
        {//該函數表示通過上面的點擊響應的函數
                   assetList.Clear();
                   string path = AssetDatabase.GetAssetPath(Selection.activeObject);//Selection表示你鼠標選擇激活的對象
                  Debug.Log("Selected Folder: " + path);
       
       
                  if (path.Length != 0)
                  {
                           path = path.Replace("Assets/", "");//因為AssetDatabase.GetAssetPath得到的是型如Assets/文件夾名稱，且看下面一句，所以才有這一句。
                            Debug.Log("Selected Folder: " + path);
                           string [] fileEntries = Directory.GetFiles(Application.dataPath+"/"+path);//因為Application.dataPath得到的是型如 "工程名稱/Assets"
                           
                           string[] div_line = new string[] { "Assets/" };
                           foreach(string fileName in fileEntries)
                           {
                                    j++;
                                    Debug.Log("fileName="+fileName);
                                    string[] sTemp = fileName.Split(div_line, StringSplitOptions.RemoveEmptyEntries);
                                    string filePath = sTemp[1];
                                     Debug.Log(filePath);
                                    filePath = "Assets/" + filePath;
                                    Debug.Log(filePath);
                                    string localPath = filePath;
                                    UnityEngine.Object t = AssetDatabase.LoadMainAssetAtPath(localPath);
                                   
                                     //Debug.Log(t.name);
                                    if (t != null)
                                    {
                                            Debug.Log(t.name);
                                            JsonResource jr=new JsonResource();
                                            jr.Name=t.name;
                                            jr.Source=path+"/"+t.name+".unity3d";
                                              Debug.Log( t.name);
                                            config.Add(jr);//實例化json對象
                                              string bundlePath = Application.dataPath+"/../"+path;
                                               if(!File.Exists(bundlePath))
                                                {
                                                   Directory.CreateDirectory(bundlePath);//在Asset同級目錄下相應文件夾
                                                }
                                              bundlePath+="/"  + t.name + ".unity3d";
                                             Debug.Log("Building bundle at: " + bundlePath);
                                             BuildPipeline.BuildAssetBundle(t, null, bundlePath, BuildAssetBundleOptions.CompleteAssets);//在對應的文件夾下生成.unity3d文件
                                    } 
                           }
                            assetList.Add("AssetList",config);
                            for(int i=0;i<config.Count;i++)
                            {
                                    Debug.Log(config[i].Source);
                            }
                  }
                string data=JsonMapper.ToJson(assetList);//序列化數據
                Debug.Log(data);
        string jsonInfoFold=Application.dataPath+"/../Scenes";
        if(!Directory.Exists(jsonInfoFold))
        {
            Directory.CreateDirectory(jsonInfoFold);//創建Scenes文件夾
        }
                string fileName1=jsonInfoFold+"/json.txt";
                if(File.Exists(fileName1))
                {
                    Debug.Log(fileName1 +"already exists");
                    return;
                }
                UnicodeEncoding uni=new UnicodeEncoding();
                  
                using(  FileStream  fs=File.Create(fileName1))//向創建的文件寫入數據
                {
                        fs.Write(uni.GetBytes(data),0,uni.GetByteCount(data));
                        fs.Close();
                }
      }
}