Introducción a Motores 3D (parte 2)

Representación en pantalla

En el post anterior mencionaba que para crear nuestro mundo 3D encontraríamos dos grandes desafíos: la modelación de los objetos en estructuras de datos y la representación de estos en nuestra pantalla 2D.

Mostré un poco, de manera general, la modelación de los objetos; ahora hablaremos de la representación de estos.

La representación de objetos 3D no es un tema fácil, requiere que el programador, no solamente sea un buen programador y conocedor del lenguaje, sino que además debe tener bastantes conocimientos de vectores, albegra lineal, física, geometría analítica, trigonometría, análisis numérico, etc.

A pesar de que nuestro modelo almacena la información en tres dimensiones, debemos transformar esta información a dos dimensiones para representarlo en el monitor. Este cálculo matemático es demasiado complejo, y aunque es posible realizarlo, nos tomaría demasiado tiempo y además ya existen herramientas que lo hacen por nosotros. Una de estas herramientas es OpenGL, éste nos brinda las funciones necesarias para poder realizar estta transformación de nuestro modelo 3D al monitor 2D.

Los objetos pasan por una serie de transformaciones para poder llegar a la representación final, estas transformaciones son:

• Modelview Transformation
• Projection Transformation
• Perspective Division
• Viewport Transformation

Modelview Transformation

En este paso, las coordenadas locales de cada objeto son tomadas y transformadas para darles una posición en el mundo 3D. Como pudimos ver anteriormente, las coordenadas que tenemos almacenadas en nuestro modelo, son coordenadas relativas al objeto y no a su posición en el mundo. En este paso, el objeto es movido a la posición que debe tener en el mundo 3D, ya sea a través de rotaciones, traslaciones o escalamientos. Es importante apuntar que la apariencia final del objeto depende del orden en que se apliquen estas transformaciones. Ejemplo:

En el inciso a) aplicamos primero una rotación al objeto y luego una traslación sobre el eje x, dado que su eje x está rotado se mueve diagonalmente. En el inciso b) aplicamos las mismas transformaciones pero en orden inverso, obteniendo así un resultado diferente.

Además de estas operaciones, se debe tomar en cuenta también la posición de la cámara, lo que transformará entonces nuestras coordenadas anteriores a unas nuevas que dependen del punto de vista del observador.

Para lograr este tipo de transformaciones, OpenGL utiliza una matriz llamada la GL_MODELVIEW matrix. Cada vértice es multiplicado por los valores de esta matriz dándole así su posición real en el mundo. Es decir, que para cada objeto, debo almacenar información que me indique cómo ubicarlo en la posición q deseo. Aplico primero las transformaciones para modificar la matriz y luego voy calculando el valor de cada vértice. Para el ejemplo del inciso a) tendríamos un código similar a este:

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glRotatef(10, 0.0f, 0.0f, 1.0f);
glTranslatef(10.0f, 0.0f, 0.0f);

La primera instrucción le indica a OpenGL con qué matriz vamos a trabajar. Luego cargamos en ella la matriz identidad y luego aplicamos las operaciones de rotación y traslación. Una vez que hemos realizado todas las transformaciones que deseamos para el objeto, le decimos a OpenGL cuáles son los vértices que queremos representar:

glBegin(GL_TRIANGLES);
for (j=0; j<numPolygons;j++) {
//----------------- FIRST VERTEX -----------------
glColor3f(polygon[j].red,polygon[j].green,polygon[j].blue);
glVertex3f( vertex[ polygon[j].vertex[0] ].x, vertex[ polygon[j].vertex[0] ].y,vertex[ polygon[j].vertex[0] ].z);

//----------------- SECOND VERTEX -----------------
glColor3f(polygon[j].red,polygon[j].green,polygon[j].blue);
glVertex3f( vertex[ polygon[j].vertex[1] ].x, vertex[ polygon[j].vertex[1] ].y,vertex[ polygon[j].vertex[1] ].z);

//----------------- THIRD VERTEX -----------------
glColor3f(polygon[j].red,polygon[j].green,polygon[j].blue);
glVertex3f( vertex[ polygon[j].vertex[2] ].x, vertex[ polygon[j].vertex[2] ].y,vertex[ polygon[j].vertex[2] ].z);
}
glEnd();

glBegin le dice a OpenGL el tipo de polígono que vamos a utilizar para representar nuestro objeto. gl Color3f es para indicar el color y glVertex3f es para indicar las coordenadas de cada vértice.

Como podemos ver, se requiere entonces almacenar por cada objeto una matriz para ubicar el objeto en la posición correcta, por lo que en nuestra definición de la clase Object3D debemos añadir esta estructura de datos. La matriz es una matriz 4x4, la explicación del funcionamiento de esta matriz es un tema que esta fuera del objetivo de este post, pero que puede ser deducido a través de un breve análisis matemático. Puede consultarse el siguiente link: http://www.geocities.com/valcoey/intro3d.html

Introducción a Motores 3D

Como lo prometí en un post hace mucho tiempo, quisiera explicar un poco acerca de lo que he aprendido de los motores 3D y la implementación de estos en OpenGL.

Un motor 3D es un programa que nos permite movernos a través de un mundo 3D visualizando objetos 3D en una pantalla 2D, a través de una serie de algoritmos complejos que utilizan la información almacenada en estructuras de datos creadas para este fin.

Podemos realizar un programa que imprima objetos 3D en la pantalla, pero implementar un motor que nos permita movernos dentro de un mundo tridimensional puede ser una tarea realmente compleja. Intentaré, a través de una serie de posts, explicar algunos principios básicos para la implementación de un motor 3D sencillo.

La tarea de crear nuestro mundo 3D contiene dos grandes desafíos:

• La modelación de los objetos en estructuras de datos adecuadas


• La representación de estas estructuras en nuestra pantalla 2D

Las Estructuras de Datos

Para poder crear un mundo 2D en una computadora quizás la utilización de archivos de imagenes, animaciones o dibujado de estructuras geométricas pueda bastarnos; pero, ¿cómo representar en nuestra computadora un objeto tridimensional, el cual tiene infinidad de puntos de vista, acercamientos, movimientos, etc? Almacenar cada pixel del objeto no sería práctico ni nos daría una representación muy real a la hora de mover el objeto a través del mundo virtual.

La mejor forma de modelar los objetos es a través de polígonos. Gran parte de los motores 3D utilizados en los juegos y aplicaciones modernas utilizan polígonos para modelar casi cualquier objeto en su mundo 3D. Y quizás el polígono más utilizado es el triángulo, a partir de triángulos podemos representar cualquier polígono, incluso círculos y esferas.

 

Para poder modelar cada uno de los triángulos que forman un objeto, solamente necesitamos almacenar las coordenadas de cada uno de sus tres vértices. Los vértices son los puntos principales sobre los que se basarán todos los cálculos de nuestro motor. Un vértice representa un punto en el espacio 3D y para modelarlo necesitamos almacenar su coordenada x, y, z. En C++, utilizaríamos una clase similar a esta:

class Vertex3D {

public:

Vertex3D();

Vertex3D(float, float, float);

float x, y, z;

};

Cada objeto de nuestro mundo 3D estará formado por polígonos (triángulos) que a su vez estarán formados por vértices. Hay diferentes formas de almacenar esta información en estructuras de datos: podríamos crear una clase Polygon3D que contenga 3 Objetos Vertex3D y una clase Object3D que contenga una lista de Polygon3D; pero quizás un método más adecuado sea crear una clase Object3D que contenga una lista de todos los vértices y una lista de todos los polígonos, donde cada uno de estos polígonos haga referencia a los vértices que lo forman; esto nos podría ahorrar la cantidad de objetos creados. Basado en esto, nuestra clase polígono sería algo así:

class Polygon3D {

public:

Polygon3D();

Polygon3D(int v1, int v2, int v3);
int vertex[3];

};

donde vertex[3] es un arreglo que contiene los índices de cada uno de los tres vértices que lo forman almacenados en la lista de vértices del objeto. Y nuestra clase Object3D sería algo así:

class Object3D {
public:
Object3D();

int numPolygons; // cantidad de triangulos
int numVertex; //cantidad de vertices
Vertex3D *vertex; // Lista de vértices
Polygon3D *polygon; // Lista de Polygon3Ds
};

Supongamos entonces que queremos modelar un cubo. Necesitaríamos 8 vértices y 12 polígonos como podemos ver en la figura:

En nuestro programa en C++ habría un segmento de código similar a este:

Object3D obj;

//Preparación de las listas de objetos

obj.numPolygons = 12;
obj.numVertex = 8;

obj.vertex = new Vertex3D[obj.numVertex];

obj.polygons = new Polygons3D[obj.numPolygons];

//Coordenadas de los vertices

obj.vertex[0].x = 0.0; obj.vertex[0].y = 0.0; obj.vertex[0].z = 0.0;
obj.vertex[1].x = 0.0; obj.vertex[1].y = 1.0; obj.vertex[1].z = 0.0;

obj.vertex[2].x = 1.0; obj.vertex[2].y = 1.0; obj.vertex[2].z = 0.0;

obj.vertex[3].x = 1.0; obj.vertex[3].y = 0.0; obj.vertex[3].z = 0.0;

obj.vertex[4].x = 0.0; obj.vertex[4].y = 0.0; obj.vertex[4].z = 1.0;

obj.vertex[5].x = 0.0; obj.vertex[5].y = 1.0; obj.vertex[5].z = 1.0;
obj.vertex[6].x = 1.0; obj.vertex[6].y = 1.0; obj.vertex[6].z = 1.0;
obj.vertex[7].x = 1.0; obj.vertex[7].y = 0.0; obj.vertex[7].z = 1.0;

//Poligonos formados

obj.polygon[0].v1 = 0; obj.polygon[0].v2 = 1; obj.polygon[0].v3 = 3;

obj.polygon[1].v1 = 1; obj.polygon[1].v2 = 2; obj.polygon[1].v3 = 3;

obj.polygon[2].v1 = 4; obj.polygon[2].v2 = 5; obj.polygon[2].v3 = 0;

obj.polygon[3].v1 = 5; obj.polygon[3].v2 = 1; obj.polygon[3].v3 = 0;

obj.polygon[4].v1 = 7; obj.polygon[4].v2 = 6; obj.polygon[4].v3 = 4;

obj.polygon[5].v1 = 6; obj.polygon[5].v2 = 5; obj.polygon[5].v3 = 4;

obj.polygon[6].v1 = 3; obj.polygon[6].v2 = 2; obj.polygon[6].v3 = 7;

obj.polygon[7].v1 = 2; obj.polygon[7].v2 = 6; obj.polygon[7].v3 = 7;

obj.polygon[8].v1 = 1;obj.polygon[8].v2 = 5; obj.polygon[8].v3 = 2;

obj.polygon[9].v1 = 5;obj.polygon[9].v2 = 6; obj.polygon[9].v3 = 2;

obj.polygon[10].v1 = 4; obj.polygon[10].v2 = 0; obj.polygon[10].v3 = 7;

obj.polygon[11].v1 = 0; obj.polygon[11].v2 = 3; obj.polygon[11].v3 = 7;

 

Es importante siempre definir los vértices de los polígonos en el mismo sentido, ya sea en el orden de las agujas del reloj o en sentido contrario; pero todos los polígonos deben de ser definidos en el mismo sentido para así poder determinar cual es la cara frontal del polígono.

Como podemos ver, estas clases nos permitirán entonces (con algunos métodos añadidos y algunos otros atributos importantes), modelar cualquier objeto a través de polígonos y vértices. Diseñar un cubo es sencillo, pero ¿cómo modelaríamos un rostro humano o una nave espacial? A través de código sería imposible; esto lo hacemos a través de herramientas de diseño gráfico como 3dMax, Maya, etc. las cuales generan archivos que después podremos importar a nuestro motor para montar esta información en nuestras estructuras de datos; pero eso lo mostraremos más adelante.

Por ahora es todo, en el post siguiente hablaré un poco sobre la representación de estos modelos en la pantalla 2D.

Servidor PowerEdge no reconoce los discos

Me sucedió hace algunos días, días después de haber cambiado de oficina un servidor Dell PowerEdge 1800, que el servidor no me arrancaba. Esto me sucedió justo después de conectar una unidad de backup por medio de un cable SCSI externo.

Al encender el servidor me mostraba en los mensajes que no reconocía los discos duros. El servidor cuenta con dos discos duros en RAID 1, es decir donde uno es el espejo del otro. Después de intentar un rato, me comuniqué con el soporte de Dell (excelente servicio, por cierto) que me indicó los pasos a seguir para habilitar los discos duros. Al parecer el servidor los había sacado de línea para protegerlos por algún problema que detectó y sencillamente lo que había que hacer era entrar a la herramienta de administración del servidor para ponerlos OnLine de nuevo. Unas vez puestos OnLine los discos revisarían consistencia lo cual tardaría un rato mostrando una luz de color anaranjado y no verde como es lo habitual, pero el Sistema Operativo cargó sin problemas y no había perdida de información.

El personal de Dell me indicó que el problema se podría haber ocasionado por faltas de actualizaciones en el firmware o por la conexión de algún dispositivo no compatible, debido a que yo le indiqué que había conectado el backup. La unidad de backup estaba conectada al servidor en la oficina anterior así que no era falta de compatibilidad, pero yo insistía en que el problema debió ocasionarse por la instalación de la unidad y no por faltas de actualización.

Después de revisar bien la conexión me di cuenta que la conexión de unidad de cinta la había instalado mal (en el puerto equivocado de la unidad de cinta), lo que ocasionó problemas en el servidor. Pero al menos pude aprender un par de cositas que de otra forma no lo hubiera hecho.