ContextGLUT.cpp

#include "ContextGLUT.hh"
#include <bias_config.h>
#include <Gui/biasgl.h>
#include <iostream>
#include <vector>
#include <Utils/GlewInitWrapper.hh>
#include <Utils/GlutInitWrapper.hh>

#ifdef GLUT_TIME_MEASURE
#include <Base/Debug/TimeMeasure.hh>
BIAS::TimeMeasure timeMeasure_;
unsigned int timeMeasureCount_ = 0;
unsigned int outputCount_ = 0;
unsigned int outputIntervall = 1;
unsigned int MEASURE_INTERVALL = 1;
unsigned int BIAS::ContextGLUT::measurementsCount_ = 0;
std::vector<double> BIAS::ContextGLUT::fpsMeasures;
#endif


using namespace std;
using namespace BIAS;

ContextGLUT* RegisteredContext;
std::vector<ContextGLUT*> registeredGlutWindows;

void SetRegisteredContext() {
  RegisteredContext = NULL;
  for(unsigned int i=0; i<registeredGlutWindows.size(); i++) {
    if(registeredGlutWindows[i]->GetGlutWindowID()==glutGetWindow()) {
      RegisteredContext = registeredGlutWindows[i];
      //   cout<<"setting new registered context to id "
      //   <<registeredGlutWindows[i]->GetGlutWindowID()<<endl;
    }
  }
}

/**  Grouping the mouseactions reported by GLUT.
 */
struct MouseActionStruct
{
  int lastLeftX, lastLeftY;
  int lastRightX, lastRightY;
  int lastMiddleX, lastMiddleY;  
  time_t lastTimeLeft;
  bool leftDown;
  bool rightDown;
  bool middleDown;
  //double / single clicks
  bool listeningForLeftDoubleClick;
  bool receivedLeftDoubleClick;
  bool leftButtonWasUp;  
  bool listeningForRightDoubleClick;
  bool receivedRightDoubleClick;
  bool rightButtonWasUp;  
} MouseAction;

#define DOUBLE_CLICK_MS 200

void BIAS::MouseMotionFunc_(int x, int y)
{ 
  
  SetRegisteredContext();
  //store if first clicked
  if(RegisteredContext->control_==NULL) {
    // BIASERR("No control has been set\n");
    return;
  }

  if(!(MouseAction.leftDown && MouseAction.rightDown)) {
    if(MouseAction.leftDown) {
      RegisteredContext->LeftMouseMoved(MouseAction.lastLeftX, x, 
                    MouseAction.lastLeftY, y);
       MouseAction.lastLeftX=x;
       MouseAction.lastLeftY=y;
    }
    if(MouseAction.rightDown) {
    
      RegisteredContext->RightMouseMoved(MouseAction.lastRightX, x, 
                     MouseAction.lastRightY, y);
      MouseAction.lastRightX=x;
      MouseAction.lastRightY=y;
    }
  } else {
    RegisteredContext->LeftAndRightMouseMoved(MouseAction.lastRightX, x, 
                          MouseAction.lastRightY, y);
    MouseAction.lastLeftX=x;
    MouseAction.lastLeftY=y;
    MouseAction.lastRightX=x;
    MouseAction.lastRightY=y;
  }
  
  if(MouseAction.middleDown) {
    RegisteredContext->MiddleMouseMoved(MouseAction.lastMiddleX, x, 
                    MouseAction.lastMiddleY, y);
    MouseAction.lastMiddleX=x;
     MouseAction.lastMiddleY=y;
  } 
  RegisteredContext->MouseMoved(x,y);
  glutPostRedisplay();
}

void BIAS::MousePassiveMotionFunc_(int x, int y)
{ 
  
  SetRegisteredContext();
  //store if first clicked
  if(RegisteredContext->control_==NULL) {
    // BIASERR("No control has been set\n");
    return;
  }

  RegisteredContext->MouseMoved(x,y);
  glutPostRedisplay();
}

/* Some explanations to double click implementation:
 * 
 * MouseButtonFunc_ activates the doubleClckListener for a double click if
 * not already activated. This is determined via global variable 
 * listeningForDoubleClick. This function is activated after DOUBLE_CLICK_MS
 * milliseconds and turns of the double click waiting state i.e. 
 * listeningForDoubleClick = false. And checks whether the mouse button was
 * raised. If this was the case a single button click was activated.
 * If a double clicked was received in the meanwhile: receivedDoubleClick 
 * this is ignored. 
 * 
 */


void leftDoubleClickListener(int) {
  MouseAction.listeningForLeftDoubleClick = false;
  if(MouseAction.receivedLeftDoubleClick)
    return;
  else {
    //not received double click was button released in between ?
    if(!MouseAction.leftButtonWasUp)
      return;
    else {
      RegisteredContext->LeftMouseSingleClicked(MouseAction.lastLeftX, 
                        MouseAction.lastLeftY);      
      glutPostRedisplay();
    }
  }
}

void rightDoubleClickListener(int) {
  MouseAction.listeningForRightDoubleClick = false;
  if(MouseAction.receivedRightDoubleClick)
    return;
  else {
    //not received double click was button released in between ?
    if(!MouseAction.rightButtonWasUp)
      return;
    else {
      RegisteredContext->RightMouseSingleClicked(MouseAction.lastRightX, 
                         MouseAction.lastRightY);      
      glutPostRedisplay();
    }
  }
}


void BIAS::MouseButtonFunc_(int button, int state, int x, int y)
{  
  SetRegisteredContext();
  switch(button) 
    {
    case GLUT_LEFT_BUTTON :
      switch(state) 
        {
        case GLUT_DOWN : 
          {
            if(!MouseAction.listeningForLeftDoubleClick) {
              MouseAction.leftDown = true;
              MouseAction.lastLeftX = x;
              MouseAction.lastLeftY = y;          
              MouseAction.receivedLeftDoubleClick = false;
              MouseAction.leftButtonWasUp = false;
              MouseAction.listeningForLeftDoubleClick = true;      
              glutTimerFunc(RegisteredContext->doubleClickInterval_,
                            leftDoubleClickListener, 0);
            }
            else {
              MouseAction.receivedLeftDoubleClick = true;
              int xDiff = MouseAction.lastLeftX - x;
              int yDiff = MouseAction.lastLeftY - y;
              if(xDiff == 0 && yDiff == 0) {
                                //cout<<"double click at ("<<x<<", "<<y<<")"<<endl;
                RegisteredContext->LeftMouseDoubleClicked(x,y,0);
                glutPostRedisplay();
                return;
              } 
            }       
            RegisteredContext->LeftMouseDown(x,y);
          }   
          break;
        case GLUT_UP :  
          {
            MouseAction.leftButtonWasUp = true;
            MouseAction.leftDown = false; 
            RegisteredContext->LeftMouseUp(x,y);
          }
          break;
        }
      break;

    case GLUT_RIGHT_BUTTON :
      switch(state) 
        {
        case GLUT_DOWN : 
          {
            if(!MouseAction.listeningForRightDoubleClick) {
              MouseAction.rightDown = true;
              MouseAction.lastRightX = x;
              MouseAction.lastRightY = y;         
              MouseAction.receivedRightDoubleClick = false;
              MouseAction.rightButtonWasUp = false;
              MouseAction.listeningForRightDoubleClick = true;      
              glutTimerFunc(RegisteredContext->doubleClickInterval_, 
                            rightDoubleClickListener, 0);
            }
            else {
              MouseAction.receivedRightDoubleClick = true;
              int xDiff = MouseAction.lastRightX - x;
              int yDiff = MouseAction.lastRightY - y;
              if(xDiff == 0 && yDiff == 0) {
                RegisteredContext->RightMouseDoubleClicked(x,y);
                glutPostRedisplay();
                return;
              } 
            }       
        
          }   
          break;
        case GLUT_UP :  
          {
            MouseAction.rightButtonWasUp = true;
            MouseAction.rightDown = false; 
          }
          break;
        }
      break;    
    
    case GLUT_MIDDLE_BUTTON :
      switch(state) 
        {
        case GLUT_DOWN : 
          MouseAction.lastMiddleX = x;
          MouseAction.lastMiddleY = y;
          MouseAction.middleDown = true;
          break;
        case GLUT_UP : MouseAction.middleDown = false; break;
        }

      break;
    }    
}


void BIAS::StandardKeyFunc_(unsigned char key, int x, int y)
{
  SetRegisteredContext();
  RegisteredContext->StandardKeyPressed(key, x, y);
  glutPostRedisplay();
}


void BIAS::StandardKeyUpFunc_(unsigned char key, int x, int y)
{
  SetRegisteredContext();
  RegisteredContext->StandardKeyUp(key, x, y);
  glutPostRedisplay();
}

void BIAS::SpecialKeyFunc_(int key, int /*x*/, int /*y*/)
{
  SetRegisteredContext();
  switch(key)
  {
    case GLUT_KEY_F1:      
      RegisteredContext->SpecialKeyPressed(KEY_F1);
      break;
    case GLUT_KEY_F2:
      RegisteredContext->SpecialKeyPressed(KEY_F2);
      break;
    case GLUT_KEY_F3:
      RegisteredContext->SpecialKeyPressed(KEY_F3);
      break;
    case GLUT_KEY_F4:
      RegisteredContext->SpecialKeyPressed(KEY_F4);
      break;      
    case GLUT_KEY_F5:
      RegisteredContext->SpecialKeyPressed(KEY_F5);
      break;      
    case GLUT_KEY_F6:
      RegisteredContext->SpecialKeyPressed(KEY_F6);
      break;      
    case GLUT_KEY_F7:
      RegisteredContext->SpecialKeyPressed(KEY_F7);
      break;      
    case GLUT_KEY_F8:
      RegisteredContext->SpecialKeyPressed(KEY_F8);
      break;      
    case GLUT_KEY_F9:
      RegisteredContext->SpecialKeyPressed(KEY_F9);
      break;      
    case GLUT_KEY_F10:
      RegisteredContext->SpecialKeyPressed(KEY_F10);
      break;      
    case GLUT_KEY_F11:
      RegisteredContext->SpecialKeyPressed(KEY_F11);
      break;      
    case GLUT_KEY_F12:
      RegisteredContext->SpecialKeyPressed(KEY_F12);
      break;      
    case GLUT_KEY_HOME:
      RegisteredContext->SpecialKeyPressed(KEY_HOME);
      break;      
    case GLUT_KEY_PAGE_UP:
      RegisteredContext->SpecialKeyPressed(KEY_PGUP);
      break;      
    case GLUT_KEY_PAGE_DOWN:
      RegisteredContext->SpecialKeyPressed(KEY_PGDOWN);
      break;      
    case GLUT_KEY_UP:
      RegisteredContext->SpecialKeyPressed(KEY_UP);
      break;
    case GLUT_KEY_DOWN:
      RegisteredContext->SpecialKeyPressed(KEY_DOWN);
      break;
    case GLUT_KEY_LEFT:
      RegisteredContext->SpecialKeyPressed(KEY_LEFT);
      break;
    case GLUT_KEY_RIGHT:
      RegisteredContext->SpecialKeyPressed(KEY_RIGHT);
      break;
  }  
  glutPostRedisplay();
  return; 
}


void BIAS::SpecialKeyUpFunc_(int key, int /*x*/, int /*y*/)
{
  SetRegisteredContext();
  switch(key)
  {
    case GLUT_KEY_F1:
      RegisteredContext->SpecialKeyUp(KEY_F1);
      break;
    case GLUT_KEY_F2:
      RegisteredContext->SpecialKeyUp(KEY_F2);
      break;
    case GLUT_KEY_F3:
      RegisteredContext->SpecialKeyUp(KEY_F3);
      break;
    case GLUT_KEY_F4:
      RegisteredContext->SpecialKeyUp(KEY_F4);
      break;
    case GLUT_KEY_F5:
      RegisteredContext->SpecialKeyUp(KEY_F5);
      break;
    case GLUT_KEY_F6:
      RegisteredContext->SpecialKeyUp(KEY_F6);
      break;
    case GLUT_KEY_F7:
      RegisteredContext->SpecialKeyUp(KEY_F7);
      break;
    case GLUT_KEY_F8:
      RegisteredContext->SpecialKeyUp(KEY_F8);
      break;
    case GLUT_KEY_F9:
      RegisteredContext->SpecialKeyUp(KEY_F9);
      break;
    case GLUT_KEY_F10:
      RegisteredContext->SpecialKeyUp(KEY_F10);
      break;
    case GLUT_KEY_F11:
      RegisteredContext->SpecialKeyUp(KEY_F11);
      break;
    case GLUT_KEY_F12:
      RegisteredContext->SpecialKeyUp(KEY_F12);
      break;
    case GLUT_KEY_HOME:
      RegisteredContext->SpecialKeyUp(KEY_HOME);
      break;
    case GLUT_KEY_PAGE_UP:
      RegisteredContext->SpecialKeyUp(KEY_PGUP);
      break;
    case GLUT_KEY_PAGE_DOWN:
      RegisteredContext->SpecialKeyUp(KEY_PGDOWN);
      break;
    case GLUT_KEY_UP:
      RegisteredContext->SpecialKeyUp(KEY_UP);
      break;
    case GLUT_KEY_DOWN:
      RegisteredContext->SpecialKeyUp(KEY_DOWN);
      break;
    case GLUT_KEY_LEFT:
      RegisteredContext->SpecialKeyUp(KEY_LEFT);
      break;
    case GLUT_KEY_RIGHT:
      RegisteredContext->SpecialKeyUp(KEY_RIGHT);
      break;
  }
  glutPostRedisplay();
  return;
}


void BIAS::Reshape_(int width, int height)
{
  SetRegisteredContext();
  RegisteredContext->WindowReshape(width, height);
}

void BIAS::Render_()
{
  SetRegisteredContext();
#ifdef GLUT_TIME_MEASURE
  timeMeasure_.Start();
#endif

  //   cout<<"rendering for win"<<RegisteredContext->GetGlutWindowID()<<" /"<<glutGetWindow()<<endl;
  RegisteredContext->Render();

#ifdef GLUT_TIME_MEASURE
  timeMeasure_.Stop();
  timeMeasureCount_++;
  if(timeMeasureCount_ > MEASURE_INTERVALL) {
    double fps = double(timeMeasureCount_*1000)/timeMeasure_.GetUserTime();
    if(ContextGLUT::measurementsCount_<ContextGLUT::fpsMeasures.size())
      ContextGLUT::fpsMeasures[BIAS::ContextGLUT::measurementsCount_++] = fps;
    outputCount_ ++;
    if(outputCount_ == outputIntervall) {
      stringstream fpsString;
      fpsString<<"user time: "<<fps<<"fps";
      glutSetWindowTitle(fpsString.str().c_str());
      outputCount_ = 0;
      if(fps>100) outputIntervall = (unsigned int) (fps/50.0);
      else {
        outputIntervall = 1;
      }
    }
    timeMeasureCount_ = 0;
    timeMeasure_.Reset();
  }
#endif
  glutSwapBuffers();
}

void BIAS::WhenIdle_()
{
  if(RegisteredContext->TimerExpired())
    RegisteredContext->Redisplay();
}


ContextGLUT::
ContextGLUT(int x0, int y0, int width, int height, 
            const std::string& name,
            const char* initDisplayString,
            int* commandLineArgc,
            char** commandLineArgv)
  : RenderContextBase()
{
  RegisteredContext = this;
  registeredGlutWindows.push_back(this);
  registrationIterator_ = registeredGlutWindows.end()-1;
  
  doubleClickInterval_ = 180;
  windowID_ = -1;
  if(registeredGlutWindows.size() == 1)
    InitContext_(initDisplayString, 
    commandLineArgc, 
    commandLineArgv);
  CreateWindow_(x0, y0, width, height, name);
}

ContextGLUT::
ContextGLUT(std::string gamemodestring, 
            const std::string& name,
            const char* initDisplayString,
            int* commandLineArgc,
            char** commandLineArgv)
  : RenderContextBase()
{
  if (gamemodestring.size()==0)
    gamemodestring = "1024x768:32";
  
  RegisteredContext = this;
  registeredGlutWindows.push_back(this);
  registrationIterator_ = registeredGlutWindows.end()-1;
  
  doubleClickInterval_ = 180;
  windowID_ = -1;
  if(registeredGlutWindows.size() == 1)
    InitContext_(initDisplayString, 
    commandLineArgc, 
    commandLineArgv);
  EnterGameMode_(gamemodestring);
}

ContextGLUT::
~ContextGLUT() 
{ 
  DestroyWindow_(); 
  RegisteredContext = NULL;
}


void ContextGLUT::
RegisterCallbacks_() const
{
  glutSetWindow(windowID_);
  glutReshapeFunc(Reshape_);
  glutMotionFunc(MouseMotionFunc_);
  glutPassiveMotionFunc(MousePassiveMotionFunc_);
  glutMouseFunc(MouseButtonFunc_);
  glutSpecialFunc(SpecialKeyFunc_);
  glutSpecialUpFunc(SpecialKeyUpFunc_);
  glutKeyboardFunc(StandardKeyFunc_);
  glutKeyboardUpFunc(StandardKeyUpFunc_);
  glutDisplayFunc(&Render_);
  glutIdleFunc(&WhenIdle_);
}

void ContextGLUT::
InitContext_(const char* initDisplayString,
             int* commandLineArgc, 
             char** commandLineArgv)
{
  if(commandLineArgc == NULL || commandLineArgv == NULL) {
    BIAS::GlutInitWrapper::GetInstance()->Init(); 
  } else
    BIAS::GlutInitWrapper::GetInstance()->Init(*commandLineArgc,commandLineArgv); 

  if (initDisplayString == NULL) {
    //string displayString = "double rgba alpha depth";
    //glutInitDisplayString(displayString.c_str());
    glutInitDisplayMode(GLUT_DOUBLE 
                        | GLUT_RGBA 
                        | GLUT_DEPTH 
                        | GLUT_ALPHA 
                        | GLUT_STENCIL
                        );
  } else
    glutInitDisplayString(initDisplayString);
}


void ContextGLUT::
CreateWindow_(int x0, int y0, int width, int height, 
              const std::string& name)
{
  if(windowID_ != -1) {
    BIASERR("ContextGLUT can only keep track of single window\n");
    return;
  }
  glutInitWindowPosition(x0, y0);
  glutInitWindowSize(width, height);
  windowID_ = glutCreateWindow(name.c_str());
  RegisterCallbacks_();

  GlewInitWrapper::GetInstance()->Init();
  gameMode_ = false;
}



void ContextGLUT::
DestroyWindow_()
{
  if(windowID_ != -1) {
    if (gameMode_) {
      if (glutGameModeGet(GLUT_GAME_MODE_ACTIVE) != 0)
        glutLeaveGameMode();
    } else {
      glutDestroyWindow(windowID_);
      registeredGlutWindows.erase(registrationIterator_);
      windowID_ = -1 ;
    }
  }
}

void ContextGLUT::
MakeGLContextCurrent()
{
  if(windowID_ != -1) {
    glutSetWindow(windowID_);

    RegisteredContext = this;//needed?
  }
}

void ContextGLUT::
Redisplay() 
{
 // glutSetWindow(windowID_);
 // glutPostRedisplay();

  if (gameMode_) {
    glutPostRedisplay();
  } else {
    glutPostWindowRedisplay(windowID_);
  }
}

bool active = false;
bool first = true;
void oneShotTimer(int interval) 
{
  //  cout<<"oneShotTimer..."<<endl;
  if(RegisteredContext->TimerExpired()) {
    //    cout<<"TimerExpired"<<endl;
    RegisteredContext->Redisplay();
  }
  RegisteredContext->SetTimer(interval);
}

void ContextGLUT::
SetTimer(unsigned int interval)
{
  if(first)
    active = true; //activated if SetTimer is called for the first time
  if(!first && !active) {
    first = true; //when deactivating next call to SetTimer will be the first?!
    return;//jumps out if not active!
  }
  glutTimerFunc(interval, &oneShotTimer, interval);    
  //  cout<<"after calling one shot!\n";
  first = false;    
}

void ContextGLUT::
DeactivateTimer()
{
  active = false;
}

void ContextGLUT::
EnterGameMode_(const string gamemodestring) {
  if(windowID_ != -1) {
    BIASERR("ContextGLUT can only keep track of single window\n");
    return;
  }
  glutGameModeString(gamemodestring.c_str());
  if (glutGameModeGet(GLUT_GAME_MODE_POSSIBLE)) { 
    BIASWARN("entering glut gamemode");
    glutEnterGameMode();
    windowID_ = glutGetWindow();
    RegisterCallbacks_();
  } else {
    BIASERR("Full Screen Mode not available: " << gamemodestring);
    BIASABORT;
  }

  GlewInitWrapper::GetInstance()->Init();
  gameMode_ = true;
}