Using Shaders

Using Shaders
In "Modern" OpenGL

Prof. David Bernstein
James Madison University

Computer Science Department

bernstdh@jmu.edu

Review

Vertex Specification:
- Using vertex buffer objects and vertex array objects to specify primitives/shapes
The Pipeline:
- Initiation using drawing commands
- The stages
- The shaders used at different stages
Some Important Shaders:
- Vertex Shaders
- Fragment Shaders

This Lecture

The "Internal" Build Process:
- Loading the shaders
- Compiling the shaders
- Creating the shader program
Putting it all Together:
- A complete application

Loading Shaders

Review:
- Shaders are written in a C-like language and stored in a text file
What's Needed:
- A way to read shaders into the program that invokes the OpenGL drawing commands

Loading Shaders (cont.)

The Specification

openglexamples/modern/fileUtilities.h

#ifndef FILE_UTILITIES__H
#define FILE_UTILITIES_H
#include <string>
using namespace std;

/**
 * /file
 * Functions for working with files.
 */

/**
 * Read a file into a stringstream.
 *
 * @param fileName  The name of the file to read
 * @return          A string containing the contents of the file
 */
string readFile(const char* fileName);

#endif

Loading Shaders (cont.)

The Implementation

openglexamples/modern/fileUtilities.cpp

#include <stdlib.h>
#include <stdio.h>
#include <iostream>
#include <fstream>
#include <sstream>
#include "fileUtilities.h"


string readFile(const char* fileName) {
  string   contents;
  ifstream stream(fileName, ios::in);
  
  if(stream.is_open()){
    stringstream sstr;
    sstr << stream.rdbuf();
    contents = sstr.str();
    stream.close();
  }
  return contents;
}

Compiling Shaders

What's Needed:
- A way to compile the source code within the program that invokes the OpenGL drawing commands
The Steps in the Process:
- Create a handle/name/ID using GLuint glCreateShader(GLenum shaderType)
- Associate the source with the ID using void glShaderSource(GLuint shaderID, GLsizei count, const GLchar **source, const GLint *length)
- Compile the source using void glCompileShader(GLuint shaderID)
- Check the status of the compilation using void glGetShaderiv(GLuint shaderID, GLenum paramname, GLint *params)
- Get the error messages (if any) using void glGetShaderInfoLog(GLuint shaderID, GLsizei maxLength, GLsizei *actualLength, GLchar *message)

Compiling Shaders (cont.)

The Specification

openglexamples/modern/shaderUtilities.h

(Fragment: buildShader)

/**
 * Build a GLSL shader.
 *
 */
GLuint buildShader(const char* fileName, GLenum shaderType);

Compiling Shaders (cont.)

The Implementation

openglexamples/modern/shaderUtilities.cpp

(Fragment: buildShader)

GLuint buildShader(const char* fileName, GLenum shaderType) {
  // Create the handle/name/ID
  GLuint id = glCreateShader(shaderType);

  // Read the shader code from the file
  string code = readFile(fileName);
  if (code.size() == 0) return 0;

  // Compile the shader
  char const* codePointer = code.c_str();
  glShaderSource(id, 1, &codePointer , NULL);
  glCompileShader(id);

  // Check the shader
  GLint   ok = GL_FALSE;
  GLsizei messageLength = 0;
  glGetShaderiv(id, GL_COMPILE_STATUS, &ok);
  if (!ok) {
    glGetShaderiv(id, GL_INFO_LOG_LENGTH, &messageLength);
    GLchar errorMessage[messageLength + 1];
    glGetShaderInfoLog(id, messageLength, NULL, &errorMessage[0]);
    printf("%s\n", &errorMessage[0]);
  }
  return id;
}

Building Programs

What's Needed:
- A way to link the various shaders into a coherent whole
The Steps in the Process:
- Create a handle/name/ID using GLuint glCreateProgram(void)
- Associate the shaders with with the ID using void glAttachShader(GLuint programID, GLuint shaderID)
- Link the pieces together using void glLinkProgram(GLuint programID)
- Check the status of the compilation using void glGetProgramiv(GLuint programID, GLenum paramname, GLint *params)
- Get the error messages (if any) using void glGetProgramInfoLog(GLuint programID, GLsizei maxLength, GLsizei *actualLength, GLchar *message)
- Cleanup using void glDetachShader(GLuint programID, GLuint shaderID) and void glDeleteShader(GLuint id)

Building Programs (cont.)

The Specification

openglexamples/modern/shaderUtilities.h

(Fragment: buildProgram)

/**
 * Build a GLSL proram.
 *
 * @param vertexFileName   The name of the file containg the vertex shader
 * @param fragmentFileName The name of the file containg the fragment shader
 */
GLuint buildProgram(const char* vertexFileName, const char* fragmentFileName);

Building Programs (cont.)

The Implementation

openglexamples/modern/shaderUtilities.cpp

(Fragment: buildProgram)

GLuint buildProgram(const char* vertexFile,
                    const char* fragmentFile){
  // Read and compile the shaders
  GLuint vertexShaderID = buildShader(vertexFile, GL_VERTEX_SHADER);
  if (vertexShaderID == 0) return 0;
  
  GLuint fragmentShaderID = buildShader(fragmentFile, GL_FRAGMENT_SHADER);
  if (fragmentShaderID == 0) return 0;

  // Link the program
  GLuint programID = glCreateProgram();
  glAttachShader(programID, vertexShaderID);
  glAttachShader(programID, fragmentShaderID);
  glLinkProgram(programID);

  // Check the program
  GLint   ok = GL_FALSE;
  GLsizei messageLength = 0;
  glGetProgramiv(programID, GL_LINK_STATUS, &ok);
  if (!ok) {
    glGetProgramiv(programID, GL_INFO_LOG_LENGTH, &messageLength);
    GLchar errorMessage[messageLength + 1];
    glGetProgramInfoLog(programID, messageLength, NULL, &errorMessage[0]);
    printf("%s\n", &errorMessage[0]);
  }

  // Cleanup
  glDetachShader(programID, vertexShaderID);
  glDetachShader(programID, fragmentShaderID);
        
  glDeleteShader(vertexShaderID);
  glDeleteShader(fragmentShaderID);

  return programID;
}

The Application that Invokes the OpenGL Drawing Commands

Initialize the environment (e.g., GLUT, GLEW, and OpenGL)
Read the shaders and create the program
Create the transformation matrices, lights, etc...
Create the vertex stream
Create the vertex buffer object
In the display loop, make the data available to the shaders and invoke the drawing commands