aglsl.cpp

GLSL tutorial with sourcecode

    return true;
}

//----------------------------------------------------------------------------- 

bool aShaderObject::sendUniform3fv(char* varname, GLsizei count, GLfloat *value)
{
    if (!useGLSL) return false; // GLSL not available
    if (!_noshader) return true;
    
    GLint loc = GetUniLoc(varname);
    if (loc==-1) return false;  // can't find variable
    
    glUniform3fvARB(loc, count, value);

    return true;
}

//----------------------------------------------------------------------------- 

bool aShaderObject::sendUniform4fv(char* varname, GLsizei count, GLfloat *value)
{
    if (!useGLSL) return false; // GLSL not available
    if (!_noshader) return true;
    
    GLint loc = GetUniLoc(varname);
    if (loc==-1) return false;  // can't find variable
    
    glUniform4fvARB(loc, count, value);

    return true;
}

//----------------------------------------------------------------------------- 

bool aShaderObject::sendUniform1iv(char* varname, GLsizei count, GLint *value)
{
    if (!useGLSL) return false; // GLSL not available
    if (!_noshader) return true;
    
    GLint loc = GetUniLoc(varname);
    if (loc==-1) return false;  // can't find variable
    
    glUniform1ivARB(loc, count, value);

    return true;
}

//----------------------------------------------------------------------------- 

bool aShaderObject::sendUniform2iv(char* varname, GLsizei count, GLint *value)
{
    if (!useGLSL) return false; // GLSL not available
    if (!_noshader) return true;
    
    GLint loc = GetUniLoc(varname);
    if (loc==-1) return false;  // can't find variable
    
    glUniform2ivARB(loc, count, value);

    return true;
}

//----------------------------------------------------------------------------- 

bool aShaderObject::sendUniform3iv(char* varname, GLsizei count, GLint *value)
{
    if (!useGLSL) return false; // GLSL not available
    if (!_noshader) return true;
    
    GLint loc = GetUniLoc(varname);
    if (loc==-1) return false;  // can't find variable
    
    glUniform3ivARB(loc, count, value);

    return true;
}

//----------------------------------------------------------------------------- 

bool aShaderObject::sendUniform4iv(char* varname, GLsizei count, GLint *value)
{
    if (!useGLSL) return false; // GLSL not available
    if (!_noshader) return true;
    
    GLint loc = GetUniLoc(varname);
    if (loc==-1) return false;  // can't find variable
    
    glUniform4ivARB(loc, count, value);

    return true;
}

//----------------------------------------------------------------------------- 

bool aShaderObject::sendUniformMatrix2fv(char* varname, GLsizei count, GLboolean transpose, GLfloat *value)
{
    if (!useGLSL) return false; // GLSL not available
    if (!_noshader) return true;
    
    GLint loc = GetUniLoc(varname);
    if (loc==-1) return false;  // can't find variable
    
    glUniformMatrix2fvARB(loc, count, transpose, value);

    return true;
}

//----------------------------------------------------------------------------- 

bool aShaderObject::sendUniformMatrix3fv(char* varname, GLsizei count, GLboolean transpose, GLfloat *value)
{
    if (!useGLSL) return false; // GLSL not available
    if (!_noshader) return true;
    
    GLint loc = GetUniLoc(varname);
    if (loc==-1) return false;  // can't find variable
    
    glUniformMatrix3fvARB(loc, count, transpose, value);

    return true;
}

//----------------------------------------------------------------------------- 

bool aShaderObject::sendUniformMatrix4fv(char* varname, GLsizei count, GLboolean transpose, GLfloat *value)
{
    if (!useGLSL) return false; // GLSL not available
    if (!_noshader) return true;
    
    GLint loc = GetUniLoc(varname);
    if (loc==-1) return false;  // can't find variable
    
    glUniformMatrix4fvARB(loc, count, transpose, value);

    return true;
}

//----------------------------------------------------------------------------- 

GLint aShaderObject::GetUniLoc(const GLcharARB *name)
{
	GLint loc;

	loc = glGetUniformLocationARB(ShaderObject, name);
	if (loc == -1) 
	{
        cout << "Error: can't find uniform variable \"" << name << "\"\n";
	}
    CHECK_GL_ERROR();
	return loc;
}

//----------------------------------------------------------------------------- 

void aShaderObject::GetUniformfv(char* name, GLfloat* values)
{
if (!useGLSL) return;
    GLint loc;

	loc = glGetUniformLocationARB(ShaderObject, name);
	if (loc == -1) 
	{
        cout << "Error: can't find uniform variable \"" << name << "\"\n";
	}
	glGetUniformfvARB(ShaderObject, loc, values);
	
}

//----------------------------------------------------------------------------- 

void aShaderObject::GetUniformiv(char* name, GLint* values)
{
if (!useGLSL) return;


    GLint loc;

	loc = glGetUniformLocationARB(ShaderObject, name);
	if (loc == -1) 
	{
        cout << "Error: can't find uniform variable \"" << name << "\"\n";
	}
	
	glGetUniformivARB(ShaderObject, loc, values);

}

bool  aShaderObject::_noshader = true;

// ************************************************************************
// Shader Program : Manage Shader Programs (Vertex/Fragment)
// ************************************************************************


aShaderProgram::aShaderProgram()
{
    initGLSL();
    compiler_log = 0;
    is_compiled = false;
    program_type = 0;
    ProgramObject = 0;
    ShaderSource = 0;
    _memalloc = false;
   
}

//----------------------------------------------------------------------------- 

aShaderProgram::~aShaderProgram()
{
   if (compiler_log!=0) free(compiler_log);
   if (ShaderSource!=0)   
   {
        if (_memalloc)
            delete[] ShaderSource;  // free ASCII Source
   }
   
   if (is_compiled)
   { 
        glDeleteObjectARB(ProgramObject);
        CHECK_GL_ERROR();
   }
}

//----------------------------------------------------------------------------- 
unsigned long getFileLength(ifstream& file)
{
    if(!file.good()) return 0;
    
    unsigned long pos=file.tellg();
    file.seekg(0,ios::end);
    unsigned long len = file.tellg();
    file.seekg(ios::beg);
    
    return len;
}


//----------------------------------------------------------------------------- 

int aShaderProgram::load(char* filename)
{
    ifstream file;
    file.open(filename, ios::in);
    if(!file) return -1;
    
    unsigned long len = getFileLength(file);
    
    if (len==0) return -2;   // "Empty File" 
    
    if (ShaderSource!=0)    // there is already a source loaded, free it!
    {
        if (_memalloc)
        delete[] ShaderSource;
    }
    
    ShaderSource = (GLubyte*) new char[len+1];
    if (ShaderSource == 0) return -3;   // can't reserve memory
    _memalloc = true;
    
    
    ShaderSource[len] = 0;  // len isn't always strlen cause some characters are stripped in ascii read...
                            // it is important to 0-terminate the real length later, len is just max possible value...
   
    unsigned int i=0;
    while (file.good())
    {
        ShaderSource[i++] = file.get();       // get character from file
        if (i>len) i=len;   // coding guidelines...
    }
    
    ShaderSource[i] = 0;  // 0 terminate it.
    
    file.close();
      
return 0;
}

//----------------------------------------------------------------------------- 

void aShaderProgram::loadFromMemory(const char* program)
{
    if (ShaderSource!=0)    // there is already a source loaded, free it!
    {
        if (_memalloc)
        delete[] ShaderSource;
    }
   _memalloc = false;
   ShaderSource = (GLubyte*) program;
      
}


// ----------------------------------------------------
// Compiler Log: Ausgabe der Compiler Meldungen in String

char* aShaderProgram::getCompilerLog(void)
{    
if (!useGLSL) return aGLSLErrorString[0];
 
 int blen = 0;	
 int slen = 0;	


 if (ProgramObject==0) return aGLSLErrorString[1];

 glGetObjectParameterivARB(ProgramObject, GL_OBJECT_INFO_LOG_LENGTH_ARB , &blen);
 CHECK_GL_ERROR();

 if (blen > 1)
 {
    if (compiler_log!=0) 
    {   
        free(compiler_log);
        compiler_log =0;
    }
    if ((compiler_log = (GLcharARB*)malloc(blen)) == NULL) 
     {
        printf("ERROR: Could not allocate compiler_log buffer\n");
        return aGLSLErrorString[3];
    }

     glGetInfoLogARB(ProgramObject, blen, &slen, compiler_log);
     CHECK_GL_ERROR();
     //cout << "compiler_log: \n", compiler_log);     
 }
 if (compiler_log!=0)
    return (char*) compiler_log;    

    return aGLSLErrorString[4];
}

// ----------------------------------------------------

bool aShaderProgram::compile(void)
{
if (!useGLSL) return false;

is_compiled = false;

int compiled = 0;

  if (ShaderSource==0) return false;

  GLint	length = (GLint) strlen((const char*)ShaderSource);
  glShaderSourceARB(ProgramObject, 1, (const GLcharARB **)&ShaderSource, &length);
  CHECK_GL_ERROR();

  glCompileShaderARB(ProgramObject); 
  CHECK_GL_ERROR();
  glGetObjectParameterivARB(ProgramObject, GL_OBJECT_COMPILE_STATUS_ARB, &compiled);
  CHECK_GL_ERROR();

  if (compiled) is_compiled=true;
 
return is_compiled;
}

// ----------------------------------------------------


aVertexShader::aVertexShader()
{
  program_type = 1; 
   if (useGLSL)
   {
       ProgramObject = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
       CHECK_GL_ERROR();
   }
}

// ----------------------------------------------------

aVertexShader::~aVertexShader()
{
}

// ----------------------------------------------------

aFragmentShader::aFragmentShader()
{
    program_type = 2;
    if (useGLSL)
    {
        ProgramObject = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB); 
        CHECK_GL_ERROR();
    }
}

// ----------------------------------------------------

aFragmentShader::~aFragmentShader()
{
}

// ----------------------------------------------------------------------------
// ShaderManager: Easy use of (multiple) Shaders

aShaderManager::aShaderManager()
{

}

aShaderManager::~aShaderManager()
{
   // free objects
   vector<aShaderObject*>::iterator  i=_shaderObjectList.begin();
   while (i!=_shaderObjectList.end()) 
   {
        aShaderObject* o = *i;
        i=_shaderObjectList.erase(i);
        delete o;
   }
}

// ----------------------------------------------------------------------------

aShaderObject* aShaderManager::loadfromFile(char* vertexFile, char* fragmentFile) 
{
   aShaderObject* o = new aShaderObject();
  
   aVertexShader* tVertexShader = new aVertexShader;
   aFragmentShader* tFragmentShader = new aFragmentShader;

    // load vertex program
   if (vertexFile!=0)
   if (tVertexShader->load(vertexFile) != 0)
   { 
     cout << "error: can't load vertex shader!\n"; 
     delete o;
     delete tVertexShader;
     delete tFragmentShader;
     return 0;
   }
  
  // Load fragment program
  if (fragmentFile!=0)
  if (tFragmentShader->load(fragmentFile) != 0)
  {
     cout << "error: can't load fragment shader!\n";
     delete o;
     delete tVertexShader;
     delete tFragmentShader;
     return 0;
  }
  
  // Compile vertex program
  if (vertexFile!=0)
  if (!tVertexShader->compile())
  {
      cout << "***COMPILER ERROR (Vertex Shader):\n";
      cout << tVertexShader->getCompilerLog() << endl;
      delete o;
      delete tVertexShader;
      delete tFragmentShader;
      return 0;
  }
   
  // Compile fragment program 
  if (fragmentFile!=0)
  if (!tFragmentShader->compile())
  {
     cout << "***COMPILER ERROR (Fragment Shader):\n";
     cout << tFragmentShader->getCompilerLog() << endl;
     
     delete o;
     delete tVertexShader;
     delete tFragmentShader;
     return 0;
     
  }
   
  // Add to object    
  if (vertexFile!=0) o->addShader(tVertexShader);
  if (fragmentFile!=0) o->addShader(tFragmentShader); 
  
  // link 
  if (!o->link())
  {
     cout << "**LINKER ERROR\n";
     cout << o->getLinkerLog() << endl;
     delete o;
     delete tVertexShader;
     delete tFragmentShader;
     return 0;
  }
  
  _shaderObjectList.push_back(o);
  o->manageMemory();

   return o;
}

// ----------------------------------------------------------------------------

aShaderObject* aShaderManager::loadfromMemory(const char* vertexMem, const char* fragmentMem)
{
  aShaderObject* o = new aShaderObject();
  
  aVertexShader* tVertexShader = new aVertexShader;
  aFragmentShader* tFragmentShader = new aFragmentShader;

  // get vertex program
  if (vertexMem!=0)
     tVertexShader->loadFromMemory(vertexMem);
  
  // get fragment program
  if (fragmentMem!=0)
     tFragmentShader->loadFromMemory(fragmentMem);
 
  // Compile vertex program
  if (vertexMem!=0)
  if (!tVertexShader->compile())
  {
      cout << "***COMPILER ERROR (Vertex Shader):\n";
      cout << tVertexShader->getCompilerLog() << endl;
      delete o;
      delete tVertexShader;
      delete tFragmentShader;
      return 0;
  }
   
  // Compile fragment program 
  if (fragmentMem!=0)
  if (!tFragmentShader->compile())
  {
     cout << "***COMPILER ERROR (Fragment Shader):\n";
     cout << tFragmentShader->getCompilerLog() << endl;
     
     delete o;
     delete tVertexShader;
     delete tFragmentShader;
     return 0;
     
  }
   
  // Add to object    
  if (vertexMem!=0) o->addShader(tVertexShader);
  if (fragmentMem!=0) o->addShader(tFragmentShader); 
  
  // link 
  if (!o->link())
  {
     cout << "**LINKER ERROR\n";
     cout << o->getLinkerLog() << endl;
     delete o;
     delete tVertexShader;
     delete tFragmentShader;
     return 0;
  }

  _shaderObjectList.push_back(o);
  o->manageMemory();

   return o;
}

// ----------------------------------------------------------------------------

 bool  aShaderManager::free(aShaderObject* o)
 {
   vector<aShaderObject*>::iterator  i=_shaderObjectList.begin();
   while (i!=_shaderObjectList.end()) 
   {
        if ((*i)==o)
        {
            _shaderObjectList.erase(i);
            delete o;
            return true;
        }
        i++;
   }   
   return false;
 }

// ----------------------------------------------------------------------------