fotonmoton/fractol
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

new files ported from dev branch

Browse source
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
Show stats Download patch file Download diff file Expand all files Collapse all files

22
CMakeLists.txt
View file

@ -8,18 +8,22 @@ link_directories(libft minilibx) # libraries
set(SOURCE_FILES
src/main.c
src/help_func.c
src/color.c
src/help_func.c
src/color.c
src/fractol_init.c
src/hooks.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
target_link_libraries(fractol
-lft
-lmlx
"-framework OpenGL"
"-framework AppKit"
-lpthread) # linkage
target_link_libraries(fractol -lft -lmlx "-framework OpenGL" "-framework AppKit") # linkage

4
Makefile
View file

@ -6,7 +6,7 @@
# By: gtertysh <marvin@42.fr> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ #
# 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)
@echo "$(CYAN)Compiling object files: $(BLUE)$@$(NORMAL)"
@$(CC) $(CC_FLAGS) $(INC) -c $< -o $@
@$(CC) $(CC_FLAGS) $(OPT) $(INC) -c $< -o $@
$(LIBFT_DIR)$(LIBFT):
@echo "$(CYAN)Compiling libft library...$(NORMAL)"

149
inc/fractol.h
View file

@ -6,7 +6,7 @@
/* By: gtertysh <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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 */
/* */
/* ************************************************************************** */
@ -17,19 +17,13 @@
# include "mlx.h"
# include <math.h>
# include <fcntl.h>
#include <pthread.h>
#include <stdio.h>
# include <pthread.h>
# include <time.h>
# include <unistd.h>
# include <stdio.h>
# define HEIGHT 1200
# define WIDTH 1200
# 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 HEIGHT 700
# define WIDTH 1300
# define RED 16711680
# define ORANGE 16744448
@ -39,92 +33,121 @@
# define INDIGO 4915330
# define VIOLET 8323327
# 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
{
double rl;
double im;
long double rl;
long double im;
} t_complex;
typedef struct s_color
{
int red;
int green;
int blue;
} t_color;
typedef struct s_mw
{
void *mlx;
void *win;
} t_mw;
typedef struct s_move
{
int x;
int y;
double z;
long double x;
long double y;
long double z;
} t_move;
typedef struct s_pixel
typedef struct s_color
{
int x;
int y;
} t_pixel;
int red;
int grn;
int blu;
} t_color;
typedef struct s_julia
typedef struct s_gradient
{
t_complex jul_const;
t_color color;
t_color grd[NUM_COLORS];
} t_gradient;
typedef struct s_frac_data
{
t_complex com_const;
t_gradient grd;
t_move mov;
int x;
int y;
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;
} t_fractals;
void *ptr;
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
{
t_mw *mw;
t_fractals *fractals;
void *mlx;
void *win;
t_frac_data *frac;
frac_func fr_funcs[3];
int w_height;
int w_width;
int bpp;
int line_size;
void *image;
char *image_data;
int endian;
t_image *img;
} t_fractol;
int tab_length(char **tab);
void free_tab(char **tab);
typedef struct s_thread_data
{
t_fractol fr;
int y_start;
int y_end;
frac_func fractal_func;
} t_thread_data;
void quit(t_fractol *fractol);
void print_help(void);
t_color color_init(int red, int green, int blue);
t_color color_lerp(t_color c1, t_color c2, double step);
int rainbow(int step, int max_step);
void parse_input(int ac, char **av);
t_color int_to_color(int c);
int color_to_int(t_color c);
t_fractol *fractol_init(void);
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);
t_fractol *fractol_init(void *mlx, int frac_type);
int key_hook(int keycode, void *m);
int mouse_move_hook( 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 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

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));
}

140
src/color.c
View file

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

48
src/fractol_init.c
View file

@ -12,41 +12,17 @@
#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))))
{
mw->mlx = mlx_init();
mw->win = mlx_new_window(mw->mlx, x, y, "FRCTL");
}
return (mw);
img = malloc(sizeof(t_image));
img->ptr = mlx_new_image(mlx, WIDTH, HEIGHT);
img->data = mlx_get_data_addr(img->ptr, &img->bpp, &img->l_size, &img->end);
return (img);
}
t_julia *jul_init(void)
{
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_init(void *mlx, int frac_type)
{
t_fractol *fractol;
@ -54,9 +30,13 @@ t_fractol *fractol_init(void)
{
fractol->w_height = HEIGHT;
fractol->w_width = WIDTH;
fractol->fractals = frac_init();
fractol->mw = mlx_and_win_ptr_init(WIDTH, HEIGHT);
fractol->image = NULL;
fractol->mlx = mlx;
fractol->win = mlx_new_window(fractol->mlx, WIDTH, HEIGHT, "FRCTL");
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);
}

38
src/help_func.c
View file

@ -12,17 +12,10 @@
#include "fractol.h"
void free_tab(char **tab)
{
while (*tab)
free(*tab++);
free(*tab);
}
void quit(t_fractol *fr)
{
if (fr && fr->mw->mlx && fr->mw->win)
mlx_destroy_window(fr->mw->mlx, fr->mw->win);
if (fr && fr->mlx && fr->win)
mlx_destroy_window(fr->mlx, fr->win);
exit(0);
}
@ -30,27 +23,8 @@ void print_help(void)
{
ft_putstr(
"Usage: "
"fdf [OPTIONS] MAP_PATH"
"fractol [FRACTALS..]"
"\n\n"
"Opitons:\n"
"--heatmap \"R,G,B - R,G,B\""
"\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);
}
"Fractals:\n"
"\033[32mjulia\033[0m \033[34mship \033[36mmandelbrot\033[0m\n");
}

77
src/hooks.c
View file

@ -6,7 +6,7 @@
/* By: gtertysh <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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);
if (keycode == 53)
quit(fr);
// if (keycode == 89)
// aclock_rot(fdf);
// if (keycode == 86)
// left_rot(fdf);
// if (keycode == 88)
// right_rot(fdf);
// if (keycode == 87)
// back_rot(fdf);
// if (keycode == 91)
// forw_rot(fdf);
// if (keycode == 92)
// clock_rot(fdf);
// if (keycode == 83)
// scale_up_z(fdf);
// if (keycode == 84)
// scale_down_z(fdf);
// if (keycode == 69)
// zoom_in(fdf);
// if (keycode == 78)
// zoom_out(fdf);
// if (keycode == 82)
// reset(fdf);
if (keycode == 49)
gradient_hook(fr);
if (keycode == 124)
move_left(fr);
if (keycode == 123)
move_right(fr);
if (keycode == 125)
move_up(fr);
if (keycode == 126)
move_down(fr);
if (keycode == 69)
change_limit_up(fr);
if (keycode == 78)
change_limit_down(fr);
return (0);
}
/*
* beware!! shitcode on lines 48-49.
*/
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);
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);
}
@ -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);
if (btn == 4)
{
((t_fractol *)fr)->fractals->jul->mov.z += 0.3;
draw_julia((t_fractol *)fr);
}
zoom_in(fr, x, y);
if (btn == 5)
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);
}

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);
}

22
src/image_routine.c
View file

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

63
src/julia.c
View file

@ -1,12 +1,12 @@
#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;
t_complex old;
i = 0;
while (i < JUL_MAX_ITER)
while (i < data->max_itr)
{
old = new;
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);
}
void *julia_computation(void *fr)
t_color julia(t_frac_data *ju, int x, int y)
{
t_complex new;
t_julia *ju;
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.im = (y - HEIGHT / 2) / (0.5 * ju->mov.z * HEIGHT) + ju->mov.y;
i = complex_parallel(new, ju->jul_const);
ju->color = int_to_color(rainbow(i, ju->max_itr));
put_pixel_to_image(x, y, &((t_fractol *)fr)->fractals->jul->color, fr);
return (0);
i = complex_jul(new, ju->com_const, ju);
return (gradient((float)i / ju->max_itr, ju->grd));
}
//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);
}

18
src/main.c
View file

@ -12,19 +12,9 @@
#include "fractol.h"
int main(void)
int main(int argc, char **argv)
{
t_fractol *fr;
fr = NULL;
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);
srand(time(NULL));
parse_input(argc, argv);
return (0);
}

71
src/mandelbrot.c
View file

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

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);
}