WidgetManip.h

Go to the documentation of this file.

//------------------------------------------------------------------------
//
//   Joe Kniss
//     6-20-03
//                   ________    ____   ___ 
//                  |        \  /    | /  /
//                  +---+     \/     |/  /
//                  +--+|  |\    /|     < 
//                  |  ||  | \  / |  |\  \ 
//                  |      |  \/  |  | \  \ 
//                   \_____|      |__|  \__\
//                       Copyright  2003 
//                      Joe Michael Kniss
//                   <<< jmk@cs.utah.edu >>>
//               "All Your Base are Belong to Us"
//-------------------------------------------------------------------------

// WidgetManip.h

#ifndef __WIDGET_MANIPULATION_DOT_H
#define __WIDGET_MANIPULATION_DOT_H

#include <mathGutz.h>
#include <iostream>
using namespace std;

/// a bunch of utilities for manipulating widgets, defines things like
///  rotation etc, that all widgets can benefit from

/// A "ball-plane" rotation. 
inline
gutz::mat3f ballPlaneRot(const gutz::vec3f &center, /// center of object being rotated 
                         const float rad,           /// radius (distance from center) 
                         const gutz::CameraSP cam,  /// camera for current event
                         const gutz::vec3f   &last, /// last mouse point    (world space)
                         const gutz::vec3f   &curr) /// current mouse point (world space)
{
   const gutz::vec3f norm = cam->getViewDir();
   const gutz::vec3f cdir = (cam->getRayWorld(curr)).d;
   const gutz::vec3f ldir = (cam->getRayWorld(last)).d;
   float tc = std::numeric_limits<float>::max();
   float tl = std::numeric_limits<float>::max();
   /// ray plane intersect
   tc = gutz::intersectRayPlane(curr, cdir, center, norm);
   tc = gutz::g_min(tc, gutz::intersectRaySphere(curr,cdir,center,rad).x);
   tl = gutz::intersectRayPlane(last, ldir, center, norm);
   tl = gutz::g_min(tl, gutz::intersectRaySphere(last,ldir,center,rad).x);
   cerr << "tc = " << tc << "  tl = " << tl << endl;
   const gutz::vec3f cpt = curr + tc * cdir - center;
   cerr << " cur = " << cpt << endl;
   const gutz::vec3f lpt = last + tl * ldir - center;
   cerr << " las = " << lpt << endl;
   return gutz::axis2axis(lpt, cpt);
}

/// a convenience version of ballPlaneRot that takes the event and
///  the objects center & rad, calls ballPlaneRot and builds a 4x4 matrix
///  from the result.
inline
gutz::mat4f ballPlane(const gutz::MouseMoveEvent &mme,
                      const gutz::vec3f          &center,
                      const float                 rad)
{
   return gutz::mat4f(ballPlaneRot(center,rad,
                                   mme.getCamera(),
                                   mme.getWorldLast(),
                                   mme.getWorldPos()),
                      gutz::vec3f_zero);
}

#endif

---

Send questions, comments, and bug reports to: