During resize OpenGL swapbuffers stalls - c++

Question

I am currently working on an OpenGL win32 project converting the standard win32 to C++ classes. During the initial implementation I ran into an issue where when the window is resized the frame freezes and the window changes size very slowly, jumping from one size to the next. When the window is finished resizing there is noticeable hesitation before the window updates the drawing surface.
I am using a WM_TIMER to update the display as frequently as possible. During 'normal' operation the program clears the screen, slowly updating the red component to visually show a change in the surface drawing. Given the extremely simple design of the test I can't imagine that the openGL code is the problem during a resize event. I did test to see if manually resizing the window by catching the mouse button down and calling setwindowpos with adjusted values would cause the same behavior and it did. If I kept the size the same and called SetWindowPos the screen didn't stall though. This leads me to believe that something in the resize handling code is locking the HDC in some way preventing the swapbuffers from performing at speed. Possibly waiting on a multithread lock somewhere in the Win32 resize code.
Below is a small program that exhibits the exact same behavior as the larger program.
Only external lib being used is opengl32.lib.
#include "stdafx.h"
#include "OpenGLTest.h"
#include <gl\GL.h>
#define MAX_LOADSTRING 100
HINSTANCE hInst;
TCHAR szTitle[MAX_LOADSTRING];
TCHAR szWindowClass[MAX_LOADSTRING];
ATOM MyRegisterClass(HINSTANCE hInstance,LPCTSTR strClassName,WNDPROC wndProc,HBRUSH brBackground);
BOOL InitInstance(HINSTANCE, int);
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
HWND _hWnd;
HDC _hDC;
HGLRC _glRC;
BOOL DrawWindow();
int APIENTRY _tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow)
{
UNREFERENCED_PARAMETER(hPrevInstance);
UNREFERENCED_PARAMETER(lpCmdLine);
// TODO: Place code here.
MSG msg;
HACCEL hAccelTable;
// Initialize global strings
LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
LoadString(hInstance, IDC_OPENGLTEST, szWindowClass, MAX_LOADSTRING);
MyRegisterClass(hInstance,szWindowClass,WndProc,NULL);
// Perform application initialization:
if (!InitInstance (hInstance, nCmdShow))
{
return FALSE;
}
hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_OPENGLTEST));
// Main message loop:
bool bRun=true;
while (bRun)
{
if (PeekMessage(&msg, NULL, 0, 0,PM_REMOVE))
{
if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
if (msg.message==WM_QUIT)
{
break;
}
}
}
return (int) msg.wParam;
}
//
// FUNCTION: MyRegisterClass()
//
// PURPOSE: Registers the window class.
//
// COMMENTS:
//
// This function and its usage are only necessary if you want this code
// to be compatible with Win32 systems prior to the 'RegisterClassEx'
// function that was added to Windows 95. It is important to call this function
// so that the application will get 'well formed' small icons associated
// with it.
//
ATOM MyRegisterClass(HINSTANCE hInstance,LPCTSTR strClassName,WNDPROC wndProc,HBRUSH brBackground)
{
WNDCLASSEX wcex;
//Register Main Window Class
wcex.cbSize = sizeof(WNDCLASSEX);
wcex.style = CS_HREDRAW | CS_VREDRAW ;
wcex.lpfnWndProc = wndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = hInstance;
wcex.hIcon = NULL;
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = brBackground;
wcex.lpszMenuName = NULL;
wcex.lpszClassName = strClassName;
wcex.hIconSm = NULL;
return RegisterClassEx(&wcex);
}
//
// FUNCTION: InitInstance(HINSTANCE, int)
//
// PURPOSE: Saves instance handle and creates main window
//
// COMMENTS:
//
// In this function, we save the instance handle in a global variable and
// create and display the main program window.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
hInst = hInstance; // Store instance handle in our global variable
_hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
if (!_hWnd)
{
return FALSE;
}
_hDC=GetDC(_hWnd);
if (_hDC!=nullptr)
{
//Create OpenGL 3.2 context
PIXELFORMATDESCRIPTOR pfd =
{
sizeof(PIXELFORMATDESCRIPTOR),
1,
PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
PFD_TYPE_RGBA, //The kind of framebuffer. RGBA or palette.
32, //Colordepth of the framebuffer.
0, 0, 0, 0, 0, 0,
0,
0,
0,
0, 0, 0, 0,
24, //Number of bits for the depthbuffer
8, //Number of bits for the stencilbuffer
0, //Number of Aux buffers in the framebuffer.
PFD_MAIN_PLANE,
0,
0, 0, 0
};
int nPixelFormat=ChoosePixelFormat(_hDC,&pfd);
SetPixelFormat(_hDC,nPixelFormat,&pfd);
if ((_glRC=wglCreateContext(_hDC))!=nullptr)
{
//Make Context Current
wglMakeCurrent(_hDC,_glRC);
}
}
ShowWindow(_hWnd, nCmdShow);
UpdateWindow(_hWnd);
SetTimer(_hWnd, 0, 1, NULL);
return TRUE;
}
//
// FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
// PURPOSE: Processes messages for the main window.
//
// WM_COMMAND - process the application menu
// WM_PAINT - Paint the main window
// WM_DESTROY - post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
int wmId, wmEvent;
PAINTSTRUCT ps;
switch (message)
{
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
// Parse the menu selections:
switch (wmId)
{
case IDM_EXIT:
DestroyWindow(hWnd);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
break;
case WM_TIMER:
DrawWindow();
break;
case WM_ERASEBKGND:
return TRUE;
case WM_PAINT:
BeginPaint(_hWnd,&ps);
EndPaint(_hWnd,&ps);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
float fRed=0.0f;
BOOL DrawWindow()
{
RECT rc;
GetClientRect(_hWnd,&rc);
HDC hDC=GetDC(_hWnd);
if ((hDC!=nullptr)&&(_glRC!=nullptr))
{
//Print Client Data to Window Title for debugging
TCHAR strTitle[MAX_LOADSTRING];
wsprintf(strTitle,L"%d, %d, %d, %d",rc.left,rc.top,rc.right,rc.bottom);
SetWindowText(_hWnd,strTitle);
wglMakeCurrent(hDC,_glRC);
glViewport(rc.left,rc.top,(rc.right-rc.left),(rc.bottom-rc.top));
glClearColor(fRed,1.0f,0.0f,0.0f);
glClear(GL_COLOR_BUFFER_BIT);
SwapBuffers(hDC);
fRed+=0.1;
if (fRed>1.0f) fRed=0.0f;
ReleaseDC(_hWnd,hDC);
}
return TRUE;
}
EDIT: The problem is a hardware issue not software. I moved over to another system and the issue is not there. Thank you for your assistance.