framebuffer.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_FRAMEBUFFER_1107121519_HPP
#define OGLPLUS_FRAMEBUFFER_1107121519_HPP

#include <oglplus/glfunc.hpp>
#include <oglplus/error/framebuffer.hpp>
#include <oglplus/framebuffer_target.hpp>
#include <oglplus/framebuffer_attachment.hpp>
#include <oglplus/framebuffer_status.hpp>
#include <oglplus/texture_target.hpp>
#include <oglplus/one_of.hpp>
#include <oglplus/object/wrapper.hpp>
#include <cassert>

namespace oglplus {

// NOTE: Xlib.h defines this symbol
// using the preprocessor.
#ifdef Status
#undef Status
#endif


template <>
class ObjGenDelOps<tag::Framebuffer>
{
protected:
    static void Gen(tag::Generate, GLsizei count, GLuint* names)
    {
        assert(names != nullptr);
        OGLPLUS_GLFUNC(GenFramebuffers)(count, names);
        OGLPLUS_CHECK_SIMPLE(GenFramebuffers);
    }
#if GL_VERSION_4_5 || GL_ARB_direct_state_access
    static void Gen(tag::Create, GLsizei count, GLuint* names)
    {
        assert(names != nullptr);
        OGLPLUS_GLFUNC(CreateFramebuffers)(count, names);
        OGLPLUS_CHECK_SIMPLE(CreateFramebuffers);
    }
#endif

    static void Delete(GLsizei count, GLuint* names)
    {
        assert(names != nullptr);
        OGLPLUS_GLFUNC(DeleteFramebuffers)(count, names);
        OGLPLUS_VERIFY_SIMPLE(DeleteFramebuffers);
    }

    static GLboolean IsA(GLuint name)
    {
        assert(name != 0);
        GLboolean result = OGLPLUS_GLFUNC(IsFramebuffer)(name);
        OGLPLUS_VERIFY_SIMPLE(IsFramebuffer);
        return result;
    }
};

template <>
class ObjBindingOps<tag::Framebuffer>
{
private:
    static GLenum _binding_query(FramebufferTarget target);
protected:
    static GLuint _binding(FramebufferTarget target);
public:
    typedef FramebufferTarget Target;


    static FramebufferName Binding(Target target)
    {
        return FramebufferName(_binding(target));
    }


    static void Bind(
        Target target,
        FramebufferName framebuffer
    )
    {
        OGLPLUS_GLFUNC(BindFramebuffer)(
            GLenum(target),
            GetGLName(framebuffer)
        );
        OGLPLUS_VERIFY(
            BindFramebuffer,
            ObjectError,
            ObjectBinding(target)
        );
    }
};


template <>
class ObjCommonOps<tag::Framebuffer>
 : public FramebufferName
 , public ObjBindingOps<tag::Framebuffer>
{
protected:
    ObjCommonOps(void){ }
public:
    using ObjBindingOps<tag::Framebuffer>::Bind;


    void Bind(Target target) const
    {
        Bind(target, *this);
    }
};


template <>
class ObjectOps<tag::ExplicitSel, tag::Framebuffer>
 : public ObjZeroOps<tag::ExplicitSel, tag::Framebuffer>
{
protected:
    ObjectOps(void){ }
public:
    struct Property
    {
        typedef OneOf<
            GLenum,
            std::tuple<
                FramebufferBuffer,
                FramebufferAttachment,
                FramebufferColorAttachment
            >
        > Buffer;

        typedef OneOf<
            GLenum,
            std::tuple<
                FramebufferAttachment,
                FramebufferColorAttachment
            >
        > Attachment;

        typedef FramebufferStatus Status;
    };


    static FramebufferStatus Status(Target target)
    {
        GLenum result = OGLPLUS_GLFUNC(CheckFramebufferStatus)(
            GLenum(target)
        );
        if(result == 0) OGLPLUS_CHECK(
            CheckFramebufferStatus,
            ObjectError,
            ObjectBinding(target)
        );
        return FramebufferStatus(result);
    }


    static bool IsComplete(Target target)
    {
        return Status(target) == FramebufferStatus::Complete;
    }

    static void HandleIncompleteError(Target target, FramebufferStatus status);

    static void Complete(Target target)
    {
        FramebufferStatus status = Status(target);
        if(status != FramebufferStatus::Complete)
        {
            HandleIncompleteError(target, status);
        }
    }


    static void AttachRenderbuffer(
        Target target,
        Property::Attachment attachment,
        RenderbufferName renderbuffer
    )
    {
        OGLPLUS_GLFUNC(FramebufferRenderbuffer)(
            GLenum(target),
            GLenum(attachment),
            GL_RENDERBUFFER,
            GetGLName(renderbuffer)
        );
        OGLPLUS_CHECK(
            FramebufferRenderbuffer,
            ObjectPairError,
            Subject(renderbuffer).
            ObjectBinding(target)
        );
    }


    static void AttachColorRenderbuffer(
        Target target,
        FramebufferColorAttachmentNumber attachment_no,
        RenderbufferName renderbuffer
    )
    {
        OGLPLUS_GLFUNC(FramebufferRenderbuffer)(
            GLenum(target),
            GL_COLOR_ATTACHMENT0 + GLuint(attachment_no),
            GL_RENDERBUFFER,
            GetGLName(renderbuffer)
        );
        OGLPLUS_CHECK(
            FramebufferRenderbuffer,
            ObjectPairError,
            Subject(renderbuffer).
            ObjectBinding(target)
        );
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_2

    static void AttachTexture(
        Target target,
        Property::Attachment attachment,
        TextureName texture,
        GLint level
    )
    {
        OGLPLUS_GLFUNC(FramebufferTexture)(
            GLenum(target),
            GLenum(attachment),
            GetGLName(texture),
            level
        );
        OGLPLUS_CHECK(
            FramebufferTexture,
            ObjectPairError,
            Subject(texture).
            ObjectBinding(target).
            Index(level)
        );
    }


    static void AttachColorTexture(
        Target target,
        FramebufferColorAttachmentNumber attachment_no,
        TextureName texture,
        GLint level
    )
    {
        OGLPLUS_GLFUNC(FramebufferTexture)(
            GLenum(target),
            GL_COLOR_ATTACHMENT0 + GLenum(attachment_no),
            GetGLName(texture),
            level
        );
        OGLPLUS_CHECK(
            FramebufferTexture,
            ObjectPairError,
            Subject(texture).
            ObjectBinding(target).
            Index(level)
        );
    }
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_0

    static void AttachTexture1D(
        Target target,
        Property::Attachment attachment,
        TextureTarget textarget,
        TextureName texture,
        GLint level
    )
    {
        OGLPLUS_GLFUNC(FramebufferTexture1D)(
            GLenum(target),
            GLenum(attachment),
            GLenum(textarget),
            GetGLName(texture),
            level
        );
        OGLPLUS_CHECK(
            FramebufferTexture1D,
            ObjectPairError,
            Subject(texture).
            ObjectBinding(target).
            Index(level)
        );
    }
#endif


    static void AttachTexture2D(
        Target target,
        Property::Attachment attachment,
        TextureTarget textarget,
        TextureName texture,
        GLint level
    )
    {
        OGLPLUS_GLFUNC(FramebufferTexture2D)(
            GLenum(target),
            GLenum(attachment),
            GLenum(textarget),
            GetGLName(texture),
            level
        );
        OGLPLUS_CHECK(
            FramebufferTexture2D,
            ObjectPairError,
            Subject(texture).
            ObjectBinding(target).
            Index(level)
        );
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_0

    static void AttachTexture3D(
        Target target,
        Property::Attachment attachment,
        TextureTarget textarget,
        TextureName texture,
        GLint level,
        GLint layer
    )
    {
        OGLPLUS_GLFUNC(FramebufferTexture3D)(
            GLenum(target),
            GLenum(attachment),
            GLenum(textarget),
            GetGLName(texture),
            level,
            layer
        );
        OGLPLUS_CHECK(
            FramebufferTexture3D,
            ObjectPairError,
            Subject(texture).
            ObjectBinding(target).
            Index(level)
        );
    }
#endif


    static void AttachTextureLayer(
        Target target,
        Property::Attachment attachment,
        TextureName texture,
        GLint level,
        GLint layer
    )
    {
        OGLPLUS_GLFUNC(FramebufferTextureLayer)(
            GLenum(target),
            GLenum(attachment),
            GetGLName(texture),
            level,
            layer
        );
        OGLPLUS_CHECK(
            FramebufferTextureLayer,
            ObjectPairError,
            Subject(texture).
            ObjectBinding(target).
            Index(level)
        );
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_3 || GL_ARB_invalidate_subdata

    static void Invalidate(
        Target target,
        const EnumArray<Property::Buffer>& buffers
    )
    {
        OGLPLUS_GLFUNC(InvalidateFramebuffer)(
            GLenum(target),
            buffers.Count(),
            buffers.Values()
        );
        OGLPLUS_CHECK(
            InvalidateFramebuffer,
            ObjectError,
            ObjectBinding(target)
        );
    }


    static void Invalidate(
        Target target,
        GLsizei count,
        const Property::Buffer* buffers
    )
    {
        Invalidate(
            target,
            EnumArray<Property::Buffer>(count, buffers)
        );
    }


    static void Invalidate(
        Target target,
        const EnumArray<Property::Buffer>& buffers,
        GLint x,
        GLint y,
        GLsizei width,
        GLsizei height
    )
    {
        OGLPLUS_GLFUNC(InvalidateSubFramebuffer)(
            GLenum(target),
            buffers.Count(),
            buffers.Values(),
            x,
            y,
            width,
            height
        );
        OGLPLUS_CHECK(
            InvalidateSubFramebuffer,
            ObjectError,
            ObjectBinding(target)
        );
    }


    static void Invalidate(
        Target target,
        GLsizei count,
        const Property::Buffer* buffers,
        GLint x,
        GLint y,
        GLsizei width,
        GLsizei height
    )
    {
        Invalidate(
            target,
            EnumArray<Property::Buffer>(count, buffers),
            x,
            y,
            width,
            height
        );
    }
#endif
};

typedef ObjectOps<tag::ExplicitSel, tag::Framebuffer>
    FramebufferOps;

struct FramebufferComplete { };

// Helper class for syntax-sugar operators
struct FramebufferTargetAndAttch
{
    FramebufferTarget target;

    typedef FramebufferOps::Property::Attachment Attachment;
    Attachment attachment;

    FramebufferTargetAndAttch(FramebufferTarget& t, Attachment a)
     : target(t)
     , attachment(a)
    { }
};

// syntax sugar operators
inline FramebufferTargetAndAttch operator | (
    FramebufferTarget target,
    FramebufferOps::Property::Attachment attachment
)
{
    return FramebufferTargetAndAttch(target, attachment);
}

inline FramebufferTargetAndAttch operator << (
    FramebufferTarget target,
    FramebufferOps::Property::Attachment attachment
)
{
    return FramebufferTargetAndAttch(target, attachment);
}

// Bind
inline FramebufferTarget operator << (
    const FramebufferOps& fbo,
    FramebufferTarget target
)
{
    fbo.Bind(target);
    return target;
}

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_2
// AttachTexture
inline FramebufferTarget operator << (
    FramebufferTargetAndAttch taa,
    TextureName tex
)
{
    FramebufferOps::AttachTexture(
        taa.target,
        taa.attachment,
        tex,
        0
    );
    return taa.target;
}
#endif

// AttachRenderbuffer
inline FramebufferTarget operator << (
    FramebufferTargetAndAttch taa,
    RenderbufferName rbo
)
{
    FramebufferOps::AttachRenderbuffer(
        taa.target,
        taa.attachment,
        rbo
    );
    return taa.target;
}

// Complete
inline FramebufferTarget operator << (
    FramebufferTarget target,
    FramebufferComplete
)
{
    FramebufferOps::Complete(target);
    return target;
}


typedef ObjectZero<ObjZeroOps<tag::ExplicitSel, tag::Framebuffer>>
    DefaultFramebuffer;

inline FramebufferTarget operator << (
    DefaultFramebuffer dfb,
    FramebufferTarget target
)
{
    dfb.Bind(target);
    return target;
}


typedef Object<FramebufferOps> Framebuffer;

} // namespace oglplus

#if !OGLPLUS_LINK_LIBRARY || defined(OGLPLUS_IMPLEMENTING_LIBRARY)
#include <oglplus/framebuffer.ipp>
#endif // OGLPLUS_LINK_LIBRARY

#endif // include guard