Source/Contrib/ComplexSceneManager/OSGCSMViewport.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *               Copyright (C) 2000-2006 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 //---------------------------------------------------------------------------
  40 //  Includes
  41 //---------------------------------------------------------------------------
  42
  43 #include <cstdlib>
  44 #include <cstdio>
  45
  46 #include "OSGConfig.h"
  47
  48 #include "OSGCSMViewport.h"
  49 #include "OSGStereoBufferViewport.h"
  50 #include "OSGShearedStereoCameraDecorator.h"
  51 #include "OSGProjectionCameraDecorator.h"
  52 #include "OSGCSMPerspectiveCamera.h"
  53 #include "OSGColorBufferViewport.h"
  54 #include "OSGPassiveViewport.h"
  55 #include "OSGCSMStatisticsForeground.h"
  56 #include "OSGCSMWindow.h"
  57
  58 OSG_BEGIN_NAMESPACE
  59
  60 // Documentation for this class is emitted in the
  61 // OSGCSMViewportBase.cpp file.
  62 // To modify it, please change the .fcd file (OSGCSMViewport.fcd) and
  63 // regenerate the base file.
  64
  65 /***************************************************************************\
  66  *                           Class variables                               *
  67 \***************************************************************************/
  68
  69 /***************************************************************************\
  70  *                           Class methods                                 *
  71 \***************************************************************************/
  72
  73 void CSMViewport::initMethod(InitPhase ePhase)
  74 {
  75     Inherited::initMethod(ePhase);
  76
  77     if(ePhase == TypeObject::SystemPost)
  78     {
  79     }
  80 }
  81
  82
  83 /***************************************************************************\
  84  *                           Instance methods                              *
  85 \***************************************************************************/
  86
  87 /*-------------------------------------------------------------------------*\
  88  -  private                                                                 -
  89 \*-------------------------------------------------------------------------*/
  90
  91 /*----------------------- constructors & destructors ----------------------*/
  92
  93 CSMViewport::CSMViewport(void) :
  94     Inherited()
  95 {
  96 }
  97
  98 CSMViewport::CSMViewport(const CSMViewport &source) :
  99     Inherited(source)
 100 {
 101 }
 102
 103 CSMViewport::~CSMViewport(void)
 104 {
 105 }
 106
 107 void CSMViewport::resolveLinks(void)
 108 {
 109     Inherited::resolveLinks();
 110
 111     ViewportStoreIt      vIt  = _vViewports.begin();
 112     ViewportStoreConstIt vEnd = _vViewports.end  ();
 113
 114     for(; vIt != vEnd; ++vIt)
 115     {
 116         (*vIt) = NULL;
 117     }
 118
 119     _vViewports.clear();
 120 }
 121
 122 /*----------------------------- class specific ----------------------------*/
 123
 124 void CSMViewport::changed(ConstFieldMaskArg whichField,
 125                             UInt32            origin,
 126                             BitVector         details)
 127 {
 128     Inherited::changed(whichField, origin, details);
 129 }
 130
 131 void CSMViewport::dump(      UInt32    ,
 132                          const BitVector ) const
 133 {
 134     SLOG << "Dump CSMViewport NI" << std::endl;
 135 }
 136
 137 bool CSMViewport::init(CSMWindow *pCSMWin)
 138 {
 139     bool returnValue = true;
 140
 141     bool bQuadBuff   = _sfStereoMode.getValue() == "quadBuffer";
 142     bool bSplitH     = _sfStereoMode.getValue() == "splitHorizontal";
 143     bool bSplitV     = _sfStereoMode.getValue() == "splitVertical";
 144     bool bSLeft      = _sfStereoMode.getValue() == "stereoLeft";
 145     bool bSRight     = _sfStereoMode.getValue() == "stereoRight";
 146     bool bAmberBlue  = _sfStereoMode.getValue() == "amberBlue";
 147
 148     bool bStereo   = (bQuadBuff   ||
 149                       bSplitH     ||
 150                       bSplitV     ||
 151                       bAmberBlue  ||
 152                       bSLeft      ||
 153                       bSRight      );
 154
 155     bool bFallback = false;
 156
 157     if(bStereo == true && _sfPassive.getValue() == true)
 158     {
 159         FWARNING(("CSMViewport: passive set with stereo config, ignoring\n"));
 160     }
 161
 162     if(bQuadBuff == true)
 163     {
 164         StereoBufferViewportUnrecPtr pPortLeft  =
 165             StereoBufferViewport::create();
 166
 167         StereoBufferViewportUnrecPtr pPortRight =
 168             StereoBufferViewport::create();
 169
 170         // Left
 171         pPortLeft->setLeft  (_sfLeftBottom.getValue()[0]);
 172         pPortLeft->setBottom(_sfLeftBottom.getValue()[1]);
 173
 174         pPortLeft->setRight (_sfRightTop  .getValue()[0]);
 175         pPortLeft->setTop   (_sfRightTop  .getValue()[1]);
 176
 177         pPortLeft->setLeftBuffer (true );
 178         pPortLeft->setRightBuffer(false);
 179
 180         pPortRight->setLeft  (_sfLeftBottom.getValue()[0]);
 181         pPortRight->setBottom(_sfLeftBottom.getValue()[1]);
 182
 183         pPortRight->setRight (_sfRightTop  .getValue()[0]);
 184         pPortRight->setTop   (_sfRightTop  .getValue()[1]);
 185
 186         pPortRight->setLeftBuffer (false);
 187         pPortRight->setRightBuffer(true );
 188
 189         _vViewports.push_back(pPortLeft );
 190         _vViewports.push_back(pPortRight);
 191     }
 192     else if(bAmberBlue == true)
 193     {
 194         ColorBufferViewportUnrecPtr pPortLeft  =
 195             ColorBufferViewport::create();
 196
 197         ColorBufferViewportUnrecPtr pPortRight =
 198             ColorBufferViewport::create();
 199
 200         // Left
 201         pPortLeft->setLeft  (_sfLeftBottom.getValue()[0]);
 202         pPortLeft->setBottom(_sfLeftBottom.getValue()[1]);
 203
 204         pPortLeft->setRight (_sfRightTop  .getValue()[0]);
 205         pPortLeft->setTop   (_sfRightTop  .getValue()[1]);
 206
 207         pPortLeft->setRed  (GL_TRUE );
 208         pPortLeft->setGreen(GL_TRUE );
 209         pPortLeft->setBlue (GL_FALSE);
 210         pPortLeft->setAlpha(GL_TRUE );
 211
 212         pPortRight->setLeft  (_sfLeftBottom.getValue()[0]);
 213         pPortRight->setBottom(_sfLeftBottom.getValue()[1]);
 214
 215         pPortRight->setRight (_sfRightTop  .getValue()[0]);
 216         pPortRight->setTop   (_sfRightTop  .getValue()[1]);
 217
 218         pPortRight->setRed  (GL_FALSE);
 219         pPortRight->setGreen(GL_FALSE);
 220         pPortRight->setBlue (GL_TRUE );
 221         pPortRight->setAlpha(GL_FALSE);
 222
 223         _vViewports.push_back(pPortLeft );
 224         _vViewports.push_back(pPortRight);
 225     }
 226     else if(bSplitH == true)
 227     {
 228         ViewportUnrecPtr pPortLeft  = Viewport::create();
 229         ViewportUnrecPtr pPortRight = Viewport::create();
 230
 231         // Left
 232         Real32 rCenter = _sfLeftBottom.getValue()[0] +
 233             (_sfRightTop  .getValue()[0] - _sfLeftBottom.getValue()[0]) * 0.5;
 234
 235         pPortLeft->setLeft  (_sfLeftBottom.getValue()[0]);
 236         pPortLeft->setBottom(_sfLeftBottom.getValue()[1]);
 237
 238         pPortLeft->setRight ( rCenter                   );
 239         pPortLeft->setTop   (_sfRightTop  .getValue()[1]);
 240
 241         // Right
 242         pPortRight->setLeft  ( rCenter                   );
 243         pPortRight->setBottom(_sfLeftBottom.getValue()[1]);
 244
 245         pPortRight->setRight (_sfRightTop  .getValue()[0]);
 246         pPortRight->setTop   (_sfRightTop  .getValue()[1]);
 247
 248         _vViewports.push_back(pPortLeft );
 249         _vViewports.push_back(pPortRight);
 250     }
 251     else if(bSplitV == true)
 252     {
 253         ViewportUnrecPtr pPortLeft  = Viewport::create();
 254         ViewportUnrecPtr pPortRight = Viewport::create();
 255
 256         // Left
 257         Real32 rCenter = _sfLeftBottom.getValue()[1] +
 258             (_sfRightTop  .getValue()[1] - _sfLeftBottom.getValue()[1]) * 0.5;
 259
 260         pPortLeft->setLeft  (_sfLeftBottom.getValue()[0]);
 261         pPortLeft->setBottom(_sfLeftBottom.getValue()[1]);
 262
 263         pPortLeft->setRight (_sfRightTop  .getValue()[0]);
 264         pPortLeft->setTop   ( rCenter                   );
 265
 266         // Right
 267         pPortRight->setLeft  (_sfLeftBottom.getValue()[0]);
 268         pPortRight->setBottom( rCenter                   );
 269
 270         pPortRight->setRight (_sfRightTop  .getValue()[0]);
 271         pPortRight->setTop   (_sfRightTop  .getValue()[1]);
 272
 273         _vViewports.push_back(pPortLeft );
 274         _vViewports.push_back(pPortRight);
 275     }
 276     else
 277     {
 278         if(_sfPassive.getValue() == true)
 279         {
 280             ViewportUnrecPtr pPort  = PassiveViewport::create();
 281
 282             _vViewports.push_back(pPort);
 283         }
 284         else
 285         {
 286             ViewportUnrecPtr pPort  = Viewport::create();
 287
 288             // Left
 289             pPort->setLeft  (_sfLeftBottom.getValue()[0]);
 290             pPort->setBottom(_sfLeftBottom.getValue()[1]);
 291
 292             pPort->setRight (_sfRightTop  .getValue()[0]);
 293             pPort->setTop   (_sfRightTop  .getValue()[1]);
 294
 295             _vViewports.push_back(pPort );
 296         }
 297     }
 298
 299     CSMPerspectiveCamera *pCSMCam =
 300         dynamic_cast<CSMPerspectiveCamera *>(_sfCamera.getValue());
 301
 302     ProjectionCameraDecorator *pProjCam =
 303         dynamic_cast<ProjectionCameraDecorator *>(_sfCamera.getValue());
 304
 305     if(pCSMCam == NULL)
 306     {
 307         if(pProjCam != NULL)
 308         {
 309             pCSMCam = dynamic_cast<CSMPerspectiveCamera *>(
 310                     pProjCam->getDecoratee());
 311         }
 312     }
 313
 314     if(pCSMCam == NULL)
 315         bFallback = true;
 316
 317     if((bQuadBuff || bSplitH || bSplitV || bAmberBlue) && (bFallback == false))
 318     {
 319         // Left
 320         StereoCameraDecoratorUnrecPtr pDecoLeft(NULL);
 321
 322         if(pProjCam != NULL)
 323         {
 324             if(pCSMCam->getHeadBeacon() != NULL)
 325             {
 326                 pProjCam->setUser(pCSMCam->getHeadBeacon());
 327             }
 328             else
 329             {
 330                 pProjCam->setUser(pCSMCam->getBeacon());
 331             }
 332
 333             pDecoLeft = pProjCam;
 334         }
 335         else
 336         {
 337             ShearedStereoCameraDecoratorUnrecPtr pSheared =
 338                 ShearedStereoCameraDecorator::create();
 339
 340
 341             pSheared->setZeroParallaxDistance(pCSMCam->getZeroParallax ());
 342             pSheared->setDecoratee           (pCSMCam                    );
 343
 344             pDecoLeft = pSheared;
 345
 346             addConnection(pCSMCam,    "zeroParallax",
 347                           pDecoLeft,  "zeroParallaxDistance");
 348         }
 349
 350         pDecoLeft->setEyeSeparation       (pCSMCam->getEyeSeparation());
 351         pDecoLeft->setLeftEye             (true                       );
 352
 353         _vViewports[0]->setCamera(pDecoLeft);
 354
 355         // Right
 356         StereoCameraDecoratorUnrecPtr pDecoRight(NULL);
 357
 358         if(pProjCam != NULL)
 359         {
 360             ProjectionCameraDecoratorUnrecPtr pProject =
 361                 ProjectionCameraDecorator::create();
 362
 363             pProject->setUser     (pProjCam->getUser());
 364             pProject->setDecoratee(pCSMCam            );
 365
 366             *(pProject->editMFSurface()) = *(pProjCam->getMFSurface());
 367
 368             pDecoRight = pProject;
 369         }
 370         else
 371         {
 372             ShearedStereoCameraDecoratorUnrecPtr pSheared =
 373                 ShearedStereoCameraDecorator::create();
 374
 375             pSheared->setZeroParallaxDistance(pCSMCam->getZeroParallax ());
 376             pSheared->setDecoratee           (pCSMCam                    );
 377
 378             pDecoRight = pSheared;
 379
 380             addConnection(pCSMCam,    "zeroParallax",
 381                           pDecoRight, "zeroParallaxDistance");
 382         }
 383
 384         pDecoRight->setEyeSeparation       (pCSMCam->getEyeSeparation());
 385         pDecoRight->setLeftEye             (false                      );
 386
 387         _vViewports[1]->setCamera(pDecoRight);
 388
 389         addConnection(pCSMCam,    "eyeSeparation",
 390                       pDecoRight, "eyeSeparation");
 391
 392
 393         addConnection(pCSMCam,    "eyeSeparation",
 394                       pDecoLeft,  "eyeSeparation");
 395     }
 396     else if((bSLeft || bSRight) && (bFallback == false))
 397     {
 398         StereoCameraDecoratorUnrecPtr pDeco(NULL);
 399
 400         if(pProjCam != NULL)
 401         {
 402             if(pCSMCam->getHeadBeacon() != NULL)
 403             {
 404                 pProjCam->setUser(pCSMCam->getHeadBeacon());
 405             }
 406             else
 407             {
 408                 pProjCam->setUser(pCSMCam->getBeacon());
 409             }
 410
 411             pDeco = pProjCam;
 412         }
 413         else
 414         {
 415             ShearedStereoCameraDecoratorUnrecPtr pSheared =
 416                 ShearedStereoCameraDecorator::create();
 417
 418             pSheared->setZeroParallaxDistance(pCSMCam->getZeroParallax ());
 419             pSheared->setDecoratee           (pCSMCam                    );
 420
 421             pDeco = pSheared;
 422
 423             addConnection(pCSMCam, "zeroParallax",
 424                           pDeco,   "zeroParallaxDistance");
 425         }
 426
 427         pDeco->setEyeSeparation       (pCSMCam->getEyeSeparation());
 428         pDeco->setLeftEye             (bSLeft                     );
 429
 430         _vViewports[0]->setCamera(pDeco);
 431
 432
 433         addConnection(pCSMCam, "eyeSeparation",
 434                       pDeco,   "eyeSeparation");
 435     }
 436     else
 437     {
 438         _vViewports[0]->setCamera(_sfCamera.getValue());
 439
 440         if(bFallback == false)
 441         {
 442             if(pProjCam != NULL)
 443             {
 444                 if(pCSMCam->getHeadBeacon() != NULL)
 445                 {
 446                     pProjCam->setUser(pCSMCam->getHeadBeacon());
 447                 }
 448                 else
 449                 {
 450                     pProjCam->setUser(pCSMCam->getBeacon());
 451                 }
 452             }
 453         }
 454     }
 455
 456     ViewportStoreConstIt vIt  = _vViewports.begin();
 457     ViewportStoreConstIt vEnd = _vViewports.end  ();
 458
 459     for(; vIt != vEnd; ++vIt)
 460     {
 461         (*vIt)->setRoot         (_sfRoot         .getValue());
 462         (*vIt)->setBackground   (_sfBackground   .getValue());
 463         (*vIt)->setRenderOptions(_sfRenderOptions.getValue());
 464         (*vIt)->setTravMask     (_sfTravMask     .getValue());
 465
 466         MFUnrecForegroundPtr::const_iterator fIt  = getMFForegrounds()->begin();
 467         MFUnrecForegroundPtr::const_iterator fEnd = getMFForegrounds()->end  ();
 468
 469         while(fIt != fEnd)
 470         {
 471             CSMStatisticsForeground *pCSMStatFG =
 472                 dynamic_cast<CSMStatisticsForeground *>(*fIt);
 473
 474             if(pCSMStatFG != NULL)
 475             {
 476                 pCSMStatFG->init(pCSMWin);
 477
 478                 StatisticsForeground *pOSGStatFG =
 479                     pCSMStatFG->getOSGForeground();
 480
 481                 if(pOSGStatFG != NULL)
 482                 {
 483                     pCSMWin->_pStatFG = pOSGStatFG;
 484
 485                     (*vIt)->addForeground(pOSGStatFG);
 486                 }
 487             }
 488             else
 489             {
 490                 (*vIt)->addForeground(*fIt);
 491             }
 492
 493             ++fIt;
 494         }
 495     }
 496
 497     return returnValue;
 498 }
 499
 500 CSMViewport::ViewportStoreConstIt CSMViewport::beginViewports(void) const
 501 {
 502     return _vViewports.begin();
 503 }
 504
 505 CSMViewport::ViewportStoreConstIt CSMViewport::endViewports(void) const
 506 {
 507     return _vViewports.end();
 508 }
 509
 510 bool CSMViewport::needsStereoVisual(void)
 511 {
 512     return _sfStereoMode.getValue() == "quadBuffer";
 513 }
 514
 515 OSG_END_NAMESPACE