int main(void) { ALLEGRO_DISPLAY *display; ALLEGRO_BITMAP *icons[NUM_ICONS]; ALLEGRO_EVENT_QUEUE *queue; int u, v; if (!al_init()) { abort_example("Could not init Allegro.\n"); } al_install_keyboard(); al_init_image_addon(); display = al_create_display(320, 200); if (!display) { abort_example("Error creating display\n"); } al_clear_to_color(al_map_rgb_f(0, 0, 0)); al_flip_display(); /* First icon 16x16: Read from file. */ icons[0] = al_load_bitmap("data/cursor.tga"); if (!icons[0]) { abort_example("icons.tga not found\n"); } /* Second icon 32x32: Create it. */ al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP); icons[1] = al_create_bitmap(32, 32); al_set_target_bitmap(icons[1]); for (v = 0; v < 32; v++) { for (u = 0; u < 32; u++) { al_put_pixel(u, v, al_map_rgb_f(u / 31.0, v / 31.0, 1)); } } al_set_target_backbuffer(display); al_set_display_icons(display, NUM_ICONS, icons); queue = al_create_event_queue(); al_register_event_source(queue, al_get_keyboard_event_source()); al_register_event_source(queue, al_get_display_event_source(display)); for (;;) { ALLEGRO_EVENT event; al_wait_for_event(queue, &event); if (event.type == ALLEGRO_EVENT_KEY_DOWN && event.keyboard.keycode == ALLEGRO_KEY_ESCAPE) { break; } if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE) { break; } } al_uninstall_system(); return 0; }
int main(void) { int i; if (!al_init()) { abort_example("Could not init Allegro.\n"); } al_install_keyboard(); open_log(); display = al_create_display(640, 100); if (!display) { abort_example("Could not create display.\n"); } if (!al_install_audio()) { abort_example("Could not init sound.\n"); } al_reserve_samples(N); al_set_mixer_postprocess_callback(al_get_default_mixer(), update_waveform, NULL); mainloop(); close_log(false); for (i = 0; i < N; i++) { al_destroy_audio_stream(stream[i]); } al_uninstall_audio(); return 0; }
int main(void) { ALLEGRO_DISPLAY *dpy; ALLEGRO_EVENT_QUEUE *queue; if (!al_init()) { abort_example("Could not init Allegro.\n"); return 1; } al_install_keyboard(); dpy = al_create_display(640, 480); if (!dpy) { abort_example("Unable to set any graphic mode\n"); return 1; } queue = al_create_event_queue(); al_register_event_source(queue, al_get_keyboard_event_source()); test_relative_timeout(queue); test_absolute_timeout(queue); return 0; }
int main(void) { if (!al_init()) { abort_example("Could not init Allegro.\n"); } open_log_monospace(); display = al_create_display(WIDTH, HEIGHT); if (!display) { abort_example("al_create_display failed\n"); } al_clear_to_color(al_map_rgb_f(0, 0, 0)); al_flip_display(); if (!al_install_keyboard()) { abort_example("al_install_keyboard failed\n"); } event_queue = al_create_event_queue(); if (!event_queue) { abort_example("al_create_event_queue failed\n"); } al_register_event_source(event_queue, al_get_keyboard_event_source()); al_register_event_source(event_queue, al_get_display_event_source(display)); main_loop(); close_log(false); return 0; }
int main(void) { ALLEGRO_DISPLAY *display; ALLEGRO_EVENT_QUEUE *queue; ALLEGRO_EVENT event; int frames = 0; double start; if (!al_init()) { abort_example("Could not init Allegro.\n"); return 1; } al_install_keyboard(); al_set_new_display_flags(ALLEGRO_OPENGL); display = al_create_display(640, 480); if (!display) { abort_example("Could not create display.\n"); return 1; } queue = al_create_event_queue(); al_register_event_source(queue, al_get_keyboard_event_source()); al_register_event_source(queue, al_get_display_event_source(display)); start = al_get_time(); while (true) { /* Check for ESC key or close button event and quit in either case. */ if (!al_is_event_queue_empty(queue)) { while (al_get_next_event(queue, &event)) { switch (event.type) { case ALLEGRO_EVENT_DISPLAY_CLOSE: goto done; case ALLEGRO_EVENT_KEY_DOWN: if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE) goto done; break; } } } draw_opengl(); al_flip_display(); frames++; } done: printf("%.1f FPS\n", frames / (al_get_time() - start)); al_destroy_event_queue(queue); return 0; }
int main(int argc, char **argv) { ALLEGRO_DISPLAY *display; ALLEGRO_BITMAP *cursor; ALLEGRO_MOUSE_STATE msestate; ALLEGRO_KEYBOARD_STATE kbdstate; int i; (void)argc; (void)argv; if (!al_init()) { abort_example("Could not init Allegro.\n"); } al_init_primitives_addon(); al_install_mouse(); al_install_keyboard(); al_init_image_addon(); init_platform_specific(); display = al_create_display(640, 480); if (!display) { abort_example("Error creating display\n"); } al_hide_mouse_cursor(display); cursor = al_load_bitmap("data/cursor.tga"); if (!cursor) { abort_example("Error loading cursor.tga\n"); } do { al_get_mouse_state(&msestate); al_get_keyboard_state(&kbdstate); al_clear_to_color(al_map_rgb(0xff, 0xff, 0xc0)); for (i = 1; i <= NUM_BUTTONS; i++) { draw_mouse_button(i, al_mouse_button_down(&msestate, i)); } al_draw_bitmap(cursor, msestate.x, msestate.y, 0); al_flip_display(); al_rest(0.005); } while (!al_key_down(&kbdstate, ALLEGRO_KEY_ESCAPE)); return 0; }
int main(int argc, const char *argv[]) { enum Mode mode = ALL; int i; if (argc > 1) { i = strtol(argv[1], NULL, 10); switch (i) { case 0: mode = PLAIN_BLIT; break; case 1: mode = SCALED_BLIT; break; case 2: mode = ROTATE_BLIT; break; } } if (!al_init()) { abort_example("Could not init Allegro\n"); } open_log(); al_init_image_addon(); al_init_primitives_addon(); display = al_create_display(640, 480); if (!display) { abort_example("Error creating display\n"); } if (mode == ALL) { for (mode = PLAIN_BLIT; mode <= ROTATE_BLIT; mode++) { do_test(mode); } } else { do_test(mode); } al_destroy_display(display); close_log(true); return 0; }
static ALLEGRO_BITMAP *load_bitmap(char const *filename) { ALLEGRO_BITMAP *bitmap = al_load_bitmap(filename); if (!bitmap) abort_example("%s not found or failed to load\n", filename); return bitmap; }
int main(int argc, const char *argv[]) { int i; if (!al_init()) { abort_example("Could not init Allegro.\n"); } open_log_monospace(); if (argc < 2) { for (i = 1; i < NUM_TESTS; i++) { log_printf("# t%d\n\n", i); all_tests[i](); log_printf("\n"); } } else { i = atoi(argv[1]); if (i > 0 && i < NUM_TESTS) { all_tests[i](); } } close_log(true); if (error) { exit(EXIT_FAILURE); } return 0; }
int main(int argc, char **argv) { int i; if (!al_init()) { abort_example("Could not init Allegro.\n"); } open_log_monospace(); log_printf("%-36s %-6s %8s %8s %8s %8s\n", "name", "flags", "ctime", "mtime", "atime", "size"); log_printf( "------------------------------------ " "------ " "-------- " "-------- " "-------- " "--------\n"); if (argc == 1) { ALLEGRO_FS_ENTRY *entry = al_create_fs_entry("data"); print_entry(entry); al_destroy_fs_entry(entry); } for (i = 1; i < argc; i++) { ALLEGRO_FS_ENTRY *entry = al_create_fs_entry(argv[i]); print_entry(entry); al_destroy_fs_entry(entry); } close_log(true); return 0; }
int main(int argc, char * argv[]) { ALLEGRO_CONFIG *config; ALLEGRO_EVENT event; unsigned buffer_count; unsigned samples; const char *s; initialize(); if (argc < 2) { log_printf("This example needs to be run from the command line.\nUsage: %s {audio_files}\n", argv[0]); goto done; } buffer_count = 0; samples = 0; config = al_load_config_file("ex_stream_seek.cfg"); if (config) { if ((s = al_get_config_value(config, "", "buffer_count"))) { buffer_count = atoi(s); } if ((s = al_get_config_value(config, "", "samples"))) { samples = atoi(s); } al_destroy_config(config); } if (buffer_count == 0) { buffer_count = 4; } if (samples == 0) { samples = 1024; } stream_filename = argv[1]; music_stream = al_load_audio_stream(stream_filename, buffer_count, samples); if (!music_stream) { abort_example("Stream error!\n"); } loop_start = 0.0; loop_end = al_get_audio_stream_length_secs(music_stream); al_set_audio_stream_loop_secs(music_stream, loop_start, loop_end); al_set_audio_stream_playmode(music_stream, ALLEGRO_PLAYMODE_LOOP); al_attach_audio_stream_to_mixer(music_stream, al_get_default_mixer()); al_start_timer(timer); while (!exiting) { al_wait_for_event(queue, &event); event_handler(&event); } done: myexit(); al_destroy_display(display); close_log(true); return 0; }
int main(int argc, char *argv[]) { ALLEGRO_DISPLAY *display; ALLEGRO_FONT *font; (void)argc; (void)argv; if (!al_init()) { abort_example("Could not init Allegro.\n"); return 1; } al_init_primitives_addon(); al_init_image_addon(); al_init_font_addon(); al_install_keyboard(); al_install_mouse(); al_set_new_display_flags(ALLEGRO_GENERATE_EXPOSE_EVENTS); display = al_create_display(640, 480); if (!display) { abort_example("Error creating display\n"); return 1; } //printf("Display format = %d\n", al_get_display_format()); font = al_load_font("data/fixed_font.tga", 0, 0); if (!font) { abort_example("Failed to load data/fixed_font.tga\n"); return 1; } /* Don't remove these braces. */ { Theme theme(font); Prog prog(theme, display); prog.run(); } al_destroy_font(font); return 0; }
static void initialize(void) { if (!al_init()) { abort_example("Could not init Allegro.\n"); } open_log(); al_init_primitives_addon(); al_init_image_addon(); al_init_font_addon(); if (!al_install_keyboard()) { abort_example("Could not init keyboard!\n"); } if (!al_install_mouse()) { abort_example("Could not init mouse!\n"); } al_init_acodec_addon(); if (!al_install_audio()) { abort_example("Could not init sound!\n"); } if (!al_reserve_samples(16)) { abort_example("Could not set up voice and mixer.\n"); } init_platform_specific(); display = al_create_display(640, 228); if (!display) { abort_example("Could not create display!\n"); } basic_font = al_load_font("data/font.tga", 0, 0); if (!basic_font) { abort_example("Could not load font!\n"); } timer = al_create_timer(1.000 / 30); if (!timer) { abort_example("Could not init timer!\n"); } queue = al_create_event_queue(); if (!queue) { abort_example("Could not create event queue!\n"); } al_register_event_source(queue, al_get_keyboard_event_source()); al_register_event_source(queue, al_get_mouse_event_source()); al_register_event_source(queue, al_get_display_event_source(display)); al_register_event_source(queue, al_get_timer_event_source(timer)); }
int main(int argc, char **argv) { ALLEGRO_EVENT_SOURCE fake_src; ALLEGRO_EVENT_QUEUE *queue; ALLEGRO_EVENT fake_keydown_event, fake_joystick_event; ALLEGRO_EVENT event; (void)argc; (void)argv; if (!al_init()) { abort_example("Could not init Allegro.\n"); } open_log(); /* register our 'fake' event source with the queue */ al_init_user_event_source(&fake_src); queue = al_create_event_queue(); al_register_event_source(queue, &fake_src); /* fake a joystick event */ fake_joystick_event.any.type = ALLEGRO_EVENT_JOYSTICK_AXIS; fake_joystick_event.joystick.stick = 1; fake_joystick_event.joystick.axis = 0; fake_joystick_event.joystick.pos = 0.5; al_emit_user_event(&fake_src, &fake_joystick_event, NULL); /* fake a keyboard event */ fake_keydown_event.any.type = ALLEGRO_EVENT_KEY_DOWN; fake_keydown_event.keyboard.keycode = ALLEGRO_KEY_ENTER; al_emit_user_event(&fake_src, &fake_keydown_event, NULL); /* poll for the events we injected */ while (!al_is_event_queue_empty(queue)) { al_wait_for_event(queue, &event); switch (event.type) { case ALLEGRO_EVENT_KEY_DOWN: ALLEGRO_ASSERT(event.user.source == &fake_src); log_printf("Got keydown: %d\n", event.keyboard.keycode); break; case ALLEGRO_EVENT_JOYSTICK_AXIS: ALLEGRO_ASSERT(event.user.source == &fake_src); log_printf("Got joystick axis: stick=%d axis=%d pos=%f\n", event.joystick.stick, event.joystick.axis, event.joystick.pos); break; } } al_destroy_user_event_source(&fake_src); al_destroy_event_queue(queue); log_printf("Done.\n"); close_log(true); return 0; }
int main(void) { ALLEGRO_DISPLAY *display; ALLEGRO_EVENT_QUEUE *events; ALLEGRO_EVENT event; double last_resize; int rs = 100; /* Initialize Allegro and create an event queue. */ if (!al_init()) { abort_example("Could not init Allegro.\n"); return 1; } events = al_create_event_queue(); /* Setup a display driver and register events from it. */ al_set_new_display_flags(ALLEGRO_RESIZABLE); display = al_create_display(rs, rs); al_register_event_source(events, al_get_display_event_source(display)); /* Setup a keyboard driver and regsiter events from it. */ al_install_keyboard(); al_register_event_source(events, al_get_keyboard_event_source()); /* Display a pulsating window until a key or the closebutton is pressed. */ redraw(); last_resize = 0; while (true) { if (al_get_next_event(events, &event)) { if (event.type == ALLEGRO_EVENT_DISPLAY_RESIZE) { ALLEGRO_DISPLAY_EVENT *de = &event.display; al_acknowledge_resize(de->source); redraw(); } if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE) { break; } if (event.type == ALLEGRO_EVENT_KEY_DOWN) { break; } } if (al_current_time() - last_resize > 0.1) { int s; last_resize = al_current_time(); rs += 10; if (rs == 300) rs = 100; s = rs; if (s > 200) s = 400 - s; al_resize_display(s, s); } } return 0; }
int main(int argc, char **argv) { ALLEGRO_DISPLAY *display; ALLEGRO_BITMAP *picture; if (!al_init()) { abort_example("Could not init Allegro.\n"); return 1; } al_init_primitives_addon(); al_install_keyboard(); al_init_image_addon(); open_log_monospace(); if (argc == 2) { al_set_new_display_adapter(atoi(argv[1])); } al_set_new_display_flags(ALLEGRO_FULLSCREEN | ALLEGRO_GENERATE_EXPOSE_EVENTS); display = al_create_display(res[cur_res].w, res[cur_res].h); if (!display) { abort_example("Error creating display\n"); return 1; } picture = al_load_bitmap("data/mysha.pcx"); if (!picture) { abort_example("mysha.pcx not found\n"); return 1; } main_loop(display, picture); al_destroy_bitmap(picture); /* Destroying the fullscreen display restores the original screen * resolution. Shutting down Allegro would automatically destroy the * display, too. */ al_destroy_display(display); return 0; }
int main(void) { ALLEGRO_COLOR black; ALLEGRO_COLOR red; ALLEGRO_KEYBOARD_STATE kbdstate; if (!al_init()) { abort_example("Error initialising Allegro.\n"); } if (!al_install_keyboard()) { abort_example("Error installing keyboard.\n"); } display1 = al_create_display(300, 300); display2 = al_create_display(300, 300); if (!display1 || !display2) { abort_example("Error creating displays.\n"); } black = al_map_rgb(0, 0, 0); red = al_map_rgb(255, 0, 0); while (1) { al_get_keyboard_state(&kbdstate); if (al_key_down(&kbdstate, ALLEGRO_KEY_ESCAPE)) { break; } if (kbdstate.display == display1) { redraw(red, black); } else if (kbdstate.display == display2) { redraw(black, red); } else { redraw(black, black); } al_rest(0.1); } return 0; }
int main(int argc, char **argv) { (void)argc; (void)argv; if (!al_init()) { abort_example("Could not init Allegro.\n"); } al_init_primitives_addon(); al_install_keyboard(); al_init_image_addon(); al_init_font_addon(); init_platform_specific(); al_set_new_display_flags(ALLEGRO_FULLSCREEN_WINDOW); display = al_create_display(640, 480); if (!display) { abort_example("Error creating display\n"); } queue = al_create_event_queue(); al_register_event_source(queue, al_get_keyboard_event_source()); al_register_event_source(queue, al_get_display_event_source(display)); picture = al_load_bitmap("data/mysha.pcx"); if (!picture) { abort_example("mysha.pcx not found\n"); } font = al_load_font("data/fixed_font.tga", 0, 0); if (!font) { abort_example("data/fixed_font.tga not found.\n"); } redraw(); run(); al_destroy_display(display); al_destroy_event_queue(queue); return 0; }
int main(void) { ALLEGRO_DISPLAY *display; ALLEGRO_FONT *accelfont; ALLEGRO_FONT *memfont; ALLEGRO_BITMAP *accelbmp; ALLEGRO_BITMAP *membmp; if (!al_init()) { abort_example("Could not init Allegro.\n"); } al_install_keyboard(); al_init_image_addon(); al_init_font_addon(); display = al_create_display(640, 400); if (!display) { abort_example("Error creating display\n"); } accelfont = al_load_font("data/font.tga", 0, 0); if (!accelfont) { abort_example("font.tga not found\n"); } accelbmp = al_load_bitmap("data/mysha.pcx"); if (!accelbmp) { abort_example("mysha.pcx not found\n"); } al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP); memfont = al_load_font("data/font.tga", 0, 0); membmp = al_load_bitmap("data/mysha.pcx"); for (;;) { if (test(membmp, memfont, "Memory bitmap (press SPACE key)")) break; if (test(accelbmp, accelfont, "Accelerated bitmap (press SPACE key)")) break; } return 0; }
int main(void) { ALLEGRO_DISPLAY *display; if (!al_init()) { abort_example("Could not init Allegro.\n"); return 1; } al_init_primitives_addon(); display = al_create_display(640, 480); if (!display) { abort_example("al_create_display failed\n"); return 1; } al_install_keyboard(); black = al_map_rgb(0, 0, 0); grey = al_map_rgb(0xe0, 0xe0, 0xe0); white = al_map_rgb(255, 255, 255); al_install_joystick(); event_queue = al_create_event_queue(); if (!event_queue) { abort_example("al_create_event_queue failed\n"); return 1; } if (al_get_keyboard_event_source()) { al_register_event_source(event_queue, al_get_keyboard_event_source()); } al_register_event_source(event_queue, al_get_display_event_source(display)); al_register_event_source(event_queue, al_get_joystick_event_source()); setup_joystick_values(al_get_joystick(0)); main_loop(); return 0; }
int main(void) { if (!al_init()) { abort_example("Could not init Allegro.\n"); return 1; } al_install_keyboard(); al_init_image_addon(); if (al_get_num_video_adapters() < 2) { abort_example("You need 2 or more adapters/monitors for this example.\n"); return 1; } go(); return 0; }
int main(void) { if (!al_init()) { abort_example("Could not init Allegro.\n"); return 1; } al_init_primitives_addon(); al_install_keyboard(); al_init_image_addon(); al_init_font_addon(); display = al_create_display(640, 480); if (!display) { abort_example("Error creating display\n"); return 1; } queue = al_create_event_queue(); al_register_event_source(queue, al_get_keyboard_event_source()); al_register_event_source(queue, al_get_display_event_source(display)); myfont = al_load_font("data/font.tga", 0, 0); if (!myfont) { abort_example("font.tga not found\n"); return 1; } while (!quit) { if (al_get_new_bitmap_flags() & ALLEGRO_FORCE_LOCKING) al_set_new_bitmap_flags(ALLEGRO_VIDEO_BITMAP); else al_set_new_bitmap_flags(ALLEGRO_FORCE_LOCKING); run(); } al_destroy_event_queue(queue); return 0; }
int main(int argc, char **argv) { ALLEGRO_DISPLAY *display; ALLEGRO_TIMER *timer; (void)argc; (void)argv; if (!al_init()) { abort_example("Could not init Allegro.\n"); } al_install_keyboard(); al_install_mouse(); al_init_image_addon(); al_init_font_addon(); init_platform_specific(); display = al_create_display(640, 480); if (!display) { abort_example("Error creating display\n"); } init(); timer = al_create_timer(1.0 / ex.FPS); ex.queue = al_create_event_queue(); al_register_event_source(ex.queue, al_get_keyboard_event_source()); al_register_event_source(ex.queue, al_get_mouse_event_source()); al_register_event_source(ex.queue, al_get_display_event_source(display)); al_register_event_source(ex.queue, al_get_timer_event_source(timer)); al_start_timer(timer); run(); al_destroy_event_queue(ex.queue); return 0; }
int main(int argc, const char *argv[]) { const char *url; ALLEGRO_DISPLAY *display; ALLEGRO_BITMAP *bmp; if (argc > 1) url = argv[1]; else url = "http://liballeg.org/images/logo.png"; if (!al_init()) { abort_example("Could not init Allegro.\n"); } open_log(); al_init_image_addon(); al_install_keyboard(); display = al_create_display(640, 480); if (!display) { abort_example("Unable to create display.\n"); } curl_global_init(CURL_GLOBAL_ALL); al_set_new_file_interface(&curl_file_vtable); bmp = al_load_bitmap(url); if (bmp) { show_image(bmp); al_destroy_bitmap(bmp); } curl_global_cleanup(); close_log(true); return 0; }
int main(int argc, const char *argv[]) { ALLEGRO_THREAD *thread[MAX_THREADS]; Background background[MAX_BACKGROUNDS] = { { 1.0, 0.5, 0.5 }, { 0.5, 1.0, 0.5 }, { 0.5, 0.5, 1.0 }, { 1.0, 1.0, 0.5 }, { 0.5, 1.0, 1.0 }, { 1.0, 0.7, 0.5 }, { 0.5, 1.0, 0.7 }, { 0.7, 0.5, 1.0 }, { 1.0, 0.7, 0.5 }, { 0.5, 0.7, 1.0 } }; int num_threads; int i; if (argc > 1) { num_threads = strtol(argv[1], NULL, 10); if (num_threads > MAX_THREADS) num_threads = MAX_THREADS; else if (num_threads < 1) num_threads = 1; } else { num_threads = 3; } if (!al_init()) { abort_example("Could not init Allegro.\n"); return 1; } al_init_primitives_addon(); al_install_keyboard(); al_install_mouse(); for (i = 0; i < num_threads; i++) { thread[i] = al_create_thread(thread_func, &background[i % MAX_BACKGROUNDS]); } for (i = 0; i < num_threads; i++) { al_start_thread(thread[i]); } for (i = 0; i < num_threads; i++) { al_join_thread(thread[i], NULL); al_destroy_thread(thread[i]); } return 0; }
static void init(void) { ex.FPS = 60; ex.font = al_load_font("data/fixed_font.tga", 0, 0); if (!ex.font) { abort_example("data/fixed_font.tga not found\n"); } ex.background = al_color_name("beige"); ex.text = al_color_name("black"); ex.white = al_color_name("white"); ex.pattern = example_bitmap(100, 100); }
int main(int argc, char *argv[]) { ALLEGRO_DISPLAY *display; ALLEGRO_FONT *font; (void)argc; (void)argv; if (!al_init()) { abort_example("Could not init Allegro\n"); return 1; } al_init_primitives_addon(); al_install_keyboard(); al_install_mouse(); al_init_font_addon(); al_init_ttf_addon(); al_set_new_display_flags(ALLEGRO_GENERATE_EXPOSE_EVENTS); display = al_create_display(640, 480); if (!display) { abort_example("Unable to create display\n"); return 1; } font = al_load_font("data/DejaVuSans.ttf", 12, 0); if (!font) { abort_example("Failed to load data/DejaVuSans.ttf\n"); return 1; } Theme theme(font); Prog prog(theme, display); prog.run(); al_destroy_font(font); return 0; }
int main(int argc, const char *argv[]) { ALLEGRO_FILE *master, *slice; ALLEGRO_PATH *tmp_path; const char *first_string = "Hello, World!"; const char *second_string = "The quick brown fox jumps over the lazy dog."; char buffer[BUFFER_SIZE]; (void) argc, (void) argv; al_init(); master = al_make_temp_file("ex_file_slice_XXXX", &tmp_path); if (!master) { abort_example("Unable to create temporary file\n"); } /* Pack both strings into the master file. */ pack_object(master, first_string, strlen(first_string)); pack_object(master, second_string, strlen(second_string)); /* Seek back to the beginning of the file, as if we had just opened it */ al_fseek(master, 0, ALLEGRO_SEEK_SET); /* Loop through the main file, opening a slice for each object */ while ((slice = get_next_chunk(master))) { /* Note: While the slice is open, we must avoid using the master file! If you were dealing with packed images, this is where you would pass 'slice' to al_load_bitmap_f(). */ if (al_fsize(slice) < BUFFER_SIZE) { /* We could have used al_fgets(), but just to show that the file slice is constrained to the string object, we'll read the entire slice. */ al_fread(slice, buffer, al_fsize(slice)); buffer[al_fsize(slice)] = 0; printf("Chunk of size %d: '%s'\n", (int) al_fsize(slice), buffer); } /* The slice must be closed before the next slice is opened. Closing the slice will advanced the master file to the end of the slice. */ al_fclose(slice); } al_fclose(master); al_remove_filename(al_path_cstr(tmp_path, '/')); return 0; }
/* Initialize the example. */ static void init(void) { ex.BUTTONS_X = 40 + 110 * 4; ex.FPS = 60; ex.myfont = al_load_font("data/font.tga", 0, 0); if (!ex.myfont) { abort_example("data/font.tga not found\n"); } ex.example = create_example_bitmap(); ex.offscreen = al_create_bitmap(640, 480); al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP); ex.memory = al_create_bitmap(640, 480); }
static void init(void) { ex.FPS = 60; ex.font = al_load_font("data/fixed_font.tga", 0, 0); if (!ex.font) { abort_example("data/fixed_font.tga not found.\n"); } ex.background = al_color_name("beige"); ex.foreground = al_color_name("black"); ex.outline = al_color_name("red"); ex.text = al_color_name("blue"); ex.white = al_color_name("white"); ex.pattern = al_create_bitmap(32, 32); ex.zoom = al_create_bitmap(32, 32); draw_pattern(ex.pattern); }