int main(int ac, char **av)
{
int fd;
t_env *env;
if (ac != 2)
{
ft_putstr("Usage: ./fdf <filename>\n");
return (0);
}
if (!(ft_strstr(av[1], ".fdf")))
ft_error("\033[31;1mFile isn't a fdf map.\033[0m");
if ((fd = open(av[1], O_RDONLY)) < 0)
ft_error("\033[31;1mError when openning file.\033[0m");
env = init_env(fd);
close(fd);
fdf(env);
mlx_hook(env->win, 2, 3, key_funct, env);
mlx_hook(env->win, 17, 1l << 17, close_win, env);
mlx_mouse_hook(env->win, mouse_funct, env);
mlx_loop(env->mlx);
return (0);
}
int main(int argc, char **argv)
{
t_env e;
e.mlx = mlx_init();
if (e.mlx == NULL)
return (0);
e.win = mlx_new_window(e.mlx, 2400, 1300, "Fil de Fer");
if (e.win == NULL)
return (0);
e.im = mlx_new_image(e.mlx, 2400, 1300);
e.imb = mlx_new_image(e.mlx, 2400, 1300);
e.x = 0;
e.y = 0;
e.map = NULL;
ft_init_space(argc, argv, &e);
mlx_key_hook(e.win, key_hook, &e);
mlx_expose_hook(e.win, expose_hook, &e);
mlx_loop(e.mlx);
return (0);
}
int main(int ac, char **av)
{
t_env e;
init_env(&e);
parsing(&e, ac, av[1]);
init_eye(&e);
get_lightspot_number(&e);
init_viewpoint(&e);
e.v = 0;
e.v2 = 0;
e.nl = 1 / e.nl;
e.mlx = mlx_init();
e.win = mlx_new_window(e.mlx, e.width, e.height, e.name);
ray_tracer(&e);
mlx_expose_hook(e.win, expose_hook, &e);
mlx_key_hook(e.win, event_mlx, &e);
mlx_loop(e.mlx);
ft_free(&e);
return (0);
}
int main(int argc, char **argv)
{
t_mlx mx;
if (argc == 2)
{
mx.map = ft_read_file(argv[1]);
if (mx.map)
{
ft_init_mlx(&mx);
lx_hook(mx.win, 3, 3, key_hook, &mx);
mlx_expose_hook(mx.win, expose_hook, &mx);
mlx_loop(mx.mlx);
}
else
ft_error("Map Error.\n");
}
else
ft_error("Necessite un argument !\n");
return (0);
}
int main()
{
t_imgdata imgdata;
t_pov pov;
t_coordinate lightsource;
start_minilibx(&imgdata);
pov.x = -700;
pov.y = 0;
pov.z = 200;
pov.anglex = 0;
pov.angley = 0;
pov.anglez = 0;
lightsource.x = -500;
lightsource.y = 400;
lightsource.z = 600;
raytracer(&imgdata, &pov, objects, &lightsource);
mlx_expose_hook(imgdata.win_ptr, expose, &imgdata);
mlx_loop(imgdata.mlx_ptr);
return (0);
}
int main(void)
{
t_fract f;
t_nebula e;
ft_bzero(&f, sizeof(t_fract));
f.mlx = mlx_init();
f.win = mlx_new_window(f.mlx, BUDDHA_WIN_X, BUDDHA_WIN_Y, "buddhabrot");
e.color = &greyscale_color;
e.r = buddhabrot(1, 5000);
e.g = buddhabrot(500, 500);
e.b = buddhabrot(500, 50);
e.max_1 = get_max_color(e.r);
e.max_2 = get_max_color(e.g);
e.max_3 = get_max_color(e.b);
convert_int_to_img(&e, &f);
ft_fprintf(2, "Buddhabrot: rendering done\nPress [ESCAPE] to quit");
mlx_hook(f.win, KEY_PRESS, KEY_PRESS_MASK, key_hook, &f);
mlx_loop(f.mlx);
return (0);
}
int mlx_launch(t_env *env)
{
debug_stdout("INIT", FILE_LINE_FUN);
if (!(MLX = mlx_init()))
return (ft_error(env, __FUNCTION__, "mlx_init error"));
if (!(WIN = mlx_new_opengl_window(MLX, WDT, HGT, TITLE)))
return (ft_error(env, __FUNCTION__, "mlx_new_window error"));
mlx_opengl_window_set_context(WIN);
if (ogl_init(env) != EXIT_SUCCESS)
return (ft_error(env, __FUNCTION__, "ogl_init error"));
mlx_expose_hook(WIN, expose_hook, env);
mlx_key_hook(WIN, key_hook, env);
mlx_hook(WIN, KeyRelease, KeyReleaseMask, key_hook, env);
if (print_tutorial(env) != EXIT_SUCCESS)
return (ft_error(env, __FUNCTION__, "print_tutorial error"));
mlx_hook(WIN, LASTEvent, NoEventMask, idle_hook, env);
mlx_loop_hook(MLX, expose_hook, env);
test_opengl_error("ERROR", __FILE__, __LINE__, "Launching MLX_LOOP");
mlx_loop(MLX);
return (EXIT_SUCCESS);
}
void init_fdf(const char *str, t_init *t_init_mlx)
{
int **numberarray;
t_map *number_map;
int fd;
fd = open(str, O_RDONLY);
number_map = get_struct_value(get_number(open(str, O_RDONLY)));
tryalloc(number_map);
t_init_mlx = (t_init*)ft_memalloc(sizeof(t_init));
tryalloc(t_init_mlx);
t_init_mlx->nbr_map = number_map;
t_init_mlx->wid = WIDTH;
t_init_mlx->hei = HEIGHT;
print_map_number(t_init_mlx->nbr_map);
t_init_mlx->mlx = mlx_init();
creat_window(t_init_mlx);
mlx_mouse_hook(t_init_mlx->win, my_mouse_func, &t_init_mlx);
mlx_key_hook(t_init_mlx->win, my_key_func, &t_init_mlx);
mlx_loop(t_init_mlx->mlx);
}
void ft_mlx(int fd)
{
t_struct **matr = NULL;
matr = ft_creatematr(matr, fd);
matr[0]->mlx = mlx_init();
matr[0]->win = mlx_new_window(matr[0]->mlx, 1280, 800, "Wolf3d");
matr[0]->i = 0;
matr[0]->image = ft_init_image(matr[0]->image, matr[0]->mlx);
matr[0]->pproj = ft_init_pproj(matr[0]->pproj);
matr[0]->player = ft_init_player(matr[0]->player, matr[0]->pproj);
clear(matr[0]->image, matr);
ft_go(matr);
mlx_do_key_autorepeatoff(matr[0]->mlx);
mlx_expose_hook(matr[0]->win, ft_expose, matr);
mlx_hook(matr[0]->win, KeyPress, KeyPressMask, ft_mask, matr);
mlx_hook(matr[0]->win, KeyRelease, KeyReleaseMask, ft_relaise, matr);
mlx_loop_hook(matr[0]->mlx, ft_key, matr);
mlx_loop(matr[0]->mlx);
ft_freeall(matr);
}
int boucle()
{
t_mlx ml;
int **tab;
int count;
tab = to_tab();
while (tab[0][count] != 123456789)
count++;
ml.mlx_ptr = mlx_init();
ml.win_ptr = mlx_new_window(ml.mlx_ptr, 1000, 1000, "Fil de fer");
ml.img = mlx_new_image(ml.mlx_ptr, 1000, 1000);
ml.data = mlx_get_data_addr(ml.img, &ml.bpp, &ml.size, &ml.endian);
put_quadri(&ml, count, tab);
put_quadri_two(&ml, count, tab);
mlx_put_image_to_window(ml.mlx_ptr, ml.win_ptr, ml.img, 0, 0);
mlx_expose_hook(ml.win_ptr, gere_expose, &ml);
mlx_mouse_hook(ml.win_ptr, gere_mouse, &ml);
mlx_key_hook(ml.win_ptr, gere_key, &ml);
mlx_loop(ml.mlx_ptr);
return (0);
}
int main(int argc, char **argv)
{
t_world *world;
if (argc != 2)
error_quit("Invalid parameters.\nUsage:\n./fdf <map_file>");
if (!(world = malloc(sizeof(*world))))
error_quit("Failed to malloc world struct");
world_init(world);
window_init(world);
load_map(world, argv[1]);
world_init_positions(world);
get_min_max(world);
mlx_do_key_autorepeatoff(world->window->mlx);
mlx_hook(world->window->mlx_window, 2, 1, &key_press_listener, world);
mlx_hook(world->window->mlx_window, 3, 2, &key_release_listener, world);
mlx_loop_hook(world->window->mlx, &loop_listener, world);
//mlx_key_hook(world->window->mlx_window, &key_listener, world);
//mlx_expose_hook(world->window->mlx_window, &expose_listener, world);
mlx_loop(world->window->mlx);
return (0);
}
int main(int argc, char **argv)
{
t_env env;
if (argc != 2)
{
ft_printf("Please include a scene file\n");
return (0);
}
get_input(&env, argv[1]);
env.mlx = mlx_init();
env.win = mlx_new_window(env.mlx, WIN_X, WIN_Y, "rtv1");
env.img.img = mlx_new_image(env.mlx, WIN_X, WIN_Y);
env.img.data = mlx_get_data_addr(env.img.img, &env.img.bpp,
&env.img.s, &env.img.e);
raytrace(&env);
mlx_expose_hook(env.win, expose, &env);
mlx_key_hook(env.win, key_hook, &env);
mlx_hook(env.win, 17, 0L, &close_window, &env);
mlx_loop(env.mlx);
return (0);
}
int main(void)
{
t_mlx *m;
m = (t_mlx*)malloc(sizeof(t_mlx));
init_wolf(m);
if (!(m->mlx = mlx_init()))
{
ft_putendl_fd("mlx_init error", 2);
return (0);
}
m->win = mlx_new_window(m->mlx, m->width, m->heigh, "wolf3d");
m->img = mlx_new_image(m->mlx, m->width, m->heigh);
m->data = mlx_get_data_addr(m->img, &m->bpp, &m->sizeline, &m->endian);
mlx_string_put(m->mlx, m->win, 500, 370, 65280, WELCOME);
mlx_string_put(m->mlx, m->win, 480, 400, 65280, PRESS);
mlx_string_put(m->mlx, m->win, 500, 430, 65280, ESC);
mlx_expose_hook(m->win, expose_hook, m);
mlx_hook(m->win, KEYPRESS, KEYPRESSMASK, key_hook, m);
mlx_loop(m->mlx);
return (0);
}
int main(int ac, char **av)
{
t_env e;
t_coord *map;
map = NULL;
e.scale = 20;
e.x = e.scale * 20;
e.y = e.scale * 15;
e.xmax = 0;
e.ymax = 0;
e.angle = 0.60;
if (!(e.mlx = mlx_init())
|| !(e.win = mlx_new_window(e.mlx, WIN_W, WIN_H, "42 FdF"))
|| !(e.map = create_map(&map, ac, av, &e)))
return (0);
mlx_key_hook(e.win, key_hook, &e);
mlx_expose_hook(e.win, expose_hook, &e);
mlx_mouse_hook(e.win, mouse_hook, &e);
mlx_loop(e.mlx);
return (0);
}
void main2(t_all *all, t_add *add, t_window *wind, t_coords *list)
{
create_window(&wind);
wind->image = mlx_new_image(wind->mlx, SIZE_W, SIZE_H);
wind->adress = (int *)mlx_get_data_addr(wind->image, \
&wind->endian, &wind->size_line, &wind->bpp);
add->k = fmin((SIZE_W / 2) / add->width, (SIZE_H / 2) / add->height);
add->sdvig_x = 0;
add->sdvig_y = 0;
all->list = list;
all->wind = wind;
all->add = add;
all->add->a = 0.4;
all->add->b = 0.4;
all->add->c = 3.2;
dooo(all);
mlx_put_image_to_window(wind->mlx, wind->window, wind->image, 0, 0);
hints(all->wind);
mlx_hook(all->wind->window, 2, 5, hadle_input_key, all);
mlx_hook(all->wind->window, 17, 1L << 17, exit_x, all);
mlx_loop(all->wind->mlx);
}
int main(int ac, char **av)
{
t_env env;
env.i = -1;
env.j = 0;
env.count = 0;
env.k = env.nbr_col;
while (ac == 2)
{
ft_nbr_line_col(av[1], &env);
if ((env.ptr = mlx_init()) == NULL)
return (EXIT_FAILURE);
if ((env.win = mlx_new_window(env.ptr, 640, 480, "fdf")) == NULL)
return (EXIT_FAILURE);
mlx_key_hook(env.win, ft_key_hook, &env);
mlx_mouse_hook(env.win, ft_mouse_hook, &env);
fake_expose(env);
mlx_loop(env.ptr);
}
return (EXIT_SUCCESS);
}
int main(int ac, char **av)
{
t_fdf e;
fdf_ini(&e);
if (ac < 2 || !my_parse(&e, ac, av))
return (0);
e.wia = FT_MAX(e.maa - e.mia, 1);
if (!(e.mlx = mlx_init()))
return (fdf_quit(&e));
if (!(e.win = mlx_new_window(e.mlx, e.wid, e.hig, "FdF")))
return (fdf_quit(&e));
if (!(e.img = mlx_new_image(e.mlx, e.wid, e.hig)))
return (fdf_quit(&e));
e.buf = mlx_get_data_addr(e.img, &e.bit, &e.lin, &e.end);
e.bit /= 8;
prepare_image(&e);
mlx_key_hook(e.win, &my_key_func, &e);
mlx_expose_hook(e.win, &my_expose_func, &e);
mlx_loop(e.mlx);
return (0);
}
int main(int ac, char **av)
{
t_env e;
int nb_ca;
int nb_la;
if (ac != 2)
return (0);
e.mlx = mlx_init();
e.win = mlx_new_window(e.mlx, LON, LAR, "42");
e.tab = ft_lecture(av[1], &nb_la, &nb_ca);
e.nb_l = nb_la;
e.nb_c = nb_ca;
e.v = remplir_vect(e);
e.v = multi_rot(e.v);
e.v = multi_scale(e.v);
e.v = multi_napoli(&e);
mlx_expose_hook(e.win, expose_hook, &e);
mlx_key_hook(e.win, key_hook, &e);
mlx_loop(e.mlx);
return (0);
}
int main(void)
{
t_env e;
int fd;
t_ray ray;
e = init_mlx(1000, 1022);
init_env(&e);
ray.origin = e.cam;
fd = ft_open();
e.list = recur_list_build(fd, NULL);
close(fd);
fd = ft_open();
e.lights = recur_lights_build(fd, NULL);
close(fd);
e.ray = ray;
mlx_do_key_autorepeaton(e.mlx);
mlx_hook(e.win, 2, 1L << 0, key_hook, &e);
mlx_expose_hook(e.win, expose_hook, &e);
mlx_loop(e.mlx);
return (0);
}
int main(int ac, char **av)
{
t_win win;
int **tab;
t_screen s_size;
if (ac != 2)
{
ft_putendl("usage : fdf [file]");
exit(1);
}
if (!(tab = parse(av[1])))
{
ft_putendl("error parse");
return (1);
}
print_tab(tab, av[1]);
gt_screen_size(av[1], tab, &s_size);
if (!(win.mlx_ptr = mlx_init()))
{
ft_putstr("error init");
return (2);
}
if (!(win.win_ptr = mlx_new_window(win.mlx_ptr, s_size.x, s_size.y, "yolo")))
{
ft_putstr("error new window");
return (3);
}
win.tab = tab;
win.s_x = s_size.x;
win.s_y = s_size.y;
win.nb_line = count_nb_line(av[1]);
win.nb_col = count_nb_col(av[1]);
mlx_expose_hook(win.win_ptr, draw, &win);
mlx_key_hook(win.win_ptr, keyboard, &win);
mlx_loop(win.mlx_ptr);
return (0);
}
int main(int ac, char **av)
{
t_param param;
t_obj_list *objects;
t_cam cam;
scene = NULL;
if (ac != 2)
return (write(2, "Usage : ./rt <scene>\n", 21));
if (get_scene(&objects, av[1]))
return (1);
if (!(param.mlx_ptr = mlx_init()))
return (1);
cam = init_cam();
param.win_ptr = mlx_new_window(param.mlx_ptr, WINX, WINY, "JazaRT");
param.cmap.img = mlx_new_image(param.mlx_ptr, WINX, WINY);
if (!(draw_plan(param.cmap, &objects, &cam)))
return (1);
mlx_key_hook(param.win_ptr, gere_key, (void *)¶m);
mlx_expose_hook(param.win_ptr, gere_expose, (void *)¶m);
mlx_loop(param.mlx_ptr);
return (0);
}
int main(int argc, char **argv)
{
t_rt s_rt;
if (argc == 3)
{
s_rt.s_eye.x = -3000;
s_rt.s_eye.y = 0;
s_rt.s_eye.z = 0;
s_rt.s_rot.x = 0;
s_rt.s_rot.y = 0;
s_rt.s_rot.z = 0;
s_rt.mode = 0;
init_mlx(&s_rt);
load_scene(&s_rt, argv);
raytracing(&s_rt);
launch_mlx(&s_rt);
mlx_loop(s_rt.mlx_ptr);
}
else
ft_putstr("Usage : ./rtv1 misc/objects.rt misc/spots.rt\n", 2);
return (EXIT_SUCCESS);
}
int main(int ac, char **av)
{
t_env e;
e.x = 2;
e.y = 7;
if (ac == 2)
ft_choose_map(av, &e);
else
ft_map(e.map);
e.mlx = mlx_init();
e.win = mlx_new_window(e.mlx, WIDTH, HEIGHT, "window");
e.img = mlx_new_image(e.mlx, WIDTH, HEIGHT);
e.data = mlx_get_data_addr(e.img, &(e.bpp), &(e.size_line), &(e.endian));
ft_print_background(&e);
mlx_hook(e.win, 2, (1L << 0), key_hook, &e);
e.angle = -M_PI / 2;
scanning_screen(&e);
mlx_put_image_to_window(e.mlx, e.win, e.img, 0, 0);
mlx_expose_hook(e.win, expose_hook, &e);
mlx_loop(e.mlx);
return (0);
}
int main(int argc, char **argv)
{
int fd;
t_coord *coord;
t_param *param;
if (argc != 2)
{
ft_putstr("fdf error ! You must give only one argument.\n");
exit(2);
}
fd = open(argv[1], O_RDONLY);
error_handler(fd);
coord = (t_coord*)malloc(sizeof(t_coord));
param = (t_param*)malloc(sizeof(t_param));
param->matrix = matrix_init(fd, param);
init_draw(param, coord);
mlx_expose_hook(param->win, expose_function, param);
mlx_key_hook(param->win, key_function, param);
free(coord);
mlx_loop(param->mlx);
return (0);
}
int main(int argc, char **argv)
{
t_ba ba;
t_obj obj;
int i;
(void)argc;
if (!(i = ft_select_env(argv, &obj)))
return (0);
ft_init_ptrfunc(&ba);
if ((ba.mlx = mlx_init()) == NULL)
{
ft_putstr("mlx_init failed. Abort.\n");
exit(-1);
}
ba.wdw = mlx_new_window(ba.mlx, (WD_H / 2), (WD_W / 2), "RT - Mr Pickles");
ft_setimg(&ba);
ft_draw(&ba, &obj);
ba.loop = mlx_key_hook(ba.wdw, &ft_key_hook, &ba);
ba.loop = mlx_expose_hook(ba.wdw, &ft_expose_hook, &ba);
ba.loop = mlx_loop(ba.mlx);
return (0);
}
int main(int ac, char **av)
{
t_env env;
(void)av;
if (ac < 2)
{
ft_menu_shell();
return (0);
}
env.f = ft_init(av[1]);
env.f.height = (env.f.x2 - env.f.x1) * env.f.zoom;
env.f.width = (env.f.y2 - env.f.y1) * env.f.zoom;
env.mlx = mlx_init();
env.win = mlx_new_window(env.mlx, env.f.height, env.f.width, "Fractol");
env.img = mlx_new_image(env.mlx, env.f.height, env.f.width);
env = ft_get_data(&env);
ft_draw(&env);
mlx_key_hook(env.win, ft_key_hook, &env);
mlx_mouse_hook(env.win, ft_mouse_hook, &env);
mlx_hook(env.win, 6, (1L << 6), motion_hook, &env);
mlx_loop(env.mlx);
}
void draw(t_env *e)
{
e->i = 0;
img_init(e);
while (e->i + 1 < e->p.lenmax)
{
iso_init(e);
if (e->a[e->i]->y == e->a[e->i + 1]->y)
{
iso_converth(e);
draw_line(e);
}
if (e->i + e->p.lenx < e->p.lenmax)
{
iso_convertv(e);
draw_line(e);
}
e->i++;
}
mlx_hook(e->win, 2, 1, keyfnc, e);
mlx_put_image_to_window(e->mlx, e->win, e->img.adr, 0, 0);
optionsdisplay(e);
mlx_loop(e->mlx);
}
int main(int argc, char **argv)
{
int fd;
t_cloud data;
t_node nodes;
init_struct(&data);
if (argc <= 1 || argc >= 3)
return (argc <= 1 ? error("Too few arguments")
: error("Too many arguments"));
if (argc != 2)
return (error("Error parameters"));
if ((fd = open(argv[1], O_RDONLY)) == -1)
return (error("Error open file"));
if (!parser(fd, &data, &nodes))
return (error("Parsing Error"));
close(fd);
draw_points(data.start_node, &data);
mlx_hook(data.win, 2, (1L << 0), distrib_key, &data);
// mlx_key_hook(data.win, distrib_key, &data);
mlx_loop(data.mlx);
return (0);
}
int main(int ac, char **av)
{
t_env *env;
env = NULL;
if (ac < 2)
{
ft_printf_fd(2, "%s\n", USAGE);
return (EXIT_FAILURE);
}
if ((env = (t_env *)malloc(sizeof(t_env))))
{
ft_bzero(env, sizeof(t_env));
ft_init_main(env, ac, av);
rt_scene(av[1], env);
ft_set_mlx(env->dt);
ft_init_vectors(env->dt, 0.5, 0.5);
ft_ray_cast_threads(env);
mlx_key_hook(env->dt->win, &ft_loop, &env);
mlx_expose_hook(env->dt->win, ft_expose, env);
mlx_loop(env->dt->conn);
}
return (EXIT_SUCCESS);
}
int main(int ac, char **av)
{
t_glob *glob;
glob = cx_malloc(1 * sizeof(*glob));
glob->graph = cx_malloc(1 * sizeof(t_graph));
glob->universe = cx_malloc(1 * sizeof(t_uni));
glob->option = cx_malloc(1 * sizeof(t_option));
if (ac < 2)
{
fprintf(stderr, "Usage: ./%s [file.xml] [flags]\n", av[0]);
put_error(USAGE_FLAG, 1);
}
parse_conf(av[1], glob);
get_args(glob, ac, av);
check_parse(glob);
init_methodes(glob);
init(glob);
tracemyray(glob);
mlx_expose_hook(glob->graph->win_ptr, &expose, glob);
mlx_key_hook(glob->graph->win_ptr, &key_hook, glob);
mlx_loop(glob->graph->mlx_ptr);
return (EXIT_SUCCESS);
}
