texture.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_DSA_TEXTURE_1107121519_HPP
#define OGLPLUS_DSA_TEXTURE_1107121519_HPP

#include <oglplus/texture.hpp>

namespace oglplus {

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_5 || GL_ARB_direct_state_access

template <>
struct ObjGenTag<tag::DirectState, tag::Texture>
{
    typedef tag::Create Type;
};


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


template <>
class ObjectOps<tag::DirectState, tag::Texture>
 : public ObjZeroOps<tag::DirectState, tag::Texture>
{
protected:
    ObjectOps(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_0
        typedef TextureSwizzleTuple SwizzleTuple;
#endif

        typedef TextureWrapCoord WrapCoord;

        typedef TextureWrap Wrap;

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

    using ObjCommonOps<tag::Texture>::Bind;

    GLint GetIntParam(GLenum query) const;
    GLfloat GetFloatParam(GLenum query) const;

    GLint GetIntParam(GLint level, GLenum query) const;
    GLfloat GetFloatParam(GLint level, GLenum query) const;


    GLsizei Width(GLint level = 0) const
    {
        return GLsizei(GetIntParam(level, GL_TEXTURE_WIDTH));
    }


    GLsizei Height(GLint level = 0) const
    {
        return GLsizei(GetIntParam(level, GL_TEXTURE_HEIGHT));
    }


    GLsizei Depth(GLint level = 0) const
    {
        return GLsizei(GetIntParam(level, GL_TEXTURE_DEPTH));
    }


    PixelDataType RedType(GLint level = 0) const
    {
        return PixelDataType(GetIntParam(
            level,
            GL_TEXTURE_RED_TYPE
        ));
    }


    PixelDataType GreenType(GLint level = 0) const
    {
        return PixelDataType(GetIntParam(
            level,
            GL_TEXTURE_GREEN_TYPE
        ));
    }


    PixelDataType BlueType(GLint level = 0) const
    {
        return PixelDataType(GetIntParam(
            level,
            GL_TEXTURE_BLUE_TYPE
        ));
    }


    PixelDataType AlphaType(GLint level = 0) const
    {
        return PixelDataType(GetIntParam(
            level,
            GL_TEXTURE_ALPHA_TYPE
        ));
    }


    PixelDataType DepthType(GLint level = 0) const
    {
        return PixelDataType(GetIntParam(
            level,
            GL_TEXTURE_DEPTH_TYPE
        ));
    }


    GLsizei RedSize(GLint level = 0) const
    {
        return GLsizei(GetIntParam(
            level,
            GL_TEXTURE_RED_SIZE
        ));
    }


    GLsizei GreenSize(GLint level = 0) const
    {
        return GLsizei(GetIntParam(
            level,
            GL_TEXTURE_GREEN_SIZE
        ));
    }


    GLsizei BlueSize(GLint level = 0) const
    {
        return GLsizei(GetIntParam(
            level,
            GL_TEXTURE_BLUE_SIZE
        ));
    }


    GLsizei AlphaSize(GLint level = 0) const
    {
        return GLsizei(GetIntParam(
            level,
            GL_TEXTURE_ALPHA_SIZE
        ));
    }


    GLsizei DepthSize(GLint level = 0) const
    {
        return GLsizei(GetIntParam(
            level,
            GL_TEXTURE_DEPTH_SIZE
        ));
    }


    GLsizei StencilSize(GLint level = 0) const
    {
        return GLsizei(GetIntParam(
            level,
            GL_TEXTURE_STENCIL_SIZE
        ));
    }


    GLsizei SharedSize(GLint level = 0) const
    {
        return GLsizei(GetIntParam(
            level,
            GL_TEXTURE_SHARED_SIZE
        ));
    }


    GLsizei CompressedImageSize(GLint level = 0) const
    {
        return GLsizei(GetIntParam(
            level,
            GL_TEXTURE_COMPRESSED_IMAGE_SIZE
        ));
    }


    PixelDataInternalFormat InternalFormat(GLint level = 0) const
    {
        return PixelDataInternalFormat(GetIntParam(
            level,
            GL_TEXTURE_INTERNAL_FORMAT
        ));
    }


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


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

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


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


    void GetCompressedImage(
        GLint level,
        std::vector<GLubyte>& dest
    ) const;


    ObjectOps& Storage1D(
        GLsizei levels,
        PixelDataInternalFormat internal_format,
        GLsizei width
    )
    {
        OGLPLUS_GLFUNC(TextureStorage1D)(
            _name,
            levels,
            GLenum(internal_format),
            width
        );
        OGLPLUS_CHECK(
            TextureStorage1D,
            ObjectError,
            Object(*this).
            EnumParam(internal_format)
        );
        return *this;
    }

    ObjectOps& Storage1D(
        GLsizei levels,
        const images::ImageSpec& image_spec
    );


    ObjectOps& Storage2D(
        GLsizei levels,
        PixelDataInternalFormat internal_format,
        GLsizei width,
        GLsizei height
    )
    {
        OGLPLUS_GLFUNC(TextureStorage2D)(
            _name,
            levels,
            GLenum(internal_format),
            width,
            height
        );
        OGLPLUS_CHECK(
            TextureStorage2D,
            ObjectError,
            Object(*this).
            EnumParam(internal_format)
        );
        return *this;
    }

    ObjectOps& Storage2D(
        GLsizei levels,
        const images::ImageSpec& image_spec
    );


    ObjectOps& Storage3D(
        GLsizei levels,
        PixelDataInternalFormat internal_format,
        GLsizei width,
        GLsizei height,
        GLsizei depth
    )
    {
        OGLPLUS_GLFUNC(TextureStorage3D)(
            _name,
            levels,
            GLenum(internal_format),
            width,
            height,
            depth
        );
        OGLPLUS_CHECK(
            TextureStorage3D,
            ObjectError,
            Object(*this).
            EnumParam(internal_format)
        );
        return *this;
    }

    ObjectOps& Storage3D(
        GLsizei levels,
        const images::ImageSpec& image_spec
    );

    ObjectOps& Storage(
        GLsizei levels,
        const images::ImageSpec& image_spec
    );


    ObjectOps& SubImage3D(
        GLint level,
        GLint xoffs,
        GLint yoffs,
        GLint zoffs,
        GLsizei width,
        GLsizei height,
        GLsizei depth,
        PixelDataFormat format,
        Property::PixDataType type,
        const void* data
    )
    {
        OGLPLUS_GLFUNC(TextureSubImage3D)(
            _name,
            level,
            xoffs,
            yoffs,
            zoffs,
            width,
            height,
            depth,
            GLenum(format),
            GLenum(type),
            data
        );
        OGLPLUS_CHECK(
            TextureSubImage3D,
            ObjectError,
            Object(*this).
            EnumParam(format).
            Index(level)
        );
        return *this;
    }


    ObjectOps& SubImage3D(
        const images::Image& image,
        GLint xoffs = 0,
        GLint yoffs = 0,
        GLint zoffs = 0,
        GLint level = 0
    );


    ObjectOps& SubImage2D(
        GLint level,
        GLint xoffs,
        GLint yoffs,
        GLsizei width,
        GLsizei height,
        PixelDataFormat format,
        Property::PixDataType type,
        const void* data
    )
    {
        OGLPLUS_GLFUNC(TextureSubImage2D)(
            _name,
            level,
            xoffs,
            yoffs,
            width,
            height,
            GLenum(format),
            GLenum(type),
            data
        );
        OGLPLUS_CHECK(
            TextureSubImage2D,
            ObjectError,
            Object(*this).
            EnumParam(format).
            Index(level)
        );
        return *this;
    }


    ObjectOps& SubImage2D(
        const images::Image& image,
        GLint xoffs = 0,
        GLint yoffs = 0,
        GLint level = 0
    );


    ObjectOps& SubImage1D(
        GLint level,
        GLint xoffs,
        GLsizei width,
        PixelDataFormat format,
        Property::PixDataType type,
        const void* data
    )
    {
        OGLPLUS_GLFUNC(TextureSubImage1D)(
            _name,
            level,
            xoffs,
            width,
            GLenum(format),
            GLenum(type),
            data
        );
        OGLPLUS_CHECK(
            TextureSubImage1D,
            ObjectError,
            Object(*this).
            EnumParam(format).
            Index(level)
        );
        return *this;
    }


    ObjectOps& SubImage1D(
        const images::Image& image,
        GLint xoffs = 0,
        GLint level = 0
    );


    ObjectOps& CopySubImage3D(
        GLint level,
        GLint xoffs,
        GLint yoffs,
        GLint zoffs,
        GLint x,
        GLint y,
        GLsizei width,
        GLsizei height
    )
    {
        OGLPLUS_GLFUNC(CopyTextureSubImage3D)(
            _name,
            level,
            xoffs,
            yoffs,
            zoffs,
            x,
            y,
            width,
            height
        );
        OGLPLUS_CHECK(
            CopyTextureSubImage3D,
            ObjectError,
            Object(*this).
            Index(level)
        );
        return *this;
    }


    ObjectOps& CopySubImage2D(
        GLint level,
        GLint xoffs,
        GLint yoffs,
        GLint x,
        GLint y,
        GLsizei width,
        GLsizei height
    )
    {
        OGLPLUS_GLFUNC(CopyTextureSubImage2D)(
            _name,
            level,
            xoffs,
            yoffs,
            x,
            y,
            width,
            height
        );
        OGLPLUS_CHECK(
            CopyTextureSubImage2D,
            ObjectError,
            Object(*this).
            Index(level)
        );
        return *this;
    }


    ObjectOps& CopySubImage1D(
        GLint level,
        GLint xoffs,
        GLint x,
        GLint y,
        GLsizei width
    )
    {
        OGLPLUS_GLFUNC(CopyTextureSubImage1D)(
            _name,
            level,
            xoffs,
            x,
            y,
            width
        );
        OGLPLUS_CHECK(
            CopyTextureSubImage1D,
            ObjectError,
            Object(*this).
            Index(level)
        );
        return *this;
    }


    ObjectOps& CompressedSubImage3D(
        GLint level,
        GLint xoffs,
        GLint yoffs,
        GLint zoffs,
        GLsizei width,
        GLsizei height,
        GLsizei depth,
        PixelDataFormat format,
        GLsizei image_size,
        const void* data
    )
    {
        OGLPLUS_GLFUNC(CompressedTextureSubImage3D)(
            _name,
            level,
            xoffs,
            yoffs,
            zoffs,
            width,
            height,
            depth,
            GLint(format),
            image_size,
            data
        );
        OGLPLUS_CHECK(
            CompressedTextureSubImage3D,
            ObjectError,
            Object(*this).
            EnumParam(format).
            Index(level)
        );
        return *this;
    }


    ObjectOps& CompressedSubImage2D(
        GLint level,
        GLint xoffs,
        GLint yoffs,
        GLsizei width,
        GLsizei height,
        PixelDataFormat format,
        GLsizei image_size,
        const void* data
    )
    {
        OGLPLUS_GLFUNC(CompressedTextureSubImage2D)(
            _name,
            level,
            xoffs,
            yoffs,
            width,
            height,
            GLint(format),
            image_size,
            data
        );
        OGLPLUS_CHECK(
            CompressedTextureSubImage2D,
            ObjectError,
            Object(*this).
            EnumParam(format).
            Index(level)
        );
        return *this;
    }


    ObjectOps& CompressedSubImage1D(
        GLint level,
        GLint xoffs,
        GLsizei width,
        PixelDataFormat format,
        GLsizei image_size,
        const void* data
    )
    {
        OGLPLUS_GLFUNC(CompressedTextureSubImage1D)(
            _name,
            level,
            xoffs,
            width,
            GLint(format),
            image_size,
            data
        );
        OGLPLUS_CHECK(
            CompressedTextureSubImage1D,
            ObjectError,
            Object(*this).
            EnumParam(format).
            Index(level)
        );
        return *this;
    }


    ObjectOps& Buffer(
        PixelDataInternalFormat internal_format,
        BufferName buffer
    )
    {
        OGLPLUS_GLFUNC(TextureBuffer)(
            _name,
            GLenum(internal_format),
            GetGLName(buffer)
        );
        OGLPLUS_CHECK(
            TextureBuffer,
            ObjectPairError,
            Subject(buffer).
            Object(*this).
            EnumParam(internal_format)
        );
        return *this;
    }


    GLuint BaseLevel(void) const
    {
        return GetIntParam(GL_TEXTURE_BASE_LEVEL);
    }


    ObjectOps& BaseLevel(GLuint level)
    {
        OGLPLUS_GLFUNC(TextureParameteri)(
            _name,
            GL_TEXTURE_BASE_LEVEL,
            level
        );
        OGLPLUS_CHECK(
            TextureParameteri,
            ObjectError,
            Object(*this).
            Index(level)
        );
        return *this;
    }


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


    ObjectOps& BorderColor(Vector<GLfloat, 4> color)
    {
        OGLPLUS_GLFUNC(TextureParameterfv)(
            _name,
            GL_TEXTURE_BORDER_COLOR,
            Data(color)
        );
        OGLPLUS_CHECK(
            TextureParameterfv,
            ObjectError,
            Object(*this)
        );
        return *this;
    }


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


    ObjectOps& BorderColor(Vector<GLint, 4> color)
    {
        OGLPLUS_GLFUNC(TextureParameterIiv)(
            _name,
            GL_TEXTURE_BORDER_COLOR,
            Data(color)
        );
        OGLPLUS_CHECK(
            TextureParameterIiv,
            ObjectError,
            Object(*this)
        );
        return *this;
    }


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


    ObjectOps& BorderColor(Vector<GLuint, 4> color)
    {
        OGLPLUS_GLFUNC(TextureParameterIuiv)(
            _name,
            GL_TEXTURE_BORDER_COLOR,
            Data(color)
        );
        OGLPLUS_CHECK(
            TextureParameterIuiv,
            ObjectError,
            Object(*this)
        );
        return *this;
    }


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


    ObjectOps& CompareMode(TextureCompareMode mode)
    {
        OGLPLUS_GLFUNC(TextureParameteri)(
            _name,
            GL_TEXTURE_COMPARE_MODE,
            GLenum(mode)
        );
        OGLPLUS_CHECK(
            TextureParameteri,
            ObjectError,
            Object(*this).
            EnumParam(mode)
        );
        return *this;
    }


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


    ObjectOps& CompareFunc(CompareFunction func)
    {
        OGLPLUS_GLFUNC(TextureParameteri)(
            _name,
            GL_TEXTURE_COMPARE_FUNC,
            GLenum(func)
        );
        OGLPLUS_CHECK(
            TextureParameteri,
            ObjectError,
            Object(*this).
            EnumParam(func)
        );
        return *this;
    }


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


    ObjectOps& LODBias(GLfloat value)
    {
        OGLPLUS_GLFUNC(TextureParameterf)(
            _name,
            GL_TEXTURE_LOD_BIAS,
            value
        );
        OGLPLUS_CHECK(
            TextureParameterf,
            ObjectError,
            Object(*this)
        );
        return *this;
    }


    ObjectOps& Filter(TextureFilter filter)
    {
        OGLPLUS_GLFUNC(TextureParameteri)(
            _name,
            GL_TEXTURE_MIN_FILTER,
            GLenum(filter)
        );
        OGLPLUS_CHECK(
            TextureParameteri,
            ObjectError,
            Object(*this).
            EnumParam(filter)
        );
        OGLPLUS_GLFUNC(TextureParameteri)(
            _name,
            GL_TEXTURE_MAG_FILTER,
            GLenum(filter)
        );
        OGLPLUS_CHECK(
            TextureParameteri,
            ObjectError,
            Object(*this).
            EnumParam(filter)
        );
        return *this;
    }


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


    ObjectOps& MagFilter(TextureMagFilter filter)
    {
        OGLPLUS_GLFUNC(TextureParameteri)(
            _name,
            GL_TEXTURE_MAG_FILTER,
            GLenum(filter)
        );
        OGLPLUS_CHECK(
            TextureParameteri,
            ObjectError,
            Object(*this).
            EnumParam(filter)
        );
        return *this;
    }


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


    ObjectOps& MinFilter(TextureMinFilter filter)
    {
        OGLPLUS_GLFUNC(TextureParameteri)(
            _name,
            GL_TEXTURE_MIN_FILTER,
            GLenum(filter)
        );
        OGLPLUS_CHECK(
            TextureParameteri,
            ObjectError,
            Object(*this).
            EnumParam(filter)
        );
        return *this;
    }


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


    ObjectOps& MinLOD(GLfloat value)
    {
        OGLPLUS_GLFUNC(TextureParameterf)(
            _name,
            GL_TEXTURE_MIN_LOD,
            value
        );
        OGLPLUS_CHECK(
            TextureParameterf,
            ObjectError,
            Object(*this)
        );
        return *this;
    }


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


    ObjectOps& MaxLOD(GLfloat value)
    {
        OGLPLUS_GLFUNC(TextureParameterf)(
            _name,
            GL_TEXTURE_MAX_LOD,
            value
        );
        OGLPLUS_CHECK(
            TextureParameterf,
            ObjectError,
            Object(*this)
        );
        return *this;
    }


    GLint MaxLevel(void) const
    {
        return GetIntParam(GL_TEXTURE_MAX_LEVEL);
    }


    ObjectOps& MaxLevel(GLint value)
    {
        OGLPLUS_GLFUNC(TextureParameteri)(
            _name,
            GL_TEXTURE_MAX_LEVEL,
            value
        );
        OGLPLUS_CHECK(
            TextureParameteri,
            ObjectError,
            Object(*this)
        );
        return *this;
    }


    GLfloat MaxAnisotropy(void) const
    {
#ifdef  GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT
        return GetFloatParam(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT);
#else
        return GLfloat(1);
#endif
    }


    GLfloat Anisotropy(void) const
    {
#ifdef  GL_TEXTURE_MAX_ANISOTROPY_EXT
        return GetFloatParam(GL_TEXTURE_MAX_ANISOTROPY_EXT);
#else
        return GLfloat(1);
#endif
    }


    ObjectOps& Anisotropy(GLfloat value)
    {
#ifdef  GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT
        OGLPLUS_GLFUNC(TextureParameterf)(
            _name,
            GL_TEXTURE_MAX_ANISOTROPY_EXT,
            value
        );
        OGLPLUS_CHECK(
            TextureParameterf,
            ObjectError,
            Object(*this)
        );
#else
        OGLPLUS_FAKE_USE(value);
#endif
        return *this;
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_3 || GL_ARB_texture_swizzle

    TextureSwizzle Swizzle(TextureSwizzleCoord coord) const
    {
        return TextureSwizzle(GetIntParam(
            GLenum(coord)
        ));
    }


    ObjectOps& Swizzle(
        TextureSwizzleCoord coord,
        TextureSwizzle mode
    )
    {
        OGLPLUS_GLFUNC(TextureParameteri)(
            _name,
            GLenum(coord),
            GLenum(mode)
        );
        OGLPLUS_CHECK(
            TextureParameteri,
            ObjectError,
            Object(*this).
            EnumParam(mode)
        );
        return *this;
    }


    TextureSwizzle SwizzleR(void) const
    {
        return Swizzle(TextureSwizzleCoord::R);
    }


    ObjectOps& SwizzleR(TextureSwizzle mode)
    {
        return Swizzle(TextureSwizzleCoord::R, mode);
    }


    TextureSwizzle SwizzleG(void) const
    {
        return Swizzle(TextureSwizzleCoord::G);
    }


    ObjectOps& SwizzleG(TextureSwizzle mode)
    {
        return Swizzle(TextureSwizzleCoord::G, mode);
    }


    TextureSwizzle SwizzleB(void) const
    {
        return Swizzle(TextureSwizzleCoord::B);
    }


    ObjectOps& SwizzleB(TextureSwizzle mode)
    {
        return Swizzle(TextureSwizzleCoord::B, mode);
    }


    TextureSwizzle SwizzleA(void) const
    {
        return Swizzle(TextureSwizzleCoord::A);
    }


    ObjectOps& SwizzleA(TextureSwizzle mode)
    {
        return Swizzle(TextureSwizzleCoord::A, mode);
    }


    TextureSwizzleTuple SwizzleRGBA(void) const
    {
        TextureSwizzleTuple result;
        OGLPLUS_GLFUNC(GetTextureParameteriv)(
            _name,
            GL_TEXTURE_SWIZZLE_RGBA,
            result.Values()
        );
        OGLPLUS_CHECK(
            GetTextureParameteriv,
            ObjectError,
            Object(*this)
        );
        return result;
    }


    ObjectOps& SwizzleRGBA(TextureSwizzle mode)
    {
        GLint m = GLint(GLenum(mode));
        GLint params[4] = {m, m, m, m};
        OGLPLUS_GLFUNC(TextureParameteriv)(
            _name,
            GL_TEXTURE_SWIZZLE_RGBA,
            params
        );
        OGLPLUS_CHECK(
            TextureParameteriv,
            ObjectError,
            Object(*this).
            EnumParam(mode)
        );
        return *this;
    }


    ObjectOps& SwizzleRGBA(
        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(TextureParameteriv)(
            _name,
            GL_TEXTURE_SWIZZLE_RGBA,
            params
        );
        OGLPLUS_CHECK(
            TextureParameteriv,
            ObjectError,
            Object(*this)
        );
        return *this;
    }


    ObjectOps& SwizzleRGBA(const TextureSwizzleTuple& modes)
    {
        OGLPLUS_GLFUNC(TextureParameteriv)(
            _name,
            GL_TEXTURE_SWIZZLE_RGBA,
            modes.Values()
        );
        OGLPLUS_CHECK(
            TextureParameteriv,
            ObjectError,
            Object(*this)
        );
        return *this;
    }
#endif // texture swizzle


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


    ObjectOps& Wrap(
        TextureWrapCoord coord,
        TextureWrap mode
    )
    {
        OGLPLUS_GLFUNC(TextureParameteri)(
            _name,
            GLenum(coord),
            GLenum(mode)
        );
        OGLPLUS_CHECK(
            TextureParameteri,
            ObjectError,
            Object(*this).
            EnumParam(mode)
        );
        return *this;
    }


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


    ObjectOps& WrapS(TextureWrap mode)
    {
        return Wrap(TextureWrapCoord::S, mode);
    }


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


    ObjectOps& WrapT(TextureWrap mode)
    {
        return Wrap(TextureWrapCoord::T, mode);
    }


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


    ObjectOps& WrapR(TextureWrap mode)
    {
        return Wrap(TextureWrapCoord::R, mode);
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_3

    PixelDataFormat DepthStencilMode(void) const
    {
        return PixelDataFormat(GetIntParam(
            GL_DEPTH_STENCIL_TEXTURE_MODE
        ));
    }


    ObjectOps& DepthStencilMode(PixelDataFormat mode)
    {
        OGLPLUS_GLFUNC(TextureParameteri)(
            _name,
            GL_DEPTH_STENCIL_TEXTURE_MODE,
            GLenum(mode)
        );
        OGLPLUS_CHECK(
            TextureParameteri,
            ObjectError,
            Object(*this).
            EnumParam(mode)
        );
        return *this;
    }
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || GL_ARB_seamless_cubemap_per_texture

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


    ObjectOps& Seamless(bool enable)
    {
        OGLPLUS_GLFUNC(TextureParameteri)(
            _name,
            GL_TEXTURE_CUBE_MAP_SEAMLESS,
            enable?GL_TRUE:GL_FALSE
        );
        OGLPLUS_CHECK(
            TextureParameteri,
            ObjectError,
            Object(*this)
        );
        return *this;
    }
#endif


    ObjectOps& GenerateMipmap(void)
    {
        OGLPLUS_GLFUNC(GenerateTextureMipmap)(_name);
        OGLPLUS_CHECK(
            GenerateTextureMipmap,
            ObjectError,
            Object(*this)
        );
        return *this;
    }

};

typedef ObjectOps<tag::DirectState, tag::Texture>
    DSATextureOps;

// Helper class for syntax-sugar operators
struct DSATextureOpsAndSlot
{
    DSATextureOps& tex;
    GLint slot;

    DSATextureOpsAndSlot(DSATextureOps& t, GLint s)
     : tex(t)
     , slot(s)
    { }
};

// syntax sugar operators
inline DSATextureOpsAndSlot operator | (
    DSATextureOps& tex,
    GLuint slot
)
{
    return DSATextureOpsAndSlot(tex, slot);
}

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

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

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

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

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

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

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

// Swizzle
inline DSATextureOps& operator << (
    DSATextureOps& tex,
    TextureSwizzle swizzle
)
{
    tex.SwizzleRGBA(swizzle);
    return tex;
}

// Swizzle
inline DSATextureOps& operator << (
    DSATextureOpsAndSlot tas,
    TextureSwizzle swizzle
)
{
    switch(tas.slot)
    {
        case 0: tas.tex.SwizzleR(swizzle); break;
        case 1: tas.tex.SwizzleG(swizzle); break;
        case 2: tas.tex.SwizzleB(swizzle); break;
        case 3: tas.tex.SwizzleA(swizzle); break;
        default: assert(!"Invalid texture swizzle slot");
    }
    return tas.tex;
}

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

/*
// Image
inline DSATextureOps& operator << (
    DSATextureOps& tex,
    const images::Image& image
)
{
    tex.Image(image);
    return tex;
}

// Image
inline DSATextureOps& operator << (
    DSATextureOps& tex,
    const images::ImageSpec& image_spec
)
{
    tex.Image(image_spec);
    return tex;
}

// Image + Level
inline DSATextureOps& operator << (
    DSATextureOpsAndSlot tas,
    const images::Image& image
)
{
    tas.tex.Image(image, tas.slot);
    return tas.tex;
}

// Image + Level
inline DSATextureOps& operator << (
    DSATextureOpsAndSlot tas,
    const images::ImageSpec& image_spec
)
{
    tas.tex.Image(image_spec, tas.slot);
    return tas.tex;
}
*/

// GenerateMipmaps
inline DSATextureOps& operator << (
    DSATextureOps& tex,
    TextureMipmap
)
{
    tex.GenerateMipmap();
    return tex;
}


typedef Object<DSATextureOps> DSATexture;

#endif // GL_ARB_direct_state_access

} // namespace oglplus

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

#endif // include guard