Ventanas GLUT

El primer paso para empezar en OpenGL es una “simple” ventana, En realidad es mas que una ventana, obviamente la diferencia esta en lo que queremos hacer (3D). Las ventanas en OpenGL, al igual que otras ventanas cargan componentes, eventos y propiedades, sin embargo para trabajar con objetos en 3D se necesitan mas requerimientos, los cuales brinda la librería GLUT de OpenGL. Antes de comenzar sugerimos ver el tutorial IDE para OpenGL. Empecemos:

Primero se deben incluir las librerías necesarias:

#include 
#include  #Libreria GLUT
#include  #Libreria de entrada y salida de Datos

El main o el método principal:

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

cout << "\nVersión de prueba";

glutInit(&argc, argv);
int ancho = glutGet(GLUT_SCREEN_WIDTH) / 2;
int alto = glutGet(GLUT_SCREEN_HEIGHT) / 2;
glutInitWindowPosition(alto, ancho);
glutInitWindowSize(500, 500);
glutInitDisplayMode(GLUT_DEPTH | GLUT_SINGLE | GLUT_RGB);
glutCreateWindow("GLUT WINDOWS");
glutReshapeFunc(dimensionar); //función secundaria de visualización
glutDisplayFunc(renderizar); //función secundaria de renderizado
glutMainLoop(); //bucle infinito del juego
return 0;
}

Funciones secundarias:

void dimensionar(GLsizei width, GLsizei height) {

glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45, (GLfloat) width / (GLfloat) height, 0.01, 20);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();

}

void dibujarCubo(){

glBegin(GL_QUADS);
glColor3f(1.0f, 0.0f, 0.0f);
glVertex3f(-0.5, 0.5, 0.5);
glVertex3f(0.5, 0.5, 0.5);
glVertex3f(0.5, -0.5, 0.5);
glVertex3f(-0.5, -0.5, 0.5);
glEnd();
}

void renderizar() {

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glLoadIdentity();
glTranslatef(0.0, 0.0, -10);
dibujarCubo();
glFlush();
glutSwapBuffers();
}

EXPLICACIÓN

Método main

glutInit(&argc, argv);

Inicialización de OpenGL, recibe como parámetros un puntero desde la función al entero argc del main y de char argv. Sino agregamos esta linea nada funcionaria

int ancho = glutGet(GLUT_SCREEN_WIDTH) / 2;

int alto = glutGet(GLUT_SCREEN_HEIGHT) / 2;

glutInitWindowPosition(alto, ancho);

Extraemos el ancho y el alto del sistema que son recibidos por la función glutInitWindowPosition

glutInitWindowSize(500, 500);

Tamaño de inicial de la ventana

glutInitDisplayMode(GLUT_DEPTH | GLUT_SINGLE | GLUT_RGB);

Esta función es importante, en ella establecemos el modo de la ventana, en este caso especificamos que percibe profundidad, tiene un buffer simple y permite paleta de colores RGB. Los modos son una combinación de parámetros booleanos, estos valores se encuentran predefinidos en la librería de GLUT. Los parámetros especifican el modo del color, el tipo y numero de buffers. Las constantes predefinidas son:

• GLUT_RGBA o GLUT_RGB – Paleta de colores
• GLUT_INDEX - Selecciona el modo del index de colores
• La Ventana puede tener un buffer simple o doble. Las constantes predefinidas son:

• GLUT_SINGLE - buffer simple
• GLUT_DOUBLE - buffer doble, requerido para suavizar animaciones

Puedes especificar si deseas que una ventana en particular tiene cierta cantidad de buffers. Los parámetros mas comunes son:

• GLUT_ACCUM - Acumulación de buffers
• GLUT_STENCIL - buffer plantilla
• GLUT_DEPTH - profundidad de buffer

glutCreateWindow("GLUT WINDOWS");

Esta función crea (no muestra) la ventana con nuestras anteriores especificaciones, recibe como parámetro el titulo de la ventana.

Método renderizar

glutDisplayFunc(renderizar);

Esta función permite renderizar la escena que deseamos.

void renderizar() {

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glLoadIdentity();
glTranslatef(0.0, 0.0, -10);
dibujarCubo();
glFlush();
glutSwapBuffers();
}

Explicación

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

Limpia los el buffer de color y profundidad, al hacer esto nos aseguramos que no queden rastros indeseados de renderizados anteriores.

glEnable(GL_DEPTH_TEST);

sino agregamos esta funcion OpenGL no detectara cuando un objeto esta detrás de otro y el renderizado se realizara en el orden de dibujado, en tal caso un objeto que esta detrás de otro podría verse adelante.

glLoadIdentity();

Cargamos la matriz de identidad encargada de nuestros objetos en el escenario. Con ella podemos modificar la escena.

glTranslatef(0.0, 0.0, -10);

Nos permite alejarnos o acercarnos a la escena.

dibujarCubo();

Implementa la secuencia de dibujado, osea lo que queremos mostrar escena

Método dibujarCubo

Al dibujar un objeto primero debemos especificar que tipo de objeto es. Luego le damos un color y asignamos la posición de cada vértice en el espacio 3D

void dibujarCubo(){

glBegin(GL_QUADS); //dibujar un cuadro
glColor3f(1.0f, 0.0f, 0.0f);//color RGB (tonalidades), f = float
glVertex3f(-0.5, 0.5, 0.5); //vertice (x,y,z)
glVertex3f(0.5, 0.5, 0.5);
glVertex3f(0.5, -0.5, 0.5);
glVertex3f(-0.5, -0.5, 0.5);
glEnd(); //terminamos el cuadro
}

La función recibe como parámetro el ancho y alto de nuestra ventana (si te preguntas por que los parametros de la función nunca son ingresados es porque OpenGL los obtiene automáticamente)}

Método dimensionar

Es necesario especificar el tamaño y la forma de nuestro volumen de

visualización. El volumen de visualización es aquel volumen cuyo contenido es el que

representaremos en pantalla . Sin este evento nuestra figura se deformaría al no tener una base de visualización, intenta cambiar el tamaño de tu ventana sin este evento y te darás cuenta del efecto que provoca.

glutReshapeFunc(dimensionar);

void dimensionar(GLsizei width, GLsizei height) {

glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45, (GLfloat) width / (GLfloat) height, 0.01, 20); 

// Restaurar a la matriz del Modelo (escena)
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();

}

Explicación

glViewport(0, 0, width, height);

Esta función define la porción de ventana donde puede dibujar

glMatrixMode(GL_PROJECTION);

Especifica la matriz actual. En OpenGL las operaciones de rotación, translación, escalado,

etc. se realizan a través de matrices de transformación. Dependiendo de lo que estemos

tratando, hay tres tipos de matriz (que son los tres posibles flags que puede llevar de

parámetro la función): matriz de proyección (GL_PROJECTION), matriz de modelo

(GL_MODELVIEW) y matriz de textura (GL_TEXTURE). Con esta función indicamos

a cual de estas tres se deben afectar las operaciones. Concretamente, GL_PROJECTION

afecta a las vistas o perspectivas o proyecciones. Esta proyección define el volumen de visualización y establece los planos de trabajo. A efectos prácticos, esta translación especifica cómo se traslada una escena finalizada a la imagen final de la pantalla. Los dos tipos de proyección más utilizados son la ortográfica y la perspectiva.

gluPerspective(45, (GLfloat) width / (GLfloat) height, 0.01, 20);

Los parámetros de gluPerspective son el ángulo para el campo de visión en sentido vertical, el aspecto es la relación entre la altura y la anchura (centrado) y las distancias de los planos