Source/System/Action/RenderAction/OSGRenderAction.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 //---------------------------------------------------------------------------
  40 //  Includes
  41 //---------------------------------------------------------------------------
  42
  43 #include <cstdlib>
  44 #include <cstdio>
  45
  46 #include "OSGConfig.h"
  47
  48 #include "OSGRenderAction.h"
  49
  50 #include "OSGRenderPartitionPool.h"
  51 #include "OSGRenderTreeNodePool.h"
  52 #include "OSGStateOverride.h"
  53 #include "OSGStateSorter.h"
  54
  55 #include "OSGWindow.h"
  56 #include "OSGRenderOptions.h"
  57 #include "OSGCamera.h"
  58
  59 #include "OSGTextureBaseChunk.h"
  60 #include "OSGMaterialChunk.h"
  61 #include "OSGShaderExecutableChunk.h"
  62 #include "OSGShaderExecutableVarChunk.h"
  63 #include "OSGVolumeDraw.h"
  64 #include "OSGTreeBuilderBase.h"
  65 #include "OSGPrimeMaterial.h"
  66
  67 OSG_USING_NAMESPACE
  68
  69 /***************************************************************************\
  70  *                            Description                                  *
  71 \***************************************************************************/
  72
  73 /***************************************************************************\
  74  *                               Types                                     *
  75 \***************************************************************************/
  76
  77 /***************************************************************************\
  78  *                           Class variables                               *
  79 \***************************************************************************/
  80
  81
  82
  83 /*! \brief the prototype which is copied to create new actions
  84  */
  85
  86 RenderAction         *RenderAction::_pPrototype            = NULL;
  87
  88 /*! \brief Default functors for instantiation
  89  */
  90
  91 Action::FunctorStore *RenderAction::_vDefaultEnterFunctors = NULL;
  92 Action::FunctorStore *RenderAction::_vDefaultLeaveFunctors = NULL;
  93
  94
  95 StatElemDesc<StatTimeElem> RenderAction::statDrawTime     (
  96     "RT-DrawTime",
  97     "time for draw tree traversal");
  98
  99 StatElemDesc<StatIntElem > RenderAction::statNMatrices    (
 100     "RT-NMatrices",
 101     "number of matrix changes");
 102 StatElemDesc<StatIntElem > RenderAction::statNStates      (
 103     "RT-States",
 104     "number of material changes");
 105 StatElemDesc<StatIntElem > RenderAction::statNChunks      (
 106     "RT-Chunks",
 107     "number of chunk changes");
 108 StatElemDesc<StatIntElem > RenderAction::statNShaders     (
 109     "RT-Shaders",
 110     "number of shader changes");
 111 StatElemDesc<StatIntElem > RenderAction::statNShaderParams(
 112     "RT-ShaderParams",
 113     "number of shader params changes");
 114
 115 /***************************************************************************\
 116  *                           Class methods                                 *
 117 \***************************************************************************/
 118
 119 bool RenderAction::terminateEnter(void)
 120 {
 121     FDEBUG_GV(("Terminate RenderAction Enter\n"));
 122
 123     delete _vDefaultEnterFunctors;
 124
 125     _vDefaultEnterFunctors = NULL;
 126
 127     return true;
 128 }
 129
 130 bool RenderAction::terminateLeave(void)
 131 {
 132     FDEBUG_GV(("Terminate RenderAction Leave\n"));
 133
 134     delete _vDefaultLeaveFunctors;
 135
 136     _vDefaultLeaveFunctors = NULL;
 137
 138     return true;
 139 }
 140
 141 /*-------------------------------------------------------------------------*\
 142  -  public                                                                 -
 143 \*-------------------------------------------------------------------------*/
 144
 145 RenderAction::ObjTransitPtr RenderAction::create(void)
 146 {
 147     ObjTransitPtr returnValue(NULL);
 148
 149     if(_pPrototype)
 150     {
 151         returnValue = new RenderAction(*_pPrototype);
 152     }
 153     else
 154     {
 155         returnValue = new RenderAction();
 156     }
 157
 158     return returnValue;
 159 }
 160
 161 /*! \brief  prototype access
 162  *  after setting the prototype all new DrawActions are clones of it
 163  */
 164
 165 void RenderAction::setPrototype(RenderAction *pPrototype)
 166 {
 167     _pPrototype = pPrototype;
 168 }
 169
 170 RenderAction *RenderAction::getPrototype(void)
 171 {
 172     return _pPrototype;
 173 }
 174
 175 /*! \brief Default registration. static, so it can be called during static init
 176  */
 177
 178 void RenderAction::registerEnterDefault(
 179     const FieldContainerType &type,
 180     const Action::Functor    &func)
 181 {
 182     if(_vDefaultEnterFunctors == NULL)
 183     {
 184         _vDefaultEnterFunctors = new Action::FunctorStore;
 185
 186         addPostFactoryExitFunction(&RenderAction::terminateEnter);
 187     }
 188
 189     while(type.getId() >= _vDefaultEnterFunctors->size())
 190     {
 191         _vDefaultEnterFunctors->push_back(&Action::_defaultEnterFunction);
 192     }
 193
 194     FDEBUG_GV(("Register rendertrav for %s\n", type.getCName()));
 195
 196     (*_vDefaultEnterFunctors)[type.getId()] = func;
 197 }
 198
 199 void RenderAction::registerLeaveDefault(
 200     const FieldContainerType &type,
 201     const Action::Functor    &func)
 202 {
 203     if(_vDefaultLeaveFunctors == NULL)
 204     {
 205         _vDefaultLeaveFunctors = new Action::FunctorStore;
 206
 207         addPostFactoryExitFunction(&RenderAction::terminateLeave);
 208     }
 209
 210     while(type.getId() >= _vDefaultLeaveFunctors->size())
 211     {
 212         _vDefaultLeaveFunctors->push_back(&Action::_defaultLeaveFunction);
 213     }
 214
 215     FDEBUG_GV(("Register rendertrav leave for %s\n", type.getCName()));
 216
 217     (*_vDefaultLeaveFunctors)[type.getId()] = func;
 218 }
 219
 220
 221
 222 /*-------------------------------------------------------------------------*\
 223  -  protected                                                              -
 224 \*-------------------------------------------------------------------------*/
 225
 226
 227 /*-------------------------------------------------------------------------*\
 228  -  private                                                                -
 229 \*-------------------------------------------------------------------------*/
 230
 231
 232
 233 /***************************************************************************\
 234  *                           Instance methods                              *
 235 \***************************************************************************/
 236
 237 /*-------------------------------------------------------------------------*\
 238  -  public                                                                 -
 239 \*-------------------------------------------------------------------------*/
 240
 241 /*-------------------------- your_category---------------------------------*/
 242
 243 Action::ResultE RenderAction::start(void)
 244 {
 245     Inherited::start();
 246
 247 #if 0 // Not needed done by the partition setup anyway.
 248     if(_pWindow != NULL && !_doCullOnly)
 249     {
 250         _pWindow->resizeGL();
 251     }
 252 #endif
 253
 254     if(_pViewarea != NULL && _pViewarea->getRenderOptions() != NULL)
 255     {
 256         _pViewarea->getRenderOptions()->activate(this);
 257     }
 258     else if(_pWindow != NULL && _pWindow->getRenderOptions() != NULL)
 259     {
 260         _pWindow->getRenderOptions()->activate(this);
 261     }
 262
 263     _vRenderPartitions[_currentBuffer].clear   ();
 264
 265     if(_bDrawPartPar == false)
 266     {
 267         _pPartitionPools  [_currentBuffer]->freeAll();
 268         _pNodePools       [_currentBuffer]->freeAll();
 269         _pStatePools      [_currentBuffer]->freeAll();
 270         _pTreeBuilderPools[_currentBuffer]->freeAll();
 271     }
 272
 273     _pActivePartition = _pPartitionPools[_currentBuffer]->create();
 274
 275     _vRenderPartitions[_currentBuffer].push_back(_pActivePartition);
 276
 277     _iActivePartitionIdx = 0;
 278
 279     _pActivePartition->setKeyGen         (_uiKeyGen                         );
 280     _pActivePartition->setAction         ( this                             );
 281     _pActivePartition->setNodePool       (_pNodePools       [_currentBuffer]);
 282     _pActivePartition->setStatePool      (_pStatePools      [_currentBuffer]);
 283     _pActivePartition->setTreeBuilderPool(_pTreeBuilderPools[_currentBuffer]);
 284     _pActivePartition->setStatCollector  (_pStatistics                      );
 285
 286     _pActivePartition->setFrustum        (_oFrustum                );
 287
 288     _pActivePartition->setFrustumCulling (_bFrustumCulling         );
 289     _pActivePartition->setVolumeDrawing  (_bVolumeDrawing          );
 290     _pActivePartition->setZWriteTrans    (_bZWriteTrans            );
 291     _pActivePartition->setCorrectNegScale(_bCorrectTwoSidedLighting);
 292
 293     _pActivePartition->getDrawEnv().setDrawerId  (_iDrawerId  );
 294     _pActivePartition->getDrawEnv().setDrawableId(_iDrawableId);
 295
 296     _pActivePartition->init();
 297
 298     if(_pGlobalOverride != NULL)
 299     {
 300         _pActivePartition->overrideMaterial(_pGlobalOverride,
 301                                              NULL           );
 302     }
 303 #ifdef OSG_DEBUGX
 304     _pActivePartition->setDebugString("DefaultPartition");
 305 #endif
 306
 307
 308 //    bool full = true;
 309
 310     if(_pViewarea != NULL)
 311     {
 312 //        _pActivePartition->setViewport(_pViewport);
 313         _pActivePartition->setWindow  (_pWindow  );
 314
 315 #if 0
 316         _pActivePartition->setViewportDimension(_pViewport->getPixelLeft  (),
 317                                                 _pViewport->getPixelBottom(),
 318                                                 _pViewport->getPixelRight (),
 319                                                 _pViewport->getPixelTop   (),
 320                                                 _pViewport->isFullWindow  ());
 321 #endif
 322
 323         _pActivePartition->calcViewportDimension(_pViewarea->getLeft  (),
 324                                                  _pViewarea->getBottom(),
 325                                                  _pViewarea->getRight (),
 326                                                  _pViewarea->getTop   (),
 327
 328                                                  _pWindow  ->getWidth (),
 329                                                  _pWindow  ->getHeight());
 330
 331         if(_pViewarea->isPassive() == true)
 332         {
 333             _pActivePartition->addSetupModeBit(RenderPartition::PassiveBit);
 334         }
 335
 336         _pActivePartition->setRenderTarget(_pViewarea->getTarget());
 337
 338         if(_pCamera != NULL)
 339         {
 340             Matrix m, t;
 341
 342             // set the projection
 343 #if 0
 344             _pCamera->getProjection          ( m,
 345                                               _pViewport->getPixelWidth (),
 346                                               _pViewport->getPixelHeight());
 347
 348             _pCamera->getProjectionTranslation( t,
 349                                                _pViewport->getPixelWidth (),
 350                                                _pViewport->getPixelHeight());
 351
 352             _pActivePartition->setupProjection(m, t);
 353
 354             _pCamera->getViewing( m,
 355                                  _pViewport->getPixelWidth (),
 356                                  _pViewport->getPixelHeight());
 357 #endif
 358
 359             _pCamera->getProjection          (
 360                  m,
 361                 _pActivePartition->getViewportWidth (),
 362                 _pActivePartition->getViewportHeight());
 363
 364             _pCamera->getProjectionTranslation(
 365                  t,
 366                 _pActivePartition->getViewportWidth (),
 367                 _pActivePartition->getViewportHeight());
 368
 369             _pActivePartition->setupProjection(m, t);
 370
 371             _pCamera->getViewing(
 372                  m,
 373                 _pActivePartition->getViewportWidth (),
 374                 _pActivePartition->getViewportHeight());
 375
 376
 377             _pActivePartition->setupViewing(m);
 378
 379             _pActivePartition->setNear(_pCamera->getNear());
 380             _pActivePartition->setFar (_pCamera->getFar ());
 381
 382             _pActivePartition->getDrawEnv().setTileFullSize(
 383                 _pCamera->tileGetFullSize());
 384             _pActivePartition->getDrawEnv().setTileRegion  (
 385                 _pCamera->tileGetRegion  ());
 386
 387         }
 388
 389         _pActivePartition->initVPMatricesFromCamera();
 390
 391         _pActivePartition->setBackground(_pBackground);
 392     }
 393
 394 //    fprintf(stderr, "Start\n");
 395
 396     if(_bDrawPartPar == true)
 397     {
 398 #ifdef OSG_RENPART_DUMP_PAR
 399         fprintf(stderr, "start with %p\n", _pActivePartition);
 400         fflush(stderr);
 401 #endif
 402         _bDefaultPartHandled = false;
 403 //        _pWindow->queueTask(_pActivePartition);
 404     }
 405
 406     return Action::Continue;
 407 }
 408
 409 Action::ResultE RenderAction::stop(ResultE res)
 410 {
 411 #ifdef OSG_RENPART_DUMP_PAR
 412     fprintf(stderr, "Stop\n");
 413     fflush(stderr);
 414 #endif
 415
 416     Inherited::stop(res);
 417
 418     if(!_doCullOnly)
 419     {
 420         drawBuffer(_currentBuffer);
 421
 422         if(getVolumeDrawing())
 423             drawVolume(_oFrustum);
 424     }
 425
 426     if(_pViewarea != NULL && _pViewarea->getRenderOptions() != NULL)
 427     {
 428         _pViewarea->getRenderOptions()->deactivate(this);
 429     }
 430     else if(_pWindow != NULL && _pWindow->getRenderOptions() != NULL)
 431     {
 432         _pWindow->getRenderOptions()->deactivate(this);
 433     }
 434
 435     return Action::Continue;
 436 }
 437
 438 void RenderAction::frameInit(void)
 439 {
 440     Inherited::frameInit();
 441
 442     if(_bDrawPartPar == true)
 443     {
 444         _pPartitionPools  [_currentBuffer]->freeAll();
 445         _pNodePools       [_currentBuffer]->freeAll();
 446         _pStatePools      [_currentBuffer]->freeAll();
 447         _pTreeBuilderPools[_currentBuffer]->freeAll();
 448     }
 449 }
 450
 451 /*------------------------------ access -----------------------------------*/
 452
 453 void RenderAction::dropFunctor(DrawEnv::DrawFunctor &func,
 454                                Material             *pMat,
 455                                bool                  bIgnoreOverrides)
 456 {
 457     if(pMat == NULL)
 458         return;
 459
 460     PrimeMaterial *pPrimeMat = pMat->finalize(_oCurrentRenderProp,
 461                                                this->getCurrentOverrides(),
 462                                               _pWindow);
 463
 464     if(pPrimeMat == NULL)
 465         return;
 466
 467     UInt32 uiNPasses = pPrimeMat->getNPasses();
 468
 469     for(UInt32 uiPass = 0; uiPass < uiNPasses; ++uiPass)
 470     {
 471         State *st = pPrimeMat->getState(uiPass);
 472
 473         if(st != NULL)
 474         {
 475             this->dropFunctor(func,
 476                               st,
 477                               pPrimeMat->getSortKey() + uiPass,
 478                               bIgnoreOverrides                );
 479         }
 480         else
 481         {
 482 #ifndef WIN32
 483             FINFO(("%s: hit material with NULL state!\n", __func__));
 484 #else
 485             FINFO(("Hit material with NULL state!\n"));
 486 #endif
 487         }
 488     }
 489 }
 490
 491 // select all visible nodes
 492 UInt32 RenderAction::selectVisibles(void)
 493 {
 494     if(getFrustumCulling() == false)
 495         return getNNodes();
 496
 497     useNodeList();
 498
 499     Color3f col;
 500
 501     UInt32 count = 0;
 502
 503     for(UInt32 i = 0; i < getNNodes(); i++)
 504     {
 505         if(isVisible(getNode(i)))
 506         {
 507             col.setValuesRGB(0,1,0);
 508
 509             addNode(getNode(i));
 510
 511             ++count;
 512         }
 513         else
 514         {
 515             col.setValuesRGB(1,0,0);
 516         }
 517
 518         if(getVolumeDrawing())
 519         {
 520             dropVolume(this, getNode(i), col);
 521         }
 522     }
 523
 524     return count;
 525 }
 526
 527
 528 bool RenderAction::pushVisibility(void)
 529 {
 530     if(_pActivePartition->pushVisibility(getActNode()) == false)
 531     {
 532         useNodeList(); // ignore all children
 533         return false;
 534     }
 535
 536     return true;
 537 }
 538
 539 void RenderAction::readdPartitionByIndex(UInt32 uiPartIdx)
 540 {
 541     OSG_ASSERT(uiPartIdx < _vRenderPartitions[_currentBuffer].size());
 542
 543     _vRenderPartitions[_currentBuffer].push_back(
 544         _vRenderPartitions[_currentBuffer][uiPartIdx]);
 545 }
 546
 547 void RenderAction::dumpPartitionList(void)
 548 {
 549     fprintf(stderr, "Dump PartitionList \n");
 550
 551     for(UInt32 i = 0; i < _vRenderPartitions[_currentBuffer].size(); ++i)
 552     {
 553         fprintf(stderr, "    %p\n",
 554                 static_cast<void *>(_vRenderPartitions[_currentBuffer][i]));
 555     }
 556 }
 557
 558 /*------------------------ multi-buffer stuff -----------------------------*/
 559
 560 void RenderAction::setNumBuffers(UInt32 n)
 561 {
 562     if(n < 1)
 563     {
 564         FWARNING(("RenderAction::setNumBuffers: need at least one "
 565                   "buffer!\n"));
 566         n = 1;
 567     }
 568
 569     if(n > _numBuffers)
 570     {
 571         for(UInt16 i = _numBuffers; i < n; ++i)
 572         {
 573             _pPartitionPools  .push_back(new RenderPartitionPool);
 574             _pNodePools       .push_back(new RenderTreeNodePool);
 575             _pStatePools      .push_back(new StateOverridePool);
 576             _pTreeBuilderPools.push_back(new TreeBuilderPool);
 577         }
 578
 579     }
 580     else if(n < _numBuffers)
 581     {
 582         for(UInt16 i = _numBuffers - 1; i >= n; --i)
 583         {
 584             delete _pPartitionPools[i];
 585             delete _pNodePools[i];
 586             delete _pStatePools[i];
 587             delete _pTreeBuilderPools[i];
 588         }
 589         _pPartitionPools  .resize(n);
 590         _pNodePools       .resize(n);
 591         _pStatePools      .resize(n);
 592         _pTreeBuilderPools.resize(n);
 593     }
 594     _numBuffers = n;
 595     _vRenderPartitions.resize(n);
 596 }
 597
 598
 599 void RenderAction::drawBuffer(UInt32 buf)
 600 {
 601     if(_pStatistics != NULL)
 602     {
 603         _pStatistics->getElem(statDrawTime)->start();
 604     }
 605
 606     if(_bDrawPartPar == false)
 607     {
 608         _vRenderPartitions[buf][0]->setupExecution(true);
 609
 610         for(PtrDiffT i = _vRenderPartitions[buf].size() - 1; i > 0; --i)
 611         {
 612             _vRenderPartitions[buf][i]->execute();
 613 //        _vRenderPartitions[buf][i]->exit();
 614         }
 615
 616         _vRenderPartitions[buf][0]->doExecution(true);
 617 //    _vRenderPartitions[buf][0]->exit();
 618
 619         if(_bUseGLFinish == true)
 620         {
 621             glFinish();
 622         }
 623     }
 624     else
 625     {
 626 #if 0
 627         if(_bDefaultPartHandled == false)
 628         {
 629             _vRenderPartitions[_currentBuffer][0]->setTaskType(
 630                 RenderPartition::Full);
 631         }
 632 #endif
 633
 634         _pWindow->queueTaskFromDrawer(_vRenderPartitions[buf][0]);
 635
 636         if(_bUseGLFinish == true)
 637         {
 638             if(_pGLFinishTask == NULL)
 639             {
 640                 _pGLFinishTask =
 641                     new RenderActionTask(RenderActionTask::HandleGLFinish);
 642             }
 643
 644             _pWindow->queueTaskFromDrawer(_pGLFinishTask);
 645
 646             _pGLFinishTask->waitForBarrier();
 647         }
 648     }
 649
 650     if(_pStatistics != NULL)
 651     {
 652         _pStatistics->getElem(statDrawTime)->stop();
 653     }
 654 }
 655
 656 /*------------------------ Occlusion Culling -----------------------------*/
 657
 658
 659 /*-------------------------- assignment -----------------------------------*/
 660
 661 /** \brief assignment
 662  */
 663
 664 /*-------------------------- comparison -----------------------------------*/
 665
 666
 667 /*-------------------------------------------------------------------------*\
 668  -  protected                                                              -
 669 \*-------------------------------------------------------------------------*/
 670
 671 /*------------- constructors & destructors --------------------------------*/
 672
 673 RenderAction::RenderAction(void) :
 674      Inherited               (          ),
 675     _doCullOnly              (     false),
 676     _numBuffers              (         0),
 677     _currentBuffer           (         0),
 678
 679     _uiKeyGen                (         0),
 680
 681     _pPartitionPools         (          ),
 682     _pNodePools              (          ),
 683     _pStatePools             (          ),
 684     _pTreeBuilderPools       (          ),
 685
 686     _vRenderPartitions       (          ),
 687
 688     _iActivePartitionIdx     (-1        ),
 689     _bInPartitionGroup       (false     ),
 690     _bDefaultPartHandled     (false     ),
 691     _pActivePartition        (NULL      ),
 692
 693     _sRenderPartitionStack   (          ),
 694     _sRenderPartitionIdxStack(          ),
 695     _sRenderPartitionGrpStack(          ),
 696
 697     _bvPassMask              (          ),
 698
 699     _occlusionCulling        (false     ),
 700     _occlusionCullingDebug   (false     ),
 701     _occDMTested             (0xffffffff),
 702     _occDMCulled             (0xffffffff),
 703     _occDMVisible            (0xffffffff),
 704     _occMinFeatureSize       (         0),
 705     _occVisibilityThreshold  (         0),
 706     _occCoveredThreshold     (      0.7f),
 707     _occQueryBufferSize      (      1000),
 708     _occMinimumTriangleCount (       500),
 709
 710     _scrlodCoverageThreshold (     0.01f),
 711     _scrlodNumLODsToUse      (         0),
 712     _scrlodDegradationFactor (      1.0f),
 713
 714     _pGLFinishTask           (NULL      )
 715 {
 716     if(_vDefaultEnterFunctors != NULL)
 717         _enterFunctors = *_vDefaultEnterFunctors;
 718
 719     if(_vDefaultLeaveFunctors != NULL)
 720         _leaveFunctors = *_vDefaultLeaveFunctors;
 721
 722     setNumBuffers(1);
 723
 724     UInt32 uiTId  = TextureBaseChunk        ::getStaticClassId() & 0x000003FF;
 725     UInt32 uiShId = ShaderExecutableChunk   ::getStaticClassId() & 0x000003FF;
 726     UInt32 uiMId  = ShaderExecutableVarChunk::getStaticClassId() & 0x000003FF;
 727
 728     _uiKeyGen = ( (uiShId) | (uiTId << 10) | (uiMId      << 20) );
 729
 730     _travMask &= ~TraversalMasks::FindNamedComponentTraversal;
 731
 732 /*
 733     fprintf(stderr, "CreateKeyGen (RT) (%p) from %d %d %d -> %08x\n",
 734             this,
 735             SHLChunk     ::getStaticClassId(),
 736             TextureChunk ::getStaticClassId(),
 737             MaterialChunk::getStaticClassId(),
 738             _uiKeyGen);
 739  */
 740
 741 }
 742
 743 RenderAction::RenderAction(const RenderAction &source) :
 744
 745      Inherited               (source                         ),
 746     _doCullOnly              (false                          ),
 747     _numBuffers              (0                              ),
 748     _currentBuffer           (0                              ),
 749
 750     _uiKeyGen                (source._uiKeyGen               ),
 751
 752     _pPartitionPools         (                               ),
 753     _pNodePools              (                               ),
 754     _pStatePools             (                               ),
 755     _pTreeBuilderPools       (                               ),
 756
 757     _vRenderPartitions       (                               ),
 758
 759     _iActivePartitionIdx     (-1                             ),
 760     _bInPartitionGroup       (false                          ),
 761     _bDefaultPartHandled     (false                          ),
 762     _pActivePartition        (NULL                           ),
 763
 764     _sRenderPartitionStack   (                               ),
 765     _sRenderPartitionIdxStack(                               ),
 766     _sRenderPartitionGrpStack(                               ),
 767
 768     _bvPassMask              (source._bvPassMask             ),
 769
 770     _occlusionCulling        (source._occlusionCulling       ),
 771     _occlusionCullingDebug   (source._occlusionCullingDebug  ),
 772     _occDMTested             (source._occDMTested            ),
 773     _occDMCulled             (source._occDMCulled            ),
 774     _occDMVisible            (source._occDMVisible           ),
 775     _occMinFeatureSize       (source._occMinFeatureSize      ),
 776     _occVisibilityThreshold  (source._occVisibilityThreshold ),
 777     _occCoveredThreshold     (source._occCoveredThreshold    ),
 778     _occQueryBufferSize      (source._occQueryBufferSize     ),
 779     _occMinimumTriangleCount (source._occMinimumTriangleCount),
 780
 781     _scrlodCoverageThreshold (source._scrlodCoverageThreshold),
 782     _scrlodNumLODsToUse      (source._scrlodNumLODsToUse     ),
 783     _scrlodDegradationFactor (source._scrlodDegradationFactor),
 784
 785     _pGLFinishTask           (NULL                           )
 786 {
 787     setNumBuffers(source._numBuffers);
 788 }
 789
 790
 791
 792 RenderAction::~RenderAction(void)
 793 {
 794     for(UInt16 i = 0; i < _numBuffers; ++i)
 795     {
 796         delete _pPartitionPools[i];
 797         delete _pNodePools[i];
 798         delete _pStatePools[i];
 799         delete _pTreeBuilderPools[i];
 800     }
 801
 802     _pGLFinishTask  = NULL;
 803 }
 804
 805
 806 Action::FunctorStore *RenderAction::getDefaultEnterFunctors(void)
 807 {
 808     return _vDefaultEnterFunctors;
 809 }
 810
 811 Action::FunctorStore *RenderAction::getDefaultLeaveFunctors(void)
 812 {
 813     return _vDefaultLeaveFunctors;
 814 }
 815
 816 void RenderAction::pushPartition(UInt32                uiCopyOnPush,
 817                                  RenderPartition::Mode eMode       )
 818 {
 819     _sRenderPartitionIdxStack.push(_iActivePartitionIdx);
 820     _sRenderPartitionStack   .push(_pActivePartition   );
 821     _sRenderPartitionGrpStack.push(_bInPartitionGroup  );
 822
 823     _pActivePartition->setNode(_actNode);
 824
 825     if(_bInPartitionGroup == false)
 826     {
 827         _pActivePartition    =
 828             _pPartitionPools  [_currentBuffer]->create(eMode);
 829         _iActivePartitionIdx = Int32(_vRenderPartitions[_currentBuffer].size());
 830
 831         _vRenderPartitions[_currentBuffer].push_back(_pActivePartition);
 832     }
 833     else
 834     {
 835 /*
 836         RenderPartitionStore::iterator it =
 837             _vRenderPartitions[_currentBuffer].begin();
 838
 839         it += _iActivePartitionIdx;
 840
 841         _pActivePartition    =
 842             _pPartitionPools  [_currentBuffer]->create(eMode);
 843
 844         _vRenderPartitions[_currentBuffer].insert(it, _pActivePartition);
 845  */
 846         _pActivePartition    =
 847             _pPartitionPools  [_currentBuffer]->create(eMode);
 848
 849         if(static_cast<size_t>(_iActivePartitionIdx) ==
 850                                      _vRenderPartitions[_currentBuffer].size())
 851         {
 852             _vRenderPartitions[_currentBuffer].push_back(_pActivePartition);
 853         }
 854         else
 855         {
 856             _vRenderPartitions[_currentBuffer]
 857                               [_iActivePartitionIdx]->addPartition(
 858                                   _pActivePartition);
 859         }
 860
 861         _bInPartitionGroup   = false;
 862     }
 863
 864 #ifdef OSG_RENPART_DUMP_PAR
 865     fprintf(stderr, "Process %p\n", _pActivePartition);
 866     fflush(stderr);
 867 #endif
 868
 869     _pActivePartition->setKeyGen         (_uiKeyGen                         );
 870     _pActivePartition->setAction         ( this                             );
 871     _pActivePartition->setNodePool       (_pNodePools       [_currentBuffer]);
 872     _pActivePartition->setStatePool      (_pStatePools      [_currentBuffer]);
 873     _pActivePartition->setTreeBuilderPool(_pTreeBuilderPools[_currentBuffer]);
 874     _pActivePartition->setStatCollector  (_pStatistics                      );
 875     _pActivePartition->setFrustumCulling (_bFrustumCulling                  );
 876     _pActivePartition->setVolumeDrawing  (_bVolumeDrawing                   );
 877     _pActivePartition->setZWriteTrans    (_bZWriteTrans                     );
 878
 879     _pActivePartition->setCorrectNegScale(_bCorrectTwoSidedLighting         );
 880
 881     _pActivePartition->getDrawEnv().setDrawerId  (_iDrawerId  );
 882     _pActivePartition->getDrawEnv().setDrawableId(_iDrawableId);
 883
 884     _pActivePartition->initFrom(_sRenderPartitionStack.top(),
 885                                 _vRenderPartitions[_currentBuffer][0],
 886                                  uiCopyOnPush               );
 887 }
 888
 889 void RenderAction::popPartition(void)
 890 {
 891     RenderPartition *pCurrPart = _pActivePartition;
 892
 893     _pActivePartition    = _sRenderPartitionStack   .top();
 894     _iActivePartitionIdx = _sRenderPartitionIdxStack.top();
 895     _bInPartitionGroup   = _sRenderPartitionGrpStack.top();
 896
 897     _actNode = _pActivePartition->getNode();
 898
 899     _sRenderPartitionStack   .pop();
 900     _sRenderPartitionIdxStack.pop();
 901     _sRenderPartitionGrpStack.pop();
 902
 903     if(_bDrawPartPar == true)
 904     {
 905         if(pCurrPart->getRenderTarget() == NULL  &&
 906            _bDefaultPartHandled         == false  )
 907         {
 908             _pActivePartition->setTaskType(RenderPartition::Setup);
 909             _pWindow->queueTaskFromDrawer(
 910                 _vRenderPartitions[_currentBuffer][0]);
 911
 912             _bDefaultPartHandled = true;
 913         }
 914
 915         _pWindow->queueTaskFromDrawer(pCurrPart);
 916
 917 #ifdef OSG_RENPART_DUMP_PAR
 918         fprintf(stderr, "queue %p\n", pCurrPart);
 919         fflush(stderr);
 920 #endif
 921     }
 922 }
 923
 924 /*-------------------------------------------------------------------------*\
 925  -  private                                                                -
 926 \*-------------------------------------------------------------------------*/
 927