fragProgARB.cpp

Go to the documentation of this file.

//////////////////////////////////////////////////////////////////////
// 12/7/02 Aaron Lefohn Scientific Computing and Imaging Institute
// School of Computing          University of Utah
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Lesser General Public
//  License as published by the Free Software Foundation; either
//  version 2.1 of the License, or (at your option) any later version.
//
//  This library is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//  Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with this library; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
/////////////////////////////////////////////////////////////////////////
//
// FragProgARB.cpp: interface for the FragProgARB class.
//
// - Class for an ARB fragment program.
//////////////////////////////////////////////////////////////////////

#include <state/fragProgARB.h>
#include <string.h>
#include <iostream>
#include <stdio.h>

using namespace std;
using namespace glift;
using namespace gutz;

////////////////////////////////////////////////////////////////////////
/// construct
////////////////////////////////////////////////////////////////////////

FragProgARB::FragProgARB( const char *fragProg, bool isFileName, PBuffGlift* pbuff, bool noload)
: m_fragProg(0), m_fragProgFile(0), m_shaderNum(0), m_pbuff(0)
{
   initMembers( fragProg, isFileName, 0, pbuff );
   if(!noload)
      this->init();
}

////////////////////////////////////////////////////////////////////////
/// copy construct
////////////////////////////////////////////////////////////////////////

FragProgARB::FragProgARB( const FragProgARB &rhs)
{
   initMembers(rhs);
}

////////////////////////////////////////////////////////////////////////
/// assign
////////////////////////////////////////////////////////////////////////
FragProgARB& FragProgARB::operator=( const FragProgARB& rhs )
{
   initMembers(rhs);
   return *this;
}

////////////////////////////////////////////////////////////////////////
/// init members
////////////////////////////////////////////////////////////////////////

void FragProgARB::initMembers( const char *fragProg, bool isFileName, GLuint shaderNum, PBuffGlift* pbuff )
{
   if(!glew.ARB_fragment_program)
   {
      err() << "initMembers() Error:\n"
         << "\tGL_ARB_fragment_program is not available.\n"
         << "\tFragProgARB only available if using an ATI >= 9700 GPU.\n";
      exit(1);
   }

   if(isFileName)
   {
      if(m_fragProgFile) delete [] m_fragProgFile;
      m_fragProgFile = new char[strlen(fragProg)+1];
      assert(m_fragProgFile);
      strcpy(m_fragProgFile, fragProg); // Copy from 'fragProg' to 'm_fragProgFile'

      FILE *fp;
      int length;

      if (!(fp = fopen(fragProg,"rb")))
      {
         err() << "initMembers() error: " << fragProg << " could not be read " << endl;
         return;
      }

      fseek(fp, 0, SEEK_END);
      length = ftell(fp);
      fseek(fp, 0, SEEK_SET);

      if(m_fragProg) delete [] m_fragProg;
      m_fragProg = new char[length+1];
      assert(m_fragProg);

      fread( m_fragProg, 1, length, fp);
      m_fragProg[length] = '\0'; // make it a regular C string
      fclose(fp);
   }
   else  //fragProg is the program itself
   {
      if(m_fragProg) {delete [] m_fragProg;}
      m_fragProg = new char[strlen(fragProg)+1];
      assert(m_fragProg);

      strcpy(m_fragProg, fragProg); // Copy from 'fragProg' to 'm_fragProg'
   }    
   m_shaderNum = shaderNum;
   m_pbuff     = pbuff;
   glGetProgramivARB( GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, &m_maxLocalParams );
}

////////////////////////////////////////////////////////////////////////
/// init members, copy
////////////////////////////////////////////////////////////////////////

void FragProgARB::initMembers( const FragProgARB &rhs)
{
   if(rhs.m_fragProg)
   {
      if(m_fragProg) delete[] m_fragProg;
      m_fragProg = new char[strlen(rhs.m_fragProg)];
      strcpy(m_fragProg, rhs.m_fragProg);
   }    
   if(rhs.m_fragProgFile)
   {
      if(m_fragProgFile) delete[] m_fragProgFile;
      m_fragProgFile = new char[strlen(rhs.m_fragProgFile)];
      strcpy(m_fragProgFile, rhs.m_fragProgFile);
   }

   m_shaderNum = rhs.m_shaderNum;
   m_pbuff     = rhs.m_pbuff;
   glGetProgramivARB( GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, &m_maxLocalParams );
}

////////////////////////////////////////////////////////////////////////
/// destruct
////////////////////////////////////////////////////////////////////////

FragProgARB::~FragProgARB()
{
   destroy();
   if(m_fragProg) delete [] m_fragProg;
   m_fragProg = 0;
   if(m_fragProgFile) delete [] m_fragProgFile;
   m_fragProgFile = 0;
}

////////////////////////////////////////////////////////////////////////
/// destroy
////////////////////////////////////////////////////////////////////////

void FragProgARB::destroy()
{
   if( m_pbuff ) {
      m_pbuff->enable(true);
   }

   if(glew.ARB_fragment_program)
   {
      glDeleteProgramsARB(1, &m_shaderNum );
      m_shaderNum = 0;
   }

   if( m_pbuff ) {
      m_pbuff->disable();
   }
}

////////////////////////////////////////////////////////////////////////
/// init
////////////////////////////////////////////////////////////////////////
void FragProgARB::init()
{

   if( m_pbuff ) {
      m_pbuff->enable(true);
   }

   if(m_fragProg)
   {
      if(!m_shaderNum)
         glGenProgramsARB( 1, &m_shaderNum);

      this->bindDef();          

#ifdef NDEBUG // Running in optimized mode, so need to eat unrelated GL errors
      glGetError();
#endif

      glProgramStringARB( GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(m_fragProg), m_fragProg);

      // Check for errors related to this fragment program
      if (glGetError() != 0)
      {
         int position;
         glGetIntegerv( GL_PROGRAM_ERROR_POSITION_ARB, &position);
         err() << "init() gl error: " << glGetString(GL_PROGRAM_ERROR_STRING_ARB) << " at character " << position << endl;
         estr() << m_fragProg << endl;
      }

      this->releaseDef();
   }

   if( m_pbuff ) {
      m_pbuff->disable();
   }
}

////////////////////////////////////////////////////////////////////////
/// reset
////////////////////////////////////////////////////////////////////////
void FragProgARB::reset()
{
   /// TODO: this won't work, needs to save off the fragProg
   destroy();
   init();

   if( isCompiled() )  {
      compile();
   }
}

////////////////////////////////////////////////////////////////////////
/// reload
////////////////////////////////////////////////////////////////////////
void FragProgARB::reload(const char *shader)
{
   if(!shader)
   {
      err() << "reload(), null shader" << endl;
      return;
   }

   if(m_fragProg) {delete [] m_fragProg;}
   m_fragProg = 0;

   m_fragProg = new char[strlen(shader)+1];
   assert(m_fragProg);
   m_fragProg[strlen(shader)] = '\0';
   strcpy(m_fragProg, shader); // Copy from 'fragProg' to 'm_fragProg'

   /// reload shader
   init();
}

////////////////////////////////////////////////////////////////////////
/// set local const
////////////////////////////////////////////////////////////////////////

void FragProgARB::setLocalConstf(unsigned int constNum, const vec4f& constant)
{
   assert( constNum < (uint)m_maxLocalParams ); 

   // Bind the new local parameter constant
   //   if( m_pbuff ) { m_pbuff->enable(true); }
   bindDef();
   glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, constNum, constant.v());

   /*   // DEBUGGING Test: Does the parameter get set?
   vec4f result(0);
   glGetProgramLocalParameterfvARB(GL_FRAGMENT_PROGRAM_ARB, constNum, result.v() );
   cerr << "FragProgARB::setLocalConstf: " << result.x << ", " << result.y << ", " << result.z << ", " << result.w << endl;
   */
   releaseDef();
   //   if( m_pbuff ) { m_pbuff->disable(); }
}

void FragProgARB::setLocalConstd(unsigned int constNum, const vec4d& constant)
{
   assert( constNum < (uint)m_maxLocalParams ); 

   // Bind the new local parameter constant
   //   if( m_pbuff ) { m_pbuff->enable(true); }
   bindDef();
   glProgramLocalParameter4dvARB(GL_FRAGMENT_PROGRAM_ARB, constNum, constant.v());
   releaseDef();
   //   if( m_pbuff ) { m_pbuff->disable(); }
}

////////////////////////////////////////////////////////////////////////
/// get info
////////////////////////////////////////////////////////////////////////
int FragProgARB::getInfoInt( GLenum param )
{
   int infoInt = 0;

   //   if( m_pbuff ) { m_pbuff->enable(true); }
   bindDef();
   glGetProgramivARB( GL_FRAGMENT_PROGRAM_ARB, param, &infoInt );
   releaseDef();
   //   if( m_pbuff ) { m_pbuff->disable(); }

   return infoInt;
}

////////////////////////////////////////////////////////////////////////
/// bind def
////////////////////////////////////////////////////////////////////////
void FragProgARB::bindDef()
{       
   glEnable( GL_FRAGMENT_PROGRAM_ARB );
   glBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, m_shaderNum);
   //   cerr << "FragProgARB::bindDef() WARNING: Code commented out\n\n";
}

////////////////////////////////////////////////////////////////////////
/// release def
////////////////////////////////////////////////////////////////////////
void FragProgARB::releaseDef()
{
   glDisable( GL_FRAGMENT_PROGRAM_ARB);
   //cerr << "FragProgARB::releaseDef() WARNING: Code commented out\n\n";
}

////////////////////////////////////////////////////////////////////////
/// set file name
////////////////////////////////////////////////////////////////////////
void  FragProgARB::setProgFile(const char *name)
{
   if(m_fragProgFile) delete[] m_fragProgFile;
   m_fragProgFile = 0;
   if(name)
   {
      m_fragProgFile = new char[strlen(name)+1];
      strcpy(m_fragProgFile,name);
      m_fragProgFile[strlen(name)] = '\0';
   }
}

---

Send questions, comments, and bug reports to: