Changeset 1717

Show
Ignore:
Timestamp:
03/19/03 13:06:29 (15 years ago)
Author:
robert
Message:

Added a realize callback to the OsgCameraGroup?.

Move osgtexture3D across to using the new realize callback for creating its textures.

Location:
OpenSceneGraph/trunk
Files:
3 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/examples/osgtexture3D/osgtexture3D.cpp

    r1697 r1717  
    2525 
    2626 
    27 class ConstructStateCallback : public osg::NodeCallback 
     27class ConstructStateCallback : public osgProducer::OsgCameraGroup::RealizeCallback 
    2828{ 
    2929    public: 
    30         ConstructStateCallback() {} 
     30        ConstructStateCallback(osg::Node* node):_node(node),_initialized(false) {} 
    3131         
    3232        osg::StateSet* constructState() 
     
    8383            texture3D->setFilter(osg::Texture3D::MIN_FILTER,osg::Texture3D::LINEAR); 
    8484            texture3D->setFilter(osg::Texture3D::MAG_FILTER,osg::Texture3D::LINEAR); 
     85            texture3D->setWrap(osg::Texture3D::WRAP_R,osg::Texture3D::REPEAT); 
    8586            texture3D->setImage(image_3d); 
    8687 
     
    104105        } 
    105106 
     107        virtual void operator()(const Producer::RenderSurface&, osgProducer::OsgCameraGroup* , osgProducer::OsgSceneHandler* sh) 
     108        {  
     109            if (!_initialized) 
     110            { 
     111                // only initialize state once, only need for cases where multiple graphics contexts are 
     112                // if which case this callback can get called multiple times. 
     113                _initialized = true; 
     114 
     115                if (_node) _node->setStateSet(constructState()); 
     116            }             
     117            // now safe to con 
     118            sh->init(); 
     119             
     120        } 
     121         
     122         
     123        osg::Node*  _node; 
     124        bool        _initialized; 
     125         
     126}; 
     127 
     128class UpdateStateCallback : public osg::NodeCallback 
     129{ 
     130    public: 
     131        UpdateStateCallback() {} 
     132         
    106133        void animateState(osg::StateSet* stateset) 
    107134        { 
     
    114141                texgen->getPlane(osg::TexGen::R)[3] += 0.001f; 
    115142            } 
    116              
     143 
    117144        } 
    118145 
     
    125152                // we have an exisitng stateset, so lets animate it. 
    126153                animateState(stateset); 
    127             } 
    128             else 
    129             { 
    130                 // no state exist yet, so we must be in the first 
    131                 // pass, so lets create our stateset with all the  
    132                 // textures in it. 
    133                 stateset = constructState(); 
    134                 if (stateset) node->setStateSet(stateset); 
    135154            } 
    136155 
     
    190209    // osg::Image::copySubImage() without using GLU which will get round 
    191210    // this current limitation. 
    192     geode->setUpdateCallback(new ConstructStateCallback()); 
     211    geode->setUpdateCallback(new UpdateStateCallback()); 
    193212     
    194213    return geode; 
     
    242261        // set the scene to render 
    243262        viewer.setSceneData(rootNode); 
     263         
     264        // the construct state uses gl commands to resize images so we are forced 
     265        // to only call it once a valid graphics context has been established, 
     266        // for that we use a realize callback. 
     267        viewer.setRealizeCallback(new ConstructStateCallback(rootNode)); 
    244268 
    245269        // create the windows and run the threads. 
  • OpenSceneGraph/trunk/include/osgProducer/OsgCameraGroup

    r1714 r1717  
    106106 
    107107 
     108        /** RealizeCallback class one should override to provide an the implemention of realize callbacks. 
     109          * Note, this callback overrides the normal call to OsgSceneHandler::init() so it become the your 
     110          * responisibility to call this within your callback if required, it is a safe assumption to 
     111          * always call OsgSceneHandler::init() within your callback..*/ 
     112        class OSGPRODUCER_EXPORT RealizeCallback : public osg::Referenced 
     113        { 
     114        public: 
     115            virtual void operator()( const Producer::RenderSurface & rs, OsgCameraGroup* cg, OsgSceneHandler* sh) = 0; 
     116             
     117        protected: 
     118            virtual ~RealizeCallback() {} 
     119        }; 
     120 
     121        /** Set the realize callback to use when once the render surfaces are realized.*/ 
     122        void setRealizeCallback( RealizeCallback* cb) { _realizeCallback = cb; } 
     123 
     124        /** Get the realize callback.*/ 
     125        RealizeCallback* getRealizeCallback() { return _realizeCallback.get(); } 
     126         
     127        /** Get the const realize callback.*/ 
     128        const RealizeCallback* getRealizeCallback() const { return _realizeCallback.get(); } 
     129         
     130 
     131 
     132 
     133 
    108134        void advance(); 
    109135 
    110136 
     137        /** Realize the render surfaces (OpenGL graphics) and various threads, and call any realize callbacks.*/ 
    111138        virtual void realize( ThreadingModel thread_model= SingleThreaded ); 
    112139 
    113140 
     141        /** Dispatch the cull and draw for each of the Camera's for this frame.*/ 
    114142        virtual void frame(); 
    115143 
     
    131159         
    132160        SceneHandlerList                        _shvec; 
     161         
     162        osg::ref_ptr<RealizeCallback>           _realizeCallback; 
     163         
    133164        osg::ref_ptr<osg::DisplaySettings>      _ds; 
    134165        bool                                    _initialized; 
  • OpenSceneGraph/trunk/src/osgProducer/OsgCameraGroup.cpp

    r1715 r1717  
    2020using namespace osgProducer; 
    2121 
     22 
     23 
     24 
     25class RenderSurfaceRealizeCallback : public Producer::RenderSurface::Callback 
     26{ 
     27public: 
     28 
     29    RenderSurfaceRealizeCallback(OsgCameraGroup* cameraGroup,OsgSceneHandler* sceneHandler): 
     30        _cameraGroup(cameraGroup), 
     31        _sceneHandler(sceneHandler) {} 
     32     
     33    virtual void operator()( const RenderSurface & rs) 
     34    { 
     35        if (_cameraGroup) 
     36        { 
     37            if (_cameraGroup->getRealizeCallback()) 
     38            { 
     39                (*(_cameraGroup->getRealizeCallback()))(rs,_cameraGroup,_sceneHandler); 
     40            } 
     41            else if (_sceneHandler) _sceneHandler->init(); 
     42        } 
     43        else if (_sceneHandler) _sceneHandler->init(); 
     44    } 
     45 
     46    OsgCameraGroup* _cameraGroup; 
     47    OsgSceneHandler* _sceneHandler; 
     48 
     49}; 
     50 
     51 
     52 
    2253std::string findCameraConfigFile(const std::string& configFile) 
    2354{ 
     
    192223 
    193224    _ds->setMaxNumberOfGraphicsContexts( _cfg->getNumberOfCameras() ); 
     225     
     226    _shvec.clear(); 
    194227 
    195228    for( unsigned int i = 0; i < _cfg->getNumberOfCameras(); i++ ) 
     
    198231        osgProducer::OsgSceneHandler *sh = new osgProducer::OsgSceneHandler(_ds.get()); 
    199232        sh->setDefaults(); 
    200         if( _global_stateset != NULL ) 
    201             sh->setGlobalStateSet( _global_stateset.get() ); 
    202         if( _scene_data != NULL ) 
    203             sh->setSceneData( _scene_data.get() ); 
    204         sh->setBackgroundColor( _background_color); 
    205         sh->getState()->setContextID(i); 
    206         sh->setFrameStamp( _frameStamp.get() ); 
    207233        _shvec.push_back( sh ); 
    208  
    209234        cam->setSceneHandler( sh ); 
     235        RenderSurface* rs = cam->getRenderSurface(); 
     236        rs->setRealizeCallback( new RenderSurfaceRealizeCallback(this, sh)); 
    210237    } 
    211238 
    212239    if( _global_stateset == NULL && _shvec.size() > 0 ) 
    213         { 
     240    { 
    214241        SceneHandlerList::iterator p = _shvec.begin(); 
    215                 _global_stateset = (*p)->getGlobalStateSet(); 
    216         } 
     242        _global_stateset = (*p)->getGlobalStateSet(); 
     243    } 
    217244 
    218245    setUpSceneViewsWithData();