2002 by Jim X. Chen: 1 Texture Lab At each rendered pixel, selected texels are used either to substitute for or to scale.

Slides:



Advertisements
Similar presentations
Hofstra University1 Texture Motivation: to model realistic objects need surface detail: wood grain, stone roughness, scratches that affect shininess, grass,
Advertisements

TEXTURE MAPPING JEFF CHASTINE 1. TEXTURE MAPPING Applying an image (or a texture ) to geometry 2D images (rectangular) 3D images (volumetric – such as.
OpenGL Texture Mapping
Texture Mapping. Typical application: mapping images on geometry 3D geometry (quads mesh) + RGB texture 2D (color-map) =
Texture Mapping OpenGl and Implementation Details CS
Texture Mapping CPSC /24/03 Abhijeet Ghosh.
CSC345: Advanced Graphics & Virtual Environments
OpenGL Texture Mapping
OpenGL Texture Mapping Ed Angel Professor of Computer Science, Electrical and Computer Engineering, and Media Arts University of New Mexico.
1 Lecture 12 Texture Mapping uploading of the texture to the video memory the application of the texture onto geometry.
OpenGL Texture Mapping April 16, Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002 Basic Stragegy Three steps to applying a texture.
CS 4731: Computer Graphics Lecture 17: Texturing Emmanuel Agu.
Texture Mapping A way of adding surface details Two ways can achieve the goal:  Surface detail polygons: create extra polygons to model object details.
Texture Mapping. To add surface details… World of Warcraft, Blizzard Inc. More polygons (slow and hard to handle small details) Less polygons but with.
Computer Graphics Texture Mapping Eriq Muhammad Adams
Introduction to Texture Mapping CSE 470/598 Introduction to Computer Graphics Arizona State University Dianne Hansford.
1 Introduction to Computer Graphics with WebGL Ed Angel Professor Emeritus of Computer Science Founding Director, Arts, Research, Technology and Science.
Texture Mapping + Texture Object = Texture Mapped Object.
2IV60 Computer Graphics set 10: Texture mapping Jack van Wijk TU/e.
Texture Mapping. Scope Buffers Buffers Various of graphics image Various of graphics image Texture mapping Texture mapping.
Texture Mapping. Example Mappings Mapping Techniques Consider the problem of rendering a sphere in the examples The geometry is very simple - a sphere.
Texture Mapping Course: Computer Graphics Presented by Fan Chen
Computer Graphics Ben-Gurion University of the Negev Fall 2012.
Mapping method Texture Mapping Environmental mapping (sphere mapping) (cube mapping)
An Interactive Introduction to OpenGL Programming Ed Angel
ECSE-4750 Computer Graphics Fall 2004 Prof. Michael Wozny TA. Abhishek Gattani TA. Stephen
Imaging and Raster Primitives Vicki Shreiner. 2 Jobs Andrew Giles Andrew Giles Chuck Fultz Chuck Fultz SIGGraph - SIGGraph.
CS380 LAB IV OpenGL Jonghyeob Lee Reference1. [OpenGL course slides by Rasmus Stenholt] Reference2. [
Texture Mapping Fall, Textures Describe color variation in interior of 3D polygon  When scan converting a polygon, vary pixel colors according.
Lecture 27: Texture Mapping Li Zhang Spring 2008
And Some Extra Information From
Texture Mapping. 2 Motivation A typical modern graphics card can handle 10s of millions of polygons a second. How many individual blades of grass are.
OpenGL Texture Mapping. 2 Objectives Introduce the OpenGL texture functions and options.
Texture Mapping Angel Angel: Interactive Computer Graphics5E © Addison-Wesley
CS 480/680 Computer Graphics OpenGL Texture Mapping Dr. Frederick C Harris, Jr. Fall 2011.
Texture Mapping Software College, Shandong University Instructor: Zhou Yuanfeng
Texture Mapping in OpenGL. Texture Mapping Imaging we are “pasting” a picture onto a model  Which part of the picture will be pasted onto which part.
Texture Mapping Drawing Pictures on Polygons. Texture Mapping.
111/17/ :24 UML Solution Involves Selection of Discrete Representation Values.
2 COEN Computer Graphics I Evening’s Goals n Discuss displaying and reading image primitives n Describe texture mapping n Discuss OpenGL modes and.
Texture Mapping. 2 3 Loading Textures void glTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border,
1 Introduction to Computer Graphics with WebGL Ed Angel Professor Emeritus of Computer Science Founding Director, Arts, Research, Technology and Science.
OpenGL Programming Guide : Texture Mapping Yoo jin wook Korea Univ. Computer Graphics Lab.
Texture Mapping. checker.c Texture-Mapped Squares.
Computer Graphics Bing-Yu Chen National Taiwan University.
1 Graphics CSCI 343, Fall 2015 Lecture 25 Texture Mapping.
Texture Mapping and NURBS Week 7 David Breen Department of Computer Science Drexel University Based on material from Ed Angel, University of New Mexico.
Details of Texture Mapping Glenn G. Chappell U. of Alaska Fairbanks CS 381 Lecture Notes Monday, December 1, 2003.
第三课. Overview of this Section Concept of Texture Mapping ( 纹理映射 ) 2D Texture 3D Texture Environment Mapping Bump Mapping Others OpenGL Implementation.
1 Chapter 7 Texture Mapping. 2 The Limits of Geometric Modeling Although graphics cards can render over 10 million polygons per second, that number is.
CS425 © 2003 Ray S. Babcock Pixels and Bitmaps ● OpenGL allows us to work directly with bits and groups of bits, or pixels, which flow down a parallel.
Texture Mapping CEng 477 Introduction to Computer Graphics.
Texture Mapping Fall, 2016.
Texture Mapping 고려대학교 컴퓨터 그래픽스 연구실 kucg.korea.ac.kr.
OpenGL Texture Mapping
Angel: Interactive Computer Graphics5E © Addison-Wesley 2009
Advanced Graphics Algorithms Ying Zhu Georgia State University
Advanced Graphics Algorithms Ying Zhu Georgia State University
OpenGL Texture Mapping
Introduction to Computer Graphics with WebGL
Computer Graphics, Lee Byung-Gook, Dongseo Univ.
Chapters VIII Image Texturing
Introduction to Texture Mapping
3D Game Programming Texture Mapping
Computer Graphics Practical Lesson 6
OpenGL Texture Mapping
OpenGL Texture Mapping
Programming Textures Lecture 15 Fri, Sep 28, 2007.
3D Game Programming Texture Mapping
OpenGL Texture Mapping
Presentation transcript:

by Jim X. Chen: 1 Texture Lab At each rendered pixel, selected texels are used either to substitute for or to scale one or more of the surface’s material properties, such as its diffuse color components. One pixel is often covered by a number of texels: nearest pixel, bilinear interpolation, bi-cubic interpolation, etc.

by Jim X. Chen: 2 An Overview Steps in Texture Mapping 1) Specify the texture. (R, G, B, A, mipmapping) 2) Indicate how the texture is to be applied to each pixel. (decal, modulate, blend) 3) Enable texture mapping. (glEnable() GL_TEXTURE_1D or GL_TEXTURE_2D 4) Draw the scene, supplying both texture and geometric coordinates. Texture Lab

by Jim X. Chen: 3 Texture mapping works only in RGB mode in OpenGL Example: A Texture-Mapped Checkerboard: checker.c void makeCheckImage(void) { int i, j, c; for (i = 0; i < checkImageHeight; i++) { for (j = 0; j < checkImageWidth; j++) { c = ((((i&0x8)==0)^((j&0x8))==0))*255; checkImage[i][j][0] = (GLubyte) c; checkImage[i][j][1] = (GLubyte) c; checkImage[i][j][2] = (GLubyte) c; checkImage[i][j][3] = (GLubyte) 255; }

by Jim X. Chen: 4 void init(void){ makeCheckImage(); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 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_FILTER, GL_NEAREST); glTexImage2D(GL_TEXTURE_2D, 0, 4, checkImageWidth, checkImageHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, checkImage); }

by Jim X. Chen: 5 checker void display(void) { glEnable(GL_TEXTURE_2D); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); glBegin(GL_QUADS); glTexCoord2f(0.0, 0.0); glVertex3f(-2.0, -1.0, 0.0); glTexCoord2f(0.0, 1.0); glVertex3f(-2.0, 1.0, 0.0); glTexCoord2f(1.0, 1.0); glVertex3f(0.0, 1.0, 0.0); glTexCoord2f(1.0, 0.0); glVertex3f(0.0, -1.0, 0.0); glTexCoord2f(0.0, 0.0); glVertex3f(1.0, -1.0, 0.0); glTexCoord2f(0.0, 1.0); glVertex3f(1.0, 1.0, 0.0); glTexCoord2f(1.0, 1.0); glVertex3f( , 1.0, ); glTexCoord2f(1.0, 0.0); glVertex3f( , -1.0, ); glEnd(); glFlush(); glDisable(GL_TEXTURE_2D); }

Texture Interpolation Specify where the vertices in world space are mapped to in texture space –s = s (x, y, z) –t = t (x, y, z) –Straight lines in world space go to straight lines in texture space Texture map s t Triangle in world space

Interpolating texture coordinates to find a pixel color (x 1, y 1 ), (s 1, t 1 )(x 2, y 2 ), (s 2, t 2 ) (x 3, y 3 ), (s 3, t 3 ) Pixel color depends on texture coord. and the texels at the coord.

Pixel Calculation A pixel may cover an area of texels A texel may cover an area of pixels Many solutions –Nearest texel for the pixel –Linear interpolation of surrounding textels for the pixel (we’ll discuss this in more detail later) 2011 by Jim X. Chen:

Transform texture coordinates All the texture coordinates are multiplied by GL_TEXTURE matrix before in use To transform texture coordinates, you do: –glMatrixMode(GL_TEXTURE);

Texture Mapping Texture mapping is done as the primitives are rasterized

by Jim X. Chen: J4_6_Texture void initTexture(void) { read_stars_image(); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); // 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_FILTER, GL_NEAREST); glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, stars_pixels, stars_pixels, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, stars_image); } Texture

by Jim X. Chen: J4_6_Texture void drawTexture(float x, float y, float z) { // glRasterPos3f(x, y, z); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glEnable(GL_TEXTURE_2D); glBegin(GL_QUADS); glTexCoord2f(0.0, 0.0); glVertex3f(x, y, z); glTexCoord2f(0.0, 1.0); glVertex3f(-x, y, z); glTexCoord2f(1.0, 1.0); glVertex3f(-x, -y, z); glTexCoord2f(1.0, 0.0); glVertex3f(x, -y, z); glEnd(); glDisable(GL_TEXTURE_2D); } Texture

by Jim X. Chen: J4_6_Texture void display(void) { drawTexture(-2.4*Width, -2.4*Height, -1.9*Width); drawRobot(A, B, C, alpha, beta, gama); glutSwapBuffers(); } Texture

by Jim X. Chen: Specifying the Texture void glTexImage2D(GLenum target, GLint level, GLint components, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels); 1) The target parameter: constant GL_TEXTURE_2D. 2) The level parameter for multiple resolutions 3) Components is 1 of 38 symbolic constants. A value of 1 selects the R component, 2 selects the R and A components, 3 selects R, G, and B, and 4 selects R, B, G, and A. It indicates which values are selected for texels 4) The width and height parameters give the dimensions of the texture image. 5) The border indicates the width of the border, which is usually zero. 6) The format and type parameters describe the format and data type of the texture image data. (GL_COLOR_INDEX, GL_RGB, GL_RGBA, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA, corresponding to 3)

by Jim X. Chen: 1.The number of texels for both the width and height of a texture image, not including the optional border, must be a power of gluScaleImage() correct/alter the sizes of your textures 3. glCopyTexImage2D() creates a 2D texture using framebuffer data 1D textures and 3D textures 3D textures are used for rendering in medical and geoscience applications (CT or MRI images) void glTexImage1D() void glTexImage3D() Some Minor Things

by Jim X. Chen: Pixel and Texel Relations Corresponding vertices of texture and polygons glBegin(GL_QUADS); glTexCoord2f(0.0, 0.0); glVertex3f(x, y, z); glTexCoord2f(0.0, 1.0); glVertex3f(-x, y, z); glTexCoord2f(1.0, 1.0); glVertex3f(-x, -y, z); glTexCoord2f(1.0, 0.0); glVertex3f(x, -y, z); Antialiasing –Pre-filtering: Filter the texture down before applying it (mipmaping) –Post-filtering: Take multiple texels from the texture and filter them before applying to the polygon fragment (linear interpolation) Texel color components replace or modulate pixel color –GL_MODULATE – multiply texture and object color –GL_BLEND – linear combination of texture and object color –GL_REPLACE – use texture color to replace object color

Multiple Levels of Detail (Pre-filtering) textures that are mapped onto smaller objects might shimmer and flash as the objects move. To use mipmapping, you provide all sizes of your texture in powers of 2 between the largest size and a 1x1 map. OpenGL chooses matching size for texture mapping Mipmapping requires some extra computation and texture storage area;

by Jim X. Chen: A Mipmapping Example: J4_8_Mipmap A Mipmapping Example: mipmap.c void myinit(void) {... ; loadImages(); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glTexImage2D(GL_TEXTURE_2D, 0, 3, 32, 32, 0, GL_RGB, GL_UNSIGNED_BYTE, &mipmapImage32[0][0][0]); glTexImage2D(GL_TEXTURE_2D, 1, 3, 16, 16, 0, GL_RGB, GL_UNSIGNED_BYTE, &mipmapImage16[0][0][0]);... glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); mipmap }

Mipmap Math Define a scale factor,  = texels/pixel –It can be derived from the transformation matrices Define =log 2  tells you which mipmap level to use –Level 0 is the original texture –Level 1 is the next smallest texture, and so on –If <0, then multiple pixels map to one texel: magnification

Post-Filtering Magnification: When <0 the image pixel is smaller than the texel: –glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, type) –Type is GL_LINEAR or GL_NEAREST Minification: When >0 the image pixel is bigger than the texel: –GL_TEX_MIN_FILTER –Can choose to: Take nearest point in base texture, GL_NEAREST Linearly interpolate nearest 4 texels in base texture, GL_LINEAR Take the nearest mipmap and then take nearest or interpolate in that mipmap, GL_LINEAR_MIPMAP_NEAREST Interpolate between the two nearest mipmaps using nearest or interpolated points from each, GL_LINEAR_MIPMAP_LINEAR

by Jim X. Chen: glTexParameteri(GL_TEXTURE_2D GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D GL_TEXTURE_MIN_FILTER, GL_NEAREST); ParameterValues GL_TEXTURE_MAG_FILTERGL_NEAREST or GL_LINEAR GL_TEXTURE_MIN_FILTERGL_NEAREST, GL_LINEAR, GL_NEAREST_MIPMP_NEAREST, GL_NEAREST_MIPMP_LINEAR, GL_LINEAR_MIPMAP_NEAREST, or GL_LINEAR_MIPMAP_LINEAR

Trilinear filtering Trilinear filtering is an extension of the bilinear texture filtering method, which also performs linear interpolation between mipmaps.

Anisotropic filtering With RIP mapping (rectim in parvo) for a 256x256 image, images are also sampled to 256x128 and 32x128 etc. –These anisotropically downloadsampled images are used when the texture mapped image frequency is different for each texture axis – RIP mapping has a limitation in that it only supports anisotropic probes that are axis aligned in texture space. –This results in blurriness when the textured surface is at an oblique angle - a very common case is the floor as it recedes into the distance. Anisotropic filtering corrects this by sampling in the correct trapezoid shape according to view angle. The resulting samples are then trilinearly filtered to generate the final color.trapezoid

by Jim X. Chen: Texturing Functions void glTexEnv{if}{v}(GLenum target, GLenum pname, TYPE param); target must be GL_TEXTURE_ENV. If pname is GL_TEXTURE_ENV_MODE, param can be GL_DECAL, GL_REPLACE, GL_MODULATE, or GL_BLEND, to specify how texture values are combined with the color values of the fragment. If pname is GL_TEXTURE_ENV_COLOR, param is an array of four floating-point values representing R, G, B, and A components, used only if the GL_BLEND texture function has been specified as well. Components Decal ModeModulate ModeBlend Mode 1undefinedC = L t C f, C = (1-L t )C f + L t C c, A = A f 2undefinedC = L t C f, C = (1-L t )C f + L t C c, A = A t A f 3C = C t C = C t C f,undefined A = A f 4 C = (1-A t )C f + A t C t,C = C t C f,undefined A = A f A = A t A f Note: t -- texture, f -- fragment, c -- the values assigned with GL_TEXTURE_ENV_COLOR Texture Lab

by Jim X. Chen: Texture Objects Generate texture objects or names: glGenTextures() Initially bind texture objects to texture data, including the image arrays and texture properties: glBindTexture() More often used objects stay in memory (prioritize the objects). Bind and rebind texture objects, making their data available for rendering texture models When we call glBindTexture() with a texture name, all subsequent glTex*() commands that specify the texture and its associated parameters are saved in the memory

by Jim X. Chen: J4_7_TexObjects Texture

by Jim X. Chen: Assigning Texture Coordinates Texture coordinates can comprise one, two, three, or four coordinates. They’re usually referred to as the s, t, r, and q coordinates. For one-dimensional textures, you use the s coordinate; for two-dimensional textures, you use s and t. The q, like w, is typically given the value 1 and can be used to create homogeneous coordinates The command to specify texture coordinates, glTexCoord*(), is similar to glVertex*(), glColor*(), and glNormal*(). Usually, texture-coordinate values range between 0 and 1; values can be assigned outside this range, however, with the results described in “Repeating and Clamping Textures.” void glTexCoord{1234}{sifd}{v}(TYPEcoords); Texture Lab

by Jim X. Chen: Computing Approximate Texture Coordinates Polygon aspect ratio 3/2 (w/h); texture aspect ration 1. To avoid distorting the texture: use texture coordinates of (0,0), (1,0), (1,2/3), (0,2/3) A can with label 4 units tall and 12 units around (aspect ratio 3/1). Textures must have aspect ratio of 2 n to 1. We can copy and paste it twice to make an aspect ration of 1. Let’s approximate the can by 30 (4*12/30) polygons. We can use the following texture coordinates: –(0,0), (1/30,0), (1/30,1/3),(0,1/3) –(1/30,0), (2/30,0), (2/30,1/3),(1/30,1/3) –… –(29/30,0), (1,0), (1,1/3),(29/30,1/3) Only a few curved surfaces (cone and cylinders) can be mapped to a flat surface without geodesic distortion. For example, a sphere (cos  cos ,cos  sin ,sin  ). The  -  rectangle can be mapped directly to a rectangular texture map, but the closer you get to the poles, the more distorted the texture.

by Jim X. Chen: Repeating and Clamping Textures You can assign texture coordinates outside the range [0,1] and have them either clamp or repeat. With repeating textures, if you have a large plane with texture coordinates running from 0.0 to 10.0 in both directions, for example, you’ll get 100 copies of the texture tiled together on the screen. For most applications where the texture is to be repeated, the texels at the top of the texture should match those at the bottom, and similarly for the left and right edges. To clamp the texture coordinates: Any values greater than 1.0 are set to 1.0, and any values less than 0.0 are set to 0.0. Clamping is useful for applications where you want a single copy of the texture to appear on a large surface. If the surface-texture coordinates range from 0.0 to 10.0 in both directions, one copy of the texture appears in the lower corner of the surface. The rest of the surface is painted with the texture’s border colors as needed. Texture Lab

by Jim X. Chen: glBegin(GL_POLYGON); glTexCoord2f(0.0, 0.0); glVertex3f(-2.0, -1.0, 0.0) glTexCoord2f(0.0, 3.0); glVertex3f(-2.0, 1.0, 0.0); glTexCoord2f(3.0, 3.0); glVertex3f(0.0, 1.0, 0.0); glTexCoord2f(3.0, 0.0); glVertex3f(0.0, -1.0, 0.0); glEnd(); glBegin(GL_POLYGON); glTexCoord2f(0.0, 0.0); glVertex3f(1.0, -1.0, 0.0); glTexCoord2f(0.0, 3.0); glVertex3f(1.0, 1.0, 0.0); glTexCoord2f(3.0, 3.0); glVertex3f( , 1.0, ); glTexCoord2f(3.0, 0.0); glVertex3f( , -1.0, ); glEnd();

by Jim X. Chen: glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_S_WRAP GL_REPEAT);glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_T_WRAP GL_REPEAT); or glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_S_WRAP GL_CLAMP); glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_T_WRAP GL_CLAMP); You can also clamp in one direction and repeat in the other.

OpenGL texture mapping 1) Specify texture -read or generate image; gluScaleImage(); -Assign to texture -glTeximage2D(GL_TEXTURE_2D, 0, GL_RGB, 64, 64, 0, GL_RGB, GL_UNSIGNED_BYTE, myImage); 2) Specify texture mapping parameters -Wrapping, filtering, how to combine pixel and texel, etc. 3) Enable GL texture mapping (GL_TEXTURE_2D) 4) Assign texture coordinates to vertices 5) Transform texture coordinates 5) Draw your objects 6) Disable GL texture mapping

Put it all together … 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_FILTER, GL_NEAREST); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); … glEnable(GL_TEXTURE_2D); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 64, 64, 0, GL_RGB, GL_UNSIGNED_BYTE, mytexture); Draw_picture1(); // define texture coordinates and vertices in the function ….

by Jim X. Chen: Automatic Texture-Coordinate Generation To make contours on a 3D model to simulate reflections from an arbitrary environment on a shiny model glTexGen*(Glenum coord, Glenum pname, TYPE param); glTexGen*v(Glenum coord, Glenum pname, TYPE *param); Teapot Control Keys E, O, S, X GL_S or GL_T; coord to be auto. generated GL_TEXTURE_GEN_MODE GL_OBJECT_PLANE GL_EYE_PLANE GL_OBJECT_LINEAR, GL_EYE_LINEAR, or GL_SPHERE_MAP If eye_plane, modelview matrix may not be the same when the polygon vertices are transformed. This function establishes a field of texture coordinates that can produce dynamic contour lines on moving objects.

by Jim X. Chen: Automatic Texture-Coordinate Generation If the texture generation function is GL_OBJECT_LINEAR, the following function is used to calculate for the parameter specified. –g=p1*xo + p2*yo + p3*zo + p4*wo, where (P1, P2, P3, P4) is the plane equation, and (x0, y0, z0, w0) is the vertex for calculation. Here g stands for s or t in the texture coordinates. Teapot Control Keys E, O, S, X

Automatic Texture-Coordinate Generation 1 st : specify the texture coordinate generation functions for S and T: –glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); –glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); 2 nd : enable texture coordinate generation: –glEnable( GL_TEXTURE_GEN_S ); –glEnable( GL_TEXTURE_GEN_T ); 3 rd : generate the texture coordinates. For object or eye linear, they are based on a reference plane: –static GLfloat sgenparams[] = { 2, 0, 0, 0 }; –static GLfloat tgenparams[] = { 0, 1, 0, 0 }; –glTexGenfv( GL_S, GL_OBJECT_PLANE, sgenparams ); –glTexGenfv( GL_T, GL_OBJECT_PLANE, tgenparams );

Perspective correction Equal spacing in screen (pixel) space is not the same as in texture space in perspective projection –Perspective foreshortening from Hill courtesy of H. Pfister

Perspective-Correct Texture Coordinate Interpolation Interpolate (tex_coord and w) over the polygon, then do perspective divide after interpolation Compute at each vertex after perspective transformation –“Numerators” s/w, t/w –“Denominator” 1/w Linearly interpolate 1/w, s/w, and t/w across the polygon At each pixel  Perform perspective division of interpolated texture coordinates (s/w, t/w) by interpolated 1/w (i.e., numerator over denominator) to get (s, t)

Perspective Correction Hint Texture coordinate and color interpolation:  Linearly in screen space (wrong) OR  Persective correct interpolation (slower) glHint (GL_PERSPECTIVE_CORRECTION_HINT, hint), where hint is one of: GL_NICEST: Perspective GL_FASTEST: Linear GL_DONT_CARE: Linear