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

@ -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

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)"

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

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

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

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

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

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

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

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

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