Raycasting 기반 3D 게임 (cub3d)

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

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

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

 1static int	loop_main(t_cub3d *p_data) 
 2{ 
 3    ... 
 4    // mlx.img는 프레임버퍼이고, mlx_win 이 출력화면과 연결되어 있다. in
 5    mlx_put_image_to_window(p_data->mlx.mlx, 
 6                            p_data->mlx.mlx_win, 
 7                            p_data->mlx.img[p_data->mlx.img_idx].img, 0, 0); 
 8    ...
 9    return (0); 
10} 
11
12int	main(int argc, char *argv[]) 
13{ 
14    ...
15    // 프레임마다 실행할 함수
16    mlx_loop_hook(data.mlx.mlx, loop_main, &data); 
17    mlx_loop(data.mlx.mlx); 
18    return (0); 
19} 

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

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

 1void	dfs_content_check(t_cub3d *p_data, char **visit_ptr, int y, int x)
 2{
 3	if (!(x >= 0 && y >= 0
 4			&& x <= p_data->content_data.content_len - 1
 5			&& y <= p_data->content_data.content_line - 1))
 6		return ;
 7	if (p_data->content_data.content_ptr[y][x] == 1)
 8		return ;
 9	if (visit_ptr[y][x] == 1)
10		return ;
11	if (p_data->content_data.content_ptr[y][x] < 0)
12		ft_exit("Error\nInvalid map content", 1);
13	visit_ptr[y][x] = 1;
14	dfs_content_check(p_data, visit_ptr, y - 1, x);
15	dfs_content_check(p_data, visit_ptr, y + 1, x);
16	dfs_content_check(p_data, visit_ptr, y, x - 1);
17	dfs_content_check(p_data, visit_ptr, y, x + 1);
18}

 1// x, y 좌표에 해당하는 컬러 값을 가져오고 dst에서 해당되는 좌표에 칠한다. 
 2void	mlx_pixel_to_image(t_img *img, unsigned int x, unsigned int y,
 3		unsigned int color)
 4{
 5	char			*dst;
 6	unsigned int	bitmask;
 7
 8	if (x < img->width && y < img->height)
 9	{
10		bitmask = 0xFFFFFFFF >> (32 - img->bits_per_pixel);
11		dst = img->addr
12			+ (y * img->line_length + x * (img->bits_per_pixel / 8));
13		*(unsigned int *)dst = color & bitmask;
14	}
15}

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

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

 1// 벽 텍스쳐에서 현재 x, y 좌표에 따라 색을 선택하는 함수
 2static unsigned int	get_color_in_texture(t_img *wall, double x, double y)
 3{
 4	unsigned int	color;
 5	char			*dst;
 6
 7	dst = wall->addr + (wall->line_length * (unsigned int)(wall->height * y)
 8			+ (wall->bits_per_pixel / 8) * (unsigned int)(wall->width * x));
 9	color = *(unsigned int *)dst;
10	return (color);
11}
12
13// 세로 한줄을 그리는 함수
14static void	draw_texture_vertical(t_cub3d *p_data, int *pos,
15		t_draw_wall *wall)
16{
17	t_img			*xpm;
18	unsigned int	i;
19	double			xpos;
20	int				idx;
21
22    // 광선이 닿은 벽의 방향에 따라 x의 시작지점과 이미지가 달라진다.
23	idx = p_data->mlx.img_idx;
24	if (wall->wall_dir == WALL_SO || wall->wall_dir == WALL_DOOR_X)
25		xpos = wall->ray_wall_dpos[0] - (int)wall->ray_wall_dpos[0];
26	else if (wall->wall_dir == WALL_NO)
27		xpos = 1 - (wall->ray_wall_dpos[0] - (int)wall->ray_wall_dpos[0]);
28	else if (wall->wall_dir == WALL_WE || wall->wall_dir == WALL_DOOR_Y)
29		xpos = wall->ray_wall_dpos[1] - (int)wall->ray_wall_dpos[1];
30	else if (wall->wall_dir == WALL_EA)
31		xpos = 1 - (wall->ray_wall_dpos[1] - (int)wall->ray_wall_dpos[1]);
32	if (wall->wall_dir == WALL_DOOR_X || wall->wall_dir == WALL_DOOR_Y)
33		wall->wall_dir = WALL_DOOR;
34	xpm = &p_data->xpm_data[wall->wall_dir];
35    // 텍스쳐에서 현재 광선에 맞는 색을 선택해서 프레임버퍼에 1픽셀씩 전체 세로줄을 찍는다. 
36    // i 는 화면의 y 픽셀좌표이고, 이걸 벽의 화면성 세로길이로 나눠서 몇퍼센트 지점에 있는 픽셀인지 계산한다.
37	i = -1;
38	while (++i < wall->vertical_len && i < WIN_HEIGHT)
39	{
40		mlx_pixel_to_image(&p_data->mlx.img[idx], \
41			pos[0], (pos[1] >= 0) * pos[1] + i, \
42			get_color_in_texture(xpm, xpos, \
43			(double)(i + ((pos[1] < 0) * pos[1] * -1)) / wall->vertical_len));
44	}
45}

 1typedef struct s_pos
 2{
 3	double	x;
 4	double	y;
 5}				t_pos;
 6
 7typedef struct s_player_data
 8{
 9	t_pos	pos;
10	double	radian;
11}				t_player_data;

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

 1static void	move_player_calculator(t_cub3d *p_data,
 2	int x_cor, int y_cor, double radian)
 3{
 4	double			tmp;
 5	t_player_data	*player;
 6	t_content_data	*content;
 7	char			tile;
 8
 9	player = &p_data->player;
10	content = &p_data->content_data;
11	tmp = player->pos.x + (x_cor * cos(radian)) * 0.001 * PLAYER_SPEED;
12	tile = content->content_ptr[(unsigned int)player->pos.y][(unsigned int)tmp];
13    // x값이 벽에 충돌한 경우 이전 값으로 복원
14	if (tile != TILE_WALL && !(tile >= TILE_DOOR_C && tile < TILE_DOOR_O))
15		player->pos.x = tmp;
16	tmp = player->pos.y + (y_cor * sin(radian)) * 0.001 * PLAYER_SPEED;
17	tile = content->content_ptr[(unsigned int)tmp][(unsigned int)player->pos.x];
18    // y값이 벽에 충돌한 경우 이전 값으로 복원
19	if (tile != TILE_WALL && !(tile >= TILE_DOOR_C && tile < TILE_DOOR_O))
20		player->pos.y = tmp;
21	p_data->update = 1;
22}

 1void	door_operator(t_cub3d *p_data)
 2{
 3	char	*c;
 4
 5	c = &p_data->content_data.content_ptr \
 6		[p_data->op_door.door_pos[1]][p_data->op_door.door_pos[0]];
 7	*c += p_data->op_door.door_status;   // door_status = 1 or -1
 8	p_data->update = 1;
 9	if (*c == TILE_DOOR_C || *c == TILE_DOOR_O)
10		p_data->op_door.door_status = 0;
11}