gpucalc::GLCgShaderSystem Class Reference

#include <gl_Cg_shader_system.h>

Inheritance diagram for gpucalc::GLCgShaderSystem:

Inheritance graph

List of all members.

Public Member Functions

void addAcceptableGraphicCoreID (const std::string &GraphicCoreID)
 Method for manual adding acceptable GraphicCore ID.
void bind (Shader *shader)
Uniform * create (Texture *texture)
 Creates Uniform from texture.
Uniform * create (const Data &data)
 creates Uniform variable.
Shader * create (const std::string &ShaderName)
 Creates Shader object.
void destroy (Shader *shader)
 Deletes Shader object.
void destroy (Uniform *uniform)
 Deletes given Uniform.
Shader * getActiveShader () const
const std::string & getClassName () const
 Returns name of class of our object.
debugger::CodeInstructor * getCodeInstructor () const
 Returns CodeInstructor - special object, which allows to instruct shader with debugging symbols.
const std::string & getObjectName () const
 Returns name of our object.
Shader * getShaderByName (const std::string &Shadername) const
void getSpecificParameter (const std::string &ParameterName, void *ParameterValue)
 Method for obtaining some specific parameters, such as texture specific params, and so on.
Uniform * getUniformByName (const std::string &UniformName) const
 GLCgShaderSystem ()
bool isAcceptCore (const GraphicCore *Core) const
 Check for GraphicCore acceptance.
bool isAcceptFileExtension (const std::string &FileExtension) const
 Check for correct file extension.
bool isLocked () const
 returns state of object.
bool isShaderCreated (const std::string &ShaderName) const
bool isUniformCreated (const std::string &UniformName) const
virtual bool preCompile (const std::string &ShaderName, const std::string &ShaderSource, const std::string &Parameters="")
void start ()
 Perform initialization of ShaderSystem.
void stop ()
 Perform deinitialization of ShaderSystem.
void unbind (Shader *shader)
 ~GLCgShaderSystem ()

Protected Member Functions

void addSpecificParameter (const std::string &ParameterName, void *ParameterValue, size_t Size)
void lock ()
void unlock ()

Private Types

typedef std::set< std::string > AcceptableGraphicCoreIDset
typedef std::map< std::string,
Shader * > 		ShaderMap
typedef std::map< std::string,
Uniform * > 		UniformMap

Private Attributes

AcceptableGraphicCoreIDset mAcceptableGraphicCoreIDset
Shader * mActiveShader
CGcontext mCgContextID
CGprofile mCgFragmentProfileID
debugger::CodeInstructor * mCodeInstructor
bool mIsStarted
ShaderMap mShaderMap
UniformMap mUniformMap

Detailed Description

Definition at line 45 of file gl_Cg_shader_system.h.

Member Typedef Documentation

typedef std::set<std::string> gpucalc::GLCgShaderSystem::AcceptableGraphicCoreIDset [private]

Definition at line 133 of file gl_Cg_shader_system.h.

typedef std::map<std::string, Shader *> gpucalc::GLCgShaderSystem::ShaderMap [private]

Definition at line 125 of file gl_Cg_shader_system.h.

typedef std::map<std::string, Uniform *> gpucalc::GLCgShaderSystem::UniformMap [private]

Definition at line 129 of file gl_Cg_shader_system.h.

Constructor & Destructor Documentation

gpucalc::GLCgShaderSystem::GLCgShaderSystem (  ) 

Definition at line 51 of file gl_Cg_shader_system.cpp.

00051                                    : ShaderSystem(_GLCgShaderSystemObjectName), mIsStarted(false), mActiveShader(0), mShaderMap(), mUniformMap(),
00052   mAcceptableGraphicCoreIDset(), mCodeInstructor(0)
00053  {
00054  }

gpucalc::GLCgShaderSystem::~GLCgShaderSystem (  ) 

Definition at line 57 of file gl_Cg_shader_system.cpp.

00058  {
00059   if (mIsStarted)
00060   {
00061    stop();
00062   }
00063  }

Member Function Documentation

void gpucalc::GLCgShaderSystem::addAcceptableGraphicCoreID ( const std::string &  GraphicCoreID  )  [virtual]

Method for manual adding acceptable GraphicCore ID.

This method is useful when we use specific GraphicCore with ID different from standart ids.

Implements gpucalc::ShaderSystem.

Definition at line 324 of file gl_Cg_shader_system.cpp.

00325  {
00326   mAcceptableGraphicCoreIDset.insert(GraphicCoreID);
00327  }

void gpucalc::Object::addSpecificParameter ( const std::string &  ParameterName,
void *  ParameterValue,
size_t  Size 
) [inline, protected, inherited]

Definition at line 254 of file object.h.

00255    {
00256     SpecificParametersMap::iterator i = mSpecificParameters.find(ParameterName);
00257     if (i != mSpecificParameters.end())
00258     {
00259      mSpecificParameters.erase(i);
00260     }
00261     mSpecificParameters[ParameterName] = Any(ParameterValue, Size);
00262    }

void gpucalc::GLCgShaderSystem::bind ( Shader *  shader  )  [virtual]

Implements gpucalc::ShaderSystem.

Definition at line 223 of file gl_Cg_shader_system.cpp.

00224  {
00225   assert(shader && "Shader does not created!!!");
00226   if (shader != mActiveShader)
00227   {
00228    GLCgShader * CgShader = static_cast<GLCgShader *>(shader);
00229    cgGLBindProgram(CgShader->mCgFragmentProgramID);
00230    mActiveShader = shader;
00231   }
00232  }

Uniform * gpucalc::GLCgShaderSystem::create ( Texture *  texture  )  [virtual]

Creates Uniform from texture.

Parameters:
texture - texture, from which we convert to our Uniform.

Implements gpucalc::ShaderSystem.

Definition at line 166 of file gl_Cg_shader_system.cpp.

00167  {
00168   assert(mIsStarted && "GLCgShaderSystem is not started!!!");
00169   UniformMap::iterator i = mUniformMap.find(texture->getObjectName());
00170   if (i != mUniformMap.end())
00171   {
00172    Except<ERR_DUPLICATE_ITEM>(this, "Uniform variable with name \"" + texture->getObjectName() + "\" already exists!",
00173     "GLCgShaderSystem::create()", __FILE__, __LINE__);
00174    return 0;
00175   }
00176   else
00177   {
00178    GLCgUniform * result = new GLCgUniform(texture->getObjectName());
00179    result->mSampler = texture;
00180    result->mUniformType = Uniform::UT_TEX_2;
00181    mUniformMap.insert(std::make_pair(texture->getObjectName(), result));
00182    return result;
00183   }
00184  }

Uniform * gpucalc::GLCgShaderSystem::create ( const Data &  data  )  [virtual]

creates Uniform variable.

Parameters:
data - represents data, from which we convert to our Uniform.

Implements gpucalc::ShaderSystem.

Definition at line 120 of file gl_Cg_shader_system.cpp.

00121  {
00122   assert(mIsStarted && "GLCgShaderSystem is not started!!!");
00123   std::string UniformName = data.getObjectName();
00124   UniformMap::iterator i = mUniformMap.find(UniformName);
00125   if (i != mUniformMap.end())
00126   {
00127    Except<ERR_DUPLICATE_ITEM>(this, "Uniform variable \"" + UniformName + "\" already exists!", "GLCgShaderSystem::createUniform()", __FILE__, __LINE__);
00128   }
00129   GLCgUniform * result = new GLCgUniform(UniformName);
00130   result->mPointer = data.pointer();
00131   result->mActualLengthGPU = data.getActualLengthCPU() / data.getNumberOfComponents();
00132   result->mNumberOfComponents = data.getNumberOfComponents();
00133   result->mTypeSize = data.getTypeSize();
00134 
00135   if (!data.isArray())
00136   {
00137    switch (data.getValueType())
00138    {
00139     case FloatType:
00140      result->mUniformType = static_cast<Uniform::UniformType>(
00141        Uniform::UT_FLOAT_1 + result->getNumberOfComponents() - 1);
00142      break;
00143 
00144     case IntType:
00145     case UnsignedIntType:
00146      result->mUniformType = static_cast<Uniform::UniformType>(
00147        Uniform::UT_INT_1 + result->getNumberOfComponents() - 1);
00148      break;
00149 
00150     default:
00151      Except<ERR_NOT_IMPLEMENTED>(this, "other ValueTypes is not implemented!",
00152       "GLCgShaderSystem::createUniform()", __FILE__, __LINE__);
00153      break;
00154    }
00155   }
00156   else
00157   {
00158    Except<ERR_INVALIDPARAMS>(this, "this method can work only with uniform data.", "GLCgShaderSystem::create()", __FILE__, __LINE__);
00159   }
00160 
00161   mUniformMap.insert(std::make_pair(UniformName, result));
00162   return result;
00163  }

Shader * gpucalc::GLCgShaderSystem::create ( const std::string &  ShaderName  )  [virtual]

Creates Shader object.

Parameters:
ShaderName - name of our shader object.

Implements gpucalc::ShaderSystem.

Definition at line 66 of file gl_Cg_shader_system.cpp.

00067  {
00068   assert(mIsStarted && "GLCgShaderSystem is not started!!!");
00069   ShaderMap::iterator i = mShaderMap.find(ShaderName);
00070   if (i != mShaderMap.end())
00071   {
00072    Except<ERR_DUPLICATE_ITEM>(this, "Shader \"" + ShaderName + "\" already exists!", "GLCgShaderSystem::create()", __FILE__, __LINE__);
00073    return 0;
00074   }
00075   else
00076   {
00077    GLCgShader * Result = new GLCgShader(ShaderName, mCgContextID, mCgFragmentProfileID, this);
00078    mShaderMap.insert(std::make_pair(ShaderName, Result));
00079    LogManager::getSingleton().logMessage(this, "Shader object \"" + ShaderName + "\" created.", LML_Trivial);
00080    return Result;
00081   }
00082  }

void gpucalc::GLCgShaderSystem::destroy ( Shader *  shader  )  [virtual]

Deletes Shader object.

This method removes shader from mShaderMap and delete it.

Implements gpucalc::ShaderSystem.

Definition at line 107 of file gl_Cg_shader_system.cpp.

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

void gpucalc::GLCgShaderSystem::destroy ( Uniform *  uniform  )  [virtual]

Deletes given Uniform.

Sometimes Uniform may contain pointers or smth else. This method does NOT delete it (pointers).

Implements gpucalc::ShaderSystem.

Definition at line 210 of file gl_Cg_shader_system.cpp.

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

Shader * gpucalc::GLCgShaderSystem::getActiveShader (  )  const [virtual]

Implements gpucalc::ShaderSystem.

Definition at line 247 of file gl_Cg_shader_system.cpp.

00248  {
00249   return mActiveShader;
00250  }

const std::string& gpucalc::Object::getClassName (  )  const [inline, inherited]

Returns name of class of our object.

Definition at line 92 of file object.h.

00093    {
00094     return mClassName;
00095    }

debugger::CodeInstructor * gpucalc::GLCgShaderSystem::getCodeInstructor (  )  const [virtual]

Returns CodeInstructor - special object, which allows to instruct shader with debugging symbols.

Implements gpucalc::ShaderSystem.

Definition at line 330 of file gl_Cg_shader_system.cpp.

00331  {
00332   return mCodeInstructor;
00333  }

const std::string& gpucalc::Object::getObjectName (  )  const [inline, inherited]

Returns name of our object.

Definition at line 101 of file object.h.

00102    {
00103     return mObjectName;
00104    }

Shader * gpucalc::GLCgShaderSystem::getShaderByName ( const std::string &  Shadername  )  const [virtual]

Implements gpucalc::ShaderSystem.

Definition at line 85 of file gl_Cg_shader_system.cpp.

00086  {
00087   assert(mIsStarted && "GLCgShaderSystem is not started!!!");
00088   ShaderMap::const_iterator i = mShaderMap.find(ShaderName);
00089   if (i != mShaderMap.end())
00090   {
00091    return i->second;
00092   }
00093   else
00094   {
00095    Except<ERR_ITEM_NOT_FOUND>(this, "Shader \"" + ShaderName + "\" cannot be found!", "GLCgShaderSystem::getShaderbyName()", __FILE__, __LINE__);
00096   }
00097  }

void gpucalc::Object::getSpecificParameter ( const std::string &  ParameterName,
void *  ParameterValue 
) [inline, inherited]

Method for obtaining some specific parameters, such as texture specific params, and so on.

Parameters:
ParameterName - name of parameter, usually it similar to specific method of some object (for example, GLTextureID)
ParameterValue - contain value of named parameter, it must be allocated and have sufficient size.
Todo:
Think for better realization.

Definition at line 128 of file object.h.

00129    {
00130     SpecificParametersMap::iterator i = mSpecificParameters.find(ParameterName);
00131     if (i != mSpecificParameters.end())
00132     {
00133      i->second.copyValue(ParameterValue);
00134     }
00135     else
00136     {
00137      Except<ERR_ITEM_NOT_FOUND>(this, "Parameter \"" + ParameterName + "\" does not exists.", "Object::getSpecificParameter()", __FILE__, __LINE__);
00138     }
00139    }

Uniform * gpucalc::GLCgShaderSystem::getUniformByName ( const std::string &  UniformName  )  const [virtual]

Implements gpucalc::ShaderSystem.

Definition at line 187 of file gl_Cg_shader_system.cpp.

00188  {
00189   assert(mIsStarted && "GLCgShaderSystem is not started!!!");
00190   UniformMap::const_iterator i = mUniformMap.find(UniformName);
00191   if (i != mUniformMap.end())
00192   {
00193    return i->second;
00194   }
00195   else
00196   {
00197    Except<ERR_ITEM_NOT_FOUND>(this, "Uniform variable with name \"" + UniformName + "\" cannot be found!",
00198     "GLCgShaderSystem::getUniformByName()", __FILE__, __LINE__);
00199   }
00200  }

bool gpucalc::GLCgShaderSystem::isAcceptCore ( const GraphicCore *  Core  )  const [virtual]

Check for GraphicCore acceptance.

We need correct type of GraphicCore, because some shader systems cannot work with some graphic cores (DX core and GL system).

Implements gpucalc::ShaderSystem.

Definition at line 312 of file gl_Cg_shader_system.cpp.

00313  {
00314   return (mAcceptableGraphicCoreIDset.find(Core->getObjectName()) != mAcceptableGraphicCoreIDset.end());
00315  }

bool gpucalc::GLCgShaderSystem::isAcceptFileExtension ( const std::string &  FileExtension  )  const [virtual]

Check for correct file extension.

Implements gpucalc::ShaderSystem.

Definition at line 318 of file gl_Cg_shader_system.cpp.

00319  {
00320   return auxillary::StringUtil::toLower(FileExtension) == std::string("cg");
00321  }

bool gpucalc::Object::isLocked (  )  const [inline, inherited]

returns state of object.

If object is locked then we cannot change some state of it, because object is used in computation. If object is unlocked then we can change some state of it, object is not in computation.

Definition at line 113 of file object.h.

00114    {
00115     return mIsLocked;
00116    }

bool gpucalc::GLCgShaderSystem::isShaderCreated ( const std::string &  ShaderName  )  const [virtual]

Implements gpucalc::ShaderSystem.

Definition at line 100 of file gl_Cg_shader_system.cpp.

00101  {
00102   assert(mIsStarted && "GLCgShaderSystem is not started!!!");
00103   return (mShaderMap.find(ShaderName) != mShaderMap.end());
00104  }

bool gpucalc::GLCgShaderSystem::isUniformCreated ( const std::string &  UniformName  )  const [virtual]

Implements gpucalc::ShaderSystem.

Definition at line 203 of file gl_Cg_shader_system.cpp.

00204  {
00205   assert(mIsStarted && "GLCgShaderSystem is not started!!!");
00206   return (mUniformMap.find(UniformName) != mUniformMap.end());
00207  }

void gpucalc::Object::lock (  )  [inline, protected, inherited]

Definition at line 265 of file object.h.

00266    {
00267     mIsLocked = true;
00268    }

bool gpucalc::ShaderSystem::preCompile ( const std::string &  ShaderName,
const std::string &  ShaderSource,
const std::string &  Parameters = "" 
) [virtual, inherited]

Definition at line 48 of file shader_system.cpp.

00049     {
00050         try
00051         {
00052             Shader * sh = create(ShaderName);
00053             sh->setSource(ShaderSource);
00054             sh->compile(Parameters);
00055             return true;
00056         }
00057         catch(const Exception & e)
00058         {
00059             LogManager::getSingleton().logMessage(this, "Precompilation failed, see log for details.", LML_Critical);
00060             return false;
00061         }
00062     }

void gpucalc::GLCgShaderSystem::start (  )  [virtual]

Perform initialization of ShaderSystem.

Implements gpucalc::ShaderSystem.

Definition at line 267 of file gl_Cg_shader_system.cpp.

00268  {
00269         if (mIsStarted) return;
00271   mCgContextID = cgCreateContext();
00272   LocalCGContext = mCgContextID;
00273   cgSetErrorCallback(cgErrorCallBackFunction);
00274   mCgFragmentProfileID = cgGLGetLatestProfile(CG_GL_FRAGMENT);
00275   cgGLSetOptimalOptions(mCgFragmentProfileID);
00276 
00277 
00278   mIsStarted = true;
00279   this->addAcceptableGraphicCoreID("GLGraphicCore");
00280   LogManager::getSingleton().logMessage(this, "---===========================================---");
00281   LogManager::getSingleton().logMessage(this, "---===     GL Cg Shader system started     ===---");
00282   LogManager::getSingleton().logMessage(this, "---===========================================---");
00283 
00284   if (debugger::Debugger::getSingletonPtr() != 0) 
00285   {
00286    mCodeInstructor = new debugger::GLCgCodeInstructor();
00287    debugger::Debugger::getSingleton().addCodeInstructor(mCodeInstructor);
00288   }
00289  }

void gpucalc::GLCgShaderSystem::stop (  )  [virtual]

Perform deinitialization of ShaderSystem.

Implements gpucalc::ShaderSystem.

Definition at line 292 of file gl_Cg_shader_system.cpp.

00293  {
00294   assert(mIsStarted && "GLCgShaderSystem is not started!!!");
00296   clearContainer(mShaderMap);
00297   clearContainer(mUniformMap);
00298 
00299   LogManager::getSingleton().logMessage(this, "---===========================================---");
00300   LogManager::getSingleton().logMessage(this, "---===     GL Cg Shader system stopped     ===---");
00301   LogManager::getSingleton().logMessage(this, "---===========================================---");
00302   mIsStarted = false;
00303 
00304   if (debugger::Debugger::getSingletonPtr() != 0) 
00305   {
00306    //debugger::Debugger::getSingleton().re
00307    delete mCodeInstructor;
00308   }
00309  }

void gpucalc::GLCgShaderSystem::unbind ( Shader *  shader  )  [virtual]

Implements gpucalc::ShaderSystem.

Definition at line 235 of file gl_Cg_shader_system.cpp.

00236  {
00237   assert(shader && "Shader does not created!!!");
00238   if (shader == mActiveShader)
00239   {
00240    GLCgShader * CgShader = static_cast<GLCgShader *>(shader);
00241    cgGLUnbindProgram(CgShader->mCgFragmentProfileID);
00242    mActiveShader = 0;
00243   }
00244  }

void gpucalc::Object::unlock (  )  [inline, protected, inherited]

Definition at line 271 of file object.h.

00272    {
00273     mIsLocked = false;
00274    }

Member Data Documentation

AcceptableGraphicCoreIDset gpucalc::GLCgShaderSystem::mAcceptableGraphicCoreIDset [private]

Definition at line 134 of file gl_Cg_shader_system.h.

Shader* gpucalc::GLCgShaderSystem::mActiveShader [private]

Definition at line 122 of file gl_Cg_shader_system.h.

CGcontext gpucalc::GLCgShaderSystem::mCgContextID [private]

Definition at line 113 of file gl_Cg_shader_system.h.

CGprofile gpucalc::GLCgShaderSystem::mCgFragmentProfileID [private]

Definition at line 116 of file gl_Cg_shader_system.h.

debugger::CodeInstructor* gpucalc::GLCgShaderSystem::mCodeInstructor [private]

Definition at line 137 of file gl_Cg_shader_system.h.

bool gpucalc::GLCgShaderSystem::mIsStarted [private]

Definition at line 119 of file gl_Cg_shader_system.h.

ShaderMap gpucalc::GLCgShaderSystem::mShaderMap [private]

Definition at line 126 of file gl_Cg_shader_system.h.

UniformMap gpucalc::GLCgShaderSystem::mUniformMap [private]

Definition at line 130 of file gl_Cg_shader_system.h.

The documentation for this class was generated from the following files:
Generated on Thu Mar 5 22:36:43 2009 for gpucalc by  doxygen 1.5.6