Recall: 6 Main Steps to Apply Texture

1. Create texture object2. Specify the texture

Read or generate image assign to texture (hardware) unit enable texturing (turn on)

3. Assign texture (corners) to Object corners4. Specify texture parameters wrapping, filtering

5. Pass textures to shaders 6. Apply textures in shaders

still haven’t talkedabout setting texture parameters

Recall: Step 4: Specify Texture Parameters

Texture parameters control how texture is applied Wrapping parameters used  if s,t outside (0,1) range

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

glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP )glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT )

textures

t

GL_CLAMPGL_REPEAT

Magnification and Minification

Texture PolygonMagnification Minification

PolygonTexture

Magnification: Stretch small texture to fill many pixelsMinification: Shrink large texture to fit few pixels

Step 4: Specify Texture ParametersTexture Value Lookup

(0,0)

(1,1)

(0.25,0) (0.5,0) (0.75,0) (1,0)

How about coordinates that are not exactly at the intersection (pixel) positions?

A) Nearest neighborB) Linear InterpolationC) Other filters

Example: Texture Magnification 48 x 48 image projected (stretched) onto 320 x 320 pixels

Nearest neighbor filter Cubic filter (weighted avg. 5 nearest texels)

Bilinear filter (avg 4 nearest texels)

2) Linear interpolate the neighbors(better quality, slower)

glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_LINEAR)

1) Nearest Neighbor (lower image quality)

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

Texture mapping parameters

Or GL_TEXTURE_MAX_FILTER

Dealing with Aliasing

Point sampling of texture can lead to aliasing errors

point samples in u,v (or x,y,z) space

point samples in texture space

miss blue stripes

Area AveragingBetter but slower option is area averaging

pixel

preimage

Other Stuff

Wrapping texture onto curved surfaces. E.g. cylinder, can, etc

Wrapping texture onto sphere

Bump mapping: perturb surface normal by a quantity proportional to texture 

ab

as

ab

a

zzzzt

ab

as

ab

at

Computer Graphics (CS 4731)Lecture 20: Environment Mapping 

(Reflections and Refractions)

Prof Emmanuel Agu(Adapted from slides by Ed Angel)

Computer Science Dept.Worcester Polytechnic Institute (WPI)

11

Environment Mapping

Environmental mapping is way to create the appearance of highly reflective and refractive surfaces without ray tracing

Reflecting the Environment

VN

R

VN

RSphere of environmentaround object

Cube of environmentaround object

Assumes environment infinitely far away Options: Store “object’s environment as

OpenGL supports cube maps and sphere maps

Types of Environment Maps

VN

R

b) Cube around object (cube map)a) Sphere around object (sphere map)

x

y

z

Cube mapping

Need to compute reflection vector, r Use r by for environment map lookup

neye

r

Cube Map: How to Store

Stores “environment” around objects as 6 sides of a cube (1 texture) Load 6 textures separately into 1 OpenGL cubemap

Cube Maps

Loaded cube map texture can be accessed in GLSL through cubemap sampler

vec4 texColor = textureCube(mycube, texcoord);

Texture coordinates must be 3D

18

Creating Cube Map Use 6 cameras directions from scene center each with a 90 degree angle of view

19

Indexing into Cube Map

VR

•Compute  R = 2(N∙V)N‐V

•Object at origin

•Perform lookup:

•Largest magnitude component  of R(x,y,z) used to determine face of cube

•Other 2 components give texture coordinates

More on this later….

vec4 texColor = textureCube(mycube, R);

Declaring Cube Maps in OpenGL

glTextureMap2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, level, rows, columns, border, GL_RGBA, GL_UNSIGNED_BYTE, image1)

Repeat similar for other 5 images (sides) Make 1 cubemap texture object from 6 images Parameters apply to all six images. E.gglTexParameteri( GL_TEXTURE_CUBE_MAP,

GL_TEXTURE_MAP_WRAP_S, GL_REPEAT)

Note: texture coordinates are in 3D space (s, t, r)

Cube Map Example (init)// colors for sides of cube

GLubyte red[3] = {255, 0, 0};GLubyte green[3] = {0, 255, 0};GLubyte blue[3] = {0, 0, 255};GLubyte cyan[3] = {0, 255, 255};GLubyte magenta[3] = {255, 0, 255};GLubyte yellow[3] = {255, 255, 0};

glEnable(GL_TEXTURE_CUBE_MAP);

// Create texture objectglGenTextures(1, tex);glActiveTexture(GL_TEXTURE1);glBindTexture(GL_TEXTURE_CUBE_MAP, tex[0]);

This example generates simpleColors as a texture

You can also just load6 pictures of environment

Cube Map (init II)

glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X ,0,3,1,1,0,GL_RGB,GL_UNSIGNED_BYTE, red);

glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X ,0,3,1,1,0,GL_RGB,GL_UNSIGNED_BYTE, green);

glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y ,0,3,1,1,0,GL_RGB,GL_UNSIGNED_BYTE, blue);

glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y ,0,3,1,1,0,GL_RGB,GL_UNSIGNED_BYTE, cyan);

glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z ,0,3,1,1,0,GL_RGB,GL_UNSIGNED_BYTE, magenta);

glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z ,0,3,1,1,0,GL_RGB,GL_UNSIGNED_BYTE, yellow);

glTexParameteri(GL_TEXTURE_CUBE_MAP,GL_TEXTURE_MAG_FILTER,GL_NEAREST);

Load 6 different pictures into1 cube map of environment

Cube Map (init III)

GLuint texMapLocation;GLuint tex[1];

texMapLocation = glGetUniformLocation(program, "texMap"); glUniform1i(texMapLocation, tex[0]);

Connect texture map (tex[0]) to variable texMap in fragment shader(texture mapping done in frag shader)

Adding Normals

void quad(int a, int b, int c, int d){

static int i =0;

normal = normalize(cross(vertices[b] - vertices[a],vertices[c] - vertices[b]));

normals[i] = normal;points[i] = vertices[a];i++;

// rest of data

Calculate and set quad normals

Vertex Shader

25

out vec3 R;in vec4 vPosition;in vec4 Normal;uniform mat4 ModelView;uniform mat4 Projection;

void main() {gl_Position = Projection*ModelView*vPosition;vec4 eyePos = vPosition; // calculate view vector Vvec4 NN = ModelView*Normal; // transform normalvec3 N =normalize(NN.xyz); // normalize normalR = reflect(eyePos.xyz, N); // calculate reflection vector R

}

Fragment Shader

in vec3 R;uniform samplerCube texMap;

void main(){

vec4 texColor = textureCube(texMap, R); // look up texture map using R

gl_FragColor = texColor;}

Refraction using Cube Map

Can also use cube map for refraction (transparent)

Reflection Refraction

Reflection vs Refraction

Reflection Refraction

Reflection and Refraction At each vertex

Refracted component IT is along transmitted direction t

tranreflspecdiffamb IIIIII

Ph

v

r m

s

dir

t

IR

IT

I

Finding Transmitted (Refracted) Direction

Transmitted direction obeys Snell’s law Snell’s law: relationship holds in diagram below

Ph

m

t

1

1

2

2 )sin()sin(cc

faster

slower2

1

c1, c2 are speeds of light in medium 1 and 2

Finding Transmitted Direction If ray goes from faster to slower medium (e.g. air to 

glass), ray is bent towards normal If ray goes from slower to faster medium (e.g. glass to 

air), ray is bent away from normal c1/c2 is important. Usually measured for medium‐to‐

vacuum. E.g water to vacuum Some measured relative c1/c2 are: Air: 99.97% Glass: 52.2% to 59% Water: 75.19% Sapphire: 56.50% Diamond: 41.33%

Transmission Angle

Vector for transmission angle can be found as

Ph

m

t

mdirmdirt

)cos()( 2

1

2

1

2 cc

cc

Medium #1

Medium #22

1

wheredir

c2

c1 2

1

22 )(11)cos( dirm

cc

Or just use GLSL built‐in function refract to get T

Refraction Vertex Shaderout vec3 T;in vec4 vPosition;in vec4 Normal;uniform mat4 ModelView;uniform mat4 Projection;

void main() {gl_Position = Projection*ModelView*vPosition;vec4 eyePos = vPosition; // calculate view vector Vvec4 NN = ModelView*Normal; // transform normalvec3 N =normalize(NN.xyz); // normalize normalT = refract(eyePos.xyz, N, iorefr); // calculate refracted vector T

}

Was previously    R = reflect(eyePos.xyz, N);

Refraction Fragment Shader

in vec3 T;uniform samplerCube RefMap;

void main(){

vec4 refractColor = textureCube(RefMap, T); // look up texture map using Trefractcolor = mix(refractColor, WHITE, 0.3); // mix pure color with 0.3 white

gl_FragColor = refractcolor;}

References

Interactive Computer Graphics (6th edition), Angel and Shreiner

Computer Graphics using OpenGL (3rd edition), Hill and Kelley

Real Time Rendering by Akenine‐Moller, Haines and Hoffman