Demos de Mapeado de Texturas

Estos días he tenido algo abandonado SDL por estar explorando OpenGL, abajo les dejo dos formas de mapeado de texturas con el.

Por ultimo debo decir que en mente tengo un nuevo proyecto con SDL el cual ya he comenzado a desarrollar y espero acabarlo pronto o por lo menos poner algún vídeo con el fin de que lo observen y ver si tiene aceptación para luego publicarlo.

Deslizador de Portadas

Mi objetivo por aprender SDL y OpenGL es combinarlos para programar juegos. Pues bien aun no termino de desarollar un nuevo juego que tengo en mente. Pero por el momento le dejo un Demo que programe en hora y media aunque con muchas distracciones. 

El demo trata de un simple deslizador de portadas hecho con las librerías de SDL y OpenGL, aunque no es muy espectacular, pero aplica los principios básicos de combinar estas dos librerías.

OpenGL Lección 04 - Luces

Vamos a hablar un poco sobre la luz en OpenGL. Supongo que para mucho esto resultara muy atractivo a la vista y en verdad lo es. La luz y los materiales van de la mano. Anteriormente hemos estado dibujando figuras y dando color a los vértices, pero los materiales nos brinda la oportunidad de darle mas realismo a nuestro objeto necesitamos a la luz para que el incida sobre el objeto y lo ilumine asi que comenzaremos con ello.

Retomare el código de la lección 03 y sobre ella trabajare. Este código lo he compilado en Linux y Windows. La única diferencia en Windows seria cambiar las cabeceras  por "glut.h". (Esta es la primera revisión, así que esta sujeta a correcciones de código, pero sobre todo gramática :p). Abajo dejo un enlace para descarar el ejemplo completo.

Primero veamos algo de sencilla teoría.

Luces

Para usar la luz en OpengGL es necesario activarla.

glEnable(GL_LIGHTING);      //Activa la luz

glDisable(GL_LIGHTING);     //Desactiva la luz

Ademas de ello OpenGL estable poder usar ocho luces y hay que activar la que vayamos a usar.

glEnable(GL_LIGHT0)      //Activa la primera luz

.

.

.

glEnable(GL_LIGHT7)      //Activa octava luz

Pero ademas luz cuenta con distintas propiedades. Hablemos  un poco acerca la luz y sus tres componentes que son: ambiental, difusa y especular. En OpenGL estas cuentan con tres componentes de color (RGB) y un valor alpha (trasparencias)

Luz Ambiental

Esta luz no proviene de ningún punto en especifico, si no que incide y rebota desde varios puntos.

Luz Difusa

Es la luz que ilumina al objeto y rebota en todas direcciones

Luz Especular

Esta es el brillo o reflejo que produce el objeto al ser visto por una persona desde el punto de refracción.

Ademas de los componentes de la luz también existen tres formas en que los rayos de luz se emiten.

Direccional: Los rayos de la luz son paralelos entre si , no existe atenuación con al distancia. El sol es único capas  de hacer esto.

Puntual o posicional

La luz se emite desde un punto en todas direcciones, ejemplo una fogata.

Focal

La luz sale desde un punto y crea una cono de iluminación, esta puede necesitar algunos parámetros extra como: un angulo y una distancia de atenuación. Ejemplo una lampara de mano.

La funcion encargada de definir la luces es:

glLightFv(GLenum luz, GLenum, Parametros, GLfloat Color[4]);

Luz: Desde GL_LIGHT0 hasta GL_LIGHT7

Parametros:

   GL_AMBIENT                 //Color del ambiente

   GL_DIFUSSE                 //Color de la luz reflejada

   GL_SPECULAR             //Color del brillo

   GL_POSITION               //Posición de la luz, puede ser de dos tipos      

      -w = 0.0f                   //Luz Direccional

      -w = 1.0f                   //Luz Puntual o focal

   GL_SPOT_CUTOFF        //Angulo de abertura desde 0 hasta 90 grados

   GL_SPOT_EXPONENT    //Perdida de intensidad al centro desde 0 hasta 128

   GL_CONSTANTA_ATTENUATION    //Por defecto 1. (0.0 - 1.0) 

   GL_LINEAR_ATTENUATION           //Por defecto 1. (0.0 - 1.0) 

   GL_QUADRATIC_ATTENUATION    //Por defecto 1. (0.0 - 1.0) 

Retomare el código de la lección 03. Vamos a agregar una luz direccional. No cambia mucho con respecto a la puntual o focal. Primero agregar algunas variables que servirán para incrementar los parámetros de la luz y mover la posición de esta.

//Definimos algunas variables
GLfloat ambiente = 0.7f;

GLfloat difusa = 0.7f;

GLfloat especular = 1.0f;

GLfloat luzPos_x = 1.0f;
GLfloat luzPos_y = 1.0f;

GLfloat luzPos_z = 1.0f;

//Inicia los Valores de OPengl

void iniciar(){

   glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

   //Activar parametor del Buffer de Profundidad

   glClearDepth(1.0);

   glDepthFunc(GL_LEQUAL);

   glEnable(GL_DEPTH_TEST);

   //Activar cortado de caras

   glFrontFace(GL_CW);

   glCullFace(GL_BACK);

   glEnable(GL_CULL_FACE);

  //Activamos la luz

  glEnable(GL_LIGHTING);

  glEnable(GL_LIGHT0);

  //Tipo de Sombredo

  glShadeModel(GL_SMOOTH);

}

En la funcion iniciar() lo unico que hacemos es activar el modo de iluminación y la luz 1.

//Se encarga de dibuja las primitivas y volcar el buffer

void dibuja(){

//Limpia los buffers de color y profundidad

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glLoadIdentity();

gluLookAt(0.0, 3.0, 10.0,   0.0, 0.0, 0.0,  0.0, 1.0, 0.0);

//Definimos los parametro de la luz

GLfloat luzDifusa[4] = {difusa, difusa, difusa, 1.0f};

GLfloat luzAmbiental[4] = {ambiente, ambiente,  ambiente, 1.0f};

GLfloat luzEspecular[4] = {especular, especular, especular, 1.0f};

GLfloat luzPosicion[4] = {luzPos_x, luzPos_y, luzPos_z, 0.0f};

//Luz numero 0

glLightfv(GL_LIGHT0, GL_AMBIENT, luzAmbiental);

glLightfv(GL_LIGHT0, GL_DIFFUSE, luzDifusa);

glLightfv(GL_LIGHT0, GL_SPECULAR, luzEspecular);

glLightfv(GL_LIGHT0, GL_POSITION, luzPosicion);

//Guardamos la matriz

glPushMatrix();

glTranslatef(0.0f, 0.0f, 0.0f);

glutSolidTeapot(1.0f);    //Dibujamos la tetera solida

glTranslatef(-3.0f, 0.0f, 0.0f);

.

.

.

glPopMatrix();

//Intercambiamos los buffers

glutSwapBuffers();

}

Por el momento dentro de dibuja() definiré el arreglo que contendrá las variables para las tres propiedades de la luz y una arreglo para la posición de la luz. Notar que el ultimo parámetro de la posición de la luz es 0.0f. Luz direccional.

Luego hay que asignar los arreglos a cada una las distintas propiedades de la luz 0 y la posición  de esta.

Por ultimo agregare algunas teteras que serviran de modelo, hay que notar que ahora tiene caras con glutSolidTeapot en vez de glutWireTeapot.

void mostrarValores(){

   printf("Luz Ambiental: %f\n", ambiente);

   printf("Luz Difusa: %f\n", difusa);

   printf("Luz Especular: %f\n\n", especular);

}

void posicionLuzValores(){

   printf("Luz Posicion en x: %f\n", luzPos_x);

   printf("Luz Posicion en y: %f\n", luzPos_y);

   printf("Luz Posicion en z: %f\n\n", luzPos_z);

}

Luego tenemos estas dos funciones que lo único que haces es mostrar los valores actuales de la luz y su posición.

Igual que la vez anterior agregamos algunos eventos de teclado para cambiar los valores de la luz  y su posición.

//Incrementa y drecementa los valores para hacer transformacion al presionar las teclas

void teclado(unsigned char tecla, int x, int y){

   //Luz ambiente

   if(tecla == 'q' || tecla == 'Q'){

      ambiente += 0.1f;

      mostrarValores();

      glutPostRedisplay();

   }

   else if(tecla == 'w' || tecla == 'W'){

      ambiente -= 0.1f;

      mostrarValores();

      glutPostRedisplay();

   }

.

.

.

}

Eso seria todos los cambios dentro del código para esta lección.

(Ejemplo de una luz puntual)

Ahora bien aun falta agregar los materiales al objeto para poder ver los reflejos, pero eso sera el siguiente paso.

Teclas:
q/w: Luz Ambiente
a/s: Lus Difusa
z/x: Luz Especular
e/r: Mover la luz en x
d/f: Mover la luz en y
c/v: Mover la luz en z

Descarga Código Fuente: leccion_04

OpenGL Lección 03 - Transformaciones

En este breve tutorial explicar como se realizan la traslación, rotación y escaldo de una figura. Retomare el código de la lección 02 y sobre ella trabajare. Este código lo he compilado en Linux y Windows. La única diferencia en Windows seria cambiar las cabeceras  por "glut.h". (Esta es la primera revisión, así que esta sujeta a correcciones de código, pero sobre todo gramática :p). Abajo dejo un enlace para descarar el ejemplo completo.

Trasladar Rotar y Escalar

La tres formas básicas de transforma un objeto son: Trasladar, rotar y escalar. La forma de aplicarlas es muy sencilla es mediante el llamado de estas funciones.

//Trasladar la figura por eje  con respecto al parámetro indicado

glTranslatef(GL_float x, GL_float y, GL_float z);

//Rota la figura en grados, entorno al eje normalmente de magnitud  = 1

glRotatef(GL_float grados, GL_float x, GL_float y, GL_float z);

//Escala la figura con respecto al parámetro indicado

glScalef(GL_float x, GL_float y, GL_float z);

Como ven las trasformaciones son muy sencillas. Pero ahora bien estas deben de seguir este orden descrito: Primero Trasladar, luego rotar y por ultimosEscalar, esto es debido a que OpenGL apila las trasformaciones y si primero rotamos y luego trasladamos a lo largo del eje "x" nos daremos cuenta de mueve en una dirección diferente a la prevista.

Retomando el codigo de la leccion_02 lo primero que haré sera agregar tres variables globales que se encargaran de increnmentar y desincremntar el valor de traslado, rotado y escalado.

GLfloat transladar = 0.0f;

GLfloat rotar = 0.0f;

GLfloat escalar = 1.0f;

Ahora pasemos a la funcion de dibujo() que ya sabemos que hace.

//Se encarga de dibuja las primitivas y volcar el buffer

void dibuja(){

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glLoadIdentity(); //Restablecemos la ubicacion

gluLookAt(0.0, 3.0, 10.0,   0.0, 0.0, 0.0,  0.0, 1.0, 0.0);

glPushMatrix();

glTranslatef(-3.0f, 0.0f, 0.0f);

glutWireTeapot(1.0f);

glPopMatrix();

glPushMatrix();

//Transfomaciones

glTranslatef(transladar, 0.0f, 0.0f);      //Transalada la figura en el eje x

glRotatef(rotar, 0.0f, 1.0f, 0.0f); //Rotar la figura entorno al eje y

glScalef(escalar, escalar, escalar); //Escalar la figura en todos sus ejes

glutWireTeapot(1.0f);

glPopMatrix();

glutSwapBuffers();

}

Dibujare dos teteras. La primera servirá como referencia y a la segunda le aplicare las trasformaciones. Con glTranslatef() movere la figura a lo lago del eje "x" con el valor de la varible global que declare al principio. glRotatef(), rotara con los grados indicados en torno al eje y. Por ultimo escalaremos la figura en todos sus ejes con glScalef().

Para hacerlo mas interactivo agregaremos eventos de teclado que permitan interactuar con las trasformaciones pudiendo cambiar los valores para moverlo, girarlo o cambiar de tamaño .

//Incrementa y drecementa los valores para hacer transformacion al presionar las teclas

void teclado(unsigned char tecla, int x, int y){

//Traslación 

if(tecla == 'q' || tecla == 'Q'){

transladar += 0.2f;

glutPostRedisplay();

}

else if(tecla == 'a' || tecla == 'A'){

transladar -= 0.2f;

glutPostRedisplay();

}

La función teclado recibe tres parametros, el primero de ellos es el teclado, los otros dos hacen referencia a mouse, solo tomaremos los del teclado. La funcion que realiza es muy sencilla. Si la tecla indicada entre comillas simples  es presionada este efectuara el incremento o desincremento del valor de la variable indicada, en este caso transladar. La funcion glutPostRedisplay(), redibuja la escena cada vez que esto ocurre. Igual aplicaremos para las demás trasformaciones.

Por ultimo en el main agregamos los evento con glutKeyboardFunc() que llama a nuestra función teclado

.
.
.
glutDisplayFunc(dibuja);

glutReshapeFunc(redimensionar);
glutKeyboardFunc(teclado);
glutMainLoop();
.

.
.

Por ultimo he de decir que pruebes cambiando el orden las trasformaciones para ver el efecto que estas tiene sobre el objeto.


Teclas usadas para las transformaciones:
q/a: Traslada el objeto
w/s: Rota el objeto
e/d: Escala el objeto

Descarga Código Fuente: leccion_03

OpenGL Lección 02 - Dibujar Figuras Parte II

 Es momento de empezar a dibujar algunas figuras sencillas con la primitivas de OpenGL, ademas de usar el buffer de profundidad y corte de caras. Retomare el código de la lección 01 y sobre el trabajare. Pondre todo el código y luego explicare los cambios hechos. Este código lo he compilado en Linux y Windows. La única diferencia en Windows seria cambiar las cabeceras  por "glut.h". (Esta es la primera revisión, así que esta sujeta a correcciones de código, pero sobre todo gramática :p). Abajo dejo un enlace para descarar el ejemplo completo.

Si uno quiere dibujar figuras muy complejas indicando manualmente vértice por vertice a la larga resulta muy tedioso. Pero si entendemos la forma básica en que se crean figuras en OpenGL entonces cabe la posibilidad de que podemos crear un sencillo y básico modelador de objetos o en todo caso exportar modelos.

Si leíste la primer parte de este tutorial seguramente casi inmediatamente sabras que hacen las nuevas funciones con solo verlas. Como ya explique como crear una venta con GLUT y el modelo de visualización dejare fuera esas partes.

//Librerias que se usaran, cambian de acuerodo a sistema

#include "GL/gl.h"

#include "GL/glu.h"

#include "GL/glut.h"

//Inicia los Parámetros de OPengl
void iniciar(){

glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0);
glDepthFunc(GL_LEQUAL);
glEnable(GL_DEPTH_TEST);
glFrontFace(GL_CW);
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
glShadeModel(GL_SMOOTH);
}


//Dibuja figuras de OpenGL por medio de primitivas
void dibuja(){
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
gluLookAt(0.0, 0.0, 6.0,   0.0, 0.0, 0.0,  0.0, 1.0, 0.0);
glPushMatrix();
glTranslatef(1.5f, 0.0f, 0.0f);
glBegin(GL_TRIANGLES);
glColor3f(1.0f, 1.0f, 1.0f);
glVertex3f(0.0f, 1.0f, 0.0f);
glVertex3f(1.0f, -1.0f, 0.0f);
glVertex3f(-1.0f, -1.0f, 0.0f);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslatef(-1.5f, 0.0f, 0.0f);
glBegin(GL_QUADS);
glColor3f(1.0f, 0.0f, 0.0f);
glVertex3f(-1.0f, 1.0f, 0.0f);
glColor3f(0.0f, 1.0f, 0.0f);
glVertex3f(1.0f, 1.0f, 0.0f);
glColor3f(0.0f, 0.0f, 1.0f);
glVertex3f(1.0f, -1.0f, 0.0f);
glColor3f(1.0f, 0.0f, 1.0f);
glVertex3f(-1.0f, -1.0f, 0.0f);
glEnd();
glPopMatrix();
glutSwapBuffers();
}


//Mantiene la relación de aspecto en las figuras
void redimensionar(GLint ancho, GLint alto){
glViewport(0, 0, ancho, alto);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0f, (GLfloat)ancho/(GLfloat)alto, 0.1f, 100.0f);
glMatrixMode(GL_MODELVIEW);
}


//Main de nuestro programa
int main(int argc, char **argv){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowSize(320,240);
glutInitWindowPosition(120,120);
glutCreateWindow("leccion_02 OpenGL");
iniciar();
glutDisplayFunc(dibuja);
glutReshapeFunc(redimensionar);
glutMainLoop();
   return 0;
}

Ok primero vayamos a la funcion main(), aqui lo unico que cambia es que le indicamos a glut el uso del parametro GLUT_DEPTH para la profundidad.

//Inicia los Parámetros de GLUT

int main(int argc, char **argv){

glutInit(&argc, argv);

glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);

glutInitWindowSize(320,240);

glutInitWindowPosition(120,120);

glutCreateWindow("leccion_02 OpenGL");

iniciar();

glutDisplayFunc(dibuja);

glutReshapeFunc(redimensionar);

glutMainLoop();

   return 0;

}

Ahora movámonos a la funcion init(). Aqui hay varias cosas nuevas que le indicamos usar a OpenGL.


//Inicia los Parámetros de OPenGL
void iniciar(){
//Establece el color de limpiado
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
//Activar parametor del Buffer de Profundidad
glClearDepth(1.0);
glDepthFunc(GL_LEQUAL);
glEnable(GL_DEPTH_TEST);
//Activar cortado de caras
glFrontFace(GL_CW);
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
//Tipo de Sombredo suavidado
glShadeModel(GL_SMOOTH);
}

Las primeras tres lineas en rojo indica el valor de limpiado del buffer de profundidad "z". luego el tipo de limpiado GL_LEQUAL indica que no dibuja todo aquello <= Z. Por ultimo activamos el buffer de profundidad.

Las otras tres lineas rojas hacen referencia a activar el corte de caras. La primera indica el sentido de los vertices para dibujar las caras GL_CW sigifica sentido horario, la segunda linea, glCullFace(GL_BACK) indica que no se calculan la caras traseras y la ultima linea indica a OpenGL activar el corte de caras.

Ahora pasemos a la función que dibuja las figuras.

//Dibuja figuras de OpenGL por medio de primitivas

void dibuja(){

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glLoadIdentity();

gluLookAt(0.0, 0.0, 6.0,   0.0, 0.0, 0.0,  0.0, 1.0, 0.0);

 

   glPushMatrix();

glTranslatef(1.5f, 0.0f, 0.0f);

glBegin(GL_TRIANGLES);

glColor3f(1.0f, 1.0f, 1.0f);

glVertex3f(0.0f, 1.0f, 0.0f);

glVertex3f(1.0f, -1.0f, 0.0f);

glVertex3f(-1.0f, -1.0f, 0.0f);

glEnd();

glPopMatrix();
.
.
.

glutSwapBuffers();

}

Primero en la funcion glClear() debemos indicarle a OpenGL que cada vez que dibuja la escena este debe de limpiar el buffer de profundidad.

La función gluLookAt() estable el punto que nos situamos para observar la escena.

Antes de dibujar nuestra figura podemos ver una función llama glPushMatrix(), esta se encarga de guardar la matriz para realizar cálculos.

Ahora lo que hacemos es mover un poco hacia la derecha nuestra figura a través del eje x con glTranslatef(), después explicare esta función.

Es momento de comenzar a dibujar la figura de un triangulo con glBegin(), dentro de ella le indicamos la forma en que queremos que interprete la figura (GL_TRIANGLES). En el siguiente renglón le indicamos el color que tomaran los vertices, todo los vértices tendrán el mismo color hasta que indiquemos alguno diferente. Luego comenzamos a dibujar la figura indicando los vértices en sentido horario como indicamos con glFrontFace(). El primer vértice esta ubicado en la parte superior, el segundo es la parte inferior derecha y el ultimo en la parte inferior izquierda. Finalizamos indicando que son todos los vértices de la figura con glEnd() y por ultimo restablecemos la matriz con glPopMatrix().

La forma en que dibujamos el cuadrado es muy similar salvo que usamos glBegin(GL_QUADS); para indicarle que seran cuatro vertices para forma una cara. De hecho podemos dibujar un cuadrado con dos triangulos y muchas de las figuras mas complejas son dibujadas usandos solo triángulos.


Aun falta mas cosas por cubrir como array de vértices o listas compiladas.

Descarga Codigo Fuente: leccion_02.cpp

OpenGL Lección 02 - Dibujar Figuras Parte I

Supongo que estamos ansiosos por empezar a dibujar figuras en OpenGL. Pero primero tomaremos una breve explicación de como se crean figuras en Opengl.

I - Vértices

La forma en que OpenGL crea figuras es muy sencilla y es por medio de vertices. Un vértices esta representado por coordenadas en el espacio tridimensional que permite ubicar su posición.

glVertex3f(1.0f, 0.0f, 1.0f);    //Vértices con valor Real

Pero con cuatro o cinco vértices se pueden dibujar muchas cosas, como puntos, lineas, triángulos, cuadrados, polígonos. Es por ello que le tenemos que indica a OpenGL la forma en que se utilizaran los vértices.

II - Crear Figuras a Través de Vértices.

OpenGL nos brinda 10 formas de poder de como poder manejar vértices.

Para indicarla la forma en que se interpretara un grupo de vertices para dibuja la primitiva se utiliza la funcion glBegin() y glEnd(). Todos los vertices contenidos entre estas dos funciones serán dibujados de la forma que se le indico con glBegin();.

glBegin(GLenum Parametros);   //Le indicamos el tipo de Parámetro

III - Colores en los Vértices

La forma en que OpenGL representa los colores es mediante RGBA.  Rojo, verde, azul y en veces Alpha.

void glColor3f(1.0, 0.0,  0.0);           //Ejemplo de color con 3 valor Real.

void glColor4f(1.0, 0.0,  0.0, 0.5);    //Ejemplo de color con 4 valor Real.

Con valores de tipo Real el valor del color oscila entre 0.0 y 1.0. 

IV - El Orden de los vértices

Es importante saber que se debe tener en cuenta el orden en que se indican los vértices al momento de dibujar la primitivas. Por ejemplo si dibujamos un triangulo este tendrá dos caras; frontal y trasera. 

Para indicar el orden de lo vertices y saber cual sera la cara frontal se utiliza:

glFrontFace(GLenum Parámetros); 

//Posibles Parametros

GL_CC          //Sentido horario del reloj

GL_CCW       //Sentido Anti-horario del reloj

Existirán casos en los que nunca veamos la cara trasera de esta, entonces no es necesario calcularla para ello se utiliza la función.

glCullFace(GLenum Parámetros);    //Indicamos la cara que no calcula

//Posibles Parametros

GL_FRONT          //No calcula la cara de enfrente

GL_BACK           //No calcula la cara de atrás

Para activar el corte de caras es necesario indicarselo a OpenGL mediante la función glEnable() y para desactivarlo con glDisable().

glEnable(GL_CULL_FACE);       //Activa el corte de caras

glDisable(GL_CULL_FACE);      //Desactiva el corte de caras

V - La cámara

Para determinar la matriz de proyección es necesario establecer un punto de vista y   mediante la funcion glLookAt() podemos lograr esto.

//Posicion de la camara
glLookAt(GLdouble Posicion_X, GLdouble Posicion_Y, GLdouble Posicion_Z,
               GLdouble enfocar_X,  GLdouble enfocar_Y,  GLdouble enfocar_Z,
               GLdouble Inc_X,    GLdouble Inc_Y,    GLdouble Inc_Z); 

glLookAt recibe tres triadas de parámetros, lo primeros tres indican la posición de la cámara  le segunda triada indica hacia que punto se esta viendo y la ultima triada indica cual es el eje que apunta hacia arriba.

VI - Buffer de Profundidad

Cuando se dibujan objetos tridimensional es necesario comprobar si se dibujan por delante o por detrás de otro objeto. Para saber esto OpenGL almacena en un buffer el eje Z y después comprueba su distancia de profundidad para evitar dibujar por encima de otro que este mas cercano hacia nosotros.

glEnable(GL_DEPTH_TEST);                //Activa el buffer de Profundidad
glDisable(GL_DEPTH_TEST);               //Desactiva el buffer de Profundidad
glClearDepth (GLfloat z);                   //Define el valor de limpiado


Primero hay que activar el buffer de profundidad y después le indicamos la el valor para limpiar el eje z, por ultimo debemos de decirle como compara la distancia.

glDepthFunc(GLenum Parametro);  //Compara la distancia


GL_NEVER          //Siempre false 
GL_LESS             //true si z referencia  < z profundidad
GL_EQUAL          //true si z referencia  = z profundidad
GL_LEQUAL        //true si z referencia  <= profundidad
GL_GREATER      //true si z referencia  > z profundidad
GL_NOTEQUAL    //true si z referencia != z profundidad
GL_GEQUAL        //true si z referencia  >= z profundidad
GL_ALWAY         //Siempre true

Al igual que con buffer de color también hay que limpiar el buffer de profundidad.

glClear(GL_DEPTH_BUFFER_BIT);       //Limpia el buffer de Profundidad