Source/System/Window/Utilities/OSGNavballEngine.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *             Copyright (C) 2000-2002 by the OpenSG Forum                   *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 #include "OSGConfig.h"
  40 #include "OSGBaseTypes.h"
  41 #include "OSGMatrix.h"
  42 #include "OSGMatrixUtility.h"
  43
  44 #include "OSGNavballEngine.h"
  45 #include "OSGNavigator.h"
  46 #include "OSGNode.h"
  47 #include "OSGCamera.h"
  48 #include "OSGBackground.h"
  49
  50 OSG_USING_NAMESPACE
  51
  52 /***************************************************************************\
  53  *                            Description                                  *
  54 \***************************************************************************/
  55
  56 /*! \class OSG::NavballEngine
  57     \ingroup GrpSystemWindowNavigators
  58
  59 The NavballEngine models a navigation model based on a rotating sphere,
  60 see \ref PageSystemWindowNavigatorsNavball for a description.
  61
  62 \dev
  63
  64 \enddev
  65
  66 */
  67
  68 /*! \var Real32 NavballEngine::_rRadius
  69
  70     The size of the trackball, relative to the screen size. Per default it is
  71     0.8.
  72 */
  73
  74 /*! \var Real32 NavballEngine::_rDistance
  75
  76     The distance of the viewer from the target point.
  77 */
  78
  79 /*! \var Matrix NavballEngine::_tMatrix
  80
  81     Temporary matrix for calculation.
  82 */
  83
  84 /*! \var Matrix NavballEngine::_finalMatrix
  85
  86     The resulting matrix for the final transformation.
  87 */
  88
  89 /*! \var State NavballEngine::_currentState
  90
  91     The current state of the trackball, whether it is currently rotating,
  92     translating in xy or in z.
  93 */
  94
  95 /*! \var Pnt3f  NavballEngine::_pFrom
  96
  97     The viewer position.
  98 */
  99
 100 /*! \var Pnt3f NavballEngine::_pAt
 101
 102     The target position.
 103 */
 104
 105 /*! \var Vec3f  NavballEngine::_vUp
 106
 107     The Up direction.
 108 */
 109
 110 /*! \var Navigator::_ip
 111
 112     Temporary hit point for intersection testing.
 113 */
 114
 115 /*! \var Navigator::_dir
 116
 117     Temporary ray direction for intersection testing.
 118 */
 119
 120 NavballEngineTransitPtr NavballEngine::create(Real32 rSize)
 121 {
 122     return NavballEngineTransitPtr(new NavballEngine(rSize));
 123 }
 124
 125 /*------------------------------ get --------------------------------------*/
 126
 127
 128 /*! Get the viewer position.
 129     The final matrix needs to be valid for this to work, if in doubt, call
 130     updateFinalMatrix() beforehand.
 131 */
 132 const Pnt3f &NavballEngine::getFrom(void)
 133 {
 134     return _pFrom;
 135 }
 136
 137 /*! Get the target position.
 138     The final matrix needs to be valid for this to work, if in doubt, call
 139     updateFinalMatrix() beforehand.
 140 */
 141 const Pnt3f &NavballEngine::getAt(void)
 142 {
 143     return _pAt;
 144 }
 145
 146 /*! Get the up direction.
 147     The final matrix needs to be valid for this to work, if in doubt, call
 148     updateFinalMatrix() beforehand.
 149 */
 150 const Vec3f &NavballEngine::getUp(void)
 151 {
 152     return _vUp;
 153 }
 154
 155 /*! Get the current transformation matrix.
 156 */
 157 const Matrix &NavballEngine::getMatrix(void)
 158 {
 159     updateFinalMatrix();
 160
 161     return _finalMatrix;
 162 }
 163
 164 Real32 NavballEngine::getDistance(void)
 165 {
 166     return _rDistance;
 167 }
 168
 169 /*------------------------------ set --------------------------------------*/
 170
 171 /*! Sets the from point, i.e. the viewer position.
 172 */
 173 void NavballEngine::setFrom(Pnt3f new_from)
 174 {
 175     set(new_from, getAt(), getUp());
 176 }
 177
 178 /*! Sets the at point, the target point and center of the window.
 179 */
 180 void NavballEngine::setAt(Pnt3f new_at)
 181 {
 182     set(getFrom(), new_at, getUp());
 183 }
 184
 185 /*! Sets the up vector.
 186 */
 187 void NavballEngine::setUp(Vec3f new_up)
 188 {
 189     set(getFrom(), getAt(), new_up);
 190 }
 191
 192 /*! Set all viewer parameters of the navigator separately.
 193 */
 194 void NavballEngine::set(Pnt3f new_from, Pnt3f new_at, Vec3f new_up)
 195 {
 196     bool b = MatrixLookAt(_finalMatrix,
 197
 198                           new_at,
 199                           new_at + (new_at - new_from),
 200                           new_up                      );
 201     if(!b)
 202     {
 203         _pFrom = new_from;
 204         _pAt   = new_at;
 205         _vUp   = new_up;
 206
 207         _rDistance = (_pAt - _pFrom).length();
 208
 209         updateFinalMatrix();
 210     }
 211     else
 212     {
 213         FNOTICE(("NavballEngine: set(.,.,.), failed"));
 214     }
 215 }
 216
 217 /*! Set all viewer parameters of the navigator with a single matrix.
 218
 219     \note The matrix does not contain all information needed for
 220     the NavballNavigator, it is therefore preferable to use
 221     NavballNavigator::set(Pnt3f,Pnt3f,Vec3f) to set the values, especially
 222     when copying from one NavballNavigator to another one.
 223 */
 224 void NavballEngine::set(const Matrix &new_matrix)
 225 {
 226     // get distance
 227     Vec3f translation( new_matrix[3][0], new_matrix[3][1], new_matrix[3][2]);
 228
 229     _rDistance = translation.length();
 230
 231     _pFrom = Pnt3f(new_matrix[3]);
 232     _pAt   = Pnt3f(new_matrix[3] - (_rDistance * new_matrix[2]));
 233     _vUp   = Vec3f(new_matrix[1]);
 234     _vUp   = Vec3f(0.0f, 1.0f, 0.0f);
 235 }
 236
 237 /*! Sets the distance from the target point in the view direction.
 238 */
 239 void NavballEngine::setDistance(Real32 new_distance)
 240 {
 241     _rDistance = new_distance;
 242
 243     updateFinalMatrix();
 244 }
 245
 246
 247 /*--------------------  navigator engine callbacks ------------------------*/
 248
 249 void NavballEngine::buttonPress(Int16      button,
 250                                 Int16      x,
 251                                 Int16      y,
 252                                 Navigator *nav   )
 253 {
 254     switch (button)
 255     {
 256         case Navigator::LEFT_MOUSE  :
 257             _currentState = Navigator::ROTATING;
 258             break;
 259
 260         case Navigator::RIGHT_MOUSE :
 261             _currentState = Navigator::TRANSLATING_Z;
 262             break;
 263
 264         case Navigator::MIDDLE_MOUSE:
 265             _currentState = Navigator::TRANSLATING_XY;
 266             getIntersectionPoint(x,y, nav);
 267             break;
 268
 269         case Navigator::UP_MOUSE    :
 270             _currentState = Navigator::IDLE;
 271             translateZ(-nav->getMotionFactor());
 272             break;
 273
 274         case Navigator::DOWN_MOUSE  :
 275             _currentState = Navigator::IDLE;
 276             translateZ(nav->getMotionFactor());
 277             break;
 278
 279         default:
 280             FNOTICE(("NavballEngine: buttonPress, unknown button\n"));
 281             break;
 282     }
 283 }
 284
 285 void NavballEngine::buttonRelease(Int16, Int16 x, Int16 y, Navigator* nav)
 286 {
 287    /* if (!nav->getMoved() && nav->getClickCenter())
 288     {
 289         Viewport        *vp  = nav->getViewport();
 290         IntersectAction *act = IntersectAction::create();
 291         Line line;
 292         vp->getCamera()->calcViewRay(line, x, y, *vp);
 293
 294         Pnt3f lp1 = line.getPosition();
 295         Vec3f ld1 = line.getDirection();
 296
 297         act->setLine(line);
 298         act->apply(vp->getRoot());
 299         if (act->didHit())
 300         {
 301             Pnt3f p1 = act->getHitPoint();
 302             setAt(p1);
 303         }
 304
 305         delete act;
 306     }*/
 307
 308     _currentState = Navigator::IDLE;
 309 }
 310
 311 void NavballEngine::keyPress(Int16 key, Int16 , Int16, Navigator *nav)
 312 {
 313     switch (key)
 314     {
 315         case Navigator::LEFT:
 316             /*undefined*/
 317             break;
 318         case Navigator::RIGHT:
 319             /*undefined*/
 320             break;
 321         case Navigator::FORWARDS:
 322             translateZ(-nav->getMotionFactor());
 323             break;
 324         case Navigator::BACKWARDS:
 325             translateZ(nav->getMotionFactor());
 326             break;
 327         default:
 328             FNOTICE(("NavballEngine: keyPress, unknown key\n"));
 329     }
 330 }
 331
 332 void NavballEngine::moveTo(Int16 x, Int16 y, Navigator* nav)
 333 {
 334
 335     Real32 fromX, fromY, toX, toY;
 336
 337     nav->calcFromTo(x, y, fromX, fromY, toX, toY);
 338
 339     switch (_currentState)
 340     {
 341         case Navigator::ROTATING:
 342             rotate(fromX, fromY, toX, toY);
 343             break;
 344
 345         case Navigator::TRANSLATING_XY:
 346         {
 347             Real32 distX = 0.0f;
 348             Real32 distY = 0.0f;
 349             Int16  lastX = nav->getLastX();
 350             Int16  lastY = nav->getLastY();
 351
 352             calcDeltas(lastX, lastY, x, y, distX, distY, nav);
 353             translateXY(distX, distY);
 354         }
 355         break;
 356
 357         case Navigator::TRANSLATING_Z:
 358         {
 359             Real32 distance = osgSgn(toY-fromY) * 100.f;
 360
 361             distance *= osgPow(osgAbs(toY-fromY), 2.f);
 362
 363             translateZ(distance * nav->getMotionFactor());
 364         }
 365         break;
 366
 367         default:
 368             //IDLE
 369             break;
 370     }
 371 }
 372
 373 void NavballEngine::idle(Int16 buttons, Int16 x, Int16 y, Navigator* nav)
 374 {
 375     // nothing to do
 376 }
 377
 378 /*-------------------- Navball Transformations --------------------------*/
 379
 380 /*! Rotate the trackball sphere for a mouse movement from \a fromX, \a fromY to
 381     \a toX, \a toY.
 382 */
 383 void NavballEngine::rotate(Real32 fromX, Real32 fromY, Real32 toX, Real32 toY)
 384 {
 385     if(osgAbs(fromX - toX) > TypeTraits<Real32>::getDefaultEps() ||
 386        osgAbs(fromY - toY) > TypeTraits<Real32>::getDefaultEps()   )
 387     {
 388
 389         Vec3f Up(0.0f,1.0f,0.0f);
 390         Vec3f Forward(_pAt - _pFrom);
 391         Forward.normalize();
 392         //Up.normalize();
 393         Vec3f Right = Forward.cross(Up);
 394
 395         Quaternion YRot(_vUp,(fromX - toX)*0.8);
 396         Matrix YRotMat;
 397         YRot.getValue(YRotMat);
 398
 399         Real32 XRotAngle((fromY - toY)*-0.5);
 400         Real32 CurAngle(osgACos(Forward.dot(Up)));
 401         if(CurAngle > 1.5707f)
 402         {
 403             if(osgSgn(XRotAngle) != osgSgn(CurAngle) &&
 404                osgAbs(3.141592f - CurAngle) < osgAbs(XRotAngle))
 405             {
 406                 XRotAngle = 0.0f;
 407             }
 408         }
 409         else
 410         {
 411             if(osgSgn(XRotAngle) == osgSgn(CurAngle) &&
 412                osgAbs(CurAngle) < osgAbs(XRotAngle))
 413             {
 414                 XRotAngle = 0.0f;
 415             }
 416         }
 417         Quaternion XRot(Right,XRotAngle);
 418         Matrix XRotMat;
 419         XRot.getValue(XRotMat);
 420
 421         Pnt3f PrevFrom(_pFrom);
 422         Vec3f PrevForward(Forward);
 423         _pFrom -= _pAt.subZero();
 424         XRotMat.mult(_pFrom,_pFrom);
 425         YRotMat.mult(_pFrom,_pFrom);
 426         _pFrom += _pAt.subZero();
 427     }
 428 }
 429
 430 /*! Translate in the XY plane.
 431 */
 432 void NavballEngine::translateXY(Real32 distanceX, Real32 distanceY)
 433 {
 434     Vec3f Up(0.0f,1.0f,0.0f);
 435     Vec3f Forward(_pAt - _pFrom);
 436     Forward.normalize();
 437     //Up.normalize();
 438     Vec3f Right = Forward.cross(Up);
 439     Up = Right.cross(Forward);
 440
 441     Vec3f Displacement(Right*distanceX + Up*distanceY);
 442     _pFrom += Displacement;
 443     _pAt += Displacement;
 444 }
 445
 446 /*! Translate along the Z-axis.
 447 */
 448
 449 void NavballEngine::translateZ(Real32 distance)
 450 {
 451     Vec3f Up(_vUp);
 452     Vec3f Forward(_pAt - _pFrom);
 453     Forward.normalize();
 454
 455     Vec3f Displacement(Forward*distance);
 456     _pFrom += Displacement;
 457
 458     if(_pFrom.dist2(_pAt) < distance*distance)
 459     {
 460         _pAt += Displacement;
 461     }
 462 }
 463
 464 /*------------------------- constructors ----------------------------------*/
 465
 466 NavballEngine::NavballEngine(Real32 rSize) :
 467      Inherited(       ),
 468     _ip       (0, 0, 0),
 469     _dir      (0, 0, 0)
 470 {
 471     _finalMatrix.setIdentity();
 472
 473     _pFrom.setValues(0, 0, 0);
 474     _pAt  .setValues(0, 0, 1);
 475     _vUp  .setValues(0, 1, 0);
 476
 477     _rDistance=(_pAt - _pFrom).length();
 478 }
 479
 480 /*-------------------------- destructors ----------------------------------*/
 481
 482 NavballEngine::~NavballEngine()
 483 {
 484 }
 485
 486 /*! Calculate the final matrix, the matrix that reflects the actual state of
 487     the NavballEngine.
 488 */
 489 void NavballEngine::updateFinalMatrix()
 490 {
 491     MatrixLookAt(_finalMatrix, _pFrom, _pAt, _vUp);
 492 }
 493
 494 static void myCalcCCtoWCMatrix(      Matrix   &       cctowc,
 495                                const Matrix   &       view,
 496                                      Viewport * const port  )
 497 {
 498     Matrix proj, projtrans;
 499
 500     if(port == NULL)
 501         return;
 502
 503     port->getCamera()->getProjection( proj, port->calcPixelWidth(),
 504                                             port->calcPixelHeight());
 505
 506     port->getCamera()->getProjectionTranslation( projtrans,
 507                                                  port->calcPixelWidth(),
 508                                                  port->calcPixelHeight());
 509
 510     Matrix wctocc = proj;
 511     wctocc.mult( projtrans );
 512     wctocc.mult( view );
 513
 514     cctowc.invertFrom( wctocc );
 515 }
 516
 517 /*! Calculates the intersection point of a ray that starts at from and goes
 518     through the position on the screen given by x,y with the world, if no
 519     intersection point exists the intersection is set to (0,0,0)
 520 */
 521 void NavballEngine::getIntersectionPoint(Int16 x, Int16 y, Navigator *nav)
 522 {
 523     Viewport *vp  = nav->getViewport();
 524     Line      line;
 525
 526     if(vp == NULL)
 527         return;
 528
 529     vp->getCamera()->calcViewRay(line, x, y, *vp);
 530
 531     if(nav->getClickNoIntersect())
 532     {
 533         Real32 u = (_dir.dot(Pnt3f(0.0f, 0.0f, 0.0f) - line.getPosition())) /
 534                    (_dir.dot(line.getDirection()));
 535         _ip = line.getPosition() + u * line.getDirection();
 536         return;
 537     }
 538
 539     IntersectActionRefPtr act = IntersectAction::create();
 540     act->setLine(line);
 541     act->apply(vp->getRoot());
 542
 543     Matrix cctowc,view;
 544     Int16 width  = vp->calcPixelWidth();
 545     Int16 height = vp->calcPixelHeight();
 546
 547     vp->getCamera()->getViewing(view, width, height);
 548
 549     myCalcCCtoWCMatrix(cctowc, view, vp);
 550
 551     Pnt3f at,to;
 552
 553     cctowc.multFull( Pnt3f( 0, 0, 0.5f ), to );
 554     cctowc.multFull( Pnt3f( 0, 0, 1    ), at );
 555
 556     _dir = to - at;
 557
 558     if (act->didHit())
 559     {
 560         _ip = act->getHitPoint();
 561     }
 562     else
 563     {
 564         Real32 u = (_dir.dot(Pnt3f(0.0f, 0.0f, 0.0f) - line.getPosition())) /
 565                    (_dir.dot(line.getDirection()));
 566         _ip = line.getPosition() + u * line.getDirection();
 567     }
 568
 569     act = NULL;
 570 }
 571
 572 /*! Calculate the real translation that has to be done, so that the
 573     trackball can actually drag the object in the plane parallel to the
 574     screen.
 575 */
 576 void NavballEngine::calcDeltas(Int16,
 577                                Int16,
 578                                Int16   toX,
 579                                Int16   toY,
 580                                Real32    &distanceX,
 581                                Real32    &distanceY,
 582                                Navigator *nav)
 583 {
 584     Matrix    view = getMatrix();
 585     Viewport *vp   = nav->getViewport();
 586
 587     if(vp == NULL)
 588         return;
 589
 590     Pnt3f from( view[3][0], view[3][1], view[3][2] );
 591
 592     view.invert();
 593     Matrix cctowc;
 594     myCalcCCtoWCMatrix(cctowc, view, vp);
 595
 596     Real32 rx(0.f), ry(0.f);
 597     vp->calcNormalizedCoordinates(rx, ry, toX, toY);
 598
 599     Pnt3f at;
 600     cctowc.multFull( Pnt3f( rx, ry, 1 ), at );
 601
 602     Line line2;
 603     line2.setValue(from, at-from);
 604
 605     Real32 u = (_dir.dot(_ip-line2.getPosition())) /
 606                (_dir.dot(line2.getDirection()));
 607
 608     Pnt3f p2 = line2.getPosition() + u * line2.getDirection();
 609
 610     Vec3f transl;
 611     transl[0] = -p2[0] + _ip[0];
 612     transl[1] = -p2[1] + _ip[1];
 613     transl[2] = -p2[2] + _ip[2];
 614
 615     view.mult(transl, transl);
 616
 617     distanceX = transl[0];
 618     distanceY = transl[1];
 619 }