1. Hofstra University1 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. Hofstra University2 The wall

3. Hofstra University3 The wall

4. Hofstra University4 The Wall: Brick

5. Hofstra University5 The Wall: Checkers

6. Hofstra University6 Texture Mapping s t x y z image geometry screen Ed Angel

7. Hofstra University7 Texture Mapping and the OpenGL Pipeline geometry pipeline vertices pixel pipeline image rasterizer Images and geometry flow through separate pipelines that join at the rasterizer “complex” textures do not affect geometric complexity Ed Angel

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

9. Hofstra University9 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. Hofstra University10 More Examples Jim Blinn

11. Hofstra University11 Environment Mapping Yoshihiro Mizutani and Kurt Reindel

12. Hofstra University12 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. Hofstra University13 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. Hofstra University14

15. Hofstra University15 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. Hofstra University16 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. Hofstra University17 Based on parametric texture coordinates glTexCoord*() specified at each vertex s t 1, 1 0, 1 0, 01, 0 (s, t) = (0.2, 0.8) (0.4, 0.2) (0.8, 0.4) A BC a b c Texture SpaceObject Space Mapping a Texture

18. Hofstra University18 Mapping texture onto parametric surface Point on the parametric surface

19. Hofstra University19 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. Hofstra University20 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. Hofstra University21 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. Hofstra University22 Two-step mapping example parametric form cylinder: x = r cos(2 PI u) y = r sin(2 PI u) z = v h 0<=u,v<=1 first step: u = s, v = t sphere cube

23. Hofstra University23 Two-step mapping example Second-step: map intermediate surface to the surface being rendered Various strategies: a, b, c

24. Hofstra University24 The texture mapping transformation

25. Hofstra University25 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. Hofstra University26 2DTexture mapping in OpenGL Pixel pipeline Texture map done at rasterization stage

27. Hofstra University27 Texture Mapping in OpenGL 1. Get hold of texture array 2. Create texture object (TO) and specify texture for it TO maintains the texture May have multiple TOs 3. 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 4. Enable texture mapping Must enable before drawing 5. 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. Hofstra University28 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_TEXTURE_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_FILTER, GL_NEAREST); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, w,h, 0, GL_RGBA, gl_type, image); } Example: Texture mapping initialization Name and create texture object for texture image Names and makes texture currently available Texture map specification: load the image and set parameters Texture map parameters: how texture to be wrapped and colors filtered if mismatch b/w texels and pixels

29. Hofstra University29 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_2D); } Turn on texturing Set the drawing mode: here the texture will “ replace”, the polygons are drawn using only the color from the texture Bind previously created texture object to use it currently (activate it)

30. Hofstra University30 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 glTexImage*D( )

31. Hofstra University31 Using texture objects Create texture names, glGenTextures( ) Returns available id’s 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. Hofstra University32 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. Hofstra University33 2D texture mapping in OpenGL 1. Provide texture array that holds the 2D texture pattern Glubyte my_texels[512][512][3]; Fill the array either Generated by program or Read from image file Typically we keep multiple arrays with different texture patterns 2. Set the parameters for the texture map (glTexParameteri) to be used with glTexImage2D set up 3. 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 2+b Which of the R,G,B,A components or intensity are selected for use. Level (of mipmap)

34. Hofstra University34 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. Hofstra University35 Mapping texture coordinates to object 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(); Example: map the array to polygon 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. Hofstra University36 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. Hofstra University37 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 Magnification Minification

38. Hofstra University38 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_FILTER, GL_NEAREST); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); or GL_LINEAR (deals better with aliasing)

39. Hofstra University39 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_FILTER, GL_NEAREST_MIPMAP_NEAREST) Or GL_NEAREST_MIPMAP_LINEAR

40. Hofstra University40 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. Hofstra University41 Environment Mapping Yoshihiro Mizutani and Kurt Reindel

42. Hofstra University42 Environment Mapping II highly reflective 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. Hofstra University43 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. Hofstra University44 Sphere Mapping Blinn and Newell’s method: for each environment mapped pixel compute the (viewer) reflection vector NV: Technical Brief: Perfecct reflections and Specular ….

45. Hofstra University45 Blinn-Newell: problems Borders Singularities at the poles (convergence)

46. Hofstra University46 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. Hofstra University47 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. Hofstra University48 Bump mapping Bump map is in texture array: d(s,t) << 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. Hofstra University49 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