CS 4363/6353 TEXTURE MAPPING PART II. WHAT WE KNOW We can open image files for reading We can load them into texture buffers We can link that texture.

CS 4363/6353

TEXTURE MAPPING PART II

WHAT WE KNOW• We can open image files for reading

• We can load them into texture buffers

• We can link that texture buffer to a variable in the fragment shader

• We can access the texture in the fragment shader using a sampler2D

RECTANGLE TEXTURES• There’s another mode called GL_TEXTURE_RECTANGLE

• Works just like GL_TEXTURE_2D, but…

• Texture coordinate range is the width and height of the image (not normalized)

• Can’t be mipmapped

• Texture coordinates cannot repeat

• Do not support compression

• Useful for when you need to process image data (image processing), not just texture

• Typically, you create an orthographic projection with 0,0 on the bottom left

• First quadrant of the Cartesian system

OpenGL SuperBible Example

CUBE MAPPING• Used for “skyboxes”

• Used for faking reflections

• Comprised of 6 individual images

• Treated as one texture

• Can be mipmapped (glGenerateMipmap (GL_TEXTURE_CUBE_MAP))

• We’re going to have 3 texture coordinates!

• S

• T

• R

• It’s easiest to think of this as a normal because the cube “surrounds” you

Neg X

Neg Y

Neg ZPos X

Pos Y

Pos Z

OpenGL SuperBible – Chapter 7

LOADING CUBE MAPS• Create/Bind a buffer like normal

• Still load using glTexImage2D, but must pass:

• GL_TEXTURE_CUBE_MAP_POSITIVE_X

• GL_TEXTURE_CUBE_MAP_NEGATIVE_X

• GL_TEXTURE_CUBE_MAP_POSITIVE_Y

• GL_TEXTURE_CUBE_MAP_NEGATIVE_Y

• GL_TEXTURE_CUBE_MAP_POSITIVE_Z

• GL_TEXTURE_CUBE_MAP_NEGATIVE_Y

• Example:

glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGBA,w, h, 0, GL_BGR, GL_UNSIGNED_BYTE, bitmap_data);

TEXTURE PARAMETERS• Still have MAG and MIN filters, but…

• Specify it’s a GL_TEXTURE_CUBE_MAP

• Specify how to wrap each texture coordinate

• ExampleglTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);

SKYBOXES• Literally just a giant box with a texture on it

• It follows the camera!

• It doesn’t rotate with the camera

• How do we map the cube map to the cube?

• What are the texture coordinates?

SKYBOXES• Literally just a giant box with a texture on it

• It follows the camera!

• It doesn’t rotate with the camera

• How do we map the cube map to the cube?

• What are the texture coordinates? The same as their positions!

SKYBOXES• Literally just a giant box with a texture on it

• It follows the camera!

• It doesn’t rotate with the camera

• How do we map the cube map to the cube?

• What are the texture coordinates?

• How do we sample the texture in our fragment shader?

Using a sampleCube variable

// Skybox Shader by Richard S. Wright, Jr.

#version 330

in vec4 vVertex;

uniform mat4 mvpMatrix;

varying vec3 vVaryingTexCoord;

void main (void) {

vVaryingTexCoord = normalize (vVertex.xyz);

gl_Position = mvpMatrix * vVertex;

}

#version 330

out vec4 vFragColor;

uniform samplerCube cubeMap;

varying vec3 vVaryingTexCoord;

void main (void) {

vFragColor = texture (cubeMap, vVaryingTexCoord);

}

REFLECTIONS

OpenGL SuperBible – Chapter 7

// Reflection Shader – Richard S. Wright Jr.

#version 330

in vec4 vVertex;

in vec3 normal;

uniform mat4 mvpMatrix;

uniform mat4 mvMatrix;

uniform mat3 normalMatrix; // Just the rots of the mv

uniform mat4 mInverseCamera; // The camera matrix inverted

smooth out vec3 vVaryingTexCoord;

void main (void) {

// Normal in eye space – only rots

vec3 vEyeNormal = normalMatrix * vNormal;

// Vertex in eye space

vec4 vVert4 = mvMatrix * vVertex;

vec3 vEyeVertex = normalize(vVert4.xyz/vVert4.w);

// Calculate a reflection vector, then invert it

vec4 vCoords = vec4(reflect(vEyeVertex, vEyeNormal), 1.0);

vCoords = mInverseCamera * vCoords;

vVaryingTexCoord.xyz = normalize(vCoords.xyz);

gl_Position = mvpMatrix * vVertex;

}

USING MULTIPLE TEXTURES• Second texture useful for:

• Adding multiple colors together

• Using it as a bump map

• Using it as a specular map

• Using it as a transparency map

FOR COLOR ALONE

BUMP MAPPING• Used to approximate very rough surfaces

• Using the second texture to adjust the normals of the surface

• Per fragment, not per vertex

• In the case below, all N◦L is the same

BUMP MAPPING• Used to approximate very rough surfaces

• Using the second texture to adjust the normals of the surface

• Per fragment, not per vertex

• In the case below, all N◦L is not the same

• Gives off a different amount of light!

• Note – the geometry has not changed!

EXAMPLE

EXAMPLE FROM BOOK

AN EXTREME EXAMPLE

http://www.chromesphere.com/Tutorials/Vue6/Optics-Basic.html

PARALLAX MAPPING• Approximate parallax

• Changes the texture coordinate based on view vector and normal

• Need a height map

http://www.jpjorge.com/index.php?headfile=portfolio.php&topic=4

http://www.virtualworldlets.net/Resources/Hosted/Resource.php?Name=ParallaxFlash

BILLBOARDING• Image always faces the camera (think of the math!)

• Typically has transparency

• Useful for trees

• Useful for particle effects

http://www.neotos.de/en/content/megaview-jogl-opengl-java-3d-engine

POINT SPRITES• OpenGL 1.5

• Based on billboarding

• Can place a 2D texture using a single point!

• Previously, needed two triangles

• 1/4th the bandwidth

• No aligning the quad to face the camera

• Using them

• Bind a 2D texture

• Draw using

glPolygonMode (GL_FRONT, GL_POINTS)

http://www.whatsthelatest.net/tutorials/run-macs-flurry-screensaver-windows-xp/

TEXTURE ARRAYS• Packing several images into a single texture units (GL_TEXTURE0)

• Good for 2D animations

• Similar use:• glBindTexture (GL_TEXTURE_2D_ARRAY, texBufID);

• glTexParameteri (GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

• However, to load the image, we are now in 3D!

glTexImage3D (GL_TEXTURE_2D_ARRAY, level, internal_format, w, h, depth, border, format, NULL);

• The depth parameter specifies how many images are in the array

LOADING THE ARRAYSfor (int i = 0; i < num_images; i++) {

data = loadBitmap (“image”+i+”.bmp”);

glTexSubImage(GL_TEXTURE_2D_ARRAY, 0, 0, 0, i, w,h, 1, GL_BGR, GL_UNSIGNED_BYTE, data);

}

ACCESSING THE IMAGES• Normally, you specify the image index from the client side

GLuint loc = glGetUniform (progID, “image_num”);

glUniform1f (loc, counter); // some int

• Then, in the vertex shader, use it as the 3 rd texture coordinate:

uniform float image_num;

in vec4 vTexCoords;

smooth out vec3 imageTexCoords;

void main (void) {

imageTexCoords.st = vTexCoords.st;

imageTexCoords.p = image_num;

…

}

YOUR FRAGMENT SHADER• Must have a sampler2DArray variable

• Must use the texture2DArray function

uniform sampler2DArray texture;

smooth in vec3 imageTexCoords;

out vFragColor;

void main () {

vFragColor = texture2DArray (texture, imageTexCoods.stp);

}