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

Search this page:

PCMOpenGLRenderingEngine.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/PCMOpenGLRenderingEngine.h"

#include "../include/PCMPluginManager.h"

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

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

#include "../include/PCMStringConverter.h"

#include "../include/PCMProcess.h"

//
// Outer includes
//

#include <algorithm>
#include <GL/glew.h>
#include <GL/glx.h>
#include <GL/glu.h>
#include <GL/glut.h>

namespace ParCompMark
{

  //
  // Constructors & destructor
  //

  OpenGLRenderingEngine::OpenGLRenderingEngine()
        // You have to initialize the following attributes:
        // - mParent
        // - mCamera
        // - mDrawStyle
        // - mRenderers
        // - mAutoRenderingQueue
        // - mObjectData
        // - mDisplayLists
        // - mCurrentDisplayList
        // - mLightCount
  {
        Except(INVALID_OPERATION_ERROR, "OpenGLRenderingEngine::OpenGLRenderingEngine()",
           "Default constructor for Squirrel compatibility. Calling this constructor always raises an exception.");
  }

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

  OpenGLRenderingEngine::OpenGLRenderingEngine(Process * parent):
        // Initialize parent process 
   mParent(parent               /* Parent process */
        )
        // You have to initialize the following attributes:
        // - mParent
        // - mCamera
        // - mDrawStyle
        // - mRenderers
        // - mAutoRenderingQueue
        // - mObjectData
        // - mDisplayLists
        // - mCurrentDisplayList
        // - mLightCount
  {
        // Do not hurt the camera (plugins might be angry :))
        mDrawStyle = FILL;

        mCurrentDisplayList = 0;
        mLightCount = 0;

        // For some OpenGL implementations, texture coordinates generated during rasterization 
        // aren't perspective correct. However, you can usually make them perspective correct 
        // by calling the following function:
        glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);

        Logger::getInstance()->log(Logger::NOTICE,
                                 "Rendering engine has been created for process `" + parent->getName() + "\'.");
  }

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

  OpenGLRenderingEngine::~OpenGLRenderingEngine()
  {
        // Cleaning up display lists
        for(std::vector < DisplayList * >::iterator i = mDisplayLists.begin(); i != mDisplayLists.end(); i++)
         glDeleteLists((*i)->handle, 1);

        // Cleaning up object data
        for(std::vector < ObjectData >::iterator i = mObjectData.begin(); i != mObjectData.end(); i++)
        {
         if(i->vertexCoordinates)
                delete[]i->vertexCoordinates;
         if(i->texCoordinates)
                delete[]i->texCoordinates;
         if(i->normals)
                delete[]i->normals;
        }

        Logger::getInstance()->log(Logger::NOTICE,
                                 "Rendering engine of process `" + mParent->getName() + "\' has been destroyed.");
  }

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

  //
  // Class methods
  //

  OpenGLRenderingEngine *OpenGLRenderingEngine::create(const char *stringPtr)
  {
        void *p = StringConverter::parsePointer(stringPtr);

        return static_cast < OpenGLRenderingEngine * >(p);
  }

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

  //
  // Methods
  //

  Renderer *OpenGLRenderingEngine::createCustomRenderer(const char *rendererName)
  {
        // Get plugin
        Plugin::Pointer plugin(PluginManager::getInstance()->getPlugin(rendererName));
        Assert(plugin->getPluginType() == Plugin::RENDERER_PLUGIN, INVALID_CLASS_ERROR,
           "OpenGLRenderingEngine::createCustomRenderer");

        // Cast plugin to renderer plugin
        RendererPlugin *rPlugin = dynamic_cast < RendererPlugin * >(plugin.getPtr());

        Assert(rPlugin, INVALID_CLASS_ERROR, "OpenGLRenderingEngine::createCustomRenderer()");

        // Create renderer
        Renderer *renderer = rPlugin->createRenderer(mParent->getRenderWindow(), this);

        // Register this renderer on this rendering engine 
        // (for later operations, for example canvas resizing)
        _registerRenderer(renderer);

        return renderer;
  }

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

  void OpenGLRenderingEngine::resizeRenderers(const u32 width, const u32 height)
  {
        for(std::set < Renderer * >::iterator i = mRenderers.begin(); i != mRenderers.end(); i++)
        {
         (*i)->resize(width, height);
        }
  }

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

  s32 OpenGLRenderingEngine::getSortOrderFromRenderers()
  {
        int order = -1;

        for(std::set < Renderer * >::iterator i = mRenderers.begin(); i != mRenderers.end(); i++)
        {
         int _order = (*i)->getSortOrder();

         if(_order != -1)
         {
                if(order != -1 && order != _order)
                 Except(INVALID_VALUE_ERROR, "OpenGLRenderingEngine::getSortOrderFromRenderers()",
                         "Conflicting sort order retrieved from renderer plugins on the same rendering engine");

                order = _order;
         }
        }

        return order;
  }

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

  void OpenGLRenderingEngine::setAutoRenderOrder(const Renderer * renderer, const s32 & order)
  {
        // Test whether the specified renderer is added to the rendering engine or not
        Assert(mRenderers.find((Renderer *) renderer) != mRenderers.end(), INVALID_OBJECT_ERROR,
           "OpenGLRenderingEngine::setAutoRenderOrder");

        // Remove from queue if the renderer is in it
        std::vector < Renderer * >::iterator i =
         std::find(mAutoRenderingQueue.begin(), mAutoRenderingQueue.end(), (Renderer *) renderer);

        if(i != mAutoRenderingQueue.end())
         mAutoRenderingQueue.erase(i);

        // Removing so jump out
        if(order == Renderer::NOAUTORENDERING)
         return;

        // Insert into the queue
        for(i = mAutoRenderingQueue.begin(); i != mAutoRenderingQueue.end(); i++)
         if((*i)->getAutoRenderOrder() > order)
                break;

        mAutoRenderingQueue.insert(i, (Renderer *) renderer);
  }

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

  void OpenGLRenderingEngine::doAutoRendering()
  {
        for(std::vector < Renderer * >::iterator i = mAutoRenderingQueue.begin(); i != mAutoRenderingQueue.end(); i++)
         (*i)->render();
  }

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

  void OpenGLRenderingEngine::perspective(const double fovy, const double zNear, const double zFar)
  {
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluPerspective(fovy,
                   (double) mParent->getRenderWindow()->getWidth() /
                   (double) mParent->getRenderWindow()->getHeight(), zNear, zFar);
  }

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

  void OpenGLRenderingEngine::ortho2D(const double left, const double right, const double bottom,
                                        const double top)
  {
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluOrtho2D(left, right, bottom, top);
  }

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

  void OpenGLRenderingEngine::viewport(const double left, const double top, const double width,
                                         const double height)
  {
        double winWidth = mParent->getRenderWindow()->getWidth();
        double winHeight = mParent->getRenderWindow()->getHeight();

        // TODO: Not works!!!
        //glViewport((GLint) (left * winWidth), (GLint) (top * winHeight), (GLsizei) (width * winWidth), (GLsizei) (height * winHeight));
        glViewport(0, 0, winWidth, winHeight);
  }

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

  void OpenGLRenderingEngine::pushModelView()
  {
        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
  }

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

  void OpenGLRenderingEngine::popModelView()
  {
        glMatrixMode(GL_MODELVIEW);
        glPopMatrix();
  }

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

  void OpenGLRenderingEngine::translate(const double x, const double y, const double z)
  {
        glMatrixMode(GL_MODELVIEW);
        glTranslated(x, y, z);
  }

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

  void OpenGLRenderingEngine::rotate(const double angle, const double x, const double y,
                                   const double z)
  {
        glMatrixMode(GL_MODELVIEW);
        glRotated(angle, x, y, z);
  }

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

  void OpenGLRenderingEngine::scale(const double x, const double y, const double z)
  {
        glMatrixMode(GL_MODELVIEW);
        glScaled(x, y, z);
  }

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

  void OpenGLRenderingEngine::setCameraPosition(const double eyeX, const double eyeY,
                                                const double eyeZ)
  {
        mCamera.position[0] = eyeX;
        mCamera.position[1] = eyeY;
        mCamera.position[2] = eyeZ;
        _refreshCamera();
  }

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

  void OpenGLRenderingEngine::setCameraTarget(const double centerX, const double centerY,
                                                const double centerZ)
  {
        mCamera.target[0] = centerX;
        mCamera.target[1] = centerY;
        mCamera.target[2] = centerZ;
        _refreshCamera();
  }

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

  void OpenGLRenderingEngine::setCameraUpVector(const double upX, const double upY,
                                                const double upZ)
  {
        mCamera.upVector[0] = upX;
        mCamera.upVector[1] = upY;
        mCamera.upVector[2] = upZ;
        _refreshCamera();
  }

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

  void OpenGLRenderingEngine::setColor(const double red, const double green, const double blue,
                                         const double alpha)
  {
        glColor4d(red, green, blue, alpha);
  }

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

  void OpenGLRenderingEngine::setAmbientMaterial(const double red, const double green,
                                                 const double blue, const double alpha)
  {
        GLfloat params[] = { red, green, blue, alpha };
        glMaterialfv(GL_FRONT, GL_AMBIENT, params);
  }

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

  void OpenGLRenderingEngine::setDiffuseMaterial(const double red, const double green,
                                                 const double blue, const double alpha)
  {
        GLfloat params[] = { red, green, blue, alpha };
        glMaterialfv(GL_FRONT, GL_DIFFUSE, params);
  }

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

  void OpenGLRenderingEngine::setSpecularMaterial(const double red, const double green,
                                                 const double blue, const double alpha,
                                                 const int shininess)
  {
        GLfloat params[] = { red, green, blue, alpha };
        glMaterialfv(GL_FRONT, GL_SPECULAR, params);
        glMateriali(GL_FRONT, GL_SHININESS, shininess);
  }

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

  void OpenGLRenderingEngine::setDrawStyle(const unsigned drawStyle)
  {
        mDrawStyle = DrawStyle(drawStyle);
  }

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

  void OpenGLRenderingEngine::setBackCulling(const bool isBackCulling)
  {
        if(isBackCulling)
        {
         glEnable(GL_CULL_FACE);
         glCullFace(GL_BACK);
        } else
         glDisable(GL_CULL_FACE);
  }

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

  void OpenGLRenderingEngine::setBlending(const bool isOn)
  {
        if(isOn)
        {
         glEnable(GL_BLEND);
         glDisable(GL_DEPTH_TEST);
         glBlendFunc(GL_SRC_ALPHA, GL_ONE);
        } else
        {
         glDisable(GL_BLEND);
         glEnable(GL_DEPTH_TEST);
        }
  }

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

  void OpenGLRenderingEngine::drawTriangle()
  {
        glBegin(GL_TRIANGLES);
        glVertex2f(1.0, 0.0);
        glVertex2f(0.0, 0.0);
        glVertex2f(0.0, 1.0);
        glEnd();

        _reportTriangles(1);
  }

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

  int OpenGLRenderingEngine::generateRandomTriangles(const int dimension, const int count)
  {
        Assert(dimension == 2
           || dimension == 3, INVALID_VALUE_ERROR, "OpenGLRenderingEngine::generateRandomTriangles()");

        // Allocate memory for data
        ObjectData data;

        data.vertexCount = 3 * count;
        data.vertexSize = dimension;
        data.texSize = 0;
        data.vertexCoordinates = new float[dimension * data.vertexCount];

        data.texCoordinates = 0;
        data.normals = new float[dimension * data.vertexCount];

        // Generate random triangles
        srand((unsigned int) (Timer::getSystemTime() * 1e6));
        for(float *vp = data.vertexCoordinates, *vpEnd = data.vertexCoordinates + dimension * data.vertexCount;
         vp != vpEnd; vp++)
        {
         *vp = (double) rand() / ((double) (RAND_MAX) + (double) (1));
        }

        // Calculate normals
        if(dimension == 3)
        {
         for(float *vp = data.vertexCoordinates, *vpEnd =
                data.vertexCoordinates + dimension * data.vertexCount, *normals = data.normals; vp != vpEnd;
                vp += 9, normals += 9)
         {
                float *v1 = vp,
                 *v2 = vp + 3,
                 *v3 = vp + 6;
                float a[3],
                b[3],
                n[3];

                a[0] = v2[0] - v1[0];
                a[1] = v2[1] - v1[1];
                a[2] = v2[2] - v1[2];
                b[0] = v3[0] - v1[0];
                b[1] = v3[1] - v1[1];
                b[2] = v3[2] - v1[2];

                n[0] = a[1] * b[2] - b[1] * a[2];
                n[1] = -(a[0] * b[2] - b[0] * a[2]);
                n[2] = a[0] * b[1] - b[0] * a[1];

                normals[0] = normals[3] = normals[6] = n[0];
                normals[1] = normals[4] = normals[7] = n[1];
                normals[2] = normals[6] = normals[8] = n[2];
         }
        }

        return _registerObject(data);
  }

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

  void OpenGLRenderingEngine::renderObject(const u32 handle, const bool useVertexArrays)
  {
        ObjectData & data = mObjectData[handle];

        _renderObject(handle, useVertexArrays, data.vertexCount);
  }

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

  void OpenGLRenderingEngine::renderObjectTriangles(const u32 handle, const bool useVertexArrays,
                                                  const u32 triangleCount)
  {
        _renderObject(handle, useVertexArrays, triangleCount * 3);
  }

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

  void OpenGLRenderingEngine::setAmbientLight(const double red, const double green,
                                                const double blue, const double alpha)
  {
        glEnable(GL_LIGHTING);

        GLfloat params[] = { red, green, blue, alpha };
        glLightModelfv(GL_LIGHT_MODEL_AMBIENT, params);
  }

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

  void OpenGLRenderingEngine::removeLightSources()
  {
        glDisable(GL_LIGHTING);
        for(u32 i = 0; i < mLightCount; i--)
         glDisable(GL_LIGHT0 + i);

        mLightCount = 0;
  }

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

  int OpenGLRenderingEngine::addLightSource()
  {
        glEnable(GL_LIGHTING);

        int newLight = mLightCount++;

        glEnable(GL_LIGHT0 + newLight);
        setLightSourcePosition(newLight, 0.0, 0.0, 0.0);
        setLightSourceDiffuse(newLight, 1.0, 1.0, 1.0, 1.0);
        setLightSourceSpecular(newLight, 1.0, 1.0, 1.0, 1.0);

        return newLight;
  }

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

  void OpenGLRenderingEngine::setLightSourcePosition(const int light, const double x,
                                                   const double y, const double z)
  {
        GLfloat params[] = { x, y, z };
        glEnable(GL_LIGHT0 + light);
        glLightfv(GL_LIGHT0 + light, GL_POSITION, params);
  }

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

  void OpenGLRenderingEngine::setLightSourceDiffuse(const int light, const double red,
                                                  const double green, const double blue,
                                                  const double alpha)
  {
        GLfloat params[] = { red, green, blue, alpha };
        glLightfv(GL_LIGHT0 + light, GL_DIFFUSE, params);
  }

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

  void OpenGLRenderingEngine::setLightSourceSpecular(const int light, const double red,
                                                   const double green, const double blue,
                                                   const double alpha)
  {
        GLfloat params[] = { red, green, blue, alpha };
        glLightfv(GL_LIGHT0 + light, GL_SPECULAR, params);
  }

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

  u32 OpenGLRenderingEngine::createDisplayList()
  {
        mCurrentDisplayList = new DisplayList();

        // Create list
        mCurrentDisplayList->handle = glGenLists(1);

        mDisplayLists.insert(mDisplayLists.begin(), mCurrentDisplayList);

        // Start list
        glNewList(mCurrentDisplayList->handle, GL_COMPILE);

        return mDisplayLists.size() - 1;
  }

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

  void OpenGLRenderingEngine::finishDisplayList()
  {
        glEndList();
        mCurrentDisplayList = 0;
  }

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

  void OpenGLRenderingEngine::executeDisplayList(const u32 displayList)
  {
        Assert(displayList < mDisplayLists.size(), INVALID_OBJECT_ERROR, "OpenGLRenderingEngine::executeDisplayList()");
        glCallList(mDisplayLists[displayList]->handle);

        // Report rendered triangles 
        mParent->getRenderWindow()->reportTriangles(mDisplayLists[displayList]->triangleCount);
  }

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

  void OpenGLRenderingEngine::drawSphere(const double radius, const int slices, const int stacks)
  {
        GLUquadricObj *sphere = gluNewQuadric();

        if(_setGLUDrawStyle(sphere))
         gluSphere(sphere, radius, slices, stacks);

        gluDeleteQuadric(sphere);
  }

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

  void OpenGLRenderingEngine::drawCylinder(const double baseRadius, const double topRadius,
                                          const double height, const int slices, const int stacks)
  {
        GLUquadricObj *cylinder = gluNewQuadric();

        if(_setGLUDrawStyle(cylinder))
         gluCylinder(cylinder, baseRadius, topRadius, height, slices, stacks);

        gluDeleteQuadric(cylinder);
  }

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

  void OpenGLRenderingEngine::drawDisk(const double innerRadius, const double outerRadius,
                                         const int slices, const int loops)
  {
        GLUquadricObj *disk = gluNewQuadric();

        if(_setGLUDrawStyle(disk))
         gluDisk(disk, innerRadius, outerRadius, slices, loops);

        gluDeleteQuadric(disk);
  }

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

  void OpenGLRenderingEngine::drawTeapot(const double size)
  {
#if defined(HAVE_GL_GLUT_H) && defined(HAVE_LIBGLUT)
        switch (mDrawStyle)
        {
         case WIRE:
                glutWireTeapot(size);
                break;
         case FILL:
                glutSolidTeapot(size);
                break;
         default:
                break;
        }
#else
        Except(OPERATION_NOT_SUPPORTED_ERROR, "OpenGLRenderingEngine::drawTeapot()",
           "GLUT library does not present on your system.");
#endif
  }

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

  void OpenGLRenderingEngine::drawCube(const double size)
  {
#if defined(HAVE_GL_GLUT_H) && defined(HAVE_LIBGLUT)
        switch (mDrawStyle)
        {
         case WIRE:
                glutWireCube(size);
                break;
         case FILL:
                glutSolidCube(size);
                _reportTriangles(6 * 2);
                break;
         default:
                break;
        }
#else
        Except(OPERATION_NOT_SUPPORTED_ERROR, "OpenGLRenderingEngine::drawCube()",
           "GLUT library does not present on your system.");
#endif
  }

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

  void OpenGLRenderingEngine::drawTorus(const double innerRadius, const double outerRadius,
                                        const int nsides, const int rings)
  {
#if defined(HAVE_GL_GLUT_H) && defined(HAVE_LIBGLUT)
        switch (mDrawStyle)
        {
         case WIRE:
                glutWireTorus(innerRadius, outerRadius, nsides, rings);
                break;
         case FILL:
                glutSolidTorus(innerRadius, outerRadius, nsides, rings);
                break;
         default:
                break;
        }
#else
        Except(OPERATION_NOT_SUPPORTED_ERROR, "OpenGLRenderingEngine::drawTorus()",
           "GLUT library does not present on your system.");
#endif
  }

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

  void OpenGLRenderingEngine::drawDodecahedron(const double size)
  {
#if defined(HAVE_GL_GLUT_H) && defined(HAVE_LIBGLUT)
        pushModelView();
        Real ratio = size /::sqrt(3);

        scale(ratio, ratio, ratio);
        switch (mDrawStyle)
        {
         case WIRE:
                glutWireDodecahedron();
                break;
         case FILL:
                glutSolidDodecahedron();
                _reportTriangles(12 * 5);
                break;
         default:
                break;
        }
        popModelView();
#else
        Except(OPERATION_NOT_SUPPORTED_ERROR, "OpenGLRenderingEngine::drawDodecahedron()",
           "GLUT library does not present on your system.");
#endif
  }

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

  void OpenGLRenderingEngine::drawOctahedron(const double size)
  {
#if defined(HAVE_GL_GLUT_H) && defined(HAVE_LIBGLUT)
        pushModelView();
        scale(size, size, size);
        switch (mDrawStyle)
        {
         case WIRE:
                glutWireOctahedron();
                break;
         case FILL:
                glutSolidOctahedron();
                _reportTriangles(8);
                break;
         default:
                break;
        }
        popModelView();
#else
        Except(OPERATION_NOT_SUPPORTED_ERROR, "OpenGLRenderingEngine::drawOctahedron()",
           "GLUT library does not present on your system.");
#endif
  }

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

  void OpenGLRenderingEngine::drawTetrahedron(const double size)
  {
#if defined(HAVE_GL_GLUT_H) && defined(HAVE_LIBGLUT)
        pushModelView();
        Real ratio = size /::sqrt(3);

        scale(ratio, ratio, ratio);
        switch (mDrawStyle)
        {
         case WIRE:
                glutWireTetrahedron();
                break;
         case FILL:
                glutSolidTetrahedron();
                _reportTriangles(4);
                break;
         default:
                break;
        }
        popModelView();
#else
        Except(OPERATION_NOT_SUPPORTED_ERROR, "OpenGLRenderingEngine::drawTetrahedron()",
           "GLUT library does not present on your system.");
#endif
  }

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

  void OpenGLRenderingEngine::drawIcosahedron(const double size)
  {
#if defined(HAVE_GL_GLUT_H) && defined(HAVE_LIBGLUT)
        pushModelView();
        scale(size, size, size);
        switch (mDrawStyle)
        {
         case WIRE:
                glutWireIcosahedron();
                break;
         case FILL:
                glutSolidIcosahedron();
                _reportTriangles(20);
                break;
         default:
                break;
        }
        popModelView();
#else
        Except(OPERATION_NOT_SUPPORTED_ERROR, "OpenGLRenderingEngine::drawIcosahedron()",
           "GLUT library does not present on your system.");
#endif
  }

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

  void OpenGLRenderingEngine::_registerRenderer(Renderer * renderer)
  {
        Assert(mRenderers.find(renderer) == mRenderers.end(), INVALID_OBJECT_ERROR,
           "OpenGLRenderingEngine::_registerRenderer()");
        mRenderers.insert(renderer);
  }

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

  u32 OpenGLRenderingEngine::_registerObject(ObjectData objectData)
  {
        mObjectData.insert(mObjectData.begin(), objectData);

        return mObjectData.size() - 1;
  }

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

  void OpenGLRenderingEngine::_renderObject(const u32 handle, const bool useVertexArrays,
                                          const u32 vertexCount)
  {
        Assert(handle < mObjectData.size(), INVALID_VALUE_ERROR, "OpenGLRenderingEngine::_renderObject()");

        ObjectData & data = mObjectData[handle];

        Assert(vertexCount <= data.vertexCount, INVALID_VALUE_ERROR, "OpenGLRenderingEngine::_renderObject()");

        // Use the vertex array for rendering
        if(useVertexArrays)
        {
         glEnableClientState(GL_VERTEX_ARRAY);
         glEnableClientState(GL_NORMAL_ARRAY);
         glNormalPointer(GL_FLOAT, 0, data.normals);
         glVertexPointer(data.vertexSize, GL_FLOAT, 0, data.vertexCoordinates);
         glDrawArrays(GL_TRIANGLES, 0, vertexCount);
         glDisableClientState(GL_VERTEX_ARRAY);
        }
        // Use for-loops for rendering (slower)
        else
        {
         glEnable(GL_NORMALIZE);
         glBegin(GL_TRIANGLES);
         // 2D triangles
         if(data.vertexSize == 2)
                for(float *vp = data.vertexCoordinates, *vpEnd = data.vertexCoordinates + data.vertexSize * vertexCount;
                 vp != vpEnd; vp += 2)
                 glVertex2fv(vp);
         // 3D triangles
         else
                for(float *vp = data.vertexCoordinates, *vpEnd =
                 data.vertexCoordinates + data.vertexSize * vertexCount, *normals = data.normals; vp != vpEnd;
                 vp += 3, normals += 3)
                {
                 glNormal3fv(normals);
                 glVertex3fv(vp);
                }
         glEnd();
        }

        _reportTriangles(vertexCount / 3);
  }

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

  void OpenGLRenderingEngine::_refreshCamera()
  {
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        gluLookAt(mCamera.position[0], mCamera.position[1], mCamera.position[2], mCamera.target[0], mCamera.target[1],
                mCamera.target[3], mCamera.upVector[0], mCamera.upVector[1], mCamera.upVector[2]);
  }

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

  bool OpenGLRenderingEngine::_setGLUDrawStyle(const void *quadratic)
  {
        switch (mDrawStyle)
        {
         case POINT:
                gluQuadricDrawStyle((GLUquadricObj *) quadratic, GLU_POINT);
                break;
         case WIRE:
                gluQuadricDrawStyle((GLUquadricObj *) quadratic, GLU_LINE);
                break;
         case FILL:
                gluQuadricDrawStyle((GLUquadricObj *) quadratic, GLU_FILL);
                break;
         default:
                return false;
        }

        return true;
  }

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

  void OpenGLRenderingEngine::_reportTriangles(const u32 & triangleCount)
  {
        // Direct rendering
        if(!mCurrentDisplayList)
         mParent->getRenderWindow()->reportTriangles(triangleCount);

        // Display list compiling
        else
         mCurrentDisplayList->triangleCount += triangleCount;
  }

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

}

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