gbrochar
/
rtv1
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

rtv1

This commit is contained in:
gbrochar 2020-11-22 17:36:11 +01:00
parent d5e0c2ee54
commit 987ae15692
112 changed files with 3957 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

86
Makefile Normal file
View File

@ -0,0 +1,86 @@
# **************************************************************************** #
# #
# ::: :::::::: #
# Makefile :+: :+: :+: #
# +:+ +:+ +:+ #
# By: gbrochar <marvin@42.fr> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ #
# Created: 2019/02/06 12:13:51 by gbrochar #+# #+# #
# Updated: 2019/02/22 09:14:49 by gbrochar ### ########.fr #
# #
# **************************************************************************** #
NAME = rtv1
SRC_FILE = main.c \
parse.c \
mlx.c \
mlx_events.c \
color.c \
vec.c \
vec_arithmetics.c \
env_list.c \
set_camera.c \
scene_params.c \
add_spot.c \
add_plane.c \
add_sphere.c \
add_cylinder.c \
add_cone.c \
raytrace.c \
ray.c \
phong.c \
maths.c \
maths_plane.c \
maths_sphere.c \
maths_cylinder.c \
maths_cone.c \
OBJ_FILE = $(SRC_FILE:.c=.o)
SRC_DIR = src/
OBJ_DIR = obj/
SRC = $(addprefix $(SRC_DIR), $(SRC_FILE))
OBJ = $(addprefix $(OBJ_DIR), $(OBJ_FILE))
LIB = libft/libft.a -lm -lmlx -framework Appkit -framework OpenGL
CC = gcc
CFLAGS = -Wall -Werror -Wextra
RED = \033[31m
GREEN = \033[32m
YELLOW = \033[33m
BLUE = \033[34m
CYAN = \033[36m
WHITE = \033[0m
all: $(NAME)
$(NAME): $(OBJ) $(SRC_DIR)rtv1.h
@make -C libft
@$(CC) $(CFLAGS) -c $(SRC)
@mv $(OBJ_FILE) $(OBJ_DIR)
@$(CC) $(CFLAGS) $(OBJ) -o $(NAME) $(LIB)
@echo "$(GREEN)[OK]$(WHITE) RTv1"
$(OBJ_DIR)%.o: $(SRC_DIR)%.c libft/ $(SRC_DIR)rtv1.h
@if [ ! -d ./obj ]; then \
mkdir -p ./obj; \
fi;
@$(CC) $(CFLAGS) -I libft/ -o $@ -c $<
@echo "$(CYAN)[CC]$(WHITE) $<"
clean:
@make -C libft clean
@rm -rf $(OBJ_DIR)
fclean: clean
@make -C libft fclean
@rm -f $(NAME)
re: fclean all
.PHONY: all clean fclean re

4
README.md
View File

@ -1,3 +1,5 @@
# rtv1
rtv1 : a basic raytracing engine made using minilibx. It features Phong shading, planes, spheres, cones and cylinders.
rtv1 : a basic raytracing engine made using minilibx. It features Phong shading, planes, spheres, cones and cylinders.
You need to have to minilibx installed to run it. It will not compile on linux systems.

1
auteur Normal file
View File

@ -0,0 +1 @@
gbrochar

122
libft/Makefile Normal file
View File

@ -0,0 +1,122 @@
# **************************************************************************** #
# #
# ::: :::::::: #
# Makefile :+: :+: :+: #
# +:+ +:+ +:+ #
# By: gbrochar <marvin@42.fr> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ #
# Created: 2015/11/27 19:26:17 by gbrochar #+# #+# #
# Updated: 2019/02/22 10:07:07 by gbrochar ### ########.fr #
# #
# **************************************************************************** #
NAME = libft.a
SRC = ft_atoi.c \
ft_atof.c \
ft_bzero.c \
ft_isalnum.c \
ft_isalpha.c \
ft_isascii.c \
ft_isdigit.c \
ft_isprint.c \
ft_isspace.c \
ft_itoa.c \
ft_lstadd.c \
ft_lstdel.c \
ft_lstdelone.c \
ft_lstiter.c \
ft_lstmap.c \
ft_lstnew.c \
ft_memalloc.c \
ft_memccpy.c \
ft_memchr.c \
ft_memcmp.c \
ft_memcpy.c \
ft_memdel.c \
ft_memmove.c \
ft_memset.c \
ft_power.c \
ft_putchar.c \
ft_putchar_fd.c \
ft_putendl.c \
ft_putendl_fd.c \
ft_putnbr.c \
ft_putnbr_fd.c \
ft_putstr.c \
ft_putstr_fd.c \
ft_sort_int.c \
ft_sqrt.c \
ft_strcat.c \
ft_strchr.c \
ft_strclr.c \
ft_strcmp.c \
ft_strcpy.c \
ft_strdel.c \
ft_strdup.c \
ft_strequ.c \
ft_striter.c \
ft_striteri.c \
ft_strjoin.c \
ft_strlcat.c \
ft_strlen.c \
ft_strmap.c \
ft_strmapi.c \
ft_strncat.c \
ft_strncmp.c \
ft_strncpy.c \
ft_strnequ.c \
ft_strnew.c \
ft_strnstr.c \
ft_strrchr.c \
ft_strsplit.c \
ft_strstr.c \
ft_strsub.c \
ft_strtrim.c \
ft_swap.c \
ft_tolower.c \
ft_toupper.c \
ft_lstadd_preview.c \
ft_get_last_node.c \
ft_ishexdigit.c \
ft_atoi_len.c \
ft_atoi_color.c \
ft_error.c \
get_next_line.c \
ft_strtab_isdigit.c \
ft_atoi_split.c \
OBJ = $(SRC:.c=.o)
CC = gcc
CFLAGS = # -Wall -Werror -Wextra
RED = \033[31m
GREEN = \033[32m
YELLOW = \033[33m
BLUE = \033[34m
CYAN = \033[36m
WHITE= \033[0m
all: $(NAME)
$(NAME): $(OBJ) libft.h get_next_line.h
@$(CC) $(CFLAGS) -c $(SRC)
@ar rc $(NAME) $(OBJ)
@ranlib $(NAME)
@echo "$(GREEN)[OK]$(WHITE) Libft.a"
%.o: %.c libft.h get_next_line.h
@$(CC) $(CFLAGS) -o $@ -c $<
@echo "$(CYAN)[OK]$(WHITE) $<"
clean:
@rm -f $(OBJ)
fclean: clean
@rm -f $(NAME)
re: fclean all
.PHONY: all clean fclean re

36
libft/ft_atof.c Normal file
View File

@ -0,0 +1,36 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_atof.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/02/06 14:47:22 by gbrochar #+# #+# */
/* Updated: 2019/02/21 15:34:04 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
double ft_atof(const char *str)
{
char *tmp;
double floating_part;
double integer_part;
integer_part = ft_atoi(str);
floating_part = 0;
tmp = ft_strchr(str, '.');
if (tmp)
{
floating_part = ft_atoi(++tmp);
while (*tmp >= '0' && *tmp <= '9')
{
floating_part /= (double)10;
tmp++;
}
}
if (integer_part < 0)
return (-1.0 * (fabs(integer_part) + floating_part));
return (integer_part + floating_part);
}

32
libft/ft_atoi.c Normal file
View File

@ -0,0 +1,32 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_atoi.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/27 19:18:43 by gbrochar #+# #+# */
/* Updated: 2019/02/06 16:16:54 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_atoi(const char *str)
{
long result;
long sign;
result = 0;
while (ft_isspace(*str))
str++;
sign = (*str == '-') ? -1 : 1;
if (*str == '-' || *str == '+')
str++;
while (*str >= '0' && *str <= '9')
{
result = (result * 10) + (*str - '0');
str++;
}
return ((int)(result * sign));
}

33
libft/ft_atoi_color.c Normal file
View File

@ -0,0 +1,33 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_atoi_color.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/27 19:18:43 by gbrochar #+# #+# */
/* Updated: 2016/05/06 10:25:37 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_atoi_color(char *hexa_color)
{
int i;
int result;
result = 0;
i = 5;
while (i >= 0)
{
if (hexa_color[i] >= '0' && hexa_color[i] <= '9')
result += (hexa_color[i] - '0') * ft_power(16, (6 - i));
else if (hexa_color[i] >= 'A' && hexa_color[i] <= 'F')
result += (hexa_color[i] - '0') * ft_power(16, (6 - i));
else
return (-1);
i--;
}
return (result);
}

35
libft/ft_atoi_len.c Normal file
View File

@ -0,0 +1,35 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_atoi_len.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/27 19:18:43 by gbrochar #+# #+# */
/* Updated: 2016/05/06 11:45:55 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_atoi_len(char *str, int *len)
{
int result;
int sign;
result = 0;
*len = 0;
sign = (*str == '-') ? -1 : 1;
if (*str == '-' || *str == '+')
{
str++;
len++;
}
while (*str >= '0' && *str <= '9')
{
result = (result * 10) + (*str - '0');
str++;
len++;
}
return (result * sign);
}

34
libft/ft_atoi_split.c Normal file
View File

@ -0,0 +1,34 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_atoi_split.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/05/31 08:52:54 by gbrochar #+# #+# */
/* Updated: 2016/05/31 09:15:51 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int *ft_atoi_split(char *str, char c, int *tab_len)
{
int *tab;
char **str_tab;
int i;
if (!str || ft_isdigit(c))
return (NULL);
str_tab = ft_strsplit(str, c);
i = 0;
while (str_tab[i])
++i;
if (!(tab = (int *)malloc((i + 1) * sizeof(int))))
return (NULL);
*tab_len = i;
i = -1;
while (str_tab[++i])
tab[i] = atoi(str_tab[i]);
return (tab);
}

25
libft/ft_bzero.c Normal file
View File

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_bzero.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/24 11:39:18 by gbrochar #+# #+# */
/* Updated: 2015/11/24 20:46:21 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_bzero(void *s, size_t n)
{
char *byte;
byte = s;
while (n-- > 0)
{
*byte = 0;
byte++;
}
}

19
libft/ft_error.c Normal file
View File

@ -0,0 +1,19 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_error.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/05/10 02:34:40 by gbrochar #+# #+# */
/* Updated: 2016/05/11 10:55:43 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_error(char *str)
{
ft_putstr_fd(str, 2);
exit(0);
}

23
libft/ft_get_last_node.c Normal file
View File

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_get_last_node.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/02/28 07:10:21 by gbrochar #+# #+# */
/* Updated: 2016/02/28 07:12:12 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
t_list *ft_get_last_node(t_list **alst)
{
t_list *tmp;
tmp = *alst;
while (tmp->next)
tmp = tmp->next;
return (tmp);
}

18
libft/ft_isalnum.c Normal file
View File

@ -0,0 +1,18 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isalnum.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/27 18:51:03 by gbrochar #+# #+# */
/* Updated: 2015/11/28 15:22:14 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_isalnum(int c)
{
return (ft_isalpha(c) || ft_isdigit(c));
}

18
libft/ft_isalpha.c Normal file
View File

@ -0,0 +1,18 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isalpha.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/27 18:59:08 by gbrochar #+# #+# */
/* Updated: 2015/11/28 15:42:21 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_isalpha(int c)
{
return (((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ? 1 : 0));
}

18
libft/ft_isascii.c Normal file
View File

@ -0,0 +1,18 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isascii.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/27 18:48:25 by gbrochar #+# #+# */
/* Updated: 2015/11/28 15:32:54 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_isascii(int c)
{
return ((c >= 0 && c <= 127) ? 1 : 0);
}

18
libft/ft_isdigit.c Normal file
View File

@ -0,0 +1,18 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isdigit.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/27 18:53:19 by gbrochar #+# #+# */
/* Updated: 2015/11/28 14:41:12 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_isdigit(int c)
{
return ((c >= '0' && c <= '9') ? 1 : 0);
}

20
libft/ft_ishexdigit.c Normal file
View File

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_ishexdigit.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/05/05 23:22:51 by gbrochar #+# #+# */
/* Updated: 2016/05/05 23:24:26 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_ishexdigit(int c)
{
if (ft_isdigit(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))
return (1);
return (0);
}

18
libft/ft_isprint.c Normal file
View File

@ -0,0 +1,18 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isprint.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/27 18:44:48 by gbrochar #+# #+# */
/* Updated: 2015/11/28 15:33:24 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_isprint(int c)
{
return ((c >= 32 && c <= 126) ? 1 : 0);
}

21
libft/ft_isspace.c Normal file
View File

@ -0,0 +1,21 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isspace.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/28 14:37:03 by gbrochar #+# #+# */
/* Updated: 2015/11/28 14:39:18 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_isspace(int c)
{
if (c == '\t' || c == '\n' || c == '\f' || c == '\v' || c == '\r'
|| c == ' ')
return (1);
return (0);
}

37
libft/ft_itoa.c Normal file
View File

@ -0,0 +1,37 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_itoa.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/29 09:56:59 by gbrochar #+# #+# */
/* Updated: 2019/02/06 16:17:43 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_itoa(int n)
{
char *str;
size_t str_size;
int n_mem;
n_mem = n;
str_size = (n < 0) ? 3 : 2;
while ((n > 9 || n < -9) && str_size++)
n /= 10;
str = (char *)malloc((str_size--) * sizeof(char));
if (!str)
return (NULL);
str[str_size--] = '\0';
while (n_mem > 9 || n_mem < -9)
{
str[str_size--] = (n_mem < 0) ? -(n_mem % 10) + '0' : n_mem % 10 + '0';
n_mem = n_mem / 10;
}
str[0] = (n_mem < 0) ? '-' : ((char)n_mem + '0');
str[1] = (n_mem < 0) ? ((char)-n_mem + '0') : str[1];
return (str);
}

23
libft/ft_lstadd.c Normal file
View File

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstadd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/12/01 14:24:17 by gbrochar #+# #+# */
/* Updated: 2016/02/26 14:02:54 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lstadd(t_list **alst, t_list *new)
{
t_list *tmp;
tmp = *alst;
while (tmp->next != NULL)
tmp = tmp->next;
tmp->next = new;
}

19
libft/ft_lstadd_preview.c Normal file
View File

@ -0,0 +1,19 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstadd_preview.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/12/01 14:24:17 by gbrochar #+# #+# */
/* Updated: 2016/02/26 14:01:33 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lstadd_preview(t_list **alst, t_list *new)
{
new->next = *alst;
*alst = new;
}

25
libft/ft_lstdel.c Normal file
View File

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstdel.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/30 21:34:50 by gbrochar #+# #+# */
/* Updated: 2015/12/05 15:10:37 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lstdel(t_list **alst, void (*del)(void *, size_t))
{
t_list *tmp;
while (*alst)
{
tmp = *alst;
ft_lstdelone(alst, del);
*alst = tmp->next;
}
}

19
libft/ft_lstdelone.c Normal file
View File

@ -0,0 +1,19 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstdelone.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/30 21:27:05 by gbrochar #+# #+# */
/* Updated: 2015/12/02 13:28:32 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lstdelone(t_list **alst, void (*del)(void *, size_t))
{
del((*alst)->content, (*alst)->content_size);
ft_memdel((void **)alst);
}

29
libft/ft_lstiter.c Normal file
View File

@ -0,0 +1,29 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstiter.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/12/02 13:38:16 by gbrochar #+# #+# */
/* Updated: 2015/12/04 16:41:19 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lstiter(t_list *lst, void (*f)(t_list *elem))
{
t_list *start;
t_list *tmp;
start = lst;
while (lst->next)
{
tmp = lst;
f(lst);
lst = tmp->next;
}
f(lst);
lst = start;
}

31
libft/ft_lstmap.c Normal file
View File

@ -0,0 +1,31 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstmap.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/12/02 14:33:07 by gbrochar #+# #+# */
/* Updated: 2015/12/02 16:17:18 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
t_list *ft_lstmap(t_list *lst, t_list *(*f)(t_list *elem))
{
t_list *lst_begin;
t_list *lst_new;
lst_begin = ft_lstnew((f(lst))->content, (f(lst))->content_size);
lst_new = lst_begin;
lst = lst->next;
while (lst->next)
{
lst_new->next = ft_lstnew((f(lst))->content, (f(lst))->content_size);
lst_new = lst_new->next;
lst = lst->next;
}
lst_new->next = ft_lstnew((f(lst))->content, (f(lst))->content_size);
return (lst_begin);
}

40
libft/ft_lstnew.c Normal file
View File

@ -0,0 +1,40 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstnew.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/30 21:21:09 by gbrochar #+# #+# */
/* Updated: 2016/02/27 21:04:51 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
t_list *ft_lstnew(void const *content, size_t content_size)
{
t_list *lst;
lst = (t_list *)malloc(sizeof(t_list));
if (!lst)
return (NULL);
if (!content)
{
lst->content = NULL;
lst->content_size = 0;
}
else
{
lst->content = ft_memalloc(content_size);
if (!lst->content)
{
free(lst);
return (NULL);
}
ft_memmove(lst->content, content, content_size);
lst->content_size = content_size;
}
lst->next = NULL;
return (lst);
}

27
libft/ft_memalloc.c Normal file
View File

@ -0,0 +1,27 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memalloc.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/28 18:11:36 by gbrochar #+# #+# */
/* Updated: 2016/02/27 21:04:55 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void *ft_memalloc(size_t size)
{
unsigned char *ptr;
size_t i;
i = 0;
ptr = (unsigned char *)malloc(size);
if (!ptr)
return (NULL);
while (i < size)
ptr[i++] = 0;
return (ptr);
}

37
libft/ft_memccpy.c Normal file
View File

@ -0,0 +1,37 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memccpy.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/24 14:40:00 by gbrochar #+# #+# */
/* Updated: 2019/02/06 16:20:23 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void *ft_memccpy(void *dst, const void *src, int c, size_t n)
{
size_t i;
unsigned char to_find;
unsigned char *dst_byte;
const unsigned char *src_byte;
to_find = (unsigned char)c;
i = 0;
dst_byte = (unsigned char *)dst;
src_byte = (const unsigned char *)src;
while (i != n && src_byte[i] != to_find)
{
dst_byte[i] = src_byte[i];
i++;
}
if (src_byte[i] == to_find)
{
dst_byte[i] = to_find;
return ((void *)&dst_byte[i + 1]);
}
return (NULL);
}

31
libft/ft_memchr.c Normal file
View File

@ -0,0 +1,31 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memchr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/25 13:03:54 by gbrochar #+# #+# */
/* Updated: 2019/02/06 16:23:56 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void *ft_memchr(const void *s, int c, size_t n)
{
unsigned char to_find;
unsigned char *str;
size_t i;
i = 0;
to_find = c;
str = (unsigned char *)s;
while (i < n)
{
if (str[i] == to_find)
return ((void *)&s[i]);
i++;
}
return (NULL);
}

33
libft/ft_memcmp.c Normal file
View File

@ -0,0 +1,33 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memcmp.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/25 14:13:46 by gbrochar #+# #+# */
/* Updated: 2015/11/30 14:46:05 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_memcmp(const void *s1, const void *s2, size_t n)
{
unsigned char *s1_byte;
unsigned char *s2_byte;
size_t i;
s1_byte = (unsigned char *)s1;
s2_byte = (unsigned char *)s2;
i = 0;
if (n <= 0)
return (0);
while (s1_byte[i] == s2_byte[i])
{
if (i + 1 == n)
return (0);
i++;
}
return (s1_byte[i] - s2_byte[i]);
}

30
libft/ft_memcpy.c Normal file
View File

@ -0,0 +1,30 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memcpy.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/25 14:42:55 by gbrochar #+# #+# */
/* Updated: 2015/11/25 14:43:02 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void *ft_memcpy(void *dst, const void *src, size_t n)
{
size_t i;
unsigned char *dst_byte;
const unsigned char *src_byte;
i = 0;
dst_byte = dst;
src_byte = src;
while (i < n)
{
dst_byte[i] = src_byte[i];
i++;
}
return (dst);
}

19
libft/ft_memdel.c Normal file
View File

@ -0,0 +1,19 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memdel.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/28 18:23:10 by gbrochar #+# #+# */
/* Updated: 2015/11/28 18:25:10 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_memdel(void **ap)
{
free(*ap);
*ap = NULL;
}

39
libft/ft_memmove.c Normal file
View File

@ -0,0 +1,39 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memmove.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/25 12:36:04 by gbrochar #+# #+# */
/* Updated: 2015/11/25 13:03:31 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void *ft_memmove(void *dst, const void *src, size_t len)
{
unsigned char *dst_byte;
const unsigned char *src_byte;
size_t index;
dst_byte = dst;
src_byte = src;
if (dst_byte > src_byte)
{
index = len;
while (index-- > 0)
dst_byte[index] = src_byte[index];
}
else
{
index = 0;
while (index < len)
{
dst_byte[index] = src_byte[index];
index++;
}
}
return (dst);
}

28
libft/ft_memset.c Normal file
View File

@ -0,0 +1,28 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memset.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/23 17:53:16 by gbrochar #+# #+# */
/* Updated: 2015/11/25 12:18:32 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void *ft_memset(void *b, int c, size_t len)
{
unsigned char *byte;
size_t i;
byte = b;
i = 0;
while (i++ < len)
{
*byte = c;
byte++;
}
return (b);
}

25
libft/ft_power.c Normal file
View File

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_power.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/12/05 15:23:07 by gbrochar #+# #+# */
/* Updated: 2015/12/07 11:03:41 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_power(int nb, int pow)
{
int ret;
ret = 1;
if (pow < 0)
return (-1);
while (pow--)
ret *= nb;
return (ret);
}

18
libft/ft_putchar.c Normal file
View File

@ -0,0 +1,18 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putchar.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/24 12:01:00 by gbrochar #+# #+# */
/* Updated: 2015/11/29 16:47:24 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_putchar(char c)
{
write(1, &c, 1);
}

18
libft/ft_putchar_fd.c Normal file
View File

@ -0,0 +1,18 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putchar_fd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/29 09:01:19 by gbrochar #+# #+# */
/* Updated: 2015/11/29 09:02:06 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_putchar_fd(char c, int fd)
{
write(fd, &c, 1);
}

19
libft/ft_putendl.c Normal file
View File

@ -0,0 +1,19 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putendl.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/29 09:04:13 by gbrochar #+# #+# */
/* Updated: 2015/11/29 09:04:50 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_putendl(char const *s)
{
ft_putstr(s);
ft_putchar('\n');
}

19
libft/ft_putendl_fd.c Normal file
View File

@ -0,0 +1,19 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putendl_fd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/29 09:04:58 by gbrochar #+# #+# */
/* Updated: 2015/11/29 09:05:51 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_putendl_fd(char const *s, int fd)
{
ft_putstr_fd(s, fd);
ft_putchar_fd('\n', fd);
}

31
libft/ft_putnbr.c Normal file
View File

@ -0,0 +1,31 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putnbr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/29 08:58:30 by gbrochar #+# #+# */
/* Updated: 2015/11/29 10:49:28 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_putnbr(int n)
{
if (n == -2147483648)
ft_putstr("-2147483648");
else if (n < 0)
{
ft_putchar('-');
ft_putnbr(-n);
}
else if (n > 9)
{
ft_putnbr(n / 10);
ft_putchar(n % 10 + '0');
}
else
ft_putchar(n + '0');
}

31
libft/ft_putnbr_fd.c Normal file
View File

@ -0,0 +1,31 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putnbr_fd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/29 09:10:52 by gbrochar #+# #+# */
/* Updated: 2015/11/29 10:49:38 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_putnbr_fd(int n, int fd)
{
if (n == -2147483648)
ft_putstr_fd("-2147483648", fd);
else if (n < 0)
{
ft_putchar_fd('-', fd);
ft_putnbr_fd(-n, fd);
}
else if (n > 9)
{
ft_putnbr_fd(n / 10, fd);
ft_putchar_fd(n % 10 + '0', fd);
}
else
ft_putchar_fd(n + '0', fd);
}

19
libft/ft_putstr.c Normal file
View File

@ -0,0 +1,19 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putstr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/27 18:23:12 by gbrochar #+# #+# */
/* Updated: 2015/11/29 09:06:37 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_putstr(char const *s)
{
while (*s)
write(1, s++, 1);
}

19
libft/ft_putstr_fd.c Normal file
View File

@ -0,0 +1,19 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putstr_fd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/29 09:02:48 by gbrochar #+# #+# */
/* Updated: 2015/11/29 09:04:05 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_putstr_fd(char const *s, int fd)
{
while (*s)
write(fd, s++, 1);
}

33
libft/ft_sort_int.c Normal file
View File

@ -0,0 +1,33 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_sort_int.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/12/05 18:36:08 by gbrochar #+# #+# */
/* Updated: 2015/12/07 11:04:19 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_sort_int(int *tab, int size)
{
int i;
int tmp;
i = 0;
while ((i + 1) < size)
{
if (tab[i] > tab[i + 1])
{
tmp = tab[i];
tab[i] = tab[i + 1];
tab[i + 1] = tmp;
i = 0;
}
else
i++;
}
}

23
libft/ft_sqrt.c Normal file
View File

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_sqrt.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/12/07 08:28:11 by gbrochar #+# #+# */
/* Updated: 2015/12/07 08:50:43 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
long ft_sqrt(long n)
{
long sqrt;
sqrt = 0;
while ((sqrt * sqrt) != n && (sqrt * sqrt) < n)
sqrt++;
return (((sqrt * sqrt) == n) ? (sqrt) : (-1));
}

32
libft/ft_strcat.c Normal file
View File

@ -0,0 +1,32 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strcat.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/25 16:26:53 by gbrochar #+# #+# */
/* Updated: 2016/04/09 21:24:58 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_strcat(char *s1, const char *s2)
{
char *p_s1;
const char *p_s2;
p_s2 = s2;
p_s1 = s1;
while (*p_s1)
p_s1++;
while (*p_s2)
{
*p_s1 = *p_s2;
p_s1++;
p_s2++;
}
*p_s1 = '\0';
return (s1);
}

23
libft/ft_strchr.c Normal file
View File

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strchr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/27 09:50:37 by gbrochar #+# #+# */
/* Updated: 2019/02/08 11:50:45 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_strchr(const char *s, int c)
{
if (s == NULL)
return (0);
while (*s != (char)c)
if (!*s++)
return (0);
return ((char *)s);
}

19
libft/ft_strclr.c Normal file
View File

@ -0,0 +1,19 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strclr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/28 20:22:52 by gbrochar #+# #+# */
/* Updated: 2015/11/28 21:09:55 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_strclr(char *s)
{
while (*s)
*s++ = '\0';
}

21
libft/ft_strcmp.c Normal file
View File

@ -0,0 +1,21 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strcmp.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/28 14:52:37 by gbrochar #+# #+# */
/* Updated: 2015/11/28 15:34:12 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_strcmp(const char *s1, const char *s2)
{
while (*s1 || *s2)
if (*s1++ != *s2++)
return ((unsigned char)*--s1 - (unsigned char)*--s2);
return (0);
}

30
libft/ft_strcpy.c Normal file
View File

@ -0,0 +1,30 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strcpy.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/25 15:10:54 by gbrochar #+# #+# */
/* Updated: 2016/04/09 16:49:30 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_strcpy(char *dst, const char *src)
{
char *p_dest;
const char *p_src;
p_src = src;
p_dest = dst;
while (*p_src)
{
*p_dest = *p_src;
p_dest++;
p_src++;
}
*p_dest = '\0';
return (dst);
}

18
libft/ft_strdel.c Normal file
View File

@ -0,0 +1,18 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strdel.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/28 20:21:47 by gbrochar #+# #+# */
/* Updated: 2015/12/08 15:21:50 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_strdel(char **as)
{
ft_memdel((void **)as);
}

29
libft/ft_strdup.c Normal file
View File

@ -0,0 +1,29 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strdup.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/25 14:47:23 by gbrochar #+# #+# */
/* Updated: 2016/04/09 21:27:37 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_strdup(const char *s1)
{
char *dest;
int i;
i = 0;
dest = ft_strnew(ft_strlen(s1));
while (s1[i])
{
dest[i] = s1[i];
i++;
}
dest[i] = '\0';
return (dest);
}

27
libft/ft_strequ.c Normal file
View File

@ -0,0 +1,27 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strequ.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/29 08:35:37 by gbrochar #+# #+# */
/* Updated: 2015/11/29 15:47:45 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_strequ(char const *s1, char const *s2)
{
int i;
i = 0;
while (s1[i] == s2[i])
{
if (s1[i] == '\0' && s2[i] == '\0')
return (1);
i++;
}
return (0);
}

25
libft/ft_striter.c Normal file
View File

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_striter.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/28 20:37:55 by gbrochar #+# #+# */
/* Updated: 2015/11/29 10:51:54 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_striter(char *s, void (*f)(char *))
{
int i;
i = 0;
while (s[i])
{
f(&s[i]);
i++;
}
}

25
libft/ft_striteri.c Normal file
View File

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_striteri.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/28 21:02:16 by gbrochar #+# #+# */
/* Updated: 2015/11/29 10:30:40 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_striteri(char *s, void (*f)(unsigned int, char *s))
{
unsigned int i;
i = 0;
while (s[i])
{
f(i, &s[i]);
i++;
}
}

34
libft/ft_strjoin.c Normal file
View File

@ -0,0 +1,34 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strjoin.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/29 09:48:11 by gbrochar #+# #+# */
/* Updated: 2016/04/09 16:30:06 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_strjoin(char const *s1, const char *s2)
{
size_t i;
char *new;
s1 = (s1 == NULL) ? "" : s1;
s2 = (s2 == NULL) ? "" : s2;
if (s1 && s2)
{
i = ft_strlen(s1) + ft_strlen(s2);
new = ft_strnew(i);
if (new)
{
new = ft_strcpy(new, s1);
new = ft_strcat(new, s2);
return (new);
}
}
return (NULL);
}

32
libft/ft_strlcat.c Normal file
View File

@ -0,0 +1,32 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strlcat.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/26 08:00:59 by gbrochar #+# #+# */
/* Updated: 2015/11/29 15:48:23 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
size_t ft_strlcat(char *dst, const char *src, size_t size)
{
size_t dst_len;
size_t src_len;
size_t i_src;
size_t i_dst;
dst_len = ft_strlen(dst);
src_len = ft_strlen(src);
i_src = 0;
i_dst = dst_len;
if (dst_len >= size)
return (size + src_len);
while (src[i_src] && (size-- - (dst_len + 1)) > 0)
dst[i_dst++] = src[i_src++];
dst[i_dst] = '\0';
return (dst_len + src_len);
}

23
libft/ft_strlen.c Normal file
View File

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strlen.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/25 14:43:32 by gbrochar #+# #+# */
/* Updated: 2016/04/09 16:57:01 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
size_t ft_strlen(const char *s)
{
size_t i;
i = 0;
while (s && s[i])
i++;
return (i);
}

33
libft/ft_strmap.c Normal file
View File

@ -0,0 +1,33 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strmap.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/28 21:30:34 by gbrochar #+# #+# */
/* Updated: 2015/11/29 16:53:26 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_strmap(char const *s, char (*f)(char))
{
char *str;
int i;
int len;
len = ft_strlen(s);
i = 0;
str = (char *)malloc((len + 1) * sizeof(char));
if (!str)
return (NULL);
while (i < len)
{
str[i] = f(s[i]);
i++;
}
str[len] = '\0';
return (str);
}

31
libft/ft_strmapi.c Normal file
View File

@ -0,0 +1,31 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strmapi.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/28 21:39:30 by gbrochar #+# #+# */
/* Updated: 2015/12/02 16:22:05 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_strmapi(char const *s, char (*f)(unsigned int, char))
{
char *str;
unsigned int i;
i = 0;
str = (char *)malloc((ft_strlen(s) + 1) * sizeof(char));
if (!str)
return (NULL);
while (s[i])
{
str[i] = f(i, s[i]);
i++;
}
str[i] = '\0';
return (str);
}

30
libft/ft_strncat.c Normal file
View File

@ -0,0 +1,30 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strncat.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/25 19:29:04 by gbrochar #+# #+# */
/* Updated: 2015/11/29 12:33:35 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_strncat(char *s1, const char *s2, size_t n)
{
size_t i_dst;
size_t i_src;
i_dst = ft_strlen(s1);
i_src = 0;
while (i_src < n && s2[i_src] != '\0')
{
s1[i_dst] = s2[i_src];
i_dst++;
i_src++;
}
s1[i_dst] = '\0';
return (s1);
}

21
libft/ft_strncmp.c Normal file
View File

@ -0,0 +1,21 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strncmp.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/28 14:57:36 by gbrochar #+# #+# */
/* Updated: 2015/11/28 15:34:45 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_strncmp(const char *s1, const char *s2, size_t n)
{
while ((*s1 || *s2) && n--)
if (*s1++ != *s2++)
return ((unsigned char)*--s1 - (unsigned char)*--s2);
return (0);
}

31
libft/ft_strncpy.c Normal file
View File

@ -0,0 +1,31 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strncpy.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/25 16:18:18 by gbrochar #+# #+# */
/* Updated: 2015/11/25 16:21:09 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_strncpy(char *dst, const char *src, size_t n)
{
size_t i;
i = 0;
while (i != n && src[i] != '\0')
{
dst[i] = src[i];
i++;
}
while (i != n)
{
dst[i] = '\0';
i++;
}
return (dst);
}

27
libft/ft_strnequ.c Normal file
View File

@ -0,0 +1,27 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strnequ.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/29 08:37:07 by gbrochar #+# #+# */
/* Updated: 2015/12/05 16:24:50 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_strnequ(char const *s1, char const *s2, size_t n)
{
size_t i;
i = 0;
while (s1[i] == s2[i] || i == n)
{
if ((s1[i] == '\0' && s2[i] == '\0') || i == n)
return (1);
i++;
}
return (0);
}

23
libft/ft_strnew.c Normal file
View File

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strnew.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/28 18:26:56 by gbrochar #+# #+# */
/* Updated: 2016/04/09 16:25:44 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_strnew(size_t size)
{
char *str;
str = (char *)malloc(sizeof(char) * (size + 1));
if (!str)
return (NULL);
return (str);
}

40
libft/ft_strnstr.c Normal file
View File

@ -0,0 +1,40 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strnstr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/27 12:49:32 by gbrochar #+# #+# */
/* Updated: 2015/11/28 16:39:13 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_strnstr(const char *s1, char *s2, size_t n)
{
size_t i;
size_t i_mem;
size_t i_tofind;
i_mem = 0;
if (s2[0] == '\0')
return ((char *)s1);
while (s1[i_mem] != '\0' && i_mem < n)
{
i_tofind = 0;
while (s1[i_mem] != s2[i_tofind] && s1[i_mem] != '\0')
i_mem++;
if (s1[i_mem] == '\0')
return (NULL);
i = i_mem;
while ((s1[i] == s2[i_tofind] || s2[i_tofind] == '\0') && i++ <= n)
if (s2[i_tofind++] == '\0')
return ((char *)&s1[i_mem]);
if (i > n)
return (NULL);
i_mem++;
}
return (NULL);
}

28
libft/ft_strrchr.c Normal file
View File

@ -0,0 +1,28 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strrchr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/27 10:05:56 by gbrochar #+# #+# */
/* Updated: 2015/11/27 10:24:37 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_strrchr(const char *s, int c)
{
int i;
i = ft_strlen(s);
if (c)
{
while (i--)
if (s[i] == (char)c)
return ((char *)&s[i]);
return (NULL);
}
return ((char *)&s[i]);
}

87
libft/ft_strsplit.c Normal file
View File

@ -0,0 +1,87 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strsplit.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/29 09:55:10 by gbrochar #+# #+# */
/* Updated: 2015/12/07 11:00:21 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
static int ft_wordcount(char const *s, char c)
{
int word_count;
int i;
i = 0;
word_count = 0;
while (s[i] != '\0')
{
while (s[i] == c)
i++;
if (s[i] != '\0')
word_count++;
while (s[i] != c && s[i] != '\0')
i++;
}
return (word_count);
}
static void *ft_taballoc(char const *s, char **str_tab, char c)
{
int i;
int i2;
int wl;
i = 0;
i2 = 0;
while (s[i2])
{
wl = 0;
while (s[i2] == c && s[i2] != '\0')
i2++;
while (s[i2] != c && s[i2] != '\0')
{
wl++;
i2++;
}
if (wl != 0)
*str_tab++ = (char *)malloc((wl + 1) * sizeof(char));
if (!(str_tab - 1))
return (NULL);
}
return (*str_tab);
}
char **ft_strsplit(char const *s, char c)
{
char **str_tab;
int i;
int i2;
int i3;
int wc;
i = 0;
i3 = 0;
wc = ft_wordcount(s, c);
str_tab = (char **)malloc((wc + 1) * sizeof(char *));
if (!str_tab)
return (NULL);
ft_taballoc(s, str_tab, c);
while (i != wc)
{
i2 = 0;
while (s[i3] == c && s[i3] != '\0')
i3++;
while (s[i3] != c && s[i3] != '\0')
str_tab[i][i2++] = s[i3++];
str_tab[i][i2] = '\0';
i++;
}
str_tab[i] = NULL;
return (str_tab);
}

38
libft/ft_strstr.c Normal file
View File

@ -0,0 +1,38 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strstr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/27 10:24:53 by gbrochar #+# #+# */
/* Updated: 2015/11/28 16:38:40 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_strstr(const char *s1, char *s2)
{
int i;
int i_mem;
int i_tofind;
i_mem = 0;
if (s2[0] == '\0')
return ((char *)s1);
while (s1[i_mem] != '\0')
{
i_tofind = 0;
while (s1[i_mem] != s2[i_tofind] && s1[i_mem] != '\0')
i_mem++;
if (s1[i_mem] == '\0')
return (NULL);
i = i_mem;
while (s1[i++] == s2[i_tofind] || s2[i_tofind] == '\0')
if (s2[i_tofind++] == '\0')
return ((char *)&s1[i_mem]);
i_mem++;
}
return (NULL);
}

28
libft/ft_strsub.c Normal file
View File

@ -0,0 +1,28 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strsub.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/29 09:14:36 by gbrochar #+# #+# */
/* Updated: 2015/12/08 15:34:26 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_strsub(char const *s, unsigned int start, size_t len)
{
char *str;
size_t i;
i = 0;
str = (char *)malloc((len + 1) * sizeof(char));
if (!str)
return (NULL);
while (i < len)
str[i++] = s[start++];
str[i] = '\0';
return (str);
}

33
libft/ft_strtab_isdigit.c Normal file
View File

@ -0,0 +1,33 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strtab_isdigit.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/05/31 08:48:47 by gbrochar #+# #+# */
/* Updated: 2016/05/31 08:50:05 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_strtab_isdigit(char **strtab)
{
int i;
int j;
i = 0;
while (strtab[i])
{
j = 0;
while (strtab[i][j])
{
if (strtab[i][j] != ' ' && ft_isdigit(strtab[i][j] == 0))
return (0);
j++;
}
i++;
}
return (1);
}

40
libft/ft_strtrim.c Normal file
View File

@ -0,0 +1,40 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strtrim.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/29 09:54:12 by gbrochar #+# #+# */
/* Updated: 2015/12/07 11:00:33 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_strtrim(char const *s)
{
char *str;
size_t i;
size_t i2;
size_t ws;
i = ft_strlen(s) - 1;
i2 = 0;
ws = 0;
while ((s[i] == ' ' || s[i] == '\n' || s[i] == '\t') && i--)
ws++;
i = 0;
while ((s[i] == ' ' || s[i] == '\n' || s[i] == '\t') && ws < ft_strlen(s))
{
i++;
ws++;
}
str = (char *)malloc((ft_strlen(s) + 1 - ws) * sizeof(char));
if (!str)
return (NULL);
while (i2 < (ft_strlen(s) - ws))
str[i2++] = s[i++];
str[i2] = '\0';
return (str);
}

22
libft/ft_swap.c Normal file
View File

@ -0,0 +1,22 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_swap.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/12/07 09:44:07 by gbrochar #+# #+# */
/* Updated: 2015/12/07 11:01:13 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_swap(int *a, int *b)
{
int c;
c = *a;
*a = *b;
*b = c;
}

20
libft/ft_tolower.c Normal file
View File

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_tolower.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/27 18:39:55 by gbrochar #+# #+# */
/* Updated: 2015/11/29 08:40:07 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_tolower(int c)
{
if ((int)c >= 'A' && (int)c <= 'Z')
c += 32;
return (c);
}

20
libft/ft_toupper.c Normal file
View File

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_toupper.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/27 18:43:24 by gbrochar #+# #+# */
/* Updated: 2015/11/28 16:01:01 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_toupper(int c)
{
if ((int)c >= 'a' && (int)c <= 'z')
c -= 32;
return (c);
}

93
libft/get_next_line.c Normal file
View File

@ -0,0 +1,93 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* get_next_line.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/03/22 00:00:51 by gbrochar #+# #+# */
/* Updated: 2019/02/22 10:11:53 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "get_next_line.h"
char *ft_strjoin2(char *str, char *str2)
{
char *tmp;
tmp = ft_strjoin(str, str2);
free(str);
return (tmp);
}
int gnl_manage_return(char **line, char **stock)
{
char *tmp;
char *tmp2;
if ((tmp = ft_strchr(*stock, '\n')))
{
*tmp = '\0';
tmp2 = ft_strdup(tmp + 1);
*line = ft_strdup(*stock);
ft_memdel((void **)stock);
*stock = ft_strdup(tmp2);
free(tmp2);
tmp2 = NULL;
tmp = NULL;
return (1);
}
if (ft_strlen(*stock) == 0)
{
ft_memdel((void **)stock);
return (0);
}
*line = ft_strdup(*stock);
ft_memdel((void **)stock);
return (1);
}
int gnl_manage_read(char **line, char **stock)
{
char *tmp;
char *tmp2;
if ((tmp = ft_strchr(*stock, '\n')))
{
*tmp = '\0';
tmp2 = ft_strdup(tmp + 1);
*line = ft_strdup(*stock);
ft_memdel((void **)stock);
*stock = ft_strdup(tmp2);
free(tmp2);
tmp2 = NULL;
tmp = NULL;
return (1);
}
return (0);
}
int get_next_line(int fd, char **line, int error)
{
static char *stock = NULL;
char buffer[BUFF_SIZE + 1];
int ret;
if (stock && error)
ft_memdel((void **)&stock);
if (error)
return (-1);
buffer[0] = '\0';
if (stock)
if (gnl_manage_read(line, &stock))
return (1);
while ((ret = read(fd, buffer, BUFF_SIZE)) > 0)
{
buffer[ret] = '\0';
stock = ft_strjoin2(stock, buffer);
if (gnl_manage_read(line, &stock))
return (1);
}
return (ret < 0 ? ret : gnl_manage_return(line, &stock));
}

22
libft/get_next_line.h Normal file
View File

@ -0,0 +1,22 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* get_next_line.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/02/28 22:19:58 by gbrochar #+# #+# */
/* Updated: 2019/02/22 10:03:10 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef GET_NEXT_LINE_H
# define GET_NEXT_LINE_H
# include "libft.h"
# define BUFF_SIZE 512
int get_next_line(int const fd, char **line, int error);
#endif

103
libft/libft.h Normal file
View File

@ -0,0 +1,103 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* libft.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/11/24 12:52:28 by gbrochar #+# #+# */
/* Updated: 2019/02/22 14:24:19 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef LIBFT_H
# define LIBFT_H
# include <string.h>
# include <unistd.h>
# include <stdlib.h>
# include <fcntl.h>
# include "get_next_line.h"
# include <math.h>
typedef struct s_list
{
void *content;
size_t content_size;
struct s_list *next;
} t_list;
t_list *ft_get_last_node(t_list **alst);
void ft_lstadd(t_list **alst, t_list *new);
void ft_lstadd_preview(t_list **alst, t_list *new);
void ft_lstdel(t_list **alst, void (*del)(void *, size_t));
void ft_lstdelone(t_list **alst, void (*del)(void *, size_t));
t_list *ft_lstnew(void const *content, size_t content_size);
void ft_lstiter(t_list *lst, void (*f)(t_list *elem));
t_list *ft_lstmap(t_list *lst, t_list *(*f)(t_list *elem));
int ft_atoi(const char *str);
double ft_atof(const char *str);
int ft_atoi_color(char *hexa_color);
int ft_atoi_len(char *str, int *len);
int *ft_atoi_split(char *str, char c, int *tab_len);
void ft_bzero(void *s, size_t n);
int ft_isalnum(int c);
int ft_isalpha(int c);
int ft_isascii(int c);
int ft_isdigit(int c);
int ft_strtab_isdigit(char **strtab);
int ft_isprint(int c);
int ft_isspace(int c);
char *ft_itoa(int n);
void *ft_memalloc(size_t size);
void *ft_memccpy(void *dst, const void *src, int c, size_t n);
void *ft_memchr(const void *s, int c, size_t n);
int ft_memcmp(const void *s1, const void *s2, size_t n);
void *ft_memcpy(void *dst, const void *src, size_t n);
void ft_memdel(void **ap);
void *ft_memmove(void *dst, const void *src, size_t len);
void *ft_memset(void *b, int c, size_t len);
int ft_power(int nb, int pow);
void ft_putchar(char c);
void ft_putchar_fd(char c, int fd);
void ft_putendl(char const *s);
void ft_putendl_fd(char const *s, int fd);
void ft_putnbr(int n);
void ft_putnbr_fd(int n, int fd);
void ft_putstr(char const *s);
void ft_putstr_fd(char const *s, int fd);
void ft_sort_int(int *tab, int size);
long ft_sqrt(long n);
char *ft_strcat(char *s1, const char *s2);
char *ft_strchr(const char *s, int c);
void ft_strclr(char *s);
int ft_strcmp(const char *s1, const char *s2);
char *ft_strcpy(char *dst, const char *src);
void ft_strdel(char **as);
char *ft_strdup(const char *s1);
int ft_strequ(char const *s1, char const *s2);
void ft_striter(char *s, void (*f)(char *));
void ft_striteri(char *s, void (*f)(unsigned int, char *s));
char *ft_strjoin(char const *s1, char const *s2);
size_t ft_strlcat(char *dst, const char *src, size_t size);
size_t ft_strlen(const char *s);
char *ft_strmap(char const *s, char (*f)(char));
char *ft_strmapi(char const *s, char (*f)(unsigned int, char));
char *ft_strncat(char *s1, const char *s2, size_t n);
int ft_strncmp(const char *s1, const char *s2, size_t n);
char *ft_strncpy(char *dst, const char *src, size_t n);
int ft_strnequ(char const *s1, char const *s2, size_t n);
char *ft_strnew(size_t size);
char *ft_strnstr(const char *s1, char *s2, size_t n);
char *ft_strrchr(const char *s, int c);
char **ft_strsplit(char const *s, char c);
char *ft_strstr(const char *s1, char *s2);
char *ft_strsub(char const *s, unsigned int start, size_t len);
char *ft_strtrim(char const *s);
void ft_swap(int *a, int *b);
int ft_tolower(int c);
int ft_toupper(int c);
int ft_ishexdigit(int c);
void ft_error(char *str);
#endif

7
scenes/cone.scene Normal file
View File

@ -0,0 +1,7 @@
CAMERA -5 0 -10 0 0 0
SPOT -5 5 0 15
SPOT 5 7 0 15
CONE -3 0 0 0.2 0.5 0.3 0.15 192 255 80
CONE 2 1 0 0.2 -0.5 0.3 0.5 80 255 80
CONE 5 -2 -4 -0.2 0.5 0.3 0.1 255 255 80
CONE -1 -5 4 0.2 0.5 -0.3 0.1 192 80 80

8
scenes/new.scene Normal file
View File

@ -0,0 +1,8 @@
CAMERA 0 5 -10 0 0 0
AMBIENT 0
SPECULAR 1 1.3
PLANE 0 -1 0 0 1 0 64 64 64
PLANE 0 0 1 0 0 -1 64 64 255
SPHERE 0 0 0 1.5 255 0 0
CYLIGROSSEPUTENDER -2 -1 0 1 1 0.2 1 64 220 64
CONE 2 0 0 -1 1 -0.2 0.3 255 255 80

4
scenes/plane.scene Normal file
View File

@ -0,0 +1,4 @@
CAMERA 0 3 -10 0 0 0
SPECULAR 0.1 0
SPOT 0 5 5 6
PLANE 0 0 0 0 1 0 255 255 255

10
scenes/rtv125.scene Normal file
View File

@ -0,0 +1,10 @@
CAMERA 3 5 0 0 0 0
AMBIENT 0
SPECULAR 3 0.5
LIGHT 3 4 -5 20
LIGHT 0 10 0 20
PLANE 0 -1 0 0 1 0 64 64 64
PLANE 0 0 1 0 0 -1 64 64 255
SPHERE 0 0 0 1.5 255 0 0
CYLINDER -2 -1 0 1 1 0.2 1 64 220 64
CONE 2 0 0 -1 1 -0.2 0.3 255 255 80

4
scenes/sphere.scene Normal file
View File

@ -0,0 +1,4 @@
CAMERA 10 10 10 0 0 0
SPECULAR 3 0.2
LIGHT 5 5 5 15
SPHERE 0 0 0 3 64 192 92

4
scenes/sphereup.scene Normal file
View File

@ -0,0 +1,4 @@
CAMERA 0 0 0 0 10 0
SPHERE 0 10 0 1 130 58 255
SPECULAR 1.5 1
SPOT 0 5 1 5

23
scenes/temple.scene Normal file
View File

@ -0,0 +1,23 @@
CAMERA 0 4 -23 0 3 0
SPHERE 0 0 -10 0.8 255 0 0
//
SPECULAR 0.7 1
SPOT -14 5 -18 150
SPOT 14 5 -18 150
//
PLANE 0 -2 0 0 1 0 128 128 128
PLANE 0 8 0 0 -1 0 64 64 64
PLANE 0 0 8 0 0 -1 80 80 255
//
SPHERE -6 8 -10 1.7 192 192 192
SPHERE -6 -2 -10 1.7 192 192 192
CYLINDER -6 0 -10 0 1 0 1 192 192 192
SPHERE 6 8 -10 1.7 192 192 192
SPHERE 6 -2 -10 1.7 192 192 192
CYLINDER 6 0 -10 0 1 0 1 192 192 192
SPHERE -6 8 2 1.7 192 192 192
SPHERE -6 -2 2 1.7 192 192 192
CYLINDER -6 0 2 0 1 0 1 192 192 192
SPHERE 6 8 2 1.7 192 192 192
SPHERE 6 -2 2 1.7 192 192 192
CYLINDER 6 0 2 0 1 0 1 192 192 192

9
scenes/test.scene Normal file
View File

@ -0,0 +1,9 @@
CAMERA 0 5 -10 0 0 0
AMBIENT 0
SPECULAR 1 0.9
LIGHT 3 4 -5 30
PLANE 0 -1 0 0 1 0 64 64 64
PLANE 0 0 1 0 0 -1 64 64 255
SPHERE 0 0 0 1.5 255 0 0
CYLINDER -2 -1 0 1 1 0.2 1 64 220 64
CONE 2 0 0 -1 1 -0.2 0.3 255 255 80

8
scenes/test2.scene Normal file
View File

@ -0,0 +1,8 @@
CAMERA 3 5 -5 0 0 0
SPECULAR 0.5 0.2
SPOT 3 5 -5 30
PLANE 0 -1 0 0 1 0 64 64 64
PLANE 0 0 1 0 0 -1 64 64 255
SPHERE 0 0 0 1.5 255 0 0
CYLINDER -2 -1 0 1 1 0.2 1 64 220 64
CONE 2 0 0 -1 1 -0.2 0.3 255 255 80

50
src/add_cone.c Normal file
View File

@ -0,0 +1,50 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* add_cone.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/02/07 21:42:11 by gbrochar #+# #+# */
/* Updated: 2019/02/21 17:11:56 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "rtv1.h"
void init_cone(t_cone *cone, t_color *c)
{
cone->o = vec(0, 0, 0);
cone->d = vec(0, 1, 0);
cone->k = 0.15;
*c = color(255, 255, 255);
}
int add_cone(char **data, t_env *e)
{
int i;
t_cone *cone;
t_color c;
i = 0;
ft_putendl("Adding cone");
if (!(cone = (t_cone *)ft_memalloc(sizeof(t_cone))))
return (FAILURE);
init_cone(cone, &c);
while (data[i] && i < 11)
i++;
if (i > 3)
cone->o = vec(ft_atof(data[1]), ft_atof(data[2]), ft_atof(data[3]));
if (i > 6)
{
cone->d = vec(ft_atof(data[4]), ft_atof(data[5]), ft_atof(data[6]));
if (FAILURE == check_direction(cone->d))
return (FAILURE);
normalize(&cone->d);
}
if (i > 7)
cone->k = ft_atof(data[7]);
if (i > 10)
c = color(ft_atoi(data[8]), ft_atoi(data[9]), ft_atoi(data[10]));
return (add_obj_node(e, (void *)cone, CONE, c));
}

50
src/add_cylinder.c Normal file
View File

@ -0,0 +1,50 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* add_cylinder.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/02/07 19:58:08 by gbrochar #+# #+# */
/* Updated: 2019/02/22 10:08:54 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "rtv1.h"
void init_cylinder(t_cylinder *cylinder, t_color *c)
{
cylinder->o = vec(0, 0, 0);
cylinder->d = vec(0, 1, 0);
cylinder->r = 1;
*c = color(255, 255, 255);
}
int add_cylinder(char **data, t_env *e)
{
int i;
t_cylinder *cylinder;
t_color c;
i = 0;
ft_putendl("Adding cylinder");
if (!(cylinder = (t_cylinder *)ft_memalloc(sizeof(t_cylinder))))
return (FAILURE);
init_cylinder(cylinder, &c);
while (data[i] && i < 11)
++i;
if (i > 3)
cylinder->o = vec(ft_atof(data[1]), ft_atof(data[2]), ft_atof(data[3]));
if (i > 6)
{
cylinder->d = vec(ft_atof(data[4]), ft_atof(data[5]), ft_atof(data[6]));
if (FAILURE == check_direction(cylinder->d))
return (FAILURE);
normalize(&cylinder->d);
}
if (i > 7)
cylinder->r = ft_atof(data[7]);
if (i > 10)
c = color(ft_atoi(data[8]), ft_atoi(data[9]), ft_atoi(data[10]));
return (add_obj_node(e, (void *)cylinder, CYLINDER, c));
}

47
src/add_plane.c Normal file
View File

@ -0,0 +1,47 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* add_plane.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/02/07 21:42:30 by gbrochar #+# #+# */
/* Updated: 2019/02/21 17:11:26 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "rtv1.h"
void init_plane(t_plane *plane, t_color *c)
{
plane->o = vec(0, 0, 0);
plane->d = vec(0, 1, 0);
*c = color(255, 255, 255);
}
int add_plane(char **data, t_env *e)
{
int i;
t_plane *plane;
t_color c;
i = 0;
ft_putendl("Adding plane");
if (!(plane = (t_plane *)ft_memalloc(sizeof(t_plane))))
return (FAILURE);
init_plane(plane, &c);
while (data[i] && i < 10)
++i;
if (i > 3)
plane->o = vec(ft_atof(data[1]), ft_atof(data[2]), ft_atof(data[3]));
if (i > 6)
{
plane->d = vec(ft_atof(data[4]), ft_atof(data[5]), ft_atof(data[6]));
if (FAILURE == check_direction(plane->d))
return (FAILURE);
normalize(&plane->d);
}
if (i > 9)
c = color(ft_atoi(data[7]), ft_atoi(data[8]), ft_atoi(data[9]));
return (add_obj_node(e, (void *)plane, PLANE, c));
}

42
src/add_sphere.c Normal file
View File

@ -0,0 +1,42 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* add_sphere.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/02/07 21:41:54 by gbrochar #+# #+# */
/* Updated: 2019/02/11 11:44:40 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "rtv1.h"
void init_sphere(t_sphere *sphere, t_color *c)
{
sphere->o = vec(0, 0, 0);
sphere->r = 1;
*c = color(255, 255, 255);
}
int add_sphere(char **data, t_env *e)
{
int i;
t_sphere *sphere;
t_color c;
i = 0;
ft_putendl("Adding sphere");
if (!(sphere = (t_sphere *)ft_memalloc(sizeof(t_sphere))))
return (FAILURE);
init_sphere(sphere, &c);
while (data[i] && i < 8)
++i;
if (i > 3)
sphere->o = vec(ft_atof(data[1]), ft_atof(data[2]), ft_atof(data[3]));
if (i > 4)
sphere->r = ft_atof(data[4]);
if (i > 7)
c = color(ft_atoi(data[5]), ft_atoi(data[6]), ft_atoi(data[7]));
return (add_obj_node(e, (void *)sphere, SPHERE, c));
}

36
src/add_spot.c Normal file
View File

@ -0,0 +1,36 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* add_spot.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/02/06 18:10:46 by gbrochar #+# #+# */
/* Updated: 2019/02/13 19:02:05 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "rtv1.h"
void init_spot(t_spot *spot)
{
spot->o = vec(0, 0, 0);
spot->i = 1;
}
int add_spot(char **data, t_env *e)
{
int i;
t_spot spot;
i = 0;
ft_putendl("Adding spot");
init_spot(&spot);
while (data[i] && i < 5)
i++;
if (i > 3)
spot.o = vec(ft_atof(data[1]), ft_atof(data[2]), ft_atof(data[3]));
if (i > 4)
spot.i = ft_atof(data[4]);
return (add_spot_node(e, spot));
}

50
src/color.c Normal file
View File

@ -0,0 +1,50 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* color.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/02/06 16:38:04 by gbrochar #+# #+# */
/* Updated: 2019/02/08 20:47:12 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "rtv1.h"
t_color color(int r, int g, int b)
{
t_color color;
color.r = r;
color.g = g;
color.b = b;
return (color);
}
t_color color_add(t_color c1, t_color c2)
{
c1.r = c1.r + c2.r;
c1.g = c1.g + c2.g;
c1.b = c1.b + c2.b;
return (c1);
}
t_color color_mul(t_color c, double scalar)
{
c.r = (int)((double)c.r * scalar);
c.g = (int)((double)c.g * scalar);
c.b = (int)((double)c.b * scalar);
return (c);
}
t_color color_cap(t_color c)
{
c.r = (c.r > 255 ? 255 : c.r);
c.r = (c.r < 0 ? 0 : c.r);
c.g = (c.g > 255 ? 255 : c.g);
c.g = (c.g < 0 ? 0 : c.g);
c.b = (c.b > 255 ? 255 : c.b);
c.b = (c.b < 0 ? 0 : c.b);
return (c);
}

55
src/env_list.c Normal file
View File

@ -0,0 +1,55 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* env_list.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/02/06 17:08:36 by gbrochar #+# #+# */
/* Updated: 2019/02/11 11:39:52 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "rtv1.h"
int add_obj_node(t_env *e, void *obj, int type, t_color c)
{
t_obj_list *obj_node;
t_obj_list *list_browser;
if (!(obj_node = (t_obj_list *)ft_memalloc(sizeof(t_obj_list))))
return (FAILURE);
obj_node->obj = obj;
obj_node->type = type;
obj_node->c = c;
if (!e->objs)
e->objs = obj_node;
else
{
list_browser = e->objs;
while (list_browser->next)
list_browser = list_browser->next;
list_browser->next = obj_node;
}
return (SUCCESS);
}
int add_spot_node(t_env *e, t_spot spot)
{
t_spot_list *spot_node;
t_spot_list *list_browser;
if (!(spot_node = (t_spot_list *)ft_memalloc(sizeof(t_spot_list))))
return (FAILURE);
spot_node->spot = spot;
if (!e->spots)
e->spots = spot_node;
else
{
list_browser = e->spots;
while (list_browser->next)
list_browser = list_browser->next;
list_browser->next = spot_node;
}
return (SUCCESS);
}

49
src/main.c Normal file
View File

@ -0,0 +1,49 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* main.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/02/06 10:11:19 by gbrochar #+# #+# */
/* Updated: 2019/02/22 08:38:14 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "rtv1.h"
void init_env(t_env *e)
{
e->func.intersect_obj[PLANE] = &intersect_plane;
e->func.intersect_obj[SPHERE] = &intersect_sphere;
e->func.intersect_obj[CYLINDER] = &intersect_cylinder;
e->func.intersect_obj[CONE] = &intersect_cone;
e->func.normal_obj[PLANE] = &normal_plane;
e->func.normal_obj[SPHERE] = &normal_sphere;
e->func.normal_obj[CYLINDER] = &normal_cylinder;
e->func.normal_obj[CONE] = &normal_cone;
}
int main(int ac, char *av[])
{
t_env e;
if (ac == 2)
if (SUCCESS == parse(av[1], &e))
if (SUCCESS == init_mlx(&e))
{
init_env(&e);
raytrace(&e);
mlx_loop(e.mlx.ptr);
}
else
free_parsing(&e);
else
{
free_parsing(&e);
ft_putendl("file is not valid");
}
else
ft_putendl("usage: ./rtv1 scene_file");
return (0);
}

27
src/maths.c Normal file
View File

@ -0,0 +1,27 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* maths.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/02/08 14:46:56 by gbrochar #+# #+# */
/* Updated: 2019/02/08 20:18:48 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "rtv1.h"
int solve_quadratic(double params[3], double roots[2])
{
double delta;
delta = params[1] * params[1] - (double)4 * params[0] * params[2];
if (delta + E > 0)
{
roots[0] = (-params[1] - sqrt(delta)) / ((double)2 * params[0]);
roots[1] = (-params[1] + sqrt(delta)) / ((double)2 * params[0]);
return (SUCCESS);
}
return (FAILURE);
}

55
src/maths_cone.c Normal file
View File

@ -0,0 +1,55 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* maths_cone.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/02/08 20:02:35 by gbrochar #+# #+# */
/* Updated: 2019/02/22 17:26:00 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "rtv1.h"
double intersect_cone(void *obj, t_ray r)
{
t_cone *co;
t_vec sub_ori;
double params[3];
double roots[2];
co = (t_cone *)obj;
sub_ori = vec_sub(r.o, co->o);
params[0] = dot_product(r.d, r.d) - (pow(co->k, 2) + (double)1)
* pow(dot_product(r.d, co->d), 2);
params[1] = (double)2 * (dot_product(r.d, sub_ori)
- (pow(co->k, 2) + (double)1) * dot_product(r.d, co->d)
* dot_product(sub_ori, co->d));
params[2] = dot_product(sub_ori, sub_ori) - (pow(co->k, 2) + (double)1)
* pow(dot_product(sub_ori, co->d), 2);
if (SUCCESS == solve_quadratic(params, roots))
{
if (roots[0] > 0)
return (roots[0] - E);
else if (roots[1] > 0)
return (roots[1] - E);
}
return (FAILURE);
}
t_vec normal_cone(void *obj, t_ray r, double t)
{
t_cone *co;
t_vec p;
double m;
co = (t_cone *)obj;
p = vec_add(r.o, vec_mul(r.d, t));
m = dot_product(r.d, co->d) * t
+ dot_product(vec_sub(r.o, co->o), co->d);
p = vec_sub(vec_sub(vec_sub(p, co->o), vec_mul(co->d, m)),
vec_mul(co->d, m * pow(co->k, 2)));
normalize(&p);
return (p);
}

52
src/maths_cylinder.c Normal file
View File

@ -0,0 +1,52 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* maths_cylinder.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/02/08 18:31:29 by gbrochar #+# #+# */
/* Updated: 2019/02/22 17:26:27 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "rtv1.h"
double intersect_cylinder(void *obj, t_ray r)
{
t_cylinder *cy;
t_vec sub_ori;
double roots[2];
double params[3];
cy = (t_cylinder *)obj;
sub_ori = vec_sub(r.o, cy->o);
params[0] = dot_product(r.d, r.d) - pow(dot_product(r.d, cy->d), 2);
params[1] = (double)2 * (dot_product(r.d, sub_ori)
- (dot_product(r.d, cy->d) * dot_product(sub_ori, cy->d)));
params[2] = dot_product(sub_ori, sub_ori)
- pow(dot_product(sub_ori, cy->d), 2) - pow(cy->r, 2);
if (SUCCESS == solve_quadratic(params, roots))
{
if (roots[0] > 0)
return (roots[0] - E);
else if (roots[1] > 0)
return (roots[1] - E);
}
return (FAILURE);
}
t_vec normal_cylinder(void *obj, t_ray r, double t)
{
t_cylinder *cy;
t_vec p;
double m;
cy = (t_cylinder *)obj;
p = vec_add(r.o, vec_mul(r.d, t));
m = dot_product(r.d, cy->d) * t
+ dot_product(vec_sub(r.o, cy->o), cy->d);
p = vec_sub(vec_sub(p, cy->o), vec_mul(cy->d, m));
normalize(&p);
return (p);
}

36
src/maths_plane.c Normal file
View File

@ -0,0 +1,36 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* maths_plane.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gbrochar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/02/08 19:57:48 by gbrochar #+# #+# */
/* Updated: 2019/02/08 20:47:52 by gbrochar ### ########.fr */
/* */
/* ************************************************************************** */
#include "rtv1.h"
double intersect_plane(void *obj, t_ray r)
{
t_plane *p;
p = (t_plane *)obj;
if (dot_product(r.d, p->d) != 0)
{
return (-dot_product(vec_sub(r.o, p->o), p->d)
/ dot_product(r.d, p->d) - E);
}
return (FAILURE);
}
t_vec normal_plane(void *obj, t_ray r, double t)
{
t_plane *p;
(void)r;
(void)t;
p = (t_plane *)obj;
return (p->d);
}

Some files were not shown because too many files have changed in this diff Show More