UnityCirclePacking

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


public class CirclePacking : MonoBehaviour {

    //public enum ScatterType { "Cat", "Sat", "Bat" }
    //public ScatterType ScatType = ScatterType.;
    //public enum Axis { X, Y }
    //public Axis axis = Axis.Y;
    public bool DoRadial = true;
    public float PopulationRadiusX = 20;
    public float PopulationRadiusZ = 10;
    //public Vector3 BoundEdges = new Vector3(10, 0, 20);
    public int CircleEmitAmnt = 100;
    public float MinCircleSize = 1f;
    public float SearchShrinkAmnt = 0.1f;
    public float MaxItterations = 1000;
    public float SearchRadiusOffset = 10;
    public LayerMask SceneCollisionLayer;
    public GameObject CircleObj;
    public bool DoDrawMesh = true;
    public Mesh TheDrawMeshBig;
    public Material DrawMeshMatBig;
    public Mesh TheDrawMeshMed;
    public Material DrawMeshMatMed;
    public Mesh TheDrawMeshSmall;
    public Material DrawMeshMatSmall;

    public int ItterationTrack = 0; // Tracks itterations when placing objects
    public bool DoGroundCollide = false;
    private List<CircleObject> CircleList = new List<CircleObject>();
    private Matrix4x4 MeshMatrix;
    class CircleObject
    {
        public CircleObject(GameObject CircleObjectObjInsert,  Vector3 PositionInsert)
        {
            //CircleObjectObj = CircleObjectObjInsert;
            //DrawMeshMesh = DrawMeshMeshInsert;
            Position = PositionInsert;
            StartPositoin = PositionInsert;
            //CircleObjectObj = (GameObject)Instantiate(CircleObjectObjInsert, Position, Quaternion.identity);// copy object
            //CircleObjectObj.transform.localScale = new Vector3(Radius, Radius, Radius); // Set start scale
            //CircleSprite = CircleObjectObj.GetComponentInChildren<SpriteRenderer>();
            //CircleSprite.color = new Color(Random.Range(0f, 1f), Random.Range(0f, 1f), Random.Range(0f, 1f), 1f);
        }
        public GameObject CircleObjectObj;
        //public SpriteRenderer CircleSprite;
        public Vector3 Position = Vector3.zero;
        public Vector3 StartPositoin = Vector3.zero;
        public float Radius = 0.05f;
        public float GrowSpeed = Random.Range(0.7f, 1.2f);
        public bool IsGrowing = true;
        public int NeiborCount = 0;
        public int RotationY = Random.Range(0, 360);
        //public Mesh DrawMeshMesh;

        public void DoGrow()
        {
            if (this.IsGrowing)
            {
                this.Radius += this.GrowSpeed * Time.deltaTime;
                //this.CircleObjectObj.transform.localScale = new Vector3(this.Radius*2f, this.Radius*2f, this.Radius*2f);
                //this.CircleObjectObj.transform.position = this.Position;
            }
        }

    }

    void NewCircle(Vector3 SpawnPos)
    {
        bool IsValid = true;
        //for(int i = 0; i < CircleList.Count; i ++)
        foreach (CircleObject circle in CircleList)
        {
            float Dist = Vector3.Distance(SpawnPos, circle.Position);
            if(Dist < circle.Radius + SearchRadiusOffset)
            {
                IsValid = false;
                ItterationTrack += 1;
            }
        }
        if (IsValid)
        {
            CircleObject NewCircle = new CircleObject(CircleObj, SpawnPos);
            //NewCircle.CircleObjectObj.transform.parent = transform;
            CircleList.Insert(0, NewCircle);
            ItterationTrack = 0;
        }

    }



    void NewRandomCircleRadial()
    {
        Vector3 SpawnPosition = Random.insideUnitSphere * PopulationRadiusX;
        SpawnPosition.x += transform.position.x;
        SpawnPosition.y = transform.position.y;
        SpawnPosition.z += transform.position.z;
        if (DoGroundCollide == true)
        {
            Vector3 HitPoint = RaySearcher(SpawnPosition);
            NewCircle(HitPoint);
        }
        else
        {
            NewCircle(SpawnPosition);
        }


    }
    void NewRandomCircle()
    {

        float RandomX = Random.Range(-PopulationRadiusX, PopulationRadiusX);
        float RandomZ = Random.Range(-PopulationRadiusZ, PopulationRadiusZ);
        RandomX += transform.position.x;
        RandomZ += transform.position.z;
        Vector3 SpawnPosition = new Vector3(RandomX, transform.position.y, RandomZ);

        if (DoGroundCollide == true)
        {
            Vector3 HitPoint = RaySearcher(SpawnPosition);
            NewCircle(HitPoint);
        }
        else
        {
            NewCircle(SpawnPosition);
        }
            //Vector3 GroundPos = new Vector3(circle.CircleObjectObj.transform.position.x, HitPoint.y - circle.Radius, circle.CircleObjectObj.transform.position.z);

    }
    void DoShow(CircleObject DrawCircle)
    {
        //CircleMat.SetPass(0);
        //Graphics.DrawMeshNow(TheDrawMesh, DrawCircle.Position, Quaternion.identity);
        //new Vector3(this.Radius*2f, this.Radius*2f, this.Radius*2f);
        Vector3 CircleScale = new Vector3(DrawCircle.Radius * 2f, DrawCircle.Radius * 2f, DrawCircle.Radius * 2f);
        //float OffsetYAmnt = new float();

        if (DoDrawMesh)
        {
            MeshMatrix = Matrix4x4.TRS(DrawCircle.Position, Quaternion.Euler(0,DrawCircle.RotationY,0), CircleScale);
            if (DrawCircle.Radius > 2)
            {
                Graphics.DrawMesh(TheDrawMeshBig, MeshMatrix, DrawMeshMatBig, 0);
            }

            else if (DrawCircle.Radius < 1)
            {
                Graphics.DrawMesh(TheDrawMeshSmall, MeshMatrix, DrawMeshMatMed, 0);
            }
            else
            {
                Graphics.DrawMesh(TheDrawMeshMed, MeshMatrix, DrawMeshMatSmall, 0);
            }
        }
        else
        {
            if(DrawCircle.CircleObjectObj == null)
            {
                DrawCircle.CircleObjectObj = (GameObject)Instantiate(CircleObj, DrawCircle.Position, Quaternion.identity, transform);// copy object
                DrawCircle.CircleObjectObj.transform.localScale = new Vector3(DrawCircle.Radius, DrawCircle.Radius, DrawCircle.Radius); // Set start scale
            }
            else
            {
                DrawCircle.CircleObjectObj.transform.localScale = new Vector3(DrawCircle.Radius*2f, DrawCircle.Radius*2f, DrawCircle.Radius*2f);
                //OffsetYAmnt = DrawCircle.StartPositoin.y + DrawCircle.Radius;
                //DrawCircle.Position.y = OffsetYAmnt;
                DrawCircle.CircleObjectObj.transform.position = DrawCircle.Position;

            }

        }

    }
    void GrowCircles()
    {
        foreach(CircleObject circle in CircleList)
        {

            DoShow(circle);
            if (circle.IsGrowing == true)
            {
                if (DoGroundCollide == true)
                {
                    /*
                    Vector3 HitPoint = RaySearcher(circle.Position);
                    Vector3 GroundPos = new Vector3(circle.CircleObjectObj.transform.position.x, HitPoint.y - circle.Radius, circle.CircleObjectObj.transform.position.z);
                    circle.CircleObjectObj.transform.position = GroundPos;
                    circle.Position = GroundPos;
                    */
                }
                foreach (CircleObject OtherCircle in CircleList)
                {
                    if(circle != OtherCircle)
                    {
                        float Dist = Vector3.Distance(circle.Position, OtherCircle.Position);
                        float RCheck = circle.Radius + OtherCircle.Radius;
                        if(Dist < RCheck)
                        {
                            circle.IsGrowing = false;
                        }
                    }
                }
            }
            circle.DoGrow();
        }

    }

    public Vector3 RaySearcher(Vector3 Pos)
    {
        Vector3 RayHitPoint= Vector3.zero;
        Vector3 rayDirection = new Vector3(0,-1,0);

        RaycastHit hit;
        //RaycastHit2D hit = Physics2D.Raycast(boid.position, Vector3.up, SearchCollisionDistance, SceneCollisionLayer);

        if (Physics.Raycast(Pos, rayDirection, out hit, 100f, SceneCollisionLayer))
        {
            RayHitPoint = hit.point;
            //Debug.DrawLine(hit.point, Pos, Color.red);
        }
        return RayHitPoint;
    }


    public Vector3 GetMouseForce()
    {
        Vector3 MouseHit = Vector3.zero;
        Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
        RaycastHit hit;
        if (Physics.Raycast(ray, out hit))
        {
            //hit.collider.GetComponent<Renderer>().material.color = Color.red;
            MouseHit = hit.point;
        }
        return MouseHit;
    }


    void Start () {


    }

    // Update is called once per frame
    void Update () {
        if (SearchRadiusOffset > MinCircleSize)
        {
            if (ItterationTrack < MaxItterations)
            {
                for (int i = 0; i < CircleEmitAmnt; i++)
                {
                    if (DoRadial)
                    {
                        NewRandomCircleRadial();
                    }
                    else
                    {
                        NewRandomCircle();
                    }
                }
            }
            else
            {
                SearchRadiusOffset -= SearchShrinkAmnt;
                ItterationTrack = 0;
            }

        }
        GrowCircles();
    }
}