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

00118 {
00119     OSG::subRef(_pStatistics);
00120 
00121     delete _pStageValidator;
00122 }

00077                                                          :
00078      Inherited      (     ),
00079     _pCamera        (NULL ),
00080     _pBackground    (NULL ),
00081     _pWindow        (NULL ),
00082     _pViewport      (NULL ),
00083     _pStatistics    (NULL ),
00084     _pStageValidator(NULL ),
00085 
00086     _bFrustumCulling(true ),
00087     _bVolumeDrawing (false),
00088     _bAutoFrustum   (true ),
00089     _oFrustum       (     )
00090 {
00091     _pStageValidator = new StageValidator();
00092 }

00095                                              :
00096 
00097      Inherited      (source                 ),
00098     _pCamera        (source._pCamera        ),
00099     _pBackground    (source._pBackground    ),
00100     _pWindow        (source._pWindow        ),
00101     _pViewport      (source._pViewport      ),
00102     _pStageValidator(NULL                   ),
00103     _pStatistics    (NULL                   ),
00104     _bFrustumCulling(source._bFrustumCulling),
00105     _bVolumeDrawing (source._bVolumeDrawing ),
00106     _bAutoFrustum   (source._bAutoFrustum   ),
00107     _oFrustum       (source._oFrustum       )
00108 {
00109     OSG::setRefd(_pStatistics, source._pStatistics);
00110 
00111     _pStageValidator = new StageValidator();
00112 }

00102 {
00103     return _pViewport;
00104 }

00172 {
00173     _pViewport = pViewport;
00174 }

00084 {
00085     return _pCamera;
00086 }

00177 {
00178     _pCamera = pCamera;
00179 }

00090 {
00091     return _pBackground;
00092 }

00182 {
00183     _pBackground = pBackground;
00184 }

00096 {
00097     return _pWindow;
00098 }

00187 {
00188     _pWindow = pWindow;
00189 }

00132 {
00133     return _pStatistics;
00134 }

00192 {
00193     OSG::setRefd(_pStatistics, pStatistics);
00194 }

00108 {
00109     return _bFrustumCulling;
00110 }

00201 {
00202     _bFrustumCulling = val;
00203 }

00114 {
00115     return _bVolumeDrawing;
00116 }

00217 {
00218     _bVolumeDrawing = val;
00219 }

00120 {
00121     return _bAutoFrustum;
00122 }

00209 {
00210     _bAutoFrustum = val;
00211 }

00126 {
00127     return _oFrustum;
00128 }

00224 {
00225     _oFrustum = oFrustum;
00226 }

00125 {
00126     if(_bFrustumCulling   == true &&
00127        _bAutoFrustum      == true &&
00128         getCamera      () != NULL &&
00129         getViewport    () != NULL)
00130     {
00131         getCamera()->getFrustum(_oFrustum, *getViewport());
00132     }
00133 
00134     if(_pStatistics != NULL)
00135     {
00136         _pStatistics->reset();
00137 
00138 
00139         _pStatistics->getElem(statTravTime       )->start();
00140 //    getStatistics()->getElem(statCullTestedNodes)->reset();
00141 //    getStatistics()->getElem(statCulledNodes    )->reset();
00142     //getStatistics()->getElem(RenderTraversalAction::statNTextures)->reset();
00143     //getStatistics()->getElem(RenderTraversalAction::statNTexBytes)->reset();
00144 
00145     // this really doesn't belong here, but don't know a better place to put it
00146         if(_pStatistics->getElem(Drawable::statNTriangles,false) != NULL)
00147         {
00148             _pStatistics->getElem(Drawable::statNTriangles )->set(0);
00149             _pStatistics->getElem(Drawable::statNLines     )->set(0);
00150             _pStatistics->getElem(Drawable::statNPoints    )->set(0);
00151             _pStatistics->getElem(Drawable::statNVertices  )->set(0);
00152             _pStatistics->getElem(Drawable::statNPrimitives)->set(0);
00153         }
00154     }
00155 
00156     _pStageValidator->incEventCounter();
00157 
00158     return Action::Continue;
00159 }

00162 {
00163     if(_pStatistics != NULL)
00164     {
00165         _pStatistics->getElem(statTravTime)->stop();
00166     }
00167 
00168     return res;
00169 }

00138 {
00139     return _pStageValidator;
00140 }

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 =