Changeset 10588

Show
Ignore:
Timestamp:
09/22/09 20:45:24 (5 years ago)
Author:
robert
Message:

Preliminary work on support for a texture object pool that is designed to help manage resources down the GPU more tightly.

Location:
OpenSceneGraph/trunk
Files:
21 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/include/osg/DisplaySettings

    r10350 r10588  
    199199        void setApplication(const std::string& application) { _application = application; } 
    200200        const std::string& getApplication() { return _application; } 
     201 
     202 
     203        void setMaxTexturePoolSize(unsigned int size) { _maxTexturePoolSize = size; } 
     204        unsigned int getMaxTexturePoolSize() const { return _maxTexturePoolSize; } 
     205 
     206        void setMaxVBOPoolSize(unsigned int size) { _maxVBOPoolSize = size; } 
     207        unsigned int getMaxVBOPoolSize() const { return _maxVBOPoolSize; } 
     208 
     209        void setMaxFBOPoolSize(unsigned int size) { _maxFBOPoolSize = size; } 
     210        unsigned int getMaxFBOPoolSize() const { return _maxFBOPoolSize; } 
    201211 
    202212    protected: 
     
    241251        std::string                     _application; 
    242252 
     253        unsigned int                    _maxTexturePoolSize; 
     254        unsigned int                    _maxVBOPoolSize; 
     255        unsigned int                    _maxFBOPoolSize; 
    243256}; 
    244257 
  • OpenSceneGraph/trunk/include/osg/State

    r10179 r10588  
    4040        #define GL_FOG_COORDINATE_ARRAY GL_FOG_COORDINATE_ARRAY_EXT 
    4141    #else 
    42          #define GL_FOG_COORDINATE_ARRAY 0x8457 
     42        #define GL_FOG_COORDINATE_ARRAY 0x8457 
    4343    #endif 
    4444#endif 
     
    4848        #define GL_SECONDARY_COLOR_ARRAY GL_SECONDARY_COLOR_ARRAY_EXT 
    4949    #else 
    50          #define GL_SECONDARY_COLOR_ARRAY 0x845E 
     50        #define GL_SECONDARY_COLOR_ARRAY 0x845E 
    5151    #endif 
    5252#endif 
     
    5555 
    5656/** macro for use with osg::StateAttribute::apply methods for detecting and 
    57   * reporting OpenGL error messages.*/ 
     57* reporting OpenGL error messages.*/ 
    5858#define OSG_GL_DEBUG(message) \ 
    5959    if (state.getFineGrainedErrorDetection()) \ 
     
    7171 
    7272/** Encapsulates the current applied OpenGL modes, attributes and vertex arrays settings, 
    73   * implements lazy state updating and provides accessors for querying the current state. 
    74   * The venerable Red Book says that "OpenGL is a state machine", and this class 
    75   * represents the OpenGL state in OSG. Furthermore, \c State also has other 
    76   * important features: 
    77   * - It works as a stack of states (see \c pushStateSet() and 
    78   *   \c popStateSet()). Manipulating this stack of OpenGL states manually is 
    79   *   seldom needed, since OSG does this in the most common situations. 
    80   * - It implements lazy state updating. This means that, if one requests a 
    81   *   state change and that particular state is already in the requested state, 
    82   *   no OpenGL call will be made. This ensures that the OpenGL pipeline is not 
    83   *   stalled by unnecessary state changes. 
    84   * - It allows to query the current OpenGL state without calls to \c glGet*(), 
    85   *   which typically stall the graphics pipeline (see, for instance, 
    86   *   \c captureCurrentState() and \c getModelViewMatrix()). 
    87   */ 
     73* implements lazy state updating and provides accessors for querying the current state. 
     74* The venerable Red Book says that "OpenGL is a state machine", and this class 
     75* represents the OpenGL state in OSG. Furthermore, \c State also has other 
     76* important features: 
     77* - It works as a stack of states (see \c pushStateSet() and 
     78*   \c popStateSet()). Manipulating this stack of OpenGL states manually is 
     79*   seldom needed, since OSG does this in the most common situations. 
     80* - It implements lazy state updating. This means that, if one requests a 
     81*   state change and that particular state is already in the requested state, 
     82*   no OpenGL call will be made. This ensures that the OpenGL pipeline is not 
     83*   stalled by unnecessary state changes. 
     84* - It allows to query the current OpenGL state without calls to \c glGet*(), 
     85*   which typically stall the graphics pipeline (see, for instance, 
     86*   \c captureCurrentState() and \c getModelViewMatrix()). 
     87*/ 
    8888class OSG_EXPORT State : public Referenced, public Observer 
    8989{ 
     
    9191 
    9292        State(); 
    93          
    94  
    95         /** Set the graphics context associated with that owns this State object.*/         
     93 
     94 
     95        /** Set the graphics context associated with that owns this State object.*/ 
    9696        void setGraphicsContext(GraphicsContext* context) { _graphicsContext = context; } 
    9797 
    98         /** Get the graphics context associated with that owns this State object.*/         
     98        /** Get the graphics context associated with that owns this State object.*/ 
    9999        GraphicsContext* getGraphicsContext() { return _graphicsContext; } 
    100100 
    101         /** Get the const graphics context associated with that owns this State object.*/         
     101        /** Get the const graphics context associated with that owns this State object.*/ 
    102102        const GraphicsContext* getGraphicsContext() const { return _graphicsContext; } 
    103          
     103 
    104104 
    105105        /** Set the current OpenGL context uniqueID. 
     
    123123        /** Pop stateset off state stack.*/ 
    124124        void popStateSet(); 
    125          
     125 
    126126        /** pop all statesets off state stack, ensuring it is empty ready for the next frame. 
    127           * Note, to return OpenGL to default state, one should do any state.popAllStatSets(); state.apply().*/ 
     127        * Note, to return OpenGL to default state, one should do any state.popAllStatSets(); state.apply().*/ 
    128128        void popAllStateSets(); 
    129129 
     
    133133        /** Pop stateset off state stack.*/ 
    134134        void removeStateSet(unsigned int pos); 
    135          
     135 
    136136        /** Get the number of StateSet's on the StateSet stack.*/ 
    137137        unsigned int getStateSetStackSize() { return static_cast<unsigned int>(_stateStateStack.size()); } 
    138          
     138 
    139139        /** Pop StateSet's for the StateSet stack till its size equals the specified size.*/ 
    140140        void popStateSetStackToSize(unsigned int size) { while (_stateStateStack.size()>size) popStateSet(); } 
     
    144144        /** Get the StateSet stack.*/ 
    145145        StateSetStack& getStateSetStack() { return _stateStateStack; } 
    146          
     146 
    147147 
    148148        /** Copy the modes and attributes which capture the current state.*/ 
     
    217217 
    218218        /** Updates the OpenGL state so that it matches the \c StateSet at the 
    219           * top of the stack of <tt>StateSet</tt>s maintained internally by a 
    220           * \c State. 
    221          */ 
     219        * top of the stack of <tt>StateSet</tt>s maintained internally by a 
     220        * \c State. 
     221        */ 
    222222        void apply(); 
    223223 
    224224 
    225225        /** Set whether a particular OpenGL mode is valid in the current graphics context. 
    226           * Use to disable OpenGL modes that are not supported by current graphics drivers/context.*/ 
     226        * Use to disable OpenGL modes that are not supported by current graphics drivers/context.*/ 
    227227        inline void setModeValidity(StateAttribute::GLMode mode,bool valid) 
    228228        { 
     
    232232 
    233233        /** Get whether a particular OpenGL mode is valid in the current graphics context. 
    234           * Use to disable OpenGL modes that are not supported by current graphics drivers/context.*/ 
     234        * Use to disable OpenGL modes that are not supported by current graphics drivers/context.*/ 
    235235        inline bool getModeValidity(StateAttribute::GLMode mode) 
    236236        { 
     
    252252 
    253253        /** Apply an OpenGL mode if required. This is a wrapper around 
    254           * \c glEnable() and \c glDisable(), that just actually calls these 
    255           * functions if the \c enabled flag is different than the current 
    256           * state. 
    257           * @return \c true if the state was actually changed. \c false 
    258           *         otherwise. Notice that a \c false return does not indicate 
    259           *         an error, it just means that the mode was already set to the 
    260           *         same value as the \c enabled parameter. 
     254        * \c glEnable() and \c glDisable(), that just actually calls these 
     255        * functions if the \c enabled flag is different than the current 
     256        * state. 
     257        * @return \c true if the state was actually changed. \c false 
     258        *         otherwise. Notice that a \c false return does not indicate 
     259        *         an error, it just means that the mode was already set to the 
     260        *         same value as the \c enabled parameter. 
    261261        */ 
    262262        inline bool applyMode(StateAttribute::GLMode mode,bool enabled) 
     
    346346 
    347347        /** Mode has been set externally, therefore dirty the associated mode in osg::State 
    348           * so it is applied on next call to osg::State::apply(..)*/ 
     348        * so it is applied on next call to osg::State::apply(..)*/ 
    349349        void haveAppliedMode(StateAttribute::GLMode mode); 
    350350 
     
    352352        void haveAppliedAttribute(const StateAttribute* attribute); 
    353353 
    354         /** Attribute has been applied externally,  
    355           * and therefore this attribute type has been dirtied  
    356           * and will need to be re-applied on next osg::State.apply(..). 
    357           * note, if you have an osg::StateAttribute which you have applied externally 
    358           * then use the have_applied(attribute) method as this will cause the osg::State to 
    359           * track the current state more accurately and enable lazy state updating such 
    360           * that only changed state will be applied.*/ 
     354        /** Attribute has been applied externally, 
     355        * and therefore this attribute type has been dirtied 
     356        * and will need to be re-applied on next osg::State.apply(..). 
     357        * note, if you have an osg::StateAttribute which you have applied externally 
     358        * then use the have_applied(attribute) method as this will cause the osg::State to 
     359        * track the current state more accurately and enable lazy state updating such 
     360        * that only changed state will be applied.*/ 
    361361        void haveAppliedAttribute(StateAttribute::Type type, unsigned int member=0); 
    362362 
    363         /** Get whether the current specified mode is enabled (true) or disabled (false).*/  
     363        /** Get whether the current specified mode is enabled (true) or disabled (false).*/ 
    364364        bool getLastAppliedMode(StateAttribute::GLMode mode) const; 
    365365 
    366         /** Get the current specified attribute, return NULL if one has not yet been applied.*/  
     366        /** Get the current specified attribute, return NULL if one has not yet been applied.*/ 
    367367        const StateAttribute* getLastAppliedAttribute(StateAttribute::Type type, unsigned int member=0) const; 
    368368 
     
    371371 
    372372        /** texture Mode has been set externally, therefore dirty the associated mode in osg::State 
    373           * so it is applied on next call to osg::State::apply(..)*/ 
     373        * so it is applied on next call to osg::State::apply(..)*/ 
    374374        void haveAppliedTextureMode(unsigned int unit, StateAttribute::GLMode mode); 
    375375 
     
    378378 
    379379        /** texture Attribute has been applied externally, 
    380           * and therefore this attribute type has been dirtied 
    381           * and will need to be re-applied on next osg::State.apply(..). 
    382           * note, if you have an osg::StateAttribute which you have applied externally 
    383           * then use the have_applied(attribute) method as this will the osg::State to 
    384           * track the current state more accurately and enable lazy state updating such 
    385           * that only changed state will be applied.*/ 
     380        * and therefore this attribute type has been dirtied 
     381        * and will need to be re-applied on next osg::State.apply(..). 
     382        * note, if you have an osg::StateAttribute which you have applied externally 
     383        * then use the have_applied(attribute) method as this will the osg::State to 
     384        * track the current state more accurately and enable lazy state updating such 
     385        * that only changed state will be applied.*/ 
    386386        void haveAppliedTextureAttribute(unsigned int unit, StateAttribute::Type type, unsigned int member=0); 
    387387 
     
    457457        { 
    458458            if (!_currentPBO) return; 
    459              
     459 
    460460            _glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB,0); 
    461461            _currentPBO = 0; 
    462462        } 
    463          
    464          
     463 
     464 
    465465        inline void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei primcount) 
    466466        { 
     
    468468            else glDrawArrays(mode, first, count); 
    469469        } 
    470      
     470 
    471471        inline void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount ) 
    472472        { 
     
    477477 
    478478        /** Wrapper around glInterleavedArrays(..). 
    479           * also resets the internal array points and modes within osg::State to keep the other 
    480           * vertex array operations consistent. */ 
     479        * also resets the internal array points and modes within osg::State to keep the other 
     480        * vertex array operations consistent. */ 
    481481        void setInterleavedArrays( GLenum format, GLsizei stride, const GLvoid* pointer); 
    482482 
     
    488488                const VertexBufferObject* vbo = array->getVertexBufferObject(); 
    489489                if (vbo) 
    490                 {  
     490                { 
    491491                    bindVertexBufferObject(vbo); 
    492492                    setVertexPointer(array->getDataSize(),array->getDataType(),0,array->getVertexBufferObjectOffset()); 
     
    502502 
    503503        /** wrapper around glEnableClientState(GL_VERTEX_ARRAY);glVertexPointer(..); 
    504           * note, only updates values that change.*/ 
     504        * note, only updates values that change.*/ 
    505505        inline void setVertexPointer( GLint size, GLenum type, 
    506                                       GLsizei stride, const GLvoid *ptr ) 
     506                                    GLsizei stride, const GLvoid *ptr ) 
    507507        { 
    508508            if (!_vertexArray._enabled || _vertexArray._dirty) 
     
    520520 
    521521        /** wrapper around glDisableClientState(GL_VERTEX_ARRAY). 
    522           * note, only updates values that change.*/ 
     522        * note, only updates values that change.*/ 
    523523        inline void disableVertexPointer() 
    524524        { 
     
    545545                const VertexBufferObject* vbo = array->getVertexBufferObject(); 
    546546                if (vbo) 
    547                 {  
     547                { 
    548548                    bindVertexBufferObject(vbo); 
    549                    setNormalPointer(array->getDataType(),0,array->getVertexBufferObjectOffset()); 
     549                setNormalPointer(array->getDataType(),0,array->getVertexBufferObjectOffset()); 
    550550                } 
    551551                else 
     
    559559 
    560560        /** wrapper around glEnableClientState(GL_NORMAL_ARRAY);glNormalPointer(..); 
    561           * note, only updates values that change.*/ 
     561        * note, only updates values that change.*/ 
    562562        inline void setNormalPointer( GLenum type, GLsizei stride, 
    563                                       const GLvoid *ptr ) 
     563                                    const GLvoid *ptr ) 
    564564        { 
    565565            if (!_normalArray._enabled || _normalArray._dirty) 
     
    577577 
    578578        /** wrapper around glDisableClientState(GL_NORMAL_ARRAY); 
    579           * note, only updates values that change.*/ 
     579        * note, only updates values that change.*/ 
    580580        inline void disableNormalPointer() 
    581581        { 
     
    601601                const VertexBufferObject* vbo = array->getVertexBufferObject(); 
    602602                if (vbo) 
    603                 {  
     603                { 
    604604                    bindVertexBufferObject(vbo); 
    605605                    setColorPointer(array->getDataSize(),array->getDataType(),0,array->getVertexBufferObjectOffset()); 
     
    616616 
    617617        /** wrapper around glEnableClientState(GL_COLOR_ARRAY);glColorPointer(..); 
    618           * note, only updates values that change.*/ 
     618        * note, only updates values that change.*/ 
    619619        inline void setColorPointer( GLint size, GLenum type, 
    620                                      GLsizei stride, const GLvoid *ptr ) 
     620                                    GLsizei stride, const GLvoid *ptr ) 
    621621        { 
    622622            if (!_colorArray._enabled || _colorArray._dirty) 
     
    634634 
    635635        /** wrapper around glDisableClientState(GL_COLOR_ARRAY); 
    636           * note, only updates values that change.*/ 
     636        * note, only updates values that change.*/ 
    637637        inline void disableColorPointer() 
    638638        { 
     
    662662                const VertexBufferObject* vbo = array->getVertexBufferObject(); 
    663663                if (vbo) 
    664                 {  
     664                { 
    665665                    bindVertexBufferObject(vbo); 
    666 #if 0                     
     666#if 0 
    667667                    setSecondaryColorPointer(array->getDataSize(),array->getDataType(),0,vbo->getOffset(array->getVertexBufferObjectIndex())); 
    668668#else 
     
    680680 
    681681        /** wrapper around glEnableClientState(GL_SECONDARY_COLOR_ARRAY);glSecondayColorPointer(..); 
    682           * note, only updates values that change.*/ 
     682        * note, only updates values that change.*/ 
    683683        void setSecondaryColorPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *ptr ); 
    684684 
    685685        /** wrapper around glDisableClientState(GL_SECONDARY_COLOR_ARRAY); 
    686           * note, only updates values that change.*/ 
     686        * note, only updates values that change.*/ 
    687687        inline void disableSecondaryColorPointer() 
    688688        { 
     
    702702 
    703703        /** wrapper around glEnableClientState(GL_INDEX_ARRAY);glIndexPointer(..); 
    704           * note, only updates values that change.*/ 
     704        * note, only updates values that change.*/ 
    705705        inline void setIndexPointer( GLenum type, GLsizei stride, 
    706                               const GLvoid *ptr ) 
     706                            const GLvoid *ptr ) 
    707707        { 
    708708            if (!_indexArray._enabled || _indexArray._dirty) 
     
    720720 
    721721        /** wrapper around glDisableClientState(GL_INDEX_ARRAY); 
    722           * note, only updates values that change.*/ 
     722        * note, only updates values that change.*/ 
    723723        inline void disableIndexPointer() 
    724724        { 
     
    748748                const VertexBufferObject* vbo = array->getVertexBufferObject(); 
    749749                if (vbo) 
    750                 {  
     750                { 
    751751                    bindVertexBufferObject(vbo); 
    752752#if 0 
     
    767767 
    768768        /** wrapper around glEnableClientState(GL_FOG_COORDINATE_ARRAY);glFogCoordPointer(..); 
    769           * note, only updates values that change.*/ 
     769        * note, only updates values that change.*/ 
    770770        void setFogCoordPointer( GLenum type, GLsizei stride, const GLvoid *ptr ); 
    771771 
    772772        /** wrapper around glDisableClientState(GL_FOG_COORDINATE_ARRAY); 
    773           * note, only updates values that change.*/ 
     773        * note, only updates values that change.*/ 
    774774        inline void disableFogCoordPointer() 
    775775        { 
     
    797797                const VertexBufferObject* vbo = array->getVertexBufferObject(); 
    798798                if (vbo) 
    799                 {  
     799                { 
    800800                    bindVertexBufferObject(vbo); 
    801801#if 0 
     
    815815 
    816816        /** wrapper around glEnableClientState(GL_TEXTURE_COORD_ARRAY);glTexCoordPointer(..); 
    817           * note, only updates values that change.*/ 
     817        * note, only updates values that change.*/ 
    818818        inline void setTexCoordPointer( unsigned int unit, 
    819819                                        GLint size, GLenum type, 
     
    840840 
    841841        /** wrapper around glDisableClientState(GL_TEXTURE_COORD_ARRAY); 
    842           * note, only updates values that change.*/ 
     842        * note, only updates values that change.*/ 
    843843        inline void disableTexCoordPointer( unsigned int unit ) 
    844844        { 
     
    897897 
    898898        /** Set the current texture unit, return true if selected, 
    899           * false if selection failed such as when multi texturing is not supported. 
    900           * note, only updates values that change.*/ 
     899        * false if selection failed such as when multi texturing is not supported. 
     900        * note, only updates values that change.*/ 
    901901        bool setActiveTextureUnit( unsigned int unit ); 
    902          
     902 
    903903        /** Get the current texture unit.*/ 
    904904        unsigned int getActiveTextureUnit() const { return _currentActiveTextureUnit; } 
    905905 
    906906        /** Set the current tex coord array texture unit, return true if selected, 
    907           * false if selection failed such as when multi texturing is not supported. 
    908           * note, only updates values that change.*/ 
     907        * false if selection failed such as when multi texturing is not supported. 
     908        * note, only updates values that change.*/ 
    909909        bool setClientActiveTextureUnit( unsigned int unit ); 
    910910 
     
    919919                const VertexBufferObject* vbo = array->getVertexBufferObject(); 
    920920                if (vbo) 
    921                 {  
     921                { 
    922922                    bindVertexBufferObject(vbo); 
    923 #if 0                     
     923#if 0 
    924924                    setVertexAttribPointer(unit, array->getDataSize(),array->getDataType(),normalized,0,vbo->getOffset(array->getVertexBufferObjectIndex())); 
    925925#else 
     
    937937 
    938938        /** wrapper around glEnableVertexAttribArrayARB(index);glVertexAttribPointerARB(..); 
    939           * note, only updates values that change.*/ 
     939        * note, only updates values that change.*/ 
    940940        void setVertexAttribPointer( unsigned int index, 
    941                                      GLint size, GLenum type, GLboolean normalized, 
    942                                      GLsizei stride, const GLvoid *ptr ); 
     941                                    GLint size, GLenum type, GLboolean normalized, 
     942                                    GLsizei stride, const GLvoid *ptr ); 
    943943 
    944944        /** wrapper around DisableVertexAttribArrayARB(index); 
    945           * note, only updates values that change.*/ 
     945        * note, only updates values that change.*/ 
    946946        void disableVertexAttribPointer( unsigned int index ); 
    947947 
     
    966966            if (_lastAppliedProgramObject!=program) 
    967967            { 
    968                 _lastAppliedProgramObject = program;  
     968                _lastAppliedProgramObject = program; 
    969969                if (program && _appliedProgramObjectSet.count(program)==0) 
    970970                { 
    971                     _appliedProgramObjectSet.insert(program);  
     971                    _appliedProgramObjectSet.insert(program); 
    972972                    program->addObserver(this); 
    973973                } 
     
    999999 
    10001000        /** Set the DisplaySettings. Note, nothing is applied, the visual settings are just 
    1001           * used in the State object to pass the current visual settings to Drawables 
    1002           * during rendering. */ 
     1001        * used in the State object to pass the current visual settings to Drawables 
     1002        * during rendering. */ 
    10031003        inline void setDisplaySettings(DisplaySettings* vs) { _displaySettings = vs; } 
    10041004 
     
    10121012 
    10131013        /** Get flag for early termination of the draw traversal, 
    1014           * if true steps should be taken to complete rendering early.*/ 
     1014        * if true steps should be taken to complete rendering early.*/ 
    10151015        bool getAbortRendering() const { return _abortRenderingPtr!=0?(*_abortRenderingPtr):false; } 
    10161016 
     
    10201020            virtual void completed(osg::State*) = 0; 
    10211021        }; 
    1022          
     1022 
    10231023        /** Set the callback to be called when the dynamic object count hits 0.*/ 
    10241024        void setDynamicObjectRenderingCompletedCallback(DynamicObjectRenderingCompletedCallback* cb){ _completeDynamicObjectRenderingCallback = cb; } 
    1025          
     1025 
    10261026        /** Get the callback to be called when the dynamic object count hits 0.*/ 
    10271027        DynamicObjectRenderingCompletedCallback* getDynamicObjectRenderingCompletedCallback() { return _completeDynamicObjectRenderingCallback.get(); } 
    1028          
     1028 
    10291029        /** Set the number of dynamic objects that will be rendered in this graphics context this frame.*/ 
    10301030        void setDynamicObjectCount(unsigned int count, bool callCallbackOnZero = false) 
     
    10421042        /** Get the number of dynamic objects that will be rendered in this graphics context this frame.*/ 
    10431043        unsigned int getDynamicObjectCount() const { return _dynamicObjectCount; } 
    1044          
    1045         /** Decrement the number of dynamic objects left to render this frame, and once the count goes to zero call the  
    1046           * DynamicObjectRenderingCompletedCallback to inform of completion.*/ 
     1044 
     1045        /** Decrement the number of dynamic objects left to render this frame, and once the count goes to zero call the 
     1046        * DynamicObjectRenderingCompletedCallback to inform of completion.*/ 
    10471047        inline void decrementDynamicObjectCount() 
    10481048        { 
     
    10521052                _completeDynamicObjectRenderingCallback->completed(this); 
    10531053            } 
    1054         }  
     1054        } 
     1055 
     1056        void setMaxTexturePoolSize(unsigned int size); 
     1057        unsigned int getMaxTexturePoolSize() const { return _maxTexturePoolSize; } 
     1058 
     1059        void setMaxVBOPoolSize(unsigned int size); 
     1060        unsigned int getMaxVBOPoolSize() const { return _maxVBOPoolSize; } 
     1061 
     1062        void setMaxFBOPoolSize(unsigned int size); 
     1063        unsigned int getMaxFBOPoolSize() const { return _maxFBOPoolSize; } 
    10551064 
    10561065 
     
    10581067        enum CheckForGLErrors 
    10591068        { 
    1060             /** NEVER_CHECK_GL_ERRORS hints that OpenGL need not be checked for, this  
     1069            /** NEVER_CHECK_GL_ERRORS hints that OpenGL need not be checked for, this 
    10611070                is the fastest option since checking for errors does incurr a small overhead.*/ 
    10621071            NEVER_CHECK_GL_ERRORS, 
     
    11551164 
    11561165        /** Apply an OpenGL mode if required, passing in mode, enable flag and 
    1157           * appropriate mode stack. This is a wrapper around \c glEnable() and 
    1158           * \c glDisable(), that just actually calls these functions if the 
    1159           * \c enabled flag is different than the current state. 
    1160           * @return \c true if the state was actually changed. \c false 
    1161           *         otherwise. Notice that a \c false return does not indicate 
    1162           *         an error, it just means that the mode was already set to the 
    1163           *         same value as the \c enabled parameter. 
     1166        * appropriate mode stack. This is a wrapper around \c glEnable() and 
     1167        * \c glDisable(), that just actually calls these functions if the 
     1168        * \c enabled flag is different than the current state. 
     1169        * @return \c true if the state was actually changed. \c false 
     1170        *         otherwise. Notice that a \c false return does not indicate 
     1171        *         an error, it just means that the mode was already set to the 
     1172        *         same value as the \c enabled parameter. 
    11641173        */ 
    11651174        inline bool applyMode(StateAttribute::GLMode mode,bool enabled,ModeStack& ms) 
     
    12251234 
    12261235        typedef std::vector<ref_ptr<const Matrix> >                     MatrixStack; 
    1227          
     1236 
    12281237        typedef std::set<const Program::PerContextProgram* >            AppliedProgramObjectSet; 
    12291238 
     
    12391248 
    12401249        StateSetStack                                                   _stateStateStack; 
     1250 
     1251        unsigned int                                                    _maxTexturePoolSize; 
     1252        unsigned int                                                    _maxVBOPoolSize; 
     1253        unsigned int                                                    _maxFBOPoolSize; 
     1254 
    12411255 
    12421256        struct EnabledArrayPair 
     
    13271341        typedef void (APIENTRY * DisableVertexAttribProc) (unsigned int); 
    13281342        typedef void (APIENTRY * BindBufferProc) (GLenum target, GLuint buffer); 
    1329          
     1343 
    13301344        typedef void (APIENTRY * DrawArraysInstancedProc)( GLenum mode, GLint first, GLsizei count, GLsizei primcount ); 
    13311345        typedef void (APIENTRY * DrawElementsInstancedProc)( GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount ); 
     
    13471361        unsigned int                                            _dynamicObjectCount; 
    13481362        osg::ref_ptr<DynamicObjectRenderingCompletedCallback>   _completeDynamicObjectRenderingCallback; 
    1349          
     1363 
    13501364}; 
    13511365 
  • OpenSceneGraph/trunk/include/osg/Texture

    r10370 r10588  
    471471        class TextureObject; 
    472472 
    473         /** Returns a pointer to the texture object for the current context. */ 
     473        /** Returns a pointer to the TextureBbject for the current context. */ 
    474474        inline TextureObject* getTextureObject(unsigned int contextID) const 
    475475        { 
    476476            return _textureObjectBuffer[contextID].get(); 
     477        } 
     478 
     479        inline void setTextureObject(unsigned int contextID, TextureObject* to) 
     480        { 
     481            _textureObjectBuffer[contextID] = to; 
    477482        } 
    478483 
     
    760765        /** Allocate mipmap levels of the texture by subsequent calling of glTexImage* function. */ 
    761766        virtual void allocateMipmap(State& state) const = 0; 
    762          
     767 
    763768        /** Returns -1 if *this < *rhs, 0 if *this==*rhs, 1 if *this>*rhs. */ 
    764769        int compareTexture(const Texture& rhs) const; 
     
    770775        mutable TexParameterDirtyList _texParametersDirtyList; 
    771776        mutable TexParameterDirtyList _texMipmapGenerationDirtyList; 
    772          
     777 
    773778        WrapMode _wrap_s; 
    774779        WrapMode _wrap_t; 
     
    791796        mutable GLenum      _sourceFormat; 
    792797        mutable GLenum      _sourceType; 
    793        
     798 
    794799        bool                _use_shadow_comparison; 
    795800        ShadowCompareFunc   _shadow_compare_func; 
     
    798803 
    799804    public: 
    800      
    801         class TextureObject : public osg::Referenced 
     805 
     806        struct TextureProfile 
    802807        { 
    803         public: 
    804          
    805             inline TextureObject(GLuint    id,GLenum target): 
    806                 _id(id), 
     808            inline TextureProfile(GLenum target): 
    807809                _target(target), 
    808810                _numMipmapLevels(0), 
     
    811813                _height(0), 
    812814                _depth(0), 
    813                 _border(0), 
     815                _border(0) {} 
     816 
     817            inline TextureProfile(GLenum    target, 
     818                                 GLint     numMipmapLevels, 
     819                                 GLenum    internalFormat, 
     820                                 GLsizei   width, 
     821                                 GLsizei   height, 
     822                                 GLsizei   depth, 
     823                                 GLint     border): 
     824                _target(target), 
     825                _numMipmapLevels(numMipmapLevels), 
     826                _internalFormat(internalFormat), 
     827                _width(width), 
     828                _height(height), 
     829                _depth(depth), 
     830                _border(border) {} 
     831 
     832 
     833            #define LESSTHAN(A,B) if (A<B) return true; if (B<A) return false; 
     834            #define FINALLESSTHAN(A,B) return (A<B); 
     835 
     836            bool operator < (const TextureProfile& rhs) const 
     837            { 
     838                LESSTHAN(_target,rhs._target); 
     839                LESSTHAN(_numMipmapLevels,rhs._numMipmapLevels); 
     840                LESSTHAN(_internalFormat,rhs._internalFormat); 
     841                LESSTHAN(_width,rhs._width); 
     842                LESSTHAN(_height,rhs._height); 
     843                LESSTHAN(_depth,rhs._depth); 
     844                FINALLESSTHAN(_border, rhs._border); 
     845            } 
     846 
     847            bool operator == (const TextureProfile& rhs) const 
     848            { 
     849                return _target == rhs._target && 
     850                       _numMipmapLevels == rhs._numMipmapLevels && 
     851                       _internalFormat == rhs._internalFormat && 
     852                       _width == rhs._width && 
     853                       _height == rhs._height && 
     854                       _depth == rhs._depth && 
     855                       _border == rhs._border; 
     856            } 
     857 
     858            inline void set(GLint numMipmapLevels, 
     859                            GLenum    internalFormat, 
     860                            GLsizei   width, 
     861                            GLsizei   height, 
     862                            GLsizei   depth, 
     863                            GLint     border) 
     864            { 
     865                _numMipmapLevels = numMipmapLevels; 
     866                _internalFormat = internalFormat; 
     867                _width = width; 
     868                _height = height; 
     869                _depth = depth; 
     870                _border = border; 
     871            } 
     872 
     873            inline bool match(GLenum    target, 
     874                       GLint     numMipmapLevels, 
     875                       GLenum    internalFormat, 
     876                       GLsizei   width, 
     877                       GLsizei   height, 
     878                       GLsizei   depth, 
     879                       GLint     border) 
     880            { 
     881                return (_target == target) && 
     882                       (_numMipmapLevels == numMipmapLevels) && 
     883                       (_internalFormat == internalFormat) && 
     884                       (_width == width) && 
     885                       (_height == height) && 
     886                       (_depth == depth) && 
     887                       (_border == border); 
     888            } 
     889 
     890            GLenum      _target; 
     891            GLint       _numMipmapLevels; 
     892            GLenum      _internalFormat; 
     893            GLsizei     _width; 
     894            GLsizei     _height; 
     895            GLsizei     _depth; 
     896            GLint       _border; 
     897        }; 
     898 
     899        // forward declare 
     900        class TextureObjectSet; 
     901        class TextureObjectManager; 
     902 
     903        class TextureObject : public osg::Referenced 
     904        { 
     905        public: 
     906 
     907            inline TextureObject(Texture* texture, GLuint id, GLenum target): 
     908                _id(id), 
     909                _profile(target), 
     910                _set(0), 
     911                _previous(0), 
     912                _next(0), 
     913                _texture(texture), 
    814914                _allocated(false), 
    815915                _timeStamp(0) {} 
    816                  
    817             inline TextureObject(GLuint    id, 
     916 
     917            inline TextureObject(Texture* texture, GLuint id, const TextureProfile& profile): 
     918                _id(id), 
     919                _profile(profile), 
     920                _set(0), 
     921                _previous(0), 
     922                _next(0), 
     923                _texture(texture), 
     924                _allocated(false), 
     925                _timeStamp(0) {} 
     926 
     927            inline TextureObject(Texture* texture, 
     928                          GLuint    id, 
    818929                          GLenum    target, 
    819930                          GLint     numMipmapLevels, 
     
    824935                          GLint     border): 
    825936                _id(id), 
    826                 _target(target), 
    827                 _numMipmapLevels(numMipmapLevels), 
    828                 _internalFormat(internalFormat), 
    829                 _width(width), 
    830                 _height(height), 
    831                 _depth(depth), 
    832                 _border(border), 
     937                _profile(target,numMipmapLevels,internalFormat,width,height,depth,border), 
     938                _set(0), 
     939                _previous(0), 
     940                _next(0), 
     941                _texture(texture), 
    833942                _allocated(false), 
    834943                _timeStamp(0) {} 
    835                            
     944 
    836945            inline bool match(GLenum    target, 
    837946                       GLint     numMipmapLevels, 
     
    843952            { 
    844953                return isReusable() && 
    845                        (_target == target) && 
    846                        (_numMipmapLevels == numMipmapLevels) && 
    847                        (_internalFormat == internalFormat) && 
    848                        (_width == width) && 
    849                        (_height == height) && 
    850                        (_depth == depth) && 
    851                        (_border == border); 
     954                       _profile.match(target,numMipmapLevels,internalFormat,width,height,depth,border); 
    852955            } 
    853              
    854              
    855             inline void bind() 
    856             { 
    857                 glBindTexture( _target, _id); 
    858             } 
    859  
     956 
     957            void bind(); 
     958 
     959            inline GLenum id() const { return _id; } 
     960            inline GLenum target() const { return _profile._target; } 
     961 
     962            inline void setTexture(Texture* texture) { _texture = texture; } 
     963            inline Texture* getTexture() const { return _texture; } 
     964 
     965            inline void setTimeStamp(double timestamp) { _timeStamp = timestamp; } 
     966            inline double getTimeStamp() const { return _timeStamp; } 
    860967 
    861968            inline void setAllocated(bool allocated=true) { _allocated = allocated; } 
    862              
     969 
    863970            inline void setAllocated(GLint     numMipmapLevels, 
    864971                              GLenum    internalFormat, 
     
    869976            { 
    870977                _allocated=true; 
    871                 _numMipmapLevels = numMipmapLevels; 
    872                 _internalFormat = internalFormat; 
    873                 _width = width; 
    874                 _height = height; 
    875                 _depth = depth; 
    876                 _border = border; 
     978                _profile.set(numMipmapLevels,internalFormat,width,height,depth,border); 
    877979            } 
    878          
     980 
    879981            inline bool isAllocated() const { return _allocated; } 
    880982 
    881             inline bool isReusable() const { return _allocated && _width!=0; } 
    882  
    883             GLuint      _id; 
    884             GLenum      _target; 
    885             GLint       _numMipmapLevels; 
    886             GLenum      _internalFormat; 
    887             GLsizei     _width; 
    888             GLsizei     _height; 
    889             GLsizei     _depth; 
    890             GLint       _border; 
    891  
    892             bool        _allocated; 
    893             double      _timeStamp; 
    894         }; 
    895          
     983            inline bool isReusable() const { return _allocated && _profile._width!=0; } 
     984 
     985 
     986            GLuint              _id; 
     987            TextureProfile      _profile; 
     988            TextureObjectSet*   _set; 
     989            TextureObject*      _previous; 
     990            TextureObject*      _next; 
     991            Texture*            _texture; 
     992            bool                _allocated; 
     993            double              _timeStamp; 
     994        }; 
     995 
    896996        typedef std::list< ref_ptr<TextureObject> > TextureObjectList; 
    897         typedef osg::buffered_object<TextureObjectList> TextureObjectListMap;  
    898  
    899         /** Takes the active texture objects from the Texture and places them 
    900           * in the specified TextureObjectListMap. */ 
    901         void takeTextureObjects(TextureObjectListMap& toblm); 
    902          
    903          
    904         static TextureObject* generateTextureObject(unsigned int contextID,GLenum target); 
    905  
    906         static TextureObject* generateTextureObject(unsigned int contextID, 
     997 
     998        class TextureObjectSet : public Referenced 
     999        { 
     1000        public: 
     1001            TextureObjectSet(TextureObjectManager* parent, const TextureProfile& profile); 
     1002 
     1003            void handlePendingOrphandedTextureObjects(); 
     1004            void flushAllDeletedTextureObjects(); 
     1005            void discardAllDeletedTextureObjects(); 
     1006            void flushDeletedTextureObjects(double currentTime, double& availableTime); 
     1007 
     1008            TextureObject* takeOrGenerate(Texture* texture); 
     1009            void moveToBack(TextureObject* to); 
     1010            void addToBack(TextureObject* to); 
     1011            void orphan(TextureObject* to); 
     1012            unsigned int size() const; 
     1013 
     1014            bool checkConsistency() const; 
     1015 
     1016        protected: 
     1017 
     1018            virtual ~TextureObjectSet(); 
     1019 
     1020            OpenThreads::Mutex  _mutex; 
     1021 
     1022            TextureObjectManager*       _parent; 
     1023            unsigned int                _contextID; 
     1024            TextureProfile              _profile; 
     1025            unsigned int                _numOfTextureObjects; 
     1026            TextureObjectList           _orphanedTextureObjects; 
     1027            TextureObjectList           _pendingOrphanedTextureObjects; 
     1028 
     1029            TextureObject*              _head; 
     1030            TextureObject*              _tail; 
     1031 
     1032        }; 
     1033 
     1034        class TextureObjectManager : public osg::Referenced 
     1035        { 
     1036        public: 
     1037            TextureObjectManager(unsigned int contextID); 
     1038 
     1039            unsigned int getContextID() const { return _contextID; } 
     1040 
     1041            void setTexturePoolSize(unsigned int size); 
     1042            unsigned int getTexturePoolSize() const { return _texturePoolSize; } 
     1043 
     1044            TextureObject* generateTextureObject(const Texture* texture, GLenum target); 
     1045            TextureObject* generateTextureObject(const Texture* texture, 
     1046                                                        GLenum    target, 
     1047                                                        GLint     numMipmapLevels, 
     1048                                                        GLenum    internalFormat, 
     1049                                                        GLsizei   width, 
     1050                                                        GLsizei   height, 
     1051                                                        GLsizei   depth, 
     1052                                                        GLint     border); 
     1053            void handlePendingOrphandedTextureObjects(); 
     1054            void flushAllDeletedTextureObjects(); 
     1055            void discardAllDeletedTextureObjects(); 
     1056            void flushDeletedTextureObjects(double currentTime, double& availableTime); 
     1057            void releaseTextureObject(TextureObject* to); 
     1058 
     1059        protected: 
     1060 
     1061            typedef std::map< TextureProfile, osg::ref_ptr<TextureObjectSet> > TextureSetMap; 
     1062            unsigned int        _contextID; 
     1063            unsigned int        _texturePoolSize; 
     1064            TextureSetMap       _textureSetMap; 
     1065        }; 
     1066 
     1067        static osg::ref_ptr<Texture::TextureObjectManager>&  getTextureObjectManager(unsigned int contextID); 
     1068 
     1069        static TextureObject* generateTextureObject(const Texture* texture, unsigned int contextID,GLenum target); 
     1070 
     1071        static TextureObject* generateTextureObject(const Texture* texture, 
     1072                                                     unsigned int contextID, 
    9071073                                                     GLenum    target, 
    9081074                                                     GLint     numMipmapLevels, 
     
    9231089 
    9241090        static void discardAllDeletedTextureObjects(unsigned int contextID); 
    925          
     1091 
    9261092        static void flushDeletedTextureObjects(unsigned int contextID,double currentTime, double& availableTime); 
    9271093 
     1094        static void releaseTextureObject(unsigned int contextID, TextureObject* to); 
    9281095 
    9291096    protected: 
  • OpenSceneGraph/trunk/src/osg/DisplaySettings.cpp

    r10415 r10588  
    8181     
    8282    _application = vs._application; 
     83 
     84    _maxTexturePoolSize = vs._maxTexturePoolSize; 
     85    _maxVBOPoolSize = vs._maxVBOPoolSize; 
     86    _maxFBOPoolSize = vs._maxFBOPoolSize; 
    8387} 
    8488 
     
    104108 
    105109    if (_application.empty()) _application = vs._application; 
     110 
     111    if (vs._maxTexturePoolSize>_maxTexturePoolSize) _maxTexturePoolSize = vs._maxTexturePoolSize; 
     112    if (vs._maxVBOPoolSize>_maxVBOPoolSize) _maxVBOPoolSize = vs._maxVBOPoolSize; 
     113    if (vs._maxFBOPoolSize>_maxFBOPoolSize) _maxFBOPoolSize = vs._maxFBOPoolSize; 
    106114} 
    107115 
     
    148156    _numDatabaseThreadsHint = 2; 
    149157    _numHttpDatabaseThreadsHint = 1; 
     158 
     159    _maxTexturePoolSize = 0; 
     160    _maxVBOPoolSize = 0; 
     161    _maxFBOPoolSize = 0; 
    150162} 
    151163 
     
    187199static ApplicationUsageProxy DisplaySetting_e16(ApplicationUsage::ENVIRONMENTAL_VARIABLE,"OSG_NUM_HTTP_DATABASE_THREADS <int>","Set the hint for the total number of threads dedicated to http requests to set up in the DatabasePager."); 
    188200static ApplicationUsageProxy DisplaySetting_e17(ApplicationUsage::ENVIRONMENTAL_VARIABLE,"OSG_MULTI_SAMPLES <int>","Set the hint for the number of samples to use when multi-sampling."); 
     201static ApplicationUsageProxy DisplaySetting_e18(ApplicationUsage::ENVIRONMENTAL_VARIABLE,"OSG_TEXTURE_POOL_SIZE <int>","Set the hint size of texture pool to manage."); 
     202static ApplicationUsageProxy DisplaySetting_e19(ApplicationUsage::ENVIRONMENTAL_VARIABLE,"OSG_VBO_POOL_SIZE <int>","Set the hint size of vertex buffer object pool to manage."); 
     203static ApplicationUsageProxy DisplaySetting_e20(ApplicationUsage::ENVIRONMENTAL_VARIABLE,"OSG_FBO_POOL_SIZE <int>","Set the hint size of frame buffer object pool to manage."); 
    189204 
    190205void DisplaySettings::readEnvironmentalVariables() 
     
    382397    { 
    383398        _numMultiSamples = atoi(ptr); 
     399    } 
     400 
     401    if( (ptr = getenv("OSG_TEXTURE_POOL_SIZE")) != 0) 
     402    { 
     403        _maxTexturePoolSize = atoi(ptr); 
     404    } 
     405 
     406    if( (ptr = getenv("OSG_VBO_POOL_SIZE")) != 0) 
     407    { 
     408        _maxVBOPoolSize = atoi(ptr); 
     409    } 
     410 
     411    if( (ptr = getenv("OSG_FBO_POOL_SIZE")) != 0) 
     412    { 
     413        _maxFBOPoolSize = atoi(ptr); 
    384414    } 
    385415} 
     
    469499    while(arguments.read("--num-db-threads",_numDatabaseThreadsHint)) {} 
    470500    while(arguments.read("--num-http-threads",_numHttpDatabaseThreadsHint)) {} 
    471 } 
     501 
     502    while(arguments.read("--texture-pool-size",_maxTexturePoolSize)) {} 
     503    while(arguments.read("--vbo-pool-size",_maxVBOPoolSize)) {} 
     504    while(arguments.read("--fbo-pool-size",_maxFBOPoolSize)) {} 
     505 
     506} 
     507 
     508 
     509 
  • OpenSceneGraph/trunk/src/osg/FrameBufferObject.cpp

    r10327 r10588  
    497497    { 
    498498        tobj = _ximpl->textureTarget->getTextureObject(contextID); 
    499         if (!tobj || tobj->_id == 0) 
     499        if (!tobj || tobj->id() == 0) 
    500500        { 
    501501            _ximpl->textureTarget->compileGLObjects(state); 
    502502            tobj = _ximpl->textureTarget->getTextureObject(contextID); 
    503503        } 
    504         if (!tobj || tobj->_id == 0) 
     504        if (!tobj || tobj->id() == 0) 
    505505            return; 
    506506 
     
    527527    { 
    528528        tobj = _ximpl->textureTarget->getTextureObject(contextID); 
    529         if (!tobj || tobj->_id == 0) 
     529        if (!tobj || tobj->id() == 0) 
    530530        { 
    531531            _ximpl->textureTarget->compileGLObjects(state); 
     
    533533 
    534534        } 
    535         if (!tobj || tobj->_id == 0) 
     535        if (!tobj || tobj->id() == 0) 
    536536            return; 
    537537    } 
     
    544544        break; 
    545545    case Pimpl::TEXTURE1D: 
    546         ext->glFramebufferTexture1DEXT(target, attachment_point, GL_TEXTURE_1D, tobj->_id, _ximpl->level); 
     546        ext->glFramebufferTexture1DEXT(target, attachment_point, GL_TEXTURE_1D, tobj->id(), _ximpl->level); 
    547547        break; 
    548548    case Pimpl::TEXTURE2D: 
    549         ext->glFramebufferTexture2DEXT(target, attachment_point, GL_TEXTURE_2D, tobj->_id, _ximpl->level); 
     549        ext->glFramebufferTexture2DEXT(target, attachment_point, GL_TEXTURE_2D, tobj->id(), _ximpl->level); 
    550550        break; 
    551551    case Pimpl::TEXTURE3D: 
    552         ext->glFramebufferTexture3DEXT(target, attachment_point, GL_TEXTURE_3D, tobj->_id, _ximpl->level, _ximpl->zoffset); 
     552        ext->glFramebufferTexture3DEXT(target, attachment_point, GL_TEXTURE_3D, tobj->id(), _ximpl->level, _ximpl->zoffset); 
    553553        break; 
    554554    case Pimpl::TEXTURE2DARRAY: 
    555         ext->glFramebufferTextureLayerEXT(target, attachment_point, tobj->_id, _ximpl->level, _ximpl->zoffset); 
     555        ext->glFramebufferTextureLayerEXT(target, attachment_point, tobj->id(), _ximpl->level, _ximpl->zoffset); 
    556556        break; 
    557557    case Pimpl::TEXTURERECT: 
    558         ext->glFramebufferTexture2DEXT(target, attachment_point, GL_TEXTURE_RECTANGLE, tobj->_id, 0); 
     558        ext->glFramebufferTexture2DEXT(target, attachment_point, GL_TEXTURE_RECTANGLE, tobj->id(), 0); 
    559559        break; 
    560560    case Pimpl::TEXTURECUBE: 
    561         ext->glFramebufferTexture2DEXT(target, attachment_point, GL_TEXTURE_CUBE_MAP_POSITIVE_X + _ximpl->cubeMapFace, tobj->_id, _ximpl->level); 
     561        ext->glFramebufferTexture2DEXT(target, attachment_point, GL_TEXTURE_CUBE_MAP_POSITIVE_X + _ximpl->cubeMapFace, tobj->id(), _ximpl->level); 
    562562        break; 
    563563    } 
  • OpenSceneGraph/trunk/src/osg/State.cpp

    r9798 r10588  
    8787    _glMaxTextureCoords = 1; 
    8888    _glMaxTextureUnits = 1; 
     89 
     90    _maxTexturePoolSize = 0; 
     91    _maxVBOPoolSize = 0; 
     92    _maxFBOPoolSize = 0; 
    8993} 
    9094 
     
    219223 
    220224    _initialInverseViewMatrix.invert(*_initialViewMatrix); 
     225} 
     226 
     227void State::setMaxTexturePoolSize(unsigned int size) 
     228{ 
     229    _maxTexturePoolSize = size; 
     230    osg::notify(osg::NOTICE)<<"_maxTexturePoolSize="<<_maxTexturePoolSize<<std::endl; 
     231} 
     232 
     233void State::setMaxVBOPoolSize(unsigned int size) 
     234{ 
     235    _maxVBOPoolSize = size; 
     236    osg::notify(osg::NOTICE)<<"_maxVBOPoolSize="<<_maxVBOPoolSize<<std::endl; 
     237} 
     238 
     239void State::setMaxFBOPoolSize(unsigned int size) 
     240{ 
     241    _maxFBOPoolSize = size; 
     242    osg::notify(osg::NOTICE)<<"_maxFBOPoolSize="<<_maxFBOPoolSize<<std::endl; 
    221243} 
    222244 
  • OpenSceneGraph/trunk/src/osg/Texture.cpp

    r10409 r10588  
    2525#include <OpenThreads/Mutex> 
    2626 
    27 using namespace osg; 
    28  
    2927#ifndef GL_TEXTURE_WRAP_R 
    3028#define GL_TEXTURE_WRAP_R                 0x8072 
     
    5553ApplicationUsageProxy Texture_e0(ApplicationUsage::ENVIRONMENTAL_VARIABLE,"OSG_MAX_TEXTURE_SIZE","Set the maximum size of textures."); 
    5654 
    57 class TextureObjectManager : public osg::Referenced 
     55typedef buffered_value< ref_ptr<Texture::Extensions> > BufferedExtensions; 
     56static BufferedExtensions s_extensions; 
     57 
     58unsigned int s_minimumNumberOfTextureObjectsToRetainInCache = 0; 
     59 
     60void Texture::setMinimumNumberOfTextureObjectsToRetainInCache(unsigned int minimum) 
     61{ 
     62    s_minimumNumberOfTextureObjectsToRetainInCache = minimum; 
     63} 
     64 
     65unsigned int Texture::getMinimumNumberOfTextureObjectsToRetainInCache() 
     66{ 
     67    return s_minimumNumberOfTextureObjectsToRetainInCache; 
     68} 
     69 
     70 
     71#define USE_NEW_TEXTURE_POOL 0 
     72 
     73void Texture::TextureObject::bind() 
     74{ 
     75    glBindTexture( _profile._target, _id); 
     76    if (_set) _set->moveToBack(this); 
     77} 
     78 
     79 
     80/////////////////////////////////////////////////////////////////////////////////////////////////////////// 
     81// 
     82//  New texture object manager 
     83// 
     84Texture::TextureObjectSet::TextureObjectSet(TextureObjectManager* parent, const TextureProfile& profile): 
     85    _parent(parent), 
     86    _contextID(parent->getContextID()), 
     87    _profile(profile), 
     88    _numOfTextureObjects(0), 
     89    _head(0), 
     90    _tail(0) 
     91{ 
     92} 
     93 
     94Texture::TextureObjectSet::~TextureObjectSet() 
     95{ 
     96#if 0 
     97    osg::notify(osg::NOTICE)<<"TextureObjectSet::~TextureObjectSet(), _numOfTextureObjects="<<_numOfTextureObjects<<std::endl; 
     98    osg::notify(osg::NOTICE)<<"     _orphanedTextureObjects = "<<_orphanedTextureObjects.size()<<std::endl; 
     99    osg::notify(osg::NOTICE)<<"     _head = "<<_head<<std::endl; 
     100    osg::notify(osg::NOTICE)<<"     _tail = "<<_tail<<std::endl; 
     101#endif 
     102} 
     103 
     104bool Texture::TextureObjectSet::checkConsistency() const 
     105{ 
     106    // return true; 
     107 
     108    // osg::notify(osg::NOTICE)<<"TextureObjectSet::checkConsistency()"<<std::endl; 
     109    // check consistency of linked list. 
     110    unsigned int numInList = 0; 
     111    Texture::TextureObject* to = _head; 
     112    while(to!=0) 
     113    { 
     114        ++numInList; 
     115 
     116        if (to->_next) 
     117        { 
     118            if ((to->_next)->_previous != to) 
     119            { 
     120                osg::notify(osg::NOTICE)<<"Error (to->_next)->_previous != to "<<std::endl; 
     121                throw "Error (to->_next)->_previous != to "; 
     122            } 
     123        } 
     124        else 
     125        { 
     126            if (_tail != to) 
     127            { 
     128                osg::notify(osg::NOTICE)<<"Error _trail != to"<<std::endl; 
     129                throw "Error _trail != to"; 
     130            } 
     131        } 
     132 
     133        to = to->_next; 
     134    } 
     135 
     136    unsigned int totalNumber = numInList + _orphanedTextureObjects.size(); 
     137    if (totalNumber != _numOfTextureObjects) 
     138    { 
     139        osg::notify(osg::NOTICE)<<"Error numInList + _orphanedTextureObjects.size() != _numOfTextureObjects"<<std::endl; 
     140        osg::notify(osg::NOTICE)<<"    numInList = "<<numInList<<std::endl; 
     141        osg::notify(osg::NOTICE)<<"    _orphanedTextureObjects.size() = "<<_orphanedTextureObjects.size()<<std::endl; 
     142        osg::notify(osg::NOTICE)<<"    _pendingOrphanedTextureObjects.size() = "<<_pendingOrphanedTextureObjects.size()<<std::endl; 
     143        osg::notify(osg::NOTICE)<<"    _numOfTextureObjects = "<<_numOfTextureObjects<<std::endl; 
     144        throw "Error numInList + _orphanedTextureObjects.size() != _numOfTextureObjects"; 
     145    } 
     146 
     147    return true; 
     148} 
     149 
     150void Texture::TextureObjectSet::handlePendingOrphandedTextureObjects() 
     151{ 
     152    // osg::notify(osg::NOTICE)<<"handlePendingOrphandedTextureObjects()"<<_pendingOrphanedTextureObjects.size()<<std::endl; 
     153 
     154    if (_pendingOrphanedTextureObjects.empty()) return; 
     155 
     156    for(TextureObjectList::iterator itr = _pendingOrphanedTextureObjects.begin(); 
     157        itr != _pendingOrphanedTextureObjects.end(); 
     158        ++itr) 
     159    { 
     160        TextureObject* to = itr->get(); 
     161 
     162        _orphanedTextureObjects.push_back(to); 
     163 
     164        if (to->_previous!=0) 
     165        { 
     166            (to->_previous)->_next = to->_next; 
     167        } 
     168        else 
     169        { 
     170            // 'to' was head so assign _head to the next in list 
     171            _head = to->_next; 
     172        } 
     173 
     174        if (to->_next!=0) 
     175        { 
     176            (to->_next)->_previous = to->_previous; 
     177        } 
     178        else 
     179        { 
     180            // 'to' was tail so assing tail to the previous in list 
     181            _tail = to->_previous; 
     182        } 
     183 
     184        // reset the 'to' list pointers as it's no longer in the active list. 
     185        to->_next = 0; 
     186        to->_previous = 0; 
     187 
     188#if 0 
     189        osg::notify(osg::NOTICE)<<"  HPOTO  after  _head = "<<_head<<std::endl; 
     190        osg::notify(osg::NOTICE)<<"  HPOTO  after _tail = "<<_tail<<std::endl; 
     191        osg::notify(osg::NOTICE)<<"  HPOTO  after to->_previous = "<<to->_previous<<std::endl; 
     192        osg::notify(osg::NOTICE)<<"  HPOTO  after to->_next = "<<to->_next<<std::endl; 
     193#endif 
     194 
     195    } 
     196 
     197    _pendingOrphanedTextureObjects.clear(); 
     198 
     199    checkConsistency(); 
     200} 
     201 
     202void Texture::TextureObjectSet::flushAllDeletedTextureObjects() 
     203{ 
     204    { 
     205        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex); 
     206        handlePendingOrphandedTextureObjects(); 
     207    } 
     208 
     209    return; 
     210 
     211    for(TextureObjectList::iterator itr = _orphanedTextureObjects.begin(); 
     212        itr != _orphanedTextureObjects.end(); 
     213        ++itr) 
     214    { 
     215 
     216        GLuint id = (*itr)->id(); 
     217 
     218        osg::notify(osg::NOTICE)<<"Deleting textureobject id="<<id<<std::endl; 
     219 
     220        glDeleteTextures( 1L, &id); 
     221    } 
     222    _numOfTextureObjects -= _orphanedTextureObjects.size(); 
     223    _orphanedTextureObjects.clear(); 
     224} 
     225 
     226void Texture::TextureObjectSet::discardAllDeletedTextureObjects() 
     227{ 
     228    _numOfTextureObjects -= _orphanedTextureObjects.size(); 
     229 
     230    // just clear the list as there is nothing else we can do with them when discarding them 
     231    _pendingOrphanedTextureObjects.clear(); 
     232    _orphanedTextureObjects.clear(); 
     233} 
     234 
     235void Texture::TextureObjectSet::flushDeletedTextureObjects(double currentTime, double& availableTime) 
     236{ 
     237    // osg::notify(osg::NOTICE)<<"Texture::TextureObjectSet::flushDeletedTextureObjects(..) Not properly implemented yet"<<std::endl; 
     238 
     239    flushAllDeletedTextureObjects(); 
     240} 
     241 
     242Texture::TextureObject* Texture::TextureObjectSet::takeOrGenerate(Texture* texture) 
     243{ 
     244    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex); 
     245 
     246    if (!_pendingOrphanedTextureObjects.empty()) handlePendingOrphandedTextureObjects(); 
     247 
     248    // see if we can recyle TextureObject from the orphane list 
     249    if (!_orphanedTextureObjects.empty()) 
     250    { 
     251        // take front of orphaned list. 
     252        ref_ptr<TextureObject> to = _orphanedTextureObjects.front(); 
     253 
     254        // remove from orphan list. 
     255        _orphanedTextureObjects.pop_front(); 
     256 
     257        // assign to new texture 
     258        to->setTexture(texture); 
     259 
     260        // place at back of active list 
     261        addToBack(to.get()); 
     262 
     263        osg::notify(osg::NOTICE)<<"Reusing orhpahned TextureObject, _numOfTextureObjects="<<_numOfTextureObjects<<std::endl; 
     264 
     265        return to.release(); 
     266    } 
     267 
     268    // see if we can reuse TextureObject by taking the least recently used active TextureObject 
     269    if ((_parent->getTexturePoolSize()!=0) && 
     270        (_numOfTextureObjects > _parent->getTexturePoolSize()) && 
     271        (_numOfTextureObjects>1) && 
     272        (_head != 0)) 
     273    { 
     274        ref_ptr<TextureObject> to = _head; 
     275 
     276        ref_ptr<Texture> original_texture = to->getTexture(); 
     277 
     278        if (original_texture.valid()) 
     279        { 
     280            original_texture->setTextureObject(_contextID,0); 
     281            osg::notify(osg::NOTICE)<<"Reusing an active TextureObject "<<to.get()<<std::endl; 
     282        } 
     283        else 
     284        { 
     285            osg::notify(osg::NOTICE)<<"Reusing a recently orphaned active TextureObject "<<to.get()<<std::endl; 
     286        } 
     287 
     288 
     289        moveToBack(to.get()); 
     290 
     291        // assign to new texture 
     292        to->setTexture(texture); 
     293 
     294        return to.release(); 
     295 
     296    } 
     297 
     298 
     299    // 
     300    // no TextureObjects available to recyle so have to create one from scratch 
     301    // 
     302    GLuint id; 
     303    glGenTextures( 1L, &id ); 
     304 
     305    TextureObject* to = new Texture::TextureObject(const_cast<Texture*>(texture),id,_profile); 
     306    to->_set = this; 
     307    ++_numOfTextureObjects; 
     308 
     309    addToBack(to); 
     310 
     311    osg::notify(osg::NOTICE)<<"Created new TextureObject, _numOfTextureObjects "<<_numOfTextureObjects<<std::endl; 
     312 
     313    return to; 
     314} 
     315 
     316void Texture::TextureObjectSet::moveToBack(Texture::TextureObject* to) 
     317{ 
     318#if 0 
     319    osg::notify(osg::NOTICE)<<"TextureObjectSet::moveToBack("<<to<<")"<<std::endl; 
     320    osg::notify(osg::NOTICE)<<"    before _head = "<<_head<<std::endl; 
     321    osg::notify(osg::NOTICE)<<"    before _tail = "<<_tail<<std::endl; 
     322    osg::notify(osg::NOTICE)<<"    before to->_previous = "<<to->_previous<<std::endl; 
     323    osg::notify(osg::NOTICE)<<"    before to->_next = "<<to->_next<<std::endl; 
     324#endif 
     325 
     326    // nothing to do if we are already tail 
     327    if (to==_tail) return; 
     328 
     329    // if no tail exists then assign 'to' as tail and head 
     330    if (_tail==0) 
     331    { 
     332        osg::notify(osg::NOTICE)<<"Error ***************** Should not get here !!!!!!!!!"<<std::endl; 
     333        _head = to; 
     334        _tail = to; 
     335        return; 
     336    } 
     337 
     338    if (to->_next==0) 
     339    { 
     340        osg::notify(osg::NOTICE)<<"Error ***************** Should not get here either !!!!!!!!!"<<std::endl; 
     341        return; 
     342    } 
     343 
     344 
     345    if (to->_previous) 
     346    { 
     347        (to->_previous)->_next = to->_next; 
     348    } 
     349    else 
     350    { 
     351        // 'to' is the head, so moving it to the back will mean we need a new head 
     352        if (to->_next) 
     353        { 
     354            _head = to->_next; 
     355        } 
     356    } 
     357 
     358    (to->_next)->_previous = to->_previous; 
     359 
     360    _tail->_next = to; 
     361 
     362    to->_previous = _tail; 
     363    to->_next = 0; 
     364 
     365    _tail = to; 
     366 
     367#if 0 
     368    osg::notify(osg::NOTICE)<<"  m2B   after  _head = "<<_head<<std::endl; 
     369    osg::notify(osg::NOTICE)<<"  m2B   after _tail = "<<_tail<<std::endl; 
     370    osg::notify(osg::NOTICE)<<"  m2B   after to->_previous = "<<to->_previous<<std::endl; 
     371    osg::notify(osg::NOTICE)<<"  m2B   after to->_next = "<<to->_next<<std::endl; 
     372#endif 
     373    checkConsistency(); 
     374} 
     375 
     376void Texture::TextureObjectSet::addToBack(Texture::TextureObject* to) 
     377{ 
     378#if 0 
     379    osg::notify(osg::NOTICE)<<"TextureObjectSet::addToBack("<<to<<")"<<std::endl; 
     380    osg::notify(osg::NOTICE)<<"    before _head = "<<_head<<std::endl; 
     381    osg::notify(osg::NOTICE)<<"    before _tail = "<<_tail<<std::endl; 
     382    osg::notify(osg::NOTICE)<<"    before to->_previous = "<<to->_previous<<std::endl; 
     383    osg::notify(osg::NOTICE)<<"    before to->_next = "<<to->_next<<std::endl; 
     384#endif 
     385 
     386    if (to->_previous !=0 || to->_next !=0) 
     387    { 
     388        moveToBack(to); 
     389    } 
     390    else 
     391    { 
     392        if (_tail) _tail->_next = to; 
     393        to->_previous = _tail; 
     394 
     395        if (!_head) _head = to; 
     396        _tail = to; 
     397    } 
     398#if 0 
     399    osg::notify(osg::NOTICE)<<"  a2B  after  _head = "<<_head<<std::endl; 
     400    osg::notify(osg::NOTICE)<<"  a2B   after _tail = "<<_tail<<std::endl; 
     401    osg::notify(osg::NOTICE)<<"  a2B   after to->_previous = "<<to->_previous<<std::endl; 
     402    osg::notify(osg::NOTICE)<<"  a2B   after to->_next = "<<to->_next<<std::endl; 
     403#endif 
     404    checkConsistency(); 
     405} 
     406 
     407void Texture::TextureObjectSet::orphan(Texture::TextureObject* to) 
     408{ 
     409    // osg::notify(osg::NOTICE)<<"TextureObjectSet::orphan("<<to<<")"<<std::endl; 
     410 
     411    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex); 
     412 
     413    // disconnect from original texture 
     414    to->setTexture(0); 
     415 
     416    // add orphan 'to' to the pending list of orphans, these will then be 
     417    // handled in the handlePendingOrphandedTextureObjects() where the TO's 
     418    // will be removed from the active list, and then placed in the orhpanTextureObject 
     419    // list.  This double buffered approach to handling orphaned TO's is used 
     420    // to avoid having to mutex the process of appling active TO's. 
     421    _pendingOrphanedTextureObjects.push_back(to); 
     422 
     423#if 0 
     424    osg::notify(osg::NOTICE)<<"TextureObjectSet::orphan("<<to<<")  _pendingOrphanedTextureObjects.size()="<<_pendingOrphanedTextureObjects.size()<<std::endl; 
     425    osg::notify(osg::NOTICE)<<"                                    _orphanedTextureObjects.size()="<<_orphanedTextureObjects.size()<<std::endl; 
     426#endif 
     427} 
     428 
     429unsigned int Texture::TextureObjectSet::size() const 
     430{ 
     431    osg::notify(osg::NOTICE)<<"Texture::TextureObjectSet::size() Not implemented yet"<<std::endl; 
     432    return 0; 
     433} 
     434 
     435 
     436Texture::TextureObjectManager::TextureObjectManager(unsigned int contextID): 
     437    _contextID(contextID), 
     438    _texturePoolSize(0) 
     439{ 
     440} 
     441 
     442void Texture::TextureObjectManager::setTexturePoolSize(unsigned int size) 
     443{ 
     444    _texturePoolSize = size; 
     445} 
     446 
     447 
     448Texture::TextureObject* Texture::TextureObjectManager::generateTextureObject(const Texture* texture, GLenum target) 
     449{ 
     450    return generateTextureObject(texture, target, 0, 0, 0, 0, 0, 0); 
     451} 
     452 
     453Texture::TextureObject* Texture::TextureObjectManager::generateTextureObject(const Texture* texture,  
     454                                             GLenum    target, 
     455                                             GLint     numMipmapLevels, 
     456                                             GLenum    internalFormat, 
     457                                             GLsizei   width, 
     458                                             GLsizei   height, 
     459                                             GLsizei   depth, 
     460                                             GLint     border) 
     461{ 
     462    Texture::TextureProfile profile(target,numMipmapLevels,internalFormat,width,height,depth,border); 
     463    osg::ref_ptr<Texture::TextureObjectSet>& tos = _textureSetMap[profile]; 
     464    if (!tos) tos = new Texture::TextureObjectSet(this, profile); 
     465    return tos->takeOrGenerate(const_cast<Texture*>(texture)); 
     466} 
     467 
     468void Texture::TextureObjectManager::handlePendingOrphandedTextureObjects() 
     469{ 
     470    for(TextureSetMap::iterator itr = _textureSetMap.begin(); 
     471        itr != _textureSetMap.end(); 
     472        ++itr) 
     473    { 
     474        (*itr).second->handlePendingOrphandedTextureObjects(); 
     475    } 
     476} 
     477 
     478void Texture::TextureObjectManager::flushAllDeletedTextureObjects() 
     479{ 
     480    for(TextureSetMap::iterator itr = _textureSetMap.begin(); 
     481        itr != _textureSetMap.end(); 
     482        ++itr) 
     483    { 
     484        (*itr).second->flushAllDeletedTextureObjects(); 
     485    } 
     486} 
     487 
     488void Texture::TextureObjectManager::discardAllDeletedTextureObjects() 
     489{ 
     490    for(TextureSetMap::iterator itr = _textureSetMap.begin(); 
     491        itr != _textureSetMap.end(); 
     492        ++itr) 
     493    { 
     494        (*itr).second->discardAllDeletedTextureObjects(); 
     495    } 
     496} 
     497 
     498void Texture::TextureObjectManager::flushDeletedTextureObjects(double currentTime, double& availableTime) 
     499{ 
     500    for(TextureSetMap::iterator itr = _textureSetMap.begin(); 
     501        (itr != _textureSetMap.end()) && (availableTime > 0.0); 
     502        ++itr) 
     503    { 
     504        (*itr).second->flushDeletedTextureObjects(currentTime, availableTime); 
     505    } 
     506} 
     507 
     508void Texture::TextureObjectManager::releaseTextureObject(Texture::TextureObject* to) 
     509{ 
     510    if (to->_set) to->_set->orphan(to); 
     511    else osg::notify(osg::NOTICE)<<"TextureObjectManager::releaseTextureObject(Texture::TextureObject* to) Not implemented yet"<<std::endl; 
     512} 
     513 
     514 
     515osg::ref_ptr<Texture::TextureObjectManager>& Texture::getTextureObjectManager(unsigned int contextID) 
     516{ 
     517    typedef osg::buffered_object< ref_ptr<Texture::TextureObjectManager> > TextureObjectManagerBuffer; 
     518    static TextureObjectManagerBuffer s_TextureObjectManager; 
     519    if (!s_TextureObjectManager[contextID]) s_TextureObjectManager[contextID] = new Texture::TextureObjectManager(contextID); 
     520    return s_TextureObjectManager[contextID]; 
     521} 
     522 
     523 
     524#if USE_NEW_TEXTURE_POOL 
     525 
     526Texture::TextureObject* Texture::generateTextureObject(const Texture* texture, unsigned int contextID, GLenum target) 
     527{ 
     528    return getTextureObjectManager(contextID)->generateTextureObject(texture, target); 
     529} 
     530 
     531Texture::TextureObject* Texture::generateTextureObject(const Texture* texture, unsigned int contextID, 
     532                                             GLenum    target, 
     533                                             GLint     numMipmapLevels, 
     534                                             GLenum    internalFormat, 
     535                                             GLsizei   width, 
     536                                             GLsizei   height, 
     537                                             GLsizei   depth, 
     538                                             GLint     border) 
     539{ 
     540    return getTextureObjectManager(contextID)->generateTextureObject(texture,target,numMipmapLevels,internalFormat,width,height,depth,border); 
     541} 
     542 
     543void Texture::flushAllDeletedTextureObjects(unsigned int contextID) 
     544{ 
     545    getTextureObjectManager(contextID)->flushAllDeletedTextureObjects(); 
     546} 
     547 
     548void Texture::discardAllDeletedTextureObjects(unsigned int contextID) 
     549{ 
     550    getTextureObjectManager(contextID)->discardAllDeletedTextureObjects(); 
     551} 
     552 
     553void Texture::flushDeletedTextureObjects(unsigned int contextID,double currentTime, double& availbleTime) 
     554{ 
     555    getTextureObjectManager(contextID)->flushDeletedTextureObjects(currentTime, availbleTime); 
     556} 
     557 
     558void Texture::releaseTextureObject(unsigned int contextID, Texture::TextureObject* to) 
     559{ 
     560    getTextureObjectManager(contextID)->releaseTextureObject(to); 
     561} 
     562 
     563#else 
     564 
     565/////////////////////////////////////////////////////////////////////////////////////////////////////////// 
     566// 
     567//  Original texture object manager 
     568// 
     569class OriginalTextureObjectManager : public osg::Referenced 
    58570{ 
    59571public: 
    60572 
    61     TextureObjectManager(): 
     573    OriginalTextureObjectManager(): 
    62574        _expiryDelay(0.0) 
    63575    { 
    64         // printf("Constructing TextureObjectManager\n"); 
    65     } 
    66  
    67     ~TextureObjectManager() 
    68     { 
    69         // printf("Destructing TextureObjectManager\n"); 
    70     } 
    71  
    72     virtual Texture::TextureObject* generateTextureObject(unsigned int contextID,GLenum target); 
    73  
    74     virtual Texture::TextureObject* generateTextureObject(unsigned int contextID, 
     576        // printf("Constructing OriginalTextureObjectManager\n"); 
     577    } 
     578 
     579    ~OriginalTextureObjectManager() 
     580    { 
     581        // printf("Destructing OriginalTextureObjectManager\n"); 
     582    } 
     583 
     584    virtual Texture::TextureObject* generateTextureObject(Texture* texture, unsigned int contextID,GLenum target); 
     585 
     586    virtual Texture::TextureObject* generateTextureObject(Texture* texture, unsigned int contextID, 
    75587                                                 GLenum    target, 
    76588                                                 GLint     numMipmapLevels, 
     
    81593                                                 GLint     border); 
    82594 
    83     virtual Texture::TextureObject* reuseTextureObject(unsigned int contextID, 
     595    virtual Texture::TextureObject* reuseTextureObject(Texture* texture, unsigned int contextID, 
    84596                                              GLenum    target, 
    85597                                              GLint     numMipmapLevels, 
     
    90602                                              GLint     border); 
    91603 
    92     inline Texture::TextureObject* reuseOrGenerateTextureObject(unsigned int contextID, 
     604    inline Texture::TextureObject* reuseOrGenerateTextureObject(Texture* texture, unsigned int contextID, 
    93605                                              GLenum    target, 
    94606                                              GLint     numMipmapLevels, 
     
    99611                                              GLint     border) 
    100612    { 
    101         Texture::TextureObject* to = reuseTextureObject(contextID,target,numMipmapLevels,internalFormat,width,height,depth,border); 
     613        Texture::TextureObject* to = reuseTextureObject(texture, contextID,target,numMipmapLevels,internalFormat,width,height,depth,border); 
    102614        if (to) return to; 
    103         else return generateTextureObject(contextID,target,numMipmapLevels,internalFormat,width,height,depth,border); 
     615        else return generateTextureObject(texture, contextID,target,numMipmapLevels,internalFormat,width,height,depth,border); 
    104616    }                                                       
    105  
    106     void addTextureObjects(Texture::TextureObjectListMap& toblm); 
    107  
    108     void addTextureObjectsFrom(Texture& texture); 
    109617 
    110618    void flushAllTextureObjects(unsigned int contextID); 
     
    121629    double                  _expiryDelay; 
    122630 
    123     Texture::TextureObjectListMap    _textureObjectListMap; 
     631    typedef osg::buffered_object<Texture::TextureObjectList> TextureObjectListMap; 
     632    TextureObjectListMap    _textureObjectListMap; 
    124633 
    125634    // mutex to keep access serialized. 
     
    127636}; 
    128637 
    129 } 
    130  
    131638unsigned int Texture::s_numberTextureReusedLastInLastFrame = 0; 
    132639unsigned int Texture::s_numberNewTextureInLastFrame = 0; 
    133640unsigned int Texture::s_numberDeletedTextureInLastFrame = 0; 
    134641 
    135 unsigned int s_minimumNumberOfTextureObjectsToRetainInCache = 0; 
    136  
    137 typedef buffered_value< ref_ptr<Texture::Extensions> > BufferedExtensions; 
    138 static BufferedExtensions s_extensions; 
    139  
    140 static ref_ptr<TextureObjectManager> s_textureObjectManager = new TextureObjectManager; 
    141  
    142 void Texture::setMinimumNumberOfTextureObjectsToRetainInCache(unsigned int minimum) 
    143 { 
    144     s_minimumNumberOfTextureObjectsToRetainInCache = minimum; 
    145 } 
    146  
    147 unsigned int Texture::getMinimumNumberOfTextureObjectsToRetainInCache() 
    148 { 
    149     return s_minimumNumberOfTextureObjectsToRetainInCache; 
    150 } 
    151  
    152 Texture::TextureObject* TextureObjectManager::generateTextureObject(unsigned int /*contextID*/,GLenum target) 
     642 
     643static ref_ptr<OriginalTextureObjectManager> s_textureObjectManager = new OriginalTextureObjectManager; 
     644 
     645 
     646Texture::TextureObject* OriginalTextureObjectManager::generateTextureObject(Texture* texture, unsigned int /*contextID*/,GLenum target) 
    153647{ 
    154648    GLuint id; 
    155649    glGenTextures( 1L, &id ); 
    156650 
    157     return new Texture::TextureObject(id,target); 
     651    return new Texture::TextureObject(texture, id,target); 
    158652} 
    159653 
    160654static int s_number = 0; 
    161655 
    162 Texture::TextureObject* TextureObjectManager::generateTextureObject(unsigned int /*contextID*/, 
     656Texture::TextureObject* OriginalTextureObjectManager::generateTextureObject(Texture* texture, unsigned int /*contextID*/, 
    163657                                                                             GLenum    target, 
    164658                                                                             GLint     numMipmapLevels, 
     
    177671    glGenTextures( 1L, &id ); 
    178672 
    179     return new Texture::TextureObject(id,target,numMipmapLevels,internalFormat,width,height,depth,border); 
    180 } 
    181  
    182 Texture::TextureObject* TextureObjectManager::reuseTextureObject(unsigned int contextID, 
     673    return new Texture::TextureObject(texture, id,target,numMipmapLevels,internalFormat,width,height,depth,border); 
     674} 
     675 
     676Texture::TextureObject* OriginalTextureObjectManager::reuseTextureObject(Texture* texture, unsigned int contextID, 
    183677                                                                             GLenum    target, 
    184678                                                                             GLint     numMipmapLevels, 
     
    206700            ++Texture::s_numberTextureReusedLastInLastFrame; 
    207701 
     702            textureObject->setTexture(texture); 
     703 
    208704            return textureObject; 
    209705        } 
     
    213709} 
    214710 
    215      
    216  
    217 void TextureObjectManager::addTextureObjects(Texture::TextureObjectListMap& toblm) 
    218 { 
    219     OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex); 
    220  
    221     for(unsigned int i=0; i< toblm.size(); ++i) 
    222     { 
    223         Texture::TextureObjectList& tol = _textureObjectListMap[i]; 
    224         tol.insert(tol.end(),toblm[i].begin(),toblm[i].end()); 
    225     } 
    226 } 
    227  
    228 void TextureObjectManager::addTextureObjectsFrom(Texture& texture) 
    229 { 
    230     OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex); 
    231  
    232     texture.takeTextureObjects(_textureObjectListMap); 
    233 } 
    234  
    235 void TextureObjectManager::flushAllTextureObjects(unsigned int contextID) 
     711void OriginalTextureObjectManager::flushAllTextureObjects(unsigned int contextID) 
    236712{ 
    237713    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex); 
     
    246722    { 
    247723        // osg::notify(osg::NOTICE)<<"  deleting texture object "<<(*itr)->_id<<std::endl; 
    248         glDeleteTextures( 1L, &((*itr)->_id)); 
     724        GLuint id = (*itr)->id(); 
     725        glDeleteTextures( 1L, &id); 
    249726    } 
    250727    tol.clear(); 
    251728} 
    252729 
    253 void TextureObjectManager::discardAllTextureObjects(unsigned int contextID) 
     730void OriginalTextureObjectManager::discardAllTextureObjects(unsigned int contextID) 
    254731{ 
    255732    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex); 
     
    259736} 
    260737 
    261 void TextureObjectManager::flushTextureObjects(unsigned int contextID,double currentTime, double& availableTime) 
     738void OriginalTextureObjectManager::flushTextureObjects(unsigned int contextID,double currentTime, double& availableTime) 
    262739{ 
    263740    // if no time available don't try to flush objects. 
     
    283760            ++itr) 
    284761        { 
    285             if ((*itr)->_timeStamp==0.0) (*itr)->_timeStamp=currentTime; 
     762            if ((*itr)->getTimeStamp()==0.0) (*itr)->setTimeStamp(currentTime); 
    286763        } 
    287764 
     
    292769            ) 
    293770        { 
    294             if ((*itr)->_timeStamp<=expiryTime) 
     771            if ((*itr)->getTimeStamp()<=expiryTime) 
    295772            { 
    296773                --s_number; 
    297774                ++Texture::s_numberDeletedTextureInLastFrame; 
    298775 
    299                 glDeleteTextures( 1L, &((*itr)->_id)); 
     776                GLuint id = (*itr)->id(); 
     777                glDeleteTextures( 1L, &id); 
    300778                itr = tol.erase(itr); 
    301779                ++numTexturesDeleted; 
     
    316794 
    317795 
    318 static TextureObjectManager* getTextureObjectManager() 
     796static OriginalTextureObjectManager* getOriginalTextureObjectManager() 
    319797{ 
    320798    return s_textureObjectManager.get(); 
     
    322800 
    323801 
    324 Texture::TextureObject* Texture::generateTextureObject(unsigned int contextID,GLenum target) 
    325 { 
    326     if (getTextureObjectManager()) return getTextureObjectManager()->generateTextureObject(contextID,target); 
     802Texture::TextureObject* Texture::generateTextureObject(const Texture* texture, unsigned int contextID,GLenum target) 
     803{ 
     804    if (getOriginalTextureObjectManager()) return getOriginalTextureObjectManager()->generateTextureObject(const_cast<osg::Texture*>(texture),contextID,target); 
    327805    else return 0; 
    328806} 
    329807 
    330 Texture::TextureObject* Texture::generateTextureObject(unsigned int contextID, 
     808Texture::TextureObject* Texture::generateTextureObject(const Texture* texture, unsigned int contextID, 
    331809                                             GLenum    target, 
    332810                                             GLint     numMipmapLevels, 
     
    337815                                             GLint     border) 
    338816{ 
    339     if (getTextureObjectManager())     
    340         return getTextureObjectManager()->reuseOrGenerateTextureObject(contextID, 
     817    if (getOriginalTextureObjectManager()) 
     818        return getOriginalTextureObjectManager()->reuseOrGenerateTextureObject(const_cast<osg::Texture*>(texture), 
     819                                             contextID, 
    341820                                             target, 
    342821                                             numMipmapLevels, 
     
    352831void Texture::flushAllDeletedTextureObjects(unsigned int contextID) 
    353832{ 
    354     if (getTextureObjectManager()) getTextureObjectManager()->flushAllTextureObjects(contextID); 
     833    if (getOriginalTextureObjectManager()) getOriginalTextureObjectManager()->flushAllTextureObjects(contextID); 
    355834} 
    356835 
    357836void Texture::discardAllDeletedTextureObjects(unsigned int contextID) 
    358837{ 
    359     if (getTextureObjectManager()) getTextureObjectManager()->discardAllTextureObjects(contextID); 
     838    if (getOriginalTextureObjectManager()) getOriginalTextureObjectManager()->discardAllTextureObjects(contextID); 
    360839} 
    361840 
    362841void Texture::flushDeletedTextureObjects(unsigned int contextID,double currentTime, double& availbleTime) 
    363842{ 
    364     if (getTextureObjectManager()) getTextureObjectManager()->flushTextureObjects(contextID, currentTime, availbleTime); 
    365 } 
     843    if (getOriginalTextureObjectManager()) getOriginalTextureObjectManager()->flushTextureObjects(contextID, currentTime, availbleTime); 
     844} 
     845 
     846void Texture::releaseTextureObject(unsigned int contextID, Texture::TextureObject* to) 
     847{ 
     848    if (getOriginalTextureObjectManager()) 
     849    { 
     850        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(getOriginalTextureObjectManager()->_mutex); 
     851        getOriginalTextureObjectManager()->_textureObjectListMap[contextID].push_back(to); 
     852    } 
     853} 
     854 
     855#endif 
     856 
     857 
    366858 
    367859Texture::Texture(): 
     
    5271019void Texture::dirtyTextureObject() 
    5281020{ 
    529     if (getTextureObjectManager()) getTextureObjectManager()->addTextureObjectsFrom(*this); 
    530 } 
    531  
    532 void Texture::takeTextureObjects(Texture::TextureObjectListMap& toblm) 
    533 { 
    534     for(unsigned int i = 0; i<_textureObjectBuffer.size();++i) 
    535     { 
    536         if (_textureObjectBuffer[i].valid())  
    537         { 
    538             //notify(INFO) << "releasing texture "<<toblm[i].size()<<std::endl; 
    539             toblm[i].push_back(_textureObjectBuffer[i]); 
    540         } 
    541     } 
    542     _textureObjectBuffer.setAllElementsTo(0); 
     1021    for(unsigned int i=0; i<_textureObjectBuffer.size();++i) 
     1022    { 
     1023        if (_textureObjectBuffer[i].valid()) 
     1024        { 
     1025            Texture::releaseTextureObject(i, _textureObjectBuffer[i].get()); 
     1026            _textureObjectBuffer[i] = 0; 
     1027        } 
     1028    } 
    5431029} 
    5441030 
     
    14831969            { 
    14841970                osg::FBOExtensions* fbo_ext = osg::FBOExtensions::instance(contextID, true); 
    1485                 fbo_ext->glGenerateMipmapEXT(textureObject->_target); 
     1971                fbo_ext->glGenerateMipmapEXT(textureObject->target()); 
    14861972            } 
    14871973        } 
     
    15212007    { 
    15222008        textureObject->bind(); 
    1523         fbo_ext->glGenerateMipmapEXT(textureObject->_target); 
     2009        fbo_ext->glGenerateMipmapEXT(textureObject->target()); 
    15242010         
    15252011        // inform state that this texture is the current one bound. 
     
    15342020} 
    15352021 
    1536  
    1537 /////////////////////////////////////////////////////////////////////////////////////////////// 
    1538 //  Static map to manage the deletion of texture objects are the right time. 
    1539 ////////////////////////////////////////////////////////////////////////////////////////////// 
    1540 #include <map> 
    1541 #include <set> 
    1542  
    1543  
    15442022void Texture::compileGLObjects(State& state) const 
    15452023{ 
     
    15612039    { 
    15622040        unsigned int contextID = state->getContextID(); 
    1563         if (_textureObjectBuffer[contextID].valid() && getTextureObjectManager())  
    1564         { 
    1565             OpenThreads::ScopedLock<OpenThreads::Mutex> lock(getTextureObjectManager()->_mutex); 
    1566              
    1567             getTextureObjectManager()->_textureObjectListMap[contextID].push_back(_textureObjectBuffer[contextID]); 
     2041        if (_textureObjectBuffer[contextID].valid()) 
     2042        { 
     2043            Texture::releaseTextureObject(contextID, _textureObjectBuffer[contextID].get()); 
     2044 
    15682045            _textureObjectBuffer[contextID] = 0; 
    15692046        } 
     
    18012278} 
    18022279 
     2280} 
  • OpenSceneGraph/trunk/src/osg/Texture1D.cpp

    r9383 r10588  
    151151 
    152152        // we don't have a applyTexImage1D_subload yet so can't reuse.. so just generate a new texture object.         
    153         _textureObjectBuffer[contextID] = textureObject = generateTextureObject(contextID,GL_TEXTURE_1D); 
     153        _textureObjectBuffer[contextID] = textureObject = generateTextureObject(this, contextID, GL_TEXTURE_1D); 
    154154 
    155155        textureObject->bind(); 
     
    172172 
    173173        // we don't have a applyTexImage1D_subload yet so can't reuse.. so just generate a new texture object.         
    174         textureObject = generateTextureObject(contextID,GL_TEXTURE_1D); 
     174        textureObject = generateTextureObject(this, contextID,GL_TEXTURE_1D); 
    175175 
    176176        textureObject->bind(); 
     
    197197    { 
    198198        _textureObjectBuffer[contextID] = textureObject = generateTextureObject( 
    199                 contextID,GL_TEXTURE_1D,_numMipmapLevels,_internalFormat,_textureWidth,1,1,0); 
     199                this,contextID,GL_TEXTURE_1D,_numMipmapLevels,_internalFormat,_textureWidth,1,1,0); 
    200200         
    201201        textureObject->bind(); 
     
    379379    _mag_filter = LINEAR; 
    380380 
    381     _textureObjectBuffer[contextID] = textureObject = generateTextureObject(contextID,GL_TEXTURE_1D); 
     381    _textureObjectBuffer[contextID] = textureObject = generateTextureObject(this, contextID,GL_TEXTURE_1D); 
    382382 
    383383    textureObject->bind(); 
  • OpenSceneGraph/trunk/src/osg/Texture2D.cpp

    r10298 r10588  
    170170    { 
    171171 
    172         _textureObjectBuffer[contextID] = textureObject = generateTextureObject(contextID,GL_TEXTURE_2D); 
     172        _textureObjectBuffer[contextID] = textureObject = generateTextureObject(this, contextID,GL_TEXTURE_2D); 
    173173 
    174174        textureObject->bind(); 
     
    200200 
    201201        _textureObjectBuffer[contextID] = textureObject = generateTextureObject( 
    202                 contextID,GL_TEXTURE_2D,_numMipmapLevels,_internalFormat,_textureWidth,_textureHeight,1,0); 
     202                this, contextID,GL_TEXTURE_2D,_numMipmapLevels,_internalFormat,_textureWidth,_textureHeight,1,0); 
    203203 
    204204        textureObject->bind(); 
     
    224224        getModifiedCount(contextID) = image->getModifiedCount(); 
    225225 
    226         if (_unrefImageDataAfterApply && areAllTextureObjectsLoaded() && image->getDataVariance()==STATIC) 
     226        if (state.getMaxTexturePoolSize()==0 && 
     227            _unrefImageDataAfterApply && 
     228            areAllTextureObjectsLoaded() && 
     229            image->getDataVariance()==STATIC) 
    227230        { 
    228231            Texture2D* non_const_this = const_cast<Texture2D*>(this); 
     
    240243    { 
    241244        _textureObjectBuffer[contextID] = textureObject = generateTextureObject( 
    242                 contextID,GL_TEXTURE_2D,_numMipmapLevels,_internalFormat,_textureWidth,_textureHeight,1,0); 
     245                this, contextID,GL_TEXTURE_2D,_numMipmapLevels,_internalFormat,_textureWidth,_textureHeight,1,0); 
    243246         
    244247        textureObject->bind(); 
     
    313316    // switch off mip-mapping. 
    314317    // 
    315     _textureObjectBuffer[contextID] = textureObject = generateTextureObject(contextID,GL_TEXTURE_2D); 
     318    _textureObjectBuffer[contextID] = textureObject = generateTextureObject(this, contextID,GL_TEXTURE_2D); 
    316319 
    317320    textureObject->bind(); 
  • OpenSceneGraph/trunk/src/osg/Texture2DArray.cpp

    r10337 r10588  
    257257    { 
    258258        // generate texture (i.e. glGenTexture) and apply parameters 
    259         _textureObjectBuffer[contextID] = textureObject = generateTextureObject(contextID, GL_TEXTURE_2D_ARRAY_EXT); 
     259        _textureObjectBuffer[contextID] = textureObject = generateTextureObject(this, contextID, GL_TEXTURE_2D_ARRAY_EXT); 
    260260        textureObject->bind(); 
    261261        applyTexParameters(GL_TEXTURE_2D_ARRAY_EXT, state); 
     
    276276        // create texture object 
    277277        textureObject = generateTextureObject( 
    278                 contextID,GL_TEXTURE_2D_ARRAY_EXT,_numMipmapLevels,_internalFormat,_textureWidth,_textureHeight,_textureDepth,0); 
     278                this, contextID,GL_TEXTURE_2D_ARRAY_EXT,_numMipmapLevels,_internalFormat,_textureWidth,_textureHeight,_textureDepth,0); 
    279279         
    280280        // bind texture 
     
    326326        // generate texture  
    327327        _textureObjectBuffer[contextID] = textureObject = generateTextureObject( 
    328                 contextID, GL_TEXTURE_2D_ARRAY_EXT,_numMipmapLevels,_internalFormat,_textureWidth,_textureHeight,_textureDepth,0); 
     328                this, contextID, GL_TEXTURE_2D_ARRAY_EXT,_numMipmapLevels,_internalFormat,_textureWidth,_textureHeight,_textureDepth,0); 
    329329         
    330330        textureObject->bind(); 
  • OpenSceneGraph/trunk/src/osg/Texture3D.cpp

    r9383 r10588  
    233233    { 
    234234 
    235         _textureObjectBuffer[contextID] = textureObject = generateTextureObject(contextID,GL_TEXTURE_3D); 
     235        _textureObjectBuffer[contextID] = textureObject = generateTextureObject(this, contextID,GL_TEXTURE_3D); 
    236236 
    237237        textureObject->bind(); 
     
    259259        computeRequiredTextureDimensions(state,*_image,_textureWidth, _textureHeight, _textureDepth,_numMipmapLevels); 
    260260 
    261         textureObject = generateTextureObject(contextID,GL_TEXTURE_3D); 
     261        textureObject = generateTextureObject(this, contextID,GL_TEXTURE_3D); 
    262262 
    263263        textureObject->bind(); 
     
    285285    { 
    286286        _textureObjectBuffer[contextID] = textureObject = generateTextureObject( 
    287                 contextID,GL_TEXTURE_3D,_numMipmapLevels,_internalFormat,_textureWidth,_textureHeight,_textureDepth,0); 
     287                this, contextID,GL_TEXTURE_3D,_numMipmapLevels,_internalFormat,_textureWidth,_textureHeight,_textureDepth,0); 
    288288         
    289289        textureObject->bind(); 
  • OpenSceneGraph/trunk/src/osg/TextureCubeMap.cpp

    r8655 r10588  
    231231    else if (_subloadCallback.valid()) 
    232232    { 
    233         _textureObjectBuffer[contextID] = textureObject = generateTextureObject(contextID,GL_TEXTURE_CUBE_MAP); 
     233        _textureObjectBuffer[contextID] = textureObject = generateTextureObject(this, contextID,GL_TEXTURE_CUBE_MAP); 
    234234 
    235235        textureObject->bind(); 
     
    262262 
    263263        textureObject = generateTextureObject( 
    264                 contextID,GL_TEXTURE_CUBE_MAP,_numMipmapLevels,_internalFormat,_textureWidth,_textureHeight,1,0); 
     264                this, contextID,GL_TEXTURE_CUBE_MAP,_numMipmapLevels,_internalFormat,_textureWidth,_textureHeight,1,0); 
    265265         
    266266        textureObject->bind(); 
     
    305305    { 
    306306        _textureObjectBuffer[contextID] = textureObject = generateTextureObject( 
    307                 contextID,GL_TEXTURE_CUBE_MAP,_numMipmapLevels,_internalFormat,_textureWidth,_textureHeight,1,0); 
     307                this, contextID,GL_TEXTURE_CUBE_MAP,_numMipmapLevels,_internalFormat,_textureWidth,_textureHeight,1,0); 
    308308         
    309309        textureObject->bind(); 
  • OpenSceneGraph/trunk/src/osg/TextureRectangle.cpp

    r10092 r10588  
    191191    { 
    192192        // we don't have a applyTexImage1D_subload yet so can't reuse.. so just generate a new texture object.         
    193         _textureObjectBuffer[contextID] = textureObject = generateTextureObject(contextID,GL_TEXTURE_RECTANGLE); 
     193        _textureObjectBuffer[contextID] = textureObject = generateTextureObject(this, contextID,GL_TEXTURE_RECTANGLE); 
    194194 
    195195        textureObject->bind(); 
     
    213213 
    214214        // we don't have a applyTexImage1D_subload yet so can't reuse.. so just generate a new texture object.         
    215         textureObject = generateTextureObject(contextID,GL_TEXTURE_RECTANGLE); 
     215        textureObject = generateTextureObject(this, contextID,GL_TEXTURE_RECTANGLE); 
    216216         
    217217        textureObject->bind(); 
     
    236236    { 
    237237        _textureObjectBuffer[contextID] = textureObject = generateTextureObject( 
    238                 contextID,GL_TEXTURE_RECTANGLE,0,_internalFormat,_textureWidth,_textureHeight,1,0); 
     238                this, contextID,GL_TEXTURE_RECTANGLE,0,_internalFormat,_textureWidth,_textureHeight,1,0); 
    239239         
    240240        textureObject->bind(); 
     
    461461    // switch off mip-mapping. 
    462462    // 
    463     _textureObjectBuffer[contextID] = textureObject = 
    464     generateTextureObject(contextID,GL_TEXTURE_RECTANGLE); 
     463    _textureObjectBuffer[contextID] = textureObject = generateTextureObject(this, contextID,GL_TEXTURE_RECTANGLE); 
    465464 
    466465    textureObject->bind(); 
  • OpenSceneGraph/trunk/src/osgText/Font.cpp

    r9376 r10588  
    591591 
    592592        _textureObjectBuffer[contextID] = textureObject = osg::Texture::generateTextureObject( 
    593                 contextID,GL_TEXTURE_2D,1,GL_ALPHA,getTextureWidth(), getTextureHeight(),1,0); 
     593                this, contextID,GL_TEXTURE_2D,1,GL_ALPHA,getTextureWidth(), getTextureHeight(),1,0); 
    594594 
    595595        textureObject->bind(); 
  • OpenSceneGraph/trunk/src/osgUtil/SceneView.cpp

    r10547 r10588  
    835835    } 
    836836     
    837      
     837 
     838 
    838839} 
    839840 
     
    845846    osg::ref_ptr<RefMatrix> proj = new osg::RefMatrix(projection); 
    846847    osg::ref_ptr<RefMatrix> mv = new osg::RefMatrix(modelview); 
     848 
     849    osg::State* state = _renderInfo.getState(); 
     850    if (state->getMaxTexturePoolSize()!=0) 
     851    { 
     852        osg::Texture::getTextureObjectManager(state->getContextID())->setTexturePoolSize(state->getMaxTexturePoolSize()); 
     853    } 
    847854 
    848855 
  • OpenSceneGraph/trunk/src/osgViewer/CompositeViewer.cpp

    r10520 r10588  
    1 /* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield  
     1/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield 
    22 * 
    3  * This library is open source and may be redistributed and/or modified under   
    4  * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or  
     3 * This library is open source and may be redistributed and/or modified under 
     4 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
    55 * (at your option) any later version.  The full license is in LICENSE file 
    66 * included with this distribution, and on the openscenegraph.org website. 
    7  *  
     7 * 
    88 * This library is distributed in the hope that it will be useful, 
    99 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
    10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  
     10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    1111 * OpenSceneGraph Public License for more details. 
    1212*/ 
     
    8585    _frameStamp->setReferenceTime(0); 
    8686    _frameStamp->setSimulationTime(0); 
    87      
     87 
    8888    _eventVisitor = new osgGA::EventVisitor; 
    8989    _eventVisitor->setFrameStamp(_frameStamp.get()); 
    90      
     90 
    9191    _updateVisitor = new osgUtil::UpdateVisitor; 
    9292    _updateVisitor->setFrameStamp(_frameStamp.get()); 
     
    100100 
    101101    stopThreading(); 
    102      
     102 
    103103    Scenes scenes; 
    104104    getScenes(scenes); 
    105      
     105 
    106106    for(Scenes::iterator sitr = scenes.begin(); 
    107107        sitr != scenes.end(); 
     
    149149 
    150150    bool alreadyRealized = isRealized(); 
    151      
     151 
    152152    bool threadsWereRunning = _threadsRunning; 
    153153    if (threadsWereRunning) stopThreading(); 
    154154 
    155155    _views.push_back(view); 
    156      
     156 
    157157    view->_viewerBase = this; 
    158      
     158 
    159159    if (view->getSceneData()) 
    160     {         
     160    { 
    161161        // make sure that existing scene graph objects are allocated with thread safe ref/unref 
    162         if (getThreadingModel()!=ViewerBase::SingleThreaded)  
     162        if (getThreadingModel()!=ViewerBase::SingleThreaded) 
    163163        { 
    164164            view->getSceneData()->setThreadSafeRefUnref(true); 
    165165        } 
    166          
     166 
    167167        // update the scene graph so that it has enough GL object buffer memory for the graphics contexts that will be using it. 
    168168        view->getSceneData()->resizeGLObjectBuffers(osg::DisplaySettings::instance()->getMaxNumberOfGraphicsContexts()); 
     
    170170 
    171171    view->setFrameStamp(_frameStamp.get()); 
    172      
     172 
    173173    if (alreadyRealized) 
    174174    { 
     
    197197 
    198198    } 
    199      
     199 
    200200    if (threadsWereRunning) startThreading(); 
    201201} 
     
    237237        if ((*citr)->isRealized()) ++numRealizedWindows; 
    238238    } 
    239      
     239 
    240240    return numRealizedWindows > 0; 
    241241} 
     
    281281        } 
    282282    } 
    283          
     283 
    284284    setReleaseContextAtEndOfFrameHint(false); 
    285285 
     
    290290{ 
    291291    _startTick = tick; 
    292      
     292 
    293293    for(RefViews::iterator vitr = _views.begin(); 
    294294        vitr != _views.end(); 
     
    297297        (*vitr)->setStartTick(tick); 
    298298    } 
    299      
     299 
    300300    Contexts contexts; 
    301301    getContexts(contexts,false); 
     
    381381{ 
    382382    cameras.clear(); 
    383      
     383 
    384384    for(RefViews::iterator vitr = _views.begin(); 
    385385        vitr != _views.end(); 
     
    388388        View* view = vitr->get(); 
    389389 
    390         if (view->getCamera() &&  
     390        if (view->getCamera() && 
    391391            (!onlyActive || (view->getCamera()->getGraphicsContext() && view->getCamera()->getGraphicsContext()->valid())) ) cameras.push_back(view->getCamera()); 
    392392 
     
    400400    } 
    401401} 
    402   
     402 
    403403void CompositeViewer::getScenes(Scenes& scenes, bool onlyValid) 
    404404{ 
     
    442442    OperationThreads operationThreads; 
    443443    getOperationThreads(operationThreads); 
    444      
     444 
    445445    for(OperationThreads::iterator itr = operationThreads.begin(); 
    446446        itr != operationThreads.end(); 
     
    452452    Scenes scenes; 
    453453    getScenes(scenes); 
    454      
     454 
    455455    for(Scenes::iterator sitr = scenes.begin(); 
    456456        sitr != scenes.end(); 
     
    477477{ 
    478478    threads.clear(); 
    479      
     479 
    480480    Contexts contexts; 
    481481    getContexts(contexts); 
     
    485485    { 
    486486        osg::GraphicsContext* gc = *gcitr; 
    487         if (gc->getGraphicsThread() &&  
     487        if (gc->getGraphicsThread() && 
    488488            (!onlyActive || gc->getGraphicsThread()->isRunning()) ) 
    489489        { 
     
    491491        } 
    492492    } 
    493      
     493 
    494494    Cameras cameras; 
    495495    getCameras(cameras); 
     
    499499    { 
    500500        osg::Camera* camera = *citr; 
    501         if (camera->getCameraThread() &&  
     501        if (camera->getCameraThread() && 
    502502            (!onlyActive || camera->getCameraThread()->isRunning()) ) 
    503503        { 
     
    505505        } 
    506506    } 
    507      
     507 
    508508} 
    509509 
     
    511511{ 
    512512    //osg::notify(osg::INFO)<<"CompositeViewer::realize()"<<std::endl; 
    513      
     513 
    514514    setCameraWithFocus(0); 
    515515 
     
    523523    Contexts contexts; 
    524524    getContexts(contexts); 
    525      
     525 
    526526    if (contexts.empty()) 
    527527    { 
    528528        osg::notify(osg::INFO)<<"CompositeViewer::realize() - No valid contexts found, setting up view across all screens."<<std::endl; 
    529      
    530         // no windows are already set up so set up a default view         
     529 
     530        // no windows are already set up so set up a default view 
    531531        _views[0]->setUpViewAcrossAllScreens(); 
    532          
     532 
    533533        getContexts(contexts); 
    534534    } 
     
    540540        return; 
    541541    } 
    542      
     542 
     543    unsigned int maxTexturePoolSize = osg::DisplaySettings::instance()->getMaxTexturePoolSize(); 
     544    unsigned int maxVBOPoolSize = osg::DisplaySettings::instance()->getMaxVBOPoolSize(); 
     545    unsigned int maxFBOPoolSize = osg::DisplaySettings::instance()->getMaxFBOPoolSize(); 
     546 
    543547    for(Contexts::iterator citr = contexts.begin(); 
    544548        citr != contexts.end(); 
     
    546550    { 
    547551        osg::GraphicsContext* gc = *citr; 
     552 
     553        // set the pool sizes, 0 the default will result in no GL object pools. 
     554        gc->getState()->setMaxTexturePoolSize(maxTexturePoolSize); 
     555        gc->getState()->setMaxVBOPoolSize(maxVBOPoolSize); 
     556        gc->getState()->setMaxFBOPoolSize(maxFBOPoolSize); 
     557 
    548558        gc->realize(); 
    549          
    550         if (_realizeOperation.valid() && gc->valid())  
     559 
     560        if (_realizeOperation.valid() && gc->valid()) 
    551561        { 
    552562            gc->makeCurrent(); 
    553              
     563 
    554564            (*_realizeOperation)(gc); 
    555              
     565 
    556566            gc->releaseContext(); 
    557567        } 
    558568    } 
    559      
     569 
    560570    // attach contexts to _incrementalCompileOperation if attached. 
    561571    if (_incrementalCompileOperation) _incrementalCompileOperation->assignContexts(contexts); 
     
    572582            if (gw) 
    573583            { 
    574                 gw->grabFocusIfPointerInWindow();     
    575             } 
    576         } 
    577     } 
    578      
    579      
     584                gw->grabFocusIfPointerInWindow(); 
     585            } 
     586        } 
     587    } 
     588 
     589 
    580590    startThreading(); 
    581591 
     
    600610                gc->getGraphicsThread()->setProcessorAffinity(processNum % numProcessors); 
    601611                gc->getGraphicsThread()->startThread(); 
    602                  
     612 
    603613                ++processNum; 
    604614            } 
     
    611621{ 
    612622    if (_done) return; 
    613      
     623 
    614624    double prevousReferenceTime = _frameStamp->getReferenceTime(); 
    615625    int previousFrameNumber = _frameStamp->getFrameNumber(); 
     
    628638        _frameStamp->setSimulationTime(simulationTime); 
    629639    } 
    630      
     640 
    631641    if (getViewerStats() && getViewerStats()->collectStats("frame_rate")) 
    632642    { 
     
    653663        { 
    654664            View* view = vitr->get(); 
    655             if (view->containsCamera(camera))  
     665            if (view->containsCamera(camera)) 
    656666            { 
    657667                _viewWithFocus = view; 
     
    667677{ 
    668678    if (_done) return; 
    669      
     679 
    670680    if (_views.empty()) return; 
    671      
     681 
    672682    double beginEventTraversal = osg::Timer::instance()->delta_s(_startTick, osg::Timer::instance()->tick()); 
    673683 
    674684    // osg::notify(osg::NOTICE)<<"CompositeViewer::frameEventTraversal()."<<std::endl; 
    675      
     685 
    676686    // need to copy events from the GraphicsWindow's into local EventQueue; 
    677      
     687 
    678688    typedef std::map<osgViewer::View*, osgGA::EventQueue::Events> ViewEventsMap; 
    679689    ViewEventsMap viewEventsMap; 
    680      
     690 
    681691    Contexts contexts; 
    682692    getContexts(contexts); 
     
    686696 
    687697    osgViewer::View* masterView = getViewWithFocus() ? getViewWithFocus() : _views[0].get(); 
    688      
     698 
    689699    osg::Camera* masterCamera = masterView->getCamera(); 
    690     osgGA::GUIEventAdapter* eventState = masterView->getEventQueue()->getCurrentEventState();  
     700    osgGA::GUIEventAdapter* eventState = masterView->getEventQueue()->getCurrentEventState(); 
    691701    osg::Matrix masterCameraVPW = masterCamera->getViewMatrix() * masterCamera->getProjectionMatrix(); 
    692     if (masterCamera->getViewport())  
     702    if (masterCamera->getViewport()) 
    693703    { 
    694704        osg::Viewport* viewport = masterCamera->getViewport(); 
     
    704714        { 
    705715            gw->checkEvents(); 
    706              
     716 
    707717            osgGA::EventQueue::Events gw_events; 
    708718            gw->getEventQueue()->takeEvents(gw_events); 
    709              
     719 
    710720            osgGA::EventQueue::Events::iterator itr; 
    711721            for(itr = gw_events.begin(); 
     
    714724            { 
    715725                osgGA::GUIEventAdapter* event = itr->get(); 
    716                  
     726 
    717727                //osg::notify(osg::NOTICE)<<"event->getGraphicsContext()="<<event->getGraphicsContext()<<std::endl; 
    718                  
     728 
    719729                bool pointerEvent = false; 
    720730 
    721731                float x = event->getX(); 
    722732                float y = event->getY(); 
    723                  
     733 
    724734                bool invert_y = event->getMouseYOrientation()==osgGA::GUIEventAdapter::Y_INCREASING_DOWNWARDS; 
    725735                if (invert_y && gw->getTraits()) y = gw->getTraits()->height - y; 
    726                  
     736 
    727737                switch(event->getEventType()) 
    728738                { 
     
    736746                    { 
    737747                        pointerEvent = true; 
    738                          
     748 
    739749                        if (event->getEventType()!=osgGA::GUIEventAdapter::DRAG || !getCameraWithFocus()) 
    740750                        { 
     
    745755                            { 
    746756                                osg::Camera* camera = *citr; 
    747                                 if (camera->getView() &&  
     757                                if (camera->getView() && 
    748758                                    camera->getAllowEventFocus() && 
    749759                                    camera->getRenderTargetImplementation()==osg::Camera::FRAME_BUFFER) 
    750760                                { 
    751761                                    osg::Viewport* viewport = camera ? camera->getViewport() : 0; 
    752                                     if (viewport &&  
     762                                    if (viewport && 
    753763                                        x >= viewport->x() && y >= viewport->y() && 
    754764                                        x <= (viewport->x()+viewport->width()) && y <= (viewport->y()+viewport->height()) ) 
     
    760770                                        { 
    761771                                            eventState->setGraphicsContext(gw); 
    762                                             eventState->setInputRange( viewport->x(), viewport->y(),  
    763                                                                        viewport->x()+viewport->width(), 
    764                                                                        viewport->y()+viewport->height()); 
     772                                            eventState->setInputRange( viewport->x(), viewport->y(), 
     773                                                                    viewport->x()+viewport->width(), 
     774                                                                    viewport->y()+viewport->height()); 
    765775 
    766776                                        } 
     
    775785                                            masterView = getViewWithFocus(); 
    776786                                            masterCamera = masterView->getCamera(); 
    777                                             eventState = masterView->getEventQueue()->getCurrentEventState();  
     787                                            eventState = masterView->getEventQueue()->getCurrentEventState(); 
    778788                                            masterCameraVPW = masterCamera->getViewMatrix() * masterCamera->getProjectionMatrix(); 
    779789 
    780                                             if (masterCamera->getViewport())  
     790                                            if (masterCamera->getViewport()) 
    781791                                            { 
    782792                                                osg::Viewport* viewport = masterCamera->getViewport(); 
     
    789799                                        { 
    790800                                            eventState->setGraphicsContext(gw); 
    791                                             eventState->setInputRange( viewport->x(), viewport->y(),  
    792                                                                        viewport->x()+viewport->width(), 
    793                                                                        viewport->y()+viewport->height()); 
     801                                            eventState->setInputRange( viewport->x(), viewport->y(), 
     802                                                                    viewport->x()+viewport->width(), 
     803                                                                    viewport->y()+viewport->height()); 
    794804 
    795805                                        } 
     
    802812                            } 
    803813                        } 
    804                          
     814 
    805815                        break; 
    806816                    } 
     
    808818                        break; 
    809819                } 
    810                  
     820 
    811821                if (pointerEvent) 
    812822                { 
     
    822832 
    823833                        x = new_coord.x(); 
    824                         y = new_coord.y();                                 
     834                        y = new_coord.y(); 
    825835 
    826836                        event->setInputRange(eventState->getXmin(), eventState->getYmin(), eventState->getXmax(), eventState->getYmax()); 
     
    830840 
    831841                    } 
    832                     // pass along the new pointer events details to the eventState of the viewer  
     842                    // pass along the new pointer events details to the eventState of the viewer 
    833843                    eventState->setX(x); 
    834844                    eventState->setY(y); 
     
    858868                        bool wasThreading = areThreadsRunning(); 
    859869                        if (wasThreading) stopThreading(); 
    860                          
     870 
    861871                        gw->close(); 
    862872 
     
    874884        } 
    875885    } 
    876      
     886 
    877887 
    878888    // osg::notify(osg::NOTICE)<<"mouseEventState Xmin = "<<eventState->getXmin()<<" Ymin="<<eventState->getYmin()<<" xMax="<<eventState->getXmax()<<" Ymax="<<eventState->getYmax()<<std::endl; 
     
    887897        view->getEventQueue()->takeEvents(viewEventsMap[view]); 
    888898    } 
    889      
     899 
    890900 
    891901    // osg::notify(osg::NOTICE)<<"Events "<<events.size()<<std::endl; 
    892      
     902 
    893903    if ((_keyEventSetsDone!=0) || _quitEventSetsDone) 
    894904    { 
     
    918928        } 
    919929    } 
    920          
     930 
    921931    if (_done) return; 
    922932 
     
    932942            View* view = veitr->first; 
    933943            _eventVisitor->setActionAdapter(view); 
    934              
     944 
    935945            if (view->getSceneData()) 
    936             {             
     946            { 
    937947                for(osgGA::EventQueue::Events::iterator itr = veitr->second.begin(); 
    938948                    itr != veitr->second.end(); 
     
    964974            } 
    965975        } 
    966          
     976 
    967977    } 
    968978 
     
    972982    { 
    973983        View* view = veitr->first; 
    974          
     984 
    975985        for(osgGA::EventQueue::Events::iterator itr = veitr->second.begin(); 
    976986            itr != veitr->second.end(); 
     
    9931003    { 
    9941004        View* view = veitr->first; 
    995          
     1005 
    9961006        for(osgGA::EventQueue::Events::iterator itr = veitr->second.begin(); 
    9971007            itr != veitr->second.end(); 
     
    10071017    } 
    10081018 
    1009      
     1019 
    10101020 
    10111021    if (getViewerStats() && getViewerStats()->collectStats("event")) 
     
    10241034{ 
    10251035    if (_done) return; 
    1026      
     1036 
    10271037    double beginUpdateTraversal = osg::Timer::instance()->delta_s(_startTick, osg::Timer::instance()->tick()); 
    10281038 
     
    10851095 
    10861096 
    1087         if (view->getCameraManipulator())  
     1097        if (view->getCameraManipulator()) 
    10881098        { 
    10891099            view->setFusionDistance( view->getCameraManipulator()->getFusionDistanceMode(), 
    1090                                      view->getCameraManipulator()->getFusionDistanceValue() ); 
    1091                                        
     1100                                    view->getCameraManipulator()->getFusionDistanceValue() ); 
     1101 
    10921102            view->getCamera()->setViewMatrix( view->getCameraManipulator()->getInverseMatrix()); 
    10931103        } 
     
    10951105 
    10961106    } 
    1097      
     1107 
    10981108    if (getViewerStats() && getViewerStats()->collectStats("update")) 
    10991109    { 
  • OpenSceneGraph/trunk/src/osgViewer/Renderer.cpp

    r10316 r10588  
    1 /* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield  
     1/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield 
    22 * 
    3  * This library is open source and may be redistributed and/or modified under   
    4  * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or  
     3 * This library is open source and may be redistributed and/or modified under 
     4 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
    55 * (at your option) any later version.  The full license is in LICENSE file 
    66 * included with this distribution, and on the openscenegraph.org website. 
    7  *  
     7 * 
    88 * This library is distributed in the hope that it will be useful, 
    99 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
    10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  
     10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    1111 * OpenSceneGraph Public License for more details. 
    1212*/ 
     
    101101    GLuint query = createQueryObject(); 
    102102    _extensions->glBeginQuery(GL_TIME_ELAPSED, query); 
    103     _queryFrameNumberList.push_back(QueryFrameNumberPair(query, frameNumber));         
     103    _queryFrameNumberList.push_back(QueryFrameNumberPair(query, frameNumber)); 
    104104} 
    105105 
     
    144144 
    145145    if (_queue.empty()) _block.set(false); 
    146      
     146 
    147147    return front; 
    148148} 
     
    200200    _sceneView[0]->setGlobalStateSet(stateset); 
    201201    _sceneView[1]->setGlobalStateSet(stateset); 
    202      
     202 
    203203    _sceneView[0]->setDefaults(sceneViewOptions); 
    204204    _sceneView[1]->setDefaults(sceneViewOptions); 
     
    214214    _availableQueue.add(_sceneView[0].get()); 
    215215    _availableQueue.add(_sceneView[1].get()); 
    216          
     216 
    217217    DEBUG_MESSAGE<<"_availableQueue.size()="<<_availableQueue._queue.size()<<std::endl; 
    218218 
     
    241241        sceneView->setGlobalStateSet(stateset); 
    242242    } 
    243      
     243 
    244244    osg::GraphicsContext* context = _camera->getGraphicsContext(); 
    245245    osg::State* state = context ? context->getState() : 0; 
    246     if (sceneView->getState()!=state)  
     246    if (sceneView->getState()!=state) 
    247247    { 
    248248        sceneView->setState(state); 
     
    256256    osgDB::ImagePager* imagePager = view ? view->getImagePager() : 0; 
    257257    sceneView->getCullVisitor()->setImageRequestHandler(imagePager); 
    258      
     258 
    259259    sceneView->setFrameStamp(view ? view->getFrameStamp() : state->getFrameStamp()); 
    260      
     260 
    261261    if (databasePager) databasePager->setCompileGLObjectsForContextID(state->getContextID(), true); 
    262      
     262 
    263263    osg::DisplaySettings* ds = _camera->getDisplaySettings() ?  _camera->getDisplaySettings() : 
    264264                               ((view &&view->getDisplaySettings()) ?  view->getDisplaySettings() :  osg::DisplaySettings::instance()); 
     
    274274 
    275275    _compileOnNextDraw = false; 
    276      
     276 
    277277    osgUtil::SceneView* sceneView = _sceneView[0].get(); 
    278278    if (!sceneView || _done) return; 
    279279 
    280     if (sceneView->getSceneData())  
     280    if (sceneView->getSceneData()) 
    281281    { 
    282282        osgUtil::GLObjectsVisitor glov; 
     
    330330        { 
    331331            DEBUG_MESSAGE<<"Collecting rendering stats"<<std::endl; 
    332          
     332 
    333333            stats->setAttribute(frameNumber, "Cull traversal begin time", osg::Timer::instance()->delta_s(_startTick, beforeCullTick)); 
    334334            stats->setAttribute(frameNumber, "Cull traversal end time", osg::Timer::instance()->delta_s(_startTick, afterCullTick)); 
     
    340340            osgUtil::Statistics sceneStats; 
    341341            sceneView->getStats(sceneStats); 
    342              
     342 
    343343            stats->setAttribute(frameNumber, "Visible vertex count", static_cast<double>(sceneStats._vertexCount)); 
    344344            stats->setAttribute(frameNumber, "Visible number of drawables", static_cast<double>(sceneStats.numDrawables)); 
     
    360360            stats->setAttribute(frameNumber, "Visible number of GL_QUAD_STRIP", static_cast<double>(pcm[GL_QUAD_STRIP])); 
    361361            stats->setAttribute(frameNumber, "Visible number of GL_POLYGON", static_cast<double>(pcm[GL_POLYGON])); 
    362              
     362 
    363363        } 
    364364 
     
    394394            compile(); 
    395395        } 
    396      
     396 
    397397        osgViewer::View* view = dynamic_cast<osgViewer::View*>(_camera->getView()); 
    398398        osgDB::DatabasePager* databasePager = view ? view->getDatabasePager() : 0; 
     
    433433        bool acquireGPUStats = stats && _timerQuerySupported && stats->collectStats("gpu"); 
    434434 
    435         if (acquireGPUStats)  
     435        if (acquireGPUStats) 
    436436        { 
    437437            checkQuery(stats); 
     
    439439 
    440440        // do draw traversal 
    441         if (acquireGPUStats)  
     441        if (acquireGPUStats) 
    442442        { 
    443443            checkQuery(stats); 
     
    446446 
    447447        osg::Timer_t beforeDrawTick; 
    448          
    449          
     448 
     449 
    450450        bool serializeDraw = sceneView->getDisplaySettings()->getSerializeDrawDispatch(); 
    451451 
    452         if (serializeDraw)  
     452        if (serializeDraw) 
    453453        { 
    454454            OpenThreads::ScopedLock<OpenThreads::Mutex> lock(s_drawSerializerMutex); 
     
    470470        // now flush delete OpenGL objects and compile any objects as required by the DatabasePager 
    471471        flushAndCompile(dispatchTime, sceneView, databasePager, compileThread); 
    472      
     472 
    473473        if (acquireGPUStats) 
    474474        { 
     
    478478 
    479479        //glFlush(); 
    480          
     480 
    481481        osg::Timer_t afterDrawTick = osg::Timer::instance()->tick(); 
    482482 
     
    509509        return; 
    510510    } 
    511      
     511 
    512512    updateSceneView(sceneView); 
    513513 
     
    541541    bool acquireGPUStats = stats && _timerQuerySupported && stats->collectStats("gpu"); 
    542542 
    543     if (acquireGPUStats)  
     543    if (acquireGPUStats) 
    544544    { 
    545545        checkQuery(stats); 
     
    577577 
    578578    // do draw traversal 
    579     if (acquireGPUStats)  
     579    if (acquireGPUStats) 
    580580    { 
    581581        checkQuery(stats); 
     
    587587    bool serializeDraw = sceneView->getDisplaySettings()->getSerializeDrawDispatch(); 
    588588 
    589     if (serializeDraw)  
     589    if (serializeDraw) 
    590590    { 
    591591        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(s_drawSerializerMutex); 
    592          
     592 
    593593        beforeDrawTick = osg::Timer::instance()->tick(); 
    594594        sceneView->draw(); 
     
    634634void Renderer::flushAndCompile(double currentElapsedFrameTime, osgUtil::SceneView* sceneView, osgDB::DatabasePager* databasePager, osg::GraphicsThread* compileThread) 
    635635{ 
    636      
     636 
    637637    double targetFrameRate = _targetFrameRate; 
    638638    double minimumTimeAvailableForGLCompileAndDeletePerFrame = _minimumTimeAvailableForGLCompileAndDeletePerFrame; 
     
    643643        minimumTimeAvailableForGLCompileAndDeletePerFrame = std::min(minimumTimeAvailableForGLCompileAndDeletePerFrame, databasePager->getMinimumTimeAvailableForGLCompileAndDeletePerFrame()); 
    644644    } 
    645      
     645 
    646646    double targetFrameTime = 1.0/targetFrameRate; 
    647647 
     
    667667    } 
    668668 
    669     // if any time left over from flush add this to compile time.         
     669    // if any time left over from flush add this to compile time. 
    670670    if (flushTime>0.0) compileTime += flushTime; 
    671671 
  • OpenSceneGraph/trunk/src/osgViewer/Viewer.cpp

    r10520 r10588  
    1 /* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield  
     1/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield 
    22 * 
    3  * This library is open source and may be redistributed and/or modified under   
    4  * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or  
     3 * This library is open source and may be redistributed and/or modified under 
     4 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
    55 * (at your option) any later version.  The full license is in LICENSE file 
    66 * included with this distribution, and on the openscenegraph.org website. 
    7  *  
     7 * 
    88 * This library is distributed in the hope that it will be useful, 
    99 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
    10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  
     10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    1111 * OpenSceneGraph Public License for more details. 
    1212*/ 
     
    6666    //arguments.getApplicationUsage()->addCommandLineOption("--collar",""); 
    6767    //arguments.getApplicationUsage()->addCommandLineOption("--im",""); 
    68      
     68 
    6969    std::string filename; 
    7070    bool readConfig = false; 
     
    140140        while (arguments.read("--wow-M",wow_M)) {} 
    141141        while (arguments.read("--wow-C",wow_C)) {} 
    142              
     142 
    143143        if (screenNum<0) screenNum = 0; 
    144          
     144 
    145145        setUpViewForWoWVxDisplay( screenNum, wow_content, wow_factor, wow_offset, wow_Zd, wow_vz, wow_M, wow_C ); 
    146146    } 
     
    175175        if (screenNum>=0) setUpViewInWindow(x, y, width, height, screenNum); 
    176176        else setUpViewInWindow(x,y,width,height); 
    177          
     177 
    178178    } 
    179179    else if (screenNum>=0) 
     
    195195    _eventVisitor->setActionAdapter(this); 
    196196    _eventVisitor->setFrameStamp(_frameStamp.get()); 
    197      
     197 
    198198    _updateVisitor = new osgUtil::UpdateVisitor; 
    199199    _updateVisitor->setFrameStamp(_frameStamp.get()); 
     
    214214 
    215215    stopThreading(); 
    216      
     216 
    217217    if (_scene.valid() && _scene->getDatabasePager()) 
    218218    { 
     
    231231        (*citr)->close(); 
    232232    } 
    233      
     233 
    234234    //osg::notify(osg::NOTICE)<<"finish Viewer::~Viewer()"<<std::endl; 
    235      
     235 
    236236    getAllThreads(threads); 
    237237 
     
    243243{ 
    244244    osgViewer::View::take(rhs); 
    245      
     245 
    246246#if 1 
    247247    osgViewer::Viewer* rhs_viewer = dynamic_cast<osgViewer::Viewer*>(&rhs); 
     
    278278        rhs_viewer->_currentContext = 0; 
    279279    } 
    280 #endif     
     280#endif 
    281281} 
    282282 
     
    284284{ 
    285285    osg::notify(osg::INFO)<<"Viewer::readConfiguration("<<filename<<")"<<std::endl; 
    286      
     286 
    287287    osg::ref_ptr<osg::Object> object = osgDB::readObjectFile(filename); 
    288     if (!object)  
     288    if (!object) 
    289289    { 
    290290        //osg::notify(osg::NOTICE)<<"Error: Unable to load configuration file \""<<filename<<"\""<<std::endl; 
    291291        return false; 
    292292    } 
    293      
     293 
    294294    CompositeViewer* compositeViewer = dynamic_cast<CompositeViewer*>(object.get()); 
    295295    if (compositeViewer) 
     
    298298        return false; 
    299299    } 
    300      
     300 
    301301    View* view = dynamic_cast<osgViewer::View*>(object.get()); 
    302302    if (view) 
     
    307307    } 
    308308    else 
    309     {     
     309    { 
    310310        osg::notify(osg::NOTICE)<<"Error: Config file \""<<filename<<"\" does not contain a valid Viewer configuration."<<std::endl; 
    311311        return false; 
     
    327327        if ((*citr)->isRealized()) ++numRealizedWindows; 
    328328    } 
    329      
     329 
    330330    return numRealizedWindows > 0; 
    331331} 
     
    420420{ 
    421421    //osg::notify(osg::INFO)<<"Viewer::realize()"<<std::endl; 
    422      
     422 
    423423    setCameraWithFocus(0); 
    424424 
    425425    Contexts contexts; 
    426426    getContexts(contexts); 
    427      
     427 
    428428    if (contexts.empty()) 
    429429    { 
    430430        osg::notify(osg::INFO)<<"Viewer::realize() - No valid contexts found, setting up view across all screens."<<std::endl; 
    431      
    432         // no windows are already set up so set up a default view         
    433          
     431 
     432        // no windows are already set up so set up a default view 
     433 
    434434        const char* ptr = 0; 
    435435        if ((ptr = getenv("OSG_CONFIG_FILE")) != 0) 
     
    467467            } 
    468468        } 
    469          
     469 
    470470        getContexts(contexts); 
    471471    } 
     
    477477        return; 
    478478    } 
    479      
     479 
     480    unsigned int maxTexturePoolSize = osg::DisplaySettings::instance()->getMaxTexturePoolSize(); 
     481    if (_camera->getDisplaySettings()) maxTexturePoolSize = std::max(maxTexturePoolSize, _camera->getDisplaySettings()->getMaxTexturePoolSize()); 
     482    if (_displaySettings.valid()) maxTexturePoolSize = std::max(maxTexturePoolSize, _displaySettings->getMaxTexturePoolSize()); 
     483 
     484    unsigned int maxVBOPoolSize = osg::DisplaySettings::instance()->getMaxVBOPoolSize(); 
     485    if (_displaySettings.valid()) maxVBOPoolSize = std::max(maxVBOPoolSize, _displaySettings->getMaxVBOPoolSize()); 
     486    if (_camera->getDisplaySettings()) maxVBOPoolSize = std::max(maxVBOPoolSize, _camera->getDisplaySettings()->getMaxVBOPoolSize()); 
     487 
     488    unsigned int maxFBOPoolSize = osg::DisplaySettings::instance()->getMaxFBOPoolSize(); 
     489    if (_displaySettings.valid()) maxFBOPoolSize = std::max(maxFBOPoolSize, _displaySettings->getMaxFBOPoolSize()); 
     490    if (_camera->getDisplaySettings()) maxFBOPoolSize = std::max(maxFBOPoolSize, _camera->getDisplaySettings()->getMaxFBOPoolSize()); 
     491 
    480492    for(Contexts::iterator citr = contexts.begin(); 
    481493        citr != contexts.end(); 
     
    483495    { 
    484496        osg::GraphicsContext* gc = *citr; 
     497 
     498        // set the pool sizes, 0 the default will result in no GL object pools. 
     499        gc->getState()->setMaxTexturePoolSize(maxTexturePoolSize); 
     500        gc->getState()->setMaxVBOPoolSize(maxVBOPoolSize); 
     501        gc->getState()->setMaxFBOPoolSize(maxFBOPoolSize); 
     502 
    485503        gc->realize(); 
    486          
     504 
    487505        if (_realizeOperation.valid() && gc->valid()) 
    488506        { 
    489507            gc->makeCurrent(); 
    490              
     508 
    491509            (*_realizeOperation)(gc); 
    492              
     510 
    493511            gc->releaseContext(); 
    494512        } 
     
    508526            if (gw) 
    509527            { 
    510                 gw->grabFocusIfPointerInWindow();     
    511             } 
    512         } 
    513     } 
    514      
     528                gw->grabFocusIfPointerInWindow(); 
     529            } 
     530        } 
     531    } 
     532 
    515533    // initialize the global timer to be relative to the current time. 
    516534    osg::Timer::instance()->setStartTick(); 
     
    520538 
    521539    setUpThreading(); 
    522      
     540 
    523541    if (osg::DisplaySettings::instance()->getCompileContextsHint()) 
    524542    { 
     
    535553                gc->getGraphicsThread()->setProcessorAffinity(processNum % numProcessors); 
    536554                gc->getGraphicsThread()->startThread(); 
    537                  
     555 
    538556                ++processNum; 
    539557            } 
    540558        } 
    541559    } 
    542      
     560 
    543561} 
    544562 
     
    564582        _frameStamp->setSimulationTime(simulationTime); 
    565583    } 
    566      
     584 
    567585    if (getViewerStats() && getViewerStats()->collectStats("frame_rate")) 
    568586    { 
     
    591609 
    592610    // osg::notify(osg::NOTICE)<<"Viewer::frameEventTraversal()."<<std::endl; 
    593      
     611 
    594612    // need to copy events from the GraphicsWindow's into local EventQueue; 
    595613    osgGA::EventQueue::Events events; 
     
    598616    getContexts(contexts); 
    599617 
    600     osgGA::GUIEventAdapter* eventState = getEventQueue()->getCurrentEventState();  
     618    osgGA::GUIEventAdapter* eventState = getEventQueue()->getCurrentEventState(); 
    601619    osg::Matrix masterCameraVPW = getCamera()->getViewMatrix() * getCamera()->getProjectionMatrix(); 
    602     if (getCamera()->getViewport())  
     620    if (getCamera()->getViewport()) 
    603621    { 
    604622        osg::Viewport* viewport = getCamera()->getViewport(); 
     
    620638        { 
    621639            gw->checkEvents(); 
    622              
     640 
    623641            osgGA::EventQueue::Events gw_events; 
    624642            gw->getEventQueue()->takeEvents(gw_events); 
    625              
     643 
    626644            osgGA::EventQueue::Events::iterator itr; 
    627645            for(itr = gw_events.begin(); 
     
    630648            { 
    631649                osgGA::GUIEventAdapter* event = itr->get(); 
    632                  
     650 
    633651                bool pointerEvent = false; 
    634652 
    635653                float x = event->getX(); 
    636654                float y = event->getY(); 
    637                  
     655 
    638656                bool invert_y = event->getMouseYOrientation()==osgGA::GUIEventAdapter::Y_INCREASING_DOWNWARDS; 
    639657                if (invert_y && gw->getTraits()) y = gw->getTraits()->height - y; 
    640                  
     658 
    641659                switch(event->getEventType()) 
    642660                { 
     
    647665                    { 
    648666                        pointerEvent = true; 
    649                          
     667 
    650668                        if (event->getEventType()!=osgGA::GUIEventAdapter::DRAG || !getCameraWithFocus()) 
    651669                        { 
     
    656674                            { 
    657675                                osg::Camera* camera = *citr; 
    658                                 if (camera->getView()==this &&  
     676                                if (camera->getView()==this && 
    659677                                    camera->getAllowEventFocus() && 
    660678                                    camera->getRenderTargetImplementation()==osg::Camera::FRAME_BUFFER) 
    661679                                { 
    662680                                    osg::Viewport* viewport = camera ? camera->getViewport() : 0; 
    663                                     if (viewport &&  
     681                                    if (viewport && 
    664682                                        x >= viewport->x() && y >= viewport->y() && 
    665683                                        x <= (viewport->x()+viewport->width()) && y <= (viewport->y()+viewport->height()) ) 
     
    671689                            } 
    672690                        } 
    673                          
     691 
    674692                        break; 
    675693                    } 
     
    677695                        break; 
    678696                } 
    679                  
     697 
    680698                if (pointerEvent) 
    681699                { 
     
    691709 
    692710                        x = new_coord.x(); 
    693                         y = new_coord.y();                                 
     711                        y = new_coord.y(); 
    694712 
    695713                        // osg::notify(osg::NOTICE)<<"pointer event new_coord.x()="<<new_coord.x()<<" new_coord.y()="<<new_coord.y()<<std::endl; 
     
    712730                        event->setMouseYOrientation(osgGA::GUIEventAdapter::Y_INCREASING_UPWARDS); 
    713731                    } 
    714                      
    715                     // pass along the new pointer events details to the eventState of the viewer  
     732 
     733                    // pass along the new pointer events details to the eventState of the viewer 
    716734                    eventState->setX(x); 
    717735                    eventState->setY(y); 
     
    743761                        bool wasThreading = areThreadsRunning(); 
    744762                        if (wasThreading) stopThreading(); 
    745                          
     763 
    746764                        gw->close(); 
    747                         _currentContext = NULL;  
    748                          
     765                        _currentContext = NULL; 
     766 
    749767                        if (wasThreading) startThreading(); 
    750                          
     768 
    751769                        break; 
    752770                    } 
     
    760778        } 
    761779    } 
    762      
     780 
    763781 
    764782    // osg::notify(osg::NOTICE)<<"mouseEventState Xmin = "<<eventState->getXmin()<<" Ymin="<<eventState->getYmin()<<" xMax="<<eventState->getXmax()<<" Ymax="<<eventState->getYmax()<<std::endl; 
     
    816834 
    817835    // osg::notify(osg::NOTICE)<<"Events "<<events.size()<<std::endl; 
    818      
     836 
    819837    if ((_keyEventSetsDone!=0) || _quitEventSetsDone) 
    820838    { 
     
    829847                    if (_keyEventSetsDone && event->getKey()==_keyEventSetsDone) _done = true; 
    830848                    break; 
    831                  
     849 
    832850                case(osgGA::GUIEventAdapter::QUIT_APPLICATION): 
    833851                    if (_quitEventSetsDone) _done = true; 
    834852                    break; 
    835                      
     853 
    836854                default: 
    837855                    break; 
     
    839857        } 
    840858    } 
    841          
     859 
    842860    if (_done) return; 
    843861 
     
    889907            (*hitr)->handleWithCheckAgainstIgnoreHandledEventsMask( *event, *this, 0, 0); 
    890908        } 
    891          
     909 
    892910    } 
    893911 
     
    902920        } 
    903921    } 
    904      
     922 
    905923    if (getViewerStats() && getViewerStats()->collectStats("event")) 
    906924    { 
     
    10041022    OperationThreads operationThreads; 
    10051023    getOperationThreads(operationThreads); 
    1006      
     1024 
    10071025    for(OperationThreads::iterator itr = operationThreads.begin(); 
    10081026        itr != operationThreads.end(); 
     
    10111029        threads.push_back(*itr); 
    10121030    } 
    1013      
     1031 
    10141032 
    10151033    if (_scene.valid()) 
     
    10341052{ 
    10351053    threads.clear(); 
    1036      
     1054 
    10371055    Contexts contexts; 
    10381056    getContexts(contexts); 
     
    10421060    { 
    10431061        osg::GraphicsContext* gc = *gcitr; 
    1044         if (gc->getGraphicsThread() &&  
     1062        if (gc->getGraphicsThread() && 
    10451063            (!onlyActive || gc->getGraphicsThread()->isRunning()) ) 
    10461064        { 
     
    10481066        } 
    10491067    } 
    1050      
     1068 
    10511069    Cameras cameras; 
    10521070    getCameras(cameras); 
     
    10561074    { 
    10571075        osg::Camera* camera = *citr; 
    1058         if (camera->getCameraThread() &&  
     1076        if (camera->getCameraThread() && 
    10591077            (!onlyActive || camera->getCameraThread()->isRunning()) ) 
    10601078        { 
     
    10621080        } 
    10631081    } 
    1064      
     1082 
    10651083} 
    10661084 
     
    10721090    contexts.clear(); 
    10731091 
    1074     if (_camera.valid() &&  
    1075         _camera->getGraphicsContext() &&  
     1092    if (_camera.valid() && 
     1093        _camera->getGraphicsContext() && 
    10761094        (_camera->getGraphicsContext()->valid() || !onlyValid)) 
    10771095    { 
     
    10791097        contexts.push_back(_camera->getGraphicsContext()); 
    10801098    } 
    1081      
     1099 
    10821100    for(unsigned int i=0; i<getNumSlaves(); ++i) 
    10831101    { 
     
    10981116{ 
    10991117    cameras.clear(); 
    1100      
    1101     if (_camera.valid() &&  
     1118 
     1119    if (_camera.valid() && 
    11021120        (!onlyActive || (_camera->getGraphicsContext() && _camera->getGraphicsContext()->valid())) ) cameras.push_back(_camera.get()); 
    11031121 
  • OpenSceneGraph/trunk/src/osgWrappers/osg/DisplaySettings.cpp

    r9775 r10588  
    385385                  "", 
    386386                  ""); 
     387        I_Method1(void, setMaxTexturePoolSize, IN, unsigned int, size, 
     388                  Properties::NON_VIRTUAL, 
     389                  __void__setMaxTexturePoolSize__unsigned_int, 
     390                  "", 
     391                  ""); 
     392        I_Method0(unsigned int, getMaxTexturePoolSize, 
     393                  Properties::NON_VIRTUAL, 
     394                  __unsigned_int__getMaxTexturePoolSize, 
     395                  "", 
     396                  ""); 
     397        I_Method1(void, setMaxVBOPoolSize, IN, unsigned int, size, 
     398                  Properties::NON_VIRTUAL, 
     399                  __void__setMaxVBOPoolSize__unsigned_int, 
     400                  "", 
     401                  ""); 
     402        I_Method0(unsigned int, getMaxVBOPoolSize, 
     403                  Properties::NON_VIRTUAL, 
     404                  __unsigned_int__getMaxVBOPoolSize, 
     405                  "", 
     406                  ""); 
     407        I_Method1(void, setMaxFBOPoolSize, IN, unsigned int, size, 
     408                  Properties::NON_VIRTUAL, 
     409                  __void__setMaxFBOPoolSize__unsigned_int, 
     410                  "", 
     411                  ""); 
     412        I_Method0(unsigned int, getMaxFBOPoolSize, 
     413                  Properties::NON_VIRTUAL, 
     414                  __unsigned_int__getMaxFBOPoolSize, 
     415                  "", 
     416                  ""); 
    387417        I_SimpleProperty(bool, AccumBuffer,  
    388418                         __bool__getAccumBuffer,  
     
    412442                         __float__getEyeSeparation,  
    413443                         __void__setEyeSeparation__float); 
     444        I_SimpleProperty(unsigned int, MaxFBOPoolSize,  
     445                         __unsigned_int__getMaxFBOPoolSize,  
     446                         __void__setMaxFBOPoolSize__unsigned_int); 
    414447        I_SimpleProperty(unsigned int, MaxNumberOfGraphicsContexts,  
    415448                         __unsigned_int__getMaxNumberOfGraphicsContexts,  
    416449                         __void__setMaxNumberOfGraphicsContexts__unsigned_int); 
     450        I_SimpleProperty(unsigned int, MaxTexturePoolSize,  
     451                         __unsigned_int__getMaxTexturePoolSize,  
     452                         __void__setMaxTexturePoolSize__unsigned_int); 
     453        I_SimpleProperty(unsigned int, MaxVBOPoolSize,  
     454                         __unsigned_int__getMaxVBOPoolSize,  
     455                         __void__setMaxVBOPoolSize__unsigned_int); 
    417456        I_SimpleProperty(unsigned int, MinimumNumAccumAlphaBits,  
    418457                         __unsigned_int__getMinimumNumAccumAlphaBits,  
  • OpenSceneGraph/trunk/src/osgWrappers/osg/State.cpp

    r10201 r10588  
    696696                  __void__decrementDynamicObjectCount, 
    697697                  "Decrement the number of dynamic objects left to render this frame, and once the count goes to zero call the DynamicObjectRenderingCompletedCallback to inform of completion. ", 
     698                  ""); 
     699        I_Method1(void, setMaxTexturePoolSize, IN, unsigned int, size, 
     700                  Properties::NON_VIRTUAL, 
     701                  __void__setMaxTexturePoolSize__unsigned_int, 
     702                  "", 
     703                  ""); 
     704        I_Method0(unsigned int, getMaxTexturePoolSize, 
     705                  Properties::NON_VIRTUAL, 
     706                  __unsigned_int__getMaxTexturePoolSize, 
     707                  "", 
     708                  ""); 
     709        I_Method1(void, setMaxVBOPoolSize, IN, unsigned int, size, 
     710                  Properties::NON_VIRTUAL, 
     711                  __void__setMaxVBOPoolSize__unsigned_int, 
     712                  "", 
     713                  ""); 
     714        I_Method0(unsigned int, getMaxVBOPoolSize, 
     715                  Properties::NON_VIRTUAL, 
     716                  __unsigned_int__getMaxVBOPoolSize, 
     717                  "", 
     718                  ""); 
     719        I_Method1(void, setMaxFBOPoolSize, IN, unsigned int, size, 
     720                  Properties::NON_VIRTUAL, 
     721                  __void__setMaxFBOPoolSize__unsigned_int, 
     722                  "", 
     723                  ""); 
     724        I_Method0(unsigned int, getMaxFBOPoolSize, 
     725                  Properties::NON_VIRTUAL, 
     726                  __unsigned_int__getMaxFBOPoolSize, 
     727                  "", 
    698728                  ""); 
    699729        I_Method1(void, setCheckForGLErrors, IN, osg::State::CheckForGLErrors, check, 
     
    851881                         __C5_Program_PerContextProgram_P1__getLastAppliedProgramObject,  
    852882                         __void__setLastAppliedProgramObject__C5_Program_PerContextProgram_P1); 
     883        I_SimpleProperty(unsigned int, MaxFBOPoolSize,  
     884                         __unsigned_int__getMaxFBOPoolSize,  
     885                         __void__setMaxFBOPoolSize__unsigned_int); 
     886        I_SimpleProperty(unsigned int, MaxTexturePoolSize,  
     887                         __unsigned_int__getMaxTexturePoolSize,  
     888                         __void__setMaxTexturePoolSize__unsigned_int); 
     889        I_SimpleProperty(unsigned int, MaxVBOPoolSize,  
     890                         __unsigned_int__getMaxVBOPoolSize,  
     891                         __void__setMaxVBOPoolSize__unsigned_int); 
    853892        I_IndexedProperty(bool, ModeValidity,  
    854893                          __bool__getModeValidity__StateAttribute_GLMode,  
  • OpenSceneGraph/trunk/src/osgWrappers/osg/Texture.cpp

    r9918 r10588  
    105105 
    106106TYPE_NAME_ALIAS(std::list< osg::ref_ptr< osg::Texture::TextureObject > >, osg::Texture::TextureObjectList) 
    107  
    108 TYPE_NAME_ALIAS(osg::buffered_object< osg::Texture::TextureObjectList >, osg::Texture::TextureObjectListMap) 
    109107 
    110108BEGIN_ABSTRACT_OBJECT_REFLECTOR(osg::Texture) 
     
    331329                  Properties::NON_VIRTUAL, 
    332330                  __TextureObject_P1__getTextureObject__unsigned_int, 
    333                   "Returns a pointer to the texture object for the current context. ", 
     331                  "Returns a pointer to the TextureBbject for the current context. ", 
     332                  ""); 
     333        I_Method2(void, setTextureObject, IN, unsigned int, contextID, IN, osg::Texture::TextureObject *, to, 
     334                  Properties::NON_VIRTUAL, 
     335                  __void__setTextureObject__unsigned_int__TextureObject_P1, 
     336                  "", 
    334337                  ""); 
    335338        I_Method0(void, dirtyTextureObject, 
     
    458461                  "Helper method. ", 
    459462                  "Subloads images into the texture, but doesn't set or use a texture binding. Note: Don't call this method directly unless you're implementing a subload callback. "); 
    460         I_Method1(void, takeTextureObjects, IN, osg::Texture::TextureObjectListMap &, toblm, 
    461                   Properties::NON_VIRTUAL, 
    462                   __void__takeTextureObjects__TextureObjectListMap_R1, 
    463                   "Takes the active texture objects from the Texture and places them in the specified TextureObjectListMap. ", 
    464                   ""); 
    465463        I_StaticMethod2(osg::Texture::Extensions *, getExtensions, IN, unsigned int, contextID, IN, bool, createIfNotInitalized, 
    466464                        __Extensions_P1__getExtensions__unsigned_int__bool_S, 
     
    479477                        "Determine the size of a compressed image, given the internalFormat, the width, the height, and the depth of the image. ", 
    480478                        "The block size and the size are output parameters. "); 
    481         I_StaticMethod2(osg::Texture::TextureObject *, generateTextureObject, IN, unsigned int, contextID, IN, GLenum, target, 
    482                         __TextureObject_P1__generateTextureObject__unsigned_int__GLenum_S, 
     479        I_StaticMethod1(osg::ref_ptr< osg::Texture::TextureObjectManager > &, getTextureObjectManager, IN, unsigned int, contextID, 
     480                        __osg_ref_ptrT1_Texture_TextureObjectManager__R1__getTextureObjectManager__unsigned_int_S, 
    483481                        "", 
    484482                        ""); 
    485         I_StaticMethod8(osg::Texture::TextureObject *, generateTextureObject, IN, unsigned int, contextID, IN, GLenum, target, IN, GLint, numMipmapLevels, IN, GLenum, internalFormat, IN, GLsizei, width, IN, GLsizei, height, IN, GLsizei, depth, IN, GLint, border, 
    486                         __TextureObject_P1__generateTextureObject__unsigned_int__GLenum__GLint__GLenum__GLsizei__GLsizei__GLsizei__GLint_S, 
     483        I_StaticMethod3(osg::Texture::TextureObject *, generateTextureObject, IN, const osg::Texture *, texture, IN, unsigned int, contextID, IN, GLenum, target, 
     484                        __TextureObject_P1__generateTextureObject__C5_Texture_P1__unsigned_int__GLenum_S, 
     485                        "", 
     486                        ""); 
     487        I_StaticMethod9(osg::Texture::TextureObject *, generateTextureObject, IN, const osg::Texture *, texture, IN, unsigned int, contextID, IN, GLenum, target, IN, GLint, numMipmapLevels, IN, GLenum, internalFormat, IN, GLsizei, width, IN, GLsizei, height, IN, GLsizei, depth, IN, GLint, border, 
     488                        __TextureObject_P1__generateTextureObject__C5_Texture_P1__unsigned_int__GLenum__GLint__GLenum__GLsizei__GLsizei__GLsizei__GLint_S, 
    487489                        "", 
    488490                        ""); 
     
    505507        I_StaticMethod3(void, flushDeletedTextureObjects, IN, unsigned int, contextID, IN, double, currentTime, IN, double &, availableTime, 
    506508                        __void__flushDeletedTextureObjects__unsigned_int__double__double_R1_S, 
     509                        "", 
     510                        ""); 
     511        I_StaticMethod2(void, releaseTextureObject, IN, unsigned int, contextID, IN, osg::Texture::TextureObject *, to, 
     512                        __void__releaseTextureObject__unsigned_int__TextureObject_P1_S, 
    507513                        "", 
    508514                        ""); 
     
    641647                         __int__getTextureHeight,  
    642648                         0); 
     649        I_IndexedProperty(osg::Texture::TextureObject *, TextureObject,  
     650                          __TextureObject_P1__getTextureObject__unsigned_int,  
     651                          __void__setTextureObject__unsigned_int__TextureObject_P1,  
     652                          0); 
    643653        I_SimpleProperty(GLenum, TextureTarget,  
    644654                         __GLenum__getTextureTarget,  
     
    665675        I_DeclaringFile("osg/Texture"); 
    666676        I_BaseType(osg::Referenced); 
    667         I_Constructor2(IN, GLuint, id, IN, GLenum, target, 
    668                        ____TextureObject__GLuint__GLenum, 
    669                        "", 
    670                        ""); 
    671         I_Constructor8(IN, GLuint, id, IN, GLenum, target, IN, GLint, numMipmapLevels, IN, GLenum, internalFormat, IN, GLsizei, width, IN, GLsizei, height, IN, GLsizei, depth, IN, GLint, border, 
    672                        ____TextureObject__GLuint__GLenum__GLint__GLenum__GLsizei__GLsizei__GLsizei__GLint, 
     677        I_Constructor3(IN, osg::Texture *, texture, IN, GLuint, id, IN, GLenum, target, 
     678                       ____TextureObject__Texture_P1__GLuint__GLenum, 
     679                       "", 
     680                       ""); 
     681        I_Constructor3(IN, osg::Texture *, texture, IN, GLuint, id, IN, const osg::Texture::TextureProfile &, profile, 
     682                       ____TextureObject__Texture_P1__GLuint__C5_TextureProfile_R1, 
     683                       "", 
     684                       ""); 
     685        I_Constructor9(IN, osg::Texture *, texture, IN, GLuint, id, IN, GLenum, target, IN, GLint, numMipmapLevels, IN, GLenum, internalFormat, IN, GLsizei, width, IN, GLsizei, height, IN, GLsizei, depth, IN, GLint, border, 
     686                       ____TextureObject__Texture_P1__GLuint__GLenum__GLint__GLenum__GLsizei__GLsizei__GLsizei__GLint, 
    673687                       "", 
    674688                       ""); 
     
    681695                  Properties::NON_VIRTUAL, 
    682696                  __void__bind, 
     697                  "", 
     698                  ""); 
     699        I_Method0(GLenum, id, 
     700                  Properties::NON_VIRTUAL, 
     701                  __GLenum__id, 
     702                  "", 
     703                  ""); 
     704        I_Method0(GLenum, target, 
     705                  Properties::NON_VIRTUAL, 
     706                  __GLenum__target, 
     707                  "", 
     708                  ""); 
     709        I_Method1(void, setTexture, IN, osg::Texture *, texture, 
     710                  Properties::NON_VIRTUAL, 
     711                  __void__setTexture__Texture_P1, 
     712                  "", 
     713                  ""); 
     714        I_Method0(osg::Texture *, getTexture, 
     715                  Properties::NON_VIRTUAL, 
     716                  __Texture_P1__getTexture, 
     717                  "", 
     718                  ""); 
     719        I_Method1(void, setTimeStamp, IN, double, timestamp, 
     720                  Properties::NON_VIRTUAL, 
     721                  __void__setTimeStamp__double, 
     722                  "", 
     723                  ""); 
     724        I_Method0(double, getTimeStamp, 
     725                  Properties::NON_VIRTUAL, 
     726                  __double__getTimeStamp, 
    683727                  "", 
    684728                  ""); 
     
    706750                         0,  
    707751                         __void__setAllocated__bool); 
     752        I_SimpleProperty(osg::Texture *, Texture,  
     753                         __Texture_P1__getTexture,  
     754                         __void__setTexture__Texture_P1); 
     755        I_SimpleProperty(double, TimeStamp,  
     756                         __double__getTimeStamp,  
     757                         __void__setTimeStamp__double); 
    708758        I_PublicMemberProperty(GLuint, _id); 
     759        I_PublicMemberProperty(osg::Texture::TextureProfile, _profile); 
     760        I_PublicMemberProperty(osg::Texture::TextureObjectSet *, _set); 
     761        I_PublicMemberProperty(osg::Texture::TextureObject *, _previous); 
     762        I_PublicMemberProperty(osg::Texture::TextureObject *, _next); 
     763        I_PublicMemberProperty(osg::Texture *, _texture); 
     764        I_PublicMemberProperty(bool, _allocated); 
     765        I_PublicMemberProperty(double, _timeStamp); 
     766END_REFLECTOR 
     767 
     768BEGIN_OBJECT_REFLECTOR(osg::Texture::TextureObjectManager) 
     769        I_DeclaringFile("osg/Texture"); 
     770        I_BaseType(osg::Referenced); 
     771        I_Constructor1(IN, unsigned int, contextID, 
     772                       Properties::NON_EXPLICIT, 
     773                       ____TextureObjectManager__unsigned_int, 
     774                       "", 
     775                       ""); 
     776        I_Method0(unsigned int, getContextID, 
     777                  Properties::NON_VIRTUAL, 
     778                  __unsigned_int__getContextID, 
     779                  "", 
     780                  ""); 
     781        I_Method1(void, setTexturePoolSize, IN, unsigned int, size, 
     782                  Properties::NON_VIRTUAL, 
     783                  __void__setTexturePoolSize__unsigned_int, 
     784                  "", 
     785                  ""); 
     786        I_Method0(unsigned int, getTexturePoolSize, 
     787                  Properties::NON_VIRTUAL, 
     788                  __unsigned_int__getTexturePoolSize, 
     789                  "", 
     790                  ""); 
     791        I_Method2(osg::Texture::TextureObject *, generateTextureObject, IN, const osg::Texture *, texture, IN, GLenum, target, 
     792                  Properties::NON_VIRTUAL, 
     793                  __TextureObject_P1__generateTextureObject__C5_Texture_P1__GLenum, 
     794                  "", 
     795                  ""); 
     796        I_Method8(osg::Texture::TextureObject *, generateTextureObject, IN, const osg::Texture *, texture, IN, GLenum, target, IN, GLint, numMipmapLevels, IN, GLenum, internalFormat, IN, GLsizei, width, IN, GLsizei, height, IN, GLsizei, depth, IN, GLint, border, 
     797                  Properties::NON_VIRTUAL, 
     798                  __TextureObject_P1__generateTextureObject__C5_Texture_P1__GLenum__GLint__GLenum__GLsizei__GLsizei__GLsizei__GLint, 
     799                  "", 
     800                  ""); 
     801        I_Method0(void, handlePendingOrphandedTextureObjects, 
     802                  Properties::NON_VIRTUAL, 
     803                  __void__handlePendingOrphandedTextureObjects, 
     804                  "", 
     805                  ""); 
     806        I_Method0(void, flushAllDeletedTextureObjects, 
     807                  Properties::NON_VIRTUAL, 
     808                  __void__flushAllDeletedTextureObjects, 
     809                  "", 
     810                  ""); 
     811        I_Method0(void, discardAllDeletedTextureObjects, 
     812                  Properties::NON_VIRTUAL, 
     813                  __void__discardAllDeletedTextureObjects, 
     814                  "", 
     815                  ""); 
     816        I_Method2(void, flushDeletedTextureObjects, IN, double, currentTime, IN, double &, availableTime, 
     817                  Properties::NON_VIRTUAL, 
     818                  __void__flushDeletedTextureObjects__double__double_R1, 
     819                  "", 
     820                  ""); 
     821        I_Method1(void, releaseTextureObject, IN, osg::Texture::TextureObject *, to, 
     822                  Properties::NON_VIRTUAL, 
     823                  __void__releaseTextureObject__TextureObject_P1, 
     824                  "", 
     825                  ""); 
     826        I_SimpleProperty(unsigned int, ContextID,  
     827                         __unsigned_int__getContextID,  
     828                         0); 
     829        I_SimpleProperty(unsigned int, TexturePoolSize,  
     830                         __unsigned_int__getTexturePoolSize,  
     831                         __void__setTexturePoolSize__unsigned_int); 
     832END_REFLECTOR 
     833 
     834BEGIN_OBJECT_REFLECTOR(osg::Texture::TextureObjectSet) 
     835        I_DeclaringFile("osg/Texture"); 
     836        I_BaseType(osg::Referenced); 
     837        I_Constructor2(IN, osg::Texture::TextureObjectManager *, parent, IN, const osg::Texture::TextureProfile &, profile, 
     838                       ____TextureObjectSet__TextureObjectManager_P1__C5_TextureProfile_R1, 
     839                       "", 
     840                       ""); 
     841        I_Method0(void, handlePendingOrphandedTextureObjects, 
     842                  Properties::NON_VIRTUAL, 
     843                  __void__handlePendingOrphandedTextureObjects, 
     844                  "", 
     845                  ""); 
     846        I_Method0(void, flushAllDeletedTextureObjects, 
     847                  Properties::NON_VIRTUAL, 
     848                  __void__flushAllDeletedTextureObjects, 
     849                  "", 
     850                  ""); 
     851        I_Method0(void, discardAllDeletedTextureObjects, 
     852                  Properties::NON_VIRTUAL, 
     853                  __void__discardAllDeletedTextureObjects, 
     854                  "", 
     855                  ""); 
     856        I_Method2(void, flushDeletedTextureObjects, IN, double, currentTime, IN, double &, availableTime, 
     857                  Properties::NON_VIRTUAL, 
     858                  __void__flushDeletedTextureObjects__double__double_R1, 
     859                  "", 
     860                  ""); 
     861        I_Method1(osg::Texture::TextureObject *, takeOrGenerate, IN, osg::Texture *, texture, 
     862                  Properties::NON_VIRTUAL, 
     863                  __TextureObject_P1__takeOrGenerate__Texture_P1, 
     864                  "", 
     865                  ""); 
     866        I_Method1(void, moveToBack, IN, osg::Texture::TextureObject *, to, 
     867                  Properties::NON_VIRTUAL, 
     868                  __void__moveToBack__TextureObject_P1, 
     869                  "", 
     870                  ""); 
     871        I_Method1(void, addToBack, IN, osg::Texture::TextureObject *, to, 
     872                  Properties::NON_VIRTUAL, 
     873                  __void__addToBack__TextureObject_P1, 
     874                  "", 
     875                  ""); 
     876        I_Method1(void, orphan, IN, osg::Texture::TextureObject *, to, 
     877                  Properties::NON_VIRTUAL, 
     878                  __void__orphan__TextureObject_P1, 
     879                  "", 
     880                  ""); 
     881        I_Method0(unsigned int, size, 
     882                  Properties::NON_VIRTUAL, 
     883                  __unsigned_int__size, 
     884                  "", 
     885                  ""); 
     886        I_Method0(bool, checkConsistency, 
     887                  Properties::NON_VIRTUAL, 
     888                  __bool__checkConsistency, 
     889                  "", 
     890                  ""); 
     891END_REFLECTOR 
     892 
     893BEGIN_VALUE_REFLECTOR(osg::Texture::TextureProfile) 
     894        I_DeclaringFile("osg/Texture"); 
     895        I_Constructor1(IN, GLenum, target, 
     896                       Properties::NON_EXPLICIT, 
     897                       ____TextureProfile__GLenum, 
     898                       "", 
     899                       ""); 
     900        I_Constructor7(IN, GLenum, target, IN, GLint, numMipmapLevels, IN, GLenum, internalFormat, IN, GLsizei, width, IN, GLsizei, height, IN, GLsizei, depth, IN, GLint, border, 
     901                       ____TextureProfile__GLenum__GLint__GLenum__GLsizei__GLsizei__GLsizei__GLint, 
     902                       "", 
     903                       ""); 
     904        I_Method6(void, set, IN, GLint, numMipmapLevels, IN, GLenum, internalFormat, IN, GLsizei, width, IN, GLsizei, height, IN, GLsizei, depth, IN, GLint, border, 
     905                  Properties::NON_VIRTUAL, 
     906                  __void__set__GLint__GLenum__GLsizei__GLsizei__GLsizei__GLint, 
     907                  "", 
     908                  ""); 
     909        I_Method7(bool, match, IN, GLenum, target, IN, GLint, numMipmapLevels, IN, GLenum, internalFormat, IN, GLsizei, width, IN, GLsizei, height, IN, GLsizei, depth, IN, GLint, border, 
     910                  Properties::NON_VIRTUAL, 
     911                  __bool__match__GLenum__GLint__GLenum__GLsizei__GLsizei__GLsizei__GLint, 
     912                  "", 
     913                  ""); 
    709914        I_PublicMemberProperty(GLenum, _target); 
    710915        I_PublicMemberProperty(GLint, _numMipmapLevels); 
     
    714919        I_PublicMemberProperty(GLsizei, _depth); 
    715920        I_PublicMemberProperty(GLint, _border); 
    716         I_PublicMemberProperty(bool, _allocated); 
    717         I_PublicMemberProperty(double, _timeStamp); 
    718 END_REFLECTOR 
    719  
    720 BEGIN_VALUE_REFLECTOR(osg::buffered_object< osg::Texture::TextureObjectList >) 
    721         I_DeclaringFile("osg/buffered_value"); 
    722         I_Constructor0(____buffered_object, 
    723                        "", 
    724                        ""); 
    725         I_Constructor1(IN, unsigned int, size, 
    726                        Properties::NON_EXPLICIT, 
    727                        ____buffered_object__unsigned_int, 
    728                        "", 
    729                        ""); 
    730         I_Method1(void, setAllElementsTo, IN, const osg::Texture::TextureObjectList &, t, 
    731                   Properties::NON_VIRTUAL, 
    732                   __void__setAllElementsTo__C5_T_R1, 
    733                   "", 
    734                   ""); 
    735         I_Method0(void, clear, 
    736                   Properties::NON_VIRTUAL, 
    737                   __void__clear, 
    738                   "", 
    739                   ""); 
    740         I_Method0(bool, empty, 
    741                   Properties::NON_VIRTUAL, 
    742                   __bool__empty, 
    743                   "", 
    744                   ""); 
    745         I_Method0(unsigned int, size, 
    746                   Properties::NON_VIRTUAL, 
    747                   __unsigned_int__size, 
    748                   "", 
    749                   ""); 
    750         I_Method1(void, resize, IN, unsigned int, newSize, 
    751                   Properties::NON_VIRTUAL, 
    752                   __void__resize__unsigned_int, 
    753                   "", 
    754                   ""); 
    755         I_SimpleProperty(const osg::Texture::TextureObjectList &, AllElementsTo,  
    756                          0,  
    757                          __void__setAllElementsTo__C5_T_R1); 
    758921END_REFLECTOR 
    759922 
     
    798961END_REFLECTOR 
    799962 
     963BEGIN_VALUE_REFLECTOR(osg::ref_ptr< osg::Texture::TextureObjectManager >) 
     964        I_DeclaringFile("osg/ref_ptr"); 
     965        I_Constructor0(____ref_ptr, 
     966                       "", 
     967                       ""); 
     968        I_Constructor1(IN, osg::Texture::TextureObjectManager *, ptr, 
     969                       Properties::NON_EXPLICIT, 
     970                       ____ref_ptr__T_P1, 
     971                       "", 
     972                       ""); 
     973        I_Constructor1(IN, const osg::ref_ptr< osg::Texture::TextureObjectManager > &, rp, 
     974                       Properties::NON_EXPLICIT, 
     975                       ____ref_ptr__C5_ref_ptr_R1, 
     976                       "", 
     977                       ""); 
     978        I_Method0(osg::Texture::TextureObjectManager *, get, 
     979                  Properties::NON_VIRTUAL, 
     980                  __T_P1__get, 
     981                  "", 
     982                  ""); 
     983        I_Method0(bool, valid, 
     984                  Properties::NON_VIRTUAL, 
     985                  __bool__valid, 
     986                  "", 
     987                  ""); 
     988        I_Method0(osg::Texture::TextureObjectManager *, release, 
     989                  Properties::NON_VIRTUAL, 
     990                  __T_P1__release, 
     991                  "", 
     992                  ""); 
     993        I_Method1(void, swap, IN, osg::ref_ptr< osg::Texture::TextureObjectManager > &, rp, 
     994                  Properties::NON_VIRTUAL, 
     995                  __void__swap__ref_ptr_R1, 
     996                  "", 
     997                  ""); 
     998        I_SimpleProperty(osg::Texture::TextureObjectManager *, ,  
     999                         __T_P1__get,  
     1000                         0); 
     1001END_REFLECTOR 
     1002 
    8001003STD_LIST_REFLECTOR(std::list< osg::ref_ptr< osg::Texture::TextureObject > >) 
    8011004