Después de 8 tutoriales de programación en 2D, seguro que ya empezabais a echar de menos comenzar con la programación en 3D. Puede que al principio os cueste un poco, pero os aseguro que los resultados merecen la pena. El Hardware de la Wii bien merece que sepáis sacarle partido a su procesador gráfico. Entrad leed y juzgarlo por vosotros mismos. Veréis como pronto estareis creando el código fuente de vuestro propio programa en 3D y comprobaréis que vuestras creaciones adquieren una apariencia espectacular.

PROGRAMACIÓN EN 3D CON GRRLIB

Devkitpro suministra una biblioteca de programación en 3D llamada GX que es bastante compleja de utilizar. GRRLIB se basa en GX simplificando todo lo que hace complicada la programación en 3D.

A los que conocen algo la programación en 3D tengo que decirles que GX tiene ciertos aspectos parecidos a OpenGL, pero no coincide con éste en muchos otros aspectos. De todas formas conocer OpenGL es una ventaja a la hora de aprender programación en 3D para Wii.

Comenzaremos el curso con algunos conceptos básicos de programación tridimensional para luego continuar con la programación específica de GRRLIB

REPRESENTACIÓN TRIDIMENSIONAL

Hasta ahora hemos utilizado un sistema de coordenadas bidimensional que nos era suficiente para representar nuestra escena en el plano de la pantalla de nuestro televisor. Es decir utilizábamos dos coordenadas (x,y) para representar la posición de un objeto en ese mundo, tomando como referencia la esquina superior izquierda de la pantalla.

Si queremos representar nuestro mundo en 3D necesitaremos una coordenada adicional (z).

Además nos será mucho más práctico situar el origen de coordenadas en el centro de la pantalla para permitir una representación mediante perspectiva.

Hasta aquí podría ser suficiente si nos limitáramos simplemente a dibujar objetos simples en un espacio limitado en 3D, pero cuando modelamos nuestro mundo en tres dimensiones debemos tomar en consideración muchos más factores, como es la posición del observador, las luces de la escena o la información de la composición de las superficies de los objetos.

Además nos resultará muy interesante el poder cambiar el sistema de referencia o realizar transformaciones de rotación, traslación y escalado sobre los objetos.

Es por ello que para el modelado en 3D nos hemos de apoyar en sistemas un poco más sofisticados en los que tendremos en cuenta los siguientes elementos:

Posición de la cámara o del observador.
Campo de visión. Es decir distancia mínima y máxima de visibilidad desde la cámara y ángulo de visión.
Sistema de coordenadas mundiales, que es como denominaremos a nuestro sistema de coordenadas de tres ejes con origen en el centro de la pantalla, tal y como lo hemos definido anteriormente.

A la hora de representar un objeto nuestra Wii no puede utilizar directamente las coordenadas de dibujo que nosotros le pasamos, ya que la pantalla del televisor no puede representar objetos tridimensionales. En realidad lo que vemos es una representación en dos dimensiones de de ese dibujo en 3D. Es decir vemos lo que llamamos una proyección en 2D de una escena en 3D.

Para calcular esa proyección, nuestra Wii debe tener en cuenta la posición del observador, el ángulo de visión y las transformaciones sobre los objetos.

Todas estas transformaciones se realizan mediante cálculo matricial, pero no os preocupéis que todo esto lo calculará nuestra Wii automáticamente, aunque sí que deberemos conocer por encima este proceso para comprender qué parámetros de configuración debemos usar.

TRANSFORMACIONES DEL MODELO DE VISTA

Para entender a que nos referimos con esto debemos tener en cuenta que lo que se va a ver en nuestra pantalla depende directamente del punto de vista desde donde lo miramos. Es decir del punto donde esté situada la cámara.

El hardware de la Wii nos mostrará lo que se ve desde ese punto de vista que debemos definir.

TRANSFORMACIONES DE MODELO

Llamamos transformaciones de modelo a las que se aplican sobre los objetos para modificarlos y que alcancen su posición definitiva antes de pasar a proyectar el resultado en coordenadas 2D.

Las transformaciones de vista que utilizaremos son Translación, Escalado y Rotación.

Tenemos que tener en cuenta que aquí es muy importante el orden de los factores. No es lo mismo mover un objeto y luego rotarlo que rotarlo y después moverlo.

En las figuras podéis ver un ejemplo de lo que os hablo.

Primero traslación y luego rotación.....

Primero rotación y luego traslación......

Como veis los resultados son totalmente diferentes.

TRANSFORMACIONES DE PROYECCIÓN

Si os fijáis en cómo se ven los objetos en el mundo real os daréis cuenta que cuando más lejos está un objeto más pequeño se ve. Esto es debido a que nuestra visión tiene un campo mayor según nos alejamos de nuestros ojos.

En un modelo 3D si representáramos todos los puntos del mismo tamaño no conseguiríamos ese efecto, ya que el objeto tendría el mismo tamaño por muy alejado que estuviera del observador.

Es por ello que una vez nuestra Wii tiene calculado el mundo en su posición final debe realizar unas transformación adicional que se llama transformación de proyección, para ello utiliza el ángulo de visión que nosotros le definiremos para empequeñecer la imagen según se aleja de la posición en la que le hemos dicho que está el observador.

TIPOS DE ILUMINACIÓN

Pero por mucho que diseñemos necesitamos iluminar la escena para que podamos ver el resultado.

Al igual que en OpenGL, el hardware de Wii permite cuatro diferentes tipos de iluminación; Iluminación ambiente, iluminación difusa, iluminación especular e iluminación de foco (o spot).

El color final de un punto de la pantalla dependerá del tipo (o tipos) de iluminación que intervengan en la escena.

Iluminación ambiente. Es aquella luz que se trasmite por igual en todas direcciones y que no viene de ningún sitio concreto.

Iluminación difusa. Al igual que la luz ambiente, la luz difusa se transmite en todas direcciones por igual, pero a diferencia de aquella, sí que tiene un punto de origen. La luz difusa además, se va atenuando según se aleja del punto de origen.

Iluminación especular. Se trata de una luz que rebota según la normal del polígono que ilumina. Con dicha luz se consiguen efectos de reflejo.

Iluminación de foco. En este caso la luz tiene el comportamiento de un foco. Parte de un punto en concreto y se transmite según un cono de luz que va ensanchándose según se aleja del punto de origen.

FUNCIONES 3D EN GRRLIB

Como os dije más arriba, GRRLIB está pensado para facilitarnos la vida. Si programáramos directamente en GX, para definir nuestro mundo en 3D necesitaríamos un montón de funciones definiendo todos y cada uno de los parámetros de nuestro universo. GRRLIB sin embargo define la mayoría de los parámetros por nosotros, pudiendo definir nuestro espacio 3D con tan solo unas pocas funciones.

Vamos a comenzar paso por paso a explicar las funciones fundamentales.

Lo primero que debemos hacer antes de empezar a modelar es indicarle a nuestra Wii que lo siguiente van a ser instrucciones en 3D y de paso decirle como debe realizar las transformaciones de proyección, es decir cómo es nuestro ángulo de visión.

Para ello utilizaremos la función GRRLIB_3DMode:

void GRRLIB_3dMode ( f32 minDist, f32 maxDist, f32 fov, bool texturemode, bool normalmode )
Cambia a modo 3D y configura la matriz de posición
Parametros
minDist: Distancia mínima a la camara.
maxDist: Distancia máxima a la camara.
fov: (Field Of View) Campo de visión de la cámara
texturemode: 
	false, GX no usará coordenadas de textura. 
	true, GX Usará coordenadas de textura.
normalmode:
	false, GX no usará coordenadas normales.
	true, GX usará coordenadas normales.

Como veis dependiendo del ángulo que le pasemos en el parámetro fov el campo de visión será mayor o menor.

La función nos pide dos parámetros booleanos en los que deberemos decirle a GRRLIB si los objetos que vamos a dibujar llevan o no texturas y si vamos a definir los vectores normales de las superficies del objeto.

En esta primera entrega en 3D vamos a trabajar sin texturas y con normales por lo que llamaremos a la función con el primero de estos dos parámetros con valor "false" y el segundo "true". Tendremos tiempo en entregas posteriores de explicar estos dos aspectos.

Para cambiar la posición y el objetivo de la cámara podemos usar la función GRRLIB_Camera3dSettings:

void GRRLIB_Camera3dSettings ( f32 posx, f32 posy, f32 posz, f32 upx, f32 upy, f32 upz, f32 lookx, f32 looky, f32 lookz )
Asigna los parámwetros de la cámara
Parametros
posx posición x de la cámara.
posy posición y de la cámara.
posz posición z de la cámara.
upx componente x de la posición "arriba" de la cámara.
upy componente y de la posición "arriba" de la cámara.
upz componente z de la posición "arriba" de la cámara
lookx posición x del punto al que mira la cámara.
looky posición y del punto al que mira la cámara.
lookz posición z del punto al que mira la cámara.

Hay que tener en cuenta que, a partir de ese momento, si queremos utilizar funciones en 2D deberemos llamar a la función GRRLIB_2dMode.

GRRLIB_2dMode();

Pero dejemos por ahora el 2D a un lado y volvamos a nuestro espacio en 3D.

Una vez hemos definido nuestro sistema de proyección y antes de empezar a dibujar, tenemos que indicarle a GRRLIB cuáles son las transformaciones que vamos a aplicar a todo lo que vayamos a dibujar a continuación.

Para ello tenemos varias posibilidades:

void GRRLIB ObjectView ( f32 posx, f32 posy, f32 posz, f32 angx, f32 angy, f32 angz, f32 scalx, f32 scaly, f32 scalz )
Configura la matriz de vista (en este orden escala, rotación y translación).
Parametros
posx coordenada de posición x del objeto.
posy coordenada de posición y del objeto.
posz coordenada de posición z del objeto.
angx angulo de rotación x del objeto.
angy angulo de rotación y del objeto.
angz angulo de rotación z del objeto.
scalx escala x del objeto.
scaly escala y del objeto.
scalz escala z del objeto.

La función GRRLIB_ObjectView aplica un escalado, una rotación y una traslación exactamente en ese orden.

Es decir, primero escalará los objetos multiplicando la magnitud de sus coordenadas x por scalx, la de sus coordenadas y por scaly y la de sus coordenadas z por scalz.

Después girará el resultado en un ángulo angx tomando el ejex como eje de rotación, con un ángulo angy sobre el eje y, y con un ángulo angz sobre el eje z.

Por último trasladará el resultado a la posición posx, posy, posz.

Esta función tiene su razón de ser en que ese es el orden más habitual en el que se aplican las transformaciones, aunque no nos sirve de mucho si queremos aplicar las transformaciones en otro orden.

void GRRLIB_ObjectViewInv ( f32 posx, f32 posy, f32 posz, f32 angx, f32 angy, f32 angz, f32 scalx, f32 scaly, f32 scalz )
Configura la matriz de vista (en este orden escala, translación y rotación).
Parametros
posx coordenada de posición x del objeto.
posy coordenada de posición y del objeto.
posz coordenada de posición z del objeto.
angx angulo de rotación x del objeto.
angy angulo de rotación y del objeto.
angz angulo de rotación z del objeto.
scalx escala x del objeto.
scaly escala y del objeto.
scalz escala z del objeto.

La función GRRLIB_ObjectViewInv es idéntica a la anterior pero intercambia el orden de la rotación y la traslación. Es decir, primero escala, después traslada y por último rota.

Como podéis ver, este sistema aunque sencillo, es muy rígido y se ve enseguida la necesidad de una forma más flexible de aplicar transformaciones, que nos permita elegir el orden en el que realicemos las mismas.

GRRLIB nos provee de funciones de rotación traslación y escalado independientes que nos permitirán elegir el orden que se nos antoje.

GRRLIB nos pide que le indiquemos cuando empiezan y cuando terminan las transformaciones. Para ello disponemos de dos funciones GRRLIB_ObjectViewBegin() y GRRLIB_ObjectViewEnd().

Todas las transformaciones que queramos realizar deberemos ponerlas entre estas dos funciones.

void GRRLIB_ObjectViewBegin (void)
Inicializa la matriz de objetos.
 
void GRRLIB_ObjectViewRotate ( f32 angx, f32 angy, f32 angz )
Gira la matriz de vista
angx angulo de rotación x del objeto.
angy angulo de rotación y del objeto.
angz angulo de rotación z del objeto.
 
void GRRLIB_ObjectViewScale ( f32 scalx, f32 scaly, f32 scalz )
Escala la matriz de vista
scalx escala x del objeto.
scaly escala y del objeto.
scalz escala z del objeto.
 
void GRRLIB_ObjectViewTrans ( f32 posx, f32 posy, f32 posz )
Traslada la matriz de vista
posx coordenada de posición x del objeto.
posy coordenada de posición y del objeto.
posz coordenada de posición z del objeto.
 
void GRRLIB_ObjectViewEnd (void)
Concatena la matriz de objetos con la de vista y calcula la inversa de la matriz normal

En el siguiente ejemplo todos los objetos que dibujemos a continuación sufrirán las siguientes transformaciones:

Primero se girarán 30 grados sobre el eje Y.
Después se moverán 20 unidades sobre el eje X.
Luego se escalarán al doble de su tamaño sobre el eje Y
Por último se girarán 10 grados sobre el eje X y 60 sobre el eje Z

GRRLIB_ObjectViewBegin();
 
GRRLIB_ObjectViewRotate(0,30,0);
GRRLIB_ObjectViewTrans(0,20,0);
GRRLIB_ObjectViewScale(2,1,1);
GRRLIB_ObjectViewRotate(10,0,60);
 
GRRLIB_ObjectViewEnd();

FUNCIONES DE DIBUJO DE OBJETOS

Todo lo anterior está muy bien, pero no tiene ninguna utilidad si no dibujamos nada.

En GX todo se dibuja a base de triángulos o de Quads o cuadriláteros (que no son más que un par de triángulos unidos por su base). No existen las superficies curvas. Estas las deberemos simular a base de juntar triángulos.

En la figura podemos ver un ejemplo de un toro circular formado por triángulos.

Como esto es muy complicado para determinadas figuras, GRRLIB nos suministra una serie de funciones que nos permiten dibujar algunas de las formas geométricas más usuales.

Todas ellas se basan en repetir quads (figuras de cuatro lados) que, como hemos dicho antes, son al fin y al cabo parejas de triángulos.

void GRRLIB_DrawCube (f32 size, bool filled, u32 col)

Dibuja un cubo de lado size. Esta es la figura más sencilla ya que cada una de sus caras son directamente quads.