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 pantallaMire 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.
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().
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).
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.
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.
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.
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.
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).
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).
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.
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().
int is_planar_bitmap(BITMAP *bmp);
Devuelve TRUE si bmp es un bitmap de pantalla plano (modo-X o Xtended).
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.
int is_screen_bitmap(BITMAP *bmp);
Devuelve TRUE si bmp es el bitmap screen, o un sub-bitmap de él.
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.
int is_system_bitmap(BITMAP *bmp);
Devuelve TRUE si bmp es un bitmap de sistema, o un sub-bitmap de uno.
int is_sub_bitmap(BITMAP *bmp);
Devuelve TRUE si bmp es un 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!
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.
void acquire_screen();
Sinónimo de acquire_bitmap(screen);
void release_screen();
Sinónimo de release_bitmap(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.