rasterization.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_CONTEXT_RASTERIZATION_1201040722_HPP
#define OGLPLUS_CONTEXT_RASTERIZATION_1201040722_HPP

#include <oglplus/glfunc.hpp>
#include <oglplus/face_mode.hpp>
#include <oglplus/polygon_mode.hpp>
#include <oglplus/provoke_mode.hpp>
#include <oglplus/math/vector.hpp>

namespace oglplus {
namespace context {


class Rasterization
{
public:

    static void FrontFace(FaceOrientation orientation)
    {
        OGLPLUS_GLFUNC(FrontFace)(GLenum(orientation));
        OGLPLUS_VERIFY(
            FrontFace,
            Error,
            EnumParam(orientation)
        );
    }


    static void CullFace(Face mode)
    {
        OGLPLUS_GLFUNC(CullFace)(GLenum(mode));
        OGLPLUS_VERIFY(
            CullFace,
            Error,
            EnumParam(mode)
        );
    }


    static Face CullFaceMode(void)
    {
        GLint result;
        OGLPLUS_GLFUNC(GetIntegerv)(GL_CULL_FACE_MODE, &result);
        OGLPLUS_VERIFY_SIMPLE(GetIntegerv);
        return Face(result);
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_0

    static void PolygonMode(Face face, oglplus::PolygonMode mode)
    {
        OGLPLUS_GLFUNC(PolygonMode)(GLenum(face), GLenum(mode));
        OGLPLUS_VERIFY(
            PolygonMode,
            Error,
            EnumParam(mode)
        );
    }


    static void PolygonMode(oglplus::PolygonMode mode)
    {
        OGLPLUS_GLFUNC(PolygonMode)(GL_FRONT_AND_BACK, GLenum(mode));
        OGLPLUS_VERIFY(
            PolygonMode,
            Error,
            EnumParam(mode)
        );
    }


    static oglplus::PolygonMode PolygonMode(void)
    {
        GLint result[2];
        OGLPLUS_GLFUNC(GetIntegerv)(GL_POLYGON_MODE, result);
        OGLPLUS_VERIFY_SIMPLE(GetIntegerv);
        return oglplus::PolygonMode(result[1]);
    }
#endif // GL_VERSION_3_0


    static void PolygonOffset(GLfloat factor, GLfloat units)
    {
        OGLPLUS_GLFUNC(PolygonOffset)(factor, units);
        OGLPLUS_VERIFY_SIMPLE(PolygonOffset);
    }


    static GLfloat PolygonOffsetFactor(void)
    {
        GLfloat result;
        OGLPLUS_GLFUNC(GetFloatv)(GL_POLYGON_OFFSET_FACTOR, &result);
        OGLPLUS_VERIFY_SIMPLE(GetFloatv);
        return result;
    }


    static GLfloat PolygonOffsetUnits(void)
    {
        GLfloat result;
        OGLPLUS_GLFUNC(GetFloatv)(GL_POLYGON_OFFSET_UNITS, &result);
        OGLPLUS_VERIFY_SIMPLE(GetFloatv);
        return result;
    }


    static void LineWidth(GLfloat width)
    {
        OGLPLUS_GLFUNC(LineWidth)(width);
        OGLPLUS_VERIFY_SIMPLE(LineWidth);
    }


    static GLfloat LineWidth(void)
    {
        GLfloat result;
        OGLPLUS_GLFUNC(GetFloatv)(GL_LINE_WIDTH, &result);
        OGLPLUS_VERIFY_SIMPLE(GetFloatv);
        return result;
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_0

    static void PointSize(GLfloat size)
    {
        OGLPLUS_GLFUNC(PointSize)(size);
        OGLPLUS_VERIFY_SIMPLE(PointSize);
    }


    static GLfloat PointSize(void)
    {
        GLfloat result;
        OGLPLUS_GLFUNC(GetFloatv)(GL_POINT_SIZE, &result);
        OGLPLUS_VERIFY_SIMPLE(GetFloatv);
        return result;
    }


    static void PointFadeThresholdSize(GLfloat size)
    {
        OGLPLUS_GLFUNC(PointParameterf)(
            GL_POINT_FADE_THRESHOLD_SIZE,
            size
        );
        OGLPLUS_VERIFY_SIMPLE(PointParameterf);
    }


    static GLfloat PointFadeThresholdSize(void)
    {
        GLfloat result;
        OGLPLUS_GLFUNC(GetFloatv)(GL_POINT_FADE_THRESHOLD_SIZE,&result);
        OGLPLUS_VERIFY_SIMPLE(GetFloatv);
        return result;
    }
#endif // GL_VERSION_3_0

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_2 || GL_ARB_provoking_vertex

    static void ProvokingVertex(ProvokeMode mode)
    {
        OGLPLUS_GLFUNC(ProvokingVertex)(GLenum(mode));
        OGLPLUS_VERIFY_SIMPLE(ProvokingVertex);
    }


    static ProvokeMode ProvokingVertex(void)
    {
        GLint result;
        OGLPLUS_GLFUNC(GetIntegerv)(GL_PROVOKING_VERTEX, &result);
        OGLPLUS_VERIFY_SIMPLE(GetIntegerv);
        return ProvokeMode(result);
    }
#endif

    static GLint SampleBuffers(void)
    {
        GLint result;
        OGLPLUS_GLFUNC(GetIntegerv)(GL_SAMPLE_BUFFERS, &result);
        OGLPLUS_VERIFY_SIMPLE(GetIntegerv);
        return result;
    }


    static GLint Samples(void)
    {
        GLint result;
        OGLPLUS_GLFUNC(GetIntegerv)(GL_SAMPLES, &result);
        OGLPLUS_VERIFY_SIMPLE(GetIntegerv);
        return result;
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_2

    static Vec2f SamplePosition(GLuint index)
    {
        Vec2f result;
        OGLPLUS_GLFUNC(GetMultisamplefv)(
            GL_SAMPLE_POSITION,
            index,
            result.Data()
        );
        OGLPLUS_VERIFY_SIMPLE(GetMultisamplefv);
        return result;
    }
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_0

    static GLfloat MinSampleShading(void)
    {
        GLfloat result;
        OGLPLUS_GLFUNC(GetFloatv)(GL_MIN_SAMPLE_SHADING_VALUE, &result);
        OGLPLUS_VERIFY_SIMPLE(GetFloatv);
        return result;
    }


    static void MinSampleShading(GLfloat value)
    {
        OGLPLUS_GLFUNC(MinSampleShading)(value);
        OGLPLUS_VERIFY_SIMPLE(MinSampleShading);
    }
#endif
};

} // namespace context
} // namespace oglplus

#endif // include guard