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