Chapter 07

Texture Mapping
Instructor
LE Thanh Sach, Ph.D
 Contact

LE Thanh Sach, Ph.D.

Office:
Department of Computer Science,
Faculty of Computer Science and Engineering,
HoChiMinh City University of Technology.
Office Address:
268 LyThuongKiet Str., Dist. 10, HoChiMinh City,
Vietnam.
E-mail: [email protected]
E-home: http://cse.hcmut.edu.vn/~ltsach/
Tel: (+84) 83-864-7256 (Ext: 5839)
Computer Graphics: Chapter 07 – Texture Mapping Slide: 2
 Acknowledgment

The slides in this PPT file are composed

using the materials supplied by
Prof. Edward Angel: He is currently from ARTS
Lab, University of New Mexico. He also the author
of the book “Interactive Computer Graphics: A
Top-down Approach Using OpenGL”

Prof. Donald Hearn and Prof. M. Pauline

Baker, from Indiana University and Purdue
University

Computer Graphics: Chapter 07 – Texture Mapping Slide: 3

 Outline

Buffers
Texture Mapping
Texture Mapping in OpenGL
Compositing and Blending

Computer Graphics: Chapter 07 – Texture Mapping Slide: 4

 Buffers

Computer Graphics: Chapter 07 – Texture Mapping Slide: 5

 Objectives

Introduce additional OpenGL buffers

Learn to read and write buffers
Learn to use blending

Computer Graphics: Chapter 07 – Texture Mapping Slide: 6

 Buffer

Define a buffer by its spatial resolution (n x m) and

its depth (or precision) k, the number of bits/pixel

pixel
Computer Graphics: Chapter 07 – Texture Mapping Slide: 7
 OpenGL Frame Buffer

Computer Graphics: Chapter 07 – Texture Mapping Slide: 8

 OpenGL Buffers

Color buffers can be displayed

Front
Back
Auxiliary
Overlay
Depth
Accumulation
High resolution buffer
Stencil
Holds masks
Computer Graphics: Chapter 07 – Texture Mapping Slide: 9
 Writing in Buffers
Conceptually, we can consider all of memory as a
large two-dimensional array of pixels
We read and write rectangular block of pixels
Bit block transfer (bitblt) operations
The frame buffer is part of this memory

memory
source frame buffer
(destination)
writing into frame buffer
Computer Graphics: Chapter 07 – Texture Mapping Slide: 10
 Writing Model

Read destination pixel before writing source

Computer Graphics: Chapter 07 – Texture Mapping Slide: 11

 Bit Writing Modes
Source and destination bits are combined bitwise
16 possible functions (one per column in table)
replace XOR
OR

Computer Graphics: Chapter 07 – Texture Mapping Slide: 12

 XOR mode
Recall from Chapter 3 that we can use XOR by
enabling logic operations and selecting the XOR write
mode
XOR is especially useful for swapping blocks of
memory such as menus that are stored off screen
If S represents screen and M represents a menu
the sequence
S SM
M SM
S SM
swaps the S and M

Computer Graphics: Chapter 07 – Texture Mapping Slide: 13

 The Pixel Pipeline

OpenGL has a separate pipeline for pixels

Writing pixels involves
Moving pixels from processor memory to the frame
buffer
Format conversions
Mapping, Lookups, Tests
Reading pixels
Format conversion

Computer Graphics: Chapter 07 – Texture Mapping Slide: 14

 Raster Position

OpenGL maintains a raster position as part

of the state
Set by glRasterPos*()
glRasterPos3f(x, y, z);
The raster position is a geometric entity
Passes through geometric pipeline
Eventually yields a 2D position in screen
coordinates
This position in the frame buffer is where the
next raster primitive is drawn

Computer Graphics: Chapter 07 – Texture Mapping Slide: 15

 Buffer Selection
OpenGL can draw into or read from any of the color
buffers (front, back, auxiliary)
Default to the back buffer
Change with glDrawBuffer and glReadBuffer
Note that format of the pixels in the frame buffer is
different from that of processor memory and these two
types of memory reside in different places
Need packing and unpacking
Drawing and reading can be slow

Computer Graphics: Chapter 07 – Texture Mapping Slide: 16

 Bitmaps

OpenGL treats 1-bit pixels (bitmaps)

differently from multi-bit pixels (pixelmaps)
Bitmaps are masks that determine if the
corresponding pixel in the frame buffer is
drawn with the present raster color
0  color unchanged
1  color changed based on writing mode
Bitmaps are useful for raster text
GLUT font: GLUT_BIT_MAP_8_BY_13
Computer Graphics: Chapter 07 – Texture Mapping Slide: 17
 Raster Color
Same as drawing color set by glColor*()
Fixed by last call to glRasterPos*()
glColor3f(1.0, 0.0, 0.0);
glRasterPos3f(x, y, z);
glColor3f(0.0, 0.0, 1.0);
glBitmap(…….
glBegin(GL_LINES);
glVertex3f(…..);

Geometry drawn in blue

Ones in bitmap use a drawing color of red
Computer Graphics: Chapter 07 – Texture Mapping Slide: 18
 Drawing Bitmaps
glBitmap(width, height, x0, y0, xi, yi,
bitmap) offset from raster
position
increments in
raster
position after
bitmap drawn

first raster position

second raster position

Computer Graphics: Chapter 07 – Texture Mapping Slide: 19

 Example: Checker Board

GLubyte wb[2] = {0 x 00, 0 x ff};

GLubyte check[512];
int i, j;
for(i=0; i<64; i++) for (j=0; j<64, j++)
check[i*8+j] = wb[(i/8+j)%2];

glBitmap( 64, 64, 0.0, 0.0, 0.0, 0.0, check);

Computer Graphics: Chapter 07 – Texture Mapping Slide: 20

 Pixel Maps

OpenGL works with rectangular arrays of pixels

called pixel maps or images
Pixels are in one byte ( 8 bit) chunks
Luminance (gray scale) images 1 byte/pixel
RGB 3 bytes/pixel
Three functions
Draw pixels: processor memory to frame buffer
Read pixels: frame buffer to processor memory
Copy pixels: frame buffer to frame buffer

Computer Graphics: Chapter 07 – Texture Mapping Slide: 21

 OpenGL Pixel Functions
glReadPixels(x,y,width,height,format,type,myimage)

start pixel in frame buffer size type of pixels

type of image pointer to processor
memory
GLubyte myimage[512][512][3];
glReadPixels(0,0, 512, 512, GL_RGB,
GL_UNSIGNED_BYTE, myimage);

glDrawPixels(width,height,format,type,myimage)
starts at raster position

Computer Graphics: Chapter 07 – Texture Mapping Slide: 22

 Image Formats
We often work with images in a standard
format (JPEG, TIFF, GIF)
How do we read/write such images with
OpenGL?
No support in OpenGL
OpenGL knows nothing of image formats
Some code available on Web
Can write readers/writers for some simple
formats in OpenGL

Computer Graphics: Chapter 07 – Texture Mapping Slide: 23

 Displaying a PPM Image

PPM is a very simple format

Each image file consists of a header
followed by all the pixel data
Header P3
# comment 1
# comment 2
.
#comment n
rows columns maxvalue
pixels
Computer Graphics: Chapter 07 – Texture Mapping Slide: 24
 Reading the Header
FILE *fd;
int k, nm;
char c;
int i;
char b[100]; check for “P3”
float s; in first line
int red, green, blue;
printf("enter file name\n");
scanf("%s", b);
fd = fopen(b, "r");
fscanf(fd,"%[^\n] ",b);
if(b[0]!='P'|| b[1] != '3'){
printf("%s is not a PPM file!\n", b);
exit(0);
}
printf("%s is a PPM file\n",b);
Computer Graphics: Chapter 07 – Texture Mapping Slide: 25
 Reading the Header (cont)

fscanf(fd, "%c",&c);
while(c == '#')
{
fscanf(fd, "%[^\n] ", b);
printf("%s\n",b);
fscanf(fd, "%c",&c);
}
ungetc(c,fd);

skip over comments by

looking for # in first column

Computer Graphics: Chapter 07 – Texture Mapping Slide: 26

 Reading the Data
fscanf(fd, "%d %d %d", &n, &m, &k);
printf("%d rows %d columns max value= %d\n",n,m,k);

nm = n*m;
image=malloc(3*sizeof(GLuint)*nm);
s=255./k;
scale factor
for(i=0;i<nm;i++)
{
fscanf(fd,"%d %d %d",&red, &green, &blue );
image[3*nm-3*i-3]=red;
image[3*nm-3*i-2]=green;
image[3*nm-3*i-1]=blue;
}

Computer Graphics: Chapter 07 – Texture Mapping Slide: 27

 Scaling the Image Data

We can scale the image in the pipeline

glPixelTransferf(GL_RED_SCALE, s);
glPixelTransferf(GL_GREEN_SCALE, s);
glPixelTransferf(GL_BLUE_SCALE, s);

We may have to swap bytes when we go from processor

memory to the frame buffer depending on the processor.
If so, we can use
glPixelStorei(GL_UNPACK_SWAP_BYTES,GL_TRUE);
Computer Graphics: Chapter 07 – Texture Mapping Slide: 28
 The display callback

void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glRasterPos2i(0,0);
glDrawPixels(n,m,GL_RGB,
GL_UNSIGNED_INT, image);
glFlush();
}

Computer Graphics: Chapter 07 – Texture Mapping Slide: 29

 Texture Mapping

Computer Graphics: Chapter 07 – Texture Mapping Slide: 30

 Objectives

Introduce Mapping Methods

Texture Mapping
Environment Mapping
Bump Mapping
Consider basic strategies
Forward vs backward mapping
Point sampling vs area averaging

Computer Graphics: Chapter 07 – Texture Mapping Slide: 31

 The Limits of Geometric Modeling
Although graphics cards can render over 10
million polygons per second, that number is
insufficient for many phenomena
Clouds
Grass
Terrain
Skin

Computer Graphics: Chapter 07 – Texture Mapping Slide: 32

 Modeling an Orange
Consider the problem of modeling an orange
(the fruit)
Start with an orange-colored sphere
Too simple
Replace sphere with a more complex shape
Does not capture surface characteristics (small
dimples)
Takes too many polygons to model all the
dimples

Computer Graphics: Chapter 07 – Texture Mapping Slide: 33

 Modeling an Orange (2)

Take a picture of a real orange, scan it, and

“paste” onto simple geometric model
This process is known as texture mapping
Still might not be sufficient because
resulting surface will be smooth
Need to change local shape
Bump mapping

Computer Graphics: Chapter 07 – Texture Mapping Slide: 34

 Three Types of Mapping

Texture Mapping
Uses images to fill inside of polygons
Environment (reflection mapping)
Uses a picture of the environment for
texture maps
Allows simulation of highly specular surfaces
Bump mapping
Emulates altering normal vectors during the
rendering process

Computer Graphics: Chapter 07 – Texture Mapping Slide: 35

 Texture Mapping

geometric model texture mapped

Computer Graphics: Chapter 07 – Texture Mapping Slide: 36

 Environment Mapping

Computer Graphics: Chapter 07 – Texture Mapping Slide: 37

 Bump Mapping

Computer Graphics: Chapter 07 – Texture Mapping Slide: 38

 Where does mapping take place?

Mapping techniques are implemented at the end of

the rendering pipeline
Very efficient because few polygons make it
past the clipper

Computer Graphics: Chapter 07 – Texture Mapping Slide: 39

 Is it simple?

Although the idea is simple---map an image

to a surface---there are 3 or 4 coordinate
systems involved

2D image

3D surface
Computer Graphics: Chapter 07 – Texture Mapping Slide: 40
 Coordinate Systems
Parametric coordinates
May be used to model curves and surfaces
Texture coordinates
Used to identify points in the image to be
mapped
Object or World Coordinates
Conceptually, where the mapping takes place
Window Coordinates
Where the final image is really produced

Computer Graphics: Chapter 07 – Texture Mapping Slide: 41

 Texture Mapping

parametric coordinates

texture coordinates
window coordinates
world coordinates

Computer Graphics: Chapter 07 – Texture Mapping Slide: 42

 Mapping Functions

Basic problem is how to find the maps

Consider mapping from texture coordinates
to a point a surface
Appear to need three functions (x,y,z)
x = x(s,t)
y = y(s,t) t
z = z(s,t)
s
But we really want
to go the other way
Computer Graphics: Chapter 07 – Texture Mapping Slide: 43
 Backward Mapping

 We really want to go backwards

 Given a pixel, we want to know to which point
on an object it corresponds
 Given a point on an object, we want to know to
which point in the texture it corresponds
 Need a map of the form
s = s(x,y,z)
t = t(x,y,z)
 Such functions are difficult to find in general

Computer Graphics: Chapter 07 – Texture Mapping Slide: 44

 Two-part mapping

One solution to the mapping problem is to

first map the texture to a simple intermediate
surface
Example: map to cylinder

Computer Graphics: Chapter 07 – Texture Mapping Slide: 45

 Cylindrical Mapping
parametric cylinder
x = r cos 2 u
y = r sin 2u
z = v/h
maps rectangle in u,v space to cylinder
of radius r and height h in world coordinates
s=u
t=v

maps from texture space

Computer Graphics: Chapter 07 – Texture Mapping Slide: 46

 Spherical Map

We can use a parametric sphere

x = r cos 2u
y = r sin 2u cos 2v
z = r sin 2u sin 2v

in a similar manner to the cylinder

but have to decide where to put
the distortion

Spheres are used in environmental maps

Computer Graphics: Chapter 07 – Texture Mapping Slide: 47

 Box Mapping

Easy to use with simple orthographic

projection
Also used in environment maps

Computer Graphics: Chapter 07 – Texture Mapping Slide: 48

 Second Mapping

Map from intermediate object to actual object

Normals from intermediate to actual
Normals from actual to intermediate
Vectors from center of intermediate
actual intermediate

Computer Graphics: Chapter 07 – Texture Mapping Slide: 49

 Aliasing

Point sampling of the texture can lead to

aliasing errors point samples in u,v
miss blue stripes
(or x,y,z) space

point samples in texture space

Computer Graphics: Chapter 07 – Texture Mapping Slide: 50
 Area Averaging
A better but slower option is to use area averaging

pixel
preimage

Note that preimage of pixel is curved

Computer Graphics: Chapter 07 – Texture Mapping Slide: 51

 Texture Mapping in OpenGL

Computer Graphics: Chapter 07 – Texture Mapping Slide: 52

 Objectives

Introduce the OpenGL texture functions

and options

Computer Graphics: Chapter 07 – Texture Mapping Slide: 53

 Basic Stragegy

Three steps to applying a texture

1. specify the texture
 read or generate image
 assign to texture
 enable texturing
2. assign texture coordinates to vertices
 Proper mapping function is left to application
3. specify texture parameters
 wrapping, filtering

Computer Graphics: Chapter 07 – Texture Mapping Slide: 54

 Texture Mapping

z x
geometry display

t
image

s
Computer Graphics: Chapter 07 – Texture Mapping Slide: 55
 Texture Example

The texture (below) is a

256 x 256 image that has
been mapped to a
rectangular polygon which
is viewed in perspective

Computer Graphics: Chapter 07 – Texture Mapping Slide: 56

 Texture Mapping and the OpenGL
Pipeline
Images and geometry flow through separate
pipelines that join during fragment
processing
“complex” textures do not affect geometric
complexity

vertices geometry pipeline

fragment
image pixel pipeline processor

Computer Graphics: Chapter 07 – Texture Mapping Slide: 57

 Specifying a Texture Image

Define a texture image from an array of

texels (texture elements) in CPU memory
Glubyte my_texels[512][512];
Define as any other pixel map
Scanned image
Generate by application code
Enable texture mapping
glEnable(GL_TEXTURE_2D)
OpenGL supports 1-4 dimensional texture maps

Computer Graphics: Chapter 07 – Texture Mapping Slide: 58

 Define Image as a Texture
glTexImage2D( target, level, components,
w, h, border, format, type, texels );

target: type of texture, e.g. GL_TEXTURE_2D

level: used for mipmapping (discussed later)
components: elements per texel
w, h: width and height of texels in pixels
border: used for smoothing (discussed later)
format and type: describe texels
texels: pointer to texel array

glTexImage2D(GL_TEXTURE_2D, 0, 3, 512, 512, 0,

GL_RGB, GL_UNSIGNED_BYTE, my_texels);

Computer Graphics: Chapter 07 – Texture Mapping Slide: 59

 Converting A Texture Image

OpenGL requires texture dimensions to be powers

of 2
If dimensions of image are not powers of 2
gluScaleImage( format, w_in, h_in,
type_in, *data_in, w_out, h_out,
type_out, *data_out );
data_in is source image
data_out is for destination image
Image interpolated and filtered during scaling

Computer Graphics: Chapter 07 – Texture Mapping Slide: 60

 Mapping a Texture

Based on parametric texture coordinates

glTexCoord*() specified at each vertex
Texture Space Object Space
t 1, 1 (s, t) = (0.2, 0.8)
0, 1 A
a

c (0.4, 0.2)
b
B C
0, 0 1, 0 s (0.8, 0.4)

Computer Graphics: Chapter 07 – Texture Mapping Slide: 61

 Typical Code

glBegin(GL_POLYGON);
glColor3f(r0, g0, b0); //if no shading used
glNormal3f(u0, v0, w0); // if shading used
glTexCoord2f(s0, t0);
glVertex3f(x0, y0, z0);
glColor3f(r1, g1, b1);
glNormal3f(u1, v1, w1);
glTexCoord2f(s1, t1);
glVertex3f(x1, y1, z1);
.
.
glEnd();

Note that we can use vertex arrays to increase efficiency

Computer Graphics: Chapter 07 – Texture Mapping Slide: 62
 Interpolation

OpenGL uses interpolation to find proper texels

from specified texture coordinates
texture stretched
Can be distortions over trapezoid
showing effects of
good selection poor selection
bilinear interpolation
of tex coordinates of tex coordinates

Computer Graphics: Chapter 07 – Texture Mapping Slide: 63

 Texture Parameters

OpenGL has a variety of parameters that

determine how texture is applied
Wrapping parameters determine what
happens if s and t are outside the (0,1) range
Filter modes allow us to use area averaging
instead of point samples
Mipmapping allows us to use textures at
multiple resolutions
Environment parameters determine how
texture mapping interacts with shading
Computer Graphics: Chapter 07 – Texture Mapping Slide: 64
 Wrapping Mode

Clamping: if s,t > 1 use 1, if s,t <0 use 0

Wrapping: use s,t modulo 1
glTexParameteri( GL_TEXTURE_2D,
GL_TEXTURE_WRAP_S, GL_CLAMP )
glTexParameteri( GL_TEXTURE_2D,
GL_TEXTURE_WRAP_T, GL_REPEAT )

s
GL_REPEAT GL_CLAMP
texture wrapping wrapping

Computer Graphics: Chapter 07 – Texture Mapping Slide: 65

 Magnification and Minification
More than one texel can cover a pixel (minification) or
more than one pixel can cover a texel (magnification)

Can use point sampling (nearest texel) or linear filtering

( 2 x 2 filter) to obtain texture values

Texture Polygon Texture Polygon

Magnification Minification

Computer Graphics: Chapter 07 – Texture Mapping Slide: 66

 Filter Modes

Modes determined by
glTexParameteri( target, type, mode )
glTexParameteri(GL_TEXTURE_2D, GL_TEXURE_MAG_FILTER,
GL_NEAREST);

glTexParameteri(GL_TEXTURE_2D, GL_TEXURE_MIN_FILTER,
GL_LINEAR);

Note that linear filtering requires a border of an

extra texel for filtering at edges (border = 1)

Computer Graphics: Chapter 07 – Texture Mapping Slide: 67

 Mipmapped Textures

 Mipmapping allows for prefiltered texture maps

of decreasing resolutions
 Lessens interpolation errors for smaller textured
objects
 Declare mipmap level during texture definition
glTexImage2D( GL_TEXTURE_*D, level, … )
 GLU mipmap builder routines will build all the
textures from a given image
gluBuild*DMipmaps( … )

Computer Graphics: Chapter 07 – Texture Mapping Slide: 68

 Example
linear
point filtering
sampling

mipmapped mipmapped
point linear
sampling filtering

Computer Graphics: Chapter 07 – Texture Mapping Slide: 69

 Texture Functions

 Controls how texture is applied

 glTexEnv{fi}[v]( GL_TEXTURE_ENV, prop,
param )
 GL_TEXTURE_ENV_MODE modes
 GL_MODULATE: modulates with computed shade
 GL_BLEND: blends with an environmental color
 GL_REPLACE: use only texture color
 GL(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,
GL_MODULATE);

 Set blend color with GL_TEXTURE_ENV_COLOR

Computer Graphics: Chapter 07 – Texture Mapping Slide: 70
 Perspective Correction Hint

Texture coordinate and color interpolation

either linearly in screen space
or using depth/perspective values (slower)
Noticeable for polygons “on edge”
glHint( GL_PERSPECTIVE_CORRECTION_HINT,
hint )
where hint is one of
GL_DONT_CARE
GL_NICEST
GL_FASTEST

Computer Graphics: Chapter 07 – Texture Mapping Slide: 71

 Generating Texture Coordinates

OpenGL can generate texture coordinates

automatically
glTexGen{ifd}[v]()
specify a plane
generate texture coordinates based upon distance
from the plane
generation modes
GL_OBJECT_LINEAR
GL_EYE_LINEAR
GL_SPHERE_MAP (used for environmental maps)

Computer Graphics: Chapter 07 – Texture Mapping Slide: 72

 Texture Objects

Texture is part of the OpenGL state

If we have different textures for different
objects, OpenGL will be moving large amounts
data from processor memory to texture memory
Recent versions of OpenGL have texture objects
one image per texture object
Texture memory can hold multiple texture
objects

Computer Graphics: Chapter 07 – Texture Mapping Slide: 73

 Applying Textures II

1. specify textures in texture objects

2. set texture filter
3. set texture function
4. set texture wrap mode
5. set optional perspective correction hint
6. bind texture object
7. enable texturing
8. supply texture coordinates for vertex
 coordinates can also be generated

Computer Graphics: Chapter 07 – Texture Mapping Slide: 74

 Other Texture Features

Environment Maps
Start with image of environment through a
wide angle lens
Can be either a real scanned image or an image
created in OpenGL
Use this texture to generate a spherical map
Use automatic texture coordinate generation
Multitexturing
Apply a sequence of textures through
cascaded texture units
Computer Graphics: Chapter 07 – Texture Mapping Slide: 75
 Compositing and Blending

Computer Graphics: Chapter 07 – Texture Mapping Slide: 76

 Objectives

Learn to use the A component in RGBA

color for
Blending for translucent surfaces
Compositing images
Antialiasing

Computer Graphics: Chapter 07 – Texture Mapping Slide: 77

 Opacity and Transparency

Opaque surfaces permit no light to pass through

Transparent surfaces permit all light to pass
Translucent surfaces pass some light
translucency = 1 – opacity ()

opaque surface  =1

Computer Graphics: Chapter 07 – Texture Mapping Slide: 78

 Physical Models

Dealing with translucency in a physically correct

manner is difficult due to
the complexity of the internal interactions of
light and matter
Using a pipeline renderer

Computer Graphics: Chapter 07 – Texture Mapping Slide: 79

 Writing Model

Use A component of RGBA (or RGB) color to

store opacity
During rendering we can expand our writing
model to use RGBA values
blend
source blending factor destination
source
component component

destination blending
factor Color Buffer

Computer Graphics: Chapter 07 – Texture Mapping Slide: 80

 Blending Equation
We can define source and destination blending factors
for each RGBA component
s = [sr, sg, sb, s]
d = [dr, dg, db, d]
Suppose that the source and destination colors are
b = [br, bg, bb, b]
c = [cr, cg, cb, c]
Blend as
c’ = [br sr+ cr dr, bg sg+ cg dg , bb sb+ cb db , b s+ c d ]
Computer Graphics: Chapter 07 – Texture Mapping Slide: 81
 OpenGL Blending and Compositing
Must enable blending and pick source and
destination factors
glEnable(GL_BLEND)
glBlendFunc(source_factor,
destination_factor)
Only certain factors supported
GL_ZERO, GL_ONE
GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA
GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA
See Redbook for complete list

Computer Graphics: Chapter 07 – Texture Mapping Slide: 82

 Example
Suppose that we start with the opaque background color
(R0,G0,B0,1)
This color becomes the initial destination color
We now want to blend in a translucent polygon with color
(R1,G1,B1,1)
Select GL_SRC_ALPHA and GL_ONE_MINUS_SRC_ALPHA as the
source and destination blending factors
R’1 = 1 R1 +(1- 1) R0, ……
Note this formula is correct if polygon is either opaque or
transparent

Computer Graphics: Chapter 07 – Texture Mapping Slide: 83

 Clamping and Accuracy

All the components (RGBA) are clamped and stay

in the range (0,1)
However, in a typical system, RGBA values are
only stored to 8 bits
Can easily loose accuracy if we add many components
together
Example: add together n images
Divide all color components by n to avoid clamping
Blend with source factor = 1, destination factor = 1
But division by n loses bits

Computer Graphics: Chapter 07 – Texture Mapping Slide: 84

 Order Dependency

Is this image correct?

Probably not
Polygons are rendered
in the order they pass
down the pipeline
Blending functions
are order dependent

Computer Graphics: Chapter 07 – Texture Mapping Slide: 85

 Opaque and Translucent Polygons

Suppose that we have a group of polygons some of

which are opaque and some translucent
How do we use hidden-surface removal?
Opaque polygons block all polygons behind them
and affect the depth buffer
Translucent polygons should not affect depth
buffer
Render with glDepthMask(GL_FALSE) which makes
depth buffer read-only
Sort polygons first to remove order dependency
Computer Graphics: Chapter 07 – Texture Mapping Slide: 86
 Fog

We can composite with a fixed color and have the

blending factors depend on depth
Simulates a fog effect
Blend source color Cs and fog color Cf by
Cs’=f Cs + (1-f) Cf
f is the fog factor
Exponential
Gaussian
Linear (depth cueing)

Computer Graphics: Chapter 07 – Texture Mapping Slide: 87

 Fog Functions

Computer Graphics: Chapter 07 – Texture Mapping Slide: 88

 OpenGL Fog Functions

GLfloat fcolor[4] = {……}:

glEnable(GL_FOG);
glFogf(GL_FOG_MODE, GL_EXP);
glFogf(GL_FOG_DENSITY, 0.5);
glFOgv(GL_FOG, fcolor);

Computer Graphics: Chapter 07 – Texture Mapping Slide: 89

 Line Aliasing

Ideal raster line is one pixel wide

All line segments, other than vertical and
horizontal segments, partially cover pixels
Simple algorithms color
only whole pixels
Lead to the “jaggies”
or aliasing
Similar issue for polygons
Computer Graphics: Chapter 07 – Texture Mapping Slide: 90
 Antialiasing

Can try to color a pixel by adding a fraction of its color to

the frame buffer
Fraction depends on percentage of pixel covered by
fragment
Fraction depends on whether there is overlap

no overlap overlap

Computer Graphics: Chapter 07 – Texture Mapping Slide: 91

 Area Averaging
Use average area 1+2-12 as blending factor

Computer Graphics: Chapter 07 – Texture Mapping Slide: 92

 OpenGL Antialiasing

Can enable separately for points, lines, or

polygons
glEnable(GL_POINT_SMOOTH);
glEnable(GL_LINE_SMOOTH);
glEnable(GL_POLYGON_SMOOTH);

glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

Computer Graphics: Chapter 07 – Texture Mapping Slide: 93

 Accumulation Buffer

Compositing and blending are limited by

resolution of the frame buffer
Typically 8 bits per color component
The accumulation buffer is a high resolution
buffer (16 or more bits per component) that avoids
this problem
Write into it or read from it with a scale factor
Slower than direct compositing into the frame
buffer
Computer Graphics: Chapter 07 – Texture Mapping Slide: 94
 Applications

Compositing
Image Filtering (convolution)
Whole scene antialiasing
Motion effects

Computer Graphics: Chapter 07 – Texture Mapping Slide: 95