The Role of WGL Functions of OpenGL Rendering onto Microsoft Windows

A Question

When we adventure into OpenGL land, as Microsoft developers, we will run into a natural question: how can OpenGL render on MFC & Win32 windows? Where does Win32/MFC message pump stay? These answers are scattered in rare posts on Internet and faded in the wind.

Furthermore, we can find out if we can have a simple framework to build our applications. [5] is one kind of attempts.

With the help of WGL functions(Wrangler library), through framebuffer, we can hangle Win32/MFC windows onto OpenGL layer. Here is my understanding of complete process flow.

Process Flow

Here is how MFC/Win32 Windows hangle onto OpenGL:

Key Struct

If Win32 window needs to support OpenGL window, it must be set up to maintain right pixel format information in device context, then generate resource context to render OpenGL window. This is where PIXELFORMATDESCRIPTOR, the key data structure steps in.

As OpenGL standards evolve to version 4.1, Win32 window can support more OpenGL rendering with OpenGL Shading language.

Background

As we know, starting an OpenGL project in Visual Studio needs OpenGL core library and GLU library. These two libaries are in OpenGL32.lib and glu32.lib and distributed with current Visual Studio 2017 for example. We just need to include header files such as #include <GL/gl.h> and #include <GL/glu.h>, then we add open32.lib and glu32.lib in Linker setting of the project configurations. Easily, we get all OpenGL support from Microsoft.

When we need to use GLUT library, we have many options such as freeglut or glut from SGI. Now, we have GLFW library. If you browse through GLUT API index, you will see most of them (70%+)are GUI related functions including menu, keyboard and mouse manipulcations.

But, there is also library GLEW to support Windows management. Relatively, we only need a small number of functions, i.e., WGL, OpenGL extension for Microsoft Windows to support OpenGL rendering on Microsoft Windows.

When I tested many good examples from codeproject.com, I got a good understanding on these WGL functions from [1][2]. Surprisingly, I found the complete list of these WGL functions[3] in header file <wingdi.h>. So they are implemented in Win32 API to fully support these OpenGL rendering functions in Windows OS.

Code Snippet

From [2], we can see, without resorting to any external libraries, only using OpenGL features from Microsoft supplied libraries, we already obtained good deal of functions from Microsoft OpenGL support. This project is a Win32 program. The critical logic is in this function:

//enable OpenGL
VOID EnableOpenGL( HWND hWnd, HDC * hDC, HGLRC * hRC )
{
    PIXELFORMATDESCRIPTOR pfd;
    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_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
    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( Structure, hDC );
} 

The major loop is already built in winMain message pump.

OpenGL project configuration in Visual Studio

As we start to test OpenGL program in Visual Studio, we need to configure it. Because it is a window application, we need to browse configuration Properties-> Linker->System -> Subsystem: set it to windows. also, since we use main() function as entry point of this application, we need to tell linker that main() function is the entry point. So in configuration Properties-> Linker -> Command Line -> additional options windows, put this option: /SUBSYSTEM:windows /ENTRY:mainCRTStartup .

Function List

To make the readers' life easier, I copied the list of functions from [1] for quick reference:

Conclusions

With existing support from Microsoft such as Visual Studio 2017 installation, we can use Win32 and MFC to build very useful applications already.

Furthermore, with GLFW, GLEW and GLM plus GLSL libraries, we have a complete eco-systems to implement very good C++ applications with MFC classes.

Any feedback or comments are welcome!

References

1. wingdi.h header
2. OpenGL Triangle Basics
3. WGL: OpenGL Extension for Microsoft Windows NT and Windows 95
4. PIXELFORMATDESCRIPTOR structure
5. Simple OpenGL Framework

History

• 20^th February, 2021: First version