glfRenderingContext_GLX.cpp

/*
 This file is part of the BIAS library (Basic ImageAlgorithmS).

 Copyright (C)  2008, 2009    (see file CONTACTS for details)
 Multimediale Systeme der Informationsverarbeitung
 Institut fuer Informatik
 Christian-Albrechts-Universitaet Kiel


 BIAS is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 2.1 of the License, or
 (at your option) any later version.

 BIAS 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 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public License
 along with BIAS; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "glfRenderingContext_GLX.hh"
#include <OpenGLFramework/Base/glfException.hh>

using namespace BIAS;
using namespace std;

glfRenderingContext_GLX::glfRenderingContext_GLX()
{
  display_  = NULL;
  drawable_ = None;
  context_  = NULL;
}

glfRenderingContext_GLX::~glfRenderingContext_GLX()
{
  Destroy();
  // make sure Destroy was called by now.
  BIASASSERT(display_ == NULL);
  BIASASSERT(drawable_ == None);
  BIASASSERT(context_ == NULL);
}

void glfRenderingContext_GLX::Init(const glfRenderingContextConfig& config)
{
  Destroy();

  // open connect to the X server
  display_ = XOpenDisplay(NULL);
  if (display_ == NULL) {
    GLF_THROW_EXCEPTION("Failed to connect to the X server");
  }

  // query GLX version
  int major, minor;
  if (glXQueryVersion(display_, &major, &minor) == False) {
    GLF_THROW_EXCEPTION("Failed to query GLX version");
  } 
  // get framebuffer configurations
  int attribs[] = {
    GLX_DRAWABLE_TYPE, GetDrawableType(),
    None
  };
  int numFbConfigs;
  GLXFBConfig* fbConfigs =
    glXChooseFBConfig(display_, DefaultScreen(display_),
                      attribs, &numFbConfigs);
  if (fbConfigs == NULL || numFbConfigs == 0) {
    GLF_THROW_EXCEPTION("Failed to get GLX framebuffer configurations");
  }

  // choose framebuffer configuration
  GLXFBConfig fbConfig = None;
  /*
  cout<<"Config:"<<endl;
  cout<<"doubleBuffer:"<<config.doubleBuffer<<endl;
  cout<<"redSize:"<<config.redSize<<endl;
  cout<<"greenSize:"<<config.greenSize<<endl;
  cout<<"blueSize:"<<config.blueSize<<endl;
  cout<<"alphaSize:"<<config.alphaSize<<endl;
  cout<<"depthSize:"<<config.depthSize<<endl;
  cout<<"stencilSize:"<<config.stencilSize<<endl<<endl;
  cout<<"numFbConfigs:"<<numFbConfigs<<endl;
  */
  for (int i = 0; i < numFbConfigs; i++) {
    int doubleBuffer, redSize, greenSize, blueSize, alphaSize, depthSize, stencilSize;
    glXGetFBConfigAttrib(display_, fbConfigs[i], GLX_DOUBLEBUFFER, &doubleBuffer);
    glXGetFBConfigAttrib(display_, fbConfigs[i], GLX_RED_SIZE,     &redSize);
    glXGetFBConfigAttrib(display_, fbConfigs[i], GLX_GREEN_SIZE,   &greenSize);
    glXGetFBConfigAttrib(display_, fbConfigs[i], GLX_BLUE_SIZE,    &blueSize);
    glXGetFBConfigAttrib(display_, fbConfigs[i], GLX_ALPHA_SIZE,   &alphaSize);
    glXGetFBConfigAttrib(display_, fbConfigs[i], GLX_DEPTH_SIZE,   &depthSize);
    glXGetFBConfigAttrib(display_, fbConfigs[i], GLX_STENCIL_SIZE, &stencilSize);
  
    /*
    cout<<"doubleBuffer:"<<doubleBuffer<<endl;
    cout<<"redSize:"<<redSize<<endl;
    cout<<"greenSize:"<<greenSize<<endl;
    cout<<"blueSize:"<<blueSize<<endl;
    cout<<"alphaSize:"<<alphaSize<<endl;
    cout<<"depthSize:"<<depthSize<<endl;
    cout<<"stencilSize:"<<stencilSize<<endl<<endl;
    */
    // if (config.doubleBuffer == (doubleBuffer == True) &&
    if (config.doubleBuffer == doubleBuffer &&
        config.redSize == redSize &&
        config.greenSize == greenSize &&
        config.blueSize == blueSize &&
        config.alphaSize == alphaSize &&
        config.depthSize == depthSize &&
        config.stencilSize == stencilSize) {
      fbConfig = fbConfigs[i];
      break;
    }
  }
  if (fbConfig == None) {
    GLF_THROW_EXCEPTION("Rendering context configuration is unsupported");
  }

  // create drawable
  drawable_ = CreateDrawable(config.width, config.height, fbConfig);
  BIASASSERT(drawable_ != None);

  // create context
  context_ = glXCreateNewContext(display_, fbConfig,
                                 GLX_RGBA_TYPE, NULL, True);
  if (context_ == NULL) {
    GLF_THROW_EXCEPTION("Failed to create GLX context");
  }
  if(!glXIsDirect(display_, context_)){
    GLF_THROW_EXCEPTION("Failed to create a direct GLX context");
  }
  // init GLEW
  MakeCurrent();
  InitGlew(); 
}

void glfRenderingContext_GLX::Destroy()
{
  if (context_ != NULL) {
    if (glXGetCurrentContext() == context_) {
      glXMakeCurrent(display_, None, NULL);
    }
    glXDestroyContext(display_, context_);
    context_ = NULL;
  }
  
  // DestroyDrawable() is called in destructor of glfBuffer_GLX
  if (display_ != NULL) {
    XCloseDisplay(display_);
    display_ = NULL;
  }
  drawable_ = None;
}

void glfRenderingContext_GLX::MakeCurrent()
{
  BIASASSERT(display_ != NULL && drawable_ != None && context_ != NULL);

  if (glXMakeCurrent(display_, drawable_, context_) == False) {
    GLF_THROW_EXCEPTION("Failed to set current GLX context");
  }
}

void glfRenderingContext_GLX::DoneCurrent()
{
  BIASASSERT(display_ != NULL && drawable_ != None && context_ != NULL);

  if (glXMakeCurrent(display_, None, NULL) == False) {
    GLF_THROW_EXCEPTION("Failed to release current GLX context");
  }
}

void glfRenderingContext_GLX::GetConfig(glfRenderingContextConfig& config)
{
  BIASASSERT(display_ != NULL && drawable_ != None && context_ != NULL);

  // query size
  unsigned int width, height;
  glXQueryDrawable(display_, drawable_, GLX_WIDTH, &width);
  glXQueryDrawable(display_, drawable_, GLX_HEIGHT, &height);
  config.width = width;
  config.height = height;

  // get framebuffer config XID
  unsigned int fbConfigId;
  glXQueryDrawable(display_, drawable_, GLX_FBCONFIG_ID, &fbConfigId);

  // get framebuffer config
  int signedFbConfigId = (int)fbConfigId;
  int attribs[] = {
    GLX_FBCONFIG_ID, signedFbConfigId,
    None
  };
  int numFbConfigs;
  GLXFBConfig* fbConfig =
    glXChooseFBConfig(display_, DefaultScreen(display_), attribs, &numFbConfigs);
  if (fbConfig == NULL || numFbConfigs == 0) {
    GLF_THROW_EXCEPTION("Failed to get framebuffer config");
  }

  // get framebuffer config attributes
  int tmp = int(config.doubleBuffer);
  glXGetFBConfigAttrib(display_, *fbConfig, GLX_DOUBLEBUFFER, &tmp);
  glXGetFBConfigAttrib(display_, *fbConfig, GLX_RED_SIZE,     &config.redSize);
  glXGetFBConfigAttrib(display_, *fbConfig, GLX_GREEN_SIZE,   &config.greenSize);
  glXGetFBConfigAttrib(display_, *fbConfig, GLX_BLUE_SIZE,    &config.blueSize);
  glXGetFBConfigAttrib(display_, *fbConfig, GLX_ALPHA_SIZE,   &config.alphaSize);
  glXGetFBConfigAttrib(display_, *fbConfig, GLX_DEPTH_SIZE,   &config.depthSize);
  glXGetFBConfigAttrib(display_, *fbConfig, GLX_STENCIL_SIZE, &config.stencilSize);
  config.doubleBuffer = double(tmp);
}