buffer_clearing.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_CONTEXT_BUFFER_CLEARING_1201040722_HPP
#define OGLPLUS_CONTEXT_BUFFER_CLEARING_1201040722_HPP

#include <oglplus/glfunc.hpp>
#include <oglplus/buffer_select_bit.hpp>
#include <oglplus/color_buffer.hpp>
#include <oglplus/bitfield.hpp>

namespace oglplus {


typedef BufferSelectBit ClearBit;

namespace context {

class BufferClearing;

struct RGBAValue
{
    // private implementation detail, do not use
    GLfloat _v[4];

    GLfloat Red(void) const
    {
        return _v[0];
    }

    GLfloat Green(void) const
    {
        return _v[1];
    }

    GLfloat Blue(void) const
    {
        return _v[2];
    }

    GLfloat Alpha(void) const
    {
        return _v[3];
    }
};


class ClrBits
{
private:
    GLbitfield _bits;

    GLbitfield _forward(void)
    {
        GLbitfield res = _bits;
        _bits = 0;
        return res;
    }

    friend class BufferClearing;

#if !OGLPLUS_NO_DELETED_FUNCTIONS
    ClrBits(void) = delete;
    ClrBits(const ClrBits&) = delete;
#else
    ClrBits(void);
    ClrBits(const ClrBits&);
#endif

    ClrBits(GLbitfield bit)
     : _bits(bit)
    { }

    inline ClrBits _make(GLbitfield bit)
    {
        return ClrBits(_forward() | bit);
    }
public:

    inline ClrBits ColorBuffer(void)
    {
        return _make(GL_COLOR_BUFFER_BIT);
    }


    inline ClrBits DepthBuffer(void)
    {
        return _make(GL_DEPTH_BUFFER_BIT);
    }


    inline ClrBits StencilBuffer(void)
    {
        return _make(GL_STENCIL_BUFFER_BIT);
    }

    inline ClrBits(ClrBits&& temp)
     : _bits(temp._forward())
    { }

    void DoIt(void) const
    {
        if(_bits)
        {
            OGLPLUS_GLFUNC(Clear)(_bits);
            OGLPLUS_VERIFY_SIMPLE(Clear);
        }
    }

    void Dismiss(void)
    {
        _bits = 0;
    }

    void operator()(void) const
    {
        DoIt();
    }

    void operator()(bool dismiss)
    {
        DoIt();
        if(dismiss) Dismiss();
    }


    inline ~ClrBits(void)
    {
        try{ DoIt(); }
        catch(...){ }
    }
};


class BufferClearing
{
public:

    static void ClearColor(GLclampf r, GLclampf g, GLclampf b, GLclampf a)
    {
        OGLPLUS_GLFUNC(ClearColor)(r, g, b, a);
        OGLPLUS_VERIFY_SIMPLE(ClearColor);
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_0

    static void ClearDepth(GLclampd d)
    {
        OGLPLUS_GLFUNC(ClearDepth)(d);
        OGLPLUS_VERIFY_SIMPLE(ClearDepth);
    }
#else
    static void ClearDepth(GLfloat d)
    {
        OGLPLUS_GLFUNC(ClearDepthf)(d);
        OGLPLUS_VERIFY_SIMPLE(ClearDepthf);
    }
#endif


    static void ClearStencil(GLint s)
    {
        OGLPLUS_GLFUNC(ClearStencil)(s);
        OGLPLUS_VERIFY_SIMPLE(ClearStencil);
    }


    static ClrBits Clear(void)
    {
        return ClrBits(0);
    }


    static void Clear(Bitfield<oglplus::ClearBit> bits)
    {
        OGLPLUS_GLFUNC(Clear)(GLbitfield(bits));
        OGLPLUS_VERIFY_SIMPLE(Clear);
    }



    static void ClearColorBuffer(
        GLint draw_buffer,
        const GLint* value
    )
    {
        OGLPLUS_GLFUNC(ClearBufferiv)(
            GL_COLOR,
            draw_buffer,
            value
        );
        OGLPLUS_CHECK(
            ClearBufferiv,
            Error,
            Index(draw_buffer)
        );
    }


    static void ClearColorBuffer(
        ColorBuffer buffer,
        GLint draw_buffer,
        const GLint* value
    )
    {
        OGLPLUS_GLFUNC(ClearBufferiv)(
            GLenum(buffer),
            draw_buffer,
            value
        );
        OGLPLUS_CHECK(
            ClearBufferiv,
            Error,
            EnumParam(buffer).
            Index(draw_buffer)
        );
    }


    static void ClearColorBuffer(
        GLint draw_buffer,
        const GLuint* value
    )
    {
        OGLPLUS_GLFUNC(ClearBufferuiv)(
            GL_COLOR,
            draw_buffer,
            value
        );
        OGLPLUS_CHECK(
            ClearBufferuiv,
            Error,
            Index(draw_buffer)
        );
    }


    static void ClearColorBuffer(
        ColorBuffer buffer,
        GLint draw_buffer,
        const GLuint* value
    )
    {
        OGLPLUS_GLFUNC(ClearBufferuiv)(
            GLenum(buffer),
            draw_buffer,
            value
        );
        OGLPLUS_CHECK(
            ClearBufferuiv,
            Error,
            EnumParam(buffer).
            Index(draw_buffer)
        );
    }


    static void ClearColorBuffer(
        GLint draw_buffer,
        const GLfloat* value
    )
    {
        OGLPLUS_GLFUNC(ClearBufferfv)(
            GL_COLOR,
            draw_buffer,
            value
        );
        OGLPLUS_CHECK(
            ClearBufferfv,
            Error,
            Index(draw_buffer)
        );
    }


    static void ClearColorBuffer(
        ColorBuffer buffer,
        GLint draw_buffer,
        const GLfloat* value
    )
    {
        OGLPLUS_GLFUNC(ClearBufferfv)(
            GLenum(buffer),
            draw_buffer,
            value
        );
        OGLPLUS_CHECK(
            ClearBufferfv,
            Error,
            EnumParam(buffer).
            Index(draw_buffer)
        );
    }


    static void ClearDepthBuffer(GLfloat value)
    {
        OGLPLUS_GLFUNC(ClearBufferfv)(GL_DEPTH, 0, &value);
        OGLPLUS_CHECK_SIMPLE(ClearBufferfv);
    }


    static void ClearStencilBuffer(GLint value)
    {
        OGLPLUS_GLFUNC(ClearBufferiv)(GL_STENCIL, 0, &value);
        OGLPLUS_CHECK_SIMPLE(ClearBufferiv);
    }


    static void ClearStencilBuffer(GLfloat depth_value, GLint stencil_value)
    {
        OGLPLUS_GLFUNC(ClearBufferfi)(
            GL_DEPTH_STENCIL,
            0,
            depth_value,
            stencil_value
        );
        OGLPLUS_CHECK_SIMPLE(ClearBufferfi);
    }


    static oglplus::context::RGBAValue ColorClearValue(void)
    {
        oglplus::context::RGBAValue result;
        OGLPLUS_GLFUNC(GetFloatv)(GL_COLOR_CLEAR_VALUE, result._v);
        OGLPLUS_VERIFY_SIMPLE(GetFloatv);
        return result;
    }


    static GLfloat DepthClearValue(void)
    {
        GLfloat result;
        OGLPLUS_GLFUNC(GetFloatv)(GL_DEPTH_CLEAR_VALUE, &result);
        OGLPLUS_VERIFY_SIMPLE(GetFloatv);
        return result;
    }


    static GLint ClearStencilValue(void)
    {
        GLint result;
        OGLPLUS_GLFUNC(GetIntegerv)(GL_STENCIL_CLEAR_VALUE, &result);
        OGLPLUS_VERIFY_SIMPLE(GetIntegerv);
        return result;
    }
};

} // namespace context
} // namespace oglplus

#endif // include guard