1. GLSL II

2. Objectives
Coupling GLSL to Applications
Example applications
GLSL 2

3. Linking Shaders to OpenGL
OpenGL Extensions
ARB_shader_objects
ARB_vertex_shader
ARB_fragment_shader
OpenGL 2.0
Almost identical to using extensions
Avoids extension suffixes on function names
GLSL 2

4. Program Object Container for shaders GLuint myProgObj;
Can contain multiple shaders
Other GLSL functions
GLuint myProgObj;
myProgObj = glCreateProgram();
/* define shader objects here */
glUseProgram(myProgObj);
glLinkProgram(myProgObj);
GLSL 2

5. Reading a Shader Shader added to program object and compiled
Usual method of passing shader
null-terminated string using function glShaderSource
If shader in file
can write reader to convert file to string
GLSL 2

6. Shader Reader #include <stdio.h>
char* readShaderSource(const char* shaderFile) {
FILE* fp = fopen(shaderFile, "r");
char* buf;
long size;
if(fp == NULL) return(NULL);
fseek(fp, 0L, SEEK_END); /* end of file */
size = ftell(fp);
fseek(fp, )L, SEEK_SET); /* start of file */
GLSL 2

7. Shader Reader (cont)
buf = (char*) malloc(statBuf.st_size + 1 * sizeof(char));
fread(buf, 1, size, fp);
buf[size] = '\0'; /null termination */
fclose(fp);
return buf; }
GLSL 2

8. Adding a Vertex Shader GLint vShader; GLunit myVertexObj;
GLchar vShaderfile[] = “my_vertex_shader”;
GLchar* vSource =
readShaderSource(vShaderFile);
glShaderSource(myVertexObj,
1, &vertexShaderFile, NULL);
myVertexObj =
glCreateShader(GL_VERTEX_SHADER);
glCompileShader(myVertexObj);
glAttachObject(myProgObj, myVertexObj);
GLSL 2

9. Vertex Attributes Vertex attributes named in shaders
Linker forms table
Application can get index from table and tie it to application variable
Similar process for uniform variables
GLSL 2

10. Vertex Attribute Example
GLint colorAttr;
colorAttr = glGetAttribLocation(myProgObj,
"myColor");
/* myColor is name in shader */
GLfloat color[4];
glVertexAttrib4fv(colorAttrib, color);
/* color is variable in application */
GLSL 2

11. Uniform Variable Example
GLint angleParam;
angleParam = glGetUniformLocation(myProgObj,
"angle");
/* angle defined in shader */
/* my_angle set in application */
GLfloat my_angle;
my_angle = 5.0 /* or some other value */
glUniform1f(angleParam, my_angle);
GLSL 2

12. Vertex Shader Applications
Moving vertices
Morphing
Wave motion
Fractals
Lighting
More realistic models
Cartoon shaders
GLSL 2

13. Wave Motion Vertex Shader
uniform float time;
uniform float xs, zs, // frequencies
uniform float h; // height scale
void main() {
vec4 t = gl_Vertex;
t.y = gl_Vertex.y
+ h*sin(time + xs*gl_Vertex.x)
+ h*sin(time + zs*gl_Vertex.z);
gl_Position =
gl_ModelViewProjectionMatrix*t; }
GLSL 2

14. Particle System uniform vec3 init_vel; uniform float g, m, t;
void main() {
vec3 object_pos;
object_pos.x = gl_Vertex.x + vel.x*t;
object_pos.y = gl_Vertex.y + vel.y*t
+ g/(2.0*m)*t*t;
object_pos.z = gl_Vertex.z + vel.z*t;
gl_Position =
gl_ModelViewProjectionMatrix*
vec4(object_pos,1); }
GLSL 2

15. Modified Phong Vertex Shader I
void main(void)
/* modified Phong vertex shader (without distance term) */ {
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
vec4 ambient, diffuse, specular;
vec4 eyePosition = gl_ModelViewMatrix * gl_Vertex;
vec4 eyeLightPos = gl_LightSource[0].position;
vec3 N = normalize(gl_NormalMatrix * gl_Normal);
vec3 L = normalize(eyeLightPos.xyz - eyePosition.xyz);
vec3 E = -normalize(eyePosition.xyz);
vec3 H = normalize(L + E);
GLSL 2

16. Modified Phong Vertex Shader II
/* compute diffuse, ambient, and specular contributions */
float Kd = max(dot(L, N), 0.0);
float Ks = pow(max(dot(N, H), 0.0), gl_FrontMaterial.shininess);
float Ka = 0.0;
ambient = Ka*gl_FrontLightProduct[0].ambient;
diffuse = Kd*gl_FrontLightProduct[0].diffuse;
specular = Ks*gl_FrontLightProduct[0].specular;
gl_FrontColor = ambient+diffuse+specular; }
GLSL 2

17. Pass Through Fragment Shader
void main(void) {
gl_FragColor = gl_Color; }
GLSL 2

18. Vertex Shader for per Fragment Lighting
varying vec3 N, L, E, H;
void main() {
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
vec4 eyePosition = gl_ModelViewMatrix * gl_Vertex;
vec4 eyeLightPos = gl_LightSource[0].position;
N = normalize(gl_NormalMatrix * gl_Normal);
L = normalize(eyeLightPos.xyz - eyePosition.xyz);
E = -normalize(eyePosition.xyz);
H = normalize(L + E); }
GLSL 2

19. Fragment Shader for Modified Phong Lighting I
varying vec3 N;
varying vec3 L;
varying vec3 E;
varying vec3 H;
void main() {
vec3 Normal = normalize(N);
vec3 Light = normalize(L);
vec3 Eye = normalize(E);
vec3 Half = normalize(H);
GLSL 2

20. Fragment Shader for Modified Phong Lighting II
float Kd = max(dot(Normal, Light), 0.0);
float Ks = pow(max(dot(Half, Normal), 0.0),
gl_FrontMaterial.shininess);
float Ka = 0.0;
vec4 diffuse = Kd * gl_FrontLightProduct[0].diffuse;
vec4 specular = Ks * gl_FrontLightProduct[0].specular;
vec4 ambient = Ka * gl_FrontLightProduct[0].ambient;
gl_FragColor = ambient + diffuse + specular; }
GLSL 2

21. Vertex vs Fragment Lighting
per vertex lighting
per fragment lighting
GLSL 2

22. Samplers Provides access to texture object
Defined for 1, 2, and 3 dimensional textures and for cube maps
In shader:
uniform sampler2D myTexture;
Vec2 texcoord;
Vec4 texcolor = texture2D(mytexture, texcoord);
In application:
texMapLocation = glGetUniformLocation(myProg,“myTexture”);
glUniform1i(texMapLocation, 0);
/* assigns to texture unit 0 */
GLSL 2

23. Fragment Shader Applications
Texture mapping
smooth shading
environment
mapping
bump mapping
GLSL 2

24. Cube Maps Can form cube map texture by defining six 2D texture maps
correspond to sides of box
Supported by OpenGL
Also supported in GLSL through cubemap sampler
vec4 texColor = textureCube(mycube, texcoord);
Texture coordinates must be 3D
GLSL 2

25. Environment Map Use reflection vector to locate texture in cube map
GLSL 2

26. Environment Maps with Shaders
Environment map usually computed in world coordinates
can differ from object coordinates because of modeling matrix
May have to keep track of modeling matrix and pass it shader as uniform variable
Can also use reflection map or refraction map (for example to simulate water)
GLSL 2

27. Reflection Map Vertex Shader
varying vec3 R;
void main(void) {
gl_Position = gl_ModelViewProjectionMatrix*gl_Vertex;
vec3 N = normalize(gl_NormalMatrix*gl_Normal);
vec4 eyePos = gl_ModelViewMatrix*gl_Vertex;
R = reflect(-eyePos.xyz, N); }
GLSL 2

28. Refelction Map Fragment Shader
varying vec3 R;
uniform samplerCube texMap;
void main(void) {
gl_FragColor = textureCube(texMap, R); }
GLSL 2

29. Bump Mapping Perturb normal for each fragment
Store perturbation as textures
GLSL 2

30. Normalization Maps
Cube maps can be viewed as lookup tables 1-4 dimensional variables
Vector from origin is pointer into table
Example: store normalized value of vector in map
Same for all points on that vector
Use “normalization map” instead of normalization function
Lookup replaces sqrt, mults and adds
GLSL 2