AssetBundle详解

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

using UnityEditor;
using System.IO;

public class CreateAssetBundles
{
    // 在Unity编辑器中Assets工具栏下的Build AssetBundles
    [MenuItem("Assets/Build AssetBundles")]
    static void BuildAllAssetBundles()
    {
        string assetBundleDirectory = "Assets/AssetBundles";
        if(!Directory.Exists(assetBundleDirectory))
        {
            Directory.CreateDirectory(assetBundleDirectory);
        }
        BuildPipeline.BuildAssetBundles(assetBundleDirectory, 
                                        BuildAssetBundleOptions.None, 
                                        BuildTarget.StandaloneWindows);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

// Manifest文件的版本号
ManifestFileVersion: 0
// CRC文件校验码，确保传输文件的完整性。
CRC: 1509223660
// 用于LoadFromCacheOrDownload中加载AB包时的参数
Hashes:
  AssetFileHash:
    serializedVersion: 2
    Hash: bd4bbd44fb22d87e0d31782ed64fd436
  TypeTreeHash:
    serializedVersion: 2
    Hash: cf3f348e2267d190e6df40cbb42919b5
HashAppended: 0
ClassTypes:
- Class: 1
  Script: {instanceID: 0}
- Class: 4
  Script: {instanceID: 0}
- Class: 21
  Script: {instanceID: 0}
- Class: 23
  Script: {instanceID: 0}
- Class: 28
  Script: {instanceID: 0}
- Class: 33
  Script: {instanceID: 0}
- Class: 43
  Script: {instanceID: 0}
- Class: 48
  Script: {instanceID: 0}
- Class: 65
  Script: {instanceID: 0}
// 该AB包里包含的资源
Assets:
- Assets/Prefabs/CubeWall.prefab
// 依赖的AB包
Dependencies:
- /Users/neowyj/Unity/AssetBundleProject/Assets/AssetBundles/share.unity3d

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 先加载依赖的AB包，加载后不做任何操作。
AssetBundle share = AssetBundle.LoadFromFile("Assets/AssetBundles/share.unity3d");
// 加载cubewall资源的AB包
AssetBundle ab = AssetBundle.LoadFromFile("Assets/AssetBundles/cubewall.unity3d");

// 异步版本
AssetBundleCreateRequest request =
AssetBundle.LoadFromFileAsync("Assets/AssetBundles/cubewall.unity3d");
// yield表示等待异步加载完成后才执行下面的代码。
yield return request;
AssetBundle ab = request.assetBundle;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

while (Caching.ready == false)
{
    // 暂停一帧，这一帧后面的代码不执行，直到下一帧再重新开始判断。
    yield return null; 
}
WWW www = WWW.LoadFromCacheOrDownload(@"file:///Users/neowyj/Unity/AssetBundleProject/Assets/AssetBundles/cubewall.unity3d", 1);
// Mac上没有一般不分盘，所以直接是file://+绝对路径。而Windows上有盘符路径为:file://盘符:+路径。
//WWW www = WWW.LoadFromCacheOrDownload(@"http://localhost:7000/AssetBundles/cubewall.unity3d", 1);
// WWW类即使有错误也不会报错停止运行，所以需要进行www错误检测，www.error不为空则表示有错。
if (!string.IsNullOrEmpty(www.error)) 
{
    Debug.Log(www.error);
    // 退出www类的下载过程，后面的代码不再执行。yield return只是针对当前帧进行等待操作。
    yield break; 
}
// 等待www下载完成再执行下面的代码
yield return www; 
AssetBundle ab = www.assetBundle;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 使用UnityWebRequest从本地文件中加载AB包
// string uri = @"file:///Users/neowyj/Unity/AssetBundleProject/Assets/AssetBundles/cubewall.unity3d";
// 使用HTTP协议从服务器上下载AB包
string uri = @"http://localhost:8000/AssetBundles/cubewall.unity3d";
UnityWebRequest request = UnityWebRequestAssetBundle.GetAssetBundle(uri);
// 发送资源请求，并等待下载完成。
yield return request.Send(); 
AssetBundle ab = DownloadHandlerAssetBundle.GetContent(request);
// 下面这种方式也可以获取AB包
// AssetBundle ab = (request.downloadHandler as DownloadHandlerAssetBundle).assetBundle;

1
2
3
4

// 从AB包里加载对应的游戏对象。注意，LoadAsset区分大小写，Unity也区分大小写，只是AssetBundle包名不区分。
GameObject CubeWallPrefab = ab.LoadAsset<GameObject>("CubeWall");
// 实例化该游戏对象，如果不指定对象实例化所需要的位置和旋转，则采用该游戏对象在Inspector面板中的默认位置和旋转。
Instantiate(CubeWallPrefab);

1
2
3
4
5

AssetBundleRequest request = ab.LoadAssetAsync<GameObject>("CubeWall");
yield return request;
// request获取的asset就是实际的游戏对象或其他类型的资源
var loadedAsset = request.asset;
Instantiate(loadedAsset);

1
2
3
4
5
6
7

Object[] objs = ab.LoadAllAssets(); 
foreach (Object o in objs)
{
    // Unity中的GameObject继承自Unity.Object
    Instantiate(o);
}
// 如果AB包里有父子关系的资源，则可以通过LoadSubAsset获取到子资源数组Object[]。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// AssetBundles的AB包没有后缀，是系统自动创建的，其他资源打包时必须加后缀，除非打包时没有添加。
AssetBundle manifestAB = AssetBundle.LoadFromFile("Assets/AssetBundles/AssetBundles"); 
// 从AB包里加载对应的manifest文件，和加载GameObject资源一样，只是类型和资源名都是AssetBundleManifest。
AssetBundleManifest manifest = manifestAB.LoadAsset<AssetBundleManifest>("AssetBundleManifest");
// 获取本次打包的所有AB包，返回一个存储AB包名字符串数组。
foreach (string name in manifest.GetAllAssetBundles()) 
{
    print(name);
}
// 先把依赖包找出来，然后再去加载对应的依赖包，这才是完整的公共资源包的加载流程。
// 获取AB包对应的依赖包时，需要传递一个AB包名，返回一个存储AB包名字符串数组。
string[] dependencies = manifest.GetAllDependencies("cubewall.unity3d"); 
foreach (string name in dependencies)
{
    print(name);
    // 只需要加载依赖的AB包，具体的依赖资源Unity会自动获取。
    AssetBundle.LoadFromFile("Assets/AssetBundles/"+ name);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

using UnityEngine;
using UnityEditor;
using System.Xml;

// 把当前场景中的GameObject信息导出到XML文档中
public class Export
{
    // 编辑器扩展
    [MenuItem("Export/ExportSceneToXML")]
    static void ExportSceneToXML()
	{
        // 根据当前场景的路径获取场景名
        string scenePath = EditorApplication.currentScene;
        string sceneName = scenePath.Substring(scenePath.LastIndexOf("/", System.StringComparison.Ordinal)+1);
        sceneName = sceneName.Substring(0, sceneName.LastIndexOf(".", System.StringComparison.Ordinal));
        // 设置导出的XML文件路径
        string savePath = "Assets/SceneXML/" + sceneName + ".xml";

        // 新建一个XML文档
        XmlDocument xml = new XmlDocument();
        // 设置XML文档的根节点
        XmlElement scene = xml.CreateElement("Scene");
        // 设置根节点的属性：名字和保存路径
        scene.SetAttribute("Name", sceneName);
        scene.SetAttribute("Path", savePath);
        xml.AppendChild(scene);

        // 获取当前场景下的所有GameObject（包括Asset目录）
        Object[] objs = Resources.FindObjectsOfTypeAll(typeof(GameObject));
        foreach (GameObject go in objs)
        {
            // 只存储最顶层的GameObject，不考虑子对象，打AB包时也是如此，因为是一个AB包所以不存在公共资源问题。
            if (go.transform.parent == null)
            {
                // 记录GameObject的名字
                XmlElement gameObject = xml.CreateElement("GameObject");
                gameObject.SetAttribute("Name", go.name);
              
                // AssetBundle不能记录资源的位置、旋转和缩放等信息
                // 记录GameObject的位置信息
                XmlElement position = xml.CreateElement("Position");
                position.SetAttribute("x", go.transform.position.x.ToString());
                position.SetAttribute("y", go.transform.position.y.ToString());
                position.SetAttribute("z", go.transform.position.z.ToString());
                gameObject.AppendChild(position);

                // 记录GameObject的旋转信息
                XmlElement rotation = xml.CreateElement("Rotation");
                rotation.SetAttribute("x", go.transform.eulerAngles.x.ToString());
                rotation.SetAttribute("y", go.transform.eulerAngles.y.ToString());
                rotation.SetAttribute("z", go.transform.eulerAngles.z.ToString());
                gameObject.AppendChild(rotation);

                // 记录GameObject的缩放信息
                XmlElement scale = xml.CreateElement("Scale");
                scale.SetAttribute("x", go.transform.localScale.x.ToString());
                scale.SetAttribute("y", go.transform.localScale.y.ToString());
                scale.SetAttribute("z", go.transform.localScale.z.ToString());
                gameObject.AppendChild(scale);

                // 添加进XML文档
                scene.AppendChild(gameObject);
            }
        }

        // 保存为路径对应的XML文件
        xml.Save(savePath);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

using System;
using System.Xml;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Load : MonoBehaviour 
{
    // Use this for initialization
    void Start()
    {
        // AB包路径
        string abPath = @"http://localhost:9000/Assets/AssetBundles/main.unity3d";
        // XML文档路径
        string xmlPath = @"http://localhost:9000/Assets/SceneXML/Main.xml";
        // 开启动态加载场景协程
        IEnumerator routine = LoadDynamicScene(abPath, xmlPath);
        StartCoroutine(routine);
	  }
  
    // 动态加载场景的协程函数
    IEnumerator LoadDynamicScene(string abPath, string xmlPath)
    {
        // 如果缓存不可使用，直接跳过当前帧，直到可以使用时再执行后续代码。
        while (Caching.ready == false)
        {
            yield return null;
        }
        WWW www = WWW.LoadFromCacheOrDownload(abPath, 1);
        // 如果下载出错就直接退出协程函数，后续代码不再执行。
        if (!string.IsNullOrEmpty(www.error))
        {
            Debug.Log(www.error);
            yield break;
        }
        // 等www下载完之后再执行后续代码
        yield return www;
        // 从www获取AB包
        AssetBundle ab = www.assetBundle;

        // 读取XML文档
        XmlDocument xml = new XmlDocument();
        xml.Load(xmlPath);
        XmlElement root = xml.DocumentElement;
        if (root.Name == "Scene")
        {
            // 获取XML文档的根节点
            XmlNodeList nodes = root.SelectNodes("/Scene/GameObject");
            Vector3 position = Vector3.zero;
            Vector3 rotation = Vector3.zero;
            Vector3 scale = Vector3.zero;
            // 开始遍历XML文档节点，获取GameObject的信息
            foreach (XmlElement xe in nodes)
            {
                foreach (XmlElement xe2 in xe.ChildNodes)
                {
                    // 获取GameObject的位置信息
                    if (xe2.Name == "Position")
                    {
                        position = new Vector3(float.Parse(xe2.GetAttribute("x")), float.Parse(xe2.GetAttribute("y")), float.Parse(xe2.GetAttribute("z")));
                    }
                    // 获取GameObject的旋转信息
                    else if (xe2.Name == "Rotation")
                    {
                        rotation = new Vector3(float.Parse(xe2.GetAttribute("x")), float.Parse(xe2.GetAttribute("y")), float.Parse(xe2.GetAttribute("z")));
                    }
                    // 获取GameObject的缩放信息
                    else
                    {
                        scale = new Vector3(float.Parse(xe2.GetAttribute("x")), float.Parse(xe2.GetAttribute("y")), float.Parse(xe2.GetAttribute("z")));
                    }
                }
                // 根据GameObject的名字从AB包中加载对应的GameObject
                //GameObject go = ab.LoadAsset<GameObject>(xe.GetAttribute("Name"));
                GameObject go = ab.LoadAsset<GameObject>(xe.GetAttribute("Name"));
                // 如果GameObject不为空就用Instantiate函数实例化，并设置对应的Transform信息。
                if (go != null)
                {
                    GameObject go2 = Instantiate(go, position, Quaternion.Euler(rotation));
                    go2.transform.localScale = scale;
                }
            }
        }
    }

    void OnDestroy()
    {
        // 停止协程
        StopAllCoroutines();
    }
}