Cg.cpp

Go to the documentation of this file.

#include "Cg.h"

#include <assert.h>


static CgObjects* g_pCg = NULL;


CgObjects::CgObjects()
{
  // profiles
  if (cgGLIsProfileSupported(CG_PROFILE_FP30)) {
    printf( "fragment program profile fp30 ... " );
    _fragmentProfile = CG_PROFILE_FP30;
  }
  /*  else if (cgGLIsProfileSupported(CG_PROFILE_FP20)) {
    printf( "fragment program profile fp20 ... " );
    _fragmentProfile = CG_PROFILE_FP20;
  }
  else if (cgGLIsProfileSupported(CG_PROFILE_ARBFP1)) {
    printf( "fragment program profile arbfp1 ... " );
    _fragmentProfile = CG_PROFILE_ARBFP1;
  }
  */
  else {
    printf( "Fragment programming extensions (GL_ARB_fragment_program or "
           "GL_NV_fragment_program) not supported, exiting...\n" );
    assert( false );
  }
  
  if (cgGLIsProfileSupported(CG_PROFILE_ARBVP1))
    _vertexProfile = CG_PROFILE_ARBVP1;
  else if (cgGLIsProfileSupported(CG_PROFILE_VP20))
    _vertexProfile = CG_PROFILE_VP20;
  else {
    printf( "Vertex programming extensions (GL_ARB_vertex_program or "
           "GL_NV_vertex_program) not supported, exiting...\n" );
    assert( false );
  }

  cgSetErrorCallback(cgErrorCallback);
  _shaderContext = cgCreateContext();
}

CgObjects::~CgObjects()
{
}

CGprofile CgObjects::fragmentProfile()
{
  return _fragmentProfile;
}
const CGprofile CgObjects::fragmentProfile() const
{
  return _fragmentProfile;
}

CGprofile CgObjects::vertexProfile()
{
  return _vertexProfile;
}
const CGprofile CgObjects::vertexProfile() const
{
  return _vertexProfile;
}

CGcontext CgObjects::shaderContext()
{
  return _shaderContext;
}
const CGcontext CgObjects::shaderContext() const
{
  return _shaderContext;
}

void CgObjects::cgErrorCallback(void)
{
  CGerror LastError = cgGetError();
  
  if(LastError) {
    printf( "Cg Error.\n" );
    const char *Listing = cgGetLastListing(Cg()->shaderContext());
    printf( "\n---------------------------------------------------\n");
    printf("%s\n\n", cgGetErrorString(LastError));
    printf("%s\n", Listing);
    printf("---------------------------------------------------\n");
    printf("Cg error, exiting...\n");
    assert( false );
  }
}

CgObjects* Cg()
{
  if (g_pCg == NULL) {
    printf( "Initializing Cg ... " );
    g_pCg = new CgObjects;
    printf( "done.\n" );
  }
  return g_pCg;
}

void releaseCg()
{
  printf( "Destroying Cg Objects ....\n" );
  delete g_pCg;
  g_pCg = NULL;
}



/*************************
 *** CgProgram ***
 *************************/

CgProgram::CgProgram()
{
  // programs
  _Program = NULL;
  _Profile = (CGprofile)0xffff;
}

void CgProgram::setFilename( const string &fn )
{
  _filename = fn;
}

void CgProgram::initProfile( CGprofile p )
{
  _Profile = p;
}


CgProgram::~CgProgram()
{
  if (_Program != NULL) {
    cgDestroyProgram(_Program);
  }
}



void CgProgram::setup()
{
  if (_Program != NULL) {
    cgDestroyProgram(_Program);
    _Program = NULL;
  }

  _Program = cgCreateProgramFromFile(Cg()->shaderContext(),
                                     CG_SOURCE,
                                     _filename.c_str(),
                                     _Profile, NULL, NULL);
  if (_Program == NULL) {
    printf( "Could not create program %s\n", _filename.c_str() );
    assert( false );
  }
  cgGLLoadProgram(_Program);
  _parameters.erase( _parameters.begin(), _parameters.end() );
}


void CgProgram::enable()
{
  // Use fragment program
  cgGLEnableProfile(_Profile);
  cgGLBindProgram(_Program);
}

void CgProgram::disable()
{
  // disable profile
  cgGLDisableProfile( _Profile );
}

CGparameter CgProgram::parameter( const string &var )
{
  // First try to find parameter in the map
  map<string, CGparameter>::const_iterator it = _parameters.find( var );
  if (it != _parameters.end()) {
    return (*it).second;
  }
  
  // Obtain parameter handle from Cg
  CGparameter p = cgGetNamedParameter(_Program, var.c_str() );
  if (!p) {
    printf( "Unable to retrieve program parameter %s, exiting.\n", var.c_str() );
    assert( false );
  }
  _parameters[var] = p;
  return p;
}

void CgProgram::setParameter( const CGparameter &p, int n, const float *v ) const
{
  switch( n ) {
  case 1:
    cgGLSetParameter1fv( p, v );
    break;
  case 2:
    cgGLSetParameter2fv( p, v );
    break;
  case 3:
    cgGLSetParameter3fv( p, v );
    break;
  case 4:
    cgGLSetParameter4fv( p, v );
    break;
  case 16:
    cgGLSetMatrixParameterfr( p, v );
    break;
  default:
    printf( "Illegal parameter length.\n" );
    assert( false );
  }
}


void CgProgram::setParameter( const string &pname, int n, const float *v )
{
  setParameter( parameter(pname), n,v );
}




/*************************
 *** CgVertexProgram ***
 *************************/

CgVertexProgram::CgVertexProgram()
{
}

CgVertexProgram::~CgVertexProgram()
{
}


void CgVertexProgram::setup()
{
  initProfile( Cg()->vertexProfile() );
  CgProgram::setup();
}



void CgVertexProgram::setStateMatrixParameter( const CGparameter &p,
                                               const CGGLenum matrix, const CGGLenum transform ) const
{
  cgGLSetStateMatrixParameter( p, matrix, transform );
}

void CgVertexProgram::setStateMatrixParameter( const string &pname,
                                               const CGGLenum matrix, const CGGLenum transform )
{
  setStateMatrixParameter( parameter(pname), matrix, transform );
}




/*************************
 *** CgFragmentProgram ***
 *************************/

CgFragmentProgram::CgFragmentProgram()
{
}

CgFragmentProgram::~CgFragmentProgram()
{
}



void CgFragmentProgram::setup()
{
  initProfile( Cg()->fragmentProfile() );
  CgProgram::setup();
  _textures.erase( _textures.begin(), _textures.end() );
}

void CgFragmentProgram::enable()
{
  CgProgram::enable();
  // enable textures
  map<CGparameter,GLuint>::const_iterator it = _textures.begin();
  while (it != _textures.end()) {
    cgGLEnableTextureParameter( (*it).first );
    cgGLSetTextureParameter( (*it).first, (*it).second );
    it++;
  }
}

void CgFragmentProgram::disable()
{
  // disable textures
  map<CGparameter,GLuint>::const_iterator it = _textures.begin();
  while (it != _textures.end()) {
    cgGLDisableTextureParameter( (*it).first );
    it++;
  }
  // disable profile
  CgProgram::disable();
}

void CgFragmentProgram::bindTexture( const string &var, GLuint T )
{
  bindTexture( parameter(var), T );
}

void CgFragmentProgram::bindTexture( const CGparameter &p, GLuint T  )
{
  _textures[p] = T;
  cgGLSetTextureParameter(p, T);
}

---