julia fractal and some hooks

This commit is contained in:
Gregory Tertyshny 2017-03-20 21:08:13 +02:00
parent 231e813653
commit 50b9a36fae
25 changed files with 248 additions and 1250 deletions

View file

@ -1,33 +1,24 @@
cmake_minimum_required(VERSION 3.6) cmake_minimum_required(VERSION 3.6)
project(fractol) project(fractol)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Werror -Wextra -O3") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Werror -Wextra")
include_directories(inc libft/includes minilibx) # headers include_directories(inc libft/includes minilibx) # headers
link_directories(libft minilibx) # libraries link_directories(libft minilibx) # libraries
set(SOURCE_FILES set(SOURCE_FILES
src/main.c src/main.c
src/line.c src/help_func.c
src/map_init.c src/color.c
src/pnt_init.c
src/help_func.c
src/render.c
src/mat4.c
src/color.c
src/fractol_init.c src/fractol_init.c
src/hooks.c src/hooks.c
src/image_routine.c src/image_routine.c
src/map_routine.c src/complex.c src/julia.c src/mandelbrot.c) # sources
src/mat4_init_funcs.c
src/mat4_operations.c
src/matrix_routine.c
src/map_movement.c
src/parse_input.c
src/map_check.c
src/map_movement_1.c
src/map_movement_2.c) # sources
add_executable(fractol ${SOURCE_FILES}) # compilation add_executable(fractol ${SOURCE_FILES}) # compilation
target_link_libraries(fractol -lft -lmlx -lXext -lX11 m) # linkage target_link_libraries(fractol
-lft
-lmlx
"-framework OpenGL"
"-framework AppKit") # linkage

View file

@ -17,6 +17,7 @@
# include "mlx.h" # include "mlx.h"
# include <math.h> # include <math.h>
# include <fcntl.h> # include <fcntl.h>
#include <stdio.h>
# define HEIGHT 1200 # define HEIGHT 1200
# define WIDTH 2500 # define WIDTH 2500
@ -29,12 +30,22 @@
# define INIT_Y_SCALE 0.9 # define INIT_Y_SCALE 0.9
# define INIT_Z_SCALE 0.1 # define INIT_Z_SCALE 0.1
typedef struct s_swap # define RED 16711680
# define ORANGE 16744448
# define YELLOW 16776960
# define GREEN 65280
# define BLUE 255
# define INDIGO 4915330
# define VIOLET 8323327
# define BLACK 0
# define JUL_MAX_ITER 100
typedef struct s_complex
{ {
int swap_x; double rl;
int swap_z; double im;
int swap_coord; } t_complex;
} t_swap;
typedef struct s_color typedef struct s_color
{ {
@ -43,71 +54,36 @@ typedef struct s_color
int blue; int blue;
} t_color; } t_color;
typedef struct s_vec
{
float x;
float y;
float z;
} t_vec;
typedef struct s_pnt
{
int x;
int y;
float z;
t_color color;
} t_pnt;
typedef struct s_line
{
t_pnt p1;
t_pnt p2;
} t_line;
typedef struct s_mw typedef struct s_mw
{ {
void *mlx; void *mlx;
void *win; void *win;
} t_mw; } t_mw;
typedef struct s_mat4 typedef struct s_move
{ {
double mx[4][4]; int x;
} t_mat4; int y;
double z;
} t_move;
typedef struct s_trnsf typedef struct s_julia
{ {
t_mat4 *tr; t_complex jul_const;
t_mat4 *sc; t_color color;
t_mat4 *vp; int max_iterations;
t_mat4 *pr; t_move mov;
t_mat4 *xr; } t_julia;
t_mat4 *yr;
t_mat4 *zr;
t_mat4 *vp_pr_tr;
t_mat4 *fin;
} t_trnsf;
typedef struct s_map typedef struct s_fractals
{ {
t_trnsf *trnsf; t_julia *jul;
t_vec **arr_vec; } t_fractals;
t_pnt **arr_pnt;
t_color *low;
t_color *high;
int x_max;
int y_max;
int z_max;
int z_min;
int z_rot;
int x_rot;
int y_rot;
float scale[3];
} t_map;
typedef struct s_fractol typedef struct s_fractol
{ {
t_mw *mw; t_mw *mw;
t_fractals *fractals;
int w_height; int w_height;
int w_width; int w_width;
int bpp; int bpp;
@ -117,68 +93,28 @@ typedef struct s_fractol
int endian; int endian;
} t_fractol; } t_fractol;
void parse_input(int ac, char **av, t_fractol **fractol);
int wrong_symbols(char **line);
void wrong_map(void);
t_map *map_init(char *path);
void pnt_init(t_map *map);
t_mat4 *mat4_init(void);
t_trnsf *trnsf_mat_init();
t_mat4 *viewport_mat_init(int x, int y);
t_mat4 *orth_mat_init(float r, float t, float f);
void initial_trnsf_mats(t_fractol *fractol);
void mat4_mult_chain(t_trnsf *tf);
void mat4_translate(t_mat4 *m, double x, double y, double z);
void mat4_scale(t_mat4 *m, double x, double y, double z);
void mat4_z_rot(t_mat4 *m, double angle);
void mat4_x_rot(t_mat4 *m, double angle);
void mat4_y_rot(t_mat4 *m, double angle);
void vec_mat_mult(t_mat4 *m, t_vec *v, t_pnt *result);
t_mat4 *mat4_mult(t_mat4 *m1, t_mat4 *m2);
void transform(t_mat4 *mat, t_map *map);
void recalculate_trnsf_matrs(t_map *map);
void center(t_map *map);
int tab_length(char **tab); int tab_length(char **tab);
void free_tab(char **tab); void free_tab(char **tab);
void quit(t_fractol *fractol); void quit(t_fractol *fractol);
void swap_init(t_swap *s);
void print_help(void); void print_help(void);
t_color color_init(int red, int green, int blue); t_color color_init(int red, int green, int blue);
t_color color_lerp(t_color c1, t_color c2, double step); 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 int_to_color(int c);
int color_to_int(t_color c); int color_to_int(t_color c);
t_color choose_color(t_line *line, t_swap *s);
void first_color(t_pnt *pnt, float z, t_map *map);
t_fractol *fractol_init(void); t_fractol *fractol_init(void);
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_button_hook(int btn, int x, int y, void *fr);
void line(t_pnt p1, t_pnt p2, t_fractol *fractol);
void render(t_fractol *fractol);
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 left_rot(t_fractol *fractol); void complex_equal(double real, double imag, t_complex *c);
void right_rot(t_fractol *fractol);
void forw_rot(t_fractol *fractol); void draw_julia(t_fractol *fr);
void back_rot(t_fractol *fractol);
void clock_rot(t_fractol *fractol);
void aclock_rot(t_fractol *fractol);
void scale_up_z(t_fractol *fractol);
void scale_down_z(t_fractol *fractol);
void zoom_in(t_fractol *fractol);
void zoom_out(t_fractol *fractol);
void reset(t_fractol *fractol);
void move(t_fractol *fractol);
#endif #endif

View file

@ -53,44 +53,48 @@ t_color int_to_color(int c)
return (new); return (new);
} }
t_color choose_color(t_line *line, t_swap *s) int rainbow(int step, int max_step)
{ {
t_color c; if (step >= 0 && step < max_step / 8)
float z1; return (RED);
float z2; if (step >= max_step / 8 && step <= max_step / 4)
return (ORANGE);
z1 = line->p1.z; if (step >= max_step / 4 && step <= max_step / 8 * 3)
z2 = line->p2.z; return (YELLOW);
if (s->swap_z) if (step >= max_step / 8 * 3 && step <= max_step / 2)
{ return (BLUE);
if (z2 == 0) if (step >= max_step / 2 && step <= max_step / 8 * 5)
c = int_to_color(color_to_int(line->p2.color)); return (VIOLET);
else if (step >= max_step / 8 * 5 && step <= max_step / 8 * 6)
c = color_lerp(line->p2.color, line->p1.color, z1 / z2); return (BLACK);
} return (0);
else
{
if (z2 == 0)
c = int_to_color(color_to_int(line->p1.color));
else
c = color_lerp(line->p1.color, line->p2.color, z1 / z2);
}
return (c);
} }
void first_color(t_pnt *pnt, float z, t_map *map) //int rainbow(int step, int max_step)
{ //{
int low_color; // if (step >= 0 && step < max_step / 8)
int high_color; // return (color_to_int(
// color_lerp(int_to_color(RED), int_to_color(ORANGE),
low_color = (map->low == NULL) ? COLOR1 : color_to_int(*map->low); // step / max_step / 8)));
high_color = (map->high == NULL) ? COLOR2 : color_to_int(*map->high); // if (step >= max_step / 8 && step <= max_step / 8 * 2)
if (z == 0) // return (color_to_int(
pnt->color = int_to_color(low_color); // color_lerp(int_to_color(ORANGE), int_to_color(YELLOW),
if (z == map->z_max - map->z_min) // step / max_step / 8 * 2)));
pnt->color = int_to_color(high_color); // if (step >= max_step / 8 * 2 && step <= max_step / 8 * 3)
else // return (color_to_int(
pnt->color = color_lerp( // color_lerp(int_to_color(YELLOW), int_to_color(GREEN),
int_to_color(low_color), // step / max_step / 8 * 3)));
int_to_color(high_color), fabs(z / (map->z_max - map->z_min))); // 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);
//}

7
src/complex.c Normal file
View file

@ -0,0 +1,7 @@
#include "fractol.h"
void complex_equal(double real, double imag, t_complex *c)
{
c->im = imag;
c->rl = real;
}

View file

@ -24,6 +24,28 @@ static t_mw *mlx_and_win_ptr_init(int x, int y)
return (mw); return (mw);
} }
t_julia *jul_init(void)
{
t_julia *j;
j = malloc(sizeof(t_julia));
complex_equal(-0.7, 0.27015, &j->jul_const);
j->max_iterations = 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)
{ {
t_fractol *fractol; t_fractol *fractol;
@ -32,13 +54,9 @@ 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->mw = mlx_and_win_ptr_init(WIDTH, HEIGHT); fractol->mw = mlx_and_win_ptr_init(WIDTH, HEIGHT);
fractol->image = mlx_new_image(fractol->mw->mlx, WIDTH, HEIGHT); fractol->image = NULL;
fractol->image_data = mlx_get_data_addr(
fractol->image,
&fractol->bpp,
&fractol->line_size,
&fractol->endian);
} }
return (fractol); return (fractol);
} }

View file

@ -26,13 +26,6 @@ void quit(t_fractol *fr)
exit(0); exit(0);
} }
void swap_init(t_swap *s)
{
s->swap_coord = 0;
s->swap_x = 1;
s->swap_z = 0;
}
void print_help(void) void print_help(void)
{ {
ft_putstr( ft_putstr(

View file

@ -12,11 +12,11 @@
#include "fractol.h" #include "fractol.h"
int key_hook(int keycode, void *fdf) int key_hook(int keycode, void *fr)
{ {
ft_putnbr(keycode); printf("%d\n", keycode);
if (keycode == 53) if (keycode == 53)
quit(fdf); quit(fr);
// if (keycode == 89) // if (keycode == 89)
// aclock_rot(fdf); // aclock_rot(fdf);
// if (keycode == 86) // if (keycode == 86)
@ -41,3 +41,21 @@ int key_hook(int keycode, void *fdf)
// reset(fdf); // reset(fdf);
return (0); return (0);
} }
int mouse_move_hook( int x, int y, void *fr)
{
fr = 0;
printf("x = %d, y = %d\n", x, y);
return (0);
}
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);
}
return (0);
}

View file

@ -12,6 +12,21 @@
#include "fractol.h" #include "fractol.h"
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);
}
}
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)

44
src/julia.c Normal file
View file

@ -0,0 +1,44 @@
#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;
new_and_clear_image(fr);
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);
}

View file

@ -1,103 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* line.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gtertysh <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/03/16 18:59:16 by gtertysh #+# #+# */
/* Updated: 2017/03/16 18:59:20 by gtertysh ### ########.fr */
/* */
/* ************************************************************************** */
#include "fractol.h"
static void swap_z(t_pnt *p1, t_pnt *p2)
{
float tmp;
t_color c;
tmp = p1->z;
p1->z = p2->z;
p2->z = tmp;
c = p1->color;
p1->color = p2->color;
p2->color = c;
}
static void swap_x_y(t_pnt *p1, t_pnt *p2)
{
int temp;
temp = p1->x;
p1->x = p1->y;
p1->y = temp;
temp = p2->x;
p2->x = p2->y;
p2->y = temp;
}
static void swap_points(t_pnt *p1, t_pnt *p2)
{
t_pnt temp;
temp = *p1;
*p1 = *p2;
*p2 = temp;
}
static void draw_line(t_line *line, t_swap *s, t_fractol *fr)
{
int dx;
int dy;
int derr;
double dz;
t_color col;
col = int_to_color(COLOR2);
dx = abs(line->p2.x - line->p1.x);
dy = abs(line->p2.y - line->p1.y);
dz = fabs(line->p2.z - line->p1.z);
derr = 2 * dy - dx;
while (line->p1.x < line->p2.x)
{
put_pixel_to_image(line->p1.x, line->p1.y, &col, fr);
if (derr > 0)
{
line->p1.y += s->swap_x;
derr -= dx;
}
(line->p1.x)++;
(line->p1.z) += dz / dx;
derr += dy;
}
}
void line(t_pnt p1, t_pnt p2, t_fractol *fdf)
{
int dx;
int dy;
t_swap swap;
t_line line;
dx = abs(p2.x - p1.x);
dy = abs(p2.y - p1.y);
swap_init(&swap);
if (dy > dx)
{
swap_x_y(&p1, &p2);
swap.swap_coord = 1;
}
if (p1.x > p2.x)
swap_points(&p1, &p2);
if (p1.y > p2.y)
swap.swap_x = -1;
if (p1.z > p2.z)
{
swap_z(&p1, &p2);
swap.swap_z = -1;
}
line.p1 = p1;
line.p2 = p2;
draw_line(&line, &swap, fdf);
}

View file

@ -13,98 +13,17 @@
#include "fractol.h" #include "fractol.h"
#include <time.h> #include <time.h>
void drawcircle(t_pnt pnt, float radius, t_fractol *fr) int main(void)
{
int x = (int)radius;
int y = 0;
int err = 0;
while (x >= y)
{
put_pixel_to_image(pnt.x + x, pnt.y + y, &pnt.color, fr);
put_pixel_to_image(pnt.x + y, pnt.y + x, &pnt.color, fr);
put_pixel_to_image(pnt.x - y, pnt.y + x, &pnt.color, fr);
put_pixel_to_image(pnt.x - x, pnt.y + y, &pnt.color, fr);
put_pixel_to_image(pnt.x - x, pnt.y - y, &pnt.color, fr);
put_pixel_to_image(pnt.x - y, pnt.y - x, &pnt.color, fr);
put_pixel_to_image(pnt.x + y, pnt.y - x, &pnt.color, fr);
put_pixel_to_image(pnt.x + x, pnt.y - y, &pnt.color, fr);
if (err <= 0)
{
y += 1;
err += 2*y + 1;
}
if (err > 0)
{
x -= 1;
err -= 2*x + 1;
}
}
}
void recursive_circles(t_pnt pnt, float radius, t_fractol *fr)
{
int tmp;
drawcircle(pnt, radius, fr);
pnt.color = color_lerp(pnt.color, color_lerp(pnt.color, color_init(0, 97, 255), 0.4), 0.3);
if (radius > 3)
{
tmp = pnt.x;
pnt.x = tmp + (int)radius / 2;
recursive_circles(pnt, radius / 2, fr);
pnt.x = tmp - (int)radius / 2;
recursive_circles(pnt, radius / 2, fr);
tmp = pnt.y;
pnt.y = tmp + (int)radius / 2;
recursive_circles(pnt, radius / 2, fr);
pnt.y = tmp - (int)radius / 2;
recursive_circles(pnt, radius / 2, fr);
}
}
int main(int argc, char **argv)
{ {
t_fractol *fr; t_fractol *fr;
t_pnt pnt;
// int i;
srand(time(NULL));
fr = NULL; fr = NULL;
argc = 0;
argv = 0;
fr = fractol_init(); fr = fractol_init();
// while (pnt.y < fr->w_height) draw_julia(fr);
// {
// pnt.x = 0;
// pnt.color = color_lerp(int_to_color(COLOR2), int_to_color(COLOR1), (float)pnt.y / (float)fr->w_height);
// while (pnt.x < fr->w_width)
// {
// drawcircle(pnt, 100, fr);
// pnt.x += 30;
// }
// pnt.y += 30;
// }
pnt.y = fr->w_height / 2;
pnt.x = fr->w_width / 2;
// i = 0;
pnt.color = color_init(255, 0, 0);
recursive_circles(pnt, 1000, fr);
// while (i < 10000)
// {
// usleep(150000);
// recursive_circles(pnt, i, fr);
// mlx_put_image_to_window(fr->mw->mlx, fr->mw->win, fr->image, 0, 0);
// 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);
// i +=10;
// }
mlx_put_image_to_window(fr->mw->mlx, fr->mw->win, fr->image, 0, 0);
mlx_hook(fr->mw->win, 2, 5, key_hook, 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); mlx_loop(fr->mw->mlx);
return (0); return (0);
} }

43
src/mandelbrot.c Normal file
View file

@ -0,0 +1,43 @@
#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);
//}

View file

@ -1,57 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* map_check.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gtertysh <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/03/16 18:59:27 by gtertysh #+# #+# */
/* Updated: 2017/03/16 18:59:29 by gtertysh ### ########.fr */
/* */
/* ************************************************************************** */
#include "fractol.h"
static int wrong_symbols_help(char *tmp)
{
if ((ft_strstr(tmp, ",0x") == tmp) && (tmp += 3))
{
if (!*tmp)
return (1);
while (ft_isdigit(*tmp) || (*tmp >= 'A' && *tmp <= 'F'))
tmp++;
}
if (*tmp)
return (1);
return (0);
}
int wrong_symbols(char **line)
{
char *tmp;
int num;
int neg;
num = 0;
neg = 0;
tmp = *line;
while ((*tmp == '-' || ft_isdigit(*tmp)) && *tmp)
{
if (*tmp == '-')
neg = 1;
else if (*tmp)
num++;
tmp++;
}
if (neg == 1 && num == 0)
return (1);
if (wrong_symbols_help(tmp))
return (1);
return (0);
}
void wrong_map(void)
{
ft_putstr("Wrong map!\n");
quit(0);
}

View file

@ -1,113 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* map_init.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gtertysh <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/03/16 18:59:36 by gtertysh #+# #+# */
/* Updated: 2017/03/16 18:59:38 by gtertysh ### ########.fr */
/* */
/* ************************************************************************** */
#include "fractol.h"
static char *to_str_map(char *path)
{
int fd;
fd = open(path, O_RDONLY);
if (fd != -1)
return (ft_read_file(fd));
return (0);
}
static int map_width(char **tab)
{
int width;
int width_tmp;
char **line_tab;
line_tab = ft_strsplit(*tab, ' ');
width = tab_length(line_tab);
free(line_tab);
width_tmp = width;
while (*tab)
{
if ((line_tab = ft_strsplit(*tab, ' ')))
{
if (wrong_symbols(line_tab))
wrong_map();
if ((width = tab_length(line_tab)) != width_tmp)
wrong_map();
}
free_tab(line_tab);
tab++;
}
return (width);
}
static void min_max_z(t_map *map, int i, int j)
{
if (map->arr_vec[i][j].z > map->z_max)
map->z_max = (int)map->arr_vec[i][j].z;
if (map->arr_vec[i][j].z < map->z_min)
map->z_min = (int)map->arr_vec[i][j].z;
}
static void to_vec_arr(char **tab, t_map *map)
{
char **line;
int i;
int j;
map->y_max = tab_length(tab);
map->x_max = map_width(tab);
map->arr_vec = malloc(sizeof(t_vec *) * (map->y_max));
i = 0;
while (i < map->y_max)
{
j = 0;
line = ft_strsplit(tab[i], ' ');
map->arr_vec[i] = malloc(sizeof(t_vec) * (map->x_max));
while (j < map->x_max)
{
map->arr_vec[i][j].z = ft_atoi(line[j]);
map->arr_vec[i][j].x = j;
map->arr_vec[i][j].y = i;
min_max_z(map, i, j);
j++;
}
free_tab(line);
i++;
}
}
t_map *map_init(char *path)
{
char *str_map;
char **tab_map;
t_map *map;
map = malloc(sizeof(t_map));
map->z_min = 0;
map->x_max = 0;
map->x_rot = 0;
map->y_rot = 0;
map->z_rot = 0;
map->scale[0] = 1;
map->scale[1] = 1;
map->scale[2] = 1;
map->low = NULL;
map->high = NULL;
if (!(str_map = to_str_map(path)))
{
ft_putstr("Wrong path to a map! For help help put \"fdf --help\"\n");
quit(0);
}
tab_map = ft_strsplit(str_map, '\n');
to_vec_arr(tab_map, map);
free(str_map);
free_tab(tab_map);
return (map);
}

View file

@ -1,52 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* map_movement.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gtertysh <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/03/16 18:58:08 by gtertysh #+# #+# */
/* Updated: 2017/03/16 18:58:14 by gtertysh ### ########.fr */
/* */
/* ************************************************************************** */
#include "fractol.h"
//
//void move(t_fdf *fdf)
//{
// recalculate_trnsf_matrs(fdf->map);
// mat4_mult_chain(fdf->map->trnsf);
// transform(fdf->map->trnsf->fin, fdf->map);
// mlx_destroy_image(fdf->mw->mlx, fdf->image);
// fdf->image = mlx_new_image(fdf->mw->mlx, WIDTH, HEIGHT);
// fdf->image_data = mlx_get_data_addr(
// fdf->image,
// &fdf->bpp,
// &fdf->line_size,
// &fdf->endian);
// render(fdf);
//}
//
//void left_rot(t_fdf *fdf)
//{
// fdf->map->y_rot -= 1;
// move(fdf);
//}
//
//void right_rot(t_fdf *fdf)
//{
// fdf->map->y_rot += 1;
// move(fdf);
//}
//
//void forw_rot(t_fdf *fdf)
//{
// fdf->map->x_rot += 1;
// move(fdf);
//}
//
//void back_rot(t_fdf *fdf)
//{
// fdf->map->x_rot -= 1;
// move(fdf);
//}

View file

@ -1,50 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* map_movement_1.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gtertysh <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/03/16 18:58:19 by gtertysh #+# #+# */
/* Updated: 2017/03/16 18:58:21 by gtertysh ### ########.fr */
/* */
/* ************************************************************************** */
#include "fractol.h"
//void scale_up_z(t_fdf *fdf)
//{
// fdf->map->scale[2] += 1.0f / 100 * 20;
// move(fdf);
//}
//
//void scale_down_z(t_fdf *fdf)
//{
// fdf->map->scale[2] -= 1.0f / 100 * 20;
// move(fdf);
//}
//
//void zoom_in(t_fdf *fdf)
//{
// fdf->map->scale[0] += 1.0f / 100 * 20;
// fdf->map->scale[1] += 1.0f / 100 * 20;
// move(fdf);
//}
//
//void zoom_out(t_fdf *fdf)
//{
// fdf->map->scale[0] -= 1.0f / 100 * 20;
// fdf->map->scale[1] -= 1.0f / 100 * 20;
// move(fdf);
//}
//
//void reset(t_fdf *fdf)
//{
// fdf->map->z_rot = 0;
// fdf->map->y_rot = 0;
// fdf->map->x_rot = 0;
// fdf->map->scale[0] = 1;
// fdf->map->scale[1] = 1;
// fdf->map->scale[2] = 1;
// move(fdf);
//}

View file

@ -1,25 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* map_movement_2.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gtertysh <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/03/16 18:58:24 by gtertysh #+# #+# */
/* Updated: 2017/03/16 18:58:26 by gtertysh ### ########.fr */
/* */
/* ************************************************************************** */
#include "fractol.h"
//
//void clock_rot(t_fdf *fdf)
//{
// fdf->map->z_rot -= 1;
// move(fdf);
//}
//
//void aclock_rot(t_fdf *fdf)
//{
// fdf->map->z_rot += 1;
// move(fdf);
//}

View file

@ -1,57 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* map_routine.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gtertysh <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/03/16 18:59:45 by gtertysh #+# #+# */
/* Updated: 2017/03/16 18:59:47 by gtertysh ### ########.fr */
/* */
/* ************************************************************************** */
#include "fractol.h"
void transform(t_mat4 *mat, t_map *map)
{
int i;
int j;
i = 0;
while (i < map->y_max)
{
j = 0;
while (j < map->x_max)
{
vec_mat_mult(mat, &map->arr_vec[i][j], &map->arr_pnt[i][j]);
j++;
}
i++;
}
}
void center(t_map *map)
{
double d_x;
double d_y;
double d_z;
int i;
int j;
d_x = map->x_max / 2.0f;
d_y = map->y_max / 2.0f;
d_z = map->z_max / 2.0f;
i = 0;
while (i < map->y_max)
{
j = 0;
while (j < map->x_max)
{
map->arr_vec[i][j].z -= d_z;
map->arr_vec[i][j].x -= d_x;
map->arr_vec[i][j].y -= d_y;
j++;
}
i++;
}
}

View file

@ -1,116 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* mat4.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gtertysh <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/03/16 18:59:57 by gtertysh #+# #+# */
/* Updated: 2017/03/16 18:59:59 by gtertysh ### ########.fr */
/* */
/* ************************************************************************** */
#include "fractol.h"
void mat4_translate(t_mat4 *m, double x, double y, double z)
{
m->mx[0][0] = 1;
m->mx[0][1] = 0;
m->mx[0][2] = 0;
m->mx[0][3] = 0;
m->mx[1][0] = 0;
m->mx[1][1] = 1;
m->mx[1][2] = 0;
m->mx[1][3] = 0;
m->mx[2][0] = 0;
m->mx[2][1] = 0;
m->mx[2][2] = 1;
m->mx[2][3] = 0;
m->mx[3][0] = x;
m->mx[3][1] = y;
m->mx[3][2] = z;
m->mx[3][3] = 1;
}
void mat4_scale(t_mat4 *m, double x, double y, double z)
{
m->mx[0][0] = x;
m->mx[0][1] = 0;
m->mx[0][2] = 0;
m->mx[0][3] = 0;
m->mx[1][0] = 0;
m->mx[1][1] = y;
m->mx[1][2] = 0;
m->mx[1][3] = 0;
m->mx[2][0] = 0;
m->mx[2][1] = 0;
m->mx[2][2] = z;
m->mx[2][3] = 0;
m->mx[3][0] = 0;
m->mx[3][1] = 0;
m->mx[3][2] = 0;
m->mx[3][3] = 1;
}
void mat4_z_rot(t_mat4 *m, double angle)
{
angle = angle * M_PI / 180;
m->mx[0][0] = cos(angle);
m->mx[0][1] = -(sin(angle));
m->mx[0][2] = 0;
m->mx[0][3] = 0;
m->mx[1][0] = sin(angle);
m->mx[1][1] = cos(angle);
m->mx[1][2] = 0;
m->mx[1][3] = 0;
m->mx[2][0] = 0;
m->mx[2][1] = 0;
m->mx[2][2] = 1;
m->mx[2][3] = 0;
m->mx[3][0] = 0;
m->mx[3][1] = 0;
m->mx[3][2] = 0;
m->mx[3][3] = 1;
}
void mat4_x_rot(t_mat4 *m, double angle)
{
angle = angle * M_PI / 180;
m->mx[0][0] = 1;
m->mx[0][1] = 0;
m->mx[0][2] = 0;
m->mx[0][3] = 0;
m->mx[1][0] = 0;
m->mx[1][1] = cos(angle);
m->mx[1][2] = (sin(angle));
m->mx[1][3] = 0;
m->mx[2][0] = 0;
m->mx[2][1] = -sin(angle);
m->mx[2][2] = cos(angle);
m->mx[2][3] = 0;
m->mx[3][0] = 0;
m->mx[3][1] = 0;
m->mx[3][2] = 0;
m->mx[3][3] = 1;
}
void mat4_y_rot(t_mat4 *m, double angle)
{
angle = angle * M_PI / 180;
m->mx[0][0] = cos(angle);
m->mx[0][1] = 0;
m->mx[0][2] = -(sin(angle));
m->mx[0][3] = 0;
m->mx[1][0] = 0;
m->mx[1][1] = 1;
m->mx[1][2] = 0;
m->mx[1][3] = 0;
m->mx[2][0] = sin(angle);
m->mx[2][1] = 0;
m->mx[2][2] = cos(angle);
m->mx[2][3] = 0;
m->mx[3][0] = 0;
m->mx[3][1] = 0;
m->mx[3][2] = 0;
m->mx[3][3] = 1;
}

View file

@ -1,110 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* mat4_init_funcs.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gtertysh <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/03/16 19:00:07 by gtertysh #+# #+# */
/* Updated: 2017/03/16 19:00:08 by gtertysh ### ########.fr */
/* */
/* ************************************************************************** */
#include "fractol.h"
t_mat4 *mat4_init(void)
{
t_mat4 *mat;
if ((mat = (t_mat4 *)malloc(sizeof(t_mat4))))
{
mat->mx[0][0] = 1;
mat->mx[0][1] = 0;
mat->mx[0][2] = 0;
mat->mx[0][3] = 0;
mat->mx[1][0] = 0;
mat->mx[1][1] = 1;
mat->mx[1][2] = 0;
mat->mx[1][3] = 0;
mat->mx[2][0] = 0;
mat->mx[2][1] = 0;
mat->mx[2][2] = 1;
mat->mx[2][3] = 0;
mat->mx[3][0] = 0;
mat->mx[3][1] = 0;
mat->mx[3][2] = 0;
mat->mx[3][3] = 1;
}
return (mat);
}
t_trnsf *trnsf_mat_init(void)
{
t_trnsf *trnsf;
if ((trnsf = malloc(sizeof(t_trnsf))))
{
trnsf->tr = mat4_init();
trnsf->sc = mat4_init();
trnsf->vp = mat4_init();
trnsf->pr = mat4_init();
trnsf->xr = mat4_init();
trnsf->yr = mat4_init();
trnsf->zr = mat4_init();
trnsf->vp_pr_tr = mat4_init();
trnsf->fin = mat4_init();
}
return (trnsf);
}
t_mat4 *viewport_mat_init(int x, int y)
{
t_mat4 *m;
if ((m = malloc(sizeof(t_mat4))))
{
m->mx[0][0] = (double)x / 2.0f;
m->mx[0][1] = 0;
m->mx[0][2] = 0;
m->mx[0][3] = 0;
m->mx[1][0] = 0;
m->mx[1][1] = (double)y / 2.0f;
m->mx[1][2] = 0;
m->mx[1][3] = 0;
m->mx[2][0] = 0;
m->mx[2][1] = 0;
m->mx[2][2] = 1;
m->mx[2][3] = 0;
m->mx[3][0] = ((double)x - 1) / 2.0f;
m->mx[3][1] = ((double)y - 1) / 2.0f;
m->mx[3][2] = 0;
m->mx[3][3] = 1;
}
return (m);
}
t_mat4 *orth_mat_init(float r, float t, float f)
{
t_mat4 *orth;
if ((orth = malloc(sizeof(t_mat4))))
{
orth->mx[0][0] = 2.0f / r;
orth->mx[0][1] = 0;
orth->mx[0][2] = 0;
orth->mx[0][3] = 0;
orth->mx[1][0] = 0;
orth->mx[1][1] = 2.0f / t;
orth->mx[1][2] = 0;
orth->mx[1][3] = 0;
orth->mx[2][0] = 0;
orth->mx[2][1] = 0;
orth->mx[2][2] = 2.0f / f;
orth->mx[2][3] = 0;
orth->mx[3][0] = -1;
orth->mx[3][1] = -1;
orth->mx[3][2] = 1;
orth->mx[3][3] = 1;
}
return (orth);
}

View file

@ -1,53 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* mat4_operations.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gtertysh <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/03/16 19:00:12 by gtertysh #+# #+# */
/* Updated: 2017/03/16 19:00:13 by gtertysh ### ########.fr */
/* */
/* ************************************************************************** */
#include "fractol.h"
void vec_mat_mult(t_mat4 *m, t_vec *v, t_pnt *result)
{
double x;
double y;
x = v->x * m->mx[0][0] + v->y * m->mx[1][0] + v->z * m->mx[2][0] +
m->mx[3][0];
y = v->x * m->mx[0][1] + v->y * m->mx[1][1] + v->z * m->mx[2][1] +
m->mx[3][1];
result->x = (int)x;
result->y = (int)y;
}
t_mat4 *mat4_mult(t_mat4 *m1, t_mat4 *m2)
{
t_mat4 *m3;
int i;
int j;
i = 0;
if ((m3 = (t_mat4 *)malloc(sizeof(t_mat4))))
{
while (i < 4)
{
j = 0;
while (j < 4)
{
m3->mx[i][j] =
m1->mx[i][0] * m2->mx[0][j] +
m1->mx[i][1] * m2->mx[1][j] +
m1->mx[i][2] * m2->mx[2][j] +
m1->mx[i][3] * m2->mx[3][j];
j++;
}
i++;
}
}
return (m3);
}

View file

@ -1,81 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* matrix_routine.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gtertysh <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/03/16 18:20:31 by gtertysh #+# #+# */
/* Updated: 2017/03/16 19:00:22 by gtertysh ### ########.fr */
/* */
/* ************************************************************************** */
#include "fractol.h"
void recalculate_trnsf_matrs(t_map *map)
{
mat4_x_rot(map->trnsf->xr, INIT_X + map->x_rot);
mat4_z_rot(map->trnsf->zr, INIT_Z + map->z_rot);
mat4_y_rot(map->trnsf->yr, INIT_Y + map->y_rot);
mat4_scale(map->trnsf->sc,
INIT_X_SCALE * map->scale[0],
INIT_Y_SCALE * map->scale[1],
INIT_Z_SCALE * map->scale[2]);
}
//
//static void viewport_projection_translate(t_trnsf *tf)
//{
// t_mat4 *tmp;
//
// tmp = tf->vp_pr_tr;
// tf->vp_pr_tr = mat4_mult(tf->vp, tf->pr);
// free(tmp);
// tmp = tf->vp_pr_tr;
// tf->vp_pr_tr = mat4_mult(tf->tr, tf->vp_pr_tr);
// free(tmp);
//}
//void initial_trnsf_mats(t_fdf *fdf)
//{
// t_trnsf *tf;
//
// tf = trnsf_mat_init();
// tf->vp = viewport_mat_init(fdf->w_width, fdf->w_height);
// tf->pr = orth_mat_init(
// (fdf->map->y_max > fdf->map->x_max) ? fdf->map->y_max :
// fdf->map->x_max + 2,
// (fdf->map->y_max > fdf->map->x_max) ? fdf->map->y_max :
// fdf->map->x_max + 2,
// fdf->map->z_max + 2);
// mat4_translate(
// tf->tr,
// (float)((fdf->map->y_max > fdf->map->x_max) ?
// fdf->map->y_max : fdf->map->x_max) / 2.0f,
// (float)((fdf->map->y_max > fdf->map->x_max) ?
// fdf->map->y_max : fdf->map->x_max) / 2.0f,
// (float)fdf->map->z_max / 2.0f);
// mat4_x_rot(tf->xr, INIT_X);
// mat4_z_rot(tf->zr, INIT_Z);
// mat4_y_rot(tf->yr, INIT_Y);
// mat4_scale(tf->sc, INIT_X_SCALE, INIT_Y_SCALE, INIT_Z_SCALE);
// viewport_projection_translate(tf);
// fdf->map->trnsf = tf;
//}
void mat4_mult_chain(t_trnsf *tf)
{
t_mat4 *tmp;
tmp = tf->fin;
tf->fin = mat4_mult(tf->zr, tf->vp_pr_tr);
free(tmp);
tmp = tf->fin;
tf->fin = mat4_mult(tf->xr, tf->fin);
free(tmp);
tmp = tf->fin;
tf->fin = mat4_mult(tf->yr, tf->fin);
free(tmp);
tmp = tf->fin;
tf->fin = mat4_mult(tf->sc, tf->fin);
free(tmp);
}

View file

@ -1,95 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* parse_input.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gtertysh <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/03/16 19:00:28 by gtertysh #+# #+# */
/* Updated: 2017/03/16 19:00:30 by gtertysh ### ########.fr */
/* */
/* ************************************************************************** */
#include "fractol.h"
//static int tab_to_color(t_color **color, char **tab)
//{
// int red;
// int green;
// int blue;
//
// red = ft_atoi(tab[0]);
// green = ft_atoi(tab[1]);
// blue = ft_atoi(tab[2]);
// if (red > 255 || red < 0 ||
// green > 255 || green < 0 ||
// blue > 255 || blue < 0)
// return (0);
// (*color)->red = red;
// (*color)->green = green;
// (*color)->blue = blue;
// return (1);
//}
//static void wrong_heatmap(t_color **low, t_color **high)
//{
// ft_putstr("wrong heatmap! Type \"fdf --help\" for heatmap example\n");
// free(*low);
// free(*high);
// *low = NULL;
// *high = NULL;
//}
//
//static void parse_heatmap(char *hm, t_color **low, t_color **high)
//{
// char **hm_tab;
// char **low_tab;
// char **high_tab;
//
// *low = malloc(sizeof(t_color));
// *high = malloc(sizeof(t_color));
// hm_tab = ft_strsplit(hm, '-');
// if ((tab_length(hm_tab) != 2))
// {
// wrong_heatmap(low, high);
// return ;
// }
// low_tab = ft_strsplit(hm_tab[0], ',');
// high_tab = ft_strsplit(hm_tab[1], ',');
// if (tab_length(low_tab) != 3 || tab_length(high_tab) != 3)
// {
// wrong_heatmap(low, high);
// return ;
// }
// if (!tab_to_color(low, low_tab) || !tab_to_color(high, high_tab))
// {
// wrong_heatmap(low, high);
// return ;
// }
//}
//
//void parse_input(int ac, char **av, t_fdf **fdf)
//{
// t_color *low;
// t_color *high;
//
// low = NULL;
// high = NULL;
// if ((ac < 2 || ac > 4) || (ac == 2 && ft_strstr(av[1], "--help")))
// {
// print_help();
// quit(*fdf);
// }
// else if (ac == 2)
// *fdf = fdf_init(av[1], low, high);
// else if (ac == 4 && ft_strstr(av[1], "--heatmap"))
// {
// parse_heatmap(av[2], &low, &high);
// *fdf = fdf_init(av[3], low, high);
// }
// else
// {
// print_help();
// quit(*fdf);
// }
//}

View file

@ -1,36 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* pnt_init.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gtertysh <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/03/16 19:00:44 by gtertysh #+# #+# */
/* Updated: 2017/03/16 19:00:45 by gtertysh ### ########.fr */
/* */
/* ************************************************************************** */
#include "fractol.h"
void pnt_init(t_map *map)
{
int i;
int j;
float z;
map->arr_pnt = malloc(sizeof(t_pnt *) * (map->y_max));
i = 0;
while (i < map->y_max)
{
map->arr_pnt[i] = malloc(sizeof(t_pnt) * (map->x_max));
j = 0;
while (j < map->x_max)
{
z = map->arr_vec[i][j].z - map->z_min;
map->arr_pnt[i][j].z = z;
first_color(&map->arr_pnt[i][j], z, map);
j++;
}
i++;
}
}

View file

@ -1,42 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* render.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gtertysh <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/03/16 19:00:37 by gtertysh #+# #+# */
/* Updated: 2017/03/16 19:01:12 by gtertysh ### ########.fr */
/* */
/* ************************************************************************** */
#include "fractol.h"
//void render(t_fractol *fr)
//{
// int i;
// int j;
// t_map *map;
//
// map = fr->map;
// i = 0;
// while (i < map->y_max)
// {
// j = 0;
// while (j < map->x_max)
// {
// if (i == map->y_max - 1 && j < map->x_max - 1)
// line(map->arr_pnt[i][j], map->arr_pnt[i][j + 1], fr);
// else if (i < map->y_max - 1 && j == map->x_max - 1)
// line(map->arr_pnt[i][j], map->arr_pnt[i + 1][j], fr);
// else if (i < map->y_max - 1 && j < map->x_max - 1)
// {
// line(map->arr_pnt[i][j], map->arr_pnt[i + 1][j], fr);
// line(map->arr_pnt[i][j], map->arr_pnt[i][j + 1], fr);
// }
// j++;
// }
// i++;
// }
// mlx_put_image_to_window(fr->mw->mlx, fr->mw->win, fr->image, 0, 0);
//}