07 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 (ocho bits por pixel). 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(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 el 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 dos secciones para hacer intercambio de páginas (mire examples/ex9.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.

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.

void destroy_bitmap(BITMAP *bitmap);
Destruye un bitmap de memoria o sub-bitmap cuando ya no lo necesite.

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_sub_bitmap(BITMAP *bmp);
Devuelve TRUE si bmp es un sub-bitmap.

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. Para las dos esquinas opuestas del área de recorte: éstas son inclusivas, ej: set_clip(bitmap, 16, 16, 32, 32) se 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