# Texture maps

Document Sample

```					Introduction to Computer Graphics
Texture Maps
Texture Mapping
Limited ability to generate complex surfaces with
geometry
Images can convey the illusion of geometry
Images painted onto
polygons is called texture
mapping
Texture Maps
Chapter 9 of Open GL Programming Guide (Red
Book)
Images applied to polygons to enhance the visual
effect of a scene
• Rectangular arrays of data
– Color, luminance, alpha
– Components of array called texels
 We’ve also had volumetric voxels
Texture Mapping
Texture map is an image, two-dimensional array of color
values (texels)
Texels are specified by texture’s (u,v) space
At each screen pixel, texel can be used to substitute a
polygon’s surface property (color)
We must map (u,v) space to polygon’s (s, t) space
V                       T

U                   S
Texture Mapping
(u,v) to (s,t) mapping can be explicitly set at
vertices by storing texture coordinates with
each vertex
How do we compute (u,v) to (s,t) mapping for
points in between
• Watch for aliasing
• Watch for many to one mappings
• Watch for perspective foreshortening effects and linear
interpolation
Example Texture Map

Applied to tilted polygon
Example Texture Map

glVertex3d (s, s, s)
glTexCoord2d(1,1);

glVertex3d (-s, -s, -s)
glTexCoord2d(1,1);
Example Texture Map

glVertex3d (s, s, s)
glTexCoord2d(5, 5);

glVertex3d (s, s, s)
glTexCoord2d(1, 1);
Texture Coordinates
Every polygon has object coordinates and texture
coordinates
• Object coordinates describe where polygon vertices are on
the screen
• Texture coordinates describe texel coordinates of each
vertex (usually 0 -> 1)
• Texture coordinates are interpolated along vertex-vertex
edges
glTexCoord{1234}{sifd}(TYPE coords)
Textures
Texture Object
• An OpenGL data type that keeps textures resident in memory and
provides identifiers to easily access them
• Provides efficiency gains over having to repeatedly load and reload a
texture
• You can prioritize textures to keep in memory
• OpenGL uses least recently used (LRU) if no priority is assigned
Example use of Texture
Read .bmp from file
• Use Image data type
– getc() and fseek() to read image x & y size
– fread() fills the Image->data memory with actual
red/green/blue values from .bmp

• Note
– malloc() Image->data to appropriate size
– .bmp stores color in bgr order and we convert to rgb order
Step 2 – create Texture Objects

glGenTextures(1, &texture[texture_num]);

• First argument tells GL how many Texture Objects to
create
• Second argument is a pointer to the place where
OpenGL will store the names (unsigned integers) of the
Texture Objects it creates
– texture[] is of type GLuint
Step 3 – Specify which texture
object is about to be defined
Tell OpenGL that you are going to define the
specifics of the Texture Object it created
• glBindTexture(GL_TEXTURE_2D, texture[texture_num]);

– Textures can be 1D and 3D as well
Step 4 – Begin defining texture
glTexParameter()
• Sets various parameters that control how a texture is treated as it’s
applied to a fragment or stored in a texture object
• // scale linearly when image bigger than texture
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER
,GL_LINEAR);
• // scale linearly when image smaller than texture
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER
,GL_LINEAR);
Step 5 – Assign image data
• glTexImage2D();
GL_TEXTURE_2D      (2D Texture)
0                  (level of detail 0)
3                  (3 components, RGB)
image1->sizeX      (size)
image1->sizeY      (size)
0                  (no border pixel)
GL_RGB             (RGB color order)
GL_UNSIGNED_BYTE   (unsigned byte data)
image1->data       (pointer to the data))
glTexImage2D – Arg 1
GLenum target
• GL_TEXTURE_2D
• GL_PROXY_TEXTURE_2D
– Provides queries for texture resources
– Proceed with hypothetical texture use (GL won’t apply
the texture)
– After query, call GLGetTexLevelParamter to verify
presence of required system components
– Doesn’t check possibility of multiple texture interference
glTexImage2D – Arg 2
GLint level
• Used for Level of Detail (LOD)
• LOD stores multiple versions of texture that can be used at
runtime (set of sizes)
• Runtime algorithms select appropriate version of texture
– Pixel size of polygon used to select best texture
– Eliminates need for error-prone filtering algorithms
glTexImage2D – Arg 3
GLint internalFormat
• Describes which of R, G, B, and A are used in internal
representation of texels
• Provides control over things texture can do
– High bit depth alpha blending
– High bit depth intensity mapping
– General purpose RGB
• GL doesn’t guarantee all options are available on given
hardware
glTexImage2D – Args 4-6
GLsizei width
GLsizei height
• Dimensions of texture image
– Must be 2m + 2b (b=0 or 1 depending on border)
– min, 64 x 64
GLint border
• Width of border (1 or 0)
– Border allows linear blending between overlapping textures
– Useful when manually tiling textures
glTexImage2D – Args 7 & 8
GLenum format
• Describe how texture data is stored in input array
– GL_RGB, GL_RGBA, GL_BLUE…
GLenum type
• Data size of array components
– GL_SHORT, GL_BYTE, GL_INT…
glTexImage2D – Arg 9
Const GLvoid *texels
• Pointer to data describing texture map
Step 6 – Apply texture
Before defining geometry
• glEnable(GL_TEXTURE_2D);
• glBindTexture(GL_TEXTURE_2D, texture[0]);
• glTexEnvf(GL_TEXTURE_ENV,
GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexEnv()

First argument to function is always GL_TEXTURE_ENV

GL_TEXTURE_ENV_MODE                    GL_DECAL

GL_REPLACE

GL_MODULATE

GL_BLEND

If GL_BLEND selected, second call to   4-float array for R,G,B,A
glTexEnv() must specify                blend
GL_TEXTURE_ENV_COLOR
gluScaleImage()
Alters the size of an image to meet the 2m size
requirement of OpenGL
• Scaling performed by linear and box filtering
glCopyTexImage2D()

Use current frame buffer contents as texture
Copy frame buffer to named texture location
glTexSubImage2D()
Replace a region of current working texture with a
smaller texture
SubImage need not adhere to 2m size limitation
This is how you add data from your system’s
camera to GL environment
glCopyTexSubImage2D
• Frame buffer cut and paste possible too
Bump Mapping
Use textures to modify surface geometry
Use texel values to modify surface normals of
polygon
Texel values correspond to height field
• Height field models a rough surface
Partial derivative of bump map specifies change
to surface normal
Bump Mapping
Displacement Mapping
Bump mapped normals are inconsistent with actual
geometry. Problems arise (shadows).
Displacement mapping actually affects the surface
geometry
Mipmaps
multum in parvo -- many things in a small place
A texture LOD technique
Prespecify a series of prefiltered texture maps of
decreasing resolutions
Requires more texture storage
Eliminates shimmering and flashing as objects
move
MIPMAPS
With versus without MIPMAP
MIPMAPS
Arrange different versions into one block of
memory
gluBuild2DMipmaps
Automatically constructs a family of textures from
original texture size down to 1x1
Advanced Mipmaps

You can specify additional mipmap levels on
the fly
• MIN_LOD may reduce popping
• MAX_LOD may reduce over compression
You can specify min mipmap level
• Useful for mosaicing (Alphabet on a texture)
Filtering
OpenGL tries to pick best mipmap level
Question: Which texel corresponds to a particular pixel?
GL_NEAREST (Point Sampling)
• Pick the texel with center nearest pixel
GL_LINEAR (Bilinear Sampling)
• Weighted average of 2x2 closest texels
GL_NEAREST_MIPMAP_LINEAR
• Average nearest texels from two mipmap levels
GL_LINEAR_MIPMAP_LINEAR (Trilinear)
• Average two averaged texels from two mipmaps

```
DOCUMENT INFO
Shared By:
Categories:
Stats:
 views: 7 posted: 1/26/2011 language: English pages: 35
Description: computer graphics and its applications
About if any file u wil find copyright contact me it will be remove in 3 to 4 buisnees days. add me on sanjaydudeja007@gmail.com or visit http://www.ohotech.com/