C:/Projekte/C++/FlowVIS_107/src/Shader.cpp

Go to the documentation of this file.

#include "Shader.h"

Shader::Shader(void)
{
  // do nothing
}

Shader::~Shader(void)
{
  glDeleteShader(m_fragment);
  glDeleteShader(m_vertex);
  glDeleteShader(m_program);
}

Shader::Shader(const char* in_vert, const char* in_frag)
{
  Load(in_vert, in_frag);
}

bool Shader::Load(const char* in_vert, const char* in_frag)
{
  char* vert = ReadFromFile(in_vert);
  char* frag = ReadFromFile(in_frag);

  if(vert == NULL || frag == NULL)
  {
    printf("Failed to load Shader\n");
    exit(0);
  }
  else
  {
    const char* v = vert;
    const char* f = frag;

    m_vertex = glCreateShader(GL_VERTEX_SHADER);
    m_fragment = glCreateShader(GL_FRAGMENT_SHADER);

    glShaderSource(m_vertex, 1, &v, NULL);
    glShaderSource(m_fragment, 1, &f, NULL);

    free(vert);
    free(frag);

    // compile shaders
    glCompileShader(m_vertex);
    glCompileShader(m_fragment);

    // check for errors
    ShaderLog(m_vertex);
    ShaderLog(m_fragment);

    // create shader program 
    m_program = glCreateProgram();

    // attach shader to program
    glAttachShader(m_program, m_vertex);
    glAttachShader(m_program, m_fragment);

    glLinkProgram(m_program);

    // check for errors
    ProgramLog(m_program);

    glUseProgram(0);
  }
  return true;
}

char* Shader::ReadFromFile( const char* shaderFile ) 
{
  FILE *file;
  char *content = NULL;
  int   count   = 0;

  if ( shaderFile != NULL ) {
    fopen_s( &file, shaderFile, "rt" );

    if (file != NULL) {
      fseek( file, 0, SEEK_END );
      count = ftell( file );
      rewind( file );

      if ( count > 0 ) {
        content = (char*) malloc( sizeof(char) * (count + 1) );
        count   = (int) fread( content, sizeof(char), count, file );
        content[count] = '\0';
      }
      fclose( file );
    }
  }
  return content;
}

void Shader::ShaderLog(GLuint obj)
{
  // compile status
  GLint compileStatus;
  GLint shaderType;

  glGetShaderiv(obj, GL_COMPILE_STATUS, &compileStatus);
  glGetShaderiv(obj, GL_SHADER_TYPE, &shaderType);

  printOglError("ShaderLog: \n");

  // if error occurs
  if(shaderType == GL_VERTEX_SHADER && compileStatus == GL_FALSE)
  {
    printf("Error: Compiling Vertex Shader\n");
  }

  if(shaderType == GL_FRAGMENT_SHADER && compileStatus == GL_FALSE)
  {
    printf("Error: Compiling Fragment Shader\n");
  }

  int infologLength = 0;
  int charsWritten  = 0;
  char *infoLog;

  glGetShaderiv(obj, GL_INFO_LOG_LENGTH,&infologLength);

  if (infologLength > 0)
  {
    infoLog = (char *)malloc(infologLength);
    glGetShaderInfoLog(obj, infologLength, &charsWritten, infoLog);
    printf("%s\n",infoLog);
    free(infoLog);
  }

  printOglError("ShaderLog\n");
}

void Shader::ProgramLog(GLuint obj)
{
  // link status
  int linkStatus;

  glGetProgramiv(m_program, GL_LINK_STATUS, &linkStatus);

  printOglError("ProgramLog");

  if(linkStatus == GL_FALSE)
  {
    printf("Error: Linking program\n");
  }

  // program info log
  int infologLength = 0;
  int charsWritten  = 0;
  char *infoLog;

  glGetProgramiv(obj, GL_INFO_LOG_LENGTH,&infologLength);

  if (infologLength > 0)
  {
    infoLog = (char *)malloc(infologLength);
    glGetProgramInfoLog(obj, infologLength, &charsWritten, infoLog);
    printf("%s\n",infoLog);
    free(infoLog);
  }
}

void Shader::Bind()
{
  glUseProgram(m_program);
}

void Shader::Unbind()
{
  glUseProgram(0);
}

GLuint Shader::GetProgram()
{
  return m_program;
}

---