Transparency Review

Include alpha with color or material: 1 means opaque
draw opaque objects first
turn off depth buffer
draw transparent objects from farthest to nearest

Accumulation Buffer

You use it for

Motion blur
Anti-Aliasing
Depth of Field

You use it by

Enabling it in the glutInit call:

    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_ACCUM | GLUT_DEPTH);

Clearing the Accumulation buffer before drawing your scenes (layers):
```
    glClear(GL_ACCUM_BUFFER_BIT);
```

Accumulating each scene (layer):

      glAccum(GL_ACCUM, 1.0/numJitters);

Copying the Accumulation buffer contents to the frame buffer:
```
    glAccum(GL_RETURN, 1.0);
```

Motion Blur

demos/accumulation/FallingTeapot.py. The important callbacks are:


    twKeyCallback('m',keys,"toggle motion blur");
    twKeyCallback('s',keys,"toggle small motion");
    twKeyCallback('+',keys,"increase frames");
    twKeyCallback('-',keys,"decrease frames");

Technique:
- Clear the accumulation buffer
- draw the scene N times
- sum the scenes with various constants
- return the scene to the framebuffer
Accumulation constants that don't sum to one can cause weird effects for the non-moving objects.
Keep motion small.
Use interpolation and other animation techniques to get the motion effects you want.

Anti-Aliasing

blurred edges usually look better than "jaggies."
Can be done by "jittering" the objects,

demos/accumulation/Aliasing.py

    twKeyCallback('a',keys,"toggle anti-aliasing");
    twKeyCallback('1',keys,"show the teapot");
    twKeyCallback('2',keys,"show the wire cube");
    twKeyCallback('3',keys,"show the solid cube");
    twKeyCallback('4',keys,"show the solid sphere");

but jittering the camera is better, using
different frustums.
demos/accumulation/AntiAliasing.py. (Look at this on Linux, not the Mac.) We'll see why, later.
Use the accumulation buffer to add up the jittered images

A nice application of this is antialiasing the Wellesley "favicon":

Depth of Field

With real lenses (cameras and eyes), objects and edges that are far from the "focal distance" look blurry.
A good description of Depth of Field
This can be accomplished by judicious use of the camera movement and frustum movement and the accumulation buffer. The camera and frustum movements are designed to cancel out at the desired focal depth; everything else will be blurry to the extent that it is at a different depth, proportional to the difference.
demos/accumulation/DepthOfField.py
Try this demo with values of depth of field around 1.

Accumulation Buffer Depth

First, run the AntiAliasing demo on the Mac. You'll see some banding. Why?

Different graphics cards have different limits. You can find out some of the limits by running demos/accumulation/OpenGL-Limits.py.

Now, try running demos/accumulation/AntiAliasing.py again, but this time supply a command-line argument about the number of iterations to do. Supply a number like 1 or 8 or 64.

Here's an example. Suppose we're averaging a bunch of numbers all around 20:

19, 19, 20, 20, 20, 21, 21, 21, 22, 22

We do that by multiplying each by 0.1 and summing:

1.9+1.9+2.0+2.0+2.0+2.1+2.1+2.1+2.2+2.2 = 20.5

Now, suppose we're doing the same thing on a machine that can't store the decimal place:

We do that by multiplying each by 0.1 and summing:

1+1+2+2+2+2+2+2+2+2 = 18

Furthermore, the values we get will be 18, 19, 20, 21, or 22; we can't get 20.5

Our accumulation operation is right-shifting by 3 bits, thereby losing precision.

Fog

Fog is not nearly as cool as you think it is. It just fogs stuff that is far from the camera, depending on how far it is. This is nice for not having to worry about details far away, but it can't do ground fog and stuff like that.

The main demos are:

Written by Scott D. Anderson
scott.anderson@acm.org

This work is licensed under a Creative Commons License.