OSG::Action Class Reference

00072     {
00073         Continue,   // continue with my children
00074         Skip,       // skip my children
00075                     // really needed? Cancel, 
00076                     // skip my brothers, go one step up
00077         Quit        // forget it, you're done
00078     };

00203 {
00204 }

00159                    : 
00160     _travMask(TypeTraits<UInt32>::getMax())
00161 {
00162     if(_defaultEnterFunctors)
00163         _enterFunctors = *_defaultEnterFunctors;
00164 
00165     if(_defaultLeaveFunctors)
00166         _leaveFunctors = *_defaultLeaveFunctors;
00167 }

00172                                     :
00173     _enterFunctors(source._enterFunctors),
00174     _leaveFunctors(source._leaveFunctors),
00175     _travMask     (source._travMask     )
00176 {
00177 }

00184 {
00185     Action *act;
00186     
00187     if(_prototype)
00188     {
00189         act = new Action(*_prototype);
00190     }
00191     else
00192     {
00193         act = new Action();
00194     }
00195 
00196     return act;
00197 }

00126 {
00127     _prototype = proto;
00128 }

00131 {
00132     return _prototype;
00133 }

00085 {
00086     if(_defaultEnterFunctors == NULL)
00087         _defaultEnterFunctors = new std::vector<Action::Functor>;
00088 
00089 #ifndef OSG_WINCE
00090     while(type.getId() >= _defaultEnterFunctors->size())
00091     {
00092         _defaultEnterFunctors->push_back(&Action::_defaultEnterFunction);
00093     }
00094 #else
00095     while(type.getId() >= _defaultEnterFunctors->size())
00096     {
00097         _defaultEnterFunctors->push_back(&NodeCore::defaultEnter);
00098     }
00099 #endif
00100     
00101     (*_defaultEnterFunctors)[type.getId()] = func;
00102 }

00106 {
00107     if(_defaultLeaveFunctors == NULL)
00108         _defaultLeaveFunctors = new std::vector<Action::Functor>;
00109 
00110 #ifndef OSG_WINCE
00111     while(type.getId() >= _defaultLeaveFunctors->size())
00112     {
00113         _defaultLeaveFunctors->push_back(&Action::_defaultLeaveFunction);
00114     }
00115 #else
00116     while(type.getId() >= _defaultLeaveFunctors->size())
00117     {
00118         _defaultLeaveFunctors->push_back(&NodeCore::defaultLeave);
00119     }
00120 #endif
00121     
00122     (*_defaultLeaveFunctors)[type.getId()] = func;
00123 }

00214 {
00215 #ifndef OSG_WINCE
00216     while(type.getId() >= _enterFunctors.size())
00217     {
00218         _enterFunctors.push_back(&Action::_defaultEnterFunction);
00219     }
00220 #else
00221     while(type.getId() >= _enterFunctors.size())
00222     {
00223         _enterFunctors.push_back(&NodeCore::defaultEnter);
00224     }
00225 #endif
00226     
00227     _enterFunctors[type.getId()] = func;
00228 }

00232 {
00233 #ifndef OSG_WINCE
00234     while(type.getId() >= _leaveFunctors.size())
00235     {
00236         _leaveFunctors.push_back(&Action::_defaultLeaveFunction);
00237     }
00238 #else
00239     while(type.getId() >= _leaveFunctors.size())
00240     {
00241         _leaveFunctors.push_back(&NodeCore::defaultLeave);
00242     }
00243 #endif
00244     
00245     _leaveFunctors[type.getId()] = func;
00246 }

00254 {
00255     Action::ResultE res = Continue;
00256     
00257     // call the start function and its' returns
00258 
00259     if((res = callStart()) != Continue)
00260         return res;     
00261     
00262     // call the given nodes
00263     
00264     for(; begin != end; ++begin)
00265     {
00266         if(*begin == NullFC)
00267         {
00268             SWARNING << "apply: encountered NullNode!" << std::endl;
00269             return Quit;            
00270         }
00271         else
00272         {
00273             res = recurse(*begin);
00274             
00275             if(res != Continue)
00276                 break;
00277         }
00278     }
00279         
00280     // call the stop function and its' returns
00281     res = callStop(res);  
00282     
00283     return res;
00284 }

00287 {
00288     if(node == NullFC)
00289     {
00290         SWARNING << "apply: node is Null!" << std::endl;
00291         return Quit;            
00292     }
00293 
00294     std::vector<NodePtr> nodeList;
00295 
00296     nodeList.push_back(node);
00297 
00298     return apply(nodeList.begin(), nodeList.end());
00299 }

00047 {
00048     return _actNode;
00049 }

00054 {
00055     _actNode = node;
00056 }

00085 {
00086     if(_actList == NULL)
00087     {
00088         return _actNode->getNChildren();
00089     }
00090     else
00091     {
00092         return (*_actList).size();
00093     }
00094 }

00060 {
00061     if(_actList == NULL)
00062     {
00063         return _actNode->getChild(index);
00064     }
00065     else
00066     {
00067         return (*_actList)[index];
00068     }
00069 }

00073 {
00074     _newList.push_back(node);
00075 }

00079 {
00080     _useNewList = true;
00081 }

00099 {
00100     return _travMask;
00101 }

00105 {
00106     _travMask = val;
00107 }

00481 {
00482     return this < &other;
00483 }

00497 {
00498     return ! (*this == other);
00499 }

00117 {
00118     ResultE result;
00119 
00120     UInt32 uiFunctorIndex = core->getType().getId();
00121 
00122     if(uiFunctorIndex < _enterFunctors.size())
00123     {
00124         result = _enterFunctors[uiFunctorIndex](core, this);
00125     }
00126     else if(getDefaultEnterFunctors() &&
00127             uiFunctorIndex < getDefaultEnterFunctors()->size())
00128     {
00129         // field container registered method after this action was instantiated
00130         // copy the new functors from default vector
00131 
00132         std::vector<Functor> *defaultEnter = getDefaultEnterFunctors();
00133 
00134         while(defaultEnter->size() > _enterFunctors.size())
00135         {
00136             _enterFunctors.push_back((*defaultEnter)[_enterFunctors.size()]);
00137         }
00138 
00139         result = _enterFunctors[uiFunctorIndex](core, this);
00140     }
00141     else // unknown field container
00142     {
00143         result = _defaultEnterFunction(core, this);
00144     }
00145 
00146     return result;
00147 }

00151 {
00152     ResultE result;
00153 
00154     UInt32 uiFunctorIndex = core->getType().getId();
00155 
00156     if(uiFunctorIndex < _leaveFunctors.size())
00157     {
00158         result = _leaveFunctors[uiFunctorIndex](core, this);
00159     }
00160     else if(getDefaultLeaveFunctors() &&
00161             uiFunctorIndex < getDefaultLeaveFunctors()->size())
00162     {
00163         // field container registered method after this action was instantiated
00164         // copy the new functors from default vector
00165 
00166         std::vector<Functor> *defaultLeave = getDefaultLeaveFunctors();
00167 
00168         while(defaultLeave->size() > _leaveFunctors.size())
00169         {
00170             _leaveFunctors.push_back((*defaultLeave)[_leaveFunctors.size()]);
00171         }
00172 
00173         result = _leaveFunctors[uiFunctorIndex](core, this);
00174     }
00175     else // unknown field container
00176     {
00177         result = _defaultLeaveFunction(core, this);
00178     }
00179 
00180     return result;
00181 }

00453 {
00454     return Continue;
00455 }

00458 {
00459     return res;
00460 }

00307 {
00308     if(node == NullFC)
00309         return Continue;
00310 
00311     if((node->getTravMask() & getTravMask()) == 0)
00312         return Continue;
00313 
00314 #if OSG_1_COMPAT
00315     if(node->getOcclusionMask() & 1)
00316         return Continue;
00317 #endif
00318 
00319     NodeCorePtr core = node->getCore();
00320     
00321     if(core == NullFC)
00322     {
00323         SWARNING << "recurse: core is Null,  don't know what to do!" 
00324                  << std::endl;
00325         return Quit;                    
00326     }
00327     
00328     Action::ResultE result;
00329     
00330     _actList = NULL;
00331     _actNode = node;
00332 
00333     _newList.clear();
00334 
00335     _useNewList = false;
00336     
00337     result = callEnter(node->getCore());
00338 
00339     if(result != Continue)
00340     {
00341         if(result == Skip)
00342             return Continue;
00343     
00344         return result;
00345     }
00346     
00347     if(! _newList.empty())
00348     {
00349         result = callNewList();
00350     }
00351     else if(! _useNewList) // new list is empty, but not used?
00352     {
00353         std::vector<NodePtr>::const_iterator it;
00354 
00355         for(  it  = node->getMFChildren()->begin(); 
00356               it != node->getMFChildren()->end(); 
00357             ++it)
00358         {
00359             result = recurse(*it);
00360             
00361             if(result != Continue)
00362                 break;
00363         }
00364     }   
00365     
00366     _actNode = node;
00367 
00368     if(result == Continue)
00369     {
00370         result = callLeave(node->getCore());
00371     }
00372     else
00373     {
00374         callLeave(node->getCore());
00375     }
00376 
00377     if(result == Skip)
00378         return Continue;
00379         
00380     return result;
00381 }

00385 {
00386     ResultE result = Continue;
00387 
00388     // need to make a copy, because the one in the action is cleared
00389 
00390     std::vector<NodePtr> nodeList;
00391 
00392     nodeList.swap(_newList);
00393 
00394     std::vector<NodePtr>::iterator it;
00395 
00396     _actList = &nodeList;
00397 
00398     for(it = nodeList.begin(); it != nodeList.end(); ++it)
00399     {
00400         result = recurse(*it);
00401 
00402         if(result != Continue)
00403             break;
00404     }
00405     
00406     return result;
00407 }

00507 {
00508     return _defaultEnterFunctors;
00509 }

00512 {
00513     return _defaultLeaveFunctors;
00514 }

00525 {
00526     return Continue;
00527 }

00531 {
00532     return Continue;
00533 }

00413 {
00414     ResultE res = Continue;
00415     
00416     // call the start and see if it returns some nodes
00417     
00418     _newList.clear();
00419 
00420     if((res = start()) != Continue)
00421         return res;     
00422     
00423     // got some nodes? call them
00424     
00425     if(! _newList.empty())
00426         res = callNewList();
00427     
00428     // return the result
00429 
00430     return res;
00431 }

00436 {
00437     // call the start and see if it returns some nodes
00438     
00439     _newList.clear();
00440 
00441     if((res = stop(res)) != Continue)
00442         return res;     
00443             
00444     if(! _newList.empty())
00445         res = callNewList();
00446 
00447     return res;
00448 }

00468 {
00469     if (this == &source)
00470         return *this;
00471 
00472     return *this;
00473 }