gl_Cg_shader_system.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_system.h"
#include "gl_Cg_shader_system/gl_Cg_code_instructor.h"
#include "gl_Cg_shader_system/gl_Cg_shader.h"
#include "gl_Cg_shader_system/gl_Cg_uniform.h"

#include "gpucalc/log_manager.h"
#include "gpucalc/text_file_loader.h"
#include "gpucalc/application.h"
#include "gpucalc/data.h"
#include "gpucalc/texture.h"
#include "gpucalc/string_util.h"
#include "gpucalc/debugger/debugger.h"



namespace gpucalc
{

 GLCgShaderSystem::GLCgShaderSystem(): ShaderSystem(_GLCgShaderSystemObjectName), mIsStarted(false), mActiveShader(0), mShaderMap(), mUniformMap(),
  mAcceptableGraphicCoreIDset(), mCodeInstructor(0)
 {
 }


 GLCgShaderSystem::~GLCgShaderSystem()
 {
  if (mIsStarted)
  {
   stop();
  }
 }


 Shader * GLCgShaderSystem::create(const std::string & ShaderName)
 {
  assert(mIsStarted && "GLCgShaderSystem is not started!!!");
  ShaderMap::iterator i = mShaderMap.find(ShaderName);
  if (i != mShaderMap.end())
  {
   Except<ERR_DUPLICATE_ITEM>(this, "Shader \"" + ShaderName + "\" already exists!", "GLCgShaderSystem::create()", __FILE__, __LINE__);
   return 0;
  }
  else
  {
   GLCgShader * Result = new GLCgShader(ShaderName, mCgContextID, mCgFragmentProfileID, this);
   mShaderMap.insert(std::make_pair(ShaderName, Result));
   LogManager::getSingleton().logMessage(this, "Shader object \"" + ShaderName + "\" created.", LML_Trivial);
   return Result;
  }
 }
 

 Shader * GLCgShaderSystem::getShaderByName(const std::string & ShaderName) const
 {
  assert(mIsStarted && "GLCgShaderSystem is not started!!!");
  ShaderMap::const_iterator i = mShaderMap.find(ShaderName);
  if (i != mShaderMap.end())
  {
   return i->second;
  }
  else
  {
   Except<ERR_ITEM_NOT_FOUND>(this, "Shader \"" + ShaderName + "\" cannot be found!", "GLCgShaderSystem::getShaderbyName()", __FILE__, __LINE__);
  }
 }


 bool GLCgShaderSystem::isShaderCreated(const std::string & ShaderName) const
 {
  assert(mIsStarted && "GLCgShaderSystem is not started!!!");
  return (mShaderMap.find(ShaderName) != mShaderMap.end());
 }


 void GLCgShaderSystem::destroy(Shader * shader)
 {
  assert(mIsStarted && "GLCgShaderSystem is not started!!!");
  std::string ShaderName = shader->getObjectName();
  if (!removeFromContainer(ShaderName, mShaderMap))
  {
   Warning<ERR_ITEM_NOT_FOUND>(this, "Shader \"" + ShaderName + "\" cannot be found, destroying anyway.", "GLChShaderSystem::destroy()", __FILE__, __LINE__);
  }
  delete shader;
  LogManager::getSingleton().logMessage(this, "Shader object \"" + ShaderName + "\" destroyed.", LML_Trivial);
 }


 Uniform * GLCgShaderSystem::create(const Data & data)
 {
  assert(mIsStarted && "GLCgShaderSystem is not started!!!");
  std::string UniformName = data.getObjectName();
  UniformMap::iterator i = mUniformMap.find(UniformName);
  if (i != mUniformMap.end())
  {
   Except<ERR_DUPLICATE_ITEM>(this, "Uniform variable \"" + UniformName + "\" already exists!", "GLCgShaderSystem::createUniform()", __FILE__, __LINE__);
  }
  GLCgUniform * result = new GLCgUniform(UniformName);
  result->mPointer = data.pointer();
  result->mActualLengthGPU = data.getActualLengthCPU() / data.getNumberOfComponents();
  result->mNumberOfComponents = data.getNumberOfComponents();
  result->mTypeSize = data.getTypeSize();

  if (!data.isArray())
  {
   switch (data.getValueType())
   {
    case FloatType:
     result->mUniformType = static_cast<Uniform::UniformType>(
       Uniform::UT_FLOAT_1 + result->getNumberOfComponents() - 1);
     break;

    case IntType:
    case UnsignedIntType:
     result->mUniformType = static_cast<Uniform::UniformType>(
       Uniform::UT_INT_1 + result->getNumberOfComponents() - 1);
     break;

    default:
     Except<ERR_NOT_IMPLEMENTED>(this, "other ValueTypes is not implemented!",
      "GLCgShaderSystem::createUniform()", __FILE__, __LINE__);
     break;
   }
  }
  else
  {
   Except<ERR_INVALIDPARAMS>(this, "this method can work only with uniform data.", "GLCgShaderSystem::create()", __FILE__, __LINE__);
  }

  mUniformMap.insert(std::make_pair(UniformName, result));
  return result;
 }


 Uniform * GLCgShaderSystem::create(Texture * texture)
 {
  assert(mIsStarted && "GLCgShaderSystem is not started!!!");
  UniformMap::iterator i = mUniformMap.find(texture->getObjectName());
  if (i != mUniformMap.end())
  {
   Except<ERR_DUPLICATE_ITEM>(this, "Uniform variable with name \"" + texture->getObjectName() + "\" already exists!",
    "GLCgShaderSystem::create()", __FILE__, __LINE__);
   return 0;
  }
  else
  {
   GLCgUniform * result = new GLCgUniform(texture->getObjectName());
   result->mSampler = texture;
   result->mUniformType = Uniform::UT_TEX_2;
   mUniformMap.insert(std::make_pair(texture->getObjectName(), result));
   return result;
  }
 }


 Uniform * GLCgShaderSystem::getUniformByName(const std::string & UniformName) const
 {
  assert(mIsStarted && "GLCgShaderSystem is not started!!!");
  UniformMap::const_iterator i = mUniformMap.find(UniformName);
  if (i != mUniformMap.end())
  {
   return i->second;
  }
  else
  {
   Except<ERR_ITEM_NOT_FOUND>(this, "Uniform variable with name \"" + UniformName + "\" cannot be found!",
    "GLCgShaderSystem::getUniformByName()", __FILE__, __LINE__);
  }
 }


 bool GLCgShaderSystem::isUniformCreated(const std::string & UniformName) const
 {
  assert(mIsStarted && "GLCgShaderSystem is not started!!!");
  return (mUniformMap.find(UniformName) != mUniformMap.end());
 }


 void GLCgShaderSystem::destroy(Uniform * uniform)
 {
  assert(mIsStarted && "GLCgShaderSystem is not started!!!");
  std::string UniformName = uniform->getObjectName();
  if (!removeFromContainer(UniformName, mUniformMap))
  {
   Warning<ERR_ITEM_NOT_FOUND>(this, "Uniform \"" + UniformName + "\" cannot be found, destroying anyway.", "GLChShaderSystem::destroy()", __FILE__, __LINE__);
  }
  delete uniform;
  LogManager::getSingleton().logMessage(this, "Uniform variable \"" + UniformName + "\" destroyed.", LML_Trivial);
 }


 void GLCgShaderSystem::bind(Shader * shader)
 {
  assert(shader && "Shader does not created!!!");
  if (shader != mActiveShader)
  {
   GLCgShader * CgShader = static_cast<GLCgShader *>(shader);
   cgGLBindProgram(CgShader->mCgFragmentProgramID);
   mActiveShader = shader;
  }
 }


 void GLCgShaderSystem::unbind(Shader * shader)
 {
  assert(shader && "Shader does not created!!!");
  if (shader == mActiveShader)
  {
   GLCgShader * CgShader = static_cast<GLCgShader *>(shader);
   cgGLUnbindProgram(CgShader->mCgFragmentProfileID);
   mActiveShader = 0;
  }
 }


 Shader * GLCgShaderSystem::getActiveShader() const
 {
  return mActiveShader;
 }


 CGcontext LocalCGContext;


 void cgErrorCallBackFunction()
 {
  CGerror LastError = cgGetError();
  if (LastError != CG_NO_ERROR)
  {
   Except<ERR_RENDERINGAPI_ERROR>(Object(_ShaderSystemClassName, _GLCgShaderSystemObjectName),
    std::string(cgGetErrorString(LastError)) + cgGetLastListing(LocalCGContext), "somewhere...", __FILE__, __LINE__);
  }
 }


 void GLCgShaderSystem::start()
 {
        if (mIsStarted) return;
  mCgContextID = cgCreateContext();
  LocalCGContext = mCgContextID;
  cgSetErrorCallback(cgErrorCallBackFunction);
  mCgFragmentProfileID = cgGLGetLatestProfile(CG_GL_FRAGMENT);
  cgGLSetOptimalOptions(mCgFragmentProfileID);


  mIsStarted = true;
  this->addAcceptableGraphicCoreID("GLGraphicCore");
  LogManager::getSingleton().logMessage(this, "---===========================================---");
  LogManager::getSingleton().logMessage(this, "---===     GL Cg Shader system started     ===---");
  LogManager::getSingleton().logMessage(this, "---===========================================---");

  if (debugger::Debugger::getSingletonPtr() != 0) 
  {
   mCodeInstructor = new debugger::GLCgCodeInstructor();
   debugger::Debugger::getSingleton().addCodeInstructor(mCodeInstructor);
  }
 }


 void GLCgShaderSystem::stop()
 {
  assert(mIsStarted && "GLCgShaderSystem is not started!!!");
  clearContainer(mShaderMap);
  clearContainer(mUniformMap);

  LogManager::getSingleton().logMessage(this, "---===========================================---");
  LogManager::getSingleton().logMessage(this, "---===     GL Cg Shader system stopped     ===---");
  LogManager::getSingleton().logMessage(this, "---===========================================---");
  mIsStarted = false;

  if (debugger::Debugger::getSingletonPtr() != 0) 
  {
   //debugger::Debugger::getSingleton().re
   delete mCodeInstructor;
  }
 }


 bool GLCgShaderSystem::isAcceptCore(const GraphicCore * Core) const
 {
  return (mAcceptableGraphicCoreIDset.find(Core->getObjectName()) != mAcceptableGraphicCoreIDset.end());
 }


 bool GLCgShaderSystem::isAcceptFileExtension(const std::string & FileExtension) const
 {
  return auxillary::StringUtil::toLower(FileExtension) == std::string("cg");
 }


 void GLCgShaderSystem::addAcceptableGraphicCoreID(const std::string & GraphicCoreID)
 {
  mAcceptableGraphicCoreIDset.insert(GraphicCoreID);
 }


 debugger::CodeInstructor * GLCgShaderSystem::getCodeInstructor() const
 {
  return mCodeInstructor;
 }
}