DragonFly On-Line Manual Pages

GLACCUM()                                                            GLACCUM()

NAME
       glAccum - operate on the accumulation buffer

C SPECIFICATION
       void glAccum( GLenum op,
                     GLfloat value )

PARAMETERS
       op     Specifies the accumulation buffer operation.  Symbolic constants
              GL_ACCUM, GL_LOAD, GL_ADD, GL_MULT, and GL_RETURN are accepted.

       value  Specifies a floating-point value used in the accumulation buffer
              operation.  op determines how value is used.

DESCRIPTION
       The accumulation buffer is an extended-range color buffer.  Images are
       not rendered into it.  Rather, images rendered into one of the color
       buffers are added to the contents of the accumulation buffer after
       rendering.  Effects such as antialiasing (of points, lines, and
       polygons), motion blur, and depth of field can be created by
       accumulating images generated with different transformation matrices.

       Each pixel in the accumulation buffer consists of red, green, blue, and
       alpha values.  The number of bits per component in the accumulation
       buffer depends on the implementation. You can examine this number by
       calling glGetIntegerv four times, with arguments GL_ACCUM_RED_BITS,
       GL_ACCUM_GREEN_BITS, GL_ACCUM_BLUE_BITS, and GL_ACCUM_ALPHA_BITS.
       Regardless of the number of bits per component, the range of values
       stored by each component is [-1, 1].  The accumulation buffer pixels
       are mapped one-to-one with frame buffer pixels.

       glAccum operates on the accumulation buffer.  The first argument, op,
       is a symbolic constant that selects an accumulation buffer operation.
       The second argument, value, is a floating-point value to be used in
       that operation.  Five operations are specified: GL_ACCUM, GL_LOAD,
       GL_ADD, GL_MULT, and GL_RETURN.

       All accumulation buffer operations are limited to the area of the
       current scissor box and applied identically to the red, green, blue,
       and alpha components of each pixel.  If a glAccum operation results in
       a value outside the range [-1, 1], the contents of an accumulation
       buffer pixel component are undefined.

       The operations are as follows:

       GL_ACCUM      Obtains R, G, B, and A values from the buffer currently
                     selected for reading (see glReadBuffer).  Each component
                     value is divided by 2^n - 1, where n is the number of
                     bits allocated to each color component in the currently
                     selected buffer.  The result is a floating-point value in
                     the range [0, 1], which is multiplied by value and added
                     to the corresponding pixel component in the accumulation
                     buffer, thereby updating the accumulation buffer.

       GL_LOAD       Similar to GL_ACCUM, except that the current value in the
                     accumulation buffer is not used in the calculation of the
                     new value.  That is, the R, G, B, and A values from the
                     currently selected buffer are divided by 2^n - 1,
                     multiplied by value, and then stored in the corresponding
                     accumulation buffer cell, overwriting the current value.

       GL_ADD        Adds value to each R, G, B, and A in the accumulation
                     buffer.

       GL_MULT       Multiplies each R, G, B, and A in the accumulation buffer
                     by value and returns the scaled component to its
                     corresponding accumulation buffer location.

       GL_RETURN     Transfers accumulation buffer values to the color buffer
                     or buffers currently selected for writing.  Each R, G, B,
                     and A component is multiplied by value, then multiplied
                     by 2^n - 1, clamped to the range [0,2^n - 1], and stored
                     in the corresponding display buffer cell.  The only
                     fragment operations that are applied to this transfer are
                     pixel ownership, scissor, dithering, and color
                     writemasks.

       To clear the accumulation buffer, call glClearAccum with R, G, B, and A
       values to set it to, then call glClear with the accumulation buffer
       enabled.

NOTES
       Only pixels within the current scissor box are updated by a glAccum
       operation.

ERRORS
       GL_INVALID_ENUM is generated if op is not an accepted value.

       GL_INVALID_OPERATION is generated if there is no accumulation buffer.

       GL_INVALID_OPERATION is generated if glAccum is executed between the
       execution of glBegin and the corresponding execution of glEnd.

ASSOCIATED GETS
       glGet with argument GL_ACCUM_RED_BITS
       glGet with argument GL_ACCUM_GREEN_BITS
       glGet with argument GL_ACCUM_BLUE_BITS
       glGet with argument GL_ACCUM_ALPHA_BITS

SEE ALSO
       glBlendFunc, glClear, glClearAccum, glCopyPixels, glGet, glLogicOp,
       glPixelStore, glPixelTransfer, glReadBuffer, glReadPixels, glScissor,
       glStencilOp

                                                                     GLACCUM()