DiviedPolygon

DiviedPolygon.cs

        public class Triangle
        {
            public Vector3[] vertices { get; protected set; }

            public Triangle(Vector3 vtx0, Vector3 vtx1, Vector3 vtx2)
            {
                vertices = new[] { vtx0, vtx1, vtx2 };
            }

            public int GetLongestSideIdx()
            {
                var ret = 0;
                var sqrMagLongest = 0f;
                for (var i = 0; i < 3; ++i)
                {
                    var vtx0 = vertices[i];
                    var vtx1 = vertices[(i + 1) % 3];

                    var sqrMag = (vtx0 - vtx1).sqrMagnitude;
                    if (sqrMag > sqrMagLongest)
                    {
                        sqrMagLongest = sqrMag;
                        ret = i;
                    }
                }

                return ret;
            }
        }

        protected static Mesh DevidePolygon(Mesh mesh, float maxSideLength)
        {
            var vertices = mesh.vertices;
            var trianges = mesh.triangles;
            var newVertices = new List<Vector3>(mesh.vertices.Length);

            for (var i = 0; i < mesh.triangles.Length; i += 3)
            {
                var idx0 = trianges[i];
                var idx1 = trianges[i + 1];
                var idx2 = trianges[i + 2];


                DevidePolygon(
                    new Triangle(
                        vertices[idx0],
                        vertices[idx1],
                        vertices[idx2]
                    ),
                    newVertices,
                    maxSideLength
                    );
            }

            mesh.vertices = newVertices.ToArray();
            mesh.triangles = Enumerable.Range(0, mesh.vertices.Length).ToArray();

            return mesh;
        }

        protected static void DevidePolygon(Triangle triagnle, List<Vector3> outputVetices, float maxSideLength)
        {
            var sideIdx = triagnle.GetLongestSideIdx();
            var vtxs = triagnle.vertices;

            var v0 = vtxs[sideIdx];
            var v1 = vtxs[(sideIdx + 1) % 3];
            var v2 = vtxs[(sideIdx + 2) % 3];
            if (Vector3.Distance(v0, v1) > maxSideLength)
            {
                var v3 = (v0 + v1) * 0.5f;
                DevidePolygon(new Triangle(v0, v3, v2), outputVetices, maxSideLength);
                DevidePolygon(new Triangle(v3, v1, v2), outputVetices, maxSideLength);
            }
            else
            {
                var startIdx = outputVetices.Count;
                outputVetices.Add(vtxs[0]);
                outputVetices.Add(vtxs[1]);
                outputVetices.Add(vtxs[2]);
            }
        }