Creating Anaglyphs using OpenGL

or

A simple example using the OpenGL accumulation buffer

Written by Paul Bourke

August 2000

See also:
Correctly forming stereo pairs
Further anaglyph examples

 

---

 

Introduction
Would you like to experiment with interactive stereographics but your graphics card doesn't support stereographics or even left and right buffers? Have you lost or never had a pair of LCD shutter glasses and don't want to pay for a pair? The following shows how to create anaglyphs using OpenGL and the accumulation buffer. It supports all the major filter colours and illustrates how to correctly form stereo pairs. A number of simple geometric forms are supplied to illustrate the principle, it should be a very simple task to add other models and provide more sophisticated interaction. While anaglyphs are somewhat the "old fashioned" way of creating stereographic images, they are still effective, even if they are limited to monochromatic images.

Approach

Stereographics primarily requires that two images (one for each eye) are presented independently to our two eyes. If these two views of a 3D model are computed correctly the human brain will fuse them and give us a stronger depth perception than we normally get with a single image There are a number of ways this can be achieved, this document deals with anaglyphs in which the left and right eye images are made up of two independent colours. By wearing glasses with matching filters, the left eye image is delivered to the left eye and the right eye image to the right eye.

Whatever technique is used, the scene needs to be rendered twice, once for each eye position. The two resulting images need to be filtered and combined before being presented to the user. The two images are most conveniently added together by using the accumulation buffer. There are only a small number of things that need to be changed to an existing OpenGL program in order for it to support anaglyphs, these are outlined below.

 

• Initialise the accumulation buffer in glut, for example:
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_ACCUM | GLUT_RGB | GLUT_DEPTH);

   

• Set the clear colour for the accumulation buffer (black as used here is the default), for example:
  glClearAccum(0.0,0.0,0.0,0.0);

• Clear the accumulation buffer when necessary
  glClear(GL_ACCUM_BUFFER_BIT);

   

• Copy the current drawing buffer to the accumulation buffer. This would normally be done after the left eye image has been drawn. Note: strictly speaking if GL_LOAD is used then it isn't necessary to clear the accumulation buffer beforehand.
  glAccum(GL_LOAD,1.0);

• Add the current drawing buffer to the accumulation buffer. This would normally done after the right eye image has been drawn.
  glAccum(GL_ACCUM,1.0);

• Copy the accumulation buffer to the current drawing buffer. After this the current drawing buffer (back buffer say) would be swapped to the front buffer.
  glAccum(GL_RETURN,1.0);

• The glAccum() functions act upon the current read and write buffers, for example these might be set as follows:
  glDrawBuffer(GL_BACK);
  glReadBuffer(GL_BACK);

In order to draw the left and right eye scene in the appropriate colour for the filters in the glasses, one could specify one colour when drawing the left eye image and another for the right eye image. This is a bit clumsy, a much easier way is to only specify colours in the scene as different shades of grey and apply glColorMask() to do the filtering automatically. For more details on the whole process see the source code.

Source code
anaglyph.c and anaglyph.h

 

Example models
The window shots on the right show the different 3D models available in the demo application (right mouse button for menus). For examples using different colour filters you will need to get and compile the software. The software as it is provided supports the three most common types of anaglyph glasses, that is, red-blue, red-green, and red-cyan. The last type has the extra advantage that where the objects intersect they form a greyscale image which is easier to look at and appreciate without glasses a well as resulting in less ghosting with glasses.

 

 

---

Feedback from Michael Callahan

If you're rendering with the hardware red and blue (for example, using color masks), then the colors do not overlap at all. So if you aren't already using the blend function for something else, the accumulation buffer is unnecessary:

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);        glColorMask(GL_TRUE, GL_FALSE, GL_FALSE, GL_TRUE);        // set camera for blue eye, red will be filtered.        // draw scene        glClear(GL_DEPTH_BUFFER_BIT);    glEnable(GL_BLEND);    glBlendFunc(GL_ONE, GL_ONE);        glColorMask(GL_FALSE, GL_FALSE, GL_TRUE, GL_TRUE);        // set camera for red eye, blue will be filtered.        // draw scene

Feedback from Daniel van Vugt

Daniel van Vugt pointed out that the accumulation buffer isn't actually needed resulting in a much faster implementation.

 

"Because the two images do not overlap in colour space, no kind of blending or accumulation is actually doing anything. Just remember to clear the depth buffer for each image, but don't clear the colour buffer between the two images."

New, faster, source code