The Buffers and Operations An Interactive Introduction to OpenGL Programming The Buffers and Operations Blending Depth Test Dithering Logical Operations Scissor Stencil Alpha Fragment Framebuffer In order for a fragment to make it to the frame buffer, it has a number of testing stages and pixel combination modes to go through. The tests that a fragment must pass are: scissor test - an additional clipping test alpha test - a filtering test based on the alpha color component stencil test - a pixel mask test depth test - fragment occlusion test Each of these tests is controlled by a glEnable() capability. If a fragment passes all enabled tests, it is then blended, dithered and/or logically combined with pixels in the framebuffer. Each of these operations can be enabled and disabled.

Usage Part of the OpenGL philosophy is to provide tools without dictating their use. These tools can be used in many ways. Often the name (“depth buffer”) suggests the most common use, but there is nothing “wrong” with using a tool quite differently.

OpenGL Buffers OpenGL has 4 types of buffers: Color buffers Depth buffer Stencil buffer Accumulation buffer Each buffer has an intended function; however, you may use the buffers in any way you wish. In order to be used, a buffer must be allocated. Do this in your glutInitDisplayMode call.

OpenGL Tests Related to the buffers are the OpenGL tests: Scissor test Alpha test Depth test Stencil test A test is an expression with a boolean value that OpenGL evaluates for every fragment. If the result is true, then the test passes, and the fragment continues down the pipeline. Otherwise, the test fails, and fragment is discarded. All tests are done in the fragment-processing part of the pipeline. In order to have any effect, a test must be enabled. Do this with glEnable.

Buffers & Tests Associated Remember: Allocate buffers; enable tests! Buffer Corresponding Test -- Scissor Test Color Buffers Alpha Test Depth Buffer Depth Test Stencil Buffer Stencil Test Accumulation Buffer

Masking Buffers Most buffers have masks associated with them. If flag is GL_FALSE, buffer writing is disabled. The mask determines whether a buffer (or part of a buffer) is ever written. For example, glColorMask(false, true, true, true); means that the R portion of the color buffer will not be changed. Note: The mask affects all commands that would change the buffer, even glClear. void glIndexMask(GLuint mask); void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); void glDepthMask(GLboolean flag); void glStencilMask(GLuint mask);

Buffers Clearing The buffers to clear are specified by bitwise-or’ing together. For example, glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_ACCUM_BUFFER_BIT); The value to store in each pixel of a buffer is set by a separate command for each buffer: glClearColor glClearDepth glClearStencil glClearAccum

Copyright @ 2001 by Jim X. Chen: jchen@cs.gmu.edu Parameter Meaning GL_RED_BITS, Number of bits per R, G, B, or A GL_GREEN_BITS, component in the color buffers GL_BLUE_BITS, GL_ALPHA_BITS GL_DEPTH_BITS No of bits per pixel in the depth buffer GL_STENCIL_BITS No of bits per pixel in the stencil buffer GL_ACCUM_RED_BITS, No of bits per R, G, B, or A GL_ACCUM_GREEN_BITS, component in the GL_ACCUM_BLUE_BITS, accumulation buffer GL_ACCUM_ALPHA_BITS glGetIntegerv() to query your OpenGL system about per-pixel buffer storage for a particular buffer 8 Copyright @ 2001 by Jim X. Chen: jchen@cs.gmu.edu

Copyright @ 2001 by Jim X. Chen: jchen@cs.gmu.edu Color Buffers (Framebuffers) Stereoscopic viewing has left and right color buffers for the left and right stereo images. Double-buffered systems have front & back buffers. Up to four optional, non-displayable auxiliary color buffers can also be supported. Stencil Buffer One use for the stencil buffer is to restrict drawing to certain portions of the screen, just as a cardboard stencil can be used with a can of spray paint to make fairly precise painted images. You can store an image of the windshield’s shape in the stencil buffer, and then draw the entire scene. 9 Copyright @ 2001 by Jim X. Chen: jchen@cs.gmu.edu

Copyright @ 2001 by Jim X. Chen: jchen@cs.gmu.edu Accumulation Buffer The accumulation buffer holds RGBA color data just like the color buffers do in RGBA mode. It’s typically used for accumulating a series of images into a final, composite image. You can perform operations like scene antialiasing by supersampling an image and then averaging the samples to produce the values that are finally painted into the pixels of the color buffers. You don’t draw directly into the accumulation buffer; accumulation operations are always performed in rectangular blocks, usually transfers of data to or from a color buffer. 1010 Copyright @ 2001 by Jim X. Chen: jchen@cs.gmu.edu

Copyright @ 2001 by Jim X. Chen: jchen@cs.gmu.edu Testing and Operating on Fragments Scissor Test If a fragment lies inside the rectangle, it passes the scissor test. void glScissor(GLint x, GLint y, GLsizei width, GLsizei height); Sets the location and size of the scissor rectangle. The parameters define the lower left corner (x, y), and the width and height of the rectangle. Pixels that lie inside the rectangle pass the scissor test. Scissoring is enabled and disabled by passing GL_SCISSOR to glEnable() and glDisable(). The scissor test is just a version of a stencil test using a rectangular region of the screen. It’s fairly easy to create a blindingly fast hardware implementation of scissoring, while a given system might be much slower at stenciling -- perhaps because the stenciling is performed in software. 1111 Copyright @ 2001 by Jim X. Chen: jchen@cs.gmu.edu

The Scissor Test The scissor test is by far the simplest of the tests. It allows you to restrict drawing to a rectangular portion of the viewport. To enable: glEnable(GL_SCISSOR_TEST); Then: glScissor(x, y, width, height); Parameters are as in the glViewport command. (x,y) is the lower-left corner of the rectangle. The scissor test passes if the pixel is within the rectangle; otherwise, it fails. The scissor test is really just a quick, simple version of stenciling. 2 Feb 2004 CS 481/681

Copyright @ 2001 by Jim X. Chen: jchen@cs.gmu.edu Alpha Test In RGBA mode, the alpha test allows you to accept or reject a fragment based on its alpha value. void glAlphaFunc(GLenum func, GLclampf ref); Sets the reference value and comparison function for the alpha test. The reference value ref is clamped to be between 0 and 1. Parameter Meaning GL_NEVER Never accept the fragment GL_ALWAYS Always accept the fragment GL_LESS Accept fragment if fragment alpha < GL_LEQUAL Accept fragment if fragment alpha <= reference alpha GL_EQUALAccept fragment if fragment alpha = GL_GEQUAL Accept fragment if fragment alpha >= GL_GREATER Accept fragment if fragment alpha > GL_NOTEQUAL Accept fragment if fragment alpha != 1313 Copyright @ 2001 by Jim X. Chen: jchen@cs.gmu.edu

An Interactive Introduction to OpenGL Programming Alpha Test Reject pixels based on their alpha value glAlphaFunc( func, value ) glEnable( GL_ALPHA_TEST ) use alpha as a mask in textures Alpha values can also be used for fragment testing. glAlphaFunc() sets a value which, if glEnable(GL_ALPHA_TEST) has been called, will test every fragment’s alpha against the value set, and if the test fails, the fragment is discarded. The functions which glAlphaFunc() can use are: GL_NEVER GL_LESS GL_EQUAL GL_LEQUAL GL_GREATER GL_NOTEQUAL GL_GEUQAL GL_ALWAYS The default is GL_ALWAYS, which always passes fragments. Alpha testing is particularly useful when combined with texture mapping with textures which have an alpha component. This allows your texture map to act as a localized pixel mask. This technique is commonly used for objects like trees or fences, where modeling the objects (and all of its holes) becomes prohibitive. CPU DL Poly. Per Vertex Raster Frag FB Pixel Texture

Copyright @ 2001 by Jim X. Chen: jchen@cs.gmu.edu Stencil Test void glStencilFunc(GLenum func, GLint ref, GLuint mask); The ref value is compared to the value in the stencil buffer using the comparison func, but the comparison applies only to those bits where the corresponding bits of the mask are 1. The function can be GL_NEVER, GL_ALWAYS, GL_LESS, GL_LEQUAL, GL_EQUAL, GL_GEQUAL, GL_GREATER, or GL_NOTEQUAL. The stencil test is enabled and disabled by passing GL_STENCIL_TEST to glEnable() and glDisable(). void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass); Specifies how the data in the stencil buffer is modified when a fragment passes or fails the stencil test. The fail, zfail, and zpass can be GL_KEEP, GL_ZERO, GL_REPLACE, GL_INCR, GL_DECR, or GL_INVERT. They correspond to keeping the current value, replacing it with zero, replacing it with the reference value, incrementing it, decrementing it, or bitwise-inverting it. 1515 Copyright @ 2001 by Jim X. Chen: jchen@cs.gmu.edu

Controlling Stencil Buffer An Interactive Introduction to OpenGL Programming Controlling Stencil Buffer glStencilFunc(func, ref, mask) compare value in buffer with ref using func only applied for bits in mask which are 1 func is one of standard comparison functions glStencilOp(fail, zfail, zpass) Allows changes in stencil buffer based on passing or failing stencil and depth tests: GL_KEEP, GL_INCR The two principal functions for using the stencil buffer are glStencilFunc()which controls how the bits in the stencil buffer are used to determine if a particular pixel in the framebuffer is writable. glStencilOp()controls how the stencil buffer values are updated, based on three tests: 1) did the pixel pass the stencil test specified with glStencilFunc() 2) did the pixel fail the depth test for that pixel. 3) did the pixel pass the depth test for that pixel. This would mean that the pixel in question would have appeared in the image.

An Interactive Introduction to OpenGL Programming Creating a Mask glInitDisplayMode( …|GLUT_STENCIL|… ); glEnable( GL_STENCIL_TEST ); glClearStencil( 0x0 ); glStencilFunc( GL_ALWAYS, 0x1, 0x1 ); glStencilOp( GL_REPLACE, GL_REPLACE, GL_REPLACE ); draw mask In this example, we specify a simple stencil mask. We do this by specifying that regardless of which tests the pixel passes or fails, we replace its value in the stencil buffer with the value 0x1. This permits us to render the shape of the pixel mask we want directly into the stencil buffer (in a manner of speaking).

An Interactive Introduction to OpenGL Programming Using Stencil Mask Draw objects where stencil = 1 glStencilFunc( GL_EQUAL, 0x1, 0x1 ) Draw objects where stencil != 1 glStencilFunc(GL_NOTEQUAL, 0x1, 0x1); glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); After the stencil mask is specified, we can use the mask to selectively update pixels. With the first set of commands, we only update the pixels where the stencil buffer is set to 0x01 in the stencil buffer. In the second example, we set the stencil state up to render only to pixels where the stencil value is not 0x01.

Copyright @ 2001 by Jim X. Chen: jchen@cs.gmu.edu Depth Test void glDepthFunc(GLenum func); Sets the comparison function for the depth test. The value for func must be GL_NEVER, GL_ALWAYS, GL_LESS, GL_LEQUAL, GL_EQUAL, GL_GEQUAL, GL_GREATER, or GL_NOTEQUAL. An incoming fragment passes the depth test if its z value has the specified relation to the value already stored in the depth buffer. The default is GL_LESS. In this case, the z value represents the distance from the object to the viewpoint. 1919 Copyright @ 2001 by Jim X. Chen: jchen@cs.gmu.edu

Copyright @ 2001 by Jim X. Chen: jchen@cs.gmu.edu The Accumulation Buffer Images is generated in one of the standard color buffers, and these are accumulated, one at a time, into the accumulation buffer. When the accumulation is finished, the result is copied back into a color buffer for viewing. To reduce rounding errors, the accumulation buffer may have higher precision (more bits per color) than the standard color buffers. A photographer typically creates a multiple exposure by taking several pictures of the same scene without advancing the film. If anything in the scene moves, that object appears blurred. 2020 Copyright @ 2001 by Jim X. Chen: jchen@cs.gmu.edu

Copyright @ 2001 by Jim X. Chen: jchen@cs.gmu.edu void glAccum(GLenum op, GLfloat value); Controls the accumulation buffer. The op parameter selects the operation, and value is a number to be used in that operation. The possible operations are GL_ACCUM, GL_LOAD, GL_RETURN, GL_ADD, and GL_MULT: ·GL_ACCUM reads each pixel from the buffer currently selected for reading, multiplies the R, G, B, and alpha values by value, and adds the result to the accumulation buffer. ·GL_LOAD does the same thing, except that the values replace those in the accumulation buffer rather than being added to them. ·GL_RETURN takes values from the accumulation buffer, multiplies them by value, and places the result in the color buffer(s) enabled for writing. ·GL_ADD and GL_MULT simply add or multiply the value of each pixel in the accumulation buffer by value, and then return it to the accumulation buffer. For GL_MULT, value is clamped to be in the range [- 1.0,1.0]. For GL_ADD, no clamping occurs. 2121 Copyright @ 2001 by Jim X. Chen: jchen@cs.gmu.edu

Copyright @ 2001 by Jim X. Chen: jchen@cs.gmu.edu Scene Antialiasing First clear the accumulation buffer and enable the front buffer for reading and writing. Then loop several times (say, n) through code that draws the image in a slightly different position, accumulating the data with glAccum(GL_ACCUM, 1.0/n); and finally calling glAccum(GL_RETURN, 1.0); To decide what n should be, you need to trade off speed (the more times you draw the scene, the longer it takes to obtain the final image) and quality (the more times you draw the scene, the smoother it gets, until you make maximum use of the accumulation buffer’s resolution). Motion Blur 2222 Copyright @ 2001 by Jim X. Chen: jchen@cs.gmu.edu

Copyright @ 2001 by Jim X. Chen: jchen@cs.gmu.edu Suppose you want to make a motion-blurred image extending over a small interval of time. Instead of spatially jittering the images, jitter them temporally. The entire scene can be made successively dimmer by calling glAccum (GL_MULT, decayFactor); where decayFactor is a number between 0.0 & 1.0. Smaller numbers for decayFactor cause the object to appear to be moving faster. You can transfer the completed scene with the object’s current position and “vapor trail” of previous positions from the accumulation buffer to the standard color buffer with glAccum (GL_RETURN, 1.0); The image looks correct even if the items move at different speeds, or if some of them are accelerated. As before, the more jitter points you use, the better the final image. You can combine motion blur with antialiasing by jittering in both the spatial and temporal domains, but you pay for higher quality with longer rendering times. 2323 Copyright @ 2001 by Jim X. Chen: jchen@cs.gmu.edu

Copyright @ 2001 by Jim X. Chen: jchen@cs.gmu.edu Depth of Field A photograph made with a camera is in perfect focus only for items lying on a single plane a certain distance from the film. The farther an item is from this plane, the more out of focus it is. The depth of field for a camera is a region about the plane of perfect focus where items are out of focus by a small enough amount. The accumulation buffer can be used to approximate what you would see in a photograph where items are more and more blurred as their distance from a plane of perfect focus increases. It isn’t an exact simulation of the effects produced in a camera, but the result looks similar. To achieve this result, draw the scene repeatedly using calls with different arg values to glFrustum(). Choose the arguments so that the position of the viewpoint varies slightly around its true position and so that each frustum shares a common rectangle that lies in the plane of perfect focus. 2424 Copyright @ 2001 by Jim X. Chen: jchen@cs.gmu.edu

Copyright @ 2001 by Jim X. Chen: jchen@cs.gmu.edu Soft Shadows To accumulate soft shadows due to multiple light sources, render the shadows with one light turned on at a time, and accumulate them together. 2525 Copyright @ 2001 by Jim X. Chen: jchen@cs.gmu.edu

An Interactive Introduction to OpenGL Programming Dithering glEnable( GL_DITHER ) Dither colors for better looking results Used to simulate more available colors Dithering is a technique to trick the eye into seeing a smoother color when only a few colors are available. Newspaper’s use this trick to make images look better. OpenGL will modify a fragment’s color value with a dithering table before it is written into the framebuffer.

Logical Operations on Pixels An Interactive Introduction to OpenGL Programming Logical Operations on Pixels Combine pixels using bitwise logical operations glLogicOp( mode ) Common modes GL_XOR GL_AND Logical operations allows pixels to be combined with bitwise logical operations, like logical ands, ors and nots. The fragment’s color bits are combined with the pixel’s color bits using the logical operation, and then written into the framebuffer. GL_XOR is a useful logical operation for creating “rubber banding” type techniques, where you only momentarily want to modify a pixel, and then return back to its original value. There are several OpenGL logical operation modes: GL_CLEAR GL_SET GL_COPY, GL_COPY_INVERTED GL_NOOP GL_INVERT GL_AND GL_NAND GL_OR GL_NOR GL_XOR GL_AND_INVERTED GL_AND_REVERSE GL_EQUIV GL_OR_REVERSE GL_OR_INVERTED