08 Objetos bitmap

Una vez haya seleccionado un modo gráfico, puede dibujar cosas en la pantalla por el bitmap 'screen'. Todas las rutinas de dibujo de Allegro dibujan en estructuras BITMAP, que son áreas de memoria que contienen imágenes rectangulares, almacenadas en arrays de packs de bytes (un byte por pixel en modos de 8 bits, sizeof(short) bytes por pixel en modos de 15 y 16 bits por pixel, 3 bytes por pixel en modos de 24 bits y sizeof(long) bytes por pixel en modos de 32 bits). Puede crear y manipular bitmaps en la memoria RAM, o puede dibujar en el bitmap especial 'screen' que representa la memoria de vídeo de su tarjeta gráfica.

Por ejemplo, para dibujar un pixel en la pantalla escribiría: 

   putpixel(screen, x, y, color);
O para implementar un sistema doble-buffer: 
   BITMAP *bmp = create_bitmap(320, 200);    // crea un bitmap en la RAM
   clear_bitmap(bmp);                        // limpia el bitmap
   putpixel(bmp, x, y, color);               // dibuja sobre el bitmap
   blit(bmp, screen, 0, 0, 0, 0, 320, 200);  // lo copia a la pantalla
Mire abajo para saber cómo obtener acceso directo a la memoria de un bitmap.

Allegro soporta varios tipos diferentes de bitmaps:

- El bitmap screen, que representa la memoria de vídeo de su hardware. Debe dibujar sobre él para que su imagen sea visible.

- Bitmaps de memoria, que están situados en la RAM del sistema y pueden ser usados para almacenar gráficos o como espacios de dibujo temporales para sistemas doble buffer. Estos pueden ser obtenidos llamando create_bitmap(), load_pcx(), o al cargar un fichero de datos.

- Sub-bitmaps. Estos comparten memoria de imagen con un bitmap padre (que puede ser la pantalla, un bitmap de memoria u otro sub-bitmap), por lo que dibujar en ellos también modificará al bitmap padre. Pueden tener cualquier tamaño y estar localizados en cualquier parte del bitmap padre. Pueden tener sus propias áreas de recorte, por lo que son útiles para dividir un bitmap en varias unidades más pequeñas, ej: partir una pantalla virtual grande en múltiples secciones (mire examples/exscroll.c).

- Bitmaps de memoria de vídeo. Estos son creados con la función create_video_bitmap(), y normalmente son implementados como sub-bitmaps del objeto screen.

- Bitmaps de sistema. Se crean mediante la función create_system_bitmap(), y están a caballo entre los bitmaps de memoria y los de video. Viven en la memoria de sistema, así pues no están limitado por la cantidad de ram de video de su tarjeta, pero se guardan en un formato específico de la plataforma que puede activar una aceleración hardware mejor de la que es posible con un bitmap de memoria normal (vea los bits GFX_HW_SYS_TO_VRAM_BLIT y GFX_HW_SYS_TO_VRAM_BLIT_MASKED en gfx_capabilities). A los bitmaps de sistema se debe acceder de la misma manera que a los bitmaps de video, usando las funciones de cambio de banco y las macro bmp_write*(). No todas las plataformas implementan este tipo de bitmap: si no están disponibles create_system_bitmap() funcionará idénticamente igual que create_bitmap().


extern BITMAP *screen;
Puntero global a un bitmap, de tamaño VIRTUAL_W x VIRTUAL_H. Esto es creado por set_gfx_mode(), y representa la memoria de vídeo de su hardware. Sólo una parte de este bitmap será visible, de tamaño SCREEN_W x SCREEN_H. Normalmente estará en la parte superior izquierda de la pantalla virtual, por lo que puede ignorar el resto de la pantalla virtual si no está interesado en scroll por hardware o intercambio de páginas. Para mover la ventana visible a otras partes del bitmap screen, llama scroll_screen(). Inicialmente el área de recorte será igual de grande que la pantalla física, por lo que si quiere dibujar en la pantalla virtual fuera de este rectángulo, deberá ajustar el área de recorte.

Relacionado con: set_gfx_mode, is_screen_bitmap, create_video_bitmap, scroll_screen.
BITMAP *create_bitmap(int width, int height);
Crea un bitmap de memoria con tamaño width por height, y devuelve un puntero a él. El bitmap tendrá el área de recorte activada y ajustada al tamaño total del bitmap. La memoria de la imagen no será limpiada, por lo que probablemente tendrá basura: debería limpiar el bitmap antes de usarlo. Esta rutina usa siempre el formato global de profundidad de color especificado al llamar set_color_depth().
Relacionado con: create_bitmap_ex, create_sub_bitmap, create_video_bitmap, destroy_bitmap, set_color_depth, is_memory_bitmap.
BITMAP *create_bitmap_ex(int color_depth, int width, int height);
Crea un bitmap de una profundidad de color específica (8, 15, 16, 24 o 32 bits por pixel).
Relacionado con: create_bitmap, create_sub_bitmap, create_video_bitmap, destroy_bitmap, is_memory_bitmap.
BITMAP *create_sub_bitmap(BITMAP *parent, int x, y, width, height);
Crea un sub-bitmap, es decir, un bitmap que comparte memoria con un bitmap ya existente, pero posiblemente con un tamaño y área de recorte diferentes. Cuando cree un sub-bitmap de la pantalla en modo-X, la posición x debe ser un múltiplo de cuatro. La anchura y altura del sub-bitmap pueden extenderse fuera de los bordes del bitmap padre (serán recortados), pero el punto de origen debe estar en una región del bitmap padre.
Relacionado con: create_bitmap, create_bitmap_ex, destroy_bitmap, is_sub_bitmap.
BITMAP *create_video_bitmap(int width, int height);
Reserva un bitmap de memoria de vídeo del tamaño especificado, devolviendo un puntero si funcionó, o NULL si hubo algún error (ej: se has quedado sin memoria vram libre). Esto puede ser usado para reservar memoria de vídeo oculta para almacenar gráficos preparados para operaciones aceleradas por hardware, o para crear múltiples páginas de vídeo que luego pueden ser visualizadas con show_video_bitmap(). Los bitmaps de memoria de vídeo son normalmente reservados usando el mismo espacio que el bitmap screen, ya que pueden sobreescribirlo: por lo tanto no es una buena idea usar screen al mismo tiempo que las superficies devueltas por esta función.
Relacionado con: create_bitmap, create_bitmap_ex, create_sub_bitmap, destroy_bitmap, screen, show_video_bitmap, gfx_capabilities, is_screen_bitmap.
BITMAP *create_system_bitmap(int width, int height);
Crea un bitmap en memoria de sistema del tamaño especificado, devolviendo un puntero a él si no hubo problemas o NULL en caso contrario.
Relacionado con: create_bitmap, create_bitmap_ex, create_video_bitmap, create_sub_bitmap, destroy_bitmap, is_system_bitmap.
void destroy_bitmap(BITMAP *bitmap);
Destruye un bitmap de memoria, sub-bitmap, bitmap de memoria de vídeo o un bitmap de sistema cuando ya no lo necesite.
Relacionado con: create_bitmap, load_bitmap.
void lock_bitmap(BITMAP *bitmap);
Bajo DOS, fija toda la memoria usada por un bitmap. Normalmente no necesita llamar a esta función a no ser que esté haciendo cosas realmente raras en su programa.


int bitmap_color_depth(BITMAP *bmp);
Devuelve la profundidad de color del bitmap especificado (8, 15, 16, 24, o 32).

Relacionado con: set_color_depth, bitmap_mask_color.
int bitmap_mask_color(BITMAP *bmp);
Devuelve el color de máscara del bitmap especificado (el valor que es ignorado al dibujar sprites). En bitmaps de 256 colores es cero, y en bitmaps truecolor es rosa fucsia (rojo y azul al máximo, verde a cero).
Relacionado con: MASK_COLOR_8, set_color_depth, bitmap_color_depth.
int is_same_bitmap(BITMAP *bmp1, BITMAP *bmp2);
Devuelve TRUE si ambos bitmaps describen el mismo área de dibujo, ej: sus punteros son iguales, uno es un sub-bitmap del otro, o ambos son sub-bitmaps de un padre común.
Relacionado con: create_sub_bitmap.
int is_linear_bitmap(BITMAP *bmp);
Devuelve TRUE si bmp es un bitmap lineal, es decir, es un bitmap de memoria, pantalla en modo 13h o SVGA. En bitmaps lineales puede usar las funciones _putpixel(), _getpixel(), bmp_write_line(), y bmp_read_line().
Relacionado con: is_planar_bitmap, is_memory_bitmap.
int is_planar_bitmap(BITMAP *bmp);
Devuelve TRUE si bmp es un bitmap de pantalla plano (modo-X o Xtended).
Relacionado con: is_linear_bitmap, is_memory_bitmap.
int is_memory_bitmap(BITMAP *bmp);
Devuelve TRUE si bmp es un bitmap de memoria, es decir, que fue creado llamando create_bitmap() o cargado de un fichero de datos o una imagen. Los bitmaps de memoria pueden ser accedidos con los punteros de línea de la estructura bitmap, ej: bmp->line[y][x] = color.
Relacionado con: is_linear_bitmap, is_planar_bitmap.
int is_screen_bitmap(BITMAP *bmp);
Devuelve TRUE si bmp es el bitmap screen, o un sub-bitmap de él.
Relacionado con: screen, create_video_bitmap, create_sub_bitmap.
int is_video_bitmap(BITMAP *bmp);
Devuelve TRUE si bmp es el bitmap screen, o un bitmap de memoria de video, o un sub-bitmap de alguno de ellos.
Relacionado con: screen, create_video_bitmap, create_sub_bitmap.
int is_system_bitmap(BITMAP *bmp);
Devuelve TRUE si bmp es un bitmap de sistema, o un sub-bitmap de uno.
Relacionado con: create_system_bitmap, create_sub_bitmap.
int is_sub_bitmap(BITMAP *bmp);
Devuelve TRUE si bmp es un sub-bitmap.
Relacionado con: create_sub_bitmap.
void acquire_bitmap(BITMAP *bmp);
Bloquea el bitmap de memoria de vídeo especificado antes de dibujar en él. Esto no se aplica a los bitmaps de memoria, y sólo afecta a algunas plataformas (Windows lo necesita, DOS no). Estas llamadas no son estrictamente necesarias, porque las rutinas de dibujo adquirirán el bitmap automáticamente antes de acceder a él, pero bloquear una superficie de DirectDraw es muy lento, y obtendrá mucho más rendimiento si adquiere la pantalla sólo una vez antes del inicio de la función de redibujado principal, y la suelta cuando el dibujado ha concluido completamente. Múltiples llamadas de adquisición serán anidadas, y el bitmap sólo será liberado cuando el contador de bloqueo sea cero. Tenga cuidado porque los programas DirectX activan un bloqueo de exclusión mutua (mutex) siempre que una superficie es bloqueada, lo que impide que reciban cualquier mensaje de entrada, ¡así que debe asegurarse de liberar todos sus bitmaps antes de usar alguna rutina de temporización, teclado o cualquier otra rutina no gráfica!
Relacionado con: release_bitmap, acquire_screen, release_screen.
void release_bitmap(BITMAP *bmp);
Libera un bitmap que fue bloqueado previamente mediante una llamada a acquire_bitmap(). Si el bitmap fue bloqueado varias veces, deberá liberarlo el mismo número de veces para que esté verdaderamente desbloqueado.
Relacionado con: acquire_bitmap, acquire_screen, release_screen.
void acquire_screen();
Sinónimo de acquire_bitmap(screen);
Relacionado con: acquire_bitmap, release_bitmap, release_screen.
void release_screen();
Sinónimo de release_bitmap(screen);
Relacionado con: acquire_bitmap, release_bitmap, acquire_screen.
void set_clip(BITMAP *bitmap, int x1, int y1, int x2, int y2);
Cada bitmap tiene un área de recorte asociada, que es el área de pantalla sobre la que puede dibujar. Nada será dibujado fuera de este espacio. Pase las dos esquinas opuestas del área de recorte: éstas son inclusivas, ej: set_clip(bitmap, 16, 16, 32, 32) le permitirá dibujar en (16, 16) y (32, 32), pero no en (15, 15) o (33, 33). Si x1, y1, x2 e y2 son cero, el área de recorte se desactivará, lo que puede acelerar algunas operaciones de dibujo (normalmente casi nada, aunque cualquier poco ayuda) pero harán que su programa muera horriblemente si intenta dibujar fuera de los bordes del bitmap.


Volver al Indice