diff --git a/bin/back b/bin/back
index 6f16127..4cea85d 100755
Binary files a/bin/back and b/bin/back differ
diff --git a/obj/display.o b/obj/display.o
index a1e0e96..0292dd6 100644
Binary files a/obj/display.o and b/obj/display.o differ
diff --git a/obj/triangles.o b/obj/triangles.o
index 8507888..f274d8d 100644
Binary files a/obj/triangles.o and b/obj/triangles.o differ
diff --git a/src/display.c b/src/display.c
index aeb18d1..7c094b7 100644
--- a/src/display.c
+++ b/src/display.c
@@ -27,6 +27,17 @@ double draw_constant ;
 int* cubeDrawOrder;
 bool* seen ;
 
+pt_2d** triangles_to_render ;
+int triangles_i ;
+
+int* reds ;
+int* greens ;
+int* blues ;
+
+int* triangles_order ;
+bool* visited_tri ;
+int visited_i ;
+
 void init_draworder() {
     drawOrder = malloc(sizeof(int)*6) ;
     cubeDrawOrder = malloc(sizeof(int)*2048);
@@ -36,6 +47,18 @@ void init_draworder() {
         seen[k] = false;
     }
     draw_constant = 0.4 ;
+    triangles_to_render = malloc(sizeof(pt_2d*)*8192) ;
+    reds = malloc(sizeof(int)*8192) ;
+    greens = malloc(sizeof(int)*8192) ;
+    blues = malloc(sizeof(int)*8192) ;
+    triangles_order = malloc(sizeof(int)*8192) ;
+    visited_tri = malloc(sizeof(bool)*8192) ;
+    for(int k = 0; k < 8192; k++) {
+        triangles_to_render[k] = malloc(sizeof(pt_2d)*3);
+        triangles_order[k] = k;
+    }
+    triangles_i = 0;
+    visited_i = 0;
 }
 
 void updateRenderer(SDL_Renderer* renderer) {
@@ -451,9 +474,9 @@ void renderTriangleNoProject(
 ) {
 
     const SDL_Vertex vtxs[3] = {
-        construct_vertex(px0, py0, red, green, blue, 128),
-        construct_vertex(px1, py1, red, green, blue, 128),
-        construct_vertex(px2, py2, red, green, blue, 128),
+        construct_vertex(px0, py0, red, green, blue, 255),
+        construct_vertex(px1, py1, red, green, blue, 255),
+        construct_vertex(px2, py2, red, green, blue, 255),
     };
     if(debug) {   
         printf("P[*] : (%f, %f), (%f, %f), (%f, %f)\n", vtxs[0].position.x,  vtxs[0].position.y,  vtxs[1].position.x,  vtxs[1].position.y,  vtxs[2].position.x,  vtxs[2].position.y);
@@ -461,12 +484,19 @@ void renderTriangleNoProject(
     SDL_RenderGeometry(renderer, NULL, vtxs, 3, NULL, 0);
 }
 
-void renderTriangle(
-    SDL_Renderer* renderer,
+pt_2d to_pt_2d(double x0, double y0, double z0) {
+    pt_2d res;
+    res.x = x0;
+    res.y = y0;
+    res.z = z0;
+    return res;
+}
+
+void addTriangle(
     double x0, double y0, double z0,
     double x1, double y1, double z1,
     double x2, double y2, double z2,
-    int red, int green, int blue, bool debug
+    int red, int green, int blue
 ) {
     double px0; double py0; double pz0;
     double px1; double py1; double pz1;
@@ -479,15 +509,13 @@ void renderTriangle(
     project_to_camera(x1, y1, z1, &px1, &py1, &pz1);
     project_to_camera(x2, y2, z2, &px2, &py2, &pz2);
     if(pz0 >= draw_constant && pz1 >= draw_constant && pz2 >= draw_constant) {
-        const SDL_Vertex vtxs[3] = {
-            construct_vertex(1500.0 * (1.0 + (px0 / (1.5 * pz0 * tan_fov))) / 2.0, 1000.0 * (1.0 + (py0 / (pz0 * tan_fov))) / 2.0, red, green, blue, 255),
-            construct_vertex(1500.0 * (1.0 + (px1 / (1.5 * pz1 * tan_fov))) / 2.0, 1000.0 * (1.0 + (py1 / (pz1 * tan_fov))) / 2.0, red, green, blue, 255),
-            construct_vertex(1500.0 * (1.0 + (px2 / (1.5 * pz2 * tan_fov))) / 2.0, 1000.0 * (1.0 + (py2 / (pz2 * tan_fov))) / 2.0, red, green, blue, 255),
-        };
-        if(debug) {
-            printf("P[3] : (%f, %f), (%f, %f), (%f, %f)\n", vtxs[0].position.x,  vtxs[0].position.y,  vtxs[1].position.x,  vtxs[1].position.y,  vtxs[2].position.x,  vtxs[2].position.y);
-        }
-        SDL_RenderGeometry(renderer, NULL, vtxs, 3, NULL, 0);
+        triangles_to_render[triangles_i][0] = to_pt_2d(1500.0 * (1.0 + (px0 / (1.5 * pz0 * tan_fov))) / 2.0, 1000.0 * (1.0 + (py0 / (pz0 * tan_fov))) / 2.0, pz0);
+        triangles_to_render[triangles_i][1] = to_pt_2d(1500.0 * (1.0 + (px1 / (1.5 * pz1 * tan_fov))) / 2.0, 1000.0 * (1.0 + (py1 / (pz1 * tan_fov))) / 2.0, pz1);
+        triangles_to_render[triangles_i][2] = to_pt_2d(1500.0 * (1.0 + (px2 / (1.5 * pz2 * tan_fov))) / 2.0, 1000.0 * (1.0 + (py2 / (pz2 * tan_fov))) / 2.0, pz2);
+        reds[triangles_i] = red ;
+        greens[triangles_i] = green ;
+        blues[triangles_i] = blue ;
+        triangles_i += 1;
     } else if((pz0 >= draw_constant) + (pz1 >= draw_constant) + (pz2 >= draw_constant) == 2) {
         if(pz0 < draw_constant) {     
             // pz1 >= draw_constant and pz2 >+ draw_constant
@@ -542,19 +570,19 @@ void renderTriangle(
             &mpx1, &mpy1, &mpz1) ;
         }
 
-        const SDL_Vertex vtxs[6] = {
-            construct_vertex(1500.0 * (1.0 + (fpx0 / (1.5 * fpz0 * tan_fov))) / 2.0, 1000.0 * (1.0 + (fpy0 / (fpz0 * tan_fov))) / 2.0, red, green, blue, 255),
-            construct_vertex(1500.0 * (1.0 + (mpx0 / (1.5 * mpz0 * tan_fov))) / 2.0, 1000.0 * (1.0 + (mpy0 / (mpz0 * tan_fov))) / 2.0, red, green, blue, 255),
-            construct_vertex(1500.0 * (1.0 + (fpx1 / (1.5 * fpz1 * tan_fov))) / 2.0, 1000.0 * (1.0 + (fpy1 / (fpz1 * tan_fov))) / 2.0, red, green, blue, 255),
-            construct_vertex(1500.0 * (1.0 + (mpx0 / (1.5 * mpz0 * tan_fov))) / 2.0, 1000.0 * (1.0 + (mpy0 / (mpz0 * tan_fov))) / 2.0, red, green, blue, 255),
-            construct_vertex(1500.0 * (1.0 + (mpx1 / (1.5 * mpz1 * tan_fov))) / 2.0, 1000.0 * (1.0 + (mpy1 / (mpz1 * tan_fov))) / 2.0, red, green, blue, 255),
-            construct_vertex(1500.0 * (1.0 + (fpx1 / (1.5 * fpz1 * tan_fov))) / 2.0, 1000.0 * (1.0 + (fpy1 / (fpz1 * tan_fov))) / 2.0, red, green, blue, 255),
-        };
-        if(debug) {
-            printf("P[2] : (%f, %f), (%f, %f), (%f, %f)\n", vtxs[0].position.x,  vtxs[0].position.y,  vtxs[1].position.x,  vtxs[1].position.y,  vtxs[2].position.x,  vtxs[2].position.y);
-            printf("       (%f, %f), (%f, %f), (%f, %f)\n", vtxs[3].position.x,  vtxs[3].position.y,  vtxs[4].position.x,  vtxs[4].position.y,  vtxs[5].position.x,  vtxs[5].position.y);
-        }
-        SDL_RenderGeometry(renderer, NULL, vtxs, 6, NULL, 0);
+        triangles_to_render[triangles_i][0] = to_pt_2d(1500.0 * (1.0 + (fpx0 / (1.5 * fpz0 * tan_fov))) / 2.0, 1000.0 * (1.0 + (fpy0 / (fpz0 * tan_fov))) / 2.0, fpz0);
+        triangles_to_render[triangles_i][1] = to_pt_2d(1500.0 * (1.0 + (mpx0 / (1.5 * mpz0 * tan_fov))) / 2.0, 1000.0 * (1.0 + (mpy0 / (mpz0 * tan_fov))) / 2.0, mpz0);
+        triangles_to_render[triangles_i][2] = to_pt_2d(1500.0 * (1.0 + (fpx1 / (1.5 * fpz1 * tan_fov))) / 2.0, 1000.0 * (1.0 + (fpy1 / (fpz1 * tan_fov))) / 2.0, fpz1);
+        triangles_to_render[triangles_i+1][0] = to_pt_2d(1500.0 * (1.0 + (mpx0 / (1.5 * mpz0 * tan_fov))) / 2.0, 1000.0 * (1.0 + (mpy0 / (mpz0 * tan_fov))) / 2.0, mpz0);
+        triangles_to_render[triangles_i+1][1] = to_pt_2d(1500.0 * (1.0 + (mpx1 / (1.5 * mpz1 * tan_fov))) / 2.0, 1000.0 * (1.0 + (mpy1 / (mpz1 * tan_fov))) / 2.0, mpz1);
+        triangles_to_render[triangles_i+1][2] = to_pt_2d(1500.0 * (1.0 + (fpx1 / (1.5 * fpz1 * tan_fov))) / 2.0, 1000.0 * (1.0 + (fpy1 / (fpz1 * tan_fov))) / 2.0, fpz1);
+        reds[triangles_i] = red ;
+        greens[triangles_i] = green ;
+        blues[triangles_i] = blue ;
+        reds[triangles_i+1] = red ;
+        greens[triangles_i+1] = green ;
+        blues[triangles_i+1] = blue ;
+        triangles_i += 2 ;
     } else if((pz0 >= draw_constant) + (pz1 >= draw_constant) + (pz2 >= draw_constant) == 1) {
         if(pz0 >= draw_constant) {
             project_to_camera(
@@ -590,24 +618,20 @@ void renderTriangle(
                 convex_pt(z2, z1, (pz2 - draw_constant)/(pz2 - pz1)),
             &px1, &py1, &pz1);
         }
-        const SDL_Vertex vtxs[3] = {
-            construct_vertex(1500.0 * (1.0 + (px0 / (1.5 * pz0 * tan_fov))) / 2.0, 1000.0 * (1.0 + (py0 / (pz0 * tan_fov))) / 2.0, red, green, blue, 255),
-            construct_vertex(1500.0 * (1.0 + (px1 / (1.5 * pz1 * tan_fov))) / 2.0, 1000.0 * (1.0 + (py1 / (pz1 * tan_fov))) / 2.0, red, green, blue, 255),
-            construct_vertex(1500.0 * (1.0 + (px2 / (1.5 * pz2 * tan_fov))) / 2.0, 1000.0 * (1.0 + (py2 / (pz2 * tan_fov))) / 2.0, red, green, blue, 255),
-        };
-        if(debug) {
-            printf("P[1] : (%f, %f), (%f, %f), (%f, %f)\n", vtxs[0].position.x,  vtxs[0].position.y,  vtxs[1].position.x,  vtxs[1].position.y,  vtxs[2].position.x,  vtxs[2].position.y);
-        }
-        SDL_RenderGeometry(renderer, NULL, vtxs, 3, NULL, 0);
+
+        triangles_to_render[triangles_i][0] = to_pt_2d(1500.0 * (1.0 + (px0 / (1.5 * pz0 * tan_fov))) / 2.0, 1000.0 * (1.0 + (py0 / (pz0 * tan_fov))) / 2.0, pz0);
+        triangles_to_render[triangles_i][1] = to_pt_2d(1500.0 * (1.0 + (px1 / (1.5 * pz1 * tan_fov))) / 2.0, 1000.0 * (1.0 + (py1 / (pz1 * tan_fov))) / 2.0, pz1);
+        triangles_to_render[triangles_i][2] = to_pt_2d(1500.0 * (1.0 + (px2 / (1.5 * pz2 * tan_fov))) / 2.0, 1000.0 * (1.0 + (py2 / (pz2 * tan_fov))) / 2.0, pz2);
+        reds[triangles_i] = red ;
+        greens[triangles_i] = green ;
+        blues[triangles_i] = blue ;
+        triangles_i += 1;
     } else {
-        if(debug) {
-            printf("P[0] : (-)\n");
-        }
+        
     }
 }
 
-void renderTriangleRotated(
-    SDL_Renderer* renderer,
+void addTriangleRotated(
     double x0, double y0, double z0,
     double x1, double y1, double z1,
     double x2, double y2, double z2,
@@ -617,261 +641,121 @@ void renderTriangleRotated(
     double px0; double py0; double pz0;
     double px1; double py1; double pz1;
     double px2; double py2; double pz2;
-    /*double px0; double py0; double pz0;
-    double px1; double py1; double pz1;
-    double px2; double py2; double pz2;*/
     rotate_cube(x0, y0, z0, &px0, &py0, &pz0, cb);
     rotate_cube(x1, y1, z1, &px1, &py1, &pz1, cb);
     rotate_cube(x2, y2, z2, &px2, &py2, &pz2, cb);
-    renderTriangle(renderer, px0, py0, pz0, px1, py1, pz1, px2, py2, pz2, red, green, blue, false);
-}
-
-void drawSfOfCube(SDL_Renderer* renderer, int sf, cube_0 c) {
-    if(sf == 0 || sf == 1) {        // x
-        renderTriangleRotated(renderer, 
-            c.x + c.w*(sf==0), c.y, c.z, 
-            c.x + c.w*(sf==0), c.y + c.h, c.z, 
-            c.x + c.w*(sf==0), c.y + c.h, c.z + c.d, 
-            c.red, c.green, c.blue, c
-        );
-        renderTriangleRotated(renderer, 
-            c.x + c.w*(sf==0), c.y, c.z, 
-            c.x + c.w*(sf==0), c.y, c.z + c.d, 
-            c.x + c.w*(sf==0), c.y + c.h, c.z + c.d, 
-            c.red, c.green, c.blue, c
-        );
-    } else if(sf == 2 || sf == 3) { // y
-        renderTriangleRotated(renderer, 
-            c.x, c.y + c.h*(sf==2), c.z, 
-            c.x + c.w, c.y + c.h*(sf==2), c.z, 
-            c.x + c.w, c.y + c.h*(sf==2), c.z + c.d, 
-            c.red, c.green, c.blue, c
-        );
-        renderTriangleRotated(renderer, 
-            c.x, c.y + c.h*(sf==2), c.z, 
-            c.x, c.y + c.h*(sf==2), c.z + c.d, 
-            c.x + c.w, c.y + c.h*(sf==2), c.z + c.d, 
-            c.red, c.green, c.blue, c
-        );
-    } else {                        // z
-        renderTriangleRotated(renderer, 
-            c.x, c.y, c.z + c.d*(sf==4), 
-            c.x + c.w, c.y, c.z + c.d*(sf==4), 
-            c.x + c.w, c.y + c.h, c.z + c.d*(sf==4), 
-            c.red, c.green, c.blue, c
-        );
-        renderTriangleRotated(renderer, 
-            c.x, c.y, c.z + c.d*(sf==4), 
-            c.x, c.y + c.h, c.z + c.d*(sf==4), 
-            c.x + c.w, c.y + c.h, c.z + c.d*(sf==4), 
-            c.red, c.green, c.blue, c
-        );
-    }
-}
-
-void drawFullCube(SDL_Renderer* renderer, cube_0 cb) {
-    int sfToDraw = surfaceDrawOrder(camx, camy, camz, cb);
-    for(int k = 0; k < sfToDraw; k++) {
-        drawSfOfCube(renderer, drawOrder[k], cb);
-    }
+    addTriangle(px0, py0, pz0, px1, py1, pz1, px2, py2, pz2, red, green, blue);
 }
 
 // -------------------------------------------------------------------------------------------------------------------------------- //
 
-void swap_cb(cube_0* arr, int i, int j) {
-    cube_0 temp = arr[i];
-    arr[i] = arr[j];
-    arr[j] = temp;
-}
-
-void swap_tp(teleporter* arr, int i, int j) {
-    teleporter temp = arr[i];
-    arr[i] = arr[j];
-    arr[j] = temp;
-}
-
-void swap_ent(entity* arr, int i, int j) {
-    entity temp = arr[i];
-    arr[i] = arr[j];
-    arr[j] = temp;
-}
-
-double mult_x = 1.0 ;
-double mult_y = 1.0 ;
-double mult_z = 1.0 ;
-
-void insertionSort_cb(cube_0* arr, int len) {
-    for(int k = 0; k < len; k++) {
-        int j = k-1 ;
-        while(j >= 0) {
-            //if(distance_pt_cube_0_3d_weighted(camx, camy, camz, mult_x, mult_y, mult_z, arr[j]) < distance_pt_cube_0_3d_weighted(camx, camy, camz, mult_x, mult_y, mult_z, arr[j+1])) {
-            //if(distance_pt_cube_0_3d_max(camx, camy, camz, arr[j]) < distance_pt_cube_0_3d_max(camx, camy, camz, arr[j+1])) {
-            if(
-                distance_pt_cube_0_3d_max(camx, camy, camz, arr[j]) + distance_pt_cube_0_3d_weighted(camx, camy, camz, mult_x, mult_y, mult_z, arr[j]) < 
-                distance_pt_cube_0_3d_max(camx, camy, camz, arr[j+1]) + distance_pt_cube_0_3d_weighted(camx, camy, camz, mult_x, mult_y, mult_z, arr[j+1])) {
-            //if(cube_z_distance_to_camera(arr[j]) < cube_z_distance_to_camera(arr[j+1])) {
-                swap_cb(arr, j, j+1);
-                j -= 1;
-            } else {
-                j = -1;
-            }
+void add_single(cube_0 c) {      // x
+    int leng = surfaceDrawOrder(camx, camy, camz, c);
+    for(int sf0 = 0; sf0 < leng; sf0++) {
+        int sf = drawOrder[sf0];
+        //printf("%d\n", sf);
+        if(sf == 0 || sf == 1) {
+            addTriangleRotated( 
+                c.x + c.w*(sf==0), c.y      , c.z, 
+                c.x + c.w*(sf==0), c.y + c.h, c.z, 
+                c.x + c.w*(sf==0), c.y + c.h, c.z + c.d, 
+                c.red, c.green, c.blue, c
+            );
+            addTriangleRotated(
+                c.x + c.w*(sf==0), c.y, c.z, 
+                c.x + c.w*(sf==0), c.y, c.z + c.d, 
+                c.x + c.w*(sf==0), c.y + c.h, c.z + c.d, 
+                c.red, c.green, c.blue, c
+            );
+        } else if(sf == 2 || sf == 3) {
+            addTriangleRotated(
+                c.x      , c.y + c.h*(sf==2), c.z, 
+                c.x + c.w, c.y + c.h*(sf==2), c.z, 
+                c.x + c.w, c.y + c.h*(sf==2), c.z + c.d, 
+                c.red, c.green, c.blue, c
+            );
+            addTriangleRotated(
+                c.x      , c.y + c.h*(sf==2), c.z, 
+                c.x      , c.y + c.h*(sf==2), c.z + c.d, 
+                c.x + c.w, c.y + c.h*(sf==2), c.z + c.d, 
+                c.red, c.green, c.blue, c
+            );
+        } else {             // z
+            addTriangleRotated(
+                c.x      , c.y      , c.z + c.d*(sf==4), 
+                c.x + c.w, c.y      , c.z + c.d*(sf==4), 
+                c.x + c.w, c.y + c.h, c.z + c.d*(sf==4), 
+                c.red, c.green, c.blue, c
+            );
+            addTriangleRotated(
+                c.x      , c.y      , c.z + c.d*(sf==4), 
+                c.x      , c.y + c.h, c.z + c.d*(sf==4), 
+                c.x + c.w, c.y + c.h, c.z + c.d*(sf==4), 
+                c.red, c.green, c.blue, c
+            );
         }
     }
 }
 
-void insertionSort_tp(teleporter* arr, int len) {
+void add_triangles_cb(cube_0* arr, int len) {
     for(int k = 0; k < len; k++) {
-        int j = k-1 ;
-        while(j >= 0) {
-            //if(distance_pt_cube_0_3d_weighted(camx, camy, camz, mult_x, mult_y, mult_z, arr[j].hitbox) < distance_pt_cube_0_3d_weighted(camx, camy, camz, mult_x, mult_y, mult_z, arr[j+1].hitbox)) {
-            //if(distance_pt_cube_0_3d_max(camx, camy, camz, arr[j].hitbox) < distance_pt_cube_0_3d_max(camx, camy, camz, arr[j+1].hitbox)) {
-            if(distance_pt_cube_0_3d_max(camx, camy, camz, arr[j].hitbox) + distance_pt_cube_0_3d_weighted(camx, camy, camz, mult_x, mult_y, mult_z, arr[j].hitbox) < 
-               distance_pt_cube_0_3d_max(camx, camy, camz, arr[j+1].hitbox) + distance_pt_cube_0_3d_weighted(camx, camy, camz, mult_x, mult_y, mult_z, arr[j+1].hitbox)) {
-            //if(cube_z_distance_to_camera(arr[j].hitbox) < cube_z_distance_to_camera(arr[j+1].hitbox)) {
-                swap_tp(arr, j, j+1);
-                j -= 1;
-            } else {
-                j = -1;
-            }
-        }
+        add_single(arr[k]);
     }
 }
 
-void insertionSort_ent(entity* arr, int len) {
+void add_triangles_tp(teleporter* arr, int len) {
     for(int k = 0; k < len; k++) {
-        int j = k-1 ;
-        while(j >= 0) {
-            //if(distance_pt_cube_0_3d_weighted(camx, camy, camz, mult_x, mult_y, mult_z, *(arr[j].pos)) < distance_pt_cube_0_3d_weighted(camx, camy, camz, mult_x, mult_y, mult_z, *(arr[j+1].pos))) {
-            //if(distance_pt_cube_0_3d_max(camx, camy, camz, *(arr[j].pos)) < distance_pt_cube_0_3d_max(camx, camy, camz, *(arr[j+1].pos))) {
-            if(distance_pt_cube_0_3d_max(camx, camy, camz, *(arr[j].pos)) + distance_pt_cube_0_3d_weighted(camx, camy, camz, mult_x, mult_y, mult_z, *(arr[j].pos)) < 
-               distance_pt_cube_0_3d_max(camx, camy, camz, *(arr[j+1].pos)) + distance_pt_cube_0_3d_weighted(camx, camy, camz, mult_x, mult_y, mult_z, *(arr[j+1].pos))) {
-            //if(cube_z_distance_to_camera(*(arr[j].pos)) < cube_z_distance_to_camera(*(arr[j+1].pos))) {
-                swap_ent(arr, j, j+1);
-                j -= 1;
-            } else {
-                j = -1;
-            }
-        }
+        add_single(arr[k].hitbox);
     }
 }
 
-void visit(SDL_Renderer* renderer, int k, cube_0* arr, int len, bool vflag, int* retptr) {
-    double overlap = 0.0;
-    if(seen[k] != vflag) {
-        seen[k] = vflag;
-        for(int k2 = 0; k2 < len; k2++) {
-            if(k != k2 && seen[k2] != vflag) {
-                if(cubeOverlap(renderer, arr[k], arr[k2], &overlap) && overlap > 0.0) {
-                    visit(renderer, k2, arr, len, vflag, retptr);
+void add_triangles_ent(entity* arr, int len) {
+    for(int k = 0; k < len; k++) {
+        add_single(*(arr[k].pos));
+    }
+}
+
+void renderTriangleFull(SDL_Renderer* renderer, int k) {
+    renderTriangleNoProject(renderer,
+        triangles_to_render[k][0].x, triangles_to_render[k][0].y, triangles_to_render[k][0].z,
+        triangles_to_render[k][1].x, triangles_to_render[k][1].y, triangles_to_render[k][1].z,
+        triangles_to_render[k][2].x, triangles_to_render[k][2].y, triangles_to_render[k][2].z,
+        reds[k], greens[k], blues[k], false
+    );
+}
+
+double deltaz ;
+void visiting(int k, bool vflag) {
+    if(visited_tri[k] != vflag) {
+        visited_tri[k] = vflag;
+        for(int k2 = 0; k2 < triangles_i; k2++) {
+            if(k2 != k && visited_tri[k2] != vflag) {
+                if(delta_get(triangles_to_render[k], triangles_to_render[k2], &deltaz) && deltaz > 0.01) {
+                    visiting(k2, vflag);
                 }
             }
         }
-        cubeDrawOrder[*retptr] = k;
-        *retptr += 1;
+        triangles_order[visited_i] = k;
+        visited_i += 1;
     }
 }
 
-void insertionDepthSort(SDL_Renderer* renderer, cube_0* arr, int len) {
-    bool vflag = !seen[0];
-    int rptr = 0;
-    for(int k = 0; k < len; k++) {
-        visit(renderer, k, arr, len, vflag, &rptr);   
+void topological_sort() {
+    bool vflag = !visited_tri[0];
+    for(int k = 0; k < triangles_i; k++) {
+        visiting(k, vflag);
     }
 }
 
 void drawCurrentRoom(SDL_Renderer* renderer) {
-    insertionSort_cb(current_room->map, current_room->map_size);
-    insertionSort_tp(current_room->tps, current_room->tps_size);
-    insertionSort_ent(current_room->ents, current_room->ent_len);
-    insertionDepthSort(NULL, current_room->map, current_room->map_size);
-
-    /*for(int k1 = 0; k1 < current_room->map_size; k1++) {
-        current_room->map[k1].red = 188 ;
-        current_room->map[k1].green = 0 ;
-        current_room->map[k1].blue = 0 ;
-    }
-
-    int front ;
-    for(int k1 = 0; k1 < current_room->map_size; k1++) {
-        for(int k2 = k1+1; k2 < current_room->map_size; k2++) {
-            if(cubeOverlap(current_room->map[k1], current_room->map[k2], &front)) {
-                current_room->map[k1].red = 188*(front==1) ;
-                current_room->map[k1].green = 188 ;
-                current_room->map[k2].red = 188*(front==-1) ;
-                current_room->map[k2].green = 188 ;
-            }
-        }
-    }*/
-
-    if(true || draw_type == 0) {
-        for(int k = 0; k < current_room->map_size; k++) {
-            //drawFullCube(renderer, current_room->map[k]);
-            drawFullCube(renderer, current_room->map[cubeDrawOrder[k]]);
-        }
-        for(int k = 0; k < current_room->ent_len; k++) {
-            drawFullCube(renderer, *(current_room->ents[k].pos));
-        }
-        for(int k = 0; k < current_room->tps_size; k++) {
-            drawFullCube(renderer, current_room->tps[k].hitbox);
-        }
-    } else if(draw_type == 1) {
-        int k_cb = 0 ;
-        int k_tp = 0 ;
-        int k_et = 0 ;
-
-        int updated = 1+2+4 ;
-
-        double dcb = -1.0 ;
-        double dtp = -1.0 ;
-        double det = -1.0 ;
-        while(k_cb < current_room->map_size || k_tp < current_room->tps_size || k_et < current_room->ent_len) {
-            if(updated == 7) {
-                if(k_et < current_room->ent_len) {
-                    det = distance_pt_cube_0_3d_weighted(camx, camy, camz, mult_x, mult_y, mult_z, *(current_room->ents[k_et].pos));
-                }
-                if(k_tp < current_room->tps_size) {
-                    dtp = distance_pt_cube_0_3d_weighted(camx, camy, camz, mult_x, mult_y, mult_z, current_room->tps[k_tp].hitbox);
-                }
-                if(k_cb < current_room->map_size) {
-                    dcb = distance_pt_cube_0_3d_weighted(camx, camy, camz, mult_x, mult_y, mult_z, current_room->map[k_cb]);
-                }
-            } else if((updated/4)%2 == 1) {
-                if(k_et < current_room->ent_len) {
-                    det = distance_pt_cube_0_3d_weighted(camx, camy, camz, mult_x, mult_y, mult_z, *(current_room->ents[k_et].pos));
-                } else {
-                    det = -1.0 ;
-                }
-            } else if((updated/2)%2 == 1) {
-                if(k_tp < current_room->tps_size) {
-                    dtp = distance_pt_cube_0_3d_weighted(camx, camy, camz, mult_x, mult_y, mult_z, current_room->tps[k_tp].hitbox);
-                } else {
-                    dtp = -1.0 ;
-                }
-            } else if(updated%2 == 1) {
-                if(k_cb < current_room->map_size) {
-                    dcb = distance_pt_cube_0_3d_weighted(camx, camy, camz, mult_x, mult_y, mult_z, current_room->map[k_cb]);
-                } else {
-                    dcb = -1.0 ;
-                }
-            }
-            updated = 0 ;
-            double mn = maxd(maxd(dcb, dtp), det);
-            if(mn == dcb) {
-                drawFullCube(renderer, current_room->map[k_cb]);
-                updated += 1 ;
-                k_cb += 1;
-            }
-            if(mn == dtp) {
-                drawFullCube(renderer, current_room->tps[k_tp].hitbox);
-                updated += 2 ;
-                k_tp += 1;
-            }
-            if(mn == det) {
-                drawFullCube(renderer, *(current_room->ents[k_et].pos));
-                updated += 4;
-                k_et += 1;
-            }
-        }
+    triangles_i = 0;
+    visited_i = 0;
+    add_triangles_cb(current_room->map, current_room->map_size);
+    add_triangles_tp(current_room->tps, current_room->tps_size);
+    add_triangles_ent(current_room->ents, current_room->ent_len);
+    topological_sort();
+    for(int k = 0; k < triangles_i; k++) {
+        renderTriangleFull(renderer, triangles_order[k]);
     }
 }
 
diff --git a/src/display.h b/src/display.h
index e27a30e..9fe51c7 100644
--- a/src/display.h
+++ b/src/display.h
@@ -44,13 +44,6 @@ void drawCurrentRoom(SDL_Renderer* renderer);
 
 void drawData(SDL_Renderer* renderer);
 
-void renderTriangle(
-    SDL_Renderer* renderer,
-    double x0, double y0, double z0,
-    double x1, double y1, double z1,
-    double x2, double y2, double z2,
-    int red, int green, int blue, bool debug
-);
 void renderTriangleNoProject(
     SDL_Renderer* renderer,
     double x0, double y0, double z0,
@@ -58,15 +51,5 @@ void renderTriangleNoProject(
     double x2, double y2, double z2,
     int red, int green, int blue, bool debug
 );
-void renderTriangleRotated(
-    SDL_Renderer* renderer,
-    double x0, double y0, double z0,
-    double x1, double y1, double z1,
-    double x2, double y2, double z2,
-    int red, int green, int blue,
-    cube_0 cb
-);
-void drawSfOfCube(SDL_Renderer* renderer, int sf, cube_0 cb);
-void drawFullCube(SDL_Renderer* renderer, cube_0 cb);
 
 #endif
\ No newline at end of file
diff --git a/src/structure.h b/src/structure.h
index e533dad..7477a8e 100644
--- a/src/structure.h
+++ b/src/structure.h
@@ -115,5 +115,7 @@ extern int draw_type ;
 
 extern double draw_constant ;
 
+extern pt_2d** triangles_to_render ;
+extern int triangles_i ;
 
 #endif
\ No newline at end of file
diff --git a/src/triangles.c b/src/triangles.c
index 38b4b0d..ec14add 100644
--- a/src/triangles.c
+++ b/src/triangles.c
@@ -482,64 +482,25 @@ bool delta_get(pt_2d* tri1, pt_2d* tri2, double* ret) {
     for(int k = 0; k < 3; k++) {        // pt
         if(point_in_triangle(tri1[k], tri2[0], tri2[1], tri2[2], &th1, &th2, &th3)) {
             //printf("%lf, %lf, %lf\n", th1, th2, th3);
-            //if(ret != NULL) {*ret = convex_tri(tri2[0].z, th1, tri2[1].z, th2, tri2[2].z, th3) - tri1[k].z;}
+            if(ret != NULL) {*ret = convex_tri(tri2[0].z, th1, tri2[1].z, th2, tri2[2].z, th3) - tri1[k].z;}
             return true;
         }
         if(point_in_triangle(tri2[k], tri1[0], tri1[1], tri1[2], &th1, &th2, &th3)) {
             //printf("%lf, %lf, %lf\n", th1, th2, th3);
-            //if(ret != NULL) {*ret = tri2[k].z - convex_tri(tri1[0].z, th1, tri1[1].z, th2, tri1[2].z, th3);}
+            if(ret != NULL) {*ret = tri2[k].z - convex_tri(tri1[0].z, th1, tri1[1].z, th2, tri1[2].z, th3);}
             return true;
         }
     }
     for(int k1 = 0; k1 < 3; k1++) {     // seg
         for(int k2 = 0; k2 < 3; k2++) {
             if(seg_seg_inter(tri1[k1], tri1[(k1+1)%3], tri2[k2], tri2[(k2+1)%3], &th1, &th2)) {
-                print_tri(tri1);
-                print_tri(tri2);
-                printf("%lf, %lf\n\n", th1, th2);
+                //print_tri(tri1);
+                //print_tri(tri2);
+                //printf("%lf, %lf\n\n", th1, th2);
                 if(ret != NULL) {*ret = convex_pt(tri2[k2].z, tri2[(k2+1)%3].z, th2) - convex_pt(tri1[k1].z, tri1[(k1+1)%3].z, th1);} //no
                 return true;
             }
         }
     }
     return false;
-}
-
-bool cubeOverlap(SDL_Renderer* renderer, cube_0 c1, cube_0 c2, double* retval) {
-    int len1 = 0;
-    int len2 = 0;
-    int id1, id2;
-    double dz = 0.0;
-    for(int i1 = 0; i1 < 6; i1++) {
-        for(int i2 = i1; i2 < 6; i2++) {
-            for(int n = 0; n < 4; n++) {
-                len1 = fillPolygon(i1, c1, n%2, cube_t1);
-                len2 = fillPolygon(i2, c2, n/2, cube_t2);
-                if(multipleTrianglesIntersection(cube_t1, len1, cube_t2, len2, &id1, &id2)) {
-                    if(delta_get(&(cube_t1[id1]), &(cube_t2[id2]), &dz) && absf(dz) >= 0.001) {
-                        if(retval != NULL) {*retval = dz;; printf("%lf\n", dz);}
-                        return true;
-                    } else if(renderer != NULL) {
-                        // debug things //
-                        SDL_SetRenderDrawColor(renderer, 255, 255, 255, SDL_ALPHA_OPAQUE);
-                        printf("ids : 1 = (%d / %d), 2 = (%d / %d)\n", id1, len1, id2, len2);
-                        renderTriangleNoProject(renderer, 
-                            cube_t1[id1].x, cube_t1[id1].y, cube_t1[id1].z,
-                            cube_t1[id1+1].x, cube_t1[id1+1].y, cube_t1[id1+1].z,
-                            cube_t1[id1+2].x, cube_t1[id1+2].y, cube_t1[id1+2].z,
-                            255, 0, 0, true);
-                        renderTriangleNoProject(renderer, 
-                            cube_t2[id2].x, cube_t2[id2].y, cube_t2[id2].z,
-                            cube_t2[id2+1].x, cube_t2[id2+1].y, cube_t2[id2+1].z,
-                            cube_t2[id2+2].x, cube_t2[id2+2].y, cube_t2[id2+2].z,
-                            0, 255, 0, true);
-                        updateRenderer(renderer);
-                        usleep(2000000);
-                        exit(1);
-                    }
-                }
-            }
-        }
-    }
-    return false;
 }
\ No newline at end of file
diff --git a/src/triangles.h b/src/triangles.h
index 55c2348..3dc3e7c 100644
--- a/src/triangles.h
+++ b/src/triangles.h
@@ -16,6 +16,6 @@ bool multipleTrianglesIntersection(pt_2d* tri1, int len1, pt_2d* tri2, int len2,
 int returnTriangle(double x0, double y0, double z0, double x1, double y1, double z1, double x2, double y2, double z2, pt_2d* retarr);
 int fillPolygon(int sf, cube_0 c, int trig, pt_2d* ret);
 
-bool cubeOverlap(SDL_Renderer* renderer, cube_0 c1, cube_0 c2, double* retval);
+bool delta_get(pt_2d* tri1, pt_2d* tri2, double* ret);
 
 #endif
\ No newline at end of file