gpucalc::Kernel Class Reference

This class representing kernel - a computation unit. More...

#include <kernel.h>

Inheritance diagram for gpucalc::Kernel:

Inheritance graph

List of all members.

Public Member Functions

void bind ()
 Bind our Kernel.
void compile (const std::string &Parameters=std::string())
 Compiles current Kernel.
void compute (const Texture *RenderTarget)
 Compute current Kernel.
const std::string & getClassName () const
 Returns name of class of our object.
FrameBuffer * getFrameBuffer () const
 Returns FrameBuffer object.
const std::string & getObjectName () const
 Returns name of our object.
Shader * getShader () const
 Returns current shader in Kernel.
void getSpecificParameter (const std::string &ParameterName, void *ParameterValue)
 Method for obtaining some specific parameters, such as texture specific params, and so on.
bool isActive () const
bool isLocked () const
 returns state of object.
 Kernel (const std::string &ObjectName, GraphicCore *DefaultGraphicCore)
void postCompute ()
 Perform all necessary task for correct obtaining result of computation of this kernel.
void preCompute ()
 Perform all necessary tasks for correct computing kernel.
FrameBuffer * removeFrameBuffer ()
 Removes current FrameBuffer.
Shader * removeShader ()
 Remove shader from our Kernel.
void setFrameBuffer (FrameBuffer *fb)
 Set FrameBuffer to our Kernel.
void setShader (Shader *shader)
 Sets Shader to our Kernel.
void unbind ()
 Unbind our Kernel.
 ~Kernel ()

Protected Member Functions

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

Private Attributes

GraphicCore * mDefaultGraphicCore
FrameBuffer * mFrameBuffer
 Pointer to FrameBuffer object.
Shader * mShader
 Pointer to Shader object.

Detailed Description

This class representing kernel - a computation unit.

Kernel - is a system with multiple inputs and outputs. Each thread in kernel computes independently from other threads. GPU kernels hasn't opportunity to write in random output, but can read value from any input. Usually, inputs and outputs are textures, and we must properly set up them

Definition at line 89 of file kernel.h.

Constructor & Destructor Documentation

gpucalc::Kernel::Kernel ( const std::string &  ObjectName,
GraphicCore *  DefaultGraphicCore 
) [inline]

Definition at line 97 of file kernel.h.

00097                                                                          : Object(_KernelClassName, ObjectName),
00098     Bindable(_KernelClassName, ObjectName), mShader(0), mFrameBuffer(0), mDefaultGraphicCore(DefaultGraphicCore)
00099    {
00100     LogManager::getSingleton().logMessage(this, "created.", LML_Trivial);
00101    }

gpucalc::Kernel::~Kernel (  )  [inline]

Warning:
Possible memory leak detected. Programmer must remove shader manually and then delete it.

Definition at line 104 of file kernel.h.

00105    {
00106     if (mShader) 
00107     {
00108      Warning<ERR_VALUE_NOT_DELETED_ERROR>(this,
00109       "Does not deleted. If you have pointer to it you must delete it manually, else there is a possible memory leak.",
00110       "Kernel::~Kernel", __FILE__, __LINE__);
00111     }
00112     LogManager::getSingleton().logMessage(this, "Deleted.", LML_Trivial);
00113    }

Member Function Documentation

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::Kernel::bind (  )  [inline, virtual]

Bind our Kernel.

This method bind Kernel::mShader and Kernel::mFrameBuffer, so our kernel ready for computations.

Implements gpucalc::Bindable.

Definition at line 262 of file kernel.h.

00263    {
00264     assert (mFrameBuffer && "This kernel does not have FrameBuffer!!!");
00265     mFrameBuffer->bind();
00266 
00267     assert(mShader && "This kernel does not have Kernel!!!");
00268     mShader->bind();
00269    }

void gpucalc::Kernel::compile ( const std::string &  Parameters = std::string()  )  [inline]

Compiles current Kernel.

This method provides compiling only current shader: Kernel::mShader, using method Shader::compileShader.

Parameters:
Parameters - parameters, passed to shader compiler.

Definition at line 190 of file kernel.h.

00191    {
00192     assert(mFrameBuffer && mShader && "This kernel does not have FrameBuffer or Shader!!!");
00193     LogManager::getSingleton().logMessage(this, "Starting compiling...", LML_Trivial);
00194     mShader->compile(Parameters);
00195     LogManager::getSingleton().logMessage(this, "Compiled kernel.", LML_Trivial);
00196    }

void gpucalc::Kernel::compute ( const Texture *  RenderTarget  )  [inline]

Compute current Kernel.

Before computing we must bind our kernel, using method Kernel::bind, after that we set all textures as uniform samplers to our Kernel::mShader. Then we check our shader for errors: Shader::validateShader, and finally we set render destination: FrameBuffer::drawBuffer.

Remarks:
if you want to obtain results of computation, you must get it from corresponding FrameBuffer object!! but it is better obtain results from corresponding Task object!!!

Definition at line 227 of file kernel.h.

00228    {
00229     LogManager::getSingleton().logMessage(this, "Computing started...", LML_Trivial);
00230 
00231     assert(mFrameBuffer && mShader && "This kernel does not ready for precomputing!!!");
00232     mDefaultGraphicCore->setMatrixMode(RenderTarget->getSizeX(), RenderTarget->getSizeY());
00233     mFrameBuffer->drawBuffer(RenderTarget);
00234     mShader->bind();
00235 
00236     Profiler::getSingleton().beginProfile("Kernel::compute");
00237     mDefaultGraphicCore->draw(RenderTarget->getSizeX(), RenderTarget->getSizeY());
00238     Profiler::getSingleton().endProfile("Kernel::compute");
00239 
00240     LogManager::getSingleton().logMessage(this, "Computing finished.", LML_Trivial);
00241    }

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    }

FrameBuffer* gpucalc::Kernel::getFrameBuffer (  )  const [inline]

Returns FrameBuffer object.

When computation is done, we may want to get results of computation directly from FrameBuffer.

Definition at line 153 of file kernel.h.

00154    {
00155     assert(mFrameBuffer && "This kernel does not have framebuffer!!!");
00156     return mFrameBuffer;
00157    }

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::Kernel::getShader (  )  const [inline]

Returns current shader in Kernel.

Definition at line 141 of file kernel.h.

00142    {
00143     assert(mShader && "This kernel does not have shader!!!");
00144     return mShader;
00145    }

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    }

bool gpucalc::Kernel::isActive (  )  const [inline, virtual]

Implements gpucalc::Bindable.

Definition at line 287 of file kernel.h.

00288    {
00289     assert (mFrameBuffer && "This kernel does not have FrameBuffer!!!");
00290     assert(mShader && "This kernel does not have Kernel!!!");
00291 
00292     return (mShader->isActive() && mFrameBuffer->isActive());
00293    }

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    }

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

Definition at line 265 of file object.h.

00266    {
00267     mIsLocked = true;
00268    }

void gpucalc::Kernel::postCompute (  )  [inline]

Perform all necessary task for correct obtaining result of computation of this kernel.

Remarks:
Actually this method must be private or protected, but if we want obtian full control on computational process, we must use this method, maybe...:))

Definition at line 251 of file kernel.h.

00252    {
00253     // does nothing
00254    }

void gpucalc::Kernel::preCompute (  )  [inline]

Perform all necessary tasks for correct computing kernel.

Remarks:
Actually this method must be private or protected, but if we want obtain full control on computational process, we must use this method, maybe...:))

Definition at line 206 of file kernel.h.

00207    {
00208     Profiler::getSingleton().beginProfile("Kernel::preCompute");
00209     assert(mFrameBuffer && mShader && "This kernel does not ready for precomputing!!!");
00210     this->bind();
00211     mShader->preCompute();
00212     Profiler::getSingleton().endProfile("Kernel::preCompute");
00213    }

FrameBuffer* gpucalc::Kernel::removeFrameBuffer (  )  [inline]

Removes current FrameBuffer.

Definition at line 173 of file kernel.h.

00174    {
00175     assert(mFrameBuffer && "This kernel does not have FrameBuffer");
00176     FrameBuffer * result = mFrameBuffer;
00177     mFrameBuffer = 0;
00178     return result;
00179    }

Shader* gpucalc::Kernel::removeShader (  )  [inline]

Remove shader from our Kernel.

Definition at line 129 of file kernel.h.

00130    {
00131     assert(mShader && "This kernel does not have shader!!!");
00132     Shader * result = mShader;
00133     mShader = 0;
00134     return result;
00135    }

void gpucalc::Kernel::setFrameBuffer ( FrameBuffer *  fb  )  [inline]

Set FrameBuffer to our Kernel.

Definition at line 163 of file kernel.h.

00164    {
00165     assert(!mFrameBuffer && "This kernel already has FrameBuffer!!!");
00166     mFrameBuffer = fb;
00167    }

void gpucalc::Kernel::setShader ( Shader *  shader  )  [inline]

Sets Shader to our Kernel.

Definition at line 119 of file kernel.h.

00120    {
00121     assert(!mShader && "This kernel already has shader!!!");
00122     mShader = shader;
00123    }

void gpucalc::Kernel::unbind (  )  [inline, virtual]

Unbind our Kernel.

This method unbind Kernel::mShader and Kernel::mFrameBuffer.

Implements gpucalc::Bindable.

Definition at line 277 of file kernel.h.

00278    {
00279     assert (mFrameBuffer && "This kernel does not have FrameBuffer!!!");
00280     mFrameBuffer->unbind();
00281 
00282     assert(mShader && "This kernel does not have Kernel!!!");
00283     mShader->unbind();
00284    }

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

Definition at line 271 of file object.h.

00272    {
00273     mIsLocked = false;
00274    }

Member Data Documentation

GraphicCore* gpucalc::Kernel::mDefaultGraphicCore [private]

Definition at line 313 of file kernel.h.

FrameBuffer* gpucalc::Kernel::mFrameBuffer [private]

Pointer to FrameBuffer object.

With this member we can obtain results of computation.

Definition at line 310 of file kernel.h.

Shader* gpucalc::Kernel::mShader [private]

Pointer to Shader object.

Definition at line 302 of file kernel.h.

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