alexandre
/
binding-of-isaac
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

working-ish depth detection

This commit is contained in:
Alexandre 2025-01-22 19:50:43 +01:00
parent 9eb127bdcd
commit 7091c822f6
14 changed files with 194 additions and 171 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
bin/back
View File

Binary file not shown.

BIN
obj/display.o
View File

Binary file not shown.

BIN
obj/entities.o
View File

Binary file not shown.

BIN
obj/main.o
View File

Binary file not shown.

BIN
obj/move.o
View File

Binary file not shown.

BIN
obj/triangles.o
View File

Binary file not shown.

186
src/display.c
View File

@ -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));
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]);
reds[triangles_i] = red ;
greens[triangles_i] = green ;
blues[triangles_i] = blue ;
triangles_i += 1;
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]);
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));
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 ;
greens[triangles_i+1] = green ;
blues[triangles_i+1] = blue ;
triangles_i += 2 ;
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);
reds[triangles_i] = red ;
greens[triangles_i] = green ;
blues[triangles_i] = blue ;
triangles_i += 1;
}
//triangles_areas[triangles_i] = area_of_triangle(triangles_to_render[triangles_i]);
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));
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]);
reds[triangles_i] = red ;
greens[triangles_i] = green ;
blues[triangles_i] = blue ;
triangles_i += 1;
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]);
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 visiting(int k, bool 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]));
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++) {
if(visited_tri[kk] != vflag) {
if(delta_get(triangles_to_render[k], triangles_og_coords[k], triangles_to_render[kk], triangles_og_coords[kk], &deltaz) && deltaz > 0.001) {
visiting(kk, vflag);
visited_tri[k] = vflag ;
for(int l = 0; l < triangles_i; l++) {
if(l != k && visited_tri[l] != vflag) {
if(is_in_front(triangles_to_render[k], triangles_og_coords[k], triangles_to_render[l], triangles_og_coords[l])) {
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]);

2
src/entities.c
View File

@ -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 ;
}
}

3
src/main.c
View File

@ -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);

25
src/move.c
View File

@ -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) ;
}
@ -199,4 +204,24 @@ void playerActions(float dtime) {
if(state[SDL_SCANCODE_M] == 1) {
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);
}

2
src/move.h
View File

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

4
src/structure.h
View File

@ -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

138
src/triangles.c
View File

@ -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) {
//printf("%lf -->", deno);
deno = 0.001 ;
} else if(-0.001 <= deno && deno <= 0.0) {
//printf("%lf -->", deno);
deno = -0.001 ;
if(absf(deno) <= 0.0001) {
return false;
}
//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) {
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) {
void get_barycentric(pt_2d p, pt_2d* tri, 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) {
if(pt_equal(p, tri[0], 0.001) || pt_equal(p, tri[1], 0.001) || pt_equal(p, tri[2], 0.001)) {
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.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) {
@ -408,4 +328,50 @@ bool is_hidden(SDL_Renderer* renderer, pt_2d p, pt_2d ogp, pt_2d* tri, pt_2d* og
return (proj_pt_distance_to_camera(mid) <= proj_pt_distance_to_camera(ogp));
}
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;
}

5
src/triangles.h
View File

@ -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, double area);
bool is_hidden(SDL_Renderer* renderer, pt_2d p, pt_2d ogp, pt_2d* tri, pt_2d* og);
#endif