Transición de pantalla con Allegro 5

 

En este ejemplo veremos dos tipos de transiciones de pantalla, realizado en C++ con Allegro 5.

1. Fundido a negro
2. Desplazamiento a la derecha

Una transición se realiza entre dos imágenes, en estos casos es entre una imagen, y una imagen en negro.

En el primer ejemplo la imagen se va desvaneciendo hasta volverse todo negro. En el segundo caso la imagen se desplaza por la pantalla, desapareciendo y dejando el fondo negro.

Fundido a Negro.

void FundidoANegro(ALLEGRO_BITMAP* img)
{
	// Muestra la imagen y realiza un fundido a Negro

	int anchoImg = al_get_bitmap_width(img);
	int altoImg = al_get_bitmap_height(img);
	ALLEGRO_BITMAP* imgNegro = al_create_bitmap(anchoImg, altoImg);
	al_set_target_bitmap(imgNegro);
	al_clear_to_color(al_map_rgb_f(0, 0, 0));

	al_set_target_backbuffer(pantalla);

	int alfa;
	for (int i = 0; i < 255; i++)
	{
		alfa = 255 - i;
		al_draw_bitmap(img, 0, 0, 0);		
		al_draw_tinted_bitmap(imgNegro, al_map_rgba_f(0, 0, 0, alfa), 0, 0, 0);

		al_flip_display();
		al_rest(0.01);
		if (i == 0 || i == 254)
		{
			al_rest(2);
		}
	}
	al_destroy_bitmap(imgNegro);
}

Esta es una función que recibe como parámetro un bitmap que es la imagen inicial que se muestra a la cual se realiza el fundido a negro.

Primero se crea una imagen con las mismas dimensiones que la imagen recibida y se pinta de color negro, esta imagen es llamada imgNegro.

Luego se realiza un bucle donde se va disminuyendo la transparencia de imgNegro, de esta forma se va oscureciendo la imagen inicial. Cada ciclo tiene un tiempo de espera de 0.01 segundo, en el primer ciclo y último se realiza una espera mayor de 2 segundos, dejando tiempo para mostrar las imágenes.

Desplazamiento a la derecha

void DesplazamientoDerecha(ALLEGRO_BITMAP* img)
{
	int display_w = al_get_display_width(pantalla);
	int display_h = al_get_display_height(pantalla);

	al_set_target_backbuffer(pantalla);

	for (int i = 0; i <= display_w; i++)
	{
		al_draw_filled_rectangle(-1, 0, i, display_h, al_map_rgb_f(0, 0, 0));
		al_draw_bitmap(img, i, 0, 0);

		al_flip_display();
		al_rest(0.01);
		if (i == 0 || i == display_w)
		{
			al_rest(2);
		}
	}
}

Esta es una función que recibe como parámetro la imagen que se va a desplazar por la pantalla. Al inicio de la función se obtiene el tamaño de la pantalla, es decir, para un correcto funcionamiento debemos tener una variable global para la pantalla, definida de la siguiente forma:

ALLEGRO_DISPLAY* pantalla;

Esta variable debe ser inicializada con la resolución con la que vamos a trabajar, en el caso de que nuestra resolucion sea 800x600, el código de inicializar es el siguiente:

pantalla = al_create_display(800, 600);

Se realiza un bucle que recorre todo el ancho de la pantalla, y va pintando un rectángulo negro, y desplaza la imagen. Al igual que el anterior se dejan 2 segundos de esperas para mostrar las imágenes de inicio y fin.