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

save #2

This commit is contained in:
Alexandre 2025-01-20 19:38:06 +01:00
parent 7ae206b6c4
commit fc1c266b49
8 changed files with 160 additions and 330 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/triangles.o
View File

Binary file not shown.

370
src/display.c
View File

@ -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);
addTriangle(px0, py0, pz0, px1, py1, pz1, px2, py2, pz2, red, green, blue);
}
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,
// -------------------------------------------------------------------------------------------------------------------------------- //
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
);
renderTriangleRotated(renderer,
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) { // y
renderTriangleRotated(renderer,
c.x, c.y + c.h*(sf==2), c.z,
} 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
);
renderTriangleRotated(renderer,
c.x, c.y + c.h*(sf==2), c.z,
c.x, c.y + c.h*(sf==2), c.z + c.d,
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
renderTriangleRotated(renderer,
c.x, c.y, c.z + c.d*(sf==4),
c.x + c.w, c.y, c.z + c.d*(sf==4),
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
);
renderTriangleRotated(renderer,
c.x, c.y, c.z + c.d*(sf==4),
c.x, c.y + c.h, c.z + c.d*(sf==4),
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 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);
}
}
// -------------------------------------------------------------------------------------------------------------------------------- //
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) {
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]) < 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;
}
}
add_single(arr[k]);
}
}
void insertionSort_tp(teleporter* 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].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].hitbox);
}
}
void insertionSort_ent(entity* arr, int len) {
void add_triangles_ent(entity* 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].pos));
}
}
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 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]);
}
}

17
src/display.h
View File

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

2
src/structure.h
View File

@ -115,5 +115,7 @@ extern int draw_type ;
extern double draw_constant ;
extern pt_2d** triangles_to_render ;
extern int triangles_i ;
#endif

49
src/triangles.c
View File

@ -482,21 +482,21 @@ 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;
}
@ -504,42 +504,3 @@ bool delta_get(pt_2d* tri1, pt_2d* tri2, double* ret) {
}
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;
}

2
src/triangles.h
View File

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