Escenarios 3D en OpenGL Ivan Olmos Pineda

Introducción


¿Qué es OpenGL?





Estándar creado por Silicon Graphics en 1992 para el diseño de librerias 2D/3D

¿Qué se requiere para programar en OpenGL?


Obtener las bibliotecas




OpenGL: proporciona todo lo necesario para acceder a las funciones de dibujado GLU (OpenGL Utility Library): proporciona acceso a las funciones más comunes de OpenGL a través de la ejecución de comandos GLX: proporciona acceso a OpenGL para interactuar con un sistema de ventanas X Window

OpenGL: Maquina de estados


Todo lo que se realice en OpenGL sigue la ideología de una máquina de estados






OpenGL se basa en activar – desactivar instrucciones o comandos La secuencia de las activaciones – desactivaciones es crucial en los resultados que se obtienen

De lo anterior se desprende lo siguiente:


No es lo mismo rotar una imagen y después trasladarla que trasladar una imagen y rotarla

OpenGL: Maquina de Estados


Esquema general de un programa en OpenGL 1.

2.

3. 4. 5.

Activar todas las opciones que van a ser persistentes en una escena (perspectiva de la cámara de visión, iluminación global, etc) Activar las opciones que establecen el estado de un objeto específico (posición, textura, color, etc) Dibujar el objeto Desactivar las opciones propias de dicho objeto Volver al punto 2 hasta haber dibujado todos los objetos

OpenGL: Representación de Objetos 3D


OpenGL utiliza una representación de objetos 3D a partir de un espacio en cuatro dimensiones





El espacio 3D se representa a través de un sistema 3D ortonormal, donde los ejes son perpendiculares y cada unidad en cada eje esta representado por un vector de módulo 1 La cuarta coordenada se utiliza para representar la perspectiva

OpenGL: Transformaciones de Objetos


Existen 3 operaciones básicas para transformar un objeto:


Traslación: desplazamiento de un objeto en el espacio




Rotación: rotar un objeto a partir de su centro de giro




Escalado: alterar el tamaño de un objeto

OpenGL: transformaciones de objetos








Toda transformación construye una matriz de cuatro dimensiones, que es multiplicada por la matriz original de coordenadas Por ejemplo, para trasladar un objeto 2 unidades en el eje X

A partir de la matriz anterior, dibujar un punto en las coord (1,0,0) será:

OpenGL: transformaciones 2D/3D





Todo objeto en OpenGL se representa a través de una matriz de dimensión 4


Un punto 3D (x, y, z) es representado por el punto (x, y, z, 1.0)




Un punto 2D (x, y) es representado por el punto (x, y, 0.0, 1.0)

De lo anterior, un punto homogéneo (x, y, z, w) es equivalente al punto 3D (x/w, y/w, z/w)

OpenGL: Funciones básicas


Activar / desactivar opciones:






glEnable() glDisable()

OpenGL maneja dos matrices muy importantes


Matriz de visualización/modelado





Matriz de proyección (matriz que guarda la información relativa a la cámara con la cual observaremos al mundo)





glMatrixMode(GL_MODELVIEW)

glmatrixMode(GL_PROJECTION)

Para almacenar y recuperar los valores de una matriz, se utiliza una estructura tipo pila



glPushMatrix() glPopMatrix()

OpenGL: dibujado de objetos


Para dibujar en OpenGL, es necesario








Habilitar el modo de dibujado Establecer las opciones de dibujado de cada vértice Dibujar cada uno de ellos Finalizar el modo de dibujado

Algunas formas de dibujado






GL_POINTS: se dibujan vértices separados GL_LINES: cada par de vértices definen una linea GL_POLYGON: todos los vértices definen el contorno de un polígono GL_TRIANGLES: cada triplete de vértices definen un triángulo GL_QUADS: cada cuarteto de vértices se interpreta como un cuadrilátero

OpenGL: dibujado de objetos





GL_LINE_STRIP: líneas conectadas GL_LINE_LOOP: líneas conectadas, con unión del 1er y último vértice GL_TRIANGLE_STRIP: dibuja un triángulo y cada nuevo vértice define un triángulo con el anterior GL_QUAD_STRIP: dibuja cuadrados con en TRIANGLE_STRIP

OpenGL: proyección


Existen dos formas de proyectar objetos


Proyección ortográfica: permite visualizar todo lo que se encuentre dentro de un cubo, delimitado por los parámetros de la función glOrto

OpenGL: proyección


Proyección perspectiva


Delimita un volúmen de visualización dado por un ángulo de cámara y una relación alto/ancho. La distancia al observador delimitará el tamaño con el que un objeto se visualiza

1er Ejemplo


Crear un código que dibuje un triángulo cuyos vértices tengan un color diferente void display(void) { glClearColor(0.0,0.0,0.0,0.0); glClear(GL_COLOR_BUFFER_BIT); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-1.0,1.0,-1.0,1.0,-1.0,1.0); glMatrixMode(GL_MODELVIEW); glBegin(GL_TRIANGLES); glColor3f(1.0,0.0,0.0); glVertex3f(0.0,0.8,0.0); glColor3f(0.0,1.0,0.0); glVertex3f(-0.6,-0.2,0.0); glColor3f(0.0,0.0,1.0); glVertex3f(0.6,-0.2,0.0); glEnd(); glFlush(); Sleep(10000); exit(0); }

1er Ejemplo: Análisis


glOrtho(-1,1,-1,1,-1,1)



Define una perspectiva ortonormal: lo que se observe será una proyección paralela en uno de los planos definidos por los ejes Los argumentos definen el volumen de vista: xmin, xmax, ymin, ymax, zmin, zmax (zmin, zmax no son coordenadas, son distancias desde el punto de vista, )

1er Ejemplo: Análisis


El punto 3D en openGL






glVertex3f() Los argumentos son desde 2 hasta 4 valores de tipo númerico

Las primitivas


glBegin()







glVertex(…); glVertex(…); …

glEnd();

1er Ejercicio: Análisis


Es importante hacer notar que el orden en el cual se dibujen los vértices de una figura definen su “sentido” glBegin(GL_TRIANGLES); glVertex3f(0,0,0); //v1 glVertex3f(0.5,0.5,0); //v2 glVertex3f(1,0,0); //v3 glEnd();

glBegin(GL_TRIANGLES); glVertex3f(-0.2,0,0); //v4 glVertex3f(-0.7,0.5,0); //v5 glVertex3f(-1,0,0); //v6 glEnd();

Notas sobre el orden de dibujo de un objeto



Cuando un polígono tiene sentido horario, se dice que es positivo; en caso contrario, es negativo En openGL






Figuras con sentido negativo muestran su “cara frontal” Figuras con sentido positivo, muestran su “cara trasera”

En openGL, por defecto se muestran las caras frontales y traseras



Sin embargo, en operaciones de renderizado solo se trabajan sobre las caras frontales y no las traseras Para mostrar únicamente las caras frontales se utiliza glEnable(GL_CULL_FACE)

1er Ejercicio

OpenGL: Sombras


En OpenGL es posible manipular la forma en la cual se asigna un color a un objeto


glShadeModel()


GL_FLAT: rellena los polígonos con el color activo al momento




GL_SMOOTH: rellenará el polígono interpolando los colores activos en la definición de cada vértice

OpenGL: visualización de caras ocultas


Cuando se visualicen objetos en OpenGL, algunos pueden estar más cerca que otros de acuerdo a nuestra perspectiva (plano z)





Para solucionar este problema se utiliza el siguiente comando








Sin embargo, cuando se dibujan objetos, OpenGL no hace una comprobación directa de quien esta más cerca glEnable(GL_DEPTH_TEST); //matriz en la cual se almacena la profundidad en “z” de los objetos. Con esto se hace una comprobación antes de pintar los pixeles glDisable(GL_DEPTH_TEST); //desactiva la matriz de profundidad

El uso de esta matriz requiere que se borre la pantalla antes de dibujar cada frame


glClear(GL_COLOR_BUFFER_BIT 1 GL_DEPTH_BUFFER_BIT);

Comandos OpenGL: Manual de Referencia

http://www.opengl.org/sdk/docs/man/