texture_swizzle.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_TEXTURE_SWIZZLE_1107121519_HPP
#define OGLPLUS_TEXTURE_SWIZZLE_1107121519_HPP

#include <oglplus/fwd.hpp>
#include <oglplus/enumerations.hpp>

namespace oglplus {


OGLPLUS_ENUM_CLASS_BEGIN(TextureSwizzleCoord, GLenum)
#include <oglplus/enums/texture_swizzle_coord.ipp>
OGLPLUS_ENUM_CLASS_END(TextureSwizzleCoord)

#if !OGLPLUS_NO_ENUM_VALUE_NAMES
#include <oglplus/enums/texture_swizzle_coord_names.ipp>
#endif

#if !OGLPLUS_ENUM_VALUE_RANGES
#include <oglplus/enums/texture_swizzle_coord_range.ipp>
#endif


OGLPLUS_ENUM_CLASS_BEGIN(TextureSwizzle, GLenum)
#include <oglplus/enums/texture_swizzle.ipp>
OGLPLUS_ENUM_CLASS_END(TextureSwizzle)

#if !OGLPLUS_NO_ENUM_VALUE_NAMES
#include <oglplus/enums/texture_swizzle_names.ipp>
#endif

#if !OGLPLUS_ENUM_VALUE_RANGES
#include <oglplus/enums/texture_swizzle_range.ipp>
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_3 || GL_ARB_texture_swizzle
class TextureSwizzleTuple
{
private:
    GLint _values[4];
public:
    const GLint* Values(void) const
    {
        return _values;
    }

    GLint* Values(void)
    {
        return _values;
    }

    TextureSwizzleTuple(void)
    {
        _values[0] = GL_RED;
        _values[1] = GL_GREEN;
        _values[2] = GL_BLUE;
        _values[3] = GL_ALPHA;
    }

    TextureSwizzleTuple(
        TextureSwizzle mode_r,
        TextureSwizzle mode_g,
        TextureSwizzle mode_b,
        TextureSwizzle mode_a
    )
    {
        _values[0] = GLint(GLenum(mode_r));
        _values[1] = GLint(GLenum(mode_g));
        _values[2] = GLint(GLenum(mode_b));
        _values[3] = GLint(GLenum(mode_a));
    }

    TextureSwizzleTuple& SwizzleR(TextureSwizzle mode)
    {
        _values[0] = GLint(GLenum(mode));
        return *this;
    }

    TextureSwizzle SwizzleR(void) const
    {
        return TextureSwizzle(_values[0]);
    }

    TextureSwizzleTuple& Red(TextureSwizzle mode)
    {
        return SwizzleR(mode);
    }

    TextureSwizzle Red(void) const
    {
        return SwizzleR();
    }

    TextureSwizzleTuple& SwizzleG(TextureSwizzle mode)
    {
        _values[1] = GLint(GLenum(mode));
        return *this;
    }

    TextureSwizzle SwizzleG(void) const
    {
        return TextureSwizzle(_values[1]);
    }

    TextureSwizzleTuple& Green(TextureSwizzle mode)
    {
        return SwizzleG(mode);
    }

    TextureSwizzle Green(void) const
    {
        return SwizzleG();
    }

    TextureSwizzleTuple& SwizzleB(TextureSwizzle mode)
    {
        _values[2] = GLint(GLenum(mode));
        return *this;
    }

    TextureSwizzle SwizzleB(void) const
    {
        return TextureSwizzle(_values[2]);
    }

    TextureSwizzleTuple& Blue(TextureSwizzle mode)
    {
        return SwizzleB(mode);
    }

    TextureSwizzle Blue(void) const
    {
        return SwizzleB();
    }

    TextureSwizzleTuple& SwizzleA(TextureSwizzle mode)
    {
        _values[3] = GLint(GLenum(mode));
        return *this;
    }

    TextureSwizzle SwizzleA(void) const
    {
        return TextureSwizzle(_values[3]);
    }

    TextureSwizzleTuple& Alpha(TextureSwizzle mode)
    {
        return SwizzleA(mode);
    }

    TextureSwizzle Alpha(void) const
    {
        return SwizzleA();
    }

    TextureSwizzleTuple& Swizzle(
        TextureSwizzleCoord coord,
        TextureSwizzle mode
    )
    {
        switch(GLenum(coord))
        {
            case GL_TEXTURE_SWIZZLE_R:
                SwizzleR(mode);
                break;
            case GL_TEXTURE_SWIZZLE_G:
                SwizzleG(mode);
                break;
            case GL_TEXTURE_SWIZZLE_B:
                SwizzleB(mode);
                break;
            case GL_TEXTURE_SWIZZLE_A:
                SwizzleA(mode);
                break;
        }
        return *this;
    }

    TextureSwizzle Swizzle(TextureSwizzleCoord coord) const
    {
        switch(GLenum(coord))
        {
            case GL_TEXTURE_SWIZZLE_R:
                return SwizzleR();
            case GL_TEXTURE_SWIZZLE_G:
                return SwizzleG();
            case GL_TEXTURE_SWIZZLE_B:
                return SwizzleB();
            case GL_TEXTURE_SWIZZLE_A:
                return SwizzleA();
        }
        return TextureSwizzle();
    }
};
#endif

} // namespace oglplus

#endif // include guard