Unity 凹多边形三角剖分

宝塔服务器面板，一键全能部署及管理，送你10850元礼包，点我领取

游戏中需要实现一个小功能，显示一个玩家的能力图，这个图是一个有6个顶点任意摆放组合的多边形。而绘制多边形主要用到的知识就是Mesh构建，mesh的构建主要需要顶点列表，三角形列表，法线列表、uv列表等等等等，在这里我们只考虑顶点列表和三角形列表。那么我们需要做的就是给定一组顶点之后，如何用三角形进行划分，以便绘制。

以下讨论的多边形：1.三角形顶点列表为顺时针顺序。2.多边形不能包含空洞。

参照文章：https://blog.csdn.net/huangzengman/article/details/77114082，表示感谢

1.凸多边形

凸多边形三角剖分比较简单，可以使用第一个点依次连接后面的其他点来组成一组共同顶点的三角形。当然这是最简单的凸多边形剖分算法，还有其他最优剖分算法，需要考虑权重等，但我们不需要。

a b

图a为凸多边形，标出了顶点序号。

图b为三角剖分后，unity中所显示的三角形网格。

2.凹多边形

凹多边形的剖分则需要判断点与多边形的关系，以此来确定可划分顶点与不可划分顶点。

a b

图a为凹多边形（没有空洞），标出了顶点序号。

图b为三角剖分后，unity中所显示的三角形网格。

代码如下，参考上述连接：

1.MeshDrawBase.cs 基础类

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public abstract class MeshDrawBase : MonoBehaviour {

    protected MeshFilter targetFilter;
    protected Mesh mesh;
    protected int[] tris;
    protected Vector2[] uvs;
    protected Vector3[] normals;

    // Use this for initialization
    void Awake ) {
        targetFilter = GetComponent<MeshFilter>);
    }
    
    // Update is called once per frame
    protected virtual void Update ) {
        DrawMesh);
    }

    protected abstract void DrawMesh);
}

View Code

2.Polygon.cs 用于绘制多边形

using System.Collections.Generic;
using UnityEngine;

public class Polygon : MeshDrawBase
{
    public List<Vector3> points = new List<Vector3>);
    public List<int> indexes = new List<int>);
    int index = 0;
    Color[] colors;

    void Start)
    {
        /*points.Addnew Vector30, 0, 0));
        points.Addnew Vector30, 1, 0));
        points.Addnew Vector31, 1, 0));
        points.Addnew Vector30.7f, 0.8f, 0));
        points.Addnew Vector31, 0.5f, 0));
        points.Addnew Vector30.7f, 0.3f, 0));
        points.Addnew Vector31, 0, 0));
        indexes.Add0);
        indexes.Add1);
        indexes.Add2);
        indexes.Add3);
        indexes.Add4);
        indexes.Add5);
        indexes.Add6);*/
    }

    protected override void DrawMesh)
    {
        ifInput.GetKeyDownKeyCode.D))
        {
            DrawPolygon);
        }
    }

    private void DrawPolygon)
    {
        mesh = new Mesh);
        mesh.name = "Polygon";
        mesh.vertices = points.ToArray);
        
        tris = Triangulation.WidelyTriangleIndexnew List<Vector3>points), indexes).ToArray);

        mesh.triangles = tris;

        normals = new Vector3[mesh.vertices.Length];
        forint i = 0; i < mesh.vertices.Length; ++i)
        {
            normals[i] = new Vector30, 0, 1);
        }

        mesh.normals = normals;
        
        mesh.RecalculateBounds);
        mesh.RecalculateTangents);

        targetFilter.mesh = mesh;
    }

    protected override void Update)
    {
        base.Update);
        ifInput.GetMouseButtonDown0))
        {
            Ray ray = Camera.main.ScreenPointToRayInput.mousePosition);
            RaycastHit hit;
            ifPhysics.Raycastray, out hit, Mathf.Infinity))
            {
                var worldHitPos = hit.point;
                var localHitPos = transform.InverseTransformPointworldHitPos);

                points.AddlocalHitPos);
                indexes.Addindex++);
            }
        }

        ifInput.GetKeyDownKeyCode.R))
        {
            this.Reset);
        }
    }

    private void Reset)
    {
        points.Clear);

        targetFilter.mesh = null;
        Destroymesh);
    }

    private void OnGUI)
    {
        if points.Count == 0) return;

        GUI.color = Color.red;

        forint i = 0; i < points.Count; ++i)
        {
            var worldPos = transform.TransformPointpoints[i]);
            var screenPos = Camera.main.WorldToScreenPointworldPos);
            var uiPos = new Vector3screenPos.x, Camera.main.pixelHeight - screenPos.y, screenPos.z);

            GUI.Labelnew RectuiPos, new Vector2100, 80)), i.ToString));
        }
    }

    private void OnDrawGizmos)
    {
        if points.Count == 0) return;

        Gizmos.color = Color.cyan;
        foreachvar pos in points)
        {
            var worldPos = transform.TransformPointpos);
            Gizmos.DrawWireSphereworldPos, .2f);
        }
    }
}

View Code

3.Triangulation.cs 三角剖分工具类

using UnityEngine;
using System.Collections.Generic;

/// <summary>
/// 三维模型重建中的凹多边形三角剖分，适用于不带空洞的凹多边形
/// ref: https://blog.csdn.net/huangzengman/article/details/77114082
/// </summary>
public static class Triangulation
{
    const double epsilon = 1e-7;

    static bool floatLessfloat value, float other)
    {
        return other - value) > epsilon;
    }

    static bool floatGreatfloat value, float other)
    {
        return value - other) > epsilon;
    }

    static bool floatEqualfloat value, float other)
    {
        return Mathf.Absvalue - other) < epsilon;
    }

    static bool Vector3EqualVector3 a, Vector3 b)
    {
        return floatEquala.x, b.x) && floatEquala.y, b.y) && floatEquala.z, b.z);
    }

    /// <summary>
    /// 凸多边形，顺时针序列，以第1个点来剖分三角形，如下：
    /// 0---1
    /// |   |
    /// 3---2  -->  0, 1, 2)、0, 2, 3)
    /// </summary>
    /// <param name="verts">顺时针排列的顶点列表</param>
    /// <param name="indexes">顶点索引列表</param>
    /// <returns>三角形列表</returns>
    public static List<int> ConvexTriangleIndexList<Vector3> verts, List<int> indexes)
    {
        int len = verts.Count;
        //若是闭环去除最后一点
        if len > 1 && Vector3Equalverts[0], verts[len - 1]))
        {
            len--;
        }
        int triangleNum = len - 2;
        List<int> triangles = new List<int>triangleNum * 3);
        for int i = 0; i < triangleNum; i++)
        {
            triangles.Addindexes[0]);
            triangles.Addindexes[i + 1]);
            triangles.Addindexes[i + 2]);
        }
        return triangles;
    }

    /// <summary>
    /// 三角剖分
    /// 1.寻找一个可划分顶点
    /// 2.分割出新的多边形和三角形
    /// 3.新多边形若为凸多边形，结束；否则继续剖分
    /// 
    /// 寻找可划分顶点
    /// 1.顶点是否为凸顶点：顶点在剩余顶点组成的图形外
    /// 2.新的多边形没有顶点在分割的三角形内
    /// </summary>
    /// <param name="verts">顺时针排列的顶点列表</param>
    /// <param name="indexes">顶点索引列表</param>
    /// <returns>三角形列表</returns>
    public static List<int> WidelyTriangleIndexList<Vector3> verts, List<int> indexes)
    {
        int len = verts.Count;
        if len <= 3) return ConvexTriangleIndexverts, indexes);

        int searchIndex = 0;
        List<int> covexIndex = new List<int>);
        bool isCovexPolygon = true;//判断多边形是否是凸多边形

        for searchIndex = 0; searchIndex < len; searchIndex++)
        {
            List<Vector3> polygon = new List<Vector3>verts.ToArray));
            polygon.RemoveAtsearchIndex);
            if IsPointInsidePolygonverts[searchIndex], polygon))
            {
                isCovexPolygon = false;
                break;
            }
            else
            {
                covexIndex.AddsearchIndex);
            }
        }

        if isCovexPolygon) return ConvexTriangleIndexverts, indexes);

        //查找可划分顶点
        int canFragementIndex = -1;//可划分顶点索引
        for int i = 0; i < len; i++)
        {
            if i > searchIndex)
            {
                List<Vector3> polygon = new List<Vector3>verts.ToArray));
                polygon.RemoveAti);
                if !IsPointInsidePolygonverts[i], polygon) && IsFragementIndexi, verts))
                {
                    canFragementIndex = i;
                    break;
                }
            }
            else
            {
                if covexIndex.IndexOfi) != -1 && IsFragementIndexi, verts))
                {
                    canFragementIndex = i;
                    break;
                }
            }
        }

        if canFragementIndex < 0)
        {
            Debug.LogError"数据有误找不到可划分顶点");
            return new List<int>);
        }

        //用可划分顶点将凹多边形划分为一个三角形和一个多边形
        List<int> tTriangles = new List<int>);
        int next = canFragementIndex == len - 1) ? 0 : canFragementIndex + 1;
        int prev = canFragementIndex == 0) ? len - 1 : canFragementIndex - 1;
        tTriangles.Addindexes[prev]);
        tTriangles.Addindexes[canFragementIndex]);
        tTriangles.Addindexes[next]);
        //剔除可划分顶点及索引
        verts.RemoveAtcanFragementIndex);
        indexes.RemoveAtcanFragementIndex);

        //递归划分
        List<int> leaveTriangles = WidelyTriangleIndexverts, indexes);
        tTriangles.AddRangeleaveTriangles);

        return tTriangles;
    }

    /// <summary>
    /// 是否是可划分顶点:新的多边形没有顶点在分割的三角形内
    /// </summary>
    private static bool IsFragementIndexint index, List<Vector3> verts)
    {
        int len = verts.Count;
        List<Vector3> triangleVert = new List<Vector3>);
        int next = index == len - 1) ? 0 : index + 1;
        int prev = index == 0) ? len - 1 : index - 1;
        triangleVert.Addverts[prev]);
        triangleVert.Addverts[index]);
        triangleVert.Addverts[next]);
        for int i = 0; i < len; i++)
        {
            if i != index && i != prev && i != next)
            {
                if IsPointInsidePolygonverts[i], triangleVert))
                {
                    return false;
                }
            }
        }
        return true;
    }

    /// <summary>
    /// 射线与线段相交性判断
    /// </summary>
    /// <param name="ray">射线</param>
    /// <param name="p1">线段头</param>
    /// <param name="p2">线段尾</param>
    /// <returns></returns>
    private static bool IsDetectIntersectRay2D ray, Vector3 p1, Vector3 p2)
    {
        float pointY;//交点Y坐标，x固定值
        if floatEqualp1.x, p2.x))
        {
            return false;
        }
        else iffloatEqualp1.y, p2.y))
        {
            pointY = p1.y;
        }
        else
        {
            //直线两点式方程：y-y2)/y1-y2) = x-x2)/x1-x2)
            float a = p1.x - p2.x;
            float b = p1.y - p2.y;
            float c = p2.y / b - p2.x / a;

            pointY = b / a * ray.origin.x + b * c;
        }
        
        if floatLesspointY, ray.origin.y))
        {
            //交点y小于射线起点y
            return false;
        }
        else
        {
            Vector3 leftP = floatLessp1.x, p2.x) ? p1 : p2;//左端点
            Vector3 rightP = floatLessp1.x, p2.x) ? p2 : p1;//右端点
            //交点x位于线段两个端点x之外，相交与线段某个端点时，仅将射线L与左侧多边形一边的端点记为焦点即就是：只将右端点记为交点)
            if !floatGreatray.origin.x, leftP.x) || floatGreatray.origin.x, rightP.x))
            {
                return false;
            }
        }

        return true;
    }

    /// <summary>
    /// 点与多边形的位置关系
    /// </summary>
    /// <param name="point">判定点</param>
    /// <param name="polygonVerts">剩余顶点按顺序排列的多边形</param>
    /// <returns>true:点在多边形之内，false:相反</returns>
    private static bool IsPointInsidePolygonVector3 point, List<Vector3> polygonVerts)
    {
        int len = polygonVerts.Count;
        Ray2D ray = new Ray2Dpoint, new Vector30, 1)); //y方向射线
        int interNum = 0;

        for int i = 1; i < len; i++)
        {
            if IsDetectIntersectray, polygonVerts[i - 1], polygonVerts[i]))
            {
                interNum++;
            }
        }

        //不是闭环
        if !Vector3EqualpolygonVerts[0], polygonVerts[len - 1]))
        {
            if IsDetectIntersectray, polygonVerts[len - 1], polygonVerts[0]))
            {
                interNum++;
            }
        }
        int remainder = interNum % 2;
        return remainder == 1;
    }
}