glfRenderingContext_WGL.cpp

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

 Copyright (C)  2008, 2009    (see file CONTACT 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 <bias_config.h>
#include "glfRenderingContext_WGL.hh"
#include <Utils/GlutInitWrapper.hh>
#include <OpenGLFramework/Base/glfException.hh>


using namespace BIAS;
using namespace std;

glfRenderingContext_WGL::glfRenderingContext_WGL()
{
  hDC_ = NULL;
  hRC_ = NULL;
}

glfRenderingContext_WGL::~glfRenderingContext_WGL()
{
  // make sure Destroy was called by now.
  BIASASSERT(hDC_ == NULL);
  BIASASSERT(hRC_ == NULL);
}

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

#ifndef BIAS_HAVE_GLEW
#error glfRenderingContext_WGL requires GLEW
#endif

#ifndef BIAS_HAVE_GLUT
#error glfRenderingContext_WGL requires GLUT
#endif

  // create a hidden glut window, because
  // 1) GLEW is needed for ARB_pixel_format
  // 2) An existing DC and RC is required.  
    BIAS::GlutInitWrapper::GetInstance()->Init(); 
    
  glutCreateWindow("Hidden window");
  glutHideWindow();

  // initialize glew
  InitGlew();

  // need WGL_ARB_pixel_format extension
  if (!WGLEW_ARB_pixel_format) {
    GLF_THROW_EXCEPTION("WGL_ARB_pixel_format extension is unsupported");
  }

  // get current OpenGL device and render context
  HDC hCurrentDC = wglGetCurrentDC();
  if (hCurrentDC == NULL) {
    GLF_THROW_EXCEPTION("Failed to get OpenGL device context");
  }

  // get pixel formats
  int attribs[] = {
    WGL_SUPPORT_OPENGL_ARB,         TRUE,
    GetWglRenderTargetAttribute(),  TRUE,
    0
  };
  const int MAX_PIXEL_FORMATS = 512;
  int pixelFormats[MAX_PIXEL_FORMATS];
  UINT numFormats;
  if (wglChoosePixelFormatARB(hCurrentDC, attribs, NULL,
                              MAX_PIXEL_FORMATS, pixelFormats,
                              &numFormats) == FALSE) {
    GLF_THROW_EXCEPTION("Failed to choose pixel format");
  }
  if (numFormats == 0) {
    GLF_THROW_EXCEPTION("No matching pixel format found");
  }
  if (numFormats > MAX_PIXEL_FORMATS) {
    numFormats = MAX_PIXEL_FORMATS;
  }

  // choose pixel format
  pixelFormat_ = -1;
  for (int i = 0; i < (int)numFormats; i++) {
    int attribList[] = {
      WGL_RED_BITS_ARB,     // 0
      WGL_GREEN_BITS_ARB,   // 1
      WGL_BLUE_BITS_ARB,    // 2
      WGL_ALPHA_BITS_ARB,   // 3
      WGL_DEPTH_BITS_ARB,   // 4
      WGL_STENCIL_BITS_ARB, // 5
      WGL_DOUBLE_BUFFER_ARB // 6
    };
    const int numAttribs = sizeof(attribList)/sizeof(int);
    int attribValues[numAttribs];
    wglGetPixelFormatAttribivARB(hCurrentDC, pixelFormats[i], 0, numAttribs,
                                 attribList, attribValues);
    if (attribValues[0] == config.redSize &&
        attribValues[1] == config.greenSize &&
        attribValues[2] == config.blueSize &&
        attribValues[3] == config.alphaSize &&
        attribValues[4] == config.depthSize &&
        attribValues[5] == config.stencilSize &&
        (attribValues[6] == TRUE) == config.doubleBuffer) {
      pixelFormat_ = pixelFormats[i];
      break;
    }
  }
  if (pixelFormat_ == -1) {
    GLF_THROW_EXCEPTION("Requested rendering context configuration is unsupported");
  }

  // create device context
  hDC_ = CreateDeviceContext(config.width, config.height, pixelFormat_);

  // create render context.
  hRC_ = wglCreateContext(hDC_);
 // hRC_ = wglCreateContextAttribsARB(hDC_, 0, NULL);
  if (hRC_ == NULL) {
    GLF_THROW_EXCEPTION("Failed to create WGL rendering context");
  }

  MakeCurrent();
}

void glfRenderingContext_WGL::Destroy()
{
  if (hRC_ != NULL) {
    wglDeleteContext(hRC_);
    hRC_ = NULL;
  }

  DestroyDeviceContext();
  hDC_ = NULL;
}

void glfRenderingContext_WGL::MakeCurrent()
{
  BIASASSERT(hDC_ != NULL && hRC_ != NULL);

  wglMakeCurrent(hDC_, hRC_);
}


void glfRenderingContext_WGL::DoneCurrent()
{
  BIASASSERT(hDC_ != NULL && hRC_ != NULL);

  cerr << "Error: glfRenderingContext_WGL::DoneCurrent() is not implemented in BIAS for Windows." << endl;
}

void glfRenderingContext_WGL::GetConfig(glfRenderingContextConfig& config)
{
  BIASASSERT(hDC_ != NULL);

  GetSize(config.width, config.height);

  int attribs[] = {
    WGL_RED_BITS_ARB,     // 0
    WGL_GREEN_BITS_ARB,   // 1
    WGL_BLUE_BITS_ARB,    // 2
    WGL_ALPHA_BITS_ARB,   // 3
    WGL_DEPTH_BITS_ARB,   // 4
    WGL_STENCIL_BITS_ARB, // 5
    WGL_DOUBLE_BUFFER_ARB // 6
  };
  const int numAttribs = sizeof(attribs)/sizeof(int);
  int attribValues[numAttribs];

  wglGetPixelFormatAttribivARB(hDC_, pixelFormat_, 0, numAttribs,
                               attribs, attribValues);

  config.doubleBuffer = (attribValues[6] == TRUE);
  config.redSize      = attribValues[0];
  config.greenSize    = attribValues[1];
  config.blueSize     = attribValues[2];
  config.alphaSize    = attribValues[3];
  config.depthSize    = attribValues[4];
  config.stencilSize  = attribValues[5];
}