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;
}
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;
}
static bool glsl_set_shader_sampler(ALLEGRO_SHADER *shader,
const char *name, ALLEGRO_BITMAP *bitmap, int unit)
{
ALLEGRO_SHADER_GLSL_S *gl_shader = (ALLEGRO_SHADER_GLSL_S *)shader;
GLint handle;
GLuint texture;
if (bitmap && al_get_bitmap_flags(bitmap) & ALLEGRO_MEMORY_BITMAP) {
ALLEGRO_WARN("Cannot use memory bitmap for sampler\n");
return false;
}
handle = glGetUniformLocation(gl_shader->program_object, name);
if (handle < 0) {
ALLEGRO_WARN("No uniform variable '%s' in shader program\n", name);
return false;
}
glActiveTexture(GL_TEXTURE0 + unit);
texture = bitmap ? al_get_opengl_texture(bitmap) : 0;
glBindTexture(GL_TEXTURE_2D, texture);
glUniform1i(handle, unit);
return check_gl_error(name);
}
void RenderTarget::resize(int32_t w, int32_t h) {
ALLEGRO_BITMAP *newBitmap = al_create_bitmap(w, h);
// Check if we have changed Smooth2D in between creating this rendertarget
// and calling this function. If so, we need to clone this bitmap, because
// bitmap resize operation flags have changed.
ALLEGRO_BITMAP *bitmapToDrawResized;
int bmFlags = al_get_bitmap_flags(this->bitmap);
int32_t origW = this->width();
int32_t origH = this->height();
bool smooth2d = CBEnchanted::instance()->isSmooth2D();
if ((!smooth2d && (bmFlags & ALLEGRO_MAG_LINEAR) == ALLEGRO_MAG_LINEAR) ||
(smooth2d && (bmFlags & ALLEGRO_MAG_LINEAR) != ALLEGRO_MAG_LINEAR))
{
// We need to clone.
bitmapToDrawResized = al_clone_bitmap(this->bitmap);
al_destroy_bitmap(this->bitmap);
}
else {
// Phew, no need to clone.
bitmapToDrawResized = this->bitmap;
}
al_set_target_bitmap(newBitmap);
al_clear_to_color(al_map_rgb(0, 0, 0));
int32_t a, b, c;
al_get_blender(&a, &b, &c);
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO);
al_draw_scaled_bitmap(bitmapToDrawResized, 0, 0, origW, origH, 0, 0, w, h, 0);
al_set_blender(a, b, c);
al_destroy_bitmap(bitmapToDrawResized);
this->bitmap = newBitmap;
bindRenderTarget = this;
}
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();
};
static void print_bitmap_flags(ALLEGRO_BITMAP *bitmap)
{
ALLEGRO_USTR *ustr = al_ustr_new("");
if (al_get_bitmap_flags(bitmap) & ALLEGRO_VIDEO_BITMAP)
al_ustr_append_cstr(ustr, " VIDEO");
if (al_get_bitmap_flags(bitmap) & ALLEGRO_MEMORY_BITMAP)
al_ustr_append_cstr(ustr, " MEMORY");
if (al_get_bitmap_flags(bitmap) & ALLEGRO_CONVERT_BITMAP)
al_ustr_append_cstr(ustr, " CONVERT");
al_ustr_trim_ws(ustr);
al_ustr_find_replace_cstr(ustr, 0, " ", " | ");
log_printf("%s", al_cstr(ustr));
al_ustr_free(ustr);
}
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;
}
/* 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);
}
}
/* Function: al_clear_depth_buffer
*/
void al_clear_depth_buffer(float z)
{
ALLEGRO_BITMAP *target = al_get_target_bitmap();
ASSERT(target);
if (al_get_bitmap_flags(target) & ALLEGRO_MEMORY_BITMAP) {
/* has no depth buffer */
}
else {
ALLEGRO_DISPLAY *display = _al_get_bitmap_display(target);
ASSERT(display);
display->vt->clear_depth_buffer(display, z);
}
}
/* 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);
}
}
static void recreate_textures(ALLEGRO_DISPLAY *display)
{
unsigned int i;
for (i = 0; i < _al_vector_size(&display->bitmaps); i++) {
ALLEGRO_BITMAP **bptr = _al_vector_ref(&display->bitmaps, i);
ALLEGRO_BITMAP *bitmap = *bptr;
int bitmap_flags = al_get_bitmap_flags(bitmap);
if (bitmap->parent)
continue;
if (bitmap_flags & ALLEGRO_MEMORY_BITMAP)
continue;
if (bitmap_flags & ALLEGRO_NO_PRESERVE_TEXTURE)
continue;
_al_ogl_upload_bitmap_memory(bitmap, _al_get_bitmap_memory_format(
bitmap), bitmap->memory);
}
}
/* Function: al_destroy_bitmap
*/
void al_destroy_bitmap(ALLEGRO_BITMAP *bitmap)
{
if (!bitmap) {
return;
}
/* As a convenience, implicitly untarget the bitmap on the calling thread
* before it is destroyed, but maintain the current display.
*/
if (bitmap == al_get_target_bitmap()) {
ALLEGRO_DISPLAY *display = al_get_current_display();
if (display)
al_set_target_bitmap(al_get_backbuffer(display));
else
al_set_target_bitmap(NULL);
}
_al_set_bitmap_shader_field(bitmap, NULL);
_al_unregister_destructor(_al_dtor_list, bitmap);
if (!al_is_sub_bitmap(bitmap)) {
ALLEGRO_DISPLAY* disp = _al_get_bitmap_display(bitmap);
if (al_get_bitmap_flags(bitmap) & ALLEGRO_MEMORY_BITMAP) {
destroy_memory_bitmap(bitmap);
return;
}
/* Else it's a display bitmap */
if (bitmap->locked)
al_unlock_bitmap(bitmap);
if (bitmap->vt)
bitmap->vt->destroy_bitmap(bitmap);
if (disp)
_al_vector_find_and_delete(&disp->bitmaps, &bitmap);
if (bitmap->memory)
al_free(bitmap->memory);
}
al_free(bitmap);
}
/* Function: al_get_d3d_texture_size
*/
bool al_get_d3d_texture_size(ALLEGRO_BITMAP *bitmap, int *width, int *height)
{
int bitmap_flags = al_get_bitmap_flags(bitmap);
ASSERT(bitmap);
ASSERT(width);
ASSERT(height);
if (!(bitmap_flags & _ALLEGRO_INTERNAL_OPENGL) &&
!(bitmap_flags & ALLEGRO_MEMORY_BITMAP)) {
ALLEGRO_BITMAP_EXTRA_D3D *d3d_bmp = get_extra(bitmap);
*width = d3d_bmp->texture_w;
*height = d3d_bmp->texture_h;
return true;
}
else {
*width = 0;
*height = 0;
return false;
}
}
T3F_ANIMATION * t3f_load_animation_f(ALLEGRO_FILE * fp, const char * fn)
{
T3F_ANIMATION * ap;
int i;
char header[12] = {0};
int ver;
int fpos = 0;
ALLEGRO_STATE old_state;
ALLEGRO_BITMAP * bp;
al_fread(fp, header, 12);
ver = check_header(header);
if(ver < 0)
{
return NULL;
}
ap = t3f_create_animation();
if(ap)
{
switch(ver)
{
case 0:
{
ap->bitmaps->count = al_fread16le(fp);
for(i = 0; i < ap->bitmaps->count; i++)
{
ap->bitmaps->bitmap[i] = t3f_load_resource_f((void **)(&ap->bitmaps->bitmap[i]), T3F_RESOURCE_TYPE_BITMAP, fp, fn, 1, 0);
}
ap->frames = al_fread16le(fp);
for(i = 0; i < ap->frames; i++)
{
ap->frame[i] = al_malloc(sizeof(T3F_ANIMATION_FRAME));
if(!ap->frame[i])
{
return NULL;
}
ap->frame[i]->bitmap = al_fread16le(fp);
ap->frame[i]->x = t3f_fread_float(fp);
ap->frame[i]->y = t3f_fread_float(fp);
ap->frame[i]->z = t3f_fread_float(fp);
ap->frame[i]->width = t3f_fread_float(fp);
ap->frame[i]->height = t3f_fread_float(fp);
ap->frame[i]->angle = t3f_fread_float(fp);
ap->frame[i]->ticks = al_fread32le(fp);
ap->frame[i]->flags = al_fread32le(fp);
}
ap->flags = al_fread32le(fp);
break;
}
case 1:
{
ap->bitmaps->count = al_fread16le(fp);
for(i = 0; i < ap->bitmaps->count; i++)
{
fpos = al_ftell(fp);
ap->bitmaps->bitmap[i] = t3f_load_resource_f((void **)(&ap->bitmaps->bitmap[i]), T3F_RESOURCE_TYPE_BITMAP, fp, fn, 0, 0);
if(!ap->bitmaps->bitmap[i])
{
al_fseek(fp, fpos, ALLEGRO_SEEK_SET);
al_store_state(&old_state, ALLEGRO_STATE_NEW_BITMAP_PARAMETERS);
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP);
bp = t3f_load_bitmap_f(fp);
al_restore_state(&old_state);
if(bp)
{
ap->bitmaps->bitmap[i] = t3f_squeeze_bitmap(bp, NULL, NULL);
al_destroy_bitmap(bp);
}
}
else if(al_get_bitmap_flags(ap->bitmaps->bitmap[i]) & ALLEGRO_MEMORY_BITMAP)
{
bp = t3f_squeeze_bitmap(ap->bitmaps->bitmap[i], NULL, NULL);
al_destroy_bitmap(ap->bitmaps->bitmap[i]);
ap->bitmaps->bitmap[i] = bp;
}
if(!ap->bitmaps->bitmap[i])
{
return NULL;
}
}
ap->frames = al_fread16le(fp);
for(i = 0; i < ap->frames; i++)
{
ap->frame[i] = al_malloc(sizeof(T3F_ANIMATION_FRAME));
if(!ap->frame[i])
{
return NULL;
}
ap->frame[i]->bitmap = al_fread16le(fp);
ap->frame[i]->x = t3f_fread_float(fp);
ap->frame[i]->y = t3f_fread_float(fp);
ap->frame[i]->z = t3f_fread_float(fp);
ap->frame[i]->width = t3f_fread_float(fp);
ap->frame[i]->height = t3f_fread_float(fp);
ap->frame[i]->angle = t3f_fread_float(fp);
ap->frame[i]->ticks = al_fread32le(fp);
ap->frame[i]->flags = al_fread32le(fp);
}
ap->flags = al_fread32le(fp);
break;
}
}
}
t3f_animation_build_frame_list(ap);
return ap;
}
static int allua_Bitmap_get_flags(lua_State * L)
{
ALLUA_bitmap bitmap = allua_check_bitmap(L, 1);
lua_pushinteger(L, al_get_bitmap_flags(bitmap));
return 1;
}
static void ogl_unlock_region_non_readonly(ALLEGRO_BITMAP *bitmap,
ALLEGRO_BITMAP_EXTRA_OPENGL *ogl_bitmap)
{
const int lock_format = bitmap->locked_region.format;
const int gl_y = bitmap->h - bitmap->lock_y - bitmap->lock_h;
ALLEGRO_DISPLAY *old_disp = NULL;
ALLEGRO_DISPLAY *disp;
int orig_format;
bool biased_alpha = false;
GLenum e;
disp = al_get_current_display();
orig_format = _al_get_real_pixel_format(disp, _al_get_bitmap_memory_format(bitmap));
/* 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));
}
/* Keep this in sync with ogl_lock_region. */
glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
{
const int lock_pixel_size = al_get_pixel_size(lock_format);
const int pixel_alignment = ogl_pixel_alignment(lock_pixel_size);
glPixelStorei(GL_UNPACK_ALIGNMENT, pixel_alignment);
e = glGetError();
if (e) {
ALLEGRO_ERROR("glPixelStorei(GL_UNPACK_ALIGNMENT, %d) failed (%s).\n",
pixel_alignment, _al_gl_error_string(e));
}
}
if (exactly_15bpp(lock_format)) {
/* OpenGL does not support 15-bpp internal format without an alpha,
* so when storing such data we must ensure the alpha bit is set.
*/
glPixelTransferi(GL_ALPHA_BIAS, 1);
biased_alpha = true;
}
if (ogl_bitmap->is_backbuffer) {
ALLEGRO_DEBUG("Unlocking backbuffer\n");
ogl_unlock_region_backbuffer(bitmap, ogl_bitmap, gl_y);
}
else {
glBindTexture(GL_TEXTURE_2D, ogl_bitmap->texture);
if (ogl_bitmap->fbo_info) {
ALLEGRO_DEBUG("Unlocking non-backbuffer (FBO)\n");
ogl_unlock_region_nonbb_fbo(bitmap, ogl_bitmap, gl_y, orig_format);
}
else {
ALLEGRO_DEBUG("Unlocking non-backbuffer (non-FBO)\n");
ogl_unlock_region_nonbb_nonfbo(bitmap, ogl_bitmap, gl_y);
}
/* If using FBOs, we need to regenerate mipmaps explicitly now. */
/* XXX why don't we check ogl_bitmap->fbo_info? */
if ((al_get_bitmap_flags(bitmap) & ALLEGRO_MIPMAP) &&
al_get_opengl_extension_list()->ALLEGRO_GL_EXT_framebuffer_object)
{
glGenerateMipmapEXT(GL_TEXTURE_2D);
e = glGetError();
if (e) {
ALLEGRO_ERROR("glGenerateMipmapEXT for texture %d failed (%s).\n",
ogl_bitmap->texture, _al_gl_error_string(e));
}
}
}
if (biased_alpha) {
glPixelTransferi(GL_ALPHA_BIAS, 0);
}
glPopClientAttrib();
if (old_disp) {
_al_set_current_display_only(old_disp);
}
}
/**
Returns the bitmap's flags.
@return the bitmap's flags.
*/
int getFlags() const {
return al_get_bitmap_flags(get());
}
