#pragma comment( lib, "openGL32.lib" )  // Estas directivas del preprocesador
#pragma comment( lib, "glu32.lib" )	// le dicen a el enlazador (linker o 
				// linkador o ...) que incluya estas
				// librerias. Esto se puede hacer en
				// la configuracion del proyecto en el
				// Visual C++ pero esto me parece mas 
				// claro.
 
#include <windows.h>    // Fichero de inclusion para programas Windows
 
#include <GL/gl.h>	// Los ficheros de inclusion de OpenGL.
#include <GL/glu.h>	// Estrictamente solo es necesario el primero.
			// El segundo es de funciones utiles que se podrian
			// hacer de otra manera. No nos vamos a complicar la 
			// vida y la usaremos.
 
HINSTANCE IdAplicacion; // Para guardar el identificador del programa
HWND IdVentana;  // Para guardar el identificador de la ventana
 
HDC	DevContex;	// Device Context para conectar la ventana con OpenGL.
HGLRC OGLrc;	// Render Context para la ventana OpenGL.
 
int AnchoVentana = 600;	  // Lo que dice el nombre de la variable
int AltoVentana = 400;	  // Lo que dice el nombre de la variable
 
//--------------------------------------------------------------
// Funcion para inicializar OpenGL.
 
void IniciaGL()
{
    // Definimos una estructura de tipo PIXELFORMATDESCRIPTOR para definir
    // las caracteristicas graficas que queremos usar (dentro de las que nos
    // permite el OpenGL de nuestra tarjeta de video) 
 	static PIXELFORMATDESCRIPTOR pfd =
	{ 				
        sizeof(PIXELFORMATDESCRIPTOR),	// Tamaño de este descriptor
        1,				// Número de versión
        PFD_DRAW_TO_WINDOW |		// El formato debe soportar ventana
        PFD_SUPPORT_OPENGL |		// El formato debe soportar OpenGL
        PFD_DOUBLEBUFFER |		// Debe soportar Doble Buffer
        PFD_TYPE_RGBA,			// También debe soportar RGBA
        32,				// Bits por pixels seleccionados
        0,0,0,0,0,0,			// Bits de color ignorados
        0,				// Sin buffer alpha
        0,				// Shift bit ignorado
        0,				// Buffer de acumulación ignorado
        0,0,0,0,			// Bits de acumulación ignorados
        32,				// Z-Buffer de 32 bits
        0,				// Sin buffer de pincel (Stencil)
        0,				// Sin buffer auxiliar
        PFD_MAIN_PLANE,			// Layer de dibujo principal
        0,				// Reservado
        0,0,0,				// Layers de máscara ignorados
	}; 	
 
    // Estas funciones son las que hacen que la ventana acepte el modo grafico 
    // que queremos dado el descriptor de pixel anterior. (en el que uno de 
    // los parametros es que funcione con OpenGL).
 
	DevContex=GetDC(IdVentana);	  
            // Obtengo el "device context" de la ventana.
	int PixF=ChoosePixelFormat(DevContex,&pfd);	
            // Busco un indice de una conbinacion
	    // que coincida con mis especificaciones
	SetPixelFormat(DevContex,PixF,&pfd);	
            // Pongo la ventana en el formato que quiero.
     // Dos funciones de OpenGL por fin (aunque sean especificas de windows).
	OGLrc=wglCreateContext(DevContex);	
            // Indico a OpenGL que la ventana esta disponible para el.
	wglMakeCurrent(DevContex,OGLrc);	
            // Le digo a OpenGL que nuestra ventana es donde tiene 
	    // que dibujar a partir de ahora.
     // A partir de ahora podemos considerar OpenGL inicializado. 
     // Aun nos queda decirle los parametros del modo en que dibujar, aunque 
     // eso se puede, y de hecho se hace continuamente, cambiar durante la
     // ejecucion del programa.
     // Ahora pondremos algunos parametros puramente de OpenGL de inicio.
	glClearDepth(1.0f);		
           // Profundidad del buffer de profundidad. Hace que lo que esta 
	   // mas cerca se vea (dibuje) encima de lo que esta mas lejos.
	glDepthFunc(GL_LEQUAL);	
	   // Comparacion del buffer de profundidad.  
	glEnable(GL_DEPTH_TEST);	
           // Habilita test de profundidad. A partir de ahora, lo que 
	   // esta mas cerca se pinta encima.
	glClearColor(0,0,0,1.0f);	
           // Color del fondo. Color con el que se borra la pantalla, o la
	   // ventana donde pintamos. Cuando usemos la funcion glClear.
	glShadeModel(GL_SMOOTH);   
          // Renderizado suave. Cuanta mejor calidad mas lento. Nosotros
	  // tenemos un ordenador reciente(+ o -) y queremos que se vea bien.
	glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);   
          // Calidad buena de perspectiva.
	glViewport(0,0,AnchoVentana,AltoVentana);
          // Le dice a OpenGL el tamaño del lienzo en el que va a pintar en
	  // pixels. Coincidira, en principio, con el tamaño de nuestra ventana 
	  // y empezando por 0,0 (la esquina de nuestra ventana).
 
 
	glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); 
           // Borramos la ventana con el color antes establecido
	   // (en realidad solo el backbuffer (la pantalla oculta
	   // donde en realidad estamos pintando)
	   // y borramos tambien el buffer de profundidad
	SwapBuffers(DevContex);	 
           // Le digo a nuestro espacio de dibujo que cambie "muy rapido" 
	   // el buffer de dibujo por el de visualizacion y viceversa 
           // (suichear en Espanglish)
 
} // Fin IniciaGL
 
 
//------------------------------------------------------------------
// Funcion para controlar lo que ocurre en la ventana segun los eventos
// que vienen de Windows. Mas tarde se asocia a la ventana que crearemos.
// De momento solo interceptamos la tecla ESC para poder salir del 
// programa cuando queramos y el evento de destruccion de ventana con el
// que terminamos la aplicacion
LRESULT FAR PASCAL ProcesaMensajes(HWND Ventana, UINT Mensaje,
     				  WPARAM wParam, LPARAM lParam)
{
	switch(Mensaje) // Según el mensaje recibido
	{
	case WM_KEYDOWN: // Caso de mensaje de pulsación de una tecla
		switch(wParam) // y segun el contenido de la variable wParam 
		{
		case VK_ESCAPE: // ESC causa la salida del programa
			// Funcion para enviar mensaje de cerrado a la ventana
			// y despues de la aplicacion
			PostMessage(Ventana, WM_CLOSE, 0, 0); 
			break;
		} 
		break;
	case WM_DESTROY:// Mensaje de destrucción de la ventana (provocado por
			// nosotros al pulsar ESC o cerrar la ventana.
		PostQuitMessage(0); // Funcion para salir del programa
		break;
	} 
  // Efectuar el proceso por defecto del mensaje (si viene cualquier mensaje
  // que no hemos usado, querremos que haga lo que suele hacer)
	return DefWindowProc(Ventana, Mensaje, wParam, lParam);
} // fin ProcesaMansajes
 
 
//------------------------------------------------------------------
// Funcion para crear la ventana de nuestro programa, que asociaremos
// al OpenGL para pintar en ella
void CreaVentana()
{
	WNDCLASS ClaseVentana; // Declaramos un tipo de ventana, el nuestro.
 
    //Definimos nuestro tipo de ventana...
	ClaseVentana.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; 
          // Se redibujara si 
	   // cambia el tamaño de la ventana horizontal y verticalmente, y 
	   // un solo DC (device context) para cada ventana (para cuando 
          // empezemos con OpenGL)	
       ClaseVentana.lpfnWndProc = ProcesaMensajes;	 
          // La definimos antes para contolar
	  // los mansajes como los del teclado 
	ClaseVentana.cbClsExtra = 0; //Sin memoria extra para la clase
	ClaseVentana.cbWndExtra = 0; //Sin memoria extra para la ventana
	ClaseVentana.hInstance = IdAplicacion; 
           // Identificador del programa para asociar
	    // esta ventana con este programa.
	ClaseVentana.hIcon = NULL; // De momento pasamos de icono
	ClaseVentana.hCursor = LoadCursor(NULL, IDC_ARROW); 
           // Flecha normal de raton
	ClaseVentana.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH); 
           // Por ahora lo ponemos blanco
	ClaseVentana.lpszMenuName = NULL; // Pasamos de menu
	ClaseVentana.lpszClassName = L"UnSitioWeb"; 
           // Nombre de la clase (la "L" antes de la cadena es
	    // por que solo admite cadenas de caracteres 
	    // unicode -LPCWSTR o TCHAR- y con la "L" se convierte).
 
	RegisterClass(&ClaseVentana); // Registramos nuestro tipo de ventana
 
	IdVentana = CreateWindowEx( 
              // Funcion que crea la ventana. Guardamos el identificativo.
	     WS_EX_APPWINDOW,    // estilo extendido de ventana
	     L"UnSitioWeb",	
                  // Nombre de la clase puesto antes (la "L" para UNICODE)
	     L"Un Sitio Web",
                  // Titulo que aparecera en la ventana.
	     WS_POPUPWINDOW|WS_CAPTION|WS_MINIMIZEBOX, 
                  // Parametros de como sera la ventana
		   // se pueden combinar varios. 
	     100,       // Posicion Horizontal. 
	     100,       // Posicion Vertical. 
	     AnchoVentana,  // Ancho de la ventana. 
	     AltoVentana,	// Alto de la ventana. 
	     (HWND) NULL,	// No depende de otra ventana.
	     (HMENU) NULL,  
               // No le damos un menu diferente al de la clase(que es ninguno)
	     IdAplicacion,  
               // Identificador del programa al que pertenece la ventana. Al
	        // empezar lo guardamos en una variable para usarlo despues.
	     (LPVOID) NULL  );   
                // Puntero a "no se que" datos (pasamos del tema, es para 
		 // aplicaciones MIDI).
 
 
	ShowWindow(IdVentana, SW_SHOW); // Mostramos nuestra ventana.
	UpdateWindow(IdVentana);  
           // La actualizo para que muestre lo que tenga que mostrar 
           // (ahora nada)

} // Fin CreaVentana
 
 
//------------------------------------------------------------------
// Funcion principal de un programa Windows (como main en C normal, 
// aqui WinMain) el prorama empieza a ejecutarse a partir de esta funcion.
int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, 
    LPSTR lpszCmdLine, int nCmdShow) 
{ 
	UNREFERENCED_PARAMETER(lpszCmdLine);  
             // Para que no moleste al compilar, no lo usamos.
	IdAplicacion = hInstance;   
             // Guardo el identificador del programa, luego lo usamos.
 
	CreaVentana(); // Funcion que crea la ventana. Definida mas arriba.
	IniciaGL(); // Funcion para inicializar OpenGL. Definida mas arriba.
 
 
   // Este es el bucle habitual de windows que se esta ejecutando  
   // continuamente hasta que recibe el mensaje de acabar (ya lo hemos 
   // preparado en la funcion "ProcesaMensajes" asociada a  
   // la ventana, tambien asociada a este programa atraves de su 
   // identificativo)
       MSG Mensaje; // Varible para contener los mensajes que van llegando.
	while(TRUE) // Se ejecuta continuamente.
		{		
		if(PeekMessage(&Mensaje, NULL, 0, 0, PM_NOREMOVE))	
                    // Exploramos la cola de mensajes.
			{// procesándolos adecuadamente
			if(!GetMessage(&Mensaje, NULL, 0, 0)) 
                            return (int)Mensaje.wParam; // Terminamos.
			TranslateMessage(&Mensaje);
			DispatchMessage(&Mensaje);
			}
		else WaitMessage();	
                    // en caso contrario esperamos un mensaje
		}
 
} // fin WinMain
//------------------------------------------------------------------