|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
 |
Fundidos
Los fundidos son muy famosos en los demos, juegos, incluso hasta en la televisión. Básicamente existen dos tipos de fundidos o Fades, uno de ellos es el conocido como Fade Out, y hace que una imagen o lo que halla en la pantalla se vaya oscureciendo poco a poco hasta apagarse todo, es decir hasta quedar toda la pantalla completamente negra. El otro tipo de fundido es el Fade In, que es todo lo contrario, es decir desde una pantalla en negro se va haciendo aparecer por ejemplo una imagen, poco a poco, hasta que aparezca completamente. Otro tipo de fundido que existe es el de iluminar por completo la pantalla, hasta que quede completamente blanca, este ultimo se podría decir que es una modificación del Fade Out.
Veamos como se hace el Fade Out, que es el más fácil de implementar. Lo primero que hay que hacer es realizar un ciclo de 0 a 63 y en cada vuelta hay que decrementar en 1 los valores de rojo, verde y azul de todos los colores. La única precaución que se debe tener es que si algún valor de rojo, verde o azul ya vale cero, entonces lo dejamos como está.
Veamos ahora como nos quedaría nuestro
código:
| void FadeOut(void)
{ t_paleta pal; int x, y; GetPal(pal); for(y=0;
y<64; y++)
|
Veamos ahora como se haría el efecto inverso, el Fade In. Inicialmente la pantalla deberá estar completamente negra y entonces poco a poco se va iluminando hasta alcanzar su intensidad final. Lo primero que hay que hacer es conocer la paleta a la que se debe llegar, de ahí hacer un ciclo de 0 a 63. Dentro de este ciclo deberemos ir comparando los valores de rojo, verde y azul con cada color de la paleta a la que queremos llegar. Si la intensidad del color en la paleta es menor que la intensidad en la variable, entonces aumentamos la intensidad de la paleta. De esta forma, cada color aumentará su intensidad hasta que se igual a la que esta almacenada en la variable.
Veamos como se hace esto en C:
| void FadeIn(t_paleta
paleta)
{ t_paleta pal; int x, y; for(y=0; y<768; y++) pal[y]=0; for(y=0;
y<64; y++)
|
Existe otro tipo de fundido que se puede realizar, y es el de iluminar por completo la pantalla. Para hacer esto simplemente hay que modificar el código de FadeOut y cambiar la línea:
if(pal[x]>0) pal[x]--;
por esta:
if(pal[x]<63) pal[x]++;
De esta forma nuestra rutina nos quedaría
así:
| void FadeWhite(void)
{ t_paleta pal; int x,y; GetPal(pal); for(y=0;
y<64; y++)
|
Rotación de la paleta
La rotación de paleta, sirve para dar la ilusión de movimiento. Supongamos que tenemos nuestra paleta con los 10 primeros colores en negro, al igual que el fondo, el cual está pintado con un color que no esta entre los primeros 10. De esta forma si cambiamos los 10 primeros colores, el color de fondo no cambiará.
Ahora supongamos que dibujamos 10 puntos consecutivos con los colores del 0 al 9. De esta forma el primer pixel tiene el color 0, el siguiente pixel a la derecha tiene el color 1, y así sucesivamente hasta llegar al último pixel, el cual tiene el color 9. Obviamente, puesto que los colores del 0 al 9 son iguales que el color de fondo, los pixeles son invisibles para nosotros.
¿Que pasaría si nosotros hacemos que el color 0 sea blanco? El primer pixel que dibujamos se volvería blanco. Ahora supongamos que hacemos un movimiento de los 10 primeros colores de la paleta de forma que el color 9 sea igual al color 8, el color 8 sea igual al color 7, el color 7 igual al color 6, ..., y por último el color 0 sería igual al color 9. A esto se le llama un Rotación de la Paleta, y puesto que todos los colores (menos el último) se movieron hacia el siguiente, entonces le llamamos una rotación hacia delante.
Pero, ahora ¿cómo han quedado los colores?
El color 0 (que era blanco) ahora vuelve a ser negro (lo que era antes el color 9). El color 1 ahora es blanco, ya que tomó su nuevo valor a partir del color 0. Todos los demás colores quedan en negro.
Y puesto que ahora el color 0 es negro, entonces el pixel que estaba blanco vuelve a estar negro, pero el pixel siguiente, que tiene el color 1, se vuelve blanco. Esto da la ilusión de que el pixel se ha movido, aunque en realidad no hemos vuelto a dibujar ningún pixel. Si realizamos otra vez la rotación de la paleta, el pixel parecerá moverse otra vez. Y si hacemos la rotación dentro de un ciclo, el pixel permanecerá en movimiento.
Para mover un pixel, lo más sencillo sería primero borrarlo y luego dibujarlo en su nueva posición. Pero que pasa si en lugar de pixeles queremos mover líneas o figuras grandes, sería muy lento el borrar y dibujar nuevamente. En cambio la rotación de paleta nos permite dar la ilusión de movimiento si tener que dibujar ni un solo pixel.
Ahora veremos una rutina que nos permite
rotar la paleta hacia delante o hacia atrás, y en un rango de colores
determinado. Veamos:
| void RotatePal(t_paleta
pal, int first, int last)
{ int i; char r, g, b; if
(first < last) // Rota la paleta una posición a la derecha
r=pal[last-2];
r=pal[last];
|
Interferencia
Este efecto es muy sencillo de realizar. De que se trata, pues bien enciendan su televisor y sintonícenla en un canal que no se transmita nada. Lo que ven en la pantalla es el efecto que queremos lograr.
El efecto es aún mejor si aparece repentinamente sobre cualquier otra cosa que aparezca en la pantalla, como si realmente se produjera un interferencia.
Para realizar el efecto existen muchas formas. Una de ellas, la más fácil, consiste en generar una pantalla virtual y llenarla de pixeles de colores al azar. El rango de colores no debe ser muy amplio, por ejemplo, entre 1 y 16, y luego en la paleta de colores fijamos un degradado de grises en los colores del 1 al 16. Para obtener un tono de grises, simplemente fijamos el mismo valor de intensidad para los componentes rojo, verde y azul de un color.
Todo lo que dijimos, se puede hacer en
C de esta forma:
| t_pvirtual pv;
t_paleta pal; void Inicia_Interferencia(void)
//
Inicializamos la pantalla virtual
//
Llenamos la pantalla virtual con pixeles al azar
//
Creamos un degradado de grises en la paleta
|
De esta forma, ya tenemos nuestra pantalla
de interferencia almacenada en pv. Ahora, cuando queramos hacer visible
la interferencia, simplemente copiamos la pantalla virtual a la pantalla
VGA y hacemos una rotación de la paleta sobre los colores del 1
al 16.
| void HacerInterferencia(void)
{ // Copiamos la pantalla virtual a la VGA Flip(pv); // Rotamos la paleta hasta que se presione una tecla do { RotatePal(pal, 1, 16); WaitRetrace(); SetPal(pal); } while(!kbhit()); } |
Ejemplos
Librería gráfica: vgalib.h
 |
Bajar todos los ejemplos (61.6 Kb) |