unity按照给定法线方向生成半球体mesh

可以使用Unity自带的Mesh类，通过指定半径和细分度来生成半球体。然后使用法线方向限制生成的顶点，再使用几何数据计算出法线、UV、三角形等信息，最后将这些信息填入Mesh中即可。具体实现代码可以参考网上的教程或者借助开源库。

相关问题

写一个unity按照给定法线方向生成半球体mesh的脚本

可以使用以下脚本实现：

using UnityEngine;

public class HalfSphereMeshGenerator : MonoBehaviour
{
    [SerializeField] private int numLongitudeSections = 10;
    [SerializeField] private int numLatitudeSections = 10;
    [SerializeField] private float radius = 1f;
    [SerializeField] private Vector3 upDirection = Vector3.up;

    private void Start()
    {
        Mesh mesh = new Mesh();

        Vector3[] vertices = new Vector3[numLongitudeSections * (numLatitudeSections + 1)];
        int[] triangles = new int[numLongitudeSections * numLatitudeSections * 6];
        
        for (int lat = 0; lat <= numLatitudeSections; lat++)
        {
            float theta = lat * Mathf.PI / numLatitudeSections;
            float sinTheta = Mathf.Sin(theta);
            float cosTheta = Mathf.Cos(theta);

            for (int lon = 0; lon < numLongitudeSections; lon++)
            {
                float phi = lon * 2f * Mathf.PI / numLongitudeSections;
                float sinPhi = Mathf.Sin(phi);
                float cosPhi = Mathf.Cos(phi);

                Vector3 direction = new Vector3(sinTheta * cosPhi, cosTheta, sinTheta * sinPhi);

                Vector3 normal = Quaternion.FromToRotation(upDirection, direction) * upDirection;

                vertices[lat * numLongitudeSections + lon] = normal * radius;
            }
        }

        int index = 0;

        for (int lat = 0; lat < numLatitudeSections; lat++)
        {
            for (int lon = 0; lon < numLongitudeSections; lon++)
            {
                int first = lat * numLongitudeSections + lon;
                int second = first + numLongitudeSections;

                triangles[index++] = first;
                triangles[index++] = second + 1;
                triangles[index++] = second;

                triangles[index++] = first;
                triangles[index++] = first + 1;
                triangles[index++] = second + 1;
            }
        }

        mesh.vertices = vertices;
        mesh.triangles = triangles;
        mesh.RecalculateNormals();

        GetComponent<MeshFilter>().mesh = mesh;
    }
}

这个脚本使用给定法线方向和半径，按照给定的经度和纬度划分数量，生成半球体的网格。您可以将它附加到一个 GameObject 上，然后通过检查器中的参数进行自定义设置。

unity沿着给定三维向量方向生成半球体mesh

你可以使用以下代码来生成一个半球体 mesh。

using UnityEngine;

public class HalfSphere : MonoBehaviour {

public int segments = 12;
public float radius = 1f;
public Vector3 axis = Vector3.up;

void Start() {

    Mesh mesh = new Mesh();
    mesh.name = "Half Sphere";

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

    float segmentSize = Mathf.PI / segments;
    float segmentAngle, radius2d, xz;
    Vector3 pt;
    int v = 0;
    int t = 0;

    // top point
    vertices[0] = Vector3.up * radius;
    uv[0] = Vector3.up;

    for (int y = 1; y <= segments / 2; y++) {
        segmentAngle = segmentSize * y;
        radius2d = radius * Mathf.Cos(segmentAngle);
        pt.y = radius * Mathf.Sin(segmentAngle);

        for (int x = 0; x < segments; x++) {
            xz = x * segmentSize;
            pt.x = radius2d * Mathf.Sin(xz);
            pt.z = radius2d * Mathf.Cos(xz);

            vertices[v + 1] = pt;
            uv[v + 1] = new Vector2(x / (float)segments, y / (float)(segments / 2));

            v++;

            if (y == 1) {
                triangles[t] = 0;
                triangles[t + 1] = v + 1;
                triangles[t + 2] = v;
                t += 3;
            }
            else if (x != 0) {
                triangles[t] = v - segments - 1;
                triangles[t + 1] = v - segments;
                triangles[t + 2] = v;
                t += 3;
            }

            if (x == segments - 1) {
                triangles[t] = v - segments;
                triangles[t + 1] = v - segments * 2 + 1;
                triangles[t + 2] = v - segments + 1;
                t += 3;
            }
        }
    }

    // bottom point
    vertices[v + 1] = Vector3.down * radius;
    uv[vertices.Length - 1] = Vector3.zero;

    mesh.vertices = vertices;
    mesh.triangles = triangles;
    mesh.uv = uv;
    mesh.RecalculateNormals();

    transform.rotation = Quaternion.FromToRotation(Vector3.up, axis);
    transform.GetComponent<MeshFilter>().mesh = mesh;
    transform.GetComponent<MeshRenderer>().material = new Material(Shader.Find("Standard"));
}

使用这个脚本，你可以通过提供一个方向向量来生成半球体 mesh，如下：

public Vector3 direction = Vector3.forward;

void Start() {
    Vector3 up = Vector3.up;
    if (Mathf.Abs(Vector3.Dot(up, direction)) == 1) {
        up = Vector3.right;
    }
    Vector3 axis = Vector3.Cross(direction, up).normalized;
    transform.rotation = Quaternion.LookRotation(direction, axis);
    HalfSphere halfSphere = gameObject.AddComponent<HalfSphere>();
    halfSphere.axis = direction;
}