vertexProgARB.cpp

Go to the documentation of this file.

//////////////////////////////////////////////////////////////////////
// 10/3/02      Joe M. Kniss    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
/////////////////////////////////////////////////////////////////////////
//
// VertexProgARB.cpp: interface for the VertexProgARB class.
//
// - Class for an ATI fragment program.
//////////////////////////////////////////////////////////////////////

#include <state/vertexProgARB.h>
#include <string.h>
#include <iostream>

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

////////////////////////////////////////////////////////////////////////
/// construct
////////////////////////////////////////////////////////////////////////
VertexProgARB::VertexProgARB( const char *vertProg, bool isFileName, PBuffGlift* pbuff, bool noload)
: m_vertProg(0), m_vertProgFile(0), m_shaderNum(0), m_pbuff(0)
{
   initMembers( vertProg, isFileName, 0, pbuff );
   if(!noload)
      this->init();
}

////////////////////////////////////////////////////////////////////////
/// copy construct
////////////////////////////////////////////////////////////////////////
VertexProgARB::VertexProgARB( const VertexProgARB &rhs)
{
   initMembers(rhs);
}

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

////////////////////////////////////////////////////////////////////////
/// init members
////////////////////////////////////////////////////////////////////////
void VertexProgARB::initMembers( const char *vertProg, bool isFileName, GLuint shaderNum, PBuffGlift* pbuff )
{
   if(!glew.ARB_vertex_program)
   {
      err() << "initMembers() Error:\n"
         << "\tGL_ARB_fragment_program is not available.\n"
         << "\tVertexProgARB only available if using a graphics card that supports it.\n";
      exit(1);
   }

   if(isFileName)
   {
      if(m_vertProgFile) delete [] m_vertProgFile;
      m_vertProgFile = new char[strlen(vertProg)+1];
      assert(m_vertProgFile);
      strcpy(m_vertProgFile, vertProg);

      FILE *fp;
      long length;

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

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

      if( m_vertProg ) {delete [] m_vertProg;}
      m_vertProg = new char[length+1];
      assert(m_vertProg);

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

   m_shaderNum = shaderNum;
   m_pbuff     = pbuff;
   glGetProgramivARB( GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, &m_maxLocalParams );
}

////////////////////////////////////////////////////////////////////////
/// init members copy
////////////////////////////////////////////////////////////////////////
void VertexProgARB::initMembers( const VertexProgARB &rhs)
{
   if(rhs.m_vertProg)
   {
      m_vertProg = new char[strlen(rhs.m_vertProg)];
   }    
   if(rhs.m_vertProgFile)
   {
      m_vertProgFile = new char[strlen(rhs.m_vertProgFile)];
   }

   m_shaderNum = rhs.m_shaderNum;
   m_pbuff     = rhs.m_pbuff;
   m_maxLocalParams = rhs.m_maxLocalParams;
}

////////////////////////////////////////////////////////////////////////
/// destruct
////////////////////////////////////////////////////////////////////////
VertexProgARB::~VertexProgARB()
{
   destroy();
   if(m_vertProg) delete [] m_vertProg;
   m_vertProg = 0;
   if(m_vertProgFile) delete [] m_vertProgFile;
   m_vertProgFile = 0;
}

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

   if(glew.ARB_vertex_program)
   {
      glDeleteProgramsARB(1, &m_shaderNum );
   }

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

////////////////////////////////////////////////////////////////////////
/// init
////////////////////////////////////////////////////////////////////////
void VertexProgARB::init()
{
   //cerr << "VertexProgARB::init() " << m_vertProg << endl;
   if( m_pbuff ) {
      m_pbuff->enable(true);
   }

   if(glew.ARB_vertex_program && m_vertProg)
   {
      glGenProgramsARB( 1, &m_shaderNum);

      this->bindDef();          

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

      glProgramStringARB( GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(m_vertProg), m_vertProg);

      if (glGetError() != 0)
      {
         int position;
         glGetIntegerv( GL_PROGRAM_ERROR_POSITION_ARB, &position);
         err() << "init() error: " << glGetString(GL_PROGRAM_ERROR_STRING_ARB) << " at character " << position << endl;
         estr() << m_vertProg << endl;
      }

      this->releaseDef();
   }

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

////////////////////////////////////////////////////////////////////////
/// reset
////////////////////////////////////////////////////////////////////////
void VertexProgARB::reset()
{
   destroy();
   init();

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

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

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

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

   /// reload shader
   init();
}

////////////////////////////////////////////////////////////////////////
/// set local const
////////////////////////////////////////////////////////////////////////
void VertexProgARB::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_VERTEX_PROGRAM_ARB, constNum, constant.v());

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

void VertexProgARB::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_VERTEX_PROGRAM_ARB, constNum, constant.v());
   releaseDef();
   //if( m_pbuff ) { m_pbuff->disable(); }
}

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

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

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

---

Send questions, comments, and bug reports to: