Unity打包AssetBundle自动分析资源依赖关系（包括UGUI图集打包）

最新推荐文章于 2023-11-06 12:48:35 发布
最新推荐文章于 2023-11-06 12:48:35 发布
阅读量1k 收藏 2
点赞数
分类专栏： Unity
原文链接：https://blog.csdn.net/u012740992/article/details/79371986
版权

https://blog.csdn.net/u012740992/article/details/79371986

 

怎么分析资源的依赖关系呢，并设置AssetBundleName呢？
我们检测资源之间的依赖关系，遍历每一个有引用的资源进行分析，对于非UGUI的图集资源（UGUI图集上面说了），如果此资源A被其他地方资源B引用仅仅1次，那么就将此资源A的AssetBundleName置空不设置，这样打包时，此资源就会自动被和资源B打到一起合成一个AssetBundle包，如此减少打包的碎片。如果资源A被引用超过2次及以上，那么就为资源独立设置AssetBundleName,从而避免被重复打包到几个依赖它的资源包。
这里所说的资源被依赖超过2次就独立打包，如果觉得碎片化太严重，产生太多AssetBundle文件，也可以设置成n（n>=1）次才独立打包，开心就好。
————————————————
版权声明：本文为CSDN博主「漫漫之间n」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/u012740992/article/details/79371986

 

前提说明：

    本文只是针对Unity5.x及以上版本打包AssetBundle。Unity5.x虽然说打包时会处理好资源的依赖关系，但前提依然要我们设置好目标资源的AssetBundleName，如果设置资源AssetBundleName时忽略了资源之间的依赖关系，那么打包AssetBundle时，依然会产生重复打包的资源，所以我写了一套脚本来自动分析资源的依赖关系，并根据资源的依赖关系来设置AssetBundleName，从而避免不必要的资源重复打包。
    我也了解过，
    Unity的AssetStore也有对应的图形界面工具，查看和处理打包AssetBundle时遇到的资源重复打包问题，但觉得图形化界面工具还得人工查看和修改，如果项目大了，一千多个ab甚至几千个ab，那么每次更新资源时去查看哪里存在依赖那也挺累得，效率不高，并且手动修正难说说没有看漏改漏。所以，不如来套脚本搞它一把，提高工作效率和质量。

我用的是Unity5.3.6。

前提有点特殊的是Unity的UGUI图集打包，Unity的官网有介绍如何将UGUI图集正确打成AssetBundle（但我现在翻回去找不到链接了= =。），简单说下：
首先，UGUI是有图集的。
我的UGUI图集打包AssetBundle方式是，每张图集打成一个AssetBundle，所以我这里保证了每张UI图片的PackingTag和自己的AssetBundleName一样。原因，如果AssetBundleName不一样，那么这张UI图片后面所打成的AssetBundle包将会扯带了整张图集的内容，这张图集别的UI图片也在用啊，却被无辜包含进了这个ab包。所以通过保证UI图片的PackingTag==AssetBundleName来保证每张图集只存在一个AssetBundle，保证图集不被重复打包。

怎么分析资源的依赖关系呢，并设置AssetBundleName呢？
我们检测资源之间的依赖关系，遍历每一个有引用的资源进行分析，对于非UGUI的图集资源（UGUI图集上面说了），如果此资源A被其他地方资源B引用仅仅1次，那么就将此资源A的AssetBundleName置空不设置，这样打包时，此资源就会自动被和资源B打到一起合成一个AssetBundle包，如此减少打包的碎片。如果资源A被引用超过2次及以上，那么就为资源独立设置AssetBundleName,从而避免被重复打包到几个依赖它的资源包。
这里所说的资源被依赖超过2次就独立打包，如果觉得碎片化太严重，产生太多AssetBundle文件，也可以设置成n（n>=1）次才独立打包，开心就好。

资源依赖处理的代码构建思路：
这里写图片描述
其实资源之间的依赖关系，就是一个树形依赖关系，只要能构建出资源之间的依赖树，那么就能了解到某个资源被多少颗树引用，也就是被多少个资源引用，从而对症下药，自然能合理设置AssetBundleName。

然后有代码LoaderManager.cs和ABInfo.cs。
注意：一定要放在Editor文件夹下！！

LoaderManager.cs

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

public class LoaderManager {

    static Dictionary<string, AssetInfo> assetInfoDict = new Dictionary<string, AssetInfo>();

    private static string curRootAsset = string.Empty;
    private static float curProgress = 0f;


    [MenuItem("AssetBundleMgr / SetAssetbundleName")]
    static void SetABNames()
    {
        string path = GetSelectedAssetPath();
        if (path == null)
        {
            Debug.LogWarning("请先选择目标文件夹");
            return;
        }
        LoaderManager.GetAllAssets(path);

    }
    [MenuItem("AssetBundleMgr / ClearAllAssetbundelname")]
    static void CleaarAllABNames()
    {
        string[] abnames = AssetDatabase.GetAllAssetBundleNames();
        foreach (var n in abnames)
        {
            AssetDatabase.RemoveAssetBundleName(n, true);
        }
    }

    public static void GetAllAssets(string rootDir) {
        assetInfoDict.Clear();

        DirectoryInfo dirinfo = new DirectoryInfo(rootDir);
        FileInfo[] fs = dirinfo.GetFiles("*.*", SearchOption.AllDirectories);
        int ind = 0;
        foreach (var f in fs)
        {
            curProgress = (float)ind / (float)fs.Length;
            curRootAsset = "正在分析依赖："+f.Name;
            EditorUtility.DisplayProgressBar(curRootAsset, curRootAsset, curProgress);
            ind++;
            int index = f.FullName.IndexOf("Assets");
            if (index != -1)
            {
                string assetPath = f.FullName.Substring(index);
                Object asset = AssetDatabase.LoadMainAssetAtPath(assetPath);
                string upath = AssetDatabase.GetAssetPath(asset);
                if (assetInfoDict.ContainsKey(assetPath) == false
                    && assetPath.StartsWith("Assets")
                    && !(asset is MonoScript)
                    && !(asset is LightingDataAsset)
                    && asset != null
                    ) {
                    AssetInfo info = new AssetInfo(upath, true);
                    //标记一下是文件夹下根资源
                    CreateDeps(info);
                }
                EditorUtility.UnloadUnusedAssetsImmediate();
            }
            EditorUtility.UnloadUnusedAssetsImmediate();
        }
        EditorUtility.ClearProgressBar();

        int setIndex = 0;
        foreach (KeyValuePair<string, AssetInfo> kv in assetInfoDict) {
            EditorUtility.DisplayProgressBar("正在设置ABName", kv.Key, (float)setIndex/(float)assetInfoDict.Count);
            setIndex++;
            AssetInfo a = kv.Value;
            a.SetAssetBundleName(2);
        }
        EditorUtility.ClearProgressBar();
        EditorUtility.UnloadUnusedAssetsImmediate();
        AssetDatabase.SaveAssets();
    }
    /// <summary>
    /// 递归分析每个所被依赖到的资源
    /// </summary>
    /// <param name="self"></param>
    /// <param name="parent"></param>
    static void CreateDeps(AssetInfo self, AssetInfo parent = null) {
        if (self.HasParent(parent))
            return;
        if (assetInfoDict.ContainsKey(self.assetPath) == false) {
            assetInfoDict.Add(self.assetPath, self);
        }
        self.AddParent(parent);

        Object[] deps = EditorUtility.CollectDependencies(new Object[] { self.GetAsset() });
        for (int i = 0; i < deps.Length; i++) {
            Object o = deps[i];
            if (o is MonoScript || o is LightingDataAsset)
                continue;
            string path = AssetDatabase.GetAssetPath(o);
            if (path == self.assetPath)
                continue;
            if (path.StartsWith("Assets") == false)
                continue;
            AssetInfo info = null;
            if (assetInfoDict.ContainsKey(path))
            {
                info = assetInfoDict[path];
            }
            else {
                info = new AssetInfo(path);
                assetInfoDict.Add(path, info);
            }
            EditorUtility.DisplayProgressBar(curRootAsset, path, curProgress);
            CreateDeps(info, self);
        }
        EditorUtility.UnloadUnusedAssetsImmediate();
    }

    static string GetSelectedAssetPath()
    {
        var selected = Selection.activeObject;
        if (selected == null)
        {
            return null;
        }
        Debug.Log(selected.GetType());
        if (selected is DefaultAsset)
        {
            string path = AssetDatabase.GetAssetPath(selected);
            Debug.Log("选中路径： " + path);
            return path;
        }
        else
        {
            return null;
        }
    }
}

    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
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140

ABInfo.cs

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

public class AssetInfo
{

    //是不是被打包文件夹下的直接资源
    private bool isRootAsset = false;

    public string assetPath { get; private set; }

    private HashSet<AssetInfo> childSet = new HashSet<AssetInfo>();
    private HashSet<AssetInfo> parentSet = new HashSet<AssetInfo>();

    public AssetInfo(string assetPath, bool isRootAsset = false)
    {
        this.assetPath = assetPath;
    }
    public Object GetAsset()
    {
        Object asset = AssetDatabase.LoadMainAssetAtPath(assetPath);
        return asset;
    }
    /// <summary>
    /// 从这里开始分析构建资源依赖树
    /// </summary>
    /// <param name="parent"></param>
    public void AddParent(AssetInfo parent)
    {
        if (parent == this || IsParentEarlyDep(parent) || parent == null)
            return;

        parentSet.Add(parent);
        parent.AddChild(this);

        parent.RemoveRepeatChildDep(this);
        RemoveRepeatParentDep(parent);
    }
    /// <summary>
    /// 清除我父节点对我子节点的重复引用，保证树形结构
    /// </summary>
    /// <param name="targetParent"></param>
    private void RemoveRepeatChildDep(AssetInfo targetChild)
    {

        List<AssetInfo> infolist = new List<AssetInfo>(parentSet);
        for (int i = 0; i < infolist.Count; i++)
        {
            AssetInfo pinfo = infolist[i];
            pinfo.RemoveChild(targetChild);
            pinfo.RemoveRepeatChildDep(targetChild);
        }
    }
    /// <summary>
    /// 清除我子节点被我父节点的重复引用，保证树形结构
    /// </summary>
    /// <param name="targetChild"></param>
    private void RemoveRepeatParentDep(AssetInfo targetParent)
    {

        List<AssetInfo> infolist = new List<AssetInfo>(childSet);
        for (int i = 0; i < infolist.Count; i++)
        {
            AssetInfo cinfo = infolist[i];
            cinfo.RemoveParent(targetParent);
            cinfo.RemoveRepeatParentDep(targetParent);
        }
    }

    private void RemoveChild(AssetInfo targetChild)
    {
        childSet.Remove(targetChild);
        targetChild.parentSet.Remove(this);
    }
    private void RemoveParent(AssetInfo parent)
    {
        parent.childSet.Remove(this);
        parentSet.Remove(parent);
    }


    private void AddChild(AssetInfo child)
    {
        childSet.Add(child);
    }

    /// <summary>
    /// 如果父节点早已当此父节点为父节点
    /// </summary>
    /// <param name="targetParent"></param>
    /// <returns></returns>
    private bool IsParentEarlyDep(AssetInfo targetParent)
    {
        if (parentSet.Contains(targetParent))
        {
            return true;
        }
        var e = parentSet.GetEnumerator();
        while (e.MoveNext())
        {
            if (e.Current.IsParentEarlyDep(targetParent))
            {
                return true;
            }
        }
        return false;
    }
    public bool HasParent(AssetInfo p)
    {
        if (parentSet.Contains(p))
            return true;
        return false;
    }
    /// <summary>
    /// 打包碎片粒度
    /// </summary>
    /// <param name="pieceThreshold"></param>
    public void SetAssetBundleName(int pieceThreshold)
    {
        AssetImporter ai = AssetImporter.GetAtPath(this.assetPath);
        //针对UGUI图集的处理,图集以文件夹为单位打包ab
        if (ai is TextureImporter)
        {
            TextureImporter tai = ai as TextureImporter;

            string filePath = System.IO.Path.GetDirectoryName(this.assetPath);
            tai.spritePackingTag = filePath.ToLower().Replace("\\", "_").Replace(".png",string.Empty).Replace(".jpg", string.Empty).Replace(" ", string.Empty);
            
            //AssetBundleName和spritePackingTag保持一致
            tai.SetAssetBundleNameAndVariant(tai.spritePackingTag + ".ab", null);
            Debug.Log("<color=#2E8A00>" + "设置ab，Image资源: " + this.assetPath + "</color>");
        }
        else
        {
            string abname = this.assetPath.Replace("/", "_") + ".ab";
            //不是图集，而且大于阀值
            if (this.parentSet.Count >= pieceThreshold)
            {
                ai.SetAssetBundleNameAndVariant(abname, string.Empty);
                Debug.Log("<color=#6501AB>" + "设置ab，有多个引用: " + this.assetPath+"</color>");
            }
            //根节点
            else if (this.parentSet.Count == 0 || this.isRootAsset)
            {
                ai.SetAssetBundleNameAndVariant(abname, string.Empty);
                Debug.Log("<color=#025082>" + "设置ab，根资源ab: " + this.assetPath + "</color>");
            }
            else
            {
                //其余的子资源
                ai.SetAssetBundleNameAndVariant(string.Empty, string.Empty);
                Debug.Log("<color=#DBAF00>" + "清除ab， 仅有1个引用: " + this.assetPath + "</color>");
            }
        }
    }
}


    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
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160

用法：
1，选择Unity内我们所要打包的资源所在的文件夹；
2，菜单栏“AssetBundleMgr->SetAssetbundleName”,完成！看一下资源的AssetBundleName。

如：我选择了Prefabs文件夹，然后菜单栏“AssetBundleMgr->SetAssetbundleName”，资源都被正确设置了AssetBundleName。


————————————————
版权声明：本文为CSDN博主「漫漫之间n」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/u012740992/article/details/79371986

kuangben2000
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2024年Unity 面试题 |五萬字 二佰道| Unity面试题大全，面试题总结【全网最全，收藏一篇足够面试】
努力前行，总会成为自己心中的那道光
02-23 12万+
正所谓 金三银四 ，又到了找工作的大好时机了，不知道大家有没有意向找一份更好的工作呢~ 之前写了很多Unity的学习和实例文章，但是面试题部分还没有一个系统的整理。 那本篇文章就来整理一下Unity中一些常见的面试题，说不准就会面试的时候就会遇到！ 本篇文章会将Unity所有方面的面试资料都融会贯通，绝对是2022年Unity面试领域最实用的文章啦！
Unity3d中的资源打包和加载
zjjlittle的专栏
08-27 2258
资源打包 1、美术资源打包 美术资源包括：角色模型，复杂特效，动作，场景 1.注入shader依赖 因为这些资源都可能用到shader，所以批量化的将shader统一注入依赖打包所有的特效，而shader可以挂在一个gameobject上面（shader需要放在Resources目录下) 2.打包后的目标目录 存放在Assets/StreamingAssets目录下，此目录会按原样打包
【Unity】AssetBundle 资源打包和依赖资源打包
阿黄的博客
01-11 1338
转载地址：http://blog.csdn.net/yxingyeyouyu/article/details/42921499 前段时间做了一个项目，刚好使用到了AssetBundle资源打包的东西，于是花了点时间研究了一下AssetBundle. AssetBundle 打包    我用NGUI插件加载了一张图片，并且把它拖拽为预制名为Texture3.prefab  和 Te
将NGUI图集打包成AssetBundle的实现
gr249321174的专栏
03-18 1625
将NGUI图集打包成AssetBundle的实现 UGUI可以很方便的实现打包功能，但是NGUI里面的图集有三个文件，一个预设一个图片一个材质，他们之间是有依赖关系的，所以要想实现以前的NGUI代码的UI图片替换（例如国际化功能），所以我在这里写了一个直接替换NGUI图集的功能。核心代码如下，有问题可以交流。 //从资源包获取UI图集     UIAtlas Get(string n
Unity5 Sprite 图集打包 AssetBundle 更新探索
热门推荐
无幻
09-11 3万+
自从Unity 提供 Sprite Packer 方案，精灵图片就不需要自己来合并图集了，而是设置 Packing Tag 就会使得 Unity 自动帮我们合并图集。但是做资源更新的时候，自动生成的图集是如何打包到 AssetBundle 呢，这里使用一些解包工具来探索一下。
AssetBundle打包依赖关系
ECUSTseven的博客
06-22 387
AssetBundle打包依赖关系
Unity3d AssetBundle依赖关系获取
qq_37421018的博客
06-19 3621
PS:本文将从“打包之前”和“打包之后”两个方面去说明如何获取依赖关系 获取AB包依赖的作用 众所周知，如果一个AB包（我们称之为C）里面的资源引用到的其他资源（我们成为R）并没有被打包成AB包，那么C里面就会多出一份资源R的备份，如果只是一个C里面多了一个R的备份那还好，但是如果有很多其他AB包Cx都备份了一个R，那么这就是资源的冗余，没有必要，这也就提示了我们应该把R打包成AB包（我们称为D），那么这些Cx就只会多出一个依赖于D包的依赖，不会多出那么多资源。 而AB包在加载还原的时候，如果依赖了其他AB
Unity之资源打包Assetbundle
zhliu1991的专栏
10-20 2964
一、如何创建AssetBundle（后面简写为AB）
（unity）AssetBundle资源打包基础——笔记
C_haning的博客
02-02 291
（完整代码–懒人笔记–学习用） 一、AssetBundle用处 1，AssetBundle是一个压缩包包含模型、贴图、预制体、声音、甚至整个场景，可以在游戏运行的时候被加载，可以理解成资源包； 2，AssetBundle可以相互依赖，比如说，预制体模型包（一个包）可以依赖与材质包（另一个包）； 3，压缩包可以使用LZMA和LZ4压缩算法，减少包大小，更快的进行网络传输； 4，把一些可以下载内容放在...
Unity3d Ugui 23图集Sprite Atlas
HexianWHH的专栏
08-15 1万+
一：版本变化 图集Sprite Packer在 Unity 2020.1以及以后的版本不再作为精灵打包模式的可用选项。以后创建的任何新项目在打包纹理时将默认使用 Sprite Atlas打包图集。旧版的图集使用请参考https://blog.csdn.net/HexianWHH/article/details/119463004?spm=1001.2014.3001.5501 二：安装和开启 1：安装 我使用的是2020.3.13f1c1新版的unitySprite Atlas是插件形式的。 导.
UGUI 图集方案 & DrawCall优化 & UI资源打包策略
08-28 2513
Unity UGUI 打包图集方案 Sprite Packer (4.X版本以上) * 小图资源需关闭Read/Write，否则打不进图集里，好奇怪！！！！。 * Resources文件夹下的资源是不被打包进图集的。 * Sprite2d 设置PackingTag 决定资源被打进哪个图集。 * 需要为每个资源设置Packin...
AssetBundle 遇到的问题记录
宁静致远
05-20 1322
Q3：Resource的场景下有两个场景Scene1.unity和Scene2.unity。我要对这些文件进行打包，生成了 Scene1.assetbundle Scene1.assetbundle.meta Scene2.assetbundle Scene2.assetbundle.meta 如果我有相同的资源，理论上它会在这两个包里各存一份，这样就造成了包体过大。所以有没有办法
Unity UGUI图集打包Assetbundle
SnoopyNa2Co3的博客
08-10 2456
Ugui图集，Sprite是根据PackingTag来分图集 那么Ugui图集怎么打包Assetbundle？ 只要我们把Assetbundle的标签设置为PackingTag就可以，然后打包Assetbundle，测试过drawcall不会增多 这些动态设置PackingTag和Assetbundle一般都用工具来设 我这个工具图集路径是在Assets/AssetBundleRes/at...
[Unity5.X]AssetBundle总结
六天
07-28 1338
AssetBundle简介当我们提到AssetBundle时,实际上有两层含义。 AssetBundle打包的资源，存在于我们的硬盘上或者远端的服务器上。此时，可以认为AssetBundle特指被压缩过的文件，包含Model、Texture等。在运行时，我们可以动态的加载这些对象到我们的场景当中。 AssetBundle对象。这是对AssetBundle打包的资源的抽象，作为游戏访问资源的接口。实际
unity打AB包，AssetBundle预制体与图集（一）
qq_42489774的博客
11-06 480
如果是一个那就写一个 buildMap[1].assetNames = new string[]{“Assets/Atlas/Atlas_One.spriteatlas”};buildMap[0].assetNames 这个是所有要打包的资源的名称，看下图。1、先创建一个AB包的按钮，如图。如下图，没有就自己新建吧。创建AB包，加上完整代码。至此，AB包完成打包。
极简教程3：Assetbundle的依赖分析与分组打包
千樽江月的博客
03-26 1439
如果你不能用最简单的语言来描述，那你就是没有真正领悟。——爱因斯坦 一、依赖关系概述 我们首先通过三张图来了解一下什么是资源依赖。 图一： 在这张图中，模型A使用了一个材质B，而材质B中又包含了一个贴图C。那么他们的实际依赖关系便是：模型A——》材质B——》贴图C。 换言之，如果我们想在游戏中使用模型A，那么我们必须提前加载材质B。但是如果我们想要使用材质B，那么我们又必须提前加载贴图C。 ...
unity打AB包，AssetBundle预制体与图集（二）
最新发布
qq_42489774的博客
11-06 409
运行，点击Btn1 ，可以加载图片ui_frame_fight。点击Btn2,可以创建预制体Prefab_One。
Unity C# AssetBundle与场景打包详解
"Unity C#打包AssetBundle与场景详解，Unity2018简化了打包流程，关注两个关键API：BuildAssetBundles()用于打包AssetBundle，BuildPlayer()用于打包场景。通过设置资源的AssetBundle名称和脚本自动化处理，实现批量...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值