$search

rtcRenderer.cpp

Go to the documentation of this file.

//== INCLUDES =============================================================
#include <cmath>
#include "rtc/rtcRenderManager.h"
#include "rtc/rtcRenderer.h"

//== CONSTANTS ============================================================
#define      DEFAULT_ZOOM_SENSITIVITY             0.2
#define      DEFAULT_ROTATE_SENSITIVITY           0.50
#define      DEFAULT_MOVE_SENSITIVITY             0.001
#define      DEFAULT_ZOOM_SENSITIVITY_2D          0.02
#define      DEFAULT_ROTATE_SENSITIVITY_2D        0.0050
#define      DEFAULT_MOVE_SENSITIVITY_2D          1.0

#define      DEFAULT_MIN_ZOOM_RANGE               0.5
#define      DEFAULT_CAMERA_FOV                   30.0
#define      DEFAULT_MIN_CLIP_RANGE               1.0
#define      DEFAULT_MAX_CLIP_RANGE               400.0

#define      KEY_ROTATE_AMOUNT                    5.0
#define      KEY_MOVE_AMOUNT                      10.0
#define      KEY_ZOOM_AMOUNT                      5.0

//Conversion factor for degrees to radians
#define D2R       0.0174532925199432957692
//Conversion factor for radians to degrees
#define R2D       57.295779513082320876

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

// Triangle vertices:
const int num_arrow_triangle_faces = 8;
const int num_arrow_triangle_vertices = num_arrow_triangle_faces*3;
const GLfloat arrow_triangle_vertices[num_arrow_triangle_vertices*3] = {
  0.000000f,0.040000f,-0.800000f,0.028284f,0.028284f,-0.800000f,
  0.000000f,0.000000f,-1.000000f,0.028284f,0.028284f,-0.800000f,
  0.040000f,0.000000f,-0.800000f,0.000000f,0.000000f,-1.000000f,
  0.040000f,0.000000f,-0.800000f,0.028284f,-0.028284f,-0.800000f,
  0.000000f,0.000000f,-1.000000f,0.028284f,-0.028284f,-0.800000f,
  0.000000f,-0.040000f,-0.800000f,0.000000f,0.000000f,-1.000000f,
  0.000000f,-0.040000f,-0.800000f,-0.028284f,-0.028284f,-0.800000f,
  0.000000f,0.000000f,-1.000000f,-0.028284f,-0.028284f,-0.800000f,
  -0.040000f,0.000000f,-0.800000f,0.000000f,0.000000f,-1.000000f,
  -0.040000f,0.000000f,-0.800000f,-0.028284f,0.028284f,-0.800000f,
  0.000000f,0.000000f,-1.000000f,-0.028284f,0.028284f,-0.800000f,
  0.000000f,0.040000f,-0.800000f,0.000000f,0.000000f,-1.000000f
};
const GLfloat arrow_triangle_normals[num_arrow_triangle_vertices*3] = {
  0.000000f,0.980581f,-0.196116f,0.693375f,0.693375f,-0.196116f,
  0.357407f,0.862856f,-0.357407f,0.693375f,0.693375f,-0.196116f,
  0.980581f,0.000000f,-0.196116f,0.862856f,0.357407f,-0.357407f,
  0.980581f,0.000000f,-0.196116f,0.693375f,-0.693375f,-0.196116f,
  0.862856f,-0.357407f,-0.357407f,0.693375f,-0.693375f,-0.196116f,
  0.000000f,-0.980581f,-0.196116f,0.357407f,-0.862856f,-0.357407f,
  0.000000f,-0.980581f,-0.196116f,-0.693375f,-0.693375f,-0.196116f,
  -0.357407f,-0.862856f,-0.357407f,-0.693375f,-0.693375f,-0.196116f,
  -0.980581f,0.000000f,-0.196116f,-0.862856f,-0.357407f,-0.357407f,
  -0.980581f,0.000000f,-0.196116f,-0.693375f,0.693375f,-0.196116f,
  -0.862856f,0.357407f,-0.357407f,-0.693375f,0.693375f,-0.196116f,
  0.000000f,0.980581f,-0.196116f,-0.357407f,0.862856f,-0.357407f
};

const int num_arrow_quad_faces = 16;
const int num_arrow_quad_vertices = num_arrow_quad_faces*4;
const GLfloat arrow_quad_vertices[num_arrow_quad_vertices*3] = {
  0.000000f,0.010000f,0.000000f,0.007000f,0.007000f,0.000000f,
  0.007000f,0.007000f,-0.800000f,0.000000f,0.010000f,-0.800000f,
  0.000000f,-0.010000f,0.000000f,-0.007000f,-0.007000f,0.000000f,
  -0.007000f,-0.007000f,-0.800000f,0.000000f,-0.010000f,-0.800000f,
  -0.007000f,-0.007000f,0.000000f,-0.010000f,0.000000f,0.000000f,
  -0.010000f,0.000000f,-0.800000f,-0.007000f,-0.007000f,-0.800000f,
  -0.010000f,0.000000f,0.000000f,-0.007000f,0.007000f,0.000000f,
  -0.007000f,0.007000f,-0.800000f,-0.010000f,0.000000f,-0.800000f,
  -0.007000f,0.007000f,0.000000f,0.000000f,0.010000f,0.000000f,
  0.000000f,0.010000f,-0.800000f,-0.007000f,0.007000f,-0.800000f,
  0.007000f,0.007000f,0.000000f,0.010000f,0.000000f,0.000000f,
  0.010000f,0.000000f,-0.800000f,0.007000f,0.007000f,-0.800000f,
  0.010000f,0.000000f,0.000000f,0.007000f,-0.007000f,0.000000f,
  0.007000f,-0.007000f,-0.800000f,0.010000f,0.000000f,-0.800000f,
  0.007000f,-0.007000f,0.000000f,0.000000f,-0.010000f,0.000000f,
  0.000000f,-0.010000f,-0.800000f,0.007000f,-0.007000f,-0.800000f,
  -0.007000f,0.007000f,-0.800000f,-0.028284f,0.028284f,-0.800000f,
  -0.040000f,0.000000f,-0.800000f,-0.010000f,0.000000f,-0.800000f,
  -0.010000f,0.000000f,-0.800000f,-0.040000f,0.000000f,-0.800000f,
  -0.028284f,-0.028284f,-0.800000f,-0.007000f,-0.007000f,-0.800000f,
  -0.007000f,-0.007000f,-0.800000f,-0.028284f,-0.028284f,-0.800000f,
  0.000000f,-0.040000f,-0.800000f,0.000000f,-0.010000f,-0.800000f,
  0.000000f,-0.010000f,-0.800000f,0.000000f,-0.040000f,-0.800000f,
  0.028284f,-0.028284f,-0.800000f,0.007000f,-0.007000f,-0.800000f,
  0.028284f,-0.028284f,-0.800000f,0.040000f,0.000000f,-0.800000f,
  0.010000f,0.000000f,-0.800000f,0.007000f,-0.007000f,-0.800000f,
  0.040000f,0.000000f,-0.800000f,0.028284f,0.028284f,-0.800000f,
  0.007000f,0.007000f,-0.800000f,0.010000f,0.000000f,-0.800000f,
  0.007000f,0.007000f,-0.800000f,0.028284f,0.028284f,-0.800000f,
  0.000000f,0.040000f,-0.800000f,0.000000f,0.010000f,-0.800000f,
  0.000000f,0.010000f,-0.800000f,0.000000f,0.040000f,-0.800000f,
  -0.028284f,0.028284f,-0.800000f,-0.007000f,0.007000f,-0.800000f
};
const GLfloat arrow_quad_normals[num_arrow_quad_vertices*3] = {
  0.000000f,1.000000f,0.000000f,0.707107f,0.707107f,0.000000f,
  0.707107f,0.707107f,0.000000f,0.000000f,1.000000f,0.000000f,
  0.000000f,-1.000000f,0.000000f,-0.707107f,-0.707107f,0.000000f,
  -0.707107f,-0.707107f,0.000000f,0.000000f,-1.000000f,0.000000f,
  -0.707107f,-0.707107f,0.000000f,-1.000000f,0.000000f,0.000000f,
  -1.000000f,0.000000f,0.000000f,-0.707107f,-0.707107f,0.000000f,
  -1.000000f,0.000000f,0.000000f,-0.707107f,0.707107f,0.000000f,
  -0.707107f,0.707107f,0.000000f,-1.000000f,0.000000f,0.000000f,
  -0.707107f,0.707107f,0.000000f,0.000000f,1.000000f,0.000000f,
  0.000000f,1.000000f,0.000000f,-0.707107f,0.707107f,0.000000f,
  0.707107f,0.707107f,0.000000f,1.000000f,0.000000f,0.000000f,
  1.000000f,0.000000f,0.000000f,0.707107f,0.707107f,0.000000f,
  1.000000f,0.000000f,0.000000f,0.707107f,-0.707107f,0.000000f,
  0.707107f,-0.707107f,0.000000f,1.000000f,0.000000f,0.000000f,
  0.707107f,-0.707107f,0.000000f,0.000000f,-1.000000f,0.000000f,
  0.000000f,-1.000000f,0.000000f,0.707107f,-0.707107f,0.000000f,
  0.000000f,0.000000f,1.000000f,0.000000f,0.000000f,1.000000f,
  0.000000f,0.000000f,1.000000f,0.000000f,0.000000f,1.000000f,
  0.000000f,0.000000f,1.000000f,0.000000f,0.000000f,1.000000f,
  0.000000f,0.000000f,1.000000f,0.000000f,0.000000f,1.000000f,
  0.000000f,0.000000f,1.000000f,0.000000f,0.000000f,1.000000f,
  0.000000f,0.000000f,1.000000f,0.000000f,0.000000f,1.000000f,
  0.000000f,0.000000f,1.000000f,0.000000f,0.000000f,1.000000f,
  0.000000f,0.000000f,1.000000f,0.000000f,0.000000f,1.000000f,
  0.000000f,0.000000f,1.000000f,0.000000f,0.000000f,1.000000f,
  0.000000f,0.000000f,1.000000f,0.000000f,0.000000f,1.000000f,
  0.000000f,0.000000f,1.000000f,0.000000f,0.000000f,1.000000f,
  0.000000f,0.000000f,1.000000f,0.000000f,0.000000f,1.000000f,
  0.000000f,0.000000f,1.000000f,0.000000f,0.000000f,1.000000f,
  0.000000f,0.000000f,1.000000f,0.000000f,0.000000f,1.000000f,
  0.000000f,0.000000f,1.000000f,0.000000f,0.000000f,1.000000f,
  0.000000f,0.000000f,1.000000f,0.000000f,0.000000f,1.000000f
};


//== IMPLEMENTATION =======================================================
// constructor
Renderer::Renderer(RenderManager* render_manager, int x, int y, int w, int h, const char *title)
:received_input(false), screen_shot_number(0), arrow_initialized(false)
{
  // initialize renderer
  initialize(render_manager,x,y,w,h,title);

  is_initialized = true;

  m_frame = 0;
  m_time = 0;
  m_timebase = 0;
  m_fps = 0;

  ilGenImages(1,&image_id);
  ilBindImage(image_id);
}

// constructor
Renderer::Renderer()
{
  is_initialized = false;
}

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

void Renderer::initialize(RenderManager* render_manager,
                          int x, int y,
                          int w, int h,
                          const char *title)
{
  float light_ambient[] = { 0, 0, 0, 0 };
  float light_diffuse[] = { 1, 1, 1, 1 };
  float light_specular[] = { 1, 1, 1, 1 };
  float light_position[] = { 0, 0, 100, 0 };
//  float light_ambient[] = {0.01, 0.01, 0.01, 1.00};
//  float light_diffuse[] = {0.65, 0.65, 0.65, 1.00};
//  float light_specular[] = {0.30, 0.30, 0.30, 1.00};
//  float light_position[] = { 0, 0, 100, 0 };

  camera_pose.state = IDLE;
  camera_pose.pan = 0;
  camera_pose.tilt = 0;
  camera_pose.distance = 10.0;
  camera_pose.x_offset = 0;
  camera_pose.y_offset = 0;
  camera_pose.z_offset = 0;

  camera_pose.x_offset_2D = 0;
  camera_pose.y_offset_2D = 0;
  camera_pose.rotation_2D = 0;
  camera_pose.zoom = 1;
  camera_pose.warp_x = 1;
  camera_pose.warp_y = 1;

  window_width = w;
  window_height = h;

  fps = 30;

  user_idle_func = NULL;
  user_timer_func = NULL;
  user_display_func = NULL;
  user_keyboard_func = NULL;
  user_mouse_func = NULL;
  user_motion_func = NULL;

  zoom_sensitivity = DEFAULT_ZOOM_SENSITIVITY;
  rotate_sensitivity = DEFAULT_ROTATE_SENSITIVITY;
  move_sensitivity = DEFAULT_MOVE_SENSITIVITY;
  min_zoom_range = DEFAULT_MIN_ZOOM_RANGE;
  camera_fov = DEFAULT_CAMERA_FOV;
  min_clip_range = DEFAULT_MIN_CLIP_RANGE;
  max_clip_range = DEFAULT_MAX_CLIP_RANGE;

  zoom_sensitivity_2D = DEFAULT_ZOOM_SENSITIVITY_2D;
  rotate_sensitivity_2D = DEFAULT_ROTATE_SENSITIVITY_2D;
  move_sensitivity_2D = DEFAULT_MOVE_SENSITIVITY_2D;

  /* setup the window */
  glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
  glutInitWindowSize(window_width, window_height);
  glutInitWindowPosition(x, y);

  // create window
  window_id = render_manager->createWindow(title,this);

  // clear color
  glClearColor(0, 0, 0, 0);

  // depth test
  glEnable(GL_DEPTH_TEST);

  // color
  glEnable(GL_COLOR_MATERIAL);
  glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);

  // transparency
  glEnable(GL_BLEND);
  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

  // shader
  glShadeModel(GL_SMOOTH);

  // light
  glEnable(GL_LIGHTING);
  glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
  glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
  glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
  glLightfv(GL_LIGHT0, GL_POSITION, light_position);
  glEnable(GL_LIGHT0);
  glEnable(GL_NORMALIZE);

  // Fog
//  GLfloat fogColor[4] = { 0.3, 0.3, 0.4, 1.0 };
//  glFogi(GL_FOG_MODE, GL_LINEAR);
//  glFogfv(GL_FOG_COLOR, fogColor);
//  glFogf(GL_FOG_DENSITY, 0.35);
//  glHint(GL_FOG_HINT, GL_DONT_CARE);
//  glFogf(GL_FOG_START, 5.0f);
//  glFogf(GL_FOG_END, 25.0f);
//  glEnable(GL_FOG);

  mode = GUI_MODE_3D;
}


//void Renderer::initialize()
//{
//  // Create dummy variables
//  char * argv[1];
//  argv[0] = "run";
//  int argc = 1;
//
//  // initialize gui3d
//  gui3D_initialize(argc, argv, 10, 10, 720, 480, 30.0);
//  gui3D_setInitialCameraPos(0.0, 0.0, 1.0, 0, 0, 1.5);
//  gui3D_setCameraParams(0.01, 0.3, 0.001, 0.009, 60, 0.4, 1000);
//
//
//}

void Renderer::setIdleFunc(idle_func idle)
{
  user_idle_func = idle;
}

void Renderer::setTimerFunc(timer_func timer)
{
  user_timer_func = timer;
}

void Renderer::setDisplayFunc(display_func display)
{
  user_display_func = display;
}

void Renderer::setKeyboardFunc(keyboard_func keyboard)
{
  user_keyboard_func = keyboard;
}

void Renderer::setMouseFunc(mouse_func mouse)
{
  user_mouse_func = mouse;
}

void Renderer::setMotionFunc(motion_func motion)
{
  user_motion_func = motion;
}

void Renderer::setPassiveMotionFunc(passive_motion_func passive_motion)
{
  user_passive_motion_func = passive_motion;
}

void Renderer::clear()
{

}

void Renderer::setRenderMode(eRenderMode render_mode)
{
  render_mode = render_mode;
}

eRenderMode Renderer::getRenderMode()
{
  return render_mode;
}

void Renderer::addRenderNode(RenderNode* node)
{
  render_nodes.push_back(node);
}

void Renderer::clearRenderNode()
{
  render_nodes.clear();
}

void Renderer::setCameraParams(double _zoom_sensitivity,
                               double _rotate_sensitivity,
                               double _move_sensitivity,
                               double _min_zoom_range,
                               double _camera_fov,
                               double _min_clip_range,
                               double _max_clip_range)
{
  zoom_sensitivity = _zoom_sensitivity;
  rotate_sensitivity = _rotate_sensitivity;
  move_sensitivity = _move_sensitivity;
  min_zoom_range = _min_zoom_range;
  camera_fov = _camera_fov;
  min_clip_range = _min_clip_range;
  max_clip_range = _max_clip_range;
  received_input = true;
}

void Renderer::set2DCameraParams(double _zoom_sensitivity,
                                 double _rotate_sensitivity,
                                 double _move_sensitivity)
{
  zoom_sensitivity_2D = _zoom_sensitivity;
  rotate_sensitivity_2D = _rotate_sensitivity;
  move_sensitivity_2D = _move_sensitivity;
  received_input = true;
}

void Renderer::rotate_camera(double dx, double dy)
{
  camera_pose.pan -= dx * rotate_sensitivity;
  camera_pose.tilt += dy * rotate_sensitivity;
  if(camera_pose.tilt < 0)
    camera_pose.tilt = 0;
  else if(camera_pose.tilt > 89.0)
    camera_pose.tilt = 89.0;
  //printf("pan %f tilt %f\n",camera_pose.pan,camera_pose.tilt);
  //if(camera_pose.tilt < 0)
  //  camera_pose.tilt = 360.0-camera_pose.tilt;
  //else if(camera_pose.tilt > 360.0)
  //  camera_pose.tilt = camera_pose.tilt-360.0;

}

void Renderer::zoom_camera(double dy)
{
  if (dy>0) camera_pose.distance = camera_pose.distance / (1 + zoom_sensitivity_2D * dy);
  else camera_pose.distance = camera_pose.distance * ( 1 - dy * zoom_sensitivity_2D);

  if(camera_pose.distance < min_zoom_range)
    camera_pose.distance = min_zoom_range;
}

void Renderer::move_camera(double dx, double dy)
{
  camera_pose.x_offset += -dy * cos(D2R*(camera_pose.pan)) * move_sensitivity * camera_pose.distance;
  camera_pose.y_offset += -dy * sin(D2R*(camera_pose.pan)) * move_sensitivity * camera_pose.distance;
  camera_pose.x_offset += dx * cos(D2R*(camera_pose.pan - 90.0)) * move_sensitivity * camera_pose.distance;
  camera_pose.y_offset += dx * sin(D2R*(camera_pose.pan - 90.0)) * move_sensitivity * camera_pose.distance;
}

void Renderer::move_camera_2D(double dx, double dy)
{
  double tempx, tempy;

  tempx = dx / (float)camera_pose.zoom;
  tempy = -dy / (float)camera_pose.zoom;

  camera_pose.x_offset_2D -=
    (tempx * cos(-camera_pose.rotation_2D) -
    tempy * sin(-camera_pose.rotation_2D)) /
    camera_pose.warp_x * move_sensitivity_2D;
  camera_pose.y_offset_2D -=
    (tempx * sin(-camera_pose.rotation_2D) +
    tempy * cos(-camera_pose.rotation_2D)) /
    camera_pose.warp_y * move_sensitivity_2D;
}

void Renderer::rotate_camera_2D(double dx)
{
  camera_pose.rotation_2D += dx * rotate_sensitivity_2D;
}

void Renderer::zoom_camera_2D(double dx)
{
  if (dx>0) camera_pose.zoom = camera_pose.zoom * (1 + zoom_sensitivity_2D * dx);
  else camera_pose.zoom = camera_pose.zoom / ( 1 - dx * zoom_sensitivity_2D);
  if(camera_pose.zoom > float(1e7))
    camera_pose.zoom = float(1e7);
  if(camera_pose.zoom < float(1e-12))
    camera_pose.zoom = float(1e-12);
}


void Renderer::setMode2D(void)
{
  mode = GUI_MODE_2D;
}

void Renderer::setMode3D(void)
{
  mode = GUI_MODE_3D;
}

int Renderer::getMode(void)
{
  return mode;
}

void Renderer::setMode(int _mode)
{
  mode = _mode;
}

void Renderer::switchTo2DMode(void) {
  setDisplayMode2D(window_width, window_height);
  /* do camera control */
  glTranslatef(window_width / 2.0, window_height / 2.0, 0.0);
  glScalef(camera_pose.zoom, camera_pose.zoom, 1.0);
  glRotatef(R2D*(camera_pose.rotation_2D), 0, 0, 1);
  glScalef(camera_pose.warp_x, camera_pose.warp_y, 1);
  glTranslatef(-camera_pose.x_offset_2D, -camera_pose.y_offset_2D, 0.0);
}

void Renderer::switchTo3DMode(void)
{
  float cpan, ctilt, camera_x, camera_y, camera_z;

  /* setup camera view */
  cpan = camera_pose.pan * M_PI / 180.0;
  ctilt = camera_pose.tilt * M_PI / 180.0;
  camera_x = camera_pose.distance * cos(cpan) * cos(ctilt);
  camera_y = camera_pose.distance * sin(cpan) * cos(ctilt);
  camera_z = camera_pose.distance * sin(ctilt);
  setDisplayMode3D(window_width, window_height, camera_fov, min_clip_range, max_clip_range);
  glViewport(0, 0, (GLsizei)window_width, (GLsizei)window_height);
  gluLookAt(camera_x + camera_pose.x_offset,
            camera_y + camera_pose.y_offset,
            camera_z + camera_pose.z_offset,
            camera_pose.x_offset,
            camera_pose.y_offset,
            camera_pose.z_offset,
            0, 0, 1);
}


void Renderer::setInitialCameraPos(double pan, double tilt, double range,
                                   double x_offset, double y_offset,
                                   double z_offset)
{
  camera_pose.pan = pan;
  camera_pose.tilt = tilt;
  camera_pose.distance = range;
  camera_pose.x_offset = x_offset;
  camera_pose.y_offset = y_offset;
  camera_pose.z_offset = z_offset;
}

void Renderer::setInitial2DCameraPos(double x_offset, double y_offset,
                                     double rotation, double zoom)
{
  camera_pose.x_offset_2D = x_offset;
  camera_pose.y_offset_2D = y_offset;
  camera_pose.rotation_2D = rotation;
  camera_pose.zoom = zoom;
}

//void Renderer::add_timerFunc(unsigned int msecs, void (*func)(int value),
//                             int value)
//{
//  glutTimerFunc(msecs, func, value);
//}

void Renderer::forceRedraw(void)
{
  received_input = true;
}

void Renderer::set2DWarping(double warp_x, double warp_y)
{
  camera_pose.warp_x = warp_x;
  camera_pose.warp_y = warp_y;
}

void Renderer::recenter(void)
{
  camera_pose.x_offset = 0;
  camera_pose.y_offset = 0;
  camera_pose.z_offset = 0;
}

void Renderer::recenter2D(void)
{
  camera_pose.x_offset_2D = 0;
  camera_pose.y_offset_2D = 0;
}

void Renderer::pickPoint(int mouse_x, int mouse_y, double *scene_x, double *scene_y)
{
  double cx = window_width / 2.0;
  double cy = window_height / 2.0;
  double pan = D2R*(-90.0 - camera_pose.pan);
  double tilt = D2R*(90.0 - camera_pose.tilt);
  double d = camera_pose.distance;
  double f = cy / tan(D2R*(camera_fov / 2.0));

  // from Matlab
  double px = (mouse_x - cx) * cos(tilt) * d / (cos(tilt) * f + sin(tilt) * mouse_y - sin(tilt) * cy);
  double py = -(mouse_y - cy) * d / (cos(tilt) * f + sin(tilt) * mouse_y - sin(tilt) * cy);

  // rotate by pan, add offset
  *scene_x =  px * cos(pan) + py * sin(pan) + camera_pose.x_offset;
  *scene_y = -px * sin(pan) + py * cos(pan) + camera_pose.y_offset;
}

void Renderer::get2DPosition(int x, int y, double *xout, double *yout)
{
  double dx, dy, ctheta, stheta;

  dx = (x - window_width / 2.0 - GLUI_x_offset) / camera_pose.zoom;
  dy = (window_height / 2.0 - y + GLUI_y_offset) / camera_pose.zoom;
  ctheta = cos(-camera_pose.rotation_2D);
  stheta = sin(-camera_pose.rotation_2D);
  *xout = camera_pose.x_offset_2D + ctheta * dx - stheta * dy;
  *yout = camera_pose.y_offset_2D + stheta * dx + ctheta * dy;
}

void Renderer::get3DPosition(double x, double y, double z, double *xout, double *yout, double *zout)
{
  GLint viewport[4];
  GLdouble modelview[16];
  GLdouble projection[16];
  glGetIntegerv(GL_VIEWPORT,viewport);
  glGetDoublev(GL_MODELVIEW_MATRIX,modelview);
  glGetDoublev(GL_PROJECTION_MATRIX,projection);
  gluUnProject(x,y,z,modelview,projection,viewport,xout,yout,zout);
}

void Renderer::setDisplayMode2D(int w, int h)
{
  glDisable(GL_DEPTH_TEST);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluOrtho2D(0.0, (GLfloat)w, 0.0, (GLfloat)h);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
}

void Renderer::setDisplayMode3D(int w, int h, float fovy, float zNear, float zFar)
{
  glEnable(GL_DEPTH_TEST);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective(fovy, w / (float)h, zNear, zFar);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
}

// --------------------------------------------------
// Renderer callbacks
// --------------------------------------------------

void Renderer::special(int key, int x, int y)
{
  int mod;
  double dx = 0, dy = 0;

  mod = glutGetModifiers();
  if(mode == GUI_MODE_3D) {
    if(mod & GLUT_ACTIVE_CTRL) {
      switch(key) {
      case GLUT_KEY_LEFT:
        dx = -KEY_ROTATE_AMOUNT;
        dy = 0;
        break;
      case GLUT_KEY_RIGHT:
        dx = KEY_ROTATE_AMOUNT;
        dy = 0;
        break;
      case GLUT_KEY_UP:
        dx = 0;
        dy = KEY_ROTATE_AMOUNT;
        break;
      case GLUT_KEY_DOWN:
        dx = 0;
        dy = -KEY_ROTATE_AMOUNT;
        break;
      }
      if(dx != 0 || dy != 0)
        rotate_camera(dx, dy);
    }
    else if(mod & GLUT_ACTIVE_ALT) {
      switch(key) {
      case GLUT_KEY_UP:
        dy = KEY_ZOOM_AMOUNT;
        break;
      case GLUT_KEY_DOWN:
        dy = -KEY_ZOOM_AMOUNT;
        break;
      }
      if(dy != 0)
        zoom_camera(dy);
    }
    else {
      switch(key) {
      case GLUT_KEY_LEFT:
        dx = KEY_MOVE_AMOUNT;
        dy = 0;
        break;
      case GLUT_KEY_RIGHT:
        dx = -KEY_MOVE_AMOUNT;
        dy = 0;
        break;
      case GLUT_KEY_UP:
        dx = 0;
        dy = KEY_MOVE_AMOUNT;
        break;
      case GLUT_KEY_DOWN:
        dx = 0;
        dy = -KEY_MOVE_AMOUNT;
        break;
      }
      if(dx != 0 || dy != 0)
        move_camera(dx, dy);
    }
  }
  else {
    if(mod & GLUT_ACTIVE_CTRL) {
      switch(key) {
      case GLUT_KEY_LEFT:
        dx = KEY_ROTATE_AMOUNT;
        dy = 0;
        break;
      case GLUT_KEY_RIGHT:
        dx = -KEY_ROTATE_AMOUNT;
        dy = 0;
        break;
      }
      if(dx != 0)
        rotate_camera_2D(dx);
    }
    else if(mod & GLUT_ACTIVE_ALT) {
      switch(key) {
      case GLUT_KEY_UP:
        dy = KEY_ZOOM_AMOUNT;
        break;
      case GLUT_KEY_DOWN:
        dy = -KEY_ZOOM_AMOUNT;
        break;
      }
      if(dy != 0)
        zoom_camera_2D(dy);
    }
    else {
      switch(key) {
      case GLUT_KEY_LEFT:
        dx = KEY_MOVE_AMOUNT;
        dy = 0;
        break;
      case GLUT_KEY_RIGHT:
        dx = -KEY_MOVE_AMOUNT;
        dy = 0;
        break;
      case GLUT_KEY_UP:
        dx = 0;
        dy = KEY_MOVE_AMOUNT;
        break;
      case GLUT_KEY_DOWN:
        dx = 0;
        dy = -KEY_MOVE_AMOUNT;
        break;
      }
      if(dx != 0 || dy != 0)
        move_camera_2D(dx, dy);
    }
  }
  received_input = true;
}

void Renderer::keyboard(unsigned char key, int x, int y)
{
  received_input = true;
  if(user_keyboard_func)
    user_keyboard_func(key, x, y);
}

void Renderer::mouse(int button, int state, int x, int y)
{
  if(state == GLUT_DOWN) {
    last_mouse_x = x;
    last_mouse_y = y;
    if(button == GLUT_LEFT_BUTTON)
      camera_pose.state = ROTATING;
    else if(button == GLUT_MIDDLE_BUTTON)
      camera_pose.state = MOVING;
    else if(button == GLUT_RIGHT_BUTTON)
      camera_pose.state = ZOOMING;
  }
  else if(state == GLUT_UP)
    camera_pose.state = IDLE;

  received_input = true;
  if(user_mouse_func)
    user_mouse_func(button, state, x, y);
}

void Renderer::motion(int x, int y)
{
  int dx, dy;

  dx = x - last_mouse_x;
  dy = y - last_mouse_y;

  if(mode == GUI_MODE_3D) {
    if(camera_pose.state == ROTATING)
      rotate_camera(dx, dy);
    else if(camera_pose.state == MOVING)
      move_camera(dx, dy);
    else if(camera_pose.state == ZOOMING)
      zoom_camera(dy);
  }
  else if(mode == GUI_MODE_2D) {
    if(camera_pose.state == ROTATING) {
      //      if(y < window_height / 2)
      //        dx *= -1;

      if(x > window_width / 2)
        dy *= -1;

      rotate_camera_2D(dx);
    }
    else if(camera_pose.state == MOVING)
      move_camera_2D(dx, dy);
    else if(camera_pose.state == ZOOMING)
      zoom_camera_2D(dy);
  }

  last_mouse_x = x;
  last_mouse_y = y;

  received_input = true;

  if(user_motion_func)
    user_motion_func(x, y);
}

void Renderer::reshape(int w, int h)
{
  int tx = 0, ty = 0, tw = w, th = h;

  GLUI_Master.get_viewport_area(&tx, &ty, &tw, &th);
  GLUI_x_offset = tx;
  GLUI_y_offset = (h - th) - ty;
  glViewport(tx, ty, tw, th);

  window_width = tw;
  window_height = th;

  if(mode == GUI_MODE_3D)
    setDisplayMode3D(tw, th, camera_fov, min_clip_range,
    max_clip_range);
  else if(mode == GUI_MODE_2D)
    setDisplayMode2D(tw, th);
}

void Renderer::display()
{
  glutSetWindow(window_id);

  // clear GL buffers
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  if(mode == GUI_MODE_3D) {
    /* setup camera view */
    switchTo3DMode();
  }
  else if(mode == GUI_MODE_2D) {
    switchTo2DMode();
  }

  // render all nodes in the list
  glColor3f(1,1,1);
  int mode_save = mode;
  TRenderNodeList::iterator it, it_end;
  for(it=render_nodes.begin(), it_end=render_nodes.end();it!=it_end;++it)
  {
    (*it)->preRender();
    (*it)->render();
    (*it)->postRender();
  }
  mode = mode_save;

  // call user defined display function
  if(user_display_func)
    user_display_func();

  // calculate fps
  m_frame++;
  m_time=glutGet(GLUT_ELAPSED_TIME);
  if (m_time - m_timebase > 1000)
  {
    m_fps = m_frame*1000.0/(m_time-m_timebase);
    m_timebase = m_time;
    m_frame = 0;
  }

  // draw the 2D graphics
  //char str[200];
  //setDisplayMode2D(window_width, window_height);
  //glColor3f(1, 1, 0);
  //sprintf(str, "%6f fps", m_fps);
  //renderBitmapString(10, 10, GLUT_BITMAP_HELVETICA_18, str);

  // flush gl and swap buffers
  glFlush();
  glutSwapBuffers();
}

void Renderer::passive_motion(int x, int y)
{

}

void Renderer::visibility(int visible)
{

}

void Renderer::timer()
{
  if(received_input) {
    glutSetWindow(window_id);
    glutPostRedisplay();
    received_input = false;
  }
  if (user_timer_func)
    user_timer_func();
}

void Renderer::idle()
{
  if (user_idle_func)
    user_idle_func();
}

camera_pose_p Renderer::getCameraPose()
{
  return &camera_pose;
}

void Renderer::setCameraPose(camera_pose_t camera_pose)
{
  camera_pose = camera_pose;
}

int Renderer::getWindowId()
{
  return window_id;
}

int Renderer::getWindowWidth()
{
  return window_width;
}

int Renderer::getWindowHeight()
{
  return window_height;
}

void Renderer::renderBitmapString(float x, float y, void *font, char *string)
{
  char *c;

  glPushMatrix();
  glRasterPos2d(x, y);
  for(c = string; *c != '\0'; c++)
    glutBitmapCharacter(font, *c);
  glPopMatrix();
}

int Renderer::bitmapStringWidth(void *font, char *string)
{
  int width = 0;
  char *c;

  for(c = string; *c != '\0'; c++)
    width += glutBitmapWidth(font, *c);
  return width;
}

void Renderer::renderBitmapString3D(float x, float y, float z, void *font, char *string)
{
  char *c;

  glPushMatrix();
  glRasterPos3d(x, y, z);
  glBitmap(0, 0, 0, 0, -bitmapStringWidth(font, string) / 2.0, 0, NULL);

  for(c = string; *c != '\0'; c++)
    glutBitmapCharacter(font, *c);
  glPopMatrix();
}

void Renderer::renderBitmapStringCentered(float x, float y, void *font, char *string)
{
  char *c;
  int vert_offset = -5;

  glPushMatrix();
  glRasterPos2d(x, y);
  if(font == GLUT_BITMAP_HELVETICA_18)
    vert_offset = -7;
  else if(font == GLUT_BITMAP_HELVETICA_12)
    vert_offset = -4;
  else if(font == GLUT_BITMAP_HELVETICA_10)
    vert_offset = -3;
  glBitmap(0, 0, 0, 0,
           -bitmapStringWidth(font, string) / 2.0, vert_offset, NULL);
  for(c = string; *c != '\0'; c++)
    glutBitmapCharacter(font, *c);
  glPopMatrix();
}

// take a screenshot
void Renderer::takeScreenShot(const char *filename)
{
  ilutRenderer(ILUT_OPENGL);
  ilutGLScreen();
  ilEnable(IL_FILE_OVERWRITE);
  ilSaveImage((const ILstring)filename);
  screen_shot_number++;
}

void Renderer::takeScreenShot()
{
  char buf[255];
  sprintf(buf,"screenshot_%03d.png",screen_shot_number);
  takeScreenShot(buf);
}


void Renderer::initializeArrow()
{
  if (!GLEW_ARB_vertex_buffer_object)
  {
    arrow_initialized = true;
    return;
  }

  glGenBuffersARB(1, &arrow_triangle_vertices_vbo);
  glBindBufferARB(GL_ARRAY_BUFFER_ARB, arrow_triangle_vertices_vbo);
  glBufferDataARB(GL_ARRAY_BUFFER_ARB, num_arrow_triangle_vertices*3*sizeof(GLfloat), arrow_triangle_vertices, GL_STATIC_DRAW_ARB);

  glGenBuffersARB(1, &arrow_triangle_normals_vbo);
  glBindBufferARB(GL_ARRAY_BUFFER_ARB, arrow_triangle_normals_vbo);
  glBufferDataARB(GL_ARRAY_BUFFER_ARB, num_arrow_triangle_vertices*3*sizeof(GLfloat), arrow_triangle_normals, GL_STATIC_DRAW_ARB);

  glGenBuffersARB(1, &arrow_quad_vertices_vbo);
  glBindBufferARB(GL_ARRAY_BUFFER_ARB, arrow_quad_vertices_vbo);
  glBufferDataARB(GL_ARRAY_BUFFER_ARB, num_arrow_quad_vertices*3*sizeof(GLfloat), arrow_quad_vertices, GL_STATIC_DRAW_ARB);

  glGenBuffersARB(1, &arrow_quad_normals_vbo);
  glBindBufferARB(GL_ARRAY_BUFFER_ARB, arrow_quad_normals_vbo);
  glBufferDataARB(GL_ARRAY_BUFFER_ARB, num_arrow_quad_vertices*3*sizeof(GLfloat), arrow_quad_normals, GL_STATIC_DRAW_ARB);

  glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
  arrow_initialized = true;
};

// Draw an X-Y-Z Frame. The red arrow corresponds to the X-Axis,
// green to the Y-Axis, and blue to the Z-Axis.
void Renderer::drawCoordinateFrame(double scale)
{
  double a_axisThicknessScale = 3*scale;

  // initialize vertex buffer objects
  if(!arrow_initialized)
    initializeArrow();

  // Set up nice color-tracking
  glEnable(GL_COLOR_MATERIAL);
  glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

  int k;
  for(k=0; k<3; k++) {

    glPushMatrix();

    // Rotate to the appropriate axis
    if (k==0) {
      glRotatef(-90.0,0,1,0);
      glColor3f(1.0f,0.0f,0.0f);
    }
    else if (k==1) {
      glRotatef(90.0,1,0,0);
      glColor3f(0.0f,1.0f,0.0f);
    }
    else {
      glRotatef(180.0,1,0,0);
      glColor3f(0.0f,0.0f,1.0f);
    }

    glScaled(a_axisThicknessScale,a_axisThicknessScale,scale);

    if (!GLEW_ARB_vertex_buffer_object)
    {
      glBegin(GL_TRIANGLES);
      for (int i=0;i<num_arrow_triangle_vertices;i++)
      {
        glVertex3d(arrow_triangle_vertices[i*3],arrow_triangle_vertices[i*3+1],arrow_triangle_vertices[i*3+2]);
        glNormal3d(arrow_triangle_normals[i*3],arrow_triangle_normals[i*3+1],arrow_triangle_normals[i*3+2]);
      }
      glEnd();

      glBegin(GL_QUADS);
      for (int i=0;i<num_arrow_quad_vertices;i++)
      {
        glVertex3d(arrow_quad_vertices[i*3],arrow_quad_vertices[i*3+1],arrow_quad_vertices[i*3+2]);
        glNormal3d(arrow_quad_normals[i*3],arrow_quad_normals[i*3+1],arrow_quad_normals[i*3+2]);
      }
      glEnd();
    }
    else
    {
      glEnableClientState(GL_NORMAL_ARRAY);
      glEnableClientState(GL_VERTEX_ARRAY);
      glBindBufferARB(GL_ARRAY_BUFFER_ARB, arrow_triangle_vertices_vbo);
      glVertexPointer(3, GL_FLOAT, 0, 0);
      glBindBufferARB(GL_ARRAY_BUFFER_ARB, arrow_triangle_normals_vbo);
      glNormalPointer(GL_FLOAT, 0, 0);
      glDrawArrays(GL_TRIANGLES, 0, num_arrow_triangle_vertices);

      glBindBufferARB(GL_ARRAY_BUFFER_ARB, arrow_quad_vertices_vbo);
      glVertexPointer(3, GL_FLOAT, 0, 0);
      glBindBufferARB(GL_ARRAY_BUFFER_ARB, arrow_quad_normals_vbo);
      glNormalPointer(GL_FLOAT, 0, 0);
      glDrawArrays(GL_QUADS, 0, num_arrow_quad_vertices);

      glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);

      glDisableClientState(GL_NORMAL_ARRAY);
      glDisableClientState(GL_VERTEX_ARRAY);
    }

    glPopMatrix();
  }
}

void Renderer::drawGrid(double center_x, double center_y, int size, double resolution) const
{
  double grid_x, grid_y;
  double size_2=(double)size/2.0;

  glLineWidth(0.5);
  glEnable(GL_BLEND);
  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

  glEnable(GL_LINE_SMOOTH);
  glBegin(GL_LINES);
  for(grid_x = -size_2; grid_x < size_2; grid_x+=resolution) {
    glVertex3f(grid_x - center_x, -size_2 - center_y, 0);
    glVertex3f(grid_x - center_x,  size_2 - center_y, 0);
  }
  for(grid_y = -size_2; grid_y < size_2; grid_y+=resolution) {
    glVertex3f(-size_2 - center_x, grid_y - center_y, 0);
    glVertex3f( size_2 - center_x, grid_y - center_y, 0);
  }
  glEnd();
  glDisable(GL_LINE_SMOOTH);
  glDisable(GL_BLEND);
}

void Renderer::drawDashedLine3D(double x1, double y1, double z1, double x2, double y2, double z2, double stripe_len) const
{
  double frac, dx, dy, dz, x, y, z;
  int i;

  frac = stripe_len / sqrt(rtc_sqr(x2-x1)+rtc_sqr(y2-y1)+rtc_sqr(z2-z1));
  dx = frac * (x2 - x1);
  dy = frac * (y2 - y1);
  dz = frac * (z2 - z1);
  x = x1;
  y = y1;
  z = z1;
  glBegin(GL_LINES);
  for(i = 0; i < (int)floor(1 / frac); i++) {
    if(i % 2 == 0) {
      glVertex3f(x, y, z);
      glVertex3f(x + dx, y + dy, z + dz);
    }
    x += dx;
    y += dy;
    z += dz;
  }
  glEnd();
}

Vec3d Renderer::unProject(double winx, double winy, double winz)
{
  Vec3d pos;
  GLint viewport[4];
  GLdouble modelview[16];
  GLdouble projection[16];
  glGetDoublev( GL_MODELVIEW_MATRIX, modelview );
  glGetDoublev( GL_PROJECTION_MATRIX, projection );
  glGetIntegerv( GL_VIEWPORT, viewport );
  gluUnProject( winx, winy, winz, modelview, projection, viewport, &pos[0], &pos[1], &pos[2]);
  return pos;
}

void Renderer::setRasterPos(double winx, double winy, double winz)
{
  Vec3d pos=unProject(winx,winy,winz);
  glRasterPos3dv(pos.x);
}

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

---

rtc
Author(s): Benjamin Pitzer
autogenerated on Sun Mar 3 11:08:04 2013