Changeset 10601

Show
Ignore:
Timestamp:
10/03/09 11:25:23 (5 years ago)
Author:
robert
Message:

Introduced new GLBufferObject pool for managing the memory footprint taken up by VertexBufferObejct?, ElementBufferObject? and PixelBufferObject?.

Location:
OpenSceneGraph/trunk
Files:
16 modified

Legend:

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

    r10600 r10601  
    1818#include <osg/Object> 
    1919#include <osg/buffered_value> 
     20#include <osg/FrameStamp> 
     21 
     22#include <list> 
     23#include <map> 
    2024 
    2125#ifndef GL_ARB_vertex_buffer_object 
     
    103107class BufferObject; 
    104108 
     109class BufferObjectProfile 
     110{ 
     111    public: 
     112        BufferObjectProfile(): 
     113            _target(0), 
     114            _usage(0), 
     115            _size(0) {} 
     116 
     117        BufferObjectProfile(GLenum target, GLenum usage, unsigned int size): 
     118            _target(target), 
     119            _usage(usage), 
     120            _size(size) {} 
     121 
     122        BufferObjectProfile(const BufferObjectProfile& bpo): 
     123            _target(bpo._target), 
     124            _usage(bpo._usage), 
     125            _size(bpo._size) {} 
     126 
     127        bool operator < (const BufferObjectProfile& rhs) const 
     128        { 
     129            if (_target < rhs._target) return true; 
     130            else if (_target > rhs._target) return false; 
     131            if (_usage < rhs._usage) return true; 
     132            else if (_usage > rhs._usage) return false; 
     133            return _size < rhs._size; 
     134        } 
     135 
     136        bool operator == (const BufferObjectProfile& rhs) const 
     137        { 
     138            return (_target == rhs._target) && 
     139                   (_usage == rhs._usage) && 
     140                   (_size == rhs._size); 
     141        } 
     142 
     143        void setProfile(GLenum target, GLenum usage, unsigned int size) 
     144        { 
     145            _target = target; 
     146            _usage = usage; 
     147            _size = size; 
     148        } 
     149 
     150        BufferObjectProfile& operator = (const BufferObjectProfile& rhs) 
     151        { 
     152            _target = rhs._target; 
     153            _usage = rhs._usage; 
     154            _size = rhs._size; 
     155            return *this; 
     156        } 
     157 
     158        GLenum _target; 
     159        GLenum _usage; 
     160        GLenum _size; 
     161}; 
     162 
     163// forward declare 
     164class GLBufferObjectSet; 
     165class GLBufferObjectManager; 
     166 
    105167class OSG_EXPORT GLBufferObject : public Referenced 
    106168{ 
     
    108170 
    109171        GLBufferObject(unsigned int contextID, BufferObject* bufferObject=0); 
     172 
     173        void setProfile(const BufferObjectProfile& profile) { _profile = profile; } 
     174        const BufferObjectProfile& getProfile() const { return _profile; } 
    110175 
    111176        void setBufferObject(BufferObject* bufferObject); 
     
    144209        inline GLsizeiptrARB getOffset(unsigned int i) const { return _bufferEntries[i].offset; } 
    145210 
    146         inline void bindBuffer() const 
     211        void bindBuffer(); 
     212 
     213        inline void unbindBuffer() 
    147214        {  
    148             _extensions->glBindBuffer(_target,_glObjectID); 
    149         } 
    150  
    151         inline void unbindBuffer() const 
    152         {  
    153             _extensions->glBindBuffer(_target,0); 
     215            _extensions->glBindBuffer(_profile._target,0); 
    154216        } 
    155217 
     
    177239        static void deleteBufferObject(unsigned int contextID,GLuint globj); 
    178240 
    179         /** flush all the cached display list which need to be deleted 
    180           * in the OpenGL context related to contextID.*/ 
    181         static void flushDeletedBufferObjects(unsigned int contextID,double /*currentTime*/, double& availableTime); 
    182  
    183         /** dicard all the cached display list which need to be deleted 
    184           * in the OpenGL context related to contextID. 
    185           * Note, unlike flush no OpenGL calls are made, instead the handles are all removed. 
    186           * this call is useful for when an OpenGL context has been destroyed. */ 
    187         static void discardDeletedBufferObjects(unsigned int contextID); 
     241        static void flushAllDeletedBufferObjects(unsigned int contextID); 
     242        static void discardAllDeletedBufferObjects(unsigned int contextID); 
     243        static void flushDeletedBufferObjects(unsigned int contextID,double currentTime, double& availbleTime); 
     244        static void releaseGLBufferObject(unsigned int contextID, GLBufferObject* to); 
    188245 
    189246        /** Extensions class which encapsulates the querying of extensions and 
     
    265322        GLuint                  _glObjectID; 
    266323 
    267         GLenum                  _target; 
    268         GLenum                  _usage; 
     324        BufferObjectProfile     _profile; 
     325        unsigned int            _allocatedSize; 
    269326 
    270327        bool                    _dirty; 
    271  
    272         mutable unsigned int    _totalSize; 
    273328 
    274329        typedef std::vector<BufferEntry> BufferEntries; 
     
    278333 
    279334    public: 
     335 
     336        GLBufferObjectSet*      _set; 
     337        GLBufferObject*         _previous; 
     338        GLBufferObject*         _next; 
     339        unsigned int            _frameLastUsed; 
     340 
     341    public: 
    280342        Extensions*             _extensions; 
    281343 
    282344}; 
     345 
     346typedef std::list< ref_ptr<GLBufferObject> > GLBufferObjectList; 
     347 
     348class OSG_EXPORT GLBufferObjectSet : public Referenced 
     349{ 
     350    public: 
     351        GLBufferObjectSet(GLBufferObjectManager* parent, const BufferObjectProfile& profile); 
     352 
     353        void handlePendingOrphandedGLBufferObjects(); 
     354        void flushAllDeletedGLBufferObjects(); 
     355        void discardAllDeletedGLBufferObjects(); 
     356        void flushDeletedGLBufferObjects(double currentTime, double& availableTime); 
     357 
     358        GLBufferObject* takeFromOrphans(BufferObject* bufferObject); 
     359        GLBufferObject* takeOrGenerate(BufferObject* bufferObject); 
     360 
     361        void moveToBack(GLBufferObject* to); 
     362        void addToBack(GLBufferObject* to); 
     363        void orphan(GLBufferObject* to); 
     364        void remove(GLBufferObject* to); 
     365 
     366        unsigned int size() const { return _profile._size * _numOfGLBufferObjects; } 
     367 
     368        bool makeSpace(unsigned int& size); 
     369 
     370        bool checkConsistency() const; 
     371 
     372        GLBufferObjectManager* getParent() { return _parent; } 
     373 
     374 
     375    protected: 
     376 
     377        virtual ~GLBufferObjectSet(); 
     378 
     379        OpenThreads::Mutex  _mutex; 
     380 
     381        GLBufferObjectManager*  _parent; 
     382        unsigned int            _contextID; 
     383        BufferObjectProfile     _profile; 
     384        unsigned int            _numOfGLBufferObjects; 
     385        GLBufferObjectList      _orphanedGLBufferObjects; 
     386        GLBufferObjectList      _pendingOrphanedGLBufferObjects; 
     387 
     388        GLBufferObject*         _head; 
     389        GLBufferObject*         _tail; 
     390}; 
     391 
     392class OSG_EXPORT GLBufferObjectManager : public osg::Referenced 
     393{ 
     394    public: 
     395        GLBufferObjectManager(unsigned int contextID); 
     396 
     397        unsigned int getContextID() const { return _contextID; } 
     398 
     399 
     400        void setNumberActiveGLBufferObjects(unsigned int size) { _numActiveGLBufferObjects = size; } 
     401        unsigned int& getNumberActiveGLBufferObjects() { return _numActiveGLBufferObjects; } 
     402        unsigned int getNumberActiveGLBufferObjects() const { return _numActiveGLBufferObjects; } 
     403 
     404        void setNumberOrphanedGLBufferObjects(unsigned int size) { _numOrphanedGLBufferObjects = size; } 
     405        unsigned int& getNumberOrphanedGLBufferObjects() { return _numOrphanedGLBufferObjects; } 
     406        unsigned int getNumberOrphanedGLBufferObjects() const { return _numOrphanedGLBufferObjects; } 
     407 
     408        void setCurrGLBufferObjectPoolSize(unsigned int size) { _currGLBufferObjectPoolSize = size; } 
     409        unsigned int& getCurrGLBufferObjectPoolSize() { return _currGLBufferObjectPoolSize; } 
     410        unsigned int getCurrGLBufferObjectPoolSize() const { return _currGLBufferObjectPoolSize; } 
     411 
     412        void setMaxGLBufferObjectPoolSize(unsigned int size); 
     413        unsigned int getMaxGLBufferObjectPoolSize() const { return _maxGLBufferObjectPoolSize; } 
     414 
     415        bool hasSpace(unsigned int size) const { return (_currGLBufferObjectPoolSize+size)<=_maxGLBufferObjectPoolSize; } 
     416        bool makeSpace(unsigned int size); 
     417 
     418        GLBufferObject* generateGLBufferObject(const osg::BufferObject* bufferObject); 
     419 
     420        void handlePendingOrphandedGLBufferObjects(); 
     421        void flushAllDeletedGLBufferObjects(); 
     422        void discardAllDeletedGLBufferObjects(); 
     423        void flushDeletedGLBufferObjects(double currentTime, double& availableTime); 
     424        void releaseGLBufferObject(GLBufferObject* to); 
     425 
     426        GLBufferObjectSet* getGLBufferObjectSet(const BufferObjectProfile& profile); 
     427 
     428        void newFrame(osg::FrameStamp* fs); 
     429        void resetStats(); 
     430        void reportStats(); 
     431 
     432        unsigned int& getFrameNumber() { return _frameNumber; } 
     433        unsigned int& getNumberFrames() { return _numFrames; } 
     434 
     435        unsigned int& getNumberDeleted() { return _numDeleted; } 
     436        double& getDeleteTime() { return _deleteTime; } 
     437 
     438        unsigned int& getNumberGenerated() { return _numGenerated; } 
     439        double& getGenerateTime() { return _generateTime; } 
     440 
     441        unsigned int& getNumberApplied() { return _numApplied; } 
     442        double& getApplyTime() { return _applyTime; } 
     443 
     444        static osg::ref_ptr<GLBufferObjectManager>& getGLBufferObjectManager(unsigned int contextID); 
     445 
     446    protected: 
     447 
     448        typedef std::map< BufferObjectProfile, osg::ref_ptr<GLBufferObjectSet> > GLBufferObjectSetMap; 
     449        unsigned int            _contextID; 
     450        unsigned int            _numActiveGLBufferObjects; 
     451        unsigned int            _numOrphanedGLBufferObjects; 
     452        unsigned int            _currGLBufferObjectPoolSize; 
     453        unsigned int            _maxGLBufferObjectPoolSize; 
     454        GLBufferObjectSetMap    _glBufferObjectSetMap; 
     455 
     456        unsigned int            _frameNumber; 
     457 
     458        unsigned int            _numFrames; 
     459        unsigned int            _numDeleted; 
     460        double                  _deleteTime; 
     461 
     462        unsigned int            _numGenerated; 
     463        double                  _generateTime; 
     464 
     465        unsigned int            _numApplied; 
     466        double                  _applyTime; 
     467 
     468}; 
     469 
    283470 
    284471class OSG_EXPORT BufferObject : public Object 
     
    295482        virtual const char* className() const { return "BufferObject"; } 
    296483 
    297         void setTarget(GLenum target) { _target = target; } 
    298         GLenum getTarget() const { return _target; } 
     484        void setTarget(GLenum target) { _profile._target = target; } 
     485        GLenum getTarget() const { return _profile._target; } 
    299486 
    300487        /** Set what type of usage the buffer object will have. Options are: 
     
    303490          *          GL_DYNAMIC_DRAW, GL_DYNAMIC_READ, or GL_DYNAMIC_COPY. 
    304491          */ 
    305         void setUsage(GLenum usage) { _usage = usage; } 
     492        void setUsage(GLenum usage) { _profile._usage = usage; } 
    306493 
    307494        /** Get the type of usage the buffer object has been set up for.*/ 
    308         GLenum getUsage() const { return _usage; } 
     495        GLenum getUsage() const { return _profile._usage; } 
     496 
     497        BufferObjectProfile& getProfile() { return _profile; } 
     498        const BufferObjectProfile& getProfile() const { return _profile; } 
    309499 
    310500        void dirty(); 
     
    327517 
    328518        unsigned int getNumBufferData() const { return _bufferDataList.size(); } 
     519 
     520        void setGLBufferObject(unsigned int contextID, GLBufferObject* glbo) { _glBufferObjects[contextID] = glbo; } 
    329521 
    330522        GLBufferObject* getGLBufferObject(unsigned int contextID) const { return _glBufferObjects[contextID].get(); } 
     
    336528        } 
    337529 
     530        unsigned int computeRequiredBufferSize() const; 
     531 
    338532    protected: 
    339533 
     
    343537        typedef osg::buffered_object< osg::ref_ptr<GLBufferObject> > GLBufferObjects; 
    344538 
    345         GLenum                  _target; 
    346         GLenum                  _usage; 
     539        BufferObjectProfile     _profile; 
     540 
    347541        BufferDataList          _bufferDataList; 
    348542 
     
    488682 
    489683        //! Set new size of the buffer object. This will reallocate the memory on the next compile 
    490         inline void setDataSize(unsigned int size) { _dataSize = size; dirty(); } 
     684        inline void setDataSize(unsigned int size) { _profile._size = size; dirty(); } 
    491685 
    492686        //! Get data size of the used buffer  
    493         inline unsigned int getDataSize() const { return _dataSize; } 
     687        inline unsigned int getDataSize() const { return _profile._size; } 
    494688 
    495689        //! Compile the buffer (reallocate the memory if buffer is dirty) 
     
    526720        virtual ~PixelDataBufferObject(); 
    527721 
    528         unsigned int _dataSize; 
    529  
    530722        typedef osg::buffered_value<unsigned int> ModeList; 
    531723         
  • OpenSceneGraph/trunk/include/osg/DisplaySettings

    r10588 r10601  
    204204        unsigned int getMaxTexturePoolSize() const { return _maxTexturePoolSize; } 
    205205 
    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; } 
     206        void setMaxBufferObjectPoolSize(unsigned int size) { _maxBufferObjectPoolSize = size; } 
     207        unsigned int getMaxBufferObjectPoolSize() const { return _maxBufferObjectPoolSize; } 
    211208 
    212209    protected: 
     
    252249 
    253250        unsigned int                    _maxTexturePoolSize; 
    254         unsigned int                    _maxVBOPoolSize; 
    255         unsigned int                    _maxFBOPoolSize; 
     251        unsigned int                    _maxBufferObjectPoolSize; 
    256252}; 
    257253 
  • OpenSceneGraph/trunk/include/osg/State

    r10600 r10601  
    412412            if (vbo == _currentVBO) return; 
    413413            if (vbo->isDirty()) vbo->compileBuffer(); 
    414             else _glBindBuffer(GL_ARRAY_BUFFER_ARB,vbo->getGLObjectID()); 
     414            else vbo->bindBuffer(); 
    415415            _currentVBO = vbo; 
    416416        } 
     
    430430            if (ebo == _currentEBO) return; 
    431431            if (ebo->isDirty()) ebo->compileBuffer(); 
    432             else _glBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB,ebo->getGLObjectID()); 
     432            else ebo->bindBuffer(); 
    433433            _currentEBO = ebo; 
    434434        } 
     
    449449 
    450450            if (pbo->isDirty()) pbo->compileBuffer(); 
    451             else _glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB,pbo->getGLObjectID()); 
     451            else pbo->bindBuffer(); 
    452452 
    453453            _currentPBO = pbo; 
     
    10411041        unsigned int getMaxTexturePoolSize() const { return _maxTexturePoolSize; } 
    10421042 
    1043         void setMaxVBOPoolSize(unsigned int size); 
    1044         unsigned int getMaxVBOPoolSize() const { return _maxVBOPoolSize; } 
    1045  
    1046         void setMaxFBOPoolSize(unsigned int size); 
    1047         unsigned int getMaxFBOPoolSize() const { return _maxFBOPoolSize; } 
    1048  
     1043        void setMaxBufferObjectPoolSize(unsigned int size); 
     1044        unsigned int getMaxBufferObjectPoolSize() const { return _maxBufferObjectPoolSize; } 
    10491045 
    10501046 
     
    12341230 
    12351231        unsigned int                                                    _maxTexturePoolSize; 
    1236         unsigned int                                                    _maxVBOPoolSize; 
    1237         unsigned int                                                    _maxFBOPoolSize; 
     1232        unsigned int                                                    _maxBufferObjectPoolSize; 
    12381233 
    12391234 
  • OpenSceneGraph/trunk/include/osg/Texture

    r10597 r10601  
    10011001        typedef std::list< ref_ptr<TextureObject> > TextureObjectList; 
    10021002 
    1003         class TextureObjectSet : public Referenced 
     1003        class OSG_EXPORT TextureObjectSet : public Referenced 
    10041004        { 
    10051005        public: 
  • OpenSceneGraph/trunk/src/osg/BufferObject.cpp

    r10600 r10601  
    3838static DeletedBufferObjectCache s_deletedBufferObjectCache; 
    3939 
     40unsigned int s_minimumNumberOfGLBufferObjectsToRetainInCache = 1000; 
     41 
    4042////////////////////////////////////////////////////////////////////////////////////////////////////// 
    4143// 
     
    4547    _contextID(contextID), 
    4648    _glObjectID(0), 
    47     _target(0), 
    48     _usage(0), 
     49    _profile(0,0,0), 
     50    _allocatedSize(0), 
    4951    _dirty(true), 
    50     _totalSize(0), 
    5152    _bufferObject(0), 
     53    _set(0), 
     54    _previous(0), 
     55    _next(0), 
    5256    _extensions(0) 
    5357{ 
     
    5963GLBufferObject::~GLBufferObject() 
    6064{ 
    61     if (_glObjectID!=0) GLBufferObject::deleteBufferObject(_contextID, _glObjectID); 
    62  
     65} 
     66 
     67void GLBufferObject::bindBuffer() 
     68{ 
     69    _extensions->glBindBuffer(_profile._target,_glObjectID); 
     70    if (_set) _set->moveToBack(this); 
     71} 
     72 
     73void GLBufferObject::setBufferObject(BufferObject* bufferObject) 
     74{ 
     75    assign(bufferObject); 
    6376} 
    6477 
     
    6982    if (_bufferObject) 
    7083    { 
    71         _target = bufferObject->getTarget(); 
    72         _usage = bufferObject->getUsage(); 
    73  
    74         _totalSize = 0; 
     84        _profile = bufferObject->getProfile(); 
    7585 
    7686        _dirty = true; 
     
    8090    else 
    8191    { 
    82         _target = 0; 
    83         _usage = 0; 
    84  
    85         _totalSize = 0; 
     92        _profile.setProfile(0,0,0); 
    8693 
    8794        // clear all previous entries; 
     
    101108 
    102109    _bufferEntries.reserve(_bufferObject->getNumBufferData()); 
    103  
    104     _totalSize = 0; 
    105110 
    106111    bool compileAll = false; 
     
    156161    } 
    157162 
     163 
    158164    if (i<_bufferEntries.size()) 
    159165    { 
     
    162168    } 
    163169 
    164     _extensions->glBindBuffer(_target, _glObjectID); 
    165  
    166     if (newTotalSize != _totalSize) 
    167     { 
    168         _totalSize = newTotalSize; 
    169         _extensions->glBufferData(_target, _totalSize, NULL, _usage); 
     170    _extensions->glBindBuffer(_profile._target, _glObjectID); 
     171 
     172    if (newTotalSize > _profile._size) 
     173    { 
     174        osg::notify(osg::NOTICE)<<"newTotalSize="<<newTotalSize<<", _profile._size="<<_profile._size<<std::endl; 
     175 
     176        _profile._size = newTotalSize; 
     177        if (_set) 
     178        { 
     179            // remove self from original set 
     180            _set->remove(this); 
     181 
     182            // get the new set for the new profile 
     183            _set = _set->getParent()->getGLBufferObjectSet(_profile); 
     184 
     185            // register self with new set. 
     186            _set->addToBack(this); 
     187        } 
     188 
     189    } 
     190 
     191    if (_allocatedSize != _profile._size) 
     192    { 
     193        _allocatedSize = _profile._size; 
     194        _extensions->glBufferData(_profile._target, _profile._size, NULL, _profile._usage); 
    170195    } 
    171196 
     
    189214                memcpy(vboMemory + (GLsizeiptrARB)entry.offset, entry.dataSource->getDataPointer(), entry.dataSize); 
    190215            else 
    191                 _extensions->glBufferSubData(_target, (GLintptrARB)entry.offset, (GLsizeiptrARB)entry.dataSize, entry.dataSource->getDataPointer()); 
     216                _extensions->glBufferSubData(_profile._target, (GLintptrARB)entry.offset, (GLsizeiptrARB)entry.dataSize, entry.dataSource->getDataPointer()); 
    192217 
    193218        } 
     
    195220 
    196221    // Unmap the texture image buffer 
    197     if (vboMemory) _extensions->glUnmapBuffer(_target); 
    198 } 
    199  
    200 GLBufferObject* GLBufferObject::createGLBufferObject(unsigned int contextID, const BufferObject* bufferObject) 
    201 { 
    202     return new GLBufferObject(contextID, const_cast<BufferObject*>(bufferObject)); 
     222    if (vboMemory) _extensions->glUnmapBuffer(_profile._target); 
     223 
     224 
    203225} 
    204226 
     
    210232        _glObjectID = 0; 
    211233 
    212         _totalSize = 0; 
     234        _allocatedSize = 0; 
    213235        _bufferEntries.clear(); 
    214236    } 
    215237} 
    216238 
    217  
    218239void GLBufferObject::deleteBufferObject(unsigned int contextID,GLuint globj) 
    219240{ 
    220     if (globj!=0) 
    221     { 
    222         OpenThreads::ScopedLock<OpenThreads::Mutex> lock(s_mutex_deletedBufferObjectCache); 
    223  
    224         // insert the globj into the cache for the appropriate context. 
    225         s_deletedBufferObjectCache[contextID].insert(BufferObjectMap::value_type(0,globj)); 
    226     } 
    227 } 
     241    osg::notify(osg::NOTICE)<<"GLBufferObject::deleteBufferObject("<<std::endl; 
     242} 
     243#if 0 
    228244 
    229245void GLBufferObject::flushDeletedBufferObjects(unsigned int contextID,double /*currentTime*/, double& availableTime) 
     
    269285    dll.clear(); 
    270286} 
    271  
     287#endif 
    272288////////////////////////////////////////////////////////////////////////////// 
    273289// 
     
    420436} 
    421437 
    422 #if 1 
    423  
    424438////////////////////////////////////////////////////////////////////////////////////////////////////// 
    425439// 
     440// GLBufferObjectSet 
     441// 
     442GLBufferObjectSet::GLBufferObjectSet(GLBufferObjectManager* parent, const BufferObjectProfile& profile): 
     443    _parent(parent), 
     444    _contextID(parent->getContextID()), 
     445    _profile(profile), 
     446    _numOfGLBufferObjects(0), 
     447    _head(0), 
     448    _tail(0) 
     449{ 
     450    osg::notify(osg::NOTICE)<<"GLBufferObjectSet::GLBufferObjectSet _profile._size="<<_profile._size<<std::endl; 
     451} 
     452 
     453GLBufferObjectSet::~GLBufferObjectSet() 
     454{ 
     455#if 0 
     456    osg::notify(osg::NOTICE)<<"GLBufferObjectSet::~GLBufferObjectSet(), _numOfGLBufferObjects="<<_numOfGLBufferObjects<<std::endl; 
     457    osg::notify(osg::NOTICE)<<"     _orphanedGLBufferObjects = "<<_orphanedGLBufferObjects.size()<<std::endl; 
     458    osg::notify(osg::NOTICE)<<"     _head = "<<_head<<std::endl; 
     459    osg::notify(osg::NOTICE)<<"     _tail = "<<_tail<<std::endl; 
     460#endif 
     461} 
     462 
     463bool GLBufferObjectSet::checkConsistency() const 
     464{ 
     465    return true; 
     466 
     467    // osg::notify(osg::NOTICE)<<"GLBufferObjectSet::checkConsistency()"<<std::endl; 
     468    // check consistency of linked list. 
     469    unsigned int numInList = 0; 
     470    GLBufferObject* to = _head; 
     471    while(to!=0) 
     472    { 
     473        ++numInList; 
     474 
     475        if (to->_next) 
     476        { 
     477            if ((to->_next)->_previous != to) 
     478            { 
     479                osg::notify(osg::NOTICE)<<"Error (to->_next)->_previous != to "<<std::endl; 
     480                throw "Error (to->_next)->_previous != to "; 
     481            } 
     482        } 
     483        else 
     484        { 
     485            if (_tail != to) 
     486            { 
     487                osg::notify(osg::NOTICE)<<"Error _trail != to"<<std::endl; 
     488                throw "Error _trail != to"; 
     489            } 
     490        } 
     491 
     492        to = to->_next; 
     493    } 
     494 
     495    unsigned int totalNumber = numInList + _orphanedGLBufferObjects.size(); 
     496    if (totalNumber != _numOfGLBufferObjects) 
     497    { 
     498        osg::notify(osg::NOTICE)<<"Error numInList + _orphanedGLBufferObjects.size() != _numOfGLBufferObjects"<<std::endl; 
     499        osg::notify(osg::NOTICE)<<"    numInList = "<<numInList<<std::endl; 
     500        osg::notify(osg::NOTICE)<<"    _orphanedGLBufferObjects.size() = "<<_orphanedGLBufferObjects.size()<<std::endl; 
     501        osg::notify(osg::NOTICE)<<"    _pendingOrphanedGLBufferObjects.size() = "<<_pendingOrphanedGLBufferObjects.size()<<std::endl; 
     502        osg::notify(osg::NOTICE)<<"    _numOfGLBufferObjects = "<<_numOfGLBufferObjects<<std::endl; 
     503        throw "Error numInList + _orphanedGLBufferObjects.size() != _numOfGLBufferObjects"; 
     504    } 
     505 
     506    return true; 
     507} 
     508 
     509void GLBufferObjectSet::handlePendingOrphandedGLBufferObjects() 
     510{ 
     511//    osg::notify(osg::NOTICE)<<"handlePendingOrphandedGLBufferObjects()"<<_pendingOrphanedGLBufferObjects.size()<<std::endl; 
     512 
     513    if (_pendingOrphanedGLBufferObjects.empty()) return; 
     514 
     515    unsigned int numOrphaned = _pendingOrphanedGLBufferObjects.size(); 
     516 
     517    for(GLBufferObjectList::iterator itr = _pendingOrphanedGLBufferObjects.begin(); 
     518        itr != _pendingOrphanedGLBufferObjects.end(); 
     519        ++itr) 
     520    { 
     521        GLBufferObject* to = itr->get(); 
     522 
     523        _orphanedGLBufferObjects.push_back(to); 
     524 
     525        remove(to); 
     526 
     527#if 0 
     528        osg::notify(osg::NOTICE)<<"  HPOTO  after  _head = "<<_head<<std::endl; 
     529        osg::notify(osg::NOTICE)<<"  HPOTO  after _tail = "<<_tail<<std::endl; 
     530        osg::notify(osg::NOTICE)<<"  HPOTO  after to->_previous = "<<to->_previous<<std::endl; 
     531        osg::notify(osg::NOTICE)<<"  HPOTO  after to->_next = "<<to->_next<<std::endl; 
     532#endif 
     533 
     534    } 
     535 
     536 
     537    // update the GLBufferObjectManager's running total of active + orphaned GLBufferObjects 
     538    _parent->getNumberOrphanedGLBufferObjects() += numOrphaned; 
     539    _parent->getNumberActiveGLBufferObjects() -= numOrphaned; 
     540 
     541    _pendingOrphanedGLBufferObjects.clear(); 
     542 
     543    checkConsistency(); 
     544} 
     545 
     546void GLBufferObjectSet::flushAllDeletedGLBufferObjects() 
     547{ 
     548    for(GLBufferObjectList::iterator itr = _orphanedGLBufferObjects.begin(); 
     549        itr != _orphanedGLBufferObjects.end(); 
     550        ++itr) 
     551    { 
     552 
     553        (*itr)->deleteGLObject(); 
     554 
     555        osg::notify(osg::NOTICE)<<"Deleting textureobject id="<<(*itr)->getGLObjectID()<<std::endl; 
     556    } 
     557 
     558    unsigned int numDeleted = _orphanedGLBufferObjects.size(); 
     559    _numOfGLBufferObjects -= numDeleted; 
     560 
     561    // update the GLBufferObjectManager's running total of current pool size 
     562    _parent->getCurrGLBufferObjectPoolSize() -= numDeleted*_profile._size; 
     563    _parent->getNumberOrphanedGLBufferObjects() -= numDeleted; 
     564    _parent->getNumberDeleted() += numDeleted; 
     565 
     566    _orphanedGLBufferObjects.clear(); 
     567} 
     568 
     569void GLBufferObjectSet::discardAllDeletedGLBufferObjects() 
     570{ 
     571    unsigned int numDiscarded = _orphanedGLBufferObjects.size(); 
     572 
     573    _numOfGLBufferObjects -= numDiscarded; 
     574 
     575    // update the GLBufferObjectManager's running total of current pool size 
     576    _parent->setCurrGLBufferObjectPoolSize( _parent->getCurrGLBufferObjectPoolSize() - numDiscarded*_profile._size ); 
     577 
     578    // update the number of active and orphaned TextureOjects 
     579    _parent->getNumberOrphanedGLBufferObjects() -= 1; 
     580    _parent->getNumberActiveGLBufferObjects() += 1; 
     581    _parent->getNumberDeleted() += 1; 
     582 
     583 
     584    // just clear the list as there is nothing else we can do with them when discarding them 
     585    _orphanedGLBufferObjects.clear(); 
     586} 
     587 
     588void GLBufferObjectSet::flushDeletedGLBufferObjects(double currentTime, double& availableTime) 
     589{ 
     590    // if nothing to delete return 
     591    if (_orphanedGLBufferObjects.empty()) return; 
     592 
     593    // if no time available don't try to flush objects. 
     594    if (availableTime<=0.0) return; 
     595 
     596    // if we don't have too many orphaned texture objects then don't bother deleting them, as we can potentially reuse them later. 
     597    if (_parent->getNumberOrphanedGLBufferObjects()<=s_minimumNumberOfGLBufferObjectsToRetainInCache) return; 
     598 
     599    unsigned int numDeleted = 0; 
     600    unsigned int maxNumObjectsToDelete = _parent->getNumberOrphanedGLBufferObjects()-s_minimumNumberOfGLBufferObjectsToRetainInCache; 
     601    if (maxNumObjectsToDelete>4) maxNumObjectsToDelete = 4; 
     602 
     603    ElapsedTime timer; 
     604 
     605    GLBufferObjectList::iterator itr = _orphanedGLBufferObjects.begin(); 
     606    for(; 
     607        itr != _orphanedGLBufferObjects.end() && timer.elapsedTime()<availableTime && numDeleted<maxNumObjectsToDelete; 
     608        ++itr) 
     609    { 
     610 
     611        osg::notify(osg::NOTICE)<<"Deleting textureobject id="<<itr->get()<<std::endl; 
     612 
     613         (*itr)->deleteGLObject(); 
     614 
     615        ++numDeleted; 
     616    } 
     617 
     618    // osg::notify(osg::NOTICE)<<"Size before = "<<_orphanedGLBufferObjects.size(); 
     619    _orphanedGLBufferObjects.erase(_orphanedGLBufferObjects.begin(), itr); 
     620    //osg::notify(osg::NOTICE)<<", after = "<<_orphanedGLBufferObjects.size()<<" numDeleted = "<<numDeleted<<std::endl; 
     621 
     622    // update the number of TO's in this GLBufferObjectSet 
     623    _numOfGLBufferObjects -= numDeleted; 
     624 
     625    _parent->setCurrGLBufferObjectPoolSize( _parent->getCurrGLBufferObjectPoolSize() - numDeleted*_profile._size ); 
     626 
     627    // update the number of active and orphaned TextureOjects 
     628    _parent->getNumberOrphanedGLBufferObjects() -= numDeleted; 
     629    _parent->getNumberActiveGLBufferObjects() += numDeleted; 
     630    _parent->getNumberDeleted() += numDeleted; 
     631 
     632    availableTime -= timer.elapsedTime(); 
     633} 
     634 
     635bool GLBufferObjectSet::makeSpace(unsigned int& size) 
     636{ 
     637    if (!_orphanedGLBufferObjects.empty()) 
     638    { 
     639        unsigned int sizeAvailable = _orphanedGLBufferObjects.size() * _profile._size; 
     640        if (size>sizeAvailable) size -= sizeAvailable; 
     641        else size = 0; 
     642 
     643        flushAllDeletedGLBufferObjects(); 
     644    } 
     645 
     646    return size==0; 
     647} 
     648 
     649GLBufferObject* GLBufferObjectSet::takeFromOrphans(BufferObject* bufferObject) 
     650{ 
     651    // take front of orphaned list. 
     652    ref_ptr<GLBufferObject> glbo = _orphanedGLBufferObjects.front(); 
     653 
     654    // remove from orphan list. 
     655    _orphanedGLBufferObjects.pop_front(); 
     656 
     657    // assign to new texture 
     658    glbo->assign(bufferObject); 
     659    glbo->setProfile(_profile); 
     660 
     661    // update the number of active and orphaned TextureOjects 
     662    _parent->getNumberOrphanedGLBufferObjects() -= 1; 
     663    _parent->getNumberActiveGLBufferObjects() += 1; 
     664 
     665    // place at back of active list 
     666    addToBack(glbo.get()); 
     667 
     668    // osg::notify(osg::NOTICE)<<"Reusing orhpahned GLBufferObject, _numOfGLBufferObjects="<<_numOfGLBufferObjects<<std::endl; 
     669 
     670    return glbo.release(); 
     671} 
     672 
     673 
     674GLBufferObject* GLBufferObjectSet::takeOrGenerate(BufferObject* bufferObject) 
     675{ 
     676    // see if we can recyle GLBufferObject from the orphane list 
     677    if (!_pendingOrphanedGLBufferObjects.empty()) 
     678    { 
     679        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex); 
     680        handlePendingOrphandedGLBufferObjects(); 
     681        return takeFromOrphans(bufferObject); 
     682    } 
     683    else if (!_orphanedGLBufferObjects.empty()) 
     684    { 
     685        return takeFromOrphans(bufferObject); 
     686    } 
     687 
     688    unsigned int minFrameNumber = _parent->getFrameNumber(); 
     689 
     690    // see if we can reuse GLBufferObject by taking the least recently used active GLBufferObject 
     691    if ((_parent->getMaxGLBufferObjectPoolSize()!=0) && 
     692        (!_parent->hasSpace(_profile._size)) && 
     693        (_numOfGLBufferObjects>1) && 
     694        (_head != 0) && 
     695        (_head->_frameLastUsed<minFrameNumber)) 
     696    { 
     697 
     698        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex); 
     699 
     700        ref_ptr<GLBufferObject> glbo = _head; 
     701 
     702        ref_ptr<BufferObject> original_BufferObject = glbo->getBufferObject(); 
     703 
     704        if (original_BufferObject.valid()) 
     705        { 
     706            original_BufferObject->setGLBufferObject(_contextID,0); 
     707            // osg::notify(osg::NOTICE)<<"GLBufferObjectSet="<<this<<": Reusing an active GLBufferObject "<<glbo.get()<<" _numOfGLBufferObjects="<<_numOfGLBufferObjects<<" size="<<_profile._size<<std::endl; 
     708        } 
     709        else 
     710        { 
     711            // osg::notify(osg::NOTICE)<<"Reusing a recently orphaned active GLBufferObject "<<glbo.get()<<std::endl; 
     712        } 
     713 
     714        moveToBack(glbo.get()); 
     715 
     716        // assign to new texture 
     717        glbo->setBufferObject(bufferObject); 
     718        glbo->setProfile(_profile); 
     719 
     720        return glbo.release(); 
     721    } 
     722 
     723    // 
     724    GLBufferObject* glbo = new GLBufferObject(_contextID, const_cast<BufferObject*>(bufferObject)); 
     725    glbo->setProfile(_profile); 
     726    glbo->_set = this; 
     727    ++_numOfGLBufferObjects; 
     728 
     729    // update the current texture pool size 
     730    _parent->getCurrGLBufferObjectPoolSize() += _profile._size; 
     731    _parent->getNumberActiveGLBufferObjects() += 1; 
     732 
     733    addToBack(glbo); 
     734 
     735    // osg::notify(osg::NOTICE)<<"Created new GLBufferObject, _numOfGLBufferObjects "<<_numOfGLBufferObjects<<std::endl; 
     736 
     737    return glbo; 
     738} 
     739 
     740void GLBufferObjectSet::moveToBack(GLBufferObject* to) 
     741{ 
     742#if 0 
     743    osg::notify(osg::NOTICE)<<"GLBufferObjectSet::moveToBack("<<to<<")"<<std::endl; 
     744    osg::notify(osg::NOTICE)<<"    before _head = "<<_head<<std::endl; 
     745    osg::notify(osg::NOTICE)<<"    before _tail = "<<_tail<<std::endl; 
     746    osg::notify(osg::NOTICE)<<"    before to->_previous = "<<to->_previous<<std::endl; 
     747    osg::notify(osg::NOTICE)<<"    before to->_next = "<<to->_next<<std::endl; 
     748#endif 
     749 
     750    to->_frameLastUsed = _parent->getFrameNumber(); 
     751 
     752    // nothing to do if we are already tail 
     753    if (to==_tail) return; 
     754 
     755    // if no tail exists then assign 'to' as tail and head 
     756    if (_tail==0) 
     757    { 
     758        osg::notify(osg::NOTICE)<<"Error ***************** Should not get here !!!!!!!!!"<<std::endl; 
     759        _head = to; 
     760        _tail = to; 
     761        return; 
     762    } 
     763 
     764    if (to->_next==0) 
     765    { 
     766        osg::notify(osg::NOTICE)<<"Error ***************** Should not get here either !!!!!!!!!"<<std::endl; 
     767        return; 
     768    } 
     769 
     770 
     771    if (to->_previous) 
     772    { 
     773        (to->_previous)->_next = to->_next; 
     774    } 
     775    else 
     776    { 
     777        // 'to' is the head, so moving it to the back will mean we need a new head 
     778        if (to->_next) 
     779        { 
     780            _head = to->_next; 
     781        } 
     782    } 
     783 
     784    (to->_next)->_previous = to->_previous; 
     785 
     786    _tail->_next = to; 
     787 
     788    to->_previous = _tail; 
     789    to->_next = 0; 
     790 
     791    _tail = to; 
     792 
     793#if 0 
     794    osg::notify(osg::NOTICE)<<"  m2B   after  _head = "<<_head<<std::endl; 
     795    osg::notify(osg::NOTICE)<<"  m2B   after _tail = "<<_tail<<std::endl; 
     796    osg::notify(osg::NOTICE)<<"  m2B   after to->_previous = "<<to->_previous<<std::endl; 
     797    osg::notify(osg::NOTICE)<<"  m2B   after to->_next = "<<to->_next<<std::endl; 
     798#endif 
     799    checkConsistency(); 
     800} 
     801 
     802void GLBufferObjectSet::addToBack(GLBufferObject* to) 
     803{ 
     804#if 0 
     805    osg::notify(osg::NOTICE)<<"GLBufferObjectSet::addToBack("<<to<<")"<<std::endl; 
     806    osg::notify(osg::NOTICE)<<"    before _head = "<<_head<<std::endl; 
     807    osg::notify(osg::NOTICE)<<"    before _tail = "<<_tail<<std::endl; 
     808    osg::notify(osg::NOTICE)<<"    before to->_previous = "<<to->_previous<<std::endl; 
     809    osg::notify(osg::NOTICE)<<"    before to->_next = "<<to->_next<<std::endl; 
     810#endif 
     811 
     812    if (to->_previous !=0 || to->_next !=0) 
     813    { 
     814        moveToBack(to); 
     815    } 
     816    else 
     817    { 
     818        to->_frameLastUsed = _parent->getFrameNumber(); 
     819 
     820        if (_tail) _tail->_next = to; 
     821        to->_previous = _tail; 
     822 
     823        if (!_head) _head = to; 
     824        _tail = to; 
     825    } 
     826#if 0 
     827    osg::notify(osg::NOTICE)<<"  a2B  after  _head = "<<_head<<std::endl; 
     828    osg::notify(osg::NOTICE)<<"  a2B   after _tail = "<<_tail<<std::endl; 
     829    osg::notify(osg::NOTICE)<<"  a2B   after to->_previous = "<<to->_previous<<std::endl; 
     830    osg::notify(osg::NOTICE)<<"  a2B   after to->_next = "<<to->_next<<std::endl; 
     831#endif 
     832    checkConsistency(); 
     833} 
     834 
     835void GLBufferObjectSet::orphan(GLBufferObject* to) 
     836{ 
     837    // osg::notify(osg::NOTICE)<<"GLBufferObjectSet::orphan("<<to<<")"<<std::endl; 
     838 
     839    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex); 
     840 
     841    // disconnect from original texture 
     842    to->setBufferObject(0); 
     843 
     844    // add orphan 'to' to the pending list of orphans, these will then be 
     845    // handled in the handlePendingOrphandedGLBufferObjects() where the TO's 
     846    // will be removed from the active list, and then placed in the orhpanGLBufferObject 
     847    // list.  This double buffered approach to handling orphaned TO's is used 
     848    // to avoid having to mutex the process of appling active TO's. 
     849    _pendingOrphanedGLBufferObjects.push_back(to); 
     850 
     851#if 0 
     852    osg::notify(osg::NOTICE)<<"GLBufferObjectSet::orphan("<<to<<")  _pendingOrphanedGLBufferObjects.size()="<<_pendingOrphanedGLBufferObjects.size()<<std::endl; 
     853    osg::notify(osg::NOTICE)<<"                                    _orphanedGLBufferObjects.size()="<<_orphanedGLBufferObjects.size()<<std::endl; 
     854#endif 
     855} 
     856 
     857void GLBufferObjectSet::remove(GLBufferObject* to) 
     858{ 
     859    if (to->_previous!=0) 
     860    { 
     861        (to->_previous)->_next = to->_next; 
     862    } 
     863    else 
     864    { 
     865        // 'to' was head so assign _head to the next in list 
     866        _head = to->_next; 
     867    } 
     868 
     869    if (to->_next!=0) 
     870    { 
     871        (to->_next)->_previous = to->_previous; 
     872    } 
     873    else 
     874    { 
     875        // 'to' was tail so assing tail to the previous in list 
     876        _tail = to->_previous; 
     877    } 
     878 
     879    // reset the 'to' list pointers as it's no longer in the active list. 
     880    to->_next = 0; 
     881    to->_previous = 0; 
     882} 
     883 
     884 
     885GLBufferObjectManager::GLBufferObjectManager(unsigned int contextID): 
     886    _contextID(contextID), 
     887    _numActiveGLBufferObjects(0), 
     888    _numOrphanedGLBufferObjects(0), 
     889    _currGLBufferObjectPoolSize(0), 
     890    _maxGLBufferObjectPoolSize(0), 
     891    _frameNumber(0), 
     892    _numFrames(0), 
     893    _numDeleted(0), 
     894    _deleteTime(0.0), 
     895    _numGenerated(0), 
     896    _generateTime(0.0), 
     897    _numApplied(0), 
     898    _applyTime(0.0) 
     899{ 
     900} 
     901 
     902void GLBufferObjectManager::setMaxGLBufferObjectPoolSize(unsigned int size) 
     903{ 
     904    if (_maxGLBufferObjectPoolSize == size) return; 
     905 
     906    if (size<_currGLBufferObjectPoolSize) 
     907    { 
     908        osg::notify(osg::NOTICE)<<"Warning: new MaxGLBufferObjectPoolSize="<<size<<" is smaller than current GLBufferObjectPoolSize="<<_currGLBufferObjectPoolSize<<std::endl; 
     909    } 
     910 
     911    _maxGLBufferObjectPoolSize = size; 
     912} 
     913 
     914bool GLBufferObjectManager::makeSpace(unsigned int size) 
     915{ 
     916    for(GLBufferObjectSetMap::iterator itr = _glBufferObjectSetMap.begin(); 
     917        itr != _glBufferObjectSetMap.end() && size>0; 
     918        ++itr) 
     919    { 
     920        if ((*itr).second->makeSpace(size)) return true; 
     921    } 
     922 
     923    return size==0; 
     924} 
     925 
     926 
     927GLBufferObject* GLBufferObjectManager::generateGLBufferObject(const BufferObject* bufferObject) 
     928{ 
     929    ElapsedTime elapsedTime(&(getGenerateTime())); 
     930    ++getNumberGenerated(); 
     931 
     932    BufferObjectProfile profile(bufferObject->getTarget(), bufferObject->getUsage(), bufferObject->computeRequiredBufferSize()); 
     933 
     934    // osg::notify(osg::NOTICE)<<"GLBufferObjectManager::generateGLBufferObject size="<<bufferObject->computeRequiredBufferSize()<<std::endl; 
     935 
     936    GLBufferObjectSet* glbos = getGLBufferObjectSet(profile); 
     937    return glbos->takeOrGenerate(const_cast<BufferObject*>(bufferObject)); 
     938} 
     939 
     940GLBufferObjectSet* GLBufferObjectManager::getGLBufferObjectSet(const BufferObjectProfile& profile) 
     941{ 
     942    osg::ref_ptr<GLBufferObjectSet>& tos = _glBufferObjectSetMap[profile]; 
     943    if (!tos) tos = new GLBufferObjectSet(this, profile); 
     944    return tos.get(); 
     945} 
     946 
     947void GLBufferObjectManager::handlePendingOrphandedGLBufferObjects() 
     948{ 
     949    for(GLBufferObjectSetMap::iterator itr = _glBufferObjectSetMap.begin(); 
     950        itr != _glBufferObjectSetMap.end(); 
     951        ++itr) 
     952    { 
     953        (*itr).second->handlePendingOrphandedGLBufferObjects(); 
     954    } 
     955} 
     956 
     957void GLBufferObjectManager::flushAllDeletedGLBufferObjects() 
     958{ 
     959    ElapsedTime elapsedTime(&(getDeleteTime())); 
     960 
     961    for(GLBufferObjectSetMap::iterator itr = _glBufferObjectSetMap.begin(); 
     962        itr != _glBufferObjectSetMap.end(); 
     963        ++itr) 
     964    { 
     965        (*itr).second->flushAllDeletedGLBufferObjects(); 
     966    } 
     967} 
     968 
     969void GLBufferObjectManager::discardAllDeletedGLBufferObjects() 
     970{ 
     971    for(GLBufferObjectSetMap::iterator itr = _glBufferObjectSetMap.begin(); 
     972        itr != _glBufferObjectSetMap.end(); 
     973        ++itr) 
     974    { 
     975        (*itr).second->discardAllDeletedGLBufferObjects(); 
     976    } 
     977} 
     978 
     979void GLBufferObjectManager::flushDeletedGLBufferObjects(double currentTime, double& availableTime) 
     980{ 
     981    ElapsedTime elapsedTime(&(getDeleteTime())); 
     982 
     983    for(GLBufferObjectSetMap::iterator itr = _glBufferObjectSetMap.begin(); 
     984        (itr != _glBufferObjectSetMap.end()) && (availableTime > 0.0); 
     985        ++itr) 
     986    { 
     987        (*itr).second->flushDeletedGLBufferObjects(currentTime, availableTime); 
     988    } 
     989} 
     990 
     991void GLBufferObjectManager::releaseGLBufferObject(GLBufferObject* to) 
     992{ 
     993    if (to->_set) to->_set->orphan(to); 
     994    else osg::notify(osg::NOTICE)<<"GLBufferObjectManager::releaseGLBufferObject(GLBufferObject* to) Not implemented yet"<<std::endl; 
     995} 
     996 
     997 
     998void GLBufferObjectManager::newFrame(osg::FrameStamp* fs) 
     999{ 
     1000    if (fs) _frameNumber = fs->getFrameNumber(); 
     1001    else ++_frameNumber; 
     1002 
     1003    ++_numFrames; 
     1004} 
     1005 
     1006void GLBufferObjectManager::reportStats() 
     1007{ 
     1008    double numFrames(_numFrames==0 ? 1.0 : _numFrames); 
     1009    osg::notify(osg::NOTICE)<<"GLBufferObjectMananger::reportStats()"<<std::endl; 
     1010    osg::notify(osg::NOTICE)<<"   total _numOfGLBufferObjects="<<_numActiveGLBufferObjects<<", _numOrphanedGLBufferObjects="<<_numOrphanedGLBufferObjects<<" _currGLBufferObjectPoolSize="<<_currGLBufferObjectPoolSize<<std::endl; 
     1011    osg::notify(osg::NOTICE)<<"   total _numGenerated="<<_numGenerated<<", _generateTime="<<_generateTime<<", averagePerFrame="<<_generateTime/numFrames*1000.0<<"ms"<<std::endl; 
     1012    osg::notify(osg::NOTICE)<<"   total _numDeleted="<<_numDeleted<<", _deleteTime="<<_deleteTime<<", averagePerFrame="<<_deleteTime/numFrames*1000.0<<"ms"<<std::endl; 
     1013    osg::notify(osg::NOTICE)<<"   total _numApplied="<<_numApplied<<", _applyTime="<<_applyTime<<", averagePerFrame="<<_applyTime/numFrames*1000.0<<"ms"<<std::endl; 
     1014} 
     1015 
     1016void GLBufferObjectManager::resetStats() 
     1017{ 
     1018    _numFrames = 0; 
     1019    _numDeleted = 0; 
     1020    _deleteTime = 0; 
     1021 
     1022    _numGenerated = 0; 
     1023    _generateTime = 0; 
     1024 
     1025    _numApplied = 0; 
     1026    _applyTime = 0; 
     1027} 
     1028 
     1029 
     1030 
     1031osg::ref_ptr<GLBufferObjectManager>& GLBufferObjectManager::getGLBufferObjectManager(unsigned int contextID) 
     1032{ 
     1033    typedef osg::buffered_object< ref_ptr<GLBufferObjectManager> > GLBufferObjectManagerBuffer; 
     1034    static GLBufferObjectManagerBuffer s_GLBufferObjectManager; 
     1035    if (!s_GLBufferObjectManager[contextID]) s_GLBufferObjectManager[contextID] = new GLBufferObjectManager(contextID); 
     1036    return s_GLBufferObjectManager[contextID]; 
     1037} 
     1038 
     1039GLBufferObject* GLBufferObject::createGLBufferObject(unsigned int contextID, const BufferObject* bufferObject) 
     1040{ 
     1041    return GLBufferObjectManager::getGLBufferObjectManager(contextID)->generateGLBufferObject(bufferObject); 
     1042} 
     1043 
     1044void GLBufferObject::flushAllDeletedBufferObjects(unsigned int contextID) 
     1045{ 
     1046    GLBufferObjectManager::getGLBufferObjectManager(contextID)->flushAllDeletedGLBufferObjects(); 
     1047} 
     1048 
     1049void GLBufferObject::discardAllDeletedBufferObjects(unsigned int contextID) 
     1050{ 
     1051    GLBufferObjectManager::getGLBufferObjectManager(contextID)->discardAllDeletedGLBufferObjects(); 
     1052} 
     1053 
     1054void GLBufferObject::flushDeletedBufferObjects(unsigned int contextID,double currentTime, double& availbleTime) 
     1055{ 
     1056    GLBufferObjectManager::getGLBufferObjectManager(contextID)->flushDeletedGLBufferObjects(currentTime, availbleTime); 
     1057} 
     1058 
     1059void GLBufferObject::releaseGLBufferObject(unsigned int contextID, GLBufferObject* to) 
     1060{ 
     1061    GLBufferObjectManager::getGLBufferObjectManager(contextID)->releaseGLBufferObject(to); 
     1062} 
     1063 
     1064 
     1065 
     1066////////////////////////////////////////////////////////////////////////////////////////////////////// 
     1067// 
    4261068// BufferObject 
    4271069// 
    428 BufferObject::BufferObject(): 
    429     _target(0), 
    430     _usage(0) 
     1070BufferObject::BufferObject() 
    4311071{ 
    4321072} 
     
    4421082} 
    4431083 
     1084 
    4441085void BufferObject::setBufferData(unsigned int index, BufferData* bd) 
    4451086{ 
     
    4651106    if (state) 
    4661107    { 
    467         _glBufferObjects[state->getContextID()] = 0; 
     1108        unsigned int contextID = state->getContextID(); 
     1109        if (_glBufferObjects[contextID].valid()) 
     1110        { 
     1111            GLBufferObject::releaseGLBufferObject(contextID, _glBufferObjects[contextID].get()); 
     1112            _glBufferObjects[contextID] = 0; 
     1113        } 
    4681114    } 
    4691115    else 
    4701116    { 
    471         _glBufferObjects.clear(); 
     1117        for(unsigned int i=0; i<_glBufferObjects.size();++i) 
     1118        { 
     1119            if (_glBufferObjects[i].valid()) 
     1120            { 
     1121                GLBufferObject::releaseGLBufferObject(i, _glBufferObjects[i].get()); 
     1122                _glBufferObjects[i] = 0; 
     1123            } 
     1124        } 
    4721125    } 
    4731126} 
     
    5291182} 
    5301183 
     1184unsigned int BufferObject::computeRequiredBufferSize() const 
     1185{ 
     1186    unsigned int newTotalSize = 0; 
     1187    for(BufferDataList::const_iterator itr = _bufferDataList.begin(); 
     1188        itr != _bufferDataList.end(); 
     1189        ++itr) 
     1190    { 
     1191        BufferData* bd = *itr; 
     1192        newTotalSize += bd->getTotalDataSize(); 
     1193    } 
     1194    return newTotalSize; 
     1195} 
     1196 
    5311197////////////////////////////////////////////////////////////////////////////////////////////////////// 
    5321198// 
     
    5571223VertexBufferObject::VertexBufferObject() 
    5581224{ 
    559     _target = GL_ARRAY_BUFFER_ARB; 
    560     _usage = GL_STATIC_DRAW_ARB; 
     1225    setTarget(GL_ARRAY_BUFFER_ARB); 
     1226    setUsage(GL_STATIC_DRAW_ARB); 
    5611227//    _usage = GL_DYNAMIC_DRAW_ARB; 
    5621228//    _usage = GL_STREAM_DRAW_ARB; 
     
    5961262    return dynamic_cast<const osg::Array*>(getBufferData(i)); 
    5971263} 
    598 #if 0 
    599 void VertexBufferObject::compileBuffer(State& state) const 
    600 { 
    601     unsigned int contextID = state.getContextID(); 
    602  
    603     _compiledList[contextID] = 1; 
    604  
    605     Extensions* extensions = getExtensions(contextID,true); 
    606  
    607     // osg::notify(osg::NOTICE)<<"VertexBufferObject::compileBuffer frameNumber="<<state.getFrameStamp()->getFrameNumber()<<std::endl; 
    608  
    609     unsigned int totalSizeRequired = 0; 
    610     unsigned int numNewArrays = 0; 
    611     for(BufferEntryArrayPairs::const_iterator itr = _bufferEntryArrayPairs.begin(); 
    612         itr != _bufferEntryArrayPairs.end(); 
    613         ++itr) 
    614     { 
    615         const BufferEntryArrayPair& bep = *itr; 
    616         if (bep.second) 
    617         { 
    618             totalSizeRequired += bep.second->getTotalDataSize(); 
    619             if (bep.first.dataSize == 0) ++numNewArrays; 
    620         } 
    621     } 
    622  
    623     bool copyAll = false; 
    624     GLuint& vbo = buffer(contextID); 
    625     if (vbo==0) 
    626     { 
    627         // building for the first time. 
    628  
    629         _totalSize = totalSizeRequired; 
    630  
    631         // don't generate buffer if size is zero. 
    632         if (_totalSize==0) return; 
    633  
    634         extensions->glGenBuffers(1, &vbo); 
    635         extensions->glBindBuffer(_target, vbo); 
    636         extensions->glBufferData(_target, _totalSize, NULL, _usage); 
    637  
    638         copyAll = true; 
    639     } 
    640     else 
    641     { 
    642         extensions->glBindBuffer(_target, vbo); 
    643  
    644         if (_totalSize != totalSizeRequired) 
    645         { 
    646             // resize vbo. 
    647             _totalSize = totalSizeRequired; 
    648             extensions->glBufferData(_target, _totalSize, NULL, _usage); 
    649  
    650             copyAll = true; 
    651         } 
    652     } 
    653  
    654     typedef std::map<unsigned int,std::vector<unsigned int> > SizePosMap_t; 
    655     SizePosMap_t freeList; 
    656     if (copyAll == false && numNewArrays > 0) 
    657     { 
    658         std::map<unsigned int,unsigned int> usedList; 
    659         for(BufferEntryArrayPairs::const_iterator itr = _bufferEntryArrayPairs.begin(); 
    660             itr != _bufferEntryArrayPairs.end(); 
    661             ++itr) 
    662         { 
    663             const BufferEntryArrayPair& bep = *itr; 
    664             if (bep.second==NULL) continue; 
    665             if (bep.first.dataSize == 0) continue; 
    666             usedList[bep.first.offset] = bep.first.dataSize; 
    667         } 
    668         unsigned int numFreeBlocks = 0; 
    669         unsigned int pos=0; 
    670  
    671         for (std::map<unsigned int,unsigned int>::const_iterator it=usedList.begin(); it!=usedList.end(); ++it) 
    672         { 
    673             unsigned int start = it->first; 
    674             unsigned int length = it->second; 
    675             if (pos < start) 
    676             { 
    677                 freeList[start-pos].push_back(pos); 
    678                 ++numFreeBlocks; 
    679             } 
    680             pos = start+length; 
    681         } 
    682         if (pos < totalSizeRequired) 
    683         { 
    684             freeList[totalSizeRequired-pos].push_back(pos); 
    685             ++numFreeBlocks; 
    686         } 
    687         if (numNewArrays < numFreeBlocks) 
    688         { 
    689             copyAll = true;     // too fragmented, fallback to copyAll 
    690             freeList.clear(); 
    691         } 
    692     } 
    693  
    694  
    695 //    osg::Timer_t start_tick = osg::Timer::instance()->tick(); 
    696  
    697  
    698     void* vboMemory = 0; 
    699  
    700 #if 0 
    701     vboMemory = extensions->glMapBuffer(_target, GL_WRITE_ONLY_ARB); 
    702 #endif 
    703  
    704     unsigned int offset = 0; 
    705     for(BufferEntryArrayPairs::const_iterator itr = _bufferEntryArrayPairs.begin(); 
    706         itr != _bufferEntryArrayPairs.end(); 
    707         ++itr) 
    708     { 
    709         const BufferEntryArrayPair& bep = *itr; 
    710         const Array* de = bep.second; 
    711         if (de) 
    712         { 
    713             const unsigned int arraySize = de->getTotalDataSize(); 
    714             if (copyAll || 
    715                 bep.first.modifiedCount[contextID] != bep.second->getModifiedCount() || 
    716                 bep.first.dataSize != arraySize) 
    717             { 
    718                 // copy data across 
    719                 unsigned int newOffset = bep.first.offset;               
    720                 if (copyAll) 
    721                 { 
    722                     newOffset = offset; 
    723                     offset += arraySize; 
    724                 } 
    725                 else if (bep.first.dataSize == 0) 
    726                 { 
    727                     SizePosMap_t::iterator findIt = freeList.lower_bound(arraySize); 
    728                     if (findIt==freeList.end()) 
    729                     { 
    730                         osg::notify(osg::FATAL)<<"No suitable Memory in VBO found!"<<std::endl; 
    731                         continue; 
    732                     } 
    733                     const unsigned int oldOffset = findIt->second.back(); 
    734                     newOffset = oldOffset; 
    735                     if (findIt->first > arraySize) // using larger block 
    736                     { 
    737                         freeList[findIt->first-arraySize].push_back(oldOffset+arraySize); 
    738                     } 
    739                     findIt->second.pop_back(); 
    740                     if (findIt->second.empty()) 
    741                     { 
    742                         freeList.erase(findIt); 
    743                     } 
    744                 } 
    745                 bep.first.dataSize = arraySize; 
    746                 bep.first.modifiedCount[contextID] = de->getModifiedCount(); 
    747                 bep.first.offset = newOffset; 
    748                 de->setVertexBufferObjectOffset((GLvoid*)newOffset); 
    749  
    750                 // osg::notify(osg::NOTICE)<<"   copying vertex buffer data "<<bep.first.dataSize<<" bytes"<<std::endl; 
    751  
    752                 if (vboMemory) 
    753                     memcpy((char*)vboMemory + bep.first.offset, de->getDataPointer(), bep.first.dataSize); 
    754                 else 
    755                     extensions->glBufferSubData(_target, bep.first.offset, bep.first.dataSize, de->getDataPointer()); 
    756  
    757             } 
    758         } 
    759     } 
    760  
    761  
    762     // Unmap the texture image buffer 
    763     if (vboMemory) extensions->glUnmapBuffer(_target); 
    764  
    765 //    osg::notify(osg::NOTICE)<<"pbo _totalSize="<<_totalSize<<std::endl; 
    766 //    osg::notify(osg::NOTICE)<<"pbo "<<osg::Timer::instance()->delta_m(start_tick,osg::Timer::instance()->tick())<<"ms"<<std::endl; 
    767 } 
    768 #endif 
    7691264 
    7701265////////////////////////////////////////////////////////////////////////////////// 
     
    7741269ElementBufferObject::ElementBufferObject() 
    7751270{ 
    776     _target = GL_ELEMENT_ARRAY_BUFFER_ARB; 
    777     _usage = GL_STATIC_DRAW_ARB; 
     1271    setTarget(GL_ELEMENT_ARRAY_BUFFER_ARB); 
     1272    setUsage(GL_STATIC_DRAW_ARB); 
    7781273} 
    7791274 
     
    8131308 
    8141309 
    815 #if 0 
    816 void ElementBufferObject::compileBuffer(State& state) const 
    817 { 
    818     unsigned int contextID = state.getContextID(); 
    819  
    820     _compiledList[contextID] = 1; 
    821  
    822     // osg::notify(osg::NOTICE)<<"ElementBufferObject::compile"<<std::endl; 
    823  
    824     Extensions* extensions = getExtensions(contextID,true); 
    825  
    826     unsigned int totalSizeRequired = 0; 
    827 //    unsigned int numModified = 0; 
    828 //    unsigned int numNotModified = 0; 
    829     for(BufferEntryDrawElementsPairs::const_iterator itr = _bufferEntryDrawElementsPairs.begin(); 
    830         itr != _bufferEntryDrawElementsPairs.end(); 
    831         ++itr) 
    832     { 
    833         const BufferEntryDrawElementsPair& bep = *itr; 
    834         if (bep.second) 
    835         { 
    836             totalSizeRequired += bep.second->getTotalDataSize(); 
    837         } 
    838     } 
    839  
    840     bool copyAll = false; 
    841     GLuint& ebo = buffer(contextID); 
    842     if (ebo==0) 
    843     { 
    844         // building for the first time. 
    845  
    846         _totalSize = totalSizeRequired; 
    847  
    848         // don't generate buffer if size is zero. 
    849         if (_totalSize==0) return; 
    850  
    851         extensions->glGenBuffers(1, &ebo); 
    852         extensions->glBindBuffer(_target, ebo); 
    853         extensions->glBufferData(_target, _totalSize, NULL, _usage); 
    854  
    855         copyAll = true; 
    856     } 
    857     else 
    858     { 
    859         extensions->glBindBuffer(_target, ebo); 
    860  
    861         if (_totalSize != totalSizeRequired) 
    862         { 
    863             // resize EBO. 
    864             _totalSize = totalSizeRequired; 
    865             extensions->glBufferData(_target, _totalSize, NULL, _usage); 
    866  
    867             copyAll = true; 
    868         } 
    869     } 
    870  
    871 //    osg::Timer_t start_tick = osg::Timer::instance()->tick(); 
    872  
    873  
    874     void* eboMemory = 0; 
    875  
    876 #if 0 
    877     eboMemory = extensions->glMapBuffer(_target, GL_WRITE_ONLY_ARB); 
    878 #endif 
    879  
    880     size_t offset = 0; 
    881     for(BufferEntryDrawElementsPairs::const_iterator itr = _bufferEntryDrawElementsPairs.begin(); 
    882         itr != _bufferEntryDrawElementsPairs.end(); 
    883         ++itr) 
    884     { 
    885         const BufferEntryDrawElementsPair& bep = *itr; 
    886         const DrawElements* de = bep.second; 
    887         if (de) 
    888         { 
    889             if (copyAll || 
    890                 bep.first.modifiedCount[contextID] != bep.second->getModifiedCount() || 
    891                 bep.first.dataSize != bep.second->getTotalDataSize()) 
    892             { 
    893                 // copy data across 
    894                 bep.first.dataSize = bep.second->getTotalDataSize(); 
    895                 bep.first.modifiedCount[contextID] = de->getModifiedCount(); 
    896                 if (copyAll) 
    897                 { 
    898                     bep.first.offset = offset; 
    899                     de->setElementBufferObjectOffset((GLvoid*)offset); 
    900                     offset += bep.first.dataSize; 
    901                 } 
    902  
    903                 if (eboMemory) 
    904                     memcpy((char*)eboMemory + bep.first.offset, de->getDataPointer(), bep.first.dataSize); 
    905                 else 
    906                     extensions->glBufferSubData(_target, bep.first.offset, bep.first.dataSize, de->getDataPointer()); 
    907  
    908             } 
    909         } 
    910     } 
    911  
    912  
    913     // Unmap the texture image buffer 
    914     if (eboMemory) extensions->glUnmapBuffer(_target); 
    915  
    916 //    osg::notify(osg::NOTICE)<<"pbo _totalSize="<<_totalSize<<std::endl; 
    917 //    osg::notify(osg::NOTICE)<<"pbo "<<osg::Timer::instance()->delta_m(start_tick,osg::Timer::instance()->tick())<<"ms"<<std::endl; 
    918 } 
    919 #endif 
    920  
    9211310////////////////////////////////////////////////////////////////////////////////// 
    9221311// 
     
    9261315    BufferObject() 
    9271316{ 
    928     _target = GL_PIXEL_UNPACK_BUFFER_ARB; 
    929     _usage = GL_STREAM_DRAW_ARB; 
     1317    setTarget(GL_PIXEL_UNPACK_BUFFER_ARB); 
     1318    setTarget(GL_STREAM_DRAW_ARB); 
    9301319 
    9311320    osg::notify(osg::NOTICE)<<"Constructing PixelBufferObject for image="<<image<<std::endl; 
     
    9581347} 
    9591348 
    960 #if 0 
    961 void PixelBufferObject::compileBuffer(State& state) const 
    962 { 
    963     unsigned int contextID = state.getContextID(); 
    964  
    965     _compiledList[contextID] = 1; 
    966  
    967     osg::Image* image = _bufferEntryImagePair.second; 
    968  
    969     _bufferEntryImagePair.first.modifiedCount[contextID] = image->getModifiedCount(); 
    970     if (!image->valid()) return; 
    971  
    972     Extensions* extensions = getExtensions(contextID,true); 
    973  
    974     GLuint& pbo = buffer(contextID); 
    975     if (pbo==0) 
    976     { 
    977         // building for the first time. 
    978  
    979         _totalSize = image->getTotalSizeInBytes(); 
    980  
    981         // don't generate buffer if size is zero. 
    982         if (_totalSize==0) return; 
    983  
    984         extensions->glGenBuffers(1, &pbo); 
    985         extensions->glBindBuffer(_target, pbo); 
    986         extensions->glBufferData(_target, _totalSize, NULL, _usage); 
    987  
    988     } 
    989     else 
    990     { 
    991         extensions->glBindBuffer(_target, pbo); 
    992  
    993         if (_totalSize != image->getTotalSizeInBytes()) 
    994         { 
    995             // resize PBO. 
    996             _totalSize = image->getTotalSizeInBytes(); 
    997             extensions->glBufferData(_target, _totalSize, NULL, _usage); 
    998         } 
    999     } 
    1000  
    1001 //    osg::Timer_t start_tick = osg::Timer::instance()->tick(); 
    1002  
    1003     void* pboMemory = extensions->glMapBuffer(_target, 
    1004                  GL_WRITE_ONLY_ARB); 
    1005  
    1006     // copy data across 
    1007     memcpy(pboMemory, image->data(), _totalSize); 
    1008  
    1009     // Unmap the texture image buffer 
    1010     extensions->glUnmapBuffer(_target); 
    1011  
    1012     _bufferEntryImagePair.first.modifiedCount[contextID] = image->getModifiedCount(); 
    1013  
    1014 //    osg::notify(osg::NOTICE)<<"pbo _totalSize="<<_totalSize<<std::endl; 
    1015 //    osg::notify(osg::NOTICE)<<"pbo "<<osg::Timer::instance()->delta_m(start_tick,osg::Timer::instance()->tick())<<"ms"<<std::endl; 
    1016 } 
    1017 #endif 
    10181349 
    10191350////////////////////////////////////////////////////////////////////////////////// 
     
    10241355PixelDataBufferObject::PixelDataBufferObject() 
    10251356{ 
    1026     _target = GL_ARRAY_BUFFER_ARB; 
    1027     _usage = GL_DYNAMIC_DRAW_ARB; 
     1357    setTarget(GL_ARRAY_BUFFER_ARB); 
     1358    setTarget(GL_DYNAMIC_DRAW_ARB); 
    10281359} 
    10291360 
     
    10431374{ 
    10441375    unsigned int contextID = state.getContextID();     
    1045     if ( _dataSize == 0) return; 
     1376    if ( _profile._size == 0) return; 
    10461377 
    10471378    GLBufferObject* bo = getOrCreateGLBufferObject(contextID); 
    10481379    if (!bo || !bo->isDirty()) return; 
    10491380 
    1050     bo->_extensions->glBindBuffer(_target, bo->getGLObjectID()); 
    1051     bo->_extensions->glBufferData(_target, _dataSize, NULL, _usage); 
    1052     bo->_extensions->glBindBuffer(_target, 0); 
     1381    bo->_extensions->glBindBuffer(_profile._target, bo->getGLObjectID()); 
     1382    bo->_extensions->glBufferData(_profile._target, _profile._size, NULL, _profile._usage); 
     1383    bo->_extensions->glBindBuffer(_profile._target, 0); 
    10531384} 
    10541385 
     
    10971428            break; 
    10981429        default: 
    1099             extensions->glBindBuffer(_target,0); 
     1430            extensions->glBindBuffer(_profile._target,0); 
    11001431            break; 
    11011432    } 
     
    11111442    _mode.resize(maxSize); 
    11121443} 
    1113  
    1114  
    1115 #endif 
  • OpenSceneGraph/trunk/src/osg/DisplaySettings.cpp

    r10588 r10601  
    8383 
    8484    _maxTexturePoolSize = vs._maxTexturePoolSize; 
    85     _maxVBOPoolSize = vs._maxVBOPoolSize; 
    86     _maxFBOPoolSize = vs._maxFBOPoolSize; 
     85    _maxBufferObjectPoolSize = vs._maxBufferObjectPoolSize; 
    8786} 
    8887 
     
    110109 
    111110    if (vs._maxTexturePoolSize>_maxTexturePoolSize) _maxTexturePoolSize = vs._maxTexturePoolSize; 
    112     if (vs._maxVBOPoolSize>_maxVBOPoolSize) _maxVBOPoolSize = vs._maxVBOPoolSize; 
    113     if (vs._maxFBOPoolSize>_maxFBOPoolSize) _maxFBOPoolSize = vs._maxFBOPoolSize; 
     111    if (vs._maxBufferObjectPoolSize>_maxBufferObjectPoolSize) _maxBufferObjectPoolSize = vs._maxBufferObjectPoolSize; 
    114112} 
    115113 
     
    158156 
    159157    _maxTexturePoolSize = 0; 
    160     _maxVBOPoolSize = 0; 
    161     _maxFBOPoolSize = 0; 
     158    _maxBufferObjectPoolSize = 0; 
    162159} 
    163160 
     
    200197static ApplicationUsageProxy DisplaySetting_e17(ApplicationUsage::ENVIRONMENTAL_VARIABLE,"OSG_MULTI_SAMPLES <int>","Set the hint for the number of samples to use when multi-sampling."); 
    201198static ApplicationUsageProxy DisplaySetting_e18(ApplicationUsage::ENVIRONMENTAL_VARIABLE,"OSG_TEXTURE_POOL_SIZE <int>","Set the hint size of texture pool to manage."); 
    202 static ApplicationUsageProxy DisplaySetting_e19(ApplicationUsage::ENVIRONMENTAL_VARIABLE,"OSG_VBO_POOL_SIZE <int>","Set the hint size of vertex buffer object pool to manage."); 
     199static ApplicationUsageProxy DisplaySetting_e19(ApplicationUsage::ENVIRONMENTAL_VARIABLE,"OSG_BUFFER_OBJECT_POOL_SIZE <int>","Set the hint size of vertex buffer object pool to manage."); 
    203200static ApplicationUsageProxy DisplaySetting_e20(ApplicationUsage::ENVIRONMENTAL_VARIABLE,"OSG_FBO_POOL_SIZE <int>","Set the hint size of frame buffer object pool to manage."); 
    204201 
     
    404401    } 
    405402 
    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); 
     403    if( (ptr = getenv("OSG_BUFFER_OBJECT_POOL_SIZE")) != 0) 
     404    { 
     405        _maxBufferObjectPoolSize = atoi(ptr); 
    414406    } 
    415407} 
     
    501493 
    502494    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  
     495    while(arguments.read("--buffer-object-pool-size",_maxBufferObjectPoolSize)) {} 
     496 
     497} 
     498 
     499 
     500 
  • OpenSceneGraph/trunk/src/osg/GLObjects.cpp

    r10600 r10601  
    5454void osg::discardAllDeletedGLObjects(unsigned int contextID) 
    5555{ 
    56     osg::GLBufferObject::discardDeletedBufferObjects(contextID); 
     56    osg::GLBufferObject::discardAllDeletedBufferObjects(contextID); 
    5757    osg::Drawable::discardAllDeletedDisplayLists(contextID); 
    5858    osg::FragmentProgram::discardDeletedFragmentProgramObjects(contextID); 
  • OpenSceneGraph/trunk/src/osg/State.cpp

    r10590 r10601  
    9090 
    9191    _maxTexturePoolSize = 0; 
    92     _maxVBOPoolSize = 0; 
    93     _maxFBOPoolSize = 0; 
     92    _maxBufferObjectPoolSize = 0; 
    9493} 
    9594 
     
    233232} 
    234233 
    235 void State::setMaxVBOPoolSize(unsigned int size) 
    236 { 
    237     _maxVBOPoolSize = size; 
    238     osg::notify(osg::NOTICE)<<"_maxVBOPoolSize="<<_maxVBOPoolSize<<std::endl; 
    239 } 
    240  
    241 void State::setMaxFBOPoolSize(unsigned int size) 
    242 { 
    243     _maxFBOPoolSize = size; 
    244     osg::notify(osg::NOTICE)<<"_maxFBOPoolSize="<<_maxFBOPoolSize<<std::endl; 
     234void State::setMaxBufferObjectPoolSize(unsigned int size) 
     235{ 
     236    _maxBufferObjectPoolSize = size; 
     237    osg::GLBufferObjectManager::getGLBufferObjectManager(getContextID())->setMaxGLBufferObjectPoolSize(_maxBufferObjectPoolSize); 
     238    osg::notify(osg::NOTICE)<<"_maxBufferObjectPoolSize="<<_maxBufferObjectPoolSize<<std::endl; 
    245239} 
    246240 
  • OpenSceneGraph/trunk/src/osg/Texture.cpp

    r10600 r10601  
    176176bool Texture::TextureObjectSet::checkConsistency() const 
    177177{ 
    178     return true; 
     178//    return true; 
    179179 
    180180    // osg::notify(osg::NOTICE)<<"TextureObjectSet::checkConsistency()"<<std::endl; 
     
    266266        GLuint id = (*itr)->id(); 
    267267 
    268         // osg::notify(osg::NOTICE)<<"Deleting textureobject id="<<id<<std::endl; 
     268        osg::notify(osg::NOTICE)<<"Deleting textureobject id="<<id<<std::endl; 
    269269 
    270270        glDeleteTextures( 1L, &id); 
     
    328328        GLuint id = (*itr)->id(); 
    329329 
    330         // osg::notify(osg::NOTICE)<<"Deleting textureobject id="<<id<<std::endl; 
     330        osg::notify(osg::NOTICE)<<"Deleting textureobject id="<<id<<std::endl; 
    331331 
    332332        glDeleteTextures( 1L, &id); 
  • OpenSceneGraph/trunk/src/osgUtil/SceneView.cpp

    r10595 r10601  
    10261026    tom->newFrame(state->getFrameStamp()); 
    10271027 
     1028    osg::GLBufferObjectManager::GLBufferObjectManager* bom = osg::GLBufferObjectManager::getGLBufferObjectManager(state->getContextID()); 
     1029    bom->newFrame(state->getFrameStamp()); 
     1030 
    10281031    if (!_initCalled) init(); 
    10291032 
     
    15671570#ifdef REPORT_TEXTURE_MANAGER_STATS 
    15681571    tom->reportStats(); 
     1572    bom->reportStats(); 
    15691573#endif 
    15701574 
  • OpenSceneGraph/trunk/src/osgViewer/CompositeViewer.cpp

    r10588 r10601  
    542542 
    543543    unsigned int maxTexturePoolSize = osg::DisplaySettings::instance()->getMaxTexturePoolSize(); 
    544     unsigned int maxVBOPoolSize = osg::DisplaySettings::instance()->getMaxVBOPoolSize(); 
    545     unsigned int maxFBOPoolSize = osg::DisplaySettings::instance()->getMaxFBOPoolSize(); 
     544    unsigned int maxBufferObjectPoolSize = osg::DisplaySettings::instance()->getMaxBufferObjectPoolSize(); 
    546545 
    547546    for(Contexts::iterator citr = contexts.begin(); 
     
    553552        // set the pool sizes, 0 the default will result in no GL object pools. 
    554553        gc->getState()->setMaxTexturePoolSize(maxTexturePoolSize); 
    555         gc->getState()->setMaxVBOPoolSize(maxVBOPoolSize); 
    556         gc->getState()->setMaxFBOPoolSize(maxFBOPoolSize); 
     554        gc->getState()->setMaxBufferObjectPoolSize(maxBufferObjectPoolSize); 
    557555 
    558556        gc->realize(); 
  • OpenSceneGraph/trunk/src/osgViewer/StatsHandler.cpp

    r10098 r10601  
    14011401        viewStr << "Bins" << std::endl; 
    14021402        viewStr << "Depth" << std::endl; 
    1403         viewStr << "Matrices" << std::endl; 
     1403        viewStr << "Materials" << std::endl; 
    14041404        viewStr << "Imposters" << std::endl; 
    14051405        viewStr << "Drawables" << std::endl; 
  • OpenSceneGraph/trunk/src/osgViewer/Viewer.cpp

    r10588 r10601  
    482482    if (_displaySettings.valid()) maxTexturePoolSize = std::max(maxTexturePoolSize, _displaySettings->getMaxTexturePoolSize()); 
    483483 
    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()); 
     484    unsigned int maxBufferObjectPoolSize = osg::DisplaySettings::instance()->getMaxBufferObjectPoolSize(); 
     485    if (_displaySettings.valid()) maxBufferObjectPoolSize = std::max(maxBufferObjectPoolSize, _displaySettings->getMaxBufferObjectPoolSize()); 
     486    if (_camera->getDisplaySettings()) maxBufferObjectPoolSize = std::max(maxBufferObjectPoolSize, _camera->getDisplaySettings()->getMaxBufferObjectPoolSize()); 
    491487 
    492488    for(Contexts::iterator citr = contexts.begin(); 
     
    498494        // set the pool sizes, 0 the default will result in no GL object pools. 
    499495        gc->getState()->setMaxTexturePoolSize(maxTexturePoolSize); 
    500         gc->getState()->setMaxVBOPoolSize(maxVBOPoolSize); 
    501         gc->getState()->setMaxFBOPoolSize(maxFBOPoolSize); 
     496        gc->getState()->setMaxBufferObjectPoolSize(maxBufferObjectPoolSize); 
    502497 
    503498        gc->realize(); 
  • OpenSceneGraph/trunk/src/osgWrappers/osg/BufferObject.cpp

    r10600 r10601  
    1414#include <osg/BufferObject> 
    1515#include <osg/CopyOp> 
     16#include <osg/FrameStamp> 
    1617#include <osg/Image> 
    1718#include <osg/Object> 
     
    174175                  "Get the type of usage the buffer object has been set up for. ", 
    175176                  ""); 
     177        I_Method0(osg::BufferObjectProfile &, getProfile, 
     178                  Properties::NON_VIRTUAL, 
     179                  __BufferObjectProfile_R1__getProfile, 
     180                  "", 
     181                  ""); 
     182        I_Method0(const osg::BufferObjectProfile &, getProfile, 
     183                  Properties::NON_VIRTUAL, 
     184                  __C5_BufferObjectProfile_R1__getProfile, 
     185                  "", 
     186                  ""); 
    176187        I_Method0(void, dirty, 
    177188                  Properties::NON_VIRTUAL, 
     
    224235                  "", 
    225236                  ""); 
     237        I_Method2(void, setGLBufferObject, IN, unsigned int, contextID, IN, osg::GLBufferObject *, glbo, 
     238                  Properties::NON_VIRTUAL, 
     239                  __void__setGLBufferObject__unsigned_int__GLBufferObject_P1, 
     240                  "", 
     241                  ""); 
    226242        I_Method1(osg::GLBufferObject *, getGLBufferObject, IN, unsigned int, contextID, 
    227243                  Properties::NON_VIRTUAL, 
     
    232248                  Properties::NON_VIRTUAL, 
    233249                  __GLBufferObject_P1__getOrCreateGLBufferObject__unsigned_int, 
     250                  "", 
     251                  ""); 
     252        I_Method0(unsigned int, computeRequiredBufferSize, 
     253                  Properties::NON_VIRTUAL, 
     254                  __unsigned_int__computeRequiredBufferSize, 
    234255                  "", 
    235256                  ""); 
     
    241262                        0,  
    242263                        __void__removeBufferData__unsigned_int); 
     264        I_IndexedProperty(osg::GLBufferObject *, GLBufferObject,  
     265                          __GLBufferObject_P1__getGLBufferObject__unsigned_int,  
     266                          __void__setGLBufferObject__unsigned_int__GLBufferObject_P1,  
     267                          0); 
     268        I_SimpleProperty(osg::BufferObjectProfile &, Profile,  
     269                         __BufferObjectProfile_R1__getProfile,  
     270                         0); 
    243271        I_SimpleProperty(GLenum, Target,  
    244272                         __GLenum__getTarget,  
     
    247275                         __GLenum__getUsage,  
    248276                         __void__setUsage__GLenum); 
     277END_REFLECTOR 
     278 
     279BEGIN_VALUE_REFLECTOR(osg::BufferObjectProfile) 
     280        I_DeclaringFile("osg/BufferObject"); 
     281        I_Constructor0(____BufferObjectProfile, 
     282                       "", 
     283                       ""); 
     284        I_Constructor3(IN, GLenum, target, IN, GLenum, usage, IN, unsigned int, size, 
     285                       ____BufferObjectProfile__GLenum__GLenum__unsigned_int, 
     286                       "", 
     287                       ""); 
     288        I_Constructor1(IN, const osg::BufferObjectProfile &, bpo, 
     289                       Properties::NON_EXPLICIT, 
     290                       ____BufferObjectProfile__C5_BufferObjectProfile_R1, 
     291                       "", 
     292                       ""); 
     293        I_Method3(void, setProfile, IN, GLenum, target, IN, GLenum, usage, IN, unsigned int, size, 
     294                  Properties::NON_VIRTUAL, 
     295                  __void__setProfile__GLenum__GLenum__unsigned_int, 
     296                  "", 
     297                  ""); 
     298        I_PublicMemberProperty(GLenum, _target); 
     299        I_PublicMemberProperty(GLenum, _usage); 
     300        I_PublicMemberProperty(GLenum, _size); 
    249301END_REFLECTOR 
    250302 
     
    322374                                   "", 
    323375                                   ""); 
     376        I_Method1(void, setProfile, IN, const osg::BufferObjectProfile &, profile, 
     377                  Properties::NON_VIRTUAL, 
     378                  __void__setProfile__C5_BufferObjectProfile_R1, 
     379                  "", 
     380                  ""); 
     381        I_Method0(const osg::BufferObjectProfile &, getProfile, 
     382                  Properties::NON_VIRTUAL, 
     383                  __C5_BufferObjectProfile_R1__getProfile, 
     384                  "", 
     385                  ""); 
    324386        I_Method1(void, setBufferObject, IN, osg::BufferObject *, bufferObject, 
    325387                  Properties::NON_VIRTUAL, 
     
    405467                        "Use deleteVertexBufferObject instead of glDeleteBuffers to allow OpenGL buffer objects to be cached until they can be deleted by the OpenGL context in which they were created, specified by contextID. ", 
    406468                        ""); 
    407         I_StaticMethod3(void, flushDeletedBufferObjects, IN, unsigned int, contextID, IN, double, x, IN, double &, availableTime, 
     469        I_StaticMethod1(void, flushAllDeletedBufferObjects, IN, unsigned int, contextID, 
     470                        __void__flushAllDeletedBufferObjects__unsigned_int_S, 
     471                        "", 
     472                        ""); 
     473        I_StaticMethod1(void, discardAllDeletedBufferObjects, IN, unsigned int, contextID, 
     474                        __void__discardAllDeletedBufferObjects__unsigned_int_S, 
     475                        "", 
     476                        ""); 
     477        I_StaticMethod3(void, flushDeletedBufferObjects, IN, unsigned int, contextID, IN, double, currentTime, IN, double &, availbleTime, 
    408478                        __void__flushDeletedBufferObjects__unsigned_int__double__double_R1_S, 
    409                         "flush all the cached display list which need to be deleted in the OpenGL context related to contextID. ", 
     479                        "", 
    410480                        ""); 
    411         I_StaticMethod1(void, discardDeletedBufferObjects, IN, unsigned int, contextID, 
    412                         __void__discardDeletedBufferObjects__unsigned_int_S, 
    413                         "dicard all the cached display list which need to be deleted in the OpenGL context related to contextID. ", 
    414                         "Note, unlike flush no OpenGL calls are made, instead the handles are all removed. this call is useful for when an OpenGL context has been destroyed. "); 
     481        I_StaticMethod2(void, releaseGLBufferObject, IN, unsigned int, contextID, IN, osg::GLBufferObject *, to, 
     482                        __void__releaseGLBufferObject__unsigned_int__GLBufferObject_P1_S, 
     483                        "", 
     484                        ""); 
    415485        I_StaticMethod2(osg::GLBufferObject::Extensions *, getExtensions, IN, unsigned int, contextID, IN, bool, createIfNotInitalized, 
    416486                        __Extensions_P1__getExtensions__unsigned_int__bool_S, 
     
    430500                         __GLuint__getGLObjectID,  
    431501                         0); 
     502        I_SimpleProperty(const osg::BufferObjectProfile &, Profile,  
     503                         __C5_BufferObjectProfile_R1__getProfile,  
     504                         __void__setProfile__C5_BufferObjectProfile_R1); 
     505        I_PublicMemberProperty(osg::GLBufferObjectSet *, _set); 
     506        I_PublicMemberProperty(osg::GLBufferObject *, _previous); 
     507        I_PublicMemberProperty(osg::GLBufferObject *, _next); 
     508        I_PublicMemberProperty(unsigned int, _frameLastUsed); 
    432509        I_PublicMemberProperty(osg::GLBufferObject::Extensions *, _extensions); 
    433510END_REFLECTOR 
     
    447524        I_PublicMemberProperty(GLsizeiptrARB, offset); 
    448525        I_PublicMemberProperty(osg::BufferData *, dataSource); 
     526END_REFLECTOR 
     527 
     528BEGIN_OBJECT_REFLECTOR(osg::GLBufferObjectManager) 
     529        I_DeclaringFile("osg/BufferObject"); 
     530        I_BaseType(osg::Referenced); 
     531        I_Constructor1(IN, unsigned int, contextID, 
     532                       Properties::NON_EXPLICIT, 
     533                       ____GLBufferObjectManager__unsigned_int, 
     534                       "", 
     535                       ""); 
     536        I_Method0(unsigned int, getContextID, 
     537                  Properties::NON_VIRTUAL, 
     538                  __unsigned_int__getContextID, 
     539                  "", 
     540                  ""); 
     541        I_Method1(void, setNumberActiveGLBufferObjects, IN, unsigned int, size, 
     542                  Properties::NON_VIRTUAL, 
     543                  __void__setNumberActiveGLBufferObjects__unsigned_int, 
     544                  "", 
     545                  ""); 
     546        I_Method0(unsigned int &, getNumberActiveGLBufferObjects, 
     547                  Properties::NON_VIRTUAL, 
     548                  __unsigned_int_R1__getNumberActiveGLBufferObjects, 
     549                  "", 
     550                  ""); 
     551        I_Method0(unsigned int, getNumberActiveGLBufferObjects, 
     552                  Properties::NON_VIRTUAL, 
     553                  __unsigned_int__getNumberActiveGLBufferObjects, 
     554                  "", 
     555                  ""); 
     556        I_Method1(void, setNumberOrphanedGLBufferObjects, IN, unsigned int, size, 
     557                  Properties::NON_VIRTUAL, 
     558                  __void__setNumberOrphanedGLBufferObjects__unsigned_int, 
     559                  "", 
     560                  ""); 
     561        I_Method0(unsigned int &, getNumberOrphanedGLBufferObjects, 
     562                  Properties::NON_VIRTUAL, 
     563                  __unsigned_int_R1__getNumberOrphanedGLBufferObjects, 
     564                  "", 
     565                  ""); 
     566        I_Method0(unsigned int, getNumberOrphanedGLBufferObjects, 
     567                  Properties::NON_VIRTUAL, 
     568                  __unsigned_int__getNumberOrphanedGLBufferObjects, 
     569                  "", 
     570                  ""); 
     571        I_Method1(void, setCurrGLBufferObjectPoolSize, IN, unsigned int, size, 
     572                  Properties::NON_VIRTUAL, 
     573                  __void__setCurrGLBufferObjectPoolSize__unsigned_int, 
     574                  "", 
     575                  ""); 
     576        I_Method0(unsigned int &, getCurrGLBufferObjectPoolSize, 
     577                  Properties::NON_VIRTUAL, 
     578                  __unsigned_int_R1__getCurrGLBufferObjectPoolSize, 
     579                  "", 
     580                  ""); 
     581        I_Method0(unsigned int, getCurrGLBufferObjectPoolSize, 
     582                  Properties::NON_VIRTUAL, 
     583                  __unsigned_int__getCurrGLBufferObjectPoolSize, 
     584                  "", 
     585                  ""); 
     586        I_Method1(void, setMaxGLBufferObjectPoolSize, IN, unsigned int, size, 
     587                  Properties::NON_VIRTUAL, 
     588                  __void__setMaxGLBufferObjectPoolSize__unsigned_int, 
     589                  "", 
     590                  ""); 
     591        I_Method0(unsigned int, getMaxGLBufferObjectPoolSize, 
     592                  Properties::NON_VIRTUAL, 
     593                  __unsigned_int__getMaxGLBufferObjectPoolSize, 
     594                  "", 
     595                  ""); 
     596        I_Method1(bool, hasSpace, IN, unsigned int, size, 
     597                  Properties::NON_VIRTUAL, 
     598                  __bool__hasSpace__unsigned_int, 
     599                  "", 
     600                  ""); 
     601        I_Method1(bool, makeSpace, IN, unsigned int, size, 
     602                  Properties::NON_VIRTUAL, 
     603                  __bool__makeSpace__unsigned_int, 
     604                  "", 
     605                  ""); 
     606        I_Method1(osg::GLBufferObject *, generateGLBufferObject, IN, const osg::BufferObject *, bufferObject, 
     607                  Properties::NON_VIRTUAL, 
     608                  __GLBufferObject_P1__generateGLBufferObject__C5_osg_BufferObject_P1, 
     609                  "", 
     610                  ""); 
     611        I_Method0(void, handlePendingOrphandedGLBufferObjects, 
     612                  Properties::NON_VIRTUAL, 
     613                  __void__handlePendingOrphandedGLBufferObjects, 
     614                  "", 
     615                  ""); 
     616        I_Method0(void, flushAllDeletedGLBufferObjects, 
     617                  Properties::NON_VIRTUAL, 
     618                  __void__flushAllDeletedGLBufferObjects, 
     619                  "", 
     620                  ""); 
     621        I_Method0(void, discardAllDeletedGLBufferObjects, 
     622                  Properties::NON_VIRTUAL, 
     623                  __void__discardAllDeletedGLBufferObjects, 
     624                  "", 
     625                  ""); 
     626        I_Method2(void, flushDeletedGLBufferObjects, IN, double, currentTime, IN, double &, availableTime, 
     627                  Properties::NON_VIRTUAL, 
     628                  __void__flushDeletedGLBufferObjects__double__double_R1, 
     629                  "", 
     630                  ""); 
     631        I_Method1(void, releaseGLBufferObject, IN, osg::GLBufferObject *, to, 
     632                  Properties::NON_VIRTUAL, 
     633                  __void__releaseGLBufferObject__GLBufferObject_P1, 
     634                  "", 
     635                  ""); 
     636        I_Method1(osg::GLBufferObjectSet *, getGLBufferObjectSet, IN, const osg::BufferObjectProfile &, profile, 
     637                  Properties::NON_VIRTUAL, 
     638                  __GLBufferObjectSet_P1__getGLBufferObjectSet__C5_BufferObjectProfile_R1, 
     639                  "", 
     640                  ""); 
     641        I_Method1(void, newFrame, IN, osg::FrameStamp *, fs, 
     642                  Properties::NON_VIRTUAL, 
     643                  __void__newFrame__osg_FrameStamp_P1, 
     644                  "", 
     645                  ""); 
     646        I_Method0(void, resetStats, 
     647                  Properties::NON_VIRTUAL, 
     648                  __void__resetStats, 
     649                  "", 
     650                  ""); 
     651        I_Method0(void, reportStats, 
     652                  Properties::NON_VIRTUAL, 
     653                  __void__reportStats, 
     654                  "", 
     655                  ""); 
     656        I_Method0(unsigned int &, getFrameNumber, 
     657                  Properties::NON_VIRTUAL, 
     658                  __unsigned_int_R1__getFrameNumber, 
     659                  "", 
     660                  ""); 
     661        I_Method0(unsigned int &, getNumberFrames, 
     662                  Properties::NON_VIRTUAL, 
     663                  __unsigned_int_R1__getNumberFrames, 
     664                  "", 
     665                  ""); 
     666        I_Method0(unsigned int &, getNumberDeleted, 
     667                  Properties::NON_VIRTUAL, 
     668                  __unsigned_int_R1__getNumberDeleted, 
     669                  "", 
     670                  ""); 
     671        I_Method0(double &, getDeleteTime, 
     672                  Properties::NON_VIRTUAL, 
     673                  __double_R1__getDeleteTime, 
     674                  "", 
     675                  ""); 
     676        I_Method0(unsigned int &, getNumberGenerated, 
     677                  Properties::NON_VIRTUAL, 
     678                  __unsigned_int_R1__getNumberGenerated, 
     679                  "", 
     680                  ""); 
     681        I_Method0(double &, getGenerateTime, 
     682                  Properties::NON_VIRTUAL, 
     683                  __double_R1__getGenerateTime, 
     684                  "", 
     685                  ""); 
     686        I_Method0(unsigned int &, getNumberApplied, 
     687                  Properties::NON_VIRTUAL, 
     688                  __unsigned_int_R1__getNumberApplied, 
     689                  "", 
     690                  ""); 
     691        I_Method0(double &, getApplyTime, 
     692                  Properties::NON_VIRTUAL, 
     693                  __double_R1__getApplyTime, 
     694                  "", 
     695                  ""); 
     696        I_StaticMethod1(osg::ref_ptr< osg::GLBufferObjectManager > &, getGLBufferObjectManager, IN, unsigned int, contextID, 
     697                        __osg_ref_ptrT1_GLBufferObjectManager__R1__getGLBufferObjectManager__unsigned_int_S, 
     698                        "", 
     699                        ""); 
     700        I_SimpleProperty(double &, ApplyTime,  
     701                         __double_R1__getApplyTime,  
     702                         0); 
     703        I_SimpleProperty(unsigned int, ContextID,  
     704                         __unsigned_int__getContextID,  
     705                         0); 
     706        I_SimpleProperty(unsigned int, CurrGLBufferObjectPoolSize,  
     707                         __unsigned_int__getCurrGLBufferObjectPoolSize,  
     708                         __void__setCurrGLBufferObjectPoolSize__unsigned_int); 
     709        I_SimpleProperty(double &, DeleteTime,  
     710                         __double_R1__getDeleteTime,  
     711                         0); 
     712        I_SimpleProperty(unsigned int &, FrameNumber,  
     713                         __unsigned_int_R1__getFrameNumber,  
     714                         0); 
     715        I_SimpleProperty(double &, GenerateTime,  
     716                         __double_R1__getGenerateTime,  
     717                         0); 
     718        I_SimpleProperty(unsigned int, MaxGLBufferObjectPoolSize,  
     719                         __unsigned_int__getMaxGLBufferObjectPoolSize,  
     720                         __void__setMaxGLBufferObjectPoolSize__unsigned_int); 
     721        I_SimpleProperty(unsigned int, NumberActiveGLBufferObjects,  
     722                         __unsigned_int__getNumberActiveGLBufferObjects,  
     723                         __void__setNumberActiveGLBufferObjects__unsigned_int); 
     724        I_SimpleProperty(unsigned int &, NumberApplied,  
     725                         __unsigned_int_R1__getNumberApplied,  
     726                         0); 
     727        I_SimpleProperty(unsigned int &, NumberDeleted,  
     728                         __unsigned_int_R1__getNumberDeleted,  
     729                         0); 
     730        I_SimpleProperty(unsigned int &, NumberFrames,  
     731                         __unsigned_int_R1__getNumberFrames,  
     732                         0); 
     733        I_SimpleProperty(unsigned int &, NumberGenerated,  
     734                         __unsigned_int_R1__getNumberGenerated,  
     735                         0); 
     736        I_SimpleProperty(unsigned int, NumberOrphanedGLBufferObjects,  
     737                         __unsigned_int__getNumberOrphanedGLBufferObjects,  
     738                         __void__setNumberOrphanedGLBufferObjects__unsigned_int); 
     739END_REFLECTOR 
     740 
     741BEGIN_OBJECT_REFLECTOR(osg::GLBufferObjectSet) 
     742        I_DeclaringFile("osg/BufferObject"); 
     743        I_BaseType(osg::Referenced); 
     744        I_Constructor2(IN, osg::GLBufferObjectManager *, parent, IN, const osg::BufferObjectProfile &, profile, 
     745                       ____GLBufferObjectSet__GLBufferObjectManager_P1__C5_BufferObjectProfile_R1, 
     746                       "", 
     747                       ""); 
     748        I_Method0(void, handlePendingOrphandedGLBufferObjects, 
     749                  Properties::NON_VIRTUAL, 
     750                  __void__handlePendingOrphandedGLBufferObjects, 
     751                  "", 
     752                  ""); 
     753        I_Method0(void, flushAllDeletedGLBufferObjects, 
     754                  Properties::NON_VIRTUAL, 
     755                  __void__flushAllDeletedGLBufferObjects, 
     756                  "", 
     757                  ""); 
     758        I_Method0(void, discardAllDeletedGLBufferObjects, 
     759                  Properties::NON_VIRTUAL, 
     760                  __void__discardAllDeletedGLBufferObjects, 
     761                  "", 
     762                  ""); 
     763        I_Method2(void, flushDeletedGLBufferObjects, IN, double, currentTime, IN, double &, availableTime, 
     764                  Properties::NON_VIRTUAL, 
     765                  __void__flushDeletedGLBufferObjects__double__double_R1, 
     766                  "", 
     767                  ""); 
     768        I_Method1(osg::GLBufferObject *, takeFromOrphans, IN, osg::BufferObject *, bufferObject, 
     769                  Properties::NON_VIRTUAL, 
     770                  __GLBufferObject_P1__takeFromOrphans__BufferObject_P1, 
     771                  "", 
     772                  ""); 
     773        I_Method1(osg::GLBufferObject *, takeOrGenerate, IN, osg::BufferObject *, bufferObject, 
     774                  Properties::NON_VIRTUAL, 
     775                  __GLBufferObject_P1__takeOrGenerate__BufferObject_P1, 
     776                  "", 
     777                  ""); 
     778        I_Method1(void, moveToBack, IN, osg::GLBufferObject *, to, 
     779                  Properties::NON_VIRTUAL, 
     780                  __void__moveToBack__GLBufferObject_P1, 
     781                  "", 
     782                  ""); 
     783        I_Method1(void, addToBack, IN, osg::GLBufferObject *, to, 
     784                  Properties::NON_VIRTUAL, 
     785                  __void__addToBack__GLBufferObject_P1, 
     786                  "", 
     787                  ""); 
     788        I_Method1(void, orphan, IN, osg::GLBufferObject *, to, 
     789                  Properties::NON_VIRTUAL, 
     790                  __void__orphan__GLBufferObject_P1, 
     791                  "", 
     792                  ""); 
     793        I_Method1(void, remove, IN, osg::GLBufferObject *, to, 
     794                  Properties::NON_VIRTUAL, 
     795                  __void__remove__GLBufferObject_P1, 
     796                  "", 
     797                  ""); 
     798        I_Method0(unsigned int, size, 
     799                  Properties::NON_VIRTUAL, 
     800                  __unsigned_int__size, 
     801                  "", 
     802                  ""); 
     803        I_Method1(bool, makeSpace, IN, unsigned int &, size, 
     804                  Properties::NON_VIRTUAL, 
     805                  __bool__makeSpace__unsigned_int_R1, 
     806                  "", 
     807                  ""); 
     808        I_Method0(bool, checkConsistency, 
     809                  Properties::NON_VIRTUAL, 
     810                  __bool__checkConsistency, 
     811                  "", 
     812                  ""); 
     813        I_Method0(osg::GLBufferObjectManager *, getParent, 
     814                  Properties::NON_VIRTUAL, 
     815                  __GLBufferObjectManager_P1__getParent, 
     816                  "", 
     817                  ""); 
     818        I_SimpleProperty(osg::GLBufferObjectManager *, Parent,  
     819                         __GLBufferObjectManager_P1__getParent,  
     820                         0); 
    449821END_REFLECTOR 
    450822 
     
    6641036END_REFLECTOR 
    6651037 
     1038TYPE_NAME_ALIAS(std::list< osg::ref_ptr< osg::GLBufferObject > >, osg::GLBufferObjectList) 
     1039 
     1040BEGIN_VALUE_REFLECTOR(osg::ref_ptr< osg::GLBufferObject >) 
     1041        I_DeclaringFile("osg/ref_ptr"); 
     1042        I_Constructor0(____ref_ptr, 
     1043                       "", 
     1044                       ""); 
     1045        I_Constructor1(IN, osg::GLBufferObject *, ptr, 
     1046                       Properties::NON_EXPLICIT, 
     1047                       ____ref_ptr__T_P1, 
     1048                       "", 
     1049                       ""); 
     1050        I_Constructor1(IN, const osg::ref_ptr< osg::GLBufferObject > &, rp, 
     1051                       Properties::NON_EXPLICIT, 
     1052                       ____ref_ptr__C5_ref_ptr_R1, 
     1053                       "", 
     1054                       ""); 
     1055        I_Method0(osg::GLBufferObject *, get, 
     1056                  Properties::NON_VIRTUAL, 
     1057                  __T_P1__get, 
     1058                  "", 
     1059                  ""); 
     1060        I_Method0(bool, valid, 
     1061                  Properties::NON_VIRTUAL, 
     1062                  __bool__valid, 
     1063                  "", 
     1064                  ""); 
     1065        I_Method0(osg::GLBufferObject *, release, 
     1066                  Properties::NON_VIRTUAL, 
     1067                  __T_P1__release, 
     1068                  "", 
     1069                  ""); 
     1070        I_Method1(void, swap, IN, osg::ref_ptr< osg::GLBufferObject > &, rp, 
     1071                  Properties::NON_VIRTUAL, 
     1072                  __void__swap__ref_ptr_R1, 
     1073                  "", 
     1074                  ""); 
     1075        I_SimpleProperty(osg::GLBufferObject *, ,  
     1076                         __T_P1__get,  
     1077                         0); 
     1078END_REFLECTOR 
     1079 
     1080BEGIN_VALUE_REFLECTOR(osg::ref_ptr< osg::GLBufferObjectManager >) 
     1081        I_DeclaringFile("osg/ref_ptr"); 
     1082        I_Constructor0(____ref_ptr, 
     1083                       "", 
     1084                       ""); 
     1085        I_Constructor1(IN, osg::GLBufferObjectManager *, ptr, 
     1086                       Properties::NON_EXPLICIT, 
     1087                       ____ref_ptr__T_P1, 
     1088                       "", 
     1089                       ""); 
     1090        I_Constructor1(IN, const osg::ref_ptr< osg::GLBufferObjectManager > &, rp, 
     1091                       Properties::NON_EXPLICIT, 
     1092                       ____ref_ptr__C5_ref_ptr_R1, 
     1093                       "", 
     1094                       ""); 
     1095        I_Method0(osg::GLBufferObjectManager *, get, 
     1096                  Properties::NON_VIRTUAL, 
     1097                  __T_P1__get, 
     1098                  "", 
     1099                  ""); 
     1100        I_Method0(bool, valid, 
     1101                  Properties::NON_VIRTUAL, 
     1102                  __bool__valid, 
     1103                  "", 
     1104                  ""); 
     1105        I_Method0(osg::GLBufferObjectManager *, release, 
     1106                  Properties::NON_VIRTUAL, 
     1107                  __T_P1__release, 
     1108                  "", 
     1109                  ""); 
     1110        I_Method1(void, swap, IN, osg::ref_ptr< osg::GLBufferObjectManager > &, rp, 
     1111                  Properties::NON_VIRTUAL, 
     1112                  __void__swap__ref_ptr_R1, 
     1113                  "", 
     1114                  ""); 
     1115        I_SimpleProperty(osg::GLBufferObjectManager *, ,  
     1116                         __T_P1__get,  
     1117                         0); 
     1118END_REFLECTOR 
     1119 
     1120STD_LIST_REFLECTOR(std::list< osg::ref_ptr< osg::GLBufferObject > >) 
     1121 
  • OpenSceneGraph/trunk/src/osgWrappers/osg/DisplaySettings.cpp

    r10588 r10601  
    395395                  "", 
    396396                  ""); 
    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, 
     397        I_Method1(void, setMaxBufferObjectPoolSize, IN, unsigned int, size, 
     398                  Properties::NON_VIRTUAL, 
     399                  __void__setMaxBufferObjectPoolSize__unsigned_int, 
     400                  "", 
     401                  ""); 
     402        I_Method0(unsigned int, getMaxBufferObjectPoolSize, 
     403                  Properties::NON_VIRTUAL, 
     404                  __unsigned_int__getMaxBufferObjectPoolSize, 
    415405                  "", 
    416406                  ""); 
     
    442432                         __float__getEyeSeparation,  
    443433                         __void__setEyeSeparation__float); 
    444         I_SimpleProperty(unsigned int, MaxFBOPoolSize,  
    445                          __unsigned_int__getMaxFBOPoolSize,  
    446                          __void__setMaxFBOPoolSize__unsigned_int); 
     434        I_SimpleProperty(unsigned int, MaxBufferObjectPoolSize,  
     435                         __unsigned_int__getMaxBufferObjectPoolSize,  
     436                         __void__setMaxBufferObjectPoolSize__unsigned_int); 
    447437        I_SimpleProperty(unsigned int, MaxNumberOfGraphicsContexts,  
    448438                         __unsigned_int__getMaxNumberOfGraphicsContexts,  
     
    451441                         __unsigned_int__getMaxTexturePoolSize,  
    452442                         __void__setMaxTexturePoolSize__unsigned_int); 
    453         I_SimpleProperty(unsigned int, MaxVBOPoolSize,  
    454                          __unsigned_int__getMaxVBOPoolSize,  
    455                          __void__setMaxVBOPoolSize__unsigned_int); 
    456443        I_SimpleProperty(unsigned int, MinimumNumAccumAlphaBits,  
    457444                         __unsigned_int__getMinimumNumAccumAlphaBits,  
  • OpenSceneGraph/trunk/src/osgWrappers/osg/State.cpp

    r10600 r10601  
    707707                  "", 
    708708                  ""); 
    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, 
     709        I_Method1(void, setMaxBufferObjectPoolSize, IN, unsigned int, size, 
     710                  Properties::NON_VIRTUAL, 
     711                  __void__setMaxBufferObjectPoolSize__unsigned_int, 
     712                  "", 
     713                  ""); 
     714        I_Method0(unsigned int, getMaxBufferObjectPoolSize, 
     715                  Properties::NON_VIRTUAL, 
     716                  __unsigned_int__getMaxBufferObjectPoolSize, 
    727717                  "", 
    728718                  ""); 
     
    881871                         __C5_Program_PerContextProgram_P1__getLastAppliedProgramObject,  
    882872                         __void__setLastAppliedProgramObject__C5_Program_PerContextProgram_P1); 
    883         I_SimpleProperty(unsigned int, MaxFBOPoolSize,  
    884                          __unsigned_int__getMaxFBOPoolSize,  
    885                          __void__setMaxFBOPoolSize__unsigned_int); 
     873        I_SimpleProperty(unsigned int, MaxBufferObjectPoolSize,  
     874                         __unsigned_int__getMaxBufferObjectPoolSize,  
     875                         __void__setMaxBufferObjectPoolSize__unsigned_int); 
    886876        I_SimpleProperty(unsigned int, MaxTexturePoolSize,  
    887877                         __unsigned_int__getMaxTexturePoolSize,  
    888878                         __void__setMaxTexturePoolSize__unsigned_int); 
    889         I_SimpleProperty(unsigned int, MaxVBOPoolSize,  
    890                          __unsigned_int__getMaxVBOPoolSize,  
    891                          __void__setMaxVBOPoolSize__unsigned_int); 
    892879        I_IndexedProperty(bool, ModeValidity,  
    893880                          __bool__getModeValidity__StateAttribute_GLMode,