【基础】Unity Mesh(一) 初步使用Mesh画平面图形

转自：http://blog.csdn.net/nanggong/article/details/54311090

最近发现Mesh很牛的样子，虽然以前也见过人家大牛用这个写过工具，当时没大在意，现在开始接触，觉得挺好玩的，首先先上我画的几个图：

据说还可以画各种形状，原理就是所有图形都是由三角形组成的。

下面我们一一的解释下：

一.画三角形

首先，给组件添加MeshFilter和MeshRenderer两个组件，这两个组件是Mesh必须的，然后我们自己新建一个材质备用，用来给Mesh赋值使用，Mesh画出来图案的材质就是你你新建的材质。

重要的两步：

第一步：指定定点，比如我们画三角形，我们指定三个定点

第二部：指定三角形顺序，注意个triangles的数组的大小必须是3的倍数，然后三角形的点顺序必须是顺时针的，当然你逆时针只能在反面看到。

下面我们看下脚本：

[csharp] view plain copy print ?

1. void DrawTriangle()  
2.     {  
3.         gameObject.AddComponent<MeshFilter>();  
4.         gameObject.AddComponent<MeshRenderer>();  
5.         gameObject.GetComponent<MeshRenderer>().material = mat;  
6.   
7.         Mesh mesh = GetComponent<MeshFilter>().mesh;  
8.         mesh.Clear();  
9.   
10.         //设置顶点  
11.         mesh.vertices = new Vector3[] { new Vector3(0, 0, 0), new Vector3(0, 1, 0), new Vector3(1, 1, 0) };  
12.         //设置三角形顶点顺序，顺时针设置  
13.         mesh.triangles = new int[] { 0, 1, 2 };  
14.     }  

最终图片如图所示：

三角形还是比较简单的，Unity官网API介绍就有这个实例，这里面我们暂时先不考虑UV.

二.画正方形

有了三角形，我们画正方形也会简单很多，我们分析一下正方形是由两个三角形组成的，我们画两个三角形就可以了，在上面的基础上我们再加一个点（1,0）就可以了，

代码如下：

[csharp] view plain copy print ?

1. #region 画正方形  
2.     void DrawSquare()  
3.     {  
4.         gameObject.AddComponent<MeshFilter>();  
5.         gameObject.AddComponent<MeshRenderer>();  
6.         gameObject.GetComponent<MeshRenderer>().material = mat;  
7.   
8.         Mesh mesh = GetComponent<MeshFilter>().mesh;  
9.         mesh.Clear();  
10.   
11.         mesh.vertices = new Vector3[] { new Vector3(0, 0, 0), new Vector3(0, 1, 0), new Vector3(1, 1, 0), new Vector3(1, 0, 0) };  
12.         mesh.triangles = new int[]  
13.         { 0, 1, 2,  
14.           0, 2, 3  
15.         };  
16.     }  
17.     #endregion  

图形如图：

正方形能画，那什么梯形，平行四边形，菱形啥的肯定也不在话下，这里我就不写demo了。

三.画圆

一开始画圆还没啥头绪，后来想想，圆其实也是有很多个三角形组成的，类似这样：

鄙人画画比较丑，将就着看吧，类似这样可以细分成很多个小三角形，然后定点坐标就是各点组成：

顶点的集合有黄色的点组成，除了圆心，其它的点的坐标都是根据角度确定的，这个我们上学时几何学过，我就不细说了。

这样我们的画圆的函数需要参数有：半径，圆心坐标，分割的份数

顶点的代码如下：

[csharp] view plain copy print ?

1. //顶点  
2.         Vector3[] vertices = new Vector3[segments + 1];  
3.         vertices[0] = centerCircle;  
4.         float deltaAngle = Mathf.Deg2Rad * 360f / segments;  
5.         float currentAngle = 0;  
6.         for (int i = 1; i < vertices.Length; i++)  
7.         {  
8.             float cosA = Mathf.Cos(currentAngle);  
9.             float sinA = Mathf.Sin(currentAngle);  
10.             vertices[i] = new Vector3(cosA * radius + centerCircle.x, sinA * radius + centerCircle.y, 0);  
11.             currentAngle += deltaAngle;  
12.         }  

Deg2Rad相当于2PI

后面就是顶点的顺序了，注意，最后一个三角形的定点涉及到初始的点：

比如我们图中 的：

如图中所示，最后一组的时候如果使用遍历，数组会越界，所以我们可以最后三个单独写，也可以采用取模。

这里我们的代码采用单独写的方式，代码如下：

[csharp] view plain copy print ?

1. //三角形  
2.         int[] triangles = new int[segments * 3];  
3.         for (int i = 0, j = 1; i < segments * 3 - 3; i += 3, j++)  
4.         {  
5.             triangles[i] = 0;  
6.             triangles[i + 1] = j + 1;  
7.             triangles[i + 2] = j;  
8.         }  
9.         triangles[segments * 3 - 3] = 0;  
10.         triangles[segments * 3 - 2] = 1;  
11.         triangles[segments * 3 - 1] = segments;  

这样我们的顶点和三角形都确定了，关于顺时针和逆时针，看你摄像头看的哪一面哈

完整的画圆代码如下：

[csharp] view plain copy print ?

1. #region 画圆  
2.     /// <summary>  
3.     /// 画圆  
4.     /// </summary>  
5.     /// <param name="radius">圆的半径</param>  
6.     /// <param name="segments">圆的分割数</param>  
7.     /// <param name="centerCircle">圆心得位置</param>  
8.     void DrawCircle(float radius, int segments, Vector3 centerCircle)  
9.     {  
10.         gameObject.AddComponent<MeshFilter>();  
11.         gameObject.AddComponent<MeshRenderer>();  
12.         gameObject.GetComponent<MeshRenderer>().material = mat;  
13.   
14.         //顶点  
15.         Vector3[] vertices = new Vector3[segments + 1];  
16.         vertices[0] = centerCircle;  
17.         float deltaAngle = Mathf.Deg2Rad * 360f / segments;  
18.         float currentAngle = 0;  
19.         for (int i = 1; i < vertices.Length; i++)  
20.         {  
21.             float cosA = Mathf.Cos(currentAngle);  
22.             float sinA = Mathf.Sin(currentAngle);  
23.             vertices[i] = new Vector3(cosA * radius + centerCircle.x, sinA * radius + centerCircle.y, 0);  
24.             currentAngle += deltaAngle;  
25.         }  
26.   
27.         //三角形  
28.         int[] triangles = new int[segments * 3];  
29.         for (int i = 0, j = 1; i < segments * 3 - 3; i += 3, j++)  
30.         {  
31.             triangles[i] = 0;  
32.             triangles[i + 1] = j + 1;  
33.             triangles[i + 2] = j;  
34.         }  
35.         triangles[segments * 3 - 3] = 0;  
36.         triangles[segments * 3 - 2] = 1;  
37.         triangles[segments * 3 - 1] = segments;  
38.   
39.   
40.         Mesh mesh = GetComponent<MeshFilter>().mesh;  
41.         mesh.Clear();  
42.   
43.         mesh.vertices = vertices;  
44.         mesh.triangles = triangles;  
45.     }  
46.     #endregion  

当然你还可以做点小变动，画成这样：

上面的毁了，这样的就自然能画出来，自己试下哈。

四.画圆环

既然，上面的圆画出来了，圆环也就在此基础上，只不过有好多小梯形组成，梯形由两个三角形组成。

示意图如下：

当分成很多等份时，就类似圆环了。

同理，我们先列顶点，这一次我们比上面多要一个参数，内圆半径：

顶点代码如下：

[csharp] view plain copy print ?

1. //顶点  
2.         Vector3[] vertices = new Vector3[segments * 2];  
3.         float deltaAngle = Mathf.Deg2Rad * 360f / segments;  
4.         float currentAngle = 0;  
5.         for (int i = 0; i < vertices.Length; i += 2)  
6.         {  
7.             float cosA = Mathf.Cos(currentAngle);  
8.             float sinA = Mathf.Sin(currentAngle);  
9.             vertices[i] = new Vector3(cosA * innerRadius + centerCircle.x, sinA * innerRadius + centerCircle.y, 0);  
10.             vertices[i + 1] = new Vector3(cosA * radius + centerCircle.x, sinA * radius + centerCircle.y, 0);  
11.             currentAngle += deltaAngle;  
12.         }  

同理，再列出三角形：

[csharp] view plain copy print ?

1. //三角形  
2.         int[] triangles = new int[segments * 6];  
3.         for (int i = 0, j = 0; i < segments * 6; i += 6, j += 2)  
4.         {  
5.             triangles[i] = j;  
6.             triangles[i + 1] = (j + 1) % vertices.Length;  
7.             triangles[i + 2] = (j + 3) % vertices.Length;  
8.   
9.             triangles[i + 3] = j;  
10.             triangles[i + 4] = (j + 3) % vertices.Length;  
11.             triangles[i + 5] = (j + 2) % vertices.Length;  
12.         }  

最终结果如图：

完整的代码如下：

[csharp] view plain copy print ?

1. #region 画圆环  
2.     /// <summary>  
3.     /// 画圆环  
4.     /// </summary>  
5.     /// <param name="radius">圆半径</param>  
6.     /// <param name="innerRadius">内圆半径</param>  
7.     /// <param name="segments">圆的分个数</param>  
8.     /// <param name="centerCircle">圆心坐标</param>  
9.     void DrawRing(float radius, float innerRadius, int segments, Vector3 centerCircle)  
10.     {  
11.         gameObject.AddComponent<MeshFilter>();  
12.         gameObject.AddComponent<MeshRenderer>();  
13.         gameObject.GetComponent<MeshRenderer>().material = mat;  
14.   
15.         //顶点  
16.         Vector3[] vertices = new Vector3[segments * 2];  
17.         float deltaAngle = Mathf.Deg2Rad * 360f / segments;  
18.         float currentAngle = 0;  
19.         for (int i = 0; i < vertices.Length; i += 2)  
20.         {  
21.             float cosA = Mathf.Cos(currentAngle);  
22.             float sinA = Mathf.Sin(currentAngle);  
23.             vertices[i] = new Vector3(cosA * innerRadius + centerCircle.x, sinA * innerRadius + centerCircle.y, 0);  
24.             vertices[i + 1] = new Vector3(cosA * radius + centerCircle.x, sinA * radius + centerCircle.y, 0);  
25.             currentAngle += deltaAngle;  
26.         }  
27.   
28.         //三角形  
29.         int[] triangles = new int[segments * 6];  
30.         for (int i = 0, j = 0; i < segments * 6; i += 6, j += 2)  
31.         {  
32.             triangles[i] = j;  
33.             triangles[i + 1] = (j + 1) % vertices.Length;  
34.             triangles[i + 2] = (j + 3) % vertices.Length;  
35.   
36.             triangles[i + 3] = j;  
37.             triangles[i + 4] = (j + 3) % vertices.Length;  
38.             triangles[i + 5] = (j + 2) % vertices.Length;  
39.         }  
40.   
41.         Mesh mesh = GetComponent<MeshFilter>().mesh;  
42.         mesh.Clear();  
43.   
44.         mesh.vertices = vertices;  
45.         mesh.triangles = triangles;  
46.     }  
47.     #endregion  

一样，代码做点小的改动就能产生太阳和锯齿的图片，如下：

、

怎么改的上面看明白的一眼就看出来了，哈哈，你们自己写吧。

五：完整代码

本篇博客涉及的脚本的完整代码如下：

[csharp] view plain copy print ?

1. using UnityEngine;  
2. using System.Collections;  
3.   
4. public enum PlaneState  
5. {  
6.     Triangle,  
7.     Square,  
8.     Circle,  
9.     Ring  
10. }  
11.   
12. public class Test : MonoBehaviour  
13. {  
14.   
15.     public Material mat;  
16.   
17.     public PlaneState planeState;  
18.   
19.     // Use this for initialization  
20.     void Start()  
21.     {  
22.   
23.         switch (planeState)  
24.         {  
25.             case PlaneState.Triangle:  
26.                 DrawTriangle();  
27.                 break;  
28.             case PlaneState.Square:  
29.                 DrawSquare();  
30.                 break;  
31.             case PlaneState.Circle:  
32.                 DrawCircle(2, 50, Vector3.zero);  
33.                 break;  
34.             case PlaneState.Ring:  
35.                 DrawRing(2, 3, 50, Vector3.zero);  
36.                 break;  
37.         }  
38.   
39.   
40.   
41.     }  
42.  
43.     #region 画三角形  
44.     void DrawTriangle()  
45.     {  
46.         gameObject.AddComponent<MeshFilter>();  
47.         gameObject.AddComponent<MeshRenderer>();  
48.         gameObject.GetComponent<MeshRenderer>().material = mat;  
49.   
50.         Mesh mesh = GetComponent<MeshFilter>().mesh;  
51.         mesh.Clear();  
52.   
53.         //设置顶点  
54.         mesh.vertices = new Vector3[] { new Vector3(0, 0, 0), new Vector3(0, 1, 0), new Vector3(1, 1, 0) };  
55.         //设置三角形顶点顺序，顺时针设置  
56.         mesh.triangles = new int[] { 0, 1, 2 };  
57.     }  
58.     #endregion  
59.  
60.     #region 画正方形  
61.     void DrawSquare()  
62.     {  
63.         gameObject.AddComponent<MeshFilter>();  
64.         gameObject.AddComponent<MeshRenderer>();  
65.         gameObject.GetComponent<MeshRenderer>().material = mat;  
66.   
67.         Mesh mesh = GetComponent<MeshFilter>().mesh;  
68.         mesh.Clear();  
69.   
70.         mesh.vertices = new Vector3[] { new Vector3(0, 0, 0), new Vector3(0, 1, 0), new Vector3(1, 1, 0), new Vector3(1, 0, 0) };  
71.         mesh.triangles = new int[]  
72.         { 0, 1, 2,  
73.           0, 2, 3  
74.         };  
75.     }  
76.     #endregion  
77.  
78.     #region 画圆  
79.     /// <summary>  
80.     /// 画圆  
81.     /// </summary>  
82.     /// <param name="radius">圆的半径</param>  
83.     /// <param name="segments">圆的分割数</param>  
84.     /// <param name="centerCircle">圆心得位置</param>  
85.     void DrawCircle(float radius, int segments, Vector3 centerCircle)  
86.     {  
87.         gameObject.AddComponent<MeshFilter>();  
88.         gameObject.AddComponent<MeshRenderer>();  
89.         gameObject.GetComponent<MeshRenderer>().material = mat;  
90.   
91.         //顶点  
92.         Vector3[] vertices = new Vector3[segments + 1];  
93.         vertices[0] = centerCircle;  
94.         float deltaAngle = Mathf.Deg2Rad * 360f / segments;  
95.         float currentAngle = 0;  
96.         for (int i = 1; i < vertices.Length; i++)  
97.         {  
98.             float cosA = Mathf.Cos(currentAngle);  
99.             float sinA = Mathf.Sin(currentAngle);  
100.             vertices[i] = new Vector3(cosA * radius + centerCircle.x, sinA * radius + centerCircle.y, 0);  
101.             currentAngle += deltaAngle;  
102.         }  
103.   
104.         //三角形  
105.         int[] triangles = new int[segments * 3];  
106.         for (int i = 0, j = 1; i < segments * 3 - 3; i += 3, j++)  
107.         {  
108.             triangles[i] = 0;  
109.             triangles[i + 1] = j + 1;  
110.             triangles[i + 2] = j;  
111.         }  
112.         triangles[segments * 3 - 3] = 0;  
113.         triangles[segments * 3 - 2] = 1;  
114.         triangles[segments * 3 - 1] = segments;  
115.   
116.   
117.         Mesh mesh = GetComponent<MeshFilter>().mesh;  
118.         mesh.Clear();  
119.   
120.         mesh.vertices = vertices;  
121.         mesh.triangles = triangles;  
122.     }  
123.     #endregion  
124.  
125.     #region 画圆环  
126.     /// <summary>  
127.     /// 画圆环  
128.     /// </summary>  
129.     /// <param name="radius">圆半径</param>  
130.     /// <param name="innerRadius">内圆半径</param>  
131.     /// <param name="segments">圆的分个数</param>  
132.     /// <param name="centerCircle">圆心坐标</param>  
133.     void DrawRing(float radius, float innerRadius, int segments, Vector3 centerCircle)  
134.     {  
135.         gameObject.AddComponent<MeshFilter>();  
136.         gameObject.AddComponent<MeshRenderer>();  
137.         gameObject.GetComponent<MeshRenderer>().material = mat;  
138.   
139.         //顶点  
140.         Vector3[] vertices = new Vector3[segments * 2];  
141.         float deltaAngle = Mathf.Deg2Rad * 360f / segments;  
142.         float currentAngle = 0;  
143.         for (int i = 0; i < vertices.Length; i += 2)  
144.         {  
145.             float cosA = Mathf.Cos(currentAngle);  
146.             float sinA = Mathf.Sin(currentAngle);  
147.             vertices[i] = new Vector3(cosA * innerRadius + centerCircle.x, sinA * innerRadius + centerCircle.y, 0);  
148.             vertices[i + 1] = new Vector3(cosA * radius + centerCircle.x, sinA * radius + centerCircle.y, 0);  
149.             currentAngle += deltaAngle;  
150.         }  
151.   
152.         //三角形  
153.         int[] triangles = new int[segments * 6];  
154.         for (int i = 0, j = 0; i < segments * 6; i += 6, j += 2)  
155.         {  
156.             triangles[i] = j;  
157.             triangles[i + 1] = (j + 1) % vertices.Length;  
158.             triangles[i + 2] = (j + 3) % vertices.Length;  
159.   
160.             triangles[i + 3] = j;  
161.             triangles[i + 4] = (j + 3) % vertices.Length;  
162.             triangles[i + 5] = (j + 2) % vertices.Length;  
163.         }  
164.   
165.         Mesh mesh = GetComponent<MeshFilter>().mesh;  
166.         mesh.Clear();  
167.   
168.         mesh.vertices = vertices;  
169.         mesh.triangles = triangles;  
170.     }  
171.     #endregion  
172. }  

欢迎多多指教！