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