manpagez: man pages & more
man glAccum(3)
Home | html | info | man
glAccum(3)                                                        glAccum(3)




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 ren-
       dering.  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  cur-
       rent  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,  multi-
                     plied  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 corre-
                     sponding 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 frag-
                     ment  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

       glClear(3), glClearAccum(3), glCopyPixels(3), glDrawBuffer(3), glGet(3),
       glReadBuffer(3), glReadPixels(3), glScissor(3), glStencilOp(3)



                                                                   glAccum(3)

Mac OS X 10.6 - Generated Thu Sep 17 20:20:13 CDT 2009
© manpagez.com 2000-2025
Individual documents may contain additional copyright information.