Nima Kalantari

CSCE 441 - Computer Graphics

​

Shading and Texture Mapping

Some slides from Ren Ng and Scott Schaefer

So far

Realistic Lighting

Image taken from http://graphics.ucsd.edu/~henrik/images/cbox.html

Rasterization Pipeline (covered)

Vertex Processing

Triangle Processing

Rasterization

Fragment Processing

Framebuffer Operations

Shaded Fragments

Fragment Stream

Triangle Stream

Vertex Stream

Display

Application

Modeling & viewing transforms

Rasterization Pipeline (covered)

Vertex Processing

Triangle Processing

Rasterization

Fragment Processing

Framebuffer Operations

Shaded Fragments

Fragment Stream

Triangle Stream

Vertex Stream

Display

Application

Sampling triangle coverage

Rasterization Pipeline (not covered)

Triangle Processing

Rasterization

Fragment Processing

Framebuffer Operations

Shaded Fragments

Fragment Stream

Triangle Stream

Vertex Stream

Display

Application

+ Specular

Phong Reflection

=

Ambient

Diffuse

+

Evaluating shading functions

Vertex Processing

Rasterization Pipeline (not covered)

Triangle Processing

Rasterization

Fragment Processing

Framebuffer Operations

Shaded Fragments

Fragment Stream

Triangle Stream

Vertex Stream

Display

Application

Texture mapping

Vertex Processing

Rasterization Pipeline (covered)

Vertex Processing

Triangle Processing

Rasterization

Fragment Processing

Framebuffer Operations

Shaded Fragments

Fragment Stream

Triangle Stream

Vertex Stream

Display

Application

Z-Buffer Visibility Tests

Lighting/Illumination

• Color is a function of how light reflects from surfaces to the eye

Reflection Models

Types of Reflection Functions

• Ideal Specular
• Reflection Law
• Mirror
• Ideal Diffuse
• Lambert’s Law
• Matte
• Specular
• Glossy
• Directional diffuse

Illumination Types

• Local illumination only accounts for light that directly hits a surface and is transmitted to the eye
• Global illumination accounts for light from all sources as it is transmitted throughout the environment

​

Realistic Lighting (global illumination)

Image taken from http://graphics.ucsd.edu/~henrik/images/cbox.html

would be completely black with local ilumination

Outline

• Phong reflection model
• Shading methods
• GLSL
• Texture mapping
• Advanced texturing methods

Phong reflection model

• A local shading model: simple, per-pixel, fast
• Based on perceptual observations, not physics

Perceptual Observations

Photo credit: Jessica Andrews, flickr

Diffuse reflection

Specular highlights

Ambient lighting

Illumination Model

• Ambient Light
• Uniform light caused by secondary reflections
• Diffuse Light
• Light scattered equally in all directions
• Specular Light
• Highlights on shiny surfaces

Ambient Light

​

• intensity of ambient light
• ambient reflection coefficient
• Really 3 equations! (Red, Green, Blue)
• Accounts for indirect illumination

Example

Diffuse Light

Diffuse Light

• Assumes that light is reflected equally in all directions

Surface

Diffuse Ball Example

akimeta.com

Lambert’s Law

Surface

Beam of Light

Lambert’s Law

Surface

Beam of Light

Lambert’s Law

Surface

Beam of Light

Diffuse Light

​

• intensity of point light source
• diffuse reflection coefficient
• angle between normal and direction to light

​

Surface

Example

Example

Specular Light

Perceptual Observations

Photo credit: Jessica Andrews, flickr

Diffuse reflection

Specular highlights

Ambient lighting

Specular Light

• Perfect, mirror-like reflection of light from surface
• Forms highlights on shiny objects (metal, plastic)

Surface

Specular Light

​

• intensity of point light source
• specular reflection coefficient
• angle between reflected vector ( ) and eye ( )
• specular exponent

​

Surface

Cosine Power Plots

• Increasing n narrows the reflection lobe

[Foley et al.]

Finding the Reflected Vector

Surface

Finding the Reflected Vector

Surface

Finding the Reflected Vector

Surface

Finding the Reflected Vector

Surface

Finding the Reflected Vector

Surface

Total Illumination

Total Illumination

Total Illumination

Total Illumination

Multiple Light Sources

• Only one ambient term no matter how many lights
• Light is additive; add contribution of multiple lights (diffuse/specular components)

Total Illumination

Total Illumination

Light Falloff

• Intensity proportional to power per unit area

Spot Lights

Spot Lights

• Eliminate light contribution outside of a cone

Surface

Spot Lights

• Eliminate light contribution outside of a cone

Surface

Spot Lights

Spot Lights

Small α

Spot Lights

Large α

Outline

• Phong reflection model
• Shading methods
• GLSL
• Texture mapping
• Advanced texturing methods

Shading Methods

• Flat Shading (shade each triangle)
• Gouraud Shading (shade each vertex)
• Phong Shading (shade each pixel)

Shading Frequency: Triangle, Vertex or Pixel

• Shade each triangle (flat shading)
• Triangle face is flat — one normal vector
• Not good for smooth surfaces
• Shade each vertex (“Gouraud” shading)
• Interpolate colors from vertices across triangle
• Each vertex has a normal vector

Defining Per-Vertex Normal Vectors

• Best to get vertex normals from the underlying

geometry

• e.g. consider a sphere
• Otherwise have to infer vertex normals from triangle faces
• Simple scheme: average �surrounding face normals

Shading Frequency: Triangle, Vertex or Pixel

• Shade each triangle (flat shading)
• Triangle face is flat — one normal vector
• Not good for smooth surfaces
• Shade each vertex (“Gouraud” shading)
• Interpolate colors from vertices across triangle
• Each vertex has a normal vector
• Shade each pixel (“Phong” shading)
• Interpolate normal vectors across each triangle
• Compute full shading model at each pixel

Defining Per-Pixel Normal Vectors

• Barycentric interpolation of vertex normals

Problem: length of vectors?

Shading Frequency: Face, Vertex or Pixel

Image credit: Happyman, http://cg2010studio.com/

Num�Vertices

Face�Flat

Vertex

Gouraud

Pixel

Phong

Shading freq. :�Shading type :

Implementation Notes

• Computation can be done in
• World space
• Camera space
• Transforming normals

Careful: Transforming Normal Vectors

Original object�& normal vectors

Careful: Transforming Normal Vectors

Original object�& normal vectors

Careful: Transforming Normal Vectors

• Transforming surface normal vectors:
• Must use inverse transpose matrix
• Derivation:

Outline

• Phong reflectance model
• Shading methods
• GLSL
• Texture mapping
• Advanced texturing methods

Rasterization Pipeline

Vertex Processing

Triangle Processing

Rasterization

Framebuffer Operations

Shaded Fragments

Fragment Stream

Triangle Stream

Vertex Stream

Display

Application

Fragment Processing

Rasterization Pipeline

Vertex Processing

Triangle Processing

Rasterization

Framebuffer Operations

Shaded Fragments

Fragment Stream

Triangle Stream

Vertex Stream

Display

Application

Fragment Processing

Vertex Shader

Fragment or Pixel Shader

Shading Language

• Assembly
• Nvidia’s CG
• DirectX High Level Shader (HLSL)
• OpenGL Shading Language (GLSL)

​

​

Vertex Information

float posBuff[] = {

p_x1, p_y1, p_z1,

p_x2, p_y2, p_z2,

p_x3, p_y3, p_z3,

.

.

.

};

float colBuff[] = {

c_r1, c_g1, c_b1,

c_r2, c_g2, c_b2,

c_r3, c_g3, c_b3,

.

.

.

};

float norBuff[] = {

n_x1, n_y1, n_z1,

n_x2, n_y2, n_z2,

n_x3, n_y3, n_z3,

​

.

.

.

};

Example

• Draw the triangles in the posBuff using the color in the colBuff
• Transform vertices based on model, view, and projection matrices (vertex shader)
• Rasterize the triangles
• Shade each fragment (fragment shader)
• Perform the visibility test

Example Vertex Shader

attribute vec3 vPos; // posBuff content passed from CPU

attribute vec3 vCol; // colBuff content passed from CPU

​

uniform mat4 model;

uniform mat4 view;

uniform mat4 projection;

​

varying vec3 color;

​

void main()

{

gl_Position = projection * view * model * vec4(vPos, 1.0f);

color = vCol; // passed to fragment shader

}

Variables

• Attribute
• Vertex information (position, normal, color, texture coordinates, etc.)
• Passed from CPU to vertex shader

Example Vertex Shader

attribute vec3 vPos; // posBuff content passed from CPU

attribute vec3 vCol; // colBuff content passed from CPU

​

uniform mat4 model;

uniform mat4 view;

uniform mat4 projection;

​

varying vec3 color;

​

void main()

{

gl_Position = projection * view * model * vec4(vPos, 1.0f);

color = vCol; // passed to fragment shader

}

Variables

• Attribute
• Vertex information (position, normal, color, texture coordinates, etc.)
• Passed from CPU to vertex shader
• Uniform
• The same for all the vertices or fragments
• Passed from CPU to vertex and fragment shaders

Example Vertex Shader

attribute vec3 vPos; // posBuff content passed from CPU

attribute vec3 vCol; // colBuff content passed from CPU

​

uniform mat4 model;

uniform mat4 view;

uniform mat4 projection;

​

varying vec3 color;

​

void main()

{

gl_Position = projection * view * model * vec4(vPos, 1.0f);

color = vCol; // passed to fragment shader

}

Variables

• Attribute
• Vertex information (position, normal, color, texture coordinates, etc.)
• Passed from CPU to vertex shader
• Uniform
• The same for all the vertices or fragments
• Passed from CPU to vertex and fragment shaders
• Varying
• Declare in vertex shader - Passed to fragment shader

​

Example Vertex Shader

attribute vec3 vPos; // posBuff content passed from CPU

attribute vec3 vCol; // colBuff content passed from CPU

​

uniform mat4 model;

uniform mat4 view;

uniform mat4 projection;

​

varying vec3 color;

​

void main()

{

gl_Position = projection * view * model * vec4(vPos, 1.0f);

color = vCol; // passed to fragment shader

}

Variables

• Attribute
• Vertex information (position, normal, color, texture coordinates, etc.)
• Passed from CPU to vertex shader
• Uniform
• The same for all the vertices or fragments
• Passed from CPU to vertex and fragment shaders
• Varying
• Declare in vertex shader - Passed to fragment shader
• Pre-defined
• gl_Position: output of vertex shader
• gl_FragColor: output of fragment shader

​

​

​

Example Vertex Shader

attribute vec3 vPos; // posBuff content passed from CPU

attribute vec3 vCol; // colBuff content passed from CPU

​

uniform mat4 model;

uniform mat4 view;

uniform mat4 projection;

​

varying vec3 color;

​

void main()

{

gl_Position = projection * view * model * vec4(vPos, 1.0f);

color = vCol; // passed to fragment shader

}

Example Fragment Shader

varying vec3 color; // passed from the vertex shader

​

void main()

{

gl_FragColor = vec4(color, 1.0);

}

Vertex Shader

• Every vertex passes through the vertex shader (in parallel)

Position0

Position1

Position2

…

Color 0

Color 1

Color 2

…

Attribute variables

Vertex buffer

Vertex Shader

Varying variables

…

gl_Position,

…

Uniform variables

Rasterizer

Fragment (Pixel) Shader

• Every fragment passes through the fragment shader (in parallel)

Fragment Shader

Varying variables

Uniform variables

gl_FragColor

Rasterizer

…

Pipeline

Position 0

Position 1

Position 2

…

Color 0

Color 1

Color 2

…

Attribute variables

Vertex buffer

Vertex Shader

Varying variables

gl_Position,

…

Uniform variables

Fragment Shader

Varying variables

gl_FragColor

Rasterizer

Uniform variables

Shader Programs

• Initialization
• Load, Compile, and Link
• Pass attributes
• Run-time
• Pass uniform variables and draw

Shader Programs

• Initialization
• Load, Compile, and Link
• Pass attributes
• Run-time
• Pass uniform variables and draw

Load, Compile, and Link

GLuint vertShader = glCreateShader(GL_VERTEX_SHADER);

GLuint fragShader = glCreateShader(GL_FRAGMENT_SHADER);

​

vsText = ReadShader(vertexShaderFileName);

fsText = ReadShader(fragmentShaderFileName);

​

glShaderSource(vertShader, 1, &vsText, 0);

glShaderSource(fragShader, 1, &fsText, 0);

​

glCompileShader(vertShader);

glCompileShader(fragShader);

​

programID = glCreateProgram();

glAttachShader(programID, vertShader);

glAttachShader(programID, fragShader);

​

glLinkProgram(programID);

Load, Compile, and Link

GLuint vertShader = glCreateShader(GL_VERTEX_SHADER);

GLuint fragShader = glCreateShader(GL_FRAGMENT_SHADER);

​

vsText = ReadShader(vertexShaderFileName);

fsText = ReadShader(fragmentShaderFileName);

​

glShaderSource(vertShader, 1, &vsText, 0);

glShaderSource(fragShader, 1, &fsText, 0);

​

glCompileShader(vertShader);

glCompileShader(fragShader);

​

programID = glCreateProgram();

glAttachShader(programID, vertShader);

glAttachShader(programID, fragShader);

​

glLinkProgram(programID);

Vertex and Fragment Shaders

Shader.vert

​

attribute vec3 vPos; // posBuff content passed from CPU

attribute vec3 vCol; // colBuff content passed from CPU

​

uniform mat4 model;

uniform mat4 view;

uniform mat4 projection;

​

varying vec3 color;

​

void main()

{

gl_Position = projection * view * model * vec4(vPos, 1.0f);

color = vCol; // passed to fragment shader

}

------------------------------------------------------------------

Shader.frag

​

varying vec3 color; // passed from the vertex shader

​

void main()

{

gl_FragColor = vec4(color, 1.0);

}

​

​

Load, Compile, and Link

GLuint vertShader = glCreateShader(GL_VERTEX_SHADER);

GLuint fragShader = glCreateShader(GL_FRAGMENT_SHADER);

​

vsText = ReadShader(vertexShaderFileName);

fsText = ReadShader(fragmentShaderFileName);

​

glShaderSource(vertShader, 1, &vsText, 0);

glShaderSource(fragShader, 1, &fsText, 0);

​

glCompileShader(vertShader);

glCompileShader(fragShader);

​

programID = glCreateProgram();

glAttachShader(programID, vertShader);

glAttachShader(programID, fragShader);

​

glLinkProgram(programID);

Shader.vert

Shader.frag

Load, Compile, and Link

GLuint vertShader = glCreateShader(GL_VERTEX_SHADER);

GLuint fragShader = glCreateShader(GL_FRAGMENT_SHADER);

​

vsText = ReadShader(vertexShaderFileName);

fsText = ReadShader(fragmentShaderFileName);

​

glShaderSource(vertShader, 1, &vsText, 0);

glShaderSource(fragShader, 1, &fsText, 0);

​

glCompileShader(vertShader);

glCompileShader(fragShader);

​

programID = glCreateProgram();

glAttachShader(programID, vertShader);

glAttachShader(programID, fragShader);

​

glLinkProgram(programID);

number of

string arrays

Length of

each string

Shader Programs

• Initialization
• Load, Compile, and Link
• Pass attributes
• Run-time
• Pass uniform variables and draw

Shader Programs

• Initialization
• Load, Compile, and Link
• Pass attributes
• Run-time
• Pass uniform variables and draw

Pass Attributes

GLuint vPosID;

glGenBuffers(1, &vPosID);

glBindBuffer(GL_ARRAY_BUFFER, vPosID);

glBufferData(GL_ARRAY_BUFFER, sizeof(posBuff), posBuff, GL_STATIC_DRAW);

​

GLint aLoc = glGetAttribLocation(programID, “vPos”);

glEnableVertexAttribArray(aLoc);

glVertexAttribPointer(aLoc, 3, GL_FLOAT, GL_FALSE, 0, 0);

Vertex Information

float posBuff[] = {

p_x1, p_y1, p_z1,

p_x2, p_y2, p_z2,

p_x3, p_y3, p_z3,

.

.

.

};

float colBuff[] = {

c_r1, c_g1, c_b1,

c_r2, c_g2, c_b2,

c_r3, c_g3, c_b3,

.

.

.

};

Pass Attributes

GLuint vPosID;

glGenBuffers(1, &vPosID);

glBindBuffer(GL_ARRAY_BUFFER, vPosID);

glBufferData(GL_ARRAY_BUFFER, sizeof(posBuff), posBuff, GL_STATIC_DRAW);

​

GLint aLoc = glGetAttribLocation(programID, “vPos”);

glEnableVertexAttribArray(aLoc);

glVertexAttribPointer(aLoc, 3, GL_FLOAT, GL_FALSE, 0, 0);

Example Vertex Shader

attribute vec3 vPos; // posBuff content passed from CPU

attribute vec3 vCol; // colBuff content passed from CPU

​

uniform mat4 model;

uniform mat4 view;

uniform mat4 projection;

​

varying vec3 color;

​

void main()

{

gl_Position = projection * view * model * vec4(vPos, 1.0f);

color = vCol; // passed to fragment shader

}

Shader Programs

• Initialization
• Load, Compile, and Link
• Pass attributes
• Run-time
• Pass uniform variables and draw

Shader Programs

• Initialization
• Load, Compile, and Link
• Pass attributes
• Run-time
• Pass uniform variables and draw

Vertex and Fragment Shaders

Shader.vert

​

attribute vec3 vPos; // posBuff content passed from CPU

attribute vec3 vCol; // colBuff content passed from CPU

​

uniform mat4 model;

uniform mat4 view;

uniform mat4 projection;

​

varying vec3 color;

​

void main()

{

gl_Position = projection * view * model * vec4(vPos, 1.0f);

color = vCol; // passed to fragment shader

}

------------------------------------------------------------------

Shader.frag

​

varying vec3 color; // passed from the vertex shader

​

void main()

{

gl_FragColor = vec4(color, 1.0);

}

​

​

Run-Time (Display code)

glm::mat4 projectionMatrix = glm::perspective(…);

glm::mat4 viewMatrix = glm::lookAt(…);

glm::mat4 modelMatrix(1.0f);

​

glUseProgram(programID);

​

GLint uLoc;

​

uLoc = glGetUniformLocation(programID, “projection”);

glUniformMatrix4fv(uLoc, 1, GL_FALSE, &projectionMatrix[0][0]);

​

uLoc = glGetUniformLocation(programID, “view”);

glUniformMatrix4fv(uLoc, 1, GL_FALSE, &viewMatrix[0][0]);

​

uLoc = glGetUniformLocation(programID, “model”);

glUniformMatrix4fv(uLoc, 1, GL_FALSE, &modelMatrix[0][0]);

​

glDrawArrays(GL_TRIANGLES, 0, NUM_TRIANGLES);

​

glUseProgram(0);

​

​

Run-Time (Display code)

glm::mat4 projectionMatrix = glm::perspective(…);

glm::mat4 viewMatrix = glm::lookAt(…);

glm::mat4 modelMatrix(1.0f);

​

glUseProgram(programID);

​

GLint uLoc;

​

uLoc = glGetUniformLocation(programID, “projection”);

glUniformMatrix4fv(uLoc, 1, GL_FALSE, &projectionMatrix[0][0]);

​

uLoc = glGetUniformLocation(programID, “view”);

glUniformMatrix4fv(uLoc, 1, GL_FALSE, &viewMatrix[0][0]);

​

uLoc = glGetUniformLocation(programID, “model”);

glUniformMatrix4fv(uLoc, 1, GL_FALSE, &modelMatrix[0][0]);

​

glDrawArrays(GL_TRIANGLES, 0, NUM_TRIANGLES);

​

glUseProgram(0);

​

​

number of

matrices

transpose?

Assignment 4

• Gouraud Shading
• Phong Shading
• Silhouette Shading

Assignment 4

Gouraud Shading

• Shade each vertex (in vertex shader)
• Interpolate the color of three vertices to obtain the color of fragment (automatically done during rasterization)

Vertex Shader

attribute vec3 vPositionModel; // in object space

attribute vec3 vNormalModel; // in object space

​

uniform mat4 model;

uniform mat4 view;

uniform mat4 projection;

​

struct lightStruct

{

vec3 position;

vec3 color;

};

​

#define NUM_LIGHTS 2

​

uniform lightStruct lights[NUM_LIGHTS];

​

uniform vec3 ka;

uniform vec3 kd;

uniform vec3 ks;

uniform float s;

​

varying vec3 color;

​

void main()

{

gl_Position = projection * view * model * vec4(vPositionModel, 1.0);

color = vec3(1.0f, 0.0f, 0.0f);

}

​

Outline

• Phong reflectance model
• Shading methods
• GLSL
• Texture mapping
• Advance texturing methods

Texture Mapping Has Many Uses

Pattern on ball

Wood grain on floor

Three Spaces

• Surface lives in 3D world space
• Every 3D surface point also has a place where it goes�in the 2D image and in the 2D texture.

Screen space

Texture space

World space

Image Texture Applied to Surface

Rendering with texture

Rendering without texture

Texture image

Zoom

Each triangle “copies” a piece of the texture image back to the surface.

Texture Mapping

Texture Mapping

Texture Mapping

Texture Mapping

Texture Mapping

• Assume texture parameterized by u, v

​

Texture Mapping

• Any u, v coordinate maps to a point on the image

​

Texture Mapping

• Associate texture coordinates with each vertex on the surface

​

Texture Mapping

• Lookup diffuse color from texture using interpolated texture coord.

​

Texture Mapping

Sampling Issues in Texture Mapping

Applying Textures is Sampling!

​

for each rasterized screen sample (x,y):

(u,v) = evaluate texcoord value at (x,y)

float3 texcolor = texture.sample(u,v);

set sample’s color to texcolor;

Point Sampling Textures

Point sampling

Jaggies

Moire

Source image: 1280x1280 pixels

256x256 pixels

High-res reference

Triangle Footprint in Texture

Screen Space

World Space

Texture Space

Triangle Footprint in Texture

Screen Space

World Space

Texture Space

Triangle Footprint in Texture

Screen Space

Texture Space

World Space

Triangle Footprint in Texture

Screen Space

World Space

Texture Space

Triangle Footprint in Texture

Screen Space

World Space

Texture Space

Screen Pixel Footprint in Texture

Screen space

Texture space

Screen Pixel Footprint in Texture

Upsampling

(Magnification)

Downsampling

(Minification)

Screen Pixel Area vs Texel Area

• Texel: A texture pixel
• At optimal viewing size:
• 1:1 mapping between pixel sampling rate and �texel sampling rate
• When texel is larger (magnification)
• Multiple pixel samples per texel sample
• When texel is smaller (minification)
• One pixel sample per multiple texel samples

Texture Magnification

• Generally don’t want this — insufficient resolution

​

Triangle Footprint in Texture

Screen Space

World Space

Texture Space

Texture sampling

Nearest Neighbor

Texture Magnification

• Generally don’t want this — insufficient resolution

​

Nearest

Bilinear Filtering

Take 4 nearest sample locations, with texture values as labeled.

Bilinear Filtering

Linear interpolation (1D)

Bilinear Filtering

Linear interpolation (1D)

Bilinear Filtering

Linear interpolation (1D)

Two helper lerps (horizontal)

Bilinear Filtering

Linear interpolation (1D)

Two helper lerps

Final vertical lerp, to get result:

u

Texture Magnification

• Generally don’t want this — insufficient resolution

​

Nearest

Bilinear

Bicubic

Texture Minification

Triangle Footprint in Texture

Screen Space

Texture Space

World Space

Triangle Footprint in Texture

Screen Space

Texture Space

World Space

Point Sampling Textures Causes Aliasing

High-res reference

Point sampling

Will Supersampling Antialias?

High-res reference

Point sampling

Texture Antialiasing

• Will supersampling work?
• Yes, high quality, but costly
• When highly minified, many texels in pixel footprint
• Goal: efficient texture antialiasing
• How? Antialiasing = filtering before sampling!

Triangle Footprint in Texture

Screen Space

Texture Space

Texture Space

Lower Resolution