vcglib/wrap/glw/buffer.h

704 lines
16 KiB
C
Raw Normal View History

2012-04-30 20:23:53 +02:00
#ifndef GLW_BUFFER_H
#define GLW_BUFFER_H
#include "./object.h"
namespace glw
{
class BufferArguments : public ObjectArguments
{
public:
typedef ObjectArguments BaseType;
typedef BufferArguments ThisType;
GLsizeiptr size;
GLenum usage;
const void * data;
BufferArguments(void)
: BaseType ()
, size (0)
, usage (GL_STATIC_DRAW)
, data (0)
2012-04-30 20:23:53 +02:00
{
this->clear();
}
BufferArguments(GLsizeiptr aSize, GLenum aUsage = GL_STATIC_DRAW, const void * aData = 0)
: BaseType ()
, size (aSize)
, usage (aUsage)
, data (aData)
{
;
}
2012-04-30 20:23:53 +02:00
void clear(void)
{
BaseType::clear();
this->size = 0;
this->usage = GL_STATIC_DRAW;
2012-04-30 20:23:53 +02:00
this->data = 0;
}
};
class Buffer : public Object
2012-04-30 20:23:53 +02:00
{
friend class Context;
2012-04-30 20:23:53 +02:00
public:
typedef Object BaseType;
typedef Buffer ThisType;
virtual ~Buffer(void)
{
this->destroy();
}
2012-04-30 20:23:53 +02:00
virtual Type type(void) const
{
return BufferType;
}
GLsizeiptr size(void) const
2012-04-30 20:23:53 +02:00
{
return this->m_size;
}
GLenum usage(void) const
{
return this->m_usage;
}
void setData(GLenum target, GLint unit, const GLsizeiptr size, GLenum usage, const GLvoid * data)
{
(void)unit;
GLW_ASSERT(this->isValid());
glBufferData(target, size, data, usage);
this->m_size = size;
this->m_usage = usage;
}
void setSubData(GLenum target, GLint unit, GLintptr offset, GLsizeiptr size, const GLvoid * data)
{
(void)unit;
GLW_ASSERT(this->isValid());
glBufferSubData(target, offset, size, data);
}
void getSubData(GLenum target, GLint unit, GLintptr offset, GLsizeiptr size, GLvoid * data)
{
(void)unit;
GLW_ASSERT(this->isValid());
glGetBufferSubData(target, offset, size, data);
}
void * map(GLenum target, GLint unit, GLenum access)
{
(void)unit;
GLW_ASSERT(this->isValid());
GLW_ASSERT(!this->isMapped(target, unit));
void * ptr = glMapBuffer(target, access);
if (ptr == 0) return 0;
this->m_mapAccess = access;
this->m_mapPointer = ptr;
return ptr;
}
void unmap(GLenum target, GLint unit)
{
(void)unit;
GLW_ASSERT(this->isValid());
GLW_ASSERT(this->isMapped(target, unit));
glUnmapBuffer(target);
this->m_mapAccess = GL_NONE;
this->m_mapPointer = 0;
}
GLenum mapAccess(GLenum target, GLint unit) const
{
(void)target;
(void)unit;
return this->m_mapAccess;
}
bool isMapped(GLenum target, GLint unit) const
{
(void)target;
(void)unit;
return (this->m_mapAccess != GL_NONE);
}
void * mapPointer(GLenum target, GLint unit) const
{
(void)target;
(void)unit;
return this->m_mapPointer;
}
void vertexAttribPointer(GLenum target, GLint unit, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * offset)
{
(void)target;
(void)unit;
GLW_ASSERT(this->isValid());
glVertexAttribPointer(index, size, type, normalized, stride, offset);
}
void drawElements(GLenum target, GLint unit, GLenum mode, GLsizei count, GLenum type, const GLvoid * indices)
{
(void)target;
(void)unit;
GLW_ASSERT(this->isValid());
glDrawElements(mode, count, type, indices);
}
2012-04-30 20:23:53 +02:00
protected:
GLsizeiptr m_size;
GLenum m_usage;
GLenum m_mapAccess;
void * m_mapPointer;
2012-04-30 20:23:53 +02:00
Buffer(Context * ctx)
: BaseType (ctx)
, m_size (0)
, m_usage (GL_NONE)
, m_mapAccess (GL_NONE)
, m_mapPointer (0)
2012-04-30 20:23:53 +02:00
{
;
}
bool create(const BufferArguments & args)
{
this->destroy();
GLint boundName = 0;
glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &boundName);
glGenBuffers(1, &(this->m_name));
glBindBuffer(GL_ARRAY_BUFFER, this->m_name);
glBufferData(GL_ARRAY_BUFFER, args.size, args.data, args.usage);
glBindBuffer(GL_ARRAY_BUFFER, boundName);
this->m_size = args.size;
this->m_usage = args.usage;
return true;
}
virtual void doDestroy(void)
{
glDeleteBuffers(1, &(this->m_name));
this->m_size = 0;
this->m_usage = GL_NONE;
this->m_mapAccess = GL_NONE;
this->m_mapPointer = 0;
}
virtual bool doIsValid(void) const
{
return (this->m_size > 0);
}
2012-04-30 20:23:53 +02:00
};
namespace detail { template <> struct BaseOf <Buffer> { typedef Object Type; }; };
typedef detail::ObjectSharedPointerTraits <Buffer> ::Type BufferPtr;
class SafeBuffer : public SafeObject
2012-04-30 20:23:53 +02:00
{
friend class Context;
friend class BoundBuffer;
2012-04-30 20:23:53 +02:00
public:
typedef SafeObject BaseType;
typedef SafeBuffer ThisType;
2012-04-30 20:23:53 +02:00
SafeBuffer(void)
: BaseType()
2012-04-30 20:23:53 +02:00
{
;
2012-04-30 20:23:53 +02:00
}
GLsizeiptr size(void) const
2012-04-30 20:23:53 +02:00
{
return this->object()->size();
2012-04-30 20:23:53 +02:00
}
GLenum usage(void) const
2012-04-30 20:23:53 +02:00
{
return this->object()->usage();
2012-04-30 20:23:53 +02:00
}
protected:
SafeBuffer(const BufferPtr & buffer)
: BaseType(buffer)
2012-04-30 20:23:53 +02:00
{
;
}
const BufferPtr & object(void) const
{
return static_cast<const BufferPtr &>(BaseType::object());
}
BufferPtr & object(void)
{
return static_cast<BufferPtr &>(BaseType::object());
}
};
namespace detail { template <> struct BaseOf <SafeBuffer> { typedef SafeObject Type; }; };
namespace detail { template <> struct ObjectBase <SafeBuffer> { typedef Buffer Type; }; };
namespace detail { template <> struct ObjectSafe <Buffer > { typedef SafeBuffer Type; }; };
typedef detail::ObjectSharedPointerTraits <SafeBuffer> ::Type BufferHandle;
class BufferBindingParams : public ObjectBindingParams
{
public:
typedef ObjectBindingParams BaseType;
typedef BufferBindingParams ThisType;
BufferBindingParams(void)
: BaseType()
{
;
}
BufferBindingParams(GLenum aTarget, GLenum aUnit)
: BaseType(aTarget, aUnit)
{
;
}
};
class BoundBuffer : public BoundObject
{
friend class Context;
public:
typedef BoundObject BaseType;
typedef BoundBuffer ThisType;
BoundBuffer(void)
: BaseType()
{
;
}
const BufferHandle & handle(void) const
{
return static_cast<const BufferHandle &>(BaseType::handle());
}
BufferHandle & handle(void)
{
return static_cast<BufferHandle &>(BaseType::handle());
}
void setData(const GLsizeiptr size, GLenum usage, const GLvoid * data)
{
this->object()->setData(this->m_target, this->m_unit, size, usage, data);
}
void setSubData(GLintptr offset, GLsizeiptr size, const GLvoid * data)
{
this->object()->setSubData(this->m_target, this->m_unit, offset, size, data);
}
void getSubData(GLintptr offset, GLsizeiptr size, GLvoid * data)
{
this->object()->getSubData(this->m_target, this->m_unit, offset, size, data);
2012-04-30 20:23:53 +02:00
}
void * map(GLenum access)
{
return this->object()->map(this->m_target, this->m_unit, access);
2012-04-30 20:23:53 +02:00
}
void unmap(void)
{
this->object()->unmap(this->m_target, this->m_unit);
2012-04-30 20:23:53 +02:00
}
GLenum mapAccess(void) const
{
return this->object()->mapAccess(this->m_target, this->m_unit);
2012-04-30 20:23:53 +02:00
}
bool isMapped(void) const
{
return this->object()->isMapped(this->m_target, this->m_unit);
2012-04-30 20:23:53 +02:00
}
void * mapPointer(void) const
{
return this->object()->mapPointer(this->m_target, this->m_unit);
}
protected:
BoundBuffer(const BufferHandle & handle, const BufferBindingParams & params)
: BaseType(handle, params)
{
;
}
const BufferPtr & object(void) const
{
return this->handle()->object();
}
BufferPtr & object(void)
{
return this->handle()->object();
}
virtual void bind(void)
{
glBindBuffer(this->m_target, this->object()->name());
}
virtual void unbind(void)
{
glBindBuffer(this->m_target, 0);
}
};
namespace detail { template <> struct ParamsOf <BoundBuffer> { typedef BufferBindingParams Type; }; };
namespace detail { template <> struct BaseOf <BoundBuffer> { typedef BoundObject Type; }; };
namespace detail { template <> struct ObjectBase <BoundBuffer> { typedef Buffer Type; }; };
namespace detail { template <> struct ObjectBound <Buffer > { typedef BoundBuffer Type; }; };
typedef detail::ObjectSharedPointerTraits <BoundBuffer> ::Type BoundBufferHandle;
class VertexBufferBindingParams : public BufferBindingParams
{
public:
typedef BufferBindingParams BaseType;
typedef VertexBufferBindingParams ThisType;
VertexBufferBindingParams(void)
: BaseType(GL_ARRAY_BUFFER, 0)
{
;
}
};
class BoundVertexBuffer : public BoundBuffer
{
friend class Context;
public:
typedef BoundBuffer BaseType;
typedef BoundVertexBuffer ThisType;
BoundVertexBuffer(void)
: BaseType()
{
;
2012-04-30 20:23:53 +02:00
}
void vertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * offset)
{
this->object()->vertexAttribPointer(this->m_target, this->m_unit, index, size, type, normalized, stride, offset);
2012-04-30 20:23:53 +02:00
}
protected:
BoundVertexBuffer(const BufferHandle & handle, const VertexBufferBindingParams & params)
: BaseType(handle, params)
2012-04-30 20:23:53 +02:00
{
;
}
};
2012-04-30 20:23:53 +02:00
namespace detail { template <> struct ParamsOf <BoundVertexBuffer> { typedef VertexBufferBindingParams Type; }; };
namespace detail { template <> struct BaseOf <BoundVertexBuffer> { typedef BoundBuffer Type; }; };
namespace detail { template <> struct ObjectBase <BoundVertexBuffer> { typedef Buffer Type; }; };
typedef detail::ObjectSharedPointerTraits <BoundVertexBuffer> ::Type BoundVertexBufferHandle;
class IndexBufferBindingParams : public BufferBindingParams
{
public:
typedef BufferBindingParams BaseType;
typedef IndexBufferBindingParams ThisType;
IndexBufferBindingParams(void)
: BaseType(GL_ELEMENT_ARRAY_BUFFER, 0)
2012-04-30 20:23:53 +02:00
{
;
2012-04-30 20:23:53 +02:00
}
};
2012-04-30 20:23:53 +02:00
class BoundIndexBuffer : public BoundBuffer
{
friend class Context;
public:
typedef BoundBuffer BaseType;
typedef BoundIndexBuffer ThisType;
BoundIndexBuffer(void)
: BaseType()
2012-04-30 20:23:53 +02:00
{
;
}
2012-04-30 20:23:53 +02:00
void drawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices)
{
this->object()->drawElements(this->m_target, this->m_unit, mode, count, type, indices);
}
2012-04-30 20:23:53 +02:00
protected:
2012-04-30 20:23:53 +02:00
BoundIndexBuffer(const BufferHandle & handle, const IndexBufferBindingParams & params)
: BaseType(handle, params)
{
;
}
};
2012-04-30 20:23:53 +02:00
namespace detail { template <> struct ParamsOf <BoundIndexBuffer> { typedef IndexBufferBindingParams Type; }; };
namespace detail { template <> struct BaseOf <BoundIndexBuffer> { typedef BoundBuffer Type; }; };
namespace detail { template <> struct ObjectBase <BoundIndexBuffer> { typedef Buffer Type; }; };
typedef detail::ObjectSharedPointerTraits <BoundIndexBuffer> ::Type BoundIndexBufferHandle;
class PixelPackBufferBindingParams : public BufferBindingParams
{
public:
typedef BufferBindingParams BaseType;
typedef PixelPackBufferBindingParams ThisType;
PixelPackBufferBindingParams(void)
: BaseType(GL_PIXEL_PACK_BUFFER, 0)
{
;
2012-04-30 20:23:53 +02:00
}
};
class BoundPixelPackBuffer : public BoundBuffer
{
friend class Context;
public:
2012-04-30 20:23:53 +02:00
typedef BoundBuffer BaseType;
typedef BoundPixelPackBuffer ThisType;
BoundPixelPackBuffer(void)
: BaseType()
2012-04-30 20:23:53 +02:00
{
;
2012-04-30 20:23:53 +02:00
}
protected:
BoundPixelPackBuffer(const BufferHandle & handle, const PixelPackBufferBindingParams & params)
: BaseType(handle, params)
2012-04-30 20:23:53 +02:00
{
;
2012-04-30 20:23:53 +02:00
}
};
namespace detail { template <> struct ParamsOf <BoundPixelPackBuffer> { typedef PixelPackBufferBindingParams Type; }; };
namespace detail { template <> struct BaseOf <BoundPixelPackBuffer> { typedef BoundBuffer Type; }; };
namespace detail { template <> struct ObjectBase <BoundPixelPackBuffer> { typedef Buffer Type; }; };
typedef detail::ObjectSharedPointerTraits <BoundPixelPackBuffer> ::Type BoundPixelPackBufferHandle;
class PixelUnpackBufferBindingParams : public BufferBindingParams
{
public:
typedef BufferBindingParams BaseType;
typedef PixelUnpackBufferBindingParams ThisType;
2012-04-30 20:23:53 +02:00
PixelUnpackBufferBindingParams(void)
: BaseType(GL_PIXEL_UNPACK_BUFFER, 0)
2012-04-30 20:23:53 +02:00
{
;
}
};
class BoundPixelUnpackBuffer : public BoundBuffer
{
friend class Context;
public:
typedef BoundBuffer BaseType;
typedef BoundPixelUnpackBuffer ThisType;
BoundPixelUnpackBuffer(void)
: BaseType()
{
;
}
protected:
BoundPixelUnpackBuffer(const BufferHandle & handle, const PixelUnpackBufferBindingParams & params)
: BaseType(handle, params)
{
;
}
};
namespace detail { template <> struct ParamsOf <BoundPixelUnpackBuffer> { typedef PixelUnpackBufferBindingParams Type; }; };
namespace detail { template <> struct BaseOf <BoundPixelUnpackBuffer> { typedef BoundBuffer Type; }; };
namespace detail { template <> struct ObjectBase <BoundPixelUnpackBuffer> { typedef Buffer Type; }; };
typedef detail::ObjectSharedPointerTraits <BoundPixelUnpackBuffer> ::Type BoundPixelUnpackBufferHandle;
class UniformBufferBindingParams : public BufferBindingParams
{
public:
typedef BufferBindingParams BaseType;
typedef UniformBufferBindingParams ThisType;
GLintptr offset;
GLsizeiptr size;
UniformBufferBindingParams(void)
: BaseType (GL_UNIFORM_BUFFER, 0)
, offset (0)
, size (0)
{
;
}
UniformBufferBindingParams(GLuint aIndex, GLintptr aOffset, GLsizeiptr aSize)
: BaseType (GL_UNIFORM_BUFFER, GLint(aIndex))
, offset (aOffset)
, size (aSize)
{
;
}
};
class BoundUniformBuffer : public BoundBuffer
{
friend class Context;
public:
typedef BoundBuffer BaseType;
typedef BoundUniformBuffer ThisType;
BoundUniformBuffer(void)
: BaseType()
{
;
}
protected:
BoundUniformBuffer(const BufferHandle & handle, const UniformBufferBindingParams & params)
: BaseType(handle, params)
{
;
}
virtual void bind(void)
{
glBindBufferRange(this->m_target, GLuint(this->m_unit), this->object()->name(), this->m_offset, this->m_size);
}
virtual void unbind(void)
{
glBindBufferRange(this->m_target, GLuint(this->m_unit), 0, 0, 0);
}
private:
GLintptr m_offset;
GLsizeiptr m_size;
};
namespace detail { template <> struct ParamsOf <BoundUniformBuffer> { typedef UniformBufferBindingParams Type; }; };
namespace detail { template <> struct BaseOf <BoundUniformBuffer> { typedef BoundBuffer Type; }; };
namespace detail { template <> struct ObjectBase <BoundUniformBuffer> { typedef Buffer Type; }; };
typedef detail::ObjectSharedPointerTraits <BoundUniformBuffer> ::Type BoundUniformBufferHandle;
class FeedbackBufferBindingParams : public BufferBindingParams
{
public:
typedef BufferBindingParams BaseType;
typedef FeedbackBufferBindingParams ThisType;
GLintptr offset;
GLsizeiptr size;
FeedbackBufferBindingParams(void)
: BaseType (GL_TRANSFORM_FEEDBACK_BUFFER, 0)
, offset (0)
, size (0)
{
;
}
FeedbackBufferBindingParams(GLuint aIndex, GLintptr aOffset, GLsizeiptr aSize)
: BaseType (GL_TRANSFORM_FEEDBACK_BUFFER, GLint(aIndex))
, offset (aOffset)
, size (aSize)
{
;
}
};
class BoundFeedbackBuffer : public BoundBuffer
{
friend class Context;
public:
typedef BoundBuffer BaseType;
typedef BoundFeedbackBuffer ThisType;
BoundFeedbackBuffer(void)
: BaseType()
{
;
}
protected:
BoundFeedbackBuffer(const BufferHandle & handle, const FeedbackBufferBindingParams & params)
: BaseType(handle, params)
{
;
}
virtual void bind(void)
{
glBindBufferRange(this->m_target, GLuint(this->m_unit), this->object()->name(), this->m_offset, this->m_size);
}
virtual void unbind(void)
{
glBindBufferRange(this->m_target, GLuint(this->m_unit), 0, 0, 0);
2012-04-30 20:23:53 +02:00
}
private:
GLintptr m_offset;
GLsizeiptr m_size;
2012-04-30 20:23:53 +02:00
};
namespace detail { template <> struct ParamsOf <BoundFeedbackBuffer> { typedef FeedbackBufferBindingParams Type; }; };
namespace detail { template <> struct BaseOf <BoundFeedbackBuffer> { typedef BoundBuffer Type; }; };
namespace detail { template <> struct ObjectBase <BoundFeedbackBuffer> { typedef Buffer Type; }; };
typedef detail::ObjectSharedPointerTraits <BoundFeedbackBuffer> ::Type BoundFeedbackBufferHandle;
2012-04-30 20:23:53 +02:00
};
2012-04-30 20:23:53 +02:00
#endif // GLW_BUFFER_H