PDF de programación - Escenarios 3D en OpenGL

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
- 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
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. Activar todas las opciones que van a ser persistentes en una
escena (perspectiva de la cámara de visión, iluminación global,
etc)

2. Activar las opciones que establecen el estado de un objeto

específico (posición, textura, color, etc)
específico (posición, textura, color, etc)

3. Dibujar el objeto

4. Desactivar las opciones propias de dicho objeto

5. 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
- 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)
- 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(<option>)
- glDisable(<option>)

- OpenGL maneja dos matrices muy importantes

- Matriz de visualización/modelado
- glMatrixMode(GL_MODELVIEW)
Matriz de proyección (matriz que guarda la información relativa a la
- Matriz de proyección (matriz que guarda la información relativa a la
cámara con la cual observaremos al mundo)
- 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
- 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
- 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);
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, )
distancias desde el punto de vista, )

1er Ejemplo: Análisis

- El punto 3D en openGL

- glVertex3f(<argumentos>)

- Los argumentos son desde 2 hasta 4 valores de tipo númerico

- Las primitivas

- glBegin(<tipo de primitiva>)

- 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);

glBegin(GL_TRIANGLES);

glVertex3f(0,0,0); //v1
glVertex3f(0.5,0.5,0); //v2
glVertex3f(1,0,0); //v3

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

glEnd();
glEnd();

glEnd();
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
- 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(<parametro>)

- 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)
- Sin embargo, cuando se dibujan objetos, OpenGL no hace una

comprobación directa de quien esta más cerca

- Para solucionar este problema se utiliza el siguiente comando
- Para solucionar este problema se utiliza el siguiente comando

- 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/