Texture

1
Texture

• Motivation to model realistic objects need
  surface detail wood grain, stone roughness,
  scratches that affect shininess, grass, wall
  paper.
• Use geometry, model surface detail with polygons
  good for large scale detail, too expensive
  otherwise.
• Improvement map an image of the details onto
  simple geometry

2
The wall
3
The wall
4
The Wall Brick
5
The Wall Checkers
6
Texture Mapping
screen
geometry
image
Ed Angel
7
Texture Mapping and the OpenGL Pipeline

• Images and geometry flow through separate
  pipelines that join at the rasterizer
• complex textures do not affect geometric
  complexity

Ed Angel
8
Texture mapping

• Texture mapping adding surface detail by mapping
  texture patterns to the surface
• Technique developed by Catmull (1974), Blinn and
  Newell (1976).

9
Texture mapping methods

• 2D texture mapping paint 2D pattern onto the
  surface
• Environmental (reflection) mapping
• Bump mapping perturb surface normals to fool
  shading algorithms
• Procedural texture mapping, 3D texture

10
More Examples
Jim Blinn
11
Environment Mapping
Yoshihiro Mizutani and Kurt Reindel
12
2D texture mapping overview

• Texture array is a 2D image pattern
• With elements texels
• Value at a texel affects surface appearance
• The texture map determines how the pattern
  lies on the surface

13
2D texture mapping overview

• Rendering uses the texture mapping
• Find surface that is front most at current pixel
• Find the the surface patch corresponding to the
  pixel
• Find the part of the texture pattern
  corresponding to the surface patch
• Use that part of the texture pattern in setting
  the pixel color

14
(No Transcript)
15
2D texture mapping

• Source 2D pattern from drawing, photo, procedure
• Destination any surface, easier if surface given
  in parametric form
• The map from 2D texture coord to 3D object
• Texture mapping transformation 2D screen coord ?
  3D object coord ? 2D texture coord and back (see
  previous slide)

16
Mapping the 2D texture to the surface

• The map 2D texture(s,t) ? 3D object(x,y,z)
• Mapping onto triangle is not difficult
• Mapping onto triangular mesh is more difficult
  (have to handle texture discontinuity)
• Mapping onto parametric surface is easier
• Alternative use an intermediate parametric
  surface (cylinder, sphere)

17
Mapping aTexture

• 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
(0.4, 0.2)
c
b
B
C
(0.8, 0.4)
s
0, 0
1, 0
18
Mapping texture onto parametric surface

• Point on the parametric surface

19
Mapping texture onto parametric surface using
liner map

• The map from texture to the parametric coord
  using invertible linear map between the texture
  space (s,t) and the domain (u,v)

20
Mapping texture onto parametric surface, example
Does not take into account curvature of
surface Equal size texture patches are stretched
to fit various areas
21
Mapping texture to a surface using an
intermediate surface

• Two-step mapping
• Map the texture to a simple intermediate surface
  (sphere, cylinder, cube)
• Map the intermediate surface (with the texture)
  onto the surface being rendered

22
Two-step mapping example

• parametric form cylinder x r cos(2 PI u)
• y r
  sin(2 PI u)
• z v h
• 0ltu,vlt1
• first step u s, v t
• sphere
• cube

23
Two-step mapping example

• Second-step map intermediate surface to the
• surface being rendered
• Various strategies a, b, c

24
The texture mapping transformation
25
Texture mapping transformation

• Consider surface visible at current pixel.
• Find the patch on the surface that corresponds to
  it.
• Map screen coord of pixel corners back to object
• Find texels that map to the surface patch
• If multiple texels lie on patch combine them
• weighted avg supersampling with
  postfiltering

26
2DTexture mapping in OpenGL

• Pixel pipeline
• Texture map done at rasterization stage

27
Texture Mapping in OpenGL

• Get hold of texture array
• Create texture object (TO) and specify texture
  for it
• TO maintains the texture
• May have multiple TOs
• Specify mode for applying texture to pixels
• possibilities for computing final using texture
• Replace (use the texture to paint) only texture
• Modulate (use the texture to modulate/scale the
  color) lighting and texture
• Constant RGB color blended in based on texture
• Enable texture mapping
• Must enable before drawing
• Draw the scene providing both texture and
  geometric coordinates
• Texture coordinates specify how the texture
  should be aligned on the fragments to which it is
  applied
• Indicate how out of range TC should be processed
• Does texture repeat to cover object or is it
  clamped to the vertices

28
Example Texture mapping initialization
GLuint texName void init(void) load
or create an image and store it in array, say
image, of wize wxh, and type gl_type
glGenTextures(1,texName) glBindTexture(GL_TEX
TURE_2D, texName) glTexParameteri(GL_TEXTURE_
2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
GL_REPEAT) glTexParameteri(GL_TEXTURE_2D,
GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILT
ER, GL_NEAREST) glTexImage2D(GL_TEXTURE_2D,
0, GL_RGBA, GL_UNSIGNED_BYTE, w,h,
0, GL_RGBA, gl_type, image)
Name and create texture object for texture
image Names and makes texture currently available
Texture map parameters how texture to be wrapped
and colors filtered if mismatch b/w texels and
pixels
Texture map specification load the image and set
parameters
29
Set the drawing mode here the texture will
replace, the polygons are drawn using only the
color from the texture
void display(void) glClear color bufer and
depth buffer bits glEnable(GL_TEXTURE_2D)
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,
GL_REPLACE) glBindTexture(GL_TEXTURE_2D,
texName) glBegin(GL_QUAD)
glTexCoord2f(0.0,0.0) glVertex3f(x1,y1,z1)
glTexCoord2f(1.0,0.0)
glVertex3f(x2,y2,z2) glTexCoord2f(1.0,1.0)
glVertex3f(x3,y3,z3)
glTexCoord2f(0.0,1.0) glVertex3f(x4,y4,z4)
glEnd() glFlush() glDisable(GL_TEXTURE_2
D)
Turn on texturing
Bind previously created texture object to use it
currently (activate it)
30
Create texture object and texture for it

• Texel values could be up to 4D (R,G,B,A)
• Texturing is expensive. Texture objects similar
  to display lists faster to bind(reuse) stored
  texture than load with glTexImageD( )

31
Using texture objects

• Create texture names, glGenTextures( )
• Returns available ids in second parameter which
  is passed by reference
• GLuint texName
• glGenTextures(1, texName)
• Create and use texture objects
  glBindTexture(GL_TEXTURE_2D, texName)
• When first use new texture object is created and
  assigned the name subsequent uses activate the
  texture object

32
Using texture objects

• glBindTexture(),
• sets texture state, subsequent calls to
  glTexImage, glTexParameters,etc., store data in
  the active texture object
• The data may include texture image (mipmaps),
  width, height,border, internal format, texture
  properties (minmag filters, wrapping modes,)

33
2D texture mapping in OpenGL

• Provide texture array that holds the 2D texture
  pattern
• Glubyte my_texels5125123
• Fill the array either
• Generated by program or
• Read from image file
• Typically we keep multiple arrays with different
  texture patterns
• Set the parameters for the texture map
  (glTexParameteri) to be used with glTexImage2D
  set up
• Specify texture map which texture array to use
  currently as 2D texture and set properties with
  glTexImage( )
• The texture map will be stored in
• texture memory
• level and border give fine control
• glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, 512, 512,
  0, GL_RGB, GL_UNSIGNED_BYTE, my_texels)

tex im size border
power of 2b
Level (of mipmap)
Which of the R,G,B,A components or intensity are
selected for use .
34
2D texture mapping in OpenGL

• Enable texture mapping
• glEnable(GL_TEXTURE_2D)
• glTexImage2D, specifies what texture image to
  use and sets some parameters and formats
• glTexCoord2, specifies how the map will be
  applied.
• map from texture array to object.
• Texture coordinates s and t are between 0 and 1
  (inclusive)
• Texture coordinates to vertices by the
  application program
• Directly, using glTexCoord2f(s, t) per vertex
• Automaticly, using glTexGen

35
Mapping texture coordinates to object
Example map the array to polygon

• glBegin(GL_QUADS)
• glTexCoord2f(0.0,0.0)
• glVertex3f(x1,y1,z1)
• glTexCoord2f(1.0,0.0)
• glVertex3f(x2,y2,z2)
• glTexCoord2f(1.0,1.0)
• glVertex3f(x3,y3,z3)
• glTexCoord2f(0.0,1.0)
• glVertex3f(x4,y4,z4)
• glEnd()

• Specify texture map at vertices,
• texture map for the interior is
• interpolated
• Need to take special care
• How to distribute the texture pattern
• onto the object
• What to do if texture coordinates get out of
  range
• How to sample the texture (pick up the texel
  values)

36
OpenGL texture parameters

• How to deal with values of texture coordintes
  out of range
• glTexParameterf(GL_TEXTURE_WRAP_S, GL_REPEAT)
• glTexParameterf(GL_TEXTURE_WRAP_T, GL_REPEAT)
• or GL_CLAMP
• Dealing with the texture sampling
• The texture coordinates for interior polygon
  points are interpolated from the texture
  coordinates of the vertices, they are real
  valued, but the texture array has discrete
  elements with integer coordinates
• A pixel is mapped onto a curveliner patch of the
  texture pattern and one texture value per pixel
  has to be computed from all texels that overlap
  with the patch
• Mismatch between texel-pixel sizes
• The question is how to compute the texture value
  per pixel
• Point sampling use the nearest texel. Prone to
  aliasing effects.
• Linear filtering use weighted average of all
  textels overlapping with the patch
• Because the pixel and texel arrays are both
  finite, and the texture map is real-valued there
  is also the issue of mismatch between the
  corresponding texel and pixel areas correponding
  to each other according to the texture map

37
OpenGL texture parameters

• How to deal with values of texture coordinates
  out of range
• glTexParameterf(GL_TEXTURE_WRAP_S, GL_REPEAT)
• glTexParameterf(GL_TEXTURE_WRAP_T, GL_REPEAT)
• or GL_CLAMP
• Dealing with the texture sampling
• The texture coordinates for interior polygon
  points are interpolated from the texture
  coordinates of the vertices, they are real
  valued, but the texture array has discrete
  elements with integer coordinates
• A pixel is mapped onto a curveliner patch of the
  texture pattern and one texture value per pixel
  has to be computed from all texels that overlap
  with the patch
• Mismatch between texel-pixel sizes

Minification
Magnification
38
OpenGL texture parameters

• In OpenGL the parameters handling the texture
  sampling issues are
• GL_TEXTURE_MIN_FILTER
• GL_TEXTURE_MAG_FILTER
• Their values are
• GL_NEAREST (for point sampling)
• GL_LINEAR for linear filtering (weighted avg)
• The parameter values are assigned with
  glTexParameterf
• glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILT
  ER, GL_NEAREST)
• glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILT
  ER, GL_NEAREST)
• or GL_LINEAR (deals better with aliasing)

39
OpenGL texture parameters

• Mipmapping another approach to deal with the
  mismatch in pixel/texel size and aliasing
• A sequence of texture arrays at different
  resolutions is kept (full resolution, half, ¼
  , etc)
• glBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB, mipmapw,
  mipmaph, GL_RGB, GL_INSIGNED_BYTE, my_texels)
• Mipmaps are set
• dierectly, using the level parameter in
  glTexImage2D
• Level 0 is full resolution
• glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, 512, 512,
  0, GL_RGB, GL_UNSIGNED_BYTE, my_texels)
• Or automaticly, using glTexParametri
• glTexParametri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTE
  R, GL_NEAREST_MIPMAP_NEAREST)
• Or GL_NEAREST_MIPMAP_LINEAR

40
OpenGL texture parameters

• Interaction between texturing and shading
• glTexEnvi(GL_TEX_ENV_MODE, GL_MODULATE)
• or GL_DECAL
• Dealing with aliasing issues related to the
  perspective projection foreshothening
• glHINT(GL_PERSPECTIVE_CORRECTION, GL_NICEST)

41
Environment Mapping
Yoshihiro Mizutani and Kurt Reindel
42
Environment Mapping II

• Put texture on a highly reflective object by
  picking up texture from the environment in which
  the object is immersed.
• Realized as two-step process
• Project the environment (excluding the object)
  onto an intermediate surface.
• Place object back, and map texture from
  intermediate surface to object

43
Environment Mapping III methods

• Sphere mapping
• Supported directly by OpenGL
• Cube mapping
• Supported by the NV GeForce 256 GPU
• OpenGL extension EXT_texture_cube

44
Sphere Mapping

• Blinn and Newells method for each environment
  mapped pixel compute the (viewer) reflection
  vector

NV Technical Brief Perfecct reflections and
Specular .
45
Blinn-Newell problems

• Borders
• Singularities at the poles (convergence)

46
Cubic mapping

• Intrtoduced by Greene in 1986.
• O mapping put a camera in the environment center
  and then project the environment onto the sides
  of a cube centered at the camera position.
  Amounts to six scene renderings.
• More uniform sampling then B-N
• The normalized reflection vector determines which
  face to use for texturing.
• The reflection vector component with larges abs
  value determines the side e.g. -0.2,0.5,-0.84
  selects the Z face

47
Bump mapping

• 2D Texture map creates odd looking rough surfaces
• Bump mapping texture map that alters surface
  normals.
• Use texture array to set a function which
  perturbs surface normals
• Altered normals match a bumpy surface
• Applying illumination model to the new normals
  shades the bumps correctly

48
Bump mapping

• Bump map is in texture array d(s,t) ltlt 1
• p point on the surface corresponding to texture
  
• coordinates s,t.
• N the normal at p
• p the bump point for p
• p p d(s,t)N
• We actually do not bump the surface, just the
• normal at p.
• N the normal at p . This normal used by the
• illumination model at p.

49
Bump mapping

• How to get N
• given two vectors tangent to the bumpy
• surface, N is their cross product
• The two vectors follow from the partial
• derivatives of the p equation wrt u,v
• p p d(s,t)N
• These partial derivatives expressed in terms of
  the derivatives of d(s,t) as s,t change