text: #include <windows.h>
  #include <GL/gl.h>
  #include <GL/glu.h>
  //#include <GL/glaux.h>
  
  
  
  HGLRC hRC = NULL;
  HDC hDC = NULL;
  HWND hWnd = NULL;
  HINSTANCE hInstance;
  
  bool keys[256];
  bool active = TRUE;
  bool fullscreen = TRUE;
  
  GLfloat rtri;
  GLfloat rquad;
  
  LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
  
  GLvoid ReSizeGLScene(GLsizei width, GLsizei height)
  {
  	if (height == 0)
  	{
  		height = 1;
  	}
  
  	glViewport(0, 0, width, height);
  	glMatrixMode(GL_PROJECTION);
  	glLoadIdentity();
  
  	gluPerspective(45.0f, (GLfloat)width / (GLfloat)height, 0.1f, 100.0f);
  
  	glMatrixMode(GL_MODELVIEW);
  	glLoadIdentity();
  }
  
  
  int InitGL(GLvoid)
  {
  	glShadeModel(GL_SMOOTH);
  	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
  
  	glClearDepth(1.0f);                         // Depth Buffer Setup
  	glEnable(GL_DEPTH_TEST);                        // Enables Depth Testing
  	glDepthFunc(GL_LEQUAL);
  
  	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
  
  	return TRUE;
  }
  
  int DrawGLScene(GLvoid)                             // Here's Where We Do All The Drawing
  {
  	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);         // Clear The Screen And The Depth Buffer
  	glLoadIdentity();                           // Reset The Current ModelView Matrix
  
  	glTranslatef(-1.5f, 0.0f, -6.0f);
  	glRotatef(rtri, 0.0f, 1.0f, 0.0f);
  
  	glBegin(GL_TRIANGLES);                      // Drawing Using Triangles
  
  	glColor3f(1.0f, 0.0f, 0.0f);          // Red
  	glVertex3f(0.0f, 1.0f, 0.0f);          // Top Of Triangle (Front)
  	glColor3f(0.0f, 1.0f, 0.0f);          // Green
  	glVertex3f(-1.0f, -1.0f, 1.0f);          // Left Of Triangle (Front)
  	glColor3f(0.0f, 0.0f, 1.0f);          // Blue
  	glVertex3f(1.0f, -1.0f, 1.0f);          // Right Of Triangle (Front)
  
  	glColor3f(1.0f, 0.0f, 0.0f);          // Red
  	glVertex3f(0.0f, 1.0f, 0.0f);          // Top Of Triangle (Right)
  	glColor3f(0.0f, 0.0f, 1.0f);          // Blue
  	glVertex3f(1.0f, -1.0f, 1.0f);          // Left Of Triangle (Right)
  	glColor3f(0.0f, 1.0f, 0.0f);          // Green
  	glVertex3f(1.0f, -1.0f, -1.0f);         // Right Of Triangle (Right)
  
  	glColor3f(1.0f, 0.0f, 0.0f);          // Red
  	glVertex3f(0.0f, 1.0f, 0.0f);          // Top Of Triangle (Back)
  	glColor3f(0.0f, 1.0f, 0.0f);          // Green
  	glVertex3f(1.0f, -1.0f, -1.0f);         // Left Of Triangle (Back)
  	glColor3f(0.0f, 0.0f, 1.0f);          // Blue
  	glVertex3f(-1.0f, -1.0f, -1.0f);         // Right Of Triangle (Back)
  
  	glColor3f(1.0f, 0.0f, 0.0f);          // Red
  	glVertex3f(0.0f, 1.0f, 0.0f);          // Top Of Triangle (Left)
  	glColor3f(0.0f, 0.0f, 1.0f);          // Blue
  	glVertex3f(-1.0f, -1.0f, -1.0f);          // Left Of Triangle (Left)
  	glColor3f(0.0f, 1.0f, 0.0f);          // Green
  	glVertex3f(-1.0f, -1.0f, 1.0f);          // Right Of Triangle (Left)
  
  	glEnd();
  
  	glTranslatef(3.0f, 0.0f, 0.0f);
  	glRotatef(rquad, 1.0f, 0.0f, 0.0f);
  	glColor3f(0.5f, 0.5f, 1.0f);              // Set The Color To Blue One Time Only
  	glBegin(GL_QUADS);                      // Draw A Quad
  
  	glColor3f(0.0f, 1.0f, 0.0f);          // Set The Color To Green
  	glVertex3f(1.0f, 1.0f, -1.0f);          // Top Right Of The Quad (Top)
  	glVertex3f(-1.0f, 1.0f, -1.0f);          // Top Left Of The Quad (Top)
  	glVertex3f(-1.0f, 1.0f, 1.0f);          // Bottom Left Of The Quad (Top)
  	glVertex3f(1.0f, 1.0f, 1.0f);          // Bottom Right Of The Quad (Top)
  
  	glColor3f(1.0f, 0.5f, 0.0f);          // Set The Color To Orange
  	glVertex3f(1.0f, -1.0f, 1.0f);          // Top Right Of The Quad (Bottom)
  	glVertex3f(-1.0f, -1.0f, 1.0f);          // Top Left Of The Quad (Bottom)
  	glVertex3f(-1.0f, -1.0f, -1.0f);          // Bottom Left Of The Quad (Bottom)
  	glVertex3f(1.0f, -1.0f, -1.0f);          // Bottom Right Of The Quad (Bottom)
  
  	glColor3f(1.0f, 0.0f, 0.0f);          // Set The Color To Red
  	glVertex3f(1.0f, 1.0f, 1.0f);          // Top Right Of The Quad (Front)
  	glVertex3f(-1.0f, 1.0f, 1.0f);          // Top Left Of The Quad (Front)
  	glVertex3f(-1.0f, -1.0f, 1.0f);          // Bottom Left Of The Quad (Front)
  	glVertex3f(1.0f, -1.0f, 1.0f);          // Bottom Right Of The Quad (Front)
  
  	glColor3f(1.0f, 1.0f, 0.0f);          // Set The Color To Yellow
  	glVertex3f(1.0f, -1.0f, -1.0f);          // Bottom Left Of The Quad (Back)
  	glVertex3f(-1.0f, -1.0f, -1.0f);          // Bottom Right Of The Quad (Back)
  	glVertex3f(-1.0f, 1.0f, -1.0f);          // Top Right Of The Quad (Back)
  	glVertex3f(1.0f, 1.0f, -1.0f);          // Top Left Of The Quad (Back)
  
  	glColor3f(0.0f, 0.0f, 1.0f);          // Set The Color To Blue
  	glVertex3f(-1.0f, 1.0f, 1.0f);          // Top Right Of The Quad (Left)
  	glVertex3f(-1.0f, 1.0f, -1.0f);          // Top Left Of The Quad (Left)
  	glVertex3f(-1.0f, -1.0f, -1.0f);          // Bottom Left Of The Quad (Left)
  	glVertex3f(-1.0f, -1.0f, 1.0f);          // Bottom Right Of The Quad (Left)
  
  	glColor3f(1.0f, 0.0f, 1.0f);          // Set The Color To Violet
  	glVertex3f(1.0f, 1.0f, -1.0f);          // Top Right Of The Quad (Right)
  	glVertex3f(1.0f, 1.0f, 1.0f);          // Top Left Of The Quad (Right)
  	glVertex3f(1.0f, -1.0f, 1.0f);          // Bottom Left Of The Quad (Right)
  	glVertex3f(1.0f, -1.0f, -1.0f);          // Bottom Right Of The Quad (Right)
  
  	glEnd();                            // Done Drawing The Quad
  
  	rtri += 0.2f;
  	rquad -= 0.15f;
  
  	return TRUE;                                // Everything Went OK
  }
  
  
  GLvoid KillGLWindow(GLvoid)                         // Properly Kill The Window
  {
  	if (fullscreen)                             // Are We In FullScreen Mode?
  	{
  		ChangeDisplaySettings(NULL, 0);                  // If So Switch Back To The Desktop
  		ShowCursor(TRUE);
  	}
  
  	if (hRC)                                // Do We Have A Rendering Context?
  	{
  		if (!wglMakeCurrent(NULL, NULL))                 // Are We Able To Release The DC And RC Contexts?
  		{
  			MessageBox(NULL, TEXT("Release Of DC And RC Failed."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION);
  		}
  
  		if (!wglDeleteContext(hRC))                 // Are We Able To Delete The RC?
  		{
  			MessageBox(NULL, TEXT("Release Rendering Context Failed."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION);
  		}
  		hRC = NULL;
  	}
  
  	if (hDC && !ReleaseDC(hWnd, hDC))                    // Are We Able To Release The DC
  	{
  		MessageBox(NULL, TEXT("Release Device Context Failed."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION);
  		hDC = NULL;                           // Set DC To NULL
  	}
  
  	if (hWnd && !DestroyWindow(hWnd))                   // Are We Able To Destroy The Window?
  	{
  		MessageBox(NULL, TEXT("Could Not Release hWnd."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION);
  		hWnd = NULL;                          // Set hWnd To NULL
  	}
  
  	if (!UnregisterClass(TEXT("OpenGL"), hInstance))               // Are We Able To Unregister Class
  	{
  		MessageBox(NULL, TEXT("Could Not Unregister Class."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION);
  		hInstance = NULL;                         // Set hInstance To NULL
  	}
  }
  
  BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
  {
  	GLuint      PixelFormat;                        // Holds The Results After Searching For A Match
  
  	WNDCLASS    wc;
  	DWORD       dwExStyle;                      // Window Extended Style
  	DWORD       dwStyle;
  	RECT WindowRect;                            // Grabs Rectangle Upper Left / Lower Right Values
  	WindowRect.left = (long)0;                        // Set Left Value To 0
  	WindowRect.right = (long)width;                       // Set Right Value To Requested Width
  	WindowRect.top = (long)0;                         // Set Top Value To 0
  	WindowRect.bottom = (long)height;
  
  	fullscreen = fullscreenflag;
  
  	hInstance = GetModuleHandle(NULL);            // Grab An Instance For Our Window
  	wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;       // Redraw On Move, And Own DC For Window
  	wc.lpfnWndProc = (WNDPROC)WndProc;                // WndProc Handles Messages
  	wc.cbClsExtra = 0;                        // No Extra Window Data
  	wc.cbWndExtra = 0;                        // No Extra Window Data
  	wc.hInstance = hInstance;                    // Set The Instance
  	wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);          // Load The Default Icon
  	wc.hCursor = LoadCursor(NULL, IDC_ARROW);          // Load The Arrow Pointer
  	wc.hbrBackground = NULL;                     // No Background Required For GL
  	wc.lpszMenuName = NULL;                     // We Don't Want A Menu
  	wc.lpszClassName = TEXT("OpenGL");
  
  
  	if (!RegisterClass(&wc))                        // Attempt To Register The Window Class
  	{
  		MessageBox(NULL, TEXT("Failed To Register The Window Class."), TEXT("ERROR"), MB_OK | MB_ICONEXCLAMATION);
  		return FALSE;                           // Exit And Return FALSE
  	}
  
  	if (fullscreen)                             // Attempt FullScreen Mode?
  	{
  		DEVMODE dmScreenSettings;                   // Device Mode
  		memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));       // Makes Sure Memory's Cleared
  		dmScreenSettings.dmSize = sizeof(dmScreenSettings);       // Size Of The DevMode Structure
  		dmScreenSettings.dmPelsWidth = width;            // Selected Screen Width
  		dmScreenSettings.dmPelsHeight = height;           // Selected Screen Height
  		dmScreenSettings.dmBitsPerPel = bits;             // Selected Bits Per Pixel
  		dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
  
  		// Try To Set Selected Mode And Get Results.NOTE: CDS_FULLSCREEN Gets Rid Of Start Bar.
  		if (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
  		{
  			if (MessageBox(NULL, TEXT("The Requested FullScreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?"), TEXT("NeHe GL"), MB_YESNO | MB_ICONEXCLAMATION) == IDYES)
  			{
  				fullscreen = FALSE;               // Select Windowed Mode (FullScreen=FALSE)
  			}
  			else
  			{
  				MessageBox(NULL, TEXT("Program Will Now Close."), TEXT("ERROR"), MB_OK | MB_ICONSTOP);
  				return FALSE;                   // Exit And Return FALSE
  			}
  		}
  	}
  
  	if (fullscreen)                             // Are We Still In FullScreen Mode?
  	{
  		dwExStyle = WS_EX_APPWINDOW;                  // Window Extended Style
  		dwStyle = WS_POPUP;                       // Windows Style
  		ShowCursor(FALSE);
  	}
  	else {
  		dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;           // Window Extended Style
  		dwStyle = WS_OVERLAPPEDWINDOW;
  	}
  
  	AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle);
  
  	if (!(hWnd = CreateWindowEx(dwExStyle,              // Extended Style For The Window
  		TEXT("OpenGL"),               // Class Name
  		title,                  // Window Title
  		WS_CLIPSIBLINGS |           // Required Window Style
  		WS_CLIPCHILDREN |           // Required Window Style
  		dwStyle,                // Selected Window Style
  		0, 0,                   // Window Position
  		WindowRect.right - WindowRect.left,   // Calculate Adjusted Window Width
  		WindowRect.bottom - WindowRect.top,   // Calculate Adjusted Window Height
  		NULL,                   // No Parent Window
  		NULL,                   // No Menu
  		hInstance,              // Instance
  		NULL)))
  	{
  		KillGLWindow();                         // Reset The Display
  		MessageBox(NULL, TEXT("Window Creation Error."), TEXT("ERROR"), MB_OK | MB_ICONEXCLAMATION);
  		return FALSE;                           // Return FALSE
  	}
  
  	static  PIXELFORMATDESCRIPTOR pfd =                  // pfd Tells Windows How We Want Things To Be
  	{
  		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
  		bits,                               // Select Our 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
  	};
  
  	if (!(hDC = GetDC(hWnd)))                         // Did We Get A Device Context?
  	{
  		KillGLWindow();                         // Reset The Display
  		MessageBox(NULL, TEXT("Can't Create A GL Device Context."), TEXT("ERROR"), MB_OK | MB_ICONEXCLAMATION);
  		return FALSE;                           // Return FALSE
  	}
  
  	if (!(PixelFormat = ChoosePixelFormat(hDC, &pfd)))             // Did Windows Find A Matching Pixel Format?
  	{
  		KillGLWindow();                         // Reset The Display
  		MessageBox(NULL, TEXT("Can't Find A Suitable PixelFormat."), TEXT("ERROR"), MB_OK | MB_ICONEXCLAMATION);
  		return FALSE;                           // Return FALSE
  	}
  
  	if (!SetPixelFormat(hDC, PixelFormat, &pfd))               // Are We Able To Set The Pixel Format?
  	{
  		KillGLWindow();                         // Reset The Display
  		MessageBox(NULL, TEXT("Can't Set The PixelFormat."), TEXT("ERROR"), MB_OK | MB_ICONEXCLAMATION);
  		return FALSE;                           // Return FALSE
  	}
  
  	if (!(hRC = wglCreateContext(hDC)))                   // Are We Able To Get A Rendering Context?
  	{
  		KillGLWindow();                         // Reset The Display
  		MessageBox(NULL, TEXT("Can't Create A GL Rendering Context."), TEXT("ERROR"), MB_OK | MB_ICONEXCLAMATION);
  		return FALSE;                           // Return FALSE
  	}
  
  	if (!wglMakeCurrent(hDC, hRC))                        // Try To Activate The Rendering Context
  	{
  		KillGLWindow();                         // Reset The Display
  		MessageBox(NULL, TEXT("Can't Activate The GL Rendering Context."), TEXT("ERROR"), MB_OK | MB_ICONEXCLAMATION);
  		return FALSE;                           // Return FALSE
  	}
  
  	ShowWindow(hWnd, SW_SHOW);                       // Show The Window
  	SetForegroundWindow(hWnd);                      // Slightly Higher Priority
  	SetFocus(hWnd);                             // Sets Keyboard Focus To The Window
  	ReSizeGLScene(width, height);
  
  	if (!InitGL())                              // Initialize Our Newly Created GL Window
  	{
  		KillGLWindow();                         // Reset The Display
  		MessageBox(NULL, TEXT("Initialization Failed."), TEXT("ERROR"), MB_OK | MB_ICONEXCLAMATION);
  		return FALSE;                           // Return FALSE
  	}
  
  	return TRUE;
  }
  
  
  LRESULT CALLBACK WndProc(HWND    hWnd,                   // Handle For This Window
  	UINT    uMsg,                   // Message For This Window
  	WPARAM  wParam,                 // Additional Message Information
  	LPARAM  lParam)                 // Additional Message Information
  {
  	switch (uMsg)                               // Check For Windows Messages
  	{
  	case WM_ACTIVATE:                       // Watch For Window Activate Message
  	{
  		if (!HIWORD(wParam))                    // Check Minimization State
  		{
  			active = TRUE;                    // Program Is Active
  		}
  		else
  		{
  			active = FALSE;                   // Program Is No Longer Active
  		}
  
  		return 0;                       // Return To The Message Loop
  	}
  	case WM_SYSCOMMAND:                     // Intercept System Commands
  	{
  		switch (wParam)                     // Check System Calls
  		{
  		case SC_SCREENSAVE:             // ScreenSaver Trying To Start?
  		case SC_MONITORPOWER:               // Monitor Trying To Enter PowerSave?
  			return 0;                   // Prevent From Happening
  		}
  		break;                          // Exit
  	}
  	case WM_CLOSE:                          // Did We Receive A Close Message?
  	{
  		PostQuitMessage(0);                 // Send A Quit Message
  		return 0;                       // Jump Back
  	}
  	case WM_KEYDOWN:                        // Is A Key Being Held Down?
  	{
  		keys[wParam] = TRUE;                    // If So, Mark It As TRUE
  		return 0;                       // Jump Back
  	}
  	case WM_KEYUP:                          // Has A Key Been Released?
  	{
  		keys[wParam] = FALSE;                   // If So, Mark It As FALSE
  		return 0;                       // Jump Back
  	}
  	case WM_SIZE:                           // Resize The OpenGL Window
  	{
  		ReSizeGLScene(LOWORD(lParam), HIWORD(lParam));       // LoWord=Width, HiWord=Height
  		return 0;                       // Jump Back
  	}
  	}
  	return DefWindowProc(hWnd, uMsg, wParam, lParam);
  }
  
  int WINAPI WinMain(HINSTANCE   hInstance,              // Instance
  	HINSTANCE   hPrevInstance,              // Previous Instance
  	LPSTR       lpCmdLine,              // Command Line Parameters
  	int     nCmdShow)               // Window Show State
  {
  	MSG msg;                                // Windows Message Structure
  	BOOL    done = FALSE;
  	if (MessageBox(NULL, TEXT("Would You Like To Run In FullScreen Mode?"), TEXT("Start FullScreen?"), MB_YESNO | MB_ICONQUESTION) == IDNO)
  	{
  		fullscreen = FALSE;                       // Windowed Mode
  	}
  	// Create Our OpenGL Window
  	if (!CreateGLWindow("NeHe's OpenGL Framework", 640, 480, 16, fullscreen))
  	{
  		return 0;                           // Quit If Window Was Not Created
  	}
  	while (!done)                                // Loop That Runs Until done=TRUE
  	{
  		if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))           // Is There A Message Waiting?
  		{
  			if (msg.message == WM_QUIT)               // Have We Received A Quit Message?
  			{
  				done = TRUE;                  // If So done=TRUE
  			}
  			else                            // If Not, Deal With Window Messages
  			{
  				TranslateMessage(&msg);             // Translate The Message
  				DispatchMessage(&msg);
  			}
  		}
  		else {
  			if (active)                     // Program Active?
  			{
  				if (keys[VK_ESCAPE])                // Was ESC Pressed?
  				{
  					done = TRUE;              // ESC Signalled A Quit
  				}
  				else                        // Not Time To Quit, Update Screen
  				{
  					DrawGLScene();              // Draw The Scene
  					SwapBuffers(hDC);
  				}
  			}
  			if (keys[VK_F1])                    // Is F1 Being Pressed?
  			{
  				keys[VK_F1] = FALSE;              // If So Make Key FALSE
  				KillGLWindow();                 // Kill Our Current Window
  				fullscreen = !fullscreen;             // Toggle FullScreen / Windowed Mode
  				// Recreate Our OpenGL Window
  				if (!CreateGLWindow("NeHe's OpenGL Framework", 640, 480, 16, fullscreen))
  				{
  					return 0;               // Quit If Window Was Not Created
  				}
  			}
  		}
  	}
  
  	// Shutdown
  	KillGLWindow();                             // Kill The Window
  	return (msg.wParam);
  }