sampler.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_SAMPLER_1107121519_HPP
#define OGLPLUS_SAMPLER_1107121519_HPP

#include <oglplus/glfunc.hpp>
#include <oglplus/math/vector.hpp>
#include <oglplus/error/object.hpp>
#include <oglplus/object/wrapper.hpp>
#include <oglplus/object/sequence.hpp>
#include <oglplus/data_type.hpp>
#include <oglplus/compare_function.hpp>
#include <oglplus/texture_wrap.hpp>
#include <oglplus/texture_compare.hpp>
#include <oglplus/texture_filter.hpp>
#include <oglplus/texture_unit.hpp>
#include <cassert>

namespace oglplus {

// if samplers are available
#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_3 || GL_ARB_sampler_objects


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

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

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

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


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


    static void Bind(
        Target target,
        SamplerName sampler
    )
    {
        OGLPLUS_GLFUNC(BindSampler)(
            GLuint(target),
            GetGLName(sampler)
        );
        OGLPLUS_VERIFY(
            BindSampler,
            ObjectError,
            Object(sampler).
            Index(GLuint(target))
        );
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_4 || GL_ARB_multi_bind
    static void Bind(
        GLuint first,
        GLsizei count,
        const GLuint* names
    )
    {
        OGLPLUS_GLFUNC(BindSamplers)(
            first,
            count,
            names
        );
        OGLPLUS_VERIFY_SIMPLE(BindSamplers);
    }


    static void Bind(
        GLuint first,
        const Sequence<SamplerName>& samplers
    )
    {
        Bind(first, GLsizei(samplers.size()), GetGLNames(samplers));
    }
#endif
};


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


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


template <>
class ObjectOps<tag::DirectState, tag::Sampler>
 : public ObjZeroOps<tag::DirectState, tag::Sampler>
{
protected:
    ObjectOps(void){ }
public:
    GLint GetIntParam(GLenum query) const
    {
        GLint result = 0;
        OGLPLUS_GLFUNC(GetSamplerParameteriv)(
            _name,
            query,
            &result
        );
        OGLPLUS_CHECK(
            GetSamplerParameteriv,
            ObjectError,
            Object(*this).
            EnumParam(query)
        );
        return result;
    }

    GLfloat GetFloatParam(GLenum query) const
    {
        GLfloat result = 0;
        OGLPLUS_GLFUNC(GetSamplerParameterfv)(
            _name,
            query,
            &result
        );
        OGLPLUS_CHECK(
            GetSamplerParameterfv,
            ObjectError,
            Object(*this).
            EnumParam(query)
        );
        return result;
    }


    Vector<GLfloat, 4> BorderColor(TypeTag<GLfloat>) const
    {
        GLfloat result[4];
        OGLPLUS_GLFUNC(GetSamplerParameterfv)(
            _name,
            GL_TEXTURE_BORDER_COLOR,
            result
        );
        OGLPLUS_CHECK(
            GetSamplerParameterfv,
            ObjectError,
            Object(*this)
        );
        return Vector<GLfloat, 4>(result, 4);
    }


    void BorderColor(Vector<GLfloat, 4> color)
    {
        OGLPLUS_GLFUNC(SamplerParameterfv)(
            _name,
            GL_TEXTURE_BORDER_COLOR,
            Data(color)
        );
        OGLPLUS_CHECK(
            SamplerParameterfv,
            ObjectError,
            Object(*this)
        );
    }


    Vector<GLint, 4> BorderColor(TypeTag<GLint>) const
    {
        GLint result[4];
        OGLPLUS_GLFUNC(GetSamplerParameterIiv)(
            _name,
            GL_TEXTURE_BORDER_COLOR,
            result
        );
        OGLPLUS_CHECK(
            GetSamplerParameterIiv,
            ObjectError,
            Object(*this)
        );
        return Vector<GLint, 4>(result, 4);
    }


    void BorderColor(Vector<GLint, 4> color)
    {
        OGLPLUS_GLFUNC(SamplerParameterIiv)(
            _name,
            GL_TEXTURE_BORDER_COLOR,
            Data(color)
        );
        OGLPLUS_CHECK(
            SamplerParameterIiv,
            ObjectError,
            Object(*this)
        );
    }


    Vector<GLuint, 4> BorderColor(TypeTag<GLuint>) const
    {
        GLuint result[4];
        OGLPLUS_GLFUNC(GetSamplerParameterIuiv)(
            _name,
            GL_TEXTURE_BORDER_COLOR,
            result
        );
        OGLPLUS_CHECK(
            GetSamplerParameterIuiv,
            ObjectError,
            Object(*this)
        );
        return Vector<GLuint, 4>(result, 4);
    }


    void BorderColor(Vector<GLuint, 4> color)
    {
        OGLPLUS_GLFUNC(SamplerParameterIuiv)(
            _name,
            GL_TEXTURE_BORDER_COLOR,
            Data(color)
        );
        OGLPLUS_CHECK(
            SamplerParameterIuiv,
            ObjectError,
            Object(*this)
        );
    }


    TextureCompareMode CompareMode(void) const
    {
        return TextureCompareMode(GetIntParam(
            GL_TEXTURE_COMPARE_MODE
        ));
    }


    void CompareMode(TextureCompareMode mode)
    {
        OGLPLUS_GLFUNC(SamplerParameteri)(
            _name,
            GL_TEXTURE_COMPARE_MODE,
            GLenum(mode)
        );
        OGLPLUS_CHECK(
            SamplerParameteri,
            ObjectError,
            Object(*this).
            EnumParam(mode)
        );
    }


    CompareFunction CompareFunc(void) const
    {
        return CompareFunction(GetIntParam(
            GL_TEXTURE_COMPARE_FUNC
        ));
    }


    void CompareFunc(CompareFunction func)
    {
        OGLPLUS_GLFUNC(SamplerParameteri)(
            _name,
            GL_TEXTURE_COMPARE_FUNC,
            GLenum(func)
        );
        OGLPLUS_CHECK(
            SamplerParameteri,
            ObjectError,
            Object(*this).
            EnumParam(func)
        );
    }


    GLfloat LODBias(void) const
    {
        return GetFloatParam(GL_TEXTURE_LOD_BIAS);
    }


    void LODBias(GLfloat value)
    {
        OGLPLUS_GLFUNC(SamplerParameterf)(
            _name,
            GL_TEXTURE_LOD_BIAS,
            value
        );
        OGLPLUS_CHECK(
            SamplerParameterf,
            ObjectError,
            Object(*this)
        );
    }


    void Filter(TextureFilter filter) const
    {
        OGLPLUS_GLFUNC(SamplerParameteri)(
            _name,
            GL_TEXTURE_MIN_FILTER,
            GLenum(filter)
        );
        OGLPLUS_CHECK(
            SamplerParameteri,
            ObjectError,
            Object(*this).
            EnumParam(filter)
        );
        OGLPLUS_GLFUNC(SamplerParameteri)(
            _name,
            GL_TEXTURE_MAG_FILTER,
            GLenum(filter)
        );
        OGLPLUS_CHECK(
            SamplerParameteri,
            ObjectError,
            Object(*this).
            EnumParam(filter)
        );
    }


    TextureMagFilter MagFilter(void) const
    {
        return TextureMagFilter(GetIntParam(
            GL_TEXTURE_MAG_FILTER
        ));
    }


    void MagFilter(TextureMagFilter filter)
    {
        OGLPLUS_GLFUNC(SamplerParameteri)(
            _name,
            GL_TEXTURE_MAG_FILTER,
            GLenum(filter)
        );
        OGLPLUS_CHECK(
            SamplerParameteri,
            ObjectError,
            Object(*this).
            EnumParam(filter)
        );
    }


    TextureMinFilter MinFilter(void) const
    {
        return TextureMinFilter(GetIntParam(
            GL_TEXTURE_MIN_FILTER
        ));
    }


    void MinFilter(TextureMinFilter filter)
    {
        OGLPLUS_GLFUNC(SamplerParameteri)(
            _name,
            GL_TEXTURE_MIN_FILTER,
            GLenum(filter)
        );
        OGLPLUS_CHECK(
            SamplerParameteri,
            ObjectError,
            Object(*this).
            EnumParam(filter)
        );
    }


    GLfloat MinLOD(void) const
    {
        return GetFloatParam(GL_TEXTURE_MIN_LOD);
    }


    void MinLOD(GLfloat value)
    {
        OGLPLUS_GLFUNC(SamplerParameterf)(
            _name,
            GL_TEXTURE_MIN_LOD,
            value
        );
        OGLPLUS_CHECK(
            SamplerParameterf,
            ObjectError,
            Object(*this)
        );
    }


    GLfloat MaxLOD(void) const
    {
        return GetFloatParam(GL_TEXTURE_MAX_LOD);
    }


    void MaxLOD(GLfloat value)
    {
        OGLPLUS_GLFUNC(SamplerParameterf)(
            _name,
            GL_TEXTURE_MAX_LOD,
            value
        );
        OGLPLUS_CHECK(
            SamplerParameterf,
            ObjectError,
            Object(*this)
        );
    }


    TextureWrap Wrap(TextureWrapCoord coord) const
    {
        return TextureWrap(GetIntParam(GLenum(coord)));
    }


    void Wrap(TextureWrapCoord coord, TextureWrap mode)
    {
        OGLPLUS_GLFUNC(SamplerParameteri)(
            _name,
            GLenum(coord),
            GLenum(mode)
        );
        OGLPLUS_CHECK(
            SamplerParameteri,
            ObjectError,
            Object(*this).
            EnumParam(mode)
        );
    }


    TextureWrap WrapS(void) const
    {
        return Wrap(TextureWrapCoord::S);
    }


    void WrapS(TextureWrap mode)
    {
        Wrap(TextureWrapCoord::S, mode);
    }


    TextureWrap WrapT(void) const
    {
        return Wrap(TextureWrapCoord::T);
    }


    void WrapT(TextureWrap mode)
    {
        Wrap(TextureWrapCoord::T, mode);
    }


    TextureWrap WrapR(void) const
    {
        return Wrap(TextureWrapCoord::R);
    }


    void WrapR(TextureWrap mode)
    {
        Wrap(TextureWrapCoord::R, mode);
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_ARB_seamless_cubemap_per_texture

    bool Seamless(void) const
    {
        return GetIntParam(GL_TEXTURE_CUBE_MAP_SEAMLESS) == GL_TRUE;
    }


    void Seamless(bool enable)
    {
        OGLPLUS_GLFUNC(SamplerParameteri)(
            _name,
            GL_TEXTURE_CUBE_MAP_SEAMLESS,
            enable?GL_TRUE:GL_FALSE
        );
        OGLPLUS_CHECK(
            SamplerParameteri,
            ObjectError,
            Object(*this)
        );
    }
#endif
};

typedef ObjectOps<tag::DirectState, tag::Sampler>
    SamplerOps;

// Helper class for syntax-sugar operators
struct SamplerOpsAndSlot
{
    SamplerOps& sam;
    GLint slot;

    SamplerOpsAndSlot(SamplerOps& sa, GLint sl)
     : sam(sa)
     , slot(sl)
    { }
};

// syntax sugar operators
inline SamplerOpsAndSlot operator | (
    SamplerOps& sam,
    GLuint slot
)
{
    return SamplerOpsAndSlot(sam, slot);
}

// Bind
inline SamplerOps& operator << (
    SamplerOps& sam,
    TextureUnitSelector tus
)
{
    sam.Bind(tus);
    return sam;
}

// Filter
inline SamplerOps& operator << (
    SamplerOps& sam,
    TextureFilter filter
)
{
    sam.Filter(filter);
    return sam;
}

// MinFilter
inline SamplerOps& operator << (
    SamplerOps& sam,
    TextureMinFilter filter
)
{
    sam.MinFilter(filter);
    return sam;
}

// MagFilter
inline SamplerOps& operator << (
    SamplerOps& sam,
    TextureMagFilter filter
)
{
    sam.MagFilter(filter);
    return sam;
}

// CompareMode
inline SamplerOps& operator << (
    SamplerOps& sam,
    TextureCompareMode mode
)
{
    sam.CompareMode(mode);
    return sam;
}

// CompareFunc
inline SamplerOps& operator << (
    SamplerOps& sam,
    CompareFunction func
)
{
    sam.CompareFunc(func);
    return sam;
}

// Wrap
inline SamplerOps& operator << (
    SamplerOps& sam,
    TextureWrap wrap
)
{
    sam.WrapR(wrap);
    sam.WrapT(wrap);
    sam.WrapS(wrap);
    return sam;
}

// Wrap
inline SamplerOps& operator << (
    SamplerOpsAndSlot sas,
    TextureWrap wrap
)
{
    switch(sas.slot)
    {
        case 0: sas.sam.WrapS(wrap); break;
        case 1: sas.sam.WrapT(wrap); break;
        case 2: sas.sam.WrapR(wrap); break;
        default: assert(!"Invalid texture wrap slot");
    }
    return sas.sam;
}

// BorderColor
template <typename T>
inline SamplerOps& operator << (
    SamplerOps& sam,
    const Vector<T, 4>& col
)
{
    sam.BorderColor(col);
    return sam;
}


typedef ObjectZero<ObjZeroOps<tag::DirectState, tag::Sampler>>
    NoSampler;


typedef Object<SamplerOps> Sampler;

#endif // sampler object

} // namespace oglplus

#endif // include guard