Initializing OpenGL in Windows 7 - WITHOUT GLUT

[Lesrd]

First, I'd like to apologize if this question has been addressed before, or if there is a more suitable place in these forums for it.

I'm building a platform-independent game engine, which will include an OpenGL rendering module. I'm using GLEW for the boilerplate code regarding the GL API. An important note, I'm not using nor do I wish to use GLUT (it's sometimes annoying following tutorials as almost all of them are plagued with using GLUT)... I will be doing the platform-dependent window code myself (for greater control).

I'm currently testing this code on a computer with 1x GeForce 8800GTX, and I'm quite sure version 2 of OpenGL is supported (OpenGL Extension Viewer said this hardware supports version 3). I'm using VS2010 Ultimate, my CPU is a Core 2 Duo E6850, Win 7 x64 but I'm compiling a 32-bit version only.

I'm having a problem, currently on Windows 7: I am able to create a window, but OpenGL initialization is failing on wglCreateContextAttribsARB with GetLastError() returning 3221692565.

This is the initialization code I have so far (based on several tutorials I saw online):

bool GLGraphicsEngine::Init()
	{
	//	OutputDebugString(L"GL Init called\n");
		// now that we have a window, setup the pixel format descriptor
		m_glHDC = GetDC(m_hWnd);
		int height, width, x, y;
		x = m_MainWindow->GetClientX();
		y = m_MainWindow->GetClientY();
		height = m_MainWindow->GetClientHeight();
		width = m_MainWindow->GetClientWidth();
 
		std::wstringstream ws;
		ws << "X: " << x << "\tY: " << y << "\tHeight: " << height << "\tWidth: " << width << std::endl;
		OutputDebugString(ws.str().c_str());
 
 
		// Set a dummy pixel format so that we can get access to wgl functions
		PIXELFORMATDESCRIPTOR pfd;
		ZeroMemory(&amp;pfd, sizeof(pfd));
		GLint iPixelFormat = 1;
 
		if(!SetPixelFormat(m_glHDC, iPixelFormat, &amp;pfd/*&amp;m_glpfd*/))
		{
			OutputDebugString(L"SetPixelFormatFailed");
			return false;
		}
 
		// Create OGL context and make it current
		m_glRC = wglCreateContext( m_glHDC );
		wglMakeCurrent( m_glHDC, m_glRC );
		if (m_glHDC == 0 || m_glRC == 0)
		{
			OutputDebugString(L"An error occured creating an OpenGL window.\n");
			return false;
		}
 
		// Setup GLEW which loads OGL function pointers
		GLenum err = glewInit();
		if(GLEW_OK != err)
		{
			/* Problem: glewInit failed, something is seriously wrong. */
			std::cerr << "GLEW Init Error: " << glewGetErrorString(err) << std::endl;
			return false;
		}
		m_oglVersion = glGetString(GL_VERSION);
 
#ifdef _DEBUG
		DebugPrintVersion();
#endif
		// Now that extensions are setup,
		// delete window and start over picking a real format.
		wglMakeCurrent(NULL, NULL);
		wglDeleteContext(m_glRC);
		ReleaseDC(m_hWnd, m_glHDC);
		DestroyWindow(m_hWnd);
 
		// Create the window again
		m_hWnd = m_MainWindow->InitWindow();
		m_glHDC = GetDC(m_hWnd);
 
		int nPixCount =0;
		int nPixelFormat;
		// Specify the important attributes we care about
		int pixAttribs[] =
		{
			WGL_SUPPORT_OPENGL_ARB, 1, // Must support OGL rendering
			WGL_DRAW_TO_WINDOW_ARB, 1, // pf that can run a window
			WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB, // must be HW accelerated
			WGL_COLOR_BITS_ARB, 24, // 8 bits of each R, G and B
			WGL_DEPTH_BITS_ARB, 16, // 16 bits of depth precision for window
			WGL_DOUBLE_BUFFER_ARB, GL_TRUE, // Double buffered context
			WGL_SAMPLE_BUFFERS_ARB, GL_TRUE, // MSAA on
			WGL_SAMPLES_ARB, 8, // 8x MSAA
			WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB, // pf should be RGBA type
			0 // NULL termination
		}; 
		// Ask OpenGL to find the most relevant format matching our attribs
		// Only get one format back.
		BOOL lolRet = wglChoosePixelFormatARB(m_glHDC, pixAttribs, NULL, 1, &amp;nPixelFormat, (UINT*)&amp;nPixCount);
 
		if(nPixelFormat != -1)
		{
			if (!lolRet)
				OutputDebugString(L"wglChoosePixelFormatARB returns FALSE\n");
			if (nPixelFormat == 0)
				OutputDebugString(L"nPixelFormat is 0!\n");
			// Got a format, now set it as the current one
			SetPixelFormat(m_glHDC, nPixelFormat, &amp;m_glpfd);
 
			int attribs[] =
			{
				WGL_CONTEXT_MAJOR_VERSION_ARB, 2,
				WGL_CONTEXT_MINOR_VERSION_ARB, 2,
				WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB,
				0
			};
 
			OutputDebugString(L"Pre ARB checking...\n");
 
			if(wglewIsSupported("WGL_ARB_create_context") == 1)
				OutputDebugString(L"wglCreateContextAttribsARB supported!\n");
			else
				OutputDebugString(L"wglCreateContextAttribsARB not supported!\n");
 
		//	m_glRC = wglCreateContext( m_glHDC );//wglCreateContextAttribsARB(m_glHDC, 0, NULL);
			m_glRC = wglCreateContextAttribsARB(m_glHDC, 0, attribs);
			if (m_glRC == NULL)
			{
				// Handle Error . . .
				DWORD err = GetLastError();
				std::wstringstream ws3;
				ws3 << "Rendering context is null: " << err << std::endl;
				OutputDebugString(ws3.str().c_str());
			}
			wglMakeCurrent( m_glHDC, m_glRC );
		}
		ShowWindow( m_hWnd, SW_SHOW );
		SetForegroundWindow( m_hWnd );
		SetFocus( m_hWnd );
 
		return true;
	}

(m_MainWindow points to an instance of a class I made, which encapsulates the concept of a window)

I'm literally pulling my hair, as I've looked for information everywhere, but can't seem to solve this. Since the initialization of OpenGL is failing (on the function I mentioned), the render function I'm using is not producing anything and I get a window with its contents set to white.

I also provide the rendering code if anyone's interested:

void GLGraphicsEngine::Render()
	{
		// 1. set up the viewport
		int x = m_MainWindow->GetClientX();
		int y = m_MainWindow->GetClientY();
		int height = m_MainWindow->GetClientHeight();
		int width = m_MainWindow->GetClientWidth(); 
 
 
		glViewport(x, y, width, height);
		// set viewport
		// to be the whole width and height
		// of the CLIENT AREA (drawable region) of the window,
		// (the CLIENT AREA excludes the titlebar and the
		// maximize/minimize buttons).
 
 
		// 2. projection matrix
		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();
		gluPerspective(45.0,(float)width/(float)height, 1, 1000);
 
		// 3. viewing transformation
		glMatrixMode(GL_MODELVIEW);
		glLoadIdentity();
 
		gluLookAt(  0, 0, 10,
					0, 0, 0,
					0, 1, 0);
 
		// 4. modelling transformation and drawing
		glClearColor( 0.5, 0, 0, 0 );
		glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
		static float i = 0.01f;
 
		i+= 0.001f;     // increase i by 0.001 from its
		// it had on the LAST FUNCTION CALL to the draw() function
/*		std::wstringstream ws;
		ws << "GLVersion: " << *m_oglVersion << "\theight: " << height <<"\twidth: " << width << "\ti: " << i << std::endl;
		OutputDebugString(ws.str().c_str()); */
 
 
 
		float c = cos( i );
		float s = sin( i );
 
		glBegin (GL_TRIANGLES);
			glColor3f(  c, 0, 0 );      // red
			glVertex3f( 1+c, 0+s, 0 );
 
			glColor3f(  c, s, 0 );      // yellow
			glVertex3f( 0+c, 1+s, 0 );
 
			glColor3f(  s, 0.1f, s );   // magenta
			glVertex3f(-1+c, 0+s, 0 );
		glEnd(); 
 
		//7.  SWAP BUFFERS.
		SwapBuffers(m_glHDC);
		// Its important to realize that the backbuffer
		// is intelligently managed by the HDC ON ITS OWN,
		// so all's you gots to do is call SwapBuffers
		// on the HDC of your window.
	}

[Simon Arbon]

wglCreateContext and wglCreateContextAttribsARB use your initial context, which doesnt exist anymore because you got rid of it!
You cant call wglMakeCurrent(NULL, NULL); until AFTER you have finished creating the new context for the second window.
The section of code:

		wglMakeCurrent(NULL, NULL);
		wglDeleteContext(m_glRC);
		ReleaseDC(m_hWnd, m_glHDC);
		DestroyWindow(m_hWnd);

needs to be moved to after the wglCreateContext, wglCreateContextAttribsARB calls, and you need separate DC, hWnd & RC variables for the two windows.

[Alfonse Reinheart]

An important note, I'm not using nor do I wish to use GLUT (it's sometimes annoying following tutorials as almost all of them are plagued with using GLUT)... I will be doing the platform-dependent window code myself (for greater control).

How exactly is GLUT a "plague"? If you're teaching someone OpenGL, you don't need to clutter the lessons with pointless stuff about rendering contexts, platform-specific windowing APIs, and other nonsense. A good teaching aid is defined most by what it doesn't teach, not what it does.

Anyway, GLUT is far from the only platform independent means of creating OpenGL windows. There are GLFW, SDL, and SMFL, all of which provide plenty of control. What is it that you are trying to do that requires that you not use any of them?

I'm having a problem, currently on Windows 7: I am able to create a window, but OpenGL initialization is failing on wglCreateContextAttribsARB with GetLastError() returning 3221692565.

You called glewInit, but does glewInit initialize WGL functions as well? I seem to recall there being a specific wglewInit for those.

wglCreateContext and wglCreateContextAttribsARB use your initial context, which doesnt exist anymore because you got rid of it!

No, they don't. WGL functions are not dependent on a rendering context. You need the RC to get them, but you can call them just fine after destroying that RC. And no rendering context has to be current to call them. I have some code that seems to be working just fine that does exactly that.

[mbentrup]

WGL_CONTEXT_MAJOR_VERSION_ARB, 2,
WGL_CONTEXT_MINOR_VERSION_ARB, 2,

Maybe the driver doesn't know how to be compatible to that OpenGL version.

[ZbuffeR]

And try 24 bits depth anyway.
One could argue about 32 bits of color bits RGBA being better aligned.

[Lesrd]

Alfonse Reinheart: perhaps I didn't explain myself clearly... I was not only looking for tutorials on OpenGL, but more specifically, tutorials that do not make use of GLUT or other libraries (though I might give SDL a chance). In that way, I called GLUT a "plague" :P! And glewInit() does initialize the windows functionality (http://glew.sourceforge.net/basic.html).

mbentrup: I'm using OpenGL Extensions Viewer 4.02 and it says it supports up to 3.3, so I'm pretty sure that is not the issue.

ZbuffeR: tried that, no change.

[mbentrup]

Lets look into the spec:

The defined versions of OpenGL at the time of writing are OpenGL
1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 2.0, 2.1, 3.0, 3.1, and 3.2. Feature
deprecation was introduced with OpenGL 3.0, so forward-compatible
contexts may only be requested for OpenGL 3.0 and above. Thus,
examples of invalid combinations of attributes include:

- Major version < 1 or > 3
- Major version == 1 and minor version < 0 or > 5
- Major version == 2 and minor version < 0 or > 1
- Major version == 3 and minor version > 2
- Forward-compatible flag set and major version < 3

No, your driver should not be able to create an OpenGL 2.2 context, especially not if you request a forward-compatible context.

[marshats]

GLUT is a good cross-platform library for teaching openGL and simple quick demos. It is definitely not the plague. Freeglut even has extensions for simply setting up forward compatible openGL contexts (as does SDL) without having to deal with OS specifics.

void glutInitContextVersion( int majorVersion, int minorVersion );
void glutInitContextFlags( int flags );
void glutInitContextProfile( int profile );

Some alternative CROSS-PLATFORM libraries to GLUT that you might also benefit from trying in addition to SDL ...

simple and fast multimedia libray

glfw

[Lesrd]

mbentrup: the prize goes to you! Can't believe how I missed that info... It is working now!

marshats: I wasn't stating it's worthless, but merely that I didn't want to use it. Out of curiosity, would I be able to have fine-grained control over the main loop in GLUT? (Since GLUT has its own from what I've seen) Would I have to feed callback functions to GLUT, which would then be called on specific parts of the GLUT loop iteration? (something simmilar to DXUT with D3D) I will also take a look at your suggestions.

Thanks for the help people!

[Alfonse Reinheart]

I was not only looking for tutorials on OpenGL, but more specifically, tutorials that do not make use of GLUT or other libraries (though I might give SDL a chance).

You didn't answer my question: why does it matter so much to you that you manually write platform-specific code to create and manage OpenGL windows? Do you have an actual need? Or is it just that all too common belief among neophyte programmers that doing everything themselves is better than using someone else's perfectly functional and well-debugged code?