13 Blits y sprites

Todas estas rutinas son afectadas por el área de recorte del bitmap destino.


void clear_bitmap(BITMAP *bitmap);
Limpia el bitmap con el color 0.

Relacionado con: clear_to_color, clear.
void clear(BITMAP *bitmap);
Un alias de clear_bitmap(), existe para mantener compatibilidad hacia atrás. Está implementado como una función estática inline. El alias puede ser desactivado definiendo el símbolo de preprocesador ALLEGRO_NO_CLEAR_BITMAP_ALIAS antes de incluir los ficheros de cabecera de Allegro, por ejemplo: 
      #define ALLEGRO_NO_CLEAR_BITMAP_ALIAS
      #include <allegro.h>
Relacionado con: clear_bitmap.
void clear_to_color(BITMAP *bitmap, int color);
Limpia el bitmap con el color especificado.
Relacionado con: clear_bitmap.
void blit(BITMAP *source, BITMAP *dest, int source_x, int source_y, int dest_x, int dest_y, int width, int height);
Copia un área rectangular del bitmap origen en el bitmap destino. Los parámetros source_x y source_y son de la esquina superior izquierda del área a copiar del bitmap origen, y dest_x y dest_y es la posición correspondiente en el bitmap destino. Esta rutina respeta el área de recorte del destino, y también habrá recorte si intenta copiar áreas que quedan fuera del bitmap origen.

Puede hacer un blit entre cualquier parte de dos bitmaps, incluso si las dos áreas se superponen (ejemplo: source y dest son el mismo bitmap, o uno es un sub-bitmap del otro). Debería tener en cuenta, sin embargo, que muchas tarjetas SVGA no tienen bancos de lectura/escritura separados, lo que significa que hacer un blit de una parte de la pantalla a otra requiere el uso de un bitmap de memoria temporal, y es por ello extremadamente lento. Como regla general debería evitar hacer blits de la pantalla sobre sí misma en modos SVGA.

Sin embargo, hacer un blit en modo-X de una parte de la pantalla a otro lado puede ser significantemente más rápido que desde la memoria hacia la pantalla, siempre y cuando el origen y el destino estén correctamente alineados el uno con el otro. Hacer una copia entre áreas de la pantalla que se superponen es lento, pero si las áreas no se superponen, y si tienen la misma alineación de planos (es decir: (source_x%4) == (dest_x%4)), entonces se pueden usar los registros de la VGA para realizar una rápida transferencia de datos. Para tomar ventaja de esto, en modo-X normalmente se almacenan los gráficos en una parte oculta de la memoria de vídeo (usando una pantalla virtual grande), y se hacen blits desde allí a la parte visible de la pantalla.

Si el bit GFX_HW_VRAM_BLIT está activado en la variable gfx_capabilities, el controlador actual soporta blits de una parte de la pantalla a otra usando aceleración por hardware. Esto es extremadamente rápido, por lo que si este bit está activado, sería útil almacenar parte de sus gráficos más frequentemente usados en una porción oculta de la memoria de vídeo.

Al contrario que la mayoría de las rutinas gráficas, blit() permite que los bitmaps de origen y destino sean de diferentes profundidades de color, por lo que se puede usar para convertir imágenes de un formato de pixel a otro.

Relacionado con: masked_blit, stretch_blit, draw_sprite, gfx_capabilities.
void masked_blit(BITMAP *source, BITMAP *dest, int source_x, int source_y, int dest_x, int dest_y, int width, int height);
Como blit(), pero salta los pixels transparentes (cero en modos de 256 colores, y rosa fucsia para modos truecolor). La imagen origen debe ser un bitmap de memoria o un sub-bitmap, y las regiones de origen y destino no pueden superponerse.

Si el bit GFX_HW_VRAM_BLIT_MASKED está activado en la variable gfx_capabilities, el controlador actual soporta blits de una parte de la pantalla a otra usando aceleración por hardware. Esto es extremadamente rápido, por lo que si este bit está activado, sería útil almacenar parte de sus gráficos más frequentemente usados en una porción oculta de la memoria de vídeo.

Atención: ¡si el bit de aceleración por hardware no está activado, masked_blit() no funcionará correctamente cuando la imagen origen sea la memoria de vídeo, y el gráfico a dibujar siempre tiene que ser un bitmap de memoria!

Relacionado con: blit, draw_sprite, bitmap_mask_color.
void stretch_blit(BITMAP *source, BITMAP *dest, int source_x, source_y, source_width, source_height, int dest_x, dest_y, dest_width, dest_height);
Como blit(), excepto que puede escalar imágenes de tal forma que las áreas de origen y destino no tienen que tener el mismo tamaño. Esta rutina no realiza tantas comprobaciones de seguridad como blit(): en particular debe tener cuidado de no copiar desde áreas fuera del bitmap origen, y no puede hacer la copia entre áreas que se superponen, y el bitmap origen y destino no pueden ser el mismo. Además, el origen debe ser un bitmap de memoria o sub-bitmap, no la pantalla hardware.
Relacionado con: blit, stretch_sprite.
void masked_stretch_blit(BITMAP *source, BITMAP *dest, int source_x, source_y, source_w, source_h, int dest_x, dest_y, dest_w, dest_h);
Como stretch_blit(), pero se salta pixels transparentes, que están marcados con un 0 en modos de 256 colores o magenta fara datos en truecolor (rojo y azul al máximo y el verde a cero). Las regiones origen (source) y destino (destination) no deben solaparse.
Relacionado con: blit, masked_blit, stretch_blit, stretch_sprite.
void draw_sprite(BITMAP *bmp, BITMAP *sprite, int x, int y);
Dibuja una copia del bitmap sprite en el bitmap destino en la posición especificada. Eso es casi igual que blit(sprite, bmp, 0, 0, x, y, sprite->w, sprite->h), pero usa un modo de dibujado con máscara en el cual los pixels transparentes (cero en modos de 256 colores, rosa fucsia para modos truecolor) son ignorados, por lo que la imagen de fondo se podrá ver por las partes enmascaradas del sprite. El sprite debe ser un bitmap de memoria, no la pantalla o un sub-bitmap. El destino puede ser cualquier bitmap.

Si el bit GFX_HW_VRAM_BLIT_MASKED está activado en la variable gfx_capabilities, el controlador actual soporta blits de una parte de la pantalla a otra usando aceleración por hardware. Esto es extremadamente rápido, por lo que si este bit está activado, sería útil almacenar parte de sus gráficos más frequentemente usados en una porción oculta de la memoria de vídeo.

Atención: ¡si el bit de aceleración por hardware no está activado, draw_sprite() no funcionará correctamente cuando la imagen origen sea la memoria de vídeo, y el gráfico a dibujar siempre tiene que ser un bitmap de memoria!

A pesar de no soportar generalmente gráficos de diferentes profundidades de color, como caso especial puede usar esta función para dibujar imágenes origen de 256 colores en bitmaps destino truecolor, por lo que puede usar efectos de paleta en sprites específicos dentro de un programa truecolor.

Relacionado con: bitmap_mask_color, draw_gouraud_sprite, stretch_sprite, rotate_sprite, draw_character, draw_rle_sprite, draw_compiled_sprite, masked_blit, blit, draw_sprite_v_flip, draw_trans_sprite, draw_lit_sprite.
void draw_sprite_v_flip(BITMAP *bmp, BITMAP *sprite, int x, int y);
void draw_sprite_h_flip(BITMAP *bmp, BITMAP *sprite, int x, int y);
void draw_sprite_vh_flip(BITMAP *bmp, BITMAP *sprite, int x, int y);
Estas son como draw_sprite(), pero invierten la imagen sobre el eje vertical, horizontal o ambos. Esto produce imágenes espejo exactas, que no es lo mismo que rotar el sprite (y además esto es más rápido que la rutina de rotación). El sprite debe ser un bitmap de memoria.
Relacionado con: draw_sprite, bitmap_mask_color.
void draw_trans_sprite(BITMAP *bmp, BITMAP *sprite, int x, int y);
Usa la tabla global color_map o las funciones de fundido truecolor para sobreimprimir un sprite encima de una imagen existente. Esto sólo debe usarse si antes se ha creado la tabla de colores (para modos de 256 colores) o las funciones de fundido (para modos truecolor). Ya que tiene que leer al igual que escribir en la memoria del bitmap, el dibujado translúcido es muy lento si dibuja directamente en la memoria de vídeo, así que siempre que sea posibe debería usar un bitmap de memoria. El bitmap y el sprite deben, normalmente, tener la misma profundidad de color, pero como caso especial puede dibujar sprites en formato RGBA de 32 bits en cualquier bitmap hicolor o truecolor, siempre y cuando llame primero a set_alpha_blender(), y puede dibujar imágenes con 8 bits de alfa en un destino en RGBA de 32 bits, mientras llame antes a set_write_alpha_blender().
Relacionado con: bitmap_mask_color, draw_sprite, draw_lit_sprite, draw_trans_rle_sprite, color_map, set_trans_blender, set_alpha_blender, set_write_alpha_blender.
void draw_lit_sprite(BITMAP *bmp, BITMAP *sprite, int x, int y, int color);
Entinta el sprite hacia el color o nivel de luz especificado, usando la tabla global color_map, y dibuja la imagen resultante en el bitmap destino. Esto sólo se puede usar si antes ha creado una tabla de colores (para modos de 256 colores) o un mapa de fundido (para modos truecolor).
Relacionado con: draw_lit_rle_sprite, color_map, set_trans_blender, bitmap_mask_color, draw_sprite, draw_trans_sprite, draw_gouraud_sprite.
void draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int x, int y, int c1, int c2, int c3, int c4);
Entinta el sprite al color o nivel de luz especificado, interpolando los cuatro colores de la esquina sobre la imagen. Esto sólo se puede usar si antes ha creado una tabla de colores (para modos de 256 colores) o un mapa de fundido (para modos truecolor).
Relacionado con: bitmap_mask_color, draw_sprite, draw_lit_sprite, color_map, set_trans_blender.
void draw_character(BITMAP *bmp, BITMAP *sprite, int x, int y, int color);
Dibuja una copia del sprite en el bitmap destino en la posición especificada, dibujando los pixels transparentes (cero en modos de 256 colores, rosa fucsia en modos truecolor) con el modo de texto actual (ignorándolos si el modo de texto es -1, de otra forma los dibuja en el color de fondo del texto), y ajustando el resto de los pixels al color especificado. El sprite debe ser una imagen de 8 bits, incluso si el destino es un bitmap truecolor.
Relacionado con: draw_sprite, bitmap_mask_color.
void rotate_sprite(BITMAP *bmp, BITMAP *sprite, int x, int y, fixed angle);
Dibuja el sprite en el bitmap destino. Será colocado usando su esquina superior izquierda como la posición especificada, y entonces será rotado el ángulo especificado sobre su centro. El ángulo es un número de punto fijo 16.16 con el mismo formato usado por las funciones trigonométricas de punto fijo, siendo 256 un círculo completo, 64 un ángulo recto, etc. Todas las funciones de rotación pueden usar diferentes tipos de bitmaps de origen y destino, incluso bitmaps de pantalla o con una profundidad de color distinta.
Relacionado con: draw_sprite, rotate_scaled_sprite, rotate_sprite_v_flip, itofix, Trigonometría de punto fijo, pivot_scaled_sprite, pivot_scaled_sprite_v_flip, pivot_sprite, pivot_sprite_v_flip, rotate_scaled_sprite_v_flip.
void rotate_sprite_v_flip(BITMAP *bmp, BITMAP *sprite, int x, int y, fixed angle);
Como rotate_sprite, pero también invierte la imágen verticalmente. Para invertir la imagen horizontalmente, use esta rutina pero añada itofix(128) al ángulo. Para invertir la imágen en ambos ejes, use rotate_sprite() y añada itofix(128) a su ángulo.
Relacionado con: pivot_sprite_v_flip, pivot_scaled_sprite_v_flip, rotate_sprite, rotate_scaled_sprite_v_flip.
void rotate_scaled_sprite(BITMAP *bmp, BITMAP *sprite, int x, int y, fixed angle, fixed scale);
Como rotate_sprite(), pero modifica el tamaño de la imagen a la vez que la rota.
Relacionado con: pivot_scaled_sprite, pivot_scaled_sprite_v_flip, rotate_sprite, rotate_scaled_sprite_v_flip.
void rotate_scaled_sprite_v_flip(BITMAP *bmp, BITMAP *sprite, int x, int y, fixed angle, fixed scale)
Dibuja el sprite, de forma similar a rotate_scaled_sprite(), excepto que primero invierte la imagen verticalmente.
Relacionado con: rotate_sprite, rotate_scaled_sprite, rotate_sprite_v_flip.
void pivot_sprite(BITMAP *bmp, BITMAP *sprite, int x, int y, int cx, int cy, fixed angle);
Como rotate_sprite(), pero toma el punto del sprite dado por (cx, cy) como (x, y) en el bitmap, y entonces lo rota sobre este punto.
Relacionado con: rotate_sprite, pivot_scaled_sprite, pivot_sprite_v_flip.
void pivot_sprite_v_flip(BITMAP *bmp, BITMAP *sprite, int x, int y, int cx, int cy, fixed angle);
Como rotate_sprite_v_flip(), pero toma el punto del sprite dado por (cx, cy) como (x, y) en el bitmap, y entonces lo rota sobre este punto.
Relacionado con: pivot_sprite, rotate_sprite_v_flip.
void pivot_scaled_sprite(BITMAP *bmp, BITMAP *sprite, int x, int y, int cx, int cy, fixed angle, fixed scale));
Como rotate_scaled_sprite(), pero toma el punto del sprite dado por (cx, cy) como (x, y) en el bitmap, y entonces lo rota y escala sobre este punto.
Relacionado con: pivot_sprite, pivot_scaled_sprite_v_flip, rotate_sprite, rotate_scaled_sprite.
void pivot_scaled_sprite_v_flip(BITMAP *bmp, BITMAP *sprite, int x, int y, fixed angle, fixed scale)
Como rotate_scaled_sprite_v_flip(), pero toma el punto del sprite dado por (cx, cy) como (x, y) en el bitmap, y entonces lo rota y escala sobre este punto.
Relacionado con: pivot_sprite, pivot_scaled_sprite, rotate_sprite, rotate_scaled_sprite_v_flip, rotate_sprite_v_flip.
void stretch_sprite(BITMAP *bmp, BITMAP *sprite, int x, int y, int w, int h);
Dibuja un sprite en el bitmap en la posición especificada, cambiando el tamaño al ancho y alto especificado. La diferencia entre stretch_sprite() y stretch_blit() es que stretch_sprite() enmascara los pixels transparentes, que son cero en modos de 256 colores, y rosa fucsia en modos truecolor (rojo y azul al máximo, verde a cero).
Relacionado con: draw_sprite, stretch_blit, bitmap_mask_color.
Volver al Indice