Source/System/Action/Base/OSGAction.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *                         Copyright 2000 by OpenSG Forum                    *
   6  *                                                                           *
   7  *          contact: {reiners|vossg}@igd.fhg.de, jbehr@zgdv.de               *
   8  *                                                                           *
   9 \*---------------------------------------------------------------------------*/
  10 /*---------------------------------------------------------------------------*\
  11  *                                License                                    *
  12  *                                                                           *
  13  *                                                                           *
  14  *                                                                           *
  15  *                                                                           *
  16  *                                                                           *
  17 \*---------------------------------------------------------------------------*/
  18 /*---------------------------------------------------------------------------*\
  19  *                                Changes                                    *
  20  *                                                                           *
  21  *                                                                           *
  22  *                                                                           *
  23  *                                                                           *
  24  *                                                                           *
  25  *                                                                           *
  26 \*---------------------------------------------------------------------------*/
  27
  28 //---------------------------------------------------------------------------
  29 //  Includes
  30 //---------------------------------------------------------------------------
  31
  32 #include <cstdlib>
  33 #include <cstdio>
  34
  35 #include "OSGConfig.h"
  36
  37 #include "OSGLog.h"
  38 #include "OSGFieldContainer.h"
  39 #include "OSGMultiCore.h"
  40 #include "OSGNodeCore.h"
  41 #include "OSGAction.h"
  42 #include "OSGRootGroup.h"
  43
  44 //#define BOOST_MEM_FN_ENABLE_CDECL
  45 #include <boost/bind.hpp>
  46
  47 OSG_USING_NAMESPACE
  48
  49
  50 /***************************************************************************\
  51  *                            Description                                  *
  52 \***************************************************************************/
  53
  54 /*! \class OSG::Action
  55     \ingroup GrpSystemAction
  56
  57 The action base class.
  58
  59 */
  60
  61 /***************************************************************************\
  62  *                               Types                                     *
  63 \***************************************************************************/
  64
  65 /***************************************************************************\
  66  *                           Class variables                               *
  67 \***************************************************************************/
  68
  69
  70 Action               *Action::_prototype            = NULL;
  71
  72 Action::FunctorStore *Action::_defaultEnterFunctors = NULL;
  73 Action::FunctorStore *Action::_defaultLeaveFunctors = NULL;
  74
  75 /***************************************************************************\
  76  *                           Class methods                                 *
  77 \***************************************************************************/
  78
  79
  80
  81 /*-------------------------------------------------------------------------*\
  82  -  public                                                                 -
  83 \*-------------------------------------------------------------------------*/
  84
  85 void Action::registerEnterDefault(const FieldContainerType &type,
  86                                   const Action::Functor    &func)
  87 {
  88     if(_defaultEnterFunctors == NULL)
  89         _defaultEnterFunctors = new FunctorStore;
  90
  91     while(type.getId() >= _defaultEnterFunctors->size())
  92     {
  93         _defaultEnterFunctors->push_back(&Action::_defaultEnterFunction);
  94     }
  95
  96     (*_defaultEnterFunctors)[type.getId()] = func;
  97 }
  98
  99 void Action::registerLeaveDefault(const FieldContainerType &type,
 100                                   const Action::Functor    &func)
 101 {
 102     if(_defaultLeaveFunctors == NULL)
 103         _defaultLeaveFunctors = new FunctorStore;
 104
 105     while(type.getId() >= _defaultLeaveFunctors->size())
 106     {
 107         _defaultLeaveFunctors->push_back(&Action::_defaultLeaveFunction);
 108     }
 109
 110     (*_defaultLeaveFunctors)[type.getId()] = func;
 111 }
 112
 113 void Action::setPrototype(Action *proto)
 114 {
 115     _prototype = proto;
 116 }
 117
 118 Action *Action::getPrototype(void)
 119 {
 120     return _prototype;
 121 }
 122
 123 /*-------------------------------------------------------------------------*\
 124  -  protected                                                              -
 125 \*-------------------------------------------------------------------------*/
 126
 127
 128 /*-------------------------------------------------------------------------*\
 129  -  private                                                                -
 130 \*-------------------------------------------------------------------------*/
 131
 132
 133
 134 /***************************************************************************\
 135  *                           Instance methods                              *
 136 \***************************************************************************/
 137
 138 /*-------------------------------------------------------------------------*\
 139  -  public                                                                 -
 140 \*-------------------------------------------------------------------------*/
 141
 142 /*------------- constructors & destructors --------------------------------*/
 143
 144 /** \brief Constructor
 145  */
 146
 147 Action::Action(void) :
 148      Inherited    (                           ),
 149     _enterFunctors(                           ),
 150     _leaveFunctors(                           ),
 151     _actNode      (NULL                       ),
 152     _actParent    (NULL                       ),
 153     _actList      (NULL                       ),
 154     _useNewList   (false                      ),
 155     _newList      (                           ),
 156     _travMask     (TypeTraits<UInt32>::BitsSet),
 157     _sTravMask    (                           ),
 158     _nodeEnterCB  (                           ),
 159     _nodeLeaveCB  (                           )
 160 {
 161     if(_defaultEnterFunctors)
 162         _enterFunctors = *_defaultEnterFunctors;
 163
 164     if(_defaultLeaveFunctors)
 165         _leaveFunctors = *_defaultLeaveFunctors;
 166 }
 167
 168 /** \brief Copy-Constructor
 169  */
 170
 171 Action::Action(const Action &source) :
 172      Inherited    (source                      ),
 173     _enterFunctors(source._enterFunctors       ),
 174     _leaveFunctors(source._leaveFunctors       ),
 175     _actNode      (NULL                        ),
 176     _actParent    (NULL                        ),
 177     _actList      (NULL                        ),
 178     _useNewList   (false                       ),
 179     _newList      (                            ),
 180     _travMask     (source._travMask            ),
 181     _sTravMask    (                            ),
 182     _nodeEnterCB  (source._nodeEnterCB         ),
 183     _nodeLeaveCB  (source._nodeLeaveCB         )
 184 {
 185 }
 186
 187
 188 /** \brief create a new action
 189  */
 190
 191 Action::ObjTransitPtr Action::create(void)
 192 {
 193     ObjTransitPtr act(NULL);
 194
 195     if(_prototype)
 196     {
 197         act = new Action(*_prototype);
 198     }
 199     else
 200     {
 201         act = new Action();
 202     }
 203
 204     return act;
 205 }
 206
 207 /** \brief Destructor
 208  */
 209
 210 Action::~Action(void)
 211 {
 212 }
 213
 214 /*------------------------------ access -----------------------------------*/
 215
 216 /*---------------------------- properties ---------------------------------*/
 217
 218 /*-------------------------- your_category---------------------------------*/
 219
 220 void Action::registerEnterFunction(const FieldContainerType &type,
 221                                    const Action::Functor    &func)
 222 {
 223     while(type.getId() >= _enterFunctors.size())
 224     {
 225         _enterFunctors.push_back(&Action::_defaultEnterFunction);
 226     }
 227
 228     _enterFunctors[type.getId()] = func;
 229 }
 230
 231 void Action::registerLeaveFunction(const FieldContainerType &type,
 232                                    const Action::Functor    &func)
 233 {
 234     while(type.getId() >= _leaveFunctors.size())
 235     {
 236         _leaveFunctors.push_back(&Action::_defaultLeaveFunction);
 237     }
 238
 239     _leaveFunctors[type.getId()] = func;
 240 }
 241
 242
 243
 244 // application entry points
 245
 246 Action::ResultE Action::apply(std::vector<Node *>::iterator begin,
 247                               std::vector<Node *>::iterator end)
 248 {
 249     Action::ResultE res = Continue;
 250
 251     // call the start function and its' returns
 252
 253     if((res = callStart()) != Continue)
 254         return res;
 255
 256     // call the given nodes
 257
 258     for(; begin != end; ++begin)
 259     {
 260         if(*begin == NULL)
 261         {
 262             SWARNING << "apply: encountered NullNode!" << std::endl;
 263             return Quit;
 264         }
 265         else
 266         {
 267             res = recurse(*begin);
 268
 269             if(res != Continue)
 270                 break;
 271         }
 272     }
 273
 274     // call the stop function and its' returns
 275     res = callStop(res);
 276
 277     return res;
 278 }
 279
 280 Action::ResultE Action::apply(Node * const node)
 281 {
 282     if(node == NULL)
 283     {
 284         SWARNING << "apply: node is Null!" << std::endl;
 285         return Quit;
 286     }
 287
 288     std::vector<Node *> nodeList;
 289
 290     nodeList.push_back(node);
 291
 292     return apply(nodeList.begin(), nodeList.end());
 293 }
 294
 295
 296
 297
 298 // recursion calling
 299
 300 Action::ResultE Action::recurse(Node * const node)
 301 {
 302     if(node == NULL)
 303         return Continue;
 304
 305     if((node->getTravMask() & getTravMask()) == 0x0000)
 306     {
 307         return Continue;
 308     }
 309
 310 #if OSG_1_COMPAT
 311     if(node->getOcclusionMask() & 1)
 312         return Continue;
 313 #endif
 314
 315     NodeCore *core = node->getCore();
 316
 317     if(core == NULL)
 318     {
 319         SWARNING << "Action::recurse: core is NULL, "
 320                  << "aborting traversal." << std::endl;
 321         return Quit;
 322     }
 323
 324     Action::ResultE result = Continue;
 325
 326     _actList   = NULL;
 327     _actNode   = node;
 328     _actParent = node;
 329
 330     _newList.clear();
 331
 332     _useNewList = false;
 333
 334     if(_nodeEnterCB != NULL)
 335         result = _nodeEnterCB(node, this);
 336
 337     if(result != Continue)
 338     {
 339         if(result == Skip)
 340             return Continue;
 341
 342         return result;
 343     }
 344
 345     result = callEnter(node->getCore());
 346
 347     _actNode   = node;
 348     _actParent = node;
 349
 350     if(result != Continue)
 351     {
 352         if(result == Skip)
 353             return Continue;
 354
 355         return result;
 356     }
 357
 358     if(! _newList.empty())
 359     {
 360         result = callNewList();
 361     }
 362     else if(! _useNewList) // new list is empty, but not used?
 363     {
 364         Node::MFChildrenType::const_iterator cIt =
 365             node->getMFChildren()->begin();
 366         Node::MFChildrenType::const_iterator cEnd =
 367             node->getMFChildren()->end  ();
 368
 369         for(; cIt != cEnd; ++cIt)
 370         {
 371             result = recurse(*cIt);
 372
 373             if(result != Continue)
 374                 break;
 375         }
 376     }
 377
 378     _actNode   = node;
 379     _actParent = node;
 380
 381     if(result == Continue)
 382     {
 383         result = callLeave(node->getCore());
 384     }
 385     else
 386     {
 387         callLeave(node->getCore());
 388     }
 389
 390     _actNode   = node;
 391     _actParent = node;
 392
 393     if(_nodeLeaveCB != NULL)
 394         _nodeLeaveCB(node, this);
 395
 396     if(result == Skip)
 397         return Continue;
 398
 399     return result;
 400 }
 401
 402 Action::ResultE Action::recurseNoCallback(Node * const node)
 403 {
 404     if(node == NULL)
 405         return Continue;
 406
 407     if((node->getTravMask() & getTravMask()) == 0x0000)
 408     {
 409         return Continue;
 410     }
 411
 412     NodeCore *core = node->getCore();
 413
 414     if(core == NULL)
 415     {
 416         SWARNING << "Action::recurseNoCallback: core is NULL, "
 417                  << "aborting traversal." << std::endl;
 418         return Quit;
 419     }
 420
 421     Action::ResultE result = Action::Continue;
 422
 423     _actList   = NULL;
 424     _actNode   = node;
 425     _actParent = node;
 426
 427     if(! _newList.empty())
 428     {
 429         result = callNewList();
 430     }
 431     else if(! _useNewList) // new list is empty, but not used?
 432     {
 433         Node::MFChildrenType::const_iterator cIt =
 434             node->getMFChildren()->begin();
 435
 436         Node::MFChildrenType::const_iterator cEnd =
 437             node->getMFChildren()->end  ();
 438
 439         for( ; cIt != cEnd; ++cIt)
 440         {
 441             result = recurse(*cIt);
 442
 443             if(result != Continue)
 444                 break;
 445         }
 446     }
 447
 448     _actNode   = node;
 449     _actParent = node;
 450
 451     if(result == Skip)
 452         return Continue;
 453
 454     return result;
 455 }
 456
 457 Action::ResultE Action::recurseMultiCoreFrom(Node      * const node,
 458                                              MultiCore * const mcore,
 459                                              NodeCore  * const from )
 460 {
 461     if(node == NULL)
 462         return Continue;
 463
 464     if((node->getTravMask() & getTravMask()) == 0x0000)
 465     {
 466         return Continue;
 467     }
 468
 469     OSG_ASSERT(node->getCore() == mcore);
 470
 471     Action::ResultE result = Continue;
 472
 473     _actList   = NULL;
 474     _actNode   = node;
 475     _actParent = node;
 476
 477     result = mcore->actionEnterFrom(this, from);
 478
 479     _actNode   = node;
 480     _actParent = node;
 481
 482     if(result != Continue)
 483     {
 484         if(result == Skip)
 485             return Continue;
 486
 487         return result;
 488     }
 489
 490     if(! _newList.empty())
 491     {
 492         result = callNewList();
 493     }
 494     else if(! _useNewList) // new list is empty, but not used?
 495     {
 496         Node::MFChildrenType::const_iterator it =
 497             node->getMFChildren()->begin();
 498         Node::MFChildrenType::const_iterator en =
 499             node->getMFChildren()->end  ();
 500
 501         for(; it != en; ++it)
 502         {
 503             result = recurse(*it);
 504
 505             if(result != Continue)
 506                 break;
 507         }
 508     }
 509
 510     _actNode   = node;
 511     _actParent = node;
 512
 513     if(result == Continue)
 514     {
 515         result = mcore->actionLeaveFrom(this, from);
 516     }
 517     else
 518     {
 519         mcore->actionLeaveFrom(this, from);
 520     }
 521
 522     _actNode   = node;
 523     _actParent = node;
 524
 525     if(result == Skip)
 526         return Continue;
 527
 528     return result;
 529 }
 530
 531
 532 // call the _newList objects
 533 Action::ResultE Action::callNewList(void)
 534 {
 535     ResultE result = Continue;
 536
 537     // need to make a copy, because the one in the action is cleared
 538
 539     std::vector<Node *> nodeList;
 540
 541     nodeList.swap(_newList);
 542
 543     std::vector<Node *>::iterator it = nodeList.begin();
 544     std::vector<Node *>::iterator en = nodeList.end();
 545
 546     _actList = &nodeList;
 547
 548     for(; it != en; ++it)
 549     {
 550         result = recurse(*it);
 551
 552         if(result != Continue)
 553             break;
 554     }
 555
 556     _actList = NULL;
 557
 558     return result;
 559 }
 560
 561
 562 // call the start function and its results
 563
 564 Action::ResultE Action::callStart(void)
 565 {
 566     ResultE       res          = Continue;
 567     FunctorStore *defaultEnter = getDefaultEnterFunctors();
 568     FunctorStore *defaultLeave = getDefaultLeaveFunctors();
 569
 570     // new default enter functor registered since this action was created
 571     if(defaultEnter          != NULL &&
 572        _enterFunctors.size() <  defaultEnter->size())
 573     {
 574         _enterFunctors.reserve(defaultEnter->size());
 575
 576         FunctorStoreConstIt fIt  = defaultEnter->begin() + _enterFunctors.size();
 577         FunctorStoreConstIt fEnd = defaultEnter->end  ();
 578
 579         for(; fIt != fEnd; ++fIt)
 580         {
 581             _enterFunctors.push_back(*fIt);
 582         }
 583     }
 584
 585     // new default leave functor registered since this action was created
 586     if(defaultLeave          != NULL &&
 587        _leaveFunctors.size() <  defaultLeave->size())
 588     {
 589         _leaveFunctors.reserve(defaultLeave->size());
 590
 591         FunctorStoreConstIt fIt  = defaultLeave->begin() + _leaveFunctors.size();
 592         FunctorStoreConstIt fEnd = defaultLeave->end  ();
 593
 594         for(; fIt != fEnd; ++fIt)
 595         {
 596             _leaveFunctors.push_back(*fIt);
 597         }
 598     }
 599
 600     // call the start and see if it returns some nodes
 601
 602     _newList.clear();
 603
 604     if((res = start()) != Continue)
 605         return res;
 606
 607     // got some nodes? call them
 608
 609     if(! _newList.empty())
 610         res = callNewList();
 611
 612     // return the result
 613
 614     return res;
 615 }
 616
 617 // call the stop function and its results
 618
 619 Action::ResultE Action::callStop(ResultE res)
 620 {
 621     // call the start and see if it returns some nodes
 622
 623     _newList.clear();
 624
 625     if((res = stop(res)) != Continue)
 626         return res;
 627
 628     if(! _newList.empty())
 629         res = callNewList();
 630
 631     return res;
 632 }
 633
 634 // default start/stop, does nothing
 635
 636 Action::ResultE Action::start(void)
 637 {
 638     while(_sTravMask.empty() == false)
 639         _sTravMask.pop();
 640
 641     return Continue;
 642 }
 643
 644 Action::ResultE Action::stop(ResultE res)
 645 {
 646     return res;
 647 }
 648
 649 /*-------------------------- assignment -----------------------------------*/
 650
 651 /** \brief assignment
 652  */
 653
 654 Action& Action::operator = (const Action &source)
 655 {
 656     if (this == &source)
 657         return *this;
 658
 659     return *this;
 660 }
 661
 662 /*-------------------------- comparison -----------------------------------*/
 663
 664 /** \brief assignment
 665  */
 666
 667 bool Action::operator < (const Action &other)
 668 {
 669     return this < &other;
 670 }
 671
 672 /** \brief equal
 673  */
 674
 675 bool Action::operator == (const Action &OSG_CHECK_ARG(other))
 676 {
 677     return false;
 678 }
 679
 680 /** \brief unequal
 681  */
 682
 683 bool Action::operator != (const Action &other)
 684 {
 685     return ! (*this == other);
 686 }
 687
 688
 689 /*-------------------------------------------------------------------------*\
 690  -  protected                                                              -
 691 \*-------------------------------------------------------------------------*/
 692
 693 Action::FunctorStore *Action::getDefaultEnterFunctors(void)
 694 {
 695     return _defaultEnterFunctors;
 696 }
 697
 698 Action::FunctorStore *Action::getDefaultLeaveFunctors(void)
 699 {
 700     return _defaultLeaveFunctors;
 701 }
 702
 703
 704 /*-------------------------------------------------------------------------*\
 705  -  private                                                                -
 706 \*-------------------------------------------------------------------------*/
 707
 708 // default Action function: just call all kids
 709
 710 Action::ResultE Action::_defaultEnterFunction(NodeCore * const,
 711                                               Action   *      )
 712 {
 713     return Continue;
 714 }
 715
 716 Action::ResultE Action::_defaultLeaveFunction(NodeCore * const,
 717                                               Action   *      )
 718 {
 719     return Continue;
 720 }
 721
 722 /*************** Functions ******************/
 723
 724 OSG_BEGIN_NAMESPACE
 725
 726 /*! Simple tree traversal function. Calls func for every node encountered
 727  */
 728
 729 Action::ResultE traverse(const std::vector<Node *>  &nodeList,
 730                                TraverseEnterFunctor  func    )
 731 {
 732     Action::ResultE res = Action::Continue;
 733
 734     std::vector<Node *>::const_iterator it = nodeList.begin();
 735     std::vector<Node *>::const_iterator en = nodeList.end  ();
 736
 737     for(; it != en; ++it)
 738     {
 739         res = traverse((*it), func);
 740
 741         if(res == ActionBase::Quit)
 742             break;
 743     }
 744
 745     return res;
 746 }
 747
 748 Action::ResultE traverse(const MFUnrecChildNodePtr  &nodeList,
 749                                TraverseEnterFunctor  func    )
 750 {
 751     Action::ResultE res = Action::Continue;
 752
 753     MFUnrecChildNodePtr::const_iterator it = nodeList.begin();
 754     MFUnrecChildNodePtr::const_iterator en = nodeList.end  ();
 755
 756     for(; it != en; ++it)
 757     {
 758         res = traverse((*it), func);
 759
 760         if(res == ActionBase::Quit)
 761             break;
 762     }
 763
 764     return res;
 765 }
 766
 767 /*! Simple tree traversal function. Calls func for every node encountered
 768  */
 769
 770 Action::ResultE traverse(Node                 * const node,
 771                          TraverseEnterFunctor         func )
 772 {
 773     Action::ResultE res = Action::Continue;
 774
 775     res = func(node);
 776
 777     if(node == NULL)
 778         return Action::Continue;
 779
 780     RootGroup *pRGroup = dynamic_cast<RootGroup *>(node->getCore());
 781
 782     switch(res)
 783     {
 784         case Action::Skip:
 785             return Action::Continue;
 786
 787         case Action::Continue:
 788         {
 789             if(pRGroup != NULL && pRGroup->getRoot() != NULL)
 790             {
 791                 return traverse(pRGroup->getRoot(), func);
 792             }
 793             else
 794             {
 795                 return traverse(*(node->getMFChildren()),
 796                                 func                    );
 797             }
 798         }
 799         break;
 800
 801         default:
 802             break;
 803     }
 804
 805     return res;
 806 }
 807
 808 /*! Simple tree traversal function. Calls enter before entering a node,
 809     leave after leaving.
 810  */
 811
 812 Action::ResultE traverse(const std::vector<Node *> &nodeList,
 813                                TraverseEnterFunctor  enter,
 814                                TraverseLeaveFunctor  leave )
 815 {
 816     Action::ResultE res = Action::Continue;
 817
 818     std::vector<Node *>::const_iterator it = nodeList.begin();
 819     std::vector<Node *>::const_iterator en = nodeList.end  ();
 820
 821     for(; it != en; ++it)
 822     {
 823         res = traverse((*it), enter, leave);
 824
 825         if(res == Action::Quit)
 826             break;
 827     }
 828
 829     return res;
 830 }
 831
 832 Action::ResultE traverse(const MFUnrecChildNodePtr  &nodeList,
 833                                TraverseEnterFunctor  enter,
 834                                TraverseLeaveFunctor  leave )
 835 {
 836     Action::ResultE res = Action::Continue;
 837
 838     MFUnrecChildNodePtr::const_iterator it = nodeList.begin();
 839     MFUnrecChildNodePtr::const_iterator en = nodeList.end  ();
 840
 841     for(; it != en; ++it)
 842     {
 843         res = traverse((*it), enter, leave);
 844
 845         if(res == Action::Quit)
 846             break;
 847     }
 848
 849     return res;
 850 }
 851
 852
 853 /*! Simple tree traversal function. Calls enter before entering a node,
 854     leave after leaving.
 855  */
 856
 857 Action::ResultE traverse(Node                 * const node,
 858                          TraverseEnterFunctor         enter,
 859                          TraverseLeaveFunctor         leave)
 860 {
 861     Action::ResultE res = Action::Continue;
 862
 863     res = enter(node);
 864
 865     RootGroup *pRGroup = dynamic_cast<RootGroup *>(node->getCore());
 866
 867     switch(res)
 868     {
 869         case Action::Skip:
 870             res = Action::Continue;
 871             break;
 872
 873         case Action::Continue:
 874         {
 875             if(pRGroup != NULL && pRGroup->getRoot() != NULL)
 876             {
 877                 res = traverse(pRGroup->getRoot(), enter, leave);
 878             }
 879             else
 880             {
 881                 res = traverse(*(node->getMFChildren()),
 882                                enter,
 883                                leave                   );
 884             }
 885         }
 886         break;
 887         default:
 888             break;
 889     }
 890
 891     res = leave(node, res);
 892
 893     return res;
 894 }
 895
 896 OSG_END_NAMESPACE