oskarsigvardsson / unity-delaunay Goto Github PK

namespace GK
{
    public class VoronoiDestruction : MonoBehaviour
    {
        [Range(0, 1000)]
        public int points = 100;
        [Range(0.0f, 10.0f)]
        public float mean = 0;
        [Range(0.0f, 10.0f)]
        public float stddev = 0.2;

        Vector2[] sites;
        VoronoiDiagram diagram = new VoronoiDiagram();
        DelaunayTriangulation trig = new DelaunayTriangulation();

        void Start()
        {
            sites = new Vector2[points];
        }

        void OnDrawGizmos()
        {
            if (Application.isPlaying)
            {
                Gizmos.color = Color.green;
                if (sites.Length > 0)
                {
                    // Draw Voronoi sites.
                    for (int i = 0; i < sites.Length; i++)
                    {
                        Vector2 worldVert = transform.TransformPoint(sites[i]);
                        Gizmos.DrawSphere(new Vector3(worldVert.x, worldVert.y, 4), 0.01f);
                    }

                    // Draw Voronoi edges.
                    Gizmos.color = Color.red;
                    for (int i = 0; i < diagram.Edges.Count; i++)
                    {
                        VoronoiDiagram.Edge edge = diagram.Edges[i];
                        Vector2 worldVert = transform.TransformPoint(diagram.Vertices[edge.Vert0]);
                        if (edge.Type == VoronoiDiagram.EdgeType.RayCW || edge.Type == VoronoiDiagram.EdgeType.RayCCW)
                        {
                            //Vector2 worldDir = transform.TransformPoint(edge.Direction);
                            Vector2 worldDir = edge.Direction;
                            Gizmos.DrawRay(new Vector3(worldVert.x, worldVert.y, 4), new Vector3(worldDir.x, worldDir.y, 0));
                        }
                        else if (edge.Type == VoronoiDiagram.EdgeType.Segment)
                        {
                            Vector2 worldVert2 = transform.TransformPoint(diagram.Vertices[edge.Vert1]);
                            Gizmos.DrawLine(new Vector3(worldVert.x, worldVert.y, 4), new Vector3(worldVert2.x, worldVert2.y, 4));
                        }
                    }

                    // Draw Delaunay triangulation.
                    Gizmos.color = Color.blue;
                    for (int i = 0; i < trig.Triangles.Count; i += 3)
                    {
                        Vector2 worldVert1 = transform.TransformPoint(trig.Vertices[trig.Triangles[i]]);
                        Vector2 worldVert2 = transform.TransformPoint(trig.Vertices[trig.Triangles[i + 1]]);
                        Vector2 worldVert3 = transform.TransformPoint(trig.Vertices[trig.Triangles[i + 2]]);
                        Gizmos.DrawLine(new Vector3(worldVert1.x, worldVert1.y, 4), new Vector3(worldVert2.x, worldVert2.y, 4));
                        Gizmos.DrawLine(new Vector3(worldVert1.x, worldVert1.y, 4), new Vector3(worldVert3.x, worldVert3.y, 4));
                        Gizmos.DrawLine(new Vector3(worldVert2.x, worldVert2.y, 4), new Vector3(worldVert3.x, worldVert3.y, 4));
                    }
                }
            }
        }

        public void redrawDiagram(Vector3 pos)
        {
            Vector3 temp = transform.InverseTransformPoint(pos);
            Vector2 position = new Vector2(temp.x, temp.y);

            var calc = new VoronoiCalculator();

            sites = new Vector2[points];

            for (int i = 0; i < sites.Length; i++)
            {
                //var dist = Mathf.Abs(NormalizedRandom(10.0f, 1.0f / 2.0f));
                var dist = Mathf.Abs(NormalizedRandom(mean, stddev));
                var angle = 2.0f * Mathf.PI * Random.value;

                sites[i] = position + new Vector2(
                        dist * Mathf.Cos(angle),
                        dist * Mathf.Sin(angle));
            }

            diagram = calc.CalculateDiagram(sites);
            trig = diagram.Triangulation;
        }

        private float NormalizedRandom(float mean, float stddev)
        {
            var u1 = UnityEngine.Random.value;
            var u2 = UnityEngine.Random.value;

            var randStdNormal = Mathf.Sqrt(-2.0f * Mathf.Log(u1)) *
                Mathf.Sin(2.0f * Mathf.PI * u2);

            return mean + stddev * randStdNormal;
        }
    }
}

int FindTriangleNode(int pi) {
	var curr = 0;

	while (!triangles[curr].IsLeaf)
	{
		var t = triangles[curr];

		if (t.C0 >= 0 && PointInTriangle(pi, t.C0)) {
			curr = t.C0;
		} else if (t.C1 >= 0 && PointInTriangle(pi, t.C1)) {
			curr = t.C1;
		} else {
			curr = t.C2;
		}
	}
	return curr;
}

for(int i = 0; i < 10; ++i)
 {
     float dist = 0.4f;
     var angle = angleStep * i;

     sites[i] = position + new Vector2(
            dist * Mathf.Cos(angle),
            dist * Mathf.Sin(angle));
  }