Sunstealer DynamicLight

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

public class DynamicLight : MonoBehaviour
{
    [Header("Generation")]
    public int precision = 720;
    public bool rotationOffset;
    public enum Shapes // your custom enumeration
    {
        Linear,
        Circle
    };

    public Shapes shape = Shapes.Circle;

    public float angle = 360;
    public float width = 1;

    /* Dégradé intégré
    public Gradient colors = new Gradient();
    public float colorsLoopInSeconds = 0;
    private float colorTime;
    */


    //public float distanceMin = 1;
    //public float distanceMax = 1;
    public float distance;

    [Header("Render")]
    public Color color;
    public float intensity = 0.1f;
    public Texture texture;

    public LayerMask LightLayer;
    public LayerMask colliderLayer;
    public LayerMask lighttest;



    [Header("Variables")]
    Vector2 velocity;
    private List<Vector2> points;
    private List<Vector3> vertices;
    private int[] triangles;
    private int uid;
    private Vector3 rotOffset;
    Light objLight;
    Camera objCam;



    //[ConditionalField("orientation", Shape.Circular)] public float angle = 2;
    //public float length;

    float DegToPi(float deg)
    {
        return deg * 1 / 180;
    }

    float PiToDeg(float pi)
    {
        return pi * 180;
    }

    private void Awake()
    {
        //We check if the setup is good
        if (LightLayer == 0)
            Debug.LogError("Please assign a layer for the light");
        if (colliderLayer== 0)
            Debug.LogError("Please assign a layer for the obstacles");

        if (LightLayer != (LightLayer | (1 << gameObject.layer)))
            Debug.LogError("Please the layer of light's gameObject must be the same of the LightLayer variable");

        if (precision <= 0)
            precision = 1;
    }


    private void Start()
    {
        Debug.LogWarning("Corrigé lighttest !");
        Debug.LogWarning("Editeur!");
        Debug.LogWarning("Material !");
        uid = Random.Range(0, 1000);
        //shootRay(precision);

        //We set the offset
        if (rotationOffset)
            rotOffset = transform.eulerAngles;
        else
            rotOffset = Vector3.zero;

        //We add the needed components
        if (!transform.GetComponent<MeshFilter>())
            gameObject.AddComponent<MeshFilter>();
        if (!transform.GetComponent<MeshRenderer>())
            gameObject.AddComponent<MeshRenderer>();

        //colorTime = colorsLoopInSeconds; Dégradé

        //We create the render object
        CreateRenderer();
    }

    private void Update()
    {
       // Debug.Log(transform.parent.transform.eulerAngles.z);
       // Debug.Log("cos: " + Mathf.Cos(DegToPi(transform.parent.transform.eulerAngles.z)) + " sin: " + Mathf.Sin(DegToPi(transform.parent.transform.eulerAngles.z)));

        //We avoid some errors
        if (angle > 360)
            angle = angle - 360;
        if (angle < 0)
            angle = 0;

        //We start the calculation of collision
        if (shape == Shapes.Circle)
            shootRayCircle((int)(precision*angle));
        else
            shootRayLine(precision);


        /* Dégradé intégré
        if (colorTime <= 0)
            colorTime = colorsLoopInSeconds;
        else
        {
            colorTime -= Time.deltaTime;
        }

        float timeStop = colorsLoopInSeconds - colorTime;
        float timeStopCoord =  timeStop / colorsLoopInSeconds;
        color = colors.Evaluate(timeStopCoord);
        */

    }

    private void LateUpdate()
    {
        //We update the light with the parent
        transform.localPosition = new Vector3(0, 0, 0 + uid);
        transform.localEulerAngles = new Vector3(transform.parent.transform.eulerAngles.x, transform.parent.transform.eulerAngles.y, -transform.parent.transform.eulerAngles.z);

        //We update the renderer (in case of color change or others variables)
        updateRenderer();
    }




    void OnDrawGizmosSelected()
    {
        // Draw a yellow sphere at the transform's position
        Gizmos.color = Color.blue;
        Gizmos.DrawSphere(transform.position, 0.1f);


        Gizmos.color = Color.yellow;
        if (EditorApplication.isPlaying)
        {
            for (int i = 0; i < vertices.Count; i++)
            {

                // Gizmos.DrawSphere(transform.TransformPoint(new Vector3(vertices[i].x, vertices[i].y, 0)), 0.05f);
                Handles.color = Color.yellow;
                Handles.Label(new Vector3(vertices[i].x, vertices[i].y, 0), i.ToString());
            }


            Gizmos.color = new Color(0.9f, 0.4f, 0.55f);
            for (int i = 0; i < points.Count; i++)
            {
              //  Gizmos.DrawSphere(transform.TransformPoint(new Vector3(points[i].x, points[i].y, 0)), 0.03f);

            }
        }
    }


    void shootRayCircle(int n)
    {
        /* Variation distance
        if (distanceMax - distanceMin > 0)
        {
            distance = distanceMin + (Mathf.PingPong(Time.time * 0.5f, distanceMax - distanceMin));
        }
        else
        {
            distance = distanceMin;
        }
        */
        points = new List<Vector2>();
        for (int i = 0; i <= n; i++)
        {
            float a = transform.parent.transform.eulerAngles.z + rotOffset.z;
            float offset = (DegToPi(-a)* Mathf.PI) - DegToPi(1.5f * angle);
            //DegToPi(-transform.eulerAngles.z * Mathf.PI)


            float x = Mathf.Sin(((DegToPi(angle) * Mathf.PI * i) / n) + offset) * distance;
            float y = Mathf.Cos(((DegToPi(angle) * Mathf.PI * i) / n) + offset) * distance;
            RaycastHit2D hit = Physics2D.Linecast(transform.position, new Vector2(transform.position.x + x, transform.position.y + y), colliderLayer);
            Debug.DrawLine(transform.position, new Vector2(transform.position.x + x, transform.position.y + y), new Color(0.8f, 0,0));
           Vector2 obj = new Vector2(x,y);
            if (hit.collider != null)
            {

                if (Vector2.Distance(transform.position, hit.transform.position) < distance * Mathf.PI)
                {
                    obj = transform.InverseTransformPoint(new Vector2(hit.point.x, hit.point.y));
                }
            }

            points.Add(obj);

        }

        GenerateMesh();

    }

    void shootRayLine(int precision)
    {
        points = new List<Vector2>();
        for (float y = 0; y < distance; y += (float)distance / (10f * (float)precision))
        {
            float x = distance;
            RaycastHit2D hit = Physics2D.Linecast(new Vector2(transform.position.x, transform.position.y+y), new Vector2(transform.position.x + x, transform.position.y + y), colliderLayer);
            Debug.DrawLine(new Vector2(transform.position.x, transform.position.y+y), new Vector2(transform.position.x + x, transform.position.y + y), new Color(0.8f, 0, 0));
            Vector2 obj = new Vector2(x, y);
            if (hit.collider != null)
            {

                if (Vector2.Distance(transform.position, hit.transform.position) < distance * Mathf.PI)
                {
                    obj = transform.InverseTransformPoint(new Vector2(hit.point.x, hit.point.y));
                }
            }

            points.Add(obj);
        }
        for (float x = width; x > -width; x-=(float)width/(10f*(float)precision))
        {
            float y = distance;
            RaycastHit2D hit = Physics2D.Linecast(new Vector2(transform.position.x+x, transform.position.y), new Vector2(transform.position.x + x, transform.position.y + y), colliderLayer);
            Debug.DrawLine(new Vector2(transform.position.x+x, transform.position.y), new Vector2(transform.position.x + x, transform.position.y + y), new Color(0.8f, 0, 0));
            Vector2 obj = new Vector2(x, y);
            if (hit.collider != null)
            {

                if (Vector2.Distance(transform.position, hit.transform.position) < distance * Mathf.PI)
                {
                    obj = transform.InverseTransformPoint(new Vector2(hit.point.x, hit.point.y));
                }
            }

            points.Add(obj);
        }
        for (float y = distance; y > 0; y -= (float)distance / (10f * (float)precision))
        {
            float x = -distance;
            RaycastHit2D hit = Physics2D.Linecast(new Vector2(transform.position.x, transform.position.y + y), new Vector2(transform.position.x + x, transform.position.y + y), colliderLayer);
            Debug.DrawLine(new Vector2(transform.position.x, transform.position.y + y), new Vector2(transform.position.x + x, transform.position.y + y), new Color(0.8f, 0, 0));
            Vector2 obj = new Vector2(x, y);
            if (hit.collider != null)
            {

                if (Vector2.Distance(transform.position, hit.transform.position) < distance * Mathf.PI)
                {
                    obj = transform.InverseTransformPoint(new Vector2(hit.point.x, hit.point.y));
                }
            }

            points.Add(obj);
        }

        GenerateMesh();
    }

    void GenerateMesh()
    {
        Mesh mesh = new Mesh();
        //mesh.c
        vertices = new List<Vector3>();
        vertices.Add(transform.InverseTransformPoint(transform.position));
        //vertices.Add(new Vector3(transform.position.x, transform.position.y, transform.position.z +uid));
        for (int i = 1; i < points.Count + 1; i++)
        {

            if (i > 1 && i < points.Count + 2)
            {

                if (new Vector2(Mathf.Round(points[i-2].x *10), Mathf.Round(points[i - 2].y * 10)) != new Vector2(Mathf.Round(vertices[vertices.Count -1].x*10), Mathf.Round(vertices[vertices.Count - 1].y * 10)))
                {
                    vertices.Add(new Vector3(points[i - 1].x, points[i - 1].y, 0));
                }
            }else
            {
                vertices.Add(new Vector3(points[i - 1].x, points[i - 1].y, 0));
            }
        }
        if (angle == 360)
        vertices.Add(new Vector3(points[0].x, points[0].y, 0));

        //Debug.Log(points.Count);
        //Debug.Log(vertices.Count);


        mesh.vertices = vertices.ToArray();

        // int[] triangles = new int[9] { 0, 1, 1, 2, 2, 3, 3, 4, 4};
        //mesh.triangles = triangles;

        triangles = new int[vertices.Count * 3 - 3];
        for (int i = 0; i < vertices.Count - 2; i++)
        {
            // Debug.Log(i + "|" + vertices.Count);
            if (i == 0)
            {

                triangles[i * 3] = 0;
                triangles[i * 3 + 1] = 1;
                triangles[i * 3 + 2] = 2;
            }
            else
            {
                triangles[i * 3] = 0;
                triangles[i * 3 + 1] = i + 1;
                triangles[i * 3 + 2] = i + 2;
            }
        }
       // triangles[(vertices.Count - 1) * 3 - 3] = vertices.Count - 2;
        //triangles[(vertices.Count - 1) * 3 - 2] = vertices.Count - 1;
        //triangles[(vertices.Count - 1) * 3 - 1] = 0;
        mesh.triangles = triangles;
        //this is also acceptable!
        //mesh.SetTriangles(new int[9]{0,1,2,3,4,3,2,1,0}, 0);

        Vector2[] uvs = new Vector2[vertices.Count];
        for (int i = 0; i < vertices.Count; i++)
        {
            //uvs[i] = new Vector2(vertices[i].x - transform.position.x, vertices[i].y - transform.position.y);
            uvs[i] = vertices[i];
        }


        mesh.uv = uvs;

        Vector3[] normals = new Vector3[vertices.Count];
        for (int i = 0; i < vertices.Count; i++)
        {
            normals[i] = Vector3.back;
        }
        mesh.normals = normals;

        //you could also call this instead...
        //mesh.RecalculateNormals();


        //grab our filter.. set the mesh
        mesh.name = transform.parent.name;
        MeshFilter filter = GetComponent<MeshFilter>();
        filter.mesh = mesh;
        //filter.sharedMesh.

        //you can do your material stuff here...
        MeshRenderer r = GetComponent<MeshRenderer>();
        Material m = r.material;
        float scale = 0.5f / distance;
        m.mainTextureScale = new Vector2(scale, scale);
        m.mainTexture = texture;
    }


    void CreateRenderer()
    {
        // GameObject objPrefab = new GameObject();
        GameObject obj = new GameObject();
        obj.transform.parent = transform.parent;
        obj.name = transform.parent.name + "LightRenderer";
        obj.transform.localPosition = new Vector3(0, 0, uid - 1);
        objCam = obj.AddComponent<Camera>();
        objCam.clearFlags = CameraClearFlags.SolidColor;
        objCam.nearClipPlane = 0;
        objCam.farClipPlane = 1;
        objCam.backgroundColor = new Color(0,0,0,0);
        objCam.cullingMask = LightLayer;
        objCam.orthographic = true;
        //objCam.fieldOfView = 60;
        objCam.orthographicSize = distance + 1;

        RenderTexture lightRenderTexture = new RenderTexture(4000, 4000, 0, RenderTextureFormat.ARGB32);
        lightRenderTexture.Create();
        lightRenderTexture.name = transform.parent.name + "Light";
        objCam.targetTexture = lightRenderTexture;

        objLight = obj.AddComponent<Light>();
        objLight.type = LightType.Directional;
        objLight.range = 11;
        objLight.intensity = intensity;
        objLight.cookie = lightRenderTexture;
        objLight.cookieSize = (distance+1)*2;



        objLight.color = color;
        Debug.LogError("Ici le lightest");
        //objLight.cullingMask = 311;

    }

    void updateRenderer()
    {
        objCam.orthographicSize = distance + 1;
        objLight.intensity = intensity;
        objLight.color = color;
    }


}