OpenGL es una API grafica 3D desarrollada por SGI (Silicon Graphics Inc.),la misma nos da la posibilidad de dibujar primitivas de forma sencilla, rápida, y aprovechando las capacidades de la tarjeta grafica instalada en el sistema. En caso de no existir soporte por hardware para realizar una determinada operación, OpenGL la simulara por Software. Pueden visitar la pagina oficial de OpenGL en http://www.opengl.org

Para los que no lo conocen, Direct3D (o D3D) es otra API grafica 3D desarrollada por Microsoft. Para el desarrollo bajo Windows puede usarse cualquiera de las dos, pero con D3D se queda restringido solo al entorno Windows. OpenGL esta diseñada para ser utilizado en casi cualquier sistema operativo, ya sea Mac OS, Linux, Unix, Windows o Solaris. 

Personalmente prefiero OpenGL por su rapidez, sencillez y versatilidad. Mientras que D3D parece hacer todo lo posible para hacer que el programador deba pasarse horas iniciándolo e intentando ajustarse a su estructura por demás incomoda y demasiado orientada a objetos, OpenGL permite al programador ocuparse en el desarrollo del programa, mas que en el manejo de la API grafica.

Muchas personas defienden D3D indicando que provee D3DX, un set de herramientas y librerías que facilitan el desarrollo del programa, proveyendo el manejo de Sprites, Texto3d, Progresive Mesh, Animación, incluso su propio formato de archivos 3d con su respectiva rutinas de carga y visualización. Es elección libre de ustedes que API elegir, personalmente no me gusta que me den todo servido, si les gusta aprender como son las cosas, y tener el mayor control posible sobre su código, les recomiendo OpenGL. 

OpenGL utiliza el prefijo gl y letras iniciales mayúsculas para nombrar sus comandos (ejemplo: glPolygonMode, glShadeModel), a su vez, las constantes definidas por OpenGL llevan el prefijo GL como por ejemplo GL_BACK, GL_TEXTURE_2D.

Por otra parte, en comandos que reciben parámetros numéricos, es indicado al final de su nombre el tipo de parámetro, y la cantidad de los mismos, como por ejemplo glVertex3f: 3f nos indica que recibirá 3 parámetros numéricos del tipo float. Algunas funciones pueden tomar hasta 8 tipos diferentes de parámetros, a continuación les presento una tabla en la que pueden observar los distintos tipos de sufijos y su respectivo tamaño, tipo, definición en C, y en OpenGL.
 

 Los mas usados comunmente son i y f.

Algunas funciones pueden tener nombres terminados en v, este sufijo indica que en lugar de recibir los parametros en forma directa (uno por uno), recibira los mismos en forma de vector, por ejemplo.

glColor3f(1.0, 2.0, 3.0);

es igual a

float color[] = {1.0, 2.0, 3.0}; glColor3fv(color);

Glut es una libreria de ayuda de OpenGL escrita por Mark Kilgard (*), la misma provee un workframe muy comodo,  sencillo y multi-plataforma. Por medio de glut podemos crear la ventana en la que trabajaremos, iniciar OpenGL y manejar algunas funciones basicas de I/O. 

Durante esta serie tutoriales trabajaremos utilizando glut, debido a que nos resultara en un codigo mas entendible y compacto, y nos permitira abocarnos de lleno en el aprendizaje de OpenGL. Mas adelante aprenderemos a inicializar OpenGL en una ventana utilizando Win32, lo que nos reportara un codigo mucho mas rapido en ejecucion. Estamos aprendiendo, y eso aun no nos importa demasiado, de modo que por ahora utilizaremos glut..

(*) Mark Kilgard. Si tienen la posibilidad, consigan algun paper de el (en la pagina de nVidia), lo cierto es que es un programador exelente y explica muchos efectos de una manera muy amena y sencilla.

A continuacion les presento un programa muy sencillo que lo unico que hace es crear una ventana utilizando glut, tampoco mostrara nada en ella, de modo que ver que sucede con alli dentro puede ser aterrador.
La idea es analizar la estructura de un programa que utiliza glut, y a su vez, analizar el funcionamiento de esta libreria de ayuda.
Los programas basados en glut deben ser proyectos de Consola (en realidad no necesariamente, pero para debug es increible), lo cual nos da el confort de un programa clasico de C. Para crear un proyecto de consola, vayan a File/New, tab Project/Win32 Console Aplication.

//  ----------------------------------------
//  glTutorial #1.c
//  ---------------------------------------- 

#include <stdio.h>
#include <gl\glut.h> 

#pragma comment( lib, "opengl32.lib" ) 
#pragma comment( lib, "glu32.lib" ) 

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);
      glutInitWindowSize(300,300);
      glutCreateWindow("glTut #1");
      glutDisplayFunc(Display);
      glutReshapeFunc(Reshape);
      glutKeyboardFunc(KeyDown);
      glutIdleFunc(Idle);
      glutMainLoop();
      return 0;
}

//  --------------------------------eof-----

Bien, analicemos este pequeño programita, la parte que mas nos interesa por el momento (bueno, por este numero al menos) es la sub main, iremos linea por linea y veremos que hace cada una.

            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, en los proximos tutoriales iremos iniciando mas cosas, como 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("glTut #1");

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 (si alguien ha utilizado alguna vez el workframe de D3D habra visto que incomodo resulta). 

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.

En esta seccion (que reconozco nada tiene que ver con los tutoriales en si) elegire un composer, y los alentare a escuchar tres composiciones del mismo. Es una (pequeña) forma de agradecerles a ellos por lo que hacen, y de intentar hacer que estos formatos sean un poco mas populares.
Los IT/XM/S3M son formatos de musica trackeada basados en el viejo .MOD (Amiga Module). Hoy en dia existen muchos Trackers gratuitos con exelentes caracteristicas tecnicas, incluyendo la conexion por MIDI. Lo cual nos da (la unica) ventaja del midi pero con una calidad de sonido exelente.

El artista elegido para este primer numero de glTutorial es Carl Larsson (Nightbeat) y los temas son:

- Approach [.it]
- Flight of the Kingfisher [.it]
- The Steadfast [.it]

Los mismos pueden ser conseguidos en The Mod Archive.

En el proximo tutorial arreglaremos este programita para poder empezar a graficar con OpenGL mientras aprenderemos algunos conceptos basicos
Si mis calculos son correctos, el numero #2 de glTutorial estara terminado dentro de 15 dias aproximadamente (espero), los veré entonces.

Cualquier duda, comentario, critica, o lo que sea, no duden en contactarme en

MSN & Mail - silencer_ar@hotmail.com
Tel. 4-842-6705 (voice)

o en el canal #programadores de irc.ciudad.com.ar, bajo el nick Silencer, Assembly, o Born2CodeC.

rodrigo pelorosso [silencer]
5/11/03 buenos aires, argentina