renderbuffer.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_RENDERBUFFER_1107121519_HPP
#define OGLPLUS_RENDERBUFFER_1107121519_HPP

#include <oglplus/glfunc.hpp>
#include <oglplus/error/object.hpp>
#include <oglplus/renderbuffer_target.hpp>
#include <oglplus/pixel_data.hpp>
#include <oglplus/object/wrapper.hpp>
#include <oglplus/images/fwd.hpp>
#include <cassert>

namespace oglplus {


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

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

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

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


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


    static void Bind(
        Target target,
        RenderbufferName renderbuffer
    )
    {
        OGLPLUS_GLFUNC(BindRenderbuffer)(
            GLenum(target),
            GetGLName(renderbuffer)
        );
        OGLPLUS_VERIFY(
            BindRenderbuffer,
            ObjectError,
            Object(renderbuffer).
            BindTarget(target)
        );
    }
};


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


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


template <>
class ObjectOps<tag::ExplicitSel, tag::Renderbuffer>
 : public ObjZeroOps<tag::ExplicitSel, tag::Renderbuffer>
{
protected:
    ObjectOps(void){ }
public:
    static GLint GetIntParam(Target target, GLenum query);


    static void Storage(
        Target target,
        PixelDataInternalFormat internalformat,
        GLsizei width,
        GLsizei height
    )
    {
        OGLPLUS_GLFUNC(RenderbufferStorage)(
            GLenum(target),
            GLenum(internalformat),
            width,
            height
        );
        OGLPLUS_CHECK(
            RenderbufferStorage,
            ObjectError,
            ObjectBinding(target).
            EnumParam(internalformat)
        );
    }


    static void Storage(Target target, const images::ImageSpec& image_spec);


    static void StorageMultisample(
        Target target,
        GLsizei samples,
        PixelDataInternalFormat internalformat,
        GLsizei width,
        GLsizei height
    )
    {
        OGLPLUS_GLFUNC(RenderbufferStorageMultisample)(
            GLenum(target),
            samples,
            GLenum(internalformat),
            width,
            height
        );
        OGLPLUS_CHECK(
            RenderbufferStorageMultisample,
            ObjectError,
            ObjectBinding(target).
            EnumParam(internalformat)
        );
    }



    static GLsizei Width(Target target)
    {
        return GLsizei(GetIntParam(target, GL_RENDERBUFFER_WIDTH));
    }


    static GLsizei Height(Target target)
    {
        return GLsizei(GetIntParam(target, GL_RENDERBUFFER_HEIGHT));
    }


    static GLsizei RedSize(Target target)
    {
        return GLsizei(GetIntParam(target, GL_RENDERBUFFER_RED_SIZE));
    }


    static GLsizei GreenSize(Target target)
    {
        return GLsizei(GetIntParam(target, GL_RENDERBUFFER_GREEN_SIZE));
    }


    static GLsizei BlueSize(Target target)
    {
        return GLsizei(GetIntParam(target, GL_RENDERBUFFER_BLUE_SIZE));
    }


    static GLsizei AlphaSize(Target target)
    {
        return GLsizei(GetIntParam(target, GL_RENDERBUFFER_ALPHA_SIZE));
    }


    static GLsizei DepthSize(Target target)
    {
        return GLsizei(GetIntParam(target, GL_RENDERBUFFER_DEPTH_SIZE));
    }


    static GLsizei StencilSize(Target target)
    {
        return GLsizei(GetIntParam(target,GL_RENDERBUFFER_STENCIL_SIZE));
    }


    static GLsizei Samples(Target target)
    {
        return GLsizei(GetIntParam(target,GL_RENDERBUFFER_SAMPLES));
    }


    static PixelDataInternalFormat InternalFormat(Target target)
    {
        return PixelDataInternalFormat(
            GetIntParam(target, GL_RENDERBUFFER_INTERNAL_FORMAT)
        );
    }
};

typedef ObjectOps<tag::ExplicitSel, tag::Renderbuffer>
    RenderbufferOps;

// syntax-sugar operators

// Bind
inline RenderbufferTarget operator << (
    const RenderbufferOps& rbo,
    RenderbufferTarget target
)
{
    rbo.Bind(target);
    return target;
}

// Storage
inline RenderbufferTarget operator << (
    RenderbufferTarget target,
    const images::ImageSpec& image_spec
)
{
    RenderbufferOps::Storage(target, image_spec);
    return target;
}


typedef ObjectZero<ObjZeroOps<tag::ExplicitSel, tag::Renderbuffer>>
    NoRenderbuffer;


typedef Object<RenderbufferOps> Renderbuffer;

} // namespace oglplus

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

#endif // include guard