784 lines
21 KiB
C++
784 lines
21 KiB
C++
#ifndef GLW_FRAMEBUFFER_H
|
|
#define GLW_FRAMEBUFFER_H
|
|
|
|
#include "./texture2d.h"
|
|
#include "./renderbuffer.h"
|
|
|
|
#include <vector>
|
|
#include <map>
|
|
#include <set>
|
|
|
|
namespace glw
|
|
{
|
|
|
|
class RenderTarget
|
|
{
|
|
public:
|
|
|
|
typedef void BaseType;
|
|
typedef RenderTarget ThisType;
|
|
|
|
RenderableHandle target;
|
|
GLint level;
|
|
GLint layer;
|
|
GLenum face;
|
|
|
|
RenderTarget(void)
|
|
{
|
|
this->clear();
|
|
}
|
|
|
|
RenderTarget(RenderableHandle & rTarget, GLint rLevel, GLint rLayer, GLenum rFace)
|
|
: target (rTarget)
|
|
, level (rLevel)
|
|
, layer (rLayer)
|
|
, face (rFace)
|
|
{
|
|
;
|
|
}
|
|
|
|
RenderTarget(RenderableHandle & rTarget)
|
|
: target (rTarget)
|
|
, level (0)
|
|
, layer (0)
|
|
, face (GL_TEXTURE_CUBE_MAP_POSITIVE_X)
|
|
{
|
|
;
|
|
}
|
|
|
|
void clear(void)
|
|
{
|
|
this->target.setNull();
|
|
this->level = 0;
|
|
this->layer = -1;
|
|
this->face = GL_TEXTURE_CUBE_MAP_POSITIVE_X;
|
|
}
|
|
|
|
bool isNull(void) const
|
|
{
|
|
return this->target.isNull();
|
|
}
|
|
};
|
|
|
|
typedef std::vector<RenderTarget> RenderTargetVector;
|
|
|
|
inline RenderTarget texture2DTarget(Texture2DHandle & handle, GLint level = 0)
|
|
{
|
|
return RenderTarget(handle, level, 0, GL_NONE);
|
|
}
|
|
|
|
inline RenderTarget textureCubeTarget(TextureCubeHandle & handle, GLenum face = GL_TEXTURE_CUBE_MAP_POSITIVE_X, GLint level = 0)
|
|
{
|
|
return RenderTarget(handle, level, 0, face);
|
|
}
|
|
|
|
inline RenderTarget renderbufferTarget(RenderbufferHandle & handle)
|
|
{
|
|
return RenderTarget(handle, 0, 0, GL_NONE);
|
|
}
|
|
|
|
class RenderTargetMapping
|
|
{
|
|
public:
|
|
|
|
typedef void BaseType;
|
|
typedef RenderTargetMapping ThisType;
|
|
|
|
typedef std::map<GLuint, RenderTarget> Map;
|
|
typedef Map::const_iterator ConstIterator;
|
|
typedef Map::iterator Iterator;
|
|
typedef Map::value_type Value;
|
|
|
|
Map bindings;
|
|
|
|
RenderTargetMapping(void)
|
|
{
|
|
this->clear();
|
|
}
|
|
|
|
void clear(void)
|
|
{
|
|
this->bindings.clear();
|
|
}
|
|
|
|
const RenderTarget & operator [] (GLuint attachmentIndex) const
|
|
{
|
|
return this->bindings.find(attachmentIndex)->second;
|
|
}
|
|
|
|
RenderTarget & operator [] (GLuint attachmentIndex)
|
|
{
|
|
return this->bindings[attachmentIndex];
|
|
}
|
|
};
|
|
|
|
class RenderTargetBinding
|
|
{
|
|
public:
|
|
|
|
typedef void BaseType;
|
|
typedef RenderTargetBinding ThisType;
|
|
|
|
typedef std::map<GLuint, GLuint> Map;
|
|
typedef Map::const_iterator ConstIterator;
|
|
typedef Map::iterator Iterator;
|
|
typedef Map::value_type Value;
|
|
|
|
Map bindings;
|
|
|
|
RenderTargetBinding(void)
|
|
{
|
|
this->clear();
|
|
}
|
|
|
|
void clear(void)
|
|
{
|
|
this->bindings.clear();
|
|
}
|
|
|
|
GLuint operator [] (GLuint attachmentIndex) const
|
|
{
|
|
return this->bindings.find(attachmentIndex)->second;
|
|
}
|
|
|
|
GLuint & operator [] (GLuint attachmentIndex)
|
|
{
|
|
return this->bindings[attachmentIndex];
|
|
}
|
|
};
|
|
|
|
class FramebufferArguments : public ObjectArguments
|
|
{
|
|
public:
|
|
|
|
typedef ObjectArguments BaseType;
|
|
typedef FramebufferArguments ThisType;
|
|
|
|
RenderTargetMapping colorTargets;
|
|
RenderTarget depthTarget;
|
|
RenderTarget stencilTarget;
|
|
RenderTargetBinding targetInputs;
|
|
|
|
FramebufferArguments(void)
|
|
: BaseType()
|
|
{
|
|
;
|
|
}
|
|
|
|
void clear(void)
|
|
{
|
|
BaseType::clear();
|
|
this->colorTargets .clear();
|
|
this->depthTarget .clear();
|
|
this->stencilTarget .clear();
|
|
this->targetInputs .clear();
|
|
}
|
|
};
|
|
|
|
class Framebuffer : public Object
|
|
{
|
|
friend class Context;
|
|
|
|
public:
|
|
|
|
typedef Object BaseType;
|
|
typedef Framebuffer ThisType;
|
|
|
|
virtual ~Framebuffer(void)
|
|
{
|
|
this->destroy();
|
|
}
|
|
|
|
virtual Type type(void) const
|
|
{
|
|
return FramebufferType;
|
|
}
|
|
|
|
const FramebufferArguments & arguments(void) const
|
|
{
|
|
return this->m_config;
|
|
}
|
|
|
|
bool setColorTarget(GLenum target, GLint unit, GLint index, const RenderTarget & renderTarget)
|
|
{
|
|
(void)unit;
|
|
GLW_ASSERT(this->isValid());
|
|
this->m_config.colorTargets[index].clear();
|
|
const bool r = this->attachTarget(target, GL_COLOR_ATTACHMENT0 + index, renderTarget);
|
|
if (!r) return false;
|
|
this->m_config.colorTargets[index] = renderTarget;
|
|
return true;
|
|
}
|
|
|
|
bool removeColorTarget(GLenum target, GLint unit, GLint index)
|
|
{
|
|
(void)unit;
|
|
GLW_ASSERT(this->isValid());
|
|
glFramebufferRenderbuffer(target, GL_COLOR_ATTACHMENT0 + index, GL_RENDERBUFFER, 0);
|
|
this->m_config.colorTargets[index].clear();
|
|
return true;
|
|
}
|
|
|
|
bool removeAllColorTargets(GLenum target, GLint unit)
|
|
{
|
|
(void)unit;
|
|
for (RenderTargetMapping::ConstIterator it=this->m_config.colorTargets.bindings.begin(); it!=this->m_config.colorTargets.bindings.end(); ++it)
|
|
{
|
|
glFramebufferRenderbuffer(target, GL_COLOR_ATTACHMENT0 + it->first, GL_RENDERBUFFER, 0);
|
|
}
|
|
this->m_config.colorTargets.clear();
|
|
return true;
|
|
}
|
|
|
|
bool setDepthTarget(GLenum target, GLint unit, const RenderTarget & renderTarget)
|
|
{
|
|
(void)unit;
|
|
GLW_ASSERT(this->isValid());
|
|
this->m_config.depthTarget.clear();
|
|
const bool r = this->attachTarget(target, GL_DEPTH_ATTACHMENT, renderTarget);
|
|
if (!r) return false;
|
|
this->m_config.depthTarget = renderTarget;
|
|
return true;
|
|
}
|
|
|
|
bool removeDepthTarget(GLenum target, GLint unit)
|
|
{
|
|
(void)unit;
|
|
GLW_ASSERT(this->isValid());
|
|
glFramebufferRenderbuffer(target, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0);
|
|
this->m_config.depthTarget.clear();
|
|
return true;
|
|
}
|
|
|
|
bool setStencilTarget(GLenum target, GLint unit, const RenderTarget & renderTarget)
|
|
{
|
|
(void)unit;
|
|
GLW_ASSERT(this->isValid());
|
|
this->m_config.stencilTarget.clear();
|
|
const bool r = this->attachTarget(target, GL_STENCIL_ATTACHMENT, renderTarget);
|
|
if (!r) return false;
|
|
this->m_config.stencilTarget = renderTarget;
|
|
return true;
|
|
}
|
|
|
|
bool removeStencilTarget(GLenum target, GLint unit)
|
|
{
|
|
(void)unit;
|
|
GLW_ASSERT(this->isValid());
|
|
glFramebufferRenderbuffer(target, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, 0);
|
|
this->m_config.stencilTarget.clear();
|
|
return true;
|
|
}
|
|
|
|
bool removeAllTargets(GLenum target, GLint unit)
|
|
{
|
|
this->removeAllColorTargets (target, unit);
|
|
this->removeDepthTarget (target, unit);
|
|
this->removeStencilTarget (target, unit);
|
|
return true;
|
|
}
|
|
|
|
bool setTargetInputs(GLenum target, GLint unit, const RenderTargetBinding & targetInputs)
|
|
{
|
|
(void)target;
|
|
(void)unit;
|
|
GLW_ASSERT(this->isValid());
|
|
this->configureTargetInputs(targetInputs);
|
|
return true;
|
|
}
|
|
|
|
bool readColorPixels(GLenum target, GLint unit, GLint index, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid * data)
|
|
{
|
|
(void)target;
|
|
(void)unit;
|
|
GLW_ASSERT(this->isValid());
|
|
if (this->m_config.colorTargets.bindings.count(index) <= 0)
|
|
{
|
|
GLW_ASSERT(0);
|
|
return false;
|
|
}
|
|
glReadBuffer(GL_COLOR_ATTACHMENT0 + index);
|
|
glReadPixels(x, y, width, height, format, type, data);
|
|
return true;
|
|
}
|
|
|
|
bool readDepthPixels(GLenum target, GLint unit, GLint x, GLint y, GLsizei width, GLsizei height, GLenum type, GLvoid * data)
|
|
{
|
|
(void)target;
|
|
(void)unit;
|
|
GLW_ASSERT(this->isValid());
|
|
if (this->m_config.depthTarget.isNull())
|
|
{
|
|
GLW_ASSERT(0);
|
|
return false;
|
|
}
|
|
glReadPixels(x, y, width, height, GL_DEPTH_COMPONENT, type, data);
|
|
return true;
|
|
}
|
|
|
|
bool readStencilPixels(GLenum target, GLint unit, GLint x, GLint y, GLsizei width, GLsizei height, GLenum type, GLvoid * data)
|
|
{
|
|
(void)target;
|
|
(void)unit;
|
|
GLW_ASSERT(this->isValid());
|
|
if (this->m_config.stencilTarget.isNull())
|
|
{
|
|
GLW_ASSERT(0);
|
|
return false;
|
|
}
|
|
glReadPixels(x, y, width, height, GL_STENCIL_INDEX, type, data);
|
|
return true;
|
|
}
|
|
|
|
protected:
|
|
|
|
Framebuffer(Context * ctx)
|
|
: BaseType(ctx)
|
|
{
|
|
;
|
|
}
|
|
|
|
bool create(const FramebufferArguments & args)
|
|
{
|
|
this->destroy();
|
|
|
|
GLint boundNameDraw = 0;
|
|
glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &boundNameDraw);
|
|
|
|
GLint boundNameRead = 0;
|
|
glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &boundNameRead);
|
|
|
|
glGenFramebuffers(1, &(this->m_name));
|
|
glBindFramebuffer(GL_FRAMEBUFFER, this->m_name);
|
|
this->configure(GL_FRAMEBUFFER, args);
|
|
glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
|
|
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, boundNameDraw);
|
|
glBindFramebuffer(GL_READ_FRAMEBUFFER, boundNameRead);
|
|
|
|
return true;
|
|
}
|
|
|
|
virtual void doDestroy(void)
|
|
{
|
|
glDeleteFramebuffers(1, &(this->m_name));
|
|
this->m_config.clear();
|
|
}
|
|
|
|
virtual bool doIsValid(void) const
|
|
{
|
|
return true;
|
|
}
|
|
|
|
private:
|
|
|
|
FramebufferArguments m_config;
|
|
|
|
void configure(GLenum target, const FramebufferArguments & args)
|
|
{
|
|
this->m_config.clear();
|
|
|
|
for (RenderTargetMapping::ConstIterator it=args.colorTargets.bindings.begin(); it!=args.colorTargets.bindings.end(); ++it)
|
|
{
|
|
const bool colorAttached = this->attachTarget(target, GL_COLOR_ATTACHMENT0 + it->first, it->second);
|
|
if (!colorAttached) continue;
|
|
this->m_config.colorTargets[it->first] = it->second;
|
|
}
|
|
|
|
const bool depthAttached = this->attachTarget(target, GL_DEPTH_ATTACHMENT, args.depthTarget);
|
|
if (depthAttached) this->m_config.depthTarget = args.depthTarget;
|
|
|
|
const bool stencilAttached = this->attachTarget(target, GL_STENCIL_ATTACHMENT, args.stencilTarget);
|
|
if (stencilAttached) this->m_config.stencilTarget = args.stencilTarget;
|
|
|
|
this->configureTargetInputs(args.targetInputs);
|
|
}
|
|
|
|
bool attachTarget(GLenum target, GLenum attachment, const RenderTarget & renderTarget)
|
|
{
|
|
const RenderableHandle & handle = renderTarget.target;
|
|
|
|
if (!handle)
|
|
{
|
|
glFramebufferRenderbuffer(target, attachment, GL_RENDERBUFFER, 0);
|
|
return false;
|
|
}
|
|
|
|
switch (handle->type())
|
|
{
|
|
case RenderbufferType : glFramebufferRenderbuffer (target, attachment, GL_RENDERBUFFER, handle->name() ); break;
|
|
case Texture2DType : glFramebufferTexture2D (target, attachment, GL_TEXTURE_2D, handle->name(), renderTarget.level); break;
|
|
case TextureCubeType : glFramebufferTexture2D (target, attachment, renderTarget.face, handle->name(), renderTarget.level); break;
|
|
default : GLW_ASSERT(0); break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void configureTargetInputs(const RenderTargetBinding & targetInputs)
|
|
{
|
|
if (this->m_config.colorTargets.bindings.empty() && targetInputs.bindings.empty())
|
|
{
|
|
glDrawBuffer(GL_NONE);
|
|
glReadBuffer(GL_NONE);
|
|
return;
|
|
}
|
|
|
|
std::vector<GLenum> drawBuffers;
|
|
drawBuffers.reserve(targetInputs.bindings.size());
|
|
for (RenderTargetBinding::ConstIterator it=targetInputs.bindings.begin(); it!=targetInputs.bindings.end(); ++it)
|
|
{
|
|
const GLuint fragOutput = it->second;
|
|
const GLuint attachmentIndex = GL_COLOR_ATTACHMENT0 + it->first;
|
|
if (drawBuffers.size() <= size_t(fragOutput))
|
|
{
|
|
drawBuffers.resize(size_t(fragOutput + 1), GL_NONE);
|
|
}
|
|
drawBuffers[fragOutput] = attachmentIndex;
|
|
this->m_config.targetInputs[it->first] = fragOutput;
|
|
}
|
|
glDrawBuffers(GLsizei(drawBuffers.size()), &(drawBuffers[0]));
|
|
glReadBuffer(drawBuffers[0]);
|
|
}
|
|
};
|
|
|
|
namespace detail { template <> struct BaseOf <Framebuffer> { typedef Object Type; }; };
|
|
typedef detail::ObjectSharedPointerTraits <Framebuffer> ::Type FramebufferPtr;
|
|
|
|
class SafeFramebuffer : public SafeObject
|
|
{
|
|
friend class Context;
|
|
friend class BoundFramebuffer;
|
|
|
|
public:
|
|
|
|
typedef SafeObject BaseType;
|
|
typedef SafeFramebuffer ThisType;
|
|
|
|
const FramebufferArguments & arguments(void) const
|
|
{
|
|
return this->object()->arguments();
|
|
}
|
|
|
|
protected:
|
|
|
|
SafeFramebuffer(const FramebufferPtr & program)
|
|
: BaseType(program)
|
|
{
|
|
;
|
|
}
|
|
|
|
const FramebufferPtr & object(void) const
|
|
{
|
|
return static_cast<const FramebufferPtr &>(BaseType::object());
|
|
}
|
|
|
|
FramebufferPtr & object(void)
|
|
{
|
|
return static_cast<FramebufferPtr &>(BaseType::object());
|
|
}
|
|
};
|
|
|
|
namespace detail { template <> struct BaseOf <SafeFramebuffer> { typedef SafeObject Type; }; };
|
|
namespace detail { template <> struct ObjectBase <SafeFramebuffer> { typedef Framebuffer Type; }; };
|
|
namespace detail { template <> struct ObjectSafe <Framebuffer > { typedef SafeFramebuffer Type; }; };
|
|
typedef detail::ObjectSharedPointerTraits <SafeFramebuffer> ::Type FramebufferHandle;
|
|
|
|
class FramebufferBindingParams : public ObjectBindingParams
|
|
{
|
|
public:
|
|
|
|
typedef ObjectBindingParams BaseType;
|
|
typedef FramebufferBindingParams ThisType;
|
|
|
|
FramebufferBindingParams(void)
|
|
: BaseType()
|
|
{
|
|
;
|
|
}
|
|
|
|
FramebufferBindingParams(GLenum target)
|
|
: BaseType(target, 0)
|
|
{
|
|
;
|
|
}
|
|
};
|
|
|
|
class BoundFramebuffer : public BoundObject
|
|
{
|
|
friend class Context;
|
|
|
|
public:
|
|
|
|
typedef BoundObject BaseType;
|
|
typedef BoundFramebuffer ThisType;
|
|
|
|
BoundFramebuffer(void)
|
|
: BaseType()
|
|
{
|
|
;
|
|
}
|
|
|
|
const FramebufferHandle & handle(void) const
|
|
{
|
|
return static_cast<const FramebufferHandle &>(BaseType::handle());
|
|
}
|
|
|
|
FramebufferHandle & handle(void)
|
|
{
|
|
return static_cast<FramebufferHandle &>(BaseType::handle());
|
|
}
|
|
|
|
GLenum getStatus(void) const
|
|
{
|
|
return glCheckFramebufferStatus(this->m_target);
|
|
}
|
|
|
|
bool isComplete(void) const
|
|
{
|
|
return (this->getStatus() == GL_FRAMEBUFFER_COMPLETE);
|
|
}
|
|
|
|
bool setColorTarget(GLint index, const RenderTarget & renderTarget)
|
|
{
|
|
return this->object()->setColorTarget(this->m_target, this->m_unit, index, renderTarget);
|
|
}
|
|
|
|
bool removeColorTarget(GLint index)
|
|
{
|
|
return this->object()->removeColorTarget(this->m_target, this->m_unit, index);
|
|
}
|
|
|
|
bool removeAllColorTargets(void)
|
|
{
|
|
return this->object()->removeAllColorTargets(this->m_target, this->m_unit);
|
|
}
|
|
|
|
bool setDepthTarget(const RenderTarget & renderTarget)
|
|
{
|
|
return this->object()->setDepthTarget(this->m_target, this->m_unit, renderTarget);
|
|
}
|
|
|
|
bool removeDepthTarget(void)
|
|
{
|
|
return this->object()->removeDepthTarget(this->m_target, this->m_unit);
|
|
}
|
|
|
|
bool setStencilTarget(const RenderTarget & renderTarget)
|
|
{
|
|
return this->object()->setStencilTarget(this->m_target, this->m_unit, renderTarget);
|
|
}
|
|
|
|
bool removeStencilTarget(void)
|
|
{
|
|
return this->object()->removeStencilTarget(this->m_target, this->m_unit);
|
|
}
|
|
|
|
bool removeAllTargets(void)
|
|
{
|
|
return this->object()->removeAllTargets(this->m_target, this->m_unit);
|
|
}
|
|
|
|
bool setTargetInputs(const RenderTargetBinding & targetInputs)
|
|
{
|
|
return this->object()->setTargetInputs(this->m_target, this->m_unit, targetInputs);
|
|
}
|
|
|
|
protected:
|
|
|
|
BoundFramebuffer(const FramebufferHandle & handle, const FramebufferBindingParams & params)
|
|
: BaseType(handle, params)
|
|
{
|
|
;
|
|
}
|
|
|
|
const FramebufferPtr & object(void) const
|
|
{
|
|
return this->handle()->object();
|
|
}
|
|
|
|
FramebufferPtr & object(void)
|
|
{
|
|
return this->handle()->object();
|
|
}
|
|
|
|
virtual void bind(void)
|
|
{
|
|
glBindFramebuffer(this->m_target, this->object()->name());
|
|
}
|
|
|
|
virtual void unbind(void)
|
|
{
|
|
glBindFramebuffer(this->m_target, 0);
|
|
}
|
|
};
|
|
|
|
namespace detail { template <> struct ParamsOf <BoundFramebuffer> { typedef FramebufferBindingParams Type; }; };
|
|
namespace detail { template <> struct BaseOf <BoundFramebuffer> { typedef BoundObject Type; }; };
|
|
namespace detail { template <> struct ObjectBase <BoundFramebuffer> { typedef Framebuffer Type; }; };
|
|
namespace detail { template <> struct ObjectBound <Framebuffer > { typedef BoundFramebuffer Type; }; };
|
|
typedef detail::ObjectSharedPointerTraits <BoundFramebuffer> ::Type BoundFramebufferHandle;
|
|
|
|
class ReadFramebufferBindingParams : public FramebufferBindingParams
|
|
{
|
|
public:
|
|
|
|
typedef FramebufferBindingParams BaseType;
|
|
typedef ReadFramebufferBindingParams ThisType;
|
|
|
|
ReadFramebufferBindingParams(void)
|
|
: BaseType(GL_READ_FRAMEBUFFER)
|
|
{
|
|
;
|
|
}
|
|
};
|
|
|
|
class BoundReadFramebuffer : public BoundFramebuffer
|
|
{
|
|
friend class Context;
|
|
|
|
public:
|
|
|
|
typedef BoundFramebuffer BaseType;
|
|
typedef BoundReadFramebuffer ThisType;
|
|
|
|
BoundReadFramebuffer(void)
|
|
: BaseType()
|
|
{
|
|
;
|
|
}
|
|
|
|
bool readColorPixels(GLint index, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid * data)
|
|
{
|
|
return this->object()->readColorPixels(this->m_target, this->m_unit, index, x, y, width, height, format, type, data);
|
|
}
|
|
|
|
bool readDepthPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type, GLvoid * data)
|
|
{
|
|
return this->object()->readDepthPixels(this->m_target, this->m_unit, x, y, width, height, type, data);
|
|
}
|
|
|
|
bool readStencilPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type, GLvoid * data)
|
|
{
|
|
return this->object()->readStencilPixels(this->m_target, this->m_unit, x, y, width, height, type, data);
|
|
}
|
|
|
|
protected:
|
|
|
|
BoundReadFramebuffer(const FramebufferHandle & handle, const ReadFramebufferBindingParams & params)
|
|
: BaseType(handle, params)
|
|
{
|
|
;
|
|
}
|
|
};
|
|
|
|
namespace detail { template <> struct ParamsOf <BoundReadFramebuffer> { typedef ReadFramebufferBindingParams Type; }; };
|
|
namespace detail { template <> struct BaseOf <BoundReadFramebuffer> { typedef BoundFramebuffer Type; }; };
|
|
namespace detail { template <> struct ObjectBase <BoundReadFramebuffer> { typedef Framebuffer Type; }; };
|
|
typedef detail::ObjectSharedPointerTraits <BoundReadFramebuffer> ::Type BoundReadFramebufferHandle;
|
|
|
|
class DrawFramebufferBindingParams : public FramebufferBindingParams
|
|
{
|
|
public:
|
|
|
|
typedef FramebufferBindingParams BaseType;
|
|
typedef DrawFramebufferBindingParams ThisType;
|
|
|
|
DrawFramebufferBindingParams(void)
|
|
: BaseType(GL_DRAW_FRAMEBUFFER)
|
|
{
|
|
;
|
|
}
|
|
};
|
|
|
|
class BoundDrawFramebuffer : public BoundFramebuffer
|
|
{
|
|
friend class Context;
|
|
|
|
public:
|
|
|
|
typedef BoundFramebuffer BaseType;
|
|
typedef BoundDrawFramebuffer ThisType;
|
|
|
|
BoundDrawFramebuffer(void)
|
|
: BaseType()
|
|
{
|
|
;
|
|
}
|
|
|
|
protected:
|
|
|
|
BoundDrawFramebuffer(const FramebufferHandle & handle, const DrawFramebufferBindingParams & params)
|
|
: BaseType(handle, params)
|
|
{
|
|
;
|
|
}
|
|
};
|
|
|
|
namespace detail { template <> struct ParamsOf <BoundDrawFramebuffer> { typedef DrawFramebufferBindingParams Type; }; };
|
|
namespace detail { template <> struct BaseOf <BoundDrawFramebuffer> { typedef BoundFramebuffer Type; }; };
|
|
namespace detail { template <> struct ObjectBase <BoundDrawFramebuffer> { typedef Framebuffer Type; }; };
|
|
typedef detail::ObjectSharedPointerTraits <BoundDrawFramebuffer> ::Type BoundDrawFramebufferHandle;
|
|
|
|
class ReadDrawFramebufferBindingParams : public FramebufferBindingParams
|
|
{
|
|
public:
|
|
|
|
typedef FramebufferBindingParams BaseType;
|
|
typedef ReadDrawFramebufferBindingParams ThisType;
|
|
|
|
ReadDrawFramebufferBindingParams(void)
|
|
: BaseType(GL_FRAMEBUFFER)
|
|
{
|
|
;
|
|
}
|
|
};
|
|
|
|
class BoundReadDrawFramebuffer : public BoundFramebuffer
|
|
{
|
|
friend class Context;
|
|
|
|
public:
|
|
|
|
typedef BoundFramebuffer BaseType;
|
|
typedef BoundReadDrawFramebuffer ThisType;
|
|
|
|
BoundReadDrawFramebuffer(void)
|
|
: BaseType()
|
|
{
|
|
;
|
|
}
|
|
|
|
bool readColorPixels(GLint index, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid * data)
|
|
{
|
|
return this->object()->readColorPixels(this->m_target, this->m_unit, index, x, y, width, height, format, type, data);
|
|
}
|
|
|
|
bool readDepthPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type, GLvoid * data)
|
|
{
|
|
return this->object()->readDepthPixels(this->m_target, this->m_unit, x, y, width, height, type, data);
|
|
}
|
|
|
|
bool readStencilPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type, GLvoid * data)
|
|
{
|
|
return this->object()->readStencilPixels(this->m_target, this->m_unit, x, y, width, height, type, data);
|
|
}
|
|
|
|
protected:
|
|
|
|
BoundReadDrawFramebuffer(const FramebufferHandle & handle, const ReadDrawFramebufferBindingParams & params)
|
|
: BaseType(handle, params)
|
|
{
|
|
;
|
|
}
|
|
};
|
|
|
|
namespace detail { template <> struct ParamsOf <BoundReadDrawFramebuffer> { typedef ReadDrawFramebufferBindingParams Type; }; };
|
|
namespace detail { template <> struct BaseOf <BoundReadDrawFramebuffer> { typedef BoundFramebuffer Type; }; };
|
|
namespace detail { template <> struct ObjectBase <BoundReadDrawFramebuffer> { typedef Framebuffer Type; }; };
|
|
typedef detail::ObjectSharedPointerTraits <BoundReadDrawFramebuffer> ::Type BoundReadDrawFramebufferHandle;
|
|
|
|
};
|
|
|
|
#endif // GLW_FRAMEBUFFER_H
|