Beispiel #1
0
        public static bool less(IndexedVertex a, IndexedVertex b)
        {
            if (a.Vertex.x - center.x >= 0 && b.Vertex.x - center.x < 0)
            {
                return(true);
            }
            if (a.Vertex.x - center.x < 0 && b.Vertex.x - center.x >= 0)
            {
                return(false);
            }
            if (a.Vertex.x - center.x == 0 && b.Vertex.x - center.x == 0)
            {
                if (a.Vertex.z - center.z >= 0 || b.Vertex.z - center.z >= 0)
                {
                    return(a.Vertex.z > b.Vertex.z);
                }
                return(b.Vertex.z > a.Vertex.z);
            }

            // compute the cross product of vectors (center -> a) x (center -> b)
            var det = (a.Vertex.x - center.x) * (b.Vertex.z - center.z) - (b.Vertex.x - center.x) * (a.Vertex.z - center.z);

            if (det < 0)
            {
                return(true);
            }
            if (det > 0)
            {
                return(false);
            }

            // points a and b are on the same line from the center
            // check which point is closer to the center
            var d1 = (a.Vertex.x - center.x) * (a.Vertex.x - center.x) + (a.Vertex.z - center.z) * (a.Vertex.z - center.z);
            var d2 = (b.Vertex.x - center.x) * (b.Vertex.x - center.x) + (b.Vertex.z - center.z) * (b.Vertex.z - center.z);

            return(d1 > d2);
        }
Beispiel #2
0
        private List <int> TriangulateBorder(List <int> borderIndicies, List <Vector3> Points, Vector3 PlaneNormal)
        {
            var res           = new List <int>();
            var centerPoint   = new Vector3();
            var rotatedPoints = new List <IndexedVertex>(borderIndicies.Count);

            for (int i = 0; i < borderIndicies.Count; i++)
            {
                centerPoint += Points[borderIndicies[i]];
                rotatedPoints.Add(new IndexedVertex()
                {
                    Index = borderIndicies[i], Vertex = Points[borderIndicies[i]]
                });
            }
            centerPoint        /= borderIndicies.Count;
            Triangulator.center = centerPoint;

            var rotation = Quaternion.FromToRotation(PlaneNormal, Vector3.up);

            for (int i = 0; i < rotatedPoints.Count; i++)
            {
                var rotated = RotatePointArroundOrigin(rotatedPoints[i].Vertex, centerPoint, rotation);
                rotatedPoints[i] = new IndexedVertex()
                {
                    Index = rotatedPoints[i].Index, Vertex = rotated
                };
            }

            rotatedPoints.Sort(new IndexedVertexComparator());
            var rotatedTris = Triangulator.Triangulate(rotatedPoints);

            for (int i = 0; i < rotatedPoints.Count - 2; i++)
            {
                res.AddRange(new int[] { rotatedPoints[0].Index, rotatedPoints[i + 1].Index, rotatedPoints[i + 2].Index });
            }

            return(res);
        }