vcglib/wrap/glw/buffer.h

#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)
		{
			this->clear();
		}

		BufferArguments(GLsizeiptr aSize, GLenum aUsage = GL_STATIC_DRAW, const void * aData = 0)
			: BaseType ()
			, size     (aSize)
			, usage    (aUsage)
			, data     (aData)
		{
			;
		}

		void clear(void)
		{
			BaseType::clear();
			this->size  = 0;
			this->usage = GL_STATIC_DRAW;
			this->data  = 0;
		}
};

class Buffer : public Object
{
	friend class Context;

	public:

		typedef Object BaseType;
		typedef Buffer ThisType;

		virtual ~Buffer(void)
		{
			this->destroy();
		}

		virtual Type type(void) const
		{
			return BufferType;
		}

		GLsizeiptr size(void) const
		{
			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);
		}

	protected:

		GLsizeiptr m_size;
		GLenum     m_usage;
		GLenum     m_mapAccess;
		void *     m_mapPointer;

		Buffer(Context * ctx)
			: BaseType     (ctx)
			, m_size       (0)
			, m_usage      (GL_NONE)
			, m_mapAccess  (GL_NONE)
			, m_mapPointer (0)
		{
			;
		}

		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);
		}
};

namespace detail { template <> struct BaseOf <Buffer> { typedef Object Type; }; };
typedef   detail::ObjectSharedPointerTraits  <Buffer> ::Type BufferPtr;

class SafeBuffer : public SafeObject
{
	friend class Context;
	friend class BoundBuffer;

	public:

		typedef SafeObject BaseType;
		typedef SafeBuffer ThisType;

		SafeBuffer(void)
			: BaseType()
		{
			;
		}

		GLsizeiptr size(void) const
		{
			return this->object()->size();
		}

		GLenum usage(void) const
		{
			return this->object()->usage();
		}

	protected:

		SafeBuffer(const BufferPtr & buffer)
			: BaseType(buffer)
		{
			;
		}

		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);
		}

		void * map(GLenum access)
		{
			return this->object()->map(this->m_target, this->m_unit, access);
		}

		void unmap(void)
		{
			this->object()->unmap(this->m_target, this->m_unit);
		}

		GLenum mapAccess(void) const
		{
			return this->object()->mapAccess(this->m_target, this->m_unit);
		}

		bool isMapped(void) const
		{
			return this->object()->isMapped(this->m_target, this->m_unit);
		}

		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()
		{
			;
		}

		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);
		}

	protected:

		BoundVertexBuffer(const BufferHandle & handle, const VertexBufferBindingParams & params)
			: BaseType(handle, params)
		{
			;
		}
};

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)
		{
			;
		}
};

class BoundIndexBuffer : public BoundBuffer
{
	friend class Context;

	public:

		typedef BoundBuffer       BaseType;
		typedef BoundIndexBuffer ThisType;

		BoundIndexBuffer(void)
			: BaseType()
		{
			;
		}

		void drawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices)
		{
			this->object()->drawElements(this->m_target, this->m_unit, mode, count, type, indices);
		}

	protected:

		BoundIndexBuffer(const BufferHandle & handle, const IndexBufferBindingParams & params)
			: BaseType(handle, params)
		{
			;
		}
};

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)
		{
			;
		}
};

class BoundPixelPackBuffer : public BoundBuffer
{
	friend class Context;

	public:

		typedef BoundBuffer          BaseType;
		typedef BoundPixelPackBuffer ThisType;

		BoundPixelPackBuffer(void)
			: BaseType()
		{
			;
		}

	protected:

		BoundPixelPackBuffer(const BufferHandle & handle, const PixelPackBufferBindingParams & params)
			: BaseType(handle, params)
		{
			;
		}
};

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;

		PixelUnpackBufferBindingParams(void)
			: BaseType(GL_PIXEL_UNPACK_BUFFER, 0)
		{
			;
		}
};

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);
		}

	private:

		GLintptr   m_offset;
		GLsizeiptr m_size;
};

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;

};

#endif // GLW_BUFFER_H