OpenGLCanvasBase.cpp

/* author: Jan Woetzel */

#include <Base/Common/BIASpragma.hh>
#include <Utils/GlutInitWrapper.hh>
#include "OpenGLCanvasBase.hh"

//#if defined(wxUSE_GLCANVAS) && wxUSE_GLCANVAS
//#  error + OK, wx compileed in gl configuration
//#else
//#  error wx has not been compiled with wxUSE_GLCANVAS=1. Please set wx/setup.h wxUSE_GLCANVAS=1 and recompile WX.
//#endif


#include <Base/Image/ImageIO.hh>
#include <Base/Math/Vector2.hh>
#include <Base/Math/Vector3.hh>
#include <Base/Math/Vector4.hh>
#include <Base/Common/FileHandling.hh>
#include <Gui/StringConv.hh>

// contains simple GL calls:
#include "GeometryGL.hh"

// mode settings (vsync, multi sampling:
#include "SettingsGL.hh"


#include <string>
#include <sstream>
#include <iostream>
#include <fstream>


#include <wx/defs.h> // key code table
#include <wx/log.h>

// Nvidia Stereo rendering conrol API:
#ifdef BIAS_HAVE_STEREOI
#  include "StereoI.h"
#endif // BIAS_HAVE_STEREOI


// -----------------------------------------
using namespace std;
using namespace BIAS;
// -----------------------------------------

// WARNING:  if you change the event table here,
// you may need to change it in the derived classes, too! (jw)
BEGIN_EVENT_TABLE (OpenGLCanvasBase, wxGLCanvas)
EVT_PAINT  (OpenGLCanvasBase::OnPaint)
EVT_SIZE   (OpenGLCanvasBase::OnSize)
EVT_ERASE_BACKGROUND (OpenGLCanvasBase::OnEraseBackground)
EVT_CHAR   (OpenGLCanvasBase::OnChar)
END_EVENT_TABLE()


// static initialization
unsigned int  OpenGLCanvasBase::instancesTotalNo_ = 0;
double        OpenGLCanvasBase::time = 0.0;
bool              OpenGLCanvasBase::animationUpdateEnabled = OPENGLCANVASBASE_DEFAULT_animationUpdateEnabled;

#ifdef BIAS_HAVE_STEREOI
// interface to nVidia consumer 3d stereo API
// Please use Get_pStereoAPI()
static StereoI* g_pStereoAPI = NULL;
#endif // BIAS_HAVE_STEREOI

// ----------------------------------

// -----------------------------------------


/// destructor
OpenGLCanvasBase::~OpenGLCanvasBase()
{
#ifdef BIAS_HAVE_FONTGL
  delete p_font;
  p_font=NULL;
#endif // BIAS_HAVE_FONTGL
}


OpenGLCanvasBase::OpenGLCanvasBase(
                                   wxFrame* parent
                                   ,wxWindowID id
                                   ,const wxPoint& pos
                                   ,const wxSize& size
                                   ,long style
                                   ,const wxString& name
                                   ,int* attribList
                                   ,const wxPalette& palette  )
                                   : wxGLCanvas(parent,id,pos,size,style,name,attribList,palette)
                                   ,p_ownerframe(NULL)
#ifdef BIAS_HAVE_FONTGL
                                   ,p_font(NULL)
#endif
{
  //CALLINFO;

  instancesTotalNo_ ++;
  InitMembers();
  p_ownerframe=parent;
}


OpenGLCanvasBase::OpenGLCanvasBase(
                                   wxFrame* parent
                                   ,wxGLContext* sharedContext
                                   ,wxWindowID id
                                   ,const wxPoint& pos
                                   ,const wxSize& size
                                   ,long style
                                   ,const wxString& name
                                   ,int* attribList
                                   ,const wxPalette& palette  )
                                   : wxGLCanvas(parent,sharedContext,id,pos,size,style,name,attribList,palette)
                                   ,p_ownerframe(NULL)
#ifdef BIAS_HAVE_FONTGL
                                   ,p_font(NULL)
#endif
{
  //CALLINFO;

  instancesTotalNo_ ++;
  InitMembers();
  p_ownerframe=parent;
}


void OpenGLCanvasBase::InitMembers()
{
  //CALLINFO;

  instance_ = instancesTotalNo_;
  InitWithContextDone_ = false;
  framecount_ = 0;
  animationUpdateEnabled = true;
}


void OpenGLCanvasBase::InitWithContext()
{
  if (InitWithContextDone_) return; /* already done */

  if (!GetContext())
  {
    BIASERR("skipped because GetContext failed on frame ");
    return; // no context available
  };
  // OK so far
  this->SetCurrent();

  if (!IsContextAvailable())
  {
    BIASERR("skipped because no context available on glGetString GL_VENDOR test");
    return;
  }


#if defined(BIAS_HAVE_GLUT)
#  if defined(__FREEGLUT_H__) || defined(__FREEGLUT_STD_H__)
  {
    // freeglut really wants a glutInit call no matter if we use their renderarea handler or not.
    int MyArgc=0;
    BIAS::GlutInitWrapper::GetInstance()->Init( &MyArgc, (char**)NULL );
  }
#  endif
#endif


#if defined(BIAS_HAVE_GLEW)
  /// OK, we have a (valid) Gl Context
  /// run init with context once
#  ifdef USE_EXPERIMENTAL_SETTING_GLEW
  // some exp. beta drivers don't expose their "hidden" capabilities
  // bypass extension query and force "on" for all extensions.
  BIASERR("WARNING: you are forcing bypassing glew extension query"<<endl
    <<"because USE_EXPERIMENTAL_SETTING_GLEW is defined."<<endl
    <<"This is *NOT* recommended in general (JW)");
  glewExperimental=GL_TRUE;
#  endif // USE_EXPERIMENTAL_SETTING_GLEW
  // init glew symbols:
  int err = glewInit();
  if (GLEW_OK != err) {
    // problem: glewInit failed, something is seriously wrong
    BIASERR("could not init GLEW. Error: "<<glewGetErrorString(err));
    exit(-1);
  };
#endif // BIAS_HAVE_GLEW


#if defined(WIN32) && defined(BIAS_HAVE_GLEW)
  // vertical sync initialization
  if (WGLEW_EXT_swap_control)
  {
    SetVSync( rendermode.vsync);
    if (GetVSync()!=rendermode.vsync){
      BIASERR("could not set vsync to "<<rendermode.vsync<<endl
        <<"\tDoes the driver allow application controlled VSYNC/page swapping settings?"<<endl
        <<"\tE.g. NVStereo will and driver tab may force overriding our settings." );
    };
  };
#endif // WIN32

#ifdef BIAS_HAVE_FONTGL
  if (p_font==NULL){
    p_font=new DrawTextGL;
    BIASASSERT(p_font!=NULL);
#  ifdef WIN32
    p_font->InitFont( GetDC(HWND(this->GetHandle())) );
#  else // WIN32
    p_font->InitFont( this->GetHandle() );
#endif // WIN32

  }
#endif // BIAS_HAVE_FONTGL

  InitWithContextDone_ =true;
}


bool OpenGLCanvasBase::IsContextAvailable()
{
  CHECK_GL_ERROR;
  if (!(GetParent()->IsShown())) {
    //BIASERR("Parent not yet shown err1");
    return false;
  };
  if (!GetContext()) {
    BIASERR("Context not (yet?) available.");
    return false; // no context available
  }
  CHECK_GL_ERROR;
  if (!(GetParent()->IsShown())) return false;
  // OK.

#ifndef WIN32
  // conflicts with FBO:
  this->SetCurrent(); // get the GL rendering focus
#endif

  CHECK_GL_ERROR;
  // get OpenGL info strings into std. strings:
  const unsigned char * p_str=NULL;
  p_str = glGetString(GL_VENDOR);
  CHECK_GL_ERROR;
  if ( p_str==NULL) {
    BIASERR("No Context available (NULL ptr)");
    CHECK_GL_ERROR;
    return false;
  };
  return true; // OK.
}


wxFrame* OpenGLCanvasBase::GetOwnerframe()
{
  BIASASSERT(p_ownerframe!=NULL);
  return p_ownerframe;
}

void OpenGLCanvasBase::SetOwnerframe(wxFrame* ptr)
{
  p_ownerframe=ptr;
}


/// return GL state info
void OpenGLCanvasBase::GetInfoGL(std::ostream & os)
{
  if (!GetContext()) return; // no context available
  this->SetCurrent(); // get the GL rendering focus
  // identify current instance of this canvas (or derived class)
  os<<"instance: "<<this->instance_<<endl;

  // display OpenGL status:
  GeometryGL::GetInfoGL(os);
  CHECK_GL_ERROR;

#ifdef BIAS_HAVE_STEREOI
  // display NV StereoI status:
  this->StereoI_GetInfo(os);
#endif //BIAS_HAVE_STEREOI
}

void OpenGLCanvasBase::SwapBuffers(){
  framecount_++;
  wxGLCanvas::SwapBuffers();
}

void
OpenGLCanvasBase::Display()
{
  //CALLINFO;
  CHECK_GL_ERROR;
  // this routine is calling SetCurrent to get rendering focus:
  if ( !IsContextAvailable() )
    return;
  if ( !InitWithContextDone_ )
    InitWithContext();
  if ( !InitWithContextDone_ )
    return;

  if (!(GetParent()->IsShown())) {
    BIASERR("Parent not yet shown.");
    return;
  };

  // realtime clock update (or specialized in derived classed)
  UpdateTime(); //< only base needs this, the drived classes use OnIdle event to update the time.

  // dummy catching all previous uncaught GL errors (in particular of other applications)
  glGetError();
  CHECK_GL_ERROR;

  // display to correct buffer for stereo rendering:
  DisplaySelectBuffer();
  CHECK_GL_ERROR;

  // set polygonmode, line+point size etc.
  DisplayRenderMode();
  CHECK_GL_ERROR;
  {
    /// >>> begin your fancy GL calls (scene like)

    DisplayCalls();

    /// <<< end of your GL calls

  }
  // check if we want to display FPS?
  CHECK_GL_ERROR;

  this->SwapBuffers(); // glcanvas swap
}


void OpenGLCanvasBase::DisplayCalls()
{
  /// >>> begin your fancy GL calls

  // simple sample calls:
  this->DisplayClear();
  this->DisplaySampleScene();

  /// <<< end of your GL calls
}


// useful only for quad buffered stereo:
void OpenGLCanvasBase::DisplaySelectBuffer()
{
  CHECK_GL_ERROR;
  // running quad buffered stereo?
  static int bufferNr=0;
  switch (rendermode.drawbuffermode)
  {
  case STEREO_UNTOUCHED:
    break;
  case MONO:
  case STEREO_CONSUMER_NV:
    glDrawBuffer(GL_BACK);
    CHECK_GL_ERROR;
    break;
  case STEREO_LEFT_RIGHT:
    {
      // toggle between left and right:
      if (bufferNr==0) {
        glDrawBuffer(GL_LEFT);
        CHECK_GL_ERROR;
        bufferNr=1;
      } else {
        glDrawBuffer(GL_RIGHT);
        CHECK_GL_ERROR;
        bufferNr=0;
      };
      break;
    }
  case STEREO_QUADBUFFERED:
    {
      // supported by quadro cards:
      //#ifdef BIAS_DEBUG
      //            cout<<endl<<"displaying quadbuffered /BACK_LEFT,BACK_RIGHT), bufferNr "<<bufferNr<<endl;
      //#endif
      // toggle between left and right:
      if (bufferNr==0) {
        glDrawBuffer(GL_BACK_LEFT);
        CHECK_GL_ERROR;
        bufferNr=1;
      } else {
        glDrawBuffer(GL_BACK_RIGHT);
        CHECK_GL_ERROR;
        bufferNr=0;
      };
      break;
    };
  default:
    cout<<"unknown/unimplemented rendermode.stereomode"<<rendermode.drawbuffermode<<endl;
  };
  CHECK_GL_ERROR;
}


// static
void OpenGLCanvasBase::DisplayClear(const GLbitfield & mask)
{
  GeometryGL::DisplayClear(mask);
  CHECK_GL_ERROR;
}


void OpenGLCanvasBase::DisplayRenderMode()
{
  GeometryGL::DisplayRenderMode(rendermode);
}


//static
void OpenGLCanvasBase::DisplaySampleScene()
{
  GeometryGL::DisplaySceneExampleSimple();
}

// static
void OpenGLCanvasBase::DisplayCoordCross(const float & size, const float & linewidth)
{
  GeometryGL::DisplayCoordCross(size, linewidth);

  // mark axes labels with "x,y,z"
#ifdef BIAS_HAVE_FONTGL
  BIASASSERT(p_font!= NULL);
  GeometryGL::DisplayCoordCrossAxesLabel(size, *p_font);
  //GeometryGL::DisplayCoordCrossAxesLabel(size, *p_font
  //  ,"X axis"
  //  ,"Y axis"
  //  ,"Z axis"
  //  );

#endif // BIAS_HAVE_FONTGL
}


void OpenGLCanvasBase::Reshape()
{
  // adapt the viewport to cover full window (overriden in child classes)
  glViewport(0,0, GetWidth(), GetHeight() );

  // (re-)display on canvas decrease due to new viewport transformation
  Display();
}


unsigned int OpenGLCanvasBase::GetWidth() const
{
  int w, h;
  //GetSize(&w, &h);
  GetClientSize(&w, &h); // DBG
  return w;
}


unsigned int OpenGLCanvasBase::GetHeight() const
{
  int w, h;
  //GetSize(&w, &h);
  GetClientSize(&w, &h);
  return h;
}


/// @return aspect 'X/Y' = ratio of width being 'bigger' than reference height
float OpenGLCanvasBase::GetAspectRatio() const {
  return ((float)GetWidth() / (float)GetHeight());
}



BIAS::Vector3<float>
OpenGLCanvasBase::GetPixelValueRGB(const wxPoint & pos2d)
{
  BIAS::Vector3<float> data;
  if (!IsContextAvailable()) {
    data.Set(0,0,0);
    BIASERR("no context");
    return data;
  };
  glReadPixels(
    (GLint)pos2d.x,
    (GLint)(GetHeight() -pos2d.y),
    (GLsizei)1,  (GLsizei)1,
    GL_RGB,
    GL_FLOAT,
    (GLvoid*)(&data[0]) );
  return data;
}


BIAS::Vector4<float>
OpenGLCanvasBase::GetPixelValueRGBA(const wxPoint & pos2d)
{
  BIAS::Vector4<float> data;
  if (!IsContextAvailable()) {
    data.Set(0,0,0,0);
    BIASERR("no context");
    return data;
  };
  glReadPixels((GLint)pos2d.x,
    (GLint)(GetHeight() -pos2d.y),
    (GLsizei)1,  (GLsizei)1,
    GL_RGBA,
    GL_FLOAT,
    (GLvoid*)(&data[0]) );
  return data;
}


float
OpenGLCanvasBase::GetPixelValueDepth(const wxPoint & pos2d) const
{
  float v=0.0;
  CHECK_GL_ERROR
    glReadPixels((GLint)pos2d.x,
    (GLint)(GetHeight()-pos2d.y),
    (GLsizei)1,  (GLsizei)1,
    GL_DEPTH_COMPONENT, /* GL_DEPTH */
    GL_FLOAT,
    (GLvoid*)&v );
  CHECK_GL_ERROR
    return v;
}


BIAS::Vector3<float>
OpenGLCanvasBase::Unproject(const wxPoint & pos2d, double & d)
{
  double pos3d[3];
  GLint viewport[4];
  GLdouble modelview[16];
  GLdouble projection[16];
  GLfloat wx=pos2d.x, wy=pos2d.y, wz=1;
  GLint x=pos2d.x, y=pos2d.y; // non const version of pos2d

  glGetIntegerv(GL_VIEWPORT, viewport);
  y=viewport[3]-y;
  wy=y;
  // get GL status matrices
  glGetDoublev(GL_MODELVIEW_MATRIX, modelview);
  glGetDoublev(GL_PROJECTION_MATRIX, projection);

  // acces Z buffer value at (x,y)
  glReadPixels(x, y, 1,1, GL_DEPTH_COMPONENT, GL_FLOAT, &wz);

  // compute 3D pos by "unprojection":
  gluUnProject(wx,wy,wz,
    modelview,
    projection,
    viewport,
    &pos3d[0], &pos3d[1], &pos3d[2] );

  //COUT("DBG "<<" wx="<<wx<<" wy="<<wy<<" wz="<<wz" pos3d= "<<pos3d);

  d=wz;
  //d=0; // TODO: not correctly implemented !

  // convert to float result:
  BIAS::Vector3<float> result(pos3d[0], pos3d[1], pos3d[2] );
  return result;
}


void OpenGLCanvasBase::ScreenShot(const std::string & filename,
                                  const bool & flipY,
                                  const GLenum & format,
                                  const bool &force8Bit )
{
  int nChannels=3;
  if (format==GL_RGBA){
    nChannels=4;
  }

  // create a temporary CPU memory image, assume three channel RGB for now.
  BIAS::ImageBase img(GetWidth(), GetHeight(), nChannels );

  this->ScreenShot(img, flipY, format, force8Bit);

  COUT("DBG "<<FUNCNAME<<" is writing "<<filename<<endl<<flush);
  int result = BIAS::ImageIO::Save(filename, img );
  if (result!=0)
  {
    BIASERR("could not save "<<filename<<" result="<<result );
  }
}



// JW
void OpenGLCanvasBase::ScreenShot(BIAS::ImageBase & dest,
                                  const bool & flipY,
                                  const GLenum & format,
                                  const bool &force8Bit )
{
  // adapt image size to screen area:
  // TODO: add similar "data area reesize really required" function to BIAS::Image

  unsigned int channels=3;
  GLenum type = GL_UNSIGNED_BYTE;
  unsigned int ByteDepth=1;
  BIAS::ImageBase::EStorageType st=BIAS::ImageBase::ST_unsignedchar;

  switch (format)
  {
  case GL_DEPTH_COMPONENT:
    if (!force8Bit)
    {
      // we need >=24 bits for depth maps (usually), so si use 32bit float
      ByteDepth=4;
      type=GL_FLOAT;
      st=BIAS::ImageBase::ST_float;
    }
  case GL_RED:
  case GL_GREEN:
  case GL_BLUE:
  case GL_ALPHA:
  case GL_LUMINANCE:
  case GL_STENCIL_INDEX:
    channels=1;
    break;
  case GL_LUMINANCE_ALPHA:
    channels=2;
    break;
  case GL_RGB:
  case GL_BGR_EXT:
    channels=3;
    break;
  case GL_RGBA:
  case GL_BGRA_EXT:
    channels=4;
    break;
  default:
    BIASERR("unsupported format");
  }

  if ( (dest.GetWidth()  != this->GetWidth())
    || (dest.GetHeight() != this->GetHeight())
    || (dest.GetChannelCount() !=  channels) /* nr. of channels */
    || (dest.GetDepth() !=  ByteDepth) /* Byte per channel */
    )
  {
    if (!dest.IsEmpty()) {
      dest.Release();
    };
    dest.Init( this->GetWidth(), this->GetHeight(),
      channels,
      st,
      true /*interleaved*/
      );
  }

  CHECK_GL_ERROR;

  // copy data from GPU to CPU:
  // read a block from the framebuffer back to CPU

  //if (!IsContextAvailable()) {
  //    BIASERR("skipped screenshot because no context available.");
  //    return;
  //}

  this->SetCurrent();
  glFlush();
  glFinish();
  glReadPixels( GLint(0), GLint(0), // x,y from lower left
    GLsizei(this->GetWidth()), GLsizei( this->GetHeight()), // width, height
    format, // format,
    type, //type
    (GLvoid*)dest.GetImageData()
    );
  CHECK_GL_ERROR;

  // flip vertically because of different texcoord systems between OpenGL and MIP?
  if (flipY) dest.Flip();
}

// JW
void OpenGLCanvasBase::ScreenShot()
{
  static unsigned int savedNr=0;
  // get context bits:
  GLint red_bits=0;
  GLint green_bits=0;
  GLint blue_bits=0;
  GLint alpha_bits=0;
  GLint depth_bits=0;
  GLint stencil_bits=0;
  glGetIntegerv(GL_RED_BITS,     &red_bits);
  glGetIntegerv(GL_GREEN_BITS,   &green_bits);
  glGetIntegerv(GL_BLUE_BITS,    &blue_bits);
  glGetIntegerv(GL_ALPHA_BITS,   &alpha_bits);
  glGetIntegerv(GL_DEPTH_BITS,   &depth_bits);
  glGetIntegerv(GL_STENCIL_BITS, &stencil_bits);

  // create unique filename
  stringstream ss;
  ss<<"out_screenshot_"
    <<"savedNr"<<FileHandling::LeadingZeroString(savedNr,5)
    <<"_framecount"<<FileHandling::LeadingZeroString(framecount_, 5)
    <<"_instance"<<FileHandling::LeadingZeroString(instance_,2)
    ;

  // save RGB tetxure
  if ((red_bits>0) || (green_bits>0) || (blue_bits>0)) {
    this->ScreenShot( ss.str() +string("_RGB") +string(BIAS_SCREENSHOT_DEFAULT_EXTENSION),
      true /*flip*/, GL_RGB );
  }

  // save alpha map (if present)
  if (alpha_bits>0){
    this->ScreenShot( ss.str() +string("_ALPHA") +string(BIAS_SCREENSHOT_DEFAULT_EXTENSION),
      true /*flip*/, GL_ALPHA );
  }
  // save combined rgba
  if (red_bits>0 && green_bits>0 && blue_bits>0 && alpha_bits>0) {
    this->ScreenShot( ss.str() +string("_RGBA") +string(BIAS_SCREENSHOT_DEFAULT_EXTENSION),
      true /*flip*/, GL_RGBA );
  }


  // save depth map (if present)
  if (depth_bits>0){
    this->ScreenShot( ss.str() +string("_DEPTH") +string(BIAS_SCREENSHOT_DEFAULT_EXTENSION),
      true /*flip*/, GL_DEPTH_COMPONENT );
  }

  // save stencil buffer (if present)
  if (stencil_bits>0){
    this->ScreenShot( ss.str() +string("_STENCIL") +string(BIAS_SCREENSHOT_DEFAULT_EXTENSION),
      true /*flip*/, GL_STENCIL_INDEX);
  }

  savedNr++;
}


// JW
void OpenGLCanvasBase::SetStatusText(const wxString& text, int c_field )
{
  bool statbarOK=false;
  int field = c_field;

  if (p_ownerframe!=NULL){
    if (p_ownerframe->GetStatusBar()!=NULL)
    {
      if (p_ownerframe->GetStatusBar()->GetFieldsCount()>field){
        // everything is fine
        statbarOK=true;
      } else {
        // status bar has not enough fields, disply to last field
        //#ifdef BIAS_DEBUG
        //        BIASERR("p_ownerframe has no only "
        //          <<p_ownerframe->GetStatusBar()->GetFieldsCount()
        //          <<" fields. could not display to field="<<field<<"!");
        //#endif // BIAS_DEBUG
        field = (p_ownerframe->GetStatusBar()->GetFieldsCount()) -1;
        statbarOK=true;
      }
    } else {
      BIASERR("p_ownerframe has no status bar!");
    }
    //} else {
    //  BIASERR("p_ownerframe is NULL!");
  };

  if (statbarOK)
  {
    p_ownerframe->SetStatusText(text, field);
  } else {
    // fallback output
    cout<<field<<": "<<text<<endl;
  };
}


void
OpenGLCanvasBase::ShowValue(const wxPoint & pos)
{
  CHECK_GL_ERROR;
  std::stringstream s;
  double d=0.0;
  BIAS::Vector3<float> p3d(0,0,0);
  p3d = Unproject(pos, d);
  CHECK_GL_ERROR;

  //get pixel value under mouse
  BIAS::Vector4<float> rgbGL;
  rgbGL = GetPixelValueRGBA(pos);
  CHECK_GL_ERROR;
  float depthGL= GetPixelValueDepth(pos);
  CHECK_GL_ERROR;

  //s<<"2d: ";
  s<<"("<<pos.x<<";"<<pos.y<<") ";
  s<<"rgba=("
    <<std::setprecision(5)<<rgbGL[0]<<";"
    <<std::setprecision(5)<<rgbGL[1]<<";"
    <<std::setprecision(5)<<rgbGL[2]<<";"
    <<std::setprecision(5)<<rgbGL[3]<<") ";

  s<<"depthGL="<<std::setprecision(5)<<depthGL<<" ";

  s<<"3d: ";
  s<<"["<<p3d[0]<<";"<<p3d[1]<<";"<<p3d[2]<<"] ";
  s<<"dist. "<<d<<" ";

//#ifdef BIAS_DEBUG
//  // display in console (for debugging, in small windows)
//  cout<<s.str()<<endl;
//#endif

  SetStatusText(AsciiToWx(s.str()));
}


// computes and displays current FPS in status bar
void OpenGLCanvasBase::ShowFPS(const int & framecounter,
                               const float & minUpdateIntervalSec,
                               const unsigned int & minNewFrames,
                               const unsigned int nField)
{
  static float fps=0.0f;
  static clock_t start=clock(); // init once
  static unsigned int startFrameNo = framecounter;

  // how many frames were drawn since last call:
  unsigned int nNewFrames = framecounter - startFrameNo;
  if (nNewFrames==0) {
    // no frames rendered, keep old value, do not update status bar
    return;
  } else if (nNewFrames<minNewFrames) {
    // too few frames for reliable measurement, keep old, do not update status bar
    return;
  };

  // measure time and fps since last fps display
  clock_t stop=clock();
  clock_t duration = stop -start;

  if (float(duration)==0){
    // do nothing, keep old value
    return;
  } else if (duration>=float(CLOCKS_PER_SEC)*minUpdateIntervalSec){
    //
    // OK
    //

    // compute avg fps of the last nNewFrames images
    fps = (float)nNewFrames * float(CLOCKS_PER_SEC)/(float)duration;

    //
    // prepare next measurement
    //
    // next start is this stop
    start=stop;
    startFrameNo = framecounter;

    //
    // update status bar
    //
    stringstream ss;
    ss<<fps<<" fps "
      <<"("<<framecounter<<")."
      ;
    SetStatusText(AsciiToWx(ss.str()), nField);
  };
}



// HACK: doing fullscreen on frame instead of canvas for now. (JW)
// TODO: hide this, create frame directly around canvas, fullscreen
void OpenGLCanvasBase::ToggleFullScreen()
{
  if (p_ownerframe!=NULL) {
    long style=0;
    if (rendermode.drawbuffermode==BIAS::STEREO_CONSUMER_NV){
      // works only in true fullscreen,
      // thus all menu and statusbar need to be disabled!
      style = style | wxFULLSCREEN_ALL;
    }
    p_ownerframe->ShowFullScreen(
      !(p_ownerframe->IsFullScreen()),
      style
      |OpenGLCanvasBase_DEFAULT_FULLSCREEN_STYLE
      //|wxFULLSCREEN_NOMENUBAR
      //|wxFULLSCREEN_NOTOOLBAR
      //|wxFULLSCREEN_NOSTATUSBAR
      //|wxFULLSCREEN_NOBORDER
      //|wxFULLSCREEN_NOCAPTION
      //|wxFULLSCREEN_ALL
      );
  }
}


void OpenGLCanvasBase::ShowFPS()
{
  ShowFPS(this->framecount_,
    3.0f, /* sec, */
    1, /* nr of new frames */
    1 /* nField in status bar */
    );
}


///
/// EVT handlers: ------------------------------------------
///

void OpenGLCanvasBase::OnPaint( wxPaintEvent &WXUNUSED(event) )
{
  // This is a dummy, to avoid an endless succession of paint messages.
  // OnPaint handlers must always create a wxPaintDC.
  wxPaintDC dc(this);
  Display();
}


void OpenGLCanvasBase::OnSize(wxSizeEvent& )
{
  Reshape();
}


std::ostream & OpenGLCanvasBase::PrintHelp(std::ostream & os)
{
  os<<"key function assignment:"<<endl
    <<"F1\t this help"<<endl
    <<"F10, INSERT, p\t Screenshot"<<endl
    <<"z,y\tPOINT rendering mode"<<endl
    <<"x\tLINE polygon rendering mode (wireframe)"<<endl
    <<"c\tFILL polygon rendering mode (vertices)"<<endl
    <<"v\tFILL front, LINE back polygon rendering mode"<<endl
    <<"Z,Y\tSMOOTH shading mode"<<endl
    <<"X\tFLAT shading mode"<<endl
    <<"i\tInformation, e.g. on OpenGL status"<<endl
    <<"k\t toggle culling back  sides"<<endl
    <<"K\t toggle culling front sides"<<endl
    <<"L\t toggle culling front and back sides, "<<endl
    <<" \t =draw only LINES and POINTS, no faces at all."<<endl
    <<"]\t increase pointsize (++)"<<endl
    <<"[\t decrease pointsize (--)"<<endl
    <<"s\tstop animation (halt)"<<endl
    <<"a\tanimate=run animation"<<endl
    <<"f,F\ttoggle Fullscreen modus (of the frame)"<<endl
    <<"V\ttoggle VSYNC swap control on/off"<<endl
    ;
  return os;
}


//JW
void OpenGLCanvasBase::OnChar(wxKeyEvent& event)
{
  switch (event.GetKeyCode())
  {
  case WXK_F1: /* popup simple help */
    {
      stringstream ss;
      PrintHelp(ss);
      ::wxMessageBox(AsciiToWx(ss.str()), wxT("Help"), wxICON_INFORMATION | wxOK );
      break;
    }
#ifdef BIAS_HAVE_STEREOI
  case WXK_F3:
    //StereoI_Init();
    StereoI_GetInfo();
    break;
#endif // BIAS_HAVE_STEREOI
  case WXK_PRINT: /* is ignored on WinXP, thus assign other keys, too. (jw) */
  case 'p':
  case WXK_F10:
    SetStatusText(wxT("saving screenshot."));
    this->ScreenShot(); break;
    //case WXK_F5: // toggles idleRepaintEnabled
    //  {
    //      idleRepaintEnabled = !idleRepaintEnabled ;
    //      stringstream ss;
    //      ss<<"Toggled idleRepaintEnabled="<<idleRepaintEnabled;
    //      // TODO: Disconnect, GetEventHandler
    //      this->GetEventHandler()->Disconnect( ID, wxID_ANY, EVT_IDLE);
    //      cout<<ss.str()<<endl;
    //      SetStatusText( ss.str().c_str() );
    //      break;
    //  }
  case 'z': /* english keyboard */
  case 'y': /* german keyboard */
    rendermode.polygonmodeFRONT=GL_POINT;
    rendermode.polygonmodeBACK=GL_POINT;
    SetStatusText(wxT("PolygonMode POINT"));
    Display();
    break;
  case 'x':  /* wireframe */
    rendermode.polygonmodeFRONT=GL_LINE;
    rendermode.polygonmodeBACK=GL_LINE;
    SetStatusText(wxT("PolygonMode LINE"));
    Display();
    break;
  case 'c':
    rendermode.polygonmodeFRONT=GL_FILL;
    rendermode.polygonmodeBACK=GL_FILL;
    SetStatusText(wxT("PolygonMode FILL"));
    Display();
    break;
  case 'v':
    // useful to debug culling
    rendermode.polygonmodeFRONT=GL_FILL;
    rendermode.polygonmodeBACK=GL_LINE;
    SetStatusText(wxT("PolygonMode: front=FILL, back=LINE"));
    Display();
    break;
  case 'Z':
  case 'Y':
    rendermode.shademodel=GL_SMOOTH;
    SetStatusText(wxT("SMOOTH shading"));
    Display();
    break;
  case 'X':
    rendermode.shademodel=GL_FLAT;
    SetStatusText(wxT("FLAT shading"));
    Display();
    break;
  case 'k':
    // backface culling = right hand order to viewer is drawn
    if (rendermode.cullface==GL_BACK)
      rendermode.enable_cullface = !(rendermode.enable_cullface); // toggle
    else
      rendermode.enable_cullface = true;
    rendermode.cullface=GL_BACK;
    if (rendermode.enable_cullface)
      SetStatusText(wxT("enabled culling BACK sides (clockwise ordering) "));
    else
      SetStatusText(wxT("disabled culling."));
    Display();
    break;
  case 'K':
    if (rendermode.cullface==GL_FRONT)
      rendermode.enable_cullface = !(rendermode.enable_cullface); // toggle
    else
      rendermode.enable_cullface = true;
    rendermode.cullface=GL_FRONT;
    if (rendermode.enable_cullface)
      SetStatusText(wxT("enabled culling FRONT sides (counterclockwise ordering) "));
    else
      SetStatusText(wxT("disabled culling. "));
    Display();
    break;
  case 'L':
    if (rendermode.cullface==GL_FRONT_AND_BACK)
      rendermode.enable_cullface = !(rendermode.enable_cullface); // toggle
    else
      rendermode.enable_cullface = true;
    rendermode.cullface=GL_FRONT_AND_BACK;
    // unusual: culling all faces, only lines and points ar drawn!
    if (rendermode.enable_cullface)
      SetStatusText(wxT("warning: Culling front and back. No faces are drawn, only LINES and POINTS are drawn, no polygones!"));
    else
      SetStatusText(wxT("disabled culling."));
    Display();
    break;
  case 'i': /* show information */
    {
      stringstream ss;
      this->GetInfoGL(ss);
      cout<<ss.str()<<endl;
      // this window is too big, add wxDialog with scrollable text control
      //::wxMessageBox(wxString(ss.str().c_str()), "Information", wxICON_INFORMATION | wxOK );
      ::wxMessageBox(wxT("see cout for information on current OpenGL status."), wxT("Information"), wxICON_INFORMATION | wxOK );
      break;
    }
  case ']':
    {
      if (rendermode.pointsize<63.0f) rendermode.pointsize++;
      BIASASSERT(rendermode.pointsize>=1.0f);
      BIASASSERT(rendermode.pointsize<=63.0f);
      stringstream ss;
      ss<<"increased pointsize to "<<rendermode.pointsize;
      SetStatusText( AsciiToWx(ss.str()) );
      Display();
      break;
    }
  case '[':
    {
      if (rendermode.pointsize>1.0f) {
        rendermode.pointsize--;
      }
      BIASASSERT(rendermode.pointsize>=1.0f);
      BIASASSERT(rendermode.pointsize<=63.0f);
      stringstream ss;
      ss<<"decreased pointsize to "<<rendermode.pointsize;
      SetStatusText( AsciiToWx(ss.str()) );
      Display();
      break;
    }
  case 's':
    animationUpdateEnabled =false;
    SetStatusText(wxT("stopped animation"));    break;
  case 'a':
    animationUpdateEnabled = true;
    SetStatusText(wxT("animation running"));    break;
  case 'f':
  case 'F':
    ToggleFullScreen(); break;
  case 'V':
    {
      string msg;
      if (!ToggleVSync()){
        // error
        msg="toggling failed. still: ";
        BIASERR("toggling VSync failed. Please verify: "<<endl
          <<"  -application controlled vsync should be set in driver tab on WIN32"<<endl
          <<"  -Nvidia Stereo driver may override vsync (for shutter glasses)"<<endl );
      }
      if (GetVSync())
        msg+="VSYNC enabled";
      else
        msg+="VSYNC disable";
      COUT(msg<<endl);
      SetStatusText(AsciiToWx(msg));
      break;
    }
  }; // end of switch keycode
  // always skip keycodes because parent canvases may use them, too - e.g. for menu short cuts.
  event.Skip();
}


void OpenGLCanvasBase::OnEraseBackground(wxEraseEvent& )
{
  // do nothing (with intention) to help avoid flashing
}


void OpenGLCanvasBase::SetVSync( const bool & trueForOn )
{
  if (trueForOn)
    SettingsGL::SetVSyncInterval( int(1) );
  else
    SettingsGL::SetVSyncInterval( int(0) );
}


bool OpenGLCanvasBase::GetVSync()
{
  return (SettingsGL::GetVSyncInterval() != int(0) );
}


bool OpenGLCanvasBase::ToggleVSync()
{
  bool act = GetVSync();
  SetVSync( !act ); // try to toggle
  // did the status really change?
  return (act!= GetVSync() );
}


void OpenGLCanvasBase::UpdateTime()
{
  time = double(clock()) / double(CLOCKS_PER_SEC);
}

bool OpenGLCanvasBase::ToggleIP(bool & value){
  value = !value;
  return value;
}


// JW
#ifdef BIAS_HAVE_STEREOI
int OpenGLCanvasBase::StereoI_Init()
{
  if (g_pStereoAPI!=NULL){
    BIASERR("StereoI API already initialized through g_pStereoAPI."<<endl
      <<"\tinterface creation should be called once, only. aborting." );
    return -1;
  };
  // must be NULL to use interface only once.
  BIASASSERT(g_pStereoAPI==NULL);
  if(!CreateStereoI(&g_pStereoAPI)){
    BIASERR("CreateStereoI failed. Did you install NVStereo and Nvidia GPU drivers? aborting.");
    g_pStereoAPI = NULL;
    return -2;
  };
  BIASASSERT(g_pStereoAPI!=NULL);
  if (g_pStereoAPI->GetStereoState() == STEREO_STATE_DISABLED){
    BIASERR("Stereo is currently DISABLED.  Did you install enable NVStereo in the driver control panel?");
    return -3;
  }

  // be verbose on current status:
  StereoI_GetInfo();

  return 0; // OK=success
}


/* catch missing initializations
and insert assertion on NULL ptr */
StereoI* Get_pStereoAPI(){
  if (g_pStereoAPI==NULL)
    OpenGLCanvasBase::StereoI_Init();
  if (g_pStereoAPI==NULL){
    BIASERR("StereoI API not avaible through g_pStereoAPI.");
    return NULL;
  }
  BIASASSERT(g_pStereoAPI!=NULL);
  return g_pStereoAPI;
}


void OpenGLCanvasBase::StereoI_GetInfo(std::ostream &os)
{
  if (Get_pStereoAPI()==NULL)
  {
    StereoI_Init();
    BIASERR("StereoI API not avaible through g_pStereoAPI.");
    return;
  }
  os<<"*StereoI state is:"<<endl;
  int tmp=0;
  os<<"CheckAPIVersion >=1: "<<bool(Get_pStereoAPI()->CheckAPIVersion(1)>=0)<<endl;

  tmp=Get_pStereoAPI()->GetStereoState();
  switch (tmp){
    case STEREO_STATE_ENABLED:
      os<<"STEREO_STATE_ENABLED"<<endl;
      break;
    case STEREO_STATE_DISABLED:
      os<<"STEREO_STATE_DISABLED"<<endl;
    default:
      {
        stringstream ss;
        ss<<"STEREO_STATE="<<tmp<<" is unknown.";
        BIASERR(ss.str());
        break;
      }
  };
  os<<"Separation:  "<<Get_pStereoAPI()->GetSeparation()<<endl;
  os<<"Convergence: "<<Get_pStereoAPI()->GetConvergence()<<endl;
}


// simple wrappers:
int OpenGLCanvasBase::StereoI_GetStereoState()
{
  if (Get_pStereoAPI()==NULL)   {
    BIASERR("StereoI API not avaible through g_pStereoAPI.");
    return 0.0f;
  }
  return Get_pStereoAPI()->GetStereoState();
}
int OpenGLCanvasBase::StereoI_SetStereoState(const int & val)
{
  if (Get_pStereoAPI()==NULL)   {
    BIASERR("StereoI API not avaible through g_pStereoAPI.");
    return 0.0f;
  }
  return Get_pStereoAPI()->SetStereoState(val);
}
float OpenGLCanvasBase::StereoI_GetSeparation()
{
  if (Get_pStereoAPI()==NULL)   {
    BIASERR("StereoI API not avaible through g_pStereoAPI.");
    return 0.0f;
  }
  return Get_pStereoAPI()->GetSeparation();
}
float OpenGLCanvasBase::StereoI_SetSeparation(const float & val)
{
  if (Get_pStereoAPI()==NULL)   {
    BIASERR("StereoI API not avaible through g_pStereoAPI.");
    return 0.0f;
  }
  return Get_pStereoAPI()->SetSeparation(val);
}
float OpenGLCanvasBase::StereoI_GetConvergence()
{
  if (Get_pStereoAPI()==NULL)   {
    BIASERR("StereoI API not avaible through g_pStereoAPI.");
    return 0.0f;
  }
  return Get_pStereoAPI()->GetConvergence();
}
float OpenGLCanvasBase::StereoI_SetConvergence(const float & val)
{
  if (Get_pStereoAPI()==NULL)   {
    BIASERR("StereoI API not avaible through g_pStereoAPI.");
    return 0.0f;
  }
  return Get_pStereoAPI()->SetConvergence(val);
}
void OpenGLCanvasBase::StereoI_CaptureStereoImage(const int & format,
                                                  const int & quality)
{
  if (Get_pStereoAPI()==NULL)   {
    BIASERR("StereoI API not avaible through g_pStereoAPI.");
    return;
  }
  return Get_pStereoAPI()->CaptureStereoImage(format, quality);
}
#endif // BIAS_HAVE_STEREOI