Source/System/Dynamics/Base/OSGFrameHandler.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 "OSGFrameHandler.h"
  49
  50 OSG_BEGIN_NAMESPACE
  51
  52 // Documentation for this class is emitted in the
  53 // OSGFrameHandlerBase.cpp file.
  54 // To modify it, please change the .fcd file (OSGFrameHandler.fcd) and
  55 // regenerate the base file.
  56
  57 /***************************************************************************\
  58  *                           Class variables                               *
  59 \***************************************************************************/
  60
  61 bool                 FrameHandler::_bRegistersInstanceRelease = false;
  62 FrameHandlerUnrecPtr FrameHandler::_pGlobalInstance           = NULL;
  63
  64 /***************************************************************************\
  65  *                           Class methods                                 *
  66 \***************************************************************************/
  67
  68 void FrameHandler::initMethod(InitPhase ePhase)
  69 {
  70     Inherited::initMethod(ePhase);
  71
  72     if(ePhase == TypeObject::SystemPost)
  73     {
  74     }
  75 }
  76
  77 FrameHandler *FrameHandler::the(void)
  78 {
  79     if(GlobalSystemState != Running)
  80         return NULL;
  81
  82     if(_pGlobalInstance == NULL)
  83     {
  84         FrameHandlerUnrecPtr pHandler = FrameHandler::create();
  85
  86         setGlobalInstance(pHandler);
  87     }
  88
  89     return _pGlobalInstance;
  90 }
  91
  92 void FrameHandler::setGlobalInstance(FrameHandler *pHandler)
  93 {
  94     if(_bRegistersInstanceRelease == false)
  95     {
  96         _bRegistersInstanceRelease = true;
  97
  98         addPreFactoryExitFunction(&FrameHandler::releaseGlobalInstance);
  99     }
 100
 101     _pGlobalInstance = pHandler;
 102 }
 103
 104 bool FrameHandler::releaseGlobalInstance(void)
 105 {
 106     _pGlobalInstance = NULL;
 107
 108     return true;
 109 }
 110
 111 /***************************************************************************\
 112  *                           Instance methods                              *
 113 \***************************************************************************/
 114
 115 /*-------------------------------------------------------------------------*\
 116  -  private                                                                 -
 117 \*-------------------------------------------------------------------------*/
 118
 119 /*----------------------- constructors & destructors ----------------------*/
 120
 121 FrameHandler::FrameHandler(void) :
 122      Inherited                (),
 123     _mfFrameTasks             (),
 124     _mfUninitializedFrameTasks(),
 125     _mfInitializedFrameTasks  ()
 126 {
 127 }
 128
 129 FrameHandler::FrameHandler(const FrameHandler &source) :
 130      Inherited                (source),
 131     _mfFrameTasks             (      ),
 132     _mfUninitializedFrameTasks(      ),
 133     _mfInitializedFrameTasks  (      )
 134 {
 135 }
 136
 137 FrameHandler::~FrameHandler(void)
 138 {
 139 }
 140
 141 /*----------------------------- class specific ----------------------------*/
 142
 143 void FrameHandler::changed(ConstFieldMaskArg whichField,
 144                            UInt32            origin,
 145                            BitVector         details)
 146 {
 147     Inherited::changed(whichField, origin, details);
 148 }
 149
 150 void FrameHandler::dump(      UInt32    ,
 151                         const BitVector ) const
 152 {
 153     SLOG << "Dump FrameHandler NI" << std::endl;
 154 }
 155
 156 void FrameHandler::addTask(FrameTaskInterface *pTask,
 157                            bool                bNoFrameFunction)
 158 {
 159     if(pTask == NULL)
 160         return;
 161
 162     if(bNoFrameFunction == false)
 163         this->pushToFrameTasks             (pTask);
 164
 165     this->pushToUninitializedFrameTasks(pTask);
 166 }
 167
 168 void FrameHandler::removeTask(FrameTaskInterface *pTask)
 169 {
 170     if(pTask != NULL)
 171     {
 172         bool rc   = this->removeObjFromFrameTasks             (pTask);
 173              rc  |= this->removeObjFromInitializedFrameTasks  (pTask);
 174
 175         bool rcU  = this->removeObjFromUninitializedFrameTasks(pTask);
 176
 177         if(rc == true && rcU == false)
 178         {
 179             pTask->shutdown();
 180         }
 181     }
 182 }
 183
 184 bool FrameHandler::init(void)
 185 {
 186     bool returnValue = true;
 187
 188     InterfaceStoreConstIt tIt  = this->getMFUninitializedFrameTasks()->begin();
 189     InterfaceStoreConstIt tEnd = this->getMFUninitializedFrameTasks()->end  ();
 190
 191     while(tIt != tEnd)
 192     {
 193         returnValue &= (*tIt)->init();
 194
 195         this->pushToInitializedFrameTasks(*tIt);
 196
 197         ++tIt;
 198     }
 199
 200     this->clearUninitializedFrameTasks();
 201
 202     return returnValue;
 203 }
 204
 205 void FrameHandler::frame(Time frameTime)
 206 {
 207     if(_mfUninitializedFrameTasks.size() != 0)
 208     {
 209         this->init();
 210     }
 211
 212     setCurrTime(frameTime);
 213
 214     if(_sfStartTime.getValue() < 0.0)
 215     {
 216         setStartTime(_sfCurrTime.getValue());
 217         setLastTime(0.f);
 218     }
 219
 220     _sfCurrTime.getValue() -= _sfStartTime.getValue();
 221
 222     if(_sfPaused.getValue() == false)
 223     {
 224         SFTime *pSFTimeStamp = editSFTimeStamp();
 225
 226         if(_sfConstantTime.getValue() == true)
 227         {
 228             pSFTimeStamp->getValue() += _sfConstantTimeStep.getValue();
 229
 230             if(pSFTimeStamp->getValue() < 0.)
 231                 pSFTimeStamp->setValue(0.0);
 232         }
 233         else
 234         {
 235             pSFTimeStamp->getValue() +=
 236                 (_sfCurrTime.getValue() - _sfLastTime.getValue()) *
 237                 _sfTimeScale.getValue();
 238
 239             if(pSFTimeStamp->getValue() < 0.)
 240                 pSFTimeStamp->setValue(0.0);
 241         }
 242     }
 243
 244     setLastTime(_sfCurrTime.getValue());
 245
 246     ++(editSFFrameCount()->getValue());
 247
 248     callTasks();
 249 }
 250
 251 void FrameHandler::frame(void)
 252 {
 253     frame(getSystemTime());
 254 }
 255
 256 void FrameHandler::shutdown(void)
 257 {
 258     InterfaceStoreConstIt tIt  = getMFInitializedFrameTasks()->begin();
 259     InterfaceStoreConstIt tEnd = getMFInitializedFrameTasks()->end  ();
 260
 261     while(tIt != tEnd)
 262     {
 263         (*tIt)->shutdown();
 264
 265         ++tIt;
 266     }
 267 }
 268
 269 void FrameHandler::callTasks(void)
 270 {
 271     Int32                 currPrio = TypeTraits<Int32>::getMin();
 272     InterfaceStoreConstIt tIt      = getMFFrameTasks()->begin();
 273     InterfaceStoreConstIt tEnd     = getMFFrameTasks()->end  ();
 274
 275     while(tIt != tEnd)
 276     {
 277         if((*tIt)->getPriority() > currPrio)
 278         {
 279             currPrio = (*tIt)->getPriority();
 280             commitChanges();
 281         }
 282
 283         (*tIt)->frame(_sfTimeStamp.getValue(), _sfFrameCount.getValue());
 284
 285         ++tIt;
 286     }
 287 }
 288
 289 //! Get the FrameHandler::_mfFrameTasks field.
 290 const FrameHandler::InterfaceStore *FrameHandler::getMFFrameTasks(void) const
 291 {
 292     return &_mfFrameTasks;
 293 }
 294
 295 //! Get the FrameHandler::_mfUninitializedFrameTasks field.
 296 const FrameHandler::InterfaceStore *
 297     FrameHandler::getMFUninitializedFrameTasks(void) const
 298 {
 299     return &_mfUninitializedFrameTasks;
 300 }
 301
 302 //! Get the FrameHandler::_mfUninitializedFrameTasks field.
 303 const FrameHandler::InterfaceStore *
 304     FrameHandler::getMFInitializedFrameTasks(void) const
 305 {
 306     return &_mfInitializedFrameTasks;
 307 }
 308
 309 void FrameHandler::pushToFrameTasks(FrameTaskInterface * const value)
 310 {
 311     InterfaceStoreIt tIt = std::lower_bound(_mfFrameTasks.begin(),
 312                                             _mfFrameTasks.end  (), value,
 313                                             FrameTaskLess()              );
 314
 315     _mfFrameTasks.insert(tIt, value);
 316 }
 317
 318 void FrameHandler::pushToUninitializedFrameTasks(
 319     FrameTaskInterface * const value)
 320 {
 321     _mfUninitializedFrameTasks.push_back(value);
 322 }
 323
 324 void FrameHandler::pushToInitializedFrameTasks(
 325     FrameTaskInterface * const value)
 326 {
 327     _mfInitializedFrameTasks.push_back(value);
 328 }
 329
 330
 331 bool FrameHandler::removeObjFromFrameTasks(FrameTaskInterface * const value)
 332 {
 333     bool returnValue = false;
 334
 335     InterfaceStoreIt it = std::find(_mfFrameTasks.begin(),
 336                                     _mfFrameTasks.end  (), value);
 337
 338     if(it != _mfFrameTasks.end())
 339     {
 340         _mfFrameTasks.erase(it);
 341
 342         returnValue = true;
 343     }
 344
 345     return returnValue;
 346 }
 347
 348 bool FrameHandler::removeObjFromUninitializedFrameTasks(
 349     FrameTaskInterface * const value)
 350 {
 351     bool returnValue = false;
 352
 353     InterfaceStoreIt it = std::find(_mfUninitializedFrameTasks.begin(),
 354                                     _mfUninitializedFrameTasks.end  (), value);
 355
 356     if(it != _mfUninitializedFrameTasks.end())
 357     {
 358         _mfUninitializedFrameTasks.erase(it);
 359
 360         returnValue = true;
 361     }
 362
 363     return returnValue;
 364 }
 365
 366 bool FrameHandler::removeObjFromInitializedFrameTasks(
 367     FrameTaskInterface * const value)
 368 {
 369     bool returnValue = false;
 370
 371     InterfaceStoreIt it = std::find(_mfInitializedFrameTasks.begin(),
 372                                     _mfInitializedFrameTasks.end  (), value);
 373
 374     if(it != _mfInitializedFrameTasks.end())
 375     {
 376         _mfInitializedFrameTasks.erase(it);
 377
 378         returnValue = true;
 379     }
 380
 381     return returnValue;
 382 }
 383
 384 void FrameHandler::clearFrameTasks(void)
 385 {
 386     _mfFrameTasks.clear();
 387 }
 388
 389 void FrameHandler::clearUninitializedFrameTasks(void)
 390 {
 391     _mfUninitializedFrameTasks.clear();
 392 }
 393
 394 void FrameHandler::clearInitializedFrameTasks(void)
 395 {
 396     _mfInitializedFrameTasks.clear();
 397 }
 398
 399 void FrameHandler::resolveLinks(void)
 400 {
 401     Inherited::resolveLinks();
 402
 403     static_cast<FrameHandler *>(this)->clearFrameTasks();
 404     static_cast<FrameHandler *>(this)->clearUninitializedFrameTasks();
 405     static_cast<FrameHandler *>(this)->clearInitializedFrameTasks  ();
 406 }
 407
 408 OSG_END_NAMESPACE