working-ish depth detection

src/display.c

@@ -30,7 +30,7 @@ double draw_constant ;
 
 pt_2d** triangles_to_render ;
 pt_2d** triangles_og_coords ;
-double* triangles_areas ;
+//double* triangles_areas ;
 int triangles_i ;
 
 int* reds ;
@@ -50,7 +50,7 @@ void init_draworder() {
     greens = malloc(sizeof(int)*MAX_SIZE) ;
     blues = malloc(sizeof(int)*MAX_SIZE) ;
     triangles_order = malloc(sizeof(int)*MAX_SIZE) ;
-    triangles_areas = malloc(sizeof(double)*MAX_SIZE) ;
+    //triangles_areas = malloc(sizeof(double)*MAX_SIZE) ;
     visited_tri = malloc(sizeof(bool)*MAX_SIZE) ;
     for(int k = 0; k < MAX_SIZE; k++) {
         triangles_to_render[k] = malloc(sizeof(pt_2d)*3);
@@ -505,6 +505,26 @@ bool inside_fov(double px, double py) {
     return true ;
 }
 
+pt_2d bounding_box_botleft(int k) {
+    pt_2d res;
+    res.x = mind(triangles_to_render[k][0].x, mind(triangles_to_render[k][1].x, triangles_to_render[k][2].x));
+    res.y = mind(triangles_to_render[k][0].y, mind(triangles_to_render[k][1].y, triangles_to_render[k][2].y));
+    return res;
+}
+
+pt_2d bounding_box_topright(int k) {
+    pt_2d res;
+    res.x = maxd(triangles_to_render[k][0].x, maxd(triangles_to_render[k][1].x, triangles_to_render[k][2].x));
+    res.y = maxd(triangles_to_render[k][0].y, maxd(triangles_to_render[k][1].y, triangles_to_render[k][2].y));
+    return res;
+}
+
+bool bbox_inside_cam(int k) {
+    pt_2d btl = bounding_box_botleft(k);
+    pt_2d tpr = bounding_box_topright(k);
+    return !(tpr.x <= 0.0 || btl.x >= 1500.0 || tpr.y <= 0.0 || btl.y >= 1000.0);
+}
+
 void addTriangle(
     double x0, double y0, double z0,
     double x1, double y1, double z1,
@@ -519,7 +539,6 @@ void addTriangle(
     double mpx0; double mpy0; double mpz0;
     double mpx1; double mpy1; double mpz1;
     double mx0, my0, mz0, mx1, my1, mz1;
-    double fx0, fy0, fz0, fx1, fy1, fz1;
     project_to_camera(x0, y0, z0, &px0, &py0, &pz0);
     project_to_camera(x1, y1, z1, &px1, &py1, &pz1);
     project_to_camera(x2, y2, z2, &px2, &py2, &pz2);
@@ -528,20 +547,20 @@ void addTriangle(
             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, getZbuffer(px0, py0, 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, getZbuffer(px1, py1, 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, getZbuffer(px2, py2, pz2));
+            if(bbox_inside_cam(triangles_i)) {
                 triangles_og_coords[triangles_i][0] = to_pt_2d(px0, py0, pz0);
                 triangles_og_coords[triangles_i][1] = to_pt_2d(px1, py1, pz1);
                 triangles_og_coords[triangles_i][2] = to_pt_2d(px2, py2, pz2);
-            triangles_areas[triangles_i] = area_of_triangle(triangles_to_render[triangles_i]);
+                //triangles_areas[triangles_i] = area_of_triangle(triangles_to_render[triangles_i]);
                 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
-                fx0 = x1 ; fy0 = y1 ; fz0 = z1 ;
                 fpx0 = px1 ; fpy0 = py1 ; fpz0 = pz1 ;
-                fx1 = x2 ; fy1 = y2 ; fz1 = z2 ;
                 fpx1 = px2 ; fpy1 = py2 ; fpz1 = pz2 ;
                 mx0 = convex_pt(x1, x0, (pz1 - draw_constant)/(pz1 - pz0));
                 my0 = convex_pt(y1, y0, (pz1 - draw_constant)/(pz1 - pz0));
@@ -556,9 +575,7 @@ void addTriangle(
                 project_to_camera(mx1, my1, mz1, &mpx1, &mpy1, &mpz1) ;
             } else if(pz1 < draw_constant) {     
                 // pz0 >= draw_constant and pz2 >+ draw_constant
-                fx0 = x0 ; fy0 = y0 ; fz0 = z0 ;
                 fpx0 = px0 ; fpy0 = py0 ; fpz0 = pz0 ;
-                fx1 = x2 ; fy1 = y2 ; fz1 = z2 ;
                 fpx1 = px2 ; fpy1 = py2 ; fpz1 = pz2 ;
                 mx0 = convex_pt(x0, x1, (pz0 - draw_constant)/(pz0 - pz1));
                 my0 = convex_pt(y0, y1, (pz0 - draw_constant)/(pz0 - pz1));
@@ -573,9 +590,7 @@ void addTriangle(
                 project_to_camera(mx1, my1, mz1, &mpx1, &mpy1, &mpz1) ;
             } else /*if(pz2 < draw_constant)*/ {     
                 // pz1 >= draw_constant and pz0 >+ draw_constant
-                fx0 = x0 ; fy0 = y0 ; fz0 = z0 ;
                 fpx0 = px0 ; fpy0 = py0 ; fpz0 = pz0 ;
-                fx1 = x1 ; fy1 = y1 ; fz1 = z1 ;
                 fpx1 = px1 ; fpy1 = py1 ; fpz1 = pz1 ;
                 mx0 = convex_pt(x0, x2, (pz0 - draw_constant)/(pz0 - pz2));
                 my0 = convex_pt(y0, y2, (pz0 - draw_constant)/(pz0 - pz2));
@@ -593,24 +608,29 @@ void addTriangle(
             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, getZbuffer(fpx0, fpy0, 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, getZbuffer(mpx0, mpy0, 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, getZbuffer(fpx1, fpy1, fpz1));
+            if(bbox_inside_cam(triangles_i)) {
                 triangles_og_coords[triangles_i][0] = to_pt_2d(fpx0, fpy0, fpz0);
                 triangles_og_coords[triangles_i][1] = to_pt_2d(mpx0, mpy0, mpz0);
                 triangles_og_coords[triangles_i][2] = to_pt_2d(fpx1, fpy1, fpz1);
-            triangles_areas[triangles_i] = area_of_triangle(triangles_to_render[triangles_i]);
-            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, getZbuffer(mpx0, mpy0, 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, getZbuffer(mpx1, mpy1, 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, getZbuffer(fpx1, fpy1, fpz1));
-            triangles_og_coords[triangles_i+1][0] = to_pt_2d(mpx0, mpy0, mpz0);
-            triangles_og_coords[triangles_i+1][1] = to_pt_2d(mpx1, mpy1, mpz1);
-            triangles_og_coords[triangles_i+1][2] = to_pt_2d(fpx1, fpy1, fpz1);
-            triangles_areas[triangles_i+1] = area_of_triangle(triangles_to_render[triangles_i+1]);
                 reds[triangles_i] = red ;
                 greens[triangles_i] = green ;
                 blues[triangles_i] = blue ;
-            reds[triangles_i+1] = red ;
+                triangles_i += 1;
-            greens[triangles_i+1] = green ;
+            }
-            blues[triangles_i+1] = blue ;
+            //triangles_areas[triangles_i] = area_of_triangle(triangles_to_render[triangles_i]);
-            triangles_i += 2 ;
+            triangles_to_render[triangles_i][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, getZbuffer(mpx0, mpy0, mpz0));
+            triangles_to_render[triangles_i][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, getZbuffer(mpx1, mpy1, mpz1));
+            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, getZbuffer(fpx1, fpy1, fpz1));
+            if(bbox_inside_cam(triangles_i)) {
+                triangles_og_coords[triangles_i][0] = to_pt_2d(mpx0, mpy0, mpz0);
+                triangles_og_coords[triangles_i][1] = to_pt_2d(mpx1, mpy1, mpz1);
+                triangles_og_coords[triangles_i][2] = to_pt_2d(fpx1, fpy1, fpz1);
+                reds[triangles_i] = red ;
+                greens[triangles_i] = green ;
+                blues[triangles_i] = blue ;
+                triangles_i += 1;
+            }
+            //triangles_areas[triangles_i+1] = area_of_triangle(triangles_to_render[triangles_i+1]);
         } else if((pz0 >= draw_constant) + (pz1 >= draw_constant) + (pz2 >= draw_constant) == 1) {
             if(pz0 >= draw_constant) {
                 project_to_camera(
@@ -650,14 +670,16 @@ void addTriangle(
             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, getZbuffer(px0, py0, 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, getZbuffer(px1, py1, 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, getZbuffer(px2, py2, pz2));
+            if(bbox_inside_cam(triangles_i)) {
                 triangles_og_coords[triangles_i][0] = to_pt_2d(px0, py0, pz0);
                 triangles_og_coords[triangles_i][1] = to_pt_2d(px1, py1, pz1);
                 triangles_og_coords[triangles_i][2] = to_pt_2d(px2, py2, pz2);
-            triangles_areas[triangles_i] = area_of_triangle(triangles_to_render[triangles_i]);
+                //triangles_areas[triangles_i] = area_of_triangle(triangles_to_render[triangles_i]);
                 reds[triangles_i] = red ;
                 greens[triangles_i] = green ;
                 blues[triangles_i] = blue ;
                 triangles_i += 1;
+            }
         } else {
             
         }
@@ -756,14 +778,43 @@ void renderTriangleFull(SDL_Renderer* renderer, int k) {
     );
 }
 
-double deltaz ;
+void remove_hidden(SDL_Renderer* renderer) {
-void visiting(int k, bool vflag) {
+    printf("%d --> ", triangles_i);
+    for(int k = 0; k < triangles_i; k++) {
+        int halt = 1 ;
+        bool fst = false ;
+        bool snd = false ;
+        bool thd = false ;
+        for(int l = 0; l < halt*triangles_i; l++) {
+            if(l != k) {
+                fst = fst || (is_hidden(renderer, triangles_to_render[k][0], triangles_og_coords[k][0], triangles_to_render[l], triangles_og_coords[l]));
+                snd = snd || (is_hidden(renderer, triangles_to_render[k][1], triangles_og_coords[k][1], triangles_to_render[l], triangles_og_coords[l]));
+                thd = thd || (is_hidden(renderer, triangles_to_render[k][2], triangles_og_coords[k][2], triangles_to_render[l], triangles_og_coords[l]));
+                if(fst && snd && thd) {
+                    triangles_to_render[k][0] = triangles_to_render[triangles_i-1][0] ;
+                    triangles_to_render[k][1] = triangles_to_render[triangles_i-1][1] ;
+                    triangles_to_render[k][2] = triangles_to_render[triangles_i-1][2] ;
+                    reds[k] = reds[triangles_i-1];
+                    greens[k] = greens[triangles_i-1];
+                    blues[k] = blues[triangles_i-1];
+                    //triangles_areas[k] = triangles_areas[triangles_i-1];
+                    triangles_i -= 1;
+                    k -= 1;
+                    halt = 0;
+                }
+            }
+        }
+    }
+    printf("%d\n", triangles_i);
+}
+
+void visit(int k, bool vflag) {
     if(visited_tri[k] != vflag) {
         visited_tri[k] = vflag ;
-        for(int kk = 0; kk < triangles_i; kk++) {
+        for(int l = 0; l < triangles_i; l++) {
-            if(visited_tri[kk] != vflag) {
+            if(l != k && visited_tri[l] != vflag) {
-                if(delta_get(triangles_to_render[k], triangles_og_coords[k], triangles_to_render[kk], triangles_og_coords[kk], &deltaz) && deltaz > 0.001) {
+                if(is_in_front(triangles_to_render[k], triangles_og_coords[k], triangles_to_render[l], triangles_og_coords[l])) {
-                    visiting(kk, vflag);
+                    visit(l, vflag);
                 }
             }
         }
@@ -775,47 +826,18 @@ void visiting(int k, bool vflag) {
 void topological_sort() {
     bool vflag = !visited_tri[0];
     for(int k = 0; k < triangles_i; k++) {
-        visiting(k, vflag);
+        visit(k, vflag);
     }
 }
 
-void remove_hidden(SDL_Renderer* renderer) {
-    printf("%d --> ", triangles_i);
-    for(int k = 0; k < triangles_i; k++) {
-        int halt = 1 ;
-        bool fst = false ;
-        bool snd = false ;
-        bool thd = false ;
-        for(int l = 0; l < halt*triangles_i; l++) {
-            if(l != k) {
-                fst = fst || (is_hidden(renderer, triangles_to_render[k][0], triangles_og_coords[k][0], triangles_to_render[l], triangles_og_coords[l], triangles_areas[l]));
-                snd = snd || (is_hidden(renderer, triangles_to_render[k][1], triangles_og_coords[k][1], triangles_to_render[l], triangles_og_coords[l], triangles_areas[l]));
-                thd = thd || (is_hidden(renderer, triangles_to_render[k][2], triangles_og_coords[k][2], triangles_to_render[l], triangles_og_coords[l], triangles_areas[l]));
-                if(fst && snd && thd) {
-                    triangles_to_render[k][0] = triangles_to_render[triangles_i-1][0] ;
-                    triangles_to_render[k][1] = triangles_to_render[triangles_i-1][1] ;
-                    triangles_to_render[k][2] = triangles_to_render[triangles_i-1][2] ;
-                    reds[k] = reds[triangles_i-1];
-                    greens[k] = greens[triangles_i-1];
-                    blues[k] = blues[triangles_i-1];
-                    triangles_areas[k] = triangles_areas[triangles_i-1];
-                    triangles_i -= 1;
-                    k -= 1;
-                    halt = 0;
-                }
-            }
-        }
-    }
-    printf("%d\n", triangles_i);
-}
-
 void drawCurrentRoom(SDL_Renderer* renderer) {
     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);
-    remove_hidden(renderer);
+    topological_sort();
+    //remove_hidden(renderer);
     //topological_sort();
     for(int k = 0; k < triangles_i; k++) {
         renderTriangleFull(renderer, triangles_order[k]);

src/entities.c

@@ -71,6 +71,8 @@ void detectHit(float dtime, int* hp, int* dmg, cube_0* ret) {
         ret->green = 192;
         ret->blue = 0;
         coins += *hp;
+        player_hp -= 10*(*hp);
+        fade_dmg = 255 ;
         *hp = 0 ;
     }
 }

src/main.c

@@ -81,8 +81,11 @@ int main(int argc, char** argv) {
 
         drawCurrentRoom(rend);
         drawData(rend) ;
+        drawHPbar(rend);
         finish = clock();
 
+        fade_dmg = max(fade_dmg-5, 0);
+
         delta = ((float)finish - (float)origin)/CLOCKS_PER_SEC;
         drawNumberToRenderer(rend, digits, (int)(1.0f/delta), 720, 60, 75/2, 105/2, 0);
         drawNumberToRenderer(rend, digits, (int)(10*sim_time), 720, 110, 75/2, 105/2, 0);

src/move.c

@@ -24,6 +24,8 @@ double speed = 0.22 ;
 double min_dist = 0.7 ;
 // ---------------------------------------------------------------------------------------------------- //
 
+int player_hp ;
+
 double camx ;
 double camy ;
 double camz ;
@@ -34,6 +36,7 @@ double rot_vt ;
 double tan_fov ;
 
 int draw_type ;
+int fade_dmg ;
 
 bool has_changed ;
 
@@ -44,6 +47,8 @@ void init_csts() {
     rot_hz = 0.0 ;
     rot_vt = 180.0 ;
     draw_type = 0 ;
+    player_hp = 1000 ;
+    fade_dmg = 0;
     tan_fov = tan((fov * 3.14159 / 180.0) / 2.0) ;
 }
 
@@ -200,3 +205,23 @@ void playerActions(float dtime) {
         rot_vt += sensitivity ;
     }
 }
+
+void drawHPbar(SDL_Renderer* renderer) {
+    SDL_Rect r ;
+    r.x = 1400 ;
+    r.y = 100 ;
+    r.w = 50 ;
+    r.h = 800 ;
+    SDL_SetRenderDrawColor(renderer, 96, 96, 96, SDL_ALPHA_OPAQUE);
+    SDL_RenderFillRect(renderer, &r);
+    r.x += 10 ;
+    r.w -= 20 ;
+    r.y += 10 ;
+    r.h -= 20 ;
+    SDL_SetRenderDrawColor(renderer, 32, 32, 32, SDL_ALPHA_OPAQUE);
+    SDL_RenderFillRect(renderer, &r);
+    r.y = 110+(780*(1000-player_hp))/1000 ;
+    r.h = 780-r.y+110 ;
+    SDL_SetRenderDrawColor(renderer, fade_dmg, 255-fade_dmg, 32, SDL_ALPHA_OPAQUE);
+    SDL_RenderFillRect(renderer, &r);
+}

src/move.h

@@ -5,4 +5,6 @@ void init_csts();
 bool is_colliding(float dtime);
 void playerActions(float dtime);
 
+void drawHPbar(SDL_Renderer* renderer);
+
 #endif

src/structure.h

@@ -120,4 +120,8 @@ extern pt_2d** triangles_og_coords ;
 extern double* triangles_areas;
 extern int triangles_i ;
 
+extern int player_hp ;
+
+extern int fade_dmg ;
+
 #endif

src/triangles.c

@@ -261,12 +261,8 @@ bool point_in_triangle(pt_2d pt, pt_2d v1, pt_2d v2, pt_2d v3, double* thetaA, d
 
 bool seg_seg_inter(pt_2d p1, pt_2d p2, pt_2d p3, pt_2d p4, double* ret0, double* ret1) {
     double deno = (p4.x - p3.x)*(p2.y - p1.y) - (p4.y - p3.y)*(p2.x - p1.x);
-    if(0.0 <= deno && deno <= 0.001) {
+    if(absf(deno) <= 0.0001) {
-        //printf("%lf -->", deno);
+        return false;
-        deno = 0.001 ;
-    } else if(-0.001 <= deno && deno <= 0.0) {
-        //printf("%lf -->", deno);
-        deno = -0.001 ;
     }
     //printf("%lf\n", deno);
     double alpha = 
@@ -282,83 +278,7 @@ bool seg_seg_inter(pt_2d p1, pt_2d p2, pt_2d p3, pt_2d p4, double* ret0, double*
     return (alpha >= 0.0 && alpha <= 1.0 && beta >= 0.0 && beta <= 1.0);
 }
 
-void print_tri(pt_2d* t) {
+void get_barycentric(pt_2d p, pt_2d* tri, double* retu, double* retv, double* retw) {
-    printf("T :\n    (%lf, %lf, %lf)\n    (%lf, %lf, %lf)\n    (%lf, %lf, %lf)\n", t[0].x, t[0].y, t[0].z, t[1].x, t[1].y, t[1].z, t[2].x, t[2].y, t[2].z);
-}
-
-double triangle_dist(pt_2d* tri) {
-    return (tri[0].z + tri[1].z + tri[2].z);
-}
-
-bool delta_get2(pt_2d* tri1, pt_2d* tri2, double* ret) {
-    if(triangleIntersection(tri1, tri2)) {
-        if(ret != NULL) {
-            *ret = triangle_dist(tri2) - triangle_dist(tri1);
-        }
-        return true;
-    } else {
-        return false ;
-    }
-}
-
-bool delta_get(pt_2d* tri1, pt_2d* og1, pt_2d* tri2, pt_2d* og2, double* ret) {
-    double th1 = 0.0;
-    double th2 = 0.0;
-    double th3 = 0.0;
-    /*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) {
-                pt_2d* trio2 = og2;
-                pt_2d proj = convex_pt2d_tri(trio2[0], th1, trio2[1], th2, trio2[2], th3);
-                pt_2d* trio1 = og1;
-                printf("[1 in 2] %lf, %lf, %lf\n", proj.x/trio1[k].x, proj.y/trio1[k].y, proj.z/trio1[k].z);
-                *ret = sqrt(proj.z*proj.z + proj.y*proj.y + proj.x*proj.x) - sqrt(trio1[k].z*trio1[k].z + trio1[k].y*trio1[k].y + trio1[k].x*trio1[k].x);
-            }
-            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) {
-                pt_2d* trio1 = og1;
-                pt_2d proj = convex_pt2d_tri(trio1[0], th1, trio1[1], th2, trio1[2], th3);
-                pt_2d* trio2 = og2;
-                printf("[2 in 1] %lf, %lf, %lf\n", proj.x/trio2[k].x, proj.y/trio2[k].y, proj.z/trio2[k].z);
-                *ret = sqrt(trio2[k].z*trio2[k].z + trio2[k].y*trio2[k].y + trio2[k].x*trio2[k].x) - sqrt(proj.z*proj.z + proj.y*proj.y + proj.x*proj.x);
-            }
-            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);
-                if(ret != NULL) {
-                    pt_2d proj1 = convex_pt2d(og1[k1], og1[(k1+1)%3], th1);
-                    pt_2d proj2 = convex_pt2d(og2[k2], og2[(k2+1)%3], th2);
-                    printf("[Seg Seg] %lf, %lf, %lf - ", proj1.x/proj2.x, proj1.y/proj2.y, proj1.z/proj2.z);
-                    printf("{%lf}\n", maxd(absf(proj1.x/proj2.x-1), maxd(absf(proj1.y/proj2.y-1), absf(proj1.z/proj2.z-1))));
-                    *ret = distance_pt_pt_3d(proj2.x, proj2.y, proj2.z, 0.0, 0.0, 0.0);
-                    *ret -= distance_pt_pt_3d(proj1.x, proj1.y, proj1.z, 0.0, 0.0, 0.0);
-                }
-                return true;
-            }
-        }
-    }
-    return false;
-}
-
-double subarea(pt_2d A, pt_2d B, pt_2d C) {
-    return (0.005*absf(A.x*B.y - A.x*C.y + B.x*C.y - B.x*A.y + C.x*A.y - C.x*B.y));
-}
-
-double area_of_triangle(pt_2d* t) {
-    return subarea(t[0], t[1], t[2]);
-}
-
-void get_barycentric(pt_2d p, pt_2d* tri, double area, double* retu, double* retv, double* retw) {
     pt_2d a = tri[0] ; pt_2d b = tri[1] ; pt_2d c = tri[2] ;
     pt_2d v0 = vect_diff(b, a);
     pt_2d v1 = vect_diff(c, a);
@@ -384,14 +304,14 @@ bool pt_equal(pt_2d p1, pt_2d p2, double epsilon) {
     return (absf(p2.x - p1.x) <= epsilon && absf(p2.y - p1.y) <= epsilon && absf(p2.z - p1.z) <= epsilon) ;
 }
 
-bool is_hidden(SDL_Renderer* renderer, pt_2d p, pt_2d ogp, pt_2d* tri, pt_2d* og, double area) {
+bool is_hidden(SDL_Renderer* renderer, pt_2d p, pt_2d ogp, pt_2d* tri, pt_2d* og) {
-    if(pt_equal(p, tri[0], 0.001) || pt_equal(p, tri[1], 0.001) || pt_equal(p, tri[2], 0.001)) {
+    if(pt_equal(p, tri[0], 0.0001) || pt_equal(p, tri[1], 0.0001) || pt_equal(p, tri[2], 0.0001)) {
         return false;
     }
     double u = 0.0 ;
     double v = 0.0 ;
     double w = 0.0 ;
-    get_barycentric(p, tri, area, &u, &v, &w);
+    get_barycentric(p, tri, &u, &v, &w);
     pt_2d mid = convex_pt2d_tri(og[0], u, og[1], v, og[2], w);
     if(renderer != NULL && (u >= 0.0) && (v >= 0.0) && (w >= 0.0) && (u+v+w <= 1.0)) {
         if(mid.z >= 0.4) {
@@ -409,3 +329,49 @@ bool is_hidden(SDL_Renderer* renderer, pt_2d p, pt_2d ogp, pt_2d* tri, pt_2d* og
     }
     return false;
 }
+
+bool nonzero(double tha, double thb, double thc, double epsilon) {
+    return (absf(tha) > epsilon && absf(thb) > epsilon && absf(thc) > epsilon);
+}
+
+bool is_in_front(pt_2d* tri1, pt_2d* og1, pt_2d* tri2, pt_2d* og2) {
+    for(int k = 0; k < 3; k++) {
+        pt_2d p = tri1[k];
+        if(pt_equal(p, tri2[0], 0.0001) || pt_equal(p, tri2[1], 0.0001) || pt_equal(p, tri2[2], 0.0001)) {
+            return false;
+        }
+        double u = 0.0 ;
+        double v = 0.0 ;
+        double w = 0.0 ;
+        get_barycentric(p, tri2, &u, &v, &w);
+        pt_2d mid = convex_pt2d_tri(og2[0], u, og2[1], v, og2[2], w);
+        if(((u >= 0.0) && (v >= 0.0) && (w >= 0.0) && (u+v+w <= 1.0)) && nonzero(u, v, w, 0.0001)) {
+            return !(proj_pt_distance_to_camera(mid) <= proj_pt_distance_to_camera(og1[k]));
+        }
+    }
+    for(int k = 0; k < 3; k++) {
+        pt_2d p = tri2[k];
+        if(pt_equal(p, tri1[0], 0.0001) || pt_equal(p, tri1[1], 0.0001) || pt_equal(p, tri1[2], 0.0001)) {
+            return false;
+        }
+        double u = 0.0 ;
+        double v = 0.0 ;
+        double w = 0.0 ;
+        get_barycentric(p, tri1, &u, &v, &w);
+        pt_2d mid = convex_pt2d_tri(og1[0], u, og1[1], v, og1[2], w);
+        if(((u >= 0.0) && (v >= 0.0) && (w >= 0.0) && (u+v+w <= 1.0)) && nonzero(u, v, w, 0.0001)) {
+            return !(proj_pt_distance_to_camera(mid) >= proj_pt_distance_to_camera(og2[k]));
+        }
+    }
+    for(int k1 = 0; k1 < 3; k1++) {
+        for(int k2 = 0; k2 < 3; k2++) {
+            double th1, th2;
+            if(seg_seg_inter(tri1[k1], tri1[(k1+1)%3], tri2[k2], tri2[(k2+1)%3], &th1, &th2)) {
+                pt_2d mid1 = convex_pt2d(tri1[k1], tri1[(k1+1)%3], th1);
+                pt_2d mid2 = convex_pt2d(tri2[k2], tri2[(k2+1)%3], th2);
+                return (proj_pt_distance_to_camera(mid1) <= proj_pt_distance_to_camera(mid2));
+            }
+        }
+    }
+    return false;
+}

src/triangles.h

@@ -13,9 +13,8 @@ bool triangleIntersection(pt_2d* tri1, pt_2d* tri2);
 bool triangleIntersectionDec(pt_2d t1_1, pt_2d t1_2, pt_2d t1_3, pt_2d t2_1, pt_2d t2_2, pt_2d t2_3);
 bool multipleTrianglesIntersection(pt_2d* tri1, int len1, pt_2d* tri2, int len2, int* ret1, int* ret2);
 
-bool delta_get(pt_2d* tri1, pt_2d* og1, pt_2d* tri2, pt_2d* og2, double* ret) ;
+bool is_in_front(pt_2d* tri1, pt_2d* og1, pt_2d* tri2, pt_2d* og2);
 
-double area_of_triangle(pt_2d* t);
+bool is_hidden(SDL_Renderer* renderer, pt_2d p, pt_2d ogp, pt_2d* tri, pt_2d* og);
-bool is_hidden(SDL_Renderer* renderer, pt_2d p, pt_2d ogp, pt_2d* tri, pt_2d* og, double area);
 
 #endif