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.
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>void clear_to_color(BITMAP *bitmap, int color);
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.
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!
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.
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.
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.
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.
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().
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).
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).
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.
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.
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
fixtoi(128) al ángulo. Para invertir la imágen en ambos ejes, use
rotate_sprite() y añada fixtoi(128) a su ángulo.
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.
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.
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.
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.
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.
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.
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).