Unity自动化之自动构建图集与压缩

---

前言

为降低DrawCall，我们需要将多个图片构建在图集上。同时还有个好处，可以自动补齐图片补齐2的幂次方或正方形图，这样便可以进行ETC和PVRTC压缩了。

官方解释请注意 Sprite Packer 在 Unity 2020.1 和更新版本中已弃用，并且将不再作为精灵打包模式的可用选项。现有已使用 Sprite Packer 的项目仍然可以继续使用它，但是在 2020.1 以后创建的任何新项目在打包纹理时将默认使用 Sprite Atlas 系统。

---

一、UI图集的压缩

如果是UI图片，设置了相同packingTag的Sprite会合并在一个图集，但是游戏中有很多本身就很大的图片，比如背景图或者大头像图。由于这些图片不一定是2的幂次方或正方形图，所以我们可以自动给它们设置成一个唯一的packingTag，这样它们也可以进行压缩了。

如果有些大图需要设置成了RGBA32或者RGBA16，并且自身并不是2的幂次方或者正方形图的话，在去加pakcingTag就不太合适了，这样只会让图片变得更大。所以，在自动构建图集的时候可以做个判断，当图片出现这类情况时不再构建图集。

首先打开图集模式
内部选项，根据需要选择

在包管理器安装2D Sprite插件包

unity2020之前的版本使用图集

设置PackingTag

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

public class CustomPackerPolicySample : UnityEditor.Sprites.IPackerPolicy
{
    bool UnityEditor.Sprites.IPackerPolicy.AllowSequentialPacking {
        get {
            return true;
        }
    }

    protected class Entry
    {
        public Sprite            sprite;
        public UnityEditor.Sprites.AtlasSettings settings;
        public string            atlasName;
        public SpritePackingMode packingMode;
        public int                anisoLevel;
    }

    private const uint kDefaultPaddingPower = 3;

    public virtual int GetVersion() { return 1; }
    protected  string TagPrefix { get { return "[RECT]"; } }
    protected  bool AllowTightWhenTagged { get { return true; } }
    protected  bool AllowRotationFlipping { get { return true; } }

    //判断图片是否为压缩格式
    public static bool IsCompressedFormat(TextureFormat fmt)
    {
        if(fmt >= TextureFormat.DXT1 && fmt <= TextureFormat.DXT5)
            return true;
        if(fmt >= TextureFormat.DXT1Crunched && fmt <= TextureFormat.DXT5Crunched)
            return true;
        if(fmt >= TextureFormat.PVRTC_RGB2 && fmt <= TextureFormat.PVRTC_RGBA4)
            return true;
        if(fmt == TextureFormat.ETC_RGB4)
            return true;
        if(fmt >= TextureFormat.ETC_RGB4 && fmt <= TextureFormat.ETC2_RGBA8)
            return true;
        if(fmt >= TextureFormat.EAC_R && fmt <= TextureFormat.EAC_RG_SIGNED)
            return true;
        if(fmt >= TextureFormat.ETC2_RGB && fmt <= TextureFormat.ETC2_RGBA8)
            return true;
        if(fmt >= TextureFormat.ASTC_RGB_4x4 && fmt <= TextureFormat.ASTC_RGBA_12x12)
            return true;
        if(fmt >= TextureFormat.DXT1Crunched && fmt <= TextureFormat.DXT5Crunched)
            return true;
        return false;
    }
public void OnGroupAtlases(BuildTarget target, UnityEditor.Sprites.PackerJob
        job, int[] textureImporterInstanceIDs)
    {
        List<Entry> entries = new List<Entry>();

        foreach(int instanceID in textureImporterInstanceIDs)
        {
            TextureImporter ti = EditorUtility.InstanceIDToObject(instanceID)
                as TextureImporter;

            TextureFormat desiredFormat;
            ColorSpace colorSpace;
            int compressionQuality;
            ti.ReadTextureImportInstructions(target, out desiredFormat, out colorSpace,
                out compressionQuality);

            TextureImporterSettings tis = new TextureImporterSettings();
            ti.ReadTextureSettings(tis);

            Sprite[] sprites =
                AssetDatabase.LoadAllAssetRepresentationsAtPath(ti.assetPath)
                    .Select(x => x as Sprite)
                    .Where(x => x != null)
                    .ToArray();

            foreach(Sprite sprite in sprites)
            {
                //设置图片的压缩参数
                Entry entry = new Entry();
                entry.sprite = sprite;
                entry.settings.format = desiredFormat;
                entry.settings.colorSpace = colorSpace;
                entry.settings.compressionQuality = IsCompressedFormat(desiredFormat)
                    ? compressionQuality : 0;
                entry.settings.filterMode = Enum.IsDefined(typeof(FilterMode),
                    ti.filterMode)
                    ? ti.filterMode
                    : FilterMode.Bilinear;
                entry.settings.maxWidth = 2048;
                entry.settings.maxHeight = 2048;
                entry.settings.generateMipMaps = false;
                entry.settings.enableRotation = AllowRotationFlipping;
                entry.settings.paddingPower = (uint)EditorSettings.
                    spritePackerPaddingPower;
                entry.settings.allowsAlphaSplitting = ti.GetAllowsAlphaSplitting();
                entry.atlasName = ParseAtlasName(ti.spritePackingTag);
                entry.packingMode = GetPackingMode(ti.spritePackingTag,
                    tis.spriteMeshType);
                entry.anisoLevel = ti.anisoLevel;

                entries.Add(entry);
            }
            Resources.UnloadAsset(ti);
        }

        //将相同图集的名称划分成不同图集
        var atlasGroups =
            from e in entries
            group e by e.atlasName;
        foreach(var atlasGroup in atlasGroups)
        {
            int page = 0;
            //相同的图集中压缩格式不同的图划分成不同的组
            var settingsGroups =
                from t in atlasGroup
                group t by t.settings;
            foreach(var settingsGroup in settingsGroups)
            {
                //已经设置了非压缩的图，这里不做成图集，避免图片变大
                bool skipAtlas = (settingsGroup.Count() == 1 && !IsCompressedFormat
                    (settingsGroup.ElementAt(0).settings.format));
                if(skipAtlas) {
                    continue;
                }

                string atlasName = atlasGroup.Key;

                if(settingsGroups.Count() > 1)
                    atlasName += string.Format("(Group {0})", page);

                UnityEditor.Sprites.AtlasSettings settings = settingsGroup.Key;
                settings.anisoLevel = 1;
                if(settings.generateMipMaps)
                    foreach(Entry entry in settingsGroup)
                        if(entry.anisoLevel > settings.anisoLevel)
                            settings.anisoLevel = entry.anisoLevel;

                job.AddAtlas(atlasName, settings);
                foreach(Entry entry in settingsGroup)
                {
                    job.AssignToAtlas(atlasName, entry.sprite, entry.packingMode,
                        SpritePackingRotation.None);
                }

                ++page;
            }
        }
    }

    protected bool IsTagPrefixed(string packingTag)
    {
        packingTag = packingTag.Trim();
        if(packingTag.Length < TagPrefix.Length)
            return false;
        return (packingTag.Substring(0, TagPrefix.Length) == TagPrefix);
    }

    private string ParseAtlasName(string packingTag)
    {
        string name = packingTag.Trim();
        if(IsTagPrefixed(name))
            name = name.Substring(TagPrefix.Length).Trim();
        return(name.Length == 0) ? "(unnamed)" : name;
    }

    private SpritePackingMode GetPackingMode(string packingTag, SpriteMeshType
        meshType)
    {
        if(meshType == SpriteMeshType.Tight)
        if(IsTagPrefixed(packingTag) == AllowTightWhenTagged)
            return SpritePackingMode.Tight;
        return SpritePackingMode.Rectangle;
    }
} 

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
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

    //如果打包前需要自动指定策略，可以强制设置本地打包使用什么图集策略，然后将策略以及打包平台传入即可
    static private void BuildAtlas(BuildTarget buildTarget)
    {
        Packer.SelectedPolicy = typeof(CustomPackerPolicySample).Name;
        Packer.RebuildAtlasCacheIfNeeded(buildTarget);
    }
1
2
3
4
5
6

unity2020之后的版本使用图集

创建图集

图集制作

使用方法

 SpriteAtlas spriteAtlas = AssetDatabase.LoadAssetAtPath<SpriteAtlas>("Assets/Art/xxxx");
 Sprite sprite = spriteAtlas.GetSprite("xxx")
1
2

具体的封装，请根据项目自行调整。

二、非UI图集压缩

如果美术人员没有提供符合2的幂次方或正方形要求的图片，那么这些角色、特效和场景图可能无法进行有效压缩。但是，在图形编辑软件中，可以通过在"Advanced"下拉面板中选择适当的"Non Power of 2"选项来强制将这些图片调整为2的幂次方大小。

在这个选项中，"ToNearest"会将图片大小调整到最接近的2的幂次方，"ToLarger"会将图片大小调整到大于等于原始大小的最小2的幂次方，而"ToSmaller"则会将图片大小调整到小于等于原始大小的最大2的幂次方。通过这些选项，可以自动将图片拉伸到符合规则的大小，从而使图片能够进行有效压缩，提高游戏性能和效率。

---

总结

该篇分享了关于Unity中图集压缩的技巧，包括UI图集和非UI图集的处理方法。通过设置packingTag和在图形编辑软件中调整图像大小的方法，大家可以学会如何有效地压缩游戏中的图像资源，提高游戏性能和效率。希望大家可以通过学习这些技能来优化自己的开发工作。不断学习和探索，打造出更出色的作品！