Show
Ignore:
Timestamp:
10/01/09 22:19:42 (5 years ago)
Author:
robert
Message:

Introduced new BufferObject? design + implementation in preperation of implementing a pool system for buffer objects

Files:
1 modified

Legend:

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

    r9302 r10600  
    100100 
    101101class State; 
    102  
    103 class OSG_EXPORT BufferObject : public Object 
    104 { 
    105     public: 
    106  
    107         BufferObject(); 
    108  
    109         /** Copy constructor using CopyOp to manage deep vs shallow copy.*/ 
    110         BufferObject(const BufferObject& bo,const CopyOp& copyop=CopyOp::SHALLOW_COPY); 
    111  
    112         virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const BufferObject*>(obj)!=NULL; } 
    113         virtual const char* libraryName() const { return "osg"; } 
    114         virtual const char* className() const { return "BufferObject"; } 
    115  
    116         /** Set what type of usage the buffer object will have. Options are:  
    117           *          GL_STREAM_DRAW, GL_STREAM_READ, GL_STREAM_COPY,  
    118           *          GL_STATIC_DRAW, GL_STATIC_READ, GL_STATIC_COPY,  
    119           *          GL_DYNAMIC_DRAW, GL_DYNAMIC_READ, or GL_DYNAMIC_COPY. 
    120           */ 
    121         void setUsage(GLenum usage) { _usage = usage; } 
    122          
    123         /** Get the type of usage the buffer object has been set up for.*/ 
    124         GLenum getUsage() const { return _usage; } 
     102class BufferData; 
     103class BufferObject; 
     104 
     105class OSG_EXPORT GLBufferObject : public Referenced 
     106{ 
     107    public: 
     108 
     109        GLBufferObject(unsigned int contextID, BufferObject* bufferObject=0); 
     110 
     111        void setBufferObject(BufferObject* bufferObject); 
     112        BufferObject* getBufferObject() { return _bufferObject; } 
    125113 
    126114        struct BufferEntry 
    127115        { 
    128             BufferEntry(): dataSize(0),offset(0) {} 
    129             BufferEntry(const BufferEntry& be): modifiedCount(be.modifiedCount),dataSize(be.dataSize),offset(be.offset) {} 
    130          
    131             BufferEntry& operator = (const BufferEntry& be) { modifiedCount=be.modifiedCount; dataSize=be.dataSize; offset=be.offset; return *this; } 
    132  
    133             mutable buffered_value<unsigned int>    modifiedCount; 
    134             mutable unsigned int                    dataSize; 
    135             mutable unsigned int                    offset; 
     116            BufferEntry(): modifiedCount(0),dataSize(0),offset(0),dataSource(0) {} 
     117 
     118            BufferEntry(const BufferEntry& rhs): 
     119                modifiedCount(rhs.modifiedCount), 
     120                dataSize(rhs.dataSize), 
     121                offset(rhs.offset), 
     122                dataSource(rhs.dataSource) {} 
     123 
     124            BufferEntry& operator = (const BufferEntry& rhs) 
     125            { 
     126                if (&rhs==this) return *this; 
     127                modifiedCount = rhs.modifiedCount; 
     128                dataSize = rhs.dataSize; 
     129                offset = rhs.offset; 
     130                dataSource = rhs.dataSource; 
     131                return *this; 
     132            } 
     133 
     134            unsigned int        modifiedCount; 
     135            GLsizeiptrARB       dataSize; 
     136            GLsizeiptrARB       offset; 
     137            BufferData*         dataSource; 
    136138        }; 
    137139 
    138         inline bool isBufferObjectSupported(unsigned int contextID) const { return getExtensions(contextID,true)->isBufferObjectSupported(); } 
    139         inline bool isPBOSupported(unsigned int contextID) const { return getExtensions(contextID,true)->isPBOSupported(); } 
    140  
    141         inline GLuint& buffer(unsigned int contextID) const { return _bufferObjectList[contextID]; } 
    142          
    143         inline void bindBuffer(unsigned int contextID) const 
     140        inline unsigned int getContextID() const { return _contextID; } 
     141 
     142        inline GLuint& getGLObjectID() { return _glObjectID; } 
     143        inline GLuint getGLObjectID() const { return _glObjectID; } 
     144        inline GLsizeiptrARB getOffset(unsigned int i) const { return _bufferEntries[i].offset; } 
     145 
     146        inline void bindBuffer() const 
    144147        {  
    145             Extensions* extensions = getExtensions(contextID,true); 
    146             extensions->glBindBuffer(_target,_bufferObjectList[contextID]); 
     148            _extensions->glBindBuffer(_target,_glObjectID); 
    147149        } 
    148150 
    149         virtual void unbindBuffer(unsigned int contextID) const 
     151        inline void unbindBuffer() const 
    150152        {  
    151             Extensions* extensions = getExtensions(contextID,true); 
    152             extensions->glBindBuffer(_target,0); 
     153            _extensions->glBindBuffer(_target,0); 
    153154        } 
    154155 
    155         inline void dirty() { _compiledList.setAllElementsTo(0); } 
    156  
    157         bool isDirty(unsigned int contextID) const { return _compiledList[contextID]==0; } 
    158  
    159         virtual void compileBuffer(State& state) const = 0; 
    160          
    161         /** Resize any per context GLObject buffers to specified size. */ 
    162         virtual void resizeGLObjectBuffers(unsigned int maxSize); 
    163  
    164         /** If State is non-zero, this function releases OpenGL objects for 
    165           * the specified graphics context. Otherwise, releases OpenGL objects 
    166           * for all graphics contexts. */ 
    167         void releaseGLObjects(State* state=0) const; 
     156        inline bool isDirty() const { return _dirty; } 
     157 
     158        void dirty() { _dirty = true; } 
     159 
     160        void clear(); 
     161 
     162        void compileBuffer(); 
     163 
     164        void deleteGLObject(); 
     165 
     166        void assign(BufferObject* bufferObject); 
     167 
     168        bool isPBOSupported() const { return _extensions->isPBOSupported(); } 
     169 
     170        static GLBufferObject* createGLBufferObject(unsigned int contextID, const BufferObject* bufferObject); 
    168171 
    169172 
     
    257260    protected: 
    258261     
    259         virtual ~BufferObject(); 
    260          
    261         typedef osg::buffered_value<GLuint> GLObjectList; 
    262         typedef osg::buffered_value<unsigned int> CompiledList; 
    263  
    264         mutable GLObjectList    _bufferObjectList; 
    265         mutable CompiledList    _compiledList; 
     262        virtual ~GLBufferObject(); 
     263 
     264        unsigned int            _contextID; 
     265        GLuint                  _glObjectID; 
    266266 
    267267        GLenum                  _target; 
    268268        GLenum                  _usage; 
     269 
     270        bool                    _dirty; 
     271 
    269272        mutable unsigned int    _totalSize; 
    270 }; 
     273 
     274        typedef std::vector<BufferEntry> BufferEntries; 
     275        BufferEntries           _bufferEntries; 
     276 
     277        BufferObject*           _bufferObject; 
     278 
     279    public: 
     280        Extensions*             _extensions; 
     281 
     282}; 
     283 
     284class OSG_EXPORT BufferObject : public Object 
     285{ 
     286    public: 
     287 
     288        BufferObject(); 
     289 
     290        /** Copy constructor using CopyOp to manage deep vs shallow copy.*/ 
     291        BufferObject(const BufferObject& bo,const CopyOp& copyop=CopyOp::SHALLOW_COPY); 
     292 
     293        virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const BufferObject*>(obj)!=NULL; } 
     294        virtual const char* libraryName() const { return "osg"; } 
     295        virtual const char* className() const { return "BufferObject"; } 
     296 
     297        void setTarget(GLenum target) { _target = target; } 
     298        GLenum getTarget() const { return _target; } 
     299 
     300        /** Set what type of usage the buffer object will have. Options are: 
     301          *          GL_STREAM_DRAW, GL_STREAM_READ, GL_STREAM_COPY, 
     302          *          GL_STATIC_DRAW, GL_STATIC_READ, GL_STATIC_COPY, 
     303          *          GL_DYNAMIC_DRAW, GL_DYNAMIC_READ, or GL_DYNAMIC_COPY. 
     304          */ 
     305        void setUsage(GLenum usage) { _usage = usage; } 
     306 
     307        /** Get the type of usage the buffer object has been set up for.*/ 
     308        GLenum getUsage() const { return _usage; } 
     309 
     310        void dirty(); 
     311 
     312        /** Resize any per context GLObject buffers to specified size. */ 
     313        virtual void resizeGLObjectBuffers(unsigned int maxSize); 
     314 
     315        /** If State is non-zero, this function releases OpenGL objects for 
     316          * the specified graphics context. Otherwise, releases OpenGL objects 
     317          * for all graphics contexts. */ 
     318        void releaseGLObjects(State* state=0) const; 
     319 
     320        unsigned int addBufferData(BufferData* bd); 
     321        void removeBufferData(unsigned int index); 
     322        void removeBufferData(BufferData* bd); 
     323 
     324        void setBufferData(unsigned int index, BufferData* bd); 
     325        BufferData* getBufferData(unsigned int index) { return _bufferDataList[index]; } 
     326        const BufferData* getBufferData(unsigned int index) const { return _bufferDataList[index]; } 
     327 
     328        unsigned int getNumBufferData() const { return _bufferDataList.size(); } 
     329 
     330        GLBufferObject* getGLBufferObject(unsigned int contextID) const { return _glBufferObjects[contextID].get(); } 
     331 
     332        GLBufferObject* getOrCreateGLBufferObject(unsigned int contextID) const 
     333        { 
     334            if (!_glBufferObjects[contextID]) _glBufferObjects[contextID] = GLBufferObject::createGLBufferObject(contextID, this); 
     335            return _glBufferObjects[contextID].get(); 
     336        } 
     337 
     338    protected: 
     339 
     340        ~BufferObject(); 
     341 
     342        typedef std::vector< BufferData* > BufferDataList; 
     343        typedef osg::buffered_object< osg::ref_ptr<GLBufferObject> > GLBufferObjects; 
     344 
     345        GLenum                  _target; 
     346        GLenum                  _usage; 
     347        BufferDataList          _bufferDataList; 
     348 
     349        mutable GLBufferObjects _glBufferObjects; 
     350}; 
     351 
     352class BufferData : public Object 
     353{ 
     354    public: 
     355 
     356        BufferData(): 
     357            Object(true), 
     358            _modifiedCount(0), 
     359            _bufferIndex(0) {} 
     360 
     361        /** Copy constructor using CopyOp to manage deep vs shallow copy.*/ 
     362        BufferData(const BufferData& bd,const CopyOp& copyop=CopyOp::SHALLOW_COPY): 
     363            osg::Object(bd,copyop), 
     364            _modifiedCount(0), 
     365            _bufferIndex(0) {} 
     366 
     367        virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const BufferData*>(obj)!=NULL; } 
     368        virtual const char* libraryName() const { return "osg"; } 
     369        virtual const char* className() const { return "BufferData"; } 
     370 
     371        virtual const GLvoid*   getDataPointer() const = 0; 
     372        virtual unsigned int    getTotalDataSize() const = 0; 
     373 
     374        void setBufferObject(BufferObject* bufferObject); 
     375        BufferObject* getBufferObject() { return _bufferObject.get(); } 
     376        const BufferObject* getBufferObject() const { return _bufferObject.get(); } 
     377 
     378        void setBufferIndex(unsigned int index) { _bufferIndex = index; } 
     379        unsigned int getBufferIndex() const { return _bufferIndex; } 
     380 
     381        GLBufferObject* getGLBufferObject(unsigned int contextID) const { return _bufferObject.valid() ? _bufferObject->getGLBufferObject(contextID) : 0; } 
     382        GLBufferObject* getOrCreateGLBufferObject(unsigned int contextID) const { return _bufferObject.valid() ? _bufferObject->getOrCreateGLBufferObject(contextID) : 0; } 
     383 
     384        /** Dirty the primitive, which increments the modified count, to force buffer objects to update. */ 
     385        inline void dirty() { ++_modifiedCount; if (_bufferObject.valid()) _bufferObject->dirty(); } 
     386 
     387        /** Set the modified count value.*/ 
     388        inline void setModifiedCount(unsigned int value) { _modifiedCount=value; } 
     389 
     390        /** Get modified count value.*/ 
     391        inline unsigned int getModifiedCount() const { return _modifiedCount; } 
     392 
     393    protected: 
     394 
     395        virtual ~BufferData(); 
     396 
     397        unsigned int                    _modifiedCount; 
     398 
     399        unsigned int                    _bufferIndex; 
     400        osg::ref_ptr<BufferObject>      _bufferObject; 
     401}; 
     402 
    271403 
    272404class Array; 
     
    281413 
    282414        META_Object(osg,VertexBufferObject); 
    283          
    284         typedef std::pair< BufferEntry, Array* > BufferEntryArrayPair; 
    285         typedef std::vector< BufferEntryArrayPair > BufferEntryArrayPairs; 
    286415 
    287416        unsigned int addArray(osg::Array* array); 
     
    289418 
    290419        void setArray(unsigned int i, Array* array); 
    291         Array* getArray(unsigned int i) { return _bufferEntryArrayPairs[i].second; } 
    292         const Array* getArray(unsigned int i) const { return _bufferEntryArrayPairs[i].second; } 
    293          
    294         const GLvoid* getOffset(unsigned int i) const { return (const GLvoid*)(((char *)0)+(_bufferEntryArrayPairs[i].first.offset)); } 
    295  
    296         virtual void compileBuffer(State& state) const; 
    297  
    298         /** Resize any per context GLObject buffers to specified size. */ 
    299         virtual void resizeGLObjectBuffers(unsigned int maxSize); 
    300  
    301     protected: 
    302      
     420        Array* getArray(unsigned int i); 
     421        const Array* getArray(unsigned int i) const; 
     422 
     423    protected: 
    303424        virtual ~VertexBufferObject(); 
    304          
    305         BufferEntryArrayPairs _bufferEntryArrayPairs; 
    306425}; 
    307426 
     
    318437        META_Object(osg,ElementBufferObject); 
    319438         
    320         typedef std::pair< BufferEntry, DrawElements* > BufferEntryDrawElementsPair; 
    321         typedef std::vector< BufferEntryDrawElementsPair > BufferEntryDrawElementsPairs; 
    322  
    323439        unsigned int addDrawElements(osg::DrawElements* PrimitiveSet); 
    324440        void removeDrawElements(osg::DrawElements* PrimitiveSet); 
    325441 
    326442        void setDrawElements(unsigned int i, DrawElements* PrimitiveSet); 
    327         DrawElements* getDrawElements(unsigned int i) { return _bufferEntryDrawElementsPairs[i].second; } 
    328         const DrawElements* getDrawElements(unsigned int i) const { return _bufferEntryDrawElementsPairs[i].second; } 
    329          
    330         const GLvoid* getOffset(unsigned int i) const { return (const GLvoid*)(((char *)0)+(_bufferEntryDrawElementsPairs[i].first.offset)); } 
    331  
    332         virtual void compileBuffer(State& state) const; 
    333  
    334         /** Resize any per context GLObject buffers to specified size. */ 
    335         virtual void resizeGLObjectBuffers(unsigned int maxSize); 
     443        DrawElements* getDrawElements(unsigned int i); 
     444        const DrawElements* getDrawElements(unsigned int i) const; 
    336445 
    337446    protected: 
    338447     
    339448        virtual ~ElementBufferObject(); 
    340          
    341         BufferEntryDrawElementsPairs _bufferEntryDrawElementsPairs; 
    342449}; 
    343450 
     
    353460 
    354461        META_Object(osg,PixelBufferObject); 
    355          
    356         typedef std::pair< BufferEntry, Image* > BufferEntryImagePair; 
    357462 
    358463        void setImage(osg::Image* image); 
    359464 
    360         Image* getImage() { return _bufferEntryImagePair.second; } 
    361         const Image* getImage() const { return _bufferEntryImagePair.second; } 
    362          
    363         unsigned int offset() const { return _bufferEntryImagePair.first.offset; } 
    364          
    365         virtual void compileBuffer(State& state) const; 
    366  
    367         /** Resize any per context GLObject buffers to specified size. */ 
    368         virtual void resizeGLObjectBuffers(unsigned int maxSize); 
     465        Image* getImage(); 
     466        const Image* getImage() const; 
     467 
     468        bool isPBOSupported(unsigned int contextID) const { return _glBufferObjects[contextID]->isPBOSupported(); } 
    369469 
    370470    protected: 
    371471     
    372472        virtual ~PixelBufferObject(); 
    373          
    374         BufferEntryImagePair _bufferEntryImagePair; 
    375473}; 
    376474 
     
    390488 
    391489        //! Set new size of the buffer object. This will reallocate the memory on the next compile 
    392         inline void setDataSize(unsigned int size) { _bufferData.dataSize = size; dirty(); } 
     490        inline void setDataSize(unsigned int size) { _dataSize = size; dirty(); } 
    393491 
    394492        //! Get data size of the used buffer  
    395         inline unsigned int getDataSize() { return _bufferData.dataSize; } 
     493        inline unsigned int getDataSize() const { return _dataSize; } 
    396494 
    397495        //! Compile the buffer (reallocate the memory if buffer is dirty) 
     
    428526        virtual ~PixelDataBufferObject(); 
    429527 
    430         BufferEntry _bufferData; 
     528        unsigned int _dataSize; 
    431529 
    432530        typedef osg::buffered_value<unsigned int> ModeList;