texture mapping (and some stuff on shaders)
TRANSCRIPT
![Page 1: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/1.jpg)
Texture Mapping(and some stuff on shaders for fun)
15-462: Computer Graphics
Eric Butler, Kristin Siu
![Page 2: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/2.jpg)
Announcements
You should be working on p1 right now…
In fact, you should be part way through the 2nd part.
There’s been an update to the starter code, so please
make sure you have the most recent version.
Homework 1 goes out today!
Midterm coming up!
![Page 3: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/3.jpg)
Outline
Project 1 Questions
Texture Mapping
OpenGL Texture Mapping
Shaders
![Page 4: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/4.jpg)
Project 1
Questions?
Otherwise, get started if you haven’t!
![Page 5: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/5.jpg)
Texture Mapping
In the general case!
![Page 6: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/6.jpg)
Motivation
Shading objects with solid colors is all well and good, but
what if we want more surface details?
Patterns? Pictures?
A really naïve implementation is just to use a model with
more polygons.
Slows down rendering speed
Still hard to model fine features
Solution!
Map a 2D image to a 3D surface!
![Page 7: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/7.jpg)
What is a texture?
A texture is just a bitmap image
Our image is a 2D array: texture[height][width[4]
Pixels of the texture are called texels
Texel coordinates are in 2D, in the range [0,1]
OpenGL uses (s, t) as the coordinate parameters.
Commonly referred to as (u, v) coordinates by most graphics
programs.
![Page 8: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/8.jpg)
Texture Mapping
In order to map a 2D image to a piece of geometry, we
consider two functions:
A mapping function which takes 3D points to (u, v)
coordinates.
f(x, y, z) returns (u, v)
A sampling/lookup function which takes (u, v) coordinates and
returns a color.
g(u, v) returns (r, g, b, a)
![Page 9: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/9.jpg)
The Mapping Function
This a fairly easy function for simple geometries: cubes,
spheres, etc…
Not so easy for more complicated shapes.
As a result, it’s often done manually.
![Page 10: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/10.jpg)
The Mapping Function
The basic idea is that for some polygon (which may have
arbitrary shape and size), we manually assign each of its
vertices (u, v) coordinates in the range from [0, 1].
We then use these (u, v) coordinates as rough indices
into our texture array.
![Page 11: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/11.jpg)
The Sampling Function
Things get a little more complicated here.
For given texture coordinates (u, v), we can find a unique
color value corresponding to the texture image at that
location.
Sometimes, we can get really lucky and use our (u, v)
coordinates as indices into our texture array.
![Page 12: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/12.jpg)
The Sampling Function
And then we get (u, v) coordinates that are not directly at
the pixels in the texture, but in between.
How do we acquire the correct color for a given point if
our texture cannot give us an exact value?
![Page 13: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/13.jpg)
The Sampling Function
There are several solutions:
Nearest neighbor
Pick the nearest pixel.
Bilinear
Interpolation on two directions.
Hermite
Similar to linear interpolation, but we weight the neighboring points
differently.
![Page 14: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/14.jpg)
OpenGL Texture Mapping
Useful for P1!
![Page 15: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/15.jpg)
OpenGL Texture Mapping
Add functionality to what we already have!
Initialization
Enable GL texture mapping
Specify texture
Read image from file into array in memory or generate image using
the program (procedural generation)
Specify any parameters
Define and activate the texture
Draw
Draw objects and assign texture coordinates to vertices
![Page 16: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/16.jpg)
Texture Enabling
You must enable a texturing mode
glEnable(GL_TEXTURE_2D)
glDisable(GL_TEXTURE_2D)
You must create a “texture object”
glGenTextures(1, &texture_id)
glBindTexture(GL_TEXTURE_2D, texture_id)
GL uses the currently bound texture when rendering
You can do glBindTexture(0) to have no active texture; this is
equivalent to having a solid white texture. You can do this to
avoid disabling texturing.
![Page 17: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/17.jpg)
Texture Parameters
There are several parameters that we can set to
determine how our texture mapping behaves.
We will go over three:
Texture coordinates out of bounds
Interpolating colors (sampling)
Color blending
![Page 18: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/18.jpg)
Texture Coordinates Out of Bounds
If texture coordinates are outside of [0,1] then what
color values can we assign them?
OpenGL provides two choices:
GL_REPEAT
Repeats the pattern
GL_CLAMP
Clamps to minimum, maximum value
![Page 19: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/19.jpg)
Texture Coordinates Out of Bounds
We use the following functions
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
GL_REPEAT);
Here, GL_TEXTURE_WRAP_* specifies which
coordinate we want to wrap, either s or t.
![Page 20: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/20.jpg)
Interpolating Colors
OpenGL offers several ways to interpolate colors, which
can be set as parameters:
GL_NEAREST
Use the nearest neighbor sampling.
Faster, but worse quality
GL_LINEAR
Linear interpolation of several neighbors.
Slower, but better quality
We can use
glTexParameteri(GL_TEXTURE_2D,
GL_TEXTURE_MIN_FILTER, GL_LINEAR);
![Page 21: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/21.jpg)
Color Blending
How does an object’s color blend with its texture?
Final color is some function of both!
In OpenGL, there are three options:
GL_REPLACE
Use texture color only
GL_BLEND
Linear combination of texture and object color
GL_MODULATE
Multiply texture and object color (default setting)
We use the following function:
glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE, GL_BLEND);
![Page 22: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/22.jpg)
Defining/Activating a Texture
We use:
glTexImage2D(GLenum target, GLint level, GLint
internalFormat, int width, int height, GLint border, GLenum
format, GLenum type, GLvoid* image);
Example:
glBindTexture(GL_TEXTURE_2D, texture_id);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0,
GL_RGBA, GL_UNSIGNED_BYTE, pointer ToImage);
This sets our active texture. To change to another
texture, you can specify another image.
One note: dimensions of texture images must be powers
of 2.
![Page 23: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/23.jpg)
Sample Code: Initialization// somewhere else...
Gluint texture_id;
void init()
{
// acquire load our texture into an array
// the function we use this semester is in imageio.hpp
char* pointer; // TODO: give me some values!
// enable textures
glEnable(GL_TEXTURE_2D);
glGenTextures(1, &texture_id);
glBindTexture(GL_TEXTURE_2D, texture_id);
// sample: specify texture parameters
glTexParameteri(GL_TEXUTRE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// set the active texture
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, pointer);
}
![Page 24: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/24.jpg)
Texture Drawing
Every time you draw a vertex, you declare its texture
coordinates before its vertices (similar to normals).
GLTexCoord2f(s,t) where s,t are in range [0,1]
And yes, if you are curious, there are texture coordinate
arrays.
![Page 25: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/25.jpg)
Sample Code: Drawing// The drawing code shouldn’t change very much…
void draw()
{
glBindTexture(GL_TEXTURE_2D, texture_id);
// draw a triangle
glBegin(GL_TRIANGLES);
glTexCoord2f(0.0, 0.0);
glVertex3f(-2.0, -1.0, 0.0);
glTexCoord2f(1.0, 0.0);
glVertex3f(-1.0, -2.0, 0.0);
glTexCoord2f(0.0, 1.0);
glVertex3f(-1.5, -1.5, 0.0);
glEnd();
}
![Page 26: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/26.jpg)
Shaders
GPU Programming Goodness…
![Page 27: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/27.jpg)
Motivation
The GPU is basically a bunch of small processers.
Back before shaders, the portion of the graphics pipeline
that handled lighting and texturing was hardcoded into
what we call the Fixed-Functionality Pipeline.
So we were stuck with Blinn-Phong shading, model view,
projection matrices, lights, materials, etc…
(In other words, almost all of the OpenGL we’ve taught you.)
But now, we can write programs to change the way the
pipeline works and rewrite portions of the pipeline to
behave differently than before.
In fact, the FFP is now implemented as a shader.
![Page 28: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/28.jpg)
And so we have shaders!
A shader is program that basically rewrites a portion of
the graphics pipeline.
They come in a variety of flavors
Vertex shaders
Geometry shaders
Fragment/Pixel shaders
And in a variety of languages
OpenGL’s GLSL
Microsoft’s HLSL
Nvidia’s Cg
![Page 29: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/29.jpg)
GLSL
OpenGL has its own shading language: GLSL
Help can be acquired via the Orange Book
GLSL is a C-like shading language
You can access OpenGL states such as lighting, materials, etc…
Textures are tricky (the vertex shader can’t access them)
We’ll use GLSL as our language for this lecture to explain
how shaders work.
![Page 30: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/30.jpg)
Back to the Pipeline (OpenGL)
![Page 31: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/31.jpg)
A Simplified OpenGL Pipeline
Let’s look a simpler version of the pipeline:
Input:
Vertex Data
Vertex Operation
Geometry Operations
Rasterization
(Interpolation)
Fragment Operation
Output:
Framebuffer
![Page 32: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/32.jpg)
Vertex Operations
Vertex shader
Operates on incoming vertices and their data (normals, texture
coordinates).
Operates on one vertex at a time
Replaces the vertex program in the pipeline
Must compute the vertex position
![Page 33: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/33.jpg)
Geometry Operations
Geometry shader
Recent addition to shaders (and shader support)
Operates on incoming primitives (vertices, triangles, etc)
Operates on one primitive (which can be composed of
multiple vertices) at a time
Can generate new primitives or remove primitives.
![Page 34: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/34.jpg)
Fragment Operations
Fragment/Pixel shader
A fragment is the smallest unit being shaded
Operates on each fragment
Replaces the pixel program in the pipeline
Must compute a color
![Page 35: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/35.jpg)
Passing Data to the Shaders
Data can be passed to the shaders (GPU) for computation.
GLSL classifies the type of data that you can pass:
const
Declaration of a compile-time constant
attribute
Per-vertex global variables passed from the application to the vertex shaders. Is read-only for (and can only be used by) vertex shaders.
varying
Used for data that is interpolated between the vertex/geometry and fragment shaders. Can be written/changed in the former and is read-only in the latter.
uniform
Per-primitive variables (not necessarily set in the draw call) that are read-only for all shaders.
![Page 36: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/36.jpg)
Interpolating Data
You can pass data between the various shaders (in GLSL,
this is done using the varying type).
When this data goes through the rasterization step, the
data is linearly interpolated.
One common mistake is passing data that can’t be linearly
interpolated (like sines and cosines).
![Page 37: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/37.jpg)
Another Look at the Pipeline
Here is our pipeline, using the information passed
between the shaders.
Input:
Vertex Data
• Positions
• Normals
• Colors
• Attributes
Vertex Operations
• Eye Positions
• Eye Normals
• Colors
• Varying
Geometry Operations
• Eye Positions
• Eye Normals
• Colors
• Varying
Rasterization
(Interpolation)
• Position
• Normal
• Color
• Varying (Interpolated)
Fragment Operations
• Pixel Color
Output:
Framebuffer
• Final image!
![Page 38: Texture Mapping (and some stuff on shaders)](https://reader031.vdocuments.site/reader031/viewer/2022013009/61cea96587f11318a477618d/html5/thumbnails/38.jpg)
Sample Code// Sample shaders that show off c-like GLSL syntax and do little else
// sample vertex shader
attribute float shift;
void main(void)
{
// Multiplies our vertex position by attribute variable passed in
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex * shift;
}
// sample fragment shader
uniform vec3 color = vec3(1.0, 0.0, 0.0);
void main()
{
// Turns all of our fragments a less-intense red
vec3 adjusted_color = color * 0.4;
glFragColor = vec4(adjusted_color, 1.0);
}
//PS: All of this shader stuff is just for fun and isn’t examinable material, but is very useful to know.