OpenGLCanvas.cpp

#ifdef WIN32
#  pragma warning (disable: 4005) // for VS8 + WX
#endif

#include "OpenGLCanvas.hh"

#include <Base/Image/ImageIO.hh>
#include <Base/Math/Vector2.hh>
#include <Base/Math/Vector3.hh>
#include <Base/Math/Vector4.hh>

#include "GeometryGL.hh"

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

// override parent classes event handling table behavior
BEGIN_EVENT_TABLE (OpenGLCanvas, OpenGLCanvasBase)
// --- parent EVT handlers ---
//EVT_PAINT     (OpenGLCanvasBase::OnPaint)
//EVT_SIZE      (OpenGLCanvasBase::OnSize)
//EVT_ERASE_BACKGROUND (OpenGLCanvasBase::OnEraseBackground)
// --- additional handlers ---
EVT_MOTION(OpenGLCanvas::OnMotion)
EVT_LEFT_DOWN(OpenGLCanvas::OnMouseDown)
EVT_MIDDLE_DOWN(OpenGLCanvas::OnMouseDown)
EVT_RIGHT_DOWN(OpenGLCanvas::OnMouseDown)
EVT_MOUSEWHEEL(OpenGLCanvas::OnMouseWheel)  
#if OPENGLCANVAS_CONNECT_ONIDLE
EVT_IDLE   (OpenGLCanvas::OnIdle)
#endif

//EVT_LEFT_DCLICK(OpenGLCanvas::OnLeftDoubleClick)
//EVT_RIGHT_DCLICK(OpenGLCanvas::OnRightDoubleClick)
//EVT_MIDDLE_DCLICK(OpenGLCanvas::OnMiddleDoubleClick)
END_EVENT_TABLE()

// -----------------------------------------
bool         OpenGLCanvas::idleRepaintEnabled = OPENGLCANVAS_DEFAULT_idleRepaintEnabled;
bool       OpenGLCanvas::realtimeAnimation = OPENGLCANVAS_DEFAULT_realtimeAnimation;
// -----------------------------------------

/// destructor
OpenGLCanvas::~OpenGLCanvas(){
  delete p_viewCtrl_; p_viewCtrl_=NULL; 
}


/// constructors: 
OpenGLCanvas::OpenGLCanvas(
                           wxFrame* parent
                           ,wxWindowID id
                           ,const wxPoint& pos
                           ,const wxSize& size
                           ,long style
                           ,const wxString& name
                           ,int* attribList 
                           ,const wxPalette& palette
                           )                           
                           : OpenGLCanvasBase(parent,id,pos,size,style,name,attribList,palette)
                           ,p_viewCtrl_(NULL)
{
  //CALLINFO;
  InitMembers();
}


OpenGLCanvas::OpenGLCanvas(
                           wxFrame* parent
                           ,wxGLContext* sharedContext
                           ,wxWindowID id
                           ,const wxPoint& pos
                           ,const wxSize& size
                           ,long style
                           ,const wxString& name
                           ,int* attribList 
                           ,const wxPalette& palette 
                           )
                           : OpenGLCanvasBase(parent,sharedContext,id,pos,size,style,name,attribList,palette)
                           ,p_viewCtrl_(NULL)
{
  //CALLINFO;
  InitMembers();
}


void OpenGLCanvas::InitMembers()
{
  //CALLINFO;
  if (p_viewCtrl_==NULL)
    p_viewCtrl_ = new CameraViewController ();

  OpenGLCanvasBase::InitMembers();
  // additional members: 
  _polygonmodeGL=GL_FILL;
  //_pos=wxPoint(0,0);
}


void OpenGLCanvas::Display(){
#ifdef BIAS_DEBUG
  if (!idleRepaintEnabled){
    cout<<"."; // display a dot for each frame only if no repaint onidle
  }
#endif // BIAS_DEBUG
  OpenGLCanvasBase::Display();
}


void OpenGLCanvas::DisplayCameraView()
{
  DisplayCameraViewInternalParams();
  DisplayCameraViewExternalParams();
}


void OpenGLCanvas::DisplayCameraViewInternalParams()
{
  GetViewController().DisplayGLInternal();
}

void OpenGLCanvas::DisplayCameraViewExternalParams(){
  GetViewController().DisplayGLExternal();
}




void OpenGLCanvas::OnMotion( wxMouseEvent &event )
{
  //#ifdef WIN32
  //  wxDC dc;
  //#else
  //  // HACK
  //  wxPaintDC dc(this); 
  //#endif

  wxPoint pos= event.GetPosition(); //< mouse position
  if ((event.LeftIsDown() && event.RightIsDown()) || event.MiddleIsDown()){
    GetViewController().MotionTranslationCoplanar( Vector2<double>(double(pos.x), double(pos.y)) );
  } else if (event.LeftIsDown()){
    GetViewController().MotionTranslation( Vector2<double>(double(pos.x), double(pos.y)) );
  } else if (event.RightIsDown()){
    GetViewController().MotionTranslationForward( Vector2<double>(double(pos.x), double(pos.y)) );
  } else {
      this->ShowValue( event.GetPosition() );
  }
  if (!this->idleRepaintEnabled){
    Display(); // extra Display onidle doe sit otherwise
  }
}

void OpenGLCanvas::OnMouseDown( wxMouseEvent &event )
{
  wxPoint pos= event.GetPosition(); //< mouse position
  GetViewController().SetSize( 
    Vector2<double>(double(GetWidth()), double(GetHeight())) );
  GetViewController().SetStartPos(
    Vector2<double>(double(pos.x), double(pos.y)) );
}

void OpenGLCanvas::OnMouseWheel( wxMouseEvent &event )
{
  const double fraction=0.25;
  const int rot = event.GetWheelRotation();
  if (rot>0){
    // forward
    GetViewController().MoveToCenter( -fraction );
  } else if (rot<0){
    //backward
    GetViewController().MoveToCenter( +fraction);
  } else {
    BIASWARN("invalid wheel motion rot="<<rot);
    BIASBREAK;
  }
  if (!this->idleRepaintEnabled){
    Display(); // extra Display onidle doe sit otherwise
  }
}


// onidle redisplay 
// useful for animations
void OpenGLCanvas::OnIdle(wxIdleEvent& event)   
{
  // CALLINFO;
  // TODO set global OpenGLCanvasBase::time based on system time?
  if (!(this->idleRepaintEnabled)) {
    return; // nothing to do, in particular do not request more OnIdle events.
  };

  // for animation
  UpdateTime();

  // paint again, timestamp may have changed, useful for animations: 
  Display();
  ShowFPS();

  // usually only one Idle event is generated on when we become idle
  // but we want to run this continuously *while* we stay idle.
  event.RequestMore();
}


void OpenGLCanvas::UpdateTime()
{
  if (animationUpdateEnabled){
    // next time step: increase a bit
    if (realtimeAnimation){
      BIAS::OpenGLCanvasBase::UpdateTime();
    } else {
      // fallback that depends on frame no. 
      // should be a fixed update
      // assume scaling for TARGET_FPS fps display...
      time +=1.0/TARGET_FPS; 
    }
    //cout<<"OpenGLCanvasBase::time="<<OpenGLCanvasBase::time <<endl; // DBG  
  }
}

/// return GL state info
void OpenGLCanvas::GetInfoGL(std::ostream & os)
{
  OpenGLCanvasBase::GetInfoGL(os);

  // display (possibly used) CamerViewcontroller member status:
  GetViewController().Print(os);
} 

void OpenGLCanvas::Reshape()
{
  if (!GetContext()) 
    return; // no context available

  this->GetViewController().GetInternals().viewport.width  = GetWidth();
  this->GetViewController().GetInternals().viewport.height = GetHeight();
  if (!GetViewController().GetInternals().frustum.isFixed)
  {
    GetViewController().GetInternals().frustum.AdaptWidth( this->GetAspectRatio() );
  }

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

CameraViewController & OpenGLCanvas::GetViewController(){
  BIASASSERT(p_viewCtrl_!=NULL);
  return *p_viewCtrl_;
}

CameraViewController OpenGLCanvas::GetViewController() const {
  BIASASSERT(p_viewCtrl_!=NULL);
  return *p_viewCtrl_;
}