static int mallegro_Poll(void)
{
#if _ANDROID_
if(al_is_bitmap_locked(scrmem)){
al_unlock_bitmap(scrmem);
al_set_target_bitmap(al_get_backbuffer(display));
//al_draw_bitmap(scrmem, 0, 0, 0);
al_draw_scaled_rotated_bitmap(scrmem, 0, 0, 0, 0, zoomfactor, zoomfactor, 0, 0);
//al_draw_scaled_rotated_bitmap(scrmem, 0, al_get_bitmap_height(al_get_backbuffer(display)), 0, 0, 2, 2, ALLEGRO_PI/2, 0);
//al_draw_scaled_rotated_bitmap(scrmem, 0, 500, 0, 0, 3, 3, ALLEGRO_PI/2, 0); //would have to recalculate mouse
al_flip_display();
}
#else
if(al_is_bitmap_locked(display_bitmap)) {
al_unlock_bitmap(display_bitmap);
al_flip_display();
}
#endif
if (!al_is_mouse_installed()) return 0;
if (al_peek_next_event(a_event_queue_m, &a_event)) return 1; //read event in read function
return 0;
}
static mrb_value
bitmap_locked(mrb_state *mrb, mrb_value self)
{
ALLEGRO_BITMAP *b;
Check_Destroyed(mrb, self, bitmap, b);
return mrb_bool_value(al_is_bitmap_locked(b));
}
ALLEGRO_MOUSE_CURSOR *_al_xwin_create_mouse_cursor(ALLEGRO_BITMAP *bmp,
int x_focus, int y_focus)
{
ALLEGRO_SYSTEM_XGLX *system = (ALLEGRO_SYSTEM_XGLX *)al_get_system_driver();
Display *xdisplay = system->x11display;
int bmp_w;
int bmp_h;
ALLEGRO_MOUSE_CURSOR_XGLX *xcursor;
XcursorImage *image;
int c, ix, iy;
bool was_locked;
bmp_w = al_get_bitmap_width(bmp);
bmp_h = al_get_bitmap_height(bmp);
xcursor = al_malloc(sizeof *xcursor);
if (!xcursor) {
return NULL;
}
image = XcursorImageCreate(bmp->w, bmp->h);
if (image == None) {
al_free(xcursor);
return NULL;
}
was_locked = al_is_bitmap_locked(bmp);
if (!was_locked) {
al_lock_bitmap(bmp, ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_READONLY);
}
c = 0;
for (iy = 0; iy < bmp_h; iy++) {
for (ix = 0; ix < bmp_w; ix++) {
ALLEGRO_COLOR col;
unsigned char r, g, b, a;
col = al_get_pixel(bmp, ix, iy);
al_unmap_rgba(col, &r, &g, &b, &a);
image->pixels[c++] = (a<<24) | (r<<16) | (g<<8) | (b);
}
}
if (!was_locked) {
al_unlock_bitmap(bmp);
}
image->xhot = x_focus;
image->yhot = y_focus;
_al_mutex_lock(&system->lock);
xcursor->cursor = XcursorImageLoadCursor(xdisplay, image);
_al_mutex_unlock(&system->lock);
XcursorImageDestroy(image);
return (ALLEGRO_MOUSE_CURSOR *)xcursor;
}
static void unlock_current_page(ALLEGRO_TTF_FONT_DATA *data)
{
if (data->page_lr) {
ALLEGRO_BITMAP **back = _al_vector_ref_back(&data->page_bitmaps);
ASSERT(al_is_bitmap_locked(*back));
al_unlock_bitmap(*back);
data->page_lr = NULL;
}
}
static int bitmap_region_is_locked(ALLEGRO_BITMAP* bmp, int x1, int y1, int w, int h)
{
ASSERT(bmp);
if (!al_is_bitmap_locked(bmp))
return 0;
if (x1 + w > bmp->lock_x && y1 + h > bmp->lock_y && x1 < bmp->lock_x + bmp->lock_w && y1 < bmp->lock_y + bmp->lock_h)
return 1;
return 0;
}
static void save_jpg_entry_helper(ALLEGRO_FILE *fp, ALLEGRO_BITMAP *bmp,
struct save_jpg_entry_helper_data *data)
{
struct jpeg_compress_struct cinfo;
struct my_err_mgr jerr;
ALLEGRO_LOCKED_REGION *lock;
data->error = false;
cinfo.err = jpeg_std_error(&jerr.pub);
jerr.pub.error_exit = my_error_exit;
if (setjmp(jerr.jmpenv)) {
/* Longjmp'd. */
data->error = true;
goto longjmp_error;
}
data->buffer = _AL_MALLOC(BUFFER_SIZE);
if (!data->buffer) {
data->error = true;
goto error;
}
jpeg_create_compress(&cinfo);
jpeg_packfile_dest(&cinfo, fp, data->buffer);
cinfo.image_width = al_get_bitmap_width(bmp);
cinfo.image_height = al_get_bitmap_height(bmp);
cinfo.input_components = 3;
cinfo.in_color_space = JCS_RGB;
jpeg_set_defaults(&cinfo);
jpeg_start_compress(&cinfo, 1);
/* See comment in load_jpg_entry_helper. */
#ifdef ALLEGRO_BIG_ENDIAN
lock = al_lock_bitmap(bmp, ALLEGRO_PIXEL_FORMAT_RGB_888,
ALLEGRO_LOCK_READONLY);
#else
lock = al_lock_bitmap(bmp, ALLEGRO_PIXEL_FORMAT_BGR_888,
ALLEGRO_LOCK_READONLY);
#endif
al_set_target_bitmap(bmp);
while (cinfo.next_scanline < cinfo.image_height) {
unsigned char *row[1];
row[0] = ((unsigned char *)lock->data)
+ cinfo.next_scanline * lock->pitch;
jpeg_write_scanlines(&cinfo, (void *)row, 1);
}
error:
jpeg_finish_compress(&cinfo);
longjmp_error:
jpeg_destroy_compress(&cinfo);
if (al_is_bitmap_locked(bmp)) {
al_unlock_bitmap(bmp);
}
_AL_FREE(data->buffer);
}
static void load_jpg_entry_helper(ALLEGRO_FILE *fp,
struct load_jpg_entry_helper_data *data)
{
struct jpeg_decompress_struct cinfo;
struct my_err_mgr jerr;
ALLEGRO_LOCKED_REGION *lock;
int w, h, s;
data->error = false;
cinfo.err = jpeg_std_error(&jerr.pub);
jerr.pub.error_exit = my_error_exit;
if (setjmp(jerr.jmpenv) != 0) {
/* Longjmp'd. */
data->error = true;
goto longjmp_error;
}
data->buffer = _AL_MALLOC(BUFFER_SIZE);
if (!data->buffer) {
data->error = true;
goto error;
}
jpeg_create_decompress(&cinfo);
jpeg_packfile_src(&cinfo, fp, data->buffer);
jpeg_read_header(&cinfo, true);
jpeg_start_decompress(&cinfo);
w = cinfo.output_width;
h = cinfo.output_height;
s = cinfo.output_components;
/* Only one and three components make sense in a JPG file. */
if (s != 1 && s != 3) {
data->error = true;
goto error;
}
data->bmp = al_create_bitmap(w, h);
if (!data->bmp) {
data->error = true;
goto error;
}
/* Allegro's pixel format is endian independent, so that in
* ALLEGRO_PIXEL_FORMAT_RGB_888 the lower 8 bits always hold the Blue
* component. On a little endian system this is in byte 0. On a big
* endian system this is in byte 2.
*
* libjpeg expects byte 0 to hold the Red component, byte 1 to hold the
* Green component, byte 2 to hold the Blue component. Hence on little
* endian systems we need the opposite format, ALLEGRO_PIXEL_FORMAT_BGR_888.
*/
#ifdef ALLEGRO_BIG_ENDIAN
lock = al_lock_bitmap(data->bmp, ALLEGRO_PIXEL_FORMAT_RGB_888,
ALLEGRO_LOCK_WRITEONLY);
#else
lock = al_lock_bitmap(data->bmp, ALLEGRO_PIXEL_FORMAT_BGR_888,
ALLEGRO_LOCK_WRITEONLY);
#endif
al_set_target_bitmap(data->bmp);
if (s == 3) {
/* Colour. */
int y;
for (y = cinfo.output_scanline; y < h; y = cinfo.output_scanline) {
unsigned char *out[1];
out[0] = ((unsigned char *)lock->data) + y * lock->pitch;
jpeg_read_scanlines(&cinfo, (void *)out, 1);
}
}
else if (s == 1) {
/* Greyscale. */
unsigned char *in;
unsigned char *out;
int x, y;
data->row = _AL_MALLOC(w);
for (y = cinfo.output_scanline; y < h; y = cinfo.output_scanline) {
jpeg_read_scanlines(&cinfo, (void *)&data->row, 1);
in = data->row;
out = ((unsigned char *)lock->data) + y * lock->pitch;
for (x = 0; x < w; x++) {
*out++ = *in;
*out++ = *in;
*out++ = *in;
in++;
}
}
}
error:
jpeg_finish_decompress(&cinfo);
longjmp_error:
jpeg_destroy_decompress(&cinfo);
if (data->bmp) {
if (al_is_bitmap_locked(data->bmp)) {
al_unlock_bitmap(data->bmp);
}
if (data->error) {
al_destroy_bitmap(data->bmp);
data->bmp = NULL;
}
}
_AL_FREE(data->buffer);
_AL_FREE(data->row);
}
static int allua_Bitmap_is_locked(lua_State * L)
{
ALLUA_bitmap bitmap = allua_check_bitmap(L, 1);
lua_pushboolean(L, al_is_bitmap_locked(bitmap));
return 1;
}
void _al_draw_soft_triangle(
ALLEGRO_VERTEX* v1, ALLEGRO_VERTEX* v2, ALLEGRO_VERTEX* v3, uintptr_t state,
void (*init)(uintptr_t, ALLEGRO_VERTEX*, ALLEGRO_VERTEX*, ALLEGRO_VERTEX*),
void (*first)(uintptr_t, int, int, int, int),
void (*step)(uintptr_t, int),
void (*draw)(uintptr_t, int, int, int))
{
/*
ALLEGRO_VERTEX copy_v1, copy_v2; <- may be needed for clipping later on
*/
ALLEGRO_VERTEX* vtx1 = v1;
ALLEGRO_VERTEX* vtx2 = v2;
ALLEGRO_VERTEX* vtx3 = v3;
ALLEGRO_BITMAP *target = al_get_target_bitmap();
int need_unlock = 0;
ALLEGRO_LOCKED_REGION *lr;
int min_x, max_x, min_y, max_y;
int clip_min_x, clip_min_y, clip_max_x, clip_max_y;
al_get_clipping_rectangle(&clip_min_x, &clip_min_y, &clip_max_x, &clip_max_y);
clip_max_x += clip_min_x;
clip_max_y += clip_min_y;
/*
TODO: Need to clip them first, make a copy of the vertices first then
*/
/*
Lock the region we are drawing to. We are choosing the minimum and maximum
possible pixels touched from the formula (easily verified by following the
above algorithm.
*/
min_x = (int)floorf(MIN(vtx1->x, MIN(vtx2->x, vtx3->x))) - 1;
min_y = (int)floorf(MIN(vtx1->y, MIN(vtx2->y, vtx3->y))) - 1;
max_x = (int)ceilf(MAX(vtx1->x, MAX(vtx2->x, vtx3->x))) + 1;
max_y = (int)ceilf(MAX(vtx1->y, MAX(vtx2->y, vtx3->y))) + 1;
/*
TODO: This bit is temporary, the min max's will be guaranteed to be within the bitmap
once clipping is implemented
*/
if (min_x >= clip_max_x || min_y >= clip_max_y)
return;
if (max_x >= clip_max_x)
max_x = clip_max_x;
if (max_y >= clip_max_y)
max_y = clip_max_y;
if (max_x < clip_min_x || max_y < clip_min_y)
return;
if (min_x < clip_min_x)
min_x = clip_min_x;
if (min_y < clip_min_y)
min_y = clip_min_y;
if (al_is_bitmap_locked(target)) {
if (!bitmap_region_is_locked(target, min_x, min_y, max_x - min_x, max_y - min_y))
return;
} else {
if (!(lr = al_lock_bitmap_region(target, min_x, min_y, max_x - min_x, max_y - min_y, ALLEGRO_PIXEL_FORMAT_ANY, 0)))
return;
need_unlock = 1;
}
triangle_stepper(state, init, first, step, draw, v1, v2, v3);
if (need_unlock)
al_unlock_bitmap(target);
}
int _al_draw_prim_indexed_opengl(ALLEGRO_BITMAP *target, ALLEGRO_BITMAP* texture, const void* vtxs, const ALLEGRO_VERTEX_DECL* decl, const int* indices, int num_vtx, int type)
{
#ifdef ALLEGRO_CFG_OPENGL
int num_primitives = 0;
ALLEGRO_DISPLAY *ogl_disp = target->display;
ALLEGRO_BITMAP_OGL *ogl_target = (ALLEGRO_BITMAP_OGL *)target;
const void* vtx;
const void* idx = indices;
GLenum idx_size;
#if defined ALLEGRO_GP2XWIZ || defined ALLEGRO_IPHONE
GLushort ind[num_vtx];
int ii;
#endif
if (target->parent) {
ogl_target = (ALLEGRO_BITMAP_OGL *)target->parent;
}
if ((!ogl_target->is_backbuffer && ogl_disp->ogl_extras->opengl_target != ogl_target) || al_is_bitmap_locked(target)) {
return _al_draw_prim_indexed_soft(texture, decl, vtxs, indices, num_vtx, type);
}
vtx = vtxs;
_al_opengl_set_blender(ogl_disp);
setup_state(vtx, decl, texture);
if(texture) {
glEnable(GL_TEXTURE_2D);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
}
#if defined ALLEGRO_GP2XWIZ || defined ALLEGRO_IPHONE
for (ii = 0; ii < num_vtx; ii++) {
ind[ii] = (GLushort)indices[ii];
}
idx = ind;
idx_size = GL_UNSIGNED_SHORT;
#else
idx_size = GL_UNSIGNED_INT;
#endif
switch (type) {
case ALLEGRO_PRIM_LINE_LIST: {
glDrawElements(GL_LINES, num_vtx, idx_size, idx);
num_primitives = num_vtx / 2;
break;
};
case ALLEGRO_PRIM_LINE_STRIP: {
glDrawElements(GL_LINE_STRIP, num_vtx, idx_size, idx);
num_primitives = num_vtx - 1;
break;
};
case ALLEGRO_PRIM_LINE_LOOP: {
glDrawElements(GL_LINE_LOOP, num_vtx, idx_size, idx);
num_primitives = num_vtx;
break;
};
case ALLEGRO_PRIM_TRIANGLE_LIST: {
glDrawElements(GL_TRIANGLES, num_vtx, idx_size, idx);
num_primitives = num_vtx / 3;
break;
};
case ALLEGRO_PRIM_TRIANGLE_STRIP: {
glDrawElements(GL_TRIANGLE_STRIP, num_vtx, idx_size, idx);
num_primitives = num_vtx - 2;
break;
};
case ALLEGRO_PRIM_TRIANGLE_FAN: {
glDrawElements(GL_TRIANGLE_FAN, num_vtx, idx_size, idx);
num_primitives = num_vtx - 2;
break;
};
case ALLEGRO_PRIM_POINT_LIST: {
glDrawElements(GL_POINTS, num_vtx, idx_size, idx);
num_primitives = num_vtx;
break;
};
}
if(texture) {
glDisable(GL_TEXTURE_2D);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
}
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
return num_primitives;
#else
(void)target;
(void)texture;
(void)vtxs;
(void)decl;
(void)indices;
(void)num_vtx;
(void)type;
return 0;
#endif
}
int _al_draw_prim_opengl(ALLEGRO_BITMAP* target, ALLEGRO_BITMAP* texture, const void* vtxs, const ALLEGRO_VERTEX_DECL* decl, int start, int end, int type)
{
#ifdef ALLEGRO_CFG_OPENGL
int num_primitives = 0;
ALLEGRO_DISPLAY *ogl_disp = target->display;
ALLEGRO_BITMAP_OGL *ogl_target = (ALLEGRO_BITMAP_OGL *)target;
const void* vtx;
int stride = decl ? decl->stride : (int)sizeof(ALLEGRO_VERTEX);
int num_vtx;
if (target->parent) {
ogl_target = (ALLEGRO_BITMAP_OGL *)target->parent;
}
if ((!ogl_target->is_backbuffer && ogl_disp->ogl_extras->opengl_target != ogl_target) || al_is_bitmap_locked(target)) {
return _al_draw_prim_soft(texture, vtxs, decl, start, end, type);
}
vtx = (const char*)vtxs + start * stride;
num_vtx = end - start;
_al_opengl_set_blender(ogl_disp);
setup_state(vtx, decl, texture);
if(texture) {
glEnable(GL_TEXTURE_2D);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
}
switch (type) {
case ALLEGRO_PRIM_LINE_LIST: {
glDrawArrays(GL_LINES, 0, num_vtx);
num_primitives = num_vtx / 2;
break;
};
case ALLEGRO_PRIM_LINE_STRIP: {
glDrawArrays(GL_LINE_STRIP, 0, num_vtx);
num_primitives = num_vtx - 1;
break;
};
case ALLEGRO_PRIM_LINE_LOOP: {
glDrawArrays(GL_LINE_LOOP, 0, num_vtx);
num_primitives = num_vtx;
break;
};
case ALLEGRO_PRIM_TRIANGLE_LIST: {
glDrawArrays(GL_TRIANGLES, 0, num_vtx);
num_primitives = num_vtx / 3;
break;
};
case ALLEGRO_PRIM_TRIANGLE_STRIP: {
glDrawArrays(GL_TRIANGLE_STRIP, 0, num_vtx);
num_primitives = num_vtx - 2;
break;
};
case ALLEGRO_PRIM_TRIANGLE_FAN: {
glDrawArrays(GL_TRIANGLE_FAN, 0, num_vtx);
num_primitives = num_vtx - 2;
break;
};
case ALLEGRO_PRIM_POINT_LIST: {
glDrawArrays(GL_POINTS, 0, num_vtx);
num_primitives = num_vtx;
break;
};
}
if(texture) {
glDisable(GL_TEXTURE_2D);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
}
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
return num_primitives;
#else
(void)target;
(void)texture;
(void)vtxs;
(void)decl;
(void)start;
(void)end;
(void)type;
return 0;
#endif
}
/**
Checks if the bitmap is locked.
@return true if locked.
*/
bool isLocked() const {
return al_is_bitmap_locked(get());
}
