En este articulo se va a tratar la paleta de colores del ordenador y posibles efectos que se pueden realizar gracias a su modificación, como el fundido de una imagen a negro, la rotación de los colores o el fundido desde el negro a una imagen. En las demos e intros se utilizan algunos de estos efectos debido a la facilidad de programación.
Antes de ver estos efectos repasemos algo de la entrega anterior sobre la historia de las tarjetas gráficas.
Los primeros ordenadores personales tenían un sistema de visualización monocromático, es decir, dos colores en pantalla (fondo y primer plano), que limitaban la vistosidad de los programas. Con la aparición de nuevas tarjetas como la CGA o la EGA se pudo disponer primero de cuatro colores y después de hasta 16 colores diferentes en la pantalla, con la que ya se podían hacer presentaciones más logradas, pero la tarjeta gráfica que ofreció unas prestaciones de calidad fue la tarjeta VGA que conseguía visualizar hasta 256 colores de forma simultánea, aunque en una resolución de 320 pixels de ancho por 200 de alto. También permitía resoluciones altas, de 640 x 480 pixels, aunque a 16 colores.
Para representar los colores el PC se sirve de una paleta que utiliza de forma parecida a la de los pintores. En ella se realizan mezclas para conseguir unas nuevas tonalidades o nuevos colores que se puedan necesitar.
Cada color está constituido por una mezcla tres colores básicos : el rojo, el verde y el azul. A estos se les llama componentes porque la union de estas tres dan como resultado un color. Por lo tanto, una paleta estará constituida por tres componentes para cada color. Para realizar estas mezclas se utiliza un sistema llamado RGB (del inglés red-green-blue) que combina estos tres colores básicos. El porqué de la utilización de este sistema es porque el monitor genera el color centrando los tres haces de luz en un solo punto. Cada haz es de un color básico, es decir, un haz es rojo, otro verde y el otro azul, por lo que al unirlos se verá en la pantalla el color que corresponda a la mezcla de las tres intensidades de cada haz. Basta con acercarse a una televisión para comprobar que cada punto está compuesto por tres pequeños puntos, cada uno activado con una intensidad.
De esta forma, para conseguir el color blanco las tres componentes deberán estar al máximo, y para conseguir el color negro las tres componentes deben estar a cero. Siguiendo la misma tónica, el color rojo más puro la tarjeta lo genera con R=63, G=0 y B=0. Podemos generar así hasta 262.144 colores, como se verá en el apartado "El DAC de la Tarjeta gráfica".
De esta manera, la paleta de colores tomando como referencia el modo 320x200 a 256 colores, es simplemente un array de 768 elementos (256 colores * 3 componentes cada uno = 768) conteniendo las componentes de estos 256 colores que la VGA guarda internamente para que, al redibujar la pantalla (puede consultarse el proceso de retrazado en la entrega anterior), cuando la tarjeta encuentra en la VideoRAM el numero 0, por ejemplo, va a esta tabla y activa los 3 haces para que generen esa tonalidad RGB.
La paleta gráfica por defecto tiene unas componentes determinadas de manera que siempre el color 0 es el negro, el 1 el azul, etc... Si miramos la paleta por defecto de la VGA, estos 768 elementos que contiene almacenados la tarjeta tendría un aspecto como:
Paleta_Defecto[768] =
{ 0,0,0, 0,0,17, ... etc ... };
El color 0 es negro porque sus componentes son (0,0,0). De la misma manera,
el color 1 es azul por defecto porque sus componentes son (0,0,17). El color
15 es blanco porque sus componentes son (63,63,63).Si queremos que el color 0 en vez de ser negro (0,0,0) sea un amarillo pálido, podemos cambiar dentro de este array interno los valores (0,0,0) por, por ejemplo, (23,44,0).
Paleta_Defecto[0] = 23; Paleta_Defecto[1] = 44; Paleta_Defecto[2] = 0;De esta misma manera, podemos cambiar el color 1, el 15, el 255... en resumen: podemos cambiar cualquier color a la tonalidad que deseemos. De ahí la necesidad de cambiar la paleta: para cada dibujo necesitamos unos colores en concreto (más verdes y menos rojos, todo grises, etc...).
En los ejemplos del CD que acompaña a la revista tenemos la imagen gráfica de una rosa. Este dibujo necesita muchos tonos de rosas que no hay en la paleta por defecto, y por eso necesitamos cambiar la paleta por defecto y elegir unas componentes que nos permitan disponer de estos colores. Por lo tanto cargamos la paleta original de la imagen (generada por el programa de dibujo durante su escaneado o creación), y que consiste en un array de 768 elementos con las componentes de los 256 colores. Ahora sólo necesitamos cambiar las componentes de la paleta por defecto por estas para que la tarjeta represente correctamente este dibujo.
El programa EJEMPLO3.EXE hace esto: primero carga en la VideoMemoria en 320x200 el dibujo de una rosa sin modificar la paleta (y por lo tanto ésta aparecerá con la paleta por defecto), y tras pulsar una tecla cambia esta paleta por la paleta correspondiente a la imagen.
El DAC (digital-analog converter) se utiliza para convertir las señales digitales que genera el ordenador a señales analógicas comprensibles por el monitor.
De esta forma, y si el monitor esta capacitado para ello, con sólo cambiar nuestra tarjeta de vídeo por otra con un DAC mejor se conseguirían más colores representables por la pantalla. El DAC de una tarjeta VGA es de 6 bits con lo que se consiguen 64 combinaciones diferentes para cada componente de color. Si recordamos, cada color tiene tres componentes diferentes(RGB), por lo que se puede calcular el numero de colores diferentes representable por una tarjeta VGA:
64 Rojos * 64 Verdes * 64 Azules = 64 ^ 3 = 262.144Este número es la cantidad de colores diferentes capaz de generar la VGA, pero no se pueden mostrar todos a la vez por la limitación de la paleta. Dependiendo del modo de vídeo podremos disponer de un número mayor o menor de colores; de esta forma de entre los 262.144 colores la paleta nos fuerza a coger un número determinado de ellos. Por ejemplo, un modo de 256 colores indica que la paleta tendrá 256 colores de los posibles 262.144, y modificando las componentes de cualquiera de estos colores podemos tener acceso a otras tonalidades de entre el total generable.
De esta forma, si se cambia la tonalidad de un color, la imagen no se ve afectada, sólamente que los puntos de la pantalla que tengan ese color cambiarán al nuevo tono. Es decir, si en un byte de la VideoMemoria se tiene el número 10, significa que en ese lugar de la pantalla se debe poner el color número 10.
Cuando el DAC retrazando la pantalla lee este valor, lee de la paleta (guardada por la tarjeta) las componentes del color 10 (r=Paleta[10*3], g=Paleta[10*3+1], b=Paleta[10*3+2]) y programa los 3 haces para que dibujen en pantalla esa tonalidad. Cambiando estas 3 componentes de la paleta, cuando el DAC lea otra vez este número, cogerá de este array interno las nuevas componentes y el color resultante en pantalla será el que nosotros deseábamos, sin necesidad de cambiar ningún dato del dibujo original. Por lo tanto la imagen no cambia, sólo cambia la tonalidad de todos los puntos de la pantalla que tengan dicho color.
Esto se puede ver ilustrado en la figura 1.
Para cambiar un color sólamente hay que cambiar sus tres componentes. Hay varias formas de hacerlo : utilizando las órdenes que el BGI pone a nuestra disposición, por medio de interrupciones o por medio de puertos. Para empezar veremos cómo se realiza por medio del lenguaje C.
Para poder utilizar la librería gráfica hace falta incluir en la cabecera del programa la librería <graphics.h> en la que se incluyen todas las funciones del BGI, pero nos centraremos en la función para cambiar la paleta : 'setrgbpalette()'. Esta función cambia el color por su RGB, por lo que tendrá como parámetros el número de color a cambiar y las tres componentes del nuevo color :
- setrgbpalette (numcolor, rojo, verde, azul); donde 'numcolor' es el número de la paleta que deseamos cambiar, y 'rojo', 'verde' y 'azul' son las tres componentes del color que queremos obtener.
Si se inicia el modo gráfico con un bloque ensamblador, no se podrán utilizar las funciones BGI porque requieren que se inicie el modo con la función initgtraph(), que inicia unas variables como el ancho o el alto de la pantalla para que el BGI pueda trabajar.
Se puede cambiar un sólo color o un bloque de colores de la paleta. Primero veremos cómo cambiar cualquier color con los servicios de la BIOS.
Hay una interrupción que nos hace este trabajo, y es la subfunción 1010h de la interrupción 10h. Para utilizar esta interrupción se deben pasar los parámetros como se muestra en la tabla 1. En CH, CL y DH se envían las tres componentes RGB (en este orden) que deben estar comprendidas entre 0 y 63. Cuando se hayan asignado los parámatros de entrada se llama a la interrupción 10h, y la BIOS se encarga de cambiar el color.
TABLA 1: Algunos servicios de la ROM BIOS para la paleta.
-----------------------------------------------------------------------
Servicio Parámetros de llamada Descripción
-----------------------------------------------------------------------
AX = 1010h BX = número de color Set One color register.
a cambiar. Cambia el color indicado
DH = valor rojo por Bx. Las componentes
CH = valor verde RGB se indican en Dh, DL
CL = valor azul y CL antes del int 10h.
------------------------------------------------------------------------
AX = 1012h ES:DX - Tabla donde se Set Block of Color reg.
indican las componentes. Cambia un bloque de colores.
BX = 1er color a cambiar (* ver nota)
CX = nº de colores que
se van a cambiar.
------------------------------------------------------------------------
AX = 1015h BX = nº de color a leer Read 1 color register.
Devuelve: Devuelve las 3 componentes
DH = rojo RGB del color indicado en BX.
CH = verde
CL = azul
-------------------------------------------------------------------------
AX = 1017h ES:DX - Tabla donde serán Read block of color reg.
guardados los colores. Lee las componentes RGB de
BX = 1er color a leer el nº de colores que se le
CX = Nº de colores a leer. indica en el array apuntado
por ES:DX.
--------------------------------------------------------------------------
(*) Nota:
En la tabla se indican las componentes de cada color
de forma sucesiva (R,G,B, R,G, B,...) por lo que la tabla
debe tener un tamaño de CX*3. Hay que informar a la interrupción
cuál va a ser el primer color a cambiar y cuántos.
LISTADO 1: Cambio de las componentes RGB de un color
void SetRGBColor( int color, char R, char G, char B);
{
asm {
mov ax, 1015h
mov bx, [color]
int 10h
mov dh, [R]
mov ch, [G]
mov cl, [B]
}
}
También se puede cambiar un bloque de colores de una sola vez, que podemos
utilizar para cambiar la paleta completa con una sola llamada. El servicio a
utilizar es el 1012h de la interrupción 10h, y la llamada a la interrupción
también está explicada en la tabla 1.Veamos un bloque de codigo que cambie toda la paleta entera, suponiendo que la nueva paleta está almacenada en un array de datos llamado 'paleta' y que se este trabajando con un modo de vídeo de 256 colores:
asm {
mov ax, seg paleta
mov es, ax
mov dx, offset paleta
mov ax, 1012h
mov bx, 0
mov cx, 256
int 10h
}
En el listado 2 encontramos la función SetPaletteBIOS() que realiza este
mismo trabajo. La instrucción assembler 'LES DX, paleta' carga en ES:DX el
segmento y el offset de un puntero far en C. Hemos de hacerlo así debido a que
a una función C no se le puede pasar un array completo, sino que hemos de
indicarle (mediante un puntero char far *) la dirección en memoria donde está
el array que le pasamos como parámetro. Podemos llamar a esta función con una
línea como:
SetPaletteBIOS( MiPaleta );siendo MiPaleta un array de 768 elementos conteniendo las componentes de los 256 colores, una tras otra.
LISTADO 2: Cambio de los 256 colores.
void SetPaletteBIOS (char far *paleta)
{
asm {
les dx, paleta
mov ax, 1012h
mov bx, 0
mov cx, 256
int 10h
}
}
El servicio de la BIOS a utilizar es el 1015h de la interrupción 10h, que lee un sólo registro de la paleta y nos devuelve su correspondiente RGB. En la tabla 1 se muestran los parámetros necesarios para su llamada, y el listado 1 es un ejemplo del empleo de este servicio.
Este bloque de código en C utiliza la función de leer un sólo color de la paleta. Esta función se puede utilizar para leer toda la paleta entera si la usamos dentro de un bucle; sin embargo, ya hay un servicio que nos devuelve las componentes de un bloque de colores. El servicio es el 1017h, como puede verse en la tabla 1.
Ahora ya se puede modificar cualquier color o bloque de colores para obtener presentaciones más profesionales, pero como se comentó en la entrega anterior, las interrupciones software son demasiado lentas. Para conseguir mayor velocidad se debe acceder más directamente a la tarjeta de video, a través del DAC. El acceso al DAC consiste en el acceso directo a los registros de la tarjeta gráfica "conectados" al controlador del DAC, de manera que pasamos directamente a controlar el hardware de la tarjeta de una forma más profesional.
TABLA 2: Registros del DAC
---------------------------------------------------------------------------
Registro: PEL Address Read Mode Register
Puerto: 03c7h
Función: Expresa dentro de la tabla interna de 256 colores (PEL) el
color al que apunta el puntero interno del DAC cuando leemos
la paleta del puerto 0c39h (PEL DATA REGISTER). Cada 3 lecturas
del puerto 3c9h este registro se incrementa en 1 (cada 3
componentes leidas se incrementa el puntero para que se refiera
al siguiente color).
----------------------------------------------------------------------------
Registro: PEL Address Write Mode Register
Puerto: 03c8h
Función: Apunta dentro de la tabla interna al color que se modificará
al realizar 3 escrituras en el PEL DATA REGISTER. Tras estas
3 escrituras en el puerto 03c9h el puntero se incrementa en 1
para hacer referencia al siguiente color dentro de la tabla PEL.
----------------------------------------------------------------------------
Registro: PEL Data Register
Puerto: 03c9h
Función: Mediante este puerto podemos modificar o leer la paleta interna
de la tarjeta gráfica. Al escribir un valor en este puerto el
DAC lo almacena dentro de la paleta actual en la dirección
apuntada por el puntero de escritura, e igual para la lectura.
Este puerto constituye para el programador la ventana a través
de la cual modificar la paleta de la tarjeta, conjuntamente con
los registros PEL Address Read y PEL Address Write, que nos
permiten seleccionar el color a leer o escribir. Tras esta
selección los 3 valores leidos/escritos en este puerto
constituirán las componentes RGB del color.
----------------------------------------------------------------------------
Los puertos 0x3C7 y 0x3C8 actúan como punteros hacia la paleta, es decir, el
valor enviado a estos puertos indica el color dentro de la paleta de 256
colores que debe ser leido o escrito mediante el acceso al puerto 0x3C9.Por ejemplo, en el caso de que se utilice el puerto 0x3C9 para lectura (se lee un valor de él), nos devolverá las componentes correspondientes al color indicado en 0x3C7.
Al utilizar el puerto 0x3C9 automáticamente se incrementa el puntero (al realizar 3 lecturas o 3 escrituras), por lo que al volver a utilizar el puerto nos devolverá las componentes del siguiente color. Así, se pueden leer o escribir más de un color de forma consecutiva sin utilizar cada vez el puerto 0x3C7 ó el 0x3C8, sólamente llamando al puerto 0x3C9 para cada componente que se quiera leer o escribir.
Suponiendo que se quiera modificar las componentes de un color de la paleta por otras diferentes, los pasos a seguir serian los siguientes:
1.- Enviar al puerto 0x3c8 el º de color a cambiar
(dirección para escritura).
2.- Enviar al puerto 0x3c9 la primera componente del
nuevo color (rojo)
3.- Enviar al puerto 0x3c9 la segunda componente
del nuevo color (verde)
4.- Enviar al puerto 0x3c9 la tercera componente del
nuevo color (azul)
De forma práctica, un listado en C sería:
outportb (0x3C8, num_color); outportb (0x3C9, rojo); outportb (0x3C9, verde); outportb (0x3C9, azul);También se puede hacer con un bloque en ensamblador dentro del C para mayor rapidez, usando las instrucciones assembler 'IN' y 'OUT'. La instrucción 'IN AL, DX' lee del puerto DX el valor que contiene y lo almacena en AL. De la misma manera, 'OUT DX, AL' escribe en el puerto DX el valor contenido en el registro AL. Tan sólo hemos de cargar los registros con los valores correctos para evitar las llamadas a funciones C (como outportb() e inportb(), que además de ser más lentas que el bloque assembler, requieren la inclusión del fichero DOS.H).
asm {
mov dx, 0x3C8
mov al, [numcolor]
out dx, al
mov dx, 0x3C9
mov al, [rojo]
out dx, al
mov al, [verde]
out dx, al
mov al, [azul]
out dx, al
}
Para acelerar el proceso se puede trabajar sobre un array que contenga los valores de la paleta para luego poner toda la paleta entera de una sola vez, utilizando la instrucción de ensamblador 'rep outsb' que es más rápido que poner cada valor de la paleta de forma individual. La instrucción outsb (instrucción utilizable a partir del procesador 80188), escribe en el puerto DX el valor contenido en DS:[SI], e incrementa SI. El prefijo REP repite esta instrucción el número de veces especificado en el registro CX, por lo que podemos enviar la paleta completa (el array de 768 elementos) al DAC con el siguiente pseudocódigo:
DS:SI = Array[0] DX = 3C8h Puerto[3C8h] = 0 DX = 3C9h CX = 256*3 = 768 REP OUTSBEste bloque de pseudocódigo selecciona (mediante la escritura en el puerto 03C8h) la modificación del color 0.
A continuación el REP OUTSB manda CX bytes desde DS:SI (nuestro array conteniendo los 768 elementos RGB) al puerto 3C9h. Los primeros 3 bytes del array son las componentes del color 0, los 3 siguientes del color 1, etc. De esta manera, como cada 3 escrituras al puerto 3C9h se incrementa el color que estamos modificando, al enviar 256*3=768 bytes estamos cambiando la paleta completa.
Como ejemplo más concreto del cambio de los 256 colores de la paleta puede examinarse el listado 5, que contiene la función SetPalette(). El proceso de lectura es similar al de escritura, pero usando la función INSB, que lee del puerto especificado en DX y lo almacena en ES:[DI], incrementando DI en 1. De esta manera podemos leer también un bloque de colores a un array apuntado por ES:DI.
LISTADO 5: Lectura con acceso directo al DAC.
void SetPal (char far *paleta)
{
lds si, paleta
mov cx, 768
xor al, al
mov dx, 3c8h
out dx, al
inc dx
rep outsb
}
Ahora que ya sabemos leer y escribir los colores de la paleta (tanto un sólo
color como un bloque completo de ellos), podemos hacer varios efectos con la
paleta. El primero que se va a ver es el fundido a negro, en el que se tiene
una pantalla y la hacemos desaparecer de la pantalla de forma suave.
El fundido a negro va reduciendo de cada color sus correspondientes componentes de forma progresiva. Así, todos los colores tenderán a oscurecerse hasta convertirse en negro.
Para empezar nuestro programa debe tener un bucle que se repita 63 veces, debido a que el 63 es el máximo valor que puede tener una sola componente.
Dentro de este bucle debe comprobarse el valor de las componente de cada color. Si es mayor que cero, se debe decrementar el valor de dicha componente, y si es cero, no decrementarlo y pasar a la siguiente componente.
Al finalizar el bucle todos los colores tendrán el mismo RGB (0,0,0) que corresponde al color negro. Así, aunque en la pantalla esta la misma imagen, no se ve nada porque todos los colores de la paleta son negros. Es un efecto bastante sencillo de realizar, como puede verse en el listado 3. La espera al retrazo vertical antes de cambiar la paleta se hace por 2 causas: la primera, ralentizar el efecto para que pueda ser visto. La segunda, evitar el parpadeo (conocido en lenguaje informático como "snow", nieve) que se produce al cambiar la paleta durante el retrazado de las imágenes. Podemos hacer un fundido más lento esperando 2, 3 o más retrazos, para conseguir distintas velocidades.
TABLA 3: Status Register: retrazo vertical.
0x3DA (read) Significado
-------------------------------------------------------------
bit 0 Si está activado, está ocurriendo un
retrazo horizontal o vertical
bit 3 Si está activado se está haciendo un
retrazo vertical
-------------------------------------------------------------
El listado 3 es un ejemplo de fundido a negro, en el que se pueden ver las
distintas partes del proceso del fundido.Se debe hacer una copia de la paleta antes de hacer el fundido si se quiere volver a utilizar la paleta original de la pantalla, por ejemplo para volver a poner la paleta correspondiente a la imagen.
LISTADO 3: FadeOut:
void FadeOut(void)
{
char paleta[768];
int x, y;
GetPalette (paleta);
for (y=0; y<63; y++)
{
for (x=0;x<768;x++)
if (paleta[x] > 0) paleta[x]--;
WaitVRetrace ();
SetPalette(paleta);
}
}
La diferencia con el ejemplo anterior es que ahora la comprobación no se hace sobre el cero, sino sobre el valor de la paleta que se desea obtener. Por tanto, el bucle debe realizarse de forma inversa al caso anterior, en vez de decrementar cada elemento de la paleta, debe incrementarse desde 0 hasta el color indicado en la paleta final.
Este ejemplo está ilustrado en el listado 4.
LISTADO 4: Fade IN:
void FadeIn ( char *paleta )
{
char pal[768];
int x, y;
for (y=0;y<768;y++) pal[y] = 0;
for (y=0; y<63; y++)
{
for (x=0;x<768;x++)
if (pal[x] < paleta[x]) pal[x]++;
WaitVRetrace();
SetPalette(pal);
}
}
Para este efecto se debe conseguir que se desplacen los colores hacia un lado, y el último pase a ser el primero para que se mantengan los colores de la paleta, sino el último color se perdería (o el primero, dependiendo del sentido de giro de los colores). Para mover un color deben desplazarse las tres componentes conjuntamente, por lo que se debe de tratar a la paleta no por sus 768 componentes, sino como 256 colores compuesto cada uno por un RGB. Además después de cada rotación se debe poner la nueva paleta para ver el efecto en la pantalla, sino se rotaría la paleta en el array pero en pantalla no se vería ningún cambio.
Por tanto, en un modo de 256 colores se debe realizar un bucle que se repita 256 veces (0..255) y desplace cada vez un color.
Si se dejara la paleta así el ultimo color se perdería y el primer color no se cambiaría, por lo que para este efecto se debe mover el ultimo color a la primera posición.
Una posible solución sería la siguiente:
char R, G, B;
R = paleta[765];
G = paleta[766];
B = paleta[767];
for (x=3;x<768;x+=3)
{
paleta[x] = paleta[x-3];
paleta[x+1] = paleta[x-2];
paleta[x+2] = paleta[x-1];
}
paleta[0] = R;
paleta[1] = G;
paleta[2] = B;
Con este proceso se obtiene la paleta rotada. Una vez acabado el proceso debe
colocarse esta paleta con los métodos que se han explicado anteriormente
(mediante el DAC, interrupciones del MS-DOS, etc.) para que en pantalla
aparezca la paleta ya rotada. Si se repite el proceso se obtiene una rotación
contínua de la paleta.
Hasta entonces, el análisis de los ejemplos incluidos en el CD que acompaña a la revista, así como los documentos que se incluyen, permitirá profundizar en la programación de la paleta.
Pulse aquí para bajarse los ejemplos y listados del artículo (53 Kb).
Figura 1: "Relación entre los valores en VRAM y la paleta."
Santiago Romero