viewport.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_CONTEXT_VIEWPORT_1201040722_HPP
#define OGLPLUS_CONTEXT_VIEWPORT_1201040722_HPP

#include <oglplus/glfunc.hpp>

namespace oglplus {
namespace context {

struct ViewportPosition
{
    // private implementation detail, do not use
    GLfloat _v[2];

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

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

struct ViewportSize
{
    // private implementation detail, do not use
    GLfloat _v[2];

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

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

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

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

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

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

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

struct BoundsRange
{
    // private implementation detail, do not use
    GLfloat _v[2];

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

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

struct DepthRange
{
    // private implementation detail, do not use
    GLfloat _v[2];

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

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


class ViewportOps
{
public:

    static void Viewport(GLint x, GLint y, GLsizei w, GLsizei h)
    {
        OGLPLUS_GLFUNC(Viewport)(x, y, w, h);
        OGLPLUS_CHECK_SIMPLE(Viewport);
    }


    static void Viewport(GLsizei w, GLsizei h)
    {
        OGLPLUS_GLFUNC(Viewport)(0, 0, w, h);
        OGLPLUS_CHECK_SIMPLE(Viewport);
    }


    static ViewportExtents Viewport(void)
    {
        ViewportExtents result;
        OGLPLUS_GLFUNC(GetFloatv)(GL_VIEWPORT, result._v);
        OGLPLUS_CHECK_SIMPLE(GetFloatv);
        return result;
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_1 || GL_ARB_viewport_array

    static BoundsRange ViewportBoundsRange(void)
    {
        BoundsRange result;
        OGLPLUS_GLFUNC(GetFloatv)(
            GL_VIEWPORT_BOUNDS_RANGE,
            result._v
        );
        OGLPLUS_VERIFY_SIMPLE(GetFloatv);
        return result;
    }
#endif


    static ViewportSize MaxViewportDims(void)
    {
        ViewportSize result;
        OGLPLUS_GLFUNC(GetFloatv)(
            GL_MAX_VIEWPORT_DIMS,
            result._v
        );
        OGLPLUS_VERIFY_SIMPLE(GetFloatv);
        return result;
    }


#if OGLPLUS_DOCUMENTATION_ONLY || \
    GL_ES_VERSION_3_0 || \
    GL_VERSION_4_1 || \
    GL_ARB_ES2_compatibility

    static void DepthRange(GLclampf near_val, GLclampf far_val)
    {
        OGLPLUS_GLFUNC(DepthRangef)(near_val, far_val);
        OGLPLUS_CHECK_SIMPLE(DepthRangef);
    }
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_0

    static void DepthRange(GLclampd near_val, GLclampd far_val)
    {
        OGLPLUS_GLFUNC(DepthRange)(near_val, far_val);
        OGLPLUS_CHECK_SIMPLE(DepthRange);
    }
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_1 || GL_ARB_viewport_array

    static GLuint MaxViewports(void)
    {
        GLint result = 0;
        OGLPLUS_GLFUNC(GetIntegerv)(GL_MAX_VIEWPORTS, &result);
        OGLPLUS_VERIFY_SIMPLE(GetIntegerv);
        return GLuint(result);
    }


    static void Viewport(
        GLuint viewport,
        GLfloat x,
        GLfloat y,
        GLfloat width,
        GLfloat height
    )
    {
        OGLPLUS_GLFUNC(ViewportIndexedf)(viewport, x, y, width, height);
        OGLPLUS_CHECK(
            ViewportIndexedf,
            Error,
            Index(viewport)
        );
    }


    static void Viewport(GLuint viewport, const GLfloat* extents)
    {
        OGLPLUS_GLFUNC(ViewportIndexedfv)(viewport, extents);
        OGLPLUS_CHECK(
            ViewportIndexedfv,
            Error,
            Index(viewport)
        );
    }


    static void ViewportArray(
        GLuint first,
        GLsizei count,
        const GLfloat* extents
    )
    {
        OGLPLUS_GLFUNC(ViewportArrayv)(first, count, extents);
        OGLPLUS_CHECK_SIMPLE(ViewportArrayv);
    }


    static ViewportExtents Viewport(GLuint viewport)
    {
        ViewportExtents result;
        OGLPLUS_GLFUNC(GetFloati_v)(GL_VIEWPORT, viewport, result._v);
        OGLPLUS_CHECK_SIMPLE(GetFloati_v);
        return result;
    }



    static void DepthRange(GLuint viewport, GLclampd near_val, GLclampd far_val)
    {
        OGLPLUS_GLFUNC(DepthRangeIndexed)(viewport, near_val, far_val);
        OGLPLUS_CHECK(
            DepthRangeIndexed,
            Error,
            Index(viewport)
        );
    }


    static void DepthRangeArray(
        GLuint first,
        GLsizei count,
        const GLclampd *v
    )
    {
        OGLPLUS_GLFUNC(DepthRangeArrayv)(first, count, v);
        OGLPLUS_CHECK_SIMPLE(DepthRangeArrayv);
    }


    static oglplus::context::DepthRange ViewportDepthRange(GLuint viewport)
    {
        oglplus::context::DepthRange result;
        OGLPLUS_GLFUNC(GetFloati_v)(GL_DEPTH_RANGE, viewport,result._v);
        OGLPLUS_CHECK(
            GetFloati_v,
            Error,
            Index(viewport)
        );
        return result;
    }
#endif
};

} // namespace context
} // namespace oglplus

#endif // include guard