gl_graphic_core.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_graphic_core/gl_graphic_core.h"
#include "gl_graphic_core/gl_texture.h"
#include "gl_graphic_core/gl_framebuffer.h"

#include "gpucalc/log_manager.h"
#include "gpucalc/string_util.h"
#include "gpucalc/application.h"
#include "gpucalc/shader_system.h"

#include <GL/glew.h>

#define GLUT_NO_LIB_PRAGMA // 
#include <GL/glut.h>



namespace gpucalc
{
 GLGraphicCore::GLGraphicCore(): GraphicCore(_GLGraphicCoreObjectName), mGLUTWindow(0),
  mGLVendor(DEFAULT), mGLMaxFrameBufferAttachmentPoints(0), mGLMaxTextureSize(0),
  mGLDefaultWidth(0.0f), mGLDefaultHeight(0.0f), mIsStarted(false), mGLTextureMap(),
  mGLFrameBufferMap(), mAcceptableShaderSystemIDSet(), mActiveFrameBuffer(0), mActiveTexture(0)
 {
 }


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


 void GLGraphicCore::start(int argc, char * argv [])
 {
        if (mIsStarted) return;
  glutInit(&argc, argv);
  mGLUTWindow = glutCreateWindow("GL Graphic Core Window");
  glutHideWindow();
  LogManager::getSingleton().logMessage(this, "Using \"glut\" library for setting up GL window and context", LML_Trivial);
  LogManager::getSingleton().logMessage(this, "glut GL window created successfully", LML_Trivial);
  LogManager::getSingleton().logMessage(this, "Using \"glew\" library for obtaining advanced functions and capabilities of OpenGL...", LML_Trivial);
  GLenum err = glewInit();
  if (err != GLEW_OK)
  {
   Except<ERR_RENDERINGAPI_ERROR>(this, (char *)glewGetErrorString(err), "GLGraphicCore::start()", __FILE__, __LINE__);
  }

  if (GLEW_VERSION_2_0)
  {
   if (GLEW_VERSION_2_1)
   {
    LogManager::getSingleton().logMessage(this, "This GPU supports OpenGL 2.1, looking good!");
   }
   else
   {
    LogManager::getSingleton().logMessage(this, "This GPU supports OpenGL 2.0.");
   }
  }
  else
  {
   Warning<ERR_RENDERINGAPI_ERROR>(this, "This GPU does not support OpenGL 2.0 and later, shading may be unavailable.", "GLGraphicCore::start()", __FILE__, __LINE__);
  }

  LogManager::getSingleton().logMessage(this, std::string("Renderer: ") +
   (char *)glGetString(GL_RENDERER), LML_Trivial);

  LogManager::getSingleton().logMessage(this, std::string("Version:  ") +
   (char * )glGetString(GL_VERSION), LML_Trivial);
  
  std::string GLVendorString = std::string((char *)glGetString(GL_VENDOR));
  mGLVendor = this->FindCorrectVendor(GLVendorString);
  LogManager::getSingleton().logMessage(this, std::string("Vendor:   ") +
   GLVendorString, LML_Trivial);

  this->checkErrors("GLGraphicCore::start()");

  glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS_EXT, &mGLMaxFrameBufferAttachmentPoints);

  LogManager::getSingleton().logMessage(this, "Max number of attachment points is: " +
   auxillary::StringUtil::toString(mGLMaxFrameBufferAttachmentPoints));


  glGetIntegerv(GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB, &mGLMaxTextureSize);

  LogManager::getSingleton().logMessage(this, "Max size of texture is: " +
   auxillary::StringUtil::toString(mGLMaxTextureSize));


  this->checkErrors("GLGraphicCore::start()");

  mIsStarted = true;

  this->addAcceptableShaderSystemID("GLGLSLShaderSystem");
  this->addAcceptableShaderSystemID("GLCgShaderSystem");
  LogManager::getSingleton().logMessage(this, "---===========================================---");
  LogManager::getSingleton().logMessage(this, "---===       GL Graphic Core started       ===---");
  LogManager::getSingleton().logMessage(this, "---===========================================---");
 }


 void GLGraphicCore::stop()
 {
  assert(mIsStarted && "GLGraphicCore is not started!!!");
  clearContainer(mGLTextureMap);
  clearContainer(mGLFrameBufferMap);
  glutDestroyWindow(mGLUTWindow);
  LogManager::getSingleton().logMessage(this, "---===========================================---");
  LogManager::getSingleton().logMessage(this, "---===       GL Graphic Core stopped       ===---");
  LogManager::getSingleton().logMessage(this, "---===========================================---");
  mIsStarted = false;
 }


 void GLGraphicCore::setMatrixMode(float Width, float Height)
 {
  assert(mIsStarted && "GLGraphicCore is not started!!!");
  mGLDefaultWidth = Width;
  mGLDefaultHeight = Height;

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluOrtho2D(0.0f, Width, 0.0f, Height);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  glViewport(0, 0, Width, Height);
  LogManager::getSingleton().logMessage(this, "ViewPort size: " +
   auxillary::StringUtil::toString(Width) + " X " + auxillary::StringUtil::toString(Height), LML_Trivial);
 }


 void GLGraphicCore::draw(float TexCoordX, float TexCoordY)
 {
  assert(mIsStarted && "GLGraphicCore is not started!!!");
  glBegin(GL_QUADS);
  {
   glTexCoord2f(0.0f, 0.0f);   glVertex2f(0.0f, 0.0f);
   glTexCoord2f(TexCoordX, 0.0f);  glVertex2f(mGLDefaultWidth, 0.0f);
   glTexCoord2f(TexCoordX, TexCoordY); glVertex2f(mGLDefaultWidth, mGLDefaultHeight);
   glTexCoord2f(0.0f, TexCoordY);  glVertex2f(0.0f, mGLDefaultHeight);
  }
  glEnd();
  glFlush();
  glFinish();
  this->checkErrors("GLGraphicCore::draw()");
  LogManager::getSingleton().logMessage(this, "Texture coords: " +
   auxillary::StringUtil::toString(TexCoordX) + " X " + auxillary::StringUtil::toString(TexCoordY), LML_Trivial);
 }


 Texture * GLGraphicCore::create(const std::string & TextureName, TextureUsage Usage)
 {
  assert(mIsStarted && "GLGraphicCore is not started!!!");
  GLTextureMap::iterator i = mGLTextureMap.find(TextureName);
  if (i != mGLTextureMap.end())
  {
   Except<ERR_DUPLICATE_ITEM>(this, "Texture object with name \"" + TextureName + "\" already exists!",
    "GLGraphicCore::create()", __FILE__, __LINE__);
   return 0;
  }
  else
  {
   GLTexture * Result = new GLTexture(TextureName, Usage, this);
   mGLTextureMap.insert(GLTextureMap::value_type(TextureName, Result));
   LogManager::getSingleton().logMessage(this, "Texture object \"" + TextureName + "\" created.", LML_Trivial);
   return Result;
  }
 }


 void GLGraphicCore::initialize(const Data & data, Texture & texture)
 {
  ConvertToTexture(data, static_cast<GLTexture &>(texture));
  texture.initialize();
 }


 Texture * GLGraphicCore::getTextureByName(const std::string & TextureName) const
 {
  assert(mIsStarted && "GLGraphicCore is not started!!!");
  GLTextureMap::const_iterator i = mGLTextureMap.find(TextureName);
  if (i != mGLTextureMap.end())
  {
   return i->second;
  }
  else
  {
   Except<ERR_ITEM_NOT_FOUND>(this, "Texture with name \"" + TextureName + "\" does not exists!", "GLGraphicCore::getTextureByName()", __FILE__, __LINE__);
   return 0;
  }
 }


 bool GLGraphicCore::isTextureCreated(const std::string & TextureName) const
 {
  assert(mIsStarted && "GLGraphicCore is not started!!!");
  return (mGLTextureMap.find(TextureName) != mGLTextureMap.end());
 }


 FrameBuffer * GLGraphicCore::create(const std::string & FrameBufferName)
 {
  assert(mIsStarted && "GLGraphicCore is not started!!!");
  GLFrameBufferMap::iterator i = mGLFrameBufferMap.find(FrameBufferName);

  if (i != mGLFrameBufferMap.end())
  {
   Except<ERR_DUPLICATE_ITEM>(this, "FrameBuffer object with name \"" + FrameBufferName + "\" already exists!",
    "GLGraphicCore::createFrameBuffer()", __FILE__, __LINE__);
   return 0;
  }
  else
  {
   GLFrameBuffer * Result = new GLFrameBuffer(FrameBufferName, static_cast<unsigned int>(mGLMaxFrameBufferAttachmentPoints), this);
   Result->initialize();
   mGLFrameBufferMap.insert(std::make_pair(FrameBufferName, Result));
   LogManager::getSingleton().logMessage(this, "Framebuffer object \"" + FrameBufferName + "\" created.", LML_Trivial);
   return Result;
  }
 }


 FrameBuffer * GLGraphicCore::getFrameBufferByName(const std::string & FrameBufferName) const
 {
  assert(mIsStarted && "GLGraphicCore is not started!!!");
  GLFrameBufferMap::const_iterator i = mGLFrameBufferMap.find(FrameBufferName);
  if (i != mGLFrameBufferMap.end())
  {
   return i->second;
  }
  else
  {
   Except<ERR_ITEM_NOT_FOUND>(this, "FrameBuffer with name \"" + FrameBufferName + "\" does not exists!",
    "GLGraphicCore::getFrameBufferByName()", __FILE__, __LINE__);
   return 0;
  }
 }


 bool GLGraphicCore::isFrameBufferCreated(const std::string & FrameBufferName) const
 {
  assert(mIsStarted && "GLGraphicCore is not started!!!");
  return (mGLFrameBufferMap.find(FrameBufferName) != mGLFrameBufferMap.end());
 }

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


 void GLGraphicCore::destroy(FrameBuffer * fb)
 {
  assert(mIsStarted && "GLGraphicCore is not started!!!");
  if (!removeFromContainer(fb->getObjectName(), mGLFrameBufferMap))
  {
   Warning<ERR_INVALIDPARAMS>(this, "FrameBuffer object \"" + fb->getObjectName() + "\" was created outside GLGraphicCore!",
    "GLGraphicCore::deleteFrameBuffer", __FILE__, __LINE__);

  }
  std::string name = fb->getObjectName();
  delete fb;
  LogManager::getSingleton().logMessage(this, "FrameBuffer \"" + name + "\" deleted.", LML_Trivial);
 }


 void GLGraphicCore::bind(Texture * texture)
 {
  assert(texture && "Texture does not created!!!");
  if (texture != mActiveTexture)
  {
   GLTexture * glTexture = static_cast<GLTexture *>(texture);
   glBindTexture(glTexture->getGLTextureTarget(), glTexture->getGLTextureID());
   mActiveTexture = texture;
  }
 }


 void GLGraphicCore::unbind(Texture * texture)
 {
  assert(texture && "Texture does not created!!!");
  if (texture == mActiveTexture)
  {
   GLTexture * glTexture = static_cast<GLTexture *>(texture);
   glBindTexture(glTexture->getGLTextureTarget(), 0);
   mActiveTexture = 0;
  }
 }


 void GLGraphicCore::bind(FrameBuffer * framebuffer)
 {
  assert(framebuffer && "FrameBuffer does not created!!!");
  if (framebuffer != mActiveFrameBuffer)
  {
   GLFrameBuffer * glFrameBuffer = static_cast<GLFrameBuffer *>(framebuffer);
   glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, glFrameBuffer->mGLFrameBufferID);
   mActiveFrameBuffer = framebuffer;
  }
 }


 void GLGraphicCore::unbind(FrameBuffer * framebuffer)
 {
  assert(framebuffer && "FrameBuffer does not created!!!");
  if (framebuffer == mActiveFrameBuffer)
  {
   glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
   mActiveFrameBuffer = 0;
  }
 }


 void GLGraphicCore::checkErrors(const std::string & where)
 {
  GLenum err_code = glGetError();
  switch (err_code)
  {
   case GL_NO_ERROR:
    return;

   case GL_INVALID_ENUM:
       Except<ERR_RENDERINGAPI_ERROR>(this, "Enum argument out of range!", where, __FILE__, __LINE__);
    return;

   case GL_INVALID_VALUE:
    Except<ERR_RENDERINGAPI_ERROR>(this, "Numeric argument out of range!", where, __FILE__, __LINE__);
    return;

   case GL_INVALID_OPERATION:
    Except<ERR_RENDERINGAPI_ERROR>(this, "Operation illegal in current state!", where, __FILE__, __LINE__);
    return;

   case GL_STACK_OVERFLOW:
    Except<ERR_RENDERINGAPI_ERROR>(this, "Command would cause a stack overflow!", where, __FILE__, __LINE__);
    return;

   case GL_STACK_UNDERFLOW:
    Except<ERR_RENDERINGAPI_ERROR>(this, "Command would cause a stack underflow!", where, __FILE__, __LINE__);
    return;

   case GL_OUT_OF_MEMORY:
    Except<ERR_RENDERINGAPI_ERROR>(this, "Not enough memory left to execute command!", where, __FILE__, __LINE__);
    return;

   case GL_TABLE_TOO_LARGE:
    Except<ERR_RENDERINGAPI_ERROR>(this, "The specified table is too large!", where, __FILE__, __LINE__);
    return;

   default:
    Except<ERR_RENDERINGAPI_ERROR>(this, "Unknown error or no error!", where, __FILE__, __LINE__);
    return;
  }
 }


 Vendor GLGraphicCore::FindCorrectVendor(const std::string & GLVendorString)
 {
  if (!(auxillary::StringUtil::toLower(GLVendorString).find("nvidia") == std::string::npos))
  {
   return NVIDIA;
  }

  if (!(auxillary::StringUtil::toLower(GLVendorString).find("ati") == std::string::npos))
  {
   return ATI;
  }

  if (!(auxillary::StringUtil::toLower(GLVendorString).find("mesa") == std::string::npos))
  {
   return MESA;
  }

  if (!(auxillary::StringUtil::toLower(GLVendorString).find("gdi") == std::string::npos))
  {
   return GDI;
  }

  return DEFAULT;
 }


 bool GLGraphicCore::isAcceptSystem(const ShaderSystem * System) const
 {
  return (mAcceptableShaderSystemIDSet.find(System->getObjectName()) != mAcceptableShaderSystemIDSet.end());
 }


 void GLGraphicCore::addAcceptableShaderSystemID(const std::string & ShaderSystemID)
 {
  mAcceptableShaderSystemIDSet.insert(ShaderSystemID);
 }


 void GLGraphicCore::ConvertToTexture(const Data & data, GLTexture & texture)
 {
  assert(mIsStarted && "GLGraphicCore is not started!!!");
  texture.mGLPointer = data.pointer();

  texture.mActualLengthGPU = data.getActualLengthCPU() / data.getNumberOfComponents();
  texture.mDimension = data.getArrayDataType();
  texture.mNumberOfComponents = data.getNumberOfComponents();
  texture.mTypeSize = data.getTypeSize();

  texture.mSizeX = data.getSizeX();
  texture.mSizeY = data.getSizeY();
  texture.mSizeZ = data.getSizeZ();

  switch (this->getVendor())
  {
   case NVIDIA:
   case MESA:
   case GDI:
    ConvertToNVTexture(data, texture);
    break;

   case ATI:
    ConvertToATITexture(data, texture);
    break;

   default:
    Except<ERR_NOT_IMPLEMENTED>(this, "Vendors different from ATI, NVIDIA, MESA or GDI are not implemented!",
     "GLDataConverter::ConvertToTexture()", __FILE__, __LINE__);
  }
 }


 void GLGraphicCore::ConvertToNVTexture(const Data & data, GLTexture & texture)
 {
  assert(mIsStarted && "GLGraphicCore is not started!!!");
  switch (data.getNumberOfComponents())
  {
   case 1:
    texture.mGLTextureFormat = GL_LUMINANCE;
    break;
    
   case 2:
    texture.mGLTextureFormat = GL_LUMINANCE_ALPHA;
    break;

   case 3:
    texture.mGLTextureFormat = GL_RGB;
    break;

   case 4:
    texture.mGLTextureFormat = GL_RGBA;
    break;

   default:
    Except<ERR_INVALIDPARAMS>(this, "Wrong number of components!", "GLDataConverter::ToNVTexture", __FILE__, __LINE__);
    break;
  }


  switch (data.getArrayDataType())
  {
   case Array1D:
    texture.mGLTextureTarget = GL_TEXTURE_1D;
    break;
    
   case Array2D:
    texture.mGLTextureTarget = GL_TEXTURE_RECTANGLE_NV;
    break;

   case Array3D:
    texture.mGLTextureTarget = GL_TEXTURE_3D;
    break;

   default:
    Except<ERR_INVALIDPARAMS>(this, "Wrong array data type!", "GLDataConverter::ToNVTexture", __FILE__, __LINE__);
    break;
  }


  switch (data.getValueType())
  {
   case FloatType:
    texture.mGLTextureType = GL_FLOAT;
    switch (texture.getNumberOfComponents())
    {
     case 1:
      texture.mGLTextureInternalFormat = GL_FLOAT_R32_NV;
      break;
      
     case 2:
      texture.mGLTextureInternalFormat = GL_FLOAT_RG32_NV;
      break;
      
     case 3:
      texture.mGLTextureInternalFormat = GL_FLOAT_RGB32_NV;
      break;

     case 4:
      texture.mGLTextureInternalFormat = GL_FLOAT_RGBA32_NV;
      break;
      
     default:
      Except<ERR_INVALIDPARAMS>(this, "Wrong number of components!", "GLDataConverter::ToNVTexture", __FILE__, __LINE__);
      break;
    }
    break;


   case UnsignedCharType:
    texture.mGLTextureType = GL_UNSIGNED_BYTE;
    switch (texture.getNumberOfComponents())
    {
     case 1:
      texture.mGLTextureInternalFormat = GL_LUMINANCE8;
      break;
      
     case 2:
      texture.mGLTextureInternalFormat = GL_LUMINANCE8_ALPHA8;
      break;
      
     case 3:
      texture.mGLTextureInternalFormat = GL_RGB8;
      break;

     case 4:
      texture.mGLTextureInternalFormat = GL_RGBA8;
      break;
      
     default:
      break;
    }
    break;


   default:
    Except<ERR_NOT_IMPLEMENTED>(this, "ValueType is not implemented!", "GLDataConverter::ToNVTexture", __FILE__, __LINE__);
    break;
  }
 }


 void GLGraphicCore::ConvertToATITexture(const Data & data, GLTexture & texture)
 {
  assert(mIsStarted && "GLGraphicCore is not started!!!");
  switch (data.getNumberOfComponents())
  {
   case 1:
    texture.mGLTextureFormat = GL_LUMINANCE;
    break;
    
   case 2:
    texture.mGLTextureFormat = GL_LUMINANCE_ALPHA;
    break;

   case 3:
    texture.mGLTextureFormat = GL_RGB;
    break;

   case 4:
    texture.mGLTextureFormat = GL_RGBA;
    break;

   default:
    Except<ERR_INVALIDPARAMS>(this, "Wrong number of components!", "GLDataConverter::ToNVTexture", __FILE__, __LINE__);
    break;
  }


  switch (data.getArrayDataType())
  {
   case Array1D:
    texture.mGLTextureTarget = GL_TEXTURE_1D;
    break;
    
   case Array2D:
    texture.mGLTextureTarget = GL_TEXTURE_RECTANGLE_ARB; // it is the same value that GL_TEXTURE_RECTANGLE_NV
    break;

   case Array3D:
    texture.mGLTextureTarget = GL_TEXTURE_3D;
    break;

   default:
    Except<ERR_INVALIDPARAMS>(this, "Wrong array data type!", "GLDataConverter::ToNVTexture", __FILE__, __LINE__);
    break;
  }


  switch (data.getValueType())
  {
   case FloatType:
    texture.mGLTextureType = GL_FLOAT;
    switch (texture.getNumberOfComponents())
    {
     case 1:
      texture.mGLTextureInternalFormat = GL_LUMINANCE_FLOAT32_ATI;
      break;

     case 2:
      texture.mGLTextureInternalFormat = GL_LUMINANCE_ALPHA_FLOAT32_ATI;
      break;

     case 3:
      texture.mGLTextureInternalFormat = GL_RGB_FLOAT32_ATI;
      break;

     case 4:
      texture.mGLTextureInternalFormat = GL_RGBA_FLOAT32_ATI;
      break;

     default:
      break;
    }
    break;


   case UnsignedCharType:
    texture.mGLTextureType = GL_UNSIGNED_BYTE;
    switch (texture.getNumberOfComponents())
    {
     case 1:
      texture.mGLTextureInternalFormat = GL_LUMINANCE8;
      break;

     case 2:
      texture.mGLTextureInternalFormat = GL_LUMINANCE8_ALPHA8;
      break;

     case 3:
      texture.mGLTextureInternalFormat = GL_RGB8;
      break;

     case 4:
      texture.mGLTextureInternalFormat = GL_RGBA8;
      break;

     default:
      break;
    }
    break;


   default:
    Except<ERR_NOT_IMPLEMENTED>(this, "ValueType is not implemented!", "GLDataConverter::ToNVTexture", __FILE__, __LINE__);
    break;
  }
 }
}