Simplist Window? please help

I have been using opengl for a few weaks now and am getting kinda used to the syntax. But I started out using someone elses window code that had alot of extra code and error detection. ANd I nevewr really learned exactly how the window is made using opengl with C++. I was just wondering if someone could post the most simple code for a window with some commenting. I think it would help me understand it better if I didnt have all the clutter, thx.

are you using windows api or glut? glut is a whole lot more simple but not used in real apps like games that much. Tell me which one u are using and I will post some code if you want.

// Here is a simple window for openGL
//for windows
//no glut

#include <windows.h>
#include <gl/gl.h>

// Function Declarations

WndProc( HWND hWnd, UINT message,
WPARAM wParam, LPARAM lParam );
VOID EnableOpenGL( HWND hWnd, HDC * hDC, HGLRC * hRC );
VOID DisableOpenGL( HWND hWnd, HDC hDC, HGLRC hRC );

// WinMain

WinMain( HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int iCmdShow )
HWND hWnd;
MSG msg;
float theta = 0.0f;

// register window class = CS_OWNDC;
wc.lpfnWndProc = WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = LoadIcon( NULL, IDI_APPLICATION );
wc.hCursor = LoadCursor( NULL, IDC_ARROW );
wc.hbrBackground = (HBRUSH)GetStockObject( BLACK_BRUSH );
wc.lpszMenuName = NULL;
wc.lpszClassName = “Window”;
RegisterClass( &wc );

// create main window
hWnd = CreateWindow(
“TWindow”, “Window”,
0, 0, 600, 400,
NULL, NULL, hInstance, NULL );

// enable OpenGL for the window
EnableOpenGL( hWnd, &hDC, &hRC );

// program main loop
while ( !bQuit ) {

// check for messages
if ( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) ) {

// handle or dispatch messages
if ( msg.message == WM_QUIT ) {
bQuit = TRUE;
} else {
TranslateMessage( &msg );
DispatchMessage( &msg );

} else {

// OpenGL animation code goes here



// shutdown OpenGL
DisableOpenGL( hWnd, hDC, hRC );

// destroy the window explicitly
DestroyWindow( hWnd );

return msg.wParam;


// Window Procedure

WndProc( HWND hWnd, UINT message,
WPARAM wParam, LPARAM lParam )

switch ( message ) {

return 0;

case WM_CLOSE:
PostQuitMessage( 0 );
return 0;

return 0;

switch ( wParam ) {

PostQuitMessage( 0 );
return 0;

return 0;

return DefWindowProc( hWnd,
message, wParam, lParam );



// Enable OpenGL

VOID EnableOpenGL( HWND hWnd, HDC * hDC, HGLRC * hRC )
int iFormat;

// get the device context (DC)
*hDC = GetDC( hWnd );

// set the pixel format for the DC
ZeroMemory( &pfd, sizeof( pfd ) );
pfd.nSize = sizeof( pfd );
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW |
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = 24;
pfd.cDepthBits = 16;
pfd.iLayerType = PFD_MAIN_PLANE;
iFormat = ChoosePixelFormat( *hDC, &pfd );
SetPixelFormat( *hDC, iFormat, &pfd );

// create and enable the render context (RC)
*hRC = wglCreateContext( *hDC );
wglMakeCurrent( *hDC, *hRC );


// Disable OpenGL

VOID DisableOpenGL( HWND hWnd, HDC hDC, HGLRC hRC )
wglMakeCurrent( NULL, NULL );
wglDeleteContext( hRC );
ReleaseDC( hWnd, hDC );


Try on this website to get more simple opengl examples.

Thank you for the replys, I am using windows api, no glut, should i use glut?

glut is very simple and easy to use but I would consider it to be slower and less useful for some things. I use it all the time for just testing simple things

This site has a good commenting on windows coding openGL

But if you don’t want to worry about windows creation then GLUT maybe the answer for you, it handles all the window stuff with very simple window opening commands with less clutter.

Using Windows code is a killer. Even the code at NeHe is far from complete. Using GLUT is nice since you don’t have to care about a lot of things. On the other hand GLUT has many limitations (both in the API design and in the implementation).

I would suggest that you have a look at GLFW . If not for anything else, at least for having a look at the source code (the win32 API is horror!). Compared to GLUT, GLFW generally gives you a greater degree of freedom and more “power”, without necessarily being more complicated to use (many prefer the GLFW interface to GLUT because it is often more intuitive).

Comment: I’m not promoting GLFW to raise its popularity (because I’m its author), but because I think/hope that it may solve many problems for people with questions such as those posted in this thread.

the code I posted above , really is the simplist, without using anything other than windows and GL

and Glut has known memory leaks