CameraViewController.cpp

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

#include "CameraViewController.hh"
#include "biasgl.h"
#include <iostream>

using namespace std;
using namespace BIAS;


// JW
CameraViewController::~CameraViewController(){
  delete p_externals;  p_externals=NULL;
  delete p_internals; p_internals=NULL; 
}


CameraViewController::CameraViewController()
: p_externals(NULL), p_internals(NULL) 
{
  InitMembers();
}


void CameraViewController::InitMembers(){
  //mode_ = ExamineTrackballmode ; //InspectionMoveCAbsolute

  if (p_externals==NULL){
    p_externals = new CameraViewExternals();
  } else
    GetExternals().InitMembers();

  if (p_internals==NULL)
    p_internals = new CameraViewInternals();
  else
    GetInternals().InitMembers();

  size.Set(100,100);
  startpos.SetZero();
  startposExt.InitMembers();
  startposInt.InitMembers();
}


void CameraViewController::DisplayGL(){
  DisplayGLInternal();
  DisplayGLExternal();
}

void CameraViewController::DisplayGLInternal(){
  GetInternals().DisplayGL();
}

void CameraViewController::DisplayGLExternal(){
  GetExternals().DisplayGL();
}


std::ostream &
CameraViewController::Print(std::ostream & os ){
  os<<"CameraViewController : "<<endl;
  GetInternals().Print(os);
  GetExternals().Print(os);
  return os;
}

void CameraViewController::SetStartPos(const BIAS::Vector2<double> & pos){
  startpos=pos;
  BIASASSERT(p_externals!=NULL);
  BIASASSERT(p_internals!=NULL);
  startposExt = *p_externals;
  startposInt = *p_internals;
}


void CameraViewController::MoveOrbit(const BIAS::Vector2<double> & deltaN)
{
  BIASASSERT(p_externals!=NULL);

  Vector2<double> middle = size /2.0;
  //cout<<"size:   "<<size<<" middle: "<<middle<<endl;

  // tangential directions mapping to motion delta
  Vector3<double> v0(1,0,0);
  Vector3<double> v1(0,1,0);
  Vector3<double> offset(0,0,0);

  //cout<<deltaN<<endl;

  Vector3<double> displaceCart = GetExternals().C - GetExternals().viewAt;
  Vector3<double> displacePolar = displaceCart.CartesianToPolar();
  //cout<<displaceCart<<" is polar "<<displacePolar<<endl;

  v1 = GetExternals().up;
  v1.Normalize();
  v0 = v1.CrossProduct(displaceCart);
  v0.Normalize();
  //cout<<v0<<" v1 "<<v1<<endl;

  
  //offset = 0.01 * Vector3<double>(deltaN[0], deltaN[1], 0.0);
  const double scale=0.1;
  offset += scale * deltaN[0] * v0;
  offset += scale * deltaN[1] * v1;

  GetExternals().C += offset;
}


void CameraViewController::MoveCoplanar(const BIAS::Vector2<double> & deltaN)
{
  BIASASSERT(p_externals!=NULL);

  Vector3<double> v0(1,0,0);
  Vector3<double> v1=GetExternals().up;
  Vector3<double> offset(0,0,0);

  Vector3<double> displaceCart = GetExternals().C - GetExternals().viewAt;

  v0 = v1.CrossProduct(displaceCart);

  v1.Normalize();
  v0.Normalize();
  
  //offset = 0.01 * Vector3<double>(deltaN[0], deltaN[1], 0.0);
  const double scale = displaceCart.Length()*2.0;
  offset += scale * deltaN[0] * v0;
  offset += scale * deltaN[1] * v1;

  GetExternals().C += offset;
  GetExternals().viewAt += offset;
}


void CameraViewController::MoveToCenter(const double & fraction)
{
  if (abs(fraction)>10.0)
  {
    BIASERR("fraction should be a normalized value, usually between -1.0 and +1.0. skipping motion");
    BIASBREAK;
    return;
  }
  BIASASSERT(p_externals!=NULL);
  Vector3<double> direction = p_externals->C - p_externals->viewAt;
  direction *= fraction;
  p_externals->C += direction;
}

void CameraViewController::MotionTranslationForward(const BIAS::Vector2<double> & pos)
{
  const Vector2<double> delta =  pos - this->startpos;
  const double fraction = delta.GetY() / size.GetY();
  MoveToCenter(fraction);
  this->startpos = pos;
}


void CameraViewController::MotionTranslation(const BIAS::Vector2<double> & pos)
{
  Vector2<double> delta =  pos - this->startpos;
  delta.DivideIP(size);
  delta *= 20.0;
  MoveOrbit(delta);

  this->startpos = pos; // new center
}

void CameraViewController::MotionTranslationCoplanar(const BIAS::Vector2<double> & pos)
{
  Vector2<double> delta =  pos - this->startpos;
  delta.DivideIP(size);
  MoveCoplanar(delta);
  this->startpos = pos; // new center
}



// helper
//#define square(arg) ((arg) * (arg))

void CameraViewController::MotionTrackballRotation(const BIAS::Vector2<double> & pos){
  // Trackball rotation
  BIASERR("incorrectly implemented");
  // TODO

  // offset from start of dragging
  Vector2<double> middle=size/2.;
  //cout<<"DBG  size="<<size<<" middle="<<middle<<endl;

  /*
  // current pos. on unit 1 sphere, determine z from x,y 
  Vector2<double> deltaPosAct = ((pos -middle) / size);
  Vector3<double> vAct(deltaPosAct[0],  -deltaPosAct[1], 0 ); // projection to XY plane
  vAct[2] = sqrt(1 - square(vAct[0]) - square(vAct[1]) ); // minus y for lower left origin
  cout<<" vAct="<<vAct<<" length: "<<vAct.Length()<<endl;

  // startpos on unit 1 sphere
  Vector2<double> deltaPosStart = (startpos -middle) / size;
  Vector3<double> vStart(deltaPosStart[0], -deltaPosStart[1],  0);
  vStart[2] = sqrt(1 - square(vStart[0]) - square(vStart[1]) );
  cout<<" vStart="<<vStart<<" length: "<<vStart.Length()<<endl;
  */


  // normalize length


  // offset from viewcenter in polar form:
  //static BIAS::Vector3<double> PolarCoords = (startC -viewAt_).CoordEuclideanToSphere();

  /*
  float dtheta = (float)(mouseX - x)*TWOPI/(float)screenWidth;
  float dphi   = (float)(y - mouseY)*TWOPI/(float)screenHeight;
  if (p == &Eye.from) {
  p->theta -= dtheta;
  p->phi   -= dphi;
  } else {
  p->theta += dtheta;
  p->phi   += dphi;
  }
  if (p->theta < -TWOPI) p->theta += TWOPI;
  else if (p->theta >  TWOPI) p->theta -= TWOPI;
  if (p->phi > M_PI) p->phi = M_PI;
  else if (p->phi < 0.) p->phi = 0.;
  */

  //// set new "rotated" eye center
  //C_ = viewAt_ +p->CoordSphereToEuclidean();
  //// adapt up vector
  //cout<<"DBG C_="<<C_<<" "<<C_.NormL2()<<endl;


  //  polarToCartesian(Eye.from, eyeCoords);
  //gluLookAt(eyeCoords[0], eyeCoords[1], eyeCoords[2],
  //  Eye.target[0], Eye.target[1], Eye.target[2],
  //  -cos(Eye.from.phi)*sin(Eye.from.theta),
  //  -cos(Eye.from.phi)*cos(Eye.from.theta),
  //  sin(Eye.from.phi));
}


//void CameraViewController::OnMotion( wxMouseEvent &event ){
//
//  //CALLINFO;
//  if (event.LeftIsDown()){
//    wxPoint pt= event.GetPosition();
//    Vector2<double> diff= Vector2<double>(pt.x, pt.y) -startpos;
//    //cout<<"diff: "<<diff<<endl;
//    Motion(diff[0], diff[1]);
//  }
//}


//void CameraViewController::OnLeftDown( wxMouseEvent &event ){
//  //CALLINFO;
//  wxPoint pos= event.GetPosition();
//  this->startpos.Set(pos.x, pos.y);
//  this->startC=C_;
//}