There's not much to prepare for with this one, you just need a build environment that supports C++. Also, I'll assume that you are using GLM for matrix and vector support, if not just leave out the functions involving the GLM classes.

First, we'll use a custom exception class for errors that might occur during compilation or linking:

class GLSLProgramException : public std::runtime_error {
public:
  GLSLProgramException( const string & msg ) : std::runtime_error(msg) { }
};

We'll use an enum for the various shader types:

namespace GLSLShader {
  enum GLSLShaderType {
        VERTEX = GL_VERTEX_SHADER, 
        FRAGMENT = GL_FRAGMENT_SHADER, 
        GEOMETRY = GL_GEOMETRY_SHADER, 
        TESS_CONTROL = GL_TESS_CONTROL_SHADER, 
        TESS_EVALUATION = GL_TESS_EVALUATION_SHADER, 
        COMPUTE = GL_COMPUTE_SHADER
  };
};

The program class itself has the following interface:

class GLSLProgram
{
private:
  int  handle;
  bool linked;
  std::map<string, int> uniformLocations;

  int  getUniformLocation(const char * name );

   // A few other helper functions

public:
  GLSLProgram();
  ~GLSLProgram();

  void compileShader( const char * filename )throw(GLSLProgramException);
  void compileShader( const char * filename, GLSLShader::GLSLShaderType type )throw(GLSLProgramException);
  void compileShader( const string & source, GLSLShader::GLSLShaderType type,const char * filename = NULL )throw(GLSLProgramException);
  void link()      throw(GLSLProgramException);
  void use()       throw(GLSLProgramException);
  void validate()  throw(GLSLProgramException);

  int    getHandle();
  bool   isLinked();

  void   bindAttribLocation( GLuint location, const char * name);
  void   bindFragDataLocation( GLuint location, const char * name );
  void   setUniform(const char *name, float x, float y,float z);
  void   setUniform(const char *name, const vec3 & v);
  void   setUniform(const char *name, const vec4 & v);
  void   setUniform(const char *name, const mat4 & m);
  void   setUniform(const char *name, const mat3 & m);
  void   setUniform(const char *name, float val );
  void   setUniform(const char *name, int val );
  void   setUniform(const char *name, bool val );

  void   printActiveUniforms();
  void   printActiveAttribs();
  void   printActiveUniformBlocks();
};

The techniques involved in the implementation of these functions are covered in previous recipes in this chapter. Due to space limitations, I won't include the code here (it's available from this book's GitHub repository), but we'll discuss some of the design decisions in the next section.

The state stored within a GLSLProgram object includes the handle to the OpenGL shader program object (handle), a Boolean variable indicating whether or not the program has been successfully linked (linked), and a map used to store uniform locations as they are discovered (uniformLocations).

The compileShader overloads will throw a GLSLProgramException if the compilation fails. The first version determines the type of shader based on the filename extension. In the second version, the caller provides the shader type, and the third version is used to compile a shader, taking the shader's source code from a string. The file name can be provided as a third argument in the case that the string was taken from a file, which is helpful for providing better error messages.

The GLSLProgramException's error message will contain the contents of the shader log or program log when an error occurs.

The private function getUniformLocation is used by the setUniform functions to find the location of a uniform variable. It checks the map uniformLocations first, and if the location is not found, queries OpenGL for the location, and stores the result in the map before returning. The fileExists function is used by compileShaderFromFile to check for file existence.

The constructor simply initializes linked to false and handle to zero. The variable handle will be initialized by calling glCreateProgram when the first shader is compiled.

The link function simply attempts to link the program by calling glLinkProgram. It then checks the link status, and if successful, sets the variable linked to true and returns true. Otherwise, it gets the program log (by calling glGetProgramInfoLog), stores the result in a GLSLProgramException and throws it.

The use function simply calls glUseProgram if the program has already been successfully linked, otherwise it does nothing.

The functions getHandle and isLinked are simply "getter" functions that return the handle to the OpenGL program object and the value of the linked variable.

The functions bindAttribLocation and bindFragDataLocation are wrappers around glBindAttribLocation and glBindFragDataLocation. Note that these functions should only be called prior to linking the program.

The setUniform overloaded functions are straightforward wrappers around the appropriate glUniform functions. Each of them calls getUniformLocation to query for the variable's location before calling the glUniform function.

Finally, the printActiveUniforms, printActiveUniformBlocks, and printActiveAttribs functions are useful for debugging purposes. They simply display a list of the active uniforms/attributes to standard output.

The following is a simple example of the use of the GLSLProgram class:

GLSLProgram prog;

try {
  prog.compileShader("myshader.vert");
  prog.compileShader("myshader.frag");
  prog.link();
  prog.validate();
  prog.use();
} catch( GLSLProgramException &e ) {
  cerr << e.what() << endl;
  exit(EXIT_FAILURE);
}


prog.printActiveUniforms();
prog.printActiveAttribs();

prog.setUniform("ModelViewMatrix", matrix);
prog.setUniform("LightPosition", 1.0f, 1.0f, 1.0f);