gl_Cg_shader.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2008 by Kutumov Alexey                                  *
 *   ru.pixel@gmail.com                                                    *
 *                                                                         *
 *   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 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program 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 General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "gl_Cg_shader_system/gl_Cg_shader.h"
#include "gl_Cg_shader_system/gl_Cg_uniform.h"

#include "gpucalc/text_file_loader.h"
#include "gpucalc/log_manager.h"
#include "gpucalc/texture.h"


namespace gpucalc
{
 GLCgShader::GLCgShader(const std::string & ShaderName, CGcontext CgContext, CGprofile CgProfile, ShaderSystem * system):
  Object(_GLCgShaderClassName, ShaderName), Shader(_GLCgShaderClassName, ShaderName, system), mCgContextID(CgContext),
  mCgFragmentProfileID(CgProfile),mIsCompiled(false), mIsDebug(false), mShaderSource(), mShaderCompilerParams(), mUniformVector()
 {
 }


 GLCgShader::~GLCgShader()
 {
  cgDestroyProgram(mCgFragmentProgramID);
 }


 void GLCgShader::setSource(const std::string & ShaderSource)
 {
  mShaderSource = ShaderSource;
  mIsCompiled = false;
 }


 void GLCgShader::addUniform(Uniform * uniform)
 {
  if (addToContainer(uniform, mUniformVector))
  {
   uniform->uploadToGPU();
  }
 }
 
 
 void GLCgShader::removeUniform(Uniform * uniform)
 {
  removeFromContainer(uniform, mUniformVector);
 }


 void GLCgShader::compile(const std::string & Parameters)
 {
  //remember compiler params for recompilation
  mShaderCompilerParams = Parameters;

  if (mIsCompiled)
  {
   cgDestroyProgram(mCgFragmentProgramID);
  }

  LogManager::getSingleton().logMessage(this, "Using following compiler parameters: \"" + Parameters + "\".", LML_Critical);
  const char ** Params = new const char * [2];
  Params[0] = Parameters.c_str();
  Params[1] = 0;
  mCgFragmentProgramID = cgCreateProgram(mCgContextID, CG_SOURCE, mShaderSource.c_str(),
   mCgFragmentProfileID, "main", Params);

  delete [] Params;

  cgGLLoadProgram(mCgFragmentProgramID);
  mIsCompiled = true;
  mIsDebug = (Parameters.find("-debug") != std::string::npos);
 }


 void GLCgShader::validate()
 {
 }


 void GLCgShader::preCompute()
 {
  if (!mIsCompiled)
  {
   compile(mShaderCompilerParams);
  }

  bind();
  cgGLEnableProfile(mCgFragmentProfileID);
  for (UniformVector::iterator i = mUniformVector.begin(); i != mUniformVector.end(); ++i)
  {
   Uniform * uniform = (*i);
   Uniform::UniformType uniform_type = uniform->getUniformType();
   if ((uniform_type == Uniform::UT_TEX_1) || (uniform_type == Uniform::UT_TEX_2))
   {
    setUniformSampler(uniform);
   }
   else
   {
    setUniformVariable(uniform);
   }
  }
 }


 void GLCgShader::setUniformVariable(Uniform * uniform)
 {
  CGparameter VariableParameter = cgGetNamedParameter(mCgFragmentProgramID, uniform->getObjectName().c_str());
  switch (uniform->getUniformType())
  {
   case Uniform::UT_INT_1:
    cgSetParameter1iv(VariableParameter, static_cast<const int *>(uniform->pointer()));
    break;

   case Uniform::UT_INT_2:
    cgSetParameter2iv(VariableParameter, static_cast<const int *>(uniform->pointer()));
    break;

   case Uniform::UT_INT_3:
    cgSetParameter3iv(VariableParameter, static_cast<const int *>(uniform->pointer()));
    break;

   case Uniform::UT_INT_4:
    cgSetParameter4iv(VariableParameter, static_cast<const int *>(uniform->pointer()));
    break;

   case Uniform::UT_FLOAT_1:
    cgSetParameter1fv(VariableParameter, static_cast<const float *>(uniform->pointer()));
    break;


   case Uniform::UT_FLOAT_2:
    cgSetParameter2fv(VariableParameter, static_cast<const float *>(uniform->pointer()));
    break;

   case Uniform::UT_FLOAT_3:
    cgSetParameter3fv(VariableParameter, static_cast<const float *>(uniform->pointer()));
    break;
   
   case Uniform::UT_FLOAT_4:
    cgSetParameter4fv(VariableParameter, static_cast<const float *>(uniform->pointer()));
    break;


   /*case Uniform::UT_MAT_2X2:
    cgSetParameter1iv(VariableParameter, false, static_cast<const float *>(uniform->pointer()));
    break;

   case Uniform::UT_MAT_3X3:
    cgSetParameter1iv(VariableParameter, false, static_cast<const float *>(uniform->pointer()));
    break;

   case Uniform::UT_MAT_4X4:
    cgSetParameter1iv(VariableParameter, false, static_cast<const float *>(uniform->pointer()));
    break;
*/
   default:
    Except<ERR_NOT_IMPLEMENTED>(this, "Other uniform types not implemented.", "GLCgShader::setUniformVariable", __FILE__, __LINE__);
    break;
  }
 }


 void GLCgShader::setUniformSampler(Uniform * uniform)
 {
  CGparameter SamplerParameter = cgGetNamedParameter(mCgFragmentProgramID, uniform->getObjectName().c_str());

  GLuint GLTextureID = 0;
  uniform->getSampler()->getSpecificParameter("GLTextureID", &GLTextureID);
  cgGLSetTextureParameter(SamplerParameter, GLTextureID);
  cgGLEnableTextureParameter(SamplerParameter);
 }
}