开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 3D图形编程 > 查看源码
Trackball.cc
资源名称：scanalyze-1.0.3_source_code.rar　[点击查看]
上传用户：kellyonhid
上传日期：2013-10-12
资源大小：932k
文件大小：22k
源码类别：

3D图形编程

开发平台：

Visual C++

Trackball.cc：源码内容
  1. //############################################################
  2. // Trackball.cc
  3. // Kari Pulli
  4. // 03/06/97
  5. //############################################################
  7. #include <iostream.h>
  8. #include <math.h>
  9. #include "Trackball.h"
  10. #include "Xform.h"
  11. #include "Projector.h"
  12. #include "defines.h"
  14. #include "plvGlobals.h" // for spinning preference...
  16. /*
  17.  * Trackball code:
  18.  *
  19.  * Implementation of a virtual trackball.
  20.  * Implemented by Gavin Bell, lots of ideas from Thant Tessman and
  21.  *   the August '88 issue of Siggraph's "Computer Graphics," 
  22.  *   pp. 121-129.
  23.  *
  24.  * Vector manip code:
  25.  *
  26.  * Original code from:
  27.  * David M. Ciemiewicz, Mark Grossman, Henry Moreton, and 
  28.  * Paul Haeberli
  29.  *
  30.  * Much mucking with by:
  31.  * Gavin Bell
  32.  * Kept most maths, changed just about everything else:
  33.  * Kari Pulli
  34.  */
  37. /*
  38.    This size should really be based on the distance from the 
  39.    center of rotation to the point on the object underneath the 
  40.    mouse.  That point would then track the mouse as closely as 
  41.    possible.  This is a simple example, though, so that is left 
  42.    as an Exercise for the Programmer.
  43. */
  44. #define TRACKBALLSIZE  (0.8)
  47. // Local function prototypes (not defined in trackball.h)
  48. static float tb_project_to_sphere(float, float, float);
  49. static void normalize_quat(float [4]);
  52. //  Given an axis and angle, compute quaternion.
  53. void
  54. axis_to_quat(Pnt3 &a, float phi, float q[4])
  55. {
  56.   a.normalize();
  57.   a *= sin(phi/2.0);
  58.   q[1]=a[0]; q[2]=a[1]; q[3]=a[2];
  59.   q[0] = cos(phi/2.0);
  60. }
  62. /*
  63.    Ok, simulate a track-ball.  Project the points onto the virtual
  64.    trackball, then figure out the axis of rotation, which is the 
  65.    cross product of P1 P2 and O P1 (O is the center of the ball, 
  66.    0,0,0)
  67.    Note:  This is a deformed trackball-- is a trackball in the 
  68.    center, but is deformed into a hyperbolic sheet of rotation 
  69.    away from the center.  This particular function was chosen 
  70.    after trying out several variations.
  72.    It is assumed that the arguments to this routine are in the 
  73.    range (-1.0 ... 1.0)
  74.  */
  75. void
  76. trackball(float q[4], float p1x, float p1y, float p2x, float p2y,
  77.   TbConstraint constraint = CONSTRAIN_NONE)
  78. {
  79.   if (p1x == p2x && p1y == p2y) {
  80.     // Zero rotation 
  81.     q[0] = 1.0;
  82.     q[1] = q[2] = q[3] = 0.0;
  83.     return;
  84.   }
  86.   // First, figure out z-coordinates for projection of P1 and P2 
  87.   // to deformed sphere
  88.   Pnt3 p1(p1x,p1y,tb_project_to_sphere(TRACKBALLSIZE,p1x,p1y));
  89.   Pnt3 p2(p2x,p2y,tb_project_to_sphere(TRACKBALLSIZE,p2x,p2y));
  90.   
  91.   // get axis of rotation
  92.   Pnt3 a = cross(p1,p2);
  94.   // Figure out how much to rotate around that axis.
  95.   float t = dist(p1,p2) / (2.0*TRACKBALLSIZE);
  96.   
  97.   // Avoid problems with out-of-control values...
  98.   if (t > 1.0) t = 1.0;
  99.   if (t < -1.0) t = -1.0;
  100.   float phi = 2.0 * asin(t); // how much to rotate about axis
  102.   if (constraint == CONSTRAIN_X)
  103.     a[1] = a[2] = 0;
  104.   if (constraint == CONSTRAIN_Y)
  105.     a[0] = a[2] = 0;
  106.   if (constraint == CONSTRAIN_Z)
  107.     a[0] = a[1] = 0;
  108.   
  109.   axis_to_quat(a,phi,q);
  110. }
  112. //
  113. // Project an x,y pair onto a sphere of radius r OR a hyperbolic 
  114. // sheet if we are away from the center of the sphere.
  115. //
  116. static float
  117. tb_project_to_sphere(float r, float x, float y)
  118. {
  119.   float d, t, z;
  120.   
  121.   d = sqrt(x*x + y*y);
  122.   if (d < r * 0.70710678118654752440) {    // Inside sphere
  123.     z = sqrt(r*r - d*d);
  124.   } else {                                 // On hyperbola
  125.     t = r / 1.41421356237309504880;
  126.     z = t*t / d;
  127.   }
  128.   return z;
  129. }
  131. /*
  132.    Given two rotations, e1 and e2, expressed as quaternion 
  133.    rotations, figure out the equivalent single rotation and stuff
  134.    it into dest.
  135.    This routine also normalizes the result every RENORMCOUNT 
  136.    times it is called, to keep error from creeping in.
  138.    NOTE: This routine is written so that q1 or q2 may be the same
  139.    as dest (or each other).
  140. */
  142. #define RENORMCOUNT 97
  144. void
  145. add_quats(float q1[4], float q2[4], float dest[4])
  146. {
  147.   static int count=0;
  149.   Pnt3 t1(&q1[1]);
  150.   t1 *= q2[0];
  151.   
  152.   Pnt3 t2(&q2[1]);
  153.   t2 *= q1[0];
  155.   Pnt3 t3 = cross(&q1[1],&q2[1]);
  156.   t3 += t1; t3 += t2;
  157.   
  158.   // watch out: q1 or q2 may be the same as dest!
  159.   dest[0] = q1[0] * q2[0] - dot(&q1[1],&q2[1]);
  160.   dest[1] = t3[0];
  161.   dest[2] = t3[1];
  162.   dest[3] = t3[2];
  164.   if (++count > RENORMCOUNT) {
  165.     count = 0;
  166.     normalize_quat(dest);
  167.   }
  168. }
  170. /*
  171.    Quaternions always obey:  a^2 + b^2 + c^2 + d^2 = 1.0
  172.    If they don't add up to 1.0, dividing by their magnitude will
  173.    renormalize them.
  174.    
  175.    Note: See the following for more information on quaternions:
  176.    
  177.    - Shoemake, K., Animating rotation with quaternion curves, 
  178.      Computer Graphics 19, No 3 (Proc. SIGGRAPH'85), 245-254,1985.
  179.      - Pletinckx, D., Quaternion calculus as a basic tool in 
  180.        computer graphics, The Visual Computer 5, 2-13, 1989.
  181. */
  182. static void
  183. normalize_quat(float q[4])
  184. {
  185.   float mag = (q[0]*q[0] + q[1]*q[1] + q[2]*q[2] + q[3]*q[3]);
  186.   for (int i = 0; i < 4; i++) q[i] /= mag;
  187. }
  189. // Build a rotation matrix, given a quaternion rotation.
  190. void
  191. build_rotmatrix(float m[4][4], float q[4])
  192. {
  193.   m[0][0] = 1.0 - 2.0 * (q[2] * q[2] + q[3] * q[3]);
  194.   m[1][0] = 2.0 * (q[1] * q[2] - q[3] * q[0]);
  195.   m[2][0] = 2.0 * (q[3] * q[1] + q[2] * q[0]);
  196.   m[3][0] = 0.0;
  198.   m[0][1] = 2.0 * (q[1] * q[2] + q[3] * q[0]);
  199.   m[1][1] = 1.0 - 2.0 * (q[3] * q[3] + q[1] * q[1]);
  200.   m[2][1] = 2.0 * (q[2] * q[3] - q[1] * q[0]);
  201.   m[3][1] = 0.0;
  203.   m[0][2] = 2.0 * (q[3] * q[1] - q[2] * q[0]);
  204.   m[1][2] = 2.0 * (q[2] * q[3] + q[1] * q[0]);
  205.   m[2][2] = 1.0 - 2.0 * (q[2] * q[2] + q[1] * q[1]);
  206.   m[3][2] = 0.0;
  208.   m[0][3] = 0.0;
  209.   m[1][3] = 0.0;
  210.   m[2][3] = 0.0;
  211.   m[3][3] = 1.0;
  212. }
  215. Trackball::Trackball(void)
  216.   : spinning_enabled(true),
  217.     rotating(0), spinning(0), panning(0), zooming(0),
  218.     orthographic(false),
  219.     lastTarget(NULL)
  220. {
  221.   trackball(currQuat, 0.0, 0.0, 0.0, 0.0);
  222.   setTransScale();
  223. }
  226. void
  227. Trackball::setSize(int w, int h)
  228. { 
  229.   W=w; H=h; 
  230. }
  233. // c  is camera center, 
  234. // o  is wherethe camera is looking at,
  235. // up is the up vector of the camera
  236. void
  237. Trackball::setup(float _c[3], float _o[3], float _up[3],
  238.  float r, float fov, float oblique_x, float oblique_y)
  239. {
  240.   o = Pnt3(_o);
  241.   c = Pnt3(_c);
  242.   up = Pnt3(_up);
  244.   radius = r;
  245.   field_of_view = fov;
  246.   oblique_camera_offset_x = oblique_x;
  247.   oblique_camera_offset_y = oblique_y;
  249.   resetXform();
  250.   resetAxes();
  251. }
  254. void
  255. Trackball::resetXform(void)
  256. {
  257.   trans = Pnt3();
  258.   rotating = spinning = panning = zooming = 0;
  259.   constraint = CONSTRAIN_NONE;
  260.   //bUndoable = false;
  262.   trackball(currQuat, 0.0, 0.0, 0.0, 0.0);
  263.   trackball(lastQuat, 0.0, 0.0, 0.0, 0.0);  
  264. }
  267. void
  268. Trackball::newRotationCenter(float _o[3], TbObj* target)
  269. {
  270.   Pnt3 newCtr = Pnt3(_o);
  271.   float distmoved = dist(newCtr, o);
  272.   if (!distmoved)
  273.     return;
  275.   // radius used for clipping planes
  276.   radius += distmoved;
  278.   if (target) {
  279.     target->new_rotation_center(newCtr);
  280.     return;
  281.   }
  283.   Xform<float> newTrans;
  284.   newTrans.translate (trans);
  285.   newTrans.translate (o);
  286.   newTrans.rotQ (-currQuat[0], currQuat[1], currQuat[2], currQuat[3]);
  287.   newTrans.translate (-o);
  288.   newTrans.translate (newCtr);
  289.   newTrans.rotQ (currQuat[0], currQuat[1], currQuat[2], currQuat[3]);
  290.   newTrans.translate (-newCtr);
  292.   newTrans.getTranslation (trans);
  293.   Pnt3 noBasisTrans;
  294.   float tempQ[4];
  295.   getXform (tempQ, noBasisTrans);
  297.   o = newCtr;
  298.   resetAxes();
  300.   Xform<float> newBasis;
  301.   newBasis.fromFrame (u, v, z, Pnt3());
  302.   newBasis.apply (noBasisTrans, trans);
  303. }
  306. void
  307. Trackball::changeFOV(float fov)
  308. {
  309.   field_of_view = fov;
  310. }
  313. float
  314. Trackball::getFOV (void)
  315. {
  316.   return field_of_view;
  317. }
  320. void
  321. Trackball::setObliqueCamera(float x, float y)
  322. {
  323.   oblique_camera_offset_x = x;
  324.   oblique_camera_offset_y = y;
  325. }
  327. void
  328. Trackball::resetAxes(void)
  329. {
  330.   // z is from the object to camera
  331.   z = c - o;
  332.   d = z.norm();
  333.   z /= d;
  334.   // u (x vector) is up X z
  335.   u = cross(up,z);
  336.   u.normalize();
  337.   // v (y vector) is z X u
  338.   v = cross(z,u);
  340.   //clipping planes based on camera and object
  341.   setClippingPlanes (o, radius);
  342. }
  344. void
  345. Trackball::setClippingPlanes(Pnt3 bb_ctr, float bb_r)
  346. {
  347.   // calculate the radius around o
  348.   radius = bb_r + dist(bb_ctr, o);
  350.   // calculate the distance from the camera to center of rotation,
  351.   // down the z axis -- d = distance from o to c along z, then subtract
  352.   // out the translation (also projected onto z axis)
  353.   float d_oc = d - dot (trans, z);
  354.   zfar  = d_oc+radius;
  355.   znear = zfar - 2*radius;
  357.   enforceZlimits();
  358. }
  361. void
  362. Trackball::pressButton(int button, int up, int x, int y, int t,
  363.        TbObj* target)
  364. {
  365.   spinning_enabled = atoi (Tcl_GetVar (g_tclInterp, "spinningAllowed",
  366.        TCL_GLOBAL_ONLY));
  367.   lastTarget = target;
  368.   y = (H-1)-y;
  370.   if (!panning && !spinning && !zooming) {
  371.     // new interaction... save state for undo
  372.     //saveUndoPos (target);
  373.     target->save_for_undo();
  374.   }
  376.   if (button == 1) {
  377.     if (up == 0) {
  378.       if (panning) {
  379. zooming = 1;
  380. panning = 0;
  381.       } else {
  382. rotating = 1;
  383. spinning = 0;
  384.       }
  385.     } else {
  386.       assert(up == 1);
  387.       rotating = 0;
  388.       if (zooming) {
  389. panning = 1;
  390. zooming = 0;
  392. // just stopped zooming.
  393. // clipping planes changed, so translation scale needs to change
  394. resetTransScale();
  395.       }
  396.     }
  397.   } else {
  398.     assert(button == 2);
  399.     if (up == 0) {
  400.       if (rotating) {
  401. zooming = 1;
  402. rotating  = 0;
  403.       } else 
  404. panning = 1;
  405.     } else {
  406.       assert(up == 1);
  407.       panning = 0;
  408.       spinning = 0;
  409.       if (zooming) {
  410. rotating = 1;
  411. zooming = 0;
  412.       }
  413.     }
  414.   }
  416.   // check if mouse was moving as button was released -- 
  417.   // compare timestamps
  418.   // on this event and last event; 
  419.   // if there was any significant delay
  420.   // between the release and the last mousemove, then don't spin.
  421.   if (up) {
  422.     float mousedist = (x-beginx)*(x-beginx) + (y-beginy)*(y-beginy);
  423.     if (mousedist < .2*(t-begint)) { 
  424.       // mouse moving really slow: turn off spin on release
  425.       //printf ("event age: %un", t - begint);
  426.       //fflush (stdout);
  427.       spinning = 0;      // unless they were still moving
  428.     }
  429.   }
  431.   beginx = x;
  432.   beginy = y;
  433.   begint = t;
  435. #if 0 //debug
  436.   cout << "press button" << button << (up?" up":" down") << endl;
  437.   SHOW(zooming);
  438.   SHOW(panning);
  439.   SHOW(rotating);
  440.   SHOW(spinning);
  441.   SHOW(beginx);
  442.   SHOW(beginy);
  443. #endif
  444. }
  447. void
  448. Trackball::move(int x, int y, int t, TbObj *target)
  449. {
  450.   //if (target)  cout << "move obj" << endl;
  451.   //else         cout << "move cam" << endl;
  453.   y = (H-1)-y;
  455.   if (rotating) {
  456.     trackball(lastQuat,
  457.       2.0 * beginx / W - 1.0,
  458.       2.0 * beginy / H - 1.0,
  459.       2.0 * x / W - 1.0,
  460.       2.0 * y / H - 1.0,
  461.       constraint);
  462.     /*
  463.     float phi = 2*asin(lastQuat[0]);
  464.     float mag = Pnt3(lastQuat+1).norm();
  465.     cout << "lastQuat " 
  466.  << 2*asin(lastQuat[0]) << " " 
  467.  << lastQuat[1]/mag << " " 
  468.  << lastQuat[2]/mag << " " 
  469.  << lastQuat[3]/mag << endl;
  470.     */
  471.     // let spin() apply the rotation
  472.     if (target) spin();
  473.     spinning = 1;
  474.   } else {
  475.     Pnt3 dt;
  476.     if (panning) {
  477.       float factor = transScale ? transScale : ((d-trans[2])/W);
  478.       dt[0] = factor*(x-beginx);
  479.       dt[1] = factor*(y-beginy);
  480.     }
  481.     
  482.     if (zooming) {
  483.       float focalDistance = fabs(d - dot (trans, z));
  484.       if (orthographic) {
  485. dt[2] = (beginy-y) * focalDistance / 400;
  486. orthoHeight -= dt[2];
  487. if (orthoHeight <= 1.e-6)
  488.   orthoHeight = 1.e-6;
  489.       } else {
  490. float newFocalDist = focalDistance * powf(2.0, 
  491.   (y-beginy)/80.0);
  492. dt[2] = (focalDistance - newFocalDist);
  493.       }
  495.       if (target == NULL) {
  496. // moving the camera
  497. zfar  -= dt[2];
  498. znear = zfar - 2*radius;
  499. enforceZlimits();
  500.       }
  501.     }
  503.     translateInEyeCoords (dt, target, false);
  504.   }
  506.   beginx = x;
  507.   beginy = y;
  508.   begint = t;
  510. #if 0  //debug
  511.   cout << "move" << endl;
  512.   SHOW(zooming);
  513.   SHOW(panning);
  514.   SHOW(rotating);
  515.   SHOW(spinning);
  516.   SHOW(beginx);
  517.   SHOW(beginy);
  518. #endif
  519. }
  522. void
  523. Trackball::getXform (float quat[4], float t[3])
  524. {
  525.   for (int i = 0; i < 4; i++)
  526.     quat[i] = currQuat[i];
  528.   t[0] = dot (trans, u);
  529.   t[1] = dot (trans, v);
  530.   t[2] = dot (trans, z);
  531. }
  533. void
  534. Trackball::getXform(float m[4][4], float t[3])
  535. {
  536.   float q[4];
  538.   getXform (q, t);
  539.   build_rotmatrix(m, q);
  540. }
  542. void
  543. Trackball::applyXform(int bReinitMatrix)
  544. {
  545.   spin();
  546.   reapplyXform (bReinitMatrix);
  547. }
  550. void
  551. Trackball::reapplyXform (int bReinitMatrix)
  552. {
  553.   float m[4][4], t[3];
  554.   getXform(m,t);
  555.   if (bReinitMatrix) {
  556.     glMatrixMode(GL_MODELVIEW);
  557.     glLoadIdentity();
  558.   }
  559.   glTranslatef(-c[0], -c[1], -c[2]); // move the camera
  560.   glTranslatef(t[0], t[1], t[2]);    // pan and zoom
  561.   glTranslatef(o[0], o[1], o[2]);    // rotate around origin
  562.   glMultMatrixf(&m[0][0]);
  563.   glTranslatef(-o[0], -o[1], -o[2]);
  565. #if 0
  566.   if (this != &tbView)
  567.     //  return;
  568.     cout << "mesh -- ";
  569.   else
  570.     cout << "view -- ";
  571.   cout << "applyXform:nCamera is at ";
  572.   int i;
  573.   for (i = 0; i < 3; i++) cout << c[i] << "t";
  574.   cout << endl;
  575.   cout << "translated by ";
  576.   for (i = 0; i < 3; i++) cout << t[i] << "t";
  577.   cout << endl;
  578.   cout << "Object is at ";
  579.   for (i = 0; i < 3; i++) cout << o[i] << "t";
  580.   cout << endl;
  581.   cout << "rotated by" << endl;
  582.   for (i = 0; i < 4; i++)
  583.     {
  584.       for (int j = 0; j < 4; j++)
  585. cout << m[i][j] << "t";
  586.       cout << endl;
  587.     }
  588.   cout << endl;
  589. #endif
  590. }
  593. void
  594. Trackball::enable_spinning(void)
  595. {
  596.   spinning_enabled = true;
  597. }
  600. void
  601. Trackball::disable_spinning(void)
  602. {
  603.   spinning_enabled = false;
  604. }
  607. void
  608. Trackball::spin(void)
  609. {
  610.   if (rotating || isSpinning()) {
  611.     if (lastTarget == NULL) {
  612.       add_quats(lastQuat, currQuat, currQuat);
  613.     } else {
  614.       // undo view transform, apply inverse rotation, 
  615.       // redo view transform
  616.       float q[4],cq[4],lq[4];
  617.       cq[0] = -currQuat[0]; cq[1] = currQuat[1];
  618.       cq[2] = currQuat[2]; cq[3] = currQuat[3];
  619.       lq[0] = lastQuat[0]; lq[1] = lastQuat[1];
  620.       lq[2] = lastQuat[2]; lq[3] = lastQuat[3];
  621.       add_quats(cq,lq,q);
  622.       cq[0] = -cq[0];
  623.       add_quats(q,cq,q);
  624.       lastTarget->rotate(q[0],q[1],q[2],q[3], false);
  625.     }
  626.   }
  627. }
  629. /*
  630. void
  631. Trackball::undo_last (void)
  632. {
  633.   if (!bUndoable)
  634.     return;
  636.   spinning = false;
  638.   Xform<float> redo;
  639.   if (lastTarget) {
  640.     redo = lastTarget->getXform();
  641.     lastTarget->setXform (undoPosition);
  642.   } else {
  643.     redo = getUndoXform();
  644.     this->setUndoXform (undoPosition);
  645.   }
  646.   undoPosition = redo;
  647. }
  648. */
  650. bool
  651. Trackball::isSpinning (void)
  652. {
  653.   if (!spinning_enabled) return false;
  654.   return spinning && !rotating && !zooming && !panning;
  655. }
  658. bool
  659. Trackball::isManipulating (void)
  660. {
  661.   return (spinning && spinning_enabled) || rotating || zooming || panning;
  662. }
  665. void
  666. Trackball::stop (void)
  667. {
  668.   spinning = false;
  669. }
  672. // return the viewing direction
  673. Pnt3 
  674. Trackball::dir(void)
  675. {
  676.   float m[4][4];
  677.   build_rotmatrix(m, currQuat);
  678.   return Pnt3(m[0][2],m[1][2],m[2][2]);
  679. }
  682. void
  683. Trackball::getRotationCenter (float center[3])
  684. {
  685.   for (int i = 0; i < 3; i++)
  686.     center[i] = o[i];
  687. }
  690. void
  691. Trackball::getCameraCenter (float center[3])
  692. {
  693.   for (int i = 0; i < 3; i++)
  694.     center[i] = c[i];
  695. }
  698. // rotate angle_rads radians around axis: axis can be any vector,
  699. // normalization is not necessary
  701. void
  702. Trackball::rotateAroundAxis (const Pnt3& axis, float angle_rads,
  703.      TbObj* target)
  704. {
  705.   float q[4];
  706.   Pnt3 a = axis;   // mungeable copy
  707.   axis_to_quat (a, angle_rads, q);
  708.   rotateQuat (q, target);
  709. }
  712. void
  713. Trackball::rotateQuat (float q[4], TbObj* target)
  714. {
  715.   if (target == NULL) { // rotate viewer
  716.     target->save_for_undo();
  717.     add_quats (q, currQuat, currQuat);
  718.   } else {
  719.     // undo view transform, apply inverse rotation, 
  720.     // redo view transform
  721.     float *c = currQuat;
  722.     target->rotate(-c[0], c[1], c[2], c[3]);
  723.     target->rotate(q[0], q[1], q[2], q[3], false);
  724.     target->rotate(c[0], c[1], c[2], c[3], false);
  725.   }
  726. }
  729. void
  730. Trackball::constrainRotation (TbConstraint _constraint)
  731. {
  732.   constraint = _constraint;
  733. }
  736. void
  737. Trackball::getBounds (float& left, float& right, float& bottom, float& top)
  738. {
  739.   float halfdiag = tan(0.5 * M_PI/180.0 * field_of_view) * znear;
  740.   top = halfdiag * H / sqrt(W*W+H*H);
  741.   bottom = -top;
  742.   right = W/H * top;
  743.   left = -right;
  745.   right -= oblique_camera_offset_x * znear;
  746.   left -= oblique_camera_offset_x * znear;
  747.   top -= oblique_camera_offset_y * znear;
  748.   bottom -= oblique_camera_offset_y * znear;
  749. }
  752. void
  753. Trackball::getFrustum (float& left, float& right,
  754.        float& bottom, float& top,
  755.        float& _znear, float& _zfar)
  756. {
  757.   getBounds (left, right, bottom, top);
  758.   _znear = znear;
  759.   _zfar = zfar;
  760. }
  763. void
  764. Trackball::setPerspXform(void)
  765. {
  766.   float left, right, bottom, top;
  767.   getBounds (left, right, bottom, top);
  769.   glFrustum(left, right, bottom, top, znear, zfar);
  770. }
  773. float
  774. Trackball::getOrthoHeight(void)
  775. {
  776.   // if not in orthographic mode, value won't be up-to-date
  777.   if (orthographic)
  778.     return orthoHeight;
  779.   else
  780.     return sqrt (znear * zfar);
  781. }
  784. void
  785. Trackball::setOrthoXform(void)
  786. {
  787.   float aspect = (float)W/H;
  788.   
  789.   glOrtho(-orthoHeight/2*aspect, orthoHeight/2*aspect,
  790.   -orthoHeight/2, orthoHeight/2,
  791.   znear, zfar);
  792. }
  795. void
  796. Trackball::applyProjection()
  797. {
  798.   int mm;
  799.   glGetIntegerv (GL_MATRIX_MODE, &mm);
  801.   glMatrixMode(GL_PROJECTION);
  802.   glLoadIdentity();
  804.   if (orthographic)
  805.     setOrthoXform();
  806.   else
  807.     setPerspXform();
  809.   glMatrixMode ((GLenum) mm);
  810. }
  813. void
  814. Trackball::getProjection (float &pFov, float &pAspect, 
  815.   float &pNear, float &pFar)
  816. {
  817.   pFov = field_of_view;
  818.   pAspect = (float)W / H;
  819.   pNear = znear;
  820.   pFar = zfar;
  821. }
  824. void
  825. Trackball::setOrthographic (bool bOrtho)
  826. {
  827.   if (bOrtho == orthographic)
  828.     return;  // nothing to do
  830.   orthographic = bOrtho;
  832.   // need to set new camera params to a reasonable facsimile of old ones
  833.   if (orthographic) {
  834.     // going orthographic
  835.     orthoHeight = sqrt (znear * zfar);
  836.   } else {
  837.     // going perspective
  838.     //znear = orthoHeight - radius;
  839.     //zfar = orthoHeight + radius;
  840.   }
  841.   setClippingPlanes (o, radius);
  842.   enforceZlimits();
  843. }
  846. bool
  847. Trackball::getOrthographic (void)
  848. {
  849.   return orthographic;
  850. }
  853. void
  854. Trackball::enforceZlimits (void)
  855. {
  856.   // znear needs both absolute and relative caps -- absolute because it
  857.   // has to be >0, relative because it needs to be within 24 bits of zfar
  858.   // (actually, notably less than 24 bits) to maintain z-buffer resolution
  859.   if (znear < 1.e-6)  znear = 1.e-6;
  860.   if (znear < zfar / 1.e3)
  861.     znear = zfar / 1.e3;
  862.   if (zfar < znear) zfar  = znear + 1.0;
  863. }
  866. Xform<float>
  867. Trackball::getUndoXform (void)
  868. {
  869.   Xform<float> xf;
  870.   xf.fromQuaternion (currQuat, trans[0], trans[1], trans[2]);
  872.   // need to save zoom...  here's a hack.
  873.   // in the xf, members m[0][3], m[1][3], m[2][3] are unused.
  874.   xf(3,0) = znear;
  875.   xf(3,1) = zfar;
  877.   return xf;
  878. }
  881. void
  882. Trackball::setUndoXform (const Xform<float>& xf)
  883. {
  884.   // hack -- see comments under getUndoXform
  885.   znear = xf(3,0);
  886.   zfar =  xf(3,1);
  888.   xf.toQuaternion (currQuat);
  889.   xf.getTranslation (trans);
  890. }
  893. void
  894. Trackball::translateInEyeCoords (Pnt3& dt, TbObj* target, bool undoable)
  895. {
  896.   if (target) {
  897.     // moving an object
  898.     // translate the mesh instead of camera
  899.     Pnt3 tr;
  900.     tr[0] = dot (dt, u);
  901.     tr[1] = dot (dt, v);
  902.     tr[2] = dot (dt, z);
  903.     Xform<float> xf;
  904.     xf.rotQ(-currQuat[0], currQuat[1], currQuat[2], currQuat[3]);
  905.     xf(tr);
  906.     target->translate(tr[0], tr[1], tr[2], undoable);
  907.     // note that this translate should check the scene and
  908.     // set up the correct clipping planes by calling
  909.     // Trackball::setClippingPlanes(Pnt3 ctr, float r)
  910.   } else {
  911.     // moving the camera
  912.     if (undoable)
  913.       target->save_for_undo();
  914.     trans += dt;
  915.   }
  916. }
  918. /*
  919. void
  920. Trackball::saveUndoPos (TbObj* target)
  921. {
  922.   if (target)
  923.     undoPosition = target->getXform();
  924.   else
  925.     undoPosition = this->getUndoXform();
  927.   lastTarget = target;
  928.   bUndoable = true;
  929. }
  930. */
  933. void
  934. Trackball::getState (Pnt3& _c, Pnt3& _o, Pnt3& _t, float q[4],
  935.         float& _fov, float &_oblique_x, float &_oblique_y)
  936. {
  937.   _c = c;
  938.   _o = o;
  940.   _t = trans;
  941.   for (int i = 0; i < 4; i++)
  942.     q[i] = currQuat[i];
  943.   _fov = field_of_view;
  944.   _oblique_x = oblique_camera_offset_x;
  945.   _oblique_y = oblique_camera_offset_y;
  946. }
  949. void
  950. Trackball::setState (Pnt3& _t, float q[4])
  951. {
  952.   for (int i = 0; i < 4; i++)
  953.     currQuat[i] = q[i];
  955.   trans = _t;
  956. }
  959. void
  960. Trackball::zoomToRect (int x1, int y1, int x2, int y2)
  961. {
  962.   // need to translate (at focal point) in screen plane, such that
  963.   // given rect goes to center of screen, then translate perpendicular
  964.   // to screen plane to zoom in by ratio of area of rect to screen
  966.   int rectW = x2 - x1;
  967.   int rectH = y2 - y1;
  969.   int cx = x1 + rectW / 2;
  970.   int cy = y1 + rectH / 2;
  972.   int dx = W / 2 - cx;
  973.   int dy = H / 2 - cy;
  975.   float zoom = MIN ((float)W / rectW, (float)H / rectH);
  977.   // now need to translate such that in screen coords, we go (dx, dy, dz)
  978.   // where dz gives the desired zoom factor.
  980.   // copied from ::move:
  981.   Pnt3 dt;
  983.   float factor = transScale ? transScale: ((d-trans[2])/W);
  984.   dt[0] = factor*(dx);
  985.   dt[1] = factor*(dy);
  987.   dt[2] = (d - trans[2]) * (1 - 1/zoom);
  989.   // and go there!
  990.   translateInEyeCoords (dt, NULL, true);
  991.   setClippingPlanes (o, radius);
  992. }
  995. void
  996. Trackball::setTransScale (const Pnt3& clickPt)
  997. {
  998.   if (clickPt[2] != 0.) {
  999.     float zeye = znear * zfar / (clickPt[2] * (zfar - znear) - zfar);
  1000.     //cerr << "setting near-click-far = " << znear << " " << zeye << " "
  1001.     // << zfar << " (" << clickPt[2] << ")" << endl;
  1002.     
  1003.     // copied from Trackball::setPerspXform
  1004.     float halfdiag = tan(0.5 * M_PI/180.0 * field_of_view) * zeye;
  1005.     float top = halfdiag / sqrt(W*W + H*H);
  1006.     transScale = (-2 * top);
  1008.     // save point that we're using as translation reference, in world
  1009.     // coords, in case we need to reproject it
  1010.     Unprojector unp (this);
  1011.     transScaleReference = unp (clickPt[0], clickPt[1], clickPt[2]);
  1012.   } else {
  1013.     transScale = 0.;
  1014.     transScaleReference = Pnt3 (0, 0, 0);
  1015.   }
  1016. }
  1019. void
  1020. Trackball::resetTransScale (void)
  1021. {
  1022.   // recomputes transScale based on previous point passed to
  1023.   // setTransScale -- useful if clipping planes change, ie after zoom.
  1025.  if (transScaleReference[2]) {
  1026.    // it doesn't suffice to recompute the transScale using the new
  1027.    // znear/zfar and old zscale value, because the zscale value (read from 
  1028.    // depth buffer) will be different for the same pixel with old and new
  1029.    // clipping planes.  Need to reproject it.
  1030.    Projector proj (this);
  1031.    Pnt3 rep = proj (transScaleReference);
  1032.    setTransScale (rep);
  1033.  }
  1034. }