OSG::IntersectAction 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     };

00255 {
00256 }

00184                                      :
00185      Inherited  (     ),
00186     _line       (     ), 
00187     _maxdist    (     ), 
00188     _hit        (false), 
00189     _enterT     (   -1), 
00190     _leaveT     (   -1), 
00191     _hitT       (   -1), 
00192     _hitObject  (     ),
00193     _hitTriangle(   -1)
00194 {
00195     if(_defaultEnterFunctors)
00196         _enterFunctors = *_defaultEnterFunctors;
00197 
00198     if(_defaultLeaveFunctors)
00199         _leaveFunctors = *_defaultLeaveFunctors;
00200 }

00203                                                               :
00204      Inherited  (source             ),
00205     _line       (source._line       ), 
00206     _maxdist    (source._maxdist    ), 
00207     _hit        (source._hit        ), 
00208     _enterT     (source._enterT     ), 
00209     _leaveT     (source._leaveT     ), 
00210     _hitT       (source._hitT       ), 
00211     _hitObject  (source._hitObject  ),
00212     _hitTriangle(source._hitTriangle)
00213 {
00214 }

00221 {
00222     IntersectAction * act;
00223     
00224     if(_prototype)
00225         act = new IntersectAction(*_prototype);
00226     else
00227         act = new IntersectAction();
00228     
00229     return act;
00230 }

00238 {
00239     IntersectAction *act;
00240     
00241     if(_prototype)
00242         act = new IntersectAction(*_prototype);
00243     else
00244         act = new IntersectAction();
00245     
00246     act->setLine(line, maxdist);
00247 
00248     return act;
00249 }

00151 {
00152     _prototype = proto;
00153 }

00156 {
00157     return _prototype;
00158 }

00263 {
00264     _line    = line;
00265     _maxdist = maxdist;
00266 }

00097 {
00098     return _line;
00099 }

00103 {
00104     return _maxdist;
00105 }

00109 {
00110     return _hit;
00111 }

00115 {
00116     if(! didHit())
00117         return -1;
00118 
00119     return _hitT;
00120 }

00124 {
00125     if(! didHit())
00126         return Pnt3f::Null;
00127     
00128     Pnt3f res;
00129 
00130     res = _line.getPosition() + getHitT() * _line.getDirection();
00131 
00132     return res;
00133 }

00137 {
00138     if(! didHit())
00139         return Vec3f::Null;
00140     
00141     return _hitNormal;
00142 }

00146 {
00147     if(! didHit())
00148         return NullFC;
00149 
00150     return _hitObject;
00151 }

00155 {
00156     if(! didHit())
00157         return -1;
00158 
00159     return _hitTriangle;
00160 }

00269 {
00270     if(leave < 0 || enter > _maxdist ||
00271        ( _hit && enter > _hitT ))
00272     {
00273         return Action::Skip;
00274     }
00275 
00276     return Action::Continue;
00277 }

00283 {
00284     if(t < 0 || t > _hitT || t > _maxdist)
00285         return;
00286         
00287     _hitT        = t;
00288     _hitObject   = obj;
00289     _hitTriangle = triIndex;
00290     _hitNormal   = normal;
00291     _hit         = true;
00292 }

00295 {
00296     _hitT    *= s;
00297     _maxdist *= s;
00298 }

00322 {
00323     return this < &other;
00324 }

00339 {
00340     return ! (*this == other);
00341 }

00114 {
00115     if(! _defaultEnterFunctors)
00116     {
00117         _defaultEnterFunctors = new std::vector<Action::Functor>;
00118 
00119         addPostFactoryExitFunction(&IntersectAction::terminateEnter);
00120     }
00121 
00122     while(type.getId() >= _defaultEnterFunctors->size())
00123     {
00124         _defaultEnterFunctors->push_back(
00125             &IntersectAction::_defaultEnterFunction);
00126     }
00127     
00128     (*_defaultEnterFunctors)[type.getId()] = func;
00129 }

00133 {
00134     if(! _defaultLeaveFunctors)
00135     {
00136         _defaultLeaveFunctors = new std::vector<Action::Functor>;
00137 
00138         addPostFactoryExitFunction(&IntersectAction::terminateLeave);
00139     }
00140 
00141     while(type.getId() >= _defaultLeaveFunctors->size())
00142     {
00143         _defaultLeaveFunctors->push_back(
00144             &IntersectAction::_defaultLeaveFunction);
00145     }
00146     
00147     (*_defaultLeaveFunctors)[type.getId()] = func;
00148 }

00087 {
00088     FDEBUG_GV(("Terminate IntersectAction Enter\n"));
00089 
00090     delete _defaultEnterFunctors;
00091 
00092     _defaultEnterFunctors = NULL;
00093 
00094     return true;
00095 }

00098 {
00099     FDEBUG_GV(("Terminate IntersectAction Leave\n"));
00100 
00101     delete _defaultLeaveFunctors;
00102 
00103     _defaultLeaveFunctors = NULL;
00104 
00105     return true;
00106 }

00304 {
00305     _hitT        = Inf;
00306     _hitObject   = NullFC;
00307     _hitTriangle = -1;
00308     _hit         = false;
00309 
00310     return Continue;
00311 }

00351 {
00352     return _defaultEnterFunctors;
00353 }

00357 {
00358     return _defaultLeaveFunctors;
00359 }

00126 {
00127     _prototype = proto;
00128 }

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 }