// INICIANDO CON OPENGL
/*
La inicialización de una ventana en OpenGL requiere 5 rutinas básicas:
glutInit(int *argc, char **argv) ==> Se encarga de inicializar a GLUT, y debe ser llamada antes de cualquier otra rutina GLUT.
glutInitDisplayMode(unsigned int mode) ==> Especifica si se usará un modelo RGB o uno basado en índices; se puede también especificar
si se trata de modelos de buffer sencillo o doble, y finalmente puede asociarse a otros
buffers como son el stencil o la profundidad.
glutInitWindowPosition(int x, int y) ==> especifica la ubicación en la pantalla de la esquina superior izquierda de nuestra ventana.
glutInitWindowSize(int x, int y) ==> especifica el tamaño (en píxeles) de nuestra ventana.
glutCreateWindow (char *string) ==> se encarga de crear la ventana con un contexto OpenGL. Nota: hasta que la función
glutMainLoop() es llamada, la pantalla no se despliega.
Otros aspectos importantes a notar:
*glClearColor (0.0, 0.0, 0.0, 0.0) ==> nos permite definir el color con el que vamos a limpiar la pantalla. Modo RGBA.
*Cada vez que se presiona una tecla, GLUT detecta la acción y determina cuál tecla fue presionada. Esta información es utilizada
*En OpenGL, las instrucciones se escriben con minúsculas (gl) mientras que las constantes lo hacen con mayúsculas (GL)
*/
#include <stdio.h>
#include <GL/glut.h>
void Display(void) { }
void Reshape(int x, int y) { }
void KeyDown(unsigned char key, int x, int y) { }
void Idle(void) { Display(); }
int main (int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB); // glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB)
glutInitWindowSize(300,300);
glutInitWindowPosition(100, 100);
glutCreateWindow("Ventana de aplicacion");
glutDisplayFunc(Display);
glutReshapeFunc(Reshape);
glutKeyboardFunc(KeyDown);
glutIdleFunc(Idle);
glutMainLoop();
return 0;
}
/*
glutInit(&argc, argv);
glutInit inicia la libreria GLUT. Recibe dos parametros, que son los parametros que son recibidos por el main desde la linea de comando. glutInit extraera de la linea de comando los parametros que sean entendidos
por GLUT. Por el momento poco nos interesa saber cuales son, y ademas dependen del sistema operativo en el que corra.
gluInit inicializara la libreria GLUT y negociara una sesion con el sistema (de ventanas) en el que este corriendo. Puede pasar que el programa se cierre si GLUT no puede gestionar una sesion, o si el sistema no soporta OpenGL. Del mismo modo reaccionara si recibe una linea de comando incorrecta.
glutInitDisplayMode(GLUT);
glutInitDisplayMode configura el modo de video inicial, el mismo recibe un parametro, con el que se le indica la configuracion deseada, el prototipo de la funcion es
void glutInitDisplayMode(unsigned int modo);
Debido a que cada opcion son mascaras de bits, se puede seleccionar mas de una mediante la operacion logica OR. Los modos permitidos son (estos no son la totalidad de los modos, pero los mas usados, para ver una lista completa, vease “The OpenGL Utility Toolkit (GLUT) Programming Interfase")
GLUT_GRBA selecciona una ventana con modo RGBA por omision se selecciona esta si no se especifio ni RGBA o INDEX.
GLUT_RGB sinonimo para RGBA
GLUT_SINGLE selecciona una ventana con un solo buffer de color, si no se selecciona ni SINGLE ni DOUBLE, por omision se utiliza este
GLUT_DOUBLE selecciona una ventana con doble buffer.
GLUT_ACCUM selecciona una ventana con un buffer de acumulacion (o accumulation buffer)
GLUT_ALPHA selecciona una ventana cuyos color buffers tienen un componente alpha
GLUT_DEPTH selecciona una ventana con Depth Buffer (o Z-Buffer, o buffer de profundidad)
GLUT_STENCIL selecciona una ventana con un stencil buffer
Por el momento solo iniciamos una ventana con RGB, posteriormente se utilizara a Depth Buffer, Double Buffer, y demas.
glutInitWindowSize(300,300);
Aqui le indicamos a GLUT que la ventana que creara debe tener una dimension de 300x300 (ancho x alto).
glutCreateWindow("Ventana de aplicacion");
Aqui le indicamos a GLUT que efectivamente cree la ventana en el sistema que se esta corriendo. glutCreateWindow toma como parametro un string, en el que se le indica el titulo de la ventana.
Bien, a partir de aqui viene la parte de asignacion de rutinas, nosotros debemos asignarle a GLUT que rutinas utilizara como Display, Reshape, Idle, entrada de datos, y demas. Cada una de estas tendra caracteristicas diferentes que veremos mas adelante. La ventaja que nos provee el hecho de que nosotros debamos asignarles las funciones, radica en que tenemos un poco mas de libertad con respecto al nombre de las mismas.
Asignemos ahora las rutinas.
glutDisplayFunc(Display);
Aqui le indicamos a GLUT que la rutina utilizada como Display sera la llamada Display. Este tipo de rutinas se ejecuta una vez por ciclo de programa, y sera la que realice todas las operaciones graficas (o sea de render).
glutReshapeFunc(Reshape);
Aqui hacemos lo mismo que antes, solo que esta vez le asignamos la rutina de Reshape. Reshape se ejecuta cuando la ventana es cambiada de tamaño, y la primera vez que la aplicacion es ejecutada.
glutKeyboardFunc(KeyDown);
Esta vez asignamos la funcion de I/O. Esta rutina se ejecuta cada vez que se detecta una entrada de datos por teclado, y sera la responsable de manejar e interpretar esa entrada.
glutIdleFunc(Idle);
Por ultimo asignamos la rutina de Idle. Idle se ejecuta una vez por ciclo de programa, y es usada usualmente para albergar el codigo de manejo de variables de la aplicacion.
Una vez asignadas todas las rutinas necesarias, el programa entra en un ciclo constante que termina cuando la aplicacion es cerrada. Dentro de este ciclo se ejecutaran las rutinas Display, Idle, y cuando sea necesario KeyDown y Reshape La entrada al ciclo se realiza mediante el llamado a
glutMainLoop();
Aqui terminamos el analisis de nuestro primer programa, si bien aun no hicimos nada con OpenGL, ya tenemos una pequeña aplicacion base, que nos servira (con unas pequeñas modificaciones) para nuestros futuros ejemplos y programas a lo largo de este tutorial.
*/