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

00165 {
00166     delete _pDrawEnv;
00167 
00168     OSG::subRef(_statistics);
00169 }

00121                                    :
00122      Inherited     (      ),
00123     _camera        (NULL  ),
00124     _background    (NULL  ),
00125     _window        (NULL  ),
00126     _viewport      (NULL  ),
00127     _statistics    (NULL  ),
00128     _frustumCulling(true  ),
00129     _volumeDrawing (false ),
00130     _autoFrustum   (true  ),
00131     _frustum       (      ),
00132     _pMaterial     (NULL  ),
00133     _pMaterialNode (NullFC),
00134     _mCameraToWorld(      ),
00135     _pDrawEnv      (NULL  )
00136 {
00137     _pDrawEnv = new DrawEnv;
00138 }

00141                                                            :
00142      Inherited     (source                 ),
00143     _camera        (source._camera         ),
00144     _background    (source._background     ),
00145     _window        (source._window         ),
00146     _viewport      (source._viewport       ),
00147     _frustumCulling(source._frustumCulling ),
00148     _volumeDrawing (source._volumeDrawing  ),
00149     _autoFrustum   (source._autoFrustum    ),
00150     _frustum       (source._frustum        ),
00151     _pMaterial     (source._pMaterial      ),
00152     _pMaterialNode (source._pMaterialNode  ),
00153     _mCameraToWorld(source._mCameraToWorld ),
00154     _pDrawEnv      (NULL                   )
00155 {
00156     _pDrawEnv = new DrawEnv;
00157 
00158     OSG::setRefd(_statistics, source._statistics);
00159 }

00113 {
00114     return _viewport;
00115 }

00259 {
00260     _viewport = viewport;
00261 }

00089 {
00090     return _camera;
00091 }

00264 {
00265     _camera = cam;
00266 }

00095 {
00096     return _mCameraToWorld;
00097 }

00101 {
00102     return _background;
00103 }

00269 {
00270     _background = background;
00271 }

00107 {
00108     return _window;
00109 }

00274 {
00275     _window = window;
00276 }

00143 {
00144     return _statistics;
00145 }

00279 {
00280 #if 0 // Altered for last frame time
00281     OSG::setRefd(_statistics, statistics);
00282     _ownStat    = false;
00283 #else
00284     OSG::setRefd(_statistics, statistics);
00285 #endif
00286 }

00119 {
00120     return _frustumCulling;
00121 }

00293 {
00294     _frustumCulling = frustumCulling;
00295 }

00125 {
00126     return _volumeDrawing;
00127 }

00309 {
00310     _volumeDrawing = volumeDrawing;
00311 }

00131 {
00132     return _autoFrustum;
00133 }

00301 {
00302     _autoFrustum = autoFrustum;
00303 }

00137 {
00138     return _frustum;
00139 }

00316 {
00317     _frustum = frustum;
00318 }

00161 {
00162     return _pDrawEnv;
00163 }

00322 {
00323     if(getFrustumCulling() == false)
00324         return getNNodes();
00325 
00326     useNodeList();
00327 
00328     Color3r col;
00329     
00330     UInt32 count = 0;
00331 
00332     for(UInt32 i = 0; i < getNNodes(); i++)
00333     {
00334         if(isVisible(getCPtr(getNode(i))))
00335         {
00336             col.setValuesRGB(0.f,1.f,0.f);
00337 
00338             addNode(getNode(i));
00339 
00340             ++count;
00341         }
00342         else
00343         {
00344             col.setValuesRGB(1.f,0.f,0.f);
00345         }
00346 
00347         if(getVolumeDrawing())
00348         {
00349             dropVolume(this, getNode(i), col);
00350         }
00351     }
00352 
00353     return count;
00354 }

00149 {
00150     return _pMaterial;
00151 }

00155 {
00156     return _pMaterialNode;
00157 }

00174 {
00175     _pMaterial     = pMaterial;
00176     _pMaterialNode = node;
00177 }

00181 {
00182     if(getFrustumCulling() == true &&
00183        getAutoFrustum   () == true &&
00184        getCamera        () != NULL &&
00185        getViewport      () != NULL)
00186     {
00187         getCamera()->getFrustum( _frustum, *getViewport() );
00188     }
00189 
00190     if(_camera != NULL && getViewport() != NULL)
00191     {
00192         _camera->getViewing( _mCameraToWorld,
00193                              getViewport()->getPixelWidth(),
00194                              getViewport()->getPixelHeight() );
00195         _mCameraToWorld.invert();
00196     }
00197 
00198 #if 0 // Altered for last frame time
00199     if(_statistics == NULL)
00200     {
00201         _statistics = StatCollector::create();
00202 
00203         OSG::addRef(_statistics);
00204 
00205         _ownStat = true;
00206     }
00207     else
00208     {
00209         _ownStat = false;        
00210     }
00211 #endif
00212 
00213     if(_statistics != NULL)
00214     {
00215         _statistics->getElem(statTravTime)->start();
00216         _statistics->getElem(statCullTestedNodes)->reset();
00217         _statistics->getElem(statCulledNodes)->reset();
00218         
00219         // this really doesn't belong here, but don't know a better place to put it
00220         if(_statistics->getElem(Drawable::statNTriangles,false))
00221         {
00222             _statistics->getElem(Drawable::statNTriangles )->set(0);
00223             _statistics->getElem(Drawable::statNLines     )->set(0);
00224             _statistics->getElem(Drawable::statNPoints    )->set(0);
00225             _statistics->getElem(Drawable::statNVertices  )->set(0);
00226             _statistics->getElem(Drawable::statNPrimitives)->set(0);
00227         }
00228     }
00229 
00230     return Action::Continue;
00231 }

00234 {
00235     if(_statistics != NULL)
00236     {
00237         _statistics->getElem(statTravTime)->stop();
00238     }
00239 
00240 #if 0 // Altered for last frame time
00241     if(_ownStat)
00242     {
00243         OSG::subRef(_statistics);
00244 
00245         _statistics = NULL;
00246     }
00247     else
00248     {
00249         _ownStat = false;        
00250     }
00251 #endif
00252         
00253     return res; 
00254 }

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 }