mp2i-vms.fr
855 lines
36 KiB
C
855 lines
36 KiB
C
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <assert.h>
|
|
#include <math.h>
|
|
#include <stdbool.h>
|
|
#include <ncurses.h>
|
|
#include <unistd.h>
|
|
#include <termios.h>
|
|
#include <limits.h>
|
|
#include <time.h>
|
|
#include <SDL2/SDL.h>
|
|
#include <SDL2/SDL_image.h>
|
|
|
|
#include "hash.h"
|
|
#include "structure.h"
|
|
#include "base.h"
|
|
#include "triangles.h"
|
|
#include "move.h"
|
|
#include "entities.h"
|
|
#include "generation.h"
|
|
#include "display.h"
|
|
|
|
int flashlight = 0 ;
|
|
|
|
int MAX_SIZE = 8192 ;
|
|
|
|
int* drawOrder;
|
|
|
|
double draw_constant ;
|
|
|
|
pt_2d** triangles_to_render ;
|
|
pt_2d** triangles_og_coords ;
|
|
double* triangles_areas ;
|
|
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) ;
|
|
draw_constant = 0.4 ;
|
|
triangles_to_render = malloc(sizeof(pt_2d*)*MAX_SIZE) ;
|
|
triangles_og_coords = malloc(sizeof(pt_2d*)*MAX_SIZE) ;
|
|
reds = malloc(sizeof(int)*MAX_SIZE) ;
|
|
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) ;
|
|
visited_tri = malloc(sizeof(bool)*MAX_SIZE) ;
|
|
for(int k = 0; k < MAX_SIZE; k++) {
|
|
triangles_to_render[k] = malloc(sizeof(pt_2d)*3);
|
|
triangles_og_coords[k] = malloc(sizeof(pt_2d)*3);
|
|
triangles_order[k] = k;
|
|
}
|
|
triangles_i = 0;
|
|
visited_i = 0;
|
|
}
|
|
|
|
void updateRenderer(SDL_Renderer* renderer) {
|
|
//printf("E");
|
|
SDL_RenderPresent(renderer);
|
|
}
|
|
|
|
void resetRenderer(SDL_Renderer* renderer) {
|
|
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
|
|
SDL_RenderClear(renderer);
|
|
}
|
|
|
|
void drawRectToRenderer(SDL_Renderer* renderer, SDL_Rect* rect, int R, int G, int B, int A) {
|
|
SDL_SetRenderDrawColor(renderer, R, G, B, A);
|
|
SDL_RenderFillRect(renderer, rect);
|
|
}
|
|
|
|
void placeRectToRenderer(SDL_Renderer* renderer, int X, int Y, int W, int H, int R, int G, int B, int A) {
|
|
SDL_Rect rect;
|
|
rect.x = X;
|
|
rect.y = Y;
|
|
rect.w = W;
|
|
rect.h = H;
|
|
SDL_SetRenderDrawColor(renderer, R, G, B, A);
|
|
SDL_RenderFillRect(renderer, &rect);
|
|
}
|
|
|
|
void placeRectToRendererNoColor(SDL_Renderer* renderer, int X, int Y, int W, int H) {
|
|
SDL_Rect rect;
|
|
rect.x = X;
|
|
rect.y = Y;
|
|
rect.w = W;
|
|
rect.h = H;
|
|
SDL_RenderFillRect(renderer, &rect);
|
|
}
|
|
|
|
void drawLineWithThicc(SDL_Renderer* renderer, int width, int x1, int x2, int y1, int y2, int R, int G, int B, int A) {
|
|
// draws line with width (native SDL cannot do that)
|
|
double theta = 0.0;
|
|
double seglen = distance_pt_pt_3d(x1, y1, 0.0, x2, y2, 0.0);
|
|
while(theta < 1.0) {
|
|
placeRectToRenderer(renderer, convex_seg(x1, x2, theta)-width/2, convex_seg(y1, y2, theta)-width/2, width, width, R, G, B, A);
|
|
theta += 1 / seglen;
|
|
}
|
|
}
|
|
|
|
void drawLineWithThiccNoColor(SDL_Renderer* renderer, int width, int x1, int x2, int y1, int y2) {
|
|
// draws line with width (native SDL cannot do that)
|
|
double theta = 0.0;
|
|
double seglen = distance_pt_pt_3d(x1, y1, 0.0, x2, y2, 0.0);
|
|
while(theta < 1.0) {
|
|
placeRectToRendererNoColor(renderer, convex_seg(x1, x2, theta)-width/2, convex_seg(y1, y2, theta)-width/2, width, width);
|
|
theta += 1 / seglen;
|
|
}
|
|
}
|
|
|
|
void drawLineWithThiccGradient(SDL_Renderer* renderer, int start_width, int end_width, int x1, int x2, int y1, int y2, int R, int G, int B, int A) {
|
|
// draws line with width ;
|
|
// width goes from start_width to end_with in a linear way
|
|
double theta = 0.0;
|
|
double seglen = distance_pt_pt_3d(x1, y1, 0.0, x2, y2, 0.0);
|
|
while(theta < 1.0) {
|
|
int width = convex_seg(start_width, end_width, theta) ;
|
|
placeRectToRenderer(renderer, convex_seg(x1, x2, theta)-width/2, convex_seg(y1, y2, theta)-width/2, width, width, R, G, B, A);
|
|
theta += 1 / seglen;
|
|
}
|
|
}
|
|
|
|
void drawDigitToRenderer(SDL_Renderer* renderer, imgs data, int digit, int X, int Y, int W, int H) {
|
|
if(digit == -727) {
|
|
SDL_Rect rect;
|
|
rect.x = X;
|
|
rect.y = Y;
|
|
rect.w = W;
|
|
rect.h = H;
|
|
|
|
SDL_Texture* texture = data.arr[10];
|
|
|
|
SDL_RenderCopy(renderer, texture, NULL, &rect);
|
|
} else if (!(0 <= digit && digit <= 9)) {
|
|
fprintf(stderr, "Illegal digit : '%d'.\n", digit);
|
|
exit(1);
|
|
} else {
|
|
SDL_Rect rect;
|
|
rect.x = X;
|
|
rect.y = Y;
|
|
rect.w = W;
|
|
rect.h = H;
|
|
|
|
SDL_Texture* texture = data.arr[digit];
|
|
|
|
SDL_RenderCopy(renderer, texture, NULL, &rect);
|
|
}
|
|
}
|
|
|
|
void drawCharToRenderer(SDL_Renderer* renderer, imgs data, char c, int X, int Y, int W, int H) {
|
|
if ((int)c >= 97 && (int)c <= 122) {
|
|
SDL_Rect rect;
|
|
rect.x = X;
|
|
rect.y = Y;
|
|
rect.w = W;
|
|
rect.h = H;
|
|
|
|
SDL_Texture* texture = data.arr[(int)c - 97];
|
|
|
|
SDL_RenderCopy(renderer, texture, NULL, &rect);
|
|
}
|
|
}
|
|
|
|
void drawNumberToRenderer(SDL_Renderer* renderer, imgs data, int n, int X, int Y, int W, int H, int Woffset) {
|
|
if(n == 0) {
|
|
drawDigitToRenderer(renderer, data, 0, X + W, Y, W, H);
|
|
} else if(n > 0) {
|
|
int toDraw = 0, remaining = n, nIter = ln_baseN(n, 10);
|
|
while(nIter != 0) {
|
|
toDraw = remaining%10;
|
|
remaining = remaining / 10;
|
|
drawDigitToRenderer(renderer, data, toDraw, X + (W-Woffset)*nIter, Y, W, H);
|
|
nIter--;
|
|
}
|
|
} else {
|
|
int toDraw = 0, remaining = -n, nIter = ln_baseN(-n, 10);
|
|
drawDigitToRenderer(renderer, data, -727, X, Y, W, H);
|
|
while(nIter != 0) {
|
|
toDraw = remaining%10;
|
|
remaining = remaining / 10;
|
|
drawDigitToRenderer(renderer, data, toDraw, X + (W-Woffset)*nIter, Y, W, H);
|
|
nIter--;
|
|
}
|
|
}
|
|
}
|
|
|
|
void drawStringToRenderer(SDL_Renderer* renderer, imgs data, char* s, int X, int Y, int W, int H) {
|
|
int k = 0 ;
|
|
while(s[k] != '\0') {
|
|
drawCharToRenderer(renderer, data, s[k], X + W*k, Y, W, H);
|
|
k += 1;
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------- //
|
|
// 3D stuff
|
|
|
|
double pt_z_distance_to_camera(double x, double y, double z) {
|
|
double ret ;
|
|
project_to_camera(x, y, z, NULL, NULL, &ret) ;
|
|
return absf(ret) ;
|
|
}
|
|
|
|
double segment_z_distance_to_camera(double x0, double y0, double z0, double x1, double y1, double z1) {
|
|
double ret0 = pt_z_distance_to_camera(x0, y0, z0);
|
|
double ret1 = pt_z_distance_to_camera(x1, y1, z1);
|
|
double theta = -(
|
|
((x1 - x0) * (x0 - camx) + (y1 - y0) * (y0 - camy) + (z1 - z0) * (z0 - camz)) /
|
|
((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0) + (z1 - z0) * (z1 - z0))
|
|
); // projection factor of camera onto the line
|
|
return absf(convex_pt(ret0, ret1, mind(maxd(theta, 0.0), 1.0)));
|
|
}
|
|
|
|
double square_z_distance_to_camera(
|
|
double x0, double y0, double z0,
|
|
double x1, double y1, double z1,
|
|
double x2, double y2, double z2
|
|
) {
|
|
return maxd(segment_z_distance_to_camera(x0, y0, z0, x1, y1, z1), segment_z_distance_to_camera(x0, y0, z0, x2, y2, z2));
|
|
}
|
|
|
|
double cube_z_distance_to_camera(cube_0 cb) {
|
|
double dist_0 = square_z_distance_to_camera(
|
|
cb.x + cb.w, cb.y, cb.z,
|
|
cb.x + cb.w, cb.y + cb.h, cb.z,
|
|
cb.x + cb.w, cb.y, cb.z + cb.d
|
|
);
|
|
double dist_1 = square_z_distance_to_camera(
|
|
cb.x, cb.y, cb.z,
|
|
cb.x, cb.y + cb.h, cb.z,
|
|
cb.x, cb.y, cb.z + cb.d
|
|
);
|
|
double dist_2 = square_z_distance_to_camera(
|
|
cb.x, cb.y + cb.h, cb.z,
|
|
cb.x + cb.w, cb.y + cb.h, cb.z,
|
|
cb.x, cb.y + cb.h, cb.z + cb.d
|
|
);
|
|
double dist_3 = square_z_distance_to_camera(
|
|
cb.x, cb.y, cb.z,
|
|
cb.x + cb.w, cb.y, cb.z,
|
|
cb.x, cb.y, cb.z + cb.d
|
|
);
|
|
double dist_4 = square_z_distance_to_camera(
|
|
cb.x, cb.y, cb.z + cb.d,
|
|
cb.x + cb.w, cb.y, cb.z + cb.d,
|
|
cb.x, cb.y + cb.h, cb.z + cb.d
|
|
);
|
|
double dist_5 = square_z_distance_to_camera(
|
|
cb.x, cb.y, cb.z,
|
|
cb.x + cb.w, cb.y, cb.z,
|
|
cb.x, cb.y + cb.h, cb.z
|
|
);
|
|
|
|
return maxd(maxd(dist_0, dist_1), maxd(maxd(dist_2, dist_3), maxd(dist_4, dist_5)));
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------- //
|
|
|
|
void rotate_cube(double x0, double y0, double z0, double* rx, double* ry, double* rz, cube_0 cb) {
|
|
// align pt to (0, 0, 0)
|
|
double x = x0 - (cb.x + cb.w/2) ;
|
|
double y = y0 - (cb.y + cb.h/2) ;
|
|
double z = z0 - (cb.z + cb.d/2) ;
|
|
|
|
// rotate (y)
|
|
double xry = x*cos(cb.hz_angle) - z*sin(cb.hz_angle) ;
|
|
double yry = y ;
|
|
double zry = z*cos(cb.hz_angle) + x*sin(cb.hz_angle) ;
|
|
|
|
// rotate (x)
|
|
*rx = (cb.x + cb.w/2) + xry ;
|
|
*ry = (cb.y + cb.h/2) + yry*cos(cb.vt_angle) - zry*sin(cb.vt_angle) ;
|
|
*rz = (cb.z + cb.d/2) + zry*cos(cb.vt_angle) + yry*sin(cb.vt_angle) ;
|
|
}
|
|
|
|
void draw_segment(SDL_Renderer* renderer, double sx, double sy, double sz, double ex, double ey, double ez) {
|
|
double spx ;double spy ;double spz ;double epx ;double epy ;double epz ;
|
|
project_to_camera(sx, sy, sz, &spx, &spy, &spz) ;
|
|
project_to_camera(ex, ey, ez, &epx, &epy, &epz) ;
|
|
if(spz >= draw_constant && epz >= draw_constant) {
|
|
drawLineWithThiccNoColor(renderer, 1,
|
|
(int)(1500.0 * (1.0 + (spx / (1.5 * spz * tan_fov))) / 2.0),
|
|
(int)(1500.0 * (1.0 + (epx / (1.5 * epz * tan_fov))) / 2.0),
|
|
(int)(1000.0 * (1.0 + (spy / (spz * tan_fov))) / 2.0),
|
|
(int)(1000.0 * (1.0 + (epy / (epz * tan_fov))) / 2.0)
|
|
) ;
|
|
} else if(epz >= draw_constant) {
|
|
double midx = convex_pt(ex, sx, (epz - draw_constant)/(epz - spz)) ;
|
|
double midy = convex_pt(ey, sy, (epz - draw_constant)/(epz - spz)) ;
|
|
double midz = convex_pt(ez, sz, (epz - draw_constant)/(epz - spz)) ;
|
|
project_to_camera(midx, midy, midz, &spx, &spy, &spz) ;
|
|
//printf("* %f\n", spz) ;
|
|
drawLineWithThiccNoColor(renderer, 1,
|
|
(int)(1500.0 * (1.0 + (spx / (1.5 * spz * tan_fov))) / 2.0),
|
|
(int)(1500.0 * (1.0 + (epx / (1.5 * epz * tan_fov))) / 2.0),
|
|
(int)(1000.0 * (1.0 + (spy / (spz * tan_fov))) / 2.0),
|
|
(int)(1000.0 * (1.0 + (epy / (epz * tan_fov))) / 2.0)
|
|
) ;
|
|
} else if(spz >= draw_constant) {
|
|
double midx = convex_pt(sx, ex, (spz - draw_constant)/(spz - epz)) ;
|
|
double midy = convex_pt(sy, ey, (spz - draw_constant)/(spz - epz)) ;
|
|
double midz = convex_pt(sz, ez, (spz - draw_constant)/(spz - epz)) ;
|
|
project_to_camera(midx, midy, midz, &epx, &epy, &epz) ;
|
|
//printf("%f *\n", epz) ;
|
|
drawLineWithThiccNoColor(renderer, 1,
|
|
(int)(1500.0 * (1.0 + (spx / (1.5 * spz * tan_fov))) / 2.0),
|
|
(int)(1500.0 * (1.0 + (epx / (1.5 * epz * tan_fov))) / 2.0),
|
|
(int)(1000.0 * (1.0 + (spy / (spz * tan_fov))) / 2.0),
|
|
(int)(1000.0 * (1.0 + (epy / (epz * tan_fov))) / 2.0)
|
|
) ;
|
|
} // else : not visible (behind camera)
|
|
}
|
|
|
|
void axialRotation_X0(double* y, double* z, double theta) {
|
|
double y0 = *y ;
|
|
*y = (*y)*cos(theta) - (*z)*sin(theta) ;
|
|
*z = (*z)*cos(theta) + y0*sin(theta) ;
|
|
}
|
|
|
|
void axialRotation_X(double* y, double* z, double theta, double cst_y, double cst_z) {
|
|
// project the space onto the (y, z) plane to get cst_y and cst_z
|
|
double y1 = *y - cst_y;
|
|
double z1 = *z - cst_z;
|
|
axialRotation_X0(&y1, &z1, theta);
|
|
*y = y1 + cst_y ;
|
|
*z = z1 + cst_z ;
|
|
}
|
|
|
|
void axialRotation_Y0(double* x, double* z, double theta) {
|
|
double x0 = *x ;
|
|
*x = (*x)*cos(theta) + (*z)*sin(theta) ;
|
|
*z = (*z)*cos(theta) - x0*sin(theta) ;
|
|
}
|
|
|
|
void axialRotation_Y(double* x, double* z, double theta, double cst_x, double cst_z) {
|
|
// project the space onto the (y, z) plane to get cst_y and cst_z
|
|
double x1 = *x - cst_x;
|
|
double z1 = *z - cst_z;
|
|
axialRotation_Y0(&x1, &z1, theta);
|
|
*x = x1 + cst_x ;
|
|
*z = z1 + cst_z ;
|
|
}
|
|
|
|
void axialRotation_Z0(double* x, double* y, double theta) {
|
|
double x0 = *x ;
|
|
*x = (*x)*cos(theta) - (*y)*sin(theta) ;
|
|
*y = (*y)*cos(theta) + x0*sin(theta) ;
|
|
}
|
|
|
|
void axialRotation_Z(double* x, double* y, double theta, double cst_x, double cst_y) {
|
|
// project the space onto the (y, z) plane to get cst_y and cst_z
|
|
double x1 = *x - cst_x;
|
|
double y1 = *y - cst_y;
|
|
axialRotation_Z0(&x1, &y1, theta);
|
|
*x = x1 + cst_x ;
|
|
*y = y1 + cst_y ;
|
|
}
|
|
|
|
void drawSegmentRotated(SDL_Renderer* renderer, double sx, double sy, double sz, double ex, double ey, double ez, double hz_angle, double vt_angle, double center_x, double center_y, double center_z) {
|
|
double psx = sx;
|
|
double psy = sy;
|
|
double psz = sz;
|
|
double pex = ex;
|
|
double pey = ey;
|
|
double pez = ez;
|
|
axialRotation_Y(&psx, &psz, -hz_angle, center_x, center_z);
|
|
axialRotation_Y(&pex, &pez, -hz_angle, center_x, center_z);
|
|
// minus signs cause the base is indirect
|
|
axialRotation_X(&psy, &psz, vt_angle, center_y, center_z);
|
|
axialRotation_X(&pey, &pez, vt_angle, center_y, center_z);
|
|
draw_segment(renderer, psx, psy, psz, pex, pey, pez);
|
|
}
|
|
|
|
void drawOutlineOfCube_0(SDL_Renderer* renderer, cube_0 c) {
|
|
// x = constant
|
|
drawSegmentRotated(renderer, c.x, c.y, c.z, c.x + c.w, c.y, c.z, c.hz_angle, c.vt_angle, c.x + c.w/2.0, c.y + c.h/2.0, c.z + c.d/2.0) ;
|
|
drawSegmentRotated(renderer, c.x, c.y + c.h, c.z, c.x + c.w, c.y + c.h, c.z, c.hz_angle, c.vt_angle, c.x + c.w/2.0, c.y + c.h/2.0, c.z + c.d/2.0) ;
|
|
drawSegmentRotated(renderer, c.x, c.y, c.z + c.d, c.x + c.w, c.y, c.z + c.d, c.hz_angle, c.vt_angle, c.x + c.w/2.0, c.y + c.h/2.0, c.z + c.d/2.0) ;
|
|
drawSegmentRotated(renderer, c.x, c.y + c.h, c.z + c.d, c.x + c.w, c.y + c.h, c.z + c.d, c.hz_angle, c.vt_angle, c.x + c.w/2.0, c.y + c.h/2.0, c.z + c.d/2.0) ;
|
|
|
|
// y = constant
|
|
drawSegmentRotated(renderer, c.x, c.y, c.z, c.x, c.y + c.h, c.z, c.hz_angle, c.vt_angle, c.x + c.w/2.0, c.y + c.h/2.0, c.z + c.d/2.0) ;
|
|
drawSegmentRotated(renderer, c.x + c.w, c.y, c.z, c.x + c.w, c.y + c.h, c.z, c.hz_angle, c.vt_angle, c.x + c.w/2.0, c.y + c.h/2.0, c.z + c.d/2.0) ;
|
|
drawSegmentRotated(renderer, c.x, c.y, c.z + c.d, c.x, c.y + c.h, c.z + c.d, c.hz_angle, c.vt_angle, c.x + c.w/2.0, c.y + c.h/2.0, c.z + c.d/2.0) ;
|
|
drawSegmentRotated(renderer, c.x + c.w, c.y, c.z + c.d, c.x + c.w, c.y + c.h, c.z + c.d, c.hz_angle, c.vt_angle, c.x + c.w/2.0, c.y + c.h/2.0, c.z + c.d/2.0) ;
|
|
|
|
// z = constant
|
|
drawSegmentRotated(renderer, c.x, c.y, c.z, c.x, c.y, c.z + c.d, c.hz_angle, c.vt_angle, c.x + c.w/2.0, c.y + c.h/2.0, c.z + c.d/2.0) ;
|
|
drawSegmentRotated(renderer, c.x + c.w, c.y, c.z, c.x + c.w, c.y, c.z + c.d, c.hz_angle, c.vt_angle, c.x + c.w/2.0, c.y + c.h/2.0, c.z + c.d/2.0) ;
|
|
drawSegmentRotated(renderer, c.x, c.y + c.h, c.z, c.x, c.y + c.h, c.z + c.d, c.hz_angle, c.vt_angle, c.x + c.w/2.0, c.y + c.h/2.0, c.z + c.d/2.0) ;
|
|
drawSegmentRotated(renderer, c.x + c.w, c.y + c.h, c.z, c.x + c.w, c.y + c.h, c.z + c.d, c.hz_angle, c.vt_angle, c.x + c.w/2.0, c.y + c.h/2.0, c.z + c.d/2.0) ;
|
|
}
|
|
|
|
// -------------------------------------------------------------------------------------------------------------------------------- //
|
|
// this is where the fun begins
|
|
|
|
int surfaceDrawOrder(double x0, double y0, double z0, cube_0 cb) {
|
|
// returns the number of surfaces that should be drawn, as well as filling drawOrder for said surfaces :
|
|
// 0 = +x ; 1 = -x
|
|
// 2 = +y ; 3 = -y
|
|
// 4 = +z ; 5 = -z
|
|
|
|
// align cube center to (0, 0, 0)
|
|
double x = x0 - (cb.x + cb.w/2.0) ;
|
|
double y = y0 - (cb.y + cb.h/2.0) ;
|
|
double z = z0 - (cb.z + cb.d/2.0) ;
|
|
// rotate (y)
|
|
double xry = x*cos(cb.hz_angle) + z*sin(cb.hz_angle) ;
|
|
double yry = y ;
|
|
double zry = z*cos(cb.hz_angle) - x*sin(cb.hz_angle) ;
|
|
// rotate (x)
|
|
double xrx = xry ;
|
|
double yrx = yry*cos(cb.vt_angle) + zry*sin(cb.vt_angle) ;
|
|
double zrx = zry*cos(cb.vt_angle) - yry*sin(cb.vt_angle) ;
|
|
// cube is centered and aligned
|
|
int id = 0 ;
|
|
if(xrx > cb.w/2.0) {
|
|
drawOrder[id] = 0 ;
|
|
id += 1 ;
|
|
} else if(xrx < -cb.w/2.0) {
|
|
drawOrder[id] = 1 ;
|
|
id += 1 ;
|
|
}
|
|
if(yrx > cb.h/2.0) {
|
|
drawOrder[id] = 2 ;
|
|
id += 1 ;
|
|
} else if(yrx < -cb.h/2.0) {
|
|
drawOrder[id] = 3 ;
|
|
id += 1 ;
|
|
}
|
|
if(zrx > cb.d/2.0) {
|
|
drawOrder[id] = 4 ;
|
|
id += 1 ;
|
|
} else if(zrx < -cb.d/2.0) {
|
|
drawOrder[id] = 5 ;
|
|
id += 1 ;
|
|
}
|
|
if(id == 0) { // inside the cube
|
|
for(int k = 0; k < 6; k++) {
|
|
drawOrder[k] = k ;
|
|
}
|
|
return 6;
|
|
} else {
|
|
return id ;
|
|
}
|
|
}
|
|
|
|
SDL_Vertex construct_vertex(double px, double py, int r, int g, int b, int a) {
|
|
SDL_Vertex vtx ;
|
|
vtx.color.r = r ;
|
|
vtx.color.g = g ;
|
|
vtx.color.b = b ;
|
|
vtx.color.a = a ;
|
|
vtx.position.x = (float)px ;
|
|
vtx.position.y = (float)py ;
|
|
vtx.tex_coord.x = 0.0f;
|
|
vtx.tex_coord.y = 0.0f;
|
|
return vtx ;
|
|
}
|
|
|
|
void renderTriangleNoProject(
|
|
SDL_Renderer* renderer,
|
|
double px0, double py0, double pz0,
|
|
double px1, double py1, double pz1,
|
|
double px2, double py2, double pz2,
|
|
int red, int green, int blue, bool debug
|
|
) {
|
|
|
|
const SDL_Vertex vtxs[3] = {
|
|
construct_vertex(px0, py0, max(red - (int)(flashlight*pz0), 0), max(green - (int)(flashlight*pz0), 0), max(blue - (int)(flashlight*pz0), 0), 255),
|
|
construct_vertex(px1, py1, max(red - (int)(flashlight*pz1), 0), max(green - (int)(flashlight*pz1), 0), max(blue - (int)(flashlight*pz1), 0), 255),
|
|
construct_vertex(px2, py2, max(red - (int)(flashlight*pz2), 0), max(green - (int)(flashlight*pz2), 0), max(blue - (int)(flashlight*pz2), 0), 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);
|
|
}
|
|
SDL_RenderGeometry(renderer, NULL, vtxs, 3, NULL, 0);
|
|
}
|
|
|
|
double near = -1.0 ;
|
|
double far = 1.0 ;
|
|
double getZbuffer(double x, double y, double z) {
|
|
return sqrt(x*x + y*y + z*z);
|
|
//return z;
|
|
//return (2.0*(z - near)/(far - near) -1.0);
|
|
//return ((far + near)/(far - near) + (1.0/z)*((-2.0*far*near)/(far - near)));
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
bool inside_fov(double px, double py) {
|
|
return true ;
|
|
}
|
|
|
|
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
|
|
) {
|
|
double px0; double py0; double pz0;
|
|
double px1; double py1; double pz1;
|
|
double px2; double py2; double pz2;
|
|
double fpx0; double fpy0; double fpz0;
|
|
double fpx1; double fpy1; double fpz1;
|
|
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);
|
|
if(inside_fov(px0, py0) || inside_fov(px1, py1) || inside_fov(px2, py2)) {
|
|
if(pz0 >= draw_constant && pz1 >= draw_constant && pz2 >= draw_constant) {
|
|
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;
|
|
} 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));
|
|
mz0 = convex_pt(z1, z0, (pz1 - draw_constant)/(pz1 - pz0));
|
|
mx1 = convex_pt(x2, x0, (pz2 - draw_constant)/(pz2 - pz0));
|
|
my1 = convex_pt(y2, y0, (pz2 - draw_constant)/(pz2 - pz0));
|
|
mz1 = convex_pt(z2, z0, (pz2 - draw_constant)/(pz2 - pz0));
|
|
// 1-0 segment
|
|
project_to_camera(mx0, my0, mz0, &mpx0, &mpy0, &mpz0) ;
|
|
|
|
// 0-2 segment
|
|
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));
|
|
mz0 = convex_pt(z0, z1, (pz0 - draw_constant)/(pz0 - pz1));
|
|
mx1 = convex_pt(x2, x1, (pz2 - draw_constant)/(pz2 - pz1));
|
|
my1 = convex_pt(y2, y1, (pz2 - draw_constant)/(pz2 - pz1));
|
|
mz1 = convex_pt(z2, z1, (pz2 - draw_constant)/(pz2 - pz1));
|
|
// 0-1 segment
|
|
project_to_camera(mx0, my0, mz0, &mpx0, &mpy0, &mpz0) ;
|
|
|
|
// 1-2 segment
|
|
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));
|
|
mz0 = convex_pt(z0, z2, (pz0 - draw_constant)/(pz0 - pz2));
|
|
mx1 = convex_pt(x1, x2, (pz1 - draw_constant)/(pz1 - pz2));
|
|
my1 = convex_pt(y1, y2, (pz1 - draw_constant)/(pz1 - pz2));
|
|
mz1 = convex_pt(z1, z2, (pz1 - draw_constant)/(pz1 - pz2));
|
|
// 0-2 segment
|
|
project_to_camera(mx0, my0, mz0, &mpx0, &mpy0, &mpz0) ;
|
|
|
|
// 1-2 segment
|
|
project_to_camera(mx1, my1, mz1, &mpx1, &mpy1, &mpz1) ;
|
|
}
|
|
|
|
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 ;
|
|
} else if((pz0 >= draw_constant) + (pz1 >= draw_constant) + (pz2 >= draw_constant) == 1) {
|
|
if(pz0 >= draw_constant) {
|
|
project_to_camera(
|
|
convex_pt(x0, x1, (pz0 - draw_constant)/(pz0 - pz1)),
|
|
convex_pt(y0, y1, (pz0 - draw_constant)/(pz0 - pz1)),
|
|
convex_pt(z0, z1, (pz0 - draw_constant)/(pz0 - pz1)),
|
|
&px1, &py1, &pz1);
|
|
project_to_camera(
|
|
convex_pt(x0, x2, (pz0 - draw_constant)/(pz0 - pz2)),
|
|
convex_pt(y0, y2, (pz0 - draw_constant)/(pz0 - pz2)),
|
|
convex_pt(z0, z2, (pz0 - draw_constant)/(pz0 - pz2)),
|
|
&px2, &py2, &pz2);
|
|
} else if(pz1 >= draw_constant) {
|
|
project_to_camera(
|
|
convex_pt(x1, x0, (pz1 - draw_constant)/(pz1 - pz0)),
|
|
convex_pt(y1, y0, (pz1 - draw_constant)/(pz1 - pz0)),
|
|
convex_pt(z1, z0, (pz1 - draw_constant)/(pz1 - pz0)),
|
|
&px0, &py0, &pz0);
|
|
project_to_camera(
|
|
convex_pt(x1, x2, (pz1 - draw_constant)/(pz1 - pz2)),
|
|
convex_pt(y1, y2, (pz1 - draw_constant)/(pz1 - pz2)),
|
|
convex_pt(z1, z2, (pz1 - draw_constant)/(pz1 - pz2)),
|
|
&px2, &py2, &pz2);
|
|
} else if(pz2 >= draw_constant) {
|
|
project_to_camera(
|
|
convex_pt(x2, x0, (pz2 - draw_constant)/(pz2 - pz0)),
|
|
convex_pt(y2, y0, (pz2 - draw_constant)/(pz2 - pz0)),
|
|
convex_pt(z2, z0, (pz2 - draw_constant)/(pz2 - pz0)),
|
|
&px0, &py0, &pz0);
|
|
project_to_camera(
|
|
convex_pt(x2, x1, (pz2 - draw_constant)/(pz2 - pz1)),
|
|
convex_pt(y2, y1, (pz2 - draw_constant)/(pz2 - pz1)),
|
|
convex_pt(z2, z1, (pz2 - draw_constant)/(pz2 - pz1)),
|
|
&px1, &py1, &pz1);
|
|
}
|
|
|
|
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;
|
|
} else {
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
void addTriangleRotated(
|
|
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
|
|
) {
|
|
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);
|
|
addTriangle(px0, py0, pz0, px1, py1, pz1, px2, py2, pz2, red, green, blue);
|
|
}
|
|
|
|
// -------------------------------------------------------------------------------------------------------------------------------- //
|
|
|
|
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];
|
|
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 add_triangles_cb(cube_0* arr, int len) {
|
|
for(int k = 0; k < len; k++) {
|
|
add_single(arr[k]);
|
|
}
|
|
}
|
|
|
|
void add_triangles_tp(teleporter* arr, int len) {
|
|
for(int k = 0; k < len; k++) {
|
|
add_single(arr[k].hitbox);
|
|
}
|
|
}
|
|
|
|
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 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);
|
|
}
|
|
}
|
|
}
|
|
triangles_order[visited_i] = k;
|
|
visited_i += 1;
|
|
}
|
|
}
|
|
|
|
void topological_sort() {
|
|
bool vflag = !visited_tri[0];
|
|
for(int k = 0; k < triangles_i; k++) {
|
|
visiting(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();
|
|
for(int k = 0; k < triangles_i; k++) {
|
|
renderTriangleFull(renderer, triangles_order[k]);
|
|
}
|
|
/*for(int k = 0; k < triangles_i; k++) {
|
|
drawNumberToRenderer(renderer, digits,
|
|
(int)(3.3*(proj_pt_distance_to_camera(triangles_og_coords[k][0])+proj_pt_distance_to_camera(triangles_og_coords[k][1])+proj_pt_distance_to_camera(triangles_og_coords[k][2]))),
|
|
(int)(0.33*(triangles_to_render[k][0].x+triangles_to_render[k][1].x+triangles_to_render[k][2].x)),
|
|
(int)(0.33*(triangles_to_render[k][0].y+triangles_to_render[k][1].y+triangles_to_render[k][2].y)),
|
|
75/4, 105/4, 0
|
|
);
|
|
}*/
|
|
for(int k = 0; k < 0*triangles_i; k++) {
|
|
for(int l = 0; l < 3; l++) {
|
|
drawNumberToRenderer(renderer, digits,
|
|
(int)(proj_pt_distance_to_camera(triangles_og_coords[k][l])),
|
|
(int)(triangles_to_render[k][l].x),
|
|
(int)(triangles_to_render[k][l].y),
|
|
75/5, 105/5, 0
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
// -------------------------------------------------------------------------------------------------------------------------------- //
|
|
|
|
void drawData(SDL_Renderer* renderer) {
|
|
drawNumberToRenderer(renderer, digits, (int)camx, 10, 10, 75/2, 105/2, 0) ;
|
|
drawNumberToRenderer(renderer, digits, (int)camy, 10, 60, 75/2, 105/2, 0) ;
|
|
drawNumberToRenderer(renderer, digits, (int)camz, 10, 110, 75/2, 105/2, 0) ;
|
|
|
|
drawNumberToRenderer(renderer, digits, (int)(rot_hz*180.0/3.14159), 10, 190, 75/2, 105/2, 0) ;
|
|
drawNumberToRenderer(renderer, digits, (int)(rot_vt*180.0/3.14159), 10, 240, 75/2, 105/2, 0) ;
|
|
|
|
drawNumberToRenderer(renderer, digits, player_chx, 310, 10, 75/2, 105/2, 0);
|
|
drawNumberToRenderer(renderer, digits, player_chy, 310, 60, 75/2, 105/2, 0);
|
|
} |