ui_SceneView.cpp

Go to the documentation of this file.

#include "ui_SceneView.hpp"
#include "Scene.hpp"
#include <iostream>

static double sDefaultZoom;

SceneView::SceneView(ProjectionType pt) 
: mProjection(pt)
, mLookAt()
, mpScene(0)
, mDragButton(-1)
, mDragBase(-1,-1) 
, mDirection(0,0,-1)
, mpCaptureRayMotionTarget(0)
, mpZoom(&sDefaultZoom)
, mCameraOffset( Point3d(0,0,0) )
{ 
}

void SceneView::setViewport(const Vec4i& vp)
{
  View::setViewport(vp);
  mProjection.setAspect( double( width() ) / double( height() ) );  
}

  void SceneView::setProjectionViewWidth(double w) 
  { 
    setProjectionViewSize( Vec2d(w,w/mProjection.getAspect() ) ); 
  }

  void SceneView::setProjectionViewHeight(double h) 
  { 
    setProjectionViewSize( Vec2d(h*mProjection.getAspect(),h) ); 
  }


void SceneView::setupLights()
{
  glMatrixMode(GL_MODELVIEW);
  GLfloat position[4] = { 0.0,0.0,10.0,1.0 };
  glLightfv(GL_LIGHT0, GL_POSITION, position);
  GLfloat ambient[4] = { 1.0,1.0,1.0,1.0 };
  glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
}

void SceneView::display()
{
  if ( (width() <= 0) || (height() <= 0) ) return;

  View::display();

  if (mpScene)
  {
    mProjection.computeTransform();
    glMatrixMode(GL_PROJECTION);
    glLoadMatrixd( mProjection.getTransformMatrix().getData() );

    glMatrixMode(GL_TEXTURE);
    glLoadIdentity();
    double a = 1.0/(*mpZoom);
    glScaled( a, a, a );

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();    

    setupLights();

    if (mpFocusPoint)
      setCenter( *mpFocusPoint );
  
    mLookAt.computeTransform();
    mLookAt.computeInverse();
    glLoadMatrixd( mLookAt.getTransformMatrix().getData() );   


    mpScene->display();
  }
}

Point3d SceneView::unprojectPoint(const Point3d& p)
{
  Point3d result;
  int success = 0;

  success = gluUnProject(
    p[0],p[1], p[2]
  , mLookAt.getTransformMatrix().getData()
  , mProjection.getTransformMatrix().getData()
  , &mViewport[0]
  , &result[0], &result[1], &result[2]
  );

  if (!success)
  {
    std::cerr << "error: SceneView::unprojectPoint : gluUnProject failed\n";
  }

  return result;
}

Rayd SceneView::makeRay(int x, int y)
{
  Point3d p1 = unprojectPoint( Point3d(x,y,0) );
  Point3d p2 = unprojectPoint( Point3d(x,y,1) );
  Vec3d d(p2-p1);
  return Rayd(p1, makeNormal(d) );
}

Rayd SceneView::makeRay(Point2i sp)
{
  return makeRay(sp[0],sp[1]);
}

// --- user-input ----------------------------------------------------------


void SceneView::mouse(int button, int state, int x, int y)
{   
  if (state == GLUT_DOWN)
  {
    mDragButton = button;
    mDragBase   = Vec2i(x,y);
    dragBegin();
    if (button == GLUT_LEFT_BUTTON)
    {
      mpScene->select( makeRay(x,y), *this );
    }
  } 
  else
  {
    dragEnd();
    mDragButton = -1;      
    mDragBase[0] = -1;
  }
}

void SceneView::motion(int x, int y)
{
  if (mDragBase[0] > 0)
  {
    Vec2i d = Vec2i(x,y) - mDragBase;
    dragUpdate(d);
    if (mDragButton == GLUT_LEFT_BUTTON)
    {
      mpScene->drag( makeRay(x,y), *this );
    }
  }
}

void SceneView::updateEye()
{
  // Vec3d eye = mLookAt.getCenter() - mDirection * ( mProjection.getZNear() ) + mCameraOffset;
  Vec3d eye = mLookAt.getCenter() - mDirection * 50.0 + mCameraOffset;
  mLookAt.setEye(eye);
}

void SceneView::setDirection(const Vec3d& direction)
{
  mDirection = direction;
  updateEye();
}

void SceneView::setUp(const Vec3d& up)
{
  mLookAt.setUp(up);
}

void SceneView::setCenter(const Vec3d& center)
{
  mLookAt.setCenter(center);
  updateEye();
}

void SceneView::setProjectionViewSize(const Vec2d& size)
{ 
  mProjection.setViewSize(size); 
}


// --- future ----------------------------------------------------------------

void SceneView::captureRayMotion(EventTarget* pTarget)
{
  mpCaptureRayMotionTarget = pTarget;
}

void SceneView::releaseRayMotion()
{
  mpCaptureRayMotionTarget = 0;
}


void SceneView::onEvent(Event& e)
{
#if 0
  switch(e.getType())
  {
  case EVENT_BUTTONDOWN:
    if (mDragButton == -1)
    {
      mDragButton = e.getButton();
      e.getSource().captureMouseMotion(*this);
      switch(e.getButton())
      {
      case BUTTON_LEFT:
        // mpScene->onEvent( makeSelectEvent( makeRay( Point2i(e.getMouseX(),e.getMouseY()) ) ) );
        break;
      case BUTTON_RIGHT:
        e.getSource().captureMouseMotion(*this);
        mDragButton = e.getButton();
        mDragBase   = Point2i(e.getMouseX(),e.getMouseY());
        mCenterBase = mpScene->getViewPoint().getFocusPoint();
        break;
      }
      break;
    }
  case EVENT_MOUSEMOTION:
    switch(mDragButton)
    {
    case BUTTON_LEFT:
      // mpScene->onEvent( makeDragEvent( makeRay( Point2i(e.getMouseX(), e.getMouseY() ) ) ) );
      break;
    case BUTTON_RIGHT:
      {
        Vec2i d = Vec2i( e.getMouseX(), e.getMouseY()) - mDragBase;
        Vec3d& focus = mpScene->getViewPoint().getFocusPoint();
        Vec2d size = mpProjection->getViewRect();
        Vec2d unit( size[0]/width() , size[1]/height() );
        focus = mCenterBase - ( mDirectionX*double(d[0])*unit[0] ) - ( mDirectionY*double(d[1])*unit[1] );                
      }
      break;
    }
    break;
  case EVENT_BUTTONUP:
    if (e.getButton() == mDragButton)
    {
      mDragButton = -1;
      e.getSource().releaseMouseMotion(*this);
    }
    break;
  }
#endif
}