Source/System/Window/Utilities/OSGNavigator.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *             Copyright (C) 2000,2001 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 #include "OSGCamera.h"
  44 #include "OSGTransform.h"
  45
  46 #include "OSGNavigator.h"
  47
  48 OSG_USING_NAMESPACE
  49
  50 /***************************************************************************\
  51  *                            Description                                  *
  52 \***************************************************************************/
  53
  54 /*! \class OSG::Navigator
  55     \ingroup GrpSystemWindowNavigators
  56
  57     The general Navigator helper class, see \ref
  58     PageSystemWindowNavigatorsNavigator for a description.
  59
  60
  61 */
  62
  63
  64 /*! \enum OSG::NavigatorBase::Mode
  65
  66     The navigation mode, i.e. the actual active low-level navigator.
  67     The NONE case is also used for the purpose of matrix consistency.
  68 */
  69
  70
  71 /*! \enum OSG::NavigatorBase::State
  72
  73     The navigation state, mainly needed for correct interpretation of mouse
  74     motions, which have to be interpreted differently for  different states.
  75     Interpretation also depends on the currently active Navigator::Mode.
  76 */
  77
  78 /*! \var NavigatorBase::State NavigatorBase::IDLE
  79
  80     Inactive state.
  81 */
  82
  83 /*! \var NavigatorBase::State NavigatorBase::ROTATING
  84
  85     State for in-place rotation.
  86 */
  87
  88 /*! \var NavigatorBase::State NavigatorBase::TRANSLATING_XY
  89
  90     State for x/y translation, used by the Trackball case.
  91 */
  92
  93 /*! \var NavigatorBase::State NavigatorBase::TRANSLATING_Z
  94
  95     State for z translation, used by the Trackball case.
  96 */
  97
  98 /*! \var NavigatorBase::State NavigatorBase::TRANSLATING_ZPLUS
  99
 100     State for rotation with automatic forward motion. The standard fly forward
 101     state.
 102 */
 103
 104 /*! \var NavigatorBase::State NavigatorBase::TRANSLATING_ZMINUS
 105
 106     State for rotation with automatic backwards motion. The standard fly
 107     backwards state.
 108 */
 109
 110
 111 /*! \enum OSG::NavigatorBase::MouseButton
 112
 113     Abstraction enumeration for mouse buttons, to keep the Navigator
 114     independent of the actual Window System.
 115 */
 116
 117 /*! \var NavigatorBase::MouseButton NavigatorBase::UP_MOUSE
 118
 119     Mouse wheel up button.
 120 */
 121
 122 /*! \var NavigatorBase::MouseButton NavigatorBase::DOWN_MOUSE
 123
 124     Mouse wheel down button.
 125 */
 126
 127
 128 /*! \enum OSG::NavigatorBase::Key
 129
 130     Abstraction enumeration for keys, to keep the Navigator
 131     independent of the actual Window System.
 132 */
 133
 134
 135
 136 /*! \var Navigator::_rMotionFactor
 137
 138     The motion factor, roughly equivalent to speed.
 139 */
 140
 141 /*------------------------- constructors ----------------------------------*/
 142
 143 Navigator::Navigator() :
 144
 145     _engine          (NULL                     ), // pointer to current engine
 146
 147     _trackballEngine (TrackballEngine::create()),
 148     _flyEngine       (FlyEngine      ::create()),
 149     _walkEngine      (WalkEngine     ::create()),
 150     _navballEngine   (NavballEngine  ::create()),
 151     _noneEngine      (NoneEngine     ::create()),
 152     _userEngine      (TrackballEngine::create()),
 153
 154     _rRotationAngle  (0.04908739f              ),
 155     _rMotionFactor   (1.f                      ),
 156     _absolute        (true                     ),
 157     _vp              (NULL                     ),
 158     _cartN           (NULL                     ),
 159     _moved           (false                    ),
 160     _clickCenter     (true                     ),
 161     _clickNoIntersect(false                    ),
 162     _lastX           (0                        ),
 163     _lastY           (0                        ),
 164     _width           (0                        ),
 165     _height          (0                        ),
 166     _theMatrix       (                         )
 167 {
 168     setMode(TRACKBALL); // use trackball as default
 169 }
 170
 171 /*-------------------------- destructors ----------------------------------*/
 172
 173 Navigator::~Navigator(void)
 174 {
 175     _cartN = NULL;
 176     _vp    = NULL;
 177
 178     _engine          = NULL;
 179     _trackballEngine = NULL;
 180     _flyEngine       = NULL;
 181     _walkEngine      = NULL;
 182     _navballEngine   = NULL;
 183     _noneEngine      = NULL;
 184     _userEngine      = NULL;
 185 }
 186
 187 /*-------------------------- Notificators ---------------------------------*/
 188
 189 /*! Mouse button press handler.
 190 */
 191 void Navigator::buttonPress(Int16 button, Int16 x, Int16 y)
 192 {
 193     _lastX = x;
 194     _lastY = y;
 195
 196     _moved = false;
 197
 198     _engine->buttonPress(button, x, y, this);
 199 }
 200
 201 /*! Mouse button release handler.
 202 */
 203 void Navigator::buttonRelease(Int16 button, Int16 x, Int16 y)
 204 {
 205     _engine->buttonRelease(button, x, y, this);
 206 }
 207
 208 /*! Key press handler.
 209 */
 210 void Navigator::keyPress(Int16 key, Int16 x, Int16 y)
 211 {
 212     _engine->keyPress(key, x, y, this);
 213 }
 214
 215 /*! Mouse motion handler.
 216 */
 217 void Navigator::moveTo(Int16 x, Int16 y)
 218 {
 219     _moved = true;
 220
 221     Real32 fromX, fromY, toX, toY;
 222
 223     if(!calcFromTo(x, y, fromX, fromY, toX, toY))
 224         return;
 225
 226     _engine->moveTo(x, y, this);
 227
 228     _lastX = x;
 229     _lastY = y;
 230 }
 231
 232 /*! Performs some idle operations, depending on the current navigation mode
 233  */
 234 void Navigator::idle(Int16 buttons, Int16 x, Int16 y)
 235 {
 236     _engine->idle(buttons, x, y, this);
 237 }
 238
 239 void Navigator::buttonPress(Int16 button,
 240                             Int16 x,
 241                             Int16 y,
 242                             Int16 width,
 243                             Int16 height )
 244 {
 245     this->_width  = width;
 246     this->_height = height;
 247
 248     this->buttonPress(button, x, y);
 249 }
 250
 251 void Navigator::buttonRelease(Int16 button,
 252                               Int16 x,
 253                               Int16 y,
 254                               Int16 width,
 255                               Int16 height )
 256 {
 257     this->_width  = width;
 258     this->_height = height;
 259
 260     this->buttonRelease(button, x, y);
 261 }
 262
 263 void Navigator::keyPress(Int16 key,
 264                          Int16 x,
 265                          Int16 y,
 266                          Int16 width,
 267                          Int16 height )
 268 {
 269     this->_width  = width;
 270     this->_height = height;
 271
 272     this->keyPress(key, x, y);
 273 }
 274
 275 void Navigator::moveTo(Int16 x,
 276                        Int16 y,
 277                        Int16 width,
 278                        Int16 height )
 279 {
 280     this->_width  = width;
 281     this->_height = height;
 282
 283     this->moveTo(x, y);
 284 }
 285
 286 void Navigator::idle(Int16 buttons,
 287                      Int16 x,
 288                      Int16 y,
 289                      Int16 width,
 290                      Int16 height )
 291 {
 292     this->_width  = width;
 293     this->_height = height;
 294
 295     this->idle(buttons, x, y);
 296 }
 297
 298
 299 /*! Updates the camera transformation matrix directly in the node specified as
 300     the cart.
 301 */
 302 void Navigator::updateCameraTransformation(void)
 303 {
 304     _theMatrix.setIdentity();
 305
 306     if(_absolute && _cartN != NULL && _cartN->getParent() != NULL)
 307     {
 308         _cartN->getParent()->getToWorld(_theMatrix);
 309
 310         _theMatrix.inverse(_theMatrix);
 311     }
 312
 313     _engine->onUpdateCameraTransformation(this);
 314
 315     _theMatrix.mult(_engine->getMatrix());
 316
 317     if(_cartN != NULL)
 318     {
 319         Transform *t = dynamic_cast<Transform *>(_cartN->getCore());
 320
 321         if(t == NULL)
 322         {
 323             FWARNING (("Navigator: updateCamTrans, "
 324                        "core is not TransformPtr\n"));
 325         }
 326         else
 327         {
 328             if(t->getMatrix() != _theMatrix)
 329             {
 330                 t->setMatrix(_theMatrix);
 331             }
 332         }
 333     }
 334     else
 335     {
 336         FFATAL (("!_cartN in Navigator::updateCameraTrans\n"));
 337     }
 338 }
 339
 340 /*------------------------------ set --------------------------------------*/
 341
 342 /*! Set the navigator mode (Trackball/Flyer/Walker).
 343 */
 344 void Navigator::setMode(Navigator::Mode new_mode, bool copyViewParams)
 345 {
 346     NavigatorEngine *engine = _trackballEngine;
 347
 348     switch (new_mode)
 349     {
 350         case TRACKBALL:
 351             engine = _trackballEngine;
 352             break;
 353
 354         case FLY:
 355             engine = _flyEngine;
 356             break;
 357
 358         case WALK:
 359             engine = _walkEngine;
 360             break;
 361
 362         case NAVBALL:
 363             engine = _navballEngine;
 364             break;
 365
 366         case NONE:
 367             engine = _noneEngine;
 368             break;
 369
 370         case USER:
 371             engine = _userEngine;
 372             break;
 373
 374         default:
 375             FWARNING (("Navigator: unknown mode. Fallback to trackball.\n"));
 376     }
 377
 378     assert(engine);
 379
 380     if(engine != _engine)
 381     {
 382         if(copyViewParams && _engine)
 383             engine->set(_engine->getFrom(), _engine->getAt(), _engine->getUp());
 384
 385         _engine = engine;
 386
 387         _engine->onActivation(this);
 388     }
 389 }
 390
 391 /*! Set the rotation angle.
 392 */
 393 void Navigator::setRotationAngle(Real32 new_angle)
 394 {
 395     _rRotationAngle = new_angle;
 396 }
 397
 398 /*! Set the motion factor.
 399 */
 400 void Navigator::setMotionFactor(Real32 new_factor)
 401 {
 402     _rMotionFactor = new_factor;
 403 }
 404
 405 /*! Set the viewport.
 406 */
 407 void Navigator::setViewport(Viewport *new_viewport)
 408 {
 409     _vp = new_viewport;
 410
 411     _engine->onViewportChanged(this);
 412 }
 413
 414 /*! Set the from point, i.e. the viewer position.
 415 */
 416 void Navigator::setFrom(Pnt3f new_from)
 417 {
 418     _engine->setFrom(new_from);
 419 }
 420
 421 /*! Set the at point, i.e. the target position for the viewer.
 422 */
 423 void Navigator::setAt(Pnt3f new_at)
 424 {
 425     _engine->setAt(new_at);
 426 }
 427
 428 /*! Set the distance from the target position.
 429 */
 430 void Navigator::setDistance(Real32 new_distance)
 431 {
 432     _engine->setDistance(new_distance);
 433 }
 434
 435
 436 /*! Set the up vector, i.e. the vertical direction on screen.
 437 */
 438 void Navigator::setUp(Vec3f new_up)
 439 {
 440     _engine->setUp(new_up);
 441 }
 442
 443 /*! Set the full navigator parameters.
 444 */
 445 void Navigator::set(Pnt3f new_from, Pnt3f new_at, Vec3f new_up)
 446 {
 447     _engine->set(new_from, new_at, new_up);
 448 }
 449
 450 /*! Set the full navigator parameters from a matrix.
 451 */
 452 void Navigator::set(const Matrix & new_matrix)
 453 {
 454     _engine->set(new_matrix);
 455 }
 456
 457
 458 /*! Set the camera transformation node.
 459 */
 460 void Navigator::setCameraTransformation(Node * const new_cartn)
 461 {
 462     if (new_cartn == NULL)
 463     {
 464         FWARNING (("Set _cartN in Navigator to NULL\n"));
 465     }
 466
 467     _cartN = new_cartn;
 468 }
 469
 470 /*------------------------------ get --------------------------------------*/
 471
 472 /*! Get the transformation matrix.
 473 */
 474 const Matrix &Navigator::getMatrix(void)
 475 {
 476     return _engine->getMatrix();
 477 }
 478
 479 /*! Get the from point, i.e. the viewer position.
 480 */
 481 const Pnt3f &Navigator::getFrom(void)
 482 {
 483     return _engine->getFrom();
 484 }
 485
 486 /*! Get the at point, i.e. the target position.
 487 */
 488 const Pnt3f &Navigator::getAt(void)
 489 {
 490     return _engine->getAt();
 491 }
 492
 493 /*! Get the up vector.
 494 */
 495 const Vec3f &Navigator::getUp(void)
 496 {
 497     return _engine->getUp();
 498 }
 499
 500
 501 /*! Get the distance from the target position.
 502 */
 503 Real32 Navigator::getDistance(void)
 504 {
 505     return _engine->getDistance();
 506 }
 507
 508 /*! Get the navigator's current state.
 509 */
 510 Navigator::State Navigator::getState(void)
 511 {
 512     return _engine->getState();
 513 }
 514
 515 /*! Get the navigator's current mode.
 516 */
 517 Navigator::Mode Navigator::getMode(void)
 518 {
 519     if(_engine == _trackballEngine)
 520         return TRACKBALL;
 521
 522     if(_engine == _flyEngine)
 523         return FLY;
 524
 525     if(_engine == _walkEngine)
 526         return WALK;
 527
 528     if(_engine == _navballEngine)
 529         return NAVBALL;
 530
 531     if(_engine == _noneEngine)
 532         return NONE;
 533
 534     return USER;
 535 }
 536
 537 /*! Get the navigator's rotation angle.
 538 */
 539 Real32 Navigator::getRotationAngle(void)
 540 {
 541     return _rRotationAngle;
 542 }
 543
 544 /*! Get the navigator's motion factor
 545 */
 546 Real32 Navigator::getMotionFactor(void)
 547 {
 548     return _rMotionFactor;
 549 }
 550
 551 /*! Get the absolute current state.
 552 */
 553 bool Navigator::getAbsolute(void)
 554 {
 555     return _absolute;
 556 }
 557
 558 /*! Get the clickCenter current state.
 559 */
 560 bool Navigator::getClickCenter(void)
 561 {
 562     return _clickCenter;
 563 }
 564
 565 /*! Get the clickNoIntersect current state.
 566 */
 567 bool Navigator::getClickNoIntersect(void)
 568 {
 569     return _clickNoIntersect;
 570 }
 571
 572
 573 bool Navigator::getMoved(void)
 574 {
 575     return _moved;
 576 }
 577
 578 Viewport *Navigator::getViewport(void)
 579 {
 580     return _vp;
 581 }
 582
 583 Int16 Navigator::getLastX(void)
 584 {
 585     return _lastX;
 586 }
 587
 588 Int16 Navigator::getLastY(void)
 589 {
 590     return _lastY;
 591 }
 592
 593 NavballEngine &Navigator::getNavballEngine(void)
 594 {
 595     return *_navballEngine;
 596 }
 597
 598 TrackballEngine &Navigator::getTrackballEngine(void)
 599 {
 600     return *_trackballEngine;
 601 }
 602
 603 FlyEngine &Navigator::getFlyEngine(void)
 604 {
 605     return *_flyEngine;
 606 }
 607
 608 WalkEngine &Navigator::getWalkEngine(void)
 609 {
 610     return *_walkEngine;
 611 }
 612
 613 NoneEngine &Navigator::getNoneEngine(void)
 614 {
 615     return *_noneEngine;
 616 }
 617
 618 NavigatorEngine &Navigator::getUserEngine(void)
 619 {
 620     return *_userEngine;
 621 }
 622
 623 void Navigator::setUserEngine(NavigatorEngine *userEngine)
 624 {
 625     if(userEngine == NULL)
 626         return;
 627
 628     if(userEngine != _userEngine)
 629     {
 630         _userEngine = userEngine;
 631     }
 632
 633     if(getMode() == USER)
 634         setMode(USER); // assign userEngine to _engine
 635 }
 636
 637
 638 /*! Set the clickCenter current state.
 639 */
 640 bool Navigator::setClickCenter(bool state)
 641 {
 642     bool old = _clickCenter;
 643
 644     _clickCenter = state;
 645
 646     return old;
 647 }
 648
 649 /*! Set absolute mode.
 650 */
 651 bool Navigator::setAbsolute(bool state)
 652 {
 653     bool old = _absolute;
 654
 655     _absolute = state;
 656
 657     return old;
 658 }
 659
 660 /*! Set the clickCenter current state.
 661 */
 662 bool Navigator::setClickNoIntersect(bool state)
 663 {
 664     bool old = _clickNoIntersect;
 665
 666     _clickNoIntersect = state;
 667
 668     return old;
 669 }
 670
 671 bool Navigator::calcFromTo(Int16   x,     Int16   y,
 672                            Real32 &fromX, Real32 &fromY,
 673                            Real32 &toX,   Real32 &toY)
 674 {
 675     if(_vp == NULL)
 676         return this->calcFromTo(x, y, _width, _height, fromX, fromY, toX, toY);
 677
 678     Real32 width  = Real32(_vp->calcPixelWidth ());
 679     Real32 height = Real32(_vp->calcPixelHeight());
 680
 681     if(width <= 0 || height <= 0)
 682         return false;
 683
 684     Window *par = _vp->getParent();
 685     Real32  winHeight;
 686
 687     if(par != NULL)
 688     {
 689         winHeight = Real32(par->getHeight());
 690     }
 691     else
 692     {
 693         winHeight = height;
 694     }
 695
 696     fromX = (2.0f * (_lastX - _vp->calcPixelLeft())- width) /  width;
 697     fromY = (2.0f * (winHeight-_lastY-_vp->calcPixelBottom())-height) / height;
 698
 699     toX   = (2.0f * (x - _vp->calcPixelLeft()) - width) / width;
 700     toY   = (2.0f * (winHeight - y - _vp->calcPixelBottom()) - height) / height;
 701
 702 #if 0
 703     fprintf(stderr, "%d %d | %f %f | %f %f | %f %f | %f %f\n",
 704             UInt32(x),
 705             UInt32(y),
 706             width,
 707             height,
 708             Real32(_vp->calcPixelLeft()),
 709             Real32( _vp->calcPixelBottom()),
 710             fromX,
 711             fromY,
 712             toX,
 713             toY      );
 714 #endif
 715
 716     return true;
 717 }
 718
 719 bool Navigator::calcFromTo(Int16   x,     Int16   y,
 720                            Real32  width, Real32  height,
 721                            Real32 &fromX, Real32 &fromY,
 722                            Real32 &toX,   Real32 &toY)
 723 {
 724     fromX = (2.0f * (         _lastX) - width ) /  width;
 725     fromY = (2.0f * (height - _lastY) - height) / height;
 726
 727     toX   = (2.0f * (          x    ) - width ) / width;
 728     toY   = (2.0f * (height -  y    ) - height) / height;
 729
 730     return true;
 731 }
 732