AssetBundles - Hexo

此脚本将在 Assets 菜单底部创建一个名为“Build AssetBundles”的菜单项，该菜单项将执行与该标签关联的函数中的代码。单击 Build AssetBundles 时，将随构建对话框一起显示一个进度条。此过程将会获取带有 AssetBundle 名称标签的所有资源，并将它们放在 abPath 定义的路径中的文件夹中

BuildAssetBundles语法

1	`BuildPipeline.BuildAssetBundles(Path, BuildAssetBundleOptions, BuildTarget);`

Path：指定AssetBundles资源存放的路径

BuildAssetBundleOptions：压缩方式

常用的三个：

BuildAssetBundleOptions.None：使用LZMA算法压缩，压缩的包更小，但是加载时间更长。使用之前需要整体解压。一旦被解压，这个包会使用LZ4重新压缩。使用资源的时候不需要整体解压。在下载的时候可以使用LZMA算法，一旦它被下载了之后，它会使用LZ4算法保存到本地上

BuildAssetBundleOptions.UncompressedAssetBundle：不压缩，包大，加载快

BuildAssetBundleOptions.ChunkBasedCompression：使用LZ4压缩，压缩率没有LZMA高，但可以加载指定资源而不用解压全部，有跟不压缩相媲美的加载速度，而且比不压缩文件要小

BuildTarget：指定平台

使用

using System.IO;
using UnityEditor;

public class CreateAssetBundles
{
    [MenuItem("Assets/Build AssetBundles")]
    static void BuildAllAssetBundles()
    {
        string abPath = "Assets/AssetBundles";
        if (!Directory.Exists(abPath))
        {
            Directory.CreateDirectory(abPath);
        }
        BuildPipeline.BuildAssetBundles(abPath, BuildAssetBundleOptions.None, BuildTarget.StandaloneWindows);
    }
}

使用AssetBundle

可以使用四种不同的 API 来加载 AssetBundle。它们的行为根据加载捆绑包的平台和构建 AssetBundle 时使用的压缩方法（未压缩、LZMA 和 LZ4）而有所不同

AssetBundle.LoadFromMemoryAsync

从内存中加载

若包采用的是 LZMA 压缩方式，将在加载时解压缩 AssetBundle

若包采用的是LZ4 压缩方式，则会以压缩状态加载

语法

//binary: AssetBundle数据的字节数组
//crc: crc校验码（选填）
AssetBundleCreateRequest LoadFromMemoryAsync(byte[] binary, uint crc);//异步
AssetBundle LoadFromMemory(byte[] binary, uint crc);//同步

使用

using System.Collections;
using System.Collections.Generic;
using System.IO;
using UnityEngine;

public class LoadFromFile : MonoBehaviour
{
    private string path = "Assets/AssetBundles/scene/cubewall";//预制体的路径
    private void Start()
    {
        //StartCoroutine("LoadFromMemoryAsync");
        //LoadFromMemory();
    }
    #region LoadFromMemory方式
    //异步的方式
    IEnumerator LoadFromMemoryAsync()
    {
        AssetBundleCreateRequest request = AssetBundle.LoadFromMemoryAsync(File.ReadAllBytes(path));
        yield return request;
        AssetBundle ab = request.assetBundle;
        if (ab == null)
        {
            Debug.Log("加载失败");
        }
        else
        {
            GameObject obj = ab.LoadAsset<GameObject>("Cube");
            Instantiate(obj);
        }
    }
    //同步的方式
    private void LoadFromMemory()
    {
        AssetBundle ab = AssetBundle.LoadFromMemory(File.ReadAllBytes(path));
        if (ab == null)
        {
            Debug.Log("加载失败");
        }
        else
        {
            GameObject obj = ab.LoadAsset<GameObject>("Cube");
            Instantiate(obj);
        }
    }
    #endregion
}

AssetBundle.LoadFromFile

从本地存储中加载未压缩的捆绑包时，此 API 非常高效。

若包未压缩或采用了数据块 (LZ4) 压缩方式，LoadFromFile 将直接从磁盘加载捆绑包

若包完全压缩 (LZMA)，首先解压缩捆绑包，然后再将其加载到内存中

语法

//path: 路径
//crc: crc校验码（选填）
//offset: 字节数组偏移量（选填）
AssetBundleCreateRequest LoadFromFileAsync(string path, uint crc, ulong offset);//异步
AssetBundle LoadFromFile




    
(string path, uint crc, ulong offset);//同步

使用

using System.Collections;
using System.Collections.Generic;
using System.IO;
using UnityEngine;

public class LoadFromFile : MonoBehaviour
{
    private string path = "Assets/AssetBundles/scene/cubewall";//预制体的路径
    private void Start()
    {
        //LoadFromFileFunc();
        //StartCoroutine("LoadFromFileAsync");
    }
    #region LoadFromFile方式
    //同步的方式
    private void LoadFromFileFunc()
    {
        AssetBundle ab = AssetBundle.LoadFromFile(path);
        if (ab == null)
        {
            Debug.Log("加载失败");
        }
        else
        {
            GameObject obj = ab.LoadAsset<GameObject>("Cube");
            Instantiate(obj);
        }
    }
    //异步的方式
    IEnumerator LoadFromFileAsync()
    {
        AssetBundleCreateRequest request = AssetBundle.LoadFromFileAsync(path);
        yield return request;
        AssetBundle ab = request.assetBundle;
        if (ab == null)
        {
            Debug.Log("加载失败");
        }
        else
        {
            GameObject obj = ab.LoadAsset<GameObject>("Cube");
            Instantiate(obj);
        }
    }
    #endregion
}

WWW.LoadFromCacheOrDownload

A从远程服务器下载 AssetBundle 或加载本地 AssetBundle 非常有用（将弃用）

从远程加载 AssetBundle 将自动缓存 AssetBundle：

若 AssetBundle 被压缩，则将启动工作线程来解压缩包并将其写入缓存

若捆绑包被解压缩并缓存，它就会像 AssetBundle.LoadFromFile 一样加载

语法

//url: 地址
//version: 版本号
//crc: crc校验码（选填）
public static WWW LoadFromCacheOrDownload(string url, int version, uint crc);

由于在 WWW 对象中缓存 AssetBundle 字节所需的内存开销，应该确保AssetBundle 保持较小的大小

在有限内存平台（如移动设备）上运行的开发人员确保其代码一次只下载一个 AssetBundle，以此避免内存峰值

如果缓存文件夹没有任何空间来缓存其他文件，LoadFromCacheOrDownload 将以迭代方式从缓存中删除最近最少使用的 AssetBundle，直到有足够的空间来存储新的 AssetBundle

如果无法腾出空间（因为硬盘已满，或者缓存中的所有文件当前都处于使用状态），LoadFromCacheOrDownload() 将不会使用缓存，而将文件流式传输到内存中

为了强制执行 LoadFromCacheOrDownload，需要更改版本参数（第二个参数）。仅当传递给函数的版本与当前缓存的 AssetBundle 的版本匹配，才会从缓存加载 AssetBundle

使用

using System.Collections;
using System.Collections.Generic;
using System.IO;
using UnityEngine;

public class LoadFromFile : MonoBehaviour
{
    private string path = "Assets/AssetBundles/scene/cubewall";//预制体的路径
    private void Start()
    {
        StartCoroutine("WWWWLoadFromLocal");
    }
    #region WWW方式
    IEnumerator WWWWLoadFromLocal()
    {
        while (!Caching.ready)
        {
            yield return null;
        }
        //从本地加载
        //WWW www = WWW.LoadFromCacheOrDownload(@"file://F:\KOONick\unity3D\AssetBundlePro\Assets\AssetBundles\scene\cubewall", 1);
        //从服务器中加载（这里把服务器弄到本地上）
        WWW www = WWW.LoadFromCacheOrDownload(@"http://localhost/AssetBundles/scene/cubewall", 1);
        yield return www;
        if (!string.IsNullOrEmpty(www.error))
        {
            Debug.Log(www.error);
            yield break;
        }
        AssetBundle ab = www.assetBundle;
        if (ab == null)
        {
            Debug.Log("加载失败");
        }
        else
        {
            GameObject obj = ab.LoadAsset<GameObject>("Cube");
            Instantiate(obj);
        }
    }
    #endregion
}

UnityWebRequest

语法

//uri: 地址
//version: 版本号
//crc: crc校验码（选填）
UnityWebRequest UnityWebRequestAssetBundle.GetAssetBundle(Uri uri, uint version, uint crc);

使用

using System.Collections;
using System.Collections.Generic;
using System.IO;
using UnityEngine;
using UnityEngine.Networking;

public class LoadFromFile : MonoBehaviour
{
    private string path = "Assets/AssetBundles/scene/cubewall";//预制体的路径
    private void Start()
    {
        StartCoroutine("UnityWebRequestFunc"); 
    }
    #region UnityWebRequest方式
    IEnumerator UnityWebRequestFunc()
    {
        //从本地加载（地址也可以写： @"file://F:\KOONick\unity3D\AssetBundlePro\Assets\AssetBundles\scene\cubewall"）
        //string uri = "file:///" + Application.dataPath + "/AssetBundles/scene/cubewall";

        //从服务器加载
        string uri = @"http://localhost/AssetBundles/scene/cubewall";
        UnityWebRequest request = UnityWebRequestAssetBundle.GetAssetBundle(uri, 0);
        yield return request.SendWebRequest();
        AssetBundle ab = DownloadHandlerAssetBundle.GetContent(request);
        if (ab == null)
        {
            Debug.Log("加载失败");
        }
        else
        {
            GameObject obj = ab.LoadAsset<GameObject>("Cube");
            Instantiate(obj);
        }
    }
    #endregion
}

加载资源

同步加载

加载单个游戏对象

1	`GameObject obj = ab.LoadAsset<GameObject>("物体名字");`

加载所有资源

//把所有资源放在一个object类型的数组中
object[] objArray = ab.LoadAllAssets();
foreach(object o in objArray)
{
    Instantiate(o as GameObject);
}

异步加载

加载单个游戏对象

AssetBundleRequest ab_request = ab.LoadAssetAsync<GameObject>("Cube_01");
yield return ab_request;
var obj = ab_request.asset;
Instantiate(obj);

加载所有资源

AssetBundleRequest ab_request = ab.LoadAllAssetsAsync();
yield return ab_request;
object[] objArray = ab_request.allAssets;
foreach (object o in objArray)
{
   Instantiate(o as GameObject);
}