用unity写一个生成胶囊体mesh的脚本，给出三种不同的实现方案

1. 第一种实现方案：使用Unity自带的胶囊体组件，将其放置在场景中，然后使用代码获取该组件的Mesh数据，再进行修改和优化，最终生成自定义的胶囊体Mesh。

2. 第二种实现方案：使用数学公式计算出胶囊体的顶点坐标和三角形索引，然后将其转换为Mesh数据，最终生成自定义的胶囊体Mesh。

3. 第三种实现方案：使用外部库或插件，如ProBuilder或MeshKit等，来生成自定义的胶囊体Mesh，这些库或插件提供了更多的功能和选项，可以更方便地生成各种形状的Mesh。

相关问题

用unity写一个生成胶囊体mesh的脚本

当然可以，以下是一个简单的Unity脚本，可以生成胶囊体Mesh：

using UnityEngine;

public class CapsuleMeshGenerator : MonoBehaviour
{
    public float radius = 0.5f;
    public float height = 1.0f;
    public int segments = 16;

    private MeshFilter meshFilter;

    void Start()
    {
        meshFilter = GetComponent<MeshFilter>();
        meshFilter.mesh = GenerateCapsuleMesh(radius, height, segments);
    }

    Mesh GenerateCapsuleMesh(float radius, float height, int segments)
    {
        Mesh mesh = new Mesh();

        int numVertices = (segments + 1) * (segments + 1) + 2;
        int numTriangles = segments * segments * 2 * 3 + segments * 6;

        Vector3[] vertices = new Vector3[numVertices];
        Vector2[] uv = new Vector2[numVertices];
        int[] triangles = new int[numTriangles];

        int vertexIndex = 0;
        int triangleIndex = 0;

        // Generate top hemisphere
        for (int y = 0; y <= segments / 2; y++)
        {
            float v = (float)y / (segments / 2);
            float latitude = Mathf.PI / 2 - v * Mathf.PI / 2;

            for (int x = 0; x <= segments; x++)
            {
                float u = (float)x / segments;
                float longitude = u * Mathf.PI * 2;

                float xCoord = Mathf.Sin(latitude) * Mathf.Cos(longitude);
                float yCoord = Mathf.Cos(latitude);
                float zCoord = Mathf.Sin(latitude) * Mathf.Sin(longitude);

                vertices[vertexIndex] = new Vector3(xCoord * radius, yCoord * radius + height / 2, zCoord * radius);
                uv[vertexIndex] = new Vector2(u, v);

                if (x < segments && y < segments / 2)
                {
                    triangles[triangleIndex++] = vertexIndex;
                    triangles[triangleIndex++] = vertexIndex + segments + 1;
                    triangles[triangleIndex++] = vertexIndex + segments;

                    triangles[triangleIndex++] = vertexIndex;
                    triangles[triangleIndex++] = vertexIndex + 1;
                    triangles[triangleIndex++] = vertexIndex + segments + 1;
                }

                vertexIndex++;
            }
        }

        // Generate bottom hemisphere
        for (int y = segments / 2; y <= segments; y++)
        {
            float v = (float)y / (segments / 2);
            float latitude = Mathf.PI / 2 - v * Mathf.PI / 2;

            for (int x = 0; x <= segments; x++)
            {
                float u = (float)x / segments;
                float longitude = u * Mathf.PI * 2;

                float xCoord = Mathf.Sin(latitude) * Mathf.Cos(longitude);
                float yCoord = Mathf.Cos(latitude);
                float zCoord = Mathf.Sin(latitude) * Mathf.Sin(longitude);

                vertices[vertexIndex] = new Vector3(xCoord * radius, yCoord * radius - height / 2, zCoord * radius);
                uv[vertexIndex] = new Vector2(u, v);

                if (x < segments && y < segments)
                {
                    triangles[triangleIndex++] = vertexIndex;
                    triangles[triangleIndex++] = vertexIndex + segments;
                    triangles[triangleIndex++] = vertexIndex + segments + 1;

                    triangles[triangleIndex++] = vertexIndex;
                    triangles[triangleIndex++] = vertexIndex + segments + 1;
                    triangles[triangleIndex++] = vertexIndex + 1;
                }

                vertexIndex++;
            }
        }

        // Generate top cap
        vertices[vertexIndex] = new Vector3(0, height / 2 - radius, 0);
        uv[vertexIndex] = new Vector2(0.5f, 1);
        int topCapIndex = vertexIndex;

        for (int i = 0; i < segments; i++)
        {
            int i1 = i + 1;
            triangles[triangleIndex++] = topCapIndex;
            triangles[triangleIndex++] = i1;
            triangles[triangleIndex++] = i;
        }

        // Generate bottom cap
        vertices[vertexIndex] = new Vector3(0, -height / 2 + radius, 0);
        uv[vertexIndex] = new Vector2(0.5f, 0);
        int bottomCapIndex = vertexIndex;

        for (int i = 0; i < segments; i++)
        {
            int i1 = i + 1;
            triangles[triangleIndex++] = bottomCapIndex;
            triangles[triangleIndex++] = i + segments * (segments / 2 + 1) + 1;
            triangles[triangleIndex++] = i1 + segments * (segments / 2 + 1) + 1;
        }

        mesh.vertices = vertices;
        mesh.uv = uv;
        mesh.triangles = triangles;

        mesh.RecalculateNormals();
        mesh.RecalculateBounds();

        return mesh;
    }
}

这个脚本可以将一个胶囊体的Mesh生成并赋值给一个MeshFilter组件。你可以将这个脚本挂载到一个GameObject上，然后在Inspector面板中设置半径、高度和细分级别，就可以生成不同大小和精度的胶囊体了。

unity 通过脚本生成 mesh 胶囊体

可以使用以下代码生成一个胶囊体 Mesh：

using UnityEngine;

public class CapsuleGenerator : MonoBehaviour
{
    public float radius = 0.5f;
    public float height = 1.0f;
    public int segments = 16;

    void Start()
    {
        MeshFilter meshFilter = GetComponent<MeshFilter>();
        if (meshFilter == null)
        {
            meshFilter = gameObject.AddComponent<MeshFilter>();
        }

        Mesh mesh = new Mesh();
        meshFilter.mesh = mesh;

        Vector3[] vertices = new Vector3[(segments + 1) * (segments + 1) + 2];
        int[] triangles = new int[segments * segments * 6 + segments * 6];
        Vector2[] uv = new Vector2[vertices.Length];

        int vertexIndex = 0;
        float angleStep = 2.0f * Mathf.PI / segments;

        // Generate top cap vertices
        vertices[vertexIndex++] = new Vector3(0.0f, height / 2.0f, 0.0f);
        for (int i = 0; i <= segments; i++)
        {
            float angle = i * angleStep;
            float x = Mathf.Sin(angle) * radius;
            float z = Mathf.Cos(angle) * radius;
            vertices[vertexIndex++] = new Vector3(x, height / 2.0f, z);
        }

        // Generate bottom cap vertices
        vertices[vertexIndex++] = new Vector3(0.0f, -height / 2.0f, 0.0f);
        for (int i = 0; i <= segments; i++)
        {
            float angle = i * angleStep;
            float x = Mathf.Sin(angle) * radius;
            float z = Mathf.Cos(angle) * radius;
            vertices[vertexIndex++] = new Vector3(x, -height / 2.0f, z);
        }

        // Generate side vertices
        for (int i = 0; i <= segments; i++)
        {
            float angle = i * angleStep;
            float x = Mathf.Sin(angle) * radius;
            float z = Mathf.Cos(angle) * radius;
            vertices[vertexIndex++] = new Vector3(x, height / 2.0f, z);
            vertices[vertexIndex++] = new Vector3(x, -height / 2.0f, z);
        }

        // Generate top cap triangles
        int triangleIndex = 0;
        for (int i = 1; i <= segments; i++)
        {
            triangles[triangleIndex++] = 0;
            triangles[triangleIndex++] = i + 1;
            triangles[triangleIndex++] = i;
        }

        // Generate bottom cap triangles
        for (int i = segments + 2; i <= 2 * segments + 1; i++)
        {
            triangles[triangleIndex++] = segments + 1;
            triangles[triangleIndex++] = i;
            triangles[triangleIndex++] = i + 1;
        }

        // Generate side triangles
        for (int i = 1; i <= segments; i++)
        {
            triangles[triangleIndex++] = i;
            triangles[triangleIndex++] = i + segments + 1;
            triangles[triangleIndex++] = i + segments + 2;

            triangles[triangleIndex++] = i;
            triangles[triangleIndex++] = i + segments + 2;
            triangles[triangleIndex++] = i + 1;
        }

        // Generate UV coordinates
        for (int i = 0; i < vertices.Length; i++)
        {
            uv[i] = new Vector2(vertices[i].x, vertices[i].z);
        }

        mesh.vertices = vertices;
        mesh.triangles = triangles;
        mesh.uv = uv;

        mesh.RecalculateNormals();
        mesh.RecalculateBounds();
    }
}

将这个脚本挂载到一个 GameObject 上，就可以生成一个胶囊体 Mesh。