1. 项目概述：为什么从Mesh开始构建几何体？

在Unity开发中，我们每天都在和模型打交道，无论是从3DMax、Blender导入的复杂角色，还是Asset Store里下载的精致场景。但你是否想过，这些五彩斑斓、形态各异的物体，在引擎底层究竟是如何被“画”出来的？答案就是Mesh（网格）。Mesh是构成所有3D可视物体的骨架，它定义了物体的形状。我们通常使用的.fbx或.obj文件，本质上就是携带了顶点、三角形等信息的Mesh数据包。

那么，为什么我们要“自讨苦吃”，不用现成模型，反而要从代码层面去构建一个基础的三角形甚至立方体呢？这绝不是为了炫技。在我经手的多个性能敏感项目，比如大规模动态地形生成、程序化建筑构建或是特效粒子系统中，动态创建和修改Mesh是家常便饭。当你需要实时生成一片随风摇曳的草地、一道破碎飞溅的墙体，或者一个根据数据流变化的可视化图表时，等待美术出模型是不现实的，必须由程序在运行时“无中生有”。理解Mesh的构建原理，就是掌握了在Unity世界中“创世”的基本功。它能让你彻底摆脱对预制模型的依赖，实现真正的动态内容和极致的性能控制。无论是想优化Draw Call，还是实现那些现成资产库中找不到的特殊效果，Mesh编程都是你必须跨越的一道坎。

2. 核心原理：Mesh数据的“五脏六腑”

在动手写代码之前，我们必须像外科医生熟悉人体解剖一样，搞清楚一个Mesh到底由哪些核心数据构成。一个完整的Mesh，主要包含以下三部分，它们共同决定了物体的形状、外观和如何被渲染。

2.1 顶点（Vertices）：空间的坐标点

顶点是Mesh最基本的元素，你可以把它想象成构成一个多面体模型的每一个“角点”。在3D空间中，每个顶点由一个Vector3（三维向量）来表示，包含了(x, y, z)坐标。这些坐标定义在物体的本地空间（Local Space）。例如，一个中心在原点的立方体，它的8个顶点坐标可能就是(±0.5, ±0.5, ±0.5)的各种组合。

顶点数据存储在Mesh.vertices数组中。这里有一个至关重要的细节：顶点的顺序本身不决定模型的形状，它只是提供了一个坐标点的列表。这些点如何连接成面，由下一个要素决定。

2.2 三角形（Triangles）：连接顶点的索引

这是最核心也最容易出错的部分。3D图形渲染的基石是三角形，所有多边形（包括四边形）最终都会被分解为三角形进行渲染。Mesh.triangles数组定义的就是这些三角形。

这个数组存储的不是Vector3，而是整数索引。这些索引指向Mesh.vertices数组中的位置。关键点在于，三角形的顶点顺序决定了面的朝向。在Unity中，默认使用逆时针（Counter-Clockwise）顺序来定义三角形的正面（即摄像机可以看到的一面）。例如，如果你定义了三个顶点索引[0, 1, 2]，那么从摄像机看去，如果顶点0->1->2是逆时针排列的，这个面就是正面，会被渲染；反之则是背面，在不开双面渲染的情况下会被剔除。

例如，要画一个矩形，我们需要两个三角形（0,1,2和0,2,3）。假设顶点数组vertices为[A, B, C, D]（按顺序对应矩形的四个角），那么三角形数组triangles应该是[0, 1, 2, 0, 2, 3]。注意这里0,2,3这个三角形，顶点顺序0->2->3在视图上是逆时针，才是正面。

2.3 法线（Normals）：光照计算的依据

法线是一个垂直于模型表面的单位向量（Vector3）。它的主要作用是计算光照。光照模型（如Lambert, Phong）需要根据表面法线与光线方向的夹角来计算该点接收到多少光。

法线数据存储在Mesh.normals数组中，它必须与Mesh.vertices数组一一对应，即第i个顶点的法线是normals[i]。对于像立方体这样有棱角的模型，一个顶点（如立方体的角）实际上被三个相邻的面共享，但每个面的朝向不同。如果简单地给这个顶点分配一个法线，棱角处看起来就会是圆滑的。为了保持硬朗的棱角，我们需要在顶点数据中复制顶点。也就是说，立方体的一个角在数据上会变成三个位置相同但法线不同的顶点，分别属于相邻的三个面。这就是为什么一个立方体需要24个顶点（6个面 * 每个面4个顶点），而不是8个。

除了以上三个核心属性，一个功能完整的Mesh通常还包括：

• UV坐标（Mesh.uv）：定义顶点在纹理贴图上的2D坐标，用于贴图采样。
• 顶点颜色（Mesh.colors）：为每个顶点定义颜色，可用于简单的着色或渐变效果。
• 切线（Mesh.tangents）：用于法线贴图（Normal Mapping）计算，是一个Vector4类型。

注意：在修改或赋值Mesh数据时，有一个性能最佳实践：尽量避免逐帧修改Mesh.vertices等属性。更好的做法是先在内存中准备好数据数组（如Vector3[] verts），然后一次性赋值给mesh.vertices = verts。频繁的get/set操作会产生大量托管堆内存分配，引发GC（垃圾回收），导致卡顿。

3. 实战构建：从三角形到立方体

理论说得再多，不如一行代码。让我们从一个最简单的三角形开始，逐步构建一个具有正确光照的立方体。我会在代码中穿插大量注释，解释每一个步骤的意图和易错点。

3.1 第一步：绘制一个单面三角形

我们首先创建一个空的GameObject，并为其添加MeshFilter和MeshRenderer组件。MeshFilter用于持有Mesh数据，MeshRenderer负责将其渲染出来。然后，我们附上下面的脚本。

using UnityEngine; [RequireComponent(typeof(MeshFilter), typeof(MeshRenderer))] public class CreateTriangle : MonoBehaviour { void Start() { // 1. 获取或创建MeshFilter组件 MeshFilter meshFilter = GetComponent<MeshFilter>(); Mesh mesh = new Mesh(); mesh.name = "My Triangle"; // 给Mesh起个名，调试时方便 // 2. 定义三个顶点的本地坐标 Vector3[] vertices = new Vector3[3]; vertices[0] = new Vector3(0, 0, 0); // 顶点A vertices[1] = new Vector3(1, 0, 0); // 顶点B vertices[2] = new Vector3(0, 1, 0); // 顶点C mesh.vertices = vertices; // 3. 定义三角形（索引数组） // 顺序至关重要：0->1->2 在XY平面逆时针，所以从Z轴正方向看是正面 int[] triangles = new int[3]; triangles[0] = 0; triangles[1] = 1; triangles[2] = 2; mesh.triangles = triangles; // 4. 计算法线 // 对于单个平面三角形，我们可以手动计算。 // 法线 = (向量AB) 叉乘 (向量AC) 后的单位向量。 Vector3 vecAB = vertices[1] - vertices[0]; Vector3 vecAC = vertices[2] - vertices[0]; Vector3 normal = Vector3.Cross(vecAB, vecAC).normalized; // 叉乘得到垂直向量并归一化 Vector3[] normals = new Vector3[3]; // 三个顶点共享同一个法线，因为它们在同一个平面上 normals[0] = normal; normals[1] = normal; normals[2] = normal; mesh.normals = normals; // 5. 分配UV坐标（简单投影，否则默认材质可能是粉红色） Vector2[] uvs = new Vector2[3]; uvs[0] = new Vector2(0, 0); uvs[1] = new Vector2(1, 0); uvs[2] = new Vector2(0, 1); mesh.uv = uvs; // 6. 将构建好的Mesh赋值给MeshFilter meshFilter.mesh = mesh; // 7. （可选）为MeshRenderer分配一个默认材质 // GetComponent<MeshRenderer>().material = new Material(Shader.Find("Standard")); } }

运行后，你应该能看到一个白色的三角形。重要检查点：如果你看不到，或者看到的是粉红色（Missing Material），请确保场景中有光源，并且MeshRenderer上已被分配了材质（Unity默认会使用一个“Default-Material”）。粉红色通常意味着着色器编译错误或材质丢失。

3.2 第二步：构建一个四边形（两个三角形）

四边形是更常见的基元。我们通过组合两个三角形来实现。

void CreateQuad() { MeshFilter meshFilter = GetComponent<MeshFilter>(); Mesh mesh = new Mesh(); mesh.name = "My Quad"; // 定义四个顶点（顺时针或逆时针顺序均可，但需保持一致） Vector3[] vertices = new Vector3[4]; vertices[0] = new Vector3(0, 0, 0); // 左下 vertices[1] = new Vector3(1, 0, 0); // 右下 vertices[2] = new Vector3(0, 1, 0); // 左上 vertices[3] = new Vector3(1, 1, 0); // 右上 mesh.vertices = vertices; // 定义两个三角形，共6个索引 // 三角形1：左下->右下->右上 (0,1,3) 注意顺序要保证逆时针 // 三角形2：左下->右上->左上 (0,3,2) int[] triangles = new int[6] { 0, 1, 3, 0, 3, 2 }; mesh.triangles = triangles; // 计算法线（所有顶点法线相同，因为四边形是平面） Vector3 normal = Vector3.Cross(vertices[1] - vertices[0], vertices[3] - vertices[0]).normalized; Vector3[] normals = new Vector3[4]; for (int i = 0; i < normals.Length; i++) normals[i] = normal; mesh.normals = normals; // 分配UV：让贴图完整覆盖四边形 Vector2[] uvs = new Vector2[4]; uvs[0] = new Vector2(0, 0); uvs[1] = new Vector2(1, 0); uvs[2] = new Vector2(0, 1); uvs[3] = new Vector2(1, 1); mesh.uv = uvs; meshFilter.mesh = mesh; }

这里的关键是三角形索引的顺序。我们画了两个三角形(0,1,3)和(0,3,2)。你可以试着在纸上画一下这四个点和这两个三角形的连接方式，确保你理解它们是如何拼成一个矩形的。错误的索引顺序会导致三角形撕裂或面朝向错误。

3.3 第三步：构建一个具有硬边的立方体

立方体是理解顶点复制和法线计算的绝佳例子。一个视觉上有棱有角的立方体，需要24个顶点（6个面 * 每个面4个顶点），而不是8个。

void CreateCube() { MeshFilter meshFilter = GetComponent<MeshFilter>(); Mesh mesh = new Mesh(); mesh.name = "Procedural Cube"; // 1. 定义24个顶点（每个面4个，独立） Vector3[] vertices = new Vector3[24]; // 前脸 (Z = 0.5) vertices[0] = new Vector3(-0.5f, -0.5f, 0.5f); vertices[1] = new Vector3(0.5f, -0.5f, 0.5f); vertices[2] = new Vector3(-0.5f, 0.5f, 0.5f); vertices[3] = new Vector3(0.5f, 0.5f, 0.5f); // 右脸 (X = 0.5) vertices[4] = new Vector3(0.5f, -0.5f, 0.5f); vertices[5] = new Vector3(0.5f, -0.5f, -0.5f); vertices[6] = new Vector3(0.5f, 0.5f, 0.5f); vertices[7] = new Vector3(0.5f, 0.5f, -0.5f); // 后脸 (Z = -0.5) 注意顶点顺序，为了保持面朝外（逆时针），顺序会变化 vertices[8] = new Vector3(0.5f, -0.5f, -0.5f); vertices[9] = new Vector3(-0.5f, -0.5f, -0.5f); vertices[10] = new Vector3(0.5f, 0.5f, -0.5f); vertices[11] = new Vector3(-0.5f, 0.5f, -0.5f); // 左脸 (X = -0.5) vertices[12] = new Vector3(-0.5f, -0.5f, -0.5f); vertices[13] = new Vector3(-0.5f, -0.5f, 0.5f); vertices[14] = new Vector3(-0.5f, 0.5f, -0.5f); vertices[15] = new Vector3(-0.5f, 0.5f, 0.5f); // 上脸 (Y = 0.5) vertices[16] = new Vector3(-0.5f, 0.5f, 0.5f); vertices[17] = new Vector3(0.5f, 0.5f, 0.5f); vertices[18] = new Vector3(-0.5f, 0.5f, -0.5f); vertices[19] = new Vector3(0.5f, 0.5f, -0.5f); // 下脸 (Y = -0.5) vertices[20] = new Vector3(-0.5f, -0.5f, -0.5f); vertices[21] = new Vector3(0.5f, -0.5f, -0.5f); vertices[22] = new Vector3(-0.5f, -0.5f, 0.5f); vertices[23] = new Vector3(0.5f, -0.5f, 0.5f); mesh.vertices = vertices; // 2. 定义三角形（6个面 * 2个三角形 * 3个索引 = 36个索引） int[] triangles = new int[36]; // 每个面的三角形索引（注意逆时针顺序） // 前，右，后，左，上，下 int[] faceTriangles = new int[] { 0, 2, 1, 2, 3, 1, // 前 4, 6, 5, 6, 7, 5, // 右 8, 10, 9, 10, 11, 9, // 后 12, 14, 13, 14, 15, 13, // 左 16, 18, 17, 18, 19, 17, // 上 20, 22, 21, 22, 23, 21 // 下 }; triangles = faceTriangles; mesh.triangles = triangles; // 3. 定义法线（每个顶点对应其所在面的朝向） Vector3[] normals = new Vector3[24]; // 前脸法线 (0,0,1) for (int i = 0; i < 4; i++) normals[i] = Vector3.forward; // 右脸法线 (1,0,0) for (int i = 4; i < 8; i++) normals[i] = Vector3.right; // 后脸法线 (0,0,-1) for (int i = 8; i < 12; i++) normals[i] = Vector3.back; // 左脸法线 (-1,0,0) for (int i = 12; i < 16; i++) normals[i] = Vector3.left; // 上脸法线 (0,1,0) for (int i = 16; i < 20; i++) normals[i] = Vector3.up; // 下脸法线 (0,-1,0) for (int i = 20; i < 24; i++) normals[i] = Vector3.down; mesh.normals = normals; // 4. 定义UV（每个面都进行完整贴图映射） Vector2[] uvs = new Vector2[24]; Vector2 uv00 = new Vector2(0, 0); Vector2 uv10 = new Vector2(1, 0); Vector2 uv01 = new Vector2(0, 1); Vector2 uv11 = new Vector2(1, 1); // 每个面的4个顶点使用相同的UV模式 for (int i = 0; i < 24; i += 4) { uvs[i] = uv00; uvs[i + 1] = uv10; uvs[i + 2] = uv01; uvs[i + 3] = uv11; } mesh.uv = uvs; // 5. 可选：重新计算包围盒，确保裁剪和碰撞检测正确 mesh.RecalculateBounds(); meshFilter.mesh = mesh; }

运行这段代码，你将得到一个标准的立方体，在方向光照射下，每个面都有清晰的光影分界，这就是“硬边”效果。如果我们将24个顶点合并为8个，并计算平均法线，就会得到一个边缘平滑的“球状”立方体。

实操心得：手动编写立方体的顶点和索引数据非常繁琐且容易出错。在实际项目中，对于这类标准几何体，我通常会先编写一个生成函数，然后用Gizmos或简单的调试绘制在OnDrawGizmos中可视化顶点和三角形的连接，确保数据正确。一旦这个基础生成器写好了，就可以作为构建更复杂形状（如圆柱、球体）的模板。

4. 性能优化与高级应用

掌握了基础构建，我们就可以聊聊更实际的问题：性能。动态Mesh生成如果使用不当，会是性能杀手。

4.1 重用与合并：减少Draw Call的利器

Unity渲染每一个使用了不同材质或不同Mesh的物体，基本上都会产生一个Draw Call。Draw Call过多是性能瓶颈的主因之一。

• Mesh合并（CombineMeshes）：如果你有大量小的、静态的、使用相同材质的程序化网格（比如一片森林中的草叶），可以使用Mesh.CombineMeshes方法将它们合并成一个大的Mesh。这能将成百上千个Draw Call减少到1个。但要注意，合并后它们将成为一个整体，无法再单独进行变换（移动、旋转）或剔除。

  void CombineExample() { MeshFilter[] meshFilters = GetComponentsInChildren<MeshFilter>(); CombineInstance[] combine = new CombineInstance[meshFilters.Length]; for (int i = 0; i < meshFilters.Length; i++) { combine[i].mesh = meshFilters[i].sharedMesh; combine[i].transform = meshFilters[i].transform.localToWorldMatrix; // 注意转换矩阵 } Mesh combinedMesh = new Mesh(); combinedMesh.CombineMeshes(combine); // 默认是合并子网格，第二个参数为true会合并为一个子网格 GetComponent<MeshFilter>().mesh = combinedMesh; // 之后可以禁用所有子物体的Renderer }

• 重用Mesh对象：避免在Update中每帧new Mesh()。应该在Start或Awake中创建好Mesh对象，然后在需要更新时，只更新其顶点数组等数据，并调用mesh.MarkDynamic()提示Unity该Mesh会频繁更改，以便引擎进行优化。

4.2 使用Mesh类的高效API

• mesh.SetVertices(List<Vector3>)/mesh.SetTriangles(List<int>, submeshIndex)：这些使用List的API比直接赋值数组在内部处理上有时更高效，尤其是当数据来自List时。
• mesh.GetVertices(List<Vector3>)：同样，使用List来获取顶点数据可以避免分配新的数组。
• mesh.Clear()：在重新填充一个Mesh之前，先调用Clear()是个好习惯，可以清除所有属性和子网格。
• 子网格（Submesh）：一个Mesh可以包含多个子网格，每个子网格对应mesh.triangles的一个索引区间，并可以关联不同的材质。这在绘制一个由多种材质组成的复杂物体（如一个角色，皮肤和衣服材质不同）时非常有用，但需要小心管理。

4.3 程序化生成复杂形状：以球体为例

构建球体是更高级的练习，它涉及到球面坐标到直角坐标的转换。思路是：在经度（φ）和纬度（θ）上进行采样，生成顶点，然后连接成四边形（再分解为三角形）。

void CreateSphere(float radius, int segments, int rings) { Mesh mesh = new Mesh(); List<Vector3> vertices = new List<Vector3>(); List<int> triangles = new List<int>(); List<Vector3> normals = new List<Vector3>(); // 生成顶点 for (int ring = 0; ring <= rings; ring++) { float v = (float)ring / rings; // 纬度比例 [0,1] float theta = Mathf.PI * v; // 纬度角 [0, π] for (int seg = 0; seg <= segments; seg++) { float u = (float)seg / segments; // 经度比例 [0,1] float phi = 2 * Mathf.PI * u; // 经度角 [0, 2π] float x = Mathf.Sin(theta) * Mathf.Cos(phi); float y = Mathf.Cos(theta); float z = Mathf.Sin(theta) * Mathf.Sin(phi); Vector3 pos = new Vector3(x, y, z) * radius; vertices.Add(pos); normals.Add(pos.normalized); // 球体顶点法线就是从球心指向顶点的方向 } } // 生成三角形索引（四边形带） for (int ring = 0; ring < rings; ring++) { for (int seg = 0; seg < segments; seg++) { int current = ring * (segments + 1) + seg; int next = current + (segments + 1); // 第一个三角形 triangles.Add(current); triangles.Add(next); triangles.Add(current + 1); // 第二个三角形 triangles.Add(current + 1); triangles.Add(next); triangles.Add(next + 1); } } mesh.SetVertices(vertices); mesh.SetTriangles(triangles, 0); mesh.SetNormals(normals); // 计算UV（这里使用球形映射，可能不是最优） // ... UV计算代码略 mesh.RecalculateBounds(); GetComponent<MeshFilter>().mesh = mesh; }

这个球体生成器展示了如何通过算法生成顶点和连接关系。segments和rings参数控制细分程度，值越高球体越光滑，但顶点和三角形数量也呈平方增长，需要权衡。

5. 常见问题与调试技巧实录

即使理解了原理，在实际操作中依然会遇到各种诡异的问题。下面是我踩过的一些坑和解决方法。

5.1 问题排查清单

5.2 调试“三板斧”

1. Gizmos可视化：在OnDrawGizmos或OnDrawGizmosSelected方法中绘制顶点和线框，这是最直接的调试手段。

   void OnDrawGizmosSelected() { if (mesh == null) return; Gizmos.color = Color.red; // 绘制顶点 foreach (var vert in mesh.vertices) { Gizmos.DrawSphere(transform.TransformPoint(vert), 0.02f); } // 绘制三角形边（简化版，实际需遍历triangles） Gizmos.color = Color.green; var verts = mesh.vertices; var tris = mesh.triangles; for (int i = 0; i < tris.Length; i += 3) { Vector3 a = transform.TransformPoint(verts[tris[i]]); Vector3 b = transform.TransformPoint(verts[tris[i + 1]]); Vector3 c = transform.TransformPoint(verts[tris[i + 2]]); Gizmos.DrawLine(a, b); Gizmos.DrawLine(b, c); Gizmos.DrawLine(c, a); } }

2. 使用简单Shader：在调试阶段，使用Unlit/Color或Unlit/Texture这类不受光照影响的Shader，可以排除法线和光照计算带来的干扰，专注于Mesh形状本身。
3. 分步构建：不要试图一次性写出生成复杂Mesh的完美代码。先从生成顶点数组并可视化开始，确认顶点位置正确；然后添加三角形索引，一次只构建一个面，确认无误后再扩展；最后再算法线和UV。步步为营，能极大降低调试难度。

5.3 关于法线计算的补充

对于简单平面或规则体，我们可以手动指定法线。但对于任意形状的Mesh，或者Mesh顶点被动态修改后（如顶点动画），我们需要重新计算法线。Unity提供了mesh.RecalculateNormals()方法，它会根据相邻面的平均法线为每个顶点计算一个平滑的法线。这对于想要平滑着色的模型非常方便，一键完成。但如果你需要硬边，就必须像我们构建立方体那样，手动管理顶点复制和法线赋值。

最后，一个经常被忽略但很重要的步骤是，在修改完Mesh的所有属性后，调用mesh.UploadMeshData(true)。这个true参数表示标记Mesh数据不再会被CPU修改，允许Unity将数据上传到GPU并进行更激进的优化。对于静态或更新不频繁的Mesh，调用这个能提升渲染性能。