#include <windows.h>		// Header File For Windows
#include <math.h>		// Header File For Windows Math Library
#include <gl\gl.h>		// Header File For The OpenGL32 Library
#include <gl\glu.h>		// Header File For The GLu32 Library
#include <gl\glaux.h>		// Header File For The GLaux Library

static	HGLRC hRC;		// Permanent Rendering Context
static	HDC hDC;		// Private GDI Device Context

GLuint	base;			// Base Display List For The Font Set
GLfloat	rot;			// Used To Rotate The Text

BOOL	keys[256];		// Array Used For The Keyboard Routine

GLvoid BuildFont(GLvoid)					// Build Our Bitmap Font
{
	GLYPHMETRICSFLOAT	gmf[256];			// Address Buffer For Font Storage
	HFONT	font;						// Windows Font ID

	base = glGenLists(256);					// Storage For 256 Characters

	font = CreateFont(	-12,				// Height Of Font

				0,				// Width Of Font

				0,				// Angle Of Escapement
				0,				// Orientation Angle

				FW_BOLD,			// Font Weight

				FALSE,				// Italic
				FALSE,				// Underline
				FALSE,				// Strikeout

				ANSI_CHARSET,			// Character Set Identifier

				OUT_TT_PRECIS,			// Output Precision

				CLIP_DEFAULT_PRECIS,		// Clipping Precision

				ANTIALIASED_QUALITY,		// Output Quality

				FF_DONTCARE|DEFAULT_PITCH,	// Family And Pitch

				"Comic Sans MS");		// Font Name

	SelectObject(hDC, font);				// Selects The Font We Created

	wglUseFontOutlines(	hDC,				// Select The Current DC
				0,				// Starting Character
				255,				// Number Of Display Lists To Build
				base,				// Starting Display Lists

				0.0f,				// Deviation From The True Outlines
				0.2f,				// Font Thickness In The Z Direction
				WGL_FONT_POLYGONS,		// Use Polygons, Not Lines
				gmf);				// Address Of Buffer To Recieve Data
}

GLvoid KillFont(GLvoid)						// Delete The Font
{
 	glDeleteLists(base, 256);				// Delete All 256 Characters
}

GLvoid glPrint(char *text)					// Custom GL "Print" Routine
{

	if (text == NULL)					// If There's No Text
		return;						// Do Nothing

	glPushAttrib(GL_LIST_BIT);				// Pushes The Display List Bits
	glListBase(base);					// Sets The Base Character to 0

	glCallLists(strlen(text), GL_UNSIGNED_BYTE, text);	// Draws The Display List Text
	glPopAttrib();						// Pops The Display List Bits
}

GLvoid InitGL(GLsizei Width, GLsizei Height)			// Will Be Called Right After The GL Window Is Created
{
	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);			// Clear The Background Color To Black
	glClearDepth(1.0);					// Enables Clearing Of The Depth Buffer
	glDepthFunc(GL_LESS);					// The Type Of Depth Test To Do
	glEnable(GL_DEPTH_TEST);				// Enables Depth Testing
	glShadeModel(GL_SMOOTH);				// Enables Smooth Color Shading

	glMatrixMode(GL_PROJECTION);				// Select The Projection Matrix
	glLoadIdentity();					// Reset The Projection Matrix

	// Calculate The Aspect Ratio Of The Window
	gluPerspective(45.0f,(GLfloat)Width/(GLfloat)Height,0.1f,100.0f);

	glMatrixMode(GL_MODELVIEW);				// Select The Modelview Matrix

	BuildFont();						// Build The Font
	glEnable(GL_LIGHT0);					// Enable Default Light (Quick And Dirty)
	glEnable(GL_LIGHTING);					// Enable Lighting
	glEnable(GL_COLOR_MATERIAL);				// Enable Coloring Of Material
}

GLvoid ReSizeGLScene(GLsizei Width, GLsizei Height)		// Handles Window Resizing
{
	if (Height==0)						// Is Window Too Small (Divide By Zero Error)
		Height=1;					// If So Make It One Pixel Tall

	// Reset The Current Viewport And Perspective Transformation
	glViewport(0, 0, Width, Height);

	glMatrixMode(GL_PROJECTION);				// Select The Projection Matrix
	glLoadIdentity();					// Reset The Projection Matrix

	// Calculate The Aspect Ratio Of The Window
	gluPerspective(45.0f,(GLfloat)Width/(GLfloat)Height,0.1f,100.0f);
	glMatrixMode(GL_MODELVIEW);				// Select The Modelview Matrix
}

GLvoid DrawGLScene(GLvoid)					// Handles Rendering
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	// Clear The Screen And The Depth Buffer
	glLoadIdentity();					// Reset The View
	glTranslatef(0.0f,0.0f,-10.0f);				// Move Ten Units Into The Screen

	glRotatef(rot,1.0f,0.0f,0.0f);				// Rotate On The X Axis
	glRotatef(rot*1.2f,0.0f,1.0f,0.0f);			// Rotate On The Y Axis
	glRotatef(rot*1.4f,0.0f,0.0f,1.0f);			// Rotate On The Z Axis

	glTranslatef(-3.5f,0.0f,0.0f);				// Move To The Left Before Drawing

	// Pulsing Colors Based On The Rotation
	glColor3f(1.0f*float(cos(rot/20.0f)),1.0f*float(sin(rot/25.0f)),1.0f-0.5f*float(cos(rot/17.0f)));

 	glPrint("OpenGL With NeHe");				// Print GL Text To The Screen

	rot+=0.1f;						// Increase The Rotation Variable
}

LRESULT CALLBACK WndProc(	HWND	hWnd,
				UINT	message,
				WPARAM	wParam,
				LPARAM	lParam)
{
	RECT	Screen;					// Used Later On To Get The Size Of The Window
	GLuint	PixelFormat;				// Pixel Format Storage
	static	PIXELFORMATDESCRIPTOR pfd=		// Pixel Format Descriptor
	{
		sizeof(PIXELFORMATDESCRIPTOR),		// Size Of This Pixel Format Descriptor
		1,					// Version Number (?)
		PFD_DRAW_TO_WINDOW |			// Format Must Support Window
		PFD_SUPPORT_OPENGL |			// Format Must Support OpenGL
		PFD_DOUBLEBUFFER,			// Must Support Double Buffering
		PFD_TYPE_RGBA,				// Request An RGBA Format
		16,					// Select A 16Bit Color Depth
		0, 0, 0, 0, 0, 0,			// Color Bits Ignored (?)
		0,					// No Alpha Buffer
		0,					// Shift Bit Ignored (?)
		0,					// No Accumulation Buffer
		0, 0, 0, 0,				// Accumulation Bits Ignored (?)
		16,					// 16Bit Z-Buffer (Depth Buffer)
		0,					// No Stencil Buffer
		0,					// No Auxiliary Buffer (?)
		PFD_MAIN_PLANE,				// Main Drawing Layer
		0,					// Reserved (?)
		0, 0, 0					// Layer Masks Ignored (?)
	};

	switch (message)						// Tells Windows We Want To Check The Message
	{
		case WM_CREATE:						// Window Creation
			hDC = GetDC(hWnd);				// Gets A Device Context For The Window
			PixelFormat = ChoosePixelFormat(hDC, &pfd);	// Finds The Closest Match To The Pixel Format We Set Above

			if (!PixelFormat)				// No Matching Pixel Format?
			{
				MessageBox(0,"Can't Find A Suitable PixelFormat.","Error",MB_OK|MB_ICONERROR);
				PostQuitMessage(0);			// This Sends A 'Message' Telling The Program To Quit
				break;					// Prevents The Rest Of The Code From Running
			}

			if(!SetPixelFormat(hDC,PixelFormat,&pfd))	// Can We Set The Pixel Mode?
			{
				MessageBox(0,"Can't Set The PixelFormat.","Error",MB_OK|MB_ICONERROR);
				PostQuitMessage(0);			// This Sends A 'Message' Telling The Program To Quit
				break;					// Prevents The Rest Of The Code From Running
			}

			hRC = wglCreateContext(hDC);			// Grab A Rendering Context
			if(!hRC)					// Did We Get One?
			{
				MessageBox(0,"Can't Create A GL Rendering Context.","Error",MB_OK|MB_ICONERROR);
				PostQuitMessage(0);			// This Sends A 'Message' Telling The Program To Quit
				break;					// Prevents The Rest Of The Code From Running
			}

			if(!wglMakeCurrent(hDC, hRC))			// Can We Make The RC Active?
			{
				MessageBox(0,"Can't Activate GLRC.","Error",MB_OK|MB_ICONERROR);
				PostQuitMessage(0);			// This Sends A 'Message' Telling The Program To Quit
				break;					// Prevents The Rest Of The Code From Running
			}

			GetClientRect(hWnd, &Screen);			// Grab Screen Info For The Current Window
			InitGL(Screen.right, Screen.bottom);		// Initialize The GL Screen Using Screen Info
			break;

		case WM_DESTROY:					// Windows Being Destroyed
		case WM_CLOSE:						// Windows Being Closed
			ChangeDisplaySettings(NULL, 0);			// Disable Fullscreen Mode

			KillFont();					// Deletes The Font Display List

			wglMakeCurrent(hDC,NULL);			// Make The DC Current
			wglDeleteContext(hRC);				// Kill The RC
			ReleaseDC(hWnd,hDC);				// Free The DC

			PostQuitMessage(0);				// Quit The Program
			break;

		case WM_KEYDOWN:					// Key Being Held Down
			keys[wParam] = TRUE;				// Make That Keys Cell True
			break;

		case WM_KEYUP:						// Key Is Released
			keys[wParam] = FALSE;				// Make That Keys Cell False
			break;

		case WM_SIZE:						// Resizing The Screen
			ReSizeGLScene(LOWORD(lParam),HIWORD(lParam));	// Resize To The New Window Size
			break;

		default:
			return (DefWindowProc(hWnd, message, wParam, lParam));	// Pass Windows Messages
	}
return (0);
}

int WINAPI WinMain(	HINSTANCE	hInstance, 
			HINSTANCE	hPrevInstance, 
			LPSTR		lpCmdLine, 
			int		nCmdShow)
{
	MSG		msg;		// Windows Message Structure
	WNDCLASS	wc;		// Windows Class Structure Used To Set Up The Type Of Window
	HWND		hWnd;		// Storage For Window Handle

	wc.style		= CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
	wc.lpfnWndProc		= (WNDPROC) WndProc;
	wc.cbClsExtra		= 0;
	wc.cbWndExtra		= 0;
	wc.hInstance		= hInstance;
	wc.hIcon		= NULL;
	wc.hCursor		= LoadCursor(NULL, IDC_ARROW);
	wc.hbrBackground	= NULL;
	wc.lpszMenuName		= NULL;
	wc.lpszClassName	= "OpenGL WinClass";

	if(!RegisterClass(&wc))
	{
		MessageBox(0,"Failed To Register The Window Class.","Error",MB_OK|MB_ICONERROR);
		return FALSE;
	}

	hWnd = CreateWindow(
	"OpenGL WinClass",
	"Jeff Molofee's GL Code Tutorial ... NeHe 2000",	// Title Appearing At The Top Of The Window

	WS_POPUP |						// Popup Window
	WS_CLIPCHILDREN |					// Clip Child Windows
	WS_CLIPSIBLINGS,					// Clip Sibling Windows

	0, 0,							// The Position Of The Window On The Screen
	640, 480,						// The Width And Height Of The WIndow

	NULL,
	NULL,
	hInstance,
	NULL);

	if(!hWnd)						// Was Window Created?
	{
		MessageBox(0,"Window Creation Error.","Error",MB_OK|MB_ICONERROR);
		return FALSE;
	}

	DEVMODE dmScreenSettings;							// Developer Mode

	memset(&dmScreenSettings, 0, sizeof(DEVMODE));					// Clear Room To Store Settings
	dmScreenSettings.dmSize		= sizeof(DEVMODE);				// Size Of The Devmode Structure
	dmScreenSettings.dmPelsWidth	= 640;						// Screen Width
	dmScreenSettings.dmPelsHeight	= 480;						// Screen Height
	dmScreenSettings.dmFields	= DM_PELSWIDTH | DM_PELSHEIGHT;			// Pixel Mode
	ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN);			// Switch To Full Screen

	ShowWindow(hWnd, SW_SHOW);							// Show Our Window
	UpdateWindow(hWnd);								// Update The Window
	SetFocus(hWnd);									// Set Focus On The Window
	wglMakeCurrent(hDC,hRC);							// Make DC/RC Current

	while (1)									// Endless Loop
	{
		// Process All Messages
		while (PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE))
		{
			if (GetMessage(&msg, NULL, 0, 0))
			{
				TranslateMessage(&msg);
				DispatchMessage(&msg);
			}
			else
			{
				return TRUE;
			}
		}

		DrawGLScene();								// Draw The Scene
		SwapBuffers(hDC);							// Swap Screen Buffers
		if (keys[VK_ESCAPE]) SendMessage(hWnd,WM_CLOSE,0,0);			// If ESC Is Pressed Quit
	}
}