Inicialización de OpenGL
Todo aquel que en alguna ocasión ha pensado programar juegos con la plataforma .NET, y en especial con C# se habrá encontrado con el dilema de como manejar los gráficos.
El estandard . NET dispone de la libreria GDI+ que es muy útil para manejar imagenes y gráficos en 2D, no obstante, la programación en 3D no está contemplada.
Para ello Microsoft ideó las DirectX para .NET. y posteriormente la libreria XNA.
No obstante, estas librerias solo están disponibles para entornos Microsoft, por lo que nos resulta imposible hacer aplicaciones multiplataforma con ellas.
Para ello, los chicos de Tao Framework portaron la conocida libreria OpenGL a la plataforma .NET, lo que nos permitirá crear aplicaciones 3D de forma medianamente sencilla con la particularidad de que funcionarán tanto en entornos windows como linux.
En este primer articulo de la serie dedicada a OpenGL veremos como inicializar una aplicación para empezar a utilizar el OpenGL en nuestras aplicaciones.

Para crear una aplicación openGL lo primero que hay que hacer es preparar la aplicación para que pueda manejar la libreria y definir una area de la pantalla donde poner el resultado.
Existen diversos metodos para hecer esto. Algunos más complejos que otros. Aqui vamos a ver algunos de ellos.

OpenGL con GLUT
En el primer ejemplo utilizaremos la libreria auxiliar GLUT.
GLUT es una libreria de utilidades para openGL que nos facilitará algunas tareas como la configuración del area de visualización, la gestión del teclado y del joystick, la creación de menús o la definición de algunas figuras geometricas entre otras muchas funciones. Podeis encontrar la referencia completa de esta libreria aqui.
La version de la libreria GLUT que incluye Tao Framewor es la denominada FreeGlut. Que de hecho es una recodificación de la libreria original que se realizó principalmente por las restricciones de licencia que tenia la original.
En los ejemplos y libros oficiales de OpenGL, como por ejemplo el famoso libro rojo de openGL se utiliza esta libreria como medio sencillo de gestionar las aplicaciones OpenGL en entornos multiplataforma.

Pese a su gran cantidad de funciones la libreria GLUT y sus variantes posee un inconveniente y es que las ventanas de las aplicaciones las gestiona completamente ella, por lo que si queremos introducir una cuadro con graficos en 3D en una zona de un formulario no podremos hacerlo a no ser que queramos gestionar todo el formulario a través de GLUT. (Lo cual no aconsejo por la dificultad que acarrea)

Para empezar a realizar una aplicación OpenGL con FreeGLUT lo primero que deberemos hacer es crear un proyecto c# de consola y añadir las referencias a Tao.OpenGL y a Tao.FreeGlut.

Una vez hecho eso ya podemos empezar con el código.
Para empezar definiremos la clase de la aplicación y algunas variables, como por ejemplo el alto y el acho de la ventana.

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Text;
  4. using Tao.OpenGl;
  5. using Tao.FreeGlut;
  6. using System.Runtime.InteropServices;
  7.  
  8. namespace OpenGLTest1
  9. {
  10.     class Program
  11.     {
  12.         static double imagehalfaspect;
  13.         static int width = 512;
  14.         static int height = 512;
  15.         static int originalheight = height;

A continuación empezaremos con la función principal Main()

static void Main(string[] args)
  1.         {
  2.             Glut.glutInit();
  3.             Glut.glutInitWindowSize(width, height);
  4.             Glut.glutInitDisplayMode(Glut.GLUT_RGBA | Glut.GLUT_DOUBLE);
  5.             Glut.glutCreateWindow("Test");
  6.             Glut.glutDisplayFunc(Display);
  7.             Glut.glutReshapeFunc(Resize);
  8.  
  9.             imagehalfaspect = ((double)width) / ((double)height) * 0.5;
  10.  
  11.             Glut.glutMainLoop();
  12.         }

En la primera linea inicializamos la libreria Glut con la función Glut.glutInit().
Las dos siguientes lineas definen el aspecto de la ventana que vamos a crear definiendo el ancho, el alto y el formato de color a utilizar. Fijaros que el formato de color está definico como GLUT_RGBA lo que significa que el formato tendrá los canales de color rojo, verde, azul y además el alfa o transparencia. Existen otros formatos como el GLUT_RGB que no tiene el canal de alfa o el GLUT_INDEX que trabaja con colores indexados, no obstante, y salvo que tengais una tarjeta de video muy, muy vieja yo recomiendo el primer formato.
En la misma función en la que definimos el modo de color también he añadido la constante GLUT_DOUBLE, que indica que trabajaremos con un doble buffer, de forma que podremos manipular una imagen mientras se muestra otra en la pantalla, y cuando tengamos la primera imagen finalizada la podremos mostrar de golpe en pantalla sin que se vean todos los pasos intermedios, como borrar la pantalla, poner los objetos e imagenes en el o hacer los calculos para crear efectos especiales. Existen más opciones, pero por ahora vamos a ver solo estás.
Una vez hemos definido el aspecto de la ventana, con la función glutCreateWindow(”Test”) ordenamos que cree una ventana con el nombre “Test” y los parametros indicados.
Luego indicamos a la libreria Glut cuales van a ser las funciones que van a encargarse de controlar que es lo que aparecerá en pantalla y que cambios habrá cuando se redimensione la pantalla.
También he definido la variable imagehalfaspect que nos ayudará a controlar el tamaño de lo que aparece en pantalla.
Finalmente le indicamos a la libreria Freeglut que ya puede empezar a ejecutar el bucle de renderizado con lo que iniciará primero la función Resize que definirá el aspecto del contenido de la pantalla y luego llamará cuando haya que redibujar la ventana a la función Display por ejemplo cuando se cambia su posición o se superpone otra ventana encima.

  1. static void Resize(int w, int h)
  2.         {
  3.             width = w;
  4.             height = h;
  5.             imagehalfaspect  = 0.5 * width / height;
  6.  
  7.             Gl.glViewport(0, 0, width, height);
  8.             Gl.glMatrixMode(Gl.GL_PROJECTION);
  9.             Gl.glLoadIdentity();
  10.             Gl.glOrtho(-imagehalfaspect  * 1.1, imagehalfaspect  * 1.1, -0.6, 0.6, -1, 10);
  11.             Glut.glutPostRedisplay();
  12.         }

Como ya he dicho la función Resize es la que va a definir el tamaño y la forma en la que se van a ver las cosas en nuestra ventana. En este caso con la función glViewport() definiremos que lo que queremos ver es el espacio de coordenadas que va desde el punto (0,0) hasta el punto (widht, height) respecto a la ventana y que variará segun el tamaño de la ventana.

Por ahora no nos preocupemos por como funcionan las coordenadas. Eso ya lo veremos más adelante en el siguiente articulo de la serie dedicado a matrices y coordenadas.

A continuación especificamos la matriz sobre la que va a actuar la libreria. OpenGL dispone de diversas matrices para realizar operaciones de transformación de los objetos y vistas. En este caso concreto el modo será la matriz de proyección con GL_PROJECTION que afectará al modo en que vamos a ver los graficos. Por ahora tampoco debes preocuparte si no sabes que es una matriz o cuales son las diversas matrices de que dispone OpenGL. Lo veremos en el proximo articulo.
Una vez seleccionada la matriz de proyección la ponemos a cero, o mejor dicho, a 1 cargando la matriz identidad (repito que en el proximo articulo explicareque es eso, ahora me limitaré unicamente a ver como inicializar una aplicación basica)

Y para terminar con la función Resize especificamos que la vista de pantalla que vamos a utilizar es la ortogonal, es decir, que lo que dibujemos no va a tener profundidad, que se va a ver todo plano y sin prespectiva. Este modo es útil para hacer por ejemplo juegos en 2D. Y una vez especificado el modo de visualización llamaremos a la función glutPostRedisplay() que llamará a la función Display para que redibuje la pantalla.

La función Display lo que hará será dibujar un cuadro de color verde en el centro de la ventana, sin más complicaciones y a modo de ejemplo. Ya veremos como tratar las fifuras geometricas y los colores en el tercer articulo de la serie.

  1. static void Display()
  2.         {
  3.             Gl.glClear(Gl.GL_COLOR_BUFFER_BIT); //Limpiamos el buffer de color (borramos el anterior dibujo de la memoria
  4.             Gl.glMatrixMode(Gl.GL_MODELVIEW);  //Activamos la matriz de modelado
  5.             Gl.glLoadIdentity(); //Ponemos la matriz a 1
  6.             Glu.gluLookAt(0, 0, 10, 0, 0, 0, 0, 1, 0); //Hacia donde mira la camara
  7.  
  8.             Gl.glColor3d(0, 1, 0); //especificamos el color
  9.             Gl.glBegin(Gl.GL_QUADS); //indicamos que vamos a dibujar un cuadrado
  10.             //Ahora especificamos las coordenadas del cuadrado
  11.             Gl.glVertex3d(-imagehalfaspect, -0.5, 0); //abajo izquierda
  12.             Gl.glVertex3d(imagehalfaspect, -0.5, 0);  //abajo derecha
  13.             Gl.glVertex3d(imagehalfaspect, 0.1, 0);   //arriba derecha
  14.             Gl.glVertex3d(-imagehalfaspect, 0.5, 0);  //arriba izquierda
  15.             Gl.glEnd();//Indicamos que hemos terminado con el cuadrado
  16.  
  17.             Glut.glutSwapBuffers(); //hacemos el cambio de buffers
  18.         }

Puedes descargarte el programa de ejemplo desde aquí.

OpenGL con SimpleOpenGlControl

Dentro de las muchas utilidades que incluye Tao Framework se incluye un control que, al igual que FreeGlut nos facilitará la vida a la hora de programar con OpenGL. Este es el SimpleOpenGlControl que se encuentra dentro de Tao.Platform.Windows y lamentablemente solo funciona sobre plataformas Windows por lo que si queremos utilizar OpenGL sobre Linux deberemos utilizar la libreria GLUT.

Para empezar a utilizarlo deberemos crear en esta ocasión una aplicación basada en Forms. Seleccionad el tipo de proyecto adecuado pues y agregad al proyecto las referencias a Tao.OpenGL y a Tao.Platform.Windows. Con lo que ya podriamos empezar a utilizar el control mediante código. No obstante y para facilitarnos las cosas lo mejos va a ser agregarlo al cuadro de herramientas y desde allí empezaremos a manejarlo como cualquier otro control del entorno de desarrollo.
El procedimiento para hacer esto variará dependiendo del entorno que esteis utilizando, aqui os explicaré como hacerlo con Visual Studio.
openglctrlPrimero pulsaremos con el botón derecho del ratón sobre el panel de herramientas para que nos aparezca el menú contextual y a contunuación seleccionaremos la opción ‘Elegir elementos…’ tras lo que nos aparecerá una nueva ventana con la lista de los elementos posibles a añadir. En la sección de Componentes de .Net Framework buscaremos SimpleOpenGlControl y lo seleccionaremos. Pulsaremos el botón de aceptar y acto seguido nos aparecerá el control dentro del cuadro de herramientas, posiblemente en la sección ‘General’.

Ahora ya podemos empezar a utilizar el control. Lo primero que haremos será colocarlo en la posición que nos interese sobre el formulario y a continuación escribiremos unas lineas de codigo para inicializar y desinicializar el contexto grafico para poder utilizarlo.

  1. using System;
  2. using System.Collections.Generic;
  3. using System.ComponentModel;
  4. using System.Data;
  5. using System.Drawing;
  6. using System.Text;
  7. using System.Windows.Forms;
  8. using Tao.OpenGl;
  9. using Tao.Platform;
  10.  
  11. namespace OpenGLTest2
  12. {
  13.     public partial class Form1 : Form
  14.     {
  15.         static double imagehalfaspect;
  16.  
  17.         public Form1()
  18.         {
  19.             InitializeComponent();
  20.  
  21.             simpleOpenGlControl1.InitializeContexts();
  22.  
  23.             InitOpenGL();
  24.         }

Como en el caso anterior, declaramos la variable imagehalfaspect para controlar el tamaño de lo que vamos a dibujar. Aunque realmente podriamos calcularlo cada vez que redibujemos, en el caso de animaciones nos podria reducir ligeramente la velocidad.

En la función de inicio del formulario, que en principio solo deberia contener InitializeComponent(); para inicializar el resto de controles del formulario, añadimos dos lineas. La primera, simpleOpenGlControl1.InitializeContexts() inicializa el contexto gráfico del control, es decir, define los colores que vamos a utilizar y el modo en que vamos a utilizar la libreria. Por defecto utiliza el modo de color RGBA con doble buffer y si quisieramos utilizar otro modo deberiamos cambiar el codigo fuente del control o utilizar metodo que describiré en ultimo lugar para inicializar el OpenGL.

La segunda linea a añadir es una llamada a una función que inicializará el formato del openGL. El contenido de está función es similar al de la función Resize del ejemplo anterior.

  1. private void InitOpenGL()
  2.         {
  3.             int width = simpleOpenGlControl1.Width;
  4.             int height = simpleOpenGlControl1.Height;
  5.             imagehalfaspect = ((double)width) / ((double)height) * 0.5;
  6.             Gl.glViewport(0, 0, width, height);
  7.             Gl.glMatrixMode(Gl.GL_PROJECTION);
  8.             Gl.glLoadIdentity();
  9.             Gl.glOrtho(-imagehalfaspect * 1.1, imagehalfaspect * 1.1, -0.6, 0.6, -1, 10);
  10.         }

Para finalizar añadiremos dos eventos al control. El primero del tipo Resize, para que cuando el control cambie de tamaño se redimensione correctamente su contenido. En caso contrario la imagen interior mantendria su tamaño y se rellenaria el espacio sobrante con el color de fondo en el mejor de los casos o con algunos elementos que no nos interese que aparezcan en pantalla. En la función controladora del evento resize escribiremos una llamada a la función InitOpenGL.

private void simpleOpenGlControl1_SizeChanged(object sender, EventArgs e)
  1.         {
  2.             InitOpenGL();
  3.         }

El segundo evento a añadir es del tipo Paint y en el escribiremos las instrucciones para dibujar el contenido del control. Como ya mencioné antes no os preocupeis por saber para que sirven las instrucciones por ahora, lo explicaré paso a paso en otro articulo aunque el ejemplo está bastante comentado.
El código como observareis es practicamente el mismo que en la función Display del ejemplo con GLUT. Eso es debido a que la forma de trabajar de openGL es exactamente igual independientemente de como se inicialice. El único detalle distinto es la llamada a la función simpleOpenGlControl1.Refresh(); que es la encargada de mostrar lo que hemos dibujado. Está función realiza la misma tarea que Glut.glutSwapBuffers() del ejemplo con GLUT. Cambia el contenido del buffer que estamos utilizando por el que se muestra en pantalla

  1. private void simpleOpenGlControl1_Paint(object sender, PaintEventArgs e)
  2.         {
  3.             Gl.glClear(Gl.GL_COLOR_BUFFER_BIT); //Limpiamos el buffer de color (borramos el anterior dibujo de la memoria
  4.             Gl.glMatrixMode(Gl.GL_MODELVIEW);  //Activamos la matriz de modelado
  5.             Gl.glLoadIdentity(); //Ponemos la matriz a 1
  6.             Glu.gluLookAt(0, 0, 10, 0, 0, 0, 0, 1, 0); //Hacia donde mira la camara
  7.  
  8.             Gl.glColor3d(0, 1, 0); //especificamos el color
  9.             Gl.glBegin(Gl.GL_QUADS); //indicamos que vamos a dibujar un cuadrado
  10.             //Ahora especificamos las coordenadas del cuadrado
  11.             Gl.glVertex3d(-imagehalfaspect, -0.5, 0); //abajo izquierda
  12.             Gl.glVertex3d(imagehalfaspect, -0.5, 0);  //abajo derecha
  13.             Gl.glVertex3d(imagehalfaspect, 0.5, 0);   //arriba derecha
  14.             Gl.glVertex3d(-imagehalfaspect, 0.5, 0);  //arriba izquierda
  15.             Gl.glEnd();//Indicamos que hemos terminado con el cuadrado
  16.             simpleOpenGlControl1.Refresh();
  17.         }

Puedes descargarte el programa de ejemplo desde aquí.

OpenGL con GDI

Este es sin duda mi metodo favorito por ahora ya que podremos controlar mucho mejor donde y como quiero insertar los gráficos OpenGL a la vez que se pueden realizar funciones que con los otros dos sistemas serian algo más complicadas.

GDI es la libreria nativa de windows para manejar graficos para diversos tipos de dispositivos como pantallas, impresoras o incluso en memoria. La última versión de está libreria, denominada GDI+ permite manejar distintos formatos gráficos con transparencias además de mejorar considerable la funcionalidad de la libreria.

Al igual que en el sistema de inicialización anterior además de la libreria Tao.OpenGL requeriremos de la libreria Tao.Platform.Windows lo que una vez más nos va a limitar a sistemas Windows. Este sistema, de hecho, es exactamente el mismo que utiliza el SimpleOpenGlControl internamente. Y aunque creo haber visto por ahí un sistema de inicialización parecido para linux sobre GTK# con la libreria Tao.Platform.X11 no se como funciona todavia por lo que lo dejaré para un proximo articulo.

Lo primero que haremos nuevamente será crear un proyecto del tipo Forms al que le añadiremos las referencias a Tao.OpenGL y a Tao.Platform.Windows. Y añadiremos al código del formulario las clausulas using necesarias.

  1. using System;
  2. using System.Collections.Generic;
  3. using System.ComponentModel;
  4. using System.Data;
  5. using System.Drawing;
  6. using System.Linq;
  7. using System.Text;
  8. using System.Windows.Forms;
  9.  
  10. using Tao.OpenGl;
  11. using Tao.Platform.Windows;

A partir de ahi podremos añadir cualquier control a un formulario, ya sea un botón, un pictureBox, un label o lo que nos apetezca para utilizarlo como contexto para el OpenGL teniendo en cuenta que el control perderá parte de su funcionalidad gráfica. Si lo deseamos también podremos utilizar el formulario completo como contexto para OpenGL.

En el caso del ejemplo utilizaremos un control del tipo Panel ya que este nos dará menos problemas que cualquier otro sobretodo a la hora de refrescar su contenido.

Una vez añadido el control empezaremos con el código de inicialización.

Dentro de la clase del formulario declararemos tres nuevas variables globales:

  1.  namespace OpenGLTest3
  2. {
  3.     public partial class Form1 : Form
  4.     {
  5.         IntPtr context;
  6.         IntPtr hDC;
  7.         static double imagehalfaspect;

Y luego crearemos una nueva función que nos servirá para inicializar el contexto del OpenGL.

  1. private void CreateGLContext(IntPtr handle)
  2.         {
  3.             Gdi.PIXELFORMATDESCRIPTOR pfd = new Gdi.PIXELFORMATDESCRIPTOR();    // pfd especifica el formato de Pantalla que deseamos
  4.             pfd.nSize = (short)Marshal.SizeOf(pfd);                             // Tamaño de est Descriptor de Formato de los Pixels
  5.             pfd.nVersion = 1;                                                   // Numero de version (siempre 1)
  6.             pfd.dwFlags = Gdi.PFD_DRAW_TO_WINDOW |                              // El formato debe soportar el modo ventana
  7.                 Gdi.PFD_SUPPORT_OPENGL |                                        // El formato debe soportar el modo OpenGL
  8.                 Gdi.PFD_DOUBLEBUFFER;                                           // El formato debe soportar el modo Doble Buffering
  9.             pfd.iPixelType = (byte)Gdi.PFD_TYPE_RGBA;                           // Pide un formato RGBA (Rojo, verde, azul y alfa o transparencia)
  10.             pfd.cColorBits = (byte)32;                                          // profundidad de color (en bits)
  11.             pfd.cRedBits = 0;                                                   // Bits de color ignorados (según el formato de color)
  12.             pfd.cRedShift = 0;
  13.             pfd.cGreenBits = 0;
  14.             pfd.cGreenShift = 0;
  15.             pfd.cBlueBits = 0;
  16.             pfd.cBlueShift = 0;
  17.             pfd.cAlphaBits = 0;                                                 // Sin buffer de alfa
  18.             pfd.cAlphaShift = 0;                                                // Bit de desplazamiento ignorado
  19.             pfd.cAccumBits = 0;                                                 // Sin buffer de acumulación
  20.             pfd.cAccumRedBits = 0;                                              // Bit de acumulación ignorado
  21.             pfd.cAccumGreenBits = 0;
  22.             pfd.cAccumBlueBits = 0;
  23.             pfd.cAccumAlphaBits = 0;
  24.             pfd.cDepthBits = 16;                                                // 16Bit Z-Buffer (Buffer de profundidad)
  25.             pfd.cStencilBits = 1;                                               // Buffer de recorte
  26.             pfd.cAuxBuffers = 0;                                                // Sin Buffer Auxiliar
  27.             pfd.iLayerType = (byte)Gdi.PFD_MAIN_PLANE;                          // Capa principal de dibujo
  28.             pfd.bReserved = 0;                                                  // Reservados
  29.             pfd.dwLayerMask = 0;                                                // Capa de mascara ignorada
  30.             pfd.dwVisibleMask = 0;
  31.             pfd.dwDamageMask = 0;
  32.  
  33.             hDC = User.GetDC(handle);                                    //Obtenemos el puntero al dispositivo de salida
  34.  
  35.             int pixelFormat = Gdi.ChoosePixelFormat(hDC, ref pfd);              //Seleccionamos el Formato de Pixels
  36.             Gdi.SetPixelFormat(hDC, pixelFormat, ref pfd);                      //Y lo establecemos
  37.  
  38.             context = Wgl.wglCreateContext(hDC);                                //Crea el contexto OpenGL
  39.  
  40.             Wgl.wglMakeCurrent(hDC, context);                                   //Establecemos el contexto openGL actual (por si trabajasemos con más de uno)
  41.         }

El sistema para inicializar es bastante simple, solo debemos especificar en una estructura del tipo PIXELFORMATDESCRIPTOR el formato de pantalla que deseamos y luego lo activamos con Gdi.ChoosePixelFormat() y Gdi.SetPixelFormat(). Finalmente, cuando el sistema ha establecido el formato indicado creamos el contexto para OpenGL.

La función Wgl.wglMakeCurrent() nos sirve para seleccionar el contexto actual como activo. Esto nos permite tener diversas “ventanas” donde dibujar cosas distintas.

Fijaros que a la función se le pasa una variable del tipo IntPtr. Esta variable es un puntero al manejador gráfico del control que estemos utilizando y lo podemos obtener a través de la propiedad Handle de cada control.

A continuación crearemos las funciones ya conocidad para inicializar el formato de la visualización de OpenGL y la función que dibujara el conocido cuadro verde.

  1.  private void InitOpenGL(int width, int height)
  2.         {
  3.             imagehalfaspect = ((double)width) / ((double)height) * 0.5;
  4.             Gl.glViewport(0,
  5.                0, width, height);
  6.             Gl.glMatrixMode(Gl.GL_PROJECTION);
  7.             Gl.glLoadIdentity();
  8.             Gl.glOrtho(-imagehalfaspect * 1.1, imagehalfaspect * 1.1, -0.6, 0.6, -1, 10);
  9.         }
  10.  
  11.         private void Pinta()
  12.         {
  13.             Gl.glClear(Gl.GL_COLOR_BUFFER_BIT); //Limpiamos el buffer de color (borramos el anterior dibujo de la memoria
  14.             Gl.glMatrixMode(Gl.GL_MODELVIEW);  //Activamos la matriz de modelado
  15.             Gl.glLoadIdentity(); //Ponemos la matriz a 1
  16.             Glu.gluLookAt(0, 0, 10, 0, 0, 0, 0, 1, 0); //Hacia donde mira la camara
  17.  
  18.             Gl.glColor3d(0, 1, 0); //especificamos el color
  19.             Gl.glBegin(Gl.GL_QUADS); //indicamos que vamos a dibujar un cuadrado
  20.             //Ahora especificamos las coordenadas del cuadrado
  21.             Gl.glVertex3d(-imagehalfaspect, -0.5, 0); //abajo izquierda
  22.             Gl.glVertex3d(imagehalfaspect, -0.5, 0);  //abajo derecha
  23.             Gl.glVertex3d(imagehalfaspect, 0.5, 0);   //arriba derecha
  24.             Gl.glVertex3d(-imagehalfaspect, 0.5, 0);  //arriba izquierda
  25.             Gl.glEnd();//Indicamos que hemos terminado con el cuadrado
  26.  
  27.             Gl.glFlush();
  28.             Gdi.SwapBuffersFast(hDC);
  29.            
  30.         }

Fijaros de nuevo que en está ocasión la forma de indicar al sistema que tiene que dibujar en pantalla lo que hemos programado es a través de la función Gdi.SwapBuffersFast()

Ahora vamos aindicar al formulario como inicializar OpenGL para lo cual insertaremos en la función constructora Form() lo siguiente:

  1. public Form1()
  2.         {
  3.             InitializeComponent();
  4.  
  5.             CreateGLContext(panel1.Handle);
  6.  
  7.             InitOpenGL(panel1.Width, panel1.Height);
  8.  
  9.             Pinta();
  10.         }

Esto hara que, tras inicializar el resto de componentes, inicialice el contexto para openGL.

Para los casos en los que el formulario deba volver a dibujarse o se redimensione añadiremos los eventos Paint y Resize a nuestro panel y incluiremos las llamadas a las funciones que hemos creado con anterioridad.

  1. private void panel1_Paint(object sender, PaintEventArgs e)
  2.         {
  3.          Pinta();
  4.         }
  5.  
  6.         private void panel1_Resize(object sender, EventArgs e)
  7.         {
  8.             InitOpenGL(panel1.Width, panel1.Height);
  9.         }

Finalmente, para cuando dejemos de precisar openGL debemos desinicializar los contextos que hemos creado. De no hacerlo esto provocaria que se quedasen reservados en memoria, huerfanos y ocupando unos recursos que pueden ser necesarios más adelante. El no cerrar bien los contextos puede llegar a colgar el equipo cuando haya muchos abiertos.

Para esto, en la función destructora del formulario añadimos lo siguiente:

  1. ~Form1()
  2.         {
  3.             Wgl.wglMakeCurrent(IntPtr.Zero, IntPtr.Zero);
  4.             Wgl.wglDeleteContext(context);
  5.             context = IntPtr.Zero;
  6.         }

Y por ahora eso es todo. Compilamos, ejecutamos y ya está. Deberiais ver el cuadrado verde en el centro del control.

Al igual que antes, el codigo lo podeis descargar aqui.

Y hasta aqui el articulo acerca de la inicialización de OpenGL. Iré ampliando los metodos de inicialización a medida que tenga tiempo. Proximamente explicaré como utilizar openGL a pantalla completa y con multiples pantallas asi coo a utilizarlo a través de la libreria multimedia SDL.

Hasta la proxima!