source: orxonox.OLD/branches/bsp_model/src/lib/graphics/shader.cc @ 8432

/*
   orxonox - the future of 3D-vertical-scrollers

   Copyright (C) 2004 orx

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   ### File Specific:
   main-programmer: Benjamin Grauer
   co-programmer: ...
*/

//#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_

#include "shader.h"

#include "stdlibincl.h"
#include "compiler.h"
//#include <stdio.h>
#include <fstream>

#include "debug.h"

#include "util/loading/resource_manager.h"


#ifndef PARSELINELENGTH
#define PARSELINELENGTH     512       //!< how many chars to read at once
#endif

using namespace std;


/**
 * standard constructor
*/
Shader::Shader (const std::string& vertexShaderFile, const std::string& fragmentShaderFile)
{
   this->setClassID(CL_SHADER, "Shader");

   this->shaderProgram = 0;
   this->vertexShader = 0;
   this->fragmentShader = 0;

   if (GLEW_ARB_shader_objects && GLEW_ARB_shading_language_100)
     {
       this->shaderProgram = glCreateProgramObjectARB();

       if (!vertexShaderFile.empty())
         this->loadShaderProgramm(Shader::Vertex, vertexShaderFile);
       if (!fragmentShaderFile.empty())
         this->loadShaderProgramm(Shader::Fragment, fragmentShaderFile);

       this->linkShaderProgram();

    }
   else
     {
       PRINTF(2)("Shaders are not supported on your hardware\n");
     }
}


/**
 * standard deconstructor
 */
Shader::~Shader ()
{
  if (this->shaderProgram == glGetHandleARB(GL_PROGRAM_OBJECT_ARB))
    Shader::deactivateShader();

  // delete what has to be deleted here
  this->deleteProgram(Shader::Vertex);
  this->deleteProgram(Shader::Fragment);

  if (this->fragmentShader != 0)
  {
    glDetachObjectARB(this->shaderProgram, this->fragmentShader);
    glDeleteObjectARB(this->fragmentShader);
  }
  if (this->vertexShader != 0)
  {
    glDetachObjectARB(this->shaderProgram, this->vertexShader);
    glDeleteObjectARB(this->vertexShader);
  }
  if (this->shaderProgram != 0)
  {
    GLint status = 0;
    //glLinkProgramARB(this->shaderProgram);
    glDeleteObjectARB(this->shaderProgram);
       // link error checking
    glGetObjectParameterivARB(this->shaderProgram, GL_OBJECT_DELETE_STATUS_ARB, &status);
    if (status == GL_INVALID_VALUE || status == GL_INVALID_OPERATION)
      this->printError(this->shaderProgram);
  }
}

Shader* Shader::getShader(const std::string& vertexShaderFile, const std::string& fragmentShaderFile)
{
  return (Shader*)ResourceManager::getInstance()->load(vertexShaderFile, SHADER,  RP_LEVEL, fragmentShaderFile);
}

bool Shader::unload(Shader* shader)
{
  return ResourceManager::getInstance()->unload(shader);
}

Shader* Shader::storedShader = NULL;


bool Shader::loadShaderProgramm(Shader::Type type, const std::string& fileName)
{
  GLhandleARB shader = 0;

  if (type != Shader::Vertex && type != Shader::Fragment)
    return false;
  this->deleteProgram(type);


  std::string program;
  if (!readShader(fileName, program))
    return false;

  if (type == Shader::Vertex && GLEW_ARB_vertex_shader)
  {
    this->vertexShaderFile = fileName;

    shader = this->vertexShader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
  }

  if (type == Shader::Fragment && GLEW_ARB_fragment_shader)
  {
    this->fragmentShaderFile = fileName;

    shader = this->fragmentShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
  }

  if (shader != 0)
  {
    GLint status = 0;
    const char* prog = program.c_str();

    glShaderSourceARB(shader, 1, &prog, NULL);
    glCompileShaderARB(shader);
    // checking on error.
    glGetObjectParameterivARB(shader, GL_OBJECT_COMPILE_STATUS_ARB, &status);
    if (status == GL_INVALID_VALUE || status == GL_INVALID_OPERATION)
      this->printError(shader);
    else
      glAttachObjectARB(this->shaderProgram, shader);
  }
}


void Shader::linkShaderProgram()
{
  GLint status = 0;

  glLinkProgramARB(this->shaderProgram);
       // link error checking
  glGetObjectParameterivARB(this->shaderProgram, GL_OBJECT_LINK_STATUS_ARB, &status);
  if (status == GL_INVALID_VALUE || status == GL_INVALID_OPERATION)
    this->printError(this->shaderProgram);
}


bool Shader::readShader(const std::string& fileName, std::string& output)
{
  char lineBuffer[PARSELINELENGTH];

  std::ifstream shader;
  shader.open(fileName.c_str());
  if (!shader.is_open())
    return false;


  while (!shader.eof())
  {
    shader.getline(lineBuffer, PARSELINELENGTH);
    output += lineBuffer;
    output += "\n";
  }


  shader.close();
  return true;
}



void Shader::activateShader()
{
  if (likely (this->shaderProgram != 0))
  {
    glUseProgramObjectARB(this->shaderProgram);
    Shader::storedShader = this;
  }
}

void Shader::deactivateShader()
{
 if (storedShader != NULL)
   glUseProgramObjectARB(0);
 Shader::storedShader = NULL;
}


void Shader::deleteProgram(Shader::Type type)
{
  GLint status = 0;
  if (type == Shader::Vertex && this->vertexShader != 0)
  {
    this->vertexShaderFile = "";
    glDetachObjectARB(this->shaderProgram, this->vertexShader);
    glDeleteObjectARB(this->vertexShader);
    glGetObjectParameterivARB(this->vertexShader, GL_OBJECT_DELETE_STATUS_ARB, &status);
    if (status == GL_INVALID_VALUE || status == GL_INVALID_OPERATION)
      Shader::printError(this->vertexShader);
    this->vertexShader = 0;
  }
  else if (type == Shader::Fragment && this->fragmentShader != 0)
  {
    this->fragmentShaderFile = "";
    glDetachObjectARB(this->shaderProgram, this->fragmentShader);
    glDeleteObjectARB(this->fragmentShader);
    glGetObjectParameterivARB(this->fragmentShader, GL_OBJECT_DELETE_STATUS_ARB, &status);
    if (status == GL_INVALID_VALUE || status == GL_INVALID_OPERATION)
      Shader::printError(this->fragmentShader);
    this->fragmentShader = 0;
  }
  else
    return;
}


void Shader::printError(GLhandleARB program)
{
  if (program == 0)
    return;

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

  glGetObjectParameterivARB(program, GL_OBJECT_INFO_LOG_LENGTH_ARB,
                            &infologLength);

  if (infologLength > 0)
  {
    infoLog = new char[infologLength+1];
    glGetInfoLogARB(program, infologLength, &charsWritten, infoLog);
    printf("%s\n", infoLog);
    delete[] infoLog;
  }
}

bool Shader::checkShaderAbility()
{
  if (GLEW_ARB_shader_objects &&
      GLEW_ARB_shading_language_100 &&
      GLEW_ARB_vertex_shader &&
      GLEW_ARB_fragment_shader)
    return true;
  else
    return false;
}

void Shader::debug() const
{
  PRINT(3)("Shader info: (SHADER: %d)\n", this->shaderProgram);
  if (this->vertexShader != 0)
  {
/*    PRINT(3)("VertexShaderProgramm: number=%d, file='%s'\n", this->vertexShader, this->vertexShaderFile);
    if (this->vertexShaderSource != NULL)
      for (unsigned int i = 0; i < this->vertexShaderSource->getCount(); i++)
        PRINT(3)("%d: %s\n", i, this->vertexShaderSource->getEntry(i));
  }
  if (this->fragmentShader != 0)
  {
    PRINT(3)("FragmentShaderProgramm: number=%d, file='%s'\n", this->fragmentShader, this->fragmentShaderFile);
    if (this->fragmentShaderSource != NULL)
      for (unsigned int i = 0; i < this->fragmentShaderSource->getCount(); i++)
        PRINT(3)("%d: %s\n", i, this->fragmentShaderSource->getEntry(i));*/
  }
}