12 Blits y sprites



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

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

void clear_to_color(BITMAP *bitmap, int color);
Limpia el bitmap con el color especificado.

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 el biestable 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 biestable 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 el biestable 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 biestable 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 biestable 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 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 el biestable 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 biestable está activada, 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 biestable de aceleración por hardware no está activada, 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 y diagonal respectivamente. 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 se puede usar si antes has creado una tabla de colores (para modos de 256 colores) o un mapa de fundido (para modos truecolor). Ya que tiene que leer al igual que escribir la memoria bitmap, el dibujado transparente es muy lento si dibuja directamente en la memoria de vídeo, así que siempre que pueda dibuje sobre un bitmap de memoria.

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 en la posición especificada rotándolo el ángulo especificado. 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 hacia la derecha, etc. El sprite debe ser un bitmap de memoria.

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 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).




Volver al Indice