Texture Mapping

last updated 11/21/06

Objectives

Introduce Mapping Methods

Consider basic strategies

Introduce the OpenGL texture functions and options

The Limits of Geometric Modeling

Although graphics cards can render over 10 million polygons per second, that number is insufficient for many phenomena


Modeling an Orange

Consider the problem of modeling an orange (the fruit)

Start with an orange-colored sphere

Replace sphere with a more complex shape

Take a picture of a real orange, scan it, and “paste” onto simple geometric model

Still might not be sufficient because resulting surface will be smooth


Three Types of Mapping

Texture Mapping

 

Environment (reflection mapping)

Bump mapping


Where does mapping take place?

Mapping techniques are implemented at the end of the rendering pipeline.  It is very efficient because few polygons make it past the clipper.


Coordinate Systems

Although the idea of texture mapping is simple---map an image to a surface---there are 3 or 4 coordinate systems involved in the process.

Parametric coordinates

Texture coordinates

Object or World Coordinates

Window Coordinates

 


Mapping Functions

Basic problem is how to find the maps. Consider mapping from texture coordinates to a point a surface, it appears we need three functions:

x = x(s,t)
y = y(s,t)
z = z(s,t)

But we really want to go the other way

Backward Mapping

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 mapping of the form

s = s(x,y,z)
t = t(x,y,z)

Such functions are difficult to find in general.

 


Two-part mapping

One solution to the mapping problem is to first map the texture to a simple intermediate surface

Example: map to cylinder

For a parametric cylinder

x = r cos (2π u)
y = r sin (2πu)
z = v/h

which maps rectangle in u,v space to cylinder of radius r and height h in world coordinates.

s = u
t = v 

then maps from texture space.


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 (GIS) maps.

Box Mapping

Easy to use with simple orthographic projection

Also used in environment maps (close up or less than a few miles in dimension--Mercator projection)

 

 


Second Mapping

Map from an intermediate object to an actual object--where do we start?

Normal from the intermediate, normals from the object surface, or normals from the center of the object.


Aliasing

Point sampling of the texture can lead to aliasing errors

Area Averaging

A better but slower option is to use area averaging


OpenGL Texture Mapping Basic Stragegy

Three steps to applying a texture

1. specify the texture
2. assign texture coordinates to vertices
3. specify texture parameters


Texture Mapping


Texture Example

The texture (on right) is a 256 x 256 image that has been mapped to a rectangular polygon which is viewed in perspective.

Texture Mapping and the OpenGL Pipeline

Images and geometry flow through separate pipelines that join at the rasterizer, thus “complex” textures do not affect geometric complexity.


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, either by

Enable texture mapping, simply with

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 below)
components: elements per texel
w, h: width and height of texels in pixels
border: used for smoothing (discussed elsewhere)
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);

 


Converting A Texture Image

OpenGL requires texture dimensions to be powers of 2 (128, 256, 512, etc.). If the dimensions of your original image are not powers of 2, you can scale the image:

 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

The image is interpolated and filtered during scaling.

 


Mapping a Texture

Based on parametric texture coordinates with glTexCoord*() specified at each vertex

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();


Interpolation

OpenGL uses interpolation to find proper texels from specified texture coordinates.

There can be distortions.

 


Texture Parameters

OpenGL has a variety of parameters that determine how texture is applied

Wrapping Mode

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

Wrapping: use s,t modulo 1 (i.e., repeat)

 

glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP )

glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT )


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

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)

 


Mipmapped Textures

Mipmapping allows for prefiltered texture maps of decreasing resolutions.

This 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( … )


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

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


Generating Texture Coordinates

OpenGL can generate texture coordinates automatically

glTexGen{ifd}[v]()

specify a plane

generation modes

GL_OBJECT_LINEAR
GL_EYE_LINEAR
GL_SPHERE_MAP (used for environmental maps)


Texture Objects

Texture is part of the OpenGL state

Recent versions of OpenGL have texture objects


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
  9. coordinates can also be generated

Other Texture Features

Environment Maps

Multitexturing