• Main
• Home
• Features
• Screenshots
• Downloads
• License
• Team profile
• Documentation
• Manual
• FAQ
• Reference

Search this page:

PCMRendererPlugin.cpp

Go to the documentation of this file.

//
// This source file is a part of ParCompMark
// Parallel Compositing Benchmark Framework
//
// for latest info see http://parcompmark.sourceforge.net

//
// Copyright (C) 2006 IT2 ParCompMark Dev. Team
// 
// 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.

//
// Inner includes
//

#include "../include/PCMRendererPlugin.h"

#include "../include/PCMRenderer.h"

#include "../include/PCMOpenGLRenderingEngine.h"

#include "../include/PCMOpenGLExtensionLoader.h"

#include "../include/PCMNode.h"

namespace ParCompMark
{

  //
  // Constructors & destructor
  //

  RendererPlugin::RendererPlugin(const Plugin::PluginType & type, const std::string & name,
                                 const std::string & filename):
        // Parent initializer 
  Plugin(type                   /* Type of the plugin. */
         , name         /* Name of the plugin. */
         , filename             /* Plugin file name. */
        )
        // You have to initialize the following attributes:
        // - mNeededOpenGLExts
        // - mPcmOnResize
        // - mPcmGetSortOrder
        // - mPcmOnRender
  {
        mPcmOnResize = 0;
        mPcmGetSortOrder = 0;
        mPcmOnRender = 0;

        _setBufferGetter();
  }

 /*----------------------------------------------------------------------*/

  RendererPlugin::~RendererPlugin()
  {
  }

 /*----------------------------------------------------------------------*/

  //
  // Class methods
  //

  void RendererPlugin::_bufferGetter(const void *pRenderer, const char *bufferName, void *pBufferData)
  {
        // Be careful! This method has to be reentrant

        // Get correspondent Renderer object
        Assert(pRenderer, NULL_POINTER_ERROR, "RendererPlugin::_bufferGetter()");
        const Renderer *renderer = static_cast < const Renderer * >(pRenderer);

        Assert(renderer, INVALID_OBJECT_ERROR, "RendererPlugin::_bufferGetter()");

        // Step up the the Node
        Node *node = renderer->getParent()->getParent()->getParent();

        // Get buffer
        Buffer::Pointer buffer = node->getBuffer(bufferName);

        // Getting the buffer
        if(pBufferData)
        {
         // Lock buffer
         //buffer.lock();

         PluginBuffer *bufferData = static_cast < PluginBuffer * >(pBufferData);

         Assert(bufferData, INVALID_OBJECT_ERROR, "RendererPlugin::_bufferGetter()");

         // Retrieve data
         bufferData->left = (unsigned) buffer->getLeft();
         bufferData->top = (unsigned) buffer->getTop();
         bufferData->width = (unsigned) buffer->getWidth();
         bufferData->height = (unsigned) buffer->getHeight();
         bufferData->colour = (unsigned char *) buffer->getColour();
        }
        // Releasing the buffer
        else
        {
         // Release buffer lock
         //buffer.unlock();
        }
  }

 /*----------------------------------------------------------------------*/

  //
  // Methods
  //

  Renderer *RendererPlugin::createRenderer(GLXRenderWindow::Pointer window, OpenGLRenderingEngine * parent)
  {
        Assert(parent, NULL_POINTER_ERROR, "RendererPlugin::createRenderer()");

        // Jump out and create renderer without handle if no such function
        if(!hasFunction("pcmOnCreateRenderer"))
         return new Renderer(this, 0, parent);

        pcmOnCreateRendererType pcmOnCreateRenderer = (pcmOnCreateRendererType) getFunction("pcmOnCreateRenderer");

        // Create ParCompMark::Renderer object without corresponding plugin object
        Renderer *renderer = new Renderer(this, 0, parent);

        // Create plugin object
        window.lock();
        void *rendererHandle =
         pcmOnCreateRenderer((void *) renderer, window->getDisplay()->getDisplay(), window->getWindow(),
                                window->getGLXGLContext()->getVisualInfo(),
                                window->getGLXGLContext()->getGLXContext());

        window.unlock();
        Assert(rendererHandle, NULL_POINTER_ERROR, "RendererPlugin::createRenderer()");

        // Set plugin object to the ParCompMark::Renderer
        // This later setter is needed (instead of constructor parameter), 
        //because ParCompMark::Renderer need a pointer to the plugin object and back
        renderer->setRendererHandle(rendererHandle);

        Logger::getInstance()->log(Logger::DEBUG,
                                 "pcmOnCreateRenderer event handler is called for renderer plugin `" + mName + "\'.");

        return renderer;
  }

 /*----------------------------------------------------------------------*/

  void RendererPlugin::destroyRenderer(Renderer * renderer)
  {
        // Jump out if no such function
        if(!hasFunction("pcmOnDestroyRenderer"))
         return;

        pcmOnDestroyRendererType pcmOnDestroyRenderer = (pcmOnDestroyRendererType) getFunction("pcmOnDestroyRenderer");

        mLastError = pcmOnDestroyRenderer(renderer->getRendererHandle());
        _checkError();

        Logger::getInstance()->log(Logger::DEBUG,
                                 "pcmOnDestroyRenderer event handler is called for renderer plugin `" + mName +
                                 "\'.");
  }

 /*----------------------------------------------------------------------*/

  void RendererPlugin::_initializeSpecific()
  {
        _getNeededOpenGLExts();

        // Get an load OpenGL extensions
        _initFastFunctions();
        OpenGLExtensionLoader::load(mNeededOpenGLExts);
  }

 /*----------------------------------------------------------------------*/

  void RendererPlugin::_finalizeSpecific()
  {
  }

 /*----------------------------------------------------------------------*/

  void RendererPlugin::_setBufferGetter()
  {
        // Jump out if no such function
        if(!hasFunction("pcmSetBufferGetter"))
         return;

        pcmSetBufferGetterType pcmSetBufferGetter = (pcmSetBufferGetterType) getFunction("pcmSetBufferGetter");

        mLastError = pcmSetBufferGetter(RendererPlugin::_bufferGetter);
        _checkError();

        Logger::getInstance()->log(Logger::DEBUG,
                                 "Buffer getter function is set for renderer plugin `" + mName + "\'.");
  }

 /*----------------------------------------------------------------------*/

  void RendererPlugin::_getNeededOpenGLExts()
  {
        // Jump out if no such function
        if(!hasFunction("pcmGetNeededOpenGLExts"))
         return;

        pcmGetNeededOpenGLExtsType pcmGetNeededOpenGLExts =
         (pcmGetNeededOpenGLExtsType) getFunction("pcmGetNeededOpenGLExts");
        const char **neededOpenGLExts = pcmGetNeededOpenGLExts();

        if(neededOpenGLExts)
         for(const char **ext = neededOpenGLExts; *ext; ext++)
                mNeededOpenGLExts.push_back(*ext);

        Logger::getInstance()->log(Logger::DEBUG,
                                 "Needed OpenGL extensions are retrieved from renderer plugin `" + mName + "\'.");
  }

 /*----------------------------------------------------------------------*/

  void RendererPlugin::_initFastFunctions()
  {
        Assert(hasFunction("pcmOnResize")
           && hasFunction("pcmOnRender"), INVALID_NAME_ERROR, "Plugin::_initFastFunctions()");

        // "Must have functions"
        mPcmOnResize = (pcmOnResizeType) getFunction("pcmOnResize");
        mPcmOnRender = (pcmOnRenderType) getFunction("pcmOnRender");

        // Optional function
        mPcmGetSortOrder = hasFunction("pcmGetSortOrder") ? (pcmGetSortOrderType) getFunction("pcmGetSortOrder") : 0;

        Logger::getInstance()->log(Logger::DEBUG,
                                 "pcmOnResize and pcmOnRender function pointers are set for renderer plugin `" +
                                 mName + "\'.");
  }

 /*----------------------------------------------------------------------*/

}

© Copyright - 2006 (IT)² ParCompMark Dev. Team