mirror/glm
1
0
Fork 0
mirror of https://github.com/g-truc/glm.git synced 2024-11-22 08:54:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Updated GLI for tests

Browse Source
This commit is contained in:
Christophe Riccio 2017-01-02 20:52:57 +01:00
parent 7839b862e8
commit 71a519387e
22 changed files with 366 additions and 365 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
test/external/gli/clear.hpp vendored
View File

@ -40,7 +40,6 @@ namespace gli
// Clear multiple layers of a texture
template <typename texture_type, typename gen_type>
void clear_layer(texture_type& Texture, size_t BaseLayer, size_t LayerCount, gen_type const& BlockData);
}//namespace gli
#include "./core/clear.inl"

1
test/external/gli/convert.hpp vendored
View File

@ -19,7 +19,6 @@ namespace gli
/// @param Format Destination Texture format, it must be uncompressed.
template <typename texture_type>
texture_type convert(texture_type const& Texture, format Format);
}//namespace gli
#include "./core/convert.inl"

2
test/external/gli/core/clear.hpp vendored
View File

@ -8,7 +8,7 @@ namespace detail
template <typename textureType, typename T, precision P>
struct clear
{
static void call(textureType & Texture, typename convert<textureType, T, P>::writeFunc Write, tvec4<T, P> const & Color)
static void call(textureType & Texture, typename convert<textureType, T, P>::writeFunc Write, vec<4, T, P> const& Color)
{
GLI_ASSERT(Write);

520
test/external/gli/core/convert_func.hpp vendored
View File

@ -157,24 +157,24 @@ namespace detail
// convertFunc class
template <typename textureType, typename retType, int D, typename T, precision P, template <int, typename, precision> class vecType, convertMode mode = CONVERT_MODE_CAST, bool isSamplerFloat = false>
template <typename textureType, typename retType, length_t L, typename T, precision P, convertMode mode = CONVERT_MODE_CAST, bool isSamplerFloat = false>
struct convertFunc
{
typedef accessFunc<textureType, vecType<D, T, P> > access;
typedef accessFunc<textureType, vec<L, T, P> > access;
static vec<4, retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
{
return make_vec4<retType, P>(vecType<D, retType, P>(access::load(Texture, TexelCoord, Layer, Face, Level)));
return make_vec4<retType, P>(vec<L, retType, P>(access::load(Texture, TexelCoord, Layer, Face, Level)));
}
static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, vec<4, retType, P> const & Texel)
{
access::store(Texture, TexelCoord, Layer, Face, Level, vecType<D, T, P>(Texel));
access::store(Texture, TexelCoord, Layer, Face, Level, vec<L, T, P>(Texel));
}
};
template <typename textureType, typename retType, int D, typename T, precision P, template <int, typename, precision> class vecType, bool isSamplerFloat>
struct convertFunc<textureType, retType, D, T, P, vecType, CONVERT_MODE_DEFAULT, isSamplerFloat>
template <typename textureType, typename retType, length_t L, typename T, precision P, bool isSamplerFloat>
struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_DEFAULT, isSamplerFloat>
{
static vec<4, retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
{
@ -185,10 +185,10 @@ namespace detail
{}
};
template <typename textureType, typename retType, int D, typename T, precision P, template <int, typename, precision> class vecType>
struct convertFunc<textureType, retType, D, T, P, vecType, CONVERT_MODE_NORM, true>
template <typename textureType, typename retType, length_t L, typename T, precision P>
struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_NORM, true>
{
typedef accessFunc<textureType, vecType<D, T, P> > access;
typedef accessFunc<textureType, vec<L, T, P> > access;
static vec<4, retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
{
@ -199,14 +199,14 @@ namespace detail
static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, vec<4, retType, P> const & Texel)
{
static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_NORM requires a float sampler");
access::store(Texture, TexelCoord, Layer, Face, Level, compScale<T>(vecType<D, retType, P>(Texel)));
access::store(Texture, TexelCoord, Layer, Face, Level, compScale<T>(vec<L, retType, P>(Texel)));
}
};
template <typename textureType, typename retType, int D, typename T, precision P, template <int, typename, precision> class vecType>
struct convertFunc<textureType, retType, D, T, P, vecType, CONVERT_MODE_SRGB, true>
template <typename textureType, typename retType, length_t L, typename T, precision P>
struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_SRGB, true>
{
typedef accessFunc<textureType, vecType<D, T, P> > access;
typedef accessFunc<textureType, vec<L, T, P> > access;
static vec<4, retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
{
@ -217,12 +217,12 @@ namespace detail
static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, vec<4, retType, P> const & Texel)
{
static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_SRGB requires a float sampler");
access::store(Texture, TexelCoord, Layer, Face, Level, gli::compScale<T>(convertLinearToSRGB(vecType<D, retType, P>(Texel))));
access::store(Texture, TexelCoord, Layer, Face, Level, gli::compScale<T>(convertLinearToSRGB(vec<L, retType, P>(Texel))));
}
};
template <typename textureType, typename retType, int D, typename T, precision P, template <int, typename, precision> class vecType>
struct convertFunc<textureType, retType, D, T, P, vecType, CONVERT_MODE_RGB9E5, true>
template <typename textureType, typename retType, length_t L, typename T, precision P>
struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_RGB9E5, true>
{
typedef accessFunc<textureType, uint32> access;
@ -235,12 +235,12 @@ namespace detail
static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, vec<4, retType, P> const & Texel)
{
static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_RGB9E5 requires a float sampler");
access::store(Texture, TexelCoord, Layer, Face, Level, packF3x9_E1x5(tvec3<float, P>(Texel)));
access::store(Texture, TexelCoord, Layer, Face, Level, packF3x9_E1x5(vec<3, float, P>(Texel)));
}
};
template <typename textureType, typename retType, int D, typename T, precision P, template <int, typename, precision> class vecType>
struct convertFunc<textureType, retType, D, T, P, vecType, CONVERT_MODE_RG11B10F, true>
template <typename textureType, typename retType, length_t L, typename T, precision P>
struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_RG11B10F, true>
{
typedef accessFunc<textureType, uint32> access;
@ -253,30 +253,30 @@ namespace detail
static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, vec<4, retType, P> const & Texel)
{
static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_RG11B10F requires a float sampler");
access::store(Texture, TexelCoord, Layer, Face, Level, packF2x11_1x10(tvec3<float, P>(Texel)));
access::store(Texture, TexelCoord, Layer, Face, Level, packF2x11_1x10(vec<3, float, P>(Texel)));
}
};
template <typename textureType, typename retType, int D, typename T, precision P, template <int, typename, precision> class vecType>
struct convertFunc<textureType, retType, D, T, P, vecType, CONVERT_MODE_HALF, true>
template <typename textureType, typename retType, length_t L, typename T, precision P>
struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_HALF, true>
{
typedef accessFunc<textureType, vecType<D, uint16, P> > access;
typedef accessFunc<textureType, vec<L, uint16, P> > access;
static vec<4, retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
{
static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_HALF requires a float sampler");
return make_vec4<retType, P>(vecType<D, retType, P>(unpackHalf(access::load(Texture, TexelCoord, Layer, Face, Level))));
return make_vec4<retType, P>(vec<L, retType, P>(unpackHalf(access::load(Texture, TexelCoord, Layer, Face, Level))));
}
static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, vec<4, retType, P> const & Texel)
{
static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_HALF requires a float sampler");
access::store(Texture, TexelCoord, Layer, Face, Level, packHalf(vecType<D, float, P>(Texel)));
access::store(Texture, TexelCoord, Layer, Face, Level, packHalf(vec<L, float, P>(Texel)));
}
};
template <typename textureType, typename retType, int D, typename T, precision P, template <int, typename, precision> class vecType>
struct convertFunc<textureType, retType, D, T, P, vecType, CONVERT_MODE_44UNORM, true>
template <typename textureType, typename retType, length_t L, typename T, precision P>
struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_44UNORM, true>
{
typedef accessFunc<textureType, uint8> access;
@ -293,8 +293,8 @@ namespace detail
}
};
template <typename textureType, typename retType, int D, typename T, precision P, template <int, typename, precision> class vecType>
struct convertFunc<textureType, retType, D, T, P, vecType, CONVERT_MODE_4444UNORM, true>
template <typename textureType, typename retType, length_t L, typename T, precision P>
struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_4444UNORM, true>
{
typedef accessFunc<textureType, uint16> access;
@ -311,8 +311,8 @@ namespace detail
}
};
template <typename textureType, typename retType, int D, typename T, precision P, template <int, typename, precision> class vecType>
struct convertFunc<textureType, retType, D, T, P, vecType, CONVERT_MODE_565UNORM, true>
template <typename textureType, typename retType, length_t L, typename T, precision P>
struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_565UNORM, true>
{
typedef accessFunc<textureType, uint16> access;
@ -329,8 +329,8 @@ namespace detail
}
};
template <typename textureType, typename retType, int D, typename T, precision P, template <int, typename, precision> class vecType>
struct convertFunc<textureType, retType, D, T, P, vecType, CONVERT_MODE_5551UNORM, true>
template <typename textureType, typename retType, length_t L, typename T, precision P>
struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_5551UNORM, true>
{
typedef accessFunc<textureType, uint16> access;
@ -347,8 +347,8 @@ namespace detail
}
};
template <typename textureType, typename retType, int D, typename T, precision P, template <int, typename, precision> class vecType>
struct convertFunc<textureType, retType, D, T, P, vecType, CONVERT_MODE_332UNORM, true>
template <typename textureType, typename retType, length_t L, typename T, precision P>
struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_332UNORM, true>
{
typedef accessFunc<textureType, uint8> access;
@ -365,8 +365,8 @@ namespace detail
}
};
template <typename textureType, typename retType, int D, typename T, precision P, template <int, typename, precision> class vecType>
struct convertFunc<textureType, retType, D, T, P, vecType, CONVERT_MODE_RGB10A2UNORM, true>
template <typename textureType, typename retType, length_t L, typename T, precision P>
struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_RGB10A2UNORM, true>
{
typedef accessFunc<textureType, uint32> access;
@ -383,8 +383,8 @@ namespace detail
}
};
template <typename textureType, typename retType, int D, typename T, precision P, template <int, typename, precision> class vecType>
struct convertFunc<textureType, retType, D, T, P, vecType, CONVERT_MODE_RGB10A2SNORM, true>
template <typename textureType, typename retType, length_t L, typename T, precision P>
struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_RGB10A2SNORM, true>
{
typedef accessFunc<textureType, uint32> access;
@ -401,8 +401,8 @@ namespace detail
}
};
template <typename textureType, typename retType, int D, typename T, precision P, template <int, typename, precision> class vecType>
struct convertFunc<textureType, retType, D, T, P, vecType, CONVERT_MODE_RGB10A2USCALE, true>
template <typename textureType, typename retType, length_t L, typename T, precision P>
struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_RGB10A2USCALE, true>
{
typedef accessFunc<textureType, uint32> access;
@ -426,8 +426,8 @@ namespace detail
}
};
template <typename textureType, typename retType, int D, typename T, precision P, template <int, typename, precision> class vecType>
struct convertFunc<textureType, retType, D, T, P, vecType, CONVERT_MODE_RGB10A2SSCALE, true>
template <typename textureType, typename retType, length_t L, typename T, precision P>
struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_RGB10A2SSCALE, true>
{
typedef accessFunc<textureType, uint32> access;
@ -451,8 +451,8 @@ namespace detail
}
};
template <typename textureType, typename retType, int D, typename T, precision P, template <int, typename, precision> class vecType>
struct convertFunc<textureType, retType, D, T, P, vecType, CONVERT_MODE_RGB10A2UINT, false>
template <typename textureType, typename retType, length_t L, typename T, precision P>
struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_RGB10A2UINT, false>
{
typedef accessFunc<textureType, uint32> access;
@ -469,8 +469,8 @@ namespace detail
}
};
template <typename textureType, typename retType, int D, typename T, precision P, template <int, typename, precision> class vecType>
struct convertFunc<textureType, retType, D, T, P, vecType, CONVERT_MODE_RGB10A2SINT, false>
template <typename textureType, typename retType, length_t L, typename T, precision P>
struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_RGB10A2SINT, false>
{
typedef accessFunc<textureType, uint32> access;
@ -490,20 +490,20 @@ namespace detail
template <typename textureType, typename samplerValType, precision P>
struct convert
{
typedef glm::tvec4<samplerValType, P>(*fetchFunc)(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level);
typedef vec<4, samplerValType, P>(*fetchFunc)(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level);
typedef void(*writeFunc)(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, vec<4, samplerValType, P> const & Texel);
template <int D, typename T, template <int, typename, precision> class vecType, convertMode mode>
template <length_t L, typename T, convertMode mode>
struct conv
{
static vec<4, samplerValType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
{
return convertFunc<textureType, samplerValType, D, T, P, vecType, mode, std::numeric_limits<samplerValType>::is_iec559>::fetch(Texture, TexelCoord, Layer, Face, Level);
return convertFunc<textureType, samplerValType, L, T, P, mode, std::numeric_limits<samplerValType>::is_iec559>::fetch(Texture, TexelCoord, Layer, Face, Level);
}
static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, vec<4, samplerValType, P> const & Texel)
{
convertFunc<textureType, samplerValType, D, T, P, vecType, mode, std::numeric_limits<samplerValType>::is_iec559>::write(Texture, TexelCoord, Layer, Face, Level, Texel);
convertFunc<textureType, samplerValType, L, T, P, mode, std::numeric_limits<samplerValType>::is_iec559>::write(Texture, TexelCoord, Layer, Face, Level, Texel);
}
};
@ -517,246 +517,246 @@ namespace detail
{
static func Table[] =
{
{conv<2, u8, tvec, CONVERT_MODE_44UNORM>::fetch, conv<2, u8, tvec, CONVERT_MODE_44UNORM>::write}, // FORMAT_RG4_UNORM
{conv<4, u8, tvec, CONVERT_MODE_4444UNORM>::fetch, conv<4, u8, tvec, CONVERT_MODE_4444UNORM>::write}, // FORMAT_RGBA4_UNORM
{conv<4, u8, tvec, CONVERT_MODE_4444UNORM>::fetch, conv<4, u8, tvec, CONVERT_MODE_4444UNORM>::write}, // FORMAT_BGRA4_UNORM
{conv<3, u8, tvec, CONVERT_MODE_565UNORM>::fetch, conv<3, u8, tvec, CONVERT_MODE_565UNORM>::write}, // FORMAT_R5G6B5_UNORM
{conv<3, u8, tvec, CONVERT_MODE_565UNORM>::fetch, conv<3, u8, tvec, CONVERT_MODE_565UNORM>::write}, // FORMAT_B5G6R5_UNORM
{conv<4, u8, tvec, CONVERT_MODE_5551UNORM>::fetch, conv<4, u8, tvec, CONVERT_MODE_5551UNORM>::write}, // FORMAT_RGB5A1_UNORM
{conv<4, u8, tvec, CONVERT_MODE_5551UNORM>::fetch, conv<4, u8, tvec, CONVERT_MODE_5551UNORM>::write}, // FORMAT_BGR5A1_UNORM
{conv<4, u8, tvec, CONVERT_MODE_5551UNORM>::fetch, conv<4, u8, tvec, CONVERT_MODE_5551UNORM>::write}, // FORMAT_A1RGB5_UNORM
{conv<2, u8, CONVERT_MODE_44UNORM>::fetch, conv<2, u8, CONVERT_MODE_44UNORM>::write}, // FORMAT_RG4_UNORM
{conv<4, u8, CONVERT_MODE_4444UNORM>::fetch, conv<4, u8, CONVERT_MODE_4444UNORM>::write}, // FORMAT_RGBA4_UNORM
{conv<4, u8, CONVERT_MODE_4444UNORM>::fetch, conv<4, u8, CONVERT_MODE_4444UNORM>::write}, // FORMAT_BGRA4_UNORM
{conv<3, u8, CONVERT_MODE_565UNORM>::fetch, conv<3, u8, CONVERT_MODE_565UNORM>::write}, // FORMAT_R5G6B5_UNORM
{conv<3, u8, CONVERT_MODE_565UNORM>::fetch, conv<3, u8, CONVERT_MODE_565UNORM>::write}, // FORMAT_B5G6R5_UNORM
{conv<4, u8, CONVERT_MODE_5551UNORM>::fetch, conv<4, u8, CONVERT_MODE_5551UNORM>::write}, // FORMAT_RGB5A1_UNORM
{conv<4, u8, CONVERT_MODE_5551UNORM>::fetch, conv<4, u8, CONVERT_MODE_5551UNORM>::write}, // FORMAT_BGR5A1_UNORM
{conv<4, u8, CONVERT_MODE_5551UNORM>::fetch, conv<4, u8, CONVERT_MODE_5551UNORM>::write}, // FORMAT_A1RGB5_UNORM
{conv<1, u8, tvec, CONVERT_MODE_NORM>::fetch, conv<1, u8, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_R8_UNORM
{conv<1, i8, tvec, CONVERT_MODE_NORM>::fetch, conv<1, i8, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_R8_SNORM
{conv<1, u8, tvec, CONVERT_MODE_CAST>::fetch, conv<1, u8, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_R8_USCALED
{conv<1, i8, tvec, CONVERT_MODE_CAST>::fetch, conv<1, i8, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_R8_SSCALED
{conv<1, u8, tvec, CONVERT_MODE_CAST>::fetch, conv<1, u8, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_R8_UINT
{conv<1, i8, tvec, CONVERT_MODE_CAST>::fetch, conv<1, i8, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_R8_SINT
{conv<1, u8, tvec, CONVERT_MODE_SRGB>::fetch, conv<1, u8, tvec, CONVERT_MODE_SRGB>::write}, // FORMAT_R8_SRGB
{conv<1, u8, CONVERT_MODE_NORM>::fetch, conv<1, u8, CONVERT_MODE_NORM>::write}, // FORMAT_R8_UNORM
{conv<1, i8, CONVERT_MODE_NORM>::fetch, conv<1, i8, CONVERT_MODE_NORM>::write}, // FORMAT_R8_SNORM
{conv<1, u8, CONVERT_MODE_CAST>::fetch, conv<1, u8, CONVERT_MODE_CAST>::write}, // FORMAT_R8_USCALED
{conv<1, i8, CONVERT_MODE_CAST>::fetch, conv<1, i8, CONVERT_MODE_CAST>::write}, // FORMAT_R8_SSCALED
{conv<1, u8, CONVERT_MODE_CAST>::fetch, conv<1, u8, CONVERT_MODE_CAST>::write}, // FORMAT_R8_UINT
{conv<1, i8, CONVERT_MODE_CAST>::fetch, conv<1, i8, CONVERT_MODE_CAST>::write}, // FORMAT_R8_SINT
{conv<1, u8, CONVERT_MODE_SRGB>::fetch, conv<1, u8, CONVERT_MODE_SRGB>::write}, // FORMAT_R8_SRGB
{conv<2, u8, tvec, CONVERT_MODE_NORM>::fetch, conv<2, u8, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_RG8_UNORM
{conv<2, i8, tvec, CONVERT_MODE_NORM>::fetch, conv<2, i8, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_RG8_SNORM
{conv<2, u8, tvec, CONVERT_MODE_CAST>::fetch, conv<2, u8, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RG8_USCALED
{conv<2, i8, tvec, CONVERT_MODE_CAST>::fetch, conv<2, i8, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RG8_SSCALED
{conv<2, u8, tvec, CONVERT_MODE_CAST>::fetch, conv<2, u8, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RG8_UINT
{conv<2, i8, tvec, CONVERT_MODE_CAST>::fetch, conv<2, i8, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RG8_SINT
{conv<2, u8, tvec, CONVERT_MODE_SRGB>::fetch, conv<2, u8, tvec, CONVERT_MODE_SRGB>::write}, // FORMAT_RG8_SRGB
{conv<2, u8, CONVERT_MODE_NORM>::fetch, conv<2, u8, CONVERT_MODE_NORM>::write}, // FORMAT_RG8_UNORM
{conv<2, i8, CONVERT_MODE_NORM>::fetch, conv<2, i8, CONVERT_MODE_NORM>::write}, // FORMAT_RG8_SNORM
{conv<2, u8, CONVERT_MODE_CAST>::fetch, conv<2, u8, CONVERT_MODE_CAST>::write}, // FORMAT_RG8_USCALED
{conv<2, i8, CONVERT_MODE_CAST>::fetch, conv<2, i8, CONVERT_MODE_CAST>::write}, // FORMAT_RG8_SSCALED
{conv<2, u8, CONVERT_MODE_CAST>::fetch, conv<2, u8, CONVERT_MODE_CAST>::write}, // FORMAT_RG8_UINT
{conv<2, i8, CONVERT_MODE_CAST>::fetch, conv<2, i8, CONVERT_MODE_CAST>::write}, // FORMAT_RG8_SINT
{conv<2, u8, CONVERT_MODE_SRGB>::fetch, conv<2, u8, CONVERT_MODE_SRGB>::write}, // FORMAT_RG8_SRGB
{conv<3, u8, tvec, CONVERT_MODE_NORM>::fetch, conv<3, u8, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_RGB8_UNORM
{conv<3, i8, tvec, CONVERT_MODE_NORM>::fetch, conv<3, i8, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_RGB8_SNORM
{conv<3, u8, tvec, CONVERT_MODE_CAST>::fetch, conv<3, u8, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RGB8_USCALED
{conv<3, i8, tvec, CONVERT_MODE_CAST>::fetch, conv<3, i8, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RGB8_SSCALED
{conv<3, u8, tvec, CONVERT_MODE_CAST>::fetch, conv<3, u8, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RGB8_UINT
{conv<3, i8, tvec, CONVERT_MODE_CAST>::fetch, conv<3, i8, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RGB8_SINT
{conv<3, u8, tvec, CONVERT_MODE_SRGB>::fetch, conv<3, u8, tvec, CONVERT_MODE_SRGB>::write}, // FORMAT_RGB8_SRGB
{conv<3, u8, CONVERT_MODE_NORM>::fetch, conv<3, u8, CONVERT_MODE_NORM>::write}, // FORMAT_RGB8_UNORM
{conv<3, i8, CONVERT_MODE_NORM>::fetch, conv<3, i8, CONVERT_MODE_NORM>::write}, // FORMAT_RGB8_SNORM
{conv<3, u8, CONVERT_MODE_CAST>::fetch, conv<3, u8, CONVERT_MODE_CAST>::write}, // FORMAT_RGB8_USCALED
{conv<3, i8, CONVERT_MODE_CAST>::fetch, conv<3, i8, CONVERT_MODE_CAST>::write}, // FORMAT_RGB8_SSCALED
{conv<3, u8, CONVERT_MODE_CAST>::fetch, conv<3, u8, CONVERT_MODE_CAST>::write}, // FORMAT_RGB8_UINT
{conv<3, i8, CONVERT_MODE_CAST>::fetch, conv<3, i8, CONVERT_MODE_CAST>::write}, // FORMAT_RGB8_SINT
{conv<3, u8, CONVERT_MODE_SRGB>::fetch, conv<3, u8, CONVERT_MODE_SRGB>::write}, // FORMAT_RGB8_SRGB
{conv<3, u8, tvec, CONVERT_MODE_NORM>::fetch, conv<3, u8, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_BGR8_UNORM
{conv<3, i8, tvec, CONVERT_MODE_NORM>::fetch, conv<3, i8, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_BGR8_SNORM
{conv<3, u8, tvec, CONVERT_MODE_CAST>::fetch, conv<3, u8, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_BGR8_USCALED
{conv<3, i8, tvec, CONVERT_MODE_CAST>::fetch, conv<3, i8, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_BGR8_SSCALED
{conv<3, u32, tvec, CONVERT_MODE_CAST>::fetch, conv<3, u32, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_BGR8_UINT
{conv<3, i32, tvec, CONVERT_MODE_CAST>::fetch, conv<3, i32, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_BGR8_SINT
{conv<3, u8, tvec, CONVERT_MODE_SRGB>::fetch, conv<3, u8, tvec, CONVERT_MODE_SRGB>::write}, // FORMAT_BGR8_SRGB
{conv<3, u8, CONVERT_MODE_NORM>::fetch, conv<3, u8, CONVERT_MODE_NORM>::write}, // FORMAT_BGR8_UNORM
{conv<3, i8, CONVERT_MODE_NORM>::fetch, conv<3, i8, CONVERT_MODE_NORM>::write}, // FORMAT_BGR8_SNORM
{conv<3, u8, CONVERT_MODE_CAST>::fetch, conv<3, u8, CONVERT_MODE_CAST>::write}, // FORMAT_BGR8_USCALED
{conv<3, i8, CONVERT_MODE_CAST>::fetch, conv<3, i8, CONVERT_MODE_CAST>::write}, // FORMAT_BGR8_SSCALED
{conv<3, u32, CONVERT_MODE_CAST>::fetch, conv<3, u32, CONVERT_MODE_CAST>::write}, // FORMAT_BGR8_UINT
{conv<3, i32, CONVERT_MODE_CAST>::fetch, conv<3, i32, CONVERT_MODE_CAST>::write}, // FORMAT_BGR8_SINT
{conv<3, u8, CONVERT_MODE_SRGB>::fetch, conv<3, u8, CONVERT_MODE_SRGB>::write}, // FORMAT_BGR8_SRGB
{conv<4, u8, tvec, CONVERT_MODE_NORM>::fetch, conv<4, u8, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_RGBA8_UNORM
{conv<4, i8, tvec, CONVERT_MODE_NORM>::fetch, conv<4, i8, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_RGBA8_SNORM
{conv<4, u8, tvec, CONVERT_MODE_CAST>::fetch, conv<4, u8, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RGBA8_USCALED
{conv<4, i8, tvec, CONVERT_MODE_CAST>::fetch, conv<4, i8, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RGBA8_SSCALED
{conv<4, u8, tvec, CONVERT_MODE_CAST>::fetch, conv<4, u8, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RGBA8_UINT
{conv<4, i8, tvec, CONVERT_MODE_CAST>::fetch, conv<4, i8, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RGBA8_SINT
{conv<4, u8, tvec, CONVERT_MODE_SRGB>::fetch, conv<4, u8, tvec, CONVERT_MODE_SRGB>::write}, // FORMAT_RGBA8_SRGB
{conv<4, u8, CONVERT_MODE_NORM>::fetch, conv<4, u8, CONVERT_MODE_NORM>::write}, // FORMAT_RGBA8_UNORM
{conv<4, i8, CONVERT_MODE_NORM>::fetch, conv<4, i8, CONVERT_MODE_NORM>::write}, // FORMAT_RGBA8_SNORM
{conv<4, u8, CONVERT_MODE_CAST>::fetch, conv<4, u8, CONVERT_MODE_CAST>::write}, // FORMAT_RGBA8_USCALED
{conv<4, i8, CONVERT_MODE_CAST>::fetch, conv<4, i8, CONVERT_MODE_CAST>::write}, // FORMAT_RGBA8_SSCALED
{conv<4, u8, CONVERT_MODE_CAST>::fetch, conv<4, u8, CONVERT_MODE_CAST>::write}, // FORMAT_RGBA8_UINT
{conv<4, i8, CONVERT_MODE_CAST>::fetch, conv<4, i8, CONVERT_MODE_CAST>::write}, // FORMAT_RGBA8_SINT
{conv<4, u8, CONVERT_MODE_SRGB>::fetch, conv<4, u8, CONVERT_MODE_SRGB>::write}, // FORMAT_RGBA8_SRGB
{conv<4, u8, tvec, CONVERT_MODE_NORM>::fetch, conv<4, u8, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_BGRA8_UNORM
{conv<4, i8, tvec, CONVERT_MODE_NORM>::fetch, conv<4, i8, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_BGRA8_SNORM
{conv<4, u8, tvec, CONVERT_MODE_CAST>::fetch, conv<4, u8, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_BGRA8_USCALED
{conv<4, i8, tvec, CONVERT_MODE_CAST>::fetch, conv<4, i8, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_BGRA8_SSCALED
{conv<4, u8, tvec, CONVERT_MODE_CAST>::fetch, conv<4, u8, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_BGRA8_UINT
{conv<4, i8, tvec, CONVERT_MODE_CAST>::fetch, conv<4, i8, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_BGRA8_SINT
{conv<4, u8, tvec, CONVERT_MODE_SRGB>::fetch, conv<4, u8, tvec, CONVERT_MODE_SRGB>::write}, // FORMAT_BGRA8_SRGB
{conv<4, u8, CONVERT_MODE_NORM>::fetch, conv<4, u8, CONVERT_MODE_NORM>::write}, // FORMAT_BGRA8_UNORM
{conv<4, i8, CONVERT_MODE_NORM>::fetch, conv<4, i8, CONVERT_MODE_NORM>::write}, // FORMAT_BGRA8_SNORM
{conv<4, u8, CONVERT_MODE_CAST>::fetch, conv<4, u8, CONVERT_MODE_CAST>::write}, // FORMAT_BGRA8_USCALED
{conv<4, i8, CONVERT_MODE_CAST>::fetch, conv<4, i8, CONVERT_MODE_CAST>::write}, // FORMAT_BGRA8_SSCALED
{conv<4, u8, CONVERT_MODE_CAST>::fetch, conv<4, u8, CONVERT_MODE_CAST>::write}, // FORMAT_BGRA8_UINT
{conv<4, i8, CONVERT_MODE_CAST>::fetch, conv<4, i8, CONVERT_MODE_CAST>::write}, // FORMAT_BGRA8_SINT
{conv<4, u8, CONVERT_MODE_SRGB>::fetch, conv<4, u8, CONVERT_MODE_SRGB>::write}, // FORMAT_BGRA8_SRGB
{conv<4, u8, tvec, CONVERT_MODE_NORM>::fetch, conv<4, u8, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_ABGR8_UNORM
{conv<4, i8, tvec, CONVERT_MODE_NORM>::fetch, conv<4, i8, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_ABGR8_SNORM
{conv<4, u8, tvec, CONVERT_MODE_CAST>::fetch, conv<4, u8, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_ABGR8_USCALED
{conv<4, i8, tvec, CONVERT_MODE_CAST>::fetch, conv<4, i8, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_ABGR8_SSCALED
{conv<4, u8, tvec, CONVERT_MODE_CAST>::fetch, conv<4, u8, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_ABGR8_UINT
{conv<4, i8, tvec, CONVERT_MODE_CAST>::fetch, conv<4, i8, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_ABGR8_SINT
{conv<4, u8, tvec, CONVERT_MODE_SRGB>::fetch, conv<4, u8, tvec, CONVERT_MODE_SRGB>::write}, // FORMAT_ABGR8_SRGB
{conv<4, u8, CONVERT_MODE_NORM>::fetch, conv<4, u8, CONVERT_MODE_NORM>::write}, // FORMAT_ABGR8_UNORM
{conv<4, i8, CONVERT_MODE_NORM>::fetch, conv<4, i8, CONVERT_MODE_NORM>::write}, // FORMAT_ABGR8_SNORM
{conv<4, u8, CONVERT_MODE_CAST>::fetch, conv<4, u8, CONVERT_MODE_CAST>::write}, // FORMAT_ABGR8_USCALED
{conv<4, i8, CONVERT_MODE_CAST>::fetch, conv<4, i8, CONVERT_MODE_CAST>::write}, // FORMAT_ABGR8_SSCALED
{conv<4, u8, CONVERT_MODE_CAST>::fetch, conv<4, u8, CONVERT_MODE_CAST>::write}, // FORMAT_ABGR8_UINT
{conv<4, i8, CONVERT_MODE_CAST>::fetch, conv<4, i8, CONVERT_MODE_CAST>::write}, // FORMAT_ABGR8_SINT
{conv<4, u8, CONVERT_MODE_SRGB>::fetch, conv<4, u8, CONVERT_MODE_SRGB>::write}, // FORMAT_ABGR8_SRGB
{conv<4, u8, tvec, CONVERT_MODE_RGB10A2UNORM>::fetch, conv<4, u8, tvec, CONVERT_MODE_RGB10A2UNORM>::write}, // FORMAT_RGB10A2_UNORM
{conv<4, i8, tvec, CONVERT_MODE_RGB10A2SNORM>::fetch, conv<4, i8, tvec, CONVERT_MODE_RGB10A2SNORM>::write}, // FORMAT_RGB10A2_SNORM
{conv<4, u8, tvec, CONVERT_MODE_RGB10A2USCALE>::fetch, conv<4, u8, tvec, CONVERT_MODE_RGB10A2USCALE>::write}, // FORMAT_RGB10A2_USCALED
{conv<4, i8, tvec, CONVERT_MODE_RGB10A2SSCALE>::fetch, conv<4, i8, tvec, CONVERT_MODE_RGB10A2SSCALE>::write}, // FORMAT_RGB10A2_SSCALED
{conv<4, u8, tvec, CONVERT_MODE_RGB10A2UINT>::fetch, conv<4, u8, tvec, CONVERT_MODE_RGB10A2UINT>::write}, // FORMAT_RGB10A2_UINT
{conv<4, i8, tvec, CONVERT_MODE_RGB10A2SINT>::fetch, conv<4, i8, tvec, CONVERT_MODE_RGB10A2SINT>::write}, // FORMAT_RGB10A2_SINT
{conv<4, u8, CONVERT_MODE_RGB10A2UNORM>::fetch, conv<4, u8, CONVERT_MODE_RGB10A2UNORM>::write}, // FORMAT_RGB10A2_UNORM
{conv<4, i8, CONVERT_MODE_RGB10A2SNORM>::fetch, conv<4, i8, CONVERT_MODE_RGB10A2SNORM>::write}, // FORMAT_RGB10A2_SNORM
{conv<4, u8, CONVERT_MODE_RGB10A2USCALE>::fetch, conv<4, u8, CONVERT_MODE_RGB10A2USCALE>::write}, // FORMAT_RGB10A2_USCALED
{conv<4, i8, CONVERT_MODE_RGB10A2SSCALE>::fetch, conv<4, i8, CONVERT_MODE_RGB10A2SSCALE>::write}, // FORMAT_RGB10A2_SSCALED
{conv<4, u8, CONVERT_MODE_RGB10A2UINT>::fetch, conv<4, u8, CONVERT_MODE_RGB10A2UINT>::write}, // FORMAT_RGB10A2_UINT
{conv<4, i8, CONVERT_MODE_RGB10A2SINT>::fetch, conv<4, i8, CONVERT_MODE_RGB10A2SINT>::write}, // FORMAT_RGB10A2_SINT
{conv<4, u8, tvec, CONVERT_MODE_RGB10A2UNORM>::fetch, conv<4, u8, tvec, CONVERT_MODE_RGB10A2UNORM>::write}, // FORMAT_BGR10A2_UNORM
{conv<4, i8, tvec, CONVERT_MODE_RGB10A2SNORM>::fetch, conv<4, i8, tvec, CONVERT_MODE_RGB10A2SNORM>::write}, // FORMAT_BGR10A2_SNORM
{conv<4, u8, tvec, CONVERT_MODE_RGB10A2USCALE>::fetch, conv<4, u8, tvec, CONVERT_MODE_RGB10A2USCALE>::write}, // FORMAT_BGR10A2_USCALED
{conv<4, i8, tvec, CONVERT_MODE_RGB10A2SSCALE>::fetch, conv<4, i8, tvec, CONVERT_MODE_RGB10A2SSCALE>::write}, // FORMAT_BGR10A2_SSCALED
{conv<4, u8, tvec, CONVERT_MODE_RGB10A2UINT>::fetch, conv<4, u8, tvec, CONVERT_MODE_RGB10A2UINT>::write}, // FORMAT_BGR10A2_UINT
{conv<4, i8, tvec, CONVERT_MODE_RGB10A2SINT>::fetch, conv<4, i8, tvec, CONVERT_MODE_RGB10A2SINT>::write}, // FORMAT_BGR10A2_SINT
{conv<4, u8, CONVERT_MODE_RGB10A2UNORM>::fetch, conv<4, u8, CONVERT_MODE_RGB10A2UNORM>::write}, // FORMAT_BGR10A2_UNORM
{conv<4, i8, CONVERT_MODE_RGB10A2SNORM>::fetch, conv<4, i8, CONVERT_MODE_RGB10A2SNORM>::write}, // FORMAT_BGR10A2_SNORM
{conv<4, u8, CONVERT_MODE_RGB10A2USCALE>::fetch, conv<4, u8, CONVERT_MODE_RGB10A2USCALE>::write}, // FORMAT_BGR10A2_USCALED
{conv<4, i8, CONVERT_MODE_RGB10A2SSCALE>::fetch, conv<4, i8, CONVERT_MODE_RGB10A2SSCALE>::write}, // FORMAT_BGR10A2_SSCALED
{conv<4, u8, CONVERT_MODE_RGB10A2UINT>::fetch, conv<4, u8, CONVERT_MODE_RGB10A2UINT>::write}, // FORMAT_BGR10A2_UINT
{conv<4, i8, CONVERT_MODE_RGB10A2SINT>::fetch, conv<4, i8, CONVERT_MODE_RGB10A2SINT>::write}, // FORMAT_BGR10A2_SINT
{conv<1, u16, tvec, CONVERT_MODE_NORM>::fetch, conv<1, u16, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_R16_UNORM_PACK16
{conv<1, i16, tvec, CONVERT_MODE_NORM>::fetch, conv<1, i16, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_R16_SNORM_PACK16
{conv<1, u16, tvec, CONVERT_MODE_CAST>::fetch, conv<1, u16, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_R16_USCALED_PACK16
{conv<1, i16, tvec, CONVERT_MODE_CAST>::fetch, conv<1, i16, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_R16_SSCALED_PACK16
{conv<1, u16, tvec, CONVERT_MODE_CAST>::fetch, conv<1, u16, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_R16_UINT_PACK16
{conv<1, i16, tvec, CONVERT_MODE_CAST>::fetch, conv<1, i16, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_R16_SINT_PACK16
{conv<1, u16, tvec, CONVERT_MODE_HALF>::fetch, conv<1, u16, tvec, CONVERT_MODE_HALF>::write}, // FORMAT_R16_SFLOAT_PACK16
{conv<1, u16, CONVERT_MODE_NORM>::fetch, conv<1, u16, CONVERT_MODE_NORM>::write}, // FORMAT_R16_UNORM_PACK16
{conv<1, i16, CONVERT_MODE_NORM>::fetch, conv<1, i16, CONVERT_MODE_NORM>::write}, // FORMAT_R16_SNORM_PACK16
{conv<1, u16, CONVERT_MODE_CAST>::fetch, conv<1, u16, CONVERT_MODE_CAST>::write}, // FORMAT_R16_USCALED_PACK16
{conv<1, i16, CONVERT_MODE_CAST>::fetch, conv<1, i16, CONVERT_MODE_CAST>::write}, // FORMAT_R16_SSCALED_PACK16
{conv<1, u16, CONVERT_MODE_CAST>::fetch, conv<1, u16, CONVERT_MODE_CAST>::write}, // FORMAT_R16_UINT_PACK16
{conv<1, i16, CONVERT_MODE_CAST>::fetch, conv<1, i16, CONVERT_MODE_CAST>::write}, // FORMAT_R16_SINT_PACK16
{conv<1, u16, CONVERT_MODE_HALF>::fetch, conv<1, u16, CONVERT_MODE_HALF>::write}, // FORMAT_R16_SFLOAT_PACK16
{conv<2, u16, tvec, CONVERT_MODE_NORM>::fetch, conv<2, u16, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_RG16_UNORM_PACK16
{conv<2, i16, tvec, CONVERT_MODE_NORM>::fetch, conv<2, i16, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_RG16_SNORM_PACK16
{conv<2, u16, tvec, CONVERT_MODE_CAST>::fetch, conv<2, u16, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RG16_USCALED_PACK16
{conv<2, i16, tvec, CONVERT_MODE_CAST>::fetch, conv<2, i16, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RG16_SSCALED_PACK16
{conv<2, u16, tvec, CONVERT_MODE_CAST>::fetch, conv<2, u16, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RG16_UINT_PACK16
{conv<2, i16, tvec, CONVERT_MODE_CAST>::fetch, conv<2, i16, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RG16_SINT_PACK16
{conv<2, u16, tvec, CONVERT_MODE_HALF>::fetch, conv<2, u16, tvec, CONVERT_MODE_HALF>::write}, // FORMAT_RG16_SFLOAT_PACK16
{conv<2, u16, CONVERT_MODE_NORM>::fetch, conv<2, u16, CONVERT_MODE_NORM>::write}, // FORMAT_RG16_UNORM_PACK16
{conv<2, i16, CONVERT_MODE_NORM>::fetch, conv<2, i16, CONVERT_MODE_NORM>::write}, // FORMAT_RG16_SNORM_PACK16
{conv<2, u16, CONVERT_MODE_CAST>::fetch, conv<2, u16, CONVERT_MODE_CAST>::write}, // FORMAT_RG16_USCALED_PACK16
{conv<2, i16, CONVERT_MODE_CAST>::fetch, conv<2, i16, CONVERT_MODE_CAST>::write}, // FORMAT_RG16_SSCALED_PACK16
{conv<2, u16, CONVERT_MODE_CAST>::fetch, conv<2, u16, CONVERT_MODE_CAST>::write}, // FORMAT_RG16_UINT_PACK16
{conv<2, i16, CONVERT_MODE_CAST>::fetch, conv<2, i16, CONVERT_MODE_CAST>::write}, // FORMAT_RG16_SINT_PACK16
{conv<2, u16, CONVERT_MODE_HALF>::fetch, conv<2, u16, CONVERT_MODE_HALF>::write}, // FORMAT_RG16_SFLOAT_PACK16
{conv<3, u16, tvec, CONVERT_MODE_NORM>::fetch, conv<3, u16, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_RGB16_UNORM_PACK16
{conv<3, i16, tvec, CONVERT_MODE_NORM>::fetch, conv<3, i16, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_RGB16_SNORM_PACK16
{conv<3, u16, tvec, CONVERT_MODE_CAST>::fetch, conv<3, u16, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RGB16_USCALED_PACK16
{conv<3, i16, tvec, CONVERT_MODE_CAST>::fetch, conv<3, i16, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RGB16_SSCALED_PACK16
{conv<3, u16, tvec, CONVERT_MODE_CAST>::fetch, conv<3, u16, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RGB16_UINT_PACK16
{conv<3, i16, tvec, CONVERT_MODE_CAST>::fetch, conv<3, i16, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RGB16_SINT_PACK16
{conv<3, u16, tvec, CONVERT_MODE_HALF>::fetch, conv<3, u16, tvec, CONVERT_MODE_HALF>::write}, // FORMAT_RGB16_SFLOAT_PACK16
{conv<3, u16, CONVERT_MODE_NORM>::fetch, conv<3, u16, CONVERT_MODE_NORM>::write}, // FORMAT_RGB16_UNORM_PACK16
{conv<3, i16, CONVERT_MODE_NORM>::fetch, conv<3, i16, CONVERT_MODE_NORM>::write}, // FORMAT_RGB16_SNORM_PACK16
{conv<3, u16, CONVERT_MODE_CAST>::fetch, conv<3, u16, CONVERT_MODE_CAST>::write}, // FORMAT_RGB16_USCALED_PACK16
{conv<3, i16, CONVERT_MODE_CAST>::fetch, conv<3, i16, CONVERT_MODE_CAST>::write}, // FORMAT_RGB16_SSCALED_PACK16
{conv<3, u16, CONVERT_MODE_CAST>::fetch, conv<3, u16, CONVERT_MODE_CAST>::write}, // FORMAT_RGB16_UINT_PACK16
{conv<3, i16, CONVERT_MODE_CAST>::fetch, conv<3, i16, CONVERT_MODE_CAST>::write}, // FORMAT_RGB16_SINT_PACK16
{conv<3, u16, CONVERT_MODE_HALF>::fetch, conv<3, u16, CONVERT_MODE_HALF>::write}, // FORMAT_RGB16_SFLOAT_PACK16
{conv<4, u16, tvec, CONVERT_MODE_NORM>::fetch, conv<4, u16, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_RGBA16_UNORM_PACK16
{conv<4, i16, tvec, CONVERT_MODE_NORM>::fetch, conv<4, i16, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_RGBA16_SNORM_PACK16
{conv<4, u16, tvec, CONVERT_MODE_CAST>::fetch, conv<4, u16, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RGBA16_USCALED_PACK16
{conv<4, i16, tvec, CONVERT_MODE_CAST>::fetch, conv<4, i16, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RGBA16_SSCALED_PACK16
{conv<4, u16, tvec, CONVERT_MODE_CAST>::fetch, conv<4, u16, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RGBA16_UINT_PACK16
{conv<4, i16, tvec, CONVERT_MODE_CAST>::fetch, conv<4, i16, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RGBA16_SINT_PACK16
{conv<4, u16, tvec, CONVERT_MODE_HALF>::fetch, conv<4, u16, tvec, CONVERT_MODE_HALF>::write}, // FORMAT_RGBA16_SFLOAT_PACK16
{conv<4, u16, CONVERT_MODE_NORM>::fetch, conv<4, u16, CONVERT_MODE_NORM>::write}, // FORMAT_RGBA16_UNORM_PACK16
{conv<4, i16, CONVERT_MODE_NORM>::fetch, conv<4, i16, CONVERT_MODE_NORM>::write}, // FORMAT_RGBA16_SNORM_PACK16
{conv<4, u16, CONVERT_MODE_CAST>::fetch, conv<4, u16, CONVERT_MODE_CAST>::write}, // FORMAT_RGBA16_USCALED_PACK16
{conv<4, i16, CONVERT_MODE_CAST>::fetch, conv<4, i16, CONVERT_MODE_CAST>::write}, // FORMAT_RGBA16_SSCALED_PACK16
{conv<4, u16, CONVERT_MODE_CAST>::fetch, conv<4, u16, CONVERT_MODE_CAST>::write}, // FORMAT_RGBA16_UINT_PACK16
{conv<4, i16, CONVERT_MODE_CAST>::fetch, conv<4, i16, CONVERT_MODE_CAST>::write}, // FORMAT_RGBA16_SINT_PACK16
{conv<4, u16, CONVERT_MODE_HALF>::fetch, conv<4, u16, CONVERT_MODE_HALF>::write}, // FORMAT_RGBA16_SFLOAT_PACK16
{conv<1, u32, tvec, CONVERT_MODE_CAST>::fetch, conv<1, u32, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_R32_UINT_PACK32
{conv<1, i32, tvec, CONVERT_MODE_CAST>::fetch, conv<1, i32, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_R32_SINT_PACK32
{conv<1, f32, tvec, CONVERT_MODE_CAST>::fetch, conv<1, f32, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_R32_SFLOAT_PACK32
{conv<1, u32, CONVERT_MODE_CAST>::fetch, conv<1, u32, CONVERT_MODE_CAST>::write}, // FORMAT_R32_UINT_PACK32
{conv<1, i32, CONVERT_MODE_CAST>::fetch, conv<1, i32, CONVERT_MODE_CAST>::write}, // FORMAT_R32_SINT_PACK32
{conv<1, f32, CONVERT_MODE_CAST>::fetch, conv<1, f32, CONVERT_MODE_CAST>::write}, // FORMAT_R32_SFLOAT_PACK32
{conv<2, u32, tvec, CONVERT_MODE_CAST>::fetch, conv<2, u32, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RG32_UINT_PACK32
{conv<2, i32, tvec, CONVERT_MODE_CAST>::fetch, conv<2, i32, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RG32_SINT_PACK32
{conv<2, f32, tvec, CONVERT_MODE_CAST>::fetch, conv<2, f32, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RG32_SFLOAT_PACK32
{conv<2, u32, CONVERT_MODE_CAST>::fetch, conv<2, u32, CONVERT_MODE_CAST>::write}, // FORMAT_RG32_UINT_PACK32
{conv<2, i32, CONVERT_MODE_CAST>::fetch, conv<2, i32, CONVERT_MODE_CAST>::write}, // FORMAT_RG32_SINT_PACK32
{conv<2, f32, CONVERT_MODE_CAST>::fetch, conv<2, f32, CONVERT_MODE_CAST>::write}, // FORMAT_RG32_SFLOAT_PACK32
{conv<3, u32, tvec, CONVERT_MODE_CAST>::fetch, conv<3, u32, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RGB32_UINT_PACK32
{conv<3, i32, tvec, CONVERT_MODE_CAST>::fetch, conv<3, i32, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RGB32_SINT_PACK32
{conv<3, f32, tvec, CONVERT_MODE_CAST>::fetch, conv<3, f32, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RGB32_SFLOAT_PACK32
{conv<3, u32, CONVERT_MODE_CAST>::fetch, conv<3, u32, CONVERT_MODE_CAST>::write}, // FORMAT_RGB32_UINT_PACK32
{conv<3, i32, CONVERT_MODE_CAST>::fetch, conv<3, i32, CONVERT_MODE_CAST>::write}, // FORMAT_RGB32_SINT_PACK32
{conv<3, f32, CONVERT_MODE_CAST>::fetch, conv<3, f32, CONVERT_MODE_CAST>::write}, // FORMAT_RGB32_SFLOAT_PACK32
{conv<4, u32, tvec, CONVERT_MODE_CAST>::fetch, conv<4, u32, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RGBA32_UINT_PACK32
{conv<4, i32, tvec, CONVERT_MODE_CAST>::fetch, conv<4, i32, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RGBA32_SINT_PACK32
{conv<4, f32, tvec, CONVERT_MODE_CAST>::fetch, conv<4, f32, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RGBA32_SFLOAT_PACK32
{conv<4, u32, CONVERT_MODE_CAST>::fetch, conv<4, u32, CONVERT_MODE_CAST>::write}, // FORMAT_RGBA32_UINT_PACK32
{conv<4, i32, CONVERT_MODE_CAST>::fetch, conv<4, i32, CONVERT_MODE_CAST>::write}, // FORMAT_RGBA32_SINT_PACK32
{conv<4, f32, CONVERT_MODE_CAST>::fetch, conv<4, f32, CONVERT_MODE_CAST>::write}, // FORMAT_RGBA32_SFLOAT_PACK32
{conv<1, u64, tvec, CONVERT_MODE_CAST>::fetch, conv<1, u64, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_R64_UINT_PACK64
{conv<1, i64, tvec, CONVERT_MODE_CAST>::fetch, conv<1, i64, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_R64_SINT_PACK64
{conv<1, f64, tvec, CONVERT_MODE_CAST>::fetch, conv<1, f64, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_R64_SFLOAT_PACK64
{conv<1, u64, CONVERT_MODE_CAST>::fetch, conv<1, u64, CONVERT_MODE_CAST>::write}, // FORMAT_R64_UINT_PACK64
{conv<1, i64, CONVERT_MODE_CAST>::fetch, conv<1, i64, CONVERT_MODE_CAST>::write}, // FORMAT_R64_SINT_PACK64
{conv<1, f64, CONVERT_MODE_CAST>::fetch, conv<1, f64, CONVERT_MODE_CAST>::write}, // FORMAT_R64_SFLOAT_PACK64
{conv<2, u64, tvec, CONVERT_MODE_CAST>::fetch, conv<2, u64, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RG64_UINT_PACK64
{conv<2, i64, tvec, CONVERT_MODE_CAST>::fetch, conv<2, i64, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RG64_SINT_PACK64
{conv<2, f64, tvec, CONVERT_MODE_CAST>::fetch, conv<2, f64, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RG64_SFLOAT_PACK64
{conv<2, u64, CONVERT_MODE_CAST>::fetch, conv<2, u64, CONVERT_MODE_CAST>::write}, // FORMAT_RG64_UINT_PACK64
{conv<2, i64, CONVERT_MODE_CAST>::fetch, conv<2, i64, CONVERT_MODE_CAST>::write}, // FORMAT_RG64_SINT_PACK64
{conv<2, f64, CONVERT_MODE_CAST>::fetch, conv<2, f64, CONVERT_MODE_CAST>::write}, // FORMAT_RG64_SFLOAT_PACK64
{conv<3, u64, tvec, CONVERT_MODE_CAST>::fetch, conv<3, u64, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RGB64_UINT_PACK64
{conv<3, i64, tvec, CONVERT_MODE_CAST>::fetch, conv<3, i64, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RGB64_SINT_PACK64
{conv<3, f64, tvec, CONVERT_MODE_CAST>::fetch, conv<3, f64, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RGB64_SFLOAT_PACK64
{conv<3, u64, CONVERT_MODE_CAST>::fetch, conv<3, u64, CONVERT_MODE_CAST>::write}, // FORMAT_RGB64_UINT_PACK64
{conv<3, i64, CONVERT_MODE_CAST>::fetch, conv<3, i64, CONVERT_MODE_CAST>::write}, // FORMAT_RGB64_SINT_PACK64
{conv<3, f64, CONVERT_MODE_CAST>::fetch, conv<3, f64, CONVERT_MODE_CAST>::write}, // FORMAT_RGB64_SFLOAT_PACK64
{conv<4, u64, tvec, CONVERT_MODE_CAST>::fetch, conv<4, u64, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RGBA64_UINT_PACK64
{conv<4, i64, tvec, CONVERT_MODE_CAST>::fetch, conv<4, i64, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RGBA64_SINT_PACK64
{conv<4, f64, tvec, CONVERT_MODE_CAST>::fetch, conv<4, f64, tvec, CONVERT_MODE_CAST>::write}, // FORMAT_RGBA64_SFLOAT_PACK64
{conv<4, u64, CONVERT_MODE_CAST>::fetch, conv<4, u64, CONVERT_MODE_CAST>::write}, // FORMAT_RGBA64_UINT_PACK64
{conv<4, i64, CONVERT_MODE_CAST>::fetch, conv<4, i64, CONVERT_MODE_CAST>::write}, // FORMAT_RGBA64_SINT_PACK64
{conv<4, f64, CONVERT_MODE_CAST>::fetch, conv<4, f64, CONVERT_MODE_CAST>::write}, // FORMAT_RGBA64_SFLOAT_PACK64
{conv<1, u32, tvec, CONVERT_MODE_RG11B10F>::fetch, conv<1, u32, tvec, CONVERT_MODE_RG11B10F>::write}, // FORMAT_RG11B10_UFLOAT
{conv<1, u32, tvec, CONVERT_MODE_RGB9E5>::fetch, conv<1, u32, tvec, CONVERT_MODE_RGB9E5>::write}, // FORMAT_RGB9E5_UFLOAT
{conv<1, u32, CONVERT_MODE_RG11B10F>::fetch, conv<1, u32, CONVERT_MODE_RG11B10F>::write}, // FORMAT_RG11B10_UFLOAT
{conv<1, u32, CONVERT_MODE_RGB9E5>::fetch, conv<1, u32, CONVERT_MODE_RGB9E5>::write}, // FORMAT_RGB9E5_UFLOAT
{conv<1, u16, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<1, u16, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_D16_UNORM_PACK16
{conv<1, u32, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<1, u32, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_D24_UNORM
{conv<1, f32, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<1, f32, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_D32_SFLOAT_PACK32
{conv<1, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<1, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_S8_UINT_PACK8
{conv<2, u16, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<2, u16, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_D16_UNORM_S8_UINT_PACK32
{conv<2, u32, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<2, u32, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_D24_UNORM_S8_UINT_PACK32
{conv<2, u32, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<2, u32, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_D32_SFLOAT_S8_UINT_PACK64
{conv<1, u16, CONVERT_MODE_DEFAULT>::fetch, conv<1, u16, CONVERT_MODE_DEFAULT>::write}, // FORMAT_D16_UNORM_PACK16
{conv<1, u32, CONVERT_MODE_DEFAULT>::fetch, conv<1, u32, CONVERT_MODE_DEFAULT>::write}, // FORMAT_D24_UNORM
{conv<1, f32, CONVERT_MODE_DEFAULT>::fetch, conv<1, f32, CONVERT_MODE_DEFAULT>::write}, // FORMAT_D32_SFLOAT_PACK32
{conv<1, u8, CONVERT_MODE_DEFAULT>::fetch, conv<1, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_S8_UINT_PACK8
{conv<2, u16, CONVERT_MODE_DEFAULT>::fetch, conv<2, u16, CONVERT_MODE_DEFAULT>::write}, // FORMAT_D16_UNORM_S8_UINT_PACK32
{conv<2, u32, CONVERT_MODE_DEFAULT>::fetch, conv<2, u32, CONVERT_MODE_DEFAULT>::write}, // FORMAT_D24_UNORM_S8_UINT_PACK32
{conv<2, u32, CONVERT_MODE_DEFAULT>::fetch, conv<2, u32, CONVERT_MODE_DEFAULT>::write}, // FORMAT_D32_SFLOAT_S8_UINT_PACK64
{conv<3, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGB_DXT1_UNORM_BLOCK8
{conv<3, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGB_DXT1_SRGB_BLOCK8
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_DXT1_UNORM_BLOCK8
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_DXT1_SRGB_BLOCK8
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_DXT3_UNORM_BLOCK16
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_DXT3_SRGB_BLOCK16
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_DXT5_UNORM_BLOCK16
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_DXT5_SRGB_BLOCK16
{conv<1, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<1, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_R_ATI1N_UNORM_BLOCK8
{conv<1, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<1, i8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_R_ATI1N_SNORM_BLOCK8
{conv<2, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<2, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RG_ATI2N_UNORM_BLOCK16
{conv<2, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<2, i8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RG_ATI2N_SNORM_BLOCK16
{conv<3, f32, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<3, f32, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGB_BP_UFLOAT_BLOCK16
{conv<3, f32, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<3, f32, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGB_BP_SFLOAT_BLOCK16
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_BP_UNORM_BLOCK16
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_BP_SRGB_BLOCK16
{conv<3, u8, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGB_DXT1_UNORM_BLOCK8
{conv<3, u8, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGB_DXT1_SRGB_BLOCK8
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_DXT1_UNORM_BLOCK8
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_DXT1_SRGB_BLOCK8
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_DXT3_UNORM_BLOCK16
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_DXT3_SRGB_BLOCK16
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_DXT5_UNORM_BLOCK16
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_DXT5_SRGB_BLOCK16
{conv<1, u8, CONVERT_MODE_DEFAULT>::fetch, conv<1, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_R_ATI1N_UNORM_BLOCK8
{conv<1, u8, CONVERT_MODE_DEFAULT>::fetch, conv<1, i8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_R_ATI1N_SNORM_BLOCK8
{conv<2, u8, CONVERT_MODE_DEFAULT>::fetch, conv<2, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RG_ATI2N_UNORM_BLOCK16
{conv<2, u8, CONVERT_MODE_DEFAULT>::fetch, conv<2, i8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RG_ATI2N_SNORM_BLOCK16
{conv<3, f32, CONVERT_MODE_DEFAULT>::fetch, conv<3, f32, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGB_BP_UFLOAT_BLOCK16
{conv<3, f32, CONVERT_MODE_DEFAULT>::fetch, conv<3, f32, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGB_BP_SFLOAT_BLOCK16
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_BP_UNORM_BLOCK16
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_BP_SRGB_BLOCK16
{conv<3, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGB_ETC2_UNORM_BLOCK8
{conv<3, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGB_ETC2_SRGB_BLOCK8
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_ETC2_A1_UNORM_BLOCK8
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_ETC2_A1_SRGB_BLOCK8
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_ETC2_UNORM_BLOCK16
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_ETC2_SRGB_BLOCK16
{conv<1, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<1, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_R_EAC_UNORM_BLOCK8
{conv<1, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<1, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_R_EAC_SNORM_BLOCK8
{conv<2, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<2, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RG_EAC_UNORM_BLOCK16
{conv<2, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<2, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RG_EAC_SNORM_BLOCK16
{conv<3, u8, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGB_ETC2_UNORM_BLOCK8
{conv<3, u8, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGB_ETC2_SRGB_BLOCK8
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_ETC2_A1_UNORM_BLOCK8
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_ETC2_A1_SRGB_BLOCK8
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_ETC2_UNORM_BLOCK16
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_ETC2_SRGB_BLOCK16
{conv<1, u8, CONVERT_MODE_DEFAULT>::fetch, conv<1, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_R_EAC_UNORM_BLOCK8
{conv<1, u8, CONVERT_MODE_DEFAULT>::fetch, conv<1, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_R_EAC_SNORM_BLOCK8
{conv<2, u8, CONVERT_MODE_DEFAULT>::fetch, conv<2, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RG_EAC_UNORM_BLOCK16
{conv<2, u8, CONVERT_MODE_DEFAULT>::fetch, conv<2, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RG_EAC_SNORM_BLOCK16
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_4x4_UNORM
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_4x4_SRGB
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_5x4_UNORM
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_5x4_SRGB
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_5x5_UNORM
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_5x5_SRGB
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_6x5_UNORM
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_6x5_SRGB
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_6x6_UNORM
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_6x6_SRGB
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_8x5_UNORM
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_8x5_SRGB
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_8x6_UNORM
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_8x6_SRGB
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_8x8_UNORM
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_8x8_SRGB
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_10x5_UNORM
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_10x5_SRGB
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_10x6_UNORM
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_10x6_SRGB
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_10x8_UNORM
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_10x8_SRGB
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_10x10_UNORM
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_10x10_SRGB
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_12x10_UNORM
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_12x10_SRGB
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_12x12_UNORM
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_12x12_SRGB
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_4x4_UNORM
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_4x4_SRGB
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_5x4_UNORM
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_5x4_SRGB
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_5x5_UNORM
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_5x5_SRGB
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_6x5_UNORM
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_6x5_SRGB
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_6x6_UNORM
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_6x6_SRGB
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_8x5_UNORM
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_8x5_SRGB
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_8x6_UNORM
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_8x6_SRGB
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_8x8_UNORM
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_8x8_SRGB
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_10x5_UNORM
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_10x5_SRGB
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_10x6_UNORM
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_10x6_SRGB
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_10x8_UNORM
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_10x8_SRGB
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_10x10_UNORM
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_10x10_SRGB
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_12x10_UNORM
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_12x10_SRGB
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_12x12_UNORM
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_ASTC_12x12_SRGB
{conv<3, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGB_PVRTC1_8X8_UNORM_BLOCK32
{conv<3, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGB_PVRTC1_8X8_SRGB_BLOCK32
{conv<3, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGB_PVRTC1_16X8_UNORM_BLOCK32
{conv<3, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGB_PVRTC1_16X8_SRGB_BLOCK32
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_PVRTC1_8X8_UNORM_BLOCK32
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_PVRTC1_8X8_SRGB_BLOCK32
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_PVRTC1_16X8_UNORM_BLOCK32
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_PVRTC1_16X8_SRGB_BLOCK32
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_PVRTC2_4X4_UNORM_BLOCK8
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_PVRTC2_4X4_SRGB_BLOCK8
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_PVRTC2_8X4_UNORM_BLOCK8
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_PVRTC2_8X4_SRGB_BLOCK8
{conv<3, u8, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGB_PVRTC1_8X8_UNORM_BLOCK32
{conv<3, u8, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGB_PVRTC1_8X8_SRGB_BLOCK32
{conv<3, u8, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGB_PVRTC1_16X8_UNORM_BLOCK32
{conv<3, u8, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGB_PVRTC1_16X8_SRGB_BLOCK32
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_PVRTC1_8X8_UNORM_BLOCK32
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_PVRTC1_8X8_SRGB_BLOCK32
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_PVRTC1_16X8_UNORM_BLOCK32
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_PVRTC1_16X8_SRGB_BLOCK32
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_PVRTC2_4X4_UNORM_BLOCK8
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_PVRTC2_4X4_SRGB_BLOCK8
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_PVRTC2_8X4_UNORM_BLOCK8
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_PVRTC2_8X4_SRGB_BLOCK8
{conv<3, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGB_ETC_UNORM_BLOCK8
{conv<3, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGB_ATC_UNORM_BLOCK8
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_ATCA_UNORM_BLOCK16
{conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, tvec, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_ATCI_UNORM_BLOCK16
{conv<3, u8, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGB_ETC_UNORM_BLOCK8
{conv<3, u8, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGB_ATC_UNORM_BLOCK8
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_ATCA_UNORM_BLOCK16
{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write}, // FORMAT_RGBA_ATCI_UNORM_BLOCK16
{conv<1, u8, tvec, CONVERT_MODE_NORM>::fetch, conv<1, u8, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_L8_UNORM_PACK8
{conv<1, u8, tvec, CONVERT_MODE_NORM>::fetch, conv<1, u8, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_A8_UNORM_PACK8
{conv<2, u8, tvec, CONVERT_MODE_NORM>::fetch, conv<2, u8, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_LA8_UNORM_PACK8
{conv<1, u16, tvec, CONVERT_MODE_NORM>::fetch, conv<1, u16, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_L16_UNORM_PACK16
{conv<1, u16, tvec, CONVERT_MODE_NORM>::fetch, conv<1, u16, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_A16_UNORM_PACK16
{conv<2, u16, tvec, CONVERT_MODE_NORM>::fetch, conv<2, u16, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_LA16_UNORM_PACK16
{conv<1, u8, CONVERT_MODE_NORM>::fetch, conv<1, u8, CONVERT_MODE_NORM>::write}, // FORMAT_L8_UNORM_PACK8
{conv<1, u8, CONVERT_MODE_NORM>::fetch, conv<1, u8, CONVERT_MODE_NORM>::write}, // FORMAT_A8_UNORM_PACK8
{conv<2, u8, CONVERT_MODE_NORM>::fetch, conv<2, u8, CONVERT_MODE_NORM>::write}, // FORMAT_LA8_UNORM_PACK8
{conv<1, u16, CONVERT_MODE_NORM>::fetch, conv<1, u16, CONVERT_MODE_NORM>::write}, // FORMAT_L16_UNORM_PACK16
{conv<1, u16, CONVERT_MODE_NORM>::fetch, conv<1, u16, CONVERT_MODE_NORM>::write}, // FORMAT_A16_UNORM_PACK16
{conv<2, u16, CONVERT_MODE_NORM>::fetch, conv<2, u16, CONVERT_MODE_NORM>::write}, // FORMAT_LA16_UNORM_PACK16
{conv<4, u8, tvec, CONVERT_MODE_NORM>::fetch, conv<4, u8, tvec, CONVERT_MODE_NORM>::write}, // FORMAT_BGRX8_UNORM
{conv<4, u8, tvec, CONVERT_MODE_SRGB>::fetch, conv<4, u8, tvec, CONVERT_MODE_SRGB>::write}, // FORMAT_BGRX8_SRGB
{conv<4, u8, CONVERT_MODE_NORM>::fetch, conv<4, u8, CONVERT_MODE_NORM>::write}, // FORMAT_BGRX8_UNORM
{conv<4, u8, CONVERT_MODE_SRGB>::fetch, conv<4, u8, CONVERT_MODE_SRGB>::write}, // FORMAT_BGRX8_SRGB
{conv<3, u8, tvec, CONVERT_MODE_332UNORM>::fetch, conv<3, u8, tvec, CONVERT_MODE_332UNORM>::write} // FORMAT_RG3B2_UNORM
{conv<3, u8, CONVERT_MODE_332UNORM>::fetch, conv<3, u8, CONVERT_MODE_332UNORM>::write} // FORMAT_RG3B2_UNORM
};
static_assert(sizeof(Table) / sizeof(Table[0]) == FORMAT_COUNT, "Texel functions need to be updated");

4
test/external/gli/core/coord.hpp vendored
View File

@ -5,8 +5,8 @@
namespace gli{
namespace detail
{
template <int D, typename T, precision P, template <int, typename, precision> class vecType>
inline vecType<D, bool, P> in_interval(vecType<D, T, P> const& Value, vecType<D, T, P> const& Min, vecType<D, T, P> const& Max)
template <length_t L, typename T, precision P>
inline vec<L, bool, P> in_interval(vec<L, T, P> const& Value, vec<L, T, P> const& Min, vec<L, T, P> const& Max)
{
return greaterThanEqual(Value, Min) && lessThanEqual(Value, Max);
}

2
test/external/gli/core/format.inl vendored
View File

@ -282,7 +282,7 @@ namespace detail
GLI_ASSERT(Format != static_cast<format>(FORMAT_INVALID));
return Table[Format - FORMAT_FIRST];
}
};
inline std::uint32_t bits_per_pixel(format Format)
{

5
test/external/gli/core/levels.inl vendored
View File

@ -1,10 +1,11 @@
#include <glm/gtc/integer.hpp>
#define GLM_ENABLE_EXPERIMENTAL
#include <glm/gtx/component_wise.hpp>
namespace gli
{
template <int D, typename T, precision P, template <int, typename, precision> class vecType>
inline T levels(vecType<D, T, P> const& Extent)
template <length_t L, typename T, precision P, template <length_t, typename, precision> class vecType>
inline T levels(vecType<L, T, P> const& Extent)
{
return glm::log2(compMax(Extent)) + static_cast<T>(1);
}

30
test/external/gli/core/reduce.inl vendored
View File

@ -11,7 +11,7 @@ namespace gli
template <typename val_type>
struct binary_func
{
typedef tvec4<val_type>(*type)(tvec4<val_type> const& A, tvec4<val_type> const& B);
typedef vec<4, val_type>(*type)(vec<4, val_type> const& A, vec<4, val_type> const& B);
};
namespace detail
@ -28,13 +28,13 @@ namespace detail
typedef texture1d::size_type size_type;
typedef texture1d::extent_type extent_type;
static tvec4<val_type> call(texture1d const& A, texture1d const& B, binary_func<val_type> TexelFunc, binary_func<val_type> ReduceFunc)
static vec<4, val_type> call(texture1d const& A, texture1d const& B, binary_func<val_type> TexelFunc, binary_func<val_type> ReduceFunc)
{
GLI_ASSERT(are_compatible(A, B));
sampler1d<val_type> const SamplerA(A, gli::WRAP_CLAMP_TO_EDGE), SamplerB(B, gli::WRAP_CLAMP_TO_EDGE);
extent_type TexelIndex(0);
tvec4<val_type> Result(TexelFunc(SamplerA.template fetch(TexelIndex, 0), SamplerB.template fetch(TexelIndex, 0)));
vec<4, val_type> Result(TexelFunc(SamplerA.template fetch(TexelIndex, 0), SamplerB.template fetch(TexelIndex, 0)));
for(size_type LevelIndex = 0, LevelCount = A.levels(); LevelIndex < LevelCount; ++LevelIndex)
{
@ -58,13 +58,13 @@ namespace detail
typedef texture1d_array::size_type size_type;
typedef texture1d_array::extent_type extent_type;
static tvec4<val_type> call(texture1d_array const& A, texture1d_array const& B, binary_func<val_type> TexelFunc, binary_func<val_type> ReduceFunc)
static vec<4, val_type> call(texture1d_array const& A, texture1d_array const& B, binary_func<val_type> TexelFunc, binary_func<val_type> ReduceFunc)
{
GLI_ASSERT(are_compatible(A, B));
sampler1d_array<val_type> const SamplerA(A, gli::WRAP_CLAMP_TO_EDGE), SamplerB(B, gli::WRAP_CLAMP_TO_EDGE);
extent_type TexelIndex(0);
tvec4<val_type> Result(TexelFunc(SamplerA.template fetch(TexelIndex, 0, 0), SamplerB.template fetch(TexelIndex, 0, 0)));
vec<4, val_type> Result(TexelFunc(SamplerA.template fetch(TexelIndex, 0, 0), SamplerB.template fetch(TexelIndex, 0, 0)));
for(size_type LayerIndex = 0, LayerCount = A.layers(); LayerIndex < LayerCount; ++LayerIndex)
for(size_type LevelIndex = 0, LevelCount = A.levels(); LevelIndex < LevelCount; ++LevelIndex)
@ -89,13 +89,13 @@ namespace detail
typedef texture2d::size_type size_type;
typedef texture2d::extent_type extent_type;
static tvec4<val_type> call(texture2d const& A, texture2d const& B, binary_func<val_type> TexelFunc, binary_func<val_type> ReduceFunc)
static vec<4, val_type> call(texture2d const& A, texture2d const& B, binary_func<val_type> TexelFunc, binary_func<val_type> ReduceFunc)
{
GLI_ASSERT(are_compatible(A, B));
sampler2d<val_type> const SamplerA(A, gli::WRAP_CLAMP_TO_EDGE), SamplerB(B, gli::WRAP_CLAMP_TO_EDGE);
extent_type TexelIndex(0);
tvec4<val_type> Result(TexelFunc(SamplerA.template fetch(TexelIndex, 0), SamplerB.template fetch(TexelIndex, 0)));
vec<4, val_type> Result(TexelFunc(SamplerA.template fetch(TexelIndex, 0), SamplerB.template fetch(TexelIndex, 0)));
for(size_type LevelIndex = 0, LevelCount = A.levels(); LevelIndex < LevelCount; ++LevelIndex)
{
@ -120,13 +120,13 @@ namespace detail
typedef texture2d_array::size_type size_type;
typedef texture2d_array::extent_type extent_type;
static tvec4<val_type> call(texture2d_array const& A, texture2d_array const& B, binary_func<val_type> TexelFunc, binary_func<val_type> ReduceFunc)
static vec<4, val_type> call(texture2d_array const& A, texture2d_array const& B, binary_func<val_type> TexelFunc, binary_func<val_type> ReduceFunc)
{
GLI_ASSERT(are_compatible(A, B));
sampler2d_array<val_type> const SamplerA(A, gli::WRAP_CLAMP_TO_EDGE), SamplerB(B, gli::WRAP_CLAMP_TO_EDGE);
extent_type TexelIndex(0);
tvec4<val_type> Result(TexelFunc(SamplerA.template fetch(TexelIndex, 0, 0), SamplerB.template fetch(TexelIndex, 0, 0)));
vec<4, val_type> Result(TexelFunc(SamplerA.template fetch(TexelIndex, 0, 0), SamplerB.template fetch(TexelIndex, 0, 0)));
for(size_type LayerIndex = 0, LayerCount = A.layers(); LayerIndex < LayerCount; ++LayerIndex)
for(size_type LevelIndex = 0, LevelCount = A.levels(); LevelIndex < LevelCount; ++LevelIndex)
@ -152,13 +152,13 @@ namespace detail
typedef texture3d::size_type size_type;
typedef texture3d::extent_type extent_type;
static tvec4<val_type> call(texture3d const& A, texture3d const& B, binary_func<val_type> TexelFunc, binary_func<val_type> ReduceFunc)
static vec<4, val_type> call(texture3d const& A, texture3d const& B, binary_func<val_type> TexelFunc, binary_func<val_type> ReduceFunc)
{
GLI_ASSERT(are_compatible(A, B));
sampler3d<val_type> const SamplerA(A, gli::WRAP_CLAMP_TO_EDGE), SamplerB(B, gli::WRAP_CLAMP_TO_EDGE);
extent_type TexelIndex(0);
tvec4<val_type> Result(TexelFunc(SamplerA.template fetch(TexelIndex, 0), SamplerB.template fetch(TexelIndex, 0)));
vec<4, val_type> Result(TexelFunc(SamplerA.template fetch(TexelIndex, 0), SamplerB.template fetch(TexelIndex, 0)));
for(size_type LevelIndex = 0, LevelCount = A.levels(); LevelIndex < LevelCount; ++LevelIndex)
{
@ -184,13 +184,13 @@ namespace detail
typedef texture_cube::size_type size_type;
typedef texture_cube::extent_type extent_type;
static tvec4<val_type> call(texture_cube const& A, texture_cube const& B, binary_func<val_type> TexelFunc, binary_func<val_type> ReduceFunc)
static vec<4, val_type> call(texture_cube const& A, texture_cube const& B, binary_func<val_type> TexelFunc, binary_func<val_type> ReduceFunc)
{
GLI_ASSERT(are_compatible(A, B));
sampler_cube<val_type> const SamplerA(A, gli::WRAP_CLAMP_TO_EDGE), SamplerB(B, gli::WRAP_CLAMP_TO_EDGE);
extent_type TexelIndex(0);
tvec4<val_type> Result(TexelFunc(SamplerA.template fetch(TexelIndex, 0, 0), SamplerB.template fetch(TexelIndex, 0, 0)));
vec<4, val_type> Result(TexelFunc(SamplerA.template fetch(TexelIndex, 0, 0), SamplerB.template fetch(TexelIndex, 0, 0)));
for(size_type FaceIndex = 0, FaceCount = A.faces(); FaceIndex < FaceCount; ++FaceIndex)
for(size_type LevelIndex = 0, LevelCount = A.levels(); LevelIndex < LevelCount; ++LevelIndex)
@ -216,13 +216,13 @@ namespace detail
typedef texture_cube_array::size_type size_type;
typedef texture_cube_array::extent_type extent_type;
static tvec4<val_type> call(texture_cube_array const& A, texture_cube_array const& B, binary_func<val_type> TexelFunc, binary_func<val_type> ReduceFunc)
static vec<4, val_type> call(texture_cube_array const& A, texture_cube_array const& B, binary_func<val_type> TexelFunc, binary_func<val_type> ReduceFunc)
{
GLI_ASSERT(are_compatible(A, B));
sampler_cube_array<val_type> const SamplerA(A, gli::WRAP_CLAMP_TO_EDGE), SamplerB(B, gli::WRAP_CLAMP_TO_EDGE);
extent_type TexelIndex(0);
tvec4<val_type> Result(TexelFunc(SamplerA.template fetch(TexelIndex, 0, 0, 0), SamplerB.template fetch(TexelIndex, 0, 0, 0)));
vec<4, val_type> Result(TexelFunc(SamplerA.template fetch(TexelIndex, 0, 0, 0), SamplerB.template fetch(TexelIndex, 0, 0, 0)));
for(size_type LayerIndex = 0, LayerCount = A.layers(); LayerIndex < LayerCount; ++LayerIndex)
for(size_type FaceIndex = 0, FaceCount = A.faces(); FaceIndex < FaceCount; ++FaceIndex)

1
test/external/gli/core/sampler.inl vendored
View File

@ -1,3 +1,4 @@
#define GLM_ENABLE_EXPERIMENTAL
#include <glm/gtx/wrap.hpp>
namespace gli{

72
test/external/gli/core/workaround.hpp vendored
View File

@ -73,14 +73,14 @@ namespace detail
uint32 pack;
};
template <typename T, typename floatType, precision P, template <int, typename, precision> class vecType, bool isInteger, bool signedType>
template <typename T, typename floatType, precision P, template <typename, precision> class vecType, bool isInteger, bool signedType>
struct compute_compNormalize
{};
template <typename T, typename floatType, precision P, template <int, typename, precision> class vecType>
template <typename T, typename floatType, precision P, template <typename, precision> class vecType>
struct compute_compNormalize<T, floatType, P, vecType, true, true>
{
GLM_FUNC_QUALIFIER static vecType<floatType, P> call(vecType<D, T, P> const & v)
GLM_FUNC_QUALIFIER static vecType<floatType, P> call(vecType<T, P> const & v)
{
floatType const Min = static_cast<floatType>(std::numeric_limits<T>::min());
floatType const Max = static_cast<floatType>(std::numeric_limits<T>::max());
@ -88,59 +88,59 @@ namespace detail
}
};
template <typename T, typename floatType, precision P, template <int, typename, precision> class vecType>
template <typename T, typename floatType, precision P, template <typename, precision> class vecType>
struct compute_compNormalize<T, floatType, P, vecType, true, false>
{
GLM_FUNC_QUALIFIER static vecType<floatType, P> call(vecType<D, T, P> const & v)
GLM_FUNC_QUALIFIER static vecType<floatType, P> call(vecType<T, P> const & v)
{
return vecType<floatType, P>(v) / static_cast<floatType>(std::numeric_limits<T>::max());
}
};
template <typename T, typename floatType, precision P, template <int, typename, precision> class vecType>
template <typename T, typename floatType, precision P, template <typename, precision> class vecType>
struct compute_compNormalize<T, floatType, P, vecType, false, true>
{
GLM_FUNC_QUALIFIER static vecType<floatType, P> call(vecType<D, T, P> const & v)
GLM_FUNC_QUALIFIER static vecType<floatType, P> call(vecType<T, P> const & v)
{
return v;
}
};
template <typename T, typename floatType, precision P, template <int, typename, precision> class vecType, bool isInteger, bool signedType>
template <typename T, typename floatType, precision P, template <typename, precision> class vecType, bool isInteger, bool signedType>
struct compute_compScale
{};
template <typename T, typename floatType, precision P, template <int, typename, precision> class vecType>
template <typename T, typename floatType, precision P, template <typename, precision> class vecType>
struct compute_compScale<T, floatType, P, vecType, true, true>
{
GLM_FUNC_QUALIFIER static vecType<D, T, P> call(vecType<floatType, P> const & v)
GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<floatType, P> const & v)
{
floatType const Max = static_cast<floatType>(std::numeric_limits<T>::max()) + static_cast<floatType>(0.5);
vecType<floatType, P> const Scaled(v * Max);
vecType<D, T, P> const Result(Scaled - static_cast<floatType>(0.5));
vecType<T, P> const Result(Scaled - static_cast<floatType>(0.5));
return Result;
}
};
template <typename T, typename floatType, precision P, template <int, typename, precision> class vecType>
template <typename T, typename floatType, precision P, template <typename, precision> class vecType>
struct compute_compScale<T, floatType, P, vecType, true, false>
{
GLM_FUNC_QUALIFIER static vecType<D, T, P> call(vecType<floatType, P> const & v)
GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<floatType, P> const & v)
{
return vecType<D, T, P>(vecType<floatType, P>(v) * static_cast<floatType>(std::numeric_limits<T>::max()));
return vecType<T, P>(vecType<floatType, P>(v) * static_cast<floatType>(std::numeric_limits<T>::max()));
}
};
template <typename T, typename floatType, precision P, template <int, typename, precision> class vecType>
template <typename T, typename floatType, precision P, template <typename, precision> class vecType>
struct compute_compScale<T, floatType, P, vecType, false, true>
{
GLM_FUNC_QUALIFIER static vecType<D, T, P> call(vecType<floatType, P> const & v)
GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<floatType, P> const & v)
{
return v;
}
};
template <int D, precision P, template <int, typename, precision> class vecType>
template <precision P, template <typename, precision> class vecType>
struct compute_half
{};
@ -202,19 +202,19 @@ namespace detail
template <precision P>
struct compute_half<P, tvec4>
{
GLM_FUNC_QUALIFIER static tvec4<uint16, P> pack(tvec4<float, P> const & v)
GLM_FUNC_QUALIFIER static vec<4, uint16, P> pack(vec<4, float, P> const & v)
{
tvec4<int16, P> const Unpacked(glm::detail::toFloat16(v.x), glm::detail::toFloat16(v.y), glm::detail::toFloat16(v.z), glm::detail::toFloat16(v.w));
return tvec4<uint16, P>(
vec<4, int16, P> const Unpacked(glm::detail::toFloat16(v.x), glm::detail::toFloat16(v.y), glm::detail::toFloat16(v.z), glm::detail::toFloat16(v.w));
return vec<4, uint16, P>(
reinterpret_cast<uint16 const &>(Unpacked.x),
reinterpret_cast<uint16 const &>(Unpacked.y),
reinterpret_cast<uint16 const &>(Unpacked.z),
reinterpret_cast<uint16 const &>(Unpacked.w));
}
GLM_FUNC_QUALIFIER static tvec4<float, P> unpack(tvec4<uint16, P> const & v)
GLM_FUNC_QUALIFIER static vec<4, float, P> unpack(vec<4, uint16, P> const & v)
{
return tvec4<float, P>(
return vec<4, float, P>(
glm::detail::toFloat32(reinterpret_cast<int16 const &>(v.x)),
glm::detail::toFloat32(reinterpret_cast<int16 const &>(v.y)),
glm::detail::toFloat32(reinterpret_cast<int16 const &>(v.z)),
@ -223,38 +223,38 @@ namespace detail
};
}//namespace detail
template <typename floatType, typename T, precision P, template <int, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<floatType, P> compNormalize(vecType<D, T, P> const & v)
template <typename floatType, typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<floatType, P> compNormalize(vecType<T, P> const & v)
{
GLM_STATIC_ASSERT(std::numeric_limits<floatType>::is_iec559, "'compNormalize' accepts only floating-point types for 'floatType' template parameter");
return detail::compute_compNormalize<T, floatType, P, vecType, std::numeric_limits<T>::is_integer, std::numeric_limits<T>::is_signed>::call(v);
}
template <typename T, typename floatType, precision P, template <int, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<D, T, P> compScale(vecType<floatType, P> const & v)
template <typename T, typename floatType, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> compScale(vecType<floatType, P> const & v)
{
GLM_STATIC_ASSERT(std::numeric_limits<floatType>::is_iec559, "'compScale' accepts only floating-point types for 'floatType' template parameter");
return detail::compute_compScale<T, floatType, P, vecType, std::numeric_limits<T>::is_integer, std::numeric_limits<T>::is_signed>::call(v);
}
template <typename uintType, typename floatType, precision P, template <int, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<D, uintType, P> packUnorm(vecType<floatType, P> const & v)
template <typename uintType, typename floatType, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<uintType, P> packUnorm(vecType<floatType, P> const & v)
{
GLM_STATIC_ASSERT(std::numeric_limits<uintType>::is_integer, "uintType must be an integer type");
GLM_STATIC_ASSERT(std::numeric_limits<floatType>::is_iec559, "floatType must be a floating point type");
return vecType<D, uintType, P>(round(clamp(v, static_cast<floatType>(0), static_cast<floatType>(1)) * static_cast<floatType>(std::numeric_limits<uintType>::max())));
return vecType<uintType, P>(round(clamp(v, static_cast<floatType>(0), static_cast<floatType>(1)) * static_cast<floatType>(std::numeric_limits<uintType>::max())));
}
template <typename uintType, typename floatType, precision P, template <int, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<floatType, P> unpackUnorm(vecType<D, uintType, P> const & v)
template <typename uintType, typename floatType, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<floatType, P> unpackUnorm(vecType<uintType, P> const & v)
{
GLM_STATIC_ASSERT(std::numeric_limits<uintType>::is_integer, "uintType must be an integer type");
GLM_STATIC_ASSERT(std::numeric_limits<floatType>::is_iec559, "floatType must be a floating point type");
return vecType<D, float, P>(v) * (static_cast<floatType>(1) / static_cast<floatType>(std::numeric_limits<uintType>::max()));
return vecType<float, P>(v) * (static_cast<floatType>(1) / static_cast<floatType>(std::numeric_limits<uintType>::max()));
}
GLM_FUNC_QUALIFIER uint8 packUnorm2x3_1x2(vec3 const & v)
@ -376,14 +376,14 @@ namespace detail
return vec3(Unpack.data.x, Unpack.data.y, Unpack.data.z) * pow(2.0f, Unpack.data.w - 15.f - 9.f);
}
template <int D, precision P, template <int, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<D, uint16, P> packHalf(vecType<D, float, P> const & v)
template <precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<uint16, P> packHalf(vecType<float, P> const & v)
{
return detail::compute_half<P, vecType>::pack(v);
}
template <int D, precision P, template <int, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<D, float, P> unpackHalf(vecType<D, uint16, P> const & v)
template <precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<float, P> unpackHalf(vecType<uint16, P> const & v)
{
return detail::compute_half<P, vecType>::unpack(v);
}

40
test/external/gli/format.hpp vendored
View File

@ -305,35 +305,35 @@ namespace gli
/// Return the number of components of a format
size_t component_count(format Format);
/// Evaluate whether a format is unsigned
bool is_unsigned(format Format);
/// Evaluate whether a format is unsigned
bool is_unsigned(format Format);
/// Evaluate whether a format is signed
bool is_signed(format Format);
/// Evaluate whether a format is signed
bool is_signed(format Format);
/// Evaluate whether the format is an integer format
bool is_integer(format Format);
/// Evaluate whether the format is an integer format
bool is_integer(format Format);
/// Evaluate whether the format is a signed integer format
bool is_signed_integer(format Format);
/// Evaluate whether the format is a signed integer format
bool is_signed_integer(format Format);
/// Evaluate whether the format is an unsigned integer format
bool is_unsigned_integer(format Format);
/// Evaluate whether the format is an unsigned integer format
bool is_unsigned_integer(format Format);
/// Evaluate whether the format is an float format
bool is_float(format Format);
/// Evaluate whether the format is an float format
bool is_float(format Format);
/// Evaluate whether the format is normalized
bool is_normalized(format Format);
/// Evaluate whether the format is normalized
bool is_normalized(format Format);
/// Evaluate whether the format is an unsigned normalized format
bool is_unorm(format Format);
/// Evaluate whether the format is an unsigned normalized format
bool is_unorm(format Format);
/// Evaluate whether the format is a signed normalized format
bool is_snorm(format Format);
/// Evaluate whether the format is a signed normalized format
bool is_snorm(format Format);
/// Evaluate whether the format is packed
bool is_packed(format Format);
/// Evaluate whether the format is packed
bool is_packed(format Format);
}//namespace gli

2
test/external/gli/gl.hpp vendored
View File

@ -328,7 +328,7 @@ namespace gli
PROFILE_KTX
};
typedef glm::tvec4<int> swizzles;
typedef glm::vec<4, int> swizzles;
struct format
{

1
test/external/gli/gli.hpp vendored
View File

@ -59,6 +59,7 @@ namespace gli
#include "sampler_cube_array.hpp"
#include "duplicate.hpp"
#include "convert.hpp"
#include "view.hpp"
#include "comparison.hpp"

4
test/external/gli/levels.hpp vendored
View File

@ -18,8 +18,8 @@ namespace gli
/// gli::texture2d::extent_type Extent(32, 10);
/// gli::texture2d Texture(gli::levels(Extent));
/// @endcode
template <int D, typename T, precision P, template <int, typename, precision> class vecType>
T levels(vecType<D, T, P> const& Extent);
template <typename T, precision P, template <typename, precision> class vecType>
T levels(vecType<T, P> const& Extent);
/*
/// Compute the number of mipmaps levels necessary to create a mipmap complete texture
///

4
test/external/gli/sampler1d.hpp vendored
View File

@ -24,8 +24,8 @@ namespace gli
typedef typename texture_type::size_type size_type;
typedef typename texture_type::extent_type extent_type;
typedef interpolate_type level_type;
typedef tvec1<interpolate_type, P> normalized_type;
typedef tvec4<T, P> texel_type;
typedef vec<1, interpolate_type, P> normalized_type;
typedef vec<4, T, P> texel_type;
sampler1d(texture_type const& Texture, wrap Wrap, filter Mip = FILTER_NEAREST, filter Min = FILTER_NEAREST, texel_type const& BorderColor = texel_type(0, 0, 0, 1));

4
test/external/gli/sampler1d_array.hpp vendored
View File

@ -24,8 +24,8 @@ namespace gli
typedef typename texture_type::size_type size_type;
typedef typename texture_type::extent_type extent_type;
typedef interpolate_type level_type;
typedef tvec1<interpolate_type, P> normalized_type;
typedef tvec4<T, P> texel_type;
typedef vec<1, interpolate_type, P> normalized_type;
typedef vec<4, T, P> texel_type;
sampler1d_array(texture_type const& Texture, wrap Wrap, filter Mip = FILTER_NEAREST, filter Min = FILTER_NEAREST, texel_type const& BorderColor = texel_type(0, 0, 0, 1));

4
test/external/gli/sampler2d.hpp vendored
View File

@ -24,8 +24,8 @@ namespace gli
typedef typename texture_type::size_type size_type;
typedef typename texture_type::extent_type extent_type;
typedef interpolate_type level_type;
typedef tvec2<interpolate_type, P> normalized_type;
typedef tvec4<T, P> texel_type;
typedef vec<2, interpolate_type, P> normalized_type;
typedef vec<4, T, P> texel_type;
sampler2d(texture_type const& Texture, wrap Wrap, filter Mip = FILTER_NEAREST, filter Min = FILTER_NEAREST, texel_type const& BorderColor = texel_type(0, 0, 0, 1));

4
test/external/gli/sampler2d_array.hpp vendored
View File

@ -24,8 +24,8 @@ namespace gli
typedef typename texture_type::size_type size_type;
typedef typename texture_type::extent_type extent_type;
typedef interpolate_type level_type;
typedef tvec2<interpolate_type, P> normalized_type;
typedef tvec4<T, P> texel_type;
typedef vec<2, interpolate_type, P> normalized_type;
typedef vec<4, T, P> texel_type;
sampler2d_array(texture_type const& Texture, wrap Wrap, filter Mip = FILTER_NEAREST, filter Min = FILTER_NEAREST, texel_type const& BorderColor = texel_type(0, 0, 0, 1));

4
test/external/gli/sampler3d.hpp vendored
View File

@ -24,8 +24,8 @@ namespace gli
typedef typename texture_type::size_type size_type;
typedef typename texture_type::extent_type extent_type;
typedef interpolate_type level_type;
typedef tvec3<interpolate_type, P> normalized_type;
typedef tvec4<T, P> texel_type;
typedef vec<3, interpolate_type, P> normalized_type;
typedef vec<4, T, P> texel_type;
sampler3d(texture_type const& Texture, wrap Wrap, filter Mip = FILTER_NEAREST, filter Min = FILTER_NEAREST, texel_type const& BorderColor = texel_type(0, 0, 0, 1));

4
test/external/gli/sampler_cube.hpp vendored
View File

@ -24,8 +24,8 @@ namespace gli
typedef typename texture_type::size_type size_type;
typedef typename texture_type::extent_type extent_type;
typedef interpolate_type level_type;
typedef tvec2<interpolate_type, P> normalized_type;
typedef tvec4<T, P> texel_type;
typedef vec<2, interpolate_type, P> normalized_type;
typedef vec<4, T, P> texel_type;
sampler_cube(texture_type const& Texture, wrap Wrap, filter Mip = FILTER_NEAREST, filter Min = FILTER_NEAREST, texel_type const& BorderColor = texel_type(0, 0, 0, 1));

4
test/external/gli/sampler_cube_array.hpp vendored
View File

@ -24,8 +24,8 @@ namespace gli
typedef typename texture_type::size_type size_type;
typedef typename texture_type::extent_type extent_type;
typedef interpolate_type level_type;
typedef tvec2<interpolate_type, P> normalized_type;
typedef tvec4<T, P> texel_type;
typedef vec<2, interpolate_type, P> normalized_type;
typedef vec<4, T, P> texel_type;
sampler_cube_array(texture_type const& Texture, wrap Wrap, filter Mip = FILTER_NEAREST, filter Min = FILTER_NEAREST, texel_type const& BorderColor = texel_type(0, 0, 0, 1));

18
test/external/gli/type.hpp vendored
View File

@ -10,7 +10,7 @@
#define GLM_FORCE_EXPLICIT_CTOR
#include <glm/glm.hpp>
#include <glm/gtc/vec1.hpp>
#include <glm/gtx/std_based_type.hpp>
#define GLM_ENABLE_EXPERIMENTAL
#if GLM_COMPILER & GLM_COMPILER_VC
# define GLI_FORCE_INLINE __forceinline
@ -34,31 +34,31 @@ namespace gli
using std::size_t;
typedef vec<1, int> extent1d;
typedef vec<2, int> extent2d;
typedef vec<3, int> extent3d;
typedef vec<4, int> extent4d;
typedef ivec1 extent1d;
typedef ivec2 extent2d;
typedef ivec3 extent3d;
typedef ivec4 extent4d;
template <typename T, precision P>
inline vec<4, T, P> make_vec4(vec<1, T, P> const& v)
inline vec<4, T, P> make_vec4(vec<1, T, P> const & v)
{
return vec<4, T, P>(v.x, static_cast<T>(0), static_cast<T>(0), static_cast<T>(1));
}
template <typename T, precision P>
inline vec<4, T, P> make_vec4(vec<2, T, P> const& v)
inline vec<4, T, P> make_vec4(vec<2, T, P> const & v)
{
return vec<4, T, P>(v.x, v.y, static_cast<T>(0), static_cast<T>(1));
}
template <typename T, precision P>
inline vec<4, T, P> make_vec4(vec<3, T, P> const& v)
inline vec<4, T, P> make_vec4(vec<3, T, P> const & v)
{
return vec<4, T, P>(v.x, v.y, v.z, static_cast<T>(1));
}
template <typename T, precision P>
inline vec<4, T, P> make_vec4(vec<4, T, P> const& v)
inline vec<4, T, P> make_vec4(vec<4, T, P> const & v)
{
return v;
}