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