RenderContextBase.cpp

#include <GLviewer/RenderContextBase.hh>
#include <GLviewer/Scenes/SceneBGImage.hh>

#include <Gui/biasgl.h>

#include <iostream>

using namespace BIAS;
using namespace BIAS;
using namespace std;


//#define MIN_ZNEAR 1.0

//#define TURN_OF_LOCKING

#ifdef BIAS_HAVE_PTHREADS
MutexSingleton* RenderContextBase::contextLock_ = new MutexSingleton();
#endif

RenderContextBase::
RenderContextBase() : ClearColor_(0.0, 0.0, 0.0, 0.0), centerViewport_(false)
{
  camera_ = NULL;
  control_ = NULL;
  backgroundImageScene_ = NULL;

  initialized_=false;
  AutoClipping_ = false;
  blendingAllowed_=false;
  AutoMinZNear_ = 0.1; //old default.
  culling_=false;
  UseStencil_ = false;
  bSelectionMode_ = false;
}

#ifdef BIAS_HAVE_PTHREADS
int RenderContextBase::LockContextSwitch()
{
  int res = contextLock_->Lock();
  MakeGLContextCurrent();
  return res;
}

int RenderContextBase::ReleaseContextSwitch()
{
  return contextLock_->Unlock();
}
#endif

void RenderContextBase::
PrintGLStatus()
{
  int redbits, greenbits, bluebits, depthbits, alphabits,stencilbits;
  GLboolean doublebuffered;
  glGetIntegerv(GL_DEPTH_BITS,&depthbits);
  glGetIntegerv(GL_RED_BITS, &redbits);
  glGetIntegerv(GL_GREEN_BITS, &greenbits);
  glGetIntegerv(GL_BLUE_BITS, &bluebits);
  glGetIntegerv(GL_ALPHA_BITS, &alphabits);
  glGetIntegerv(GL_STENCIL_BITS, &stencilbits);
  glGetBooleanv(GL_DOUBLEBUFFER, &doublebuffered);
  int viewport[4];
  glGetIntegerv(GL_VIEWPORT, viewport);
  cout <<"GL buffer resolution Red:     "<<redbits<<" bits"<<endl;
  cout <<"GL buffer resolution Green:   "<<greenbits <<" bits"<<endl;
  cout <<"GL buffer resolution Blue:    "<<bluebits <<" bits"<<endl;
  cout <<"GL buffer resolution Alpha:   "<<alphabits <<" bits"<<endl;
  cout <<"GL buffer resolution Depth:   "<<depthbits <<" bits"<<endl;
  cout <<"GL buffer resolution Stencil: "<<stencilbits <<" bits"<<endl;
  cout <<"GL doublebuffered:            "<<(doublebuffered == GL_TRUE)<<endl;
  cout <<"GL Viewport:                  "<<viewport[0];
  cout<<","<<viewport[1]<<","<<viewport[2]<<","<<viewport[3]<<endl;
}

int RenderContextBase::
GetImage(BIAS::Image<unsigned char>& Image, bool lock)
{
  if(camera_==NULL) {
    BIASERR("No camera set!\n");
    return -1;
  }
  if (lock) LockContextSwitch();
  camera_->GetImage(Image);
  if (lock) ReleaseContextSwitch();
  return 0;
}

int RenderContextBase::
GetGreyImage(BIAS::Image<unsigned char>& Image, bool lock)
{
 if(camera_==NULL) {
   BIASERR("No camera set!\n");
   return -1;
 }
 if (lock) LockContextSwitch();
 camera_->GetGreyImage(Image);
 if (lock) ReleaseContextSwitch();
 return 0;
}

int RenderContextBase::
GetDepthMap(BIAS::Image<float>& Image, const float invalid, bool lock)
{
  if(camera_==NULL) {
    BIASERR("No camera set!\n");
    return -1;
  }

  if (lock) LockContextSwitch();
  int retVal = camera_->GetDepthMap(Image, invalid);
  if (lock) ReleaseContextSwitch();
  return retVal;

}

int RenderContextBase::
GetZBuffer(BIAS::Image<float>& Image, bool lock)
{
  if(camera_==NULL) {
    BIASERR("No camera set!\n");
    return -1;
  }

  if (lock) LockContextSwitch();
  int retVal = camera_->GetZBuffer(Image);
  if (lock) ReleaseContextSwitch();
  return retVal;

}

int RenderContextBase::
GetMetricZMap(BIAS::Image<float>& Image, const float invalid, bool lock)
{
  if (camera_ == NULL)
    {
        BIASERR("No camera set!\n");
      return -1;
    }
  if (lock) LockContextSwitch();
  int retVal = camera_->GetMetricZMap(Image, invalid);
  if (lock) ReleaseContextSwitch();
  return retVal;
}


void RenderContextBase::
Init_()
{
  int  depthbits;
  SetBlending(blendingAllowed_);
  SetBackfaceCulling(culling_);

  glEnable(GL_DEPTH_TEST);
  glDepthFunc(GL_LESS);

  glGetIntegerv(GL_DEPTH_BITS,&depthbits);
  if(depthbits == 0)
    BIASERR("No depth buffer was found most functionality is unavailable!");

  initialized_ = true;
}

bool RenderContextBase::
SetBlending(bool blend){
  blendingAllowed_ = blend;
  int alphabits;
  glGetIntegerv(GL_ALPHA_BITS, &alphabits);
  if(alphabits>0 && blend)
    glEnable(GL_BLEND);
  else{
    blendingAllowed_=false;
    glDisable(GL_BLEND);
  }
  return blendingAllowed_;
}

bool RenderContextBase::
SetBackfaceCulling(bool cull){
  culling_ = cull;
  if(cull)
    glEnable(GL_CULL_FACE);
  else
    glDisable(GL_CULL_FACE);
  return culling_;
}

int RenderContextBase::
Render()
{

#ifndef TURN_OF_LOCKING
#ifdef BIAS_HAVE_PTHREADS
  LockContextSwitch();
#endif
#endif

  GLenum err = glGetError();
  if (err != GL_NO_ERROR) {
    BIASERR("OpenGL Error before rendering: " << gluErrorString(err));
  }

//  MakeGLContextCurrent();
  if(camera_ == NULL) {
    BIASERR("No GLProjection object set!\n");
#ifdef BIAS_HAVE_PTHREADS
    ReleaseContextSwitch();
#endif
    return -1;
  }

  if(!initialized_) Init_();


  glClearColor(ClearColor_[0], ClearColor_[1],
               ClearColor_[2], ClearColor_[3]);

  // cout<<"ClearColor:"<<ClearColor_[0]<<","<<ClearColor_[1]<<","<<ClearColor_[2]<<","<<ClearColor_[3]<<endl;
  if(UseStencil_)
    {
     glClearStencil(0);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
   }
   else
   {
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
   }

  // near and far clipping plane is automatically derived and set.
  if (AutoClipping_)
  {
    Vector3<double> C, min, max, radiusOfSphere, centerOfBox;

    double zFar  = 0.0;
    double zNear = 0.0;
    bool autoClippingSucceeded = false;

    for (unsigned int i = 0; i < scenes_.size(); i++)
    {
      double newNear = 0.0;
      double newFar  = 0.0;

      scenes_[i]->GetBoundingBox(min, max);

      //cout<<"min :"<<min<<" max: "<<max<<endl;

      // has the scene a bounding box.
      if (min.Length() == 0.0 && max.Length() == 0.0)
      {
        continue;
      }

      //this is the new way, droogs!
      C = camera_->GetMyselfAsProjectionParametersBase()->GetC();
      //  cout<<"C:"<<C<<endl;

      // compute radius of the sphere around the bounding box.
      centerOfBox = max - min;
      centerOfBox = centerOfBox / 2.0;
      radiusOfSphere = centerOfBox;
      centerOfBox = min + centerOfBox;

      Vector3<double> direction;
      direction = (centerOfBox - C);
      newNear = (direction.Length() - radiusOfSphere.Length());
      newFar  = (direction.Length() + radiusOfSphere.Length());

      if (zNear == 0.0) zNear = newNear;

      // set new clipping planes.
      if (newNear < zNear)
      {
        zNear = newNear;
      }

      if (newFar > zFar)
      {
        zFar = newFar;
      }
      autoClippingSucceeded = true;
    }


    if (autoClippingSucceeded) {
      // set clipping planes to nearest and farest point +-10%
      zFar  *= 1.1;
      zNear *= 0.9;

      if (zNear < AutoMinZNear_) zNear = AutoMinZNear_; //MIN_ZNEAR
      if (zFar  < zNear*1.01) zFar = zNear*1.01;

      //cout<<"Context ALTERTED znear,zfar to:"<<zNear<<","<<zFar<<endl;
      //cout<<"Setting clipping planes to "<<zNear<<";"<<zFar<<endl;
      camera_->SetFarClippingPlane(zFar);
      camera_->SetNearClippingPlane(zNear);
    } else {
      BIASWARNONCE("autoclipping active but no bounding boxes could be retrieved.");
    }
  }//end if(autoclipping)

  //finally draw scenes with camera
  int res =  camera_->Draw(scenes_, backgroundImageScene_);

  // draw views
  for (int i = 0; i < (int)views_.size(); i++) {
    views_[i]->Render();
  }

  // TODO: should this be called once or for each view?
  for (unsigned int i=0; i<additionalListeners_.size(); i++)
    additionalListeners_[i]->FinishedDraw();

#ifndef TURN_OF_LOCKING
#ifdef BIAS_HAVE_PTHREADS
  ReleaseContextSwitch();
#endif
#endif
  err = glGetError();
  if (err != GL_NO_ERROR) {
    BIASERR("OpenGL Error after rendering: " << gluErrorString(err));
  }

  return res;
}

int RenderContextBase::
GetSceneCount()
{
  return scenes_.size();
}

void RenderContextBase::AppendScene(SceneBase* scene, bool push_front)
{
  scene->SetGLProjectionParametersInterface(camera_);

  if (push_front)
    scenes_.insert(scenes_.begin(),scene);
  else
    scenes_.push_back(scene);

}

void RenderContextBase::RemoveScene(SceneBase* scene, bool noWarning)
{
  int index = -1;
  int numberOfScenes = (int)scenes_.size();
  for (int i = 0; i < numberOfScenes; i++)
    if (scenes_[i] == scene)
      index = i;

  if (index != -1)
    scenes_.erase(scenes_.begin() + index);
  else
    if (!noWarning) BIASWARN("Cannot remove scene. Unknown scene pointer");
}

void RenderContextBase::
InsertSceneAt(SceneBase* scene, unsigned int index)
{
  vector<SceneBase*>::iterator itor = scenes_.begin();

  if (index <= scenes_.size())
  {
    unsigned int i = 0;
    while (i < index)
    {
      itor++;
      i++;
    }
    scenes_.insert( itor, 1, scene );
  }
  else
  {
    scenes_.push_back(scene);
  }
}

void RenderContextBase::
DeleteBackgroundImageScene()
{
  delete backgroundImageScene_;
  SetBackgroundImageScene(NULL);
}


void RenderContextBase::
DeleteSceneAt(unsigned int index)
{
  vector<SceneBase*>::iterator itor = scenes_.begin();

  if (index >= scenes_.size())
  {
    BIASERR("Index out of range");
  }

  unsigned int i = 0;
  while (i < index)
  {
    itor++;
    i++;
  }
  scenes_.erase(itor);
}

void RenderContextBase::
DeleteScenes()
{
  for(unsigned int i=0; i<scenes_.size(); i++)
    delete scenes_[i];
  scenes_.clear();
}

SceneBase* RenderContextBase::
GetSceneAt(unsigned int index){
  BIASASSERT(index < scenes_.size())
  return scenes_[index];
}

void RenderContextBase::
ClearScenes()
{
  scenes_.clear();
}

void BIAS::RenderContextBase::
RemoveAdditionalListener(ControlInterface& listener)
{
  std::vector<ControlInterface*>::iterator begin, end, pos;
  begin = additionalListeners_.begin();
  end = additionalListeners_.end();
  ControlInterface* test = &listener;
  for(pos = begin; test != *pos && pos != end; pos++) {}
  if(*pos == test)
    additionalListeners_.erase(pos);
}

bool BIAS::RenderContextBase::
GetSceneCenter(Vector3<double>& center, Vector3<double>& radius)
{
  center = Vector3<double>(0.0,0.0,0.0);
  radius = Vector3<double>(0.0,0.0,0.0);

  Vector3<double> min, max;
  Vector3<double> newCenter, newRadius;
  unsigned int foundBoundingBox = 0;

  for (unsigned int i = 0; i < scenes_.size(); i++)
  {
    scenes_[i]->GetBoundingBox(min, max);

    // has the scene a bounding box.
    if (min.Length() == 0.0 && max.Length() == 0.0)
      continue;

    foundBoundingBox++;

    // compute radius of the sphere around the bounding box.
    newRadius   = ((max - min) / 2.0);
    newCenter   = newRadius + min;

    if (newRadius.Length() > radius.Length())
      radius = newRadius;

    if (foundBoundingBox >= 2)
    {
      // compute new center and radius of sphere which includes all
      // spheres
      newCenter   = (newCenter - center) / 2.0;
      newRadius   = newCenter + radius;
      newCenter   = newCenter + center;
    }

    // set new radius and center for next iteration
    radius = newRadius;
    center = newCenter;
  }


  // if radius is zero then no bounding box was retrieved
  if (radius.Length() == 0.0)
    return false;
  else
    return true;
}


void RenderContextBase::
SetGLProjectionParametersInterface(GLProjectionParametersInterface* newCamera)
{
  if(newCamera == NULL) {
    BIASERR("RenderContextBase: specified camera is NULL");
    return;
  }
  camera_ = newCamera;
  camera_->SetClearColor(ClearColor_);
  for(unsigned int i=0; i<scenes_.size(); i++)
    scenes_[i]->SetGLProjectionParametersInterface(camera_);
  if(control_ != NULL)
    control_->SetGLProjectionParametersInterface(camera_);
}


bool RenderContextBase::
MouseWheelUsed(double stepsize){

    bool callCaught = false;
    callCaught = control_->MouseWheelUsed(stepsize);
    for (int i = 0; i < (int)additionalListeners_.size(); i++)
    {
        bool res = additionalListeners_[i]->MouseWheelUsed(stepsize);
        callCaught = callCaught || res;
    }
    return callCaught;
}


void RenderContextBase::
SetBackgroundImageScene(SceneBGImage* backgroundImageScene)
{
  BIAS::Vector4<float> cc(255,255,255,0);
  SetClearColor(cc);
  backgroundImageScene_ = backgroundImageScene;
}

void RenderContextBase::
SetControl(ControlInterface* newControl)
{
  control_ = newControl;
  if(control_ != NULL && camera_ != NULL) {
    control_->SetGLProjectionParametersInterface(camera_);
  }

}

bool RenderContextBase::
RightMouseDoubleClicked(int x, int y)
{

  bool res = false;
  if(control_!=NULL)
    res = control_->RightMouseDoubleClicked(x, y);

  for (unsigned i = 0; i < additionalListeners_.size(); i++)
  {
    res = res || additionalListeners_[i]->RightMouseDoubleClicked(x, y);
  }

  return res;
}

bool RenderContextBase::LeftMouseDown(int x, int y)
{
  bool callCaught = false;
  if(control_!=NULL) {
    callCaught = control_->LeftMouseDown(x,y);
  }
  for (int i = 0; i < (int)additionalListeners_.size(); i++)
  {
    bool res = additionalListeners_[i]->LeftMouseDown(x, y);
    callCaught = callCaught || res;
  }
  return callCaught;
}

bool RenderContextBase::LeftMouseUp(int x, int y)
{
  bool callCaught = false;
  if(control_!=NULL) {
    callCaught = control_->LeftMouseUp(x,y);
  }

  for (int i = 0; i < (int)additionalListeners_.size(); i++)
  {
    bool res = additionalListeners_[i]->LeftMouseUp(x, y);
    callCaught = callCaught || res;
  }

  return callCaught;
}

bool RenderContextBase::
LeftMouseDoubleClicked(int x, int y, int m)
{
    bool callCaught = false;

    //if the selection mode is enabled, call selectAt for all scenes
    if(bSelectionMode_){
        // Get from 2D mouse position 3D point in scene.
        if(camera_->GetViewportCoordinates(x, y)) {
            BIAS::HomgPoint3D p=camera_->UnProject(x, y);
            if (p[3] != 0.0)
            {
                BIAS::Vector3<double> p3(p[0],p[1],p[2]);
                for(unsigned i=0;i<scenes_.size();i++)
                    scenes_[i]->SelectObjectAt(p3);
            }
        }
  }

  if(control_!=NULL) {
    callCaught = control_->LeftMouseDoubleClicked(x, y, m);
  }

  for (unsigned int i = 0; i < additionalListeners_.size(); i++)
    {
      bool res = additionalListeners_[i]->LeftMouseDoubleClicked(x, y, m);
      callCaught = callCaught || res;
    }

  return callCaught;
}

bool RenderContextBase::
LeftMouseSingleClicked(int x, int y)
{
    bool callCaught = false;
    if(control_!=NULL)
        callCaught = control_->LeftMouseSingleClicked(x, y);

    for (unsigned i = 0; i < additionalListeners_.size(); i++)
    {
        bool res = additionalListeners_[i]->LeftMouseSingleClicked(x, y);
        callCaught = callCaught || res;
    }

  return callCaught;
}

bool RenderContextBase::
RightMouseSingleClicked(int x, int y)
{
  bool callCaught = false;
  if(control_!=NULL)
    callCaught = control_->RightMouseSingleClicked(x, y);


  for (unsigned i = 0; i < additionalListeners_.size(); i++)
  {
    bool res = additionalListeners_[i]->RightMouseSingleClicked(x, y);
    callCaught = callCaught || res;
  }

  return callCaught;
}

bool RenderContextBase::
LeftMouseMoved(int x1, int x2, int y1, int y2)
{
  bool callCaught = false;
  if(control_!=NULL)
    callCaught = control_->LeftMouseMoved(x1, x2, y1, y2);

  for (unsigned i = 0; i < additionalListeners_.size(); i++)
  {
    bool res = additionalListeners_[i]->LeftMouseMoved(x1, x2, y1, y2);
    callCaught = callCaught || res;
  }

  return callCaught;
}

bool RenderContextBase::
RightMouseMoved(int x1, int x2, int y1, int y2)
{
  bool callCaught = false;
  if(control_!=NULL)
    callCaught = control_->RightMouseMoved(x1, x2, y1, y2);

  if(scenes_.size() == 0 || callCaught)
    return callCaught;

  for (unsigned i = 0; i < additionalListeners_.size(); i++)
  {
    bool res = additionalListeners_[i]->RightMouseMoved(x1, x2, y1, y2);
    callCaught = callCaught || res;
  }
  return callCaught;
}


bool RenderContextBase::RightMouseDown(int x, int y)
{
  bool callCaught = false;
  if(control_!=NULL) {
        callCaught = control_->RightMouseDown(x,y);
  }
  for (int i = 0; i < (int)additionalListeners_.size(); i++)
  {
        bool res = additionalListeners_[i]->RightMouseDown(x, y);
        callCaught = callCaught || res;
  }
  return callCaught;
}

bool RenderContextBase::RightMouseUp(int x, int y)
{
  bool callCaught = false;
  if(control_!=NULL) {
    callCaught = control_->RightMouseUp(x,y);
  }

  for (int i = 0; i < (int)additionalListeners_.size(); i++)
  {
        bool res = additionalListeners_[i]->RightMouseUp(x, y);
        callCaught = callCaught || res;
  }

  return callCaught;
}

bool RenderContextBase::MouseLeftWindow()
{
  bool callCaught = false;
  if(control_!=NULL)
    callCaught = control_->MouseLeftWindow();
  for (unsigned i = 0; i < additionalListeners_.size(); i++)
   {
    bool res = additionalListeners_[i]->MouseLeftWindow();
    callCaught = callCaught || res;
   }
  return callCaught;
}

bool RenderContextBase::
MiddleMouseMoved(int x1, int x2, int y1, int y2)
{
  bool callCaught = false;
  if(control_!=NULL)
    callCaught = control_->MiddleMouseMoved(x1, x2, y1, y2);

  if(scenes_.size() == 0 || callCaught)
    return callCaught;

  for (unsigned i = 0; i < additionalListeners_.size(); i++)
  {
    bool res = additionalListeners_[i]->MiddleMouseMoved(x1, x2, y1, y2);
    callCaught = callCaught || res;
  }
  return callCaught;
}

bool RenderContextBase::MiddleMouseDown(int x, int y)
{
  bool callCaught = false;
  if(control_!=NULL) {
        callCaught = control_->MiddleMouseDown(x,y);
  }
  for (int i = 0; i < (int)additionalListeners_.size(); i++)
  {
        bool res = additionalListeners_[i]->MiddleMouseDown(x, y);
        callCaught = callCaught || res;
  }
  return callCaught;
}

bool RenderContextBase::MiddleMouseUp(int x, int y)
{
  bool callCaught = false;
  if(control_!=NULL) {
    callCaught = control_->MiddleMouseUp(x,y);
  }

  for (int i = 0; i < (int)additionalListeners_.size(); i++)
  {
        bool res = additionalListeners_[i]->MiddleMouseUp(x, y);
        callCaught = callCaught || res;
  }

  return callCaught;
}

bool RenderContextBase::
MouseMoved(int x, int y)
{
  bool callCaught = false;
  if(control_!=NULL){
    callCaught = control_->MouseMoved(x, y);
   // cout<<"RCB Mouse Moved:"<<x<<" "<<y<<endl;
  }

  for (unsigned i = 0; i < additionalListeners_.size(); i++)
  {
    bool res = additionalListeners_[i]->MouseMoved(x, y);
    callCaught = callCaught || res;
  }
  return callCaught;
}


bool RenderContextBase::
LeftAndRightMouseMoved(int x1, int x2, int y1, int y2)
{
  bool callCaught = false;
  if(control_!=NULL)
    callCaught = control_->LeftAndRightMouseMoved(x1, x2, y1, y2);

  if(scenes_.size() == 0 || callCaught)
    return callCaught;

  for (unsigned i = 0; i < additionalListeners_.size(); i++)
  {
    bool res = additionalListeners_[i]->LeftAndRightMouseMoved(x1, x2, y1, y2);
    callCaught = callCaught || res;
  }
  return callCaught;
}

bool RenderContextBase::
SpecialKeyPressed(int key)
{
    bool callCaught = false;
    if(control_!=NULL) {
        callCaught = control_->SpecialKeyPressed(key);
    }

    for (unsigned int i = 0; i < additionalListeners_.size(); i++)
    {
    bool res = additionalListeners_[i]->SpecialKeyPressed(key);
    callCaught = callCaught || res;
  }

  return callCaught;
}

bool RenderContextBase::
SpecialKeyUp(int key)
{
        bool callCaught = false;
        if(control_!=NULL) {
                callCaught = control_->SpecialKeyUp(key);
        }

        for (unsigned int i = 0; i < additionalListeners_.size(); i++)
        {
    bool res = additionalListeners_[i]->SpecialKeyUp(key);
    callCaught = callCaught || res;
  }

  return callCaught;
}



bool RenderContextBase::
StandardKeyPressed(unsigned char key,int x,int y)
{
        bool callCaught = false;
  if(control_!=NULL) {
        callCaught = control_->StandardKeyPressed(key,x,y);
  }

  for (unsigned int i = 0; i < additionalListeners_.size(); i++)
  {
        bool res = additionalListeners_[i]->StandardKeyPressed(key,x,y);
        callCaught = callCaught || res;
  }
  return callCaught;
}

bool RenderContextBase::
StandardKeyUp(unsigned char key,int x,int y)
{
        bool callCaught = false;
  if(control_!=NULL) {
        callCaught = control_->StandardKeyUp(key,x,y);
  }

  for (unsigned int i = 0; i < additionalListeners_.size(); i++)
  {
        bool res = additionalListeners_[i]->StandardKeyUp(key,x,y);
        callCaught = callCaught || res;
  }
  return callCaught;
}

// static int calls = 0;
bool RenderContextBase::
TimerExpired()
{
  bool callCaught = false;
  if(control_!=NULL) {
    callCaught = control_->TimerExpired();
  }

  for( unsigned int i = 0; i<additionalListeners_.size(); i++) {
    bool res =  additionalListeners_[i]->TimerExpired();
    callCaught = callCaught || res;
  }
  return callCaught;
}

void RenderContextBase::
CenterViewport(bool center) {
  centerViewport_ = center;
}

bool RenderContextBase::
WindowReshape(int width, int height)
{
  LockContextSwitch();//MakeGLContextCurrent();

  int viewport[4];
  glGetIntegerv(GL_VIEWPORT, viewport);

  if(centerViewport_) {
    int newviewport[4];
    if(viewport[2]>width) {
      newviewport[0]=0;
      newviewport[2]=width;
    } else {
      int viewportHalfWidth = viewport[2]/2;
      int windowHalfWidth = width/2;
      newviewport[0]=windowHalfWidth-viewportHalfWidth;
      newviewport[2]=viewport[2];
    }

    if(viewport[3]>height) {
      newviewport[1]=0;
      newviewport[3]=width;
    } else {
      int viewportHalfHeight = viewport[3]/2;
      int windowHalfHeight = height/2;
      newviewport[1]=windowHalfHeight-viewportHalfHeight;
      newviewport[3]=viewport[3];
    }

    glViewport(newviewport[0], newviewport[1], newviewport[2], newviewport[3]);
  } else {
   /* cout<<"---------------------------------------------------------------"<<endl;
    cout<<"viewport was: "<<viewport[0]<<" "<<viewport[1]<<" "<<viewport[2]<<" "<<viewport[3]<<endl;
    cout<<"setting view port in windowreshape to: "<<width<<" "<<height<<endl;*/
    glViewport(0,0, width, height);
  }

  if(control_!=NULL) {
    control_->WindowReshape(width, height);
  }

  // unsigned int i = 0;
  //   while(i<scenes_.size()) {
  //     scenes_[i]->WindowReshape(width, height);
  //     i++;
  //   }
  ReleaseContextSwitch();
  return true;
}

void RenderContextBase::
AppendView(View* view)
{
  BIASASSERT(view != NULL);
  views_.push_back(view);
}

void RenderContextBase::EnableStencilUsage(bool enable)
{
  UseStencil_ = enable;
}