Desarrollo de Videojuegos


Matemáticas Básicas
Álbegra Matricial. Modelado alámbrico de figuras 3D


Artículo realizado por
David Isla "Cid"





Capítulo 3.
Sistema alámbrico.

Como ya muchos deduciréis del título, este capitulo se encarga del diseño de un pequeño sistema para dibujar líneas que formen un modelado alámbrico. En realidad esta basado en funciones que actuaran con matrices y una lista que contendrá las líneas a dibujar. Definiremos qué líneas queremos en nuestra figura, y mas tarde usaremos funciones que también diseñaremos aquí para modificar los puntos origen y fin de cada línea usando el álgebra matricial, para que lo veáis mejor pasemos de lleno a ello.

La lista de líneas

Lo primero que tenemos que tener para construir el modelo son sus líneas, ¿no? y si queremos que el sistema sea algo manejable, podríamos utilizar alguna clase en la que nos sea fácil sumar, modificar o quitar líneas a nuestro antojo. Yo pensé en la clase de las MFC Carray. Esta clase nos permite todo lo anteriormente citado, es decir, permite que la lista pueda crecer indefinidamente y además, guarda cualquier tipo de dato.

Para nosotros nos basta con que guarde un dato al que llamaremos Linea. Este dato contendrá los valores X,Y,Z originales (los que se dieron cuando se sumaron a la lista) y los valores XPantalla, YPantalla, ZPantalla de trabajo que usaremos para calcular las nuevas posiciones. Esto último evitará que perdamos la referencia de dónde estaban las líneas originalmente. Con todo lo dicho anteriormente, podríamos definir una estructura como sigue:






   // Vertices

   struct Vertice

   {

	double nX;

	double nY;

	double nZ;

	double nXPantalla;

	double nYPantalla;

	double nZPantalla;

   };



   // Lineas

   struct Linea

   {

	Vertice Inicio, Final;

   };

Si queremos guardar estructuras del tipo Lineas en la clase CArray, definiremos una instancia de esta de la forma siguiente:






   CArray<Linea,Linea     oLineas;      // Lineas del dibujo

Esta línea de código, define una lista llamada oLineas, que contendrá datos del tipo Linea (pudiera haber sido un tipo básico como un int, un double, una estructura o un objeto, en definitiva, cualquier cosa). Con ella tenemos tres operaciones fundamentales que nos van ha ser de mucha ayuda, estas operaciones son Add, GetAt y SetAt, es decir:


   oLineas.Add( Linea );

   oLineas.GetAt( N );

   oLineas.SetAt( N, Linea );

la primera función, esto es, Add, suma la línea Linea a la lista. GetAt devuelve la línea colocada en la posición N y la tercera operación, SetAt, modifica la línea N y la iguala a Linea. Como decíamos anteriormente, tenemos ya las operaciones de sumar y modificar, y nos faltaría las de eliminar que, aunque no la utilizaremos para este ejemplo os, la comento:


   oLineas.RemoveAt( N );

RemoveAt lo que hará será eliminar la línea colocada en N.

Las funciones que multiplican vectores y matrices

Usaremos dos funciones para realizar los cálculos. Una multiplicará matrices de 4x4 dimensiones y la otra multiplicará vectores de cuatro elementos por matrices de 4x4 dimensiones. Al principio de estos artículos dejé claro que no iba a dar una "tésis doctoral" sobre álgebra matricial, por eso el código no está documentado. Lo que os quiero es ahorrar el tiempo que os supondría aprender ahora álgebra matricial (aunque si alguien se anima es lo mejor que hace, las matematicas en videojuegos son muy importantes, y esta especialmente en el campo de las 3D), pensad en estas funciones como funciones de librería, que portáis a vuestras aplicaciones.




void MultiplicarMatriz( double Resultado[4][4],

                        double Matriz1[4][4],

                        double Matriz2[4][4] )

{

   for( int i=0; i <4 ; i++ )

   {

      for( int j=0; j <4 ; j++)

      {

         Resultado[i][j] = 0;

         for( int k=0; k<4 ; k++ )

         Resultado[i][j] += Matriz1[i][k] * Matriz2[k][j];

      } 

   }

}



void MultiplicarVector( double Resultado[4],

                        double Matriz1[4],

                        double Matriz2[4][4] )

{

   Resultado[0] = Matriz1[0]*Matriz2[0][0] +

                  Matriz1[1]*Matriz2[0][1] +

                  Matriz1[2]*Matriz2[0][2] +

                  Matriz1[3]*Matriz2[0][3];

   Resultado[1] = Matriz1[0]*Matriz2[1][0] +

                  Matriz1[1]*Matriz2[1][1] +

                  Matriz1[2]*Matriz2[1][2] +

                  Matriz1[3]*Matriz2[1][3];

   Resultado[2] = Matriz1[0]*Matriz2[2][0] +

                  Matriz1[1]*Matriz2[2][1] +

                  Matriz1[2]*Matriz2[2][2] +

                  Matriz1[3]*Matriz2[2][3];

   Resultado[3] = Matriz1[0]*Matriz2[3][0] +

                  Matriz1[1]*Matriz2[3][1] +

                  Matriz1[2]*Matriz2[3][2] +

                  Matriz1[3]*Matriz2[3][3];

}

¡¡¡Y ya esta!!!

Estamos preparados para hacer un programa que maneje gráficos en 3D teniendo la lista de líneas y las operaciones para trabajar con ellas. Sólo nos falta montar una aplicación que reúna todas estas operaciones. Eso lo haremos en el siguiente capítulo, utilizando Visual C++.



Puedes conseguir el código fuente del artículo pulsando aquí


ÚLTIMA REVISIÓN EN FEBRERO DE 1999




DESARROLLO DE VIDEOJUEGOS
a
MACEDONIA Magazine