Updated GLI for tests

test/external/gli/clear.hpp

@@ -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"

test/external/gli/convert.hpp

@@ -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"

test/external/gli/core/clear.hpp

@@ -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);
 

test/external/gli/core/convert_func.hpp

@@ -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<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<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<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, 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<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, 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, 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, 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, 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<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<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<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<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<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<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<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<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<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<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<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<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<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, 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<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, 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<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<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, 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<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<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<3, u8, tvec, CONVERT_MODE_332UNORM>::fetch, conv<3, u8, tvec, CONVERT_MODE_332UNORM>::write}				// FORMAT_RG3B2_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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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");
 

test/external/gli/core/coord.hpp

@@ -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);
 	}

test/external/gli/core/format.inl

@@ -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)
 	{

test/external/gli/core/levels.inl

@@ -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);
 	}

test/external/gli/core/reduce.inl

@@ -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)

test/external/gli/core/sampler.inl

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

test/external/gli/core/workaround.hpp

@@ -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);
 	}

test/external/gli/format.hpp

@@ -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
 

test/external/gli/gl.hpp

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

test/external/gli/gli.hpp

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

test/external/gli/levels.hpp

@@ -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
 	/// 

test/external/gli/sampler1d.hpp

@@ -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));
 

test/external/gli/sampler1d_array.hpp

@@ -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));
 

test/external/gli/sampler2d.hpp

@@ -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));
 

test/external/gli/sampler2d_array.hpp

@@ -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));
 

test/external/gli/sampler3d.hpp

@@ -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));
 

test/external/gli/sampler_cube.hpp

@@ -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));
 

test/external/gli/sampler_cube_array.hpp

@@ -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));
 

test/external/gli/type.hpp

@@ -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;
 	}