rparodi/Cub3D
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

v1.0 - normed texture system, multiple keypress, fixes on parsing, removed trailing maps

Browse source
This commit is contained in:
B.Goulard 2024-12-16 14:56:22 +01:00
parent e581c72b02
commit 3f43074d05
35 changed files with 474 additions and 438 deletions
Download patch file Download diff file Expand all files Collapse all files

8
Makefile
View file

@ -6,7 +6,7 @@
# By: rparodi <rparodi@student.42.fr> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ #
# Created: 2023/11/12 11:05:05 by rparodi #+# #+# #
# Updated: 2024/12/02 00:17:35 by rparodi ### ########.fr #
# Updated: 2024/12/16 14:50:54 by bgoulard ### ########.fr #
# #
# **************************************************************************** #
@ -44,16 +44,19 @@ MLXFLAGS += -L/opt/X11/lib
LDFLAGS += $(MLXFLAGS)
SRC =\
ft_addons/ft_inrange.c \
mlx_layer/mlx_init.c \
mlx_layer/looks.c \
mlx_layer/mlx_load_texture.c \
mlx_layer/mooves.c \
mlx_layer/hooks.c \
mlx_layer/keys_event.c \
raycast/frame_update.c \
raycast/frame_update2.c \
raycast/rc_utils.c \
raycast/utils_math.c \
raycast/get_cl.c \
raycast/draw_call.c \
raycast/get_texture.c \
sources/options_impl.c \
sources/main.c \
sources/error.c \
@ -127,7 +130,6 @@ $(OBJDIRNAME)/%.o: %.c
# Header
header:
@clear
@printf '\n\n'
@printf '$(GOLD) ******* ****** ******* $(END)\n'
@printf '$(GOLD) ****** *** ******* $(END)\n'

24
ft_addons/ft_inrange.c Normal file
View file

@ -0,0 +1,24 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_inrange.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: bgoulard <bgoulard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/12/16 06:04:32 by bgoulard #+# #+# */
/* Updated: 2024/12/16 09:01:36 by bgoulard ### ########.fr */
/* */
/* ************************************************************************** */
// dest ft_math/ft_inrange.c
#include <stdbool.h>
bool ft_inrange_ex(int value, int min, int max)
{
return (value > min && value < max);
}
bool ft_inrange(int value, int min, int max)
{
return (value >= min && value <= max);
}

13
includes/cub3d.h
View file

@ -6,7 +6,7 @@
/* By: rparodi <rparodi@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/30 16:30:26 by rparodi #+# #+# */
/* Updated: 2024/12/05 16:45:30 by rparodi ### ########.fr */
/* Updated: 2024/12/16 14:48:17 by bgoulard ### ########.fr */
/* */
/* ************************************************************************** */
@ -22,9 +22,15 @@
# include <stdbool.h>
// raycasting
void draw_bg(t_info *data);
void set_step(t_ipoint *step, t_dpoint raydir);
void set_side_dist(t_dpoint *side_dist, t_dpoint *tb, t_ipoint pos_i);
t_texture *get_texture(int side, t_ipoint step, t_info *data);
void draw_(int *ti, double *td, t_ipoint step, t_info *data);
// utils
void draw_floor(t_info *data);
void dump_info(t_info *info);
int render_frame(t_info *data);
void my_mlx_pixel_put(t_info *data, int x, int y, int color);
double deg2rad(int deg);
@ -38,6 +44,9 @@ void move_backward(t_info *data);
void move_left(t_info *data);
void move_right(t_info *data);
int keyrelease_feature(int keycode, t_info *data);
int keypress_feature(int keycode, t_info *data);
int displacement_hook(t_info *data);
int get_cl(int side, t_ipoint step);
t_tile *c3_get_cell(t_tile *map, t_ipoint dimensions, t_ipoint pos);

23
includes/cub3d_struct.h
View file

@ -6,7 +6,7 @@
/* By: bgoulard <bgoulard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/11/28 13:53:54 by bgoulard #+# #+# */
/* Updated: 2024/12/01 18:01:48 by rparodi ### ########.fr */
/* Updated: 2024/12/16 14:15:43 by bgoulard ### ########.fr */
/* */
/* ************************************************************************** */
@ -18,7 +18,7 @@
# define FILE_EXTENSION ".cub"
# define FILE_EXTENSION_LEN 4
# define BG_CLG 0
# define BG_SKY 0
# define BG_FLR 1
# define TILE_SIZE 64
# define WIN_COEF .5
@ -26,8 +26,8 @@
// defines that should be mooved to a config option / file
# define FOV 70
# define ROT_SPEED 0.1
# define MOVE_SPEED 0.5
# define ROT_SPEED 0.004
# define MOVE_SPEED 0.008
// -- graphic utils
@ -132,12 +132,25 @@ typedef enum e_error
ERROR_MISSING_FILE,
ERROR_MALLOC,
ERROR_PARSE,
ERROR_MAP_OPEN,
ERROR_PARSE_BG_COLOR_FORMAT,
ERROR_PARSE_ALREADY_SET,
ERROR_CLI,
ERROR_MLX,
ERROR_TEXTURE_FORMAT,
ERROR_IMPLEM,
} t_error;
typedef struct s_kb
{
bool forward;
bool backward;
bool left;
bool right;
bool l_left;
bool l_right;
} t_keyboard;
typedef struct s_pixel_buffer
{
char *img_addr;
@ -153,11 +166,13 @@ typedef struct s_info
{
t_error last_error;
int errno_state;
t_keyboard kb;
t_xvar *mlx_ptr;
t_win_list *win_ptr;
t_ipoint screen_size;
t_pixel_buffer camera;
bool redraw;
t_map map;
t_player player;

32
includes/ft_addons.h Normal file
View file

@ -0,0 +1,32 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_addons.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: bgoulard <bgoulard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/12/16 06:09:01 by bgoulard #+# #+# */
/* Updated: 2024/12/16 09:36:19 by bgoulard ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef FT_ADDONS_H
# include <stdbool.h>
// ft_addons
/// @brief Says if a value is in a range excluding the bounds
/// @param value The value to check
/// @param min The lower bound
/// @param max The upper bound
/// @return true if the value is in the range, false otherwise
bool ft_inrange_ex(int value, int min, int max);
/// @brief Says if a value is in a range including the bounds
/// @param value The value to check
/// @param min The lower bound
/// @param max The upper bound
/// @return true if the value is in the range, false otherwise
bool ft_inrange(int value, int min, int max);
#endif

4
libft/include/ft_string.h
View file

@ -6,7 +6,7 @@
/* By: bgoulard <bgoulard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/07 23:25:27 by bgoulard #+# #+# */
/* Updated: 2024/08/21 21:42:42 by bgoulard ### ########.fr */
/* Updated: 2024/12/16 06:02:56 by bgoulard ### ########.fr */
/* */
/* ************************************************************************** */
@ -322,7 +322,7 @@ size_t ft_strclen(char *str, char c);
/// @param str String to search from
/// @param c Char to search
/// @return the number of occurance of char c in string str
size_t ft_strcnb(char *str, char c);
size_t ft_strcnb(const char *str, char c);
/// @brief Calculate the length of the starting segment of str that contain
/// char from the accept string

4
libft/src/ft_string/ft_str/ft_strcnb.c
View file

@ -6,13 +6,13 @@
/* By: bgoulard <bgoulard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/12/28 10:58:46 by bgoulard #+# #+# */
/* Updated: 2024/05/18 20:04:31 by bgoulard ### ########.fr */
/* Updated: 2024/12/16 06:02:31 by bgoulard ### ########.fr */
/* */
/* ************************************************************************** */
#include <stddef.h>
size_t ft_strcnb(char *str, char c)
size_t ft_strcnb(const char *str, char c)
{
size_t i;
size_t nb;

23
maps/bad_format_color_c.cub
View file

@ -1,23 +0,0 @@
SO ./textures/png_ugly.png
NO ./textures/png_ugly.png
WE ./textures/png_pretty.png
EA ./textures/png_pretty.png
F 255,255,255
C 255,,255
111
1N1
111

23
maps/bad_format_color_f.cub
View file

@ -1,23 +0,0 @@
SO ./textures/png_ugly.png
NO ./textures/png_ugly.png
WE ./textures/png_pretty.png
EA ./textures/png_pretty.png
F 255,255,
C 255,255,255
111
1N1
111

24
maps/bad_format_map_char.cub
View file

@ -1,24 +0,0 @@
SO ./textures/png_ugly.png
NO ./textures/png_ugly.png
WE ./textures/png_pretty.png
EA ./textures/png_pretty.png
F 255,255,255
C 255,255,255
111
1N11111
1000xy1
1111111

23
maps/bad_format_map_open.cub
View file

@ -1,23 +0,0 @@
SO ./textures/png_ugly.png
NO ./textures/png_ugly.png
WE ./textures/png_pretty.png
EA ./textures/png_pretty.png
F 255,255,255
C 255,255,255
1111
00N1
1111

23
maps/bad_format_texture.cub
View file

@ -1,23 +0,0 @@
SO ./textures/png_ugly.png
NO = ./textures/png_ugly.png
WE ./textures/png_pretty.png
EA ./textures/png_pretty.png
F 255,255,255
C 255,255,255
111
1N1
111

20
maps/bad_open_map.cub Normal file
View file

@ -0,0 +1,20 @@
SO ./textures/b.xpm
NO ./textures/wasteland_32.xpm
WE ./textures/sandy_32.xpm
EA ./textures/cobblestone_32.xpm
F 0,255,0
C 0,123,255
11111111111111111111
10000011000001010101
10000011000000000001
10111111111111000101
1011 1000000
10111111 11000100
10000011111110000000
100000000000000N0000
11111111111111111111

20
maps/bad_open_map_inside.cub Normal file
View file

@ -0,0 +1,20 @@
SO ./textures/b.xpm
NO ./textures/wasteland_32.xpm
WE ./textures/sandy_32.xpm
EA ./textures/cobblestone_32.xpm
F 0,255,0
C 0,123,255
11111111111111111111
10000011000001010101
10000011000000000001
10111111101111000101
1011 1000000
10111111 11000100
10000011111110000000
100000000000000N0000
11111111111111111111

23
maps/bad_perm.cub
View file

@ -1,23 +0,0 @@
SO ./textures/png_ugly.png
NO ./textures/png_ugly.png
WE ./textures/png_pretty.png
EA ./textures/png_pretty.png
F 255,255,255
C 255,255,255
111
1N1
111

14
maps/valid_01.cub
View file

@ -1,10 +1,10 @@
SO ./textures/a.xpm
NO ./textures/a.xpm
WE ./textures/a.xpm
EA ./textures/a.xpm
SO ./textures/b.xpm
NO ./textures/wasteland_32.xpm
WE ./textures/sandy_32.xpm
EA ./textures/cobblestone_32.xpm
F 255,255,255
C 255,255,255
F 0,255,0
C 0,255,255
@ -19,7 +19,7 @@ C 255,255,255
11111111111111111111111
100000000N0000000000001
100000000S0000000000001
10000000000000000000001
10000000000000000000001
11111011101100111110011

20
maps/valid_02.cub Normal file
View file

@ -0,0 +1,20 @@
SO ./textures/b.xpm
NO ./textures/wasteland_32.xpm
WE ./textures/sandy_32.xpm
EA ./textures/cobblestone_32.xpm
F 0,255,0
C 0,123,255
11111111111111111111
10000011000001010101
10000011000000000001
10111111111111000101
1011 1000001
10111111 11000101
10000011111110000001
100000000000000N0001
11111111111111111111

42
mlx_layer/hooks.c
View file

@ -6,44 +6,38 @@
/* By: bgoulard <bgoulard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/11/28 14:12:25 by bgoulard #+# #+# */
/* Updated: 2024/12/01 18:46:32 by rparodi ### ########.fr */
/* Updated: 2024/12/16 14:16:17 by bgoulard ### ########.fr */
/* */
/* ************************************************************************** */
#include "cub3d.h"
#include "cub3d_struct.h"
#include "mlx_functions.h"
#include "ft_char.h"
#include <X11/keysym.h>
#include <stdio.h>
#include <sys/types.h>
int key_hook(int keycode, t_info *data)
static void update_pos_i(t_player *player)
{
if (ft_isalpha(keycode))
printf("Event detected: %d\t(%c)\n", keycode, keycode);
else if (keycode == 65361)
printf("Event detected: %d\t(Left Arrow)\n", keycode);
else if (keycode == 65363)
printf("Event detected: %d\t(Right Arrow)\n", keycode);
else if (keycode == 65307)
printf("Event detected: %d\t(Echap)\n", keycode);
else
printf("Event detected: %d\n", keycode);
if (keycode == XK_Escape)
mlx_loop_end(data->mlx_ptr);
if (keycode == XK_w)
player->pos_i.x = (int)player->pos.x;
player->pos_i.y = (int)player->pos.y;
}
int displacement_hook(t_info *data)
{
data->redraw = true;
update_pos_i(&data->player);
if (data->kb.forward && !data->kb.backward)
move_straight(data);
if (keycode == XK_s)
if (data->kb.backward && !data->kb.forward)
move_backward(data);
if (keycode == XK_a)
if (data->kb.left && !data->kb.right)
move_left(data);
if (keycode == XK_d)
if (data->kb.right && !data->kb.left)
move_right(data);
if (keycode == XK_Left)
if (data->kb.l_left && !data->kb.l_right)
look_left(data);
if (keycode == XK_Right)
if (data->kb.l_right && !data->kb.l_left)
look_right(data);
update_pos_i(&data->player);
return (0);
}

63
mlx_layer/keys_event.c Normal file
View file

@ -0,0 +1,63 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* keys_event.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: bgoulard <bgoulard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/12/16 14:40:02 by bgoulard #+# #+# */
/* Updated: 2024/12/16 14:41:40 by bgoulard ### ########.fr */
/* */
/* ************************************************************************** */
#include "cub3d_struct.h"
#include "mlx_functions.h"
#include <stdbool.h>
#include <X11/keysym.h>
void set_kb(t_keyboard *kb, int keycode)
{
if (keycode == XK_w)
kb->forward = true;
if (keycode == XK_s)
kb->backward = true;
if (keycode == XK_a)
kb->left = true;
if (keycode == XK_d)
kb->right = true;
if (keycode == XK_Right)
kb->l_right = true;
if (keycode == XK_Left)
kb->l_left = true;
}
void unset_kb(t_keyboard *kb, int keycode)
{
if (keycode == XK_w)
kb->forward = false;
if (keycode == XK_s)
kb->backward = false;
if (keycode == XK_a)
kb->left = false;
if (keycode == XK_d)
kb->right = false;
if (keycode == XK_Left)
kb->l_left = false;
if (keycode == XK_Right)
kb->l_right = false;
}
int keypress_feature(int keycode, t_info *data)
{
if (keycode == XK_Escape)
mlx_loop_end(data->mlx_ptr);
set_kb(&data->kb, keycode);
return (0);
}
int keyrelease_feature(int keycode, t_info *data)
{
unset_kb(&data->kb, keycode);
return (0);
}

19
mlx_layer/mlx_init.c
View file

@ -6,25 +6,22 @@
/* By: rparodi <rparodi@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/11/11 19:53:42 by rparodi #+# #+# */
/* Updated: 2024/12/05 16:55:30 by rparodi ### ########.fr */
/* Updated: 2024/12/16 14:40:55 by bgoulard ### ########.fr */
/* */
/* ************************************************************************** */
#include "cub3d.h"
#include "cub3d_struct.h"
#include "mlx_functions.h"
#include "mlx_structs.h"
#include "ft_string.h"
#include "ft_math.h"
#include <stdbool.h>
#include <stdlib.h>
#include <X11/keysym.h>
int c3_frame_update(void *inf_ptr);
int key_hook(int keycode, t_info *data);
/* move player w keys and call to redraw screen */
int c3_keyhook(int keycode, t_info *info)
{
if (keycode == XK_Escape || keycode == 65307)
@ -41,8 +38,8 @@ t_win_list *c3_init_mlx_window(t_info *info)
{
mlx_get_screen_size(info->mlx_ptr, \
&info->screen_size.x, &info->screen_size.y);
/*info->screen_size.x *= WIN_COEF;*/
/*info->screen_size.y *= WIN_COEF;*/
info->screen_size.x *= WIN_COEF;
info->screen_size.y *= WIN_COEF;
ft_clamp(info->screen_size.x, 0, 1920);
ft_clamp(info->screen_size.y, 0, 1080);
return (\
@ -58,7 +55,9 @@ int init_mlx_env(t_info *info)
info->win_ptr = c3_init_mlx_window(info);
if (!info->win_ptr)
return (ERROR_MLX);
mlx_hook(info->win_ptr, KeyPress, KeyPressMask, key_hook, info);
mlx_hook(info->win_ptr, KeyPress, KeyPressMask, keypress_feature, info);
mlx_hook(info->win_ptr, KeyRelease, KeyReleaseMask, keyrelease_feature, \
info);
mlx_hook(info->win_ptr, DestroyNotify, StructureNotifyMask, \
c3_redcross, info);
mlx_loop_hook(info->mlx_ptr, (int (*)())shelves_launch, info);

45
mlx_layer/mlx_load_texture.c
View file

@ -1,45 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* mlx_load_texture.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: rparodi <rparodi@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/11/20 12:25:45 by rparodi #+# #+# */
/* Updated: 2024/12/05 17:01:12 by rparodi ### ########.fr */
/* */
/* ************************************************************************** */
#include "cub3d.h"
#include "mlx_functions.h"
t_img *mlx_load_image(t_info *info, char *path)
{
t_img *image;
int size;
size = TILES_SIZE;
image = mlx_xpm_file_to_image(info->mlx_ptr, path, &size, &size);
if (!image)
return (NULL);
return (image);
}
bool mlx_load_all_textures(t_info *info)
{
size_t i;
i = 0;
info->map.texture[0] = mlx_load_image(info, "../textures/wasteland_32.xpm");
info->map.texture[1] = mlx_load_image(info, "../textures/b.xpm");
info->map.texture[2] = mlx_load_image(info, "../textures/sandy_32.xpm");
info->map.texture[3] = mlx_load_image(info, "../textures/cobblestone_32.xpm");
while (i < 4)
{
if (!info->map.texture[i])
return (false);
i++;
}
return (true);
}

12
mlx_layer/mooves.c
View file

@ -6,7 +6,7 @@
/* By: bgoulard <bgoulard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/11/28 14:10:44 by bgoulard #+# #+# */
/* Updated: 2024/12/01 18:36:26 by rparodi ### ########.fr */
/* Updated: 2024/12/16 08:36:17 by bgoulard ### ########.fr */
/* */
/* ************************************************************************** */
@ -14,12 +14,6 @@
#include "cub3d_struct.h"
#include "cub3d_parsing.h"
void update_pos_i(t_player *player)
{
player->pos_i.x = (int)player->pos.x;
player->pos_i.y = (int)player->pos.y;
}
void move_straight(t_info *data)
{
t_tile *tile_x;
@ -35,7 +29,6 @@ void move_straight(t_info *data)
+ data->player.dir.y * MOVE_SPEED)});
if (tile_y->tile_type == EMPTY)
data->player.pos.y += data->player.dir.y * MOVE_SPEED;
update_pos_i(&data->player);
}
void move_backward(t_info *data)
@ -53,7 +46,6 @@ void move_backward(t_info *data)
- data->player.dir.y * MOVE_SPEED)});
if (tile_y->tile_type == EMPTY)
data->player.pos.y -= data->player.dir.y * MOVE_SPEED;
update_pos_i(&data->player);
}
void move_left(t_info *data)
@ -74,7 +66,6 @@ void move_left(t_info *data)
pplayer.y * MOVE_SPEED)});
if (tile_y->tile_type == EMPTY)
data->player.pos.y += pplayer.y * MOVE_SPEED;
update_pos_i(&data->player);
}
void move_right(t_info *data)
@ -95,5 +86,4 @@ void move_right(t_info *data)
* MOVE_SPEED)});
if (tile_y->tile_type == EMPTY)
data->player.pos.y -= pplayer.y * MOVE_SPEED;
update_pos_i(&data->player);
}

69
parsing/load_bgs.c
View file

@ -6,63 +6,66 @@
/* By: bgoulard <bgoulard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/12/01 17:47:37 by bgoulard #+# #+# */
/* Updated: 2024/12/01 17:52:28 by bgoulard ### ########.fr */
/* Updated: 2024/12/16 09:36:28 by bgoulard ### ########.fr */
/* */
/* ************************************************************************** */
#include "ft_addons.h"
#include "cub3d_struct.h"
#include "cub3d_parsing.h"
#include "ft_string.h"
#include <stdbool.h>
#include <stdio.h>
// col [ 3 ] is alpha channel (not used in the project)
bool color_from_str(const char *str, t_color *color)
{
int col[4];
char **split;
int col[4];
const char *arr[3];
split = ft_split(str, ',');
if (split == NULL)
if (ft_strcnb(str, ',') != 2)
return (false);
col[0] = ft_atoi(split[0]);
col[1] = ft_atoi(split[1]);
col[2] = ft_atoi(split[2]);
if (split[3])
col[3] = ft_atoi(split[3]);
else
col[3] = 255;
if (col[0] < 0 || col[0] > 255 || col[1] < 0 || col[1] > 255 || col[2] < 0
|| col[2] > 255 || col[3] < 0 || col[3] > 255)
arr[0] = ft_strtok((char *)str, ",");
arr[1] = ft_strtok(NULL, ",");
arr[2] = ft_strtok(NULL, ",");
if (!arr[0] || !arr[1] || !arr[2] || !ft_str_isnum(arr[0]) || \
!ft_str_isnum(arr[1]) || !ft_str_isnum(arr[2]))
return (false);
col[0] = ft_atoi(arr[0]);
col[1] = ft_atoi(arr[1]);
col[2] = ft_atoi(arr[2]);
col[3] = 255;
if (ft_inrange(col[0], 0, 255) == false || \
ft_inrange(col[1], 0, 255) == false || \
ft_inrange(col[2], 0, 255) == false)
return (false);
*color = (t_color){.r = col[0], .g = col[1], .b = col[2], .a = col[3]};
ft_free_2d((void **)split);
return (true);
}
bool load_bg(t_info *info, const char *line, const char **id_str)
{
t_color color;
size_t i;
size_t id_idx;
i = 0;
id_idx = 0;
ft_bzero(&color, sizeof(t_color));
while (id_str[i])
{
if (ft_strstart_with(line, id_str[i]) && (color_from_str(line
+ ft_strlen(id_str[i]), &color) == false || color.a < 255))
return (info->last_error = ERROR_PARSE, false);
if (ft_strstart_with(id_str[i], "F "))
info->map.bg_colors[BG_FLR] = color;
else
info->map.bg_colors[BG_CLG] = color;
i++;
}
if (color.color == 0)
return (info->last_error = ERROR_PARSE, false);
while (id_str[id_idx] && ft_strstart_with(line, id_str[id_idx]) == false)
id_idx++;
if (color_from_str(line + ft_strlen(id_str[id_idx]), &color) == false)
return (info->last_error = ERROR_PARSE_BG_COLOR_FORMAT, false);
if (id_idx == BG_FLR && info->map.bg_colors[BG_FLR].color == 0)
info->map.bg_colors[BG_FLR] = color;
else if (id_idx == BG_SKY && info->map.bg_colors[BG_SKY].color == 0)
info->map.bg_colors[BG_SKY] = color;
else
return (info->last_error = ERROR_PARSE_ALREADY_SET, false);
return (true);
}
void *load_bgs(void *data)
{
const char *id_str[] = {"F ", "C ", NULL};
const char *id_str[] = {[BG_FLR] = "F ", [BG_SKY] = "C ", [2] = NULL};
t_info *info;
size_t i;
@ -70,8 +73,8 @@ void *load_bgs(void *data)
info = (t_info *)data;
while (info->map.fraw[i])
{
if (is_identifier(info->map.fraw[i], id_str) && load_bg(info,
info->map.fraw[i], id_str) == false)
if (is_identifier(info->map.fraw[i], id_str) && \
load_bg(info, info->map.fraw[i], id_str) == false)
return (NULL);
i++;
}

21
parsing/load_textures.c
View file

@ -6,7 +6,7 @@
/* By: bgoulard <bgoulard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/12/01 17:46:52 by bgoulard #+# #+# */
/* Updated: 2024/12/01 17:53:44 by bgoulard ### ########.fr */
/* Updated: 2024/12/16 14:25:52 by bgoulard ### ########.fr */
/* */
/* ************************************************************************** */
@ -17,6 +17,13 @@
#include "mlx_functions.h"
#include <stdbool.h>
#include <stdio.h>
static void sv_errno(t_info *inf, int err_code)
{
inf->errno_state = errno;
inf->last_error = err_code;
}
bool load_texture(t_info *info, const char *str, const char **id_str)
{
@ -28,17 +35,17 @@ bool load_texture(t_info *info, const char *str, const char **id_str)
{
if (ft_strstart_with(str, id_str[i]))
{
texture.path = ft_strtrim(str + ft_strlen(id_str[i]), " ");
if (info->map.texture_[i].img != NULL)
return (sv_errno(info, ERROR_PARSE_ALREADY_SET), false);
texture.path = ft_strtrim(str + ft_strlen(id_str[i]), " \t");
if (texture.path == NULL)
return (info->errno_state = errno,
info->last_error = ERROR_MALLOC, false);
return (sv_errno(info, ERROR_MALLOC), false);
if (ft_strend_with(texture.path, ".xpm") == false)
return (info->last_error = ERROR_TEXTURE_FORMAT, false);
return (sv_errno(info, ERROR_TEXTURE_FORMAT), false);
texture.img = mlx_xpm_file_to_image(info->mlx_ptr, texture.path,
&texture.width, &texture.height);
if (texture.img == NULL)
return (info->errno_state = errno, info->last_error = ERROR_MLX,
false);
return (sv_errno(info, ERROR_MLX), false);
return (info->map.texture_[i] = texture, true);
}
i++;

20
parsing/load_tiles.c
View file

@ -6,7 +6,7 @@
/* By: bgoulard <bgoulard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/12/01 17:47:15 by bgoulard #+# #+# */
/* Updated: 2024/12/01 17:53:53 by bgoulard ### ########.fr */
/* Updated: 2024/12/16 09:33:53 by bgoulard ### ########.fr */
/* */
/* ************************************************************************** */
@ -17,6 +17,8 @@
#include "ft_vector.h"
#include "ft_math.h"
#include <stdio.h>
void *ft_strchrs(const char *str, const char *chrs)
{
while (*str)
@ -68,16 +70,28 @@ t_vector *load_vector(t_map *map)
int set_player(t_info *info, int i, t_vector *str_map)
{
t_dpoint pos;
char *str;
ft_bzero(&pos, sizeof(t_dpoint));
if (info->player.pos.x != 0 || info->player.pos.y != 0 || i == 0)
return (ft_vec_destroy(&str_map), info->last_error = ERROR_PARSE, \
EXIT_FAILURE);
str = ft_strchrs(ft_vec_at(str_map, i), "SNWE");
pos.y = i + .5;
pos.x = ft_strchrs(ft_vec_at(str_map, i), "SNWE")
- ft_vec_at(str_map, i) + .5;
pos.x = str - (char *)ft_vec_at(str_map, i) + .5;
info->player.dir = (t_dpoint){.x = 0, 0};
info->player.pos = pos;
info->player.pos_i = (t_ipoint){.x = (int)pos.x, .y = (int)pos.y};
if (*str == 'N')
info->player.dir.y = -1;
else if (*str == 'S')
info->player.dir.y = 1;
else if (*str == 'W')
info->player.dir.x = -1;
else if (*str == 'E')
info->player.dir.x = 1;
info->player.plane = (t_dpoint){.x = info->player.dir.y, \
.y = -info->player.dir.x};
return (EXIT_SUCCESS);
}

6
parsing/map.c
View file

@ -6,7 +6,7 @@
/* By: bgoulard <bgoulard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/11/12 08:31:06 by bgoulard #+# #+# */
/* Updated: 2024/12/01 17:51:13 by bgoulard ### ########.fr */
/* Updated: 2024/12/16 08:49:53 by bgoulard ### ########.fr */
/* */
/* ************************************************************************** */
@ -37,8 +37,8 @@ void parse_map(t_info *info)
opt = (t_optional){.val = info, .pres = OPT_SOME};
info->map.path = info->cli_ctx.file;
if (ft_optional_chain(&opt, function_list) == false)
return (c3_perror(info), (void)0);
info->player.plane = (t_dpoint){.x = 0, .y = 2 * atan(deg2rad(FOV / 2))};
info->player.dir = (t_dpoint){.x = -1, .y = 0};
if (ft_optional_chain(&opt, function_list) == false)
return (c3_perror(info), (void)0);
}

4
parsing/traverse_map.c
View file

@ -6,7 +6,7 @@
/* By: bgoulard <bgoulard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/12/01 17:49:12 by bgoulard #+# #+# */
/* Updated: 2024/12/01 17:54:03 by bgoulard ### ########.fr */
/* Updated: 2024/12/16 09:45:25 by bgoulard ### ########.fr */
/* */
/* ************************************************************************** */
@ -49,6 +49,6 @@ void *traverse_map(void *data)
info = (t_info *)data;
pos_start = (t_ipoint){.x = info->player.pos.x, .y = info->player.pos.y};
if (flood_fill(info->map.map, pos_start, info->map.size) == false)
return (info->last_error = ERROR_PARSE, NULL);
return (info->last_error = ERROR_MAP_OPEN, NULL);
return (info);
}

6
parsing/utils.c
View file

@ -6,7 +6,7 @@
/* By: bgoulard <bgoulard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/12/01 17:43:17 by bgoulard #+# #+# */
/* Updated: 2024/12/01 17:45:58 by bgoulard ### ########.fr */
/* Updated: 2024/12/16 09:39:50 by bgoulard ### ########.fr */
/* */
/* ************************************************************************** */
@ -21,9 +21,7 @@ t_tile *c3_get_cell(t_tile *map, t_ipoint dimensions, t_ipoint pos)
{
if (pos.x < 0 || pos.y < 0 || pos.x >= dimensions.x
|| pos.y >= dimensions.y)
return (printf("runtime error: %s:%d (pos:%d,%d on dims:%d,%d)\n",
__func__, __LINE__, pos.x, pos.y, dimensions.x, dimensions.y),
NULL);
return (NULL);
return (map + (pos.y * dimensions.x + pos.x));
}

70
raycast/draw_call.c Normal file
View file

@ -0,0 +1,70 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* draw_call.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: bgoulard <bgoulard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/12/16 14:43:09 by bgoulard #+# #+# */
/* Updated: 2024/12/16 14:47:56 by bgoulard ### ########.fr */
/* */
/* ************************************************************************** */
#include "cub3d_struct.h"
#include "cub3d.h"
#include "ft_math.h"
#include <math.h>
#define PT_LINEH 0
#define PT_D_START 1
#define PT_D_END 2
#define PT_X 3
#define TI_SIDE 0
#define TI_X 1
#define TD_PERP_WALL_DIST 0
#define TD_WALL_X 1
static void draw__(t_texture *texture, int *passthroug, t_info *data, \
double wallX)
{
t_ipoint text_off;
const double _step = (double)texture->height / passthroug[PT_LINEH];
double text_offset;
char *ptr_pix;
text_offset = (passthroug[PT_D_START] - (double)data->screen_size.y / 2 + \
(double)passthroug[PT_LINEH] / 2) * _step;
text_off.x = (wallX * texture->width);
while (passthroug[PT_D_START] < passthroug[PT_D_END])
{
text_off.y = (int)text_offset & (texture->height - 1);
text_offset += _step;
ptr_pix = texture->img->data + (text_off.y * \
texture->img->image->bytes_per_line + text_off.x * \
(texture->img->image->bits_per_pixel / 8));
my_mlx_pixel_put(data, passthroug[PT_X], passthroug[PT_D_START], \
*(unsigned int *)ptr_pix);
passthroug[PT_D_START]++;
}
}
// int texX = (int)(wallX * (double)texture->width);
void draw_(int *ti, double *td, t_ipoint step, t_info *data)
{
const int line_height = (int)(data->screen_size.y / \
td[TD_PERP_WALL_DIST]) * cos(deg2rad(FOV / 2));
int draw_start;
int draw_end;
t_texture *texture;
draw_start = ft_clamp(-line_height / 2 + data->screen_size.y / 2, 0, \
data->screen_size.y - 1);
draw_end = ft_clamp(line_height / 2 + data->screen_size.y / 2, 0, \
data->screen_size.y - 1);
texture = get_texture(ti[TI_SIDE], step, data);
draw__(texture, (int []){line_height, draw_start, draw_end, ti[TI_X]}, \
data, td[TD_WALL_X]);
}

85
raycast/frame_update.c
View file

@ -6,7 +6,7 @@
/* By: bgoulard <bgoulard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/11/12 06:02:54 by bgoulard #+# #+# */
/* Updated: 2024/12/05 16:44:04 by rparodi ### ########.fr */
/* Updated: 2024/12/16 14:51:46 by bgoulard ### ########.fr */
/* */
/* ************************************************************************** */
@ -15,51 +15,31 @@
#include "mlx_functions.h"
#include "ft_string.h"
#include "ft_math.h"
#include <math.h>
#include <unistd.h>
void set_step(t_ipoint *step, t_dpoint raydir);
void set_side_dist(t_dpoint *side_dist, t_dpoint *tb, t_ipoint pos_i);
/// line 33: normalize draw_start and draw_end
void draw_(int side, double perpWallDist, t_ipoint step, int x, t_info *data)
void search_hit(t_dpoint delta_dist, t_ipoint *pos_i, t_ipoint step, \
void *_data[3])
{
const int line_height = (int)(data->screen_size.y / perpWallDist) \
* cos(deg2rad(FOV / 2));
int draw_start;
int draw_end;
int color;
draw_start = -line_height / 2 + data->screen_size.y / 2;
draw_end = line_height / 2 + data->screen_size.y / 2;
draw_start = ft_clamp(draw_start, 0, data->screen_size.y - 1);
draw_end = ft_clamp(draw_end, 0, data->screen_size.y - 1);
color = get_cl(side, step);
while (draw_start < draw_end)
my_mlx_pixel_put(data, x, draw_start++, color);
}
void search_hit(t_dpoint *sideDist, t_dpoint deltaDist, t_ipoint *pos_i, \
t_ipoint step, void *_data[2])
{
int *side;
t_info *data;
int *side;
t_info *data;
t_dpoint *side_dist;
side = (int *)_data[1];
data = (t_info *)_data[0];
side_dist = (t_dpoint *)_data[2];
while (true)
{
if (sideDist->x < sideDist->y)
if (side_dist->x < side_dist->y)
{
sideDist->x += deltaDist.x;
side_dist->x += delta_dist.x;
pos_i->x += step.x;
*side = 0;
}
else
{
sideDist->y += deltaDist.y;
side_dist->y += delta_dist.y;
pos_i->y += step.y;
*side = 1;
}
@ -69,11 +49,14 @@ void search_hit(t_dpoint *sideDist, t_dpoint deltaDist, t_ipoint *pos_i, \
}
}
// t_dpoint prep_distoff ->
// x - perpwall_dist
// y - wall_off
void column_handler(t_ipoint pos_i, t_dpoint ray_dir, t_info *data, int x)
{
t_dpoint side_dist;
t_dpoint delta_dist;
double perp_wall_dist;
t_dpoint perp_distoff;
t_ipoint step;
int side;
@ -81,17 +64,23 @@ void column_handler(t_ipoint pos_i, t_dpoint ray_dir, t_info *data, int x)
set_step(&step, ray_dir);
set_side_dist(&side_dist, (t_dpoint[]){ray_dir, data->player.pos, \
delta_dist}, pos_i);
search_hit(&side_dist, delta_dist, &pos_i, step, (void *[]){data, &side});
search_hit(delta_dist, &pos_i, step, (void *[]){data, &side, &side_dist});
if (side == 0)
perp_wall_dist = (pos_i.x - data->player.pos.x + \
perp_distoff.x = (pos_i.x - data->player.pos.x + \
(double)(1 - step.x) / 2) / ray_dir.x;
else
perp_wall_dist = (pos_i.y - data->player.pos.y + \
perp_distoff.x = (pos_i.y - data->player.pos.y + \
(double)(1 - step.y) / 2) / ray_dir.y;
draw_(side, perp_wall_dist, step, x, data);
perp_distoff.y = data->player.pos.x + perp_distoff.x * ray_dir.x;
if (side == 0)
perp_distoff.y = data->player.pos.y + perp_distoff.x * ray_dir.y;
perp_distoff.y -= floor(perp_distoff.y);
draw_((int []){side, x}, (double []){perp_distoff.x, perp_distoff.y}, \
step, data);
}
int render_frame(t_info *data)
{
double camera_x;
double coef;
@ -101,7 +90,7 @@ int render_frame(t_info *data)
coef = 2 * tan(deg2rad(FOV) / 2) / (double)data->screen_size.x;
ft_bzero(data->camera.img_addr, data->screen_size.x * data->screen_size.y \
* (data->camera.bpp / 8));
draw_floor(data);
draw_bg(data);
while (x < data->screen_size.x)
{
camera_x = x * coef - 1;
@ -112,28 +101,6 @@ int render_frame(t_info *data)
x++;
}
mlx_put_image_to_window(data->mlx_ptr, data->win_ptr, \
data->camera.screen_buff, 0, 0);
data->camera.screen_buff, 0, 0);
return (0);
}
// Return 42 is irrelevant check mlx_loop to see that mlx doesn't care for the
// return of the function...
// (Why 'int (*)(void*)' when you dont use the int)
//
// This function is called each time the mlx loops over the mlx pointer in
// mlx_loop. here we do calc on time since last frame and player position
// to know if we need to re-draw the screen. if yes call raph function for
// calc.
// The need to redraw can also be expressed in the diferent key_pressed
// functions, I would recomend to make a bool field for that in the info
// struct.
// As a pure artefact of using mlx this function will likely be mooved to
// mlx_layer in the final repo.
int c3_frame_update(void *inf_ptr)
{
t_info *info;
info = inf_ptr;
mlx_clear_window(info->mlx_ptr, info->win_ptr);
return (EXIT_SUCCESS);
}

18
raycast/frame_update2.c
View file

@ -6,34 +6,36 @@
/* By: rparodi <rparodi@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/12/01 18:55:11 by rparodi #+# #+# */
/* Updated: 2024/12/05 16:43:53 by rparodi ### ########.fr */
/* Updated: 2024/12/16 09:43:18 by bgoulard ### ########.fr */
/* */
/* ************************************************************************** */
#include "cub3d.h"
#include "cub3d_struct.h"
#include "mlx_functions.h"
#include "ft_string.h"
#include "ft_math.h"
#include <math.h>
#include <unistd.h>
void draw_floor(t_info *data)
void draw_bg(t_info *data)
{
t_ipoint temp;
int switch_point;
int color;
temp.y = data->screen_size.y / 2;
ft_bzero(&temp, sizeof(t_ipoint));
switch_point = data->screen_size.y / 2;
color = data->map.bg_colors[BG_SKY].color;
while (temp.y < data->screen_size.y)
{
temp.x = 0;
while (temp.x < data->screen_size.x)
{
my_mlx_pixel_put(data, temp.x, temp.y, 0xFFFFFF);
my_mlx_pixel_put(data, temp.x, temp.y, color);
temp.x++;
}
temp.y++;
if (temp.y >= switch_point)
color = data->map.bg_colors[BG_FLR].color;
}
}

25
raycast/get_texture.c Normal file
View file

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* get_texture.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: bgoulard <bgoulard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/12/16 14:46:04 by bgoulard #+# #+# */
/* Updated: 2024/12/16 14:46:14 by bgoulard ### ########.fr */
/* */
/* ************************************************************************** */
#include "cub3d_struct.h"
t_texture *get_texture(int side, t_ipoint step, t_info *data)
{
if (side == 0 && step.x > 0)
return (&data->map.texture_[0]);
else if (side == 0 && step.x < 0)
return (&data->map.texture_[1]);
else if (side == 1 && step.y > 0)
return (&data->map.texture_[2]);
else
return (&data->map.texture_[3]);
}

8
raycast/rc_utils.c
View file

@ -6,13 +6,13 @@
/* By: rparodi <rparodi@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/11/12 12:24:35 by rparodi #+# #+# */
/* Updated: 2024/12/01 18:39:11 by rparodi ### ########.fr */
/* Updated: 2024/12/16 14:08:46 by bgoulard ### ########.fr */
/* */
/* ************************************************************************** */
#include "cub3d.h"
#include "cub3d_struct.h"
#include "mlx_functions.h"
#include "raycast.h"
#include <stdlib.h>
@ -55,6 +55,8 @@ double rc_launch(t_info *info, double angle)
int shelves_launch(t_info *info)
{
render_frame(info);
displacement_hook(info);
if (info->redraw)
(render_frame(info), info->redraw = false);
return (EXIT_SUCCESS);
}

7
sources/error.c
View file

@ -6,7 +6,7 @@
/* By: rparodi <rparodi@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/31 11:09:00 by rparodi #+# #+# */
/* Updated: 2024/11/27 12:00:34 by bgoulard ### ########.fr */
/* Updated: 2024/12/16 14:37:11 by bgoulard ### ########.fr */
/* */
/* ************************************************************************** */
@ -17,7 +17,7 @@
#include <unistd.h>
const char *const g_error_message[] = {
static const char *g_error_message[] = {
"no error",
"unknown error",
"could not open file",
@ -27,6 +27,9 @@ const char *const g_error_message[] = {
"missing file",
"malloc error",
"parse error",
"map open error",
"bad format for background color",
"variable was set multiple times",
"cli error",
"mlx error",
"texture format error",

71
sources/main.c
View file

@ -6,7 +6,7 @@
/* By: rparodi <rparodi@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/30 16:30:03 by rparodi #+# #+# */
/* Updated: 2024/12/01 18:53:12 by rparodi ### ########.fr */
/* Updated: 2024/12/16 09:38:44 by bgoulard ### ########.fr */
/* */
/* ************************************************************************** */
@ -19,69 +19,7 @@
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
void dump_map(t_tile *map, t_ipoint size)
{
int i;
int j;
i = 0;
while (i < size.y)
{
j = 0;
printf("\t\t\t");
while (j < size.x)
{
printf("%d", map[i * size.x + j].tile_type);
j++;
}
printf("\n");
i++;
}
}
// not normed but we'll take care of this as a niceties at the last
// possible moment :)
void dump_info(t_info *info)
{
const char *bool_str[2] = {"False", "True"};
size_t i;
i = 0;
printf("t_info:\n");
printf("\tplayer:\n");
printf("\t\tpos_i:\t(x: %d, y:%d)\n", \
info->player.pos_i.x, info->player.pos_i.y);
printf("\t\tpos:\t(x:%lf, y:%lf)\n", \
info->player.pos.x, info->player.pos.y);
printf("\t\tdir:\t(x:%lf, y:%lf)\n", \
info->player.dir.x, info->player.dir.y);
printf("\t\tplane:\t(x:%lf, y:%lf)\n", \
info->player.plane.x, info->player.plane.y);
printf("\tcli_ctx:\n");
printf("\t\tfile:\t%s\n", info->cli_ctx.file);
printf("\t\tdebug:\t%s\n", bool_str[info->cli_ctx.debug]);
printf("\t\tsave:\t%s\n", bool_str[info->cli_ctx.save]);
printf("\t\thelp:\t%s\n", bool_str[info->cli_ctx.help]);
printf("\tmap:\n");
printf("\t\tpath:%s\n", info->map.path);
printf("\t\tfd:\t%d\n", info->map.fd);
printf("\t\tsize:\t(x:%d, y:%d)\n", info->map.size.x, info->map.size.y);
while (info->map.fraw[i])
{
printf("\t\tmap.fraw[%*zu]: %s\n", 3, i, info->map.fraw[i]);
i++;
}
printf("\t\ttexture[0]: %p\n", info->map.texture[0]);
printf("\t\ttexture[1]: %p\n", info->map.texture[1]);
printf("\t\ttexture[2]: %p\n", info->map.texture[2]);
printf("\t\ttexture[3]: %p\n", info->map.texture[3]);
printf("\t\tmap: %p\n", info->map.map);
dump_map(info->map.map, info->map.size);
printf("\tlast_error: %d\n", info->last_error);
printf("\terno_state: %d\n", info->errno_state);
printf("\n");
}
#include <unistd.h>
void check_err(t_info *info)
{
@ -103,13 +41,16 @@ void run_cub3d(t_info *info)
return ;
parse_map(info);
if (info->cli_ctx.debug)
dump_info(info);
ft_putstr_fd("no debug mod on production run", STDERR_FILENO);
if (info->last_error != NO_ERROR)
return ;
if (info->cli_ctx.no_graphics == true)
return ;
info->camera.screen_buff = mlx_new_image(info->mlx_ptr, info->screen_size.x,
info->screen_size.y);
info->camera.img_addr = mlx_get_data_addr(info->camera.screen_buff,
&info->camera.bpp, &info->camera.line_len, &info->camera.endian);
info->redraw = true;
mlx_loop(info->mlx_ptr);
}