using UnityEngine;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.AddressableAssets;
using System.Collections;

public class ConstructBloc : MonoBehaviour
{
    //static Texture2D AddressableTexture;
    static bool isOnCeilling;

    public static void AddBloc(int nO)
    {
        GameObject.Find("HIDER").transform.Find("LoadingCircle").gameObject.SetActive(true);
        string[] C = _G.OBJs[nO];
        //Addbloc();
        print("C[41]=====" + C[41]);//C[41]=====none?#737373?#ffffffff?#ffffffff?1?0?0.1?0.05   
        Material MAT = UIT_MATERIAL.GetMaterial(C[41]);
        C[41] = C[41].Replace(",", "?");
        MAT.name = C[41].Split("?")[0];
        GameObject BASE = GameObject.CreatePrimitive(PrimitiveType.Cube);
        BASE.name = C[0];
        if (C[41].Split("?").Length > 3 && MAT.name != "MELAMINEWHITE" && MAT.name != "none")
        {
            StaticCoroutine.Start(GORETURN(BASE, MAT, nO));
        }
        else
        {
            AddblocToScene(BASE, MAT, nO);
            GameObject.Find("HIDER").transform.Find("LoadingCircle").gameObject.SetActive(false);
        }
    }
    public static void AddblocToScene(GameObject BASE, Material MAT,int nO)
    {
        string[] C = _G.OBJs[nO];
        float w = DOIT.ConvertStringToNumber(C[6]);
        float h = DOIT.ConvertStringToNumber(C[7]);
        float d = DOIT.ConvertStringToNumber(C[8]);
        float px = DOIT.ConvertStringToNumber(C[15]);
        float py = DOIT.ConvertStringToNumber(C[16]);
        float pz = DOIT.ConvertStringToNumber(C[17]);
        float rx = DOIT.ConvertStringToNumber(C[18]);
        float ry = DOIT.ConvertStringToNumber(C[19]);
        float rz = DOIT.ConvertStringToNumber(C[20]);

        isOnCeilling = C[22] == "ceil";
        if (py > _G.HEIGHT * 0.5f - 24) isOnCeilling = true;

        //create block
        BASE.transform.localScale = new(w + 0.5f, h + 0.5f, d + 0.5f);
        BASE.GetComponent<MeshRenderer>().shadowCastingMode = 0;
        //BASE.name = C[0];
        // BLOC118 (gaz) / BLOC119 (plomberie) : reperes de sortie murale. Meme boitier
        // rectangulaire que BLOC101-107, mais la couleur est imposee par le modele
        // (orange / bleu) au lieu de suivre C[41], et un pictogramme est colle sur la face avant.
        string SignIcon = "";
        if (C[1] == "BLOC118") SignIcon = "ICONS/Bloc/Gaz";
        if (C[1] == "BLOC119") SignIcon = "ICONS/Bloc/Plumbing";
        if (SignIcon != "")
        {
            MAT = UIT_MATERIAL.GetMaterial((C[1] == "BLOC118" ? "F07800" : "1E64C8") + "_Matt_none");
        }

        if (Get.Bool(C[1], "BLOC101_BLOC102_BLOC103_BLOC104_BLOC105_BLOC106_BLOC107_BLOC118_BLOC119"))
        {
            GameObject top = CreateMcx("top", w, d, 1, 0, h / 2, 0, 90, 0, 0,MAT); top.transform.SetParent(BASE.transform);
            GameObject front = CreateMcx("front", w, h, 1, 0, 0, -d / 2, 0, 0, 0,MAT); front.transform.SetParent(BASE.transform);
            GameObject left = CreateMcx("left", d, h, 1, -w / 2, 0, 0, 0, 90, 0,MAT); left.transform.SetParent(BASE.transform);
            GameObject back = CreateMcx("back", w, h, 1, 0, 0, d / 2, 0, 180, 0,MAT); back.transform.SetParent(BASE.transform);
            GameObject right = CreateMcx("right", d, h, 1, w / 2, 0, 0, 0, -90, 0,MAT); right.transform.SetParent(BASE.transform);
            GameObject under = CreateMcx("under", w, d, 1, 0, -h / 2, 0, -90, 0, 0,MAT); under.transform.SetParent(BASE.transform);

            // Pictogramme : quad legerement en avant de la face avant, meme orientation qu'elle.
            if (SignIcon != "")
            {
                GameObject sign = CreateSign(SignIcon, w * 0.8f, h * 0.8f, 0, 0, -d / 2 - 0.1f);
                sign.transform.SetParent(BASE.transform);
            }
        }
        if (C[1] == "BLOC108")
        {
            w = Mathf.Abs(w);
            Vector3 P1 = new(-w / 2, h / 2, -d / 2);
            Vector3 P2 = new(-w / 2, h / 2, d / 2);
            Vector3 P3 = new(w / 2, h / 2, d / 2);
            Vector3 P4 = new(-w / 2, -h / 2, -d / 2);
            Vector3 P5 = new(-w / 2, -h / 2, d / 2);
            Vector3 P6 = new(w / 2, -h / 2, d / 2);
            Vector3 P0 = new(0, 0, 0);
            GameObject top = CreateFace("top", P1, P2, P3, P0,MAT); top.transform.SetParent(BASE.transform);
            GameObject left = CreateFace("left", P5, P2, P1, P4,MAT); left.transform.SetParent(BASE.transform);
            GameObject back = CreateFace("back", P6, P3, P2, P5,MAT); back.transform.SetParent(BASE.transform);
            GameObject right = CreateFace("right", P4, P1, P3, P6,MAT); right.transform.SetParent(BASE.transform);
            GameObject under = CreateFace("under", P4, P6, P5, P0,MAT); under.transform.SetParent(BASE.transform);
        }
        if (C[1] == "BLOC109")
        {
            w = Mathf.Abs(w);
            Vector3 P1 = new(w / 2, h / 2, -d / 2);
            Vector3 P2 = new(-w / 2, h / 2, d / 2);
            Vector3 P3 = new(w / 2, h / 2, d / 2);
            Vector3 P4 = new(w / 2, -h / 2, -d / 2);
            Vector3 P5 = new(-w / 2, -h / 2, d / 2);
            Vector3 P6 = new(w / 2, -h / 2, d / 2);
            Vector3 P0 = new(0, 0, 0);
            GameObject top = CreateFace("top", P1, P2, P3, P0,MAT); top.transform.SetParent(BASE.transform);
            GameObject left = CreateFace("left", P5, P2, P1, P4,MAT); left.transform.SetParent(BASE.transform);
            GameObject back = CreateFace("back", P6, P3, P2, P5,MAT); back.transform.SetParent(BASE.transform);
            GameObject right = CreateFace("right", P4, P1, P3, P6,MAT); right.transform.SetParent(BASE.transform);
            GameObject under = CreateFace("under", P4, P6, P5, P0,MAT); under.transform.SetParent(BASE.transform);
        }
        if (C[1] == "BLOC110")
        {
            w = Mathf.Abs(w);
            Vector3 P1 = new(-w / 2, -h / 2, -d / 2);
            Vector3 P2 = new(-w / 2, h / 2, d / 2);
            Vector3 P3 = new(w / 2, h / 2, d / 2);
            Vector3 P4 = new(w / 2, -h / 2, -d / 2);

            Vector3 P5 = new(-w / 2, -h / 2, d / 2);
            Vector3 P6 = new(w / 2, -h / 2, d / 2);
            Vector3 P0 = new(0, 0, 0);
            GameObject top = CreateFace("top", P1, P2, P3, P4,MAT); top.transform.SetParent(BASE.transform);
            GameObject left = CreateFace("left", P5, P2, P1, P0,MAT); left.transform.SetParent(BASE.transform);
            GameObject back = CreateFace("back", P6, P3, P2, P5,MAT); back.transform.SetParent(BASE.transform);
            GameObject right = CreateFace("right", P4, P3, P6, P0,MAT); right.transform.SetParent(BASE.transform);
            GameObject under = CreateFace("under", P5, P1, P4, P6,MAT); under.transform.SetParent(BASE.transform);
        }
        if (C[1] == "BLOC111")
        {
            w = Mathf.Abs(w);
            Vector3 P1 = new(-w / 2, h / 2, -d / 2);
            Vector3 P2 = new(-w / 2, h / 2, d / 2);
            Vector3 P3 = new(w / 2, h / 2, d / 2);
            Vector3 P4 = new(w / 2, h / 2, -d / 2);

            Vector3 P5 = new(-w / 2, -h / 2, d / 2);
            Vector3 P6 = new(w / 2, -h / 2, d / 2);
            Vector3 P0 = new(0, 0, 0);
            GameObject top = CreateFace("top", P1, P2, P3, P4,MAT); top.transform.SetParent(BASE.transform);
            GameObject left = CreateFace("left", P5, P2, P1, P0,MAT); left.transform.SetParent(BASE.transform);
            GameObject back = CreateFace("back", P6, P3, P2, P5,MAT); back.transform.SetParent(BASE.transform);
            GameObject right = CreateFace("right", P4, P3, P6, P0,MAT); right.transform.SetParent(BASE.transform);
            GameObject under = CreateFace("under", P5, P1, P4, P6,MAT); under.transform.SetParent(BASE.transform);
        }
        if (C[1] == "BLOC112")
        {
            float r = DOIT.ConvertStringToNumber(C[9]);
            if (r > w) r = w;
            if (r > d) r = d;
            GameObject Cylinder = Instantiate(Resources.Load("OBJECTS/BLOCS/CylinderQuarter", typeof(GameObject))) as GameObject;

            float wc = r; float dc = d - r;
            GameObject Cube1 = CreateCube("Cube1", wc, h, dc,MAT);
            Cube1.transform.position = new(-w * 0.5f + wc * 0.5f, 0, d * 0.5f - dc * 0.5f);

            wc = w - r; dc = d - r;
            GameObject Cube2 = CreateCube("Cube2", wc, h, dc,MAT);
            Cube2.transform.position = new(w * 0.5f - wc * 0.5f, 0, d * 0.5f - dc * 0.5f);

            wc = w - r; dc = r;
            GameObject Cube3 = CreateCube("Cube2", wc, h, dc,MAT);
            Cube3.transform.position = new(w * 0.5f - wc * 0.5f, 0, -d * 0.5f + dc * 0.5f);

            //Cylinder.transform.localScale=new(r,h*0.5f,r);
            GameObject Cyl1 = CreateCylinder(Cylinder, "Cyl1", r, h,MAT);
            Cyl1.transform.position = new(-w * 0.5f + r * 0.5f, 0, -d * 0.5f + r * 0.5f);
            Cyl1.transform.localRotation = Quaternion.Euler(0, -90, 0);

            Cube1.transform.SetParent(BASE.transform);
            Cube2.transform.SetParent(BASE.transform);
            Cube3.transform.SetParent(BASE.transform);
            Cyl1.transform.SetParent(BASE.transform);
            Destroy(Cylinder);
        }
        if (C[1] == "BLOC113")
        {
            float r = DOIT.ConvertStringToNumber(C[9]);
            if (r > w * 0.5f) r = w * 0.5f;
            if (r > d) r = d;
            GameObject Cylinder = Instantiate(Resources.Load("OBJECTS/BLOCS/CylinderQuarter", typeof(GameObject))) as GameObject;

            float wc = w - r * 2; float dc = r;
            GameObject Cube1 = CreateCube("Cube1", wc, h, dc,MAT);
            Cube1.transform.position = new(0, 0, -d * 0.5f + dc * 0.5f);

            wc = w; dc = d - r;
            GameObject Cube2 = CreateCube("Cube2", wc, h, dc,MAT);
            Cube2.transform.position = new(0, 0, d * 0.5f - dc * 0.5f);

            GameObject Cyl1 = CreateCylinder(Cylinder, "Cyl1", r, h,MAT);
            Cyl1.transform.position = new(-w * 0.5f + r * 0.5f, 0, -d * 0.5f + r * 0.5f);
            Cyl1.transform.localRotation = Quaternion.Euler(0, -90, 0);

            GameObject Cyl2 = CreateCylinder(Cylinder, "Cyl2", r, h,MAT);
            Cyl2.transform.position = new(w * 0.5f - r * 0.5f, 0, -d * 0.5f + r * 0.5f);
            Cyl2.transform.localRotation = Quaternion.Euler(0, 180, 0);

            Cube1.transform.SetParent(BASE.transform);
            Cube2.transform.SetParent(BASE.transform);
            Cyl1.transform.SetParent(BASE.transform);
            Cyl2.transform.SetParent(BASE.transform);

            Destroy(Cylinder);
        }
        if (C[1] == "BLOC114")
        {
            float r = DOIT.ConvertStringToNumber(C[9]);
            if (r > w * 0.5f) r = w * 0.5f;
            if (r > d * 0.5f) r = d * 0.5f;
            GameObject Cylinder = Instantiate(Resources.Load("OBJECTS/BLOCS/CylinderQuarter", typeof(GameObject))) as GameObject;

            float wc = w - r * 2; float dc = d;
            GameObject Cube1 = CreateCube("Cube1", wc, h, dc,MAT);
            Cube1.transform.position = new(0, 0, 0);

            wc = w; dc = d - r * 2;
            GameObject Cube2 = CreateCube("Cube2", wc, h, dc,MAT);
            Cube2.transform.position = new(0, 0, 0);

            GameObject Cyl1 = CreateCylinder(Cylinder, "Cyl1", r, h,MAT);
            Cyl1.transform.position = new(-w * 0.5f + r * 0.5f, 0, -d * 0.5f + r * 0.5f);
            Cyl1.transform.localRotation = Quaternion.Euler(0, -90, 0);

            GameObject Cyl2 = CreateCylinder(Cylinder, "Cyl2", r, h,MAT);
            Cyl2.transform.position = new(w * 0.5f - r * 0.5f, 0, -d * 0.5f + r * 0.5f);
            Cyl2.transform.localRotation = Quaternion.Euler(0, 180, 0);

            GameObject Cyl3 = CreateCylinder(Cylinder, "Cyl3", r, h,MAT);
            Cyl3.transform.position = new(-w * 0.5f + r * 0.5f, 0, d * 0.5f - r * 0.5f);
            Cyl3.transform.localRotation = Quaternion.Euler(0, 0, 0);

            GameObject Cyl4 = CreateCylinder(Cylinder, "Cyl4", r, h,MAT);
            Cyl4.transform.position = new(w * 0.5f - r * 0.5f, 0, d * 0.5f - r * 0.5f);
            Cyl4.transform.localRotation = Quaternion.Euler(0, 90, 0);

            Cube1.transform.SetParent(BASE.transform);
            Cube2.transform.SetParent(BASE.transform);
            Cyl1.transform.SetParent(BASE.transform);
            Cyl2.transform.SetParent(BASE.transform);
            Cyl3.transform.SetParent(BASE.transform);
            Cyl4.transform.SetParent(BASE.transform);

            Destroy(Cylinder);
        }
        if (C[1] == "BLOC115")
        {
            GameObject Cyl = CreateCylinderPrimitif("Cylinder", w, d, h,MAT);
            Cyl.transform.SetParent(BASE.transform);
        }
        if (C[1] == "BLOC116")
        {
            GameObject Cyl = CreateCylinderPrimitif_90("Cylinder", w, h, d,MAT);
            Cyl.transform.SetParent(BASE.transform);
        }
        if (C[1] == "BLOC117")
        {
            float wallWidth = w;
            float sL = 0f, sR = 0f; // front-face setbacks at left/right ends (miter cuts)

            if (C[22].Length > 1 && C[22][0] == 'w' && int.TryParse(C[22][1..], out int wn) && wn >= 1 && wn <= _G.WallsWidth.Count)
            {
                wallWidth = _G.WallsWidth[wn - 1];
                GameObject wallObj = Get.o1("ROOM/w" + wn.ToString());
                if (wallObj != null)
                {
                    Vector2 wpc = _G.WallsPointCenter[wn - 1];
                    Vector3 fwd = -wallObj.transform.forward;
                    px = wpc.x + d / 2f * fwd.x;
                    pz = wpc.y + d / 2f * fwd.z;
                    ry = _G.WallsAngle[wn - 1];

                    // Miter setbacks: interior angle at each junction = 180° - angle between wall right vectors
                    int NW = _G.NW;
                    int prevWn = wn == 1 ? NW : wn - 1;
                    int nextWn = wn == NW ? 1 : wn + 1;
                    GameObject prevWall = Get.o1("ROOM/w" + prevWn);
                    GameObject nextWall = Get.o1("ROOM/w" + nextWn);

                    float extPrev = prevWall != null ? Vector3.Angle(wallObj.transform.right, prevWall.transform.right) : 90f;
                    float extNext = nextWall != null ? Vector3.Angle(wallObj.transform.right, nextWall.transform.right) : 90f;
                    float intPrev = 180f - extPrev;
                    float intNext = 180f - extNext;
                    float sbPrev = d / Mathf.Max(Mathf.Tan(intPrev * 0.5f * Mathf.Deg2Rad), 0.001f);
                    float sbNext = d / Mathf.Max(Mathf.Tan(intNext * 0.5f * Mathf.Deg2Rad), 0.001f);

                    // Assign left/right: check if wall traversal direction aligns with local +X
                    Vector2 wDir = (_G.WallsPointStart[wn % NW] - _G.WallsPointStart[wn - 1]).normalized;
                    float alignment = wDir.x * wallObj.transform.right.x + wDir.y * wallObj.transform.right.z;
                    if (alignment >= 0f) { sL = sbPrev; sR = sbNext; }
                    else                 { sL = sbNext; sR = sbPrev; }

                    if (C[70] != "y") sL = 0f;
                    if (C[71] != "y") sR = 0f;

                    sL = Mathf.Min(sL, wallWidth * 0.4f);
                    sR = Mathf.Min(sR, wallWidth * 0.4f);
                }
            }

            w = wallWidth;
            C[6] = w.ToString();
            py = _G.HEIGHT / 2 - h / 2;
            BASE.transform.localScale = new(w + 0.5f, h + 0.5f, d + 0.5f);

            float xL = -w / 2f,      xR  = w / 2f;
            float xLf = xL + sL,     xRf = xR - sR;   // front-face corners (set back by miter)
            float yT = h / 2f,       yB  = -h / 2f;
            float zBk = d / 2f,      zFr = -d / 2f;

            // Back: full width at wall face
            GameObject back = CreateMcx("back", w, h, 1, 0, 0, zBk, 0, 180, 0, MAT);
            back.transform.SetParent(BASE.transform);

            // Front: shortened between the two setbacks
            float fw = xRf - xLf;
            GameObject front = CreateMcx("front", fw, h, 1, (xLf + xRf) / 2f, 0, zFr, 0, 0, 0, MAT);
            front.transform.SetParent(BASE.transform);

            // Top: trapezoid (wide at back, narrow at front)
            GameObject top = CreateFace("top",
                new Vector3(xL,  yT, zBk), new Vector3(xR,   yT, zBk),
                new Vector3(xRf, yT, zFr), new Vector3(xLf,  yT, zFr), MAT);
            top.tag = "bloc";   top.transform.SetParent(BASE.transform);

            // Under: trapezoid (opposite winding for -Y normal)
            GameObject under = CreateFace("under",
                new Vector3(xLf, yB, zFr), new Vector3(xRf,  yB, zFr),
                new Vector3(xR,  yB, zBk), new Vector3(xL,   yB, zBk), MAT);
            under.tag = "bloc"; under.transform.SetParent(BASE.transform);

            // Left end: parallelogram (angled when sL > 0)
            GameObject left = CreateFace("left",
                new Vector3(xL,  yB, zBk), new Vector3(xL,   yT, zBk),
                new Vector3(xLf, yT, zFr), new Vector3(xLf,  yB, zFr), MAT);
            left.tag = "bloc";  left.transform.SetParent(BASE.transform);

            // Right end: parallelogram (angled when sR > 0)
            GameObject right = CreateFace("right",
                new Vector3(xRf, yB, zFr), new Vector3(xRf,  yT, zFr),
                new Vector3(xR,  yT, zBk), new Vector3(xR,   yB, zBk), MAT);
            right.tag = "bloc"; right.transform.SetParent(BASE.transform);
        }
        Mesure.Addpoints("WALL", BASE);

        float leftBox = -w*0.5f;
        float rightBox = w*0.5f;
        float backBox = d*0.5f;
        float frontkBox = d*0.5f;
        float Top = h*0.5f;
        float Under = -h*0.5f;

        CREATE.EmptyPoint(BASE, "PBLU", leftBox,  Top,  backBox);//P1
        CREATE.EmptyPoint(BASE, "PBRU", rightBox, Top,  backBox);//P2
        CREATE.EmptyPoint(BASE, "PFLU", leftBox,  Top,  frontkBox);//P3
        CREATE.EmptyPoint(BASE, "PFRU", rightBox, Top,  frontkBox);//P4
        
        CREATE.EmptyPoint(BASE, "PBLB", leftBox,  Under,  backBox);//P1
        CREATE.EmptyPoint(BASE, "PBRB", rightBox, Under,  backBox);//P2
        CREATE.EmptyPoint(BASE, "PFLB", leftBox,  Under,  frontkBox);//P3
        CREATE.EmptyPoint(BASE, "PFRB", rightBox, Under,  frontkBox);//P4
    
        //RigidBody
        BASE.AddComponent<Rigidbody>();
        BASE.GetComponent<Rigidbody>().useGravity = false;
        BASE.GetComponent<Rigidbody>().isKinematic = true;
        BASE.GetComponent<Rigidbody>().detectCollisions = true;
        BASE.GetComponent<BoxCollider>().isTrigger = true;

        //Stet in scene
        BASE.AddComponent(typeof(MoveObject));
        BASE.transform.position = new(px, py, pz);
        BASE.transform.localRotation = Quaternion.Euler(rx, ry, rz);
        BASE.GetComponent<MeshRenderer>().sharedMaterial = _G.INV;
        BASE.transform.SetParent(GameObject.Find("SCENE").transform);
    }


    //CREATE SHAPES
    public static GameObject CreateCube(string name, float wc, float h, float dc, Material MAT)
    {
        GameObject Cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
        Cube.transform.localScale = new(wc, h, dc);
        Cube.name = name;
        Cube.tag = "bloc";
        Cube.GetComponent<MeshRenderer>().sharedMaterial = MAT;
        Cube.GetComponent<BoxCollider>().enabled = false;
        DOIT.SetSizeTex(Cube, 48, 48, 0, 0, 0, 0, 90, 90);
        Cube.GetComponent<MeshRenderer>().probeAnchor = GameObject.Find("Reflection Probe").transform;
        return Cube;
    }
    public static GameObject CreateCylinder(GameObject Cyl, string name, float r, float h, Material MAT)
    {
        GameObject Cylinder = Instantiate(Cyl);
        Cylinder.transform.localScale = new(r, h * 0.5f, r);
        Cylinder.name = name;
        Cylinder.tag = "bloc";
        Cylinder.transform.GetChild(0).GetComponent<MeshRenderer>().material = MAT;
        Cylinder.transform.GetChild(0).GetComponent<MeshRenderer>().probeAnchor = GameObject.Find("Reflection Probe").transform;
        return Cylinder;
    }
    public static GameObject CreateCylinderPrimitif(string name, float w, float d, float h, Material MAT)
    {
        GameObject Cylinder = new(name);
        GameObject Cyl = GameObject.CreatePrimitive(PrimitiveType.Cylinder);
        Cyl.transform.SetParent(Cylinder.transform);
        Cylinder.transform.localScale = new(w, h * 0.5f, d);
        Cylinder.name = name;
        Cylinder.tag = "bloc";
        Cyl.GetComponent<MeshRenderer>().material = MAT;
        Cyl.GetComponent<MeshRenderer>().probeAnchor = GameObject.Find("Reflection Probe").transform;
        return Cylinder;
    }
    public static GameObject CreateCylinderPrimitif_90(string name, float w, float d, float h, Material MAT)
    {
        GameObject Cylinder = new(name);
        GameObject Cyl = GameObject.CreatePrimitive(PrimitiveType.Cylinder);
        Cyl.transform.SetParent(Cylinder.transform);
        Cyl.transform.localScale = new(h, w * 0.5f, d);
        Cylinder.transform.rotation = Quaternion.FromToRotation(Vector3.up, new(1, 0, 0));
        Cylinder.name = name;
        Cylinder.tag = "bloc";
        Cyl.GetComponent<MeshRenderer>().material = MAT;
        Cyl.GetComponent<MeshRenderer>().probeAnchor = GameObject.Find("Reflection Probe").transform;

        return Cylinder;
    }

    public static GameObject CreateMcx(string n, float sx, float sy, float sz, float px, float py, float pz, float rx, float ry, float rz, Material MAT)
    {
        GameObject obj = GameObject.CreatePrimitive(PrimitiveType.Quad);
        obj.transform.localScale = new(sx, sy, sz);
        obj.transform.position = new(px, py, pz);
        obj.transform.localRotation = Quaternion.Euler(rx, ry, rz);
        obj.tag = "bloc";
        obj.name = n;
        obj.GetComponent<MeshCollider>().enabled = false;
        Material mat = MAT_TRASH.New(MAT, obj);
        //Vector2 tile=new(sx/24,sy/24);
        //mat.SetVector("_Tile",tile);
        obj.GetComponent<MeshRenderer>().sharedMaterial= mat;
        obj.GetComponent<MeshRenderer>().probeAnchor = GameObject.Find("Reflection Probe").transform;
        if (isOnCeilling)
        {
            obj.GetComponent<MeshRenderer>().shadowCastingMode = 0;
            obj.layer = 6;
        }
        //Texture
        DOIT.SetSizeTex(obj, 24, 24, 0, 0, 0, 0, 90, 90);
        //
        return obj;
    }

    // Face pictogramme des BLOC118/BLOC119. Volontairement PAS CreateMcx : celui-ci passe par
    // DOIT.SetSizeTex, qui reconstruit les UV en 24x24 et repeterait l'image 24 fois.
    // Materiau transparent (_G.TRANS) : le fond de l'image laisse voir la couleur du boitier.
    public static GameObject CreateSign(string icon, float sx, float sy, float px, float py, float pz)
    {
        GameObject obj = GameObject.CreatePrimitive(PrimitiveType.Quad);
        obj.name = "sign";
        obj.tag = "bloc";
        obj.transform.localScale = new(sx, sy, 1);
        obj.transform.position = new(px, py, pz);
        obj.transform.localRotation = Quaternion.Euler(0, 0, 0);
        obj.GetComponent<MeshCollider>().enabled = false;

        Material M = MAT_TRASH.New(_G.TRANS, obj);
        M.SetTexture("_BaseMap", Resources.Load<Texture2D>(icon));
        M.SetColor("_BaseColor", Color.white);
        M.mainTextureScale = Vector2.one;
        M.mainTextureOffset = Vector2.zero;
        obj.GetComponent<MeshRenderer>().sharedMaterial = M;
        obj.GetComponent<MeshRenderer>().probeAnchor = GameObject.Find("Reflection Probe").transform;
        if (isOnCeilling)
        {
            obj.GetComponent<MeshRenderer>().shadowCastingMode = 0;
            obj.layer = 6;
        }
        return obj;
    }

    public static GameObject CreateFace(string N, Vector3 P1, Vector3 P2, Vector3 P3, Vector3 P4, Material MAT)
    {
        GameObject s = new(N);
        s.AddComponent(typeof(MeshFilter));
        s.AddComponent(typeof(MeshRenderer));
        if (P4 == new Vector3(0, 0, 0)) { s.GetComponent<MeshFilter>().mesh = CreateMeshShape3V(P1, P2, P3); }
        if (P4 != new Vector3(0, 0, 0)) { s.GetComponent<MeshFilter>().mesh = CreateMeshShape4V(P1, P2, P3, P4); }
        s.GetComponent<MeshRenderer>().material = MAT;
        DOIT.SetSizeTex(s, 24, 24, 24, 0, 0, 0, 90, 90);
        s.GetComponent<MeshRenderer>().probeAnchor = GameObject.Find("Reflection Probe").transform;
        return s;
    }
    public static Mesh CreateMeshShape3V(Vector3 P1, Vector3 P2, Vector3 P3)
    {
        Mesh m = new()
        {
            vertices = new[] { P1, P2, P3 },
            uv = new Vector2[] {
            new (0, 0),
            new (0, 1),
            new (1, 1),
        },
            triangles = new int[] { 0, 1, 2 }
        };
        m.RecalculateNormals();
        m.RecalculateTangents();
        return m;
    }
    public static Mesh CreateMeshShape4V(Vector3 P1, Vector3 P2, Vector3 P3, Vector3 P4)
    {
        Mesh m = new()
        {
            vertices = new[] { P1, P2, P3, P4 },
            uv = new Vector2[] {
            new (0, 0),
            new (0, 1),
            new (1, 1),
            new (1, 0),
        },
            triangles = new int[] { 0, 1, 2, 0, 2, 3 }
        };
        m.RecalculateNormals();
        m.RecalculateTangents();
        return m;
    }

    //Addressable Texture

    public static IEnumerator GORETURN(GameObject BASE, Material MAT, int nO) {
        string TexName = MAT.name;
        if (string.IsNullOrEmpty(TexName)){ TexName= "MELAMINEWHITE";}
        TexName.Replace(",", "?");    
        if (TexName != "MELAMINEWHITE" && TexName != "none")
        {
            Addressables.LoadAssetAsync<Texture2D>(TexName.Split("?")[0]).Completed += handle =>
            {
                if (handle.Status == AsyncOperationStatus.Succeeded)
                {
                    Texture2D tex = Instantiate(handle.Result);
                    MAT.SetTexture("_Texture", tex);
                    AddblocToScene(BASE, MAT, nO);
                    GameObject.Find("HIDER").transform.Find("LoadingCircle").gameObject.SetActive(false);
                }
                else
                {
                    Debug.LogError("Failed to load texture: " + BASE.name);
                }
            };
        }
        yield return null; //new WaitForSeconds(2);
    }
}