RenderingWidget Class Reference

#include <quaternion_demo.h>

Inheritance diagram for RenderingWidget:

Public Member Functions
EIGEN_MAKE_ALIGNED_OPERATOR_NEW	RenderingWidget ()
	~RenderingWidget ()
QWidget *	createNavigationControlWidget ()

Protected Slots
virtual void	animate (void)
virtual void	drawScene (void)
virtual void	grabFrame (void)
virtual void	stopAnimation ()
virtual void	setNavMode (int)
virtual void	setLerpMode (int)
virtual void	setRotationMode (int)
virtual void	resetCamera ()

Protected Member Functions
virtual void	initializeGL ()
virtual void	resizeGL (int width, int height)
virtual void	paintGL ()
virtual void	mousePressEvent (QMouseEvent *e)
virtual void	mouseReleaseEvent (QMouseEvent *e)
virtual void	mouseMoveEvent (QMouseEvent *e)
virtual void	keyPressEvent (QKeyEvent *e)

Private Types
enum	TrackMode {   TM_NO_TRACK = 0 , TM_ROTATE_AROUND , TM_ZOOM , TM_LOCAL_ROTATE ,   TM_FLY_Z , TM_FLY_PAN }
enum	NavMode { NavTurnAround , NavFly }
enum	LerpMode { LerpQuaternion , LerpEulerAngles }
enum	RotationMode { RotationStable , RotationStandard }
typedef std::map< float, Frame >	TimeLine

Private Member Functions
Frame	lerpFrame (float t)
void	setupCamera ()

Private Attributes
TimeLine	m_timeline
Frame	mInitFrame
bool	mAnimate
float	m_alpha
Camera	mCamera
TrackMode	mCurrentTrackingMode
NavMode	mNavMode
LerpMode	mLerpMode
RotationMode	mRotationMode
Vector2i	mMouseCoords
Trackball	mTrackball
QTimer	m_timer
std::vector< Vector3f >	mVertices
std::vector< Vector3f >	mNormals
std::vector< int >	mIndices

Member Typedef Documentation

TimeLine

typedef std::map<float, Frame> RenderingWidget::TimeLine

private

Member Enumeration Documentation

LerpMode

enum RenderingWidget::LerpMode

private

Enumerator
LerpQuaternion
LerpEulerAngles

{ LerpQuaternion, LerpEulerAngles };

NavMode

enum RenderingWidget::NavMode

private

Enumerator
NavTurnAround
NavFly

{ NavTurnAround, NavFly };

RotationMode

enum RenderingWidget::RotationMode

private

Enumerator
RotationStable
RotationStandard

{ RotationStable, RotationStandard };

TrackMode

enum RenderingWidget::TrackMode

private

Enumerator
TM_NO_TRACK
TM_ROTATE_AROUND
TM_ZOOM
TM_LOCAL_ROTATE
TM_FLY_Z
TM_FLY_PAN

{ TM_NO_TRACK = 0, TM_ROTATE_AROUND, TM_ZOOM, TM_LOCAL_ROTATE, TM_FLY_Z, TM_FLY_PAN };

Constructor & Destructor Documentation

RenderingWidget()

RenderingWidget::RenderingWidget

(

)

                                 {
  mAnimate = false;
  mCurrentTrackingMode = TM_NO_TRACK;
  mNavMode = NavTurnAround;
  mLerpMode = LerpQuaternion;
  mRotationMode = RotationStable;
  mTrackball.setCamera(&mCamera);
 
  // required to capture key press events
  setFocusPolicy(Qt::ClickFocus);
}

~RenderingWidget()

RenderingWidget::~RenderingWidget ( )

inline

{}

Member Function Documentation

animate

void RenderingWidget::animate ( void  )

protectedvirtualslot

                              {
  m_alpha += double(m_timer.interval()) * 1e-3;
 
  TimeLine::const_iterator hi = m_timeline.upper_bound(m_alpha);
  TimeLine::const_iterator lo = hi;
  --lo;
 
  Frame currentFrame;
 
  if (hi == m_timeline.end()) {
    // end
    currentFrame = lo->second;
    stopAnimation();
  } else if (hi == m_timeline.begin()) {
    // start
    currentFrame = hi->second;
  } else {
    float s = (m_alpha - lo->first) / (hi->first - lo->first);
    if (mLerpMode == LerpEulerAngles)
      currentFrame = ::lerpFrame<EulerAngles<float> >(s, lo->second, hi->second);
    else if (mLerpMode == LerpQuaternion)
      currentFrame = ::lerpFrame<Eigen::Quaternionf>(s, lo->second, hi->second);
    else {
      std::cerr << "Invalid rotation interpolation mode (abort)\n";
      exit(2);
    }
    currentFrame.orientation.coeffs().normalize();
  }
 
  currentFrame.orientation = currentFrame.orientation.inverse();
  currentFrame.position = -(currentFrame.orientation * currentFrame.position);
  mCamera.setFrame(currentFrame);
 
  updateGL();
}

References e(), Frame::orientation, Frame::position, and s.

createNavigationControlWidget()

QWidget * RenderingWidget::createNavigationControlWidget

(

)

                                                        {
  QWidget* panel = new QWidget();
  QVBoxLayout* layout = new QVBoxLayout();
 
  {
    QPushButton* but = new QPushButton("reset");
    but->setToolTip("move the camera to initial position (with animation)");
    layout->addWidget(but);
    connect(but, SIGNAL(clicked()), this, SLOT(resetCamera()));
  }
  {
    // navigation mode
    QGroupBox* box = new QGroupBox("navigation mode");
    QVBoxLayout* boxLayout = new QVBoxLayout;
    QButtonGroup* group = new QButtonGroup(panel);
    QRadioButton* but;
    but = new QRadioButton("turn around");
    but->setToolTip("look around an object");
    group->addButton(but, NavTurnAround);
    boxLayout->addWidget(but);
    but = new QRadioButton("fly");
    but->setToolTip("free navigation like a spaceship\n(this mode can also be enabled pressing the \"shift\" key)");
    group->addButton(but, NavFly);
    boxLayout->addWidget(but);
    group->button(mNavMode)->setChecked(true);
    connect(group, SIGNAL(buttonClicked(int)), this, SLOT(setNavMode(int)));
    box->setLayout(boxLayout);
    layout->addWidget(box);
  }
  {
    // track ball, rotation mode
    QGroupBox* box = new QGroupBox("rotation mode");
    QVBoxLayout* boxLayout = new QVBoxLayout;
    QButtonGroup* group = new QButtonGroup(panel);
    QRadioButton* but;
    but = new QRadioButton("stable trackball");
    group->addButton(but, RotationStable);
    boxLayout->addWidget(but);
    but->setToolTip("use the stable trackball implementation mapping\nthe 2D coordinates to 3D points on a sphere");
    but = new QRadioButton("standard rotation");
    group->addButton(but, RotationStandard);
    boxLayout->addWidget(but);
    but->setToolTip(
        "standard approach mapping the x and y displacements\nas rotations around the camera's X and Y axes");
    group->button(mRotationMode)->setChecked(true);
    connect(group, SIGNAL(buttonClicked(int)), this, SLOT(setRotationMode(int)));
    box->setLayout(boxLayout);
    layout->addWidget(box);
  }
  {
    // interpolation mode
    QGroupBox* box = new QGroupBox("spherical interpolation");
    QVBoxLayout* boxLayout = new QVBoxLayout;
    QButtonGroup* group = new QButtonGroup(panel);
    QRadioButton* but;
    but = new QRadioButton("quaternion slerp");
    group->addButton(but, LerpQuaternion);
    boxLayout->addWidget(but);
    but->setToolTip("use quaternion spherical interpolation\nto interpolate orientations");
    but = new QRadioButton("euler angles");
    group->addButton(but, LerpEulerAngles);
    boxLayout->addWidget(but);
    but->setToolTip("use Euler angles to interpolate orientations");
    group->button(mNavMode)->setChecked(true);
    connect(group, SIGNAL(buttonClicked(int)), this, SLOT(setLerpMode(int)));
    box->setLayout(boxLayout);
    layout->addWidget(box);
  }
  layout->addItem(new QSpacerItem(0, 0, QSizePolicy::Minimum, QSizePolicy::Expanding));
  panel->setLayout(layout);
  return panel;
}

drawScene

void RenderingWidget::drawScene ( void  )

protectedvirtualslot

                                {
  static FancySpheres sFancySpheres;
  float length = 50;
  gpu.drawVector(Vector3f::Zero(), length * Vector3f::UnitX(), Color(1, 0, 0, 1));
  gpu.drawVector(Vector3f::Zero(), length * Vector3f::UnitY(), Color(0, 1, 0, 1));
  gpu.drawVector(Vector3f::Zero(), length * Vector3f::UnitZ(), Color(0, 0, 1, 1));
 
  // draw the fractal object
  float sqrt3 = std::sqrt(3.);
  glLightfv(GL_LIGHT0, GL_AMBIENT, Vector4f(0.5, 0.5, 0.5, 1).data());
  glLightfv(GL_LIGHT0, GL_DIFFUSE, Vector4f(0.5, 1, 0.5, 1).data());
  glLightfv(GL_LIGHT0, GL_SPECULAR, Vector4f(1, 1, 1, 1).data());
  glLightfv(GL_LIGHT0, GL_POSITION, Vector4f(-sqrt3, -sqrt3, sqrt3, 0).data());
 
  glLightfv(GL_LIGHT1, GL_AMBIENT, Vector4f(0, 0, 0, 1).data());
  glLightfv(GL_LIGHT1, GL_DIFFUSE, Vector4f(1, 0.5, 0.5, 1).data());
  glLightfv(GL_LIGHT1, GL_SPECULAR, Vector4f(1, 1, 1, 1).data());
  glLightfv(GL_LIGHT1, GL_POSITION, Vector4f(-sqrt3, sqrt3, -sqrt3, 0).data());
 
  glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, Vector4f(0.7, 0.7, 0.7, 1).data());
  glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, Vector4f(0.8, 0.75, 0.6, 1).data());
  glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, Vector4f(1, 1, 1, 1).data());
  glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 64);
 
  glEnable(GL_LIGHTING);
  glEnable(GL_LIGHT0);
  glEnable(GL_LIGHT1);
 
  sFancySpheres.draw();
  glVertexPointer(3, GL_FLOAT, 0, mVertices[0].data());
  glNormalPointer(GL_FLOAT, 0, mNormals[0].data());
  glEnableClientState(GL_VERTEX_ARRAY);
  glEnableClientState(GL_NORMAL_ARRAY);
  glDrawArrays(GL_TRIANGLES, 0, mVertices.size());
  glDisableClientState(GL_VERTEX_ARRAY);
  glDisableClientState(GL_NORMAL_ARRAY);
 
  glDisable(GL_LIGHTING);
}

References data, FancySpheres::draw(), GpuHelper::drawVector(), gpu, sqrt(), and oomph::PseudoSolidHelper::Zero.

grabFrame

void RenderingWidget::grabFrame ( void  )

protectedvirtualslot

                                    {
  // ask user for a time
  bool ok = false;
  double t = 0;
  if (!m_timeline.empty()) t = (--m_timeline.end())->first + 1.;
  t = QInputDialog::getDouble(this, "Eigen's RenderingWidget", "time value: ", t, 0, 1e3, 1, &ok);
  if (ok) {
    Frame aux;
    aux.orientation = mCamera.viewMatrix().linear();
    aux.position = mCamera.viewMatrix().translation();
    m_timeline[t] = aux;
  }
}

References Frame::orientation, Frame::position, and plotPSD::t.

initializeGL()

void RenderingWidget::initializeGL ( )

protectedvirtual

                                   {
  glClearColor(1., 1., 1., 0.);
  glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
  glDepthMask(GL_TRUE);
  glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
 
  mCamera.setPosition(Vector3f(-200, -200, -200));
  mCamera.setTarget(Vector3f(0, 0, 0));
  mInitFrame.orientation = mCamera.orientation().inverse();
  mInitFrame.position = mCamera.viewMatrix().translation();
}

keyPressEvent()

void RenderingWidget::keyPressEvent ( QKeyEvent *  e )

protectedvirtual

                                                {
  switch (e->key()) {
    case Qt::Key_Up:
      mCamera.zoom(2);
      break;
    case Qt::Key_Down:
      mCamera.zoom(-2);
      break;
    // add a frame
    case Qt::Key_G:
      grabFrame();
      break;
    // clear the time line
    case Qt::Key_C:
      m_timeline.clear();
      break;
    // move the camera to initial pos
    case Qt::Key_R:
      resetCamera();
      break;
    // start/stop the animation
    case Qt::Key_A:
      if (mAnimate) {
        stopAnimation();
      } else {
        m_alpha = 0;
        connect(&m_timer, SIGNAL(timeout()), this, SLOT(animate()));
        m_timer.start(1000 / 30);
        mAnimate = true;
      }
      break;
    default:
      break;
  }
 
  updateGL();
}

References e().

lerpFrame()

Frame RenderingWidget::lerpFrame ( float  t )

private

mouseMoveEvent()

void RenderingWidget::mouseMoveEvent ( QMouseEvent *  e )

protectedvirtual

                                                   {
  // tracking
  if (mCurrentTrackingMode != TM_NO_TRACK) {
    float dx = float(e->x() - mMouseCoords.x()) / float(mCamera.vpWidth());
    float dy = -float(e->y() - mMouseCoords.y()) / float(mCamera.vpHeight());
 
    // speedup the transformations
    if (e->modifiers() & Qt::ShiftModifier) {
      dx *= 10.;
      dy *= 10.;
    }
 
    switch (mCurrentTrackingMode) {
      case TM_ROTATE_AROUND:
      case TM_LOCAL_ROTATE:
        if (mRotationMode == RotationStable) {
          // use the stable trackball implementation mapping
          // the 2D coordinates to 3D points on a sphere.
          mTrackball.track(Vector2i(e->pos().x(), e->pos().y()));
        } else {
          // standard approach mapping the x and y displacements as rotations
          // around the camera's X and Y axes.
          Quaternionf q = AngleAxisf(dx * M_PI, Vector3f::UnitY()) * AngleAxisf(-dy * M_PI, Vector3f::UnitX());
          if (mCurrentTrackingMode == TM_LOCAL_ROTATE)
            mCamera.localRotate(q);
          else
            mCamera.rotateAroundTarget(q);
        }
        break;
      case TM_ZOOM:
        mCamera.zoom(dy * 100);
        break;
      case TM_FLY_Z:
        mCamera.localTranslate(Vector3f(0, 0, -dy * 200));
        break;
      case TM_FLY_PAN:
        mCamera.localTranslate(Vector3f(dx * 200, dy * 200, 0));
        break;
      default:
        break;
    }
 
    updateGL();
  }
 
  mMouseCoords = Vector2i(e->pos().x(), e->pos().y());
}

References e(), M_PI, and Eigen::numext::q.

mousePressEvent()

void RenderingWidget::mousePressEvent ( QMouseEvent *  e )

protectedvirtual

                                                    {
  mMouseCoords = Vector2i(e->pos().x(), e->pos().y());
  bool fly = (mNavMode == NavFly) || (e->modifiers() & Qt::ControlModifier);
  switch (e->button()) {
    case Qt::LeftButton:
      if (fly) {
        mCurrentTrackingMode = TM_LOCAL_ROTATE;
        mTrackball.start(Trackball::Local);
      } else {
        mCurrentTrackingMode = TM_ROTATE_AROUND;
        mTrackball.start(Trackball::Around);
      }
      mTrackball.track(mMouseCoords);
      break;
    case Qt::MidButton:
      if (fly)
        mCurrentTrackingMode = TM_FLY_Z;
      else
        mCurrentTrackingMode = TM_ZOOM;
      break;
    case Qt::RightButton:
      mCurrentTrackingMode = TM_FLY_PAN;
      break;
    default:
      break;
  }
}

References Trackball::Around, e(), and Trackball::Local.

mouseReleaseEvent()

void RenderingWidget::mouseReleaseEvent ( QMouseEvent *  e )

protectedvirtual

                                                    {
  mCurrentTrackingMode = TM_NO_TRACK;
  updateGL();
}

paintGL()

void RenderingWidget::paintGL ( )

protectedvirtual

                              {
  glEnable(GL_DEPTH_TEST);
  glDisable(GL_CULL_FACE);
  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  glDisable(GL_COLOR_MATERIAL);
  glDisable(GL_BLEND);
  glDisable(GL_ALPHA_TEST);
  glDisable(GL_TEXTURE_1D);
  glDisable(GL_TEXTURE_2D);
  glDisable(GL_TEXTURE_3D);
 
  // Clear buffers
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
  mCamera.activateGL();
 
  drawScene();
}

resetCamera

void RenderingWidget::resetCamera ( )

protectedvirtualslot

                                  {
  if (mAnimate) stopAnimation();
  m_timeline.clear();
  Frame aux0 = mCamera.frame();
  aux0.orientation = aux0.orientation.inverse();
  aux0.position = mCamera.viewMatrix().translation();
  m_timeline[0] = aux0;
 
  Vector3f currentTarget = mCamera.target();
  mCamera.setTarget(Vector3f::Zero());
 
  // compute the rotation duration to move the camera to the target
  Frame aux1 = mCamera.frame();
  aux1.orientation = aux1.orientation.inverse();
  aux1.position = mCamera.viewMatrix().translation();
  float duration = aux0.orientation.angularDistance(aux1.orientation) * 0.9;
  if (duration < 0.1) duration = 0.1;
 
  // put the camera at that time step:
  aux1 = aux0.lerp(duration / 2, mInitFrame);
  // and make it look at the target again
  aux1.orientation = aux1.orientation.inverse();
  aux1.position = -(aux1.orientation * aux1.position);
  mCamera.setFrame(aux1);
  mCamera.setTarget(Vector3f::Zero());
 
  // add this camera keyframe
  aux1.orientation = aux1.orientation.inverse();
  aux1.position = mCamera.viewMatrix().translation();
  m_timeline[duration] = aux1;
 
  m_timeline[2] = mInitFrame;
  m_alpha = 0;
  animate();
  connect(&m_timer, SIGNAL(timeout()), this, SLOT(animate()));
  m_timer.start(1000 / 30);
  mAnimate = true;
}

References Frame::lerp(), Frame::orientation, Frame::position, and oomph::PseudoSolidHelper::Zero.

resizeGL()

void RenderingWidget::resizeGL ( int  width, int  height  )

protectedvirtual

{ mCamera.setViewport(width, height); }

References Global_Physical_Variables::height().

setLerpMode

void RenderingWidget::setLerpMode ( int  m )

protectedvirtualslot

{ mLerpMode = LerpMode(m); }

References m.

setNavMode

void RenderingWidget::setNavMode ( int  m )

protectedvirtualslot

{ mNavMode = NavMode(m); }

References m.

setRotationMode

void RenderingWidget::setRotationMode ( int  m )

protectedvirtualslot

{ mRotationMode = RotationMode(m); }

References m.

setupCamera()

void RenderingWidget::setupCamera ( )

private

stopAnimation

void RenderingWidget::stopAnimation ( )

protectedvirtualslot

                                    {
  disconnect(&m_timer, SIGNAL(timeout()), this, SLOT(animate()));
  m_timer.stop();
  mAnimate = false;
  m_alpha = 0;
}

Member Data Documentation

m_alpha

float RenderingWidget::m_alpha

private

m_timeline

TimeLine RenderingWidget::m_timeline

private

m_timer

QTimer RenderingWidget::m_timer

private

mAnimate

bool RenderingWidget::mAnimate

private

mCamera

Camera RenderingWidget::mCamera

private

mCurrentTrackingMode

TrackMode RenderingWidget::mCurrentTrackingMode

private

mIndices

std::vector<int> RenderingWidget::mIndices

private

mInitFrame

Frame RenderingWidget::mInitFrame

private

mLerpMode

LerpMode RenderingWidget::mLerpMode

private

mMouseCoords

Vector2i RenderingWidget::mMouseCoords

private

mNavMode

NavMode RenderingWidget::mNavMode

private

mNormals

std::vector<Vector3f> RenderingWidget::mNormals

private

mRotationMode

RotationMode RenderingWidget::mRotationMode

private

mTrackball

Trackball RenderingWidget::mTrackball

private

mVertices

std::vector<Vector3f> RenderingWidget::mVertices

private

---

The documentation for this class was generated from the following files:

• quaternion_demo.h
• quaternion_demo.cpp