gl_glsl_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_glsl_shader_system/gl_glsl_shader_system.h"
#include "gl_glsl_shader_system/gl_glsl_code_instructor.h"
#include "gl_glsl_shader_system/gl_glsl_shader.h"

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



namespace gpucalc
{


 GLGLSLShaderSystem::GLGLSLShaderSystem(): ShaderSystem(_GLGLSLShaderSystemObjectName), mShaderMap(), mUniformMap(), mAcceptableGraphicCoreIDset(),
  mIsStarted(false), mActiveShader(0), mCodeInstructor(0)
 {
       // mAcceptableGraphicCoreIDset.insert("GLGraphicCore"); // added standart gl graphic core
 }


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

  LogManager::getSingleton().logMessage(this, "Successfully destroyed.", LML_Normal);
 }


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


 Shader * GLGLSLShaderSystem::getShaderByName(const std::string & ShaderName) const
 {
  assert(mIsStarted && "GLGLSLShaderSystem 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 with name \"" + ShaderName + "\" cannot be found.", "GLGLSLShaderSystem::getShaderByName()", __FILE__, __LINE__);
  }
 }


 bool GLGLSLShaderSystem::isShaderCreated(const std::string & ShaderName) const
 {
  return (mShaderMap.find(ShaderName) != mShaderMap.end());
 }


 void GLGLSLShaderSystem::destroy(Shader * shader)
 {
  assert(mIsStarted && "GLGLSLShaderSystem is not started!!!");
  std::string ShaderName = shader->getObjectName();
  if (!removeFromContainer(ShaderName, mShaderMap))
  {
   Warning<ERR_INVALIDPARAMS>(this, "Shader object \"" + ShaderName + "\" was created outside GLGLSLShaderSystem!!! Destroying anyway.",
            "GLGraphicCore::deleteFrameBuffer", __FILE__, __LINE__);
  }
  delete shader;
  LogManager::getSingleton().logMessage(this, ShaderName + " successfully deleted.", LML_Trivial);
 }


 void GLGLSLShaderSystem::bind(Shader * shader)
 {
  assert(shader && "Shader does not created!!!");
  if (shader != mActiveShader)
  {
   GLGLSLShader * GLSLShader = static_cast<GLGLSLShader *>(shader);
   glUseProgramObjectARB(GLSLShader->mGLSLProgramID);
   mActiveShader = shader;
  }
 }


 void GLGLSLShaderSystem::unbind(Shader * shader)
 {
  assert(shader && "Shader does not created!!!");
  if (shader == mActiveShader)
  {
   glUseProgramObjectARB(0);
   mActiveShader = 0;
  }
 }


 void GLGLSLShaderSystem::start()
 {
        if (mIsStarted) return;
  LogManager::getSingleton().logMessage(this, "---===========================================---");
  LogManager::getSingleton().logMessage(this, "---===    GL GLSL Shader system started    ===---");
  LogManager::getSingleton().logMessage(this, "---===========================================---");
  mIsStarted = true;
  this->addAcceptableGraphicCoreID("GLGraphicCore");

  if (debugger::Debugger::getSingletonPtr() != 0)
  {
   mCodeInstructor = new debugger::GLGLSLCodeInstructor();
  }
 }


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

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

  if (debugger::Debugger::getSingletonPtr() != 0)
  {
   delete mCodeInstructor;
  }
 }


 Uniform * GLGLSLShaderSystem::create(const Data & data)
 {
  assert(mIsStarted && "GLGLSLShaderSystem is not started!!!");
  UniformMap::iterator i = mUniformMap.find(data.getObjectName());
  if (i != mUniformMap.end())
  {
   Except<ERR_DUPLICATE_ITEM>(this, "Uniform variable with name \"" + data.getObjectName() + "\" already exists!",
    "GLGLSLShaderSystem::createUniform()", __FILE__, __LINE__);
  }
  else
  {
   GLGLSLUniform * result = new GLGLSLUniform(data.getObjectName());
   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!",
       "GLGLSLShaderSystem::createUniform()", __FILE__, __LINE__);
      break;
    }
   }
   else
   {
    Except<ERR_INVALIDPARAMS>(this, "this method can work only with uniform data.", "GLGLSLShaderSystem::create()", __FILE__, __LINE__);
   }

   mUniformMap.insert(std::make_pair(data.getObjectName(), result));
   LogManager::getSingleton().logMessage(this, "Uniform variable created from data. Name is: " + data.getObjectName(), LML_Trivial);
   return result;
  }
  return 0;
 }


 Uniform * GLGLSLShaderSystem::create(Texture * texture)
 {
  assert(mIsStarted && "GLGLSLShaderSystem 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!",
    "GLGLSLShaderSystem::create()", __FILE__, __LINE__);
   return 0;
  }
  else
  {
   GLGLSLUniform * result = new GLGLSLUniform(texture->getObjectName());
   result->mSampler = texture;
   result->mUniformType = Uniform::UT_TEX_2;
   mUniformMap.insert(std::make_pair(texture->getObjectName(), result));
   LogManager::getSingleton().logMessage(this, "Uniform variable created from texture. Name is: " + texture->getObjectName(), LML_Trivial);
   return result;
  }
 }


 Uniform * GLGLSLShaderSystem::getUniformByName(const std::string & UniformName) const
 {
  assert(mIsStarted && "GLGLSLShaderSystem 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!",
    "GLGLSLShaderSystem::getUniformByName()", __FILE__, __LINE__);
  }
 }


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


 void GLGLSLShaderSystem::destroy(Uniform * uniform)
 {
  assert(mIsStarted && "GLGLSLShaderSystem is not started!!!");
  std::string UniformName = uniform->getObjectName();
  if (!removeFromContainer(UniformName, mUniformMap))
  {
   Warning<ERR_INVALIDPARAMS>(this, "Uniform object \"" + UniformName + "\" was created outside GLGLSLShaderSystem!!! Destroying anyway.",
    "GLGLSLShaderSystem::destroy", __FILE__, __LINE__);
  }
  delete uniform;
  LogManager::getSingleton().logMessage(this, "Uniform object \"" + UniformName + "\" deleted", LML_Trivial);
 }


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


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


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


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