InitShader.cpp

#include <GL/glew.h>
#include <GL/freeglut.h>
#include <GL/freeglut_ext.h>

#include <fstream>
#include <iostream>
using namespace std;

//Adapted from Edward Angels InitShader code

// Create a NULL-terminated string by reading the provided file
static char* readShaderSource(const char* shaderFile)
{
   ifstream ifs(shaderFile, ios::in | ios::binary | ios::ate);
   if(ifs.is_open())
   {
      unsigned int filesize = static_cast<unsigned int>(ifs.tellg());
      ifs.seekg(0, ios::beg);
      char* bytes = new char[filesize + 1];
      memset(bytes, 0, filesize+1);
      ifs.read(bytes, filesize);
      ifs.close();
      return bytes;
   }
   return NULL;
}

void printShaderCompileError(GLuint shader)
{
   GLint  logSize;
   glGetShaderiv( shader, GL_INFO_LOG_LENGTH, &logSize );
   char* logMsg = new char[logSize];
   glGetShaderInfoLog( shader, logSize, NULL, logMsg );
   std::cerr << logMsg << std::endl;
   delete [] logMsg;

}

void printProgramLinkError(GLuint program)
{
   GLint  logSize;
   glGetProgramiv( program, GL_INFO_LOG_LENGTH, &logSize);
   char* logMsg = new char[logSize];
   glGetProgramInfoLog( program, logSize, NULL, logMsg );
   std::cerr << logMsg << std::endl;
   delete [] logMsg;
}

GLuint InitShader(const char* computeShaderFile)
{
   bool error = false;
   struct Shader 
   {
      const char*  filename;
      GLenum       type;
      GLchar*      source;
   }  shaders[1] = 
   {
      { computeShaderFile, GL_COMPUTE_SHADER, NULL }
   };

   GLuint program = glCreateProgram();
    
   for ( int i = 0; i < 1; ++i ) 
   {
      Shader& s = shaders[i];
      s.source = readShaderSource( s.filename );
      if ( shaders[i].source == NULL ) 
      {
         std::cerr << "Failed to read " << s.filename << std::endl;
         error = true;
      }

      GLuint shader = glCreateShader( s.type );
      glShaderSource( shader, 1, (const GLchar**) &s.source, NULL );
      glCompileShader( shader );

      GLint  compiled;
      glGetShaderiv( shader, GL_COMPILE_STATUS, &compiled );
      if ( !compiled ) 
      {
         std::cerr << s.filename << " failed to compile:" << std::endl;
         printShaderCompileError(shader);
         error = true;
      }

      delete [] s.source;

      glAttachShader( program, shader );
   }

   /* link  and error check */
   glLinkProgram(program);

   GLint  linked;
   glGetProgramiv( program, GL_LINK_STATUS, &linked );
   if ( !linked ) 
   {
      std::cerr << "Shader program failed to link" << std::endl;
      printProgramLinkError(program);

      error = true;
   }

   if(error == true)
   {
      return -1;
   }

   /* use program object */
   glUseProgram(program);

   return program;
}


// Create a GLSL program object from vertex and fragment shader files
GLuint InitShader(const char* vShaderFile, const char* fShaderFile)
{

   bool error = false;
   struct Shader 
   {
      const char*  filename;
      GLenum       type;
      GLchar*      source;
   }  shaders[2] = 
   {
      { vShaderFile, GL_VERTEX_SHADER, NULL },
      { fShaderFile, GL_FRAGMENT_SHADER, NULL }
   };

   GLuint program = glCreateProgram();
    
   for ( int i = 0; i < 2; ++i ) 
   {
      Shader& s = shaders[i];
      s.source = readShaderSource( s.filename );
      if ( shaders[i].source == NULL ) 
      {
         std::cerr << "Failed to read " << s.filename << std::endl;
         error = true;
      }

      GLuint shader = glCreateShader( s.type );
      glShaderSource( shader, 1, (const GLchar**) &s.source, NULL );
      glCompileShader( shader );

      GLint  compiled;
      glGetShaderiv( shader, GL_COMPILE_STATUS, &compiled );
      if ( !compiled ) 
      {
         std::cerr << s.filename << " failed to compile:" << std::endl;
         printShaderCompileError(shader);
         error = true;
      }

      delete [] s.source;

      glAttachShader( program, shader );
   }

   /* link  and error check */
   glLinkProgram(program);

   GLint  linked;
   glGetProgramiv( program, GL_LINK_STATUS, &linked );
   if ( !linked ) 
   {
      std::cerr << "Shader program failed to link" << std::endl;
      printProgramLinkError(program);

      error = true;
   }

   if(error == true)
   {
      return -1;
   }

   /* use program object */
   glUseProgram(program);
   return program;
}

// Create a GLSL program object from vertex and fragment shader files
GLuint InitShader(const char* vShaderFile, const char* gShaderFile, const char* fShaderFile)
{
   bool error = false;
   struct Shader 
   {
      const char*  filename;
      GLenum       type;
      GLchar*      source;
   }  shaders[3] = 
   {
      { vShaderFile, GL_VERTEX_SHADER, NULL },
      { gShaderFile, GL_GEOMETRY_SHADER, NULL },
      { fShaderFile, GL_FRAGMENT_SHADER, NULL }
   };

   GLuint program = glCreateProgram();
    
   for ( int i = 0; i < 3; ++i ) 
   {
      Shader& s = shaders[i];
      s.source = readShaderSource( s.filename );
      if ( shaders[i].source == NULL ) 
      {
         std::cerr << "Failed to read " << s.filename << std::endl;
         error = true;
      }

      GLuint shader = glCreateShader( s.type );
      glShaderSource( shader, 1, (const GLchar**) &s.source, NULL );
      glCompileShader( shader );

      GLint  compiled;
      glGetShaderiv( shader, GL_COMPILE_STATUS, &compiled );
      if ( !compiled ) 
      {
         std::cerr << s.filename << " failed to compile:" << std::endl;
         printShaderCompileError(shader);
         error = true;
      }

      delete [] s.source;

      glAttachShader( program, shader );
   }

   /* link  and error check */
   glLinkProgram(program);

   GLint  linked;
   glGetProgramiv( program, GL_LINK_STATUS, &linked );
   if ( !linked ) 
   {
      std::cerr << "Shader program failed to link" << std::endl;
      printProgramLinkError(program);

      error = true;
   }

   if(error == true)
   {
      return -1;
   }

   /* use program object */
   glUseProgram(program);

   return program;
}

GLuint InitShader( const char* vShaderFile, const char* tcShader, const char* teShader, const char* fShaderFile )
{
   bool error = false;
   struct Shader 
   {
      const char*  filename;
      GLenum       type;
      GLchar*      source;
   }  shaders[4] = 
   {
      { vShaderFile, GL_VERTEX_SHADER, NULL },
      { tcShader, GL_TESS_CONTROL_SHADER, NULL },
      { teShader, GL_TESS_EVALUATION_SHADER, NULL },
      { fShaderFile, GL_FRAGMENT_SHADER, NULL }
   };

   GLuint program = glCreateProgram();
    
   for ( int i = 0; i < 4; ++i ) 
   {
      Shader& s = shaders[i];
      s.source = readShaderSource( s.filename );
      if ( shaders[i].source == NULL ) 
      {
         std::cerr << "Failed to read " << s.filename << std::endl;
         error = true;
      }

      GLuint shader = glCreateShader( s.type );
      glShaderSource( shader, 1, (const GLchar**) &s.source, NULL );
      glCompileShader( shader );

      GLint  compiled;
      glGetShaderiv( shader, GL_COMPILE_STATUS, &compiled );
      if ( !compiled ) 
      {
         std::cerr << s.filename << " failed to compile:" << std::endl;
         printShaderCompileError(shader);
         error = true;
      }

      delete [] s.source;

      glAttachShader( program, shader );
   }

   /* link  and error check */
   glLinkProgram(program);

   GLint  linked;
   glGetProgramiv( program, GL_LINK_STATUS, &linked );
   if ( !linked ) 
   {
      std::cerr << "Shader program failed to link" << std::endl;
      printProgramLinkError(program);

      error = true;
   }

   if(error == true)
   {
      return -1;
   }

   /* use program object */
 //  glUseProgram(program);

   return program;
}