Source/System/NodeCores/Groups/Base/OSGMultiCore.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 "OSGMultiCore.h"
  49 #include "OSGRenderAction.h"
  50
  51 OSG_BEGIN_NAMESPACE
  52
  53 // Documentation for this class is emitted in the
  54 // OSGMultiCoreBase.cpp file.
  55 // To modify it, please change the .fcd file (OSGMultiCore.fcd) and
  56 // regenerate the base file.
  57
  58 /***************************************************************************\
  59  *                           Class variables                               *
  60 \***************************************************************************/
  61
  62 /***************************************************************************\
  63  *                           Class methods                                 *
  64 \***************************************************************************/
  65
  66 void MultiCore::initMethod(InitPhase ePhase)
  67 {
  68     Inherited::initMethod(ePhase);
  69
  70     if(ePhase == TypeObject::SystemPost)
  71     {
  72         RenderAction::registerEnterDefault(
  73             MultiCore::getClassType(),
  74             reinterpret_cast<Action::Callback>(&MultiCore::renderEnter));
  75
  76         RenderAction::registerLeaveDefault(
  77             MultiCore::getClassType(),
  78             reinterpret_cast<Action::Callback>(&MultiCore::renderLeave));
  79     }
  80 }
  81
  82
  83 /***************************************************************************\
  84  *                           Instance methods                              *
  85 \***************************************************************************/
  86
  87 /*-------------------------------------------------------------------------*\
  88  -  private                                                                 -
  89 \*-------------------------------------------------------------------------*/
  90
  91 /*----------------------- constructors & destructors ----------------------*/
  92
  93 MultiCore::MultiCore(void) :
  94     Inherited()
  95 {
  96 }
  97
  98 MultiCore::MultiCore(const MultiCore &source) :
  99     Inherited(source)
 100 {
 101 }
 102
 103 MultiCore::~MultiCore(void)
 104 {
 105 }
 106
 107 /*----------------------------- class specific ----------------------------*/
 108
 109 void MultiCore::changed(ConstFieldMaskArg whichField,
 110                             UInt32            origin,
 111                             BitVector         details)
 112 {
 113     if(whichField & CoresFieldMask)
 114     {
 115         invalidateVolume();
 116     }
 117
 118     Inherited::changed(whichField, origin, details);
 119 }
 120
 121 /*-------------------------------------------------------------------------*/
 122 /*                               Helper                                    */
 123
 124 void MultiCore::accumulateMatrix(Matrix &result)
 125 {
 126     MFUnrecChildNodeCorePtr::const_iterator coreIt  = getMFCores()->begin();
 127     MFUnrecChildNodeCorePtr::const_iterator coreEnd = getMFCores()->end  ();
 128
 129     while(coreIt != coreEnd)
 130     {
 131         (*coreIt)->accumulateMatrix(result);
 132
 133         ++coreIt;
 134     }
 135 }
 136
 137 void MultiCore::adjustVolume(Volume &volume)
 138 {
 139     MFUnrecChildNodeCorePtr::const_iterator coreIt  = getMFCores()->begin();
 140     MFUnrecChildNodeCorePtr::const_iterator coreEnd = getMFCores()->end  ();
 141
 142     while(coreIt != coreEnd)
 143     {
 144         (*coreIt)->adjustVolume(volume);
 145
 146         ++coreIt;
 147     }
 148 }
 149
 150 void MultiCore::dump(      UInt32    ,
 151                          const BitVector ) const
 152 {
 153     SLOG << "Dump MultiCore NI" << std::endl;
 154 }
 155
 156 Action::ResultE MultiCore::renderEnter(Action *action)
 157 {
 158     MFUnrecChildNodeCorePtr::const_iterator coreIt  =
 159         this->getMFCores()->begin();
 160
 161     MFUnrecChildNodeCorePtr::const_iterator coreEnd =
 162         this->getMFCores()->end  ();
 163
 164     Action::ResultE returnValue = Action::Continue;
 165
 166     while(coreIt != coreEnd)
 167     {
 168         action->setActParent(this);
 169
 170         Action::ResultE rc = action->callEnter(*coreIt);
 171
 172         if(rc == Action::Skip)
 173         {
 174             returnValue = rc;
 175
 176             if(_sfExitOnSkip.getValue() == true)
 177                 break;
 178         }
 179         else if(rc == Action::Quit)
 180         {
 181             returnValue = rc;
 182
 183             break;
 184         }
 185
 186         ++coreIt;
 187     }
 188
 189     return returnValue;
 190 }
 191
 192 Action::ResultE MultiCore::renderLeave(Action *action)
 193 {
 194     MFUnrecChildNodeCorePtr::const_iterator coreIt  =
 195         this->getMFCores()->begin();
 196
 197     MFUnrecChildNodeCorePtr::const_iterator coreEnd =
 198         this->getMFCores()->end  ();
 199
 200     Action::ResultE returnValue = Action::Continue;
 201
 202     while(coreIt != coreEnd)
 203     {
 204         action->setActParent(this);
 205
 206         Action::ResultE rc = action->callLeave(*coreIt);
 207
 208         if(rc == Action::Skip)
 209         {
 210             returnValue = rc;
 211
 212             if(_sfExitOnSkip.getValue() == true)
 213                 break;
 214         }
 215         else if(rc == Action::Quit)
 216         {
 217             returnValue = rc;
 218
 219             break;
 220         }
 221
 222         ++coreIt;
 223     }
 224
 225     return returnValue;
 226 }
 227
 228 Action::ResultE MultiCore::actionEnterFrom(Action   *action,
 229                                            NodeCore *pFrom )
 230 {
 231     MFUnrecChildNodeCorePtr::const_iterator coreIt  =
 232         this->getMFCores()->begin();
 233
 234     MFUnrecChildNodeCorePtr::const_iterator coreEnd =
 235         this->getMFCores()->end  ();
 236
 237     Action::ResultE returnValue = Action::Continue;
 238
 239     bool bActive = false;
 240
 241     while(coreIt != coreEnd)
 242     {
 243         if(bActive == true)
 244         {
 245             action->setActParent(this);
 246
 247             Action::ResultE rc = action->callEnter(*coreIt);
 248
 249             if(rc == Action::Skip)
 250             {
 251                 returnValue = rc;
 252
 253                 if(_sfExitOnSkip.getValue() == true)
 254                     break;
 255             }
 256             else if(rc == Action::Quit)
 257             {
 258                 returnValue = rc;
 259
 260                 break;
 261             }
 262         }
 263
 264         if(*coreIt == pFrom)
 265             bActive = true;
 266
 267         ++coreIt;
 268     }
 269
 270     return returnValue;
 271 }
 272
 273 Action::ResultE MultiCore::actionLeaveFrom(Action   *action,
 274                                            NodeCore *pFrom )
 275 {
 276     MFUnrecChildNodeCorePtr::const_iterator coreIt  =
 277         this->getMFCores()->begin();
 278
 279     MFUnrecChildNodeCorePtr::const_iterator coreEnd =
 280         this->getMFCores()->end  ();
 281
 282     Action::ResultE returnValue = Action::Continue;
 283
 284     bool bActive = false;
 285
 286     while(coreIt != coreEnd)
 287     {
 288         if(bActive == true)
 289         {
 290             action->setActParent(this);
 291
 292             Action::ResultE rc = action->callLeave(*coreIt);
 293
 294             if(rc == Action::Skip)
 295             {
 296                 returnValue = rc;
 297
 298                 if(_sfExitOnSkip.getValue() == true)
 299                     break;
 300             }
 301             else if(rc == Action::Quit)
 302             {
 303                 returnValue = rc;
 304
 305                 break;
 306             }
 307         }
 308
 309         if(*coreIt == pFrom)
 310             bActive = true;
 311
 312         ++coreIt;
 313     }
 314
 315     return returnValue;
 316 }
 317
 318 void MultiCore::replaceCore(UInt32           uiIndex,
 319                             NodeCore * const value   )
 320 {
 321     if(value == NULL)
 322         return;
 323
 324     if(uiIndex >= _mfCores.size())
 325         return;
 326
 327     editMField(CoresFieldMask, _mfCores);
 328
 329     _mfCores.replace(uiIndex, value);
 330 }
 331
 332 void MultiCore::replaceCoreByObj(NodeCore * const pOldElem,
 333                                  NodeCore * const pNewElem)
 334 {
 335     if(pNewElem == NULL)
 336         return;
 337
 338     Int32 elemIdx = _mfCores.findIndex(pOldElem);
 339
 340     if(elemIdx != -1)
 341     {
 342         editMField(CoresFieldMask, _mfCores);
 343
 344         _mfCores.replace(elemIdx, pNewElem);
 345     }
 346 }
 347
 348 OSG_SYSTEM_DLLMAPPING
 349 void addCoreToNode(Node     *pNode,
 350                    NodeCore *pCore)
 351 {
 352     if(pNode == NULL || pCore == NULL)
 353         return;
 354
 355     NodeCore  *pCurrCore = pNode->getCore();
 356     MultiCore *pMCore    = dynamic_cast<MultiCore *>(pCurrCore);
 357
 358     if(pMCore != NULL)
 359     {
 360         Int32 iIdx = pMCore->findCore(pCore);
 361
 362         if(iIdx == -1)
 363         {
 364             pMCore->addCore(pCore);
 365         }
 366     }
 367     else if(pCurrCore == NULL)
 368     {
 369         pNode->setCore(pCore);
 370     }
 371     else
 372     {
 373         if(pCore != pCurrCore)
 374         {
 375             MultiCoreUnrecPtr pNewMCore = MultiCore::create();
 376
 377             pNewMCore->addCore(pCurrCore);
 378             pNewMCore->addCore(pCore    );
 379
 380             pNode->setCore(pNewMCore);
 381         }
 382     }
 383 }
 384
 385 OSG_SYSTEM_DLLMAPPING
 386 void subCoreFromNode(Node     *pNode,
 387                      NodeCore *pCore,
 388                      bool      bSimplify)
 389 {
 390     if(pNode == NULL || pCore == NULL)
 391         return;
 392
 393     NodeCore          *pCurrCore = pNode->getCore();
 394     MultiCoreUnrecPtr  pMCore    = dynamic_cast<MultiCore *>(pCurrCore);
 395
 396     if(pMCore != NULL)
 397     {
 398         pMCore->subCoreByObj(pCore);
 399
 400         if(bSimplify == true)
 401         {
 402             if(pMCore->getNCores() == 1)
 403             {
 404                 pNode->setCore(pMCore->getCores(0));
 405
 406                 pMCore = NULL;
 407             }
 408             else if(pMCore->getNCores() == 0)
 409             {
 410                 pNode->setCore(NULL);
 411             }
 412         }
 413     }
 414     else
 415     {
 416         if(pCore == pCurrCore)
 417         {
 418             pNode->setCore(NULL);
 419         }
 420     }
 421 }
 422
 423 OSG_END_NAMESPACE