6d66e1abaa
parameter in osg::Image. To support this Image::setData(..) now has a new optional rowLength parameter which defaults to 0, which provides the original behaviour, Image::setRowLength(int) and int Image::getRowLength() are also provided. With the introduction of RowLength support in osg::Image it is now possible to create a sub image where the t size of the image are smaller than the row length, useful for when you have a large image on the CPU and which to use a small portion of it on the GPU. However, when these sub images are created the data within the image is no longer contiguous so data access can no longer assume that all the data is in one block. The new method Image::isDataContiguous() enables the user to check whether the data is contiguous, and if not one can either access the data row by row using Image::data(column,row,image) accessor, or use the new Image::DataIterator for stepping through each block on memory assocatied with the image. To support the possibility of non contiguous osg::Image usage of image objects has had to be updated to check DataContiguous and handle the case or use access via the DataIerator or by row by row. To achieve this a relatively large number of files has had to be modified, in particular the texture classes and image plugins that doing writing.
841 lines
32 KiB
C++
841 lines
32 KiB
C++
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
|
|
*
|
|
* This library is open source and may be redistributed and/or modified under
|
|
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
|
|
* (at your option) any later version. The full license is in LICENSE file
|
|
* included with this distribution, and on the openscenegraph.org website.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* OpenSceneGraph Public License for more details.
|
|
*/
|
|
|
|
#ifndef OSG_BUFFEROBJECT
|
|
#define OSG_BUFFEROBJECT 1
|
|
|
|
#include <osg/GL>
|
|
#include <osg/Object>
|
|
#include <osg/buffered_value>
|
|
#include <osg/FrameStamp>
|
|
|
|
#include <iosfwd>
|
|
#include <list>
|
|
#include <map>
|
|
|
|
// identify GLES 1.1
|
|
#if (defined(GL_VERSION_ES_CM_1_0) && GL_VERSION_ES_CM_1_0 > 0) || \
|
|
(defined(GL_VERSION_ES_CM_1_1) && GL_VERSION_ES_CM_1_1 > 0)
|
|
|
|
#define OPENGLES_1_1_FOUND 1
|
|
|
|
#endif
|
|
|
|
// for compatibility with gl.h headers that don't support VBO,
|
|
//GL_VERSION_1_5 and GL_ARB_vertex_buffer_object provide these types for OpenGL
|
|
//all ES versions except GL_OES_VERSION_1_0 provide these types for OpenGL ES
|
|
#if !defined(GL_VERSION_1_5) && !defined(GL_ARB_vertex_buffer_object) \
|
|
&& !defined(GL_ES_VERSION_2_0) && !defined(OPENGLES_1_1_FOUND)
|
|
#if defined(_WIN64)
|
|
typedef __int64 GLintptr;
|
|
typedef __int64 GLsizeiptr;
|
|
#elif defined(__ia64__) || defined(__x86_64__) || defined(ANDROID)
|
|
typedef long int GLintptr;
|
|
typedef long int GLsizeiptr;
|
|
#else
|
|
typedef int GLintptr;
|
|
typedef int GLsizeiptr;
|
|
#endif
|
|
#endif
|
|
|
|
#ifndef GL_ARB_vertex_buffer_object
|
|
#define GL_ARB_vertex_buffer_object
|
|
|
|
typedef GLintptr GLintptrARB;
|
|
typedef GLsizeiptr GLsizeiptrARB;
|
|
|
|
#define GL_ARRAY_BUFFER_ARB 0x8892
|
|
#define GL_ELEMENT_ARRAY_BUFFER_ARB 0x8893
|
|
#define GL_ARRAY_BUFFER_BINDING_ARB 0x8894
|
|
#define GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB 0x8895
|
|
#define GL_VERTEX_ARRAY_BUFFER_BINDING_ARB 0x8896
|
|
#define GL_NORMAL_ARRAY_BUFFER_BINDING_ARB 0x8897
|
|
#define GL_COLOR_ARRAY_BUFFER_BINDING_ARB 0x8898
|
|
#define GL_INDEX_ARRAY_BUFFER_BINDING_ARB 0x8899
|
|
#define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB 0x889A
|
|
#define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB 0x889B
|
|
#define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB 0x889C
|
|
#define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB 0x889D
|
|
#define GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB 0x889E
|
|
#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB 0x889F
|
|
#define GL_STREAM_DRAW_ARB 0x88E0
|
|
#define GL_STREAM_READ_ARB 0x88E1
|
|
#define GL_STREAM_COPY_ARB 0x88E2
|
|
#define GL_STATIC_DRAW_ARB 0x88E4
|
|
#define GL_STATIC_READ_ARB 0x88E5
|
|
#define GL_STATIC_COPY_ARB 0x88E6
|
|
#define GL_DYNAMIC_DRAW_ARB 0x88E8
|
|
#define GL_DYNAMIC_READ_ARB 0x88E9
|
|
#define GL_DYNAMIC_COPY_ARB 0x88EA
|
|
#define GL_READ_ONLY_ARB 0x88B8
|
|
#define GL_WRITE_ONLY_ARB 0x88B9
|
|
#define GL_READ_WRITE_ARB 0x88BA
|
|
#define GL_BUFFER_SIZE_ARB 0x8764
|
|
#define GL_BUFFER_USAGE_ARB 0x8765
|
|
#define GL_BUFFER_ACCESS_ARB 0x88BB
|
|
#define GL_BUFFER_MAPPED_ARB 0x88BC
|
|
#define GL_BUFFER_MAP_POINTER_ARB 0x88BD
|
|
#endif
|
|
|
|
#ifndef GL_VERSION_1_5
|
|
#define GL_STREAM_DRAW 0x88E0
|
|
#define GL_STREAM_READ 0x88E1
|
|
#define GL_STREAM_COPY 0x88E2
|
|
#define GL_STATIC_DRAW 0x88E4
|
|
#define GL_STATIC_READ 0x88E5
|
|
#define GL_STATIC_COPY 0x88E6
|
|
#define GL_DYNAMIC_DRAW 0x88E8
|
|
#define GL_DYNAMIC_READ 0x88E9
|
|
#define GL_DYNAMIC_COPY 0x88EA
|
|
#endif
|
|
|
|
#ifndef GL_VERSION_2_1
|
|
#define GL_PIXEL_PACK_BUFFER 0x88EB
|
|
#define GL_PIXEL_UNPACK_BUFFER 0x88EC
|
|
#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED
|
|
#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF
|
|
#endif
|
|
|
|
|
|
#ifndef GL_ARB_pixel_buffer_object
|
|
#define GL_PIXEL_PACK_BUFFER_ARB 0x88EB
|
|
#define GL_PIXEL_UNPACK_BUFFER_ARB 0x88EC
|
|
#define GL_PIXEL_PACK_BUFFER_BINDING_ARB 0x88ED
|
|
#define GL_PIXEL_UNPACK_BUFFER_BINDING_ARB 0x88EF
|
|
#endif
|
|
|
|
namespace osg
|
|
{
|
|
|
|
class State;
|
|
class BufferData;
|
|
class BufferObject;
|
|
|
|
class BufferObjectProfile
|
|
{
|
|
public:
|
|
BufferObjectProfile():
|
|
_target(0),
|
|
_usage(0),
|
|
_size(0) {}
|
|
|
|
BufferObjectProfile(GLenum target, GLenum usage, unsigned int size):
|
|
_target(target),
|
|
_usage(usage),
|
|
_size(size) {}
|
|
|
|
BufferObjectProfile(const BufferObjectProfile& bpo):
|
|
_target(bpo._target),
|
|
_usage(bpo._usage),
|
|
_size(bpo._size) {}
|
|
|
|
bool operator < (const BufferObjectProfile& rhs) const
|
|
{
|
|
if (_target < rhs._target) return true;
|
|
else if (_target > rhs._target) return false;
|
|
if (_usage < rhs._usage) return true;
|
|
else if (_usage > rhs._usage) return false;
|
|
return _size < rhs._size;
|
|
}
|
|
|
|
bool operator == (const BufferObjectProfile& rhs) const
|
|
{
|
|
return (_target == rhs._target) &&
|
|
(_usage == rhs._usage) &&
|
|
(_size == rhs._size);
|
|
}
|
|
|
|
void setProfile(GLenum target, GLenum usage, unsigned int size)
|
|
{
|
|
_target = target;
|
|
_usage = usage;
|
|
_size = size;
|
|
}
|
|
|
|
BufferObjectProfile& operator = (const BufferObjectProfile& rhs)
|
|
{
|
|
_target = rhs._target;
|
|
_usage = rhs._usage;
|
|
_size = rhs._size;
|
|
return *this;
|
|
}
|
|
|
|
GLenum _target;
|
|
GLenum _usage;
|
|
GLenum _size;
|
|
};
|
|
|
|
// forward declare
|
|
class GLBufferObjectSet;
|
|
class GLBufferObjectManager;
|
|
|
|
class OSG_EXPORT GLBufferObject : public Referenced
|
|
{
|
|
public:
|
|
|
|
GLBufferObject(unsigned int contextID, BufferObject* bufferObject, unsigned int glObjectID=0);
|
|
|
|
void setProfile(const BufferObjectProfile& profile) { _profile = profile; }
|
|
const BufferObjectProfile& getProfile() const { return _profile; }
|
|
|
|
void setBufferObject(BufferObject* bufferObject);
|
|
BufferObject* getBufferObject() { return _bufferObject; }
|
|
|
|
struct BufferEntry
|
|
{
|
|
BufferEntry(): modifiedCount(0),dataSize(0),offset(0),dataSource(0) {}
|
|
|
|
BufferEntry(const BufferEntry& rhs):
|
|
modifiedCount(rhs.modifiedCount),
|
|
dataSize(rhs.dataSize),
|
|
offset(rhs.offset),
|
|
dataSource(rhs.dataSource) {}
|
|
|
|
BufferEntry& operator = (const BufferEntry& rhs)
|
|
{
|
|
if (&rhs==this) return *this;
|
|
modifiedCount = rhs.modifiedCount;
|
|
dataSize = rhs.dataSize;
|
|
offset = rhs.offset;
|
|
dataSource = rhs.dataSource;
|
|
return *this;
|
|
}
|
|
|
|
unsigned int modifiedCount;
|
|
unsigned int dataSize;
|
|
unsigned int offset;
|
|
BufferData* dataSource;
|
|
};
|
|
|
|
inline unsigned int getContextID() const { return _contextID; }
|
|
|
|
inline GLuint& getGLObjectID() { return _glObjectID; }
|
|
inline GLuint getGLObjectID() const { return _glObjectID; }
|
|
inline GLsizeiptrARB getOffset(unsigned int i) const { return _bufferEntries[i].offset; }
|
|
|
|
inline void bindBuffer();
|
|
|
|
inline void unbindBuffer()
|
|
{
|
|
_extensions->glBindBuffer(_profile._target,0);
|
|
}
|
|
|
|
inline bool isDirty() const { return _dirty; }
|
|
|
|
void dirty() { _dirty = true; }
|
|
|
|
void clear();
|
|
|
|
void compileBuffer();
|
|
|
|
void deleteGLObject();
|
|
|
|
void assign(BufferObject* bufferObject);
|
|
|
|
bool isPBOSupported() const { return _extensions->isPBOSupported(); }
|
|
|
|
static GLBufferObject* createGLBufferObject(unsigned int contextID, const BufferObject* bufferObject);
|
|
|
|
static void deleteAllBufferObjects(unsigned int contextID);
|
|
static void discardAllBufferObjects(unsigned int contextID);
|
|
static void flushAllDeletedBufferObjects(unsigned int contextID);
|
|
static void discardAllDeletedBufferObjects(unsigned int contextID);
|
|
static void flushDeletedBufferObjects(unsigned int contextID,double currentTime, double& availbleTime);
|
|
static void releaseGLBufferObject(unsigned int contextID, GLBufferObject* to);
|
|
|
|
/** Extensions class which encapsulates the querying of extensions and
|
|
* associated function pointers, and provide convenience wrappers to
|
|
* check for the extensions or use the associated functions.*/
|
|
class OSG_EXPORT Extensions : public osg::Referenced
|
|
{
|
|
public:
|
|
Extensions(unsigned int contextID);
|
|
|
|
Extensions(const Extensions& rhs);
|
|
|
|
void lowestCommonDenominator(const Extensions& rhs);
|
|
|
|
void setupGLExtensions(unsigned int contextID);
|
|
|
|
bool isBufferObjectSupported() const { return _glGenBuffers!=0; }
|
|
bool isPBOSupported() const { return _isPBOSupported; }
|
|
bool isUniformBufferObjectSupported() const { return _isUniformBufferObjectSupported; }
|
|
|
|
void glGenBuffers (GLsizei n, GLuint *buffers) const;
|
|
void glBindBuffer (GLenum target, GLuint buffer) const;
|
|
void glBufferData (GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage) const;
|
|
void glBufferSubData (GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid *data) const;
|
|
void glDeleteBuffers (GLsizei n, const GLuint *buffers) const;
|
|
GLboolean glIsBuffer (GLuint buffer) const;
|
|
void glGetBufferSubData (GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid *data) const;
|
|
GLvoid* glMapBuffer (GLenum target, GLenum access) const;
|
|
GLboolean glUnmapBuffer (GLenum target) const;
|
|
void glGetBufferParameteriv (GLenum target, GLenum pname, GLint *params) const;
|
|
void glGetBufferPointerv (GLenum target, GLenum pname, GLvoid* *params) const;
|
|
void glBindBufferRange (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
|
|
void glBindBufferBase (GLenum target, GLuint index, GLuint buffer);
|
|
|
|
protected:
|
|
|
|
typedef void (GL_APIENTRY * GenBuffersProc) (GLsizei n, GLuint *buffers);
|
|
typedef void (GL_APIENTRY * BindBufferProc) (GLenum target, GLuint buffer);
|
|
typedef void (GL_APIENTRY * BufferDataProc) (GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage);
|
|
typedef void (GL_APIENTRY * BufferSubDataProc) (GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid *data);
|
|
typedef void (GL_APIENTRY * DeleteBuffersProc) (GLsizei n, const GLuint *buffers);
|
|
typedef GLboolean (GL_APIENTRY * IsBufferProc) (GLuint buffer);
|
|
typedef void (GL_APIENTRY * GetBufferSubDataProc) (GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid *data);
|
|
typedef GLvoid* (GL_APIENTRY * MapBufferProc) (GLenum target, GLenum access);
|
|
typedef GLboolean (GL_APIENTRY * UnmapBufferProc) (GLenum target);
|
|
typedef void (GL_APIENTRY * GetBufferParameterivProc) (GLenum target, GLenum pname, GLint *params);
|
|
typedef void (GL_APIENTRY * GetBufferPointervProc) (GLenum target, GLenum pname, GLvoid* *params);
|
|
typedef void (GL_APIENTRY * BindBufferRangeProc) (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
|
|
typedef void (GL_APIENTRY * BindBufferBaseProc) (GLenum target, GLuint index, GLuint buffer);
|
|
|
|
|
|
GenBuffersProc _glGenBuffers;
|
|
BindBufferProc _glBindBuffer;
|
|
BufferDataProc _glBufferData;
|
|
BufferSubDataProc _glBufferSubData;
|
|
DeleteBuffersProc _glDeleteBuffers;
|
|
IsBufferProc _glIsBuffer;
|
|
GetBufferSubDataProc _glGetBufferSubData;
|
|
MapBufferProc _glMapBuffer;
|
|
UnmapBufferProc _glUnmapBuffer;
|
|
GetBufferParameterivProc _glGetBufferParameteriv;
|
|
GetBufferPointervProc _glGetBufferPointerv;
|
|
BindBufferRangeProc _glBindBufferRange;
|
|
BindBufferBaseProc _glBindBufferBase;
|
|
|
|
bool _isPBOSupported;
|
|
bool _isUniformBufferObjectSupported;
|
|
};
|
|
|
|
/** Function to call to get the extension of a specified context.
|
|
* If the Extension object for that context has not yet been created
|
|
* and the 'createIfNotInitalized' flag been set to false then returns NULL.
|
|
* If 'createIfNotInitalized' is true then the Extensions object is
|
|
* automatically created. However, in this case the extension object is
|
|
* only created with the graphics context associated with ContextID..*/
|
|
static Extensions* getExtensions(unsigned int contextID,bool createIfNotInitalized);
|
|
|
|
/** setExtensions allows users to override the extensions across graphics contexts.
|
|
* typically used when you have different extensions supported across graphics pipes
|
|
* but need to ensure that they all use the same low common denominator extensions.*/
|
|
static void setExtensions(unsigned int contextID,Extensions* extensions);
|
|
|
|
protected:
|
|
|
|
virtual ~GLBufferObject();
|
|
|
|
unsigned int computeBufferAlignment(unsigned int pos, unsigned int bufferAlignment) const
|
|
{
|
|
if (bufferAlignment<2) return pos;
|
|
if ((pos%bufferAlignment)==0) return pos;
|
|
return ((pos/bufferAlignment)+1)*bufferAlignment;
|
|
}
|
|
|
|
unsigned int _contextID;
|
|
GLuint _glObjectID;
|
|
|
|
BufferObjectProfile _profile;
|
|
unsigned int _allocatedSize;
|
|
|
|
bool _dirty;
|
|
|
|
typedef std::vector<BufferEntry> BufferEntries;
|
|
BufferEntries _bufferEntries;
|
|
|
|
BufferObject* _bufferObject;
|
|
|
|
public:
|
|
|
|
GLBufferObjectSet* _set;
|
|
GLBufferObject* _previous;
|
|
GLBufferObject* _next;
|
|
unsigned int _frameLastUsed;
|
|
|
|
public:
|
|
Extensions* _extensions;
|
|
|
|
};
|
|
|
|
typedef std::list< ref_ptr<GLBufferObject> > GLBufferObjectList;
|
|
|
|
class OSG_EXPORT GLBufferObjectSet : public Referenced
|
|
{
|
|
public:
|
|
GLBufferObjectSet(GLBufferObjectManager* parent, const BufferObjectProfile& profile);
|
|
|
|
const BufferObjectProfile& getProfile() const { return _profile; }
|
|
|
|
void handlePendingOrphandedGLBufferObjects();
|
|
|
|
void deleteAllGLBufferObjects();
|
|
void discardAllGLBufferObjects();
|
|
void flushAllDeletedGLBufferObjects();
|
|
void discardAllDeletedGLBufferObjects();
|
|
void flushDeletedGLBufferObjects(double currentTime, double& availableTime);
|
|
|
|
GLBufferObject* takeFromOrphans(BufferObject* bufferObject);
|
|
GLBufferObject* takeOrGenerate(BufferObject* bufferObject);
|
|
|
|
void moveToBack(GLBufferObject* to);
|
|
void addToBack(GLBufferObject* to);
|
|
void orphan(GLBufferObject* to);
|
|
void remove(GLBufferObject* to);
|
|
void moveToSet(GLBufferObject* to, GLBufferObjectSet* set);
|
|
|
|
unsigned int size() const { return _profile._size * _numOfGLBufferObjects; }
|
|
|
|
bool makeSpace(unsigned int& size);
|
|
|
|
bool checkConsistency() const;
|
|
|
|
GLBufferObjectManager* getParent() { return _parent; }
|
|
|
|
unsigned int computeNumGLBufferObjectsInList() const;
|
|
unsigned int getNumOfGLBufferObjects() const { return _numOfGLBufferObjects; }
|
|
unsigned int getNumOrphans() const { return _orphanedGLBufferObjects.size(); }
|
|
unsigned int getNumPendingOrphans() const { return _pendingOrphanedGLBufferObjects.size(); }
|
|
|
|
|
|
protected:
|
|
|
|
virtual ~GLBufferObjectSet();
|
|
|
|
OpenThreads::Mutex _mutex;
|
|
|
|
GLBufferObjectManager* _parent;
|
|
unsigned int _contextID;
|
|
BufferObjectProfile _profile;
|
|
unsigned int _numOfGLBufferObjects;
|
|
GLBufferObjectList _orphanedGLBufferObjects;
|
|
GLBufferObjectList _pendingOrphanedGLBufferObjects;
|
|
|
|
GLBufferObject* _head;
|
|
GLBufferObject* _tail;
|
|
};
|
|
|
|
class OSG_EXPORT GLBufferObjectManager : public osg::Referenced
|
|
{
|
|
public:
|
|
GLBufferObjectManager(unsigned int contextID);
|
|
|
|
unsigned int getContextID() const { return _contextID; }
|
|
|
|
|
|
void setNumberActiveGLBufferObjects(unsigned int size) { _numActiveGLBufferObjects = size; }
|
|
unsigned int& getNumberActiveGLBufferObjects() { return _numActiveGLBufferObjects; }
|
|
unsigned int getNumberActiveGLBufferObjects() const { return _numActiveGLBufferObjects; }
|
|
|
|
void setNumberOrphanedGLBufferObjects(unsigned int size) { _numOrphanedGLBufferObjects = size; }
|
|
unsigned int& getNumberOrphanedGLBufferObjects() { return _numOrphanedGLBufferObjects; }
|
|
unsigned int getNumberOrphanedGLBufferObjects() const { return _numOrphanedGLBufferObjects; }
|
|
|
|
void setCurrGLBufferObjectPoolSize(unsigned int size) { _currGLBufferObjectPoolSize = size; }
|
|
unsigned int& getCurrGLBufferObjectPoolSize() { return _currGLBufferObjectPoolSize; }
|
|
unsigned int getCurrGLBufferObjectPoolSize() const { return _currGLBufferObjectPoolSize; }
|
|
|
|
void setMaxGLBufferObjectPoolSize(unsigned int size);
|
|
unsigned int getMaxGLBufferObjectPoolSize() const { return _maxGLBufferObjectPoolSize; }
|
|
|
|
bool hasSpace(unsigned int size) const { return (_currGLBufferObjectPoolSize+size)<=_maxGLBufferObjectPoolSize; }
|
|
bool makeSpace(unsigned int size);
|
|
|
|
GLBufferObject* generateGLBufferObject(const osg::BufferObject* bufferObject);
|
|
|
|
void handlePendingOrphandedGLBufferObjects();
|
|
|
|
void deleteAllGLBufferObjects();
|
|
void discardAllGLBufferObjects();
|
|
void flushAllDeletedGLBufferObjects();
|
|
void discardAllDeletedGLBufferObjects();
|
|
void flushDeletedGLBufferObjects(double currentTime, double& availableTime);
|
|
void releaseGLBufferObject(GLBufferObject* to);
|
|
|
|
GLBufferObjectSet* getGLBufferObjectSet(const BufferObjectProfile& profile);
|
|
|
|
void newFrame(osg::FrameStamp* fs);
|
|
void resetStats();
|
|
void reportStats(std::ostream& out);
|
|
void recomputeStats(std::ostream& out);
|
|
|
|
unsigned int& getFrameNumber() { return _frameNumber; }
|
|
unsigned int& getNumberFrames() { return _numFrames; }
|
|
|
|
unsigned int& getNumberDeleted() { return _numDeleted; }
|
|
double& getDeleteTime() { return _deleteTime; }
|
|
|
|
unsigned int& getNumberGenerated() { return _numGenerated; }
|
|
double& getGenerateTime() { return _generateTime; }
|
|
|
|
unsigned int& getNumberApplied() { return _numApplied; }
|
|
double& getApplyTime() { return _applyTime; }
|
|
|
|
static osg::ref_ptr<GLBufferObjectManager>& getGLBufferObjectManager(unsigned int contextID);
|
|
|
|
protected:
|
|
|
|
typedef std::map< BufferObjectProfile, osg::ref_ptr<GLBufferObjectSet> > GLBufferObjectSetMap;
|
|
unsigned int _contextID;
|
|
unsigned int _numActiveGLBufferObjects;
|
|
unsigned int _numOrphanedGLBufferObjects;
|
|
unsigned int _currGLBufferObjectPoolSize;
|
|
unsigned int _maxGLBufferObjectPoolSize;
|
|
GLBufferObjectSetMap _glBufferObjectSetMap;
|
|
|
|
unsigned int _frameNumber;
|
|
|
|
unsigned int _numFrames;
|
|
unsigned int _numDeleted;
|
|
double _deleteTime;
|
|
|
|
unsigned int _numGenerated;
|
|
double _generateTime;
|
|
|
|
unsigned int _numApplied;
|
|
double _applyTime;
|
|
|
|
};
|
|
|
|
|
|
class OSG_EXPORT BufferObject : public Object
|
|
{
|
|
public:
|
|
|
|
BufferObject();
|
|
|
|
/** Copy constructor using CopyOp to manage deep vs shallow copy.*/
|
|
BufferObject(const BufferObject& bo,const CopyOp& copyop=CopyOp::SHALLOW_COPY);
|
|
|
|
virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const BufferObject*>(obj)!=NULL; }
|
|
virtual const char* libraryName() const { return "osg"; }
|
|
virtual const char* className() const { return "BufferObject"; }
|
|
|
|
void setTarget(GLenum target) { _profile._target = target; }
|
|
GLenum getTarget() const { return _profile._target; }
|
|
|
|
/** Set what type of usage the buffer object will have. Options are:
|
|
* GL_STREAM_DRAW, GL_STREAM_READ, GL_STREAM_COPY,
|
|
* GL_STATIC_DRAW, GL_STATIC_READ, GL_STATIC_COPY,
|
|
* GL_DYNAMIC_DRAW, GL_DYNAMIC_READ, or GL_DYNAMIC_COPY.
|
|
*/
|
|
void setUsage(GLenum usage) { _profile._usage = usage; }
|
|
|
|
/** Get the type of usage the buffer object has been set up for.*/
|
|
GLenum getUsage() const { return _profile._usage; }
|
|
|
|
BufferObjectProfile& getProfile() { return _profile; }
|
|
const BufferObjectProfile& getProfile() const { return _profile; }
|
|
|
|
|
|
/** Set whether the BufferObject should use a GLBufferObject just for copying the BufferData and release it immmediately so that it may be reused.*/
|
|
void setCopyDataAndReleaseGLBufferObject(bool copyAndRelease) { _copyDataAndReleaseGLBufferObject = copyAndRelease; }
|
|
|
|
/** Get whether the BufferObject should use a GLBufferObject just for copying the BufferData and release it immmediately.*/
|
|
bool getCopyDataAndReleaseGLBufferObject() const { return _copyDataAndReleaseGLBufferObject; }
|
|
|
|
|
|
void dirty();
|
|
|
|
/** Resize any per context GLObject buffers to specified size. */
|
|
virtual void resizeGLObjectBuffers(unsigned int maxSize);
|
|
|
|
/** If State is non-zero, this function releases OpenGL objects for
|
|
* the specified graphics context. Otherwise, releases OpenGL objects
|
|
* for all graphics contexts. */
|
|
void releaseGLObjects(State* state=0) const;
|
|
|
|
unsigned int addBufferData(BufferData* bd);
|
|
void removeBufferData(unsigned int index);
|
|
void removeBufferData(BufferData* bd);
|
|
|
|
void setBufferData(unsigned int index, BufferData* bd);
|
|
BufferData* getBufferData(unsigned int index) { return _bufferDataList[index]; }
|
|
const BufferData* getBufferData(unsigned int index) const { return _bufferDataList[index]; }
|
|
|
|
unsigned int getNumBufferData() const { return _bufferDataList.size(); }
|
|
|
|
void setGLBufferObject(unsigned int contextID, GLBufferObject* glbo) { _glBufferObjects[contextID] = glbo; }
|
|
|
|
GLBufferObject* getGLBufferObject(unsigned int contextID) const { return _glBufferObjects[contextID].get(); }
|
|
|
|
GLBufferObject* getOrCreateGLBufferObject(unsigned int contextID) const
|
|
{
|
|
if (!_glBufferObjects[contextID]) _glBufferObjects[contextID] = GLBufferObject::createGLBufferObject(contextID, this);
|
|
return _glBufferObjects[contextID].get();
|
|
}
|
|
|
|
unsigned int computeRequiredBufferSize() const;
|
|
|
|
/** deprecated, provided for backwards compatibility.*/
|
|
static void deleteBufferObject(unsigned int contextID,GLuint globj);
|
|
|
|
protected:
|
|
|
|
~BufferObject();
|
|
|
|
typedef std::vector< BufferData* > BufferDataList;
|
|
typedef osg::buffered_object< osg::ref_ptr<GLBufferObject> > GLBufferObjects;
|
|
|
|
BufferObjectProfile _profile;
|
|
|
|
bool _copyDataAndReleaseGLBufferObject;
|
|
|
|
BufferDataList _bufferDataList;
|
|
|
|
mutable GLBufferObjects _glBufferObjects;
|
|
};
|
|
|
|
class OSG_EXPORT BufferData : public Object
|
|
{
|
|
public:
|
|
|
|
BufferData():
|
|
Object(true),
|
|
_modifiedCount(0),
|
|
_bufferIndex(0) {}
|
|
|
|
/** Copy constructor using CopyOp to manage deep vs shallow copy.*/
|
|
BufferData(const BufferData& bd,const CopyOp& copyop=CopyOp::SHALLOW_COPY):
|
|
osg::Object(bd,copyop),
|
|
_modifiedCount(0),
|
|
_bufferIndex(0),
|
|
_modifiedCallback(bd._modifiedCallback) {}
|
|
|
|
virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const BufferData*>(obj)!=NULL; }
|
|
virtual const char* libraryName() const { return "osg"; }
|
|
virtual const char* className() const { return "BufferData"; }
|
|
|
|
virtual const GLvoid* getDataPointer() const = 0;
|
|
virtual unsigned int getTotalDataSize() const = 0;
|
|
|
|
virtual osg::Array* asArray() { return 0; }
|
|
virtual const osg::Array* asArray() const { return 0; }
|
|
|
|
virtual osg::PrimitiveSet* asPrimitiveSet() { return 0; }
|
|
virtual const osg::PrimitiveSet* asPrimitiveSet() const { return 0; }
|
|
|
|
virtual osg::Image* asImage() { return 0; }
|
|
virtual const osg::Image* asImage() const { return 0; }
|
|
|
|
void setBufferObject(BufferObject* bufferObject);
|
|
BufferObject* getBufferObject() { return _bufferObject.get(); }
|
|
const BufferObject* getBufferObject() const { return _bufferObject.get(); }
|
|
|
|
void setBufferIndex(unsigned int index) { _bufferIndex = index; }
|
|
unsigned int getBufferIndex() const { return _bufferIndex; }
|
|
|
|
GLBufferObject* getGLBufferObject(unsigned int contextID) const { return _bufferObject.valid() ? _bufferObject->getGLBufferObject(contextID) : 0; }
|
|
GLBufferObject* getOrCreateGLBufferObject(unsigned int contextID) const { return _bufferObject.valid() ? _bufferObject->getOrCreateGLBufferObject(contextID) : 0; }
|
|
|
|
struct ModifiedCallback : public virtual osg::Object
|
|
{
|
|
ModifiedCallback() {}
|
|
|
|
ModifiedCallback(const ModifiedCallback&,const CopyOp&) {}
|
|
|
|
META_Object(osg,ModifiedCallback);
|
|
|
|
virtual void modified(BufferData* /*bufferData*/) const {}
|
|
};
|
|
|
|
void setModifiedCallback(ModifiedCallback* md) { _modifiedCallback = md; }
|
|
ModifiedCallback* getModifiedCallback() { return _modifiedCallback.get(); }
|
|
const ModifiedCallback* getModifiedCallback() const { return _modifiedCallback.get(); }
|
|
|
|
/** Dirty the primitive, which increments the modified count, to force buffer objects to update.
|
|
* If a ModifiedCallback is attached to this BufferData then the callback is called prior to the bufferObject's dirty is called. */
|
|
inline void dirty()
|
|
{
|
|
++_modifiedCount;
|
|
if (_modifiedCallback.valid()) _modifiedCallback->modified(this);
|
|
if (_bufferObject.valid()) _bufferObject->dirty();
|
|
}
|
|
|
|
/** Set the modified count value.*/
|
|
inline void setModifiedCount(unsigned int value) { _modifiedCount=value; }
|
|
|
|
/** Get modified count value.*/
|
|
inline unsigned int getModifiedCount() const { return _modifiedCount; }
|
|
|
|
/** Resize any per context GLObject buffers to specified size. */
|
|
virtual void resizeGLObjectBuffers(unsigned int maxSize);
|
|
|
|
/** If State is non-zero, this function releases OpenGL objects for
|
|
* the specified graphics context. Otherwise, releases OpenGL objects
|
|
* for all graphics contexts. */
|
|
void releaseGLObjects(State* state=0) const;
|
|
|
|
protected:
|
|
|
|
virtual ~BufferData();
|
|
|
|
unsigned int _modifiedCount;
|
|
|
|
unsigned int _bufferIndex;
|
|
osg::ref_ptr<BufferObject> _bufferObject;
|
|
osg::ref_ptr<ModifiedCallback> _modifiedCallback;
|
|
};
|
|
|
|
|
|
class Array;
|
|
class OSG_EXPORT VertexBufferObject : public BufferObject
|
|
{
|
|
public:
|
|
|
|
VertexBufferObject();
|
|
|
|
/** Copy constructor using CopyOp to manage deep vs shallow copy.*/
|
|
VertexBufferObject(const VertexBufferObject& vbo,const CopyOp& copyop=CopyOp::SHALLOW_COPY);
|
|
|
|
META_Object(osg,VertexBufferObject);
|
|
|
|
unsigned int addArray(osg::Array* array);
|
|
void removeArray(osg::Array* array);
|
|
|
|
void setArray(unsigned int i, Array* array);
|
|
Array* getArray(unsigned int i);
|
|
const Array* getArray(unsigned int i) const;
|
|
|
|
protected:
|
|
virtual ~VertexBufferObject();
|
|
};
|
|
|
|
class DrawElements;
|
|
class OSG_EXPORT ElementBufferObject : public BufferObject
|
|
{
|
|
public:
|
|
|
|
ElementBufferObject();
|
|
|
|
/** Copy constructor using CopyOp to manage deep vs shallow copy.*/
|
|
ElementBufferObject(const ElementBufferObject& pbo,const CopyOp& copyop=CopyOp::SHALLOW_COPY);
|
|
|
|
META_Object(osg,ElementBufferObject);
|
|
|
|
unsigned int addDrawElements(osg::DrawElements* PrimitiveSet);
|
|
void removeDrawElements(osg::DrawElements* PrimitiveSet);
|
|
|
|
void setDrawElements(unsigned int i, DrawElements* PrimitiveSet);
|
|
DrawElements* getDrawElements(unsigned int i);
|
|
const DrawElements* getDrawElements(unsigned int i) const;
|
|
|
|
protected:
|
|
|
|
virtual ~ElementBufferObject();
|
|
};
|
|
|
|
class Image;
|
|
class OSG_EXPORT PixelBufferObject : public BufferObject
|
|
{
|
|
public:
|
|
|
|
PixelBufferObject(osg::Image* image=0);
|
|
|
|
/** Copy constructor using CopyOp to manage deep vs shallow copy.*/
|
|
PixelBufferObject(const PixelBufferObject& pbo,const CopyOp& copyop=CopyOp::SHALLOW_COPY);
|
|
|
|
META_Object(osg,PixelBufferObject);
|
|
|
|
void setImage(osg::Image* image);
|
|
|
|
Image* getImage();
|
|
const Image* getImage() const;
|
|
|
|
bool isPBOSupported(unsigned int contextID) const { return _glBufferObjects[contextID]->isPBOSupported(); }
|
|
|
|
protected:
|
|
|
|
virtual ~PixelBufferObject();
|
|
};
|
|
|
|
/**
|
|
* This object represent a general class of pixel buffer objects,
|
|
* which are capable of allocating buffer object (memory)
|
|
* on the GPU. The memory can then be used either for CPU-GPU
|
|
* pixel transfer or directly for GPU-GPU transfer, without CPU intervention.
|
|
**/
|
|
class OSG_EXPORT PixelDataBufferObject : public BufferObject
|
|
{
|
|
public:
|
|
PixelDataBufferObject();
|
|
PixelDataBufferObject(const PixelDataBufferObject& pbo, const CopyOp& copyop=CopyOp::SHALLOW_COPY);
|
|
|
|
META_Object(osg, PixelDataBufferObject);
|
|
|
|
//! Set new size of the buffer object. This will reallocate the memory on the next compile
|
|
inline void setDataSize(unsigned int size) { _profile._size = size; dirty(); }
|
|
|
|
//! Get data size of the used buffer
|
|
inline unsigned int getDataSize() const { return _profile._size; }
|
|
|
|
//! Compile the buffer (reallocate the memory if buffer is dirty)
|
|
virtual void compileBuffer(State& state) const;
|
|
|
|
//! Bind the buffer in read mode, which means that data can be downloaded from the buffer (note: GL_PIXEL_UNPACK_BUFFER_ARB)
|
|
virtual void bindBufferInReadMode(State& state);
|
|
|
|
//! Bind the buffer in write mode, which means following OpenGL instructions will write data into the buffer (note: GL_PIXEL_PACK_BUFFER_ARB)
|
|
virtual void bindBufferInWriteMode(State& state);
|
|
|
|
//! Unbind the buffer
|
|
virtual void unbindBuffer(unsigned int contextID) const;
|
|
|
|
/** Resize any per context GLObject buffers to specified size. */
|
|
virtual void resizeGLObjectBuffers(unsigned int maxSize);
|
|
|
|
enum Mode
|
|
{
|
|
//! A normal mode of this data buffer
|
|
NONE = 0,
|
|
|
|
//! Buffer is in read mode (@see bindBufferInReadMode)
|
|
READ = 1,
|
|
|
|
//! Buffer is in write mode (@see bindBufferInWriteMode)
|
|
WRITE = 2
|
|
};
|
|
|
|
Mode getMode(unsigned int contextID) const { return (Mode)_mode[contextID]; }
|
|
|
|
protected:
|
|
|
|
virtual ~PixelDataBufferObject();
|
|
|
|
typedef osg::buffered_value<unsigned int> ModeList;
|
|
|
|
mutable ModeList _mode;
|
|
|
|
};
|
|
|
|
class OSG_EXPORT UniformBufferObject : public BufferObject
|
|
{
|
|
public:
|
|
UniformBufferObject();
|
|
UniformBufferObject(const UniformBufferObject& ubo, const CopyOp& copyop=CopyOp::SHALLOW_COPY);
|
|
META_Object(osg, UniformBufferObject);
|
|
protected:
|
|
virtual ~UniformBufferObject();
|
|
};
|
|
|
|
inline void GLBufferObject::bindBuffer()
|
|
{
|
|
_extensions->glBindBuffer(_profile._target,_glObjectID);
|
|
if (_set) _set->moveToBack(this);
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|