rtcRenderManager.cpp

Go to the documentation of this file.

//== INCLUDES ==================================================================
#include <cmath>
#include <IL/il.h>
#include <IL/ilu.h>
#include <IL/ilut.h>
#include "rtc/rtcRenderer.h"
#include "rtc/rtcRenderManager.h"

//== NAMESPACES ===============================================================
namespace rtc {

Renderer* renderers[MAX_NUMBER_OF_RENDERERS];

int RenderManager::m_currentIdleRenderer = 0;
int RenderManager::m_idleFunctionEnabled = 0;
static int use_glui = 1;

//== IMPLEMENTATION ============================================================

// --------------------------------------------------
// RenderManager
// --------------------------------------------------

// constructor
RenderManager::RenderManager(int* argc, char **argv)
{
  // initialize il
  ilInit();
  iluInit();
  ilutRenderer(ILUT_OPENGL);
  // initialize glut
  glutInit(argc, argv);
}

// destructor
RenderManager::~RenderManager()
{
}

void RenderManager::callbackDisplayFunc(void)
{
//  int windowID = glutGetWindow();
  renderers[0]->display();
}

void RenderManager::callbackIdleFunc(void)
{
  if(m_idleFunctionEnabled && m_currentIdleRenderer){
    glutSetWindow(m_currentIdleRenderer);
    //TODO: implement idle callback
    //renderers[m_currentIdleRenderer]->idle();
  }
  renderers[0]->idle();
}

void RenderManager::callbackKeyboardFunc(unsigned char key, int x, int y)
{
//  int windowID = glutGetWindow();
  renderers[0]->keyboard(key, x, y);
}

void RenderManager::callbackMotionFunc(int x, int y)
{
//  int windowID = glutGetWindow();
  renderers[0]->motion(x, y);
}

void RenderManager::callbackMouseFunc(int button, int state, int x, int y)
{
//  int windowID = glutGetWindow();
  renderers[0]->mouse(button, state, x, y);
}

void RenderManager::callbackPassiveMotionFunc(int x, int y)
{
//  int windowID = glutGetWindow();
  renderers[0]->passive_motion(x, y);
}

void RenderManager::callbackReshapeFunc(int w, int h)
{
//  int windowID = glutGetWindow();
  renderers[0]->reshape(w, h);
}

void RenderManager::callbackSpecialFunc(int key, int x, int y)
{
//  int windowID = glutGetWindow();
  renderers[0]->special(key, x, y);
}

void RenderManager::callbackVisibilityFunc(int visible)
{
//  int windowID = glutGetWindow();
  renderers[0]->visibility(visible);
}

void RenderManager::callbackTimerFunc(int value)
{
//  int windowID = glutGetWindow();
  renderers[0]->timer();
  glutTimerFunc((int)floor(1000.0 / 30.0), callbackTimerFunc, 0);
}

int RenderManager::createWindow(const char* title, Renderer* renderer)
{
  // Open new window, record its windowID ,
  int windowID = glutCreateWindow(title);

  // Initialize glew
  GLenum err = glewInit();
  if (GLEW_OK != err) {
    printf("Error: %s\n", glewGetErrorString(err));
    exit(0);
  }

  fprintf(stdout, "Status: Using GLEW %s\n", glewGetString(GLEW_VERSION));

  // Store the address of new window in global array
  // so RenderManager can send events to propoer callback functions.
  renderers[0] = renderer;

  // Hand address of universal static callback functions to Glut.
  // This must be for each new window, even though the address are constant.
  if(use_glui) {
      GLUI_Master.set_glutKeyboardFunc(callbackKeyboardFunc);
      GLUI_Master.set_glutSpecialFunc(callbackSpecialFunc);
      GLUI_Master.set_glutMouseFunc(callbackMouseFunc);
      GLUI_Master.set_glutReshapeFunc(callbackReshapeFunc);
      // Do not uncomment this line.  It causes CPU usage to go to
      // 100 %
      //GLUI_Master.set_glutIdleFunc(callbackIdleFunc);
  }
  else {
    glutReshapeFunc(callbackReshapeFunc);
    glutSpecialFunc(callbackSpecialFunc);
    glutKeyboardFunc(callbackKeyboardFunc);
    glutMouseFunc(callbackMouseFunc);
  }

  glutDisplayFunc(callbackDisplayFunc);
  glutIdleFunc(callbackIdleFunc);
  glutMotionFunc(callbackMotionFunc);
  //glutPassiveMotionFunc(callbackPassiveMotionFunc);
  //glutVisibilityFunc(callbackVisibilityFunc);
  glutTimerFunc((int)floor(1000.0 / 30.0), callbackTimerFunc, 0);

  return windowID;
}

void RenderManager::dispatch(void)
{
  glutMainLoop();
}

void RenderManager::disableIdleFunction(void)
{
  m_idleFunctionEnabled = 0;
}

void RenderManager::enableIdleFunction(void)
{
  m_idleFunctionEnabled = 1;
}

int RenderManager::idleFunctionEnabled(void)
{
  // Is idle function enabled?
  return(m_idleFunctionEnabled);
}

int RenderManager::idleSetToCurrentWindow(void)
{
  // Is current idle window same as current window?
  return( m_currentIdleRenderer == glutGetWindow() );
}

void RenderManager::setIdleToCurrentWindow(void)
{
  m_currentIdleRenderer = glutGetWindow();
}

//==============================================================================
} // namespace rtc
//==============================================================================