Source/Contrib/ComplexSceneManager/OSGComplexSceneManager.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 <boost/bind.hpp>
  47
  48 #include "OSGConfig.h"
  49
  50 #include "OSGComplexSceneManager.h"
  51 #include "OSGOSGSceneFileType.h"
  52 #include "OSGContainerCollection.h"
  53 #include "OSGSceneFileHandler.h"
  54 #include "OSGImageFileHandler.h"
  55 #include "OSGNameAttachment.h"
  56 #include "OSGAction.h"
  57 #include "OSGCSMResetInterface.h"
  58 #include "OSGFrameHandler.h"
  59 #include "OSGGeoProperty.h"
  60
  61 #include "OSGGeoFunctions.h"
  62 #include "OSGGraphOpFactory.h"
  63
  64 #include "OSGCSMDrawManager.h"
  65
  66 //#include "OSGFieldContainerFactory.h"
  67 //#include "OSGTypeFactory.h"
  68
  69 OSG_BEGIN_NAMESPACE
  70
  71 // Documentation for this class is emitted in the
  72 // OSGComplexSceneManagerBase.cpp file.
  73 // To modify it, please change the .fcd file (OSGComplexSceneManager.fcd) and
  74 // regenerate the base file.
  75
  76 struct NodeFinder
  77 {
  78     std::string  _szRefName;
  79     Node        *_pResult;
  80
  81     NodeFinder(void) :
  82         _szRefName(    ),
  83         _pResult  (NULL)
  84     {
  85     }
  86
  87     Action::ResultE enter(Node * const pNode)
  88     {
  89         Action::ResultE returnValue = Action::Continue;
  90
  91         const Char8 *szName = OSG::getName(pNode);
  92
  93         if(szName != NULL)
  94         {
  95             if(osgStringCmp(_szRefName.c_str(), szName) == 0)
  96             {
  97                 _pResult = pNode;
  98
  99                 returnValue = Action::Quit;
 100             }
 101         }
 102
 103         return returnValue;
 104     }
 105
 106   private:
 107
 108     NodeFinder(const NodeFinder &other);
 109     void operator=(const NodeFinder &rhs);
 110 };
 111
 112 struct ElementFinder
 113 {
 114     std::string     _szRefName;
 115     FieldContainer *_pResult;
 116
 117     ElementFinder(void) :
 118         _szRefName(    ),
 119         _pResult  (NULL)
 120     {
 121     }
 122
 123     Action::ResultE enter(Node * const pNode)
 124     {
 125         Action::ResultE returnValue = Action::Continue;
 126
 127         const Char8 *szName = OSG::getName(pNode);
 128
 129         if(szName != NULL)
 130         {
 131             if(osgStringCmp(_szRefName.c_str(), szName) == 0)
 132             {
 133                 _pResult = pNode;
 134
 135                 returnValue = Action::Quit;
 136             }
 137         }
 138         else if(pNode->getCore() != NULL)
 139         {
 140             szName = OSG::getName(pNode->getCore());
 141
 142             if(szName != NULL)
 143             {
 144                 if(osgStringCmp(_szRefName.c_str(), szName) == 0)
 145                 {
 146                     _pResult = pNode;
 147
 148                     returnValue = Action::Quit;
 149                 }
 150             }
 151         }
 152
 153         return returnValue;
 154     }
 155
 156   private:
 157
 158     ElementFinder(const ElementFinder &other);
 159     void operator=(const ElementFinder &rhs);
 160
 161 };
 162
 163 /***************************************************************************\
 164  *                           Class variables                               *
 165 \***************************************************************************/
 166
 167 Time                                 ComplexSceneManager::SystemTime = 0.0;
 168
 169 ComplexSceneManagerUnrecPtr          ComplexSceneManager::_the = NULL;
 170 PathHandler                          ComplexSceneManager::_oPathHandler;
 171 std::vector<FieldContainerUnrecPtr > ComplexSceneManager::_vStaticGlobals;
 172 std::vector<
 173  ComplexSceneManager::DeferredFCUse> ComplexSceneManager::_vStaticUnresolvedFCs;
 174
 175 /***************************************************************************\
 176  *                           Class methods                                 *
 177 \***************************************************************************/
 178
 179 void ComplexSceneManager::initMethod(InitPhase ePhase)
 180 {
 181     Inherited::initMethod(ePhase);
 182
 183     if(ePhase == TypeObject::SystemPost)
 184     {
 185     }
 186 }
 187
 188
 189 ComplexSceneManager *ComplexSceneManager::the(void)
 190 {
 191     return _the;
 192 }
 193
 194 FieldContainer *ComplexSceneManager::resolveStatic(
 195     const Char8          *szName,
 196           FieldContainer *pDestContainer,
 197           Int32           iDestFieldId)
 198 {
 199     std::vector<FieldContainerUnrecPtr>::const_iterator gIt  =
 200         _vStaticGlobals.begin();
 201
 202     std::vector<FieldContainerUnrecPtr>::const_iterator gEnd =
 203         _vStaticGlobals.end  ();
 204
 205           AttachmentContainer *pAttCnt     = NULL;
 206           Node                *pNode       = NULL;
 207     const Char8               *szTmpName   = NULL;
 208
 209     while(gIt != gEnd)
 210     {
 211         pNode = dynamic_cast<Node *>((*gIt).get());
 212
 213         if(pNode != NULL)
 214         {
 215             ElementFinder oFinder;
 216
 217             oFinder._szRefName = szName;
 218
 219             traverse(pNode, boost::bind(&ElementFinder::enter, &oFinder, _1));
 220
 221             if(oFinder._pResult != NULL)
 222             {
 223                 return oFinder._pResult;
 224             }
 225          }
 226
 227         pAttCnt = dynamic_cast<AttachmentContainer *>((*gIt).get());
 228
 229         if(pAttCnt != NULL)
 230         {
 231             szTmpName = OSG::getName(pAttCnt);
 232
 233             if(szTmpName != NULL && osgStringCmp(szTmpName, szName) == 0)
 234             {
 235                 return pAttCnt;
 236             }
 237             else
 238             {
 239 #if 0
 240                 FieldContainer *tmpVal = pAttCnt->findNamedComponent(szName);
 241
 242                 if(tmpVal != NULL)
 243                     return tmpVal;
 244 #endif
 245             }
 246         }
 247
 248         ++gIt;
 249     }
 250
 251     if(pDestContainer != NULL && iDestFieldId >= 0)
 252     {
 253         DeferredFCUse tmpBlock;
 254
 255         tmpBlock._szName       = szName;
 256         tmpBlock._pDstCnt      = pDestContainer;
 257         tmpBlock._uiDstFieldId = UInt32(iDestFieldId);
 258
 259         _vStaticUnresolvedFCs.push_back(tmpBlock);
 260     }
 261
 262     return NULL;
 263 }
 264
 265 void ComplexSceneManager::addStaticGlobals(const Char8 *szFilename)
 266 {
 267     std::string szFilenameResolved = _oPathHandler.findFile(szFilename);
 268
 269     if(szFilenameResolved.empty() == true)
 270     {
 271         fprintf(stderr, "Could not find static global file %s\n",
 272                 szFilename);
 273
 274         return;
 275     }
 276
 277     FieldContainerUnrecPtr pRes =
 278         readOSGFile(szFilenameResolved,
 279                     boost::bind(&ComplexSceneManager::resolveStatic,
 280                                 _1, _2, _3));
 281
 282     if(pRes == NULL)
 283         return;
 284
 285     ContainerCollectionUnrecPtr pColl =
 286         dynamic_pointer_cast<ContainerCollection>(pRes);
 287
 288     if(pColl == NULL)
 289         return;
 290
 291     MFUnrecFieldContainerPtr::const_iterator fIt  =
 292         pColl->getMFContainers()->begin();
 293
 294     MFUnrecFieldContainerPtr::const_iterator fEnd =
 295         pColl->getMFContainers()->end();
 296
 297     while(fIt != fEnd)
 298     {
 299         _vStaticGlobals.push_back(*fIt);
 300
 301         ++fIt;
 302     }
 303 }
 304
 305 void ComplexSceneManager::scanParamFile(
 306     const Char8                    *szFilename,
 307           std::vector<std::string> &vParams   )
 308 {
 309     FILE *pIn = fopen(szFilename, "r");
 310
 311     Char8 szRow[1024];
 312
 313           std::string  szBuffer;
 314     const Char8       *szDelim = " \t\n ";
 315
 316     vParams.clear();
 317
 318     while(!feof(pIn))
 319     {
 320         fgets(szRow, 1024, pIn);
 321
 322         szBuffer = szRow;
 323
 324         if(feof(pIn)                ||
 325            szBuffer.empty() == true ||
 326            szBuffer[0]      == '\n' ||
 327            szBuffer[0]      == '#'   )
 328         {
 329             continue;
 330         }
 331
 332         string_token_iterator cIt (szBuffer, szDelim);
 333         string_token_iterator cEnd;
 334
 335         while(cIt != cEnd)
 336         {
 337             vParams.push_back(*cIt);
 338             ++cIt;
 339         }
 340     }
 341
 342     fclose(pIn);
 343 }
 344
 345 void ComplexSceneManager::scanPreSystem(std::vector<std::string> &vParams)
 346 {
 347     static const UInt32 ScanSystem  = 0;
 348     static const UInt32 ScanData    = 1;
 349     static const UInt32 ScanGlobals = 2;
 350
 351     UInt32 uiState = ScanSystem;
 352
 353     std::vector<std::string>::iterator       pIt  = vParams.begin();
 354     std::vector<std::string>::const_iterator pEnd = vParams.end  ();
 355
 356     while(pIt != pEnd)
 357     {
 358         if((*pIt)[0] == '-' && (*pIt)[1] == '-')
 359         {
 360             if((*pIt)[2] == 'd' && (*pIt)[3] == 'a' &&
 361                (*pIt)[4] == 't' && (*pIt)[5] == 'a')
 362             {
 363                 uiState = ScanData;
 364             }
 365             else if((*pIt)[2] == 'g' && (*pIt)[3] == 'l' &&
 366                     (*pIt)[4] == 'o' && (*pIt)[5] == 'b' &&
 367                     (*pIt)[6] == 'a' && (*pIt)[7] == 'l')
 368             {
 369                 uiState = ScanGlobals;
 370             }
 371             else if((*pIt)[2] == 's' && (*pIt)[3] == 'y' &&
 372                     (*pIt)[4] == 's' && (*pIt)[5] == 't' &&
 373                     (*pIt)[6] == 'e' && (*pIt)[7] == 'm')
 374             {
 375                 uiState = ScanSystem;
 376             }
 377             else
 378             {
 379                 fprintf(stderr, "Unknow option %s\n", (*pIt).c_str());
 380                 break;
 381             }
 382         }
 383         else
 384         {
 385             if(uiState == ScanSystem)
 386             {
 387                 break;
 388             }
 389             else if(uiState == ScanGlobals)
 390             {
 391                 addStaticGlobals((*pIt).c_str());
 392             }
 393             else if(uiState == ScanData)
 394             {
 395                 FWARNING(("Error data not allowed at this point, "
 396                           "ignoring %s\n", (*pIt).c_str()));
 397             }
 398         }
 399
 400         ++pIt;
 401     }
 402
 403     if(pIt != vParams.begin())
 404     {
 405         vParams.erase(vParams.begin(), pIt);
 406     }
 407 }
 408
 409 void ComplexSceneManager::startFrom(const std::string &szParamFilename)
 410 {
 411     _oPathHandler.clearPathList();
 412     _oPathHandler.clearBaseFile();
 413
 414     _oPathHandler.push_frontCurrentDir();
 415
 416     std::string szParamFileResolved =
 417         _oPathHandler.findFile(szParamFilename.c_str());
 418
 419     if(szParamFileResolved.empty() == true)
 420     {
 421         fprintf(stderr, "Could not find param file %s\n",
 422                 szParamFilename.c_str());
 423
 424         return;
 425     }
 426
 427     _oPathHandler.setBaseFile(szParamFileResolved.c_str());
 428
 429     OSG::SceneFileHandler::the()->setPathHandler(&_oPathHandler);
 430
 431     std::vector<std::string> vParams;
 432
 433     scanParamFile(szParamFileResolved.c_str(), vParams);
 434
 435     Self::startUp(vParams);
 436 }
 437
 438 /***************************************************************************\
 439  *                           Instance methods                              *
 440 \***************************************************************************/
 441
 442 /*-------------------------------------------------------------------------*\
 443  -  private                                                                 -
 444 \*-------------------------------------------------------------------------*/
 445
 446 /*----------------------- constructors & destructors ----------------------*/
 447
 448 ComplexSceneManager::ComplexSceneManager(void) :
 449      Inherited     (    ),
 450     _fMainloop     (    ),
 451     _oKeyHelper    (    ),
 452     _vUnresolvedFCs(    )
 453 #ifdef OSG_WITH_WEBSERVICE
 454    ,_pWebInterface (NULL)
 455 #endif
 456 {
 457 }
 458
 459 ComplexSceneManager::ComplexSceneManager(const ComplexSceneManager &source) :
 460      Inherited     (source),
 461     _fMainloop     (      ),
 462     _oKeyHelper    (      ),
 463     _vUnresolvedFCs(      )
 464 #ifdef OSG_WITH_WEBSERVICE
 465    ,_pWebInterface (NULL  )
 466 #endif
 467 {
 468 }
 469
 470 ComplexSceneManager::~ComplexSceneManager(void)
 471 {
 472 }
 473
 474 FieldContainer *ComplexSceneManager::resolve(
 475     const Char8          *szName,
 476           FieldContainer *pDestContainer,
 477           Int32           iDestFieldId)
 478 {
 479     FieldContainer *returnValue = this->findNamedComponent(szName);
 480
 481     if(returnValue == NULL && pDestContainer != NULL && iDestFieldId >= 0)
 482     {
 483         DeferredFCUse tmpBlock;
 484
 485         tmpBlock._szName       = szName;
 486         tmpBlock._pDstCnt      = pDestContainer;
 487         tmpBlock._uiDstFieldId = UInt32(iDestFieldId);
 488
 489         _vUnresolvedFCs.push_back(tmpBlock);
 490     }
 491
 492     return returnValue;
 493 }
 494
 495 void ComplexSceneManager::addGlobals(const std::string &filename)
 496 {
 497     if(_sfDrawManager.getValue() == NULL)
 498     {
 499         return;
 500     }
 501
 502     std::string szFilenameResolved = _oPathHandler.findFile(filename.c_str());
 503
 504     if(szFilenameResolved.empty() == true)
 505     {
 506         return;
 507     }
 508
 509     FieldContainerUnrecPtr pRes =
 510         readOSGFile(szFilenameResolved,
 511                     boost::bind(&ComplexSceneManager::resolve, this,
 512                                 _1, _2, _3));
 513
 514     fprintf(stderr, "addGlobals::pres %p\n", static_cast<void *>(pRes.get()));
 515
 516     if(pRes == NULL)
 517         return;
 518
 519     ContainerCollectionUnrecPtr pColl =
 520         dynamic_pointer_cast<ContainerCollection>(pRes);
 521
 522     if(pColl != NULL)
 523     {
 524         MFUnrecFieldContainerPtr::const_iterator fIt  =
 525             pColl->getMFContainers()->begin();
 526
 527         MFUnrecFieldContainerPtr::const_iterator fEnd =
 528             pColl->getMFContainers()->end();
 529
 530         while(fIt != fEnd)
 531         {
 532             this->pushToGlobals(*fIt);
 533             ++fIt;
 534         }
 535     }
 536     else
 537     {
 538         this->pushToGlobals(pRes);
 539     }
 540
 541     return;
 542 }
 543
 544 void ComplexSceneManager::addData(const std::string &filename)
 545 {
 546     Node *pModelRoot = findNode("ModelRoot");
 547
 548     if(pModelRoot == NULL)
 549     {
 550         return;
 551     }
 552
 553     std::string szFilenameResolved = _oPathHandler.findFile(filename.c_str());
 554
 555     if(szFilenameResolved.empty() == true)
 556     {
 557         fprintf(stderr, "Could not find data file %s\n",
 558                 filename.c_str());
 559
 560         return;
 561     }
 562
 563     _oPathHandler.pushState();
 564
 565     _oPathHandler.setBaseFile(szFilenameResolved.c_str());
 566
 567     fprintf(stderr, "loading data %s ...\n",
 568             filename.c_str());
 569
 570     NodeUnrecPtr pFile =
 571         OSG::SceneFileHandler::the()->read(
 572             szFilenameResolved.c_str(),
 573             NULL,
 574             boost::bind(&ComplexSceneManager::resolve, this, _1, _2, _3),
 575             true);
 576
 577     _oPathHandler.popState();
 578
 579     if(pFile != NULL)
 580     {
 581 #if defined(OSG_OGL_ES2)
 582         OSG::GraphOpRefPtr op =
 583             OSG::GraphOpFactory::the()->create("PrepareES");
 584
 585         fprintf(stderr, "do es prep %p\n", static_cast<void *>(op.get()));
 586
 587         op->traverse(pFile);
 588 #endif
 589
 590         pModelRoot->addChild(pFile);
 591     }
 592 }
 593
 594 Node *ComplexSceneManager::findNode(const std::string &filename) const
 595 {
 596     MFGlobalsType::const_iterator gIt  = _mfGlobals.begin();
 597     MFGlobalsType::const_iterator gEnd = _mfGlobals.end  ();
 598
 599     Node                *pNode       = NULL;
 600     Node                *returnValue = NULL;
 601
 602     while(gIt != gEnd)
 603     {
 604         pNode = dynamic_cast<Node *>(*gIt);
 605
 606         if(pNode != NULL)
 607         {
 608             NodeFinder oFinder;
 609
 610             oFinder._szRefName = filename;
 611
 612             traverse(pNode, boost::bind(&NodeFinder::enter, &oFinder, _1));
 613
 614             if(oFinder._pResult != NULL)
 615             {
 616                 returnValue = oFinder._pResult;
 617                 break;
 618             }
 619         }
 620
 621         ++gIt;
 622     }
 623
 624     return returnValue;
 625 }
 626
 627 void ComplexSceneManager::processUnresolved(void)
 628 {
 629     std::vector<DeferredFCUse>::const_iterator uIt  = _vUnresolvedFCs.begin();
 630     std::vector<DeferredFCUse>::const_iterator uEnd = _vUnresolvedFCs.end  ();
 631
 632     for(; uIt != uEnd; ++uIt)
 633     {
 634         if(uIt->_pDstCnt == NULL)
 635             continue;
 636
 637         FieldContainer *pTmpFC = this->findNamedComponent(uIt->_szName.c_str());
 638
 639         if(pTmpFC == NULL)
 640         {
 641             continue;
 642         }
 643
 644         EditFieldHandlePtr pDstField =
 645             uIt->_pDstCnt->editField(uIt->_uiDstFieldId);
 646
 647         FieldContainerPtrSFieldBase::EditHandlePtr pSFHandle =
 648             boost::dynamic_pointer_cast<
 649                 FieldContainerPtrSFieldBase::EditHandle>(
 650                     pDstField);
 651
 652         FieldContainerPtrMFieldBase::EditHandlePtr pMFHandle =
 653             boost::dynamic_pointer_cast<
 654                 FieldContainerPtrMFieldBase::EditHandle>(
 655                     pDstField);
 656
 657         EditMapFieldHandlePtr pMapHandle =
 658             boost::dynamic_pointer_cast<
 659                 EditMapFieldHandle>(pDstField);
 660
 661         if(pSFHandle != NULL && pSFHandle->isValid())
 662         {
 663             pSFHandle->set(pTmpFC);
 664         }
 665         else if(pMFHandle != NULL && pMFHandle->isValid())
 666         {
 667             pMFHandle->add(pTmpFC);
 668         }
 669         else if(pMapHandle != NULL && pMapHandle->isValid())
 670         {
 671             pMapHandle->add(pTmpFC, "0");
 672         }
 673
 674     }
 675
 676     _vUnresolvedFCs.clear();
 677 }
 678
 679 FieldContainerTransitPtr ComplexSceneManager::readOSGFile(
 680     const std::string &filename,
 681           Resolver     resolver)
 682 {
 683     FieldContainerTransitPtr returnValue(NULL);
 684
 685     _oPathHandler.pushState();
 686
 687     _oPathHandler.setBaseFile(filename.c_str());
 688
 689     ImageFileHandler::the()->setPathHandler(&_oPathHandler);
 690
 691     fprintf(stderr, "loading osg file %s ...\n",
 692             filename.c_str());
 693
 694     returnValue = OSG::OSGSceneFileType::the().readContainer(
 695         filename.c_str(),
 696         resolver);
 697
 698     ImageFileHandler::the()->setPathHandler(NULL);
 699
 700     _oPathHandler.popState();
 701
 702     return returnValue;
 703 }
 704
 705 FieldContainer *ComplexSceneManager::findNamedComponent(
 706     const Char8 *szName)
 707 {
 708     MFGlobalsType::const_iterator gIt  = _mfGlobals.begin();
 709     MFGlobalsType::const_iterator gEnd = _mfGlobals.end  ();
 710
 711           AttachmentContainer *pAttCnt     = NULL;
 712           Node                *pNode       = NULL;
 713     const Char8               *szTmpName   = NULL;
 714
 715     if(_sfDrawManager.getValue() != NULL)
 716     {
 717         szTmpName = OSG::getName(_sfDrawManager.getValue());
 718
 719         if(szTmpName != NULL && osgStringCmp(szTmpName, szName) == 0)
 720         {
 721             return _sfDrawManager.getValue();
 722         }
 723
 724          FieldContainer *tmpVal =
 725              _sfDrawManager.getValue()->findNamedComponent(szName);
 726
 727          if(tmpVal != NULL)
 728              return tmpVal;
 729     }
 730
 731     while(gIt != gEnd)
 732     {
 733         pNode = dynamic_cast<Node *>(*gIt);
 734
 735         if(pNode != NULL)
 736         {
 737             ElementFinder oFinder;
 738
 739             oFinder._szRefName = szName;
 740
 741             traverse(pNode, boost::bind(&ElementFinder::enter, &oFinder, _1));
 742
 743             if(oFinder._pResult != NULL)
 744             {
 745                 return oFinder._pResult;
 746             }
 747          }
 748
 749         pAttCnt = dynamic_cast<AttachmentContainer *>(*gIt);
 750
 751         if(pAttCnt != NULL)
 752         {
 753             szTmpName = OSG::getName(pAttCnt);
 754
 755             if(szTmpName != NULL && osgStringCmp(szTmpName, szName) == 0)
 756             {
 757                 return pAttCnt;
 758             }
 759             else
 760             {
 761                 FieldContainer *tmpVal = pAttCnt->findNamedComponent(szName);
 762
 763                 if(tmpVal != NULL)
 764                     return tmpVal;
 765             }
 766         }
 767
 768         ++gIt;
 769     }
 770
 771     return NULL;
 772 }
 773
 774 void ComplexSceneManager::addFrameProducer(
 775     FrameProducerInterface *pProducer)
 776 {
 777     if(_sfDrawManager.getValue() != NULL)
 778     {
 779         _sfDrawManager.getValue()->addProducer(pProducer);
 780     }
 781 }
 782
 783 void ComplexSceneManager::removeFrameProducer(
 784     FrameProducerInterface *pProducer)
 785 {
 786     if(_sfDrawManager.getValue() != NULL)
 787     {
 788         _sfDrawManager.getValue()->removeProducer(pProducer);
 789     }
 790 }
 791
 792 /*----------------------------- class specific ----------------------------*/
 793
 794 void ComplexSceneManager::changed(ConstFieldMaskArg whichField,
 795                             UInt32            origin,
 796                             BitVector         details)
 797 {
 798     Inherited::changed(whichField, origin, details);
 799 }
 800
 801 void ComplexSceneManager::dump(      UInt32    ,
 802                          const BitVector ) const
 803 {
 804     SLOG << "Dump ComplexSceneManager NI" << std::endl;
 805 }
 806
 807 void ComplexSceneManager::onCreate(const ComplexSceneManager *source)
 808 {
 809     Inherited::onCreate(source);
 810
 811     // Don't add the prototype instances to the list
 812     if(GlobalSystemState != Running)
 813         return;
 814
 815     if(_the != NULL)
 816     {
 817         fprintf(stderr, "WARNING ADDING SECOND COMPLEX SCENE MANAGER,"
 818                 " WILL SELF DESTRUCT IN 45 SECONDS");
 819     }
 820
 821     _the = this;
 822
 823     std::vector<FieldContainerUnrecPtr>::const_iterator gIt  =
 824         _vStaticGlobals.begin();
 825
 826     std::vector<FieldContainerUnrecPtr>::const_iterator gEnd =
 827         _vStaticGlobals.end  ();
 828
 829     while(gIt != gEnd)
 830     {
 831         this->pushToGlobals(*gIt);
 832         ++gIt;
 833     }
 834
 835 #if 0
 836     SensorTaskUnrecPtr pSensorTask = SensorTask::create();
 837
 838     setSensorTask(pSensorTask);
 839 #endif
 840 }
 841
 842 bool ComplexSceneManager::startFrom(int argc, char **argv)
 843 {
 844     _oPathHandler.clearPathList();
 845     _oPathHandler.clearBaseFile();
 846
 847     _oPathHandler.push_frontCurrentDir();
 848
 849     std::vector<std::string> vParams;
 850     std::string              szTmp;
 851
 852     for(Int32 i = 1; i < argc; ++i)
 853     {
 854         szTmp = argv[i];
 855
 856         vParams.push_back(szTmp);
 857     }
 858
 859     Self::startUp(vParams);
 860
 861     return true;
 862 }
 863
 864 bool ComplexSceneManager::startUp(std::vector<std::string> &vParams)
 865 {
 866     setVBOUsageOnPropertyProtos(true);
 867
 868     scanPreSystem(vParams);
 869
 870     std::string szSystemFile         = vParams[0];
 871
 872     std::string szSystemFileResolved =
 873         _oPathHandler.findFile(szSystemFile.c_str());
 874
 875     if(szSystemFileResolved.empty() == true)
 876     {
 877         fprintf(stderr, "Could not find system file %s\n",
 878                 szSystemFile.c_str());
 879
 880         return false;
 881     }
 882
 883     readOSGFile(szSystemFileResolved,
 884                 boost::bind(&ComplexSceneManager::resolveStatic,
 885                             _1, _2, _3));
 886
 887     _vStaticGlobals.clear();
 888
 889     if(OSG::ComplexSceneManager::the() == NULL)
 890     {
 891         fprintf(stderr, "Error could not find any complex scenemanager\n");
 892         return false;
 893     }
 894
 895     OSG::SceneFileHandler::the()->setGlobalResolver(
 896         boost::bind(&ComplexSceneManager::resolve, _the.get(), _1, _2, _3));
 897
 898     OSG::ComplexSceneManager::the()->init(vParams);
 899
 900     OSG::ComplexSceneManager::the()->run();
 901
 902     return true;
 903 }
 904
 905 bool ComplexSceneManager::init(const std::vector<std::string> &vParams)
 906 {
 907     bool returnValue = true;
 908
 909     bool bDoData = false;
 910
 911     _vUnresolvedFCs.insert(_vUnresolvedFCs.begin(),
 912                            _vStaticUnresolvedFCs.begin(),
 913                            _vStaticUnresolvedFCs.end  ());
 914
 915     _vStaticUnresolvedFCs.clear();
 916
 917     for(UInt32 i = 1; i < vParams.size(); ++i)
 918     {
 919         if(vParams[i][0] == '-' && vParams[i][1] == '-')
 920         {
 921             if(vParams[i][2] == 'd' && vParams[i][3] == 'a' &&
 922                vParams[i][4] == 't' && vParams[i][5] == 'a')
 923             {
 924                 bDoData = true;
 925             }
 926             else if(vParams[i][2] == 'g' && vParams[i][3] == 'l' &&
 927                     vParams[i][4] == 'o' && vParams[i][5] == 'b' &&
 928                     vParams[i][6] == 'a' && vParams[i][7] == 'l')
 929             {
 930                 bDoData = false;
 931             }
 932             else
 933             {
 934                 fprintf(stderr, "Unknow option %s\n", vParams[i].c_str());
 935                 return false;
 936             }
 937
 938         }
 939         else
 940         {
 941             if(bDoData == true)
 942             {
 943                 addData(vParams[i]);
 944             }
 945             else
 946             {
 947                 addGlobals(vParams[i]);
 948             }
 949         }
 950     }
 951
 952     this->processUnresolved();
 953
 954     if(_sfDrawManager.getValue() == NULL)
 955     {
 956         return false;
 957     }
 958
 959     commitChanges();
 960
 961     returnValue = _sfDrawManager.getValue()->init();
 962
 963     if(returnValue == true && FrameHandler::the() != NULL)
 964     {
 965         returnValue &= FrameHandler::the()->init();
 966     }
 967
 968     return returnValue;
 969 }
 970
 971 void ComplexSceneManager::terminate(void)
 972 {
 973     _vStaticGlobals.clear();
 974
 975     _the->shutdown();
 976
 977     _the = NULL;
 978 }
 979
 980 void ComplexSceneManager::shutdown(void)
 981 {
 982 #ifdef OSG_WITH_WEBSERVICE
 983     _pWebInterface = NULL;
 984 #endif
 985
 986     if(FrameHandler::the() != NULL)
 987     {
 988         FrameHandler::the()->shutdown();
 989     }
 990
 991     this->clearGlobals();
 992
 993     if(_sfDrawManager.getValue() != NULL)
 994     {
 995         _sfDrawManager.getValue()->shutdown();
 996     }
 997
 998
 999     this->setDrawManager(NULL);
1000 //    this->setSensorTask (NULL);
1001 }
1002
1003 void ComplexSceneManager::setMainloop(MainLoopFuncF fMainloop)
1004 {
1005     _fMainloop = fMainloop;
1006 }
1007
1008 void ComplexSceneManager::run(void)
1009 {
1010 #ifdef OSG_WITH_WEBSERVICE
1011     if(this->getEnableWebService() == true)
1012     {
1013         _pWebInterface = WebInterface::create(this->getWebServicePort());
1014
1015         FieldContainer *pRoot =
1016             this->resolve(this->getWebServiceRoot().c_str(), NULL, 0);
1017
1018         Node *pRootNode = dynamic_cast<Node *>(pRoot);
1019
1020         if(pRootNode != NULL)
1021         {
1022             fprintf(stderr, "WebService using : %p\n",
1023                     static_cast<void *>(pRootNode)   );
1024
1025             _pWebInterface->setRoot           (pRootNode);
1026             _pWebInterface->setSystemContainer(this     );
1027         }
1028     }
1029 #endif
1030
1031     if(_fMainloop)
1032     {
1033         _fMainloop();
1034     }
1035     else
1036     {
1037         FWARNING(("ComplexSceneManager: no mainloop exiting\n"));
1038     }
1039
1040     osgExit();
1041 }
1042
1043 void ComplexSceneManager::frame(void)
1044 {
1045 #if 0
1046     setCurrTime(getSystemTime());
1047
1048     if(osgAbs(_sfStartTime.getValue()) < 0.00001)
1049     {
1050         setStartTime(_sfCurrTime.getValue());
1051
1052         setLastTime(0.f);
1053     }
1054
1055     _sfCurrTime.getValue() -= _sfStartTime.getValue();
1056
1057     if(_sfPaused.getValue() == false)
1058     {
1059         SFTime *pSFTimeStamp = editSFTimeStamp();
1060
1061         if(_sfConstantTime.getValue() == true)
1062         {
1063             pSFTimeStamp->getValue() += _sfConstantTimeStep.getValue();
1064
1065             if(pSFTimeStamp->getValue() < 0.)
1066                 pSFTimeStamp->setValue(0.0);
1067         }
1068         else
1069         {
1070             pSFTimeStamp->getValue() +=
1071                 (_sfCurrTime.getValue() - _sfLastTime.getValue()) *
1072                 _sfTimeScale.getValue();
1073
1074             if(pSFTimeStamp->getValue() < 0.)
1075                 pSFTimeStamp->setValue(0.0);
1076         }
1077     }
1078
1079     setLastTime(_sfCurrTime.getValue());
1080
1081     SystemTime = _sfTimeStamp.getValue();
1082
1083     ++(editSFFrameCount()->getValue());
1084
1085     if(_sfSensorTask.getValue() != NULL)
1086     {
1087         _sfSensorTask.getValue()->frame(_sfTimeStamp.getValue (),
1088                                         _sfFrameCount.getValue());
1089     }
1090 #endif
1091
1092     if(_sfDumpFrameStart.getValue() == true)
1093     {
1094         fprintf(stderr, "=================================================\n");
1095         fprintf(stderr, "Render Frame\n");
1096         fprintf(stderr, "=================================================\n");
1097     }
1098
1099     FrameHandler::the()->frame();
1100
1101     SystemTime = FrameHandler::the()->getTimeStamp();
1102
1103     commitChanges();
1104
1105 #ifdef OSG_WITH_WEBSERVICE
1106     if(_pWebInterface != NULL)
1107     {
1108         _pWebInterface->waitRequest(0.01);
1109         _pWebInterface->handleRequests();
1110     }
1111 #endif
1112
1113     if(_sfDrawManager.getValue() != NULL)
1114     {
1115         _sfDrawManager.getValue()->frame(FrameHandler::the()->getTimeStamp(),
1116                                          FrameHandler::the()->getFrameCount());
1117     }
1118
1119     if(this->getWaitKeyAfterFrame() == true)
1120     {
1121         getchar();
1122     }
1123 }
1124
1125 void ComplexSceneManager::resetScene(void)
1126 {
1127     MFGlobalsType::const_iterator gIt  = _mfGlobals.begin();
1128     MFGlobalsType::const_iterator gEnd = _mfGlobals.end  ();
1129
1130     CSMResetInterface *pIf = NULL;
1131
1132     for(; gIt != gEnd; ++gIt)
1133     {
1134         pIf = dynamic_cast<CSMResetInterface *>(*gIt);
1135
1136         if(pIf != NULL)
1137         {
1138             fprintf(stderr, "found if %p\n", static_cast<void *>(pIf));
1139
1140             pIf->reset();
1141         }
1142     }
1143 }
1144
1145 void ComplexSceneManager::key(Int32 x,
1146                               Int32 y,
1147                               Int32 iState,
1148                               Char8 cKey  )
1149 {
1150     _oKeyHelper.update(x, y, iState, cKey);
1151 }
1152
1153 void ComplexSceneManager::updateKeySensor(KeySensor *pSensor)
1154 {
1155     _oKeyHelper.updateSensors(pSensor);
1156 }
1157
1158 void ComplexSceneManager::removeKeySensor(KeySensor *pSensor)
1159 {
1160     _oKeyHelper.removeSensor(pSensor);
1161 }
1162
1163 OSG_END_NAMESPACE