void _reload_loaded_bitmaps_delayed(void) { int flags = al_get_new_bitmap_flags(); int format = al_get_new_bitmap_format(); for (size_t i = 0; i < loaded_bitmaps.size(); i++) { MBITMAP *m = loaded_bitmaps[i]->bitmap; if ((loaded_bitmaps[i]->flags & ALLEGRO_NO_PRESERVE_TEXTURE) && loaded_bitmaps[i]->delayed) { al_set_new_bitmap_flags(loaded_bitmaps[i]->flags); al_set_new_bitmap_format(loaded_bitmaps[i]->format); if (loaded_bitmaps[i]->load_type == LOAD_LOAD) { m->bitmap = my_load_bitmap(loaded_bitmaps[i]->load.filename.c_str()); if (loaded_bitmaps[i]->load.redraw) { loaded_bitmaps[i]->load.redraw(m, loaded_bitmaps[i]->load.data); } } else { // create Recreate *d = &loaded_bitmaps[i]->recreate; m->bitmap = my_al_create_bitmap(d->w, d->h); if (d->func) { // recreate with func d->func(m, d->data); } } al_use_shader(NULL); } } al_set_new_bitmap_flags(flags); al_set_new_bitmap_format(format); }
Overlay::Overlay(renderer* parent) : parent(parent) { { CoreSuspender suspend; //parent->zoom(df::zoom_commands::zoom_reset); good_viewscreen = false; ReadTileLocations(); copy_from_inner(); } front_mutex = al_create_mutex(); int32_t flags = al_get_new_bitmap_flags(); if(al_get_current_display() != NULL){ al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP | ALLEGRO_ALPHA_TEST); } front = al_create_bitmap(0,0); if(al_get_current_display() != NULL){ al_set_new_bitmap_flags(al_get_bitmap_flags(al_get_backbuffer(al_get_current_display()))); } back = al_create_bitmap(0,0); al_set_new_bitmap_flags(flags); Flip(); };
MBITMAP *m_create_alpha_bitmap(int w, int h, void (*create)(MBITMAP *bitmap, RecreateData *), RecreateData *data, void (*destroy)(MBITMAP *b), bool delayed) // check { int f = al_get_new_bitmap_format(); al_set_new_bitmap_format(ALPHA_FMT); ALLEGRO_BITMAP *bitmap; int flags = al_get_new_bitmap_flags(); int new_flags = flags; if (config.getUseOnlyMemoryBitmaps()) { al_set_new_bitmap_flags(new_flags|ALLEGRO_MEMORY_BITMAP); bitmap = my_al_create_bitmap(w, h); } else { bitmap = my_al_create_bitmap(w, h); } al_set_new_bitmap_flags(flags); al_set_new_bitmap_format(f); MBITMAP *m = new_mbitmap(bitmap); if (create) { create(m, data); } #if defined ALLEGRO_ANDROID || defined ALLEGRO_WINDOWS if ( #ifdef ALLEGRO_WINDOWS (al_get_display_flags(display) & ALLEGRO_DIRECT3D) && #endif (al_get_bitmap_flags(bitmap) & ALLEGRO_NO_PRESERVE_TEXTURE) && !(al_get_bitmap_flags(bitmap) & ALLEGRO_MEMORY_BITMAP) ) { LoadedBitmap *lb = new LoadedBitmap; null_lb(lb); lb->load_type = LOAD_CREATE; lb->flags = al_get_bitmap_flags(bitmap); lb->format = al_get_bitmap_format(bitmap); lb->destroy.func = destroy; lb->recreate.func = create; lb->recreate.data = data; lb->recreate.w = w; lb->recreate.h = h; lb->bitmap = m; lb->delayed = delayed; loaded_bitmaps.push_back(lb); } else { #endif if (data) { delete data; } #if defined ALLEGRO_ANDROID || defined ALLEGRO_WINDOWS } #endif return m; }
/* The menu item owns the icon bitmap. It is converted to a memory bitmap * when set to make sure any system threads will be able to read the data. */ static void set_item_icon(ALLEGRO_MENU_ITEM *item, ALLEGRO_BITMAP *icon) { item->icon = icon; if (icon && al_get_bitmap_flags(item->icon) & ALLEGRO_VIDEO_BITMAP) { int old_flags = al_get_new_bitmap_flags(); al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP); item->icon = al_clone_bitmap(icon); al_destroy_bitmap(icon); al_set_new_bitmap_flags(old_flags); } }
bool Imgui_ImplA5_CreateDeviceObjects() { ImGuiIO &io = ImGui::GetIO(); // Build texture unsigned char *pixels; int width, height; io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height); // Create texture int flags = al_get_new_bitmap_flags(); int fmt = al_get_new_bitmap_format(); al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP|ALLEGRO_MIN_LINEAR|ALLEGRO_MAG_LINEAR); al_set_new_bitmap_format(ALLEGRO_PIXEL_FORMAT_ABGR_8888_LE); ALLEGRO_BITMAP* img = al_create_bitmap(width, height); al_set_new_bitmap_flags(flags); al_set_new_bitmap_format(fmt); if (!img) return false; ALLEGRO_LOCKED_REGION *locked_img = al_lock_bitmap(img, al_get_bitmap_format(img), ALLEGRO_LOCK_WRITEONLY); if (!locked_img) { al_destroy_bitmap(img); return false; } memcpy(locked_img->data, pixels, sizeof(int)*width*height); al_unlock_bitmap(img); // Convert software texture to hardware texture. ALLEGRO_BITMAP* cloned_img = al_clone_bitmap(img); al_destroy_bitmap(img); if (!cloned_img) return false; // Store our identifier io.Fonts->TexID = (void*)cloned_img; g_Texture = cloned_img; // Cleanup (don't clear the input data if you want to append new fonts later) io.Fonts->ClearInputData(); io.Fonts->ClearTexData(); // Create an invisible mouse cursor // Because al_hide_mouse_cursor() seems to mess up with the actual inputs.. ALLEGRO_BITMAP* mouse_cursor = al_create_bitmap(8,8); g_MouseCursorInvisible = al_create_mouse_cursor(mouse_cursor, 0, 0); al_destroy_bitmap(mouse_cursor); return true; }
ALLEGRO_BITMAP *Object::create_memory_bitmap() { setBit(ER_BITMAP); setBit(ISMEM_BITMAP); int flags = al_get_new_bitmap_flags(); al_set_new_bitmap_flags(flags | ALLEGRO_MEMORY_BITMAP); ALLEGRO_BITMAP *bmp; bmp = al_create_bitmap(w, h); al_set_new_bitmap_flags(flags); return bmp; }
MBITMAP *create_trapezoid(int dir, int topw, int bottomw, int length, MCOLOR color) { MBITMAP *b; color.a = 1.0f; m_push_target_bitmap(); int flgs = al_get_new_bitmap_flags(); al_set_new_bitmap_flags(flgs & ~ALLEGRO_NO_PRESERVE_TEXTURE); if (dir == DIRECTION_NORTH) { b = m_create_bitmap(bottomw, length); // check } else if (dir == DIRECTION_EAST) { b = m_create_bitmap(length, bottomw); // check } else if (dir == DIRECTION_SOUTH) { b = m_create_bitmap(bottomw, length); // check } else { b = m_create_bitmap(length, bottomw); // check } al_set_new_bitmap_flags(flgs); m_set_target_bitmap(b); m_clear(m_map_rgba(0, 0, 0, 0)); float y = get_trap_peak(topw, bottomw, length); if (dir == DIRECTION_NORTH) { m_draw_triangle(bottomw/2, length+y-1, 0, 0, bottomw-1, 0, color); } else if (dir == DIRECTION_EAST) { m_draw_triangle(-y, bottomw/2, length-1, 0, length-1, bottomw-1, color); } else if (dir == DIRECTION_SOUTH) { m_draw_triangle(bottomw/2, -y, bottomw-1, length-1, 0, length-1, color); } else if (dir == DIRECTION_WEST) { m_draw_triangle(length+y-1, bottomw/2, 0, 0, 0, bottomw-1, color); } m_pop_target_bitmap(); return b; }
bool System::initSharedSystem() { if (!al_is_system_installed()) { assert(al_init() && "Failed to initialize Allegro."); assert(al_inhibit_screensaver(true) && "Failed to inhibit screensaver."); al_set_new_display_flags(ALLEGRO_WINDOWED | ALLEGRO_GENERATE_EXPOSE_EVENTS | ALLEGRO_OPENGL_FORWARD_COMPATIBLE | ALLEGRO_OPENGL); al_set_new_bitmap_flags(ALLEGRO_VIDEO_BITMAP | ALLEGRO_MIN_LINEAR | ALLEGRO_MAG_LINEAR); } if (!al_init_image_addon()) { std::cerr << "Failed to initialize image addon" << std::endl; return false; } if (!al_install_keyboard()) { std::cerr << "Failed to install keyboard" << std::endl; return false; } if (!al_install_mouse()) { std::cerr << "Failed to install mouse" << std::endl; return false; } if (!al_install_joystick()) { std::cerr << "Failed to install joystick" << std::endl; return false; } return true; }
void _al_win_set_display_icon(ALLEGRO_DISPLAY *display, ALLEGRO_BITMAP *bmp) { ALLEGRO_BITMAP *scaled_bmp; HICON icon, old_small, old_big; ALLEGRO_DISPLAY_WIN *win_display = (ALLEGRO_DISPLAY_WIN *)display; ALLEGRO_STATE backup; al_store_state(&backup, ALLEGRO_STATE_BITMAP | ALLEGRO_STATE_BLENDER); al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP); al_set_new_bitmap_format(ALLEGRO_PIXEL_FORMAT_ARGB_8888); scaled_bmp = al_create_bitmap(32, 32); al_set_target_bitmap(scaled_bmp); al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO, al_map_rgb(255, 255, 255)); al_draw_scaled_bitmap(bmp, 0, 0, al_get_bitmap_width(bmp), al_get_bitmap_height(bmp), 0, 0, 32, 32, 0); al_restore_state(&backup); icon = _al_win_create_icon(win_display->window, scaled_bmp, 0, 0, false); old_small = (HICON)SendMessage(win_display->window, WM_SETICON, ICON_SMALL, (LPARAM)icon); old_big = (HICON)SendMessage(win_display->window, WM_SETICON, ICON_BIG, (LPARAM)icon); if (old_small) DestroyIcon(old_small); if (old_big) DestroyIcon(old_big); al_destroy_bitmap(scaled_bmp); }
void init_video (void) { if (! al_init_image_addon ()) error (-1, 0, "%s (void): failed to initialize image addon", __func__); al_set_new_display_flags (al_get_new_display_flags () | (display_mode < 0 ? ALLEGRO_WINDOWED : ALLEGRO_FULLSCREEN) | ALLEGRO_RESIZABLE | ALLEGRO_GENERATE_EXPOSE_EVENTS); display_width = display_width ? display_width : DISPLAY_WIDTH; display_height = display_height ? display_height : DISPLAY_HEIGHT; if (display_mode >= 0) { ALLEGRO_DISPLAY_MODE d; get_display_mode (display_mode, &d); display_width = d.width; display_height = d.height; al_set_new_display_refresh_rate (d.refresh_rate); al_set_new_display_flags (al_get_new_display_flags () & ~ALLEGRO_FULLSCREEN_WINDOW); } al_set_new_display_option (ALLEGRO_SINGLE_BUFFER, 1, ALLEGRO_SUGGEST); display = al_create_display (display_width, display_height); if (! display) error (-1, 0, "%s (void): failed to initialize display", __func__); set_target_backbuffer (display); al_set_new_bitmap_flags (ALLEGRO_VIDEO_BITMAP); al_set_window_title (display, WINDOW_TITLE); icon = load_bitmap (ICON); al_set_display_icon (display, icon); cutscene = true; if (mr.fit_w == 0 && mr.fit_h == 0) { mr.fit_w = 2; mr.fit_h = 2; } set_multi_room (1, 1); effect_buffer = create_bitmap (CUTSCENE_WIDTH, CUTSCENE_HEIGHT); black_screen = create_bitmap (CUTSCENE_WIDTH, CUTSCENE_HEIGHT); uscreen = create_bitmap (CUTSCENE_WIDTH, CUTSCENE_HEIGHT); iscreen = create_bitmap (display_width, display_height); clear_bitmap (uscreen, TRANSPARENT_COLOR); video_timer = create_timer (1.0 / EFFECT_HZ); al_init_font_addon (); builtin_font = al_create_builtin_font (); if (! builtin_font) error (-1, 0, "%s (void): cannot create builtin font", __func__); if (! al_init_primitives_addon ()) error (-1, 0, "%s (void): failed to initialize primitives addon", __func__); }
int main(int argc, char **argv) { al_init(); al_init_image_addon(); al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP | ALLEGRO_NO_PREMULTIPLIED_ALPHA); al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO); ALLEGRO_BITMAP *tm = al_load_bitmap("tilemap.png"); int w = al_get_bitmap_width(tm); int h = al_get_bitmap_height(tm); int wt = w / 16; int ht = h / 16; ALLEGRO_BITMAP *b = al_create_bitmap(16, 16); al_set_target_bitmap(b); for (int y = 0; y < ht; y++) { for (int x = 0; x < wt; x++) { al_clear_to_color(al_map_rgba_f(0, 0, 0, 0)); al_draw_bitmap_region(tm, x*16, y*16, 16, 16, 0, 0, 0); char name[200]; sprintf(name, "out/%d-%d.png", x, y); al_save_bitmap(name, b); } } }
/* Converts a display bitmap to a memory bitmap preserving its contents. * Driver specific resources occupied by the display bitmap are freed. * A converted sub bitmap is invalid until its parent is converted. */ void _al_convert_to_memory_bitmap(ALLEGRO_BITMAP *bitmap) { ALLEGRO_BITMAP *tmp; ALLEGRO_STATE backup; size_t old_size; /* Do nothing if it is a memory bitmap already. */ if (bitmap->flags & ALLEGRO_MEMORY_BITMAP) return; if (bitmap->parent) { _al_vector_find_and_delete(&bitmap->display->bitmaps, &bitmap); //al_realloc(bitmap, sizeof(ALLEGRO_BITMAP)); bitmap->display = NULL; bitmap->flags |= ALLEGRO_MEMORY_BITMAP; return; } ALLEGRO_DEBUG("converting display bitmap %p to memory bitmap\n", bitmap); /* Allocate a temporary bitmap which will hold the data * during the conversion process. */ al_store_state(&backup, ALLEGRO_STATE_BITMAP | ALLEGRO_STATE_BLENDER); al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP); al_set_new_bitmap_format(bitmap->format); tmp = _al_create_memory_bitmap(bitmap->w, bitmap->h); /* Preserve bitmap contents. */ al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO); al_set_target_bitmap(tmp); al_draw_bitmap(bitmap, 0, 0, 0); tmp->cb_excl = bitmap->cb_excl; tmp->cr_excl = bitmap->cr_excl; tmp->cl = bitmap->cl; tmp->ct = bitmap->ct; al_restore_state(&backup); /* Destroy the display bitmap to free driver-specific resources. */ if (bitmap->vt) bitmap->vt->destroy_bitmap(bitmap); _al_vector_find_and_delete(&bitmap->display->bitmaps, &bitmap); /* Do not shrink the bitmap object. This way we can convert back to the * display bitmap. */ /*al_realloc(bitmap, tmp->size); bitmap->size = tmp->size*/ /* Put the contents back to the bitmap. */ old_size = bitmap->size; memcpy(bitmap, tmp, tmp->size); bitmap->size = old_size; al_free(tmp); }
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; }
ALLEGRO_BITMAP_OGL* _al_ogl_create_backbuffer(ALLEGRO_DISPLAY *disp) { ALLEGRO_BITMAP_OGL *ogl_backbuffer; ALLEGRO_BITMAP *backbuffer; ALLEGRO_STATE backup; int format; ALLEGRO_DEBUG("Creating backbuffer\n"); al_store_state(&backup, ALLEGRO_STATE_NEW_BITMAP_PARAMETERS); // FIXME: _al_deduce_color_format would work fine if the display paramerers // are filled in, for WIZ and IPOD #ifdef ALLEGRO_GP2XWIZ format = ALLEGRO_PIXEL_FORMAT_RGB_565; /* Only support display format */ #elif defined ALLEGRO_IPHONE format = ALLEGRO_PIXEL_FORMAT_ABGR_8888_LE; // TODO: This one is also supported //format = ALLEGRO_PIXEL_FORMAT_RGB_565; #else format = _al_deduce_color_format(&disp->extra_settings); /* Eww. No OpenGL hardware in the world does that - let's just * switch to some default. */ if (al_get_pixel_size(format) == 3) { /* Or should we use RGBA? Maybe only if not Nvidia cards? */ format = ALLEGRO_PIXEL_FORMAT_ABGR_8888; } #endif ALLEGRO_TRACE_CHANNEL_LEVEL("display", 1)("Deduced format %s for backbuffer.\n", _al_pixel_format_name(format)); /* Now that the display backbuffer has a format, update extra_settings so * the user can query it back. */ _al_set_color_components(format, &disp->extra_settings, ALLEGRO_REQUIRE); disp->backbuffer_format = format; ALLEGRO_DEBUG("Creating backbuffer bitmap\n"); al_set_new_bitmap_format(format); /* Using ALLEGRO_NO_PRESERVE_TEXTURE prevents extra memory being allocated */ al_set_new_bitmap_flags(ALLEGRO_VIDEO_BITMAP | ALLEGRO_NO_PRESERVE_TEXTURE); backbuffer = _al_ogl_create_bitmap(disp, disp->w, disp->h); al_restore_state(&backup); if (!backbuffer) { ALLEGRO_DEBUG("Backbuffer bitmap creation failed.\n"); return NULL; } ALLEGRO_TRACE_CHANNEL_LEVEL("display", 1)( "Created backbuffer bitmap (actual format: %s)\n", _al_pixel_format_name(backbuffer->format)); ogl_backbuffer = (ALLEGRO_BITMAP_OGL*)backbuffer; ogl_backbuffer->is_backbuffer = 1; backbuffer->display = disp; return ogl_backbuffer; }
ALLEGRO_FONT *_al_load_bitmap_font(const char *fname, int size, int flags) { ALLEGRO_BITMAP *import_bmp; ALLEGRO_FONT *f; ALLEGRO_STATE backup; int range[2]; ASSERT(fname); (void)size; (void)flags; al_store_state(&backup, ALLEGRO_STATE_NEW_BITMAP_PARAMETERS); al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP); al_set_new_bitmap_format(ALLEGRO_PIXEL_FORMAT_ANY_WITH_ALPHA); import_bmp = al_load_bitmap(fname); al_restore_state(&backup); if (!import_bmp) return NULL; /* We assume a single unicode range, starting at the space * character. */ range[0] = 32; range[1] = 32 + bitmap_font_count(import_bmp) - 1; f = al_grab_font_from_bitmap(import_bmp, 1, range); al_destroy_bitmap(import_bmp); return f; }
void Overlay::Flip() { //do the starting timer stuff clock_t starttime = clock(); al_lock_mutex(front_mutex); { al_unlock_bitmap(front); if(al_get_bitmap_width(front) != ssState.ScreenW || al_get_bitmap_height(front) != ssState.ScreenH){ al_destroy_bitmap(front); int32_t flags = al_get_new_bitmap_flags(); if(al_get_current_display() != NULL){ al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP | ALLEGRO_ALPHA_TEST); } front = al_create_bitmap(ssState.ScreenW, ssState.ScreenH); al_set_new_bitmap_flags(flags); } al_set_target_bitmap(front); al_draw_bitmap(back, 0, 0, 0); front_data = al_lock_bitmap(front, al_get_bitmap_format(front), ALLEGRO_LOCK_READONLY); } front_updated = true; al_unlock_mutex(front_mutex); if(al_get_bitmap_width(back) != ssState.ScreenW || al_get_bitmap_height(back) != ssState.ScreenH){ al_destroy_bitmap(back); int32_t flags = al_get_new_bitmap_flags(); if(al_get_current_display() != NULL){ al_set_new_bitmap_flags(al_get_bitmap_flags(al_get_backbuffer(al_get_current_display()))); } back = al_create_bitmap(ssState.ScreenW, ssState.ScreenH); al_set_new_bitmap_flags(flags); } al_set_target_bitmap(back); //do the ending timer stuff clock_t donetime = clock(); ssTimers.overlay_time = (donetime - starttime)*0.1 + ssTimers.overlay_time*0.9; }
MBITMAP *m_load_bitmap(const char *name, bool force_memory, bool ok_to_fail) { ALLEGRO_BITMAP *bitmap = 0; int flags = al_get_new_bitmap_flags(); if (force_memory || config.getUseOnlyMemoryBitmaps()) { al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP); } else { al_set_new_bitmap_flags((flags & ~ALLEGRO_MEMORY_BITMAP)); } bitmap = my_load_bitmap(name, ok_to_fail); al_set_new_bitmap_flags(flags); if (!bitmap) { return NULL; } MBITMAP *m = new_mbitmap(bitmap); #if defined ALLEGRO_ANDROID || defined ALLEGRO_WINDOWS if ( #ifdef ALLEGRO_WINDOWS (al_get_display_flags(display) & ALLEGRO_DIRECT3D) && #endif (al_get_bitmap_flags(bitmap) & ALLEGRO_NO_PRESERVE_TEXTURE) && !(al_get_bitmap_flags(bitmap) & ALLEGRO_MEMORY_BITMAP) ) { LoadedBitmap *lb = new LoadedBitmap; null_lb(lb); lb->load_type = LOAD_LOAD; lb->flags = al_get_bitmap_flags(bitmap); lb->format = al_get_bitmap_format(bitmap); lb->load.filename = name; lb->load.redraw = NULL; lb->load.data = NULL; lb->bitmap = m; loaded_bitmaps.push_back(lb); } #endif return m; }
bool BitmapResource::load(void) { al_set_new_bitmap_format(ALLEGRO_PIXEL_FORMAT_ANY_WITH_ALPHA); al_set_new_bitmap_flags(ALLEGRO_MIN_LINEAR | ALLEGRO_MAG_LINEAR); bitmap = al_load_bitmap(filename.c_str()); if (!bitmap) debug_message("Error loading bitmap %s\n", filename.c_str()); return bitmap != 0; }
bool Framework::initialize(std::string config_filename) { if (initialized) return initialized; if (!al_init()) std::cerr << "al_init() failed" << std::endl; ALLEGRO_PATH *resource_path = al_get_standard_path(ALLEGRO_RESOURCES_PATH); al_change_directory(al_path_cstr(resource_path, ALLEGRO_NATIVE_PATH_SEP)); al_destroy_path(resource_path); if (!al_install_mouse()) std::cerr << "al_install_mouse() failed" << std::endl; if (!al_install_keyboard()) std::cerr << "al_install_keyboard() failed" << std::endl; if (!al_install_joystick()) std::cerr << "al_install_joystick() failed" << std::endl; if (!al_install_audio()) std::cerr << "al_install_audio() failed" << std::endl; if (!al_init_native_dialog_addon()) std::cerr << "al_init_native_dialog_addon() failed" << std::endl; if (!al_init_primitives_addon()) std::cerr << "al_init_primitives_addon() failed" << std::endl; if (!al_init_image_addon()) std::cerr << "al_init_image_addon() failed" << std::endl; if (!al_init_font_addon()) std::cerr << "al_init_font_addon() failed" << std::endl; if (!al_init_ttf_addon()) std::cerr << "al_init_ttf_addon() failed" << std::endl; if (!al_init_acodec_addon()) std::cerr << "al_init_acodec_addon() failed" << std::endl; if (!al_reserve_samples(32)) std::cerr << "al_reserve_samples() failed" << std::endl; srand(time(NULL)); primary_timer = al_create_timer(ALLEGRO_BPS_TO_SECS(60)); al_set_new_bitmap_flags(ALLEGRO_MIN_LINEAR | ALLEGRO_MAG_LINEAR); // al_set_new_bitmap_flags(ALLEGRO_MIN_LINEAR | ALLEGRO_MAG_LINEAR | ALLEGRO_MIPMAP); builtin_font = al_create_builtin_font(); event_queue = al_create_event_queue(); al_register_event_source(event_queue, al_get_keyboard_event_source()); al_register_event_source(event_queue, al_get_mouse_event_source()); al_register_event_source(event_queue, al_get_joystick_event_source()); al_register_event_source(event_queue, al_get_timer_event_source(primary_timer)); al_register_event_source(event_queue, al_get_joystick_event_source()); al_register_event_source(event_queue, al_get_default_menu_event_source()); if (al_get_num_joysticks()) joystick = al_get_joystick(0); // make this better eventually else std::cerr << "no joystick(s) detected" << std::endl; instance = new Framework(config_filename); Attributes::create_datatype_definition( AllegroColorAttributeDatatype::IDENTIFIER, AllegroColorAttributeDatatype::to_val_func, AllegroColorAttributeDatatype::to_str_func ); initialized = true; return true; }
bool init() { if (!al_init()) return false; if (!al_init_image_addon()) return false; ILogger::setLogger(new ConsoleLogger); al_set_new_bitmap_flags(ALLEGRO_MIPMAP | ALLEGRO_MIN_LINEAR); return true; }
int initialize() { // Initialize Subsystems Error::initialize(); // Initialize Allegro al_init(); al_init_image_addon(); al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP | ALLEGRO_NO_PREMULTIPLIED_ALPHA); return 1; }
BigBitmap::BigBitmap(std::string bitmap_to_load, float sector_width, float sector_height) : region_size_w(sector_width), region_size_h(sector_height) { ALLEGRO_BITMAP *restoreto =al_get_target_bitmap(); orig_flags = al_get_new_bitmap_flags(); al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP | ALLEGRO_MAG_LINEAR | ALLEGRO_MIN_LINEAR); big_bitmap = al_load_bitmap(bitmap_to_load.c_str()); if(big_bitmap == nullptr) { al_show_native_message_box(NULL, "Error", "Failed to load Image", bitmap_to_load.c_str(), NULL, ALLEGRO_MESSAGEBOX_ERROR); } orig_width = width = al_get_bitmap_width(big_bitmap); orig_height = height = al_get_bitmap_height(big_bitmap); w_regions = ceil(orig_width / region_size_w); h_regions = ceil(orig_height / region_size_h); float vector_size = w_regions+1 + h_regions+1; bitmaps.reserve(vector_size); al_set_new_bitmap_flags(ALLEGRO_VIDEO_BITMAP | ALLEGRO_MAG_LINEAR | ALLEGRO_MIN_LINEAR); for(int h = 0; h < h_regions; h++) { for(int w = 0; w < w_regions; w++) { bitmaps.push_back(al_create_bitmap(region_size_w, region_size_h)); al_set_target_bitmap(bitmaps[bitmaps.size()-1]); al_clear_to_color(al_map_rgb(0,0,0)); al_draw_bitmap_region(big_bitmap, w*region_size_w, h*region_size_h, region_size_w, region_size_h, 0, 0, 0); #ifdef _BBDEBUG std::string cont = "["+ std::to_string(h) +","+ std::to_string(w) +"]"; al_draw_text(dgbf, al_map_rgb(255,0,0),region_size_w/2,region_size_h/2,ALLEGRO_ALIGN_CENTRE,cont.c_str()); al_draw_rectangle(0,0,region_size_w, region_size_h, al_map_rgb(255,0,0),0); #endif // _BBDEBUG } } al_set_new_bitmap_flags(orig_flags); al_set_target_bitmap(restoreto); }
void init_misc() { al_set_blender(ALLEGRO_ADD, ALLEGRO_ALPHA, ALLEGRO_INVERSE_ALPHA); al_set_window_title(display, "Pikmin fangame engine"); if(smooth_scaling) al_set_new_bitmap_flags(ALLEGRO_MAG_LINEAR | ALLEGRO_MIN_LINEAR | ALLEGRO_MIPMAP); al_reserve_samples(16); srand(time(NULL)); // TODO the function is always returning 0. area_image_size = /*al_get_new_display_option(ALLEGRO_MAX_BITMAP_SIZE, NULL)*/ 800; }
MFONT *m_load_font(const char *name) { ALLEGRO_FONT *f; int flags = al_get_new_bitmap_flags(); al_set_new_bitmap_flags(flags & ~ALLEGRO_NO_PRESERVE_TEXTURE); f = al_load_font(name, 0, 0); if (f) { al_set_new_bitmap_flags(flags); return f; } debug_message("couldn't load font: using mem bitmaps"); al_set_new_bitmap_flags(flags|ALLEGRO_MEMORY_BITMAP); f = al_load_font(name, 0, 0); al_set_new_bitmap_flags(flags); return f; }
/* Create an example bitmap. */ static ALLEGRO_BITMAP *create_example_bitmap(void) { ALLEGRO_BITMAP *raw; ALLEGRO_BITMAP *bitmap; int i, j; ALLEGRO_LOCKED_REGION *locked; unsigned char *data; /* Create out example bitmap as a memory bitmap with a fixed format. */ al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP); al_set_new_bitmap_format(ALLEGRO_PIXEL_FORMAT_ABGR_8888); raw = al_create_bitmap(100, 100); locked = al_lock_bitmap(raw, ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_WRITEONLY); data = locked->data; for (j = 0; j < 100; j++) { for (i = 0; i < 100; i++) { int x = i - 50, y = j - 50; int r = sqrt(x * x + y * y); float rc = 1 - r / 50.0; if (rc < 0) rc = 0; data[i * 4 + 0] = i * 255 / 100; data[i * 4 + 1] = j * 255 / 100; data[i * 4 + 2] = rc * 255; data[i * 4 + 3] = rc * 255; } data += locked->pitch; } al_unlock_bitmap(raw); /* Now clone it into a fast display bitmap. */ al_set_new_bitmap_flags(0); al_set_new_bitmap_format(ALLEGRO_PIXEL_FORMAT_ANY_WITH_ALPHA); bitmap = al_clone_bitmap(raw); /* And don't forget to destroy the memory copy. */ al_destroy_bitmap(raw); return bitmap; }
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; }
void _al_win_set_display_icon(ALLEGRO_DISPLAY *display, ALLEGRO_BITMAP *bmp) { ALLEGRO_BITMAP *sm_bmp, *big_bmp; HICON sm_icon, big_icon, old_small, old_big; ALLEGRO_DISPLAY_WIN *win_display = (ALLEGRO_DISPLAY_WIN *)display; ALLEGRO_STATE backup; int sm_w, sm_h, big_w, big_h; al_store_state(&backup, ALLEGRO_STATE_BITMAP | ALLEGRO_STATE_BLENDER); al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP); al_set_new_bitmap_format(ALLEGRO_PIXEL_FORMAT_ARGB_8888); sm_w = GetSystemMetrics(SM_CXSMICON); sm_h = GetSystemMetrics(SM_CYSMICON); big_w = GetSystemMetrics(SM_CXICON); big_h = GetSystemMetrics(SM_CYICON); sm_bmp = al_create_bitmap(sm_w, sm_h); al_set_target_bitmap(sm_bmp); al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO); al_draw_scaled_bitmap(bmp, 0, 0, al_get_bitmap_width(bmp), al_get_bitmap_height(bmp), 0, 0, sm_w, sm_h, 0); big_bmp = al_create_bitmap(big_w, big_h); al_set_target_bitmap(big_bmp); al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO); al_draw_scaled_bitmap(bmp, 0, 0, al_get_bitmap_width(bmp), al_get_bitmap_height(bmp), 0, 0, big_w, big_h, 0); al_restore_state(&backup); sm_icon = _al_win_create_icon(win_display->window, sm_bmp, 0, 0, false, false); big_icon = _al_win_create_icon(win_display->window, big_bmp, 0, 0, false, false); old_small = (HICON)SendMessage(win_display->window, WM_SETICON, ICON_SMALL, (LPARAM)sm_icon); old_big = (HICON)SendMessage(win_display->window, WM_SETICON, ICON_BIG, (LPARAM)big_icon); if (old_small) DestroyIcon(old_small); if (old_big) DestroyIcon(old_big); al_destroy_bitmap(sm_bmp); al_destroy_bitmap(big_bmp); }
static void win_set_display_icon(ALLEGRO_DISPLAY_WIN *win_display, const WPARAM icon_type, const int sys_w, const int sys_h, const int num_icons, ALLEGRO_BITMAP *bmps[]) { HICON icon; HICON old_icon; ALLEGRO_BITMAP *bmp; int bmp_w; int bmp_h; int i; i = win_choose_icon_bitmap(sys_w, sys_h, num_icons, bmps); bmp = bmps[i]; bmp_w = al_get_bitmap_width(bmp); bmp_h = al_get_bitmap_height(bmp); if (bmp_w == sys_w && bmp_h == sys_h) { icon = _al_win_create_icon(win_display->window, bmp, 0, 0, false, false); } else { ALLEGRO_BITMAP *tmp_bmp; ALLEGRO_STATE backup; tmp_bmp = al_create_bitmap(sys_w, sys_h); if (!tmp_bmp) return; al_store_state(&backup, ALLEGRO_STATE_BITMAP | ALLEGRO_STATE_BLENDER); al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP); al_set_new_bitmap_format(ALLEGRO_PIXEL_FORMAT_ARGB_8888); al_set_target_bitmap(tmp_bmp); al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO); al_draw_scaled_bitmap(bmp, 0, 0, bmp_w, bmp_h, 0, 0, sys_w, sys_h, 0); al_restore_state(&backup); icon = _al_win_create_icon(win_display->window, tmp_bmp, 0, 0, false, false); al_destroy_bitmap(tmp_bmp); } old_icon = (HICON)SendMessage(win_display->window, WM_SETICON, icon_type, (LPARAM)icon); if (old_icon) DestroyIcon(old_icon); }
MBITMAP *m_load_alpha_bitmap(const char *name, bool force_memory) { ALLEGRO_BITMAP *bitmap = 0; int old = al_get_new_bitmap_format(); al_set_new_bitmap_format(ALPHA_FMT); if (!force_memory) bitmap = my_load_bitmap(name); if (!bitmap) { ALLEGRO_STATE s; al_store_state(&s, ALLEGRO_STATE_NEW_BITMAP_PARAMETERS); al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP); bitmap = my_load_bitmap(name); al_restore_state(&s); } al_set_new_bitmap_format(old); if (!bitmap) { return NULL; } MBITMAP *m = new_mbitmap(bitmap); #if defined ALLEGRO_ANDROID || defined ALLEGRO_WINDOWS if ( #ifdef ALLEGRO_WINDOWS (al_get_display_flags(display) & ALLEGRO_DIRECT3D) && #endif (al_get_bitmap_flags(bitmap) & ALLEGRO_NO_PRESERVE_TEXTURE) && !(al_get_bitmap_flags(bitmap) & ALLEGRO_MEMORY_BITMAP) ) { LoadedBitmap *lb = new LoadedBitmap; null_lb(lb); lb->load_type = LOAD_LOAD; lb->flags = al_get_bitmap_flags(bitmap); lb->format = al_get_bitmap_format(bitmap); lb->load.filename = name; lb->load.redraw = NULL; lb->load.data = NULL; lb->bitmap = m; loaded_bitmaps.push_back(lb); } #endif return m; }
/* 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); }