Texture Environment

Textures provide color information, but so does glColor or lighting.

The texture environment controls how these colors interact.

glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, mode)

A "GL_REPLACE" environment uses just the texture color, and ignores everything else.
    Color = C_t

A "GL_MODULATE" environment combines the texture and other color, multiplying them together.
    Color = C_t * C_f

Example: texenv.py

Texture Environment

GL_MODULATE mode is used when objects are both textured and lighted

Example: texlight.py

Filtering

Applying a texture involves sampling - for each pixel drawn on the screen, OpenGL must compute a color from the texture image.

Texels (texture pixels) rarely match up exactly 1-to-1 with the pixels on the screen .

Filtering modes select what to do when texels are larger than screen pixels (magnification), or when texels are smaller than screen pixels (minification).

    

Filtering

glTexParameteri(GL_TEXTURE_2D, filter, mode)

If filter is GL_TEX_MAG_FILTER, mode can be

• GL_NEAREST - choose the texel nearest the center of the pixel
• GL_LINEAR - average the four nearest texels

If filter is GL_TEX_MIN_FILTER, mode can be

• GL_NEAREST - choose the texel nearest the center of the pixel
• GL_LINEAR - average the four nearest texels
• a mipmapping mode

Example: texfilter.py

Mipmapping

Mipmapping uses versions of the texture at smaller & smaller sizes image, to effectively pre-compute the average of many texels.

As a texture gets more and more minified, many texels will correspond to a single screen pixel, and using a "nearest" or "linear" filter will not compute an accurate result. The texture will appear to flicker as the object moves.

A mipmapped texture avoids the flickering problem when minified. As a result, it can look a bit fuzzier.

Mipmapping

gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB,
                  width, height, GL_RGB,
                  GL_UNSIGNED_BYTE, pixels)

Use gluBuild2DMipmaps in place of glTexImage2D.
It will automatically generate all the smaller versions of the texture.

Example: mipmap.py

Alpha

• Originated in early paintbox programs
• Formalized in Porter & Duff's "Compositing Digital Images", SIGGRAPH '84

• Fourth component of colors (RGBA)
• Used for semi-transparent objects
• Represents opacity

Blending

• Combines color of object being drawn with color in frame buffer
• Makes drawn object appear transparent

Most common method:

Blending

Many different formulas for blending colors can be used

Formula is defined by glBlendFunc() function

is defined by:

  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)

Blending

BlendFunc is applied to pixels as they are drawn - blending incoming color with color in the frame buffer

Example: alpha.py

Smooth-shaded Alpha

Alpha is treated like any other color component

If alpha differs at each vertex, it will be smoothly interpolated.
Can give objects soft edges.

Examples: smoothAlpha.py     alphawheel.py

Time-varying Alpha

Changing alpha over time can make an object a fade in or out

Example: fade.py

Blending & Drawing Order

Objects are rendered one at a time

When blending, all that is known is the current polygon, and the results of previous rendering (frame buffer contents)

These are the source & destination colors of the blending formula

+

=

Blending & Drawing Order

Depth-buffering occurs before blending

To draw a transparent plus an opaque object, draw the opaque one first

Draw sphere, then cube	Draw cube, then sphere

Example: drawOrder0.py

Blending & Drawing Order

Multiple transparent objects need to be drawn in back-to-front order

The order can depend on the camera position

Example: drawOrder1.py

Depth Mask

Can prevent transparent objects occluding each other by disabling the depth mask:

glDepthMask(GL_FALSE)

Result can be incorrect, but errors are less noticeable

Example: depthmask.py

Backface Culling

Back faces are normally visible in transparent objects

glEnable(GL_CULL_FACE) prevents drawing back faces of objects

glDisable(GL_CULL_FACE)		glEnable(GL_CULL_FACE)

Example: cullface.py

Backface Culling

"Front-facingness" is determined by vertex order

When viewed from the front, vertices are in counter-clockwise order

Front facing		Back facing

Multipass Rendering

Rendering the same objects more than once, with different modes

Render once with glCullFace(GL_FRONT), once with glCullFace(GL_BACK)

Other Blend Functions

General blending formula is:

(R_s, G_s, B_s) is the source color (object being drawn)
(R_d, G_d, B_d) is the destination color (color already in the framebuffer)

SourceFactor and DestinationFactor are defined by glBlendFunc()

Other Blend Functions

Filters

Blending can be used to apply a color filter to the whole scene

Draw a square that covers the entire window, with the appropriate blending function

# Dim the scene glBlendFunc(GL_ZERO, GL_SRC_ALPHA)          glColor4f(1.0, 1.0, 1.0, 0.5)

Example: filter.py

Filters

# Apply a purple filter glBlendFunc(GL_ZERO, GL_SRC_COLOR) glColor4f(1.0, 0.0, 0.5, 1.0)
# Invert all the colors glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ZERO)      glColor4f(1.0, 1.0, 1.0, 1.0)

This document is by Dave Pape, and is released under a Creative Commons License.