Raycasting 기반 3D 게임 (cub3d)

# m1 mac : arch -x86_64 make
$ make
$ ./cub3D ./maps/map.cub

assets/    # 텍스쳐 이미지 파일 
maps/      # 맵 설정 파일  
base/      # 가장 먼저 실행되는 파일 
parse/     # 맵 파일 파싱 함수  
engine/    # 게임 동작 관련 함수들 (캐릭터 이동, 미니맵, 레이캐스팅 등)  
get_next_line/, libft/, utils/ # 유틸 함수들이 포함된 폴더 
mlx/       # mlx 라이브러리 폴더 
mlx_utils/ # 화면 출력 관련 유틸 함수들이 포함된 폴더

typedef struct s_mlx
{
	void		*mlx;
	void		*mlx_win;   // 실제 디스플레이와 연결된 window
	t_img		img[2];     // 프레임버퍼
	int			img_idx;    // 현재 버퍼 이미지 인덱스
}				t_mlx;

static int	loop_main(t_cub3d *p_data) 
{ 
    ... 
    // mlx.img는 프레임버퍼이고, mlx_win 이 출력화면과 연결되어 있다. in
    mlx_put_image_to_window(p_data->mlx.mlx, 
                            p_data->mlx.mlx_win, 
                            p_data->mlx.img[p_data->mlx.img_idx].img, 0, 0); 
    ...
    return (0); 
} 

int	main(int argc, char *argv[]) 
{ 
    ...
    // 프레임마다 실행할 함수
    mlx_loop_hook(data.mlx.mlx, loop_main, &data); 
    mlx_loop(data.mlx.mlx); 
    return (0); 
} 

int	parse_data(t_cub3d *p_data)
{
    // 한줄 씩 파싱하며, 총 6개의 데이터가 파싱될 때까지 반복
    // 파싱된 데이터는 플래그를 세팅해둔다.
	while (idx < p_data->file_line && parse_cnt < 6)
	{
		parse_type = parse_line(p_data->file_ptr[idx], p_data);
		if (parse_type == PARSE_ERROR)
			ft_exit("Error\nInvalid parse symbol", 1);
		if (parse_type != PARSE_NONE)
			parse_cnt++;
		p_data->parse_flag |= parse_type;
		idx++;
	}
    // 파싱이 완료됐는지 체크 (모든 플래그가 켜져있는지)
    if (p_data->parse_flag != PARSE_FINISH)
    // ... 
}

void	content_checker(t_cub3d *p_data)
{
	if (!set_content_data(p_data))
		ft_exit("Error\nInvalid map content", 1);
	p_data->content_data.content_ptr = content_malloc(p_data, -0x30);
	if (p_data->content_data.content_ptr == 0)
		ft_exit("Error\nMemory allocation error", 1);
	set_content(p_data);         // 맵을 메모리에 세팅
	content_close_check(p_data); // 맵이 닫힌 상태인지 체크
	set_player(p_data);          // 플레이어 위치와 방향 세팅
}

void	dfs_content_check(t_cub3d *p_data, char **visit_ptr, int y, int x)
{
	if (!(x >= 0 && y >= 0
			&& x <= p_data->content_data.content_len - 1
			&& y <= p_data->content_data.content_line - 1))
		return ;
	if (p_data->content_data.content_ptr[y][x] == 1)
		return ;
	if (visit_ptr[y][x] == 1)
		return ;
	if (p_data->content_data.content_ptr[y][x] < 0)
		ft_exit("Error\nInvalid map content", 1);
	visit_ptr[y][x] = 1;
	dfs_content_check(p_data, visit_ptr, y - 1, x);
	dfs_content_check(p_data, visit_ptr, y + 1, x);
	dfs_content_check(p_data, visit_ptr, y, x - 1);
	dfs_content_check(p_data, visit_ptr, y, x + 1);
}

// x, y 좌표에 해당하는 컬러 값을 가져오고 dst에서 해당되는 좌표에 칠한다. 
void	mlx_pixel_to_image(t_img *img, unsigned int x, unsigned int y,
		unsigned int color)
{
	char			*dst;
	unsigned int	bitmask;

	if (x < img->width && y < img->height)
	{
		bitmask = 0xFFFFFFFF >> (32 - img->bits_per_pixel);
		dst = img->addr
			+ (y * img->line_length + x * (img->bits_per_pixel / 8));
		*(unsigned int *)dst = color & bitmask;
	}
}

// 라디안 계산은 PI/180 이고, 시야각을 전체 가로픽셀을 나누면(FOV를 픽셀만큼 잘개쪼갬) 픽셀당 라디안 값이 나온다.
rad_per_pixel = PI/180 * FOV/CAM_WIDTH_PIXEL;
start_radian = player->radian - rad_per_pixel * CAM_WIDTH_PIXEL/2;
while (i < CAM_WIDTH_PIXEL)
{
    raycast_function(start_radian);
    draw_vertical();
    start_radian += rad_per_pixel;
}

// 장애물은 경계면의 뒤에 있기 때문에 dir 0 에서 나가지면 광선이 x좌표 경계면에 닿은것이다. 
while (map[x][y] != 1)
{
    if (sideDistX < sideDistY)
    {
        sideDistX += deltaDistX;
        x+=x_dir;
        dir = 0;
    }
    else
    {
        sideDistY += deltaDistY;
        y+=y_dir
        dir = 1;
    }
}
// 마지막 닿은 방향이 x라면 직전 경계 길이인 sideDistX - deltaDistX 가 광선의 길이가 된다.
int ray_distance = dir == 0 ? sideDistX : sideDistY;

// 벽 텍스쳐에서 현재 x, y 좌표에 따라 색을 선택하는 함수
static unsigned int	get_color_in_texture(t_img *wall, double x, double y)
{
	unsigned int	color;
	char			*dst;

	dst = wall->addr + (wall->line_length * (unsigned int)(wall->height * y)
			+ (wall->bits_per_pixel / 8) * (unsigned int)(wall->width * x));
	color = *(unsigned int *)dst;
	return (color);
}

// 세로 한줄을 그리는 함수
static void	draw_texture_vertical(t_cub3d *p_data, int *pos,
		t_draw_wall *wall)
{
	t_img			*xpm;
	unsigned int	i;
	double			xpos;
	int				idx;

    // 광선이 닿은 벽의 방향에 따라 x의 시작지점과 이미지가 달라진다.
	idx = p_data->mlx.img_idx;
	if (wall->wall_dir == WALL_SO || wall->wall_dir == WALL_DOOR_X)
		xpos = wall->ray_wall_dpos[0] - (int)wall->ray_wall_dpos[0];
	else if (wall->wall_dir == WALL_NO)
		xpos = 1 - (wall->ray_wall_dpos[0] - (int)wall->ray_wall_dpos[0]);
	else if (wall->wall_dir == WALL_WE || wall->wall_dir == WALL_DOOR_Y)
		xpos = wall->ray_wall_dpos[1] - (int)wall->ray_wall_dpos[1];
	else if (wall->wall_dir == WALL_EA)
		xpos = 1 - (wall->ray_wall_dpos[1] - (int)wall->ray_wall_dpos[1]);
	if (wall->wall_dir == WALL_DOOR_X || wall->wall_dir == WALL_DOOR_Y)
		wall->wall_dir = WALL_DOOR;
	xpm = &p_data->xpm_data[wall->wall_dir];
    // 텍스쳐에서 현재 광선에 맞는 색을 선택해서 프레임버퍼에 1픽셀씩 전체 세로줄을 찍는다. 
    // i 는 화면의 y 픽셀좌표이고, 이걸 벽의 화면성 세로길이로 나눠서 몇퍼센트 지점에 있는 픽셀인지 계산한다.
	i = -1;
	while (++i < wall->vertical_len && i < WIN_HEIGHT)
	{
		mlx_pixel_to_image(&p_data->mlx.img[idx], \
			pos[0], (pos[1] >= 0) * pos[1] + i, \
			get_color_in_texture(xpm, xpos, \
			(double)(i + ((pos[1] < 0) * pos[1] * -1)) / wall->vertical_len));
	}
}

typedef struct s_pos
{
	double	x;
	double	y;
}				t_pos;

typedef struct s_player_data
{
	t_pos	pos;
	double	radian;
}				t_player_data;

static void	move_player_calculator(t_player_data *player,
	int x_cor, int y_cor, double radian)
{
	player->xpos += (x_cor * cos(radian)) * 0.1;    // 1이 미니맵상 1칸이기 때문에 0.1은 이동속도 보정
	player->ypos += (y_cor * sin(radian)) * 0.1;
}

static void	move_player_calculator(t_cub3d *p_data,
	int x_cor, int y_cor, double radian)
{
	double			tmp;
	t_player_data	*player;
	t_content_data	*content;
	char			tile;

	player = &p_data->player;
	content = &p_data->content_data;
	tmp = player->pos.x + (x_cor * cos(radian)) * 0.001 * PLAYER_SPEED;
	tile = content->content_ptr[(unsigned int)player->pos.y][(unsigned int)tmp];
    // x값이 벽에 충돌한 경우 이전 값으로 복원
	if (tile != TILE_WALL && !(tile >= TILE_DOOR_C && tile < TILE_DOOR_O))
		player->pos.x = tmp;
	tmp = player->pos.y + (y_cor * sin(radian)) * 0.001 * PLAYER_SPEED;
	tile = content->content_ptr[(unsigned int)tmp][(unsigned int)player->pos.x];
    // y값이 벽에 충돌한 경우 이전 값으로 복원
	if (tile != TILE_WALL && !(tile >= TILE_DOOR_C && tile < TILE_DOOR_O))
		player->pos.y = tmp;
	p_data->update = 1;
}

void	door_operator(t_cub3d *p_data)
{
	char	*c;

	c = &p_data->content_data.content_ptr \
		[p_data->op_door.door_pos[1]][p_data->op_door.door_pos[0]];
	*c += p_data->op_door.door_status;   // door_status = 1 or -1
	p_data->update = 1;
	if (*c == TILE_DOOR_C || *c == TILE_DOOR_O)
		p_data->op_door.door_status = 0;
}