texture.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_TEXTURE_1107121519_HPP
#define OGLPLUS_TEXTURE_1107121519_HPP

#include <oglplus/fwd.hpp>
#include <oglplus/glfunc.hpp>
#include <oglplus/error/object.hpp>
#include <oglplus/math/vector.hpp>
#include <oglplus/object/sequence.hpp>
#include <oglplus/object/wrapper.hpp>
#include <oglplus/compare_function.hpp>
#include <oglplus/data_type.hpp>
#include <oglplus/pixel_data.hpp>
#include <oglplus/access_specifier.hpp>
#include <oglplus/texture_target.hpp>
#include <oglplus/texture_compare.hpp>
#include <oglplus/texture_filter.hpp>
#include <oglplus/texture_swizzle.hpp>
#include <oglplus/texture_wrap.hpp>
#include <oglplus/texture_unit.hpp>
#include <oglplus/one_of.hpp>
#include <oglplus/output_data.hpp>
#include <oglplus/images/fwd.hpp>
#include <cassert>

namespace oglplus {

GLuint TextureTargetDimensions(TextureTarget target);


template <>
class ObjGenDelOps<tag::Texture>
{
protected:
    static void Gen(tag::Generate, GLsizei count, GLuint* names)
    {
        assert(names != nullptr);
        OGLPLUS_GLFUNC(GenTextures)(count, names);
        OGLPLUS_CHECK_SIMPLE(GenTextures);
    }
#if GL_VERSION_4_5 || GL_ARB_direct_state_access
    static void Gen(
        tag::Create,
        GLenum target,
        GLsizei count,
        GLuint* names
    )
    {
        assert(names != nullptr);
        OGLPLUS_GLFUNC(CreateTextures)(target, count, names);
        OGLPLUS_CHECK_SIMPLE(CreateTextures);
    }

    GLenum _type;

    void Gen(tag::Create create, GLsizei count, GLuint* names)
    {
        Gen(create, _type, count, names);
    }
#endif

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

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

template <>
struct ObjectSubtype<tag::Texture>
{
    typedef TextureTarget Type;
};

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


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


    static void Bind(
        Target target,
        TextureName texture
    )
    {
        OGLPLUS_GLFUNC(BindTexture)(
            GLenum(target),
            GetGLName(texture)
        );
        OGLPLUS_VERIFY(
            BindTexture,
            ObjectError,
            Object(texture).
            BindTarget(target)
        );
    }

#if OGLPLUS_DOCUMENTATION_ONLY ||GL_VERSION_4_2 ||GL_ARB_shader_image_load_store

    static void BindImage(
        ImageUnitSelector unit,
        TextureName texture,
        GLint level,
        bool layered,
        GLint layer,
        AccessSpecifier access,
        ImageUnitFormat format
    )
    {
        OGLPLUS_GLFUNC(BindImageTexture)(
            GLuint(unit),
            GetGLName(texture),
            level,
            layered? GL_TRUE : GL_FALSE,
            layer,
            GLenum(access),
            GLenum(format)
        );
        OGLPLUS_CHECK(
            BindImageTexture,
            ObjectError,
            Object(texture).
            EnumParam(format).
            Index(level)
        );
    }
#endif

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

    static void BindImage(
        GLuint first,
        GLsizei count,
        const GLuint* names
    )
    {
        OGLPLUS_GLFUNC(BindImageTextures)(
            first,
            count,
            names
        );
        OGLPLUS_VERIFY_SIMPLE(BindImageTextures);
    }


    static void Bind(
        GLuint first,
        const Sequence<TextureName>& textures
    )
    {
        Bind(first, GLsizei(textures.size()), GetGLNames(textures));
    }


    static void BindImage(
        GLuint first,
        const Sequence<TextureName>& textures
    )
    {
        BindImage(
            first,
            GLsizei(textures.size()),
            GetGLNames(textures)
        );
    }
#endif
};


template <>
class ObjCommonOps<tag::Texture>
 : public TextureName
 , public ObjBindingOps<tag::Texture>
{
protected:
    ObjCommonOps(void){ }
public:

    static void Active(TextureUnitSelector index)
    {
        OGLPLUS_GLFUNC(ActiveTexture)(
            GLenum(GL_TEXTURE0 + GLuint(index))
        );
        OGLPLUS_VERIFY(
            ActiveTexture,
            Error,
            Index(GLuint(index))
        );
    }


    static GLint Active(void)
    {
        GLint result;
        OGLPLUS_GLFUNC(GetIntegerv)(GL_ACTIVE_TEXTURE, &result);
        OGLPLUS_VERIFY(
            GetIntegerv,
            Error,
            EnumParam(GLenum(GL_ACTIVE_TEXTURE))
        );
        return GL_TEXTURE0 - result;
    }


    static Target CubeMapFace(GLuint face)
    {
        assert(face <= 5);
        return Target(GL_TEXTURE_CUBE_MAP_POSITIVE_X+face);
    }

    using ObjBindingOps<tag::Texture>::Bind;
#if OGLPLUS_DOCUMENTATION_ONLY ||GL_VERSION_4_2 ||GL_ARB_shader_image_load_store
    using ObjBindingOps<tag::Texture>::BindImage;
#endif


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

#if OGLPLUS_DOCUMENTATION_ONLY ||GL_VERSION_4_2 ||GL_ARB_shader_image_load_store

    void BindImage(
        ImageUnitSelector unit,
        GLint level,
        bool layered,
        GLint layer,
        AccessSpecifier access,
        ImageUnitFormat format
    ) const
    {
        BindImage(unit, *this, level, layered, layer, access, format);
    }
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_3

    void InvalidateImage(GLsizei level)
    {
        OGLPLUS_GLFUNC(InvalidateTexImage)(_name, level);
        OGLPLUS_CHECK(
            InvalidateTexImage,
            ObjectError,
            Object(*this).
            Index(level)
        );
    }


    void InvalidateSubImage(
        GLsizei level,
        GLint xoffs,
        GLint yoffs,
        GLint zoffs,
        GLsizei width,
        GLsizei height,
        GLsizei depth
    )
    {
        OGLPLUS_GLFUNC(InvalidateTexSubImage)(
            _name,
            level,
            xoffs,
            yoffs,
            zoffs,
            width,
            height,
            depth
        );
        OGLPLUS_CHECK(
            InvalidateTexSubImage,
            ObjectError,
            Object(*this).
            Index(level)
        );
    }
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_4

    template <typename GLtype>
    void ClearImage(
        GLsizei level,
        PixelDataFormat format,
        const GLtype* data
    )
    {
        OGLPLUS_GLFUNC(ClearTexImage)(
            _name,
            level,
            GLenum(format),
            GLenum(GetDataType<GLtype>()),
            data
        );
        OGLPLUS_CHECK(
            ClearTexImage,
            ObjectError,
            Object(*this).
            Index(level)
        );
    }


    template <typename GLtype>
    void ClearSubImage(
        GLsizei level,
        GLint xoffs,
        GLint yoffs,
        GLint zoffs,
        GLsizei width,
        GLsizei height,
        GLsizei depth,
        PixelDataFormat format,
        const GLtype* data
    )
    {
        OGLPLUS_GLFUNC(ClearTexImage)(
            _name,
            level,
            xoffs,
            yoffs,
            zoffs,
            width,
            height,
            depth,
            GLenum(format),
            GLenum(GetDataType<GLtype>()),
            data
        );
        OGLPLUS_CHECK(
            ClearTexImage,
            ObjectError,
            Object(*this).
            Index(level)
        );
    }
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_3 || GL_ARB_texture_view

    void View(
        Target target,
        TextureName orig_texture,
        PixelDataInternalFormat internal_format,
        GLuint min_level,
        GLuint num_levels,
        GLuint min_layer,
        GLuint num_layers
    )
    {
        OGLPLUS_GLFUNC(TextureView)(
            _name,
            GLenum(target),
            GetGLName(orig_texture),
            GLenum(internal_format),
            min_level,
            num_levels,
            min_layer,
            num_layers
        );
        OGLPLUS_CHECK(
            TextureView,
            ObjectError,
            Object(*this).
            BindTarget(target)
        );
    }
#endif
};


template <>
class ObjZeroOps<tag::ExplicitSel, tag::Texture>
 : public ObjCommonOps<tag::Texture>
{
protected:
    ObjZeroOps(void) { }
public:
    struct Property
    {
        typedef TextureCompareMode CompareMode;

        typedef TextureFilter Filter;

        typedef TextureMagFilter MagFilter;

        typedef TextureMinFilter MinFilter;

        typedef TextureSwizzleCoord SwizzleCoord;

        typedef TextureSwizzle Swizzle;

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_3 || GL_ARB_texture_swizzle
        typedef TextureSwizzleTuple SwizzleTuple;
#endif

        typedef TextureWrapCoord WrapCoord;

        typedef TextureWrap Wrap;

        typedef OneOf<
            GLenum,
            std::tuple<
                DataType,
                PixelDataType
            >
        > PixDataType;
    };

    static GLint GetIntParam(Target target, GLenum query);
    static GLfloat GetFloatParam(Target target, GLenum query);

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_0
    static GLint GetIntParam(Target target, GLint level, GLenum query);
    static GLfloat GetFloatParam(Target target, GLint level, GLenum query);


    static GLsizei Width(Target target, GLint level = 0)
    {
        return GLsizei(GetIntParam(target, level, GL_TEXTURE_WIDTH));
    }


    static GLsizei Height(Target target, GLint level = 0)
    {
        return GLsizei(GetIntParam(target, level, GL_TEXTURE_HEIGHT));
    }


    static GLsizei Depth(Target target, GLint level = 0)
    {
        return GLsizei(GetIntParam(target, level, GL_TEXTURE_DEPTH));
    }


    static PixelDataType RedType(Target target, GLint level = 0)
    {
        return PixelDataType(GetIntParam(
            target,
            level,
            GL_TEXTURE_RED_TYPE
        ));
    }


    static PixelDataType GreenType(Target target, GLint level = 0)
    {
        return PixelDataType(GetIntParam(
            target,
            level,
            GL_TEXTURE_GREEN_TYPE
        ));
    }


    static PixelDataType BlueType(Target target, GLint level = 0)
    {
        return PixelDataType(GetIntParam(
            target,
            level,
            GL_TEXTURE_BLUE_TYPE
        ));
    }


    static PixelDataType AlphaType(Target target, GLint level = 0)
    {
        return PixelDataType(GetIntParam(
            target,
            level,
            GL_TEXTURE_ALPHA_TYPE
        ));
    }


    static PixelDataType DepthType(Target target, GLint level = 0)
    {
        return PixelDataType(GetIntParam(
            target,
            level,
            GL_TEXTURE_DEPTH_TYPE
        ));
    }


    static GLsizei RedSize(Target target, GLint level = 0)
    {
        return GLsizei(GetIntParam(
            target,
            level,
            GL_TEXTURE_RED_SIZE
        ));
    }


    static GLsizei GreenSize(Target target, GLint level = 0)
    {
        return GLsizei(GetIntParam(
            target,
            level,
            GL_TEXTURE_GREEN_SIZE
        ));
    }


    static GLsizei BlueSize(Target target, GLint level = 0)
    {
        return GLsizei(GetIntParam(
            target,
            level,
            GL_TEXTURE_BLUE_SIZE
        ));
    }


    static GLsizei AlphaSize(Target target, GLint level = 0)
    {
        return GLsizei(GetIntParam(
            target,
            level,
            GL_TEXTURE_ALPHA_SIZE
        ));
    }


    static GLsizei DepthSize(Target target, GLint level = 0)
    {
        return GLsizei(GetIntParam(
            target,
            level,
            GL_TEXTURE_DEPTH_SIZE
        ));
    }


    static GLsizei StencilSize(Target target, GLint level = 0)
    {
        return GLsizei(GetIntParam(
            target,
            level,
            GL_TEXTURE_STENCIL_SIZE
        ));
    }


    static GLsizei SharedSize(Target target, GLint level = 0)
    {
        return GLsizei(GetIntParam(
            target,
            level,
            GL_TEXTURE_SHARED_SIZE
        ));
    }


    static GLsizei CompressedImageSize(Target target, GLint level = 0)
    {
        return GLsizei(GetIntParam(
            target,
            level,
            GL_TEXTURE_COMPRESSED_IMAGE_SIZE
        ));
    }


    static PixelDataInternalFormat InternalFormat(
        Target target,
        GLint level = 0
    )
    {
        return PixelDataInternalFormat(GetIntParam(
            target,
            level,
            GL_TEXTURE_INTERNAL_FORMAT
        ));
    }


    static void GetImage(
        Target target,
        GLint level,
        PixelDataFormat format,
        const OutputData& dest
    );


    static void GetImage(
        Target target,
        GLint level,
        PixelDataFormat format,
        Property::PixDataType type,
        GLsizei size,
        GLvoid* buffer
    )
    {
        GetImage(target, level, format, OutputData(type, size, buffer));
    }


    static void GetCompressedImage(
        Target target,
        GLint level,
        const OutputData& dest
    );


    static void GetCompressedImage(
        Target target,
        GLint level,
        GLsizei size,
        GLubyte* buffer
    )
    {
        GetCompressedImage(target, level, OutputData(size, buffer));
    }


    static void GetCompressedImage(
        Target target,
        GLint level,
        std::vector<GLubyte>& dest
    );
#endif // GL_VERSION_3_0


    static void Image3D(
        Target target,
        GLint level,
        PixelDataInternalFormat internal_format,
        GLsizei width,
        GLsizei height,
        GLsizei depth,
        GLint border,
        PixelDataFormat format,
        Property::PixDataType type,
        const void* data
    )
    {
        OGLPLUS_GLFUNC(TexImage3D)(
            GLenum(target),
            level,
            GLint(internal_format),
            width,
            height,
            depth,
            border,
            GLenum(format),
            GLenum(type),
            data
        );
        OGLPLUS_CHECK(
            TexImage3D,
            ObjectError,
            ObjectBinding(target).
            EnumParam(internal_format).
            Index(level)
        );
    }


    static void Image3D(
        Target target,
        const images::Image& image,
        GLint level = 0,
        GLint border = 0
    );


    static void SubImage3D(
        Target target,
        GLint level,
        GLint xoffs,
        GLint yoffs,
        GLint zoffs,
        GLsizei width,
        GLsizei height,
        GLsizei depth,
        PixelDataFormat format,
        Property::PixDataType type,
        const void* data
    )
    {
        OGLPLUS_GLFUNC(TexSubImage3D)(
            GLenum(target),
            level,
            xoffs,
            yoffs,
            zoffs,
            width,
            height,
            depth,
            GLenum(format),
            GLenum(type),
            data
        );
        OGLPLUS_CHECK(
            TexSubImage3D,
            ObjectError,
            ObjectBinding(target).
            EnumParam(format).
            Index(level)
        );
    }


    static void SubImage3D(
        Target target,
        const images::Image& image,
        GLint xoffs,
        GLint yoffs,
        GLint zoffs,
        GLint level = 0
    );


    static void Image2D(
        Target target,
        GLint level,
        PixelDataInternalFormat internal_format,
        GLsizei width,
        GLsizei height,
        GLint border,
        PixelDataFormat format,
        Property::PixDataType type,
        const void* data
    )
    {
        OGLPLUS_GLFUNC(TexImage2D)(
            GLenum(target),
            level,
            GLint(internal_format),
            width,
            height,
            border,
            GLenum(format),
            GLenum(type),
            data
        );
        OGLPLUS_CHECK(
            TexImage2D,
            ObjectError,
            ObjectBinding(target).
            EnumParam(internal_format).
            Index(level)
        );
    }


    static void Image2D(
        Target target,
        const images::Image& image,
        GLint level = 0,
        GLint border = 0
    );


    static void ImageCM(
        GLuint face,
        GLint level,
        PixelDataInternalFormat internal_format,
        GLsizei width,
        GLsizei height,
        GLint border,
        PixelDataFormat format,
        Property::PixDataType type,
        const void* data
    )
    {
        assert(face <= 5);
        Target target = Target(GL_TEXTURE_CUBE_MAP_POSITIVE_X+face);
        OGLPLUS_GLFUNC(TexImage2D)(
            GLenum(target),
            level,
            GLint(internal_format),
            width,
            height,
            border,
            GLenum(format),
            GLenum(type),
            data
        );
        OGLPLUS_CHECK(
            TexImage2D,
            ObjectError,
            ObjectBinding(target).
            EnumParam(format).
            Index(level)
        );
    }


    static void ImageCM(
        GLuint face,
        const images::Image& image,
        GLint level = 0,
        GLint border = 0
    );


    static void SubImage2D(
        Target target,
        GLint level,
        GLint xoffs,
        GLint yoffs,
        GLsizei width,
        GLsizei height,
        PixelDataFormat format,
        Property::PixDataType type,
        const void* data
    )
    {
        OGLPLUS_GLFUNC(TexSubImage2D)(
            GLenum(target),
            level,
            xoffs,
            yoffs,
            width,
            height,
            GLenum(format),
            GLenum(type),
            data
        );
        OGLPLUS_CHECK(
            TexSubImage2D,
            ObjectError,
            ObjectBinding(target).
            EnumParam(format).
            Index(level)
        );
    }


    static void SubImage2D(
        Target target,
        const images::Image& image,
        GLint xoffs,
        GLint yoffs,
        GLint level = 0
    );

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_0

    static void Image1D(
        Target target,
        GLint level,
        PixelDataInternalFormat internal_format,
        GLsizei width,
        GLint border,
        PixelDataFormat format,
        Property::PixDataType type,
        const void* data
    )
    {
        OGLPLUS_GLFUNC(TexImage1D)(
            GLenum(target),
            level,
            GLint(internal_format),
            width,
            border,
            GLenum(format),
            GLenum(type),
            data
        );
        OGLPLUS_CHECK(
            TexImage1D,
            ObjectError,
            ObjectBinding(target).
            EnumParam(internal_format).
            Index(level)
        );
    }


    static void Image1D(
        Target target,
        const images::Image& image,
        GLint level = 0,
        GLint border = 0
    );


    static void SubImage1D(
        Target target,
        GLint level,
        GLint xoffs,
        GLsizei width,
        PixelDataFormat format,
        Property::PixDataType type,
        const void* data
    )
    {
        OGLPLUS_GLFUNC(TexSubImage1D)(
            GLenum(target),
            level,
            xoffs,
            width,
            GLenum(format),
            GLenum(type),
            data
        );
        OGLPLUS_CHECK(
            TexSubImage1D,
            ObjectError,
            ObjectBinding(target).
            EnumParam(format).
            Index(level)
        );
    }


    static void SubImage1D(
        Target target,
        const images::Image& image,
        GLint xoffs,
        GLint level = 0
    );
#endif // GL_VERSION_3_0


    static void Image(
        Target target,
        const images::Image& image,
        GLint level = 0,
        GLint border = 0
    );


    static void Image(
        Target target,
        const images::ImageSpec& image_spec,
        GLint level = 0,
        GLint border = 0
    );


    static void CopyImage2D(
        Target target,
        GLint level,
        PixelDataInternalFormat internal_format,
        GLint x,
        GLint y,
        GLsizei width,
        GLsizei height,
        GLint border
    )
    {
        OGLPLUS_GLFUNC(CopyTexImage2D)(
            GLenum(target),
            level,
            GLint(internal_format),
            x,
            y,
            width,
            height,
            border
        );
        OGLPLUS_CHECK(
            CopyTexImage2D,
            ObjectError,
            ObjectBinding(target).
            EnumParam(internal_format).
            Index(level)
        );
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_0

    static void CopyImage1D(
        Target target,
        GLint level,
        PixelDataInternalFormat internal_format,
        GLint x,
        GLint y,
        GLsizei width,
        GLint border
    )
    {
        OGLPLUS_GLFUNC(CopyTexImage1D)(
            GLenum(target),
            level,
            GLint(internal_format),
            x,
            y,
            width,
            border
        );
        OGLPLUS_CHECK(
            CopyTexImage1D,
            ObjectError,
            ObjectBinding(target).
            EnumParam(internal_format).
            Index(level)
        );
    }
#endif // GL_VERSION_3_0


    static void CopySubImage3D(
        Target target,
        GLint level,
        GLint xoffs,
        GLint yoffs,
        GLint zoffs,
        GLint x,
        GLint y,
        GLsizei width,
        GLsizei height
    )
    {
        OGLPLUS_GLFUNC(CopyTexSubImage3D)(
            GLenum(target),
            level,
            xoffs,
            yoffs,
            zoffs,
            x,
            y,
            width,
            height
        );
        OGLPLUS_CHECK(
            CopyTexSubImage3D,
            ObjectError,
            ObjectBinding(target).
            Index(level)
        );
    }


    static void CopySubImage2D(
        Target target,
        GLint level,
        GLint xoffs,
        GLint yoffs,
        GLint x,
        GLint y,
        GLsizei width,
        GLsizei height
    )
    {
        OGLPLUS_GLFUNC(CopyTexSubImage2D)(
            GLenum(target),
            level,
            xoffs,
            yoffs,
            x,
            y,
            width,
            height
        );
        OGLPLUS_CHECK(
            CopyTexSubImage2D,
            ObjectError,
            ObjectBinding(target).
            Index(level)
        );
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_0

    static void CopySubImage1D(
        Target target,
        GLint level,
        GLint xoffs,
        GLint x,
        GLint y,
        GLsizei width
    )
    {
        OGLPLUS_GLFUNC(CopyTexSubImage1D)(
            GLenum(target),
            level,
            xoffs,
            x,
            y,
            width
        );
        OGLPLUS_CHECK(
            CopyTexSubImage1D,
            ObjectError,
            ObjectBinding(target).
            Index(level)
        );
    }
#endif // GL_VERSION_3_0


    static void CompressedImage3D(
        Target target,
        GLint level,
        PixelDataInternalFormat internal_format,
        GLsizei width,
        GLsizei height,
        GLsizei depth,
        GLint border,
        GLsizei image_size,
        const void* data
    )
    {
        OGLPLUS_GLFUNC(CompressedTexImage3D)(
            GLenum(target),
            level,
            GLint(internal_format),
            width,
            height,
            depth,
            border,
            image_size,
            data
        );
        OGLPLUS_CHECK(
            CompressedTexImage3D,
            ObjectError,
            ObjectBinding(target).
            EnumParam(internal_format).
            Index(level)
        );
    }


    static void CompressedImage2D(
        Target target,
        GLint level,
        PixelDataInternalFormat internal_format,
        GLsizei width,
        GLsizei height,
        GLint border,
        GLsizei image_size,
        const void* data
    )
    {
        OGLPLUS_GLFUNC(CompressedTexImage2D)(
            GLenum(target),
            level,
            GLint(internal_format),
            width,
            height,
            border,
            image_size,
            data
        );
        OGLPLUS_CHECK(
            CompressedTexImage2D,
            ObjectError,
            ObjectBinding(target).
            EnumParam(internal_format).
            Index(level)
        );
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_0

    static void CompressedImage1D(
        Target target,
        GLint level,
        PixelDataInternalFormat internal_format,
        GLsizei width,
        GLint border,
        GLsizei image_size,
        const void* data
    )
    {
        OGLPLUS_GLFUNC(CompressedTexImage1D)(
            GLenum(target),
            level,
            GLint(internal_format),
            width,
            border,
            image_size,
            data
        );
        OGLPLUS_CHECK(
            CompressedTexImage1D,
            ObjectError,
            ObjectBinding(target).
            EnumParam(internal_format).
            Index(level)
        );
    }
#endif // GL_VERSION_3_0


    static void CompressedSubImage3D(
        Target target,
        GLint level,
        GLint xoffs,
        GLint yoffs,
        GLint zoffs,
        GLsizei width,
        GLsizei height,
        GLsizei depth,
        PixelDataFormat format,
        GLsizei image_size,
        const void* data
    )
    {
        OGLPLUS_GLFUNC(CompressedTexSubImage3D)(
            GLenum(target),
            level,
            xoffs,
            yoffs,
            zoffs,
            width,
            height,
            depth,
            GLint(format),
            image_size,
            data
        );
        OGLPLUS_CHECK(
            CompressedTexSubImage3D,
            ObjectError,
            ObjectBinding(target).
            EnumParam(format).
            Index(level)
        );
    }


    static void CompressedSubImage2D(
        Target target,
        GLint level,
        GLint xoffs,
        GLint yoffs,
        GLsizei width,
        GLsizei height,
        PixelDataFormat format,
        GLsizei image_size,
        const void* data
    )
    {
        OGLPLUS_GLFUNC(CompressedTexSubImage2D)(
            GLenum(target),
            level,
            xoffs,
            yoffs,
            width,
            height,
            GLint(format),
            image_size,
            data
        );
        OGLPLUS_CHECK(
            CompressedTexSubImage2D,
            ObjectError,
            ObjectBinding(target).
            EnumParam(format).
            Index(level)
        );
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_0

    static void CompressedSubImage1D(
        Target target,
        GLint level,
        GLint xoffs,
        GLsizei width,
        PixelDataFormat format,
        GLsizei image_size,
        const void* data
    )
    {
        OGLPLUS_GLFUNC(CompressedTexSubImage1D)(
            GLenum(target),
            level,
            xoffs,
            width,
            GLint(format),
            image_size,
            data
        );
        OGLPLUS_CHECK(
            CompressedTexSubImage1D,
            ObjectError,
            ObjectBinding(target).
            EnumParam(format).
            Index(level)
        );
    }
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_2 || GL_ARB_texture_multisample

    static void Image3DMultisample(
        Target target,
        GLsizei samples,
        PixelDataInternalFormat internal_format,
        GLsizei width,
        GLsizei height,
        GLsizei depth,
        bool fixed_sample_locations
    )
    {
        OGLPLUS_GLFUNC(TexImage3DMultisample)(
            GLenum(target),
            samples,
            GLint(internal_format),
            width,
            height,
            depth,
            fixed_sample_locations ? GL_TRUE : GL_FALSE
        );
        OGLPLUS_CHECK(
            TexImage3DMultisample,
            ObjectError,
            ObjectBinding(target).
            EnumParam(internal_format)
        );
    }


    static void Image2DMultisample(
        Target target,
        GLsizei samples,
        PixelDataInternalFormat internal_format,
        GLsizei width,
        GLsizei height,
        bool fixed_sample_locations
    )
    {
        OGLPLUS_GLFUNC(TexImage2DMultisample)(
            GLenum(target),
            samples,
            GLint(internal_format),
            width,
            height,
            fixed_sample_locations ? GL_TRUE : GL_FALSE
        );
        OGLPLUS_CHECK(
            TexImage2DMultisample,
            ObjectError,
            ObjectBinding(target).
            EnumParam(internal_format)
        );
    }
#endif // texture multisample

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_1

    static void Buffer(
        Target target,
        PixelDataInternalFormat internal_format,
        BufferName buffer
    )
    {
        OGLPLUS_GLFUNC(TexBuffer)(
            GLenum(target),
            GLenum(internal_format),
            GetGLName(buffer)
        );
        OGLPLUS_CHECK(
            TexBuffer,
            ObjectPairError,
            Subject(buffer).
            ObjectBinding(target).
            EnumParam(internal_format)
        );
    }
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_3

    static void BufferRange(
        Target target,
        PixelDataInternalFormat internal_format,
        BufferName buffer,
        GLintptr offset,
        GLsizeiptr size
    )
    {
        OGLPLUS_GLFUNC(TexBufferRange)(
            GLenum(target),
            GLenum(internal_format),
            GetGLName(buffer),
            offset,
            size
        );
        OGLPLUS_CHECK(
            TexBufferRange,
            ObjectPairError,
            Subject(buffer).
            ObjectBinding(target).
            EnumParam(internal_format)
        );
    }
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_2 || GL_ARB_texture_storage

    static void Storage1D(
        Target target,
        GLsizei levels,
        PixelDataInternalFormat internal_format,
        GLsizei width
    )
    {
        OGLPLUS_GLFUNC(TexStorage1D)(
            GLenum(target),
            levels,
            GLenum(internal_format),
            width
        );
        OGLPLUS_CHECK(
            TexStorage1D,
            ObjectError,
            ObjectBinding(target).
            EnumParam(internal_format)
        );
    }


    static void Storage2D(
        Target target,
        GLsizei levels,
        PixelDataInternalFormat internal_format,
        GLsizei width,
        GLsizei height
    )
    {
        OGLPLUS_GLFUNC(TexStorage2D)(
            GLenum(target),
            levels,
            GLenum(internal_format),
            width,
            height
        );
        OGLPLUS_CHECK(
            TexStorage2D,
            ObjectError,
            ObjectBinding(target).
            EnumParam(internal_format)
        );
    }


    static void Storage3D(
        Target target,
        GLsizei levels,
        PixelDataInternalFormat internal_format,
        GLsizei width,
        GLsizei height,
        GLsizei depth
    )
    {
        OGLPLUS_GLFUNC(TexStorage3D)(
            GLenum(target),
            levels,
            GLenum(internal_format),
            width,
            height,
            depth
        );
        OGLPLUS_CHECK(
            TexStorage3D,
            ObjectError,
            ObjectBinding(target).
            EnumParam(internal_format)
        );
    }
#endif


    static GLuint BaseLevel(Target target)
    {
        return GetIntParam(target, GL_TEXTURE_BASE_LEVEL);
    }


    static void BaseLevel(Target target, GLuint level)
    {
        OGLPLUS_GLFUNC(TexParameteri)(
            GLenum(target),
            GL_TEXTURE_BASE_LEVEL,
            level
        );
        OGLPLUS_CHECK(
            TexParameteri,
            ObjectError,
            ObjectBinding(target).
            Index(level)
        );
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_0

    static Vector<GLfloat, 4> BorderColor(Target target, TypeTag<GLfloat>)
    {
        GLfloat result[4];
        OGLPLUS_GLFUNC(GetTexParameterfv)(
            GLenum(target),
            GL_TEXTURE_BORDER_COLOR,
            result
        );
        OGLPLUS_CHECK(
            GetTexParameterfv,
            ObjectError,
            ObjectBinding(target)
        );
        return Vector<GLfloat, 4>(result, 4);
    }


    static void BorderColor(Target target, Vector<GLfloat, 4> color)
    {
        OGLPLUS_GLFUNC(TexParameterfv)(
            GLenum(target),
            GL_TEXTURE_BORDER_COLOR,
            Data(color)
        );
        OGLPLUS_CHECK(
            TexParameterfv,
            ObjectError,
            ObjectBinding(target)
        );
    }


    static Vector<GLint, 4> BorderColor(Target target, TypeTag<GLint>)
    {
        GLint result[4];
        OGLPLUS_GLFUNC(GetTexParameterIiv)(
            GLenum(target),
            GL_TEXTURE_BORDER_COLOR,
            result
        );
        OGLPLUS_CHECK(
            GetTexParameterIiv,
            ObjectError,
            ObjectBinding(target)
        );
        return Vector<GLint, 4>(result, 4);
    }


    static void BorderColor(Target target, Vector<GLint, 4> color)
    {
        OGLPLUS_GLFUNC(TexParameterIiv)(
            GLenum(target),
            GL_TEXTURE_BORDER_COLOR,
            Data(color)
        );
        OGLPLUS_CHECK(
            TexParameterIiv,
            ObjectError,
            ObjectBinding(target)
        );
    }


    static Vector<GLuint, 4> BorderColor(Target target, TypeTag<GLuint>)
    {
        GLuint result[4];
        OGLPLUS_GLFUNC(GetTexParameterIuiv)(
            GLenum(target),
            GL_TEXTURE_BORDER_COLOR,
            result
        );
        OGLPLUS_CHECK(
            GetTexParameterIuiv,
            ObjectError,
            ObjectBinding(target)
        );
        return Vector<GLuint, 4>(result, 4);
    }


    static void BorderColor(Target target, Vector<GLuint, 4> color)
    {
        OGLPLUS_GLFUNC(TexParameterIuiv)(
            GLenum(target),
            GL_TEXTURE_BORDER_COLOR,
            Data(color)
        );
        OGLPLUS_CHECK(
            TexParameterIuiv,
            ObjectError,
            ObjectBinding(target)
        );
    }
#endif // GL_VERSION_3_0


    static TextureCompareMode CompareMode(Target target)
    {
        return TextureCompareMode(GetIntParam(
            target,
            GL_TEXTURE_COMPARE_MODE
        ));
    }


    static void CompareMode(Target target, TextureCompareMode mode)
    {
        OGLPLUS_GLFUNC(TexParameteri)(
            GLenum(target),
            GL_TEXTURE_COMPARE_MODE,
            GLenum(mode)
        );
        OGLPLUS_CHECK(
            TexParameteri,
            ObjectError,
            ObjectBinding(target).
            EnumParam(mode)
        );
    }


    static CompareFunction CompareFunc(Target target)
    {
        return CompareFunction(GetIntParam(
            target,
            GL_TEXTURE_COMPARE_FUNC
        ));
    }


    static void CompareFunc(Target target, CompareFunction func)
    {
        OGLPLUS_GLFUNC(TexParameteri)(
            GLenum(target),
            GL_TEXTURE_COMPARE_FUNC,
            GLenum(func)
        );
        OGLPLUS_CHECK(
            TexParameteri,
            ObjectError,
            ObjectBinding(target).
            EnumParam(func)
        );
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_0

    static GLfloat LODBias(Target target)
    {
        return GetFloatParam(target, GL_TEXTURE_LOD_BIAS);
    }


    static void LODBias(Target target, GLfloat value)
    {
        OGLPLUS_GLFUNC(TexParameterf)(
            GLenum(target),
            GL_TEXTURE_LOD_BIAS,
            value
        );
        OGLPLUS_CHECK(
            TexParameterf,
            ObjectError,
            ObjectBinding(target)
        );
    }
#endif // GL_VERSION_3_0


    static void Filter(Target target, TextureFilter filter)
    {
        OGLPLUS_GLFUNC(TexParameteri)(
            GLenum(target),
            GL_TEXTURE_MIN_FILTER,
            GLenum(filter)
        );
        OGLPLUS_CHECK(
            TexParameteri,
            ObjectError,
            ObjectBinding(target).
            EnumParam(filter)
        );
        OGLPLUS_GLFUNC(TexParameteri)(
            GLenum(target),
            GL_TEXTURE_MAG_FILTER,
            GLenum(filter)
        );
        OGLPLUS_CHECK(
            TexParameteri,
            ObjectError,
            ObjectBinding(target).
            EnumParam(filter)
        );
    }


    static TextureMagFilter MagFilter(Target target)
    {
        return TextureMagFilter(GetIntParam(
            target,
            GL_TEXTURE_MAG_FILTER
        ));
    }


    static void MagFilter(Target target, TextureMagFilter filter)
    {
        OGLPLUS_GLFUNC(TexParameteri)(
            GLenum(target),
            GL_TEXTURE_MAG_FILTER,
            GLenum(filter)
        );
        OGLPLUS_CHECK(
            TexParameteri,
            ObjectError,
            ObjectBinding(target).
            EnumParam(filter)
        );
    }


    static TextureMinFilter MinFilter(Target target)
    {
        return TextureMinFilter(GetIntParam(
            target,
            GL_TEXTURE_MIN_FILTER
        ));
    }


    static void MinFilter(Target target, TextureMinFilter filter)
    {
        OGLPLUS_GLFUNC(TexParameteri)(
            GLenum(target),
            GL_TEXTURE_MIN_FILTER,
            GLenum(filter)
        );
        OGLPLUS_CHECK(
            TexParameteri,
            ObjectError,
            ObjectBinding(target).
            EnumParam(filter)
        );
    }


    static GLfloat MinLOD(Target target)
    {
        return GetFloatParam(target, GL_TEXTURE_MIN_LOD);
    }


    static void MinLOD(Target target, GLfloat value)
    {
        OGLPLUS_GLFUNC(TexParameterf)(
            GLenum(target),
            GL_TEXTURE_MIN_LOD,
            value
        );
        OGLPLUS_CHECK(
            TexParameterf,
            ObjectError,
            ObjectBinding(target)
        );
    }


    static GLfloat MaxLOD(Target target)
    {
        return GetFloatParam(target, GL_TEXTURE_MAX_LOD);
    }


    static void MaxLOD(Target target, GLfloat value)
    {
        OGLPLUS_GLFUNC(TexParameterf)(
            GLenum(target),
            GL_TEXTURE_MAX_LOD,
            value
        );
        OGLPLUS_CHECK(
            TexParameterf,
            ObjectError,
            ObjectBinding(target)
        );
    }


    static GLint MaxLevel(Target target)
    {
        return GetIntParam(target, GL_TEXTURE_MAX_LEVEL);
    }


    static void MaxLevel(Target target, GLint value)
    {
        OGLPLUS_GLFUNC(TexParameteri)(
            GLenum(target),
            GL_TEXTURE_MAX_LEVEL,
            value
        );
        OGLPLUS_CHECK(
            TexParameteri,
            ObjectError,
            ObjectBinding(target)
        );
    }


    static GLfloat MaxAnisotropy(Target target)
    {
#ifdef  GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT
        return GetFloatParam(
            target,
            GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT
        );
#else
        OGLPLUS_FAKE_USE(target);
        return GLfloat(1);
#endif
    }


    static GLfloat Anisotropy(Target target)
    {
#ifdef  GL_TEXTURE_MAX_ANISOTROPY_EXT
        return GetFloatParam(
            target,
            GL_TEXTURE_MAX_ANISOTROPY_EXT
        );
#else
        OGLPLUS_FAKE_USE(target);
        return GLfloat(1);
#endif
    }


    static void Anisotropy(Target target, GLfloat value)
    {
#ifdef  GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT
        OGLPLUS_GLFUNC(TexParameterf)(
            GLenum(target),
            GL_TEXTURE_MAX_ANISOTROPY_EXT,
            value
        );
        OGLPLUS_CHECK(
            TexParameterf,
            ObjectError,
            ObjectBinding(target)
        );
#else
        OGLPLUS_FAKE_USE(target);
        OGLPLUS_FAKE_USE(value);
#endif
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_3 || GL_ARB_texture_swizzle

    static TextureSwizzle Swizzle(Target target, TextureSwizzleCoord coord)
    {
        return TextureSwizzle(GetIntParam(
            target,
            GLenum(coord)
        ));
    }


    static void Swizzle(
        Target target,
        TextureSwizzleCoord coord,
        TextureSwizzle mode
    )
    {
        OGLPLUS_GLFUNC(TexParameteri)(
            GLenum(target),
            GLenum(coord),
            GLenum(mode)
        );
        OGLPLUS_CHECK(
            TexParameteri,
            ObjectError,
            ObjectBinding(target).
            EnumParam(mode)
        );
    }


    static TextureSwizzle SwizzleR(Target target)
    {
        return Swizzle(target, TextureSwizzleCoord::R);
    }


    static void SwizzleR(Target target, TextureSwizzle mode)
    {
        Swizzle(target, TextureSwizzleCoord::R, mode);
    }


    static TextureSwizzle SwizzleG(Target target)
    {
        return Swizzle(target, TextureSwizzleCoord::G);
    }


    static void SwizzleG(Target target, TextureSwizzle mode)
    {
        Swizzle(target, TextureSwizzleCoord::G, mode);
    }


    static TextureSwizzle SwizzleB(Target target)
    {
        return Swizzle(target, TextureSwizzleCoord::B);
    }


    static void SwizzleB(Target target, TextureSwizzle mode)
    {
        Swizzle(target, TextureSwizzleCoord::B, mode);
    }


    static TextureSwizzle SwizzleA(Target target)
    {
        return Swizzle(target, TextureSwizzleCoord::A);
    }


    static void SwizzleA(Target target, TextureSwizzle mode)
    {
        Swizzle(target, TextureSwizzleCoord::A, mode);
    }


    static TextureSwizzleTuple SwizzleRGBA(Target target)
    {
        TextureSwizzleTuple result;
        OGLPLUS_GLFUNC(GetTexParameteriv)(
            GLenum(target),
            GL_TEXTURE_SWIZZLE_RGBA,
            result.Values()
        );
        OGLPLUS_CHECK(
            GetTexParameteriv,
            ObjectError,
            ObjectBinding(target)
        );
        return result;
    }


    static void SwizzleRGBA(Target target, TextureSwizzle mode)
    {
        GLint m = GLint(GLenum(mode));
        GLint params[4] = {m, m, m, m};

        OGLPLUS_GLFUNC(TexParameteriv)(
            GLenum(target),
            GL_TEXTURE_SWIZZLE_RGBA,
            params
        );
        OGLPLUS_CHECK(
            TexParameteriv,
            ObjectError,
            ObjectBinding(target).
            EnumParam(mode)
        );
    }


    static void SwizzleRGBA(
        Target target,
        TextureSwizzle mode_r,
        TextureSwizzle mode_g,
        TextureSwizzle mode_b,
        TextureSwizzle mode_a
    )
    {
        GLint params[4] = {
            GLint(GLenum(mode_r)),
            GLint(GLenum(mode_g)),
            GLint(GLenum(mode_b)),
            GLint(GLenum(mode_a))
        };

        OGLPLUS_GLFUNC(TexParameteriv)(
            GLenum(target),
            GL_TEXTURE_SWIZZLE_RGBA,
            params
        );
        OGLPLUS_CHECK(
            TexParameteriv,
            ObjectError,
            ObjectBinding(target)
        );
    }


    static void SwizzleRGBA(Target target, const TextureSwizzleTuple& modes)
    {
        OGLPLUS_GLFUNC(TexParameteriv)(
            GLenum(target),
            GL_TEXTURE_SWIZZLE_RGBA,
            modes.Values()
        );
        OGLPLUS_CHECK(
            TexParameteriv,
            ObjectError,
            ObjectBinding(target)
        );
    }
#endif // texture swizzle


    static TextureWrap Wrap(Target target, TextureWrapCoord coord)
    {
        return TextureWrap(GetIntParam(
            target,
            GLenum(coord)
        ));
    }


    static void Wrap(
        Target target,
        TextureWrapCoord coord,
        TextureWrap mode
    )
    {
        OGLPLUS_GLFUNC(TexParameteri)(
            GLenum(target),
            GLenum(coord),
            GLenum(mode)
        );
        OGLPLUS_CHECK(
            TexParameteri,
            ObjectError,
            ObjectBinding(target).
            EnumParam(mode)
        );
    }


    static TextureWrap WrapS(Target target)
    {
        return Wrap(target, TextureWrapCoord::S);
    }


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


    static TextureWrap WrapT(Target target)
    {
        return Wrap(target, TextureWrapCoord::T);
    }


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


    static TextureWrap WrapR(Target target)
    {
        return Wrap(target, TextureWrapCoord::R);
    }


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

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_3

    static PixelDataFormat DepthStencilMode(Target target)
    {
        return PixelDataFormat(GetIntParam(
            target,
            GL_DEPTH_STENCIL_TEXTURE_MODE
        ));
    }


    static void DepthStencilMode(
        Target target,
        PixelDataFormat mode
    )
    {
        OGLPLUS_GLFUNC(TexParameteri)(
            GLenum(target),
            GL_DEPTH_STENCIL_TEXTURE_MODE,
            GLenum(mode)
        );
        OGLPLUS_CHECK(
            TexParameteri,
            ObjectError,
            ObjectBinding(target).
            EnumParam(mode)
        );
    }
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || GL_ARB_seamless_cubemap_per_texture

    static bool Seamless(Target target)
    {
        return GetIntParam(
            target,
            GL_TEXTURE_CUBE_MAP_SEAMLESS
        ) == GL_TRUE;
    }


    static void Seamless(Target target, bool enable)
    {
        OGLPLUS_GLFUNC(TexParameteri)(
            GLenum(target),
            GL_TEXTURE_CUBE_MAP_SEAMLESS,
            enable?GL_TRUE:GL_FALSE
        );
        OGLPLUS_CHECK(
            TexParameteri,
            ObjectError,
            ObjectBinding(target)
        );
    }
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || \
    GL_VERSION_4_5 || \
    GL_ARB_texture_barrier || \
    GL_NV_texture_barrier

    static void Barrier(void)
    {
#if GL_VERSION_4_5 || GL_ARB_texture_barrier
        OGLPLUS_GLFUNC(TextureBarrier)();
        OGLPLUS_VERIFY_SIMPLE(TextureBarrier);
#elif GL_NV_texture_barrier
        OGLPLUS_GLFUNC(TextureBarrierNV)();
        OGLPLUS_VERIFY_SIMPLE(TextureBarrierNV);
#endif
    }
#endif


    static void GenerateMipmap(Target target)
    {
        OGLPLUS_GLFUNC(GenerateMipmap)(GLenum(target));
        OGLPLUS_CHECK(
            GenerateMipmap,
            ObjectError,
            ObjectBinding(target)
        );
    }
};

typedef ObjZeroOps<tag::ExplicitSel, tag::Texture>
    DefaultTextureOps;

template <>
class ObjectOps<tag::ExplicitSel, tag::Texture>
 : public ObjZeroOps<tag::ExplicitSel, tag::Texture>
{
protected:
    ObjectOps(void){ }
};

typedef ObjectOps<tag::ExplicitSel, tag::Texture>
    TextureOps;


struct TextureMipmap { };

// Helper class for syntax-sugar operators
struct TextureTargetAndSlot
{
    TextureTarget target;
    GLint slot;

    TextureTargetAndSlot(TextureTarget& t, GLint s)
     : target(t)
     , slot(s)
    { }
};

// syntax sugar operators
inline TextureTargetAndSlot operator | (TextureTarget target, GLuint slot)
{
    return TextureTargetAndSlot(target, slot);
}

// helper class for syntax-sugar operators
struct TextureUnitAndTarget
{
    TextureUnitSelector unit;
    TextureTarget tgt;

    TextureUnitAndTarget(TextureUnitSelector u, TextureTarget t)
     : unit(u)
     , tgt(t)
    { }
};

// syntax sugar operators
inline TextureUnitAndTarget operator | (
    TextureUnitSelector unit,
    TextureTarget tex
)
{
    return TextureUnitAndTarget(unit, tex);
}

// Bind
inline TextureTarget operator << (
    const DefaultTextureOps& tex,
    TextureTarget target
)
{
    tex.Bind(target);
    return target;
}

// Filter
inline TextureTarget operator << (TextureTarget target, TextureFilter filter)
{
    DefaultTextureOps::Filter(target, filter);
    return target;
}

// MinFilter
inline TextureTarget operator << (TextureTarget target, TextureMinFilter filter)
{
    DefaultTextureOps::MinFilter(target, filter);
    return target;
}

// MagFilter
inline TextureTarget operator << (TextureTarget target, TextureMagFilter filter)
{
    DefaultTextureOps::MagFilter(target, filter);
    return target;
}

// CompareMode
inline TextureTarget operator << (TextureTarget target, TextureCompareMode mode)
{
    DefaultTextureOps::CompareMode(target, mode);
    return target;
}

// CompareFunc
inline TextureTarget operator << (TextureTarget target, CompareFunction func)
{
    DefaultTextureOps::CompareFunc(target, func);
    return target;
}

// Wrap
inline TextureTarget operator << (TextureTarget target, TextureWrap wrap)
{
    switch(TextureTargetDimensions(target))
    {
        case 3: DefaultTextureOps::WrapR(target, wrap);
        case 2: DefaultTextureOps::WrapT(target, wrap);
        case 1: DefaultTextureOps::WrapS(target, wrap);
        case 0: break;
        default: assert(!"Invalid texture wrap dimension");
    }
    return target;
}

// Wrap
inline TextureTargetAndSlot operator << (
    TextureTargetAndSlot tas,
    TextureWrap wrap
)
{
    switch(tas.slot)
    {
        case 0: DefaultTextureOps::WrapS(tas.target, wrap); break;
        case 1: DefaultTextureOps::WrapT(tas.target, wrap); break;
        case 2: DefaultTextureOps::WrapR(tas.target, wrap); break;
        default: assert(!"Invalid texture wrap slot");
    }
    return tas;
}

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_3 || GL_ARB_texture_swizzle
// Swizzle
inline TextureTarget operator << (TextureTarget target, TextureSwizzle swizzle)
{
    DefaultTextureOps::SwizzleRGBA(target, swizzle);
    return target;
}

// Swizzle
inline TextureTargetAndSlot operator << (
    TextureTargetAndSlot tas,
    TextureSwizzle swizzle
)
{
    switch(tas.slot)
    {
        case 0: DefaultTextureOps::SwizzleR(tas.target, swizzle); break;
        case 1: DefaultTextureOps::SwizzleG(tas.target, swizzle); break;
        case 2: DefaultTextureOps::SwizzleB(tas.target, swizzle); break;
        case 3: DefaultTextureOps::SwizzleA(tas.target, swizzle); break;
        default: assert(!"Invalid texture swizzle slot");
    }
    return tas;
}
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_0
// BorderColor
template <typename T>
inline TextureTarget operator << (
    TextureTarget target,
    const Vector<T, 4>& col
)
{
    DefaultTextureOps::BorderColor(target, col);
    return target;
}
#endif

// Image
inline TextureTarget operator << (
    TextureTarget target,
    const images::Image& image
)
{
    DefaultTextureOps::Image(target, image);
    return target;
}

// Image
inline TextureTarget operator << (
    TextureTarget target,
    const images::ImageSpec& image_spec
)
{
    DefaultTextureOps::Image(target, image_spec);
    return target;
}

// Image + Level
inline TextureTarget operator << (
    TextureTargetAndSlot tas,
    const images::Image& image
)
{
    DefaultTextureOps::Image(tas.target, image, tas.slot);
    return tas.target;
}

// Image + Level
inline TextureTarget operator << (
    TextureTargetAndSlot tas,
    const images::ImageSpec& image_spec
)
{
    DefaultTextureOps::Image(tas.target, image_spec, tas.slot);
    return tas.target;
}

// GenerateMipmap
inline TextureTarget operator << (
    TextureTarget target,
    TextureMipmap
)
{
    DefaultTextureOps::GenerateMipmap(target);
    return target;
}


typedef ObjectZero<DefaultTextureOps> DefaultTexture;


typedef Object<TextureOps> Texture;

} // namespace oglplus

#if !OGLPLUS_LINK_LIBRARY || defined(OGLPLUS_IMPLEMENTING_LIBRARY)
#include <oglplus/texture.ipp>
#endif // OGLPLUS_LINK_LIBRARY

#endif // include guard