Cocos Creator资源管理AssetManager细说一二

关于AssetManager

Asset Manager 是 Creator 在 v2.4 新推出的资源管理器，用于替代之前的 cc.loader。新的 Asset Manager 资源管理模块具备加载资源、查找资源、销毁资源、缓存资源、Asset Bundle 等功能，相比之前的 cc.loader 拥有更好的性能，更易用的 API，以及更强的扩展性。所有函数和方法可通过 cc.assetManager 进行访问，所有类型和枚举可通过 cc.AssetManager 命名空间进行访问。

同时，新的资源管理模块也开始正式支持类似于Unity3D的AssetBundle功能，允许开发者把资源合理分配打包分开加载

关于AssetManager资源管理系统，官方也有相关介绍文档–AssetManager资源管理，我这里作为学习笔记作为一个重要总结。

开始

我们来看下主要用到的功能类

• cc.AssetManager: 此模块管理资源的行为和信息，包括加载，释放等，所有成员能够通过 cc.assetManager 调用. 所有类型或枚举能通过 cc.AssetManager 访问
• Bundle类： 一个包含一定数量资源（包括场景）的包，你可以加载，预加载，释放此包内的资源型

cc.AssetManager主要API

• bundles: AssetManager.Cache<AssetManager.Bundle> : 已加载 bundle 的集合
• assets: AssetManager.Cache<cc.Asset> : 已加载资源的集合
• dependUtil: cc.AssetManager.DependUtil : 管理资源依赖关系
• cacheAsset: boolean ： 是否缓存已加载的资源
• resources: cc.AssetManager.Bundle : 内置 resources 包
• main: cc.AssetManager.Bundle; 内置 main 包
• internal: cc.AssetManager.Bundle; 内置 internal 包
• getBundle (name: string): cc.AssetManager.Bundle; 获取已加载的分包
• removeBundle(bundle: cc.AssetManager.Bundle): void; 移除此包, 注意：这个包内的资源不会自动释放, 如果需要的话你可以在摧毁之前手动调用
• loadAny : 通用加载资源接口，可传入进度回调以及完成回调，通过组合 request 和 options 参数，几乎可以实现和扩展所有想要的加载效果。
• preloadAny : 通用预加载资源接口，可传入进度回调以及完成回调
• postLoadNative : 加载资源的原生文件，如果你勾选了’延迟加载资源’选项，你可能需要在使用资源之前调用此方法来加载原生文件
• loadRemote : 使用 url 加载远程资源，例如音频，图片，文本等等。
• loadScript : 加载脚本
• loadBundle : 加载资源包
• releaseAsset : 释放资源以及其依赖资源, 这个方法不仅会从 assetManager 中删除资源的缓存引用，还会清理它的资源内容。
• releaseAll : 释放所有资源

Bundle 类

Bundle我们可以用cc.resources去调用,在d.ts文件中我们可以看到cc.resource的声明是export var resources: AssetManager.Bundle;

一般我们加载本地资源（resource文件夹下的）都是用到cc.resources

• name bundle名称
• _config:Config AssetBund相关资源配置信息
• getAssetInfo (uuid: string): Record<string, any>; 通过 uuid 获取资源信息
• getSceneInfo(name: string): Record<string, any>; 通过场景名获取场景信息
• load() 通过相对路径加载分包中的资源。路径是相对分包文件夹路径的相对路径。（函数参数太长，这里就详细列出来了。下同）
• preload() 通过相对路径预加载分包中的资源。调用完后，你仍然需要通过 Bundle.load 来完成加载。
• loadDir() 加载目标文件夹中的所有资源, 注意：路径中只能使用斜杠，反斜杠将停止工作
• preloadDir() 预加载目标文件夹中的所有资源。调用完后，你仍然需要通过 Bundle.loadDir 来完成加载
• loadScene() 通过场景名称加载分包中的场景。
• preloadScene() 通过场景名称预加载分包中的场景.调用完后，你仍然需要通过Bundle.loadScene 或 cc.director.loadScene 来完成加载。
• get(path: string, type?: typeof cc.Asset): T 通过路径与类型获取资源
• release(path: string, type: typeof cc.Asset): void; --type可选 释放
• releaseAll(): void; 释放此包中的所有资源

资源的加载

1. 本地动态加载

资源放在 resources 目录下，并配合 cc.resources.load,资源动态加载的时候都是 异步 的

cc.resources.load('images/background', cc.SpriteFrame, (err, asset) => {
   this.getComponent(cc.Sprite).spriteFrame = asset;
 });

上面是简单的加载资源的方式，这个方法还有几个参数
load

• paths: resources文件夹下面的资源路径（最后的文件名不带后缀）
• type(cc.Asset): 资源类型(可选参数)
• onProgress: 进度（可选参数）
  1. finish（number）：完成的进度数
  2. total(number)：完成总数
  3. item(RequestItem)： 相关信息集合
• onComplete: 完成加载的事件回调
  1. error: 资源加载错误信息
  2. assets: 完成的相关资源
     也可以整个文件夹加载

cc.resources.loadDir('images', cc.SpriteFrame, (err, assetArr) => {
   //这个时候assetArr是包含Images所有SpriteFrame资源的数组
 });

加载整个文件夹的函数的参数和上面load一样的，只是回调的资源从单个资源换成了数组

注意： 图片设置为 Sprite 后，将会在 资源管理器 中生成一个对应的 SpriteFrame。但如果直接加载 test assets/image，得到的类型将会是 cc.Texture2D。你必须指定第二个参数为资源的类型，才能加载到图片生成的 cc.SpriteFrame：

2. 加载远程资源

直接调用 cc.assetManager.loadRemote 方法。同时，如果开发者用其他方式下载了资源到本地设备存储中，也需要用同样的 API 来加载，上文中的 cc.resources.load 等 API 只适用于应用包内的资源和热更新的本地资源

//loadRemote<T extends cc.Asset>(url: string, options: Record<string, any>, onComplete: (err: Error, asset: T) => void): void;

// 远程 url 带图片后缀名
var remoteUrl = "http://unknown.org/someres.png";
cc.assetManager.loadRemote(remoteUrl, function (err, texture) {
    // Use texture to create sprite frame
});

// 远程 url 不带图片后缀名，此时必须指定远程图片文件的类型
remoteUrl = "http://unknown.org/emoji?id=124982374";
cc.assetManager.loadRemote(remoteUrl, {ext: '.png'}, function () {
    // Use texture to create sprite frame
});

// 用绝对路径加载设备存储内的资源，比如相册
var absolutePath = "/dara/data/some/path/to/image.png"
cc.assetManager.loadRemote(absolutePath, function () {
    // Use texture to create sprite frame
});

// 远程音频
remoteUrl = "http://unknown.org/sound.mp3";
cc.assetManager.loadRemote(remoteUrl, function (err, audioClip) {
    // play audio clip
});

// 远程文本
remoteUrl = "http://unknown.org/skill.txt";
cc.assetManager.loadRemote(remoteUrl, function (err, textAsset) {
    // use string to do something
});

目前的此类手动资源加载还有一些限制，对开发者影响比较大的是：

1. 这种加载方式只支持图片、声音、文本等原生资源类型，不支持 SpriteFrame、SpriteAtlas、Tilemap 等资源的直接加载和解析。（如需远程加载所有资源，可使用 Asset Bundle)
2. Web 端的远程加载受到浏览器的 CORS 跨域策略限制，如果对方服务器禁止跨域访问，那么会加载失败，而且由于 WebGL 安全策略的限制，即便对方服务器允许 http 请求成功之后也无法渲染。

3. 从AssetBundle中加载资源

这里的流程只是多了一个加载AssetBundle资源

加载AssetBundle-bundle-bundle中加载资源
通过cc.assetManager.loadBundle 来加载AssetBundle，加载时需要传入AssetBundle 配置面板中的Bundle名称或者AssetBundle的url。但当你复用其他项目的AssetBundle 时，则只能通过 url 进行加载

在AssetBundle 加载完成后，返回了一个cc.AssetManager.Bundle类的实例。上面我们说过，cc.resources本质上也是个cc.AssetManager.Bundle类实例，所以到这里我们就可以通过上面的cc.resources.load去加载我们
AssetBundle里面的资源了

cc.assetManager.loadBundle('01_graphics', (err, bundle) =>
        {
            // 加载 Prefab
            bundle.load(`prefab`, cc.Prefab, function (err, prefab)
            {
                let newNode = cc.instantiate(prefab);
                cc.director.getScene().addChild(newNode);
            });

            // 加载 Texture
            bundle.load(`image`, cc.Texture2D, function (err, texture)
            {
                console.log(texture)
            });
        });

// 当复用其他项目的 Asset Bundle 时
cc.assetManager.loadBundle('https://othergame.com/remote/01_graphics', (err, bundle) => {
    bundle.load('xxx');
});

如果需要批量加载就调用loadDir就行

// 加载 textures 目录下的所有资源
bundle.loadDir("textures", function (err, assets) {
    // ...
});

关于AssetBundle的还有很大篇幅要讲，这里只是简单说下加载。想了解具体的AssetBundle知识的可以看这里（Cocos Creator AssetBundle详解）

4. 预加载

为了减少下载的延迟，cc.assetManager 和 Asset Bundle 中不但提供了加载资源的接口，每一个加载接口还提供了对应的预加载版本。开发者可在游戏中进行预加载工作，然后在真正需要时完成加载。预加载只会下载必要的资源，不会进行反序列化和初始化工作，所以性能消耗更小，适合在游戏过程中使用

cc.resources.preload('test assets/image', cc.SpriteFrame);

// wait for while
cc.resources.load('test assets/image', cc.SpriteFrame, function (err, spriteFrame) {
    self.node.getComponent(cc.Sprite).spriteFrame = spriteFrame;
});

开发者可以使用预加载相关接口提前加载资源，不需要等到预加载结束即可使用正常加载接口进行加载，正常加载接口会直接复用预加载过程中已经下载好的内容，缩短加载时间

为了尽可能缩短下载时间，很多游戏都会使用预加载。Asset Manager 中的大部分加载接口包括 load、loadDir、loadScene 都有其对应的预加载版本。加载接口与预加载接口所用的参数是完全一样的，两者的区别在于：

1. 预加载只会下载资源，不会对资源进行解析和初始化操作。
2. 预加载在加载过程中会受到更多限制，例如最大下载并发数会更小。
3. 预加载的下载优先级更低，当多个资源在等待下载时，预加载的资源会放在最后下载。
4. 因为预加载没有做任何解析操作，所以当所有的预加载完成时，不会返回任何可用资源。
   相比 Creator v2.4 以前的版本，以上优化手段充分降低了预加载的性能损耗，确保了游戏体验顺畅。开发者可以充分利用游戏过程中的网络带宽缩短后续资源的加载时间。

5. 加载场景

加载场景和加载资源差不多的

//loadScene(sceneName: string, options: Record<string, any>, onProgress: (finish: number, total: number, item: RequestItem) => void, onComplete: (error: Error, sceneAsset: cc.SceneAsset) => void): void;
cc.resources.loadScene(_url, (e: Error, res: cc.SceneAsset) =>
        {
            if (e) {
                cc.error('resource error:', e.name, e.message, e.stack, ',url:', _url);
            }
            else {
                cc.log('load resource success:', _url);
                _completeCB();
            }
        });

相关参数也差不多，这里也没什么好说的

我们也可以预加载场景

cc.resources.preloadScene('mainScene',(err:Error)=>{
            if (err) {
                cc.error('resource error:', err.name, err.message, err.stack);
            }
            console.log('场景预加载完成');
        });

资源的依赖与释放

在加载完资源之后，所有的资源都会临时被缓存到cc.assetManager中，以避免重复加载资源时发送无意义的http请求，当然，缓存的内容都会占用内存，有些资源可能开发者不再需要了，想要释放他们，这里介绍一下在做资源释放时需要注意的事项。

资源之间是互相依赖的
比如下图，Prefab资源中的Node包含Sprite组件，Sprite组件依赖于SpriteFrame，SpriteFrame资源依赖于Texture资源，而Prefab，SpriteFrame和Texture资源都被cc.assetManager缓存起来了，这样做的好处是，有可能有另一个SpriteAtlas资源
依赖于同样的一个SpriteFrame和Texture，那么当你手动加载这个SpriteAtlas的时候，就不需要再重新请求贴图资源了，cc.assetManager会自动使用缓存中的资源

自动释放

场景的自动释放可以直接在编辑器中设置。在资源管理器选中场景后，属性检查器中会出现自动释放资源选项。
另外，所有 cc.Asset 实例都拥有成员函数 cc.Asset.addRef 和 cc.Asset.decRef，分别用于增加和减少引用计数。一旦引用计数为零，Creator 会对资源进行自动释放（需要先通过释放检查，具体可参考下部分内容的介绍）

start () {
    cc.resources.load('images/background', cc.Texture2D, (err, texture) => {
        this.texture = texture;
        // 当需要使用资源时，增加其引用
        texture.addRef();
        // ...
    });
}


onDestroy () {
    // 当不需要使用资源时，减少引用
    // Creator 会在调用 decRef 后尝试对其进行自动释放
    this.texture.decRef();
}

自动释放的优势在于不用显式地调用释放接口，开发者只需要维护好资源的引用计数，Creator 会根据引用计数自动进行释放。这大大降低了错误释放资源的可能性，并且开发者不需要了解资源之间复杂的引用关系。对于没有特殊需求的项目，建议尽量使用自动释放的方式来释放资源。

释放检查

为了避免错误释放正在使用的资源造成渲染或其他问题，Creator 会在自动释放资源之前进行一系列的检查，只有检查通过了，才会进行自动释放。

1. 如果资源的引用计数为 0，即没有其他地方引用到该资源，则无需做后续检查，直接摧毁该资源，移除缓存。
2. 资源一旦被移除，会同步触发其依赖资源的释放检查，将移除缓存后的资源的 直接 依赖资源（不包含后代）的引用都减 1，并同步触发释放检查。
3. 如果资源的引用计数不为 0，即存在其他地方引用到该资源，此时需要进行循环引用检查，避免出现自己的后代引用自己的情况。如果循环引用检查完成之后引用计数仍不为 0，则终止释放，否则直接摧毁该资源，移除缓存，并触发其依赖资源的释放检查（同步骤 2）。

手动释放

当项目中使用了更复杂的资源释放机制时，可以调用 Asset Manager 的相关接口来手动释放资源。例如：

cc.assetManager.releaseAsset(texture);

因为资源管理模块在 v2.4 做了升级，所以释放接口与之前的版本有一点区别：

1. cc.assetManager.releaseAsset 接口仅能释放单个资源，且为了统一，接口只能通过资源本身来释放资源，不能通过资源 uuid、资源 url 等属性进行释放。
2. 在释放资源时，开发者只需要关注资源本身，引擎会 自动释放 其依赖资源，不再需要通过 getDependsRecursively 手动获取依赖。

注意：release 系列接口（例如 release、releaseAsset、releaseAll）会直接释放资源，而不会进行释放检查，只有其依赖资源会进行释放检查。所以当显式调用 release 系列接口时，可以确保资源本身一定会被释放。

引用计数统计

在 v2.4 之前，Creator 选择让开发者自行控制所有资源的释放，包括资源本身及其依赖项，开发者必须手动获取资源所有的依赖项并选择需要释放的依赖项。这种方式给予了开发者最大的控制权，对于小型项目来说工作良好。但随着 Creator 的发展，项目的规模不断扩大，场景所引用的资源不断增加，其他场景也可能复用了这些资源，这就会导致释放资源的复杂度越来越高，开发者要掌握所有资源的使用非常困难。

为了解决这个痛点，Asset Manager 提供了一套基于引用计数的资源释放机制，让开发者可以简单高效地释放资源，不用担心项目规模的急剧膨胀。需要说明的是 Asset Manager 只会自动统计资源之间的静态引用，并不能真实地反应资源在游戏中被动态引用的情况，动态引用还需要开发者进行控制以保证资源能够被正确释放。原因如下：

JavaScript 是拥有垃圾回收机制的语言，会对其内存进行管理，在浏览器环境中引擎无法知道某个资源是否被销毁。

JavaScript 无法提供赋值运算符的重载，而引用计数的统计则高度依赖于赋值运算符的重载。

资源的静态引用

当开发者在编辑器中编辑资源时（例如场景、预制体、材质等），需要在这些资源的属性中配置一些其他的资源，例如在材质中设置贴图，在场景的 Sprite 组件上设置 SpriteFrame。那么这些引用关系会被记录在资源的序列化数据中，引擎可以通过这些数据分析出依赖资源列表，像这样的引用关系就是静态引用。

引擎对资源的静态引用的统计方式为：

1. 在使用 cc.assetManager 或者 Asset Bundle 加载某个资源时，引擎会在底层加载管线中记录该资源所有 直接依赖资源 的信息，并将所有 直接依赖资源 的引用计数加 1，然后将该资源的引用计数初始化为 0。
2. 在释放资源时，取得该资源之前记录的所有 直接依赖资源 信息，并将所有依赖资源的引用计数减 1。

因为在释放检查时，如果资源的引用计数为 0，才可以被自动释放。所以上述步骤可以保证资源的依赖资源无法先于资源本身被释放，因为依赖资源的引用计数肯定不为 0。也就是说，只要一个资源本身不被释放，其依赖资源就不会被释放，从而保证在复用资源时不会错误地进行释放。下面我们来看一个例子：

1. 假设现在有一个 A 预制体，其依赖的资源包括 a 材质和 b 材质。a 材质引用了 α 贴图，b 材质引用了 β 贴图。那么在加载 A 预制体之后，a、b 材质的引用计数都为 1，α、β 贴图的引用计数也都为 1。

2. 假设现在又有一个 B 预制体，其依赖的资源包括 b 材质和 c 材质。则在加载 B 预制体之后，b 材质的引用计数为 2，因为它同时被 A 和 B 预制体所引用。而 c 材质的引用计数为 1，α、β 贴图的引用计数也仍为 1。

3. 此时释放 A 预制体，则 a，b 材质的引用计数会各减 1

• a 材质的引用计数变为 0，被释放，所以贴图 α 的引用计数减 1 变为了 0，也被释放。
• b 材质的引用计数变为 1，被保留，所以贴图 β 的引用计数仍为 1，也被保留。
• 因为 B 预制体没有被释放，所以 c 材质的引用计数仍为 1，被保留。

资源的动态引用

当开发者在编辑器中没有对资源做任何设置，而是通过代码动态加载资源并设置到场景的组件上，则资源的引用关系不会记录在序列化数据中，引擎无法统计到这部分的引用关系，这些引用关系就是动态引用。

如果开发者在项目中使用动态加载资源来进行动态引用，例如：

cc.resources.load('images/background', cc.SpriteFrame, function (err, spriteFrame) {
    self.getComponent(cc.Sprite).spriteFrame = spriteFrame;
});

此时会将 SpriteFrame 资源设置到 Sprite 组件上，引擎不会做特殊处理，SpriteFrame 的引用计数仍保持 0。如果动态加载出来的资源需要长期引用、持有，或者复用时，建议使用 addRef 接口手动增加引用计数。例如：

cc.resources.load('images/background', cc.SpriteFrame, function (err, spriteFrame) {
    self.getComponent(cc.Sprite).spriteFrame = spriteFrame;
    spriteFrame.addRef();
});

增加引用计数后，可以保证该资源不会被提前错误释放。而在不需要引用该资源以及相关组件，或者节点销毁时，请 务必记住 使用 decRef 移除引用计数，并将资源引用设为 null，例如：

this.spriteFrame.decRef();
this.spriteFrame = null;

最后一个值得关注的要点：JavaScript的垃圾回收是延迟的

想象一种情况，当你释放了cc.assetManager对某个资源的引用之后，由于考虑不周的原因，游戏逻辑再次请求了这个资源。此时垃圾回收还没有开始（垃圾回收时机不可控），当出现这个情况时，意味着这个资源还存在内存中，但是cc.assetManger已经
访问不到了，所以会重新加载它。这造成这个资源在内存中有两份同样的拷贝，浪费了内存。如果只是一个资源还好，但是如果类似的资源很多，甚至于不知一次被重复加载，这对于内存的压力是有可能很高的。

如果观察到游戏使用的内存曲线有这样的异常，请仔细检查游戏逻辑，避免释放近期内将要重复的资源，如果没有的话，垃圾回收机制是会正常回收这些内存的。