Source/Contrib/ComplexSceneManager/OSGCSMDrawer.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 "OSGCSMDrawer.h"
  49 #include "OSGCSMWindow.h"
  50
  51 #include "OSGRenderAction.h"
  52 #include "OSGNameAttachment.h"
  53
  54 OSG_BEGIN_NAMESPACE
  55
  56 // Documentation for this class is emitted in the
  57 // OSGCSMDrawerBase.cpp file.
  58 // To modify it, please change the .fcd file (OSGCSMDrawer.fcd) and
  59 // regenerate the base file.
  60
  61 /***************************************************************************\
  62  *                           Class variables                               *
  63 \***************************************************************************/
  64
  65 /***************************************************************************\
  66  *                           Class methods                                 *
  67 \***************************************************************************/
  68
  69 void CSMDrawer::initMethod(InitPhase ePhase)
  70 {
  71     Inherited::initMethod(ePhase);
  72
  73     if(ePhase == TypeObject::SystemPost)
  74     {
  75     }
  76 }
  77
  78
  79 /***************************************************************************\
  80  *                           Instance methods                              *
  81 \***************************************************************************/
  82
  83 /*-------------------------------------------------------------------------*\
  84  -  private                                                                 -
  85 \*-------------------------------------------------------------------------*/
  86
  87 /*----------------------- constructors & destructors ----------------------*/
  88
  89 CSMDrawer::CSMDrawer(void) :
  90      Inherited      (     ),
  91     _pAction        (NULL ),
  92     _pDrawThread    (NULL ),
  93     _pSyncFromThread(NULL ),
  94     _pSyncBarrier   (NULL ),
  95     _pSwapBarrier   (NULL ),
  96 #ifdef OSG_GLOBAL_SYNC_LOCK
  97     _pSyncLock      (NULL ),
  98 #endif
  99
 100     _uiSyncCount    (0    ),
 101     _uiSwapCount    (0    ),
 102     _bParallel      (false),
 103     _bRun           (false)
 104 {
 105 }
 106
 107 CSMDrawer::CSMDrawer(const CSMDrawer &source) :
 108      Inherited      (source),
 109     _pAction        (NULL  ),
 110     _pDrawThread    (NULL  ),
 111     _pSyncFromThread(NULL ),
 112     _pSyncBarrier   (NULL  ),
 113     _pSwapBarrier   (NULL  ),
 114 #ifdef OSG_GLOBAL_SYNC_LOCK
 115     _pSyncLock      (NULL ),
 116 #endif
 117
 118     _uiSyncCount    (0     ),
 119     _uiSwapCount    (0     ),
 120     _bParallel      (false ),
 121     _bRun           (false)
 122 {
 123 }
 124
 125 CSMDrawer::~CSMDrawer(void)
 126 {
 127     _pAction = NULL;
 128 }
 129
 130 void CSMDrawer::setSyncFromThread(Thread *pThread)
 131 {
 132     _pSyncFromThread = pThread;
 133 }
 134
 135 void CSMDrawer::setSyncBarrier(Barrier *pSyncBarrier)
 136 {
 137     _pSyncBarrier = pSyncBarrier;
 138 }
 139
 140 void CSMDrawer::setSwapBarrier(Barrier *pSwapBarrier)
 141 {
 142     _pSwapBarrier = pSwapBarrier;
 143 }
 144
 145 #ifdef OSG_GLOBAL_SYNC_LOCK
 146 void CSMDrawer::setSyncLock(Lock *pSyncLock)
 147 {
 148     _pSyncLock = pSyncLock;
 149 }
 150 #endif
 151
 152
 153 void CSMDrawer::setSyncCount(UInt32 uiSyncCount)
 154 {
 155     _uiSyncCount = uiSyncCount;
 156 }
 157
 158 void CSMDrawer::setSwapCount(UInt32 uiSwapCount)
 159 {
 160     _uiSwapCount = uiSwapCount;
 161 }
 162
 163 void CSMDrawer::setParallel(bool bParallel)
 164 {
 165     _bParallel = bParallel;
 166 }
 167
 168 void CSMDrawer::postSync(void)
 169 {
 170     MFUnrecChildCSMWindowPtr::const_iterator wIt  = getMFWindows()->begin();
 171     MFUnrecChildCSMWindowPtr::const_iterator wEnd = getMFWindows()->end  ();
 172
 173     for(; wIt != wEnd; ++wIt)
 174     {
 175         (*wIt)->postSync();
 176     }
 177 }
 178
 179 /*----------------------------- class specific ----------------------------*/
 180
 181 void CSMDrawer::changed(ConstFieldMaskArg whichField,
 182                         UInt32            origin,
 183                         BitVector         details)
 184 {
 185     Inherited::changed(whichField, origin, details);
 186 }
 187
 188 void CSMDrawer::dump(      UInt32    ,
 189                      const BitVector ) const
 190 {
 191     SLOG << "Dump CSMDrawer NI" << std::endl;
 192 }
 193
 194 bool CSMDrawer::init(void)
 195 {
 196     bool returnValue = true;
 197
 198     MFUnrecChildCSMWindowPtr::const_iterator wIt  = getMFWindows()->begin();
 199     MFUnrecChildCSMWindowPtr::const_iterator wEnd = getMFWindows()->end  ();
 200
 201     for(; wIt != wEnd; ++wIt)
 202     {
 203         returnValue = (*wIt)->init();
 204
 205         if(returnValue == false)
 206             break;
 207     }
 208
 209     _pAction = RenderAction::create();
 210
 211     if(_bParallel == true)
 212     {
 213         _pDrawThread  = CSMDrawThread ::get(NULL, false);
 214
 215         OSG_ASSERT(_pDrawThread     != NULL);
 216         OSG_ASSERT(_pSyncBarrier    != NULL);
 217         OSG_ASSERT(_pSyncFromThread != NULL);
 218 #ifdef OSG_GLOBAL_SYNC_LOCK
 219         OSG_ASSERT(_pSyncLock       != NULL);
 220 #endif
 221
 222         _pDrawThread->setDrawer(this);
 223         _pDrawThread->run(_sfAspect.getValue());
 224     }
 225
 226 //    _pAction->setFrustumCulling(false);
 227
 228     return returnValue;
 229 }
 230
 231 void CSMDrawer::endDrawThread (void)
 232 {
 233     if(_bParallel == true)
 234     {
 235         _pDrawThread->setRunning(false);
 236     }
 237 }
 238
 239 void CSMDrawer::shutdown(void)
 240 {
 241     MFUnrecChildCSMWindowPtr::const_iterator winIt  = getMFWindows()->begin();
 242     MFUnrecChildCSMWindowPtr::const_iterator winEnd = getMFWindows()->end  ();
 243
 244     while(winIt != winEnd)
 245     {
 246         (*winIt)->shutdown();
 247
 248         ++winIt;
 249     }
 250 }
 251
 252 void CSMDrawer::joinDrawThread(void)
 253 {
 254     if(_bParallel == true)
 255     {
 256         Thread::join(_pDrawThread);
 257
 258         _pDrawThread = NULL;
 259     }
 260 }
 261
 262 void CSMDrawer::frame(Time oTime, UInt32 uiFrame)
 263 {
 264     MFUnrecChildCSMWindowPtr::const_iterator winIt  = getMFWindows()->begin();
 265     MFUnrecChildCSMWindowPtr::const_iterator winEnd = getMFWindows()->end  ();
 266
 267     while(winIt != winEnd)
 268     {
 269         (*winIt)->render(_pAction);
 270
 271         ++winIt;
 272     }
 273 }
 274
 275 FieldContainer *CSMDrawer::findNamedComponent(const Char8 *szName)
 276 {
 277     MFUnrecChildCSMWindowPtr::const_iterator winIt  = _mfWindows.begin();
 278     MFUnrecChildCSMWindowPtr::const_iterator winEnd = _mfWindows.end  ();
 279
 280     const Char8               *szTmpName   = NULL;
 281
 282     while(winIt != winEnd)
 283     {
 284         szTmpName = OSG::getName(*winIt);
 285
 286         if(szTmpName != NULL && osgStringCmp(szTmpName, szName) == 0)
 287         {
 288             return *winIt;
 289         }
 290         else
 291         {
 292             FieldContainer *tmpVal = (*winIt)->findNamedComponent(szName);
 293
 294             if(tmpVal != NULL)
 295                 return tmpVal;
 296         }
 297
 298         ++winIt;
 299     }
 300
 301     return NULL;
 302 }
 303
 304 void CSMDrawer::render(void)
 305 {
 306     MFUnrecChildCSMWindowPtr::const_iterator winIt  = getMFWindows()->begin();
 307     MFUnrecChildCSMWindowPtr::const_iterator winEnd = getMFWindows()->end  ();
 308
 309     while(winIt != winEnd)
 310     {
 311         (*winIt)->render(_pAction);
 312
 313         ++winIt;
 314     }
 315 }
 316
 317 void CSMDrawer::runParallel(void)
 318 {
 319     fprintf(stderr, "Drawer run par\n");
 320
 321     _bRun = true;
 322
 323     for(UInt32 i = 0; i < 10; ++i)
 324     {
 325         _pSyncBarrier->enter(_uiSyncCount);
 326         _pSyncBarrier->enter(_uiSyncCount);
 327
 328 #ifdef OSG_GLOBAL_SYNC_LOCK
 329         _pSyncLock->acquire();
 330 #endif
 331
 332         _pSyncFromThread->getChangeList()->applyNoClear();
 333
 334 #ifdef OSG_GLOBAL_SYNC_LOCK
 335         _pSyncLock->release();
 336 #endif
 337
 338         _pSyncBarrier->enter(_uiSyncCount);
 339
 340         Thread::getCurrentChangeList()->commitChanges();
 341     }
 342
 343     if(_pSwapBarrier == NULL)
 344     {
 345         fprintf(stderr, "Running without swap lock\n");
 346         fflush (stderr);
 347
 348         fprintf(stderr, "Running with %" PRISize "-windws\n",
 349                 _mfWindows.size());
 350         fflush (stderr);
 351
 352         while(_bRun == true)
 353         {
 354             _pSyncBarrier->enter               (_uiSyncCount);
 355             _pSyncBarrier->enter               (_uiSyncCount);
 356
 357 # ifdef OSG_GLOBAL_SYNC_LOCK
 358             _pSyncLock->acquire();
 359 # endif
 360
 361             _pSyncFromThread->getChangeList()->applyNoClear();
 362
 363 # ifdef OSG_GLOBAL_SYNC_LOCK
 364             _pSyncLock->release();
 365 # endif
 366
 367             _pSyncBarrier->enter               (_uiSyncCount);
 368
 369             Thread::getCurrentChangeList()->commitChanges();
 370
 371             if(_bRun == false)
 372             {
 373                 Thread::getCurrentChangeList()->commitChangesAndClear();
 374
 375                 break;
 376             }
 377
 378             this->render();
 379
 380             Thread::getCurrentChangeList()->commitChangesAndClear();
 381         }
 382     }
 383     else
 384     {
 385         fprintf(stderr, "Running with swap lock\n");
 386         fflush (stderr);
 387
 388         fprintf(stderr, "Running with %" PRISize "-windws\n",
 389                 _mfWindows.size());
 390         fflush (stderr);
 391
 392         while(_bRun == true)
 393         {
 394             _pSyncBarrier->enter               (_uiSyncCount);
 395             _pSyncBarrier->enter               (_uiSyncCount);
 396
 397 # ifdef OSG_GLOBAL_SYNC_LOCK
 398             _pSyncLock->acquire();
 399 # endif
 400             _pSyncFromThread->getChangeList()->applyNoClear();
 401
 402 # ifdef OSG_GLOBAL_SYNC_LOCK
 403             _pSyncLock->release();
 404 # endif
 405
 406             _pSyncBarrier->enter               (_uiSyncCount);
 407
 408             OSG::Thread::getCurrentChangeList()->commitChanges();
 409
 410             if(_bRun == false)
 411             {
 412                 OSG::Thread::getCurrentChangeList()->commitChangesAndClear();
 413
 414                 break;
 415             }
 416
 417             this->frameRenderNoFinish(            );
 418
 419             _pSwapBarrier->enter     (_uiSwapCount);
 420
 421             this->frameFinish        (            );
 422
 423             OSG::Thread::getCurrentChangeList()->commitChangesAndClear();
 424         }
 425     }
 426
 427     _pSyncBarrier->enter               (_uiSyncCount);
 428
 429     fprintf(stderr, "Drawer run par stop\n");
 430
 431
 432     // Main structure
 433     _pSyncBarrier->enter(_uiSyncCount);
 434
 435 #ifdef OSG_GLOBAL_SYNC_LOCK
 436     _pSyncLock->acquire();
 437 #endif
 438
 439 //    _pSyncFromThread->getChangeList()->dump();
 440     _pSyncFromThread->getChangeList()->applyNoClear();
 441
 442 #ifdef OSG_GLOBAL_SYNC_LOCK
 443     _pSyncLock->release();
 444 #endif
 445
 446     Thread::getCurrentChangeList()->commitChangesAndClear();
 447
 448     this->frameExit();
 449
 450     _pSyncBarrier->enter(_uiSyncCount);
 451
 452
 453     // gl takedown
 454     _pSyncBarrier->enter(_uiSyncCount);
 455
 456 #ifdef OSG_GLOBAL_SYNC_LOCK
 457     _pSyncLock->acquire();
 458 #endif
 459
 460 //    _pSyncFromThread->getChangeList()->dump();
 461     _pSyncFromThread->getChangeList()->applyNoClear();
 462
 463 #ifdef OSG_GLOBAL_SYNC_LOCK
 464     _pSyncLock->release();
 465 #endif
 466
 467     _pSyncBarrier->enter(_uiSyncCount);
 468
 469
 470     // Windows
 471     _pSyncBarrier->enter(_uiSyncCount);
 472
 473 #ifdef OSG_GLOBAL_SYNC_LOCK
 474     _pSyncLock->acquire();
 475 #endif
 476
 477 //    _pSyncFromThread->getChangeList()->dump();
 478     _pSyncFromThread->getChangeList()->applyNoClear();
 479
 480 #ifdef OSG_GLOBAL_SYNC_LOCK
 481     _pSyncLock->release();
 482 #endif
 483
 484     _pSyncBarrier->enter(_uiSyncCount);
 485
 486     Thread::getCurrentChangeList()->commitChangesAndClear();
 487 }
 488
 489 void CSMDrawer::frameRenderNoFinish(void)
 490 {
 491     MFUnrecChildCSMWindowPtr::const_iterator winIt  = getMFWindows()->begin();
 492     MFUnrecChildCSMWindowPtr::const_iterator winEnd = getMFWindows()->end  ();
 493
 494     while(winIt != winEnd)
 495     {
 496         (*winIt)->frameRenderNoFinish(_pAction);
 497
 498         ++winIt;
 499     }
 500 }
 501
 502 void CSMDrawer::frameFinish(void)
 503 {
 504     MFUnrecChildCSMWindowPtr::const_iterator winIt  = getMFWindows()->begin();
 505     MFUnrecChildCSMWindowPtr::const_iterator winEnd = getMFWindows()->end  ();
 506
 507     while(winIt != winEnd)
 508     {
 509         (*winIt)->frameFinish();
 510
 511         ++winIt;
 512     }
 513 }
 514
 515 void CSMDrawer::frameExit(void)
 516 {
 517     MFUnrecChildCSMWindowPtr::const_iterator winIt  = getMFWindows()->begin();
 518     MFUnrecChildCSMWindowPtr::const_iterator winEnd = getMFWindows()->end  ();
 519
 520     while(winIt != winEnd)
 521     {
 522         (*winIt)->frameExit();
 523
 524         ++winIt;
 525     }
 526 }
 527
 528 void CSMDrawer::setRunning(bool bVal)
 529 {
 530     _bRun = false;
 531 }
 532
 533 void CSMDrawer::resolveLinks(void)
 534 {
 535     Inherited::resolveLinks();
 536 }
 537
 538 void CSMDrawer::terminateGLContexts(void)
 539 {
 540     MFUnrecChildCSMWindowPtr::const_iterator winIt  = getMFWindows()->begin();
 541     MFUnrecChildCSMWindowPtr::const_iterator winEnd = getMFWindows()->end  ();
 542
 543     while(winIt != winEnd)
 544     {
 545         (*winIt)->terminateGLContext();
 546
 547         ++winIt;
 548     }
 549 }
 550
 551
 552 /***************************************************************************\
 553  *                           Class variables                               *
 554 \***************************************************************************/
 555
 556 MPThreadType CSMDrawThread::_type(
 557     "OSGCSMDrawThread",
 558     "OSGThread",
 559     static_cast<CreateThreadF>(CSMDrawThread::create),
 560     NULL);
 561
 562 /***************************************************************************\
 563  *                           Class methods                                 *
 564 \***************************************************************************/
 565
 566 /***************************************************************************\
 567  *                           Instance methods                              *
 568 \***************************************************************************/
 569
 570 /*-------------------------------------------------------------------------*\
 571  -  private                                                                 -
 572 \*-------------------------------------------------------------------------*/
 573
 574 CSMDrawThread *CSMDrawThread::find(Char8 *szName)
 575 {
 576     BaseThread *pThread = ThreadManager::the()->findThread(szName);
 577
 578     return dynamic_cast<CSMDrawThread *>(pThread);
 579 }
 580
 581 CSMDrawThread::ObjTransitPtr CSMDrawThread::get(Char8 *szName, bool bGlobal)
 582 {
 583     BaseThreadTransitPtr pThread =
 584         ThreadManager::the()->getThread(szName,
 585                                         bGlobal,
 586                                         "OSGCSMDrawThread");
 587
 588     return dynamic_pointer_cast<CSMDrawThread>(pThread);
 589 }
 590
 591 void CSMDrawThread::setDrawer(CSMDrawer *pDrawer)
 592 {
 593     _pDrawer = pDrawer;
 594 }
 595
 596 void CSMDrawThread::setRunning(bool bVal)
 597 {
 598     _pDrawer->setRunning(bVal);
 599 }
 600
 601
 602 BaseThread *CSMDrawThread::create(const Char8  *szName,
 603                                         UInt32  uiId,
 604                                         bool    bGlobal)
 605 {
 606     return new CSMDrawThread(szName, uiId, bGlobal);
 607 }
 608
 609 CSMDrawThread::CSMDrawThread(const Char8 *szName, UInt32 uiId, bool bGlobal) :
 610      Inherited(szName,
 611                uiId,
 612                bGlobal),
 613     _pDrawer  (NULL   )
 614 {
 615 }
 616
 617 CSMDrawThread::~CSMDrawThread(void)
 618 {
 619 }
 620
 621 void CSMDrawThread::workProc(void)
 622 {
 623     OSG_ASSERT(_pDrawer != NULL);
 624
 625     _pDrawer->runParallel();
 626 }
 627
 628 OSG_END_NAMESPACE