Performance Unity-提高网格生成和渲染性能

因为我最近才开始研究网格，它们是如何工作的，它们做什么等等，所以我决定用我自己的计算来创建一个圆的网格。不幸的是，这真的很慢

因此，我正在寻找改进的技巧，使它只慢一点（因为这可能是它将得到的最好的…）

下面是我用来生成圆的代码：

public static void createCircle(MeshFilter meshFilter, float innerRadius, float outerRadius, Color color, float xPosition = 0, float yPosition = 0, float startDegree = 0, float endDegree = 360, int points = 100)
         {
             Mesh mesh = meshFilter.mesh;
             mesh.Clear();

             //These values will result in no (or very ugly in the case of points < 10) circle, so let's safe calculation and just return an empty mesh!
             if (startDegree == endDegree || points < 10 || innerRadius >= outerRadius || innerRadius < 0 || outerRadius <= 0)
             {
                 return;
             }

             //The points for the full circle shall be whatever is given but if its not the full circle we dont need all the points!
             points = (int)(Mathf.Abs(endDegree - startDegree) / 360f * points);

             //We always need an uneven number of points!
             if (points % 2 != 0) { points++; }

             Vector3[] vertices = new Vector3[points];
             float degreeStepSize = (endDegree - startDegree) * 2 / (points - 3);
             float halfRadStepSize = (degreeStepSize) * Mathf.Deg2Rad / 2f;
             float startRad = Mathf.Deg2Rad * startDegree;
             float endRad = Mathf.Deg2Rad * endDegree;

             //Let's save the vector at the beginning and the one on the end to make a perfectly straight line
             vertices[0] = new Vector3(Mathf.Sin(startRad) * outerRadius + xPosition, Mathf.Cos(startRad) * outerRadius + yPosition, 0);
             vertices[vertices.Length - 1] = new Vector3(Mathf.Sin(endRad) * innerRadius + xPosition, Mathf.Cos(endRad) * innerRadius + yPosition, 0);

             for (int i = 1; i < vertices.Length - 1; i++)
             {
                 //Pure coinsidence that saved some calculatons. Half Step Size is the same as what would needed to be calculated here!
                 float rad = (i - 1) * halfRadStepSize + startRad;
                 if (i % 2 == 0)
                 {
                     vertices[i] = new Vector3(Mathf.Sin(rad) * outerRadius + xPosition, Mathf.Cos(rad) * outerRadius + yPosition, 0);
                 }
                 else
                 {
                     vertices[i] = new Vector3(Mathf.Sin(rad) * innerRadius + xPosition, Mathf.Cos(rad) * innerRadius + yPosition, 0);
                 }
             }
             mesh.vertices = vertices;

             int[] tri = new int[(vertices.Length - 2) * 3];
             for (int i = 0; i < (vertices.Length - 2); i++)
             {
                 int index = i * 3;
                 if (i % 2 == 0)
                 {
                     tri[index + 0] = i + 0;
                     tri[index + 1] = i + 2;
                     tri[index + 2] = i + 1;
                 }
                 else
                 {
                     tri[index + 0] = i + 0;
                     tri[index + 1] = i + 1;
                     tri[index + 2] = i + 2;
                 }
             }

             mesh.triangles = tri;
             Vector3[] normals = new Vector3[vertices.Length];
             Color[] colors = new Color[vertices.Length];
             for (int i = 0; i < vertices.Length; i++)
             {
                 normals[i] = Vector3.forward;
                 colors[i] = color;
             }
             mesh.normals = normals;
             mesh.colors = colors;

             meshFilter.mesh = mesh;
         }

public static void createCircle（网格过滤器网格过滤器，浮点内半径，浮点外半径，颜色，浮点X位置=0，浮点Y位置=0，浮点起始度=0，浮点结束度=360，整数点=100）
{
Mesh Mesh=meshFilter.Mesh；
mesh.Clear（）；
//这些值将导致没有（或在点<10的情况下非常难看）圆，因此让我们安全地计算并返回一个空网格！
如果（startDegree==endDegree | | points<10 | | innerRadius>=outerRadius | | | innerRadius<0 | | | outerRadius通过删除额外的内存分配，您几乎可以将速度提高一倍。由于Vector3是一种值类型，在分配数组时它们已经被分配。Vector3.forward每次也分配一个新的Vector3，我们可以重复使用它

public static void createCircle(MeshFilter meshFilter, float innerRadius, float outerRadius, Color color, float xPosition = 0, float yPosition = 0, float startDegree = 0, float endDegree = 360, int points = 100)
 {
     Mesh mesh = meshFilter.mesh;
     mesh.Clear();

     //These values will result in no (or very ugly in the case of points < 10) circle, so let's safe calculation and just return an empty mesh!
     if (startDegree == endDegree || points < 10 || innerRadius >= outerRadius || innerRadius < 0 || outerRadius <= 0)
     {
         return;
     }

     //The points for the full circle shall be whatever is given but if its not the full circle we dont need all the points!
     points = (int)(Mathf.Abs(endDegree - startDegree) / 360f * points);

     //We always need an uneven number of points!
     if (points % 2 != 0) { points++; }

     Vector3[] vertices = new Vector3[points];
     float degreeStepSize = (endDegree - startDegree) * 2 / (points - 3);
     float halfRadStepSize = (degreeStepSize) * Mathf.Deg2Rad / 2f;
     float startRad = Mathf.Deg2Rad * startDegree;
     float endRad = Mathf.Deg2Rad * endDegree;

     //Let's save the vector at the beginning and the one on the end to make a perfectly straight line
     vertices[0] = new Vector3(Mathf.Sin(startRad) * outerRadius + xPosition, Mathf.Cos(startRad) * outerRadius + yPosition, 0);
     vertices[vertices.Length - 1] = new Vector3(Mathf.Sin(endRad) * innerRadius + xPosition, Mathf.Cos(endRad) * innerRadius + yPosition, 0);

     for (int i = 1; i < vertices.Length - 1; i++)
     {
         //Pure coinsidence that saved some calculatons. Half Step Size is the same as what would needed to be calculated here!
         float rad = (i - 1) * halfRadStepSize + startRad;
         if (i % 2 == 0)
         {
             vertices[i].x = Mathf.Sin(rad) * outerRadius + xPosition;
             vertices[i].y = Mathf.Cos(rad) * outerRadius + yPosition;
             vertices[i].z = 0;
         }
         else
         {
             vertices[i].x = Mathf.Sin(rad) * innerRadius + xPosition;
             vertices[i].y = Mathf.Cos(rad) * innerRadius + yPosition;
             vertices[i].z = 0;;
         }
     }
     mesh.vertices = vertices;

     int[] tri = new int[(vertices.Length - 2) * 3];
     for (int i = 0; i < (vertices.Length - 2); i++)
     {
         int index = i * 3;
         if (i % 2 == 0)
         {
             tri[index + 0] = i + 0;
             tri[index + 1] = i + 2;
             tri[index + 2] = i + 1;
         }
         else
         {
             tri[index + 0] = i + 0;
             tri[index + 1] = i + 1;
             tri[index + 2] = i + 2;
         }
     }

     mesh.triangles = tri;
     Vector3[] normals = new Vector3[vertices.Length];
     Color[] colors = new Color[vertices.Length];

    var f = Vector3.forward;

     for (int i = 0; i < vertices.Length; i++)
     {
         normals[i].x= f.x;
         normals[i].y= f.y;
         normals[i].z= f.z;
         colors[i] = color;
     }
     mesh.normals = normals;
     mesh.colors = colors;

     meshFilter.mesh = mesh;
 }

public static void createCircle（网格过滤器网格过滤器，浮点内半径，浮点外半径，颜色，浮点X位置=0，浮点Y位置=0，浮点起始度=0，浮点结束度=360，整数点=100）
{
Mesh Mesh=meshFilter.Mesh；
mesh.Clear（）；
//这些值将导致没有（或在点<10的情况下非常难看）圆，因此让我们安全地计算并返回一个空网格！
如果（startDegree==endDegree | | points<10 | | innerRadius>=outerRadius | | innerRadius<0 | | | | outerRadius好吧，我不确定我是否理解你的答案，但我也在统一处理点云和网格。我所做的最初是使用
协程来提高性能，但何时屈服是一个大问题或者像我这样的大数据。现在我正在创建一个新线程并在那里创建我的网格，我不知道它是否慢，因为Unity在其他方法中一直挂起，但至少Unity不再挂起。但是在Unity中使用多线程编程时必须小心。你可以检查。@AliKanat谢谢你的评论。我是act我对任何事情都持开放态度，基本上是在寻找一些改进意见、想法和技巧……我一定会查看你的链接，非常感谢！