1. 项目概述与核心价值

在Unity项目里，尤其是2D或者UI密集型的项目，图集（Atlas）是个绕不开的话题。官方提供的Sprite Atlas系统功能强大，开箱即用，但当你需要更精细的控制、特定的打包策略，或者需要在运行时动态管理纹理资源时，一个完全由自己掌控的自定义图集系统就显得尤为重要。这个系列文章，我们聚焦于“自定义”三个字，从零开始，一步步构建一个贴合项目实际需求、性能可控、功能灵活的图集系统。今天这篇是第五部分，我们将深入到最核心也是最复杂的环节：实现一个高效、可靠的图集打包算法，并处理随之而来的UV坐标计算与精灵信息映射。

很多开发者可能觉得，图集不就是把一堆小图拼成一张大图吗？听起来简单，但要做好却有不少门道。拼图时如何最大化利用空间，减少纹理浪费？如何处理不同尺寸、长宽比的精灵？打包后的纹理，如何让原来的精灵还能正确显示？这些问题都需要一个健壮的算法来支撑。市面上有各种打包算法，比如MaxRects, Guillotine, Shelf等，每种都有其适用场景和性能权衡。在这一篇里，我会结合自己项目中的实战经验，带你实现一个基于MaxRects算法的打包器，并详细讲解其中的优化技巧和避坑指南。

无论你是正在优化项目Draw Call的TA，还是负责UI框架的程序，亦或是想深入理解Unity资源管理机制的开发者，掌握自定义图集的核心打包逻辑，都能让你对项目的渲染效率和内存管理有更强的把控力。我们不止于实现功能，更要理解每一步背后的“为什么”，这样才能在遇到千奇百怪的需求时，能够灵活调整方案。

2. 核心算法选型：为什么是MaxRects？

在动手写代码之前，我们先要选定打包的核心算法。自定义图集的核心挑战是二维矩形装箱问题（2D Bin Packing），这是一个NP难问题，意味着没有在多项式时间内找到最优解的通用算法，我们追求的是在可接受时间内找到一个“足够好”的近似解。

2.1 常见算法对比

常见的算法主要有以下几种：

1. 简单线性排列：按宽或高排序后，一行行或一列列放置。实现简单，但空间利用率极低，仅适用于教学或特定规整资源。
2. Shelf（货架）算法：将纹理空间视为多个水平的“货架”。精灵按高度排序，放入当前货架，如果放不下则开辟新货架。比线性排列好，但对高度差异大的精灵组合不友好。
3. Guillotine（ Guillotine ）算法：每次放入一个矩形后，将剩余空间切割成两个更小的矩形（通常是向右和向下）。它维护一个“可用矩形”列表。实现相对简单，空间利用率不错，是很多开源库的选择。
4. MaxRects算法：这是目前业界在离线打包和部分运行时打包中公认效率较高的算法之一。它同样维护一个“可用矩形”列表，但在选择放置位置和插入后处理剩余空间时，策略更为激进和优化，旨在最大化空间利用率。

为了更直观地对比，我们看下面这个表格：

2.2 选择MaxRects的深层考量

我选择实现MaxRects算法，主要基于以下几点实战考量：

• 高空间利用率：对于移动平台，纹理内存非常宝贵。MaxRects通过更智能地选择放置位置和合并剩余空间，能更紧密地排列精灵，直接减少图集纹理的尺寸，有时甚至能减少一个纹理等级（如从2048x2048降到1024x1024），内存节省立竿见影。
• 策略灵活：MaxRects算法在决定“将下一个矩形放在哪里”时，有多种启发式规则（Rule）可选，例如BestShortSideFit,BestLongSideFit,BestAreaFit等。这意味着我们可以根据精灵的特点（如是否多为方形、长条形）调整策略，适应性更强。
• 行业验证：TexturePacker等知名工具的内部算法也借鉴或采用了MaxRects的变种，其有效性和可靠性经过了大量项目的检验。
• 挑战与收获：实现它确实比Guillotine复杂一点，涉及到更多的矩形相交判断和空间合并逻辑。但攻克这个过程，能让你对计算几何、空间管理有更深的理解，这笔知识投资绝对划算。

注意：MaxRects算法不是银弹。在精灵数量巨大（如超过1000）且需要实时打包的场景下，其O(n²)的最坏时间复杂度可能成为瓶颈。此时可能需要考虑分帧打包、使用更简单的算法，或者直接使用预计算的离线图集。我们的实现会包含一些优化技巧来缓解这个问题。

3. 数据结构与核心类设计

在开始狂写算法之前，良好的数据结构设计是成功的一半。我们需要几个核心类来清晰地描述“矩形”、“可用空间”和“打包结果”。

3.1 基础结构：Rect和PackedSpriteInfo

首先，我们需要一个整数版本的Rect，因为纹理坐标是像素精度的。

// 使用System.Drawing或自定义一个。这里为简化，我们自定义一个。 public struct RectInt { public int x; public int y; public int width; public int height; public RectInt(int x, int y, int width, int height) { ... } public bool Overlaps(RectInt other) { ... } public bool Contains(RectInt other) { ... } // 其他辅助方法：坐标获取、设置等 }

接下来，定义一个类来保存精灵的源信息以及打包后的结果。

public class SpritePackingRequest { // 原始精灵的唯一标识（如Guid或路径） public string Id { get; set; } // 原始精灵的纹理（或尺寸） public Texture2D SourceTexture { get; set; } // 精灵在源纹理中的矩形区域（如果是从大图集里剪裁） public RectInt SourceRect { get; set; } // 是否允许旋转90度放置以节省空间 public bool AllowRotation { get; set; } // 用户自定义的Padding值（像素） public int Padding { get; set; } } public class PackedSpriteInfo { public SpritePackingRequest Request { get; set; } // 该精灵在图集纹理中的位置和尺寸 public RectInt PackedRect { get; set; } // 是否被旋转了（相对于原始方向） public bool WasRotated { get; set; } // 计算出的UV坐标（标准化，0-1范围） public Vector4 UV { get; set; } // (xMin, yMin, xMax, yMax) }

3.2 核心引擎：MaxRectsPacker类

这个类将是算法实现的主体。它的主要职责是：接收一批SpritePackingRequest，在一个指定最大尺寸的“画布”上，尝试将它们全部放置进去，并返回打包结果和图集的实际所需尺寸。

public class MaxRectsPacker { // 最大允许的图集尺寸 private int _maxWidth; private int _maxHeight; // 全局Padding，每个精灵周围都会留出这个间距，防止纹理采样时 bleeding private int _globalPadding; // 是否允许精灵旋转 private bool _allowRotation; // 核心：当前可用的空闲矩形列表 private List<RectInt> _freeRectangles; // 已经放置好的矩形列表 private List<RectInt> _usedRectangles; // 打包结果 private List<PackedSpriteInfo> _packedSprites; private int _actualPackedWidth; private int _actualPackedHeight; public MaxRectsPacker(int maxWidth = 2048, int maxHeight = 2048, int padding = 2, bool allowRotation = true) { _maxWidth = maxWidth; _maxHeight = maxHeight; _globalPadding = padding; _allowRotation = allowRotation; // 初始化时，整个画布就是一个大的空闲矩形 _freeRectangles = new List<RectInt> { new RectInt(0, 0, maxWidth, maxHeight) }; _usedRectangles = new List<RectInt>(); _packedSprites = new List<PackedSpriteInfo>(); } public PackingResult Pack(IEnumerable<SpritePackingRequest> requests) { ... } }

PackingResult是一个简单的容器，包含打包是否成功、实际尺寸、精灵信息列表以及最终生成的纹理（这一步我们稍后处理）。

4. MaxRects算法实现详解

算法的核心流程在Pack方法中。我们一步步拆解。

4.1 预处理：排序与尺寸调整

在开始放置前，对请求进行排序能显著提高空间利用率。一个常见的策略是按面积或最长边降序排序。大块先放，小块填空隙，这是直觉，也通常更有效。

private List<SpritePackingRequest> PreprocessRequests(IEnumerable<SpritePackingRequest> requests) { var list = requests.ToList(); // 按面积降序排序。也可以尝试按Max(width, height)排序，效果不同。 list.Sort((a, b) => { int areaA = (a.SourceRect.width + _globalPadding) * (a.SourceRect.height + _globalPadding); int areaB = (b.SourceRect.width + _globalPadding) * (b.SourceRect.height + _globalPadding); return areaB.CompareTo(areaA); // 降序 }); return list; }

关键细节：Padding的处理。为了防止精灵边缘在纹理采样时出现“颜色渗出”（Bleeding），我们需要在每个精灵的四周加上Padding。在算法内部，我们处理的矩形尺寸应该是原始宽/高 + 2 * Padding。但在最终记录PackedRect时，需要记录的是精灵内容的区域（即去掉Padding的内部区域），这样在生成UV时才是正确的。

4.2 核心放置循环

对排序后的每个请求，我们尝试将其放入当前的空闲矩形列表中。

foreach (var request in sortedRequests) { int width = request.SourceRect.width + 2 * _globalPadding; int height = request.SourceRect.height + 2 * _globalPadding; // 步骤1：为当前矩形寻找最佳放置位置 RectInt bestRect; bool bestWasRotated; FindBestPosition(width, height, out bestRect, out bestWasRotated); if (bestRect.width == 0) // 没有找到合适位置 { // 处理打包失败：可以尝试扩展画布（如果允许）、或记录失败 return PackingResult.Failed; } // 步骤2：放置矩形，将其从空闲列表移除，并添加到已用列表 PlaceRect(bestRect); // 步骤3：更新空闲矩形列表。这是MaxRects算法的精髓之一。 // 遍历所有空闲矩形，检查新放置的矩形是否与它们相交或包含。 // 如果相交，将原来的空闲矩形切割成最多4个新的小矩形（上、下、左、右）。 PruneFreeList(); // 步骤4：记录打包信息 var packedInfo = new PackedSpriteInfo { Request = request, // PackedRect 记录的是内容区域，所以要去掉Padding PackedRect = new RectInt( bestRect.x + _globalPadding, bestRect.y + _globalPadding, request.SourceRect.width, request.SourceRect.height ), WasRotated = bestWasRotated }; _packedSprites.Add(packedInfo); // 步骤5：更新实际已使用的画布边界 _actualPackedWidth = Mathf.Max(_actualPackedWidth, bestRect.x + bestRect.width); _actualPackedHeight = Mathf.Max(_actualPackedHeight, bestRect.y + bestRect.height); }

4.3 FindBestPosition：启发式规则

FindBestPosition函数负责扫描当前的_freeRectangles列表，为给定尺寸的矩形选择一个“最好”的空闲矩形来放置。这个“好”的标准就是启发式规则。我们实现两种最常用的：

• BestAreaFit（最佳面积适应）：选择放置后剩余面积最小的那个空闲矩形。这倾向于找到能刚好容纳目标矩形的空间，减少空间碎片。
• BestShortSideFit（最佳短边适应）：选择放置后，短边剩余长度最小的那个。这有助于生成更方正的剩余空间，便于后续放置。

private void FindBestPosition(int width, int height, out RectInt bestRect, out bool bestWasRotated) { bestRect = new RectInt(); bestWasRotated = false; int bestScore = int.MaxValue; // 分数越低越好 foreach (var freeRect in _freeRectangles) { // 尝试不旋转放置 if (freeRect.width >= width && freeRect.height >= height) { int score = CalculateScore(freeRect, width, height, HeuristicRule.BestAreaFit); if (score < bestScore) { bestScore = score; bestRect = new RectInt(freeRect.x, freeRect.y, width, height); bestWasRotated = false; } } // 如果允许旋转，尝试旋转90度放置 if (_allowRotation && freeRect.width >= height && freeRect.height >= width) { int score = CalculateScore(freeRect, height, width, HeuristicRule.BestAreaFit); // 注意width/height交换 if (score < bestScore) { bestScore = score; bestRect = new RectInt(freeRect.x, freeRect.y, height, width); // 注意尺寸 bestWasRotated = true; } } } } private int CalculateScore(RectInt freeRect, int rectWidth, int rectHeight, HeuristicRule rule) { int leftoverWidth = freeRect.width - rectWidth; int leftoverHeight = freeRect.height - rectHeight; switch (rule) { case HeuristicRule.BestAreaFit: // 剩余面积 return leftoverWidth * leftoverHeight; case HeuristicRule.BestShortSideFit: // 剩余短边长度 return Mathf.Min(leftoverWidth, leftoverHeight); // 可以扩展其他规则... default: return int.MaxValue; } }

4.4 PruneFreeList：空间分割与合并

放置一个新矩形后，我们需要更新空闲列表。MaxRects算法的标准做法是：遍历所有现有空闲矩形，如果与新矩形相交，则将该空闲矩形切割。通常采用“最大矩形”切割法，即尝试从原空闲矩形的上、下、左、右四个方向，切出可能的最大矩形。

private void PruneFreeList() { // 临时列表存放新的空闲矩形 List<RectInt> newFreeRects = new List<RectInt>(); // 假设 latestPlacedRect 是刚刚放置的矩形（带Padding的尺寸） foreach (var freeRect in _freeRectangles) { if (!freeRect.Overlaps(latestPlacedRect)) { // 不相交，保留 newFreeRects.Add(freeRect); continue; } // 相交，进行切割 // 尝试从上方切割 if (latestPlacedRect.y > freeRect.y) { newFreeRects.Add(new RectInt( freeRect.x, freeRect.y, freeRect.width, latestPlacedRect.y - freeRect.y )); } // 尝试从下方切割 if (latestPlacedRect.y + latestPlacedRect.height < freeRect.y + freeRect.height) { newFreeRects.Add(new RectInt( freeRect.x, latestPlacedRect.y + latestPlacedRect.height, freeRect.width, (freeRect.y + freeRect.height) - (latestPlacedRect.y + latestPlacedRect.height) )); } // 尝试从左方切割（注意，左右切割的区域需要扣除上下已切割的部分的Y范围） if (latestPlacedRect.x > freeRect.x) { newFreeRects.Add(new RectInt( freeRect.x, freeRect.y, latestPlacedRect.x - freeRect.x, freeRect.height )); } // 尝试从右方切割 if (latestPlacedRect.x + latestPlacedRect.width < freeRect.x + freeRect.width) { newFreeRects.Add(new RectInt( latestPlacedRect.x + latestPlacedRect.width, freeRect.y, (freeRect.x + freeRect.width) - (latestPlacedRect.x + latestPlacedRect.width), freeRect.height )); } } // 替换旧列表 _freeRectangles = newFreeRects; // **关键优化步骤：合并空闲矩形** // 经过多次切割后，会产生大量小的、相邻的空闲矩形，需要合并以简化列表，提升后续查找效率。 MergeFreeRectangles(); }

MergeFreeRectangles函数是一个优化点，它遍历空闲矩形列表，尝试将可以合并成更大矩形的相邻矩形合并。这能防止空闲列表无限膨胀，显著提升算法在放置后期（当空间碎片多时）的性能。实现逻辑是检查任意两个矩形，如果一个矩形能完全包含另一个，则移除小的；如果两个矩形在水平或垂直方向上相邻且宽度或高度相同，则合并为一个更大的矩形。

5. UV计算与纹理生成

当所有精灵都成功放置后，我们得到了每个精灵在图集上的像素坐标PackedRect。接下来需要将其转换为UV坐标（0到1的范围），并最终生成一张纹理。

5.1 计算标准化UV坐标

UV计算非常简单，但要注意纹理坐标系的差异。在Unity和大多数图形API中，纹理的原点(0,0)通常在左下角。

private void CalculateUVs(int atlasWidth, int atlasHeight) { foreach (var info in _packedSprites) { RectInt rect = info.PackedRect; // 转换为左下角原点坐标系 float xMin = (float)rect.x / atlasWidth; float yMin = (float)rect.y / atlasHeight; float xMax = (float)(rect.x + rect.width) / atlasWidth; float yMax = (float)(rect.y + rect.height) / atlasHeight; info.UV = new Vector4(xMin, yMin, xMax, yMax); // 如果精灵被旋转了，UV需要对应调整。 // 旋转90度意味着纹理坐标需要绕中心旋转。 // 一种常见做法是记录旋转信息，在采样时通过Shader或顶点数据调整。 // 这里我们简单记录，在生成Sprite或Material时处理。 if (info.WasRotated) { // 例如，可以交换UV的x和y分量，或者存储一个旋转矩阵 // 为了简单，我们只记录标志，实际应用时再做变换。 } } }

5.2 生成最终的Texture2D

有了所有精灵的放置信息和UV，我们就可以将它们的像素数据“画”到一张新的大纹理上了。

public Texture2D CreateAtlasTexture(int width, int height, TextureFormat format = TextureFormat.RGBA32, bool mipmap = false) { // 创建一个新的可读写纹理 Texture2D atlasTexture = new Texture2D(width, height, format, mipmap); // 初始化为透明黑色或特定背景色 Color[] clearPixels = new Color[width * height]; for (int i = 0; i < clearPixels.Length; i++) clearPixels[i] = Color.clear; atlasTexture.SetPixels(clearPixels); foreach (var info in _packedSprites) { var request = info.Request; RectInt sourceRect = request.SourceRect; RectInt destRect = info.PackedRect; // 获取源精灵的像素数据 // 注意：SourceTexture可能是原始小图，也可能是另一个图集的一部分 Color[] sourcePixels = request.SourceTexture.GetPixels(sourceRect.x, sourceRect.y, sourceRect.width, sourceRect.height); // 如果需要旋转，在这里处理像素数据 if (info.WasRotated) { sourcePixels = RotatePixels90Clockwise(sourcePixels, sourceRect.width, sourceRect.height); // 旋转后，宽高交换 int temp = destRect.width; destRect.width = destRect.height; destRect.height = temp; // 注意：destRect的x,y可能也需要根据旋转中心调整，这里简化处理 // 更严谨的做法是在FindBestPosition时，就计算出旋转后的正确放置位置。 } // 将像素数据设置到图集纹理的对应位置 atlasTexture.SetPixels(destRect.x, destRect.y, destRect.width, destRect.height, sourcePixels); } atlasTexture.Apply(false); // 不生成mipmaps，如果前面创建时没要求的话 return atlasTexture; } private Color[] RotatePixels90Clockwise(Color[] original, int origWidth, int origHeight) { Color[] rotated = new Color[original.Length]; for (int y = 0; y < origHeight; y++) { for (int x = 0; x < origWidth; x++) { int origIndex = y * origWidth + x; // 顺时针旋转90度后，原图的(x,y)点对应新图的(y, origWidth-1-x) int newY = x; int newX = origHeight - 1 - y; int newIndex = newY * origHeight + newX; // 注意旋转后新图的宽度是origHeight rotated[newIndex] = original[origIndex]; } } return rotated; }

重要提示：Texture2D.GetPixels和SetPixels是CPU端操作，对于大纹理或大量精灵，这会非常耗时。在运行时动态生成图集时，需要谨慎使用，考虑分帧操作或使用Graphics.CopyTexture（如果纹理格式支持）等GPU端方法进行加速。我们的自定义图集系统更常用于离线工具链的预处理阶段，此时性能要求相对宽松。

6. 性能优化与高级特性

一个基础的MaxRects打包器已经完成了。但要投入生产环境，我们还需要考虑更多。

6.1 性能优化点

1. 空间矩形列表的优化数据结构：当空闲矩形数量很多时，线性列表的查找和遍历会成为瓶颈。可以考虑使用空间划分数据结构，如四叉树（Quadtree）或R树来管理空闲矩形，将查找复杂度从O(n)降低到O(log n)。但对于几百个精灵的打包，优化后的线性列表通常也够用。
2. 批量合并操作：在PruneFreeList中，合并矩形是一个O(n²)的操作。可以优化合并算法，例如先按位置排序，然后只检查相邻的矩形，能降低一些复杂度。
3. 提前拒绝：在FindBestPosition时，如果空闲矩形的面积小于当前待放置矩形的面积，可以直接跳过，无需计算分数。
4. 多线程打包：如果精灵之间没有依赖关系，且打包算法是无状态的（需要仔细设计），可以考虑将排序后的精灵列表分块，用多个线程并行寻找放置位置。但线程间同步最终的空闲列表会变得复杂，需要权衡。

6.2 支持高级特性

1. Alpha通道边缘扩张（Padding填充）：我们之前加的Padding是空的。但为了消除Bleeding，更好的做法是将精灵边缘的像素向外“扩张”到Padding区域。这需要在CreateAtlasTexture的SetPixels步骤中，不仅复制原像素，还要用边缘像素填充周围的Padding区域。这能有效解决纹理过滤时出现的黑边或透明边问题。
2. 多图集支持（Bin Packing）：当所有精灵无法放入一张最大尺寸的纹理时，我们需要自动创建多个图集。这需要在主循环中加入判断：如果当前图集放不下某个精灵，就完成当前图集的创建，用剩余精灵列表初始化一个新的MaxRectsPacker实例，开始打包下一个图集。
3. 自定义摆放策略：除了算法规则，有时我们还需要满足一些业务逻辑。例如，将所有“血条”相关的精灵尽量放在同一个图集页，或者将频繁同时使用的精灵放在相邻位置以提高缓存命中率。这需要在排序阶段或评分函数中引入权重因子。

7. 实战：集成到Unity编辑器与运行时

7.1 创建编辑器工具

我们可以创建一个EditorWindow，让美术或策划能够方便地选择一堆精灵或纹理，配置好参数（最大尺寸、Padding、是否旋转等），然后一键生成自定义图集和对应的Sprite Sheet数据（一个记录每个精灵ID和UV的JSON或ScriptableObject）。

// 示例性的编辑器工具方法 [MenuItem("Tools/Atlas/Custom Atlas Packer")] public static void OpenCustomAtlasPackerWindow() { var window = GetWindow<CustomAtlasPackerWindow>(); window.titleContent = new GUIContent("Atlas Packer"); window.Show(); } // 在CustomAtlasPackerWindow中，提供UI选择文件夹、配置参数，然后调用我们的MaxRectsPacker void OnGUI() { // ... UI代码 ... if (GUILayout.Button("Pack Selected Sprites")) { var requests = PreparePackingRequests(); var packer = new MaxRectsPacker(_maxSize, _maxSize, _padding, _allowRotation); var result = packer.Pack(requests); if (result.Success) { var texture = result.CreateAtlasTexture(); byte[] pngData = texture.EncodeToPNG(); System.IO.File.WriteAllBytes(Application.dataPath + "/AtlasOutput.png", pngData); AssetDatabase.Refresh(); // 保存UV和精灵信息到ScriptableObject SaveAtlasMetaInfo(result); } else { EditorUtility.DisplayDialog("Packing Failed", "Not all sprites could be packed. Try increasing max size or enabling rotation.", "OK"); } } }

7.2 运行时动态图集

对于运行时动态加载的UI元素（如网络下载的图标），我们可以使用同样的MaxRectsPacker类在内存中管理一个“动态图集”。当需要添加一个新精灵时，调用Pack方法尝试放入现有图集纹理的空闲区域。如果放不下，可以扩展纹理（创建更大的纹理并拷贝旧数据）或者开辟新的动态图集页。同时，需要配套一个管理器来负责纹理的引用计数和释放。

运行时注意事项：

• 纹理读写：运行时动态修改纹理需要设置texture.isReadable = true或使用RenderTexture中转，有性能开销。
• 内存碎片：频繁的增删操作会导致图集纹理中出现很多“空洞”，需要实现碎片整理算法，或者定期重建图集。
• Draw Call：动态图集中的精灵如果和静态图集一起使用，可能会因为纹理不同而打断合批。需要合理规划渲染顺序和材质属性块。

8. 常见问题与排查技巧实录

在实际实现和使用自定义图集系统的过程中，我踩过不少坑。这里总结几个典型问题和解决方法。

一个关键的调试技巧：在开发打包算法时，强烈建议实现一个可视化调试工具。将每一步的空闲矩形（用线框表示）、已用矩形（用色块表示）绘制出来，保存为图片或直接在Editor中显示。这能让你直观地看到算法的决策过程，快速定位是寻找位置、切割空间还是合并矩形的逻辑出了问题。我当初就是靠画了上百张调试图，才彻底理清了MaxRects的切割合并逻辑。

实现一个完整的自定义图集系统是一项系统工程，从算法选型、实现、优化，到编辑器集成和运行时管理，每一步都需要仔细权衡。本文详细剖析了核心的MaxRects打包算法，并提供了从理论到实践的完整路径。希望这份深度解析能帮助你构建出更高效、更贴合项目需求的图集解决方案。记住，没有最好的算法，只有最适合当前场景的选择。理解原理，灵活应用，才是应对各种项目挑战的不二法门。