new files ported from dev branch

This commit is contained in:
Gregory Tertyshny 2017-03-24 19:09:49 +02:00
parent 8e9693a2be
commit a4097c80f8
18 changed files with 610 additions and 369 deletions

View file

@ -13,13 +13,17 @@ set(SOURCE_FILES
src/fractol_init.c src/fractol_init.c
src/hooks.c src/hooks.c
src/image_routine.c src/image_routine.c
src/complex.c src/julia.c src/mandelbrot.c) # sources src/complex.c
src/julia.c
src/threads_routine.c
src/mandelbrot.c
src/burning_ship.c
src/fractal_routine.c
src/hooks_funcs.c
src/parse_input.c
src/hooks_funcs_1.c
src/hooks_funcs_2.c) # sources
add_executable(fractol ${SOURCE_FILES}) # compilation add_executable(fractol ${SOURCE_FILES}) # compilation
target_link_libraries(fractol target_link_libraries(fractol -lft -lmlx "-framework OpenGL" "-framework AppKit") # linkage
-lft
-lmlx
"-framework OpenGL"
"-framework AppKit"
-lpthread) # linkage

View file

@ -6,7 +6,7 @@
# By: gtertysh <marvin@42.fr> +#+ +:+ +#+ # # By: gtertysh <marvin@42.fr> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ # # +#+#+#+#+#+ +#+ #
# Created: 2016/12/14 16:54:48 by gtertysh #+# #+# # # Created: 2016/12/14 16:54:48 by gtertysh #+# #+# #
# Updated: 2017/03/20 15:31:33 by gtertysh ### ########.fr # # Updated: 2017/03/24 13:59:39 by gtertysh ### ########.fr #
# # # #
# **************************************************************************** # # **************************************************************************** #
@ -82,7 +82,7 @@ $(NAME): $(LIBFT_DIR)$(LIBFT) $(MLX_DIR)$(MLX) $(OBJ)
$(OBJ_DIR)%.o: $(SRC_DIR)%.c $(FRACTOL_INC)$(FRACTOL_HEADER) $(OBJ_DIR)%.o: $(SRC_DIR)%.c $(FRACTOL_INC)$(FRACTOL_HEADER)
@echo "$(CYAN)Compiling object files: $(BLUE)$@$(NORMAL)" @echo "$(CYAN)Compiling object files: $(BLUE)$@$(NORMAL)"
@$(CC) $(CC_FLAGS) $(INC) -c $< -o $@ @$(CC) $(CC_FLAGS) $(OPT) $(INC) -c $< -o $@
$(LIBFT_DIR)$(LIBFT): $(LIBFT_DIR)$(LIBFT):
@echo "$(CYAN)Compiling libft library...$(NORMAL)" @echo "$(CYAN)Compiling libft library...$(NORMAL)"

View file

@ -6,7 +6,7 @@
/* By: gtertysh <marvin@42.fr> +#+ +:+ +#+ */ /* By: gtertysh <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2017/03/16 20:59:04 by gtertysh #+# #+# */ /* Created: 2017/03/16 20:59:04 by gtertysh #+# #+# */
/* Updated: 2017/03/20 15:32:52 by gtertysh ### ########.fr */ /* Updated: 2017/03/24 14:00:01 by gtertysh ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -18,18 +18,12 @@
# include <math.h> # include <math.h>
# include <fcntl.h> # include <fcntl.h>
# include <pthread.h> # include <pthread.h>
# include <time.h>
# include <unistd.h>
# include <stdio.h> # include <stdio.h>
# define HEIGHT 1200 # define HEIGHT 700
# define WIDTH 1200 # define WIDTH 1300
# define COLOR1 0
# define COLOR2 16777215
# define INIT_X 30
# define INIT_Y -20
# define INIT_Z -45
# define INIT_X_SCALE 0.9
# define INIT_Y_SCALE 0.9
# define INIT_Z_SCALE 0.1
# define RED 16711680 # define RED 16711680
# define ORANGE 16744448 # define ORANGE 16744448
@ -39,92 +33,121 @@
# define INDIGO 4915330 # define INDIGO 4915330
# define VIOLET 8323327 # define VIOLET 8323327
# define BLACK 0 # define BLACK 0
# define WHITE 16777215
# define JUL_MAX_ITER 300 # define NUM_COLORS 8
# define FRAC_MAX_ITR 150
# define NUM_THREADS 24
# define NUM_THREADS 4
typedef struct s_complex typedef struct s_complex
{ {
double rl; long double rl;
double im; long double im;
} t_complex; } t_complex;
typedef struct s_move
{
long double x;
long double y;
long double z;
} t_move;
typedef struct s_color typedef struct s_color
{ {
int red; int red;
int green; int grn;
int blue; int blu;
} t_color; } t_color;
typedef struct s_mw typedef struct s_gradient
{ {
void *mlx; t_color grd[NUM_COLORS];
void *win; } t_gradient;
} t_mw;
typedef struct s_move typedef struct s_frac_data
{ {
int x; t_complex com_const;
int y; t_gradient grd;
double z;
} t_move;
typedef struct s_pixel
{
int x;
int y;
} t_pixel;
typedef struct s_julia
{
t_complex jul_const;
t_color color;
t_move mov; t_move mov;
int x;
int y;
int max_itr; int max_itr;
} t_julia; int com_rl_im_change;
int allow_mouse_change;
int frac_type;
} t_frac_data;
typedef struct s_fractals typedef struct s_image
{ {
t_julia *jul; void *ptr;
} t_fractals; char *data;
int l_size;
int end;
int bpp;
} t_image;
typedef t_color (*frac_func)(t_frac_data *data, int x, int y);
typedef struct s_fractol typedef struct s_fractol
{ {
t_mw *mw; void *mlx;
t_fractals *fractals; void *win;
t_frac_data *frac;
frac_func fr_funcs[3];
int w_height; int w_height;
int w_width; int w_width;
int bpp; t_image *img;
int line_size;
void *image;
char *image_data;
int endian;
} t_fractol; } t_fractol;
int tab_length(char **tab); typedef struct s_thread_data
void free_tab(char **tab); {
t_fractol fr;
int y_start;
int y_end;
frac_func fractal_func;
} t_thread_data;
void quit(t_fractol *fractol); void quit(t_fractol *fractol);
void print_help(void); void print_help(void);
t_color color_init(int red, int green, int blue); void parse_input(int ac, char **av);
t_color color_lerp(t_color c1, t_color c2, double step);
int rainbow(int step, int max_step);
t_color int_to_color(int c); t_color gradient(float value, t_gradient gradient);
t_gradient default_gradient(void);
t_gradient random_gradient(void);
int color_to_int(t_color c); int color_to_int(t_color c);
t_fractol *fractol_init(void);
t_fractol *fractol_init(void *mlx, int frac_type);
int key_hook(int keycode, void *m); int key_hook(int keycode, void *m);
int mouse_move_hook( int x, int y, void *fr); int mouse_move_hook( int x, int y, void *fr);
int mouse_button_hook(int btn, int x, int y, void *fr); int mouse_button_hook(int btn, int x, int y, void *fr);
void put_pixel_to_image(int x, int y, t_color *col, t_fractol *fr); void put_pixel_to_image(int x, int y, t_color col, t_fractol *fr);
void new_and_clear_image(t_fractol *fr); void new_and_clear_image(t_fractol *fr);
void complex_equal(double real, double imag, t_complex *c); void complex_equal(double real, double imag, t_complex *c);
void draw_julia(t_fractol *fr); t_frac_data *frac_init(int frac_type);
void *fractal_routine(void *th_data);
t_color julia(t_frac_data *ju, int x, int y);
t_color mandelbrot(t_frac_data *ma, int x, int y);
t_color ship(t_frac_data *sh, int x, int y);
void fractal_fork(int frac_type);
void parallel_fractal(t_fractol *fr);
void zoom_in(t_fractol *frm, int x, int y);
void zoom_out(t_fractol *fr);
void move_left(t_fractol *fr);
void move_right(t_fractol *fr);
void move_up(t_fractol *fr);
void move_down(t_fractol *fr);
void reset(t_fractol *fr);
void change_limit_down(t_fractol *fr);
void change_limit_up(t_fractol *fr);
int change_real(t_fractol *fr, int x, int *start_x);
int change_imagianry(t_fractol *fr, int x, int *start_x);
void gradient_hook(t_fractol *fr);
#endif #endif

32
src/burning_ship.c Normal file
View file

@ -0,0 +1,32 @@
#include "fractol.h"
int complex_ship(t_complex new, t_complex com_const, t_frac_data *data)
{
int i;
t_complex old;
i = 0;
while (i < data->max_itr)
{
old = new;
new.rl = fabsl(old.rl * old.rl - old.im * old.im + com_const.rl);
new.im = fabsl(2 * old.rl * old.im + com_const.im);
if((new.rl * new.rl + new.im * new.im) > 4)
break ;
i++;
}
return (i);
}
t_color ship(t_frac_data *sh, int x, int y)
{
t_complex new;
int i;
new.rl = 1.5 * (x - WIDTH / 2) / (0.5 * sh->mov.z * WIDTH) +
sh->mov.x - 0.5;
new.im = (y - HEIGHT / 2) / (0.5 * sh->mov.z * HEIGHT) +
sh->mov.y - 0.5;
i = complex_ship(sh->com_const, new, sh);
return (gradient((float)i / sh->max_itr, sh->grd));
}

View file

@ -12,89 +12,75 @@
#include "fractol.h" #include "fractol.h"
t_color color_init(int red, int green, int blue) t_color int_to_color(int c)
{
t_color c;
c.red = red;
c.green = green;
c.blue = blue;
return (c);
}
t_color color_lerp(t_color c1, t_color c2, double step)
{ {
t_color new; t_color new;
double red;
double green;
double blue;
red = (double)(c2.red - c1.red) * step + c1.red; new.blu = c & 0x0000FF;
green = (double)(c2.green - c1.green) * step + c1.green; new.grn = (c >> 8) & 0x0000FF;
blue = (double)(c2.blue - c1.blue) * step + c1.blue; new.red = (c >> 16) & 0x0000FF;
new.red = (int)red;
new.green = (int)green;
new.blue = (int)blue;
return (new); return (new);
} }
int color_to_int(t_color c) int color_to_int(t_color c)
{ {
return ((c.red << 16) | (c.green << 8) | c.blue); return ((c.red << 16) | (c.grn << 8) | c.blu);
} }
t_color int_to_color(int c) t_gradient default_gradient(void)
{ {
t_color new; t_gradient grad;
new.blue = c & 0x0000FF; grad.grd[0] = int_to_color(BLACK);
new.green = (c >> 8) & 0x0000FF; grad.grd[1] = int_to_color(BLUE);
new.red = (c >> 16) & 0x0000FF; grad.grd[2] = int_to_color(VIOLET);
return (new); grad.grd[3] = int_to_color(INDIGO);
grad.grd[4] = int_to_color(RED);
grad.grd[5] = int_to_color(ORANGE);
grad.grd[6] = int_to_color(YELLOW);
grad.grd[7] = int_to_color(WHITE);
return (grad);
} }
//
//int rainbow(int step, int max_step)
//{
// if (step >= 0 && step < max_step / 8)
// return (RED);
// if (step >= max_step / 8 && step <= max_step / 4)
// return (ORANGE);
// if (step >= max_step / 4 && step <= max_step / 8 * 3)
// return (YELLOW);
// if (step >= max_step / 8 * 3 && step <= max_step / 2)
// return (BLUE);
// if (step >= max_step / 2 && step <= max_step / 8 * 5)
// return (VIOLET);
// if (step >= max_step / 8 * 5 && step <= max_step / 8 * 6)
// return (BLACK);
// return (0);
//}
int rainbow(int step, int max_step) t_gradient random_gradient(void)
{ {
if (step >= 0 && step < max_step / 8) t_gradient grad;
return (color_to_int( int i;
color_lerp(int_to_color(RED), int_to_color(ORANGE), t_color c;
(float)step / (float)max_step)));
if (step >= max_step / 8 && step <= max_step / 8 * 2) i = 0;
return (color_to_int( while (i < NUM_COLORS)
color_lerp(int_to_color(ORANGE), int_to_color(YELLOW), {
step / max_step / 8 * 2))); c.red = rand() % 255;
if (step >= max_step / 8 * 2 && step <= max_step / 8 * 3) c.grn = rand() % 255;
return (color_to_int( c.blu = rand() % 255;
color_lerp(int_to_color(YELLOW), int_to_color(GREEN), grad.grd[i++] = c;
step / max_step / 8 * 3)));
if (step >= max_step / 8 * 3 && step <= max_step / 8 * 4)
return (color_to_int(
color_lerp(int_to_color(GREEN), int_to_color(BLUE),
step / max_step / 8 * 4)));
if (step >= max_step / 8 * 4 && step <= max_step / 8 * 5)
return (color_to_int(
color_lerp(int_to_color(BLUE), int_to_color(VIOLET),
step / max_step / 8 * 5)));
if (step >= max_step / 8 * 5 && step <= max_step / 8 * 6)
return (color_to_int(
color_lerp(int_to_color(VIOLET), int_to_color(BLACK),
step / max_step / 8 * 6)));
return (0);
} }
return (grad);
}
t_color gradient(float value, t_gradient grad)
{
int id1;
int id2;
float frac;
t_color c;
frac = 0;
if(value <= 0)
id1 = id2 = 0;
else if(value >= 1)
id1 = id2 = NUM_COLORS - 1;
else
{
value = value * (NUM_COLORS - 1);
id1 = (int)floor(value);
id2 = id1 + 1;
frac = value - (float)id1;
}
c.red = (grad.grd[id2].red - grad.grd[id1].red) * frac + grad.grd[id1].red;
c.blu = (grad.grd[id2].blu - grad.grd[id1].blu) * frac + grad.grd[id1].blu;
c.grn = (grad.grd[id2].grn - grad.grd[id1].grn) * frac + grad.grd[id1].grn;
return (c);
}

56
src/fractal_routine.c Normal file
View file

@ -0,0 +1,56 @@
#include "fractol.h"
void *fractal_routine(void *th_data)
{
int x;
t_color col;
t_thread_data *data;
data = (t_thread_data *)th_data;
while (data->y_start < HEIGHT && data->y_start < data->y_end)
{
x = 0;
while(x < data->fr.w_width)
{
col = data->fractal_func(data->fr.frac, x, data->y_start);
put_pixel_to_image(x, data->y_start, col, &data->fr);
x++;
}
data->y_start++;
}
free(data);
pthread_exit(NULL);
}
t_frac_data *frac_init(int frac_type)
{
t_frac_data *f;
f = malloc(sizeof(t_frac_data));
f->max_itr = FRAC_MAX_ITR;
f->grd = default_gradient();
if (frac_type == 0)
complex_equal(-0.4, 0.6, &f->com_const);
else
complex_equal(0, 0, &f->com_const);
f->com_rl_im_change = 1;
f->allow_mouse_change = -1;
f->mov.x = 0;
f->mov.y = 0;
f->mov.z = 1;
f->frac_type = frac_type;
return (f);
}
void fractal_fork(int frac_type)
{
t_fractol *fr;
fr = fractol_init(mlx_init(), frac_type);
parallel_fractal(fr);
mlx_put_image_to_window(fr->mlx, fr->win, fr->img->ptr, 0, 0);
mlx_hook(fr->win, 2, 5, key_hook, fr);
mlx_hook(fr->win, 6, (1L<<6), mouse_move_hook, fr);
mlx_hook(fr->win, 4, (1L<<0), mouse_button_hook, fr);
mlx_loop(fr->mlx);
}

View file

@ -12,41 +12,17 @@
#include "fractol.h" #include "fractol.h"
static t_mw *mlx_and_win_ptr_init(int x, int y) t_image *img_init(void *mlx)
{ {
t_mw *mw; t_image *img;
if ((mw = malloc(sizeof(t_mw)))) img = malloc(sizeof(t_image));
{ img->ptr = mlx_new_image(mlx, WIDTH, HEIGHT);
mw->mlx = mlx_init(); img->data = mlx_get_data_addr(img->ptr, &img->bpp, &img->l_size, &img->end);
mw->win = mlx_new_window(mw->mlx, x, y, "FRCTL"); return (img);
}
return (mw);
} }
t_julia *jul_init(void) t_fractol *fractol_init(void *mlx, int frac_type)
{
t_julia *j;
j = malloc(sizeof(t_julia));
complex_equal(-0.7, 0.27015, &j->jul_const);
j->max_itr = JUL_MAX_ITER;
j->mov.x = 0;
j->mov.y = 0;
j->mov.z = 1;
return (j);
}
t_fractals *frac_init(void)
{
t_fractals *f;
f = malloc(sizeof(t_fractals));
f->jul = jul_init();
return (f);
}
t_fractol *fractol_init(void)
{ {
t_fractol *fractol; t_fractol *fractol;
@ -54,9 +30,13 @@ t_fractol *fractol_init(void)
{ {
fractol->w_height = HEIGHT; fractol->w_height = HEIGHT;
fractol->w_width = WIDTH; fractol->w_width = WIDTH;
fractol->fractals = frac_init(); fractol->mlx = mlx;
fractol->mw = mlx_and_win_ptr_init(WIDTH, HEIGHT); fractol->win = mlx_new_window(fractol->mlx, WIDTH, HEIGHT, "FRCTL");
fractol->image = NULL; fractol->img = img_init(fractol->mlx);
fractol->frac = frac_init(frac_type);
fractol->fr_funcs[0] = julia;
fractol->fr_funcs[1] = mandelbrot;
fractol->fr_funcs[2] = ship;
} }
return (fractol); return (fractol);
} }

View file

@ -12,17 +12,10 @@
#include "fractol.h" #include "fractol.h"
void free_tab(char **tab)
{
while (*tab)
free(*tab++);
free(*tab);
}
void quit(t_fractol *fr) void quit(t_fractol *fr)
{ {
if (fr && fr->mw->mlx && fr->mw->win) if (fr && fr->mlx && fr->win)
mlx_destroy_window(fr->mw->mlx, fr->mw->win); mlx_destroy_window(fr->mlx, fr->win);
exit(0); exit(0);
} }
@ -30,27 +23,8 @@ void print_help(void)
{ {
ft_putstr( ft_putstr(
"Usage: " "Usage: "
"fdf [OPTIONS] MAP_PATH" "fractol [FRACTALS..]"
"\n\n" "\n\n"
"Opitons:\n" "Fractals:\n"
"--heatmap \"R,G,B - R,G,B\"" "\033[32mjulia\033[0m \033[34mship \033[36mmandelbrot\033[0m\n");
"\toptional parameter for specifying color range of\n"
"\t\t\t\theatmap in RGB format. Each color component\n"
"\t\t\t\tshould be between 0 and 255.\n"
"\t\t\t\tPlease, put range in double quotes, for example:\n\n"
"\t\t\t\tfdf --heatmap \"125,255,6 - 250,41,1\" ~/maps/42.fdf\n\n");
}
int tab_length(char **tab)
{
int len;
len = 0;
if (tab)
while (*tab)
{
tab++;
len++;
}
return (len);
} }

View file

@ -6,7 +6,7 @@
/* By: gtertysh <marvin@42.fr> +#+ +:+ +#+ */ /* By: gtertysh <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2017/03/16 18:59:03 by gtertysh #+# #+# */ /* Created: 2017/03/16 18:59:03 by gtertysh #+# #+# */
/* Updated: 2017/03/20 15:29:10 by gtertysh ### ########.fr */ /* Updated: 2017/03/24 14:02:46 by gtertysh ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -17,35 +17,51 @@ int key_hook(int keycode, void *fr)
printf("%d\n", keycode); printf("%d\n", keycode);
if (keycode == 53) if (keycode == 53)
quit(fr); quit(fr);
// if (keycode == 89) if (keycode == 49)
// aclock_rot(fdf); gradient_hook(fr);
// if (keycode == 86) if (keycode == 124)
// left_rot(fdf); move_left(fr);
// if (keycode == 88) if (keycode == 123)
// right_rot(fdf); move_right(fr);
// if (keycode == 87) if (keycode == 125)
// back_rot(fdf); move_up(fr);
// if (keycode == 91) if (keycode == 126)
// forw_rot(fdf); move_down(fr);
// if (keycode == 92) if (keycode == 69)
// clock_rot(fdf); change_limit_up(fr);
// if (keycode == 83) if (keycode == 78)
// scale_up_z(fdf); change_limit_down(fr);
// if (keycode == 84)
// scale_down_z(fdf);
// if (keycode == 69)
// zoom_in(fdf);
// if (keycode == 78)
// zoom_out(fdf);
// if (keycode == 82)
// reset(fdf);
return (0); return (0);
} }
/*
* beware!! shitcode on lines 48-49.
*/
int mouse_move_hook( int x, int y, void *fr) int mouse_move_hook( int x, int y, void *fr)
{ {
fr = 0; static int start_x = WIDTH / 2;
int to_render;
t_fractol *fr_p;
to_render = 0;
y = to_render;
printf("x = %d, y = %d\n", x, y); printf("x = %d, y = %d\n", x, y);
to_render = y;
fr_p = (t_fractol *)fr;
if (fr_p->frac->com_rl_im_change == 1 &&
fr_p->frac->allow_mouse_change == 1)
to_render = change_real(fr_p, x, &start_x);
else if (fr_p->frac->com_rl_im_change == -1 &&
fr_p->frac->allow_mouse_change == 1)
to_render = change_imagianry(fr_p, x, &start_x);
if (to_render)
{
new_and_clear_image(fr_p);
parallel_fractal(fr_p);
mlx_put_image_to_window(fr_p->mlx, fr_p->win, fr_p->img->ptr, 0, 0);
}
return (0); return (0);
} }
@ -53,9 +69,14 @@ int mouse_button_hook(int btn, int x, int y, void *fr)
{ {
printf("x = %d, y = %d, btn = %d\n", x, y, btn); printf("x = %d, y = %d, btn = %d\n", x, y, btn);
if (btn == 4) if (btn == 4)
{ zoom_in(fr, x, y);
((t_fractol *)fr)->fractals->jul->mov.z += 0.3; if (btn == 5)
draw_julia((t_fractol *)fr); zoom_out(fr);
} if (btn == 3)
((t_fractol *)fr)->frac->com_rl_im_change *= -1;
if (btn == 2)
((t_fractol *)fr)->frac->allow_mouse_change *= -1;
if (btn == 1)
reset(fr);
return (0); return (0);
} }

61
src/hooks_funcs.c Normal file
View file

@ -0,0 +1,61 @@
#include "fractol.h"
void gradient_hook(t_fractol *fr)
{
fr->frac->grd = random_gradient();
new_and_clear_image(fr);
parallel_fractal(fr);
mlx_put_image_to_window(fr->mlx, fr->win, fr->img->ptr, 0, 0);
}
int change_imagianry(t_fractol *fr, int x, int *start_x)
{
int to_render;
to_render = 0;
if (x > *start_x)
{
if (fr->frac->com_const.im < 3)
{
fr->frac->com_const.im += 0.01;
to_render = 1;
}
*start_x = x;
}
else if (x < *start_x)
{
if (fr->frac->com_const.im > -4)
{
fr->frac->com_const.im -= 0.1;
to_render = 1;
}
*start_x = x;
}
return (to_render);
}
int change_real(t_fractol *fr, int x, int *start_x)
{
int to_render;
to_render = 0;
if (x > *start_x)
{
if (fr->frac->com_const.rl < 3)
{
fr->frac->com_const.rl += 0.1;
to_render = 1;
}
*start_x = x;
}
else if (x < *start_x)
{
if (fr->frac->com_const.rl > -4)
{
fr->frac->com_const.rl -= 0.1;
to_render = 1;
}
*start_x = x;
}
return (to_render);
}

54
src/hooks_funcs_1.c Normal file
View file

@ -0,0 +1,54 @@
#include "fractol.h"
void move_down(t_fractol *fr)
{
printf("z %Lf\n", fr->frac->mov.z);
fr->frac->mov.y += 1.f / fr->frac->mov.z * 0.2;
new_and_clear_image(fr);
parallel_fractal(fr);
mlx_put_image_to_window(fr->mlx, fr->win, fr->img->ptr, 0, 0);
}
void move_up(t_fractol *fr)
{
printf("z %Lf\n", fr->frac->mov.z);
fr->frac->mov.y -= 1.f / fr->frac->mov.z * 0.2;
new_and_clear_image(fr);
parallel_fractal(fr);
mlx_put_image_to_window(fr->mlx, fr->win, fr->img->ptr, 0, 0);
}
void reset(t_fractol *fr)
{
fr->frac->mov.x = 0;
fr->frac->mov.y = 0;
fr->frac->mov.z = 1;
fr->frac->max_itr = FRAC_MAX_ITR;
fr->frac->grd = default_gradient();
if (fr->frac->frac_type == 0)
complex_equal(-0.4, 0.6, &fr->frac->com_const);
else
complex_equal(0, 0, &fr->frac->com_const);
new_and_clear_image(fr);
parallel_fractal(fr);
mlx_put_image_to_window(fr->mlx, fr->win, fr->img->ptr, 0, 0);
}
void change_limit_up(t_fractol *fr)
{
fr->frac->max_itr +=50;
new_and_clear_image(fr);
parallel_fractal(fr);
mlx_put_image_to_window(fr->mlx, fr->win, fr->img->ptr, 0, 0);
}
void change_limit_down(t_fractol *fr)
{
if (fr->frac->max_itr >= 100)
{
fr->frac->max_itr -= 50;
new_and_clear_image(fr);
parallel_fractal(fr);
mlx_put_image_to_window(fr->mlx, fr->win, fr->img->ptr, 0, 0);
}
}

44
src/hooks_funcs_2.c Normal file
View file

@ -0,0 +1,44 @@
#include "fractol.h"
void zoom_in(t_fractol *fr, int x, int y)
{
int center_x;
int center_y;
center_x = WIDTH / 2;
center_y = HEIGHT / 2;
new_and_clear_image(fr);
fr->frac->mov.z *= 1.5;
fr->frac->mov.x += ((float)x - center_x) / (center_x * fr->frac->mov.z) * 0.8;
fr->frac->mov.y += ((float)y - center_y) / (center_y * fr->frac->mov.z) * 0.8;
parallel_fractal(fr);
mlx_put_image_to_window(fr->mlx, fr->win, fr->img->ptr, 0, 0);
}
void zoom_out(t_fractol *fr)
{
new_and_clear_image(fr);
fr->frac->mov.z /= 2;
parallel_fractal(fr);
mlx_put_image_to_window(fr->mlx, fr->win, fr->img->ptr, 0, 0);
}
void move_left(t_fractol *fr)
{
printf("z %Lf\n", fr->frac->mov.z);
fr->frac->mov.x -= 1.f / fr->frac->mov.z * 0.2;
new_and_clear_image(fr);
parallel_fractal(fr);
mlx_put_image_to_window(fr->mlx, fr->win, fr->img->ptr, 0, 0);
}
void move_right(t_fractol *fr)
{
printf("z %Lf\n", fr->frac->mov.z);
fr->frac->mov.x += 1.f / fr->frac->mov.z * 0.2;
new_and_clear_image(fr);
parallel_fractal(fr);
mlx_put_image_to_window(fr->mlx, fr->win, fr->img->ptr, 0, 0);
}

View file

@ -16,21 +16,21 @@ void new_and_clear_image(t_fractol *fr)
{ {
if (fr) if (fr)
{ {
if (fr->image) if (fr->img->ptr)
mlx_destroy_image(fr->mw->mlx, fr->image); mlx_destroy_image(fr->mlx, fr->img->ptr);
fr->image = mlx_new_image(fr->mw->mlx, WIDTH, HEIGHT); fr->img->ptr = mlx_new_image(fr->mlx, WIDTH, HEIGHT);
fr->image_data = mlx_get_data_addr( fr->img->data = mlx_get_data_addr(
fr->image, fr->img->ptr,
&fr->bpp, &fr->img->bpp,
&fr->line_size, &fr->img->l_size,
&fr->endian); &fr->img->end);
} }
} }
void put_pixel_to_image(int x, int y, t_color *col, t_fractol *fr) void put_pixel_to_image(int x, int y, t_color col, t_fractol *fr)
{ {
if (x < 0 || y < 0 || x >= fr->w_width || y >= fr->w_height) if (x < 0 || y < 0 || x >= fr->w_width || y >= fr->w_height)
return ; return ;
*(int *)((fr->image_data + x * fr->bpp / 8 + y * fr->line_size)) = *(int *)((fr->img->data + x * fr->img->bpp / 8 + y * fr->img->l_size)) =
color_to_int(*col); color_to_int(col);
} }

View file

@ -1,12 +1,12 @@
#include "fractol.h" #include "fractol.h"
int complex_parallel(t_complex new, t_complex com_const) int complex_jul(t_complex new, t_complex com_const, t_frac_data *data)
{ {
int i; int i;
t_complex old; t_complex old;
i = 0; i = 0;
while (i < JUL_MAX_ITER) while (i < data->max_itr)
{ {
old = new; old = new;
new.rl = old.rl * old.rl - old.im * old.im + com_const.rl; new.rl = old.rl * old.rl - old.im * old.im + com_const.rl;
@ -18,67 +18,14 @@ int complex_parallel(t_complex new, t_complex com_const)
return (i); return (i);
} }
void *julia_computation(void *fr) t_color julia(t_frac_data *ju, int x, int y)
{ {
t_complex new; t_complex new;
t_julia *ju;
int i; int i;
int x;
int y;
ju = ((t_fractol *)fr)->fractals->jul;
x = ju->x;
y = ju->y;
new.rl = 1.5 * (x - WIDTH / 2) / (0.5 * ju->mov.z * WIDTH) + ju->mov.x; new.rl = 1.5 * (x - WIDTH / 2) / (0.5 * ju->mov.z * WIDTH) + ju->mov.x;
new.im = (y - HEIGHT / 2) / (0.5 * ju->mov.z * HEIGHT) + ju->mov.y; new.im = (y - HEIGHT / 2) / (0.5 * ju->mov.z * HEIGHT) + ju->mov.y;
i = complex_parallel(new, ju->jul_const); i = complex_jul(new, ju->com_const, ju);
ju->color = int_to_color(rainbow(i, ju->max_itr)); return (gradient((float)i / ju->max_itr, ju->grd));
put_pixel_to_image(x, y, &((t_fractol *)fr)->fractals->jul->color, fr);
return (0);
} }
//void julia_parralel(t_fractol *fr)
//{
// pthread_t threads[NUM_THREADS];
// t_fractol *fr_tmp;
// int rc;
// int i;
//
// i = 0;
// while (i < NUM_THREADS && fr->fractals->jul->y < fr->w_width)
// {
// fr_tmp = malloc(sizeof(t_fractol));
// *fr_tmp = *fr;
//// printf("In main: creating thread %d\n", i);
// rc = pthread_create(&threads[i], NULL, julia_computation, (void *)fr_tmp);
// if (rc){
// printf("ERROR; return code from pthread_create() is %d\n", rc);
// exit(-1);
// }
// free(fr_tmp);
// fr->fractals->jul->y++;
// i++;
// }
//}
void draw_julia(t_fractol *fr)
{
int x;
int y;
new_and_clear_image(fr);
y = 0;
while (y < fr->w_height)
{
x = 0;
while(x < fr->w_width)
{
fr->fractals->jul->x = x;
fr->fractals->jul->y = y;
julia_computation(fr);
x++;
}
y++;
}
mlx_put_image_to_window(fr->mw->mlx, fr->mw->win, fr->image, 0, 0);
}

View file

@ -12,19 +12,9 @@
#include "fractol.h" #include "fractol.h"
int main(int argc, char **argv)
int main(void)
{ {
t_fractol *fr; srand(time(NULL));
parse_input(argc, argv);
fr = NULL; return (0);
fr = fractol_init();
draw_julia(fr);
mlx_hook(fr->mw->win, 2, 5, key_hook, fr);
mlx_hook(fr->mw->win, 4, 0, mouse_button_hook, fr);
mlx_hook(fr->mw->win, 6, 0, mouse_move_hook, fr);
mlx_loop(fr->mw->mlx);
pthread_exit(NULL);
} }

View file

@ -1,43 +1,32 @@
#include "fractol.h" #include "fractol.h"
//static void julia_computation(int x, int y, t_julia *ju) int complex_man(t_complex new, t_complex com_const, t_frac_data *data)
//{ {
// t_complex new; int i;
// t_complex old; t_complex old;
// int i;
// i = 0;
// new.rl = 1.5 * (x - WIDTH / 2) / (0.5 * ju->mov.z * WIDTH) + ju->mov.x; while (i < data->max_itr)
// new.im = (y - HEIGHT / 2) / (0.5 * ju->mov.z * HEIGHT) + ju->mov.y; {
// i = 0; old = new;
// while (i < ju->max_iterations) new.rl = old.rl * old.rl - old.im * old.im + com_const.rl;
// { new.im = 2 * old.rl * old.im + com_const.im;
// old = new; if((new.rl * new.rl + new.im * new.im) > 4)
// new.rl = old.rl * old.rl - old.im * old.im + ju->jul_const.rl; break ;
// new.im = 2 * old.rl * old.im + ju->jul_const.im; i++;
// if((new.rl * new.rl + new.im * new.im) > 4) }
// break ; return (i);
// i++; }
// }
// ju->color = int_to_color(rainbow(i, ju->max_iterations)); t_color mandelbrot(t_frac_data *ma, int x, int y)
//} {
// t_complex new;
// int i;
//void draw_julia(t_fractol *fr)
//{ new.rl = 1.5 * (x - WIDTH / 2) / (0.5 * ma->mov.z * WIDTH) +
// int x; ma->mov.x - 0.7;
// int y; new.im = (y - HEIGHT / 2) / (0.5 * ma->mov.z * HEIGHT) +
// ma->mov.y;
// x = 0; i = complex_man(ma->com_const, new, ma);
// while (x < fr->w_width) return (gradient((float)i / ma->max_itr, ma->grd));
// { }
// y = 0;
// while(y < fr->w_height)
// {
// julia_computation(x, y, fr->fractals->jul);
// put_pixel_to_image(x, y, &fr->fractals->jul->color, fr);
// y++;
// }
// x++;
// }
// mlx_put_image_to_window(fr->mw->mlx, fr->mw->win, fr->image, 0, 0);
//}

43
src/parse_input.c Normal file
View file

@ -0,0 +1,43 @@
#include <fractol.h>
int check_argument(char *arg)
{
if (!ft_strcmp(arg, "julia"))
return (0);
if (!ft_strcmp(arg, "mandelbrot"))
return (1);
if (!ft_strcmp(arg, "ship"))
return (2);
return (-1);
}
void error(void)
{
print_help();
quit(0);
}
void parse_input(int ac, char **av)
{
int i;
int frac_type;
int pid;
if (ac < 2)
error();
i = 0;
while (i < ac - 1)
if (((frac_type = check_argument(av[i + 1])) != -1))
{
pid = fork();
if (pid > 0)
{
fractal_fork(frac_type);
break ;
}
if (pid == 0)
i++;
}
else
error();
}

37
src/threads_routine.c Normal file
View file

@ -0,0 +1,37 @@
#include "fractol.h"
t_thread_data *thread_data_init(t_fractol *fr, int i)
{
t_thread_data *data;
int img_strip;
img_strip = (int)ceil(HEIGHT / NUM_THREADS) + 1;
data = malloc(sizeof(t_thread_data));
data->y_start = img_strip * i;
data->y_end = data->y_start + img_strip;
data->fr = *fr;
data->fractal_func = fr->fr_funcs[fr->frac->frac_type];
return (data);
}
void parallel_fractal(t_fractol *fr)
{
pthread_t threads[NUM_THREADS];
pthread_attr_t attr;
t_thread_data *data;
int i;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
i = 0;
while (i < NUM_THREADS)
{
data = thread_data_init(fr, i);
pthread_create(&threads[i], &attr, fractal_routine, (void *)data);
i++;
}
pthread_attr_destroy(&attr);
i = 0;
while (i < NUM_THREADS)
pthread_join(threads[i++], NULL);
}