blending.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_CONTEXT_BLENDING_1201040722_HPP
#define OGLPLUS_CONTEXT_BLENDING_1201040722_HPP

#include <oglplus/glfunc.hpp>
#include <oglplus/blend_function.hpp>

namespace oglplus {
namespace context {


class Blending
{
public:

#if OGLPLUS_DOCUMENTATION_ONLY || GL_KHR_blend_equation_advanced

    static void BlendBarrier(void)
    {
        OGLPLUS_GLFUNC(BlendBarrierKHR)();
        OGLPLUS_VERIFY_SIMPLE(BlendBarrierKHR);
    }
#endif


    static void BlendEquation(
        OneOf<
            GLenum,
            std::tuple<
                oglplus::BlendEquation,
                oglplus::BlendEquationAdvanced
            >
        > eq
    )
    {
        OGLPLUS_GLFUNC(BlendEquation)(GLenum(eq));
        OGLPLUS_VERIFY_SIMPLE(BlendEquation);
    }


    static void BlendEquationSeparate(
        oglplus::BlendEquation eq_rgb,
        oglplus::BlendEquation eq_alpha
    )
    {
        OGLPLUS_GLFUNC(BlendEquationSeparate)(
            GLenum(eq_rgb),
            GLenum(eq_alpha)
        );
        OGLPLUS_VERIFY_SIMPLE(BlendEquationSeparate);
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_0

    static void BlendEquation(
        GLuint buffer,
        OneOf<
            GLenum,
            std::tuple<
                oglplus::BlendEquation,
                oglplus::BlendEquationAdvanced
            >
        > eq
    )
    {
        OGLPLUS_GLFUNC(BlendEquationi)(buffer, GLenum(eq));
        OGLPLUS_VERIFY(
            BlendEquationi,
            Error,
            Index(buffer)
        );
    }


    static void BlendEquationSeparate(
        GLuint buffer,
        oglplus::BlendEquation eq_rgb,
        oglplus::BlendEquation eq_alpha
    )
    {
        OGLPLUS_GLFUNC(BlendEquationSeparatei)(
            buffer,
            GLenum(eq_rgb),
            GLenum(eq_alpha)
        );
        OGLPLUS_VERIFY(
            BlendEquationSeparatei,
            Error,
            Index(buffer)
        );
    }
#endif


    static void BlendFunc(BlendFunction src, BlendFunction dst)
    {
        OGLPLUS_GLFUNC(BlendFunc)(GLenum(src), GLenum(dst));
        OGLPLUS_VERIFY_SIMPLE(BlendFunc);
    }


    static void BlendFuncSeparate(
        BlendFunction src_rgb,
        BlendFunction dst_rgb,
        BlendFunction src_alpha,
        BlendFunction dst_alpha
    )
    {
        OGLPLUS_GLFUNC(BlendFuncSeparate)(
            GLenum(src_rgb),
            GLenum(dst_rgb),
            GLenum(src_alpha),
            GLenum(dst_alpha)
        );
        OGLPLUS_VERIFY_SIMPLE(BlendFuncSeparate);
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_0

    static void BlendFunc(
        GLuint buffer,
        BlendFunction src,
        BlendFunction dst
    )
    {
        OGLPLUS_GLFUNC(BlendFunci)(buffer, GLenum(src), GLenum(dst));
        OGLPLUS_VERIFY(
            BlendFunci,
            Error,
            Index(buffer)
        );
    }


    static void BlendFuncSeparate(
        GLuint buffer,
        BlendFunction src_rgb,
        BlendFunction dst_rgb,
        BlendFunction src_alpha,
        BlendFunction dst_alpha
    )
    {
        OGLPLUS_GLFUNC(BlendFuncSeparatei)(
            buffer,
            GLenum(src_rgb),
            GLenum(dst_rgb),
            GLenum(src_alpha),
            GLenum(dst_alpha)
        );
        OGLPLUS_VERIFY(
            BlendFuncSeparatei,
            Error,
            Index(buffer)
        );
    }
#endif


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

} // namespace context
} // namespace oglplus

#endif // include guard