Tearing in OpenGL? - c++

Question

I'm using win32 and opengl and I have a window set up with the projection at glOrtho of the window's coordinates. I have double buffering enabled, tested it with glGet as well. My program always seems to tear any primitives that I try to draw on it if it's being constantly translated.
Here is my OpenGL initialization function:
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glViewport(0, 0, 640, 480);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, 640, 0, 480, 0, 100);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glDrawBuffer(GL_BACK);
glLoadIdentity();
And this is my rendering function, gMouseX and gMouseY are the coordinates of the mouse:
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glTranslatef(gMouseX, gMouseY, 0.0f);
glColor3f(0.5f, 0.5f, 0.5f);
glBegin(GL_TRIANGLES);
glVertex2f(0.0f, 128.0f);
glVertex2f(128.0f, 0.0f);
glVertex2f(0.0f, 0.0f);
glEnd();
SwapBuffers(hDC);
The same tearing problem occurs regardless of how often the rendering function runs. Is there something I'm doing wrong or missing here?

Answer 1

If you're just rendering one or two trianges, you're going to have an insanely high framerate (in the thousands of FPS probably), which means it's SwapBuffering like hell, which means you're probably always swapping during the screen refresh (even with double buffering on). Once your scene gets going with more content and the framerate falls to more realistic values, it should stop tearing. Alternatively, look in to enabling V-Sync, such as with wglSwapIntervalEXT on Windows.

Answer 2

This issue doesn't have to be strictly connected to VSync, as all people around the internet try to suggest. In my case the problem was caused by the way in which the window was initialized. I noticed, that getting rid off dwStyle=WS_POPUP solved the problem, but only partially because then the window wasn't in the fullscreen mode. What worked for me in the end was using SetWindowLong(hwnd, GWL_STYLE, 0); after creating the window. It basically clears the window style. So my code for initializing the window looks like that:
dwStyle=WS_POPUP; //Windows Style
ShowCursor(FALSE); //Hide Mouse Pointer
//Create the Window
hwnd= CreateWindowEx(NULL,
"GLClass",
appName,
dwStyle,
0, 0,
(long)windowWidth,
(long)windowHeight,
NULL,
NULL,
hInstance,
NULL);
SetWindowLong(hwnd, GWL_STYLE, 0);
After this modification all my problems with tearing and also not being able to PrintScreen, were solved. I didn't need to touch VSync anywhere.

Answer 3

When defining your win32 application window styles, don't include WS_POPUP
After debugging a problem where full screen would introduce screen tearing, I discovered the styles for full screen, after removing WS_POPUP it seemed to have stop tearing single handedly, without having to force the rendering loop to the refresh rate. WS_POPUP is known for being problematic, I guess. It would also block any full screen screenshots to complete white.

Answer 4

Tearing is caused by not synchronizing your updates with the monitor's vertical blanking interval. It's a bit hardware dependent in OpenGL (I think, not an expert), start with looking for glXWaitVideoSyncSGI. Googling "opengl sync to vblank" pays off too.

Answer 5

Try to putting a cap / limiting on the frame rate or yielding it probably (if you don't have a vsync):
Here is the pseudo code:
let tick equals new_tick
if tick is less than last_tick do
yield
done
calculate last_tick
Try the sleep function and setting it to one, so to yield:
Sleep(1);
Also remember limiting or capping frame rate is not that advisable as there is certain functions that are really meant for reducing frame calculations.