// Colision de píxel perfecto bool PixelCol(ALLEGRO_BITMAP *player, ALLEGRO_BITMAP *enemy, float x, float y, float w, float h, float ex, float ey, float ew, float eh) { // El valor más alto entre la parte de arriba del jugador y del enemigo float top = fmax(y, ey); // El valor más bajo entre la parte de abajo del jugador y del enemigo float bottom = fmin(y + h, ey + eh); // El valor más alto entre la parte izquierda del jugador y del enemigo float left = fmax(x, ex); // El valor más bajo entre la parte derecha del jugador y del enemigo float right = fmin(x + w, ex + ew); // Hace un par de for's para revisar si hace colisión for(int i = top; i < bottom; i++) { for(int j = left; j < right; j++) { al_lock_bitmap(player, al_get_bitmap_format(player), ALLEGRO_LOCK_READONLY); al_lock_bitmap(enemy, al_get_bitmap_format(enemy), ALLEGRO_LOCK_READONLY); ALLEGRO_COLOR color = al_get_pixel(player, j - x, i - y); ALLEGRO_COLOR color2 = al_get_pixel(enemy, j - ex, i - ey); // Si el color alpha del jugador es diferente de 0 y el color alpha del enemigo es diferente de 0, // y están en la misma posición, entonces detecta una colisión if(color.a != 0 && color2.a != 0) return true; } } // Pero de lo contrario, devuelve false return false; }
void m_draw_scaled_backbuffer(int sx, int sy, int sw, int sh, int dx, int dy, int dw, int dh, MBITMAP *dest) { ALLEGRO_BITMAP *old_target = al_get_target_bitmap(); int old_format = al_get_new_bitmap_format(); al_set_new_bitmap_format(al_get_bitmap_format(al_get_backbuffer(display))); MBITMAP *tmp = m_create_bitmap(sw, sh); int scr_w = al_get_display_width(display); int scr_h = al_get_display_height(display); if (sx+sw > scr_w) { sw = scr_w-sx; } else if (sx < 0) { sw -= sx; sx = 0; } if (sy+sh > scr_h) { sh = scr_h-sy; } else if (sy < 0) { sh -= sy; sy = 0; } #if defined ALLEGRO_RASPBERRYPI || defined ALLEGRO_IPHONE || defined ALLEGRO_ANDROID ALLEGRO_LOCKED_REGION *lr1 = al_lock_bitmap(tmp->bitmap, ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_WRITEONLY); ALLEGRO_LOCKED_REGION *lr2 = al_lock_bitmap_region( al_get_backbuffer(display), sx, sy, sw, sh, ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_READONLY ); int pixel_size = al_get_pixel_size(al_get_bitmap_format(al_get_backbuffer(display))); for (int y = 0; y < sh; y++) { uint8_t *d1 = (uint8_t *)lr1->data + lr1->pitch * y; uint8_t *d2 = (uint8_t *)lr2->data + lr2->pitch * y; memcpy(d1, d2, pixel_size*sw); } al_unlock_bitmap(tmp->bitmap); al_unlock_bitmap(al_get_backbuffer(display)); #else m_set_target_bitmap(tmp); al_draw_bitmap_region(al_get_backbuffer(display), sx, sy, sw, sh, 0, 0, 0); #endif m_set_target_bitmap(dest); al_draw_scaled_bitmap( tmp->bitmap, 0, 0, sw, sh, dx, dy, dw, dh, 0 ); m_destroy_bitmap(tmp); al_set_target_bitmap(old_target); al_set_new_bitmap_format(old_format); }
static bool transfer_bitmap_data(ALLEGRO_BITMAP *src, ALLEGRO_BITMAP *dst) { ALLEGRO_LOCKED_REGION *dst_region; ALLEGRO_LOCKED_REGION *src_region; int src_format = al_get_bitmap_format(src); int dst_format = al_get_bitmap_format(dst); bool src_compressed = _al_pixel_format_is_compressed(src_format); bool dst_compressed = _al_pixel_format_is_compressed(dst_format); int copy_w = src->w; int copy_h = src->h; if (src_compressed && dst_compressed && src_format == dst_format) { int block_width = al_get_pixel_block_width(src_format); int block_height = al_get_pixel_block_height(src_format); if (!(src_region = al_lock_bitmap_blocked(src, ALLEGRO_LOCK_READONLY))) return false; if (!(dst_region = al_lock_bitmap_blocked(dst, ALLEGRO_LOCK_WRITEONLY))) { al_unlock_bitmap(src); return false; } copy_w = _al_get_least_multiple(copy_w, block_width); copy_h = _al_get_least_multiple(copy_h, block_height); ALLEGRO_DEBUG("Taking fast clone path.\n"); } else { int lock_format = ALLEGRO_PIXEL_FORMAT_ANY; /* Go through a non-compressed intermediate */ if (src_compressed && !dst_compressed) { lock_format = dst_format; } else if (!src_compressed && dst_compressed) { lock_format = src_format; } if (!(src_region = al_lock_bitmap(src, lock_format, ALLEGRO_LOCK_READONLY))) return false; if (!(dst_region = al_lock_bitmap(dst, lock_format, ALLEGRO_LOCK_WRITEONLY))) { al_unlock_bitmap(src); return false; } } _al_convert_bitmap_data( src_region->data, src_region->format, src_region->pitch, dst_region->data, dst_region->format, dst_region->pitch, 0, 0, 0, 0, copy_w, copy_h); al_unlock_bitmap(src); al_unlock_bitmap(dst); return true; }
static void _bitmap_drawer(ALLEGRO_BITMAP *bitmap, ALLEGRO_COLOR tint, float sx, float sy, float sw, float sh, int flags) { ALLEGRO_BITMAP *dest = al_get_target_bitmap(); ALLEGRO_DISPLAY *display = _al_get_bitmap_display(dest); ASSERT(bitmap->parent == NULL); ASSERT(!(flags & (ALLEGRO_FLIP_HORIZONTAL | ALLEGRO_FLIP_VERTICAL))); ASSERT(bitmap != dest && bitmap != dest->parent); /* If destination is memory, do a memory blit */ if (al_get_bitmap_flags(dest) & ALLEGRO_MEMORY_BITMAP || _al_pixel_format_is_compressed(al_get_bitmap_format(dest))) { _al_draw_bitmap_region_memory(bitmap, tint, sx, sy, sw, sh, 0, 0, flags); } else { /* if source is memory or incompatible */ if ((al_get_bitmap_flags(bitmap) & ALLEGRO_MEMORY_BITMAP) || (!al_is_compatible_bitmap(bitmap))) { if (display && display->vt->draw_memory_bitmap_region) { display->vt->draw_memory_bitmap_region(display, bitmap, sx, sy, sw, sh, flags); } else { _al_draw_bitmap_region_memory(bitmap, tint, sx, sy, sw, sh, 0, 0, flags); } } else { /* Compatible display bitmap, use full acceleration */ bitmap->vt->draw_bitmap_region(bitmap, tint, sx, sy, sw, sh, flags); } } }
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; }
static void _al_draw_bitmap_region_memory_fast(ALLEGRO_BITMAP *bitmap, int sx, int sy, int sw, int sh, int dx, int dy, int flags) { ALLEGRO_LOCKED_REGION *src_region; ALLEGRO_LOCKED_REGION *dst_region; ALLEGRO_BITMAP *dest = al_get_target_bitmap(); int dw = sw, dh = sh; ASSERT(_al_pixel_format_is_real(al_get_bitmap_format(bitmap))); ASSERT(_al_pixel_format_is_real(al_get_bitmap_format(dest))); ASSERT(bitmap->parent == NULL); /* Currently the only flags are for flipping, which is handled as negative * scaling. */ ASSERT(flags == 0); (void)flags; CLIPPER(bitmap, sx, sy, sw, sh, dest, dx, dy, dw, dh, 1, 1, flags) if (!(src_region = al_lock_bitmap_region(bitmap, sx, sy, sw, sh, ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_READONLY))) { return; } if (!(dst_region = al_lock_bitmap_region(dest, dx, dy, sw, sh, ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_WRITEONLY))) { al_unlock_bitmap(bitmap); return; } /* will detect if no conversion is needed */ _al_convert_bitmap_data( src_region->data, src_region->format, src_region->pitch, dst_region->data, dst_region->format, dst_region->pitch, 0, 0, 0, 0, sw, sh); al_unlock_bitmap(bitmap); al_unlock_bitmap(dest); }
const char *get_format_name(ALLEGRO_BITMAP *bmp) { if (!bmp) return "none"; int format = al_get_bitmap_format(bmp); for (unsigned i = 0; i < NUM_FORMATS; i++) { if (formats[i].format == format) return formats[i].name; } return "unknown"; }
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; }
static void use_fbo_for_bitmap(ALLEGRO_DISPLAY *display, ALLEGRO_BITMAP *bitmap, ALLEGRO_FBO_INFO *info) { ALLEGRO_BITMAP_EXTRA_OPENGL *ogl_bitmap = bitmap->extra; GLint e; if (info->fbo_state == FBO_INFO_UNUSED) info->fbo_state = FBO_INFO_TRANSIENT; info->owner = bitmap; info->last_use_time = al_get_time(); ogl_bitmap->fbo_info = info; /* Bind to the FBO. */ _al_ogl_bind_framebuffer(info->fbo); /* Attach the texture. */ if (ANDROID_PROGRAMMABLE_PIPELINE(al_get_current_display())) { glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, ogl_bitmap->texture, 0); } else { glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, ogl_bitmap->texture, 0); } e = glGetError(); if (e) { ALLEGRO_DEBUG("glFrameBufferTexture2DEXT failed! fbo=%d texture=%d (%s)", info->fbo, ogl_bitmap->texture, _al_gl_error_string(e)); } /* See comment about unimplemented functions on Android above */ if (UNLESS_ANDROID_OR_RPI( glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) != GL_FRAMEBUFFER_COMPLETE_EXT)) { /* For some reason, we cannot use the FBO with this * texture. So no reason to keep re-trying, output a log * message and switch to (extremely slow) software mode. */ ALLEGRO_ERROR("Could not use FBO for bitmap with format %s.\n", _al_pixel_format_name(al_get_bitmap_format(bitmap))); ALLEGRO_ERROR("*** SWITCHING TO SOFTWARE MODE ***\n"); _al_ogl_bind_framebuffer(0); glDeleteFramebuffersEXT(1, &info->fbo); _al_ogl_reset_fbo_info(info); ogl_bitmap->fbo_info = NULL; } else { display->ogl_extras->opengl_target = bitmap; } }
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; }
void KinectPlayer::Render() { // if (!mPlayerPresent) { // return; // } std::vector<UserData> users; mUserTracking.GetUsers(users); if (users.empty()) { return; } al_set_target_bitmap(mBitmap); al_clear_to_color(al_map_rgb(0x00, 0x00, 0x00)); al_convert_mask_to_alpha(mBitmap, al_map_rgb(0x00, 0x00, 0x00)); xn::SceneMetaData scene_meta; mUserTracking.GetUserPixels(users[0], scene_meta); const XnRGB24Pixel* pRgbBuf = mKinect.GetImageData(); const XnLabel* pLabelBuf = scene_meta.Data(); ALLEGRO_LOCKED_REGION* lock = al_lock_bitmap(mBitmap, al_get_bitmap_format(mBitmap), ALLEGRO_LOCK_WRITEONLY); al_set_target_bitmap(mBitmap); for (int y = 0; y < mBitmapHeight; y++) { for (int x = 0; x < mBitmapWidth; x++, pLabelBuf++, pRgbBuf++) { if (*pLabelBuf == users[0].GetId()) { al_put_pixel(x, y, al_map_rgb(pRgbBuf->nRed, pRgbBuf->nGreen, pRgbBuf->nBlue)); } } } al_unlock_bitmap(mBitmap); const int screen_x_res = al_get_display_width(al_get_current_display()); const int screen_y_res = al_get_display_height(al_get_current_display()); al_set_target_bitmap(al_get_backbuffer(al_get_current_display())); al_draw_scaled_bitmap(mBitmap, 0, 0, mBitmapWidth, mBitmapHeight, GetXPos(), GetYPos(), GetWidth(), GetHeight(), 0); }
void redrawCells(ALLEGRO_BITMAP* pBuffer, bool** pCells, bool** pNextCells, short int iWidth, short int iHeight, ALLEGRO_COLOR oCellColor, ALLEGRO_COLOR oBackColor) { al_lock_bitmap(pBuffer, al_get_bitmap_format(pBuffer), ALLEGRO_LOCK_WRITEONLY); al_set_target_bitmap(pBuffer); for (short int i = 0; i < iWidth; i++) { for (short int j = 0; j < iHeight; j++) { if (pCells[i][j] == true) { al_put_pixel(i, j, oCellColor); } else { al_put_pixel(i, j, oBackColor); } } } al_unlock_bitmap(pBuffer); }
/* Function: al_clear_to_color */ void al_clear_to_color(ALLEGRO_COLOR color) { ALLEGRO_BITMAP *target = al_get_target_bitmap(); ASSERT(target); if (al_get_bitmap_flags(target) & ALLEGRO_MEMORY_BITMAP || _al_pixel_format_is_compressed(al_get_bitmap_format(target))) { _al_clear_bitmap_by_locking(target, &color); } else { ALLEGRO_DISPLAY *display = _al_get_bitmap_display(target); ASSERT(display); ASSERT(display->vt); display->vt->clear(display, &color); } }
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; }
/* Function: al_draw_pixel */ void al_draw_pixel(float x, float y, ALLEGRO_COLOR color) { ALLEGRO_BITMAP *target = al_get_target_bitmap(); ASSERT(target); if (al_get_bitmap_flags(target) & ALLEGRO_MEMORY_BITMAP || _al_pixel_format_is_compressed(al_get_bitmap_format(target))) { _al_draw_pixel_memory(target, x, y, &color); } else { ALLEGRO_DISPLAY *display = _al_get_bitmap_display(target); ASSERT(display); ASSERT(display->vt); display->vt->draw_pixel(display, x, y, &color); } }
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; }
MBITMAP *m_load_bitmap_redraw(const char *name, void (*redraw)(MBITMAP *bmp, RecreateData *data), RecreateData *data, bool delayed) { ALLEGRO_BITMAP *bitmap = 0; bitmap = my_load_bitmap(name); if (!bitmap) { debug_message("Error loading bitmap %s\n", name); return NULL; } MBITMAP *m = new_mbitmap(bitmap); if (redraw) { redraw(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_LOAD; lb->flags = al_get_bitmap_flags(bitmap); lb->format = al_get_bitmap_format(bitmap); lb->load.filename = name; lb->load.redraw = redraw; lb->load.data = data; lb->bitmap = m; lb->delayed = delayed; loaded_bitmaps.push_back(lb); } #endif return m; }
static void draw(void) { float x, y; int cx, cy, cw, ch; int w = al_get_bitmap_width(ex.zoom); int h = al_get_bitmap_height(ex.zoom); ALLEGRO_BITMAP *screen = al_get_target_bitmap(); ALLEGRO_BITMAP *mem; int rects_num = 16, i, j; float rects[16 * 4]; for (j = 0; j < 4; j++) { for (i = 0; i < 4; i++) { rects[(j * 4 + i) * 4 + 0] = 2 + i * 0.25 + i * 7; rects[(j * 4 + i) * 4 + 1] = 2 + j * 0.25 + j * 7; rects[(j * 4 + i) * 4 + 2] = 2 + i * 0.25 + i * 7 + 5; rects[(j * 4 + i) * 4 + 3] = 2 + j * 0.25 + j * 7 + 5; } } al_get_clipping_rectangle(&cx, &cy, &cw, &ch); al_clear_to_color(ex.background); set_xy(8, 0); print("Drawing %s (press SPACE to change)", names[ex.what]); set_xy(8, 16); print("Original"); set_xy(80, 16); print("Enlarged x 16"); al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO); if (ex.software) { al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP); al_set_new_bitmap_format(al_get_bitmap_format(al_get_target_bitmap())); mem = al_create_bitmap(w, h); al_set_target_bitmap(mem); x = 0; y = 0; } else { mem = NULL; x = 8; y = 40; } al_draw_bitmap(ex.pattern, x, y, 0); /* Draw the test scene. */ al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA); for (i = 0; i < rects_num; i++) { ALLEGRO_COLOR rgba = ex.foreground; rgba.a *= 0.5; primitive( x + rects[i * 4 + 0], y + rects[i * 4 + 1], x + rects[i * 4 + 2], y + rects[i * 4 + 3], rgba, false); } al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO); if (ex.software) { al_set_target_bitmap(screen); x = 8; y = 40; al_draw_bitmap(mem, x, y, 0); al_destroy_bitmap(mem); } /* Grab screen contents into our bitmap. */ al_set_target_bitmap(ex.zoom); al_draw_bitmap_region(screen, x, y, w, h, 0, 0, 0); al_set_target_bitmap(screen); /* Draw it enlarged. */ x = 80; y = 40; al_draw_scaled_bitmap(ex.zoom, 0, 0, w, h, x, y, w * 16, h * 16, 0); /* Draw outlines. */ for (i = 0; i < rects_num; i++) { primitive( x + rects[i * 4 + 0] * 16, y + rects[i * 4 + 1] * 16, x + rects[i * 4 + 2] * 16, y + rects[i * 4 + 3] * 16, ex.outline, true); } set_xy(8, 640 - 48); print("Thickness: %d (press T to change)", ex.thickness); print("Drawing with: %s (press S to change)", ex.software ? "software" : "hardware"); print("Supersampling: %dx (edit ex_draw.ini to change)", ex.samples); // FIXME: doesn't work // al_get_display_option(ALLEGRO_SAMPLE_BUFFERS)); }
static int allua_Bitmap_get_format(lua_State * L) { ALLUA_bitmap bitmap = allua_check_bitmap(L, 1); lua_pushinteger(L, al_get_bitmap_format(bitmap)); return 1; }
void m_flip_display(void) { bool skip_flip = false; if (prompt_for_close_on_next_flip) { prompt_for_close_on_next_flip = false; prepareForScreenGrab2(); bool hidden = is_cursor_hidden(); show_mouse_cursor(); int r = triple_prompt("", "Really quit game or return to menu?", "", "Menu", "Quit", "Cancel", 2, true); if (hidden) { hide_mouse_cursor(); } if (r == 0) { break_main_loop = true; } else if (r == 1) { do_close_exit_game(); } skip_flip = true; } else if (show_item_info_on_flip >= 0) { int tmp = show_item_info_on_flip; show_item_info_on_flip = -1; prepareForScreenGrab2(); showItemInfo(tmp, true); skip_flip = true; } else if (show_player_info_on_flip) { show_player_info_on_flip = false; prepareForScreenGrab2(); if (player_to_show_on_flip) { showPlayerInfo_ptr(player_to_show_on_flip); player_to_show_on_flip = NULL; } else { showPlayerInfo_number(player_number_to_show_on_flip); } skip_flip = true; } else if (close_pressed_for_configure) { close_pressed_for_configure = false; int _dx, _dy, _dw, _dh; get_screen_offset_size(&_dx, &_dy, &_dw, &_dh); ALLEGRO_STATE state; al_store_state(&state, ALLEGRO_STATE_TARGET_BITMAP | ALLEGRO_STATE_NEW_BITMAP_PARAMETERS); al_set_new_bitmap_format(al_get_bitmap_format(tmpbuffer->bitmap)); al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP); ALLEGRO_BITMAP *tmp = al_create_bitmap( al_get_bitmap_width(tmpbuffer->bitmap), al_get_bitmap_height(tmpbuffer->bitmap) ); al_set_target_bitmap(tmp); al_clear_to_color(black); al_draw_bitmap(tmpbuffer->bitmap, 0, 0, 0); al_restore_state(&state); config_menu(); int __dx, __dy, __dw, __dh; get_screen_offset_size(&__dx, &__dy, &__dw, &__dh); al_store_state(&state, ALLEGRO_STATE_TARGET_BITMAP); al_set_target_bitmap(tmpbuffer->bitmap); al_clear_to_color(black); al_draw_scaled_bitmap( tmp, _dx, _dy, _dw, _dh, __dx, __dy, __dw, __dh, 0 ); al_restore_state(&state); al_destroy_bitmap(tmp); } if (!skip_flip) { al_flip_display(); } int xxx, yyy, www, hhh; al_get_clipping_rectangle(&xxx, &yyy, &www, &hhh); al_set_clipping_rectangle( 0, 0, al_get_display_width(display), al_get_display_height(display) ); m_clear(black); al_set_clipping_rectangle(xxx, yyy, www, hhh); fps_frames++; double elapsed = al_get_time() - fps_counter; if (fps_on && elapsed > 2) { fps = (int)(round((float)fps_frames/elapsed)); fps_counter = al_get_time(); fps_frames = 0; } }
static void _al_draw_transformed_bitmap_memory(ALLEGRO_BITMAP *src, ALLEGRO_COLOR tint, int sx, int sy, int sw, int sh, int dw, int dh, ALLEGRO_TRANSFORM* local_trans, int flags) { float xsf[4], ysf[4]; int tl = 0, tr = 1, bl = 3, br = 2; int tmp; ALLEGRO_VERTEX v[4]; ASSERT(_al_pixel_format_is_real(al_get_bitmap_format(src))); /* Decide what order to take corners in. */ if (flags & ALLEGRO_FLIP_VERTICAL) { tl = 3; tr = 2; bl = 0; br = 1; } else { tl = 0; tr = 1; bl = 3; br = 2; } if (flags & ALLEGRO_FLIP_HORIZONTAL) { tmp = tl; tl = tr; tr = tmp; tmp = bl; bl = br; br = tmp; } xsf[0] = 0; ysf[0] = 0; xsf[1] = dw; ysf[1] = 0; xsf[2] = 0; ysf[2] = dh; al_transform_coordinates(local_trans, &xsf[0], &ysf[0]); al_transform_coordinates(local_trans, &xsf[1], &ysf[1]); al_transform_coordinates(local_trans, &xsf[2], &ysf[2]); v[tl].x = xsf[0]; v[tl].y = ysf[0]; v[tl].z = 0; v[tl].u = sx; v[tl].v = sy; v[tl].color = tint; v[tr].x = xsf[1]; v[tr].y = ysf[1]; v[tr].z = 0; v[tr].u = sx + sw; v[tr].v = sy; v[tr].color = tint; v[br].x = xsf[2] + xsf[1] - xsf[0]; v[br].y = ysf[2] + ysf[1] - ysf[0]; v[br].z = 0; v[br].u = sx + sw; v[br].v = sy + sh; v[br].color = tint; v[bl].x = xsf[2]; v[bl].y = ysf[2]; v[bl].z = 0; v[bl].u = sx; v[bl].v = sy + sh; v[bl].color = tint; al_lock_bitmap(src, ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_READONLY); _al_triangle_2d(src, &v[tl], &v[tr], &v[br]); _al_triangle_2d(src, &v[tl], &v[br], &v[bl]); al_unlock_bitmap(src); }
ALLEGRO_LOCKED_REGION *_al_ogl_lock_region_new(ALLEGRO_BITMAP *bitmap, int x, int y, int w, int h, int format, int flags) { ALLEGRO_BITMAP_EXTRA_OPENGL * const ogl_bitmap = bitmap->extra; const GLint gl_y = bitmap->h - y - h; ALLEGRO_DISPLAY *disp; ALLEGRO_DISPLAY *old_disp = NULL; ALLEGRO_BITMAP *old_target = al_get_target_bitmap(); GLenum e; bool ok; bool restore_fbo = false; if (format == ALLEGRO_PIXEL_FORMAT_ANY) { /* Never pick compressed formats with ANY, as it interacts weirdly with * existing code (e.g. al_get_pixel_size() etc) */ int bitmap_format = al_get_bitmap_format(bitmap); if (_al_pixel_format_is_compressed(bitmap_format)) { // XXX Get a good format from the driver? format = ALLEGRO_PIXEL_FORMAT_ABGR_8888_LE; } else { format = bitmap_format; } } disp = al_get_current_display(); format = _al_get_real_pixel_format(disp, format); /* Change OpenGL context if necessary. */ if (!disp || (_al_get_bitmap_display(bitmap)->ogl_extras->is_shared == false && _al_get_bitmap_display(bitmap) != disp)) { old_disp = disp; _al_set_current_display_only(_al_get_bitmap_display(bitmap)); } ok = true; /* Set up the pixel store state. We will need to match it when unlocking. * There may be other pixel store state we should be setting. * See also pitfalls 7 & 8 from: * http://www.opengl.org/resources/features/KilgardTechniques/oglpitfall/ */ glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT); { const int pixel_size = al_get_pixel_size(format); const int pixel_alignment = ogl_pixel_alignment(pixel_size); glPixelStorei(GL_PACK_ALIGNMENT, pixel_alignment); e = glGetError(); if (e) { ALLEGRO_ERROR("glPixelStorei(GL_PACK_ALIGNMENT, %d) failed (%s).\n", pixel_alignment, _al_gl_error_string(e)); ok = false; } } if (ok) { if (ogl_bitmap->is_backbuffer) { ALLEGRO_DEBUG("Locking backbuffer\n"); ok = ogl_lock_region_backbuffer(bitmap, ogl_bitmap, x, gl_y, w, h, format, flags); } else if (flags & ALLEGRO_LOCK_WRITEONLY) { ALLEGRO_DEBUG("Locking non-backbuffer WRITEONLY\n"); ok = ogl_lock_region_nonbb_writeonly(bitmap, ogl_bitmap, x, gl_y, w, h, format); } else { ALLEGRO_DEBUG("Locking non-backbuffer READWRITE\n"); ok = ogl_lock_region_nonbb_readwrite(bitmap, ogl_bitmap, x, gl_y, w, h, format, &restore_fbo); } } glPopClientAttrib(); /* Restore state after switching FBO. */ if (restore_fbo) { if (!old_target) { /* Old target was NULL; release the context. */ _al_set_current_display_only(NULL); } else if (!_al_get_bitmap_display(old_target)) { /* Old target was memory bitmap; leave the current display alone. */ } else if (old_target != bitmap) { /* Old target was another OpenGL bitmap. */ _al_ogl_setup_fbo(_al_get_bitmap_display(old_target), old_target); } } ASSERT(al_get_target_bitmap() == old_target); if (old_disp != NULL) { _al_set_current_display_only(old_disp); } if (ok) { return &bitmap->locked_region; } ALLEGRO_ERROR("Failed to lock region\n"); ASSERT(ogl_bitmap->lock_buffer == NULL); return NULL; }
/** Returns the bitmap's format. @return the bitmap's format. */ int getFormat() const { return al_get_bitmap_format(get()); }