texture.hpp

Go to the documentation of this file.

#ifndef OGLPLUS_BOUND_TEXTURE_1107121519_HPP
#define OGLPLUS_BOUND_TEXTURE_1107121519_HPP

#include <oglplus/object/bound.hpp>
#include <oglplus/texture.hpp>
#include <utility>

namespace oglplus {


template <>
class BoundObjOps<tag::Texture>
{
private:
    typedef ObjectOps<tag::ExplicitSel, tag::Texture> ExplicitOps;
public:
    typedef ExplicitOps::Target Target;
    Target target;

    BoundObjOps(void)
    { }

    BoundObjOps(Target init_tgt)
     : target(init_tgt)
    { }

    GLint GetIntParam(
        GLenum query
    ) const
    {
        return ExplicitOps::GetIntParam(
            this->target,
            query
        );
    }


    GLfloat GetFloatParam(
        GLenum query
    ) const
    {
        return ExplicitOps::GetFloatParam(
            this->target,
            query
        );
    }


    GLint GetIntParam(
        GLint level,
        GLenum query
    ) const
    {
        return ExplicitOps::GetIntParam(
            this->target,
            level,
            query
        );
    }


    GLfloat GetFloatParam(
        GLint level,
        GLenum query
    ) const
    {
        return ExplicitOps::GetFloatParam(
            this->target,
            level,
            query
        );
    }


    GLsizei Width(
        GLint level = 0
    ) const
    {
        return ExplicitOps::Width(
            this->target,
            level
        );
    }


    GLsizei Height(
        GLint level = 0
    ) const
    {
        return ExplicitOps::Height(
            this->target,
            level
        );
    }


    GLsizei Depth(
        GLint level = 0
    ) const
    {
        return ExplicitOps::Depth(
            this->target,
            level
        );
    }


    PixelDataType RedType(
        GLint level = 0
    ) const
    {
        return ExplicitOps::RedType(
            this->target,
            level
        );
    }


    PixelDataType GreenType(
        GLint level = 0
    ) const
    {
        return ExplicitOps::GreenType(
            this->target,
            level
        );
    }


    PixelDataType BlueType(
        GLint level = 0
    ) const
    {
        return ExplicitOps::BlueType(
            this->target,
            level
        );
    }


    PixelDataType AlphaType(
        GLint level = 0
    ) const
    {
        return ExplicitOps::AlphaType(
            this->target,
            level
        );
    }


    PixelDataType DepthType(
        GLint level = 0
    ) const
    {
        return ExplicitOps::DepthType(
            this->target,
            level
        );
    }


    GLsizei RedSize(
        GLint level = 0
    ) const
    {
        return ExplicitOps::RedSize(
            this->target,
            level
        );
    }


    GLsizei GreenSize(
        GLint level = 0
    ) const
    {
        return ExplicitOps::GreenSize(
            this->target,
            level
        );
    }


    GLsizei BlueSize(
        GLint level = 0
    ) const
    {
        return ExplicitOps::BlueSize(
            this->target,
            level
        );
    }


    GLsizei AlphaSize(
        GLint level = 0
    ) const
    {
        return ExplicitOps::AlphaSize(
            this->target,
            level
        );
    }


    GLsizei DepthSize(
        GLint level = 0
    ) const
    {
        return ExplicitOps::DepthSize(
            this->target,
            level
        );
    }


    GLsizei StencilSize(
        GLint level = 0
    ) const
    {
        return ExplicitOps::StencilSize(
            this->target,
            level
        );
    }


    GLsizei SharedSize(
        GLint level = 0
    ) const
    {
        return ExplicitOps::SharedSize(
            this->target,
            level
        );
    }


    GLsizei CompressedImageSize(
        GLint level = 0
    ) const
    {
        return ExplicitOps::CompressedImageSize(
            this->target,
            level
        );
    }


    PixelDataInternalFormat InternalFormat(
        GLint level = 0
    ) const
    {
        return ExplicitOps::InternalFormat(
            this->target,
            level
        );
    }


    const BoundObjOps& GetImage(
        GLint level,
        PixelDataFormat format,
        ExplicitOps::Property::PixDataType type,
        GLsizei size,
        GLvoid * buffer
    ) const
    {
        ExplicitOps::GetImage(
            this->target,
            level,
            format,
            type,
            size,
            buffer
        );
        return *this;
    }


    template <typename T>
    const BoundObjOps& GetImage(
        GLint level,
        PixelDataFormat format,
        std::vector< T > & dest
    ) const
    {
        ExplicitOps::GetImage(
            this->target,
            level,
            format,
            dest
        );
        return *this;
    }


    const BoundObjOps& GetCompressedImage(
        GLint level,
        GLsizei size,
        GLubyte * buffer
    ) const
    {
        ExplicitOps::GetCompressedImage(
            this->target,
            level,
            size,
            buffer
        );
        return *this;
    }


    const BoundObjOps& GetCompressedImage(
        GLint level,
        std::vector< GLubyte > & dest
    ) const
    {
        ExplicitOps::GetCompressedImage(
            this->target,
            level,
            dest
        );
        return *this;
    }


    const BoundObjOps& Image3D(
        GLint level,
        PixelDataInternalFormat internal_format,
        GLsizei width,
        GLsizei height,
        GLsizei depth,
        GLint border,
        PixelDataFormat format,
        ExplicitOps::Property::PixDataType type,
        const void * data
    ) const
    {
        ExplicitOps::Image3D(
            this->target,
            level,
            internal_format,
            width,
            height,
            depth,
            border,
            format,
            type,
            data
        );
        return *this;
    }


    const BoundObjOps& Image3D(
        const images::Image & image,
        GLint level = 0,
        GLint border = 0
    ) const
    {
        ExplicitOps::Image3D(
            this->target,
            image,
            level,
            border
        );
        return *this;
    }


    const BoundObjOps& SubImage3D(
        GLint level,
        GLint xoffs,
        GLint yoffs,
        GLint zoffs,
        GLsizei width,
        GLsizei height,
        GLsizei depth,
        PixelDataFormat format,
        ExplicitOps::Property::PixDataType type,
        const void * data
    ) const
    {
        ExplicitOps::SubImage3D(
            this->target,
            level,
            xoffs,
            yoffs,
            zoffs,
            width,
            height,
            depth,
            format,
            type,
            data
        );
        return *this;
    }


    const BoundObjOps& SubImage3D(
        const images::Image & image,
        GLint xoffs,
        GLint yoffs,
        GLint zoffs,
        GLint level = 0
    ) const
    {
        ExplicitOps::SubImage3D(
            this->target,
            image,
            xoffs,
            yoffs,
            zoffs,
            level
        );
        return *this;
    }


    const BoundObjOps& Image2D(
        GLint level,
        PixelDataInternalFormat internal_format,
        GLsizei width,
        GLsizei height,
        GLint border,
        PixelDataFormat format,
        ExplicitOps::Property::PixDataType type,
        const void * data
    ) const
    {
        ExplicitOps::Image2D(
            this->target,
            level,
            internal_format,
            width,
            height,
            border,
            format,
            type,
            data
        );
        return *this;
    }


    const BoundObjOps& Image2D(
        const images::Image & image,
        GLint level = 0,
        GLint border = 0
    ) const
    {
        ExplicitOps::Image2D(
            this->target,
            image,
            level,
            border
        );
        return *this;
    }


    const BoundObjOps& SubImage2D(
        GLint level,
        GLint xoffs,
        GLint yoffs,
        GLsizei width,
        GLsizei height,
        PixelDataFormat format,
        ExplicitOps::Property::PixDataType type,
        const void * data
    ) const
    {
        ExplicitOps::SubImage2D(
            this->target,
            level,
            xoffs,
            yoffs,
            width,
            height,
            format,
            type,
            data
        );
        return *this;
    }


    const BoundObjOps& SubImage2D(
        const images::Image & image,
        GLint xoffs,
        GLint yoffs,
        GLint level = 0
    ) const
    {
        ExplicitOps::SubImage2D(
            this->target,
            image,
            xoffs,
            yoffs,
            level
        );
        return *this;
    }


    const BoundObjOps& Image1D(
        GLint level,
        PixelDataInternalFormat internal_format,
        GLsizei width,
        GLint border,
        PixelDataFormat format,
        ExplicitOps::Property::PixDataType type,
        const void * data
    ) const
    {
        ExplicitOps::Image1D(
            this->target,
            level,
            internal_format,
            width,
            border,
            format,
            type,
            data
        );
        return *this;
    }


    const BoundObjOps& Image1D(
        const images::Image & image,
        GLint level = 0,
        GLint border = 0
    ) const
    {
        ExplicitOps::Image1D(
            this->target,
            image,
            level,
            border
        );
        return *this;
    }


    const BoundObjOps& SubImage1D(
        GLint level,
        GLint xoffs,
        GLsizei width,
        PixelDataFormat format,
        ExplicitOps::Property::PixDataType type,
        const void * data
    ) const
    {
        ExplicitOps::SubImage1D(
            this->target,
            level,
            xoffs,
            width,
            format,
            type,
            data
        );
        return *this;
    }


    const BoundObjOps& SubImage1D(
        const images::Image & image,
        GLint xoffs,
        GLint level = 0
    ) const
    {
        ExplicitOps::SubImage1D(
            this->target,
            image,
            xoffs,
            level
        );
        return *this;
    }


    const BoundObjOps& Image(
        const images::Image & image,
        GLint level = 0,
        GLint border = 0
    ) const
    {
        ExplicitOps::Image(
            this->target,
            image,
            level,
            border
        );
        return *this;
    }


    const BoundObjOps& Image(
        const images::ImageSpec & image_spec,
        GLint level = 0,
        GLint border = 0
    ) const
    {
        ExplicitOps::Image(
            this->target,
            image_spec,
            level,
            border
        );
        return *this;
    }


    const BoundObjOps& CopyImage2D(
        GLint level,
        PixelDataInternalFormat internal_format,
        GLint x,
        GLint y,
        GLsizei width,
        GLsizei height,
        GLint border
    ) const
    {
        ExplicitOps::CopyImage2D(
            this->target,
            level,
            internal_format,
            x,
            y,
            width,
            height,
            border
        );
        return *this;
    }


    const BoundObjOps& CopyImage1D(
        GLint level,
        PixelDataInternalFormat internal_format,
        GLint x,
        GLint y,
        GLsizei width,
        GLint border
    ) const
    {
        ExplicitOps::CopyImage1D(
            this->target,
            level,
            internal_format,
            x,
            y,
            width,
            border
        );
        return *this;
    }


    const BoundObjOps& CopySubImage3D(
        GLint level,
        GLint xoffs,
        GLint yoffs,
        GLint zoffs,
        GLint x,
        GLint y,
        GLsizei width,
        GLsizei height
    ) const
    {
        ExplicitOps::CopySubImage3D(
            this->target,
            level,
            xoffs,
            yoffs,
            zoffs,
            x,
            y,
            width,
            height
        );
        return *this;
    }


    const BoundObjOps& CopySubImage2D(
        GLint level,
        GLint xoffs,
        GLint yoffs,
        GLint x,
        GLint y,
        GLsizei width,
        GLsizei height
    ) const
    {
        ExplicitOps::CopySubImage2D(
            this->target,
            level,
            xoffs,
            yoffs,
            x,
            y,
            width,
            height
        );
        return *this;
    }


    const BoundObjOps& CopySubImage1D(
        GLint level,
        GLint xoffs,
        GLint x,
        GLint y,
        GLsizei width
    ) const
    {
        ExplicitOps::CopySubImage1D(
            this->target,
            level,
            xoffs,
            x,
            y,
            width
        );
        return *this;
    }


    const BoundObjOps& CompressedImage3D(
        GLint level,
        PixelDataInternalFormat internal_format,
        GLsizei width,
        GLsizei height,
        GLsizei depth,
        GLint border,
        GLsizei image_size,
        const void * data
    ) const
    {
        ExplicitOps::CompressedImage3D(
            this->target,
            level,
            internal_format,
            width,
            height,
            depth,
            border,
            image_size,
            data
        );
        return *this;
    }


    const BoundObjOps& CompressedImage2D(
        GLint level,
        PixelDataInternalFormat internal_format,
        GLsizei width,
        GLsizei height,
        GLint border,
        GLsizei image_size,
        const void * data
    ) const
    {
        ExplicitOps::CompressedImage2D(
            this->target,
            level,
            internal_format,
            width,
            height,
            border,
            image_size,
            data
        );
        return *this;
    }


    const BoundObjOps& CompressedImage1D(
        GLint level,
        PixelDataInternalFormat internal_format,
        GLsizei width,
        GLint border,
        GLsizei image_size,
        const void * data
    ) const
    {
        ExplicitOps::CompressedImage1D(
            this->target,
            level,
            internal_format,
            width,
            border,
            image_size,
            data
        );
        return *this;
    }


    const BoundObjOps& CompressedSubImage3D(
        GLint level,
        GLint xoffs,
        GLint yoffs,
        GLint zoffs,
        GLsizei width,
        GLsizei height,
        GLsizei depth,
        PixelDataFormat format,
        GLsizei image_size,
        const void * data
    ) const
    {
        ExplicitOps::CompressedSubImage3D(
            this->target,
            level,
            xoffs,
            yoffs,
            zoffs,
            width,
            height,
            depth,
            format,
            image_size,
            data
        );
        return *this;
    }


    const BoundObjOps& CompressedSubImage2D(
        GLint level,
        GLint xoffs,
        GLint yoffs,
        GLsizei width,
        GLsizei height,
        PixelDataFormat format,
        GLsizei image_size,
        const void * data
    ) const
    {
        ExplicitOps::CompressedSubImage2D(
            this->target,
            level,
            xoffs,
            yoffs,
            width,
            height,
            format,
            image_size,
            data
        );
        return *this;
    }


    const BoundObjOps& CompressedSubImage1D(
        GLint level,
        GLint xoffs,
        GLsizei width,
        PixelDataFormat format,
        GLsizei image_size,
        const void * data
    ) const
    {
        ExplicitOps::CompressedSubImage1D(
            this->target,
            level,
            xoffs,
            width,
            format,
            image_size,
            data
        );
        return *this;
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_2 || GL_ARB_texture_multisample

    const BoundObjOps& Image3DMultisample(
        GLsizei samples,
        PixelDataInternalFormat internal_format,
        GLsizei width,
        GLsizei height,
        GLsizei depth,
        bool fixed_sample_locations
    ) const
    {
        ExplicitOps::Image3DMultisample(
            this->target,
            samples,
            internal_format,
            width,
            height,
            depth,
            fixed_sample_locations
        );
        return *this;
    }
#endif // GL_VERSION_3_2 GL_ARB_texture_multisample

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_2 || GL_ARB_texture_multisample

    const BoundObjOps& Image2DMultisample(
        GLsizei samples,
        PixelDataInternalFormat internal_format,
        GLsizei width,
        GLsizei height,
        bool fixed_sample_locations
    ) const
    {
        ExplicitOps::Image2DMultisample(
            this->target,
            samples,
            internal_format,
            width,
            height,
            fixed_sample_locations
        );
        return *this;
    }
#endif // GL_VERSION_3_2 GL_ARB_texture_multisample

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_1

    const BoundObjOps& Buffer(
        PixelDataInternalFormat internal_format,
        BufferName buffer
    ) const
    {
        ExplicitOps::Buffer(
            this->target,
            internal_format,
            buffer
        );
        return *this;
    }
#endif // GL_VERSION_3_1

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_3

    const BoundObjOps& BufferRange(
        PixelDataInternalFormat internal_format,
        BufferName buffer,
        GLintptr offset,
        GLsizeiptr size
    ) const
    {
        ExplicitOps::BufferRange(
            this->target,
            internal_format,
            buffer,
            offset,
            size
        );
        return *this;
    }
#endif // GL_VERSION_4_3

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_2 || GL_ARB_texture_storage

    const BoundObjOps& Storage1D(
        GLsizei levels,
        PixelDataInternalFormat internal_format,
        GLsizei width
    ) const
    {
        ExplicitOps::Storage1D(
            this->target,
            levels,
            internal_format,
            width
        );
        return *this;
    }
#endif // GL_VERSION_4_2 GL_ARB_texture_storage

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_2 || GL_ARB_texture_storage

    const BoundObjOps& Storage2D(
        GLsizei levels,
        PixelDataInternalFormat internal_format,
        GLsizei width,
        GLsizei height
    ) const
    {
        ExplicitOps::Storage2D(
            this->target,
            levels,
            internal_format,
            width,
            height
        );
        return *this;
    }
#endif // GL_VERSION_4_2 GL_ARB_texture_storage

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_2 || GL_ARB_texture_storage

    const BoundObjOps& Storage3D(
        GLsizei levels,
        PixelDataInternalFormat internal_format,
        GLsizei width,
        GLsizei height,
        GLsizei depth
    ) const
    {
        ExplicitOps::Storage3D(
            this->target,
            levels,
            internal_format,
            width,
            height,
            depth
        );
        return *this;
    }
#endif // GL_VERSION_4_2 GL_ARB_texture_storage


    GLuint BaseLevel(void) const
    {
        return ExplicitOps::BaseLevel(
            this->target
        );
    }


    const BoundObjOps& BaseLevel(
        GLuint level
    ) const
    {
        ExplicitOps::BaseLevel(
            this->target,
            level
        );
        return *this;
    }


    Vector< GLfloat, 4 > BorderColor(
        TypeTag< GLfloat > _auto_param_2
    ) const
    {
        return ExplicitOps::BorderColor(
            this->target,
            _auto_param_2
        );
    }


    const BoundObjOps& BorderColor(
        Vector< GLfloat, 4 > color
    ) const
    {
        ExplicitOps::BorderColor(
            this->target,
            color
        );
        return *this;
    }


    Vector< GLint, 4 > BorderColor(
        TypeTag< GLint > _auto_param_2
    ) const
    {
        return ExplicitOps::BorderColor(
            this->target,
            _auto_param_2
        );
    }


    const BoundObjOps& BorderColor(
        Vector< GLint, 4 > color
    ) const
    {
        ExplicitOps::BorderColor(
            this->target,
            color
        );
        return *this;
    }


    Vector< GLuint, 4 > BorderColor(
        TypeTag< GLuint > _auto_param_2
    ) const
    {
        return ExplicitOps::BorderColor(
            this->target,
            _auto_param_2
        );
    }


    const BoundObjOps& BorderColor(
        Vector< GLuint, 4 > color
    ) const
    {
        ExplicitOps::BorderColor(
            this->target,
            color
        );
        return *this;
    }


    TextureCompareMode CompareMode(void) const
    {
        return ExplicitOps::CompareMode(
            this->target
        );
    }


    const BoundObjOps& CompareMode(
        TextureCompareMode mode
    ) const
    {
        ExplicitOps::CompareMode(
            this->target,
            mode
        );
        return *this;
    }


    CompareFunction CompareFunc(void) const
    {
        return ExplicitOps::CompareFunc(
            this->target
        );
    }


    const BoundObjOps& CompareFunc(
        CompareFunction func
    ) const
    {
        ExplicitOps::CompareFunc(
            this->target,
            func
        );
        return *this;
    }


    GLfloat LODBias(void) const
    {
        return ExplicitOps::LODBias(
            this->target
        );
    }


    const BoundObjOps& LODBias(
        GLfloat value
    ) const
    {
        ExplicitOps::LODBias(
            this->target,
            value
        );
        return *this;
    }


    const BoundObjOps& Filter(
        TextureFilter filter
    ) const
    {
        ExplicitOps::Filter(
            this->target,
            filter
        );
        return *this;
    }


    TextureMagFilter MagFilter(void) const
    {
        return ExplicitOps::MagFilter(
            this->target
        );
    }


    const BoundObjOps& MagFilter(
        TextureMagFilter filter
    ) const
    {
        ExplicitOps::MagFilter(
            this->target,
            filter
        );
        return *this;
    }


    TextureMinFilter MinFilter(void) const
    {
        return ExplicitOps::MinFilter(
            this->target
        );
    }


    const BoundObjOps& MinFilter(
        TextureMinFilter filter
    ) const
    {
        ExplicitOps::MinFilter(
            this->target,
            filter
        );
        return *this;
    }


    GLfloat MinLOD(void) const
    {
        return ExplicitOps::MinLOD(
            this->target
        );
    }


    const BoundObjOps& MinLOD(
        GLfloat value
    ) const
    {
        ExplicitOps::MinLOD(
            this->target,
            value
        );
        return *this;
    }


    GLfloat MaxLOD(void) const
    {
        return ExplicitOps::MaxLOD(
            this->target
        );
    }


    const BoundObjOps& MaxLOD(
        GLfloat value
    ) const
    {
        ExplicitOps::MaxLOD(
            this->target,
            value
        );
        return *this;
    }


    GLint MaxLevel(void) const
    {
        return ExplicitOps::MaxLevel(
            this->target
        );
    }


    const BoundObjOps& MaxLevel(
        GLint value
    ) const
    {
        ExplicitOps::MaxLevel(
            this->target,
            value
        );
        return *this;
    }


    GLfloat MaxAnisotropy(void) const
    {
        return ExplicitOps::MaxAnisotropy(
            this->target
        );
    }


    GLfloat Anisotropy(void) const
    {
        return ExplicitOps::Anisotropy(
            this->target
        );
    }


    const BoundObjOps& Anisotropy(
        GLfloat value
    ) const
    {
        ExplicitOps::Anisotropy(
            this->target,
            value
        );
        return *this;
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_3 || GL_ARB_texture_swizzle

    TextureSwizzle Swizzle(
        TextureSwizzleCoord coord
    ) const
    {
        return ExplicitOps::Swizzle(
            this->target,
            coord
        );
    }
#endif // GL_VERSION_3_3 GL_ARB_texture_swizzle

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_3 || GL_ARB_texture_swizzle

    const BoundObjOps& Swizzle(
        TextureSwizzleCoord coord,
        TextureSwizzle mode
    ) const
    {
        ExplicitOps::Swizzle(
            this->target,
            coord,
            mode
        );
        return *this;
    }
#endif // GL_VERSION_3_3 GL_ARB_texture_swizzle

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_3 || GL_ARB_texture_swizzle

    TextureSwizzle SwizzleR(void) const
    {
        return ExplicitOps::SwizzleR(
            this->target
        );
    }
#endif // GL_VERSION_3_3 GL_ARB_texture_swizzle

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_3 || GL_ARB_texture_swizzle

    const BoundObjOps& SwizzleR(
        TextureSwizzle mode
    ) const
    {
        ExplicitOps::SwizzleR(
            this->target,
            mode
        );
        return *this;
    }
#endif // GL_VERSION_3_3 GL_ARB_texture_swizzle

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_3 || GL_ARB_texture_swizzle

    TextureSwizzle SwizzleG(void) const
    {
        return ExplicitOps::SwizzleG(
            this->target
        );
    }
#endif // GL_VERSION_3_3 GL_ARB_texture_swizzle

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_3 || GL_ARB_texture_swizzle

    const BoundObjOps& SwizzleG(
        TextureSwizzle mode
    ) const
    {
        ExplicitOps::SwizzleG(
            this->target,
            mode
        );
        return *this;
    }
#endif // GL_VERSION_3_3 GL_ARB_texture_swizzle

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_3 || GL_ARB_texture_swizzle

    TextureSwizzle SwizzleB(void) const
    {
        return ExplicitOps::SwizzleB(
            this->target
        );
    }
#endif // GL_VERSION_3_3 GL_ARB_texture_swizzle

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_3 || GL_ARB_texture_swizzle

    const BoundObjOps& SwizzleB(
        TextureSwizzle mode
    ) const
    {
        ExplicitOps::SwizzleB(
            this->target,
            mode
        );
        return *this;
    }
#endif // GL_VERSION_3_3 GL_ARB_texture_swizzle

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_3 || GL_ARB_texture_swizzle

    TextureSwizzle SwizzleA(void) const
    {
        return ExplicitOps::SwizzleA(
            this->target
        );
    }
#endif // GL_VERSION_3_3 GL_ARB_texture_swizzle

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_3 || GL_ARB_texture_swizzle

    const BoundObjOps& SwizzleA(
        TextureSwizzle mode
    ) const
    {
        ExplicitOps::SwizzleA(
            this->target,
            mode
        );
        return *this;
    }
#endif // GL_VERSION_3_3 GL_ARB_texture_swizzle

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_3 || GL_ARB_texture_swizzle

    TextureSwizzleTuple SwizzleRGBA(void) const
    {
        return ExplicitOps::SwizzleRGBA(
            this->target
        );
    }
#endif // GL_VERSION_3_3 GL_ARB_texture_swizzle

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_3 || GL_ARB_texture_swizzle

    const BoundObjOps& SwizzleRGBA(
        TextureSwizzle mode
    ) const
    {
        ExplicitOps::SwizzleRGBA(
            this->target,
            mode
        );
        return *this;
    }
#endif // GL_VERSION_3_3 GL_ARB_texture_swizzle

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_3 || GL_ARB_texture_swizzle

    const BoundObjOps& SwizzleRGBA(
        TextureSwizzle mode_r,
        TextureSwizzle mode_g,
        TextureSwizzle mode_b,
        TextureSwizzle mode_a
    ) const
    {
        ExplicitOps::SwizzleRGBA(
            this->target,
            mode_r,
            mode_g,
            mode_b,
            mode_a
        );
        return *this;
    }
#endif // GL_VERSION_3_3 GL_ARB_texture_swizzle

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_3 || GL_ARB_texture_swizzle

    const BoundObjOps& SwizzleRGBA(
        const TextureSwizzleTuple & modes
    ) const
    {
        ExplicitOps::SwizzleRGBA(
            this->target,
            modes
        );
        return *this;
    }
#endif // GL_VERSION_3_3 GL_ARB_texture_swizzle


    TextureWrap Wrap(
        TextureWrapCoord coord
    ) const
    {
        return ExplicitOps::Wrap(
            this->target,
            coord
        );
    }


    const BoundObjOps& Wrap(
        TextureWrapCoord coord,
        TextureWrap mode
    ) const
    {
        ExplicitOps::Wrap(
            this->target,
            coord,
            mode
        );
        return *this;
    }


    TextureWrap WrapS(void) const
    {
        return ExplicitOps::WrapS(
            this->target
        );
    }


    const BoundObjOps& WrapS(
        TextureWrap mode
    ) const
    {
        ExplicitOps::WrapS(
            this->target,
            mode
        );
        return *this;
    }


    TextureWrap WrapT(void) const
    {
        return ExplicitOps::WrapT(
            this->target
        );
    }


    const BoundObjOps& WrapT(
        TextureWrap mode
    ) const
    {
        ExplicitOps::WrapT(
            this->target,
            mode
        );
        return *this;
    }


    TextureWrap WrapR(void) const
    {
        return ExplicitOps::WrapR(
            this->target
        );
    }


    const BoundObjOps& WrapR(
        TextureWrap mode
    ) const
    {
        ExplicitOps::WrapR(
            this->target,
            mode
        );
        return *this;
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_3

    PixelDataFormat DepthStencilMode(void) const
    {
        return ExplicitOps::DepthStencilMode(
            this->target
        );
    }
#endif // GL_VERSION_4_3

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_3

    const BoundObjOps& DepthStencilMode(
        PixelDataFormat mode
    ) const
    {
        ExplicitOps::DepthStencilMode(
            this->target,
            mode
        );
        return *this;
    }
#endif // GL_VERSION_4_3

#if OGLPLUS_DOCUMENTATION_ONLY || GL_ARB_seamless_cubemap_per_texture

    bool Seamless(void) const
    {
        return ExplicitOps::Seamless(
            this->target
        );
    }
#endif // GL_ARB_seamless_cubemap_per_texture

#if OGLPLUS_DOCUMENTATION_ONLY || GL_ARB_seamless_cubemap_per_texture

    const BoundObjOps& Seamless(
        bool enable
    ) const
    {
        ExplicitOps::Seamless(
            this->target,
            enable
        );
        return *this;
    }
#endif // GL_ARB_seamless_cubemap_per_texture


    const BoundObjOps& GenerateMipmap(void) const
    {
        ExplicitOps::GenerateMipmap(
            this->target
        );
        return *this;
    }


}; // class BoundObjOps

} // namespace oglplus

#endif // include guard