【Unity】AssetBundle打包策略_unity assetbundle打包策略

【Unity】AssetBundle打包策略

在游戏开发过程中，AssetBundle(AB)打包策略的重要性不容忽视。游戏开发者往往手动设置游戏资源包名进行管理，难免会造成资源确实或导致冗余，因此对于AB包的打包流程来说，进行策略管理显得十分重要。
采用打包策略管理整个AssetBundle打包流程，可以一键将你所需要的整个文件夹打成一个包、以及将特定文件夹下的每个资源单独打一个包，还会将这些资源所依赖的资源打进这个包里，不会产生冗余AB包，更容易进行管理。

1. 记录打包文件路径

1.1 创建ScriptObject

m_AllPrefabPath 用于记录该文件夹需要将每个prefab打成单独一个包。
m_AllFileDirAB 用于记录将整个文件夹打成一个ab包。

using System.Collections.Generic;
using UnityEngine;

[CreateAssetMenu(fileName = "ABConfig_SO", menuName = "CreateABConfig", order = 0)]
public class ABConfig_SO : ScriptableObject 
{
    //单个文件所在文件夹路径，会遍历这个文件夹下面所有Prefab，所有的Prefab的名字不能重复，必须保证名字的唯一性
    public List<string> m_AllPrefabPath = new List<string>();

    public List<FileDirABName> m_AllFileDirAB = new List<FileDirABName>();

    [Serializable]
    public struct FileDirABName
    {
        //AB包名
        public string ABName;
        //文件夹路径
        public string Path;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

1.2 创建 SO 文件

2. 记录所有的AB包文件信息及依赖

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using System.Linq;

public class BundleEditor
{
    //SO文件配置
    private static string CONFIGPATH = "Assets/Editor/ABConfig_SO.asset";
    //记录文件夹 key文件夹包名 value文件夹路径
    private static Dictionary<string, string> m_AllDirDict = new Dictionary<string, string>();
    //记录AB文件路径信息（包括文件夹路径、文件路径）
    private static List<string> m_AllABFilePath = new List<string>();

    [MenuItem("Tool/打包")]
    public static void Build()
    {
        //获取SO文件信息
        ABConfig_SO abConfig = AssetDatabase.LoadAssetAtPath<ABConfig_SO>(CONFIGPATH);

        //记录文件夹AB包信息
        foreach(ABConfig_SO.FileDirABName fdABName in abConfig.m_AllFileDirAB)
        {
            //避免不同文件夹存在相同包名
            if(m_AllDirDict.ContainsKey(fdABName.ABName))
            {
                Debug.LogError("存在相同包名的 文件夹路径");
            }
            else
            {
                m_AllDirDict.Add(fdABName.ABName, fdABName.Path);
                //记录AB文件路径
                m_AllABFilePath.Add(fdABName.Path);

            }
        }

        //记录文件信息
        string[] allPrefabsGUID = AssetDatabase.FindAssets("t:Prefab", abConfig.m_AllPrefabPath.ToArray());
        for(int i = 0; i < allPrefabsGUID.Length; i++)
        {
            //通过GUID获取文件路径
            string path = AssetDatabase.GUIDToAssetPath(allPrefabsGUID[i]);
            //启动 Unity 进度条
            EditorUtility.DisplayProgressBar("查找Prefab", "Prefab:" + path, (i + 1) * 1.0f / allPrefabsGUID.Length);
            
            //资源不存在记录的文件夹中，同时也是新发现的文件
            if(!ContainAllABFile(path))
            {
                //获得资源的所有依赖(依赖包括自身)
                string[] allDepend = AssetDatabase.GetDependencies(path);
                for(int j = 0; j < allDepend.Length; j++)
                {
                    //资源不存在记录的文件夹中，同时也是新发现的文件
                    //并且该依赖资源不是 脚本文件
                    if (!ContainAllABFile(allDepend[j]) ||
                        allDepend[j].EndsWith(".cs"))
                    {
                        m_AllABFilePath.Add(allDepend[j]);
                    }
                }
            }
        }

        DebugAllABFilePath();
        EditorUtility.ClearProgressBar();
    }

    /// <summary>
    /// 是否存在文件是否存在AB文件路径信息（避免资源冗余）
    /// </summary>
    /// <param name="path">资源路径</param>
    /// <returns></returns>
    private static bool ContainAllABFile(string path)
    {
        for(int i = 0; i < m_AllABFilePath.Count; i++)
        {
            //1.资源已被记录   2.资源存在文件夹中
            if (path == m_AllABFilePath[i] ||
                (path.Contains(m_AllABFilePath[i])
                && path.Replace(m_AllABFilePath[i], "")[0] == '/'))
            {
                return true;
            }
        }
        return false;
    }

    /// <summary>
    /// 输出全部AB包文件路径
    /// </summary>
    private static void DebugAllABFilePath()
    {
        for(int i = 0; i < m_AllABFilePath.Count; i++)
        {
            Debug.Log(m_AllABFilePath[i]);
        }
    }
}
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
92
93
94
95
96
97
98
99
100

点击菜单 【Tool - 打包】，会输出所有记录的AB包资源的路径
1

3. 将文件归属到各个包中

3.1 创建字典

//记录单个prefab所需要的所有依赖路径
private static Dictionary<string, List<string>> m_AllPrefabDict = new Dictionary<string, List<string>>();
m_AllPrefabDict.Clear();
1
2
3

3.2 记录Prefab依赖信息

//获得资源的所有依赖(依赖包括自身)
string[] allDepend = AssetDatabase.GetDependencies(path);

//将所有依赖打成一个包 以 prefab 游戏对象名为 AB包名
GameObject obj = AssetDatabase.LoadAssetAtPath<GameObject>(path);
List<string> allDependPath = new List<string>();

for (int j = 0; j < allDepend.Length; j++)
{
    //资源不存在记录的文件夹中，同时也是新发现的文件
    //并且该依赖资源不是 脚本文件
    if (!ContainAllABFile(allDepend[j]) ||
        allDepend[j].EndsWith(".cs"))
    {
        m_AllABFilePath.Add(allDepend[j]);

        //记录文件依赖路径，将其设置成同一个AB包中
        allDependPath.Add(allDepend[j]);
    }
}

if(m_AllPrefabDict.ContainsKey(obj.name))
{
    Debug.Log("存在相同名字：[" + obj.name + "] 的Prefab");
}
else
{
    m_AllPrefabDict.Add(obj.name, allDependPath);
}
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

3.3 为资源添加包名

    //添加AB包名
    foreach(string name in m_AllDirDict.Keys)
    {
        SetABName(m_AllDirDict[name], name);
        Debug.Log("[" + name + "]" + m_AllDirDict[name]);
    }

    foreach(string name in m_AllPrefabDict.Keys)
    {
        SetABName(m_AllPrefabDict[name], name);
        Debug.Log("[" + name + "]" + m_AllPrefabDict[name]);
    }

    //TODO:打AB包

    //清除所有AB包名字，防止重复设置包名
    string[] oldABNames = AssetDatabase.GetAllAssetBundleNames();
    for(int i = 0; i < oldABNames.Length; i++)
    {
        //移除AB包名
        AssetDatabase.RemoveAssetBundleName(oldABNames[i], true);
        EditorUtility.DisplayProgressBar("清除AB包名", "名字：" + oldABNames[i], (i + 1) * 1.0f / oldABNames.Length);
    }

    AssetDatabase.Refresh();
    EditorUtility.ClearProgressBar();
}

/// <summary>
/// 设置文件的AB包名
/// </summary>
/// <param name="path">文件路径</param>
/// <param name="name">AB包名</param>
private static void SetABName(string path, string name)
{
    AssetImporter ai = AssetImporter.GetAtPath(path);
    if(ai == null)
    {
        Debug.LogError("不存在文件路径：" + path);
    }
    else
    {
        //设置AB包名
        ai.assetBundleName = name;
    }
}

/// <summary>
/// 设置文件的AB包名
/// </summary>
/// <param name="dependPath">文件的所有依赖的路径</param>
/// <param name="name">AB包名</param>
private static void SetABName(List<string> dependPath, string name)
{
    for(int i = 0; i < dependPath.Count; i++)
    {
        SetABName(dependPath[i], 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

最终，资源被分成了3个包
1

4. 根据包名进行打包

4.1 生成AB包

private static void BuildAssetBundle()
{
    //删除的此时不存在的AB包
    DeleteInExistenceAB();
    
    //TODO：生成配置表

    //打包
    BuildPipeline.BuildAssetBundles(AssetBundleBuildPath, BuildAssetBundleOptions.ChunkBasedCompression, EditorUserBuildSettings.activeBuildTarget);
}

/// <summary>
/// 删除的此时不存在的AB包
/// </summary>
private static void DeleteInExistenceAB()
{
    //获取所有AB包名
    string[] allBundles = AssetDatabase.GetAllAssetBundleNames();
    DirectoryInfo dir = new DirectoryInfo(AssetBundleBuildPath);
    //获得文件夹下所有文件
    FileInfo[] files = dir.GetFiles("*", SearchOption.AllDirectories);
    for (int i = 0; i < files.Length; i++)
    {
        //不删除同包名的文件，也不删除所有meta文件
        if (ContainABName(files[i].Name, allBundles) ||
            files[i].Name.EndsWith(".meta"))
        {
            continue;
        }

        Debug.Log("此  [ "  + files[i].Name + "] AB包已经被删除或被更名");
        if (File.Exists(files[i].FullName))
        {
            File.Delete(files[i].FullName);
        }
    }
}
/// <summary>
/// 判断名字是否在数组中
/// </summary>
/// <param name="name">名字</param>
/// <param name="strs">数组</param>
/// <returns></returns>
private static bool ContainABName(string name, string[] strs)
{
    for(int i = 0; i < strs.Length; i++)
    {
        if(name == strs[i])
        {
            return true;
        }
    }
    return false;
}
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

4.2 创建生成路径

//AB包输出路径
private static string AssetBundleBuildPath = Application.streamingAssetsPath;
1
2

4.3 调用创建AB包

5. 创建数据格式

using System.Collections.Generic;
using System.Xml.Serialization;
using System;

[Serializable]
public class AssetBundleConfig
{
    //资源数据
    [XmlElement("ABList")]
    public List<ABBase> ABList { get; set; }
}

[Serializable]
public class ABBase
{
    //资源路径
    [XmlAttribute("Path")]
    public string Path { get; set; }

    //crc代码
    [XmlAttribute("Crc")]
    public uint Crc { get; set; }

    //AB包名
    [XmlAttribute("ABName")]
    public string ABName { get; set; }

    //资源名称
    [XmlAttribute("AssetName")]
    public string AssetName { get; set; }

    //资源所依赖包名
    [XmlElement("ABDependce")]
    public List<string> ABDependce { get; set; }
}

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

6. 插入现成CRC32码

/// <summary>  
/// CRC 效验  
/// 快速检测算法
/// </summary>  
public class Crc32
{
    //crc表
    static uint[] crcTable =
    {
        0x0, 0x77073096, 0xee0e612c, 0x990951ba, 0x76dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
        0xedb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x9b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
        0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
        0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
        0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
        0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
        0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
        0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
        0x76dc4190, 0x1db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x6b6b51f, 0x9fbfe4a5, 0xe8b8d433,
        0x7807c9a2, 0xf00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x86d3d2d, 0x91646c97, 0xe6635c01,
        0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
        0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
        0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
        0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
        0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
        0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
        0xedb88320, 0x9abfb3b6, 0x3b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x4db2615, 0x73dc1683,
        0xe3630b12, 0x94643b84, 0xd6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0xa00ae27, 0x7d079eb1,
        0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
        0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
        0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
        0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
        0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
        0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
        0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x26d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x5005713,
        0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0xcb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0xbdbdf21,
        0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
        0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
        0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
        0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
        0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
        0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
        };


    //返回字符串的crc
    public static uint GetCRC32(string msg)
    {
        if (string.IsNullOrEmpty(msg))
            return 0;

        int iCount = msg.Length;
        uint crc = 0xFFFFFFFF;
        for (int i = 0; i < iCount; i++)
        {
            crc = ((crc >> 8) & 0x00FFFFFF) ^ crcTable[(crc ^ (byte)msg[i]) & 0xFF];
        }
        return crc ^ 0xFFFFFFFF;
    }
}
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

7. 生成配置数据

7.1 根据资源路径 及 包名 写入数据

/// <summary>
/// 写入数据
/// </summary>
/// <param name="resPathDict">资源路径字典</param>
private static void WriteData(Dictionary<string, string> resPathDict)
{
    AssetBundleConfig config = new AssetBundleConfig();
    config.ABList = new List<ABBase>();

    foreach(string path in resPathDict.Keys)
    {
        //创建数据
        ABBase abBase = new ABBase();
        abBase.Path = path;
        abBase.ABName = resPathDict[path];
        abBase.Crc = Crc32.GetCRC32(path);
        abBase.AssetName = path.Remove(0, path.LastIndexOf('/') + 1);

        //记录其依赖的AB包名
        abBase.ABDependce = new List<string>();

        //获取每个文件依赖
        string[] resDependce = AssetDatabase.GetDependencies(path);
        for(int i = 0; i < resDependce.Length; i++)
        {
            //不包括本身资源 也不包括脚本文件
            if (resDependce[i] == path ||
                resDependce[i].EndsWith(".cs"))
            {
                continue;
            }

            string abName = "";
            if(resPathDict.TryGetValue(resDependce[i], out abName))
            {
                //资源在当前包内
                if(abName == abBase.ABName)
                {
                    continue;
                }

                //新的依赖包才添加到依赖中
                if(!abBase.ABDependce.Contains(abName))
                {
                    abBase.ABDependce.Add(abName);
                }
            }
        }
        config.ABList.Add(abBase);
    }

    //TODO：制作成 Xml 文件 和 二进制文件
}
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

7.2 整理资源的有效数据

7.2.1 创建字典

//记录有效的AB包文件（文件夹）路径
private static List<string> m_ValidConfigPath = new List<string>();
1
2

7.2.2 记录SO数据的文件夹及Prefab

//记录有效文件夹路径
m_ValidConfigPath.Add(fdABName.Path);

//记录有效文件
m_ValidConfigPath.Add(path);
1
2
3
4
5

7.2.3 修改配置表记录的数据

//只记录有效资源的数据，不记录所依赖的资源情况
if(ValidPath(allAssetPath[j]))
{
    resPathDict.Add(allAssetPath[j], allBundles[i]);
}

/// <summary>
/// 是否是有效的AB包路径
/// </summary>
/// <param name="path">该资源路径</param>
/// <returns></returns>
private static bool ValidPath(string path)
{
    for(int i = 0; i < m_ValidConfigPath.Count; i++)
    {
        if (path.Contains(m_ValidConfigPath[i]))
        {
            return true;
        }
    }
    return false;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

8. 生成配置表文件

    //写入Xml
    string xmlPath = Application.dataPath + "/AssetbundleConfig.xml";
    if (File.Exists(xmlPath)) File.Delete(xmlPath);
    FileStream fileStream = new FileStream(xmlPath, FileMode.Create);
    StreamWriter sw = new StreamWriter(fileStream, Encoding.UTF8);
    XmlSerializer xs = new XmlSerializer(config.GetType());
    xs.Serialize(sw, config);
    sw.Close();
    fileStream.Close();

    //写入二进制
    //取消文件路径名
    foreach (ABBase abBase in config.ABList)
    {
        abBase.Path = "";
    }

    string bytePath = AssetBundleBuildPath + "/AssetBundleConfig.bytes";
    if (File.Exists(bytePath)) File.Delete(bytePath);
    fileStream = new FileStream(bytePath, FileMode.Create);
    BinaryFormatter bf = new BinaryFormatter();
    bf.Serialize(fileStream, config);
    fileStream.Close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

打包出来的Xml

因为作者精力有限，文章中难免出现一些错漏，敬请广大专家和网友批评、指正。