diff --git a/external/gli/gli/CMakeLists.txt b/external/gli/gli/CMakeLists.txt index 87142a82..46d803d1 100644 --- a/external/gli/gli/CMakeLists.txt +++ b/external/gli/gli/CMakeLists.txt @@ -1,10 +1,11 @@ -set(NAME gli) +set(NAME gli_dummy) file(GLOB ROOT_SOURCE *.cpp) file(GLOB ROOT_INLINE *.inl) file(GLOB ROOT_HEADER *.hpp) file(GLOB ROOT_TEXT ../*.txt) file(GLOB ROOT_MD ../*.md) +file(GLOB ROOT_KMG ../doc/spec/*.html) file(GLOB_RECURSE CORE_SOURCE ./core/*.cpp) file(GLOB_RECURSE CORE_INLINE ./core/*.inl) @@ -14,6 +15,7 @@ file(GLOB_RECURSE GTX_SOURCE ./gtx/*.cpp) file(GLOB_RECURSE GTX_INLINE ./gtx/*.inl) file(GLOB_RECURSE GTX_HEADER ./gtx/*.hpp) +source_group("KMG Spec" FILES ${ROOT_KMG}) source_group("Text Files" FILES ${ROOT_TEXT} ${ROOT_MD}) source_group("Core Files" FILES ${CORE_SOURCE}) source_group("Core Files" FILES ${CORE_INLINE}) @@ -24,7 +26,7 @@ source_group("GTX Files" FILES ${GTX_HEADER}) include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..) -add_executable(${NAME} ${ROOT_TEXT} ${ROOT_MD} +add_executable(${NAME} ${ROOT_TEXT} ${ROOT_MD} ${ROOT_KMG} ${ROOT_SOURCE} ${ROOT_INLINE} ${ROOT_HEADER} ${CORE_SOURCE} ${CORE_INLINE} ${CORE_HEADER} ${GTX_SOURCE} ${GTX_INLINE} ${GTX_HEADER}) diff --git a/external/gli/gli/clear.hpp b/external/gli/gli/clear.hpp new file mode 100644 index 00000000..db5a98f8 --- /dev/null +++ b/external/gli/gli/clear.hpp @@ -0,0 +1,46 @@ +/// @brief Include to copy textures or a subset of either textures. These operations are performed without memory allocations. +/// @file gli/clear.hpp + +#pragma once + +namespace gli +{ + /// Clear a complete texture + template + void clear(texture_type& Texture); + + /// Clear a complete texture + template + void clear(texture_type& Texture, gen_type const& BlockData); + + /// Clear a specific image of a texture + template + void clear(texture_type& Texture, size_t Layer, size_t Face, size_t Level, gen_type const& BlockData); + + // Clear an entire level of a texture + template + void clear_level(texture_type& Texture, size_t BaseLevel, gen_type const& BlockData); + + // Clear multiple levels of a texture + template + void clear_level(texture_type& Texture, size_t BaseLevel, size_t LevelCount, gen_type const& BlockData); + + // Clear an entire face of a texture + template + void clear_face(texture_type& Texture, size_t BaseFace, gen_type const& BlockData); + + // Clear multiple faces of a texture + template + void clear_face(texture_type& Texture, size_t BaseFace, size_t FaceCount, gen_type const& BlockData); + + // Clear an entire layer of a texture + template + void clear_layer(texture_type& Texture, size_t BaseLayer, gen_type const& BlockData); + + // Clear multiple layers of a texture + template + void clear_layer(texture_type& Texture, size_t BaseLayer, size_t LayerCount, gen_type const& BlockData); +}//namespace gli + +#include "./core/clear.inl" + diff --git a/external/gli/gli/comparison.hpp b/external/gli/gli/comparison.hpp index 4154a331..687cca4e 100644 --- a/external/gli/gli/comparison.hpp +++ b/external/gli/gli/comparison.hpp @@ -1,30 +1,5 @@ -/////////////////////////////////////////////////////////////////////////////////// -/// OpenGL Image (gli.g-truc.net) -/// -/// Copyright (c) 2008 - 2015 G-Truc Creation (www.g-truc.net) -/// Permission is hereby granted, free of charge, to any person obtaining a copy -/// of this software and associated documentation files (the "Software"), to deal -/// in the Software without restriction, including without limitation the rights -/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -/// copies of the Software, and to permit persons to whom the Software is -/// furnished to do so, subject to the following conditions: -/// -/// The above copyright notice and this permission notice shall be included in -/// all copies or substantial portions of the Software. -/// -/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -/// THE SOFTWARE. -/// -/// @ref core +/// @brief Include to use operators to compare whether two textures or images are equal /// @file gli/comparison.hpp -/// @date 2013-02-04 / 2013-02-04 -/// @author Christophe Riccio -/////////////////////////////////////////////////////////////////////////////////// #pragma once @@ -39,11 +14,17 @@ namespace gli { - bool operator==(image const & ImageA, image const & ImageB); - bool operator!=(image const & ImageA, image const & ImageB); + /// Compare two images. Two images are equal when the date is the same. + bool operator==(image const& ImageA, image const& ImageB); - bool operator==(texture const & A, texture const & B); - bool operator!=(texture const & A, texture const & B); + /// Compare two images. Two images are equal when the date is the same. + bool operator!=(image const& ImageA, image const& ImageB); + + /// Compare two textures. Two textures are the same when the data, the format and the targets are the same. + bool operator==(texture const& A, texture const& B); + + /// Compare two textures. Two textures are the same when the data, the format and the targets are the same. + bool operator!=(texture const& A, texture const& B); }//namespace gli #include "./core/comparison.inl" diff --git a/external/gli/gli/convert.hpp b/external/gli/gli/convert.hpp new file mode 100644 index 00000000..21d90d9a --- /dev/null +++ b/external/gli/gli/convert.hpp @@ -0,0 +1,24 @@ +/// @brief Include to copy textures, images or a subset of either textures or an images. These operations will cause memory allocations. +/// @file gli/convert.hpp + +#pragma once + +#include "texture1d.hpp" +#include "texture1d_array.hpp" +#include "texture2d.hpp" +#include "texture2d_array.hpp" +#include "texture3d.hpp" +#include "texture_cube.hpp" +#include "texture_cube_array.hpp" + +namespace gli +{ + /// Convert texture data to a new format + /// + /// @param Texture Source texture, the format must be uncompressed. + /// @param Format Destination Texture format, it must be uncompressed. + template + texture_type convert(texture_type const& Texture, format Format); +}//namespace gli + +#include "./core/convert.inl" diff --git a/external/gli/gli/copy.hpp b/external/gli/gli/copy.hpp index 9550b132..ec32f87a 100644 --- a/external/gli/gli/copy.hpp +++ b/external/gli/gli/copy.hpp @@ -1,98 +1,62 @@ -/////////////////////////////////////////////////////////////////////////////////// -/// OpenGL Image (gli.g-truc.net) -/// -/// Copyright (c) 2008 - 2015 G-Truc Creation (www.g-truc.net) -/// Permission is hereby granted, free of charge, to any person obtaining a copy -/// of this software and associated documentation files (the "Software"), to deal -/// in the Software without restriction, including without limitation the rights -/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -/// copies of the Software, and to permit persons to whom the Software is -/// furnished to do so, subject to the following conditions: -/// -/// The above copyright notice and this permission notice shall be included in -/// all copies or substantial portions of the Software. -/// -/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -/// THE SOFTWARE. -/// -/// @ref core +/// @brief Include to copy textures or a subset of either textures. These operations are performed without memory allocations. /// @file gli/copy.hpp -/// @date 2013-02-01 / 2013-02-03 -/// @author Christophe Riccio -/////////////////////////////////////////////////////////////////////////////////// #pragma once -#include "image.hpp" -#include "texture1d.hpp" -#include "texture1d_array.hpp" -#include "texture2d.hpp" -#include "texture2d_array.hpp" -#include "texture3d.hpp" -#include "texture_cube.hpp" -#include "texture_cube_array.hpp" +#include "type.hpp" namespace gli { - /// Copy an image and create a new image with a new storage allocation. - image copy(image const & Image); + /// Copy a specific image of a texture + template + void copy( + texture_src_type const& TextureSrc, size_t LayerSrc, size_t FaceSrc, size_t LevelSrc, + texture_dst_type& TextureDst, size_t LayerDst, size_t FaceDst, size_t LevelDst); - /// Copy a texture and create a new texture with a new storage allocation. - texture copy(texture const & Texture); + /// Copy a texture + template + void copy( + texture_src_type const& TextureSrc, + texture_dst_type& TextureDst); - /// Copy a texture and create a new texture with a new storage allocation. - template - texture copy(texType const & Texture); + // Copy an entire level of a texture + template + void copy_level( + texture_src_type const& TextureSrc, size_t BaseLevelSrc, + texture_dst_type& TextureDst, size_t BaseLevelDst); - /// Copy a texture and create a new texture with a new storage allocation but a different format. - /// The format must be a compatible format, a format which block size match the original format. - template - texture copy(texType const & Texture, format Format); + // Copy multiple levels of a texture + template + void copy_level( + texture_src_type const& TextureSrc, size_t BaseLevelSrc, + texture_dst_type& TextureDst, size_t BaseLevelDst, + size_t LevelCount); - /// Copy a subset of a texture and create a new texture with a new storage allocation. - texture copy( - texture1D const & Texture, - texture1D::size_type BaseLevel, texture1D::size_type MaxLevel); + // Copy an entire face of a texture + template + void copy_face( + texture_src_type const& TextureSrc, size_t BaseFaceSrc, + texture_dst_type& TextureDst, size_t BaseFaceDst); - /// Copy a subset of a texture and create a new texture with a new storage allocation. - texture copy( - texture1DArray const & Texture, - texture1DArray::size_type BaseLayer, texture1DArray::size_type MaxLayer, - texture1DArray::size_type BaseLevel, texture1DArray::size_type MaxLevel); + // Copy multiple faces of a texture + template + void copy_face( + texture_src_type const& TextureSrc, size_t BaseFaceSrc, + texture_dst_type& TextureDst, size_t BaseFaceDst, + size_t FaceCount); - /// Copy a subset of a texture and create a new texture with a new storage allocation. - texture copy( - texture2D const & Texture, - texture2D::size_type BaseLevel, texture2D::size_type MaxLevel); + // Copy an entire layer of a texture + template + void copy_layer( + texture_src_type const& TextureSrc, size_t BaseLayerSrc, + texture_dst_type& TextureDst, size_t BaseLayerDst); - /// Copy a subset of a texture and create a new texture with a new storage allocation. - texture copy( - texture2DArray const & Texture, - texture2DArray::size_type BaseLayer, texture2DArray::size_type MaxLayer, - texture2DArray::size_type BaseLevel, texture2DArray::size_type MaxLevel); - - /// Copy a subset of a texture and create a new texture with a new storage allocation. - texture copy( - texture3D const & Texture, - texture3D::size_type BaseLevel, texture3D::size_type MaxLevel); - - /// Copy a subset of a texture and create a new texture with a new storage allocation. - texture copy( - textureCube const & Texture, - textureCube::size_type BaseFace, textureCube::size_type MaxFace, - textureCube::size_type BaseLevel, textureCube::size_type MaxLevel); - - /// Copy a subset of a texture and create a new texture with a new storage allocation. - texture copy( - textureCubeArray const & Texture, - textureCubeArray::size_type BaseLayer, textureCubeArray::size_type MaxLayer, - textureCubeArray::size_type BaseFace, textureCubeArray::size_type MaxFace, - textureCubeArray::size_type BaseLevel, textureCubeArray::size_type MaxLevel); + // Copy multiple layers of a texture + template + void copy_layer( + texture_src_type const& TextureSrc, size_t BaseLayerSrc, + texture_dst_type& TextureDst, size_t BaseLayerDst, + size_t LayerCount); }//namespace gli #include "./core/copy.inl" diff --git a/external/gli/gli/core/clear.hpp b/external/gli/gli/core/clear.hpp new file mode 100644 index 00000000..8516c371 --- /dev/null +++ b/external/gli/gli/core/clear.hpp @@ -0,0 +1,25 @@ +#pragma once + +#include "convert_func.hpp" + +namespace gli{ +namespace detail +{ + template + struct clear + { + static void call(textureType & Texture, typename convert::writeFunc Write, vec<4, T, P> const& Color) + { + GLI_ASSERT(Write); + + texture const ConvertTexel(Texture.target(), Texture.format(), texture::extent_type(1), 1, 1, 1); + textureType Texel(ConvertTexel); + Write(Texel, typename textureType::extent_type(0), 0, 0, 0, Color); + + size_t const BlockSize(block_size(Texture.format())); + for(size_t BlockIndex = 0, BlockCount = Texture.size() / BlockSize; BlockIndex < BlockCount; ++BlockIndex) + memcpy(static_cast(Texture.data()) + BlockSize * BlockIndex, Texel.data(), BlockSize); + } + }; +}//namespace detail +}//namespace gli diff --git a/external/gli/gli/core/clear.inl b/external/gli/gli/core/clear.inl new file mode 100644 index 00000000..d7c682d8 --- /dev/null +++ b/external/gli/gli/core/clear.inl @@ -0,0 +1,71 @@ +namespace gli +{ + template + inline void clear(texture_type& Texture) + { + Texture.clear(); + } + + template + inline void clear(texture_type& Texture, gen_type const& BlockData) + { + Texture.clear(BlockData); + } + + template + inline void clear(texture_type& Texture, size_t Layer, size_t Face, size_t Level, gen_type const& BlockData) + { + Texture.clear(Layer, Face, Level, BlockData); + } + + template + inline void clear_level(texture_type& Texture, size_t BaseLevel, size_t LevelCount, gen_type const& BlockData) + { + for(size_t LayerIndex = 0, LayerCount = Texture.layers(); LayerIndex < LayerCount; ++LayerIndex) + for(size_t FaceIndex = 0, FaceCount = Texture.faces(); FaceIndex < FaceCount; ++FaceIndex) + for(size_t LevelIndex = 0; LevelIndex < LevelCount; ++LevelIndex) + { + Texture.template clear(LayerIndex, FaceIndex, BaseLevel + LevelIndex, BlockData); + } + } + + template + inline void clear_level(texture_type& Texture, size_t BaseLevel, gen_type const& BlockData) + { + clear_level(Texture, BaseLevel, 1, BlockData); + } + + template + inline void clear_face(texture_type& Texture, size_t BaseFace, size_t FaceCount, gen_type const& BlockData) + { + for(size_t LayerIndex = 0, LayerCount = Texture.layers(); LayerIndex < LayerCount; ++LayerIndex) + for(size_t FaceIndex = 0; FaceIndex < FaceCount; ++FaceIndex) + for(size_t LevelIndex = 0, LevelCount = Texture.levels(); LevelIndex < LevelCount; ++LevelIndex) + { + Texture.template clear(LayerIndex, BaseFace + FaceIndex, LevelIndex, BlockData); + } + } + + template + inline void clear_face(texture_type& Texture, size_t BaseFace, gen_type const& BlockData) + { + clear_face(Texture, BaseFace, 1, BlockData); + } + + template + inline void clear_layer(texture_type& Texture, size_t BaseLayer, size_t LayerCount, gen_type const& BlockData) + { + for(size_t LayerIndex = 0; LayerIndex < LayerCount; ++LayerIndex) + for(size_t FaceIndex = 0, FaceCount = Texture.faces(); FaceIndex < FaceCount; ++FaceIndex) + for(size_t LevelIndex = 0, LevelCount = Texture.levels(); LevelIndex < LevelCount; ++LevelIndex) + { + Texture.template clear(LayerIndex + BaseLayer, FaceIndex, LevelIndex, BlockData); + } + } + + template + inline void clear_layer(texture_type& Texture, size_t BaseLayer, gen_type const& BlockData) + { + clear_layer(Texture, BaseLayer, 1, BlockData); + } +}//namespace gli diff --git a/external/gli/gli/core/comparison.inl b/external/gli/gli/core/comparison.inl index 52fe748f..df920b48 100644 --- a/external/gli/gli/core/comparison.inl +++ b/external/gli/gli/core/comparison.inl @@ -1,31 +1,3 @@ -/////////////////////////////////////////////////////////////////////////////////// -/// OpenGL Image (gli.g-truc.net) -/// -/// Copyright (c) 2008 - 2015 G-Truc Creation (www.g-truc.net) -/// Permission is hereby granted, free of charge, to any person obtaining a copy -/// of this software and associated documentation files (the "Software"), to deal -/// in the Software without restriction, including without limitation the rights -/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -/// copies of the Software, and to permit persons to whom the Software is -/// furnished to do so, subject to the following conditions: -/// -/// The above copyright notice and this permission notice shall be included in -/// all copies or substantial portions of the Software. -/// -/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -/// THE SOFTWARE. -/// -/// @ref core -/// @file gli/core/comparison.inl -/// @date 2013-02-04 / 2013-02-04 -/// @author Christophe Riccio -/////////////////////////////////////////////////////////////////////////////////// - #include namespace gli{ @@ -33,44 +5,43 @@ namespace detail { inline bool equalData(texture const & TextureA, texture const & TextureB) { + GLI_ASSERT(TextureA.size() == TextureB.size()); + if(TextureA.data() == TextureB.data()) return true; - void const* PointerA = TextureA.data(); - void const* PointerB = TextureB.data(); - if(std::memcmp(PointerA, PointerB, TextureA.size()) == 0) - return true; + for(texture::size_type LayerIndex = 0, LayerCount = TextureA.layers(); LayerIndex < LayerCount; ++LayerIndex) + for(texture::size_type FaceIndex = 0, FaceCount = TextureA.faces(); FaceIndex < FaceCount; ++FaceIndex) + for(texture::size_type LevelIndex = 0, LevelCount = TextureA.levels(); LevelIndex < LevelCount; ++LevelIndex) + { + void const* PointerA = TextureA.data(LayerIndex, FaceIndex, LevelIndex); + void const* PointerB = TextureB.data(LayerIndex, FaceIndex, LevelIndex); + if(std::memcmp(PointerA, PointerB, TextureA.size(LevelIndex)) != 0) + return false; + } - return false; + return true; } }//namespace detail inline bool operator==(image const & ImageA, image const & ImageB) { - if(!glm::all(glm::equal(ImageA.dimensions(), ImageB.dimensions()))) + if(!glm::all(glm::equal(ImageA.extent(), ImageB.extent()))) return false; if(ImageA.size() != ImageB.size()) return false; - for(std::size_t i = 0; i < ImageA.size(); ++i) - if(*(ImageA.data() + i) != *(ImageB.data() + i)) - return false; - - return true; + return std::memcmp(ImageA.data(), ImageB.data(), ImageA.size()) == 0; } inline bool operator!=(image const & ImageA, image const & ImageB) { - if(!glm::all(glm::equal(ImageA.dimensions(), ImageB.dimensions()))) + if(!glm::all(glm::equal(ImageA.extent(), ImageB.extent()))) return true; if(ImageA.size() != ImageB.size()) return true; - for(std::size_t i = 0; i < ImageA.size(); ++i) - if(*(ImageA.data() + i) != *(ImageB.data() + i)) - return true; - - return false; + return std::memcmp(ImageA.data(), ImageB.data(), ImageA.size()) != 0; } inline bool equal(texture const & TextureA, texture const & TextureB) @@ -117,12 +88,12 @@ namespace detail return !detail::equalData(TextureA, TextureB); } - inline bool operator==(gli::texture const & A, gli::texture const & B) + inline bool operator==(texture const & A, texture const & B) { return gli::equal(A, B); } - inline bool operator!=(gli::texture const & A, gli::texture const & B) + inline bool operator!=(texture const & A, texture const & B) { return gli::notEqual(A, B); } diff --git a/external/gli/gli/core/convert.inl b/external/gli/gli/core/convert.inl new file mode 100644 index 00000000..b9e5d2e8 --- /dev/null +++ b/external/gli/gli/core/convert.inl @@ -0,0 +1,45 @@ +#include "../core/convert_func.hpp" + +namespace gli +{ + template + inline texture_type convert(texture_type const& Texture, format Format) + { + typedef float T; + typedef typename texture::extent_type extent_type; + typedef typename texture_type::size_type size_type; + typedef typename extent_type::value_type component_type; + typedef typename detail::convert::fetchFunc fetch_type; + typedef typename detail::convert::writeFunc write_type; + + GLI_ASSERT(!Texture.empty()); + GLI_ASSERT(!is_compressed(Texture.format()) && !is_compressed(Format)); + + fetch_type Fetch = detail::convert::call(Texture.format()).Fetch; + write_type Write = detail::convert::call(Format).Write; + + texture Storage(Texture.target(), Format, Texture.texture::extent(), Texture.layers(), Texture.faces(), Texture.levels(), Texture.swizzles()); + texture_type Copy(Storage); + + for(size_type Layer = 0; Layer < Texture.layers(); ++Layer) + for(size_type Face = 0; Face < Texture.faces(); ++Face) + for(size_type Level = 0; Level < Texture.levels(); ++Level) + { + extent_type const& Dimensions = Texture.texture::extent(Level); + + for(component_type k = 0; k < Dimensions.z; ++k) + for(component_type j = 0; j < Dimensions.y; ++j) + for(component_type i = 0; i < Dimensions.x; ++i) + { + typename texture_type::extent_type const Texelcoord(extent_type(i, j, k)); + Write( + Copy, Texelcoord, Layer, Face, Level, + Fetch(Texture, Texelcoord, Layer, Face, Level)); + } + } + + return texture_type(Copy); + } + +}//namespace gli + diff --git a/external/gli/gli/core/convert_func.hpp b/external/gli/gli/core/convert_func.hpp new file mode 100644 index 00000000..b16bea0f --- /dev/null +++ b/external/gli/gli/core/convert_func.hpp @@ -0,0 +1,767 @@ +#pragma once + +#include "../type.hpp" +#include "../texture1d.hpp" +#include "../texture1d_array.hpp" +#include "../texture2d.hpp" +#include "../texture2d_array.hpp" +#include "../texture3d.hpp" +#include "../texture_cube.hpp" +#include "../texture_cube_array.hpp" +#include +#include +#include + +namespace gli{ +namespace detail +{ + enum convertMode + { + CONVERT_MODE_DEFAULT, + CONVERT_MODE_CAST, + CONVERT_MODE_NORM, + CONVERT_MODE_SRGB, + CONVERT_MODE_HALF, + CONVERT_MODE_RGB9E5, + CONVERT_MODE_RG11B10F, + CONVERT_MODE_RGB10A2UNORM, + CONVERT_MODE_RGB10A2SNORM, + CONVERT_MODE_RGB10A2USCALE, + CONVERT_MODE_RGB10A2SSCALE, + CONVERT_MODE_RGB10A2UINT, + CONVERT_MODE_RGB10A2SINT, + CONVERT_MODE_44UNORM, + CONVERT_MODE_44SCALED, + CONVERT_MODE_4444UNORM, + CONVERT_MODE_4444SCALED, + CONVERT_MODE_565UNORM, + CONVERT_MODE_565SCALED, + CONVERT_MODE_5551UNORM, + CONVERT_MODE_5551SCALED, + CONVERT_MODE_332UNORM + }; + + template + struct accessFunc + {}; + + template + struct accessFunc + { + static genType load(texture1d const & Texture, texture1d::extent_type const & TexelCoord, texture1d::size_type Layer, texture1d::size_type Face, texture1d::size_type Level) + { + GLI_ASSERT(Layer == 0 && Face == 0); + return Texture.load(TexelCoord, Level); + } + + static void store(texture1d & Texture, texture1d::extent_type const & TexelCoord, texture1d::size_type Layer, texture1d::size_type Face, texture1d::size_type Level, genType const & Texel) + { + GLI_ASSERT(Layer == 0 && Face == 0); + Texture.store(TexelCoord, Level, Texel); + } + }; + + template + struct accessFunc + { + static genType load(texture1d_array const& Texture, texture1d_array::extent_type const& TexelCoord, texture1d_array::size_type Layer, texture1d_array::size_type Face, texture1d_array::size_type Level) + { + GLI_ASSERT(Face == 0); + return Texture.load(TexelCoord, Layer, Level); + } + + static void store(texture1d_array& Texture, texture1d_array::extent_type const& TexelCoord, texture1d_array::size_type Layer, texture1d_array::size_type Face, texture1d_array::size_type Level, genType const& Texel) + { + GLI_ASSERT(Face == 0); + Texture.store(TexelCoord, Layer, Level, Texel); + } + }; + + template + struct accessFunc + { + static genType load(texture2d const & Texture, texture2d::extent_type const & TexelCoord, texture2d::size_type Layer, texture2d::size_type Face, texture2d::size_type Level) + { + GLI_ASSERT(Layer == 0 && Face == 0); + return Texture.load(TexelCoord, Level); + } + + static void store(texture2d & Texture, texture2d::extent_type const & TexelCoord, texture2d::size_type Layer, texture2d::size_type Face, texture2d::size_type Level, genType const & Texel) + { + GLI_ASSERT(Layer == 0 && Face == 0); + Texture.store(TexelCoord, Level, Texel); + } + }; + + template + struct accessFunc + { + static genType load(texture2d_array const & Texture, texture2d_array::extent_type const & TexelCoord, texture2d_array::size_type Layer, texture2d_array::size_type Face, texture2d_array::size_type Level) + { + GLI_ASSERT(Face == 0); + return Texture.load(TexelCoord, Layer, Level); + } + + static void store(texture2d_array & Texture, texture2d_array::extent_type const & TexelCoord, texture2d_array::size_type Layer, texture2d_array::size_type Face, texture2d_array::size_type Level, genType const & Texel) + { + GLI_ASSERT(Face == 0); + Texture.store(TexelCoord, Layer, Level, Texel); + } + }; + + template + struct accessFunc + { + static genType load(texture3d const & Texture, texture3d::extent_type const & TexelCoord, texture3d::size_type Layer, texture3d::size_type Face, texture3d::size_type Level) + { + GLI_ASSERT(Layer == 0 && Face == 0); + return Texture.load(TexelCoord, Level); + } + + static void store(texture3d & Texture, texture3d::extent_type const & TexelCoord, texture3d::size_type Layer, texture3d::size_type Face, texture3d::size_type Level, genType const & Texel) + { + GLI_ASSERT(Layer == 0 && Face == 0); + Texture.store(TexelCoord, Level, Texel); + } + }; + + template + struct accessFunc + { + static genType load(texture_cube const& Texture, texture_cube::extent_type const& TexelCoord, texture_cube::size_type Layer, texture_cube::size_type Face, texture_cube::size_type Level) + { + GLI_ASSERT(Layer == 0); + return Texture.load(TexelCoord, Face, Level); + } + + static void store(texture_cube& Texture, texture_cube::extent_type const& TexelCoord, texture_cube::size_type Layer, texture_cube::size_type Face, texture_cube::size_type Level, genType const& Texel) + { + GLI_ASSERT(Layer == 0); + Texture.store(TexelCoord, Face, Level, Texel); + } + }; + + template + struct accessFunc + { + static genType load(texture_cube_array const & Texture, texture_cube_array::extent_type const & TexelCoord, texture_cube_array::size_type Layer, texture_cube_array::size_type Face, texture_cube_array::size_type Level) + { + return Texture.load(TexelCoord, Layer, Face, Level); + } + + static void store(texture_cube_array & Texture, texture_cube_array::extent_type const & TexelCoord, texture_cube_array::size_type Layer, texture_cube_array::size_type Face, texture_cube_array::size_type Level, genType const & Texel) + { + Texture.store(TexelCoord, Layer, Face, Level, Texel); + } + }; + + // convertFunc class + + template + struct convertFunc + { + typedef accessFunc > 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(vec(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, vec(Texel)); + } + }; + + template + struct convertFunc + { + 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 vec<4, retType, P>(0, 0, 0, 1); + } + + 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) + {} + }; + + template + struct convertFunc + { + typedef accessFunc > 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::is_iec559, "CONVERT_MODE_NORM requires a float sampler"); + return make_vec4(compNormalize(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::is_iec559, "CONVERT_MODE_NORM requires a float sampler"); + access::store(Texture, TexelCoord, Layer, Face, Level, compScale(vec(Texel))); + } + }; + + template + struct convertFunc + { + typedef accessFunc > 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::is_iec559, "CONVERT_MODE_SRGB requires a float sampler"); + return make_vec4(convertSRGBToLinear(compNormalize(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::is_iec559, "CONVERT_MODE_SRGB requires a float sampler"); + access::store(Texture, TexelCoord, Layer, Face, Level, gli::compScale(convertLinearToSRGB(vec(Texel)))); + } + }; + + template + struct convertFunc + { + typedef accessFunc 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::is_iec559, "CONVERT_MODE_RGB9E5 requires a float sampler"); + return vec<4, retType, P>(unpackF3x9_E1x5(access::load(Texture, TexelCoord, Layer, Face, Level)), static_cast(1)); + } + + 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::is_iec559, "CONVERT_MODE_RGB9E5 requires a float sampler"); + access::store(Texture, TexelCoord, Layer, Face, Level, packF3x9_E1x5(vec<3, float, P>(Texel))); + } + }; + + template + struct convertFunc + { + typedef accessFunc 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::is_iec559, "CONVERT_MODE_RG11B10F requires a float sampler"); + return vec<4, retType, P>(unpackF2x11_1x10(access::load(Texture, TexelCoord, Layer, Face, Level)), static_cast(1)); + } + + 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::is_iec559, "CONVERT_MODE_RG11B10F requires a float sampler"); + access::store(Texture, TexelCoord, Layer, Face, Level, packF2x11_1x10(vec<3, float, P>(Texel))); + } + }; + + template + struct convertFunc + { + typedef accessFunc > 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::is_iec559, "CONVERT_MODE_HALF requires a float sampler"); + return make_vec4(vec(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::is_iec559, "CONVERT_MODE_HALF requires a float sampler"); + access::store(Texture, TexelCoord, Layer, Face, Level, packHalf(vec(Texel))); + } + }; + + template + struct convertFunc + { + typedef accessFunc 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::is_iec559, "CONVERT_MODE_44UNORM requires a float sampler"); + return vec<4, retType, P>(vec<2, retType, P>(unpackUnorm2x4(access::load(Texture, TexelCoord, Layer, Face, Level))), static_cast(0), static_cast(1)); + } + + 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::is_iec559, "CONVERT_MODE_44UNORM requires a float sampler"); + access::store(Texture, TexelCoord, Layer, Face, Level, packUnorm2x4(vec<2, float, P>(Texel))); + } + }; + + template + struct convertFunc + { + typedef accessFunc 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::is_iec559, "CONVERT_MODE_4444UNORM requires a float sampler"); + return vec<4, retType, P>(unpackUnorm4x4(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::is_iec559, "CONVERT_MODE_4444UNORM requires a float sampler"); + access::store(Texture, TexelCoord, Layer, Face, Level, packUnorm4x4(vec<4, float, P>(Texel))); + } + }; + + template + struct convertFunc + { + typedef accessFunc 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::is_iec559, "CONVERT_MODE_565UNORM requires a float sampler"); + return vec<4, retType, P>(unpackUnorm1x5_1x6_1x5(access::load(Texture, TexelCoord, Layer, Face, Level)), static_cast(1)); + } + + 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::is_iec559, "CONVERT_MODE_565UNORM requires a float sampler"); + access::store(Texture, TexelCoord, Layer, Face, Level, packUnorm1x5_1x6_1x5(vec<3, float, P>(Texel))); + } + }; + + template + struct convertFunc + { + typedef accessFunc 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::is_iec559, "CONVERT_MODE_5551UNORM requires a float sampler"); + return vec<4, retType, P>(unpackUnorm3x5_1x1(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::is_iec559, "CONVERT_MODE_5551UNORM requires a float sampler"); + access::store(Texture, TexelCoord, Layer, Face, Level, packUnorm3x5_1x1(vec<4, float, P>(Texel))); + } + }; + + template + struct convertFunc + { + typedef accessFunc 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::is_iec559, "CONVERT_MODE_332UNORM requires a float sampler"); + return vec<4, retType, P>(unpackUnorm2x3_1x2(access::load(Texture, TexelCoord, Layer, Face, Level)), static_cast(1)); + } + + 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::is_iec559, "CONVERT_MODE_332UNORM requires a float sampler"); + access::store(Texture, TexelCoord, Layer, Face, Level, packUnorm2x3_1x2(vec<3, float, P>(Texel))); + } + }; + + template + struct convertFunc + { + typedef accessFunc 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::is_iec559, "CONVERT_MODE_RGB10A2UNORM requires a float sampler"); + return vec<4, retType, P>(unpackUnorm3x10_1x2(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::is_iec559, "CONVERT_MODE_RGB10A2UNORM requires a float sampler"); + access::store(Texture, TexelCoord, Layer, Face, Level, packUnorm3x10_1x2(vec<4, float, P>(Texel))); + } + }; + + template + struct convertFunc + { + typedef accessFunc 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::is_iec559, "CONVERT_MODE_RGB10A2SNORM requires a float sampler"); + return vec<4, retType, P>(unpackSnorm3x10_1x2(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::is_iec559, "CONVERT_MODE_RGB10A2SNORM requires a float sampler"); + access::store(Texture, TexelCoord, Layer, Face, Level, packSnorm3x10_1x2(Texel)); + } + }; + + template + struct convertFunc + { + typedef accessFunc 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::is_iec559, "CONVERT_MODE_RGB10A2USCALE requires a float sampler"); + glm::detail::u10u10u10u2 Unpack; + Unpack.pack = access::load(Texture, TexelCoord, Layer, Face, Level); + return vec<4, retType, P>(Unpack.data.x, Unpack.data.y, Unpack.data.z, Unpack.data.w); + } + + 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::is_iec559, "CONVERT_MODE_RGB10A2USCALE requires a float sampler"); + glm::detail::u10u10u10u2 Unpack; + Unpack.data.x = static_cast(Texel.x); + Unpack.data.y = static_cast(Texel.y); + Unpack.data.z = static_cast(Texel.z); + Unpack.data.w = static_cast(Texel.w); + access::store(Texture, TexelCoord, Layer, Face, Level, Unpack.pack); + } + }; + + template + struct convertFunc + { + typedef accessFunc 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::is_iec559, "CONVERT_MODE_RGB10A2SSCALE requires a float sampler"); + glm::detail::i10i10i10i2 Unpack; + Unpack.pack = access::load(Texture, TexelCoord, Layer, Face, Level); + return vec<4, retType, P>(Unpack.data.x, Unpack.data.y, Unpack.data.z, Unpack.data.w); + } + + 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::is_iec559, "CONVERT_MODE_RGB10A2SSCALE requires a float sampler"); + glm::detail::i10i10i10i2 Unpack; + Unpack.data.x = static_cast(Texel.x); + Unpack.data.y = static_cast(Texel.y); + Unpack.data.z = static_cast(Texel.z); + Unpack.data.w = static_cast(Texel.w); + access::store(Texture, TexelCoord, Layer, Face, Level, Unpack.pack); + } + }; + + template + struct convertFunc + { + typedef accessFunc 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::is_integer, "CONVERT_MODE_RGB10A2UINT requires an integer sampler"); + return vec<4, retType, P>(unpackU3x10_1x2(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::is_integer, "CONVERT_MODE_RGB10A2UINT requires an integer sampler"); + access::store(Texture, TexelCoord, Layer, Face, Level, packU3x10_1x2(Texel)); + } + }; + + template + struct convertFunc + { + typedef accessFunc 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::is_integer, "CONVERT_MODE_RGB10A2SINT requires an integer sampler"); + return vec<4, retType, P>(unpackI3x10_1x2(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::is_integer, "CONVERT_MODE_RGB10A2SINT requires an integer sampler"); + access::store(Texture, TexelCoord, Layer, Face, Level, packI3x10_1x2(Texel)); + } + }; + + template + struct convert + { + 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 + 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::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::is_iec559>::write(Texture, TexelCoord, Layer, Face, Level, Texel); + } + }; + + struct func + { + fetchFunc Fetch; + writeFunc Write; + }; + + static func call(format Format) + { + static func Table[] = + { + {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"); + + return Table[Format - FORMAT_FIRST]; + } + }; +}//namespace detail +}//namespace gli diff --git a/external/gli/gli/core/coord.hpp b/external/gli/gli/core/coord.hpp new file mode 100644 index 00000000..e78081b3 --- /dev/null +++ b/external/gli/gli/core/coord.hpp @@ -0,0 +1,87 @@ +#pragma once + +#include "../type.hpp" + +namespace gli{ +namespace detail +{ + template + inline vec in_interval(vec const& Value, vec const& Min, vec const& Max) + { + return greaterThanEqual(Value, Min) && lessThanEqual(Value, Max); + } + + template + struct coord_nearest + { + extent_type Texel; + typename extent_type::bool_type UseTexel; + }; + + template + inline coord_nearest make_coord_nearest(extent_type const& TexelExtent, normalized_type const& SampleCoord) + { + normalized_type const TexelLast(normalized_type(TexelExtent) - normalized_type(1)); + + coord_nearest Coord; + Coord.Texel = extent_type(round(SampleCoord * TexelLast)); + Coord.UseTexel = in_interval(Coord.Texel, extent_type(0), TexelExtent - 1); + return Coord; + } + + template + struct coord_linear + { + extent_type TexelFloor; + extent_type TexelCeil; + normalized_type Blend; + }; + + template + struct coord_linear_border : public coord_linear + { + typename extent_type::bool_type UseTexelFloor; + typename extent_type::bool_type UseTexelCeil; + }; + + template + GLI_FORCE_INLINE coord_linear make_coord_linear(extent_type const& TexelExtent, normalized_type const& SampleCoord) + { + coord_linear Coord; + + normalized_type const TexelExtentF(TexelExtent); + normalized_type const TexelLast = TexelExtentF - normalized_type(1); + normalized_type const ScaledCoord(SampleCoord * TexelLast); + normalized_type const ScaledCoordFloor = normalized_type(extent_type(ScaledCoord)); + normalized_type const ScaledCoordCeil = normalized_type(extent_type(ScaledCoord + normalized_type(0.5))); + //normalized_type const ScaledCoordFloor(floor(ScaledCoord)); + //normalized_type const ScaledCoordCeil(ceil(ScaledCoord)); + + Coord.Blend = ScaledCoord - ScaledCoordFloor; + Coord.TexelFloor = extent_type(ScaledCoordFloor); + Coord.TexelCeil = extent_type(ScaledCoordCeil); + + return Coord; + } + + template + GLI_FORCE_INLINE coord_linear_border make_coord_linear_border(extent_type const& TexelExtent, normalized_type const& SampleCoord) + { + coord_linear_border Coord; + + normalized_type const TexelExtentF(TexelExtent); + normalized_type const TexelLast = TexelExtentF - normalized_type(1); + normalized_type const ScaledCoord(SampleCoord * TexelLast); + normalized_type const ScaledCoordFloor(floor(ScaledCoord)); + normalized_type const ScaledCoordCeil(ceil(ScaledCoord)); + + Coord.Blend = ScaledCoord - ScaledCoordFloor; + Coord.TexelFloor = extent_type(ScaledCoordFloor); + Coord.TexelCeil = extent_type(ScaledCoordCeil); + Coord.UseTexelFloor = in_interval(Coord.TexelFloor, extent_type(0), TexelExtent - 1); + Coord.UseTexelCeil = in_interval(Coord.TexelCeil, extent_type(0), TexelExtent - 1); + + return Coord; + } +}//namespace detail +}//namespace gli diff --git a/external/gli/gli/core/copy.inl b/external/gli/gli/core/copy.inl index e3173f21..9aea05d9 100644 --- a/external/gli/gli/core/copy.inl +++ b/external/gli/gli/core/copy.inl @@ -1,256 +1,112 @@ -/////////////////////////////////////////////////////////////////////////////////// -/// OpenGL Image (gli.g-truc.net) -/// -/// Copyright (c) 2008 - 2015 G-Truc Creation (www.g-truc.net) -/// Permission is hereby granted, free of charge, to any person obtaining a copy -/// of this software and associated documentation files (the "Software"), to deal -/// in the Software without restriction, including without limitation the rights -/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -/// copies of the Software, and to permit persons to whom the Software is -/// furnished to do so, subject to the following conditions: -/// -/// The above copyright notice and this permission notice shall be included in -/// all copies or substantial portions of the Software. -/// -/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -/// THE SOFTWARE. -/// -/// @ref core -/// @file gli/core/copy.inl -/// @date 2013-01-23 / 2013-02-03 -/// @author Christophe Riccio -/////////////////////////////////////////////////////////////////////////////////// +#include "../type.hpp" +#include namespace gli { - inline image copy(image const & Image) - { - image Result(Image.format(), Image.dimensions()); - - memcpy(Result.data(), Image.data(), Image.size()); - - return Result; - } - - inline texture copy(texture const & Texture) - { - texture Copy( - Texture.target(), - Texture.format(), - Texture.dimensions(), - Texture.layers(), - Texture.faces(), - Texture.levels()); - - memcpy(Copy.data(), Texture.data(), Copy.size()); - - return Copy; - } - - template - inline texture copy(texType const & Texture) - { - texture Copy( - Texture.target(), - Texture.format(), - Texture.texture::dimensions(), - Texture.layers(), - Texture.faces(), - Texture.levels()); - - memcpy(Copy.data(), Texture.data(), Copy.size()); - - return Copy; - } - - template - inline texture copy(texType const & Texture, typename texType::format_type Format) - { - assert(block_size(Texture.format()) == block_size(Format)); - - texture Copy( - Texture.target(), - Format, - Texture.dimensions(), - Texture.layers(), - Texture.faces(), - Texture.levels()); - - memcpy(Copy.data(), Texture.data(), Copy.size()); - - return Copy; - } - - inline texture copy + template + void copy ( - texture1D const & Texture, - texture1D::size_type BaseLevel, texture1D::size_type MaxLevel + texture_src_type const& TextureSrc, size_t LayerSrc, size_t FaceSrc, size_t LevelSrc, + texture_dst_type& TextureDst, size_t LayerDst, size_t FaceDst, size_t LevelDst ) { - assert(BaseLevel <= MaxLevel); - assert(BaseLevel < Texture.levels()); - assert(MaxLevel < Texture.levels()); + TextureDst.copy(TextureSrc, LayerSrc, FaceSrc, LevelSrc, LayerDst, FaceDst, LevelDst); + } + + template + void copy + ( + texture_src_type const& TextureSrc, + texture_dst_type& TextureDst + ) + { + copy_layer(TextureSrc, 0, TextureDst, 0, TextureDst.layers()); + } + + template + void copy_level + ( + texture_src_type const& TextureSrc, size_t BaseLevelSrc, + texture_dst_type& TextureDst, size_t BaseLevelDst, + size_t LevelCount + ) + { + for(size_t LayerIndex = 0, LayerCount = TextureSrc.layers(); LayerIndex < LayerCount; ++LayerIndex) + for(size_t FaceIndex = 0, FaceCount = TextureSrc.faces(); FaceIndex < FaceCount; ++FaceIndex) + for(size_t LevelIndex = 0; LevelIndex < LevelCount; ++LevelIndex) + { + TextureDst.copy( + TextureSrc, + LayerIndex, FaceIndex, BaseLevelSrc + LevelIndex, + LayerIndex, FaceIndex, BaseLevelDst + LevelIndex); + } + } - texture1D Copy( - Texture.format(), - texture1D::dim_type(Texture[BaseLevel].dimensions().x), - MaxLevel - BaseLevel + 1); - - memcpy(Copy.data(), Texture[BaseLevel].data(), Copy.size()); - - return Copy; - } - - inline texture copy + template + void copy_level ( - texture1DArray const & Texture, - texture1DArray::size_type BaseLayer, texture1DArray::size_type MaxMayer, - texture1DArray::size_type BaseLevel, texture1DArray::size_type MaxLevel + texture_src_type const& TextureSrc, size_t BaseLevelSrc, + texture_dst_type& TextureDst, size_t BaseLevelDst ) { - assert(BaseLevel <= MaxLevel); - assert(BaseLevel < Texture.levels()); - assert(MaxLevel < Texture.levels()); - assert(BaseLayer <= MaxMayer); - assert(BaseLayer < Texture.layers()); - assert(MaxMayer < Texture.layers()); - - texture1DArray Copy( - Texture.format(), - texture1DArray::dim_type(Texture[BaseLayer][BaseLevel].dimensions().x), - MaxMayer - BaseLayer + 1, - MaxLevel - BaseLevel + 1); - - for(texture1DArray::size_type Layer = 0; Layer < Copy.layers(); ++Layer) - memcpy(Copy[Layer].data(), Texture[Layer + BaseLayer][BaseLevel].data(), Copy[Layer].size()); - - return Copy; + copy_level(TextureSrc, BaseLevelSrc, TextureDst, BaseLevelDst, 1); } - inline texture copy + template + void copy_face ( - texture2D const & Texture, - texture2D::size_type BaseLevel, texture2D::size_type MaxLevel + texture_src_type const& TextureSrc, size_t BaseFaceSrc, + texture_dst_type& TextureDst, size_t BaseFaceDst, + size_t FaceCount ) { - assert(BaseLevel <= MaxLevel); - assert(BaseLevel < Texture.levels()); - assert(MaxLevel < Texture.levels()); - - texture2D Copy( - Texture.format(), - texture2D::dim_type(Texture[BaseLevel].dimensions().x), - MaxLevel - BaseLevel + 1); - - memcpy(Copy.data(), Texture[BaseLevel].data(), Copy.size()); - - return Copy; + for(size_t LayerIndex = 0, LayerCount = TextureSrc.layers(); LayerIndex < LayerCount; ++LayerIndex) + for(size_t FaceIndex = 0; FaceIndex < FaceCount; ++FaceIndex) + for(size_t LevelIndex = 0, LevelCount = TextureSrc.levels(); LevelIndex < LevelCount; ++LevelIndex) + { + TextureDst.copy( + TextureSrc, + LayerIndex, BaseFaceSrc + FaceIndex, LevelIndex, + LayerIndex, BaseFaceDst + FaceIndex, LevelIndex); + } } - inline texture copy + template + void copy_face ( - texture2DArray const & Texture, - texture2DArray::size_type BaseLayer, texture2DArray::size_type MaxMayer, - texture2DArray::size_type BaseLevel, texture2DArray::size_type MaxLevel + texture_src_type const& TextureSrc, size_t BaseFaceSrc, + texture_dst_type& TextureDst, size_t BaseFaceDst ) { - assert(BaseLevel <= MaxLevel); - assert(BaseLevel < Texture.levels()); - assert(MaxLevel < Texture.levels()); - assert(BaseLayer <= MaxMayer); - assert(BaseLayer < Texture.layers()); - assert(MaxMayer < Texture.layers()); - - texture2DArray Copy( - Texture.format(), - texture2DArray::dim_type(Texture[BaseLayer][BaseLevel].dimensions()), - MaxMayer - BaseLayer + 1, - MaxLevel - BaseLevel + 1); - - for(texture2DArray::size_type Layer = 0; Layer < Copy.layers(); ++Layer) - memcpy(Copy[Layer].data(), Texture[Layer + BaseLayer][BaseLevel].data(), Copy[Layer].size()); - - return Copy; + copy_face(TextureSrc, BaseFaceSrc, TextureDst, BaseFaceDst, 1); } - inline texture copy + template + void copy_layer ( - texture3D const & Texture, - texture3D::size_type BaseLevel, texture3D::size_type MaxLevel + texture_src_type const& TextureSrc, size_t BaseLayerSrc, + texture_dst_type& TextureDst, size_t BaseLayerDst, + size_t LayerCount ) { - assert(BaseLevel <= MaxLevel); - assert(BaseLevel < Texture.levels()); - assert(MaxLevel < Texture.levels()); - - texture3D Copy( - Texture.format(), - texture3D::dim_type(Texture[BaseLevel].dimensions()), - MaxLevel - BaseLevel + 1); - - memcpy(Copy.data(), Texture[BaseLevel].data(), Copy.size()); - - return Copy; + for(size_t LayerIndex = 0; LayerIndex < LayerCount; ++LayerIndex) + for(size_t FaceIndex = 0, FaceCount = TextureSrc.faces(); FaceIndex < FaceCount; ++FaceIndex) + for(size_t LevelIndex = 0, LevelCount = TextureSrc.levels(); LevelIndex < LevelCount; ++LevelIndex) + { + TextureDst.copy( + TextureSrc, + BaseLayerSrc + LayerIndex, FaceIndex, LevelIndex, + BaseLayerDst + LayerIndex, FaceIndex, LevelIndex); + } } - inline texture copy + template + void copy_layer ( - textureCube const & Texture, - textureCube::size_type BaseFace, textureCube::size_type MaxFace, - textureCube::size_type BaseLevel, textureCube::size_type MaxLevel + texture_src_type const& TextureSrc, size_t BaseLayerSrc, + texture_dst_type& TextureDst, size_t BaseLayerDst ) { - assert(BaseLevel <= MaxLevel); - assert(BaseLevel < Texture.levels()); - assert(MaxLevel < Texture.levels()); - assert(BaseFace <= MaxFace); - assert(BaseFace < Texture.faces()); - assert(MaxFace < Texture.faces()); - - textureCube Copy( - Texture.format(), - textureCube::dim_type(Texture[BaseFace][BaseLevel].dimensions()), - MaxLevel - BaseLevel + 1); - - for(textureCube::size_type Face = 0; Face < Copy.faces(); ++Face) - memcpy(Copy[Face].data(), Texture[Face + BaseFace][BaseLevel].data(), Copy[Face].size()); - - return Copy; - } - - inline texture copy - ( - textureCubeArray const & Texture, - textureCubeArray::size_type BaseLayer, textureCubeArray::size_type MaxLayer, - textureCubeArray::size_type BaseFace, textureCubeArray::size_type MaxFace, - textureCubeArray::size_type BaseLevel, textureCubeArray::size_type MaxLevel - ) - { - assert(BaseLevel <= MaxLevel); - assert(BaseLevel < Texture.levels()); - assert(MaxLevel < Texture.levels()); - assert(BaseFace <= MaxFace); - assert(BaseFace < Texture.faces()); - assert(MaxFace < Texture.faces()); - assert(BaseLayer <= MaxLayer); - assert(BaseLayer < Texture.layers()); - assert(MaxLayer < Texture.layers()); - - textureCubeArray Copy( - Texture.format(), - textureCubeArray::dim_type(Texture[BaseLayer][BaseFace][BaseLevel].dimensions()), - MaxLayer - BaseLayer + 1, - MaxLevel - BaseLevel + 1); - - for(textureCubeArray::size_type Layer = 0; Layer < Copy.layers(); ++Layer) - for(textureCubeArray::size_type Face = 0; Face < Copy[Layer].faces(); ++Face) - memcpy(Copy[Layer][Face].data(), Texture[Layer + BaseLayer][Face + BaseFace][BaseLevel].data(), Copy[Layer][Face].size()); - - return Copy; + copy_layer(TextureSrc, BaseLayerSrc, TextureDst, BaseLayerDst, 1); } }//namespace gli diff --git a/external/gli/gli/core/duplicate.inl b/external/gli/gli/core/duplicate.inl new file mode 100644 index 00000000..7b9efda5 --- /dev/null +++ b/external/gli/gli/core/duplicate.inl @@ -0,0 +1,267 @@ +namespace gli{ +namespace detail +{ + inline void duplicate_images + ( + texture const & Src, texture & Dst, + texture::size_type BaseLayer, texture::size_type MaxLayer, + texture::size_type BaseFace, texture::size_type MaxFace, + texture::size_type BaseLevel, texture::size_type MaxLevel + ) + { + GLI_ASSERT(BaseLayer >= 0 && BaseLayer <= MaxLayer && MaxLayer < Src.layers()); + GLI_ASSERT(BaseFace >= 0 && BaseFace <= MaxFace && MaxFace < Src.faces()); + GLI_ASSERT(BaseLevel >= 0 && BaseLevel <= MaxLevel && MaxLevel < Src.levels()); + + texture::size_type LevelsSize = 0; + for(texture::size_type LevelIndex = 0; LevelIndex < MaxLevel - BaseLevel + 1; ++LevelIndex) + { + GLI_ASSERT(Dst.size(LevelIndex) == Src.size(LevelIndex)); + LevelsSize += Dst.size(LevelIndex); + } + + for(texture::size_type LayerIndex = 0, LayerCount = MaxLayer - BaseLayer + 1; LayerIndex < LayerCount; ++LayerIndex) + for(texture::size_type FaceIndex = 0, FaceCount = MaxFace - BaseFace + 1; FaceIndex < FaceCount; ++FaceIndex) + { + memcpy(Dst.data(LayerIndex, FaceIndex, BaseLevel), Src.data(BaseLayer + LayerIndex, BaseFace + FaceIndex, BaseLevel), LevelsSize); + } + } +}//namespace detail + + inline image duplicate(image const & Image) + { + image Result(Image.format(), Image.extent()); + + memcpy(Result.data(), Image.data(), Image.size()); + + return Result; + } + + template <> + inline texture duplicate(texture const & Texture) + { + texture Duplicate( + Texture.target(), + Texture.format(), + Texture.extent(), + Texture.layers(), + Texture.faces(), + Texture.levels()); + + detail::duplicate_images( + Texture, Duplicate, + 0, Texture.layers() - 1, + 0, Texture.faces() - 1, + 0, Texture.levels() - 1); + + return Duplicate; + } + + template + inline texture duplicate(texType const & Texture) + { + texture Duplicate( + Texture.target(), + Texture.format(), + Texture.texture::extent(), + Texture.layers(), + Texture.faces(), + Texture.levels()); + + detail::duplicate_images( + Texture, Duplicate, + 0, Texture.layers() - 1, + 0, Texture.faces() - 1, + 0, Texture.levels() - 1); + + return Duplicate; + } + + template + inline texture duplicate(texType const & Texture, typename texType::format_type Format) + { + GLI_ASSERT(block_size(Texture.format()) == block_size(Format)); + + texture Duplicate( + Texture.target(), + Format, + Texture.extent(), + Texture.layers(), + Texture.faces(), + Texture.levels()); + + detail::duplicate_images( + Texture, Duplicate, + 0, Texture.layers() - 1, + 0, Texture.faces() - 1, + 0, Texture.levels() - 1); + + return Duplicate; + } + + inline texture duplicate + ( + texture1d const & Texture, + texture1d::size_type BaseLevel, texture1d::size_type MaxLevel + ) + { + GLI_ASSERT(BaseLevel <= MaxLevel); + GLI_ASSERT(BaseLevel < Texture.levels()); + GLI_ASSERT(MaxLevel < Texture.levels()); + + texture1d Duplicate( + Texture.format(), + Texture.extent(BaseLevel), + MaxLevel - BaseLevel + 1); + + memcpy(Duplicate.data(), Texture.data(0, 0, BaseLevel), Duplicate.size()); + + return Duplicate; + } + + inline texture duplicate + ( + texture1d_array const & Texture, + texture1d_array::size_type BaseLayer, texture1d_array::size_type MaxMayer, + texture1d_array::size_type BaseLevel, texture1d_array::size_type MaxLevel + ) + { + GLI_ASSERT(BaseLevel <= MaxLevel); + GLI_ASSERT(BaseLevel < Texture.levels()); + GLI_ASSERT(MaxLevel < Texture.levels()); + GLI_ASSERT(BaseLayer <= MaxMayer); + GLI_ASSERT(BaseLayer < Texture.layers()); + GLI_ASSERT(MaxMayer < Texture.layers()); + + texture1d_array Duplicate( + Texture.format(), + Texture[BaseLayer].extent(BaseLevel), + MaxMayer - BaseLayer + 1, + MaxLevel - BaseLevel + 1); + + for(texture1d_array::size_type Layer = 0; Layer < Duplicate.layers(); ++Layer) + memcpy(Duplicate.data(Layer, 0, 0), Texture.data(Layer + BaseLayer, 0, BaseLevel), Duplicate[Layer].size()); + + return Duplicate; + } + + inline texture duplicate + ( + texture2d const & Texture, + texture2d::size_type BaseLevel, texture2d::size_type MaxLevel + ) + { + GLI_ASSERT(BaseLevel <= MaxLevel); + GLI_ASSERT(BaseLevel < Texture.levels()); + GLI_ASSERT(MaxLevel < Texture.levels()); + + texture2d Duplicate( + Texture.format(), + Texture.extent(BaseLevel), + MaxLevel - BaseLevel + 1); + + memcpy(Duplicate.data(), Texture.data(0, 0, BaseLevel), Duplicate.size()); + + return Duplicate; + } + + inline texture duplicate + ( + texture2d_array const & Texture, + texture2d_array::size_type BaseLayer, texture2d_array::size_type MaxMayer, + texture2d_array::size_type BaseLevel, texture2d_array::size_type MaxLevel + ) + { + GLI_ASSERT(BaseLevel <= MaxLevel); + GLI_ASSERT(BaseLevel < Texture.levels()); + GLI_ASSERT(MaxLevel < Texture.levels()); + GLI_ASSERT(BaseLayer <= MaxMayer); + GLI_ASSERT(BaseLayer < Texture.layers()); + GLI_ASSERT(MaxMayer < Texture.layers()); + + texture2d_array Duplicate( + Texture.format(), + Texture.extent(BaseLevel), + MaxMayer - BaseLayer + 1, + MaxLevel - BaseLevel + 1); + + for(texture2d_array::size_type Layer = 0; Layer < Duplicate.layers(); ++Layer) + memcpy(Duplicate.data(Layer, 0, 0), Texture.data(Layer + BaseLayer, 0, BaseLevel), Duplicate[Layer].size()); + + return Duplicate; + } + + inline texture duplicate + ( + texture3d const & Texture, + texture3d::size_type BaseLevel, texture3d::size_type MaxLevel + ) + { + GLI_ASSERT(BaseLevel <= MaxLevel); + GLI_ASSERT(BaseLevel < Texture.levels()); + GLI_ASSERT(MaxLevel < Texture.levels()); + + texture3d Duplicate( + Texture.format(), + Texture.extent(BaseLevel), + MaxLevel - BaseLevel + 1); + + memcpy(Duplicate.data(), Texture.data(0, 0, BaseLevel), Duplicate.size()); + + return Duplicate; + } + + inline texture duplicate + ( + texture_cube const & Texture, + texture_cube::size_type BaseFace, texture_cube::size_type MaxFace, + texture_cube::size_type BaseLevel, texture_cube::size_type MaxLevel + ) + { + GLI_ASSERT(BaseLevel >= 0 && BaseLevel < Texture.levels() && BaseLevel <= MaxLevel && MaxLevel < Texture.levels()); + GLI_ASSERT(BaseFace <= MaxFace); + GLI_ASSERT(BaseFace < Texture.faces()); + GLI_ASSERT(MaxFace < Texture.faces()); + + texture_cube Duplicate( + Texture.format(), + Texture[BaseFace].extent(BaseLevel), + MaxLevel - BaseLevel + 1); + + for(texture_cube::size_type Face = 0; Face < Duplicate.faces(); ++Face) + memcpy(Duplicate[Face].data(), Texture[Face + BaseFace][BaseLevel].data(), Duplicate[Face].size()); + + return Duplicate; + } + + inline texture duplicate + ( + texture_cube_array const & Texture, + texture_cube_array::size_type BaseLayer, texture_cube_array::size_type MaxLayer, + texture_cube_array::size_type BaseFace, texture_cube_array::size_type MaxFace, + texture_cube_array::size_type BaseLevel, texture_cube_array::size_type MaxLevel + ) + { + GLI_ASSERT(BaseLevel <= MaxLevel); + GLI_ASSERT(BaseLevel < Texture.levels()); + GLI_ASSERT(MaxLevel < Texture.levels()); + GLI_ASSERT(BaseFace <= MaxFace); + GLI_ASSERT(BaseFace < Texture.faces()); + GLI_ASSERT(MaxFace < Texture.faces()); + GLI_ASSERT(BaseLayer <= MaxLayer); + GLI_ASSERT(BaseLayer < Texture.layers()); + GLI_ASSERT(MaxLayer < Texture.layers()); + + texture_cube_array Duplicate( + Texture.format(), + Texture[BaseLayer][BaseFace].extent(BaseLevel), + MaxLayer - BaseLayer + 1, + MaxLevel - BaseLevel + 1); + + for(texture_cube_array::size_type Layer = 0; Layer < Duplicate.layers(); ++Layer) + for(texture_cube_array::size_type Face = 0; Face < Duplicate[Layer].faces(); ++Face) + memcpy(Duplicate[Layer][Face].data(), Texture[Layer + BaseLayer][Face + BaseFace][BaseLevel].data(), Duplicate[Layer][Face].size()); + + return Duplicate; + } +}//namespace gli diff --git a/external/gli/gli/core/dx.inl b/external/gli/gli/core/dx.inl index 45e00ee8..d39a72cb 100644 --- a/external/gli/gli/core/dx.inl +++ b/external/gli/gli/core/dx.inl @@ -1,30 +1,4 @@ -/////////////////////////////////////////////////////////////////////////////////// -/// OpenGL Image (gli.g-truc.net) -/// -/// Copyright (c) 2008 - 2015 G-Truc Creation (www.g-truc.net) -/// Permission is hereby granted, free of charge, to any person obtaining a copy -/// of this software and associated documentation files (the "Software"), to deal -/// in the Software without restriction, including without limitation the rights -/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -/// copies of the Software, and to permit persons to whom the Software is -/// furnished to do so, subject to the following conditions: -/// -/// The above copyright notice and this permission notice shall be included in -/// all copies or substantial portions of the Software. -/// -/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -/// THE SOFTWARE. -/// -/// @ref core -/// @file gli/core/dx.inl -/// @date 2013-11-09 / 2013-11-09 -/// @author Christophe Riccio -/////////////////////////////////////////////////////////////////////////////////// +#include namespace gli { @@ -32,212 +6,306 @@ namespace gli { static format const Table[] = { - // unorm formats - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R8_UNORM, glm::u32vec4(0x00FF0000, 0x00000000, 0x00000000, 0x00000000)}, //R8_UNORM, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R8G8_UNORM, glm::u32vec4(0x00FF0000, 0x0000FF00, 0x00000000, 0x00000000)}, //RG8_UNORM, - {DDPF_RGB, D3DFMT_R8G8B8, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0x00FF0000, 0x0000FF00, 0x000000FF, 0x00000000)}, //RGB8_UNORM, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R8G8B8A8_UNORM, glm::u32vec4(0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000)}, //RGBA8_UNORM, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_RG4_UNORM_GLI, glm::u32vec4(0x000F, 0x00F0, 0x0000, 0x0000)}, //FORMAT_RG4_UNORM, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_RGBA4_UNORM_GLI, glm::u32vec4(0x000F, 0x00F0, 0x0F00, 0xF000)}, //FORMAT_RGBA4_UNORM, + {DDPF_FOURCC, D3DFMT_A4R4G4B4, DXGI_FORMAT_B4G4R4A4_UNORM, glm::u32vec4(0x0F00, 0x00F0, 0x000F, 0xF000)}, //FORMAT_BGRA4_UNORM, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R5G6B5_UNORM_GLI, glm::u32vec4(0x001f, 0x07e0, 0xf800, 0x0000)}, //FORMAT_R5G6B5_UNORM, + {DDPF_FOURCC, D3DFMT_R5G6B5, DXGI_FORMAT_B5G6R5_UNORM, glm::u32vec4(0xf800, 0x07e0, 0x001f, 0x0000)}, //FORMAT_B5G6R5_UNORM, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R5G5B5A1_UNORM_GLI, glm::u32vec4(0x001f, 0x03e0, 0x7c00, 0x8000)}, //FORMAT_RGB5A1_UNORM, + {DDPF_FOURCC, D3DFMT_A1R5G5B5, DXGI_FORMAT_B5G5R5A1_UNORM, glm::u32vec4(0x7c00, 0x03e0, 0x001f, 0x8000)}, //FORMAT_BGR5A1_UNORM, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_A1B5G5R5_UNORM_GLI, glm::u32vec4(0x7c00, 0x03e0, 0x001f, 0x8000)}, //FORMAT_A1RGB5_UNORM, - {DDPF_FOURCC, D3DFMT_L16, DXGI_FORMAT_R16_UNORM, glm::u32vec4(0x0000FFFF, 0x00000000, 0x00000000, 0x00000000)}, //R16_UNORM, - {DDPF_FOURCC, D3DFMT_G16R16, DXGI_FORMAT_R16G16_UNORM, glm::u32vec4(0x0000FFFF, 0xFFFF0000, 0x00000000, 0x00000000)}, //RG16_UNORM, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //RGB16_UNORM, - {DDPF_FOURCC, D3DFMT_A16B16G16R16, DXGI_FORMAT_R16G16B16A16_UNORM, glm::u32vec4(0)}, //RGBA16_UNORM, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R8_UNORM, glm::u32vec4(0x00FF0000, 0x00000000, 0x00000000, 0x00000000)}, //FORMAT_R8_UNORM, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R8_SNORM, glm::u32vec4(0)}, //FORMAT_R8_SNORM, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R8_USCALED_GLI, glm::u32vec4(0x00FF0000, 0x00000000, 0x00000000, 0x00000000)}, //FORMAT_R8_USCALED, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R8_SSCALED_GLI, glm::u32vec4(0)}, //FORMAT_R8_SSCALED, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R8_UINT, glm::u32vec4(0)}, //FORMAT_R8_UINT, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R8_SINT, glm::u32vec4(0)}, //FORMAT_R8_SINT, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R8_SRGB_GLI, glm::u32vec4(0)}, //FORMAT_R8_SRGB, - // snorm formats - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R8_SNORM, glm::u32vec4(0)}, //R8_SNORM, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R8G8_SNORM, glm::u32vec4(0)}, //RG8_SNORM, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //RGB8_SNORM, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R8G8B8A8_SNORM, glm::u32vec4(0)}, //RGBA8_SNORM, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R8G8_UNORM, glm::u32vec4(0x00FF0000, 0x0000FF00, 0x00000000, 0x00000000)}, //FORMAT_RG8_UNORM, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R8G8_SNORM, glm::u32vec4(0)}, //FORMAT_RG8_SNORM, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R8G8_USCALED_GLI, glm::u32vec4(0x00FF0000, 0x0000FF00, 0x00000000, 0x00000000)}, //FORMAT_RG8_USCALED, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R8G8_SSCALED_GLI, glm::u32vec4(0)}, //FORMAT_RG8_SSCALED, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R8G8_UINT, glm::u32vec4(0)}, //FORMAT_RG8_UINT, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R8G8_SINT, glm::u32vec4(0)}, //FORMAT_RG8_SINT, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R8G8_SRGB_GLI, glm::u32vec4(0)}, //FORMAT_RG8_SRGB, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R16_SNORM, glm::u32vec4(0)}, //R16_SNORM, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R16G16_SNORM, glm::u32vec4(0)}, //RG16_SNORM, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //RGB16_SNORM, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R16G16B16A16_SNORM, glm::u32vec4(0)}, //RGBA16_SNORM, + {DDPF_RGB, D3DFMT_GLI1, DXGI_FORMAT_R8G8B8_UNORM_GLI, glm::u32vec4(0x000000FF, 0x0000FF00, 0x00FF0000, 0x00000000)}, //FORMAT_RGB8_UNORM, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R8G8B8_SNORM_GLI, glm::u32vec4(0)}, //FORMAT_RGB8_SNORM, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R8G8B8_USCALED_GLI, glm::u32vec4(0)}, //FORMAT_RGB8_USCALED, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R8G8B8_SSCALED_GLI, glm::u32vec4(0)}, //FORMAT_RGB8_SSCALED, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R8G8B8_UINT_GLI, glm::u32vec4(0)}, //FORMAT_RGB8_UINT, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R8G8B8_SINT_GLI, glm::u32vec4(0)}, //FORMAT_RGB8_SINT, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R8G8B8_SRGB_GLI, glm::u32vec4(0)}, //FORMAT_RGB8_SRGB, - // Unsigned integer formats - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R8_UINT, glm::u32vec4(0)}, //R8U, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R8G8_UINT, glm::u32vec4(0)}, //RG8U, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //RGB8U, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R8G8B8A8_UINT, glm::u32vec4(0)}, //RGBA8U, + {DDPF_RGB, D3DFMT_R8G8B8, DXGI_FORMAT_B8G8R8_UNORM_GLI, glm::u32vec4(0x00FF0000, 0x0000FF00, 0x000000FF, 0x00000000)}, //FORMAT_BGR8_UNORM, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_B8G8R8_SNORM_GLI, glm::u32vec4(0)}, //FORMAT_BGR8_SNORM, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_B8G8R8_USCALED_GLI, glm::u32vec4(0)}, //FORMAT_BGR8_USCALED, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_B8G8R8_SSCALED_GLI, glm::u32vec4(0)}, //FORMAT_BGR8_SSCALED, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_B8G8R8_UINT_GLI, glm::u32vec4(0)}, //FORMAT_BGR8_UINT, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_B8G8R8_SINT_GLI, glm::u32vec4(0)}, //FORMAT_BGR8_SINT, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_B8G8R8_SRGB_GLI, glm::u32vec4(0)}, //FORMAT_BGR8_SRGB, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R16_UINT, glm::u32vec4(0)}, //R16U, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R16G16_UINT, glm::u32vec4(0)}, //RG16U, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //RGB16U, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R16G16B16A16_UINT, glm::u32vec4(0)}, //RGBA16U, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R8G8B8A8_UNORM, glm::u32vec4(0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000)}, //FORMAT_RGBA8_UNORM, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R8G8B8A8_SNORM, glm::u32vec4(0)}, //FORMAT_RGBA8_SNORM, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R8G8B8A8_USCALED_GLI, glm::u32vec4(0)}, //FORMAT_RGBA8_USCALED, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R8G8B8A8_SSCALED_GLI, glm::u32vec4(0)}, //FORMAT_RGBA8_SSCALED, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R8G8B8A8_UINT, glm::u32vec4(0)}, //FORMAT_RGBA8_UINT, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R8G8B8A8_SINT, glm::u32vec4(0)}, //FORMAT_RGBA8_SINT, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, glm::u32vec4(0)}, //FORMAT_RGBA8_SRGB, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R32_UINT, glm::u32vec4(0)}, //R32U, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R32G32_UINT, glm::u32vec4(0)}, //RG32U, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R32G32B32_UINT, glm::u32vec4(0)}, //RGB32U, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R32G32B32A32_UINT, glm::u32vec4(0)}, //RGBA32U, + {DDPF_FOURCC, D3DFMT_A8R8G8B8, DXGI_FORMAT_B8G8R8A8_UNORM, glm::u32vec4(0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000)}, //FORMAT_BGRA8_UNORM, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_B8G8R8A8_SNORM_GLI, glm::u32vec4(0)}, //FORMAT_BGRA8_SNORM, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_B8G8R8A8_USCALED_GLI, glm::u32vec4(0)}, //FORMAT_BGRA8_USCALED, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_B8G8R8A8_SSCALED_GLI, glm::u32vec4(0)}, //FORMAT_BGRA8_SSCALED, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_B8G8R8A8_UINT_GLI, glm::u32vec4(0)}, //FORMAT_BGRA8_UINT, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_B8G8R8A8_SINT_GLI, glm::u32vec4(0)}, //FORMAT_BGRA8_SINT, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_B8G8R8A8_UNORM_SRGB, glm::u32vec4(0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000)}, //FORMAT_BGRA8_SRGB, - /// Signed integer formats - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R8_SINT, glm::u32vec4(0)}, //R8I, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R8G8_SINT, glm::u32vec4(0)}, //RG8I, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //RGB8I, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R8G8B8A8_SINT, glm::u32vec4(0)}, //RGBA8I, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R8G8B8A8_PACK_UNORM_GLI, glm::u32vec4(0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000)}, //FORMAT_ABGR8_UNORM, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R8G8B8A8_PACK_SNORM_GLI, glm::u32vec4(0)}, //FORMAT_ABGR8_SNORM, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R8G8B8A8_PACK_USCALED_GLI, glm::u32vec4(0)}, //FORMAT_ABGR8_USCALED, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R8G8B8A8_PACK_SSCALED_GLI, glm::u32vec4(0)}, //FORMAT_ABGR8_SSCALED, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R8G8B8A8_PACK_UINT_GLI, glm::u32vec4(0)}, //FORMAT_ABGR8_UINT, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R8G8B8A8_PACK_SINT_GLI, glm::u32vec4(0)}, //FORMAT_ABGR8_SINT, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R8G8B8A8_PACK_SRGB_GLI, glm::u32vec4(0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000)}, //FORMAT_ABGR8_SRGB, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R16_SINT, glm::u32vec4(0)}, //R16I, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R16G16_SINT, glm::u32vec4(0)}, //RG16I, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //RGB16I, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R16G16B16A16_SINT, glm::u32vec4(0)}, //RGBA16I, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R10G10B10A2_UNORM, glm::u32vec4(0x000003FF, 0x000FFC00, 0x3FF00000, 0xC0000000)}, //FORMAT_RGB10A2_UNORM_PACK32, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R10G10B10A2_SNORM_GLI, glm::u32vec4(0x000003FF, 0x000FFC00, 0x3FF00000, 0xC0000000)}, //FORMAT_RGB10A2_SNORM_PACK32, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R10G10B10A2_USCALED_GLI, glm::u32vec4(0x000003FF, 0x000FFC00, 0x3FF00000, 0xC0000000)}, //FORMAT_RGB10A2_USCALED_PACK32, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R10G10B10A2_SSCALED_GLI, glm::u32vec4(0x000003FF, 0x000FFC00, 0x3FF00000, 0xC0000000)}, //FORMAT_RGB10A2_SSCALED_PACK32, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R10G10B10A2_UINT, glm::u32vec4(0x000003FF, 0x000FFC00, 0x3FF00000, 0xC0000000)}, //FORMAT_RGB10A2_UINT_PACK32, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R10G10B10A2_SINT_GLI, glm::u32vec4(0x000003FF, 0x000FFC00, 0x3FF00000, 0xC0000000)}, //FORMAT_RGB10A2_SINT_PACK32, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R32_SINT, glm::u32vec4(0)}, //R32I, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R32G32_SINT, glm::u32vec4(0)}, //RG32I, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R32G32B32_SINT, glm::u32vec4(0)}, //RGB32I, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R32G32B32A32_SINT, glm::u32vec4(0)}, //RGBA32I, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_B10G10R10A2_UNORM_GLI, glm::u32vec4(0x3FF00000, 0x000FFC00, 0x000003FF, 0xC0000000)}, //FORMAT_BGR10A2_UNORM_PACK32, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_B10G10R10A2_SNORM_GLI, glm::u32vec4(0x3FF00000, 0x000FFC00, 0x000003FF, 0xC0000000)}, //FORMAT_BGR10A2_SNORM_PACK32, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_B10G10R10A2_USCALED_GLI, glm::u32vec4(0x3FF00000, 0x000FFC00, 0x000003FF, 0xC0000000)}, //FORMAT_BGR10A2_USCALED_PACK32, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_B10G10R10A2_SSCALED_GLI, glm::u32vec4(0x3FF00000, 0x000FFC00, 0x000003FF, 0xC0000000)}, //FORMAT_BGR10A2_SSCALED_PACK32, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_B10G10R10A2_UINT_GLI, glm::u32vec4(0x3FF00000, 0x000FFC00, 0x000003FF, 0xC0000000)}, //FORMAT_BGR10A2_UINT_PACK32, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_B10G10R10A2_SINT_GLI, glm::u32vec4(0x3FF00000, 0x000FFC00, 0x000003FF, 0xC0000000)}, //FORMAT_BGR10A2_SINT_PACK32, - /// Floating formats - {DDPF_FOURCC, D3DFMT_R16F, DXGI_FORMAT_R16_FLOAT, glm::u32vec4(0)}, //R16F, - {DDPF_FOURCC, D3DFMT_G16R16F, DXGI_FORMAT_R16G16_FLOAT, glm::u32vec4(0)}, //RG16F, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //RGB16F, - {DDPF_FOURCC, D3DFMT_A16B16G16R16F, DXGI_FORMAT_R16G16B16A16_FLOAT, glm::u32vec4(0)}, //RGBA16F, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R16_UNORM, glm::u32vec4(0x0000FFFF, 0x00000000, 0x00000000, 0x00000000)}, //FORMAT_R16_UNORM_PACK16, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R16_SNORM, glm::u32vec4(0x0000FFFF, 0x00000000, 0x00000000, 0x00000000)}, //FORMAT_R16_SNORM_PACK16, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R16_USCALED_GLI, glm::u32vec4(0x0000FFFF, 0x00000000, 0x00000000, 0x00000000)}, //FORMAT_R16_USCALED_PACK16, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R16_SSCALED_GLI, glm::u32vec4(0x0000FFFF, 0x00000000, 0x00000000, 0x00000000)}, //FORMAT_R16_SSCALED_PACK16, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R16_UINT, glm::u32vec4(0x0000FFFF, 0x00000000, 0x00000000, 0x0000000)}, //FORMAT_R16_UINT_PACK16, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R16_SINT, glm::u32vec4(0x0000FFFF, 0x00000000, 0x00000000, 0x0000000)}, //FORMAT_R16_SINT_PACK16, + {DDPF_FOURCC, D3DFMT_R16F, DXGI_FORMAT_R16_FLOAT, glm::u32vec4(0x0000FFFF, 0x00000000, 0x00000000, 0x0000000)}, //FORMAT_R16_SFLOAT_PACK16, - {DDPF_FOURCC, D3DFMT_R32F, DXGI_FORMAT_R32_FLOAT, glm::u32vec4(0xFFFFFFFF, 0x0000000, 0x0000000, 0x0000000)}, //R32F, - {DDPF_FOURCC, D3DFMT_G32R32F, DXGI_FORMAT_R32G32_FLOAT, glm::u32vec4(0)}, //RG32F, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R32G32B32_FLOAT, glm::u32vec4(0)}, //RGB32F, - {DDPF_FOURCC, D3DFMT_A32B32G32R32F, DXGI_FORMAT_R32G32B32A32_FLOAT, glm::u32vec4(0)}, //RGBA32F, + {DDPF_FOURCC, D3DFMT_G16R16, DXGI_FORMAT_R16G16_UNORM, glm::u32vec4(0x0000FFFF, 0xFFFF0000, 0x00000000, 0x00000000)}, //FORMAT_RG16_UNORM_PACK16, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R16G16_SNORM, glm::u32vec4(0x0000FFFF, 0xFFFF0000, 0x00000000, 0x00000000)}, //FORMAT_RG16_SNORM_PACK16, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R16G16_USCALED_GLI, glm::u32vec4(0x0000FFFF, 0xFFFF0000, 0x00000000, 0x00000000)}, //FORMAT_RG16_USCALED_PACK16, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R16G16_SSCALED_GLI, glm::u32vec4(0x0000FFFF, 0xFFFF0000, 0x00000000, 0x00000000)}, //FORMAT_RG16_SSCALED_PACK16, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R16G16_UINT, glm::u32vec4(0x0000FFFF, 0xFFFF0000, 0x00000000, 0x00000000)}, //FORMAT_RG16_UINT_PACK16, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R16G16_SINT, glm::u32vec4(0x0000FFFF, 0xFFFF0000, 0x00000000, 0x00000000)}, //FORMAT_RG16_SINT_PACK16, + {DDPF_FOURCC, D3DFMT_G16R16F, DXGI_FORMAT_R16G16_FLOAT, glm::u32vec4(0x0000FFFF, 0xFFFF0000, 0x00000000, 0x00000000)}, //FORMAT_RG16_SFLOAT_PACK16, - /// sRGB formats - {DDPF_FOURCC, D3DFMT_UNKNOWN, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //SR8, - {DDPF_FOURCC, D3DFMT_UNKNOWN, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //SRG8, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_B8G8R8X8_UNORM_SRGB, glm::u32vec4(0)}, //SRGB8, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, glm::u32vec4(0)}, //SRGB8_ALPHA8, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R16G16B16_UNORM_GLI, glm::u32vec4(0)}, //FORMAT_RGB16_UNORM_PACK16, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R16G16B16_SNORM_GLI, glm::u32vec4(0)}, //FORMAT_RGB16_SNORM_PACK16, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R16G16B16_USCALED_GLI, glm::u32vec4(0)}, //FORMAT_RGB16_USCALED_PACK16, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R16G16B16_SSCALED_GLI, glm::u32vec4(0)}, //FORMAT_RGB16_SSCALED_PACK16, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R16G16B16_UINT_GLI, glm::u32vec4(0)}, //FORMAT_RGB16_UINT_PACK16, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R16G16B16_SINT_GLI, glm::u32vec4(0)}, //FORMAT_RGB16_SINT_PACK16, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R16G16B16_FLOAT_GLI, glm::u32vec4(0)}, //FORMAT_RGB16_SFLOAT_PACK16, - /// Packed formats - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R10G10B10A2_UNORM, glm::u32vec4(0x3FF00000, 0x000FFC00, 0x000003FF, 0xC0000000)}, //RGB10A2_UNORM, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R10G10B10A2_UINT, glm::u32vec4(0)}, //RGB10A2U, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R9G9B9E5_SHAREDEXP, glm::u32vec4(0)}, //RGB9E5, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R11G11B10_FLOAT, glm::u32vec4(0)}, //RG11B10F, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0x70, 0x38, 0xC0, 0x00)}, //RG3B2, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_B5G6R5_UNORM, glm::u32vec4(0xf800, 0x07e0, 0x001f, 0x0000)}, //R5G6B5, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_B5G5R5A1_UNORM, glm::u32vec4(0x7c00, 0x03e0, 0x001f, 0x8000)}, //RGB5A1, - {DDPF_FOURCC, D3DFMT_A4R4G4B4, DXGI_FORMAT_B4G4R4A4_UNORM, glm::u32vec4(0x0F00, 0x00F0, 0x000F, 0xF000)}, //RGBA4, + {DDPF_FOURCC, D3DFMT_A16B16G16R16, DXGI_FORMAT_R16G16B16A16_UNORM, glm::u32vec4(0)}, //FORMAT_RGBA16_UNORM_PACK16, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R16G16B16A16_SNORM, glm::u32vec4(0)}, //FORMAT_RGBA16_SNORM_PACK16, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R16G16B16A16_USCALED_GLI, glm::u32vec4(0)}, //FORMAT_RGBA16_USCALED_PACK16, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R16G16B16A16_SSCALED_GLI, glm::u32vec4(0)}, //FORMAT_RGBA16_SSCALED_PACK16, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R16G16B16A16_UINT, glm::u32vec4(0)}, //FORMAT_RGBA16_UINT_PACK16, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R16G16B16A16_SINT, glm::u32vec4(0)}, //FORMAT_RGBA16_SINT_PACK16, + {DDPF_FOURCC, D3DFMT_A16B16G16R16F, DXGI_FORMAT_R16G16B16A16_FLOAT, glm::u32vec4(0)}, //FORMAT_RGBA16_SFLOAT_PACK16, - /// Swizzle formats - {DDPF_RGB, D3DFMT_R8G8B8, DXGI_FORMAT_B8G8R8X8_UNORM, glm::u32vec4(0x00FF0000, 0x0000FF00, 0x000000FF, 0x00000000)}, //FORMAT_BGRX8_UNORM, - {DDPF_RGBA, D3DFMT_A8R8G8B8, DXGI_FORMAT_B8G8R8A8_UNORM, glm::u32vec4(0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000)}, //BGRA8_UNORM, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_B8G8R8X8_UNORM_SRGB, glm::u32vec4(0x00FF0000, 0x0000FF00, 0x000000FF, 0x00000000)}, //SBGR8_UNORM, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_B8G8R8A8_UNORM_SRGB, glm::u32vec4(0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000)}, //SBGR8_ALPHA8_UNORM, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R32_UINT, glm::u32vec4(0)}, //FORMAT_R32_UINT_PACK32, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R32_SINT, glm::u32vec4(0)}, //FORMAT_R32_SINT_PACK32, + {DDPF_FOURCC, D3DFMT_R32F, DXGI_FORMAT_R32_FLOAT, glm::u32vec4(0xFFFFFFFF, 0x0000000, 0x0000000, 0x0000000)}, //FORMAT_R32_SFLOAT_PACK32, - /// Luminance Alpha formats - {DDPF_LUMINANCE, D3DFMT_L8, DXGI_FORMAT_R8_UNORM, glm::u32vec4(0x000000FF, 0x00000000, 0x00000000, 0x00000000)}, //L8_UNORM, - {DDPF_ALPHA, D3DFMT_A8, DXGI_FORMAT_R8_UNORM, glm::u32vec4(0x00000000, 0x00000000, 0x00000000, 0x000000FF)}, //A8_UNORM, - {DDPF_LUMINANCE_ALPHA, D3DFMT_A8L8, DXGI_FORMAT_R8G8_UNORM, glm::u32vec4(0x000000FF, 0x00000000, 0x00000000, 0x0000FF00)}, //LA8_UNORM, - {DDPF_LUMINANCE, D3DFMT_L16, DXGI_FORMAT_R16_UNORM, glm::u32vec4(0x0000FFFF, 0x00000000, 0x00000000, 0x00000000)}, //L16_UNORM, - {DDPF_ALPHA, D3DFMT_UNKNOWN, DXGI_FORMAT_R16_UNORM, glm::u32vec4(0x00000000, 0x00000000, 0x00000000, 0x0000FFFF)}, //A16_UNORM, - {DDPF_LUMINANCE_ALPHA, D3DFMT_UNKNOWN, DXGI_FORMAT_R16_UNORM, glm::u32vec4(0x0000FFFF, 0x00000000, 0x00000000, 0xFFFF0000)}, //LA16_UNORM, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R32G32_UINT, glm::u32vec4(0)}, //FORMAT_RG32_UINT_PACK32 + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R32G32_SINT, glm::u32vec4(0)}, //FORMAT_RG32_SINT_PACK32, + {DDPF_FOURCC, D3DFMT_G32R32F, DXGI_FORMAT_R32G32_FLOAT, glm::u32vec4(0)}, //FORMAT_RG32_SFLOAT_PACK32, - /// Depth formats - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_D16_UNORM, glm::u32vec4(0)}, //D16, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //D24X8, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_D24_UNORM_S8_UINT, glm::u32vec4(0)}, //D24S8, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_D32_FLOAT, glm::u32vec4(0)}, //D32F, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_D32_FLOAT_S8X24_UINT, glm::u32vec4(0)}, //D32FS8X24, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R32G32B32_UINT, glm::u32vec4(0)}, //FORMAT_RGB32_UINT_PACK32, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R32G32B32_SINT, glm::u32vec4(0)}, //FORMAT_RGB32_SINT_PACK32, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R32G32B32_FLOAT, glm::u32vec4(0)}, //FORMAT_RGB32_SFLOAT_PACK32, - /// Compressed formats - {DDPF_FOURCC, D3DFMT_DXT1, DXGI_FORMAT_BC1_UNORM, glm::u32vec4(0)}, //RGB_DXT1, - {DDPF_FOURCC_ALPHAPIXELS, D3DFMT_DXT1, DXGI_FORMAT_BC1_UNORM, glm::u32vec4(0)}, //RGBA_DXT1, - {DDPF_FOURCC_ALPHAPIXELS, D3DFMT_DXT3, DXGI_FORMAT_BC2_UNORM, glm::u32vec4(0)}, //RGBA_DXT3, - {DDPF_FOURCC_ALPHAPIXELS, D3DFMT_DXT5, DXGI_FORMAT_BC3_UNORM, glm::u32vec4(0)}, //RGBA_DXT5, - {DDPF_FOURCC, D3DFMT_ATI1, DXGI_FORMAT_BC4_UNORM, glm::u32vec4(0)}, //R_ATI1N_UNORM, - {DDPF_FOURCC, D3DFMT_AT1N, DXGI_FORMAT_BC4_SNORM, glm::u32vec4(0)}, //R_ATI1N_SNORM, - {DDPF_FOURCC, D3DFMT_ATI2, DXGI_FORMAT_BC5_UNORM, glm::u32vec4(0)}, //RG_ATI2N_UNORM, - {DDPF_FOURCC, D3DFMT_AT2N, DXGI_FORMAT_BC5_SNORM, glm::u32vec4(0)}, //RG_ATI2N_SNORM, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_BC6H_UF16, glm::u32vec4(0)}, //RGB_BP_UF16, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_BC6H_SF16, glm::u32vec4(0)}, //RGB_BP_SF16, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_BC7_UNORM, glm::u32vec4(0)}, //RGB_BP_UNORM, - {DDPF_FOURCC, D3DFMT_POWERVR_4BPP, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //RGB_PVRTC_4BPP, - {DDPF_FOURCC, D3DFMT_POWERVR_2BPP, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //RGB_PVRTC_2BPP, - {DDPF_FOURCC, D3DFMT_POWERVR_4BPP, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //RGBA_PVRTC_4BPP, - {DDPF_FOURCC, D3DFMT_POWERVR_2BPP, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //RGBA_PVRTC_2BPP, - {DDPF_FOURCC, D3DFMT_UNKNOWN, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //RGBA_PVRTC2_4BPP, - {DDPF_FOURCC, D3DFMT_UNKNOWN, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //RGBA_PVRTC2_2BPP, - {DDPF_FOURCC, D3DFMT_ATC, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //ATC_RGB, - {DDPF_FOURCC, D3DFMT_ATCA, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //ATC_RGBA_EXPLICIT_ALPHA, - {DDPF_FOURCC, D3DFMT_ATCI, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //ATC_RGBA_INTERPOLATED_ALPHA, - {DDPF_FOURCC, D3DFMT_ETC, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //FORMAT_RGB_ETC_UNORM, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //FORMAT_RGB2_ETC_UNORM, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //RGBA_ETC2_PUNCHTHROUGH_UNORM, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //RGBA_ETC2_UNORM, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //R11_EAC_UNORM, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //R11_EAC_SNORM, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //RG11_EAC_UNORM, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //RG11_EAC_SNORM, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_4X4_UNORM, glm::u32vec4(0)}, //RGBA_ASTC_4x4, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_5X4_UNORM, glm::u32vec4(0)}, //RGBA_ASTC_5x4, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_5X5_UNORM, glm::u32vec4(0)}, //RGBA_ASTC_5x5, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_6X5_UNORM, glm::u32vec4(0)}, //RGBA_ASTC_6x5, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_6X6_UNORM, glm::u32vec4(0)}, //RGBA_ASTC_6x6, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_8X5_UNORM, glm::u32vec4(0)}, //RGBA_ASTC_8x5, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_8X6_UNORM, glm::u32vec4(0)}, //RGBA_ASTC_8x6, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_8X8_UNORM, glm::u32vec4(0)}, //RGBA_ASTC_8x8, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_10X5_UNORM, glm::u32vec4(0)}, //RGBA_ASTC_10x5, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_10X6_UNORM, glm::u32vec4(0)}, //RGBA_ASTC_10x6, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_10X8_UNORM, glm::u32vec4(0)}, //RGBA_ASTC_10x8, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_10X10_UNORM, glm::u32vec4(0)}, //RGBA_ASTC_10x10, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_12X10_UNORM, glm::u32vec4(0)}, //RGBA_ASTC_12x10, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_12X12_UNORM, glm::u32vec4(0)}, //RGBA_ASTC_12x12, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R32G32B32A32_UINT, glm::u32vec4(0)}, //FORMAT_RGBA32_UINT_PACK32, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R32G32B32A32_SINT, glm::u32vec4(0)}, //FORMAT_RGBA32_SINT_PACK32, + {DDPF_FOURCC, D3DFMT_A32B32G32R32F, DXGI_FORMAT_R32G32B32A32_FLOAT, glm::u32vec4(0)}, //FORMAT_RGBA32_SFLOAT_PACK32, - // Compressed sRGB formats - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_BC1_UNORM_SRGB, glm::u32vec4(0)}, //FORMAT_RGB_DXT1_SRGB, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_BC1_UNORM_SRGB, glm::u32vec4(0)}, //FORMAT_RGBA_DXT1_SRGB, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_BC2_UNORM_SRGB, glm::u32vec4(0)}, //FORMAT_RGBA_DXT3_SRGB, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_BC3_UNORM_SRGB, glm::u32vec4(0)}, //FORMAT_RGBA_DXT5_SRGB, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R64_UINT_GLI, glm::u32vec4(0)}, //FORMAT_R64_UINT_PACK64, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R64_SINT_GLI, glm::u32vec4(0)}, //FORMAT_R64_SINT_PACK64, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R64_FLOAT_GLI, glm::u32vec4(0)}, //FORMAT_R64_SFLOAT_PACK64, + + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R64G64_UINT_GLI, glm::u32vec4(0)}, //FORMAT_RG64_UINT_PACK64, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R64G64_SINT_GLI, glm::u32vec4(0)}, //FORMAT_RG64_SINT_PACK64, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R64G64_FLOAT_GLI, glm::u32vec4(0)}, //FORMAT_RG64_SFLOAT_PACK64, + + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R64G64B64_UINT_GLI, glm::u32vec4(0)}, //FORMAT_RGB64_UINT_PACK64, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R64G64B64_SINT_GLI, glm::u32vec4(0)}, //FORMAT_RGB64_SINT_PACK64, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R64G64B64_FLOAT_GLI, glm::u32vec4(0)}, //FORMAT_RGB64_SFLOAT_PACK64, + + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R64G64B64A64_UINT_GLI, glm::u32vec4(0)}, //FORMAT_RGBA64_UINT_PACK64, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R64G64B64A64_SINT_GLI, glm::u32vec4(0)}, //FORMAT_RGBA64_SINT_PACK64, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R64G64B64A64_FLOAT_GLI, glm::u32vec4(0)}, //FORMAT_RGBA64_SFLOAT_PACK64, + + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R11G11B10_FLOAT, glm::u32vec4(0)}, //FORMAT_RG11B10_UFLOAT, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_R9G9B9E5_SHAREDEXP, glm::u32vec4(0)}, //FORMAT_RGB9E5_UFLOAT, + + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_D16_UNORM, glm::u32vec4(0)}, //FORMAT_D16_UNORM_PACK16, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_D24_UNORM_GLI, glm::u32vec4(0)}, //FORMAT_D24_UNORM, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_D32_FLOAT, glm::u32vec4(0)}, //FORMAT_D32_SFLOAT_PACK32, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_S8_UINT_GLI, glm::u32vec4(0)}, //FORMAT_S8_UINT_PACK8, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_D16_UNORM_S8_UINT_GLI, glm::u32vec4(0)}, //FORMAT_D16_UNORM_S8_UINT_PACK32, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_D24_UNORM_S8_UINT, glm::u32vec4(0)}, //FORMAT_D24_UNORM_S8_UINT_PACK32, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_D32_FLOAT_S8X24_UINT, glm::u32vec4(0)}, //FORMAT_D32_SFLOAT_S8_UINT_PACK64, + + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_BC1_RGB_UNORM_GLI, glm::u32vec4(0)}, //FORMAT_RGB_DXT1_UNORM_BLOCK8, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_BC1_RGB_SRGB_GLI, glm::u32vec4(0)}, //FORMAT_RGB_DXT1_SRGB_BLOCK8, + {DDPF_FOURCC, D3DFMT_DXT1, DXGI_FORMAT_BC1_UNORM, glm::u32vec4(0)}, //FORMAT_RGBA_DXT1_UNORM_BLOCK8, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_BC1_UNORM_SRGB, glm::u32vec4(0)}, //FORMAT_RGBA_DXT1_SRGB_BLOCK8, + {DDPF_FOURCC, D3DFMT_DXT3, DXGI_FORMAT_BC2_UNORM, glm::u32vec4(0)}, //FORMAT_RGBA_DXT3_UNORM_BLOCK16, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_BC2_UNORM_SRGB, glm::u32vec4(0)}, //FORMAT_RGBA_DXT3_SRGB_BLOCK16, + {DDPF_FOURCC, D3DFMT_DXT5, DXGI_FORMAT_BC3_UNORM, glm::u32vec4(0)}, //FORMAT_RGBA_DXT5_UNORM_BLOCK16, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_BC3_UNORM_SRGB, glm::u32vec4(0)}, //FORMAT_RGBA_DXT5_SRGB_BLOCK16, + {DDPF_FOURCC, D3DFMT_ATI1, DXGI_FORMAT_BC4_UNORM, glm::u32vec4(0)}, //FORMAT_R_ATI1N_UNORM_BLOCK8, + {DDPF_FOURCC, D3DFMT_AT1N, DXGI_FORMAT_BC4_SNORM, glm::u32vec4(0)}, //FORMAT_R_ATI1N_SNORM_BLOCK8, + {DDPF_FOURCC, D3DFMT_ATI2, DXGI_FORMAT_BC5_UNORM, glm::u32vec4(0)}, //FORMAT_RG_ATI2N_UNORM_BLOCK16, + {DDPF_FOURCC, D3DFMT_AT2N, DXGI_FORMAT_BC5_SNORM, glm::u32vec4(0)}, //FORMAT_RG_ATI2N_SNORM_BLOCK16, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_BC6H_UF16, glm::u32vec4(0)}, //FORMAT_RGB_BP_UFLOAT_BLOCK16, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_BC6H_SF16, glm::u32vec4(0)}, //FORMAT_RGB_BP_SFLOAT_BLOCK16, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_BC7_UNORM, glm::u32vec4(0)}, //FORMAT_RGB_BP_UNORM, {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_BC7_UNORM_SRGB, glm::u32vec4(0)}, //FORMAT_RGB_BP_SRGB, - {DDPF_FOURCC, D3DFMT_UNKNOWN, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //FORMAT_RGB_PVRTC1_8X8_SRGB, - {DDPF_FOURCC, D3DFMT_UNKNOWN, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //FORMAT_RGB_PVRTC1_16X8_SRGB, - {DDPF_FOURCC, D3DFMT_UNKNOWN, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //FORMAT_RGBA_PVRTC1_8X8_SRGB, - {DDPF_FOURCC, D3DFMT_UNKNOWN, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //FORMAT_RGBA_PVRTC1_16X8_SRGB, - {DDPF_FOURCC, D3DFMT_UNKNOWN, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //FORMAT_RGBA_PVRTC2_8X8_SRGB, - {DDPF_FOURCC, D3DFMT_UNKNOWN, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //FORMAT_RGBA_PVRTC2_16X8_SRGB, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //FORMAT_RGB_ETC_SRGB, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //FORMAT_RGBA_ETC2_PUNCHTHROUGH_SRGB, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_UNKNOWN, glm::u32vec4(0)}, //FORMAT_RGBA_ETC2_SRGB, - {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_4X4_UNORM_SRGB, glm::u32vec4(0)}, //SRGB_ALPHA_ASTC_4x4, + + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_RGB_ETC2_UNORM_GLI, glm::u32vec4(0)}, //FORMAT_RGB_ETC2_UNORM_BLOCK8, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_RGB_ETC2_SRGB_GLI, glm::u32vec4(0)}, //FORMAT_RGB_ETC2_SRGB_BLOCK8, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_RGBA_ETC2_A1_UNORM_GLI, glm::u32vec4(0)}, //FORMAT_RGBA_ETC2_A1_UNORM_BLOCK8, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_RGBA_ETC2_A1_SRGB_GLI, glm::u32vec4(0)}, //FORMAT_RGBA_ETC2_A1_SRGB_BLOCK8, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_RGBA_ETC2_UNORM_GLI, glm::u32vec4(0)}, //FORMAT_RGBA_ETC2_UNORM_BLOCK16, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_RGBA_ETC2_SRGB_GLI, glm::u32vec4(0)}, //FORMAT_RGBA_ETC2_SRGB_BLOCK16, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R11_EAC_UNORM_GLI, glm::u32vec4(0)}, //FORMAT_R_EAC_UNORM_BLOCK8, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R11_EAC_SNORM_GLI, glm::u32vec4(0)}, //FORMAT_R_EAC_SNORM_BLOCK8, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_RG11_EAC_UNORM_GLI, glm::u32vec4(0)}, //FORMAT_RG_EAC_UNORM_BLOCK8, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_RG11_EAC_SNORM_GLI, glm::u32vec4(0)}, //FORMAT_RG_EAC_SNORM_BLOCK8, + + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_4X4_UNORM, glm::u32vec4(0)}, //FORMAT_ASTC_4x4_UNORM, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_4X4_UNORM_SRGB, glm::u32vec4(0)}, //FORMAT_ASTC_4x4_SRGB, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_5X4_UNORM, glm::u32vec4(0)}, //RGBA_ASTC_5x4, {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_5X4_UNORM_SRGB, glm::u32vec4(0)}, //SRGB_ALPHA_ASTC_5x4, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_5X5_UNORM, glm::u32vec4(0)}, //RGBA_ASTC_5x5, {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_5X5_UNORM_SRGB, glm::u32vec4(0)}, //SRGB_ALPHA_ASTC_5x5, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_6X5_UNORM, glm::u32vec4(0)}, //RGBA_ASTC_6x5, {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_6X5_UNORM_SRGB, glm::u32vec4(0)}, //SRGB_ALPHA_ASTC_6x5, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_6X6_UNORM, glm::u32vec4(0)}, //RGBA_ASTC_6x6, {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_6X6_UNORM_SRGB, glm::u32vec4(0)}, //SRGB_ALPHA_ASTC_6x6, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_8X5_UNORM, glm::u32vec4(0)}, //RGBA_ASTC_8x5, {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_8X5_UNORM_SRGB, glm::u32vec4(0)}, //SRGB_ALPHA_ASTC_8x5, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_8X6_UNORM, glm::u32vec4(0)}, //RGBA_ASTC_8x6, {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_8X6_UNORM_SRGB, glm::u32vec4(0)}, //SRGB_ALPHA_ASTC_8x6, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_8X8_UNORM, glm::u32vec4(0)}, //RGBA_ASTC_8x8, {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_8X8_UNORM_SRGB, glm::u32vec4(0)}, //SRGB_ALPHA_ASTC_8x8, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_10X5_UNORM, glm::u32vec4(0)}, //RGBA_ASTC_10x5, {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_10X5_UNORM_SRGB, glm::u32vec4(0)}, //SRGB_ALPHA_ASTC_10x5, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_10X6_UNORM, glm::u32vec4(0)}, //RGBA_ASTC_10x6, {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_10X6_UNORM_SRGB, glm::u32vec4(0)}, //SRGB_ALPHA_ASTC_10x6, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_10X8_UNORM, glm::u32vec4(0)}, //RGBA_ASTC_10x8, {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_10X8_UNORM_SRGB, glm::u32vec4(0)}, //SRGB_ALPHA_ASTC_10x8, {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_10X10_UNORM_SRGB, glm::u32vec4(0)}, //SRGB_ALPHA_ASTC_10x10, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_10X10_UNORM, glm::u32vec4(0)}, //RGBA_ASTC_10x10, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_12X10_UNORM, glm::u32vec4(0)}, //RGBA_ASTC_12x10, {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_12X10_UNORM_SRGB, glm::u32vec4(0)}, //SRGB_ALPHA_ASTC_12x10, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_12X12_UNORM, glm::u32vec4(0)}, //RGBA_ASTC_12x12, {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_ASTC_12X12_UNORM_SRGB, glm::u32vec4(0)}, //SRGB_ALPHA_ASTC_12x12, - }; + {DDPF_FOURCC, D3DFMT_POWERVR_4BPP, DXGI_FORMAT_RGB_PVRTC1_8X8_UNORM_GLI, glm::u32vec4(0)}, //FORMAT_RGB_PVRTC1_8X8_UNORM_BLOCK32, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_RGB_PVRTC1_8X8_SRGB_GLI, glm::u32vec4(0)}, //FORMAT_RGB_PVRTC1_8X8_SRGB_BLOCK32, + {DDPF_FOURCC, D3DFMT_POWERVR_2BPP, DXGI_FORMAT_RGB_PVRTC1_16X8_UNORM_GLI, glm::u32vec4(0)}, //FORMAT_RGB_PVRTC1_16X8_UNORM_BLOCK32, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_RGB_PVRTC1_16X8_SRGB_GLI, glm::u32vec4(0)}, //FORMAT_RGB_PVRTC1_16X8_SRGB_BLOCK32, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_RGBA_PVRTC1_8X8_UNORM_GLI, glm::u32vec4(0)}, //FORMAT_RGBA_PVRTC1_8X8_UNORM_BLOCK32, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_RGBA_PVRTC1_8X8_SRGB_GLI, glm::u32vec4(0)}, //FORMAT_RGBA_PVRTC1_8X8_SRGB_BLOCK32, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_RGBA_PVRTC1_16X8_UNORM_GLI, glm::u32vec4(0)}, //FORMAT_RGBA_PVRTC1_16X8_UNORM_BLOCK32, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_RGBA_PVRTC1_16X8_SRGB_GLI, glm::u32vec4(0)}, //FORMAT_RGBA_PVRTC1_16X8_SRGB_BLOCK32, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_RGBA_PVRTC2_8X8_UNORM_GLI, glm::u32vec4(0)}, //FORMAT_RGBA_PVRTC2_8X8_UNORM, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_RGBA_PVRTC2_8X8_SRGB_GLI, glm::u32vec4(0)}, //FORMAT_RGBA_PVRTC2_8X8_SRGB, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_RGBA_PVRTC2_16X8_UNORM_GLI, glm::u32vec4(0)}, //FORMAT_RGBA_PVRTC2_16X8_UNORM, + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_RGBA_PVRTC2_16X8_SRGB_GLI, glm::u32vec4(0)}, //FORMAT_RGBA_PVRTC2_16X8_SRGB, + + {DDPF_FOURCC, D3DFMT_ETC, DXGI_FORMAT_RGB_ETC_UNORM_GLI, glm::u32vec4(0)}, //FORMAT_RGB_ETC_UNORM_BLOCK8, + {DDPF_FOURCC, D3DFMT_ATC, DXGI_FORMAT_RGB_ATC_UNORM_GLI, glm::u32vec4(0)}, //FORMAT_RGB_ATC_UNORM_BLOCK8, + {DDPF_FOURCC, D3DFMT_ATCA, DXGI_FORMAT_RGBA_ATCA_UNORM_GLI, glm::u32vec4(0)}, //FORMAT_RGBA_ATCA_UNORM_BLOCK16, + {DDPF_FOURCC, D3DFMT_ATCI, DXGI_FORMAT_RGBA_ATCI_UNORM_GLI, glm::u32vec4(0)}, //FORMAT_RGBA_ATCI_UNORM_BLOCK16, + + {DDPF_LUMINANCE, D3DFMT_L8, DXGI_FORMAT_L8_UNORM_GLI, glm::u32vec4(0x000000FF, 0x00000000, 0x00000000, 0x00000000)}, //L8_UNORM, + {DDPF_ALPHA, D3DFMT_A8, DXGI_FORMAT_A8_UNORM_GLI, glm::u32vec4(0x00000000, 0x00000000, 0x00000000, 0x000000FF)}, //A8_UNORM, + {DDPF_LUMINANCE_ALPHA, D3DFMT_A8L8, DXGI_FORMAT_LA8_UNORM_GLI, glm::u32vec4(0x000000FF, 0x00000000, 0x00000000, 0x0000FF00)}, //LA8_UNORM, + {DDPF_LUMINANCE, D3DFMT_L16, DXGI_FORMAT_L16_UNORM_GLI, glm::u32vec4(0x0000FFFF, 0x00000000, 0x00000000, 0x00000000)}, //L16_UNORM, + {DDPF_ALPHA, D3DFMT_GLI1, DXGI_FORMAT_A16_UNORM_GLI, glm::u32vec4(0x00000000, 0x00000000, 0x00000000, 0x0000FFFF)}, //A16_UNORM, + {DDPF_LUMINANCE_ALPHA, D3DFMT_GLI1, DXGI_FORMAT_LA16_UNORM_GLI, glm::u32vec4(0x0000FFFF, 0x00000000, 0x00000000, 0xFFFF0000)}, //LA16_UNORM, + + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_B8G8R8X8_UNORM, glm::u32vec4(0x00FF0000, 0x0000FF00, 0x000000FF, 0x00000000)}, //FORMAT_BGR8_UNORM_PACK32, + {DDPF_FOURCC, D3DFMT_DX10, DXGI_FORMAT_B8G8R8X8_UNORM_SRGB, glm::u32vec4(0x00FF0000, 0x0000FF00, 0x000000FF, 0x00000000)}, //FORMAT_BGR8_SRGB_PACK32, + + {DDPF_FOURCC, D3DFMT_GLI1, DXGI_FORMAT_R3G3B2_UNORM_GLI, glm::u32vec4(0x70, 0x38, 0xC0, 0x00)}, //FORMAT_RG3B2_UNORM, + }; static_assert(sizeof(Table) / sizeof(Table[0]) == FORMAT_COUNT, "GLI error: format descriptor list doesn't match number of supported formats"); std::copy(&Table[0], &Table[0] + FORMAT_COUNT, this->Translation.begin()); } - inline dx::format const & dx::translate(gli::format const & Format) const + inline dx::format const& dx::translate(gli::format Format) const { - return Translation[Format]; + GLI_ASSERT(Format >= FORMAT_FIRST && Format <= FORMAT_LAST); + return Translation[Format - FORMAT_FIRST]; } - inline gli::format dx::find(dx::D3DFORMAT FourCC) + inline gli::format dx::find(dx::d3dfmt FourCC) const { - for(int FormatIndex = 0; FormatIndex < FORMAT_COUNT; ++FormatIndex) + gli::format FormatResult = static_cast(FORMAT_INVALID); + for(int FormatIndex = FORMAT_FIRST; FormatIndex <= FORMAT_LAST; ++FormatIndex) { - if(this->Translation[FormatIndex].D3DFormat != FourCC) + if(this->Translation[FormatIndex - FORMAT_FIRST].D3DFormat != FourCC) continue; - return static_cast(FormatIndex); + + FormatResult = static_cast(FormatIndex); + break; } - return static_cast(FORMAT_INVALID); + return FormatResult; } - inline gli::format dx::find(dx::dxgiFormat Format) + inline gli::format dx::find(dx::d3dfmt FourCC, dx::dxgiFormat Format) const { - for(int FormatIndex = 0; FormatIndex < FORMAT_COUNT; ++FormatIndex) + GLI_ASSERT(FourCC == D3DFMT_DX10 || FourCC == D3DFMT_GLI1); + + gli::format FormatResult = static_cast(FORMAT_INVALID); + for(int FormatIndex = FORMAT_FIRST; FormatIndex <= FORMAT_LAST; ++FormatIndex) { - if(this->Translation[FormatIndex].DXGIFormat != Format) - continue; - return static_cast(FormatIndex); + gli::format CurrentFormat = static_cast(FormatIndex); + detail::formatInfo const & FormatInfo = detail::get_format_info(CurrentFormat); + + dx::format const & DXFormat = this->Translation[FormatIndex - FORMAT_FIRST]; + + if(FourCC == D3DFMT_GLI1 && (FormatInfo.Flags & detail::CAP_DDS_GLI_EXT_BIT) && DXFormat.DXGIFormat.GLI == Format.GLI) + { + FormatResult = static_cast(FormatIndex); + break; + } + + if(FourCC == D3DFMT_DX10 && !(FormatInfo.Flags & detail::CAP_DDS_GLI_EXT_BIT) && DXFormat.DXGIFormat.DDS == Format.DDS) + { + FormatResult = static_cast(FormatIndex); + break; + } } - return static_cast(FORMAT_INVALID); + return FormatResult; + } + + inline bool is_dds_ext(target Target, format Format) + { + dx DX; + dx::format const & DXFormat = DX.translate(Format); + + bool const UseDDSExt = detail::get_format_info(Format).Flags & detail::CAP_DDS_GLI_EXT_BIT ? true : false; + + return ((DXFormat.DDPixelFormat & dx::DDPF_FOURCC) && DXFormat.D3DFormat == dx::D3DFMT_GLI1) || ((is_target_array(Target) || is_target_1d(Target)) && UseDDSExt); } }//namespace gli diff --git a/external/gli/gli/core/fetch.hpp b/external/gli/gli/core/fetch.hpp deleted file mode 100644 index 01033645..00000000 --- a/external/gli/gli/core/fetch.hpp +++ /dev/null @@ -1,62 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////////// -/// OpenGL Image (gli.g-truc.net) -/// -/// Copyright (c) 2008 - 2015 G-Truc Creation (www.g-truc.net) -/// Permission is hereby granted, free of charge, to any person obtaining a copy -/// of this software and associated documentation files (the "Software"), to deal -/// in the Software without restriction, including without limitation the rights -/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -/// copies of the Software, and to permit persons to whom the Software is -/// furnished to do so, subject to the following conditions: -/// -/// The above copyright notice and this permission notice shall be included in -/// all copies or substantial portions of the Software. -/// -/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -/// THE SOFTWARE. -/// -/// @ref core -/// @file gli/core/fetch.hpp -/// @date 2008-12-19 / 2013-01-13 -/// @author Christophe Riccio -/////////////////////////////////////////////////////////////////////////////////// - -#pragma once - -#include "../gli.hpp" - -namespace gli -{ - /// Fetch a texel from a texture - /// The texture format must be uncompressed - template - genType texel_fetch( - texture2D const & Texture, - texture2D::dim_type const & Texcoord, - texture2D::size_type const & Level); - - /// Write a texel to a texture - /// The texture format must be uncompressed - template - void texel_write( - texture2D & Texture, - texture2D::dim_type const & Texcoord, - texture2D::size_type const & Level, - genType const & Color); - - /// Sample a pixel from a texture - /// The texture format must be uncompressed - template - genType texture_lod( - texture2D const & Texture, - texture2D::texcoord_type const & Texcoord, - texture2D::size_type const & Level); - -}//namespace gli - -#include "fetch.inl" diff --git a/external/gli/gli/core/fetch.inl b/external/gli/gli/core/fetch.inl deleted file mode 100644 index 06a15903..00000000 --- a/external/gli/gli/core/fetch.inl +++ /dev/null @@ -1,107 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////////// -/// OpenGL Image (gli.g-truc.net) -/// -/// Copyright (c) 2008 - 2015 G-Truc Creation (www.g-truc.net) -/// Permission is hereby granted, free of charge, to any person obtaining a copy -/// of this software and associated documentation files (the "Software"), to deal -/// in the Software without restriction, including without limitation the rights -/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -/// copies of the Software, and to permit persons to whom the Software is -/// furnished to do so, subject to the following conditions: -/// -/// The above copyright notice and this permission notice shall be included in -/// all copies or substantial portions of the Software. -/// -/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -/// THE SOFTWARE. -/// -/// @ref core -/// @file gli/gtx/fetch.inl -/// @date 2008-12-19 / 2013-01-13 -/// @author Christophe Riccio -/////////////////////////////////////////////////////////////////////////////////// - -namespace gli -{ - template - inline genType texel_fetch - ( - texture2D const & Texture, - texture2D::dim_type const & TexCoord, - texture2D::size_type const & Level - ) - { - assert(!Texture.empty()); - assert(!is_compressed(Texture.format())); - assert(block_size(Texture.format()) == sizeof(genType)); - - image::dim_type Dimensions = Texture[Level].dimensions(); - genType const * const Data = reinterpret_cast(Texture[Level].data()); - - return reinterpret_cast(Data)[TexCoord.x + TexCoord.y * Dimensions.x]; - } - - template - void texel_write - ( - texture2D & Texture, - texture2D::dim_type const & Texcoord, - texture2D::size_type const & Level, - genType const & Color - ) - { - assert(!Texture.empty()); - assert(!is_compressed(Texture.format())); - assert(block_size(Texture.format()) == sizeof(genType)); - - genType * Data = Texture[Level].data(); - std::size_t Index = Texcoord.x + Texcoord.y * Texture[Level].dimensions().x; - - std::size_t Capacity = Texture[Level].size(); - assert(Index < Capacity); - - *(Data + Index) = Color; - } - - template - inline genType texture_lod - ( - texture2D const & Texture, - texture2D::texcoord_type const & Texcoord, - texture2D::size_type const & Level - ) - { - //assert(Texture.format() == R8U || Texture.format() == RG8U || Texture.format() == RGB8U || Texture.format() == RGBA8U); - - image::dim_type Dimensions = Texture[Level].dimensions(); - genType const * const Data = reinterpret_cast(Texture[Level].data()); - - std::size_t s_below = std::size_t(glm::floor(Texcoord.s * float(Dimensions.x - 1))); - std::size_t s_above = std::size_t(glm::ceil( Texcoord.s * float(Dimensions.x - 1))); - std::size_t t_below = std::size_t(glm::floor(Texcoord.t * float(Dimensions.y - 1))); - std::size_t t_above = std::size_t(glm::ceil( Texcoord.t * float(Dimensions.y - 1))); - - float s_below_normalized = s_below / float(Dimensions.x); - float t_below_normalized = t_below / float(Dimensions.y); - - genType Value1 = reinterpret_cast(Data)[s_below + t_below * Dimensions.x]; - genType Value2 = reinterpret_cast(Data)[s_above + t_below * Dimensions.x]; - genType Value3 = reinterpret_cast(Data)[s_above + t_above * Dimensions.x]; - genType Value4 = reinterpret_cast(Data)[s_below + t_above * Dimensions.x]; - - float BlendA = float(Texcoord.s - s_below_normalized) * float(Dimensions.x - 1); - float BlendB = float(Texcoord.s - s_below_normalized) * float(Dimensions.x - 1); - float BlendC = float(Texcoord.t - t_below_normalized) * float(Dimensions.y - 1); - - genType ValueA(glm::mix(Value1, Value2, BlendA)); - genType ValueB(glm::mix(Value4, Value3, BlendB)); - - return genType(glm::mix(ValueA, ValueB, BlendC)); - } - -}//namespace gli diff --git a/external/gli/gli/core/file.hpp b/external/gli/gli/core/file.hpp new file mode 100644 index 00000000..b61e7ba9 --- /dev/null +++ b/external/gli/gli/core/file.hpp @@ -0,0 +1,15 @@ +/// @brief File helper functions +/// @file gli/core/file.hpp + +#pragma once + +#include + +namespace gli{ +namespace detail +{ + FILE* open_file(const char *Filename, const char *mode); +}//namespace detail +}//namespace gli + +#include "./file.inl" diff --git a/external/gli/gli/core/file.inl b/external/gli/gli/core/file.inl new file mode 100644 index 00000000..018358fa --- /dev/null +++ b/external/gli/gli/core/file.inl @@ -0,0 +1,19 @@ +#pragma once + +#include + +namespace gli{ +namespace detail +{ + inline FILE* open_file(const char *Filename, const char *Mode) + { +# if GLM_COMPILER & GLM_COMPILER_VC + FILE *File = nullptr; + fopen_s(&File, Filename, Mode); + return File; +# else + return std::fopen(Filename, Mode); +# endif + } +}//namespace detail +}//namespace gli diff --git a/external/gli/gli/core/filter.hpp b/external/gli/gli/core/filter.hpp new file mode 100644 index 00000000..5176ae98 --- /dev/null +++ b/external/gli/gli/core/filter.hpp @@ -0,0 +1,23 @@ +/// @brief Include to use filter enum, to select filtering methods. +/// @file gli/core/filter.hpp + +#pragma once + +namespace gli +{ + /// Texture filtring modes + enum filter + { + FILTER_NONE = 0, + FILTER_NEAREST, FILTER_FIRST = FILTER_NEAREST, + FILTER_LINEAR, FILTER_LAST = FILTER_LINEAR + }; + + enum + { + FILTER_COUNT = FILTER_LAST - FILTER_FIRST + 1, + FILTER_INVALID = -1 + }; +}//namespace gli + +#include "filter.inl" diff --git a/external/gli/gli/core/filter.inl b/external/gli/gli/core/filter.inl new file mode 100644 index 00000000..fd0ab9b0 --- /dev/null +++ b/external/gli/gli/core/filter.inl @@ -0,0 +1,8 @@ +#pragma once + +namespace gli{ +namespace detail +{ + +}//namespace detail +}//namespace gli diff --git a/external/gli/gli/core/filter_compute.hpp b/external/gli/gli/core/filter_compute.hpp new file mode 100644 index 00000000..a3956e53 --- /dev/null +++ b/external/gli/gli/core/filter_compute.hpp @@ -0,0 +1,390 @@ +#pragma once + +#include "filter.hpp" +#include "coord.hpp" +#include + +namespace gli{ +namespace detail +{ + enum dimension + { + DIMENSION_1D, + DIMENSION_2D, + DIMENSION_3D + }; + + template + struct interpolate + { + typedef float type; + }; + + template <> + struct interpolate + { + typedef double type; + }; + + template <> + struct interpolate + { + typedef long double type; + }; + + template + struct filterBase + { + typedef typename texture_type::size_type size_type; + typedef typename texture_type::extent_type extent_type; + + typedef texel_type(*filterFunc)( + texture_type const & Texture, fetch_type Fetch, normalized_type const & SampleCoordWrap, + size_type Layer, size_type Face, interpolate_type Level, + texel_type const & BorderColor); + }; + + template + struct nearest : public filterBase + { + typedef filterBase base_type; + typedef typename base_type::size_type size_type; + typedef typename base_type::extent_type extent_type; + typedef coord_nearest coord_type; + + static texel_type call(texture_type const & Texture, fetch_type Fetch, normalized_type const & SampleCoordWrap, size_type Layer, size_type Face, size_type Level, texel_type const & BorderColor) + { + extent_type const TexelDim(Texture.extent(Level)); + normalized_type const TexelLast(normalized_type(TexelDim) - normalized_type(1)); + + //extent_type const TexelCoord(SampleCoordWrap * TexelLast + interpolate_type(0.5)); + extent_type const TexelCoord = extent_type(round(SampleCoordWrap * TexelLast)); + typename extent_type::bool_type const UseTexelCoord = in_interval(TexelCoord, extent_type(0), TexelDim - 1); + + texel_type Texel(BorderColor); + if(all(UseTexelCoord)) + Texel = Fetch(Texture, TexelCoord, Layer, Face, Level); + + return Texel; + } + }; + + template + struct nearest : public filterBase + { + typedef filterBase base_type; + typedef typename base_type::size_type size_type; + typedef typename base_type::extent_type extent_type; + typedef coord_nearest coord_type; + + static texel_type call(texture_type const & Texture, fetch_type Fetch, normalized_type const & SampleCoordWrap, size_type Layer, size_type Face, size_type Level, texel_type const & BorderColor) + { + normalized_type const TexelLast(normalized_type(Texture.extent(Level)) - normalized_type(1)); + extent_type const TexelCoord(SampleCoordWrap * TexelLast + interpolate_type(0.5)); + //extent_type const TexelCoord = extent_type(round(SampleCoordWrap * TexelLast)); + + return Fetch(Texture, TexelCoord, Layer, Face, Level); + } + }; + + template + struct linear : public filterBase + { + typedef filterBase base_type; + typedef typename base_type::size_type size_type; + typedef typename base_type::extent_type extent_type; + + static texel_type call(texture_type const & Texture, fetch_type Fetch, normalized_type const & SampleCoordWrap, size_type Layer, size_type Face, size_type Level, texel_type const& BorderColor) + { + return texel_type(0); + } + }; + + template + struct linear : public filterBase + { + typedef filterBase base_type; + typedef typename base_type::size_type size_type; + typedef typename base_type::extent_type extent_type; + typedef coord_linear_border coord_type; + + static texel_type call(texture_type const & Texture, fetch_type Fetch, normalized_type const & SampleCoordWrap, size_type Layer, size_type Face, size_type Level, texel_type const & BorderColor) + { + coord_type const& Coord = make_coord_linear_border(Texture.extent(Level), SampleCoordWrap); + + texel_type Texel0(BorderColor); + if(Coord.UseTexelFloor.s) + Texel0 = Fetch(Texture, extent_type(Coord.TexelFloor.s), Layer, Face, Level); + + texel_type Texel1(BorderColor); + if(Coord.UseTexelCeil.s) + Texel1 = Fetch(Texture, extent_type(Coord.TexelCeil.s), Layer, Face, Level); + + return mix(Texel0, Texel1, Coord.Blend.s); + } + }; + + template + struct linear : public filterBase + { + typedef filterBase base_type; + typedef typename base_type::size_type size_type; + typedef typename base_type::extent_type extent_type; + typedef coord_linear coord_type; + + static texel_type call(texture_type const & Texture, fetch_type Fetch, normalized_type const & SampleCoordWrap, size_type Layer, size_type Face, size_type Level, texel_type const & BorderColor) + { + coord_type const& Coord = make_coord_linear(Texture.extent(Level), SampleCoordWrap); + + texel_type const Texel0 = Fetch(Texture, extent_type(Coord.TexelFloor.s), Layer, Face, Level); + texel_type const Texel1 = Fetch(Texture, extent_type(Coord.TexelCeil.s), Layer, Face, Level); + + return mix(Texel0, Texel1, Coord.Blend.s); + } + }; + + template + struct linear : public filterBase + { + typedef filterBase base_type; + typedef typename base_type::size_type size_type; + typedef typename base_type::extent_type extent_type; + typedef coord_linear_border coord_type; + + static texel_type call(texture_type const& Texture, fetch_type Fetch, normalized_type const& SampleCoordWrap, size_type Layer, size_type Face, size_type Level, texel_type const& BorderColor) + { + coord_type const& Coord = make_coord_linear_border(Texture.extent(Level), SampleCoordWrap); + + texel_type Texel00(BorderColor); + if(Coord.UseTexelFloor.s && Coord.UseTexelFloor.t) + Texel00 = Fetch(Texture, extent_type(Coord.TexelFloor.s, Coord.TexelFloor.t), Layer, Face, Level); + + texel_type Texel10(BorderColor); + if(Coord.UseTexelCeil.s && Coord.UseTexelFloor.t) + Texel10 = Fetch(Texture, extent_type(Coord.TexelCeil.s, Coord.TexelFloor.t), Layer, Face, Level); + + texel_type Texel11(BorderColor); + if(Coord.UseTexelCeil.s && Coord.UseTexelCeil.t) + Texel11 = Fetch(Texture, extent_type(Coord.TexelCeil.s, Coord.TexelCeil.t), Layer, Face, Level); + + texel_type Texel01(BorderColor); + if(Coord.UseTexelFloor.s && Coord.UseTexelCeil.t) + Texel01 = Fetch(Texture, extent_type(Coord.TexelFloor.s, Coord.TexelCeil.t), Layer, Face, Level); + + texel_type const ValueA(mix(Texel00, Texel10, Coord.Blend.s)); + texel_type const ValueB(mix(Texel01, Texel11, Coord.Blend.s)); + return mix(ValueA, ValueB, Coord.Blend.t); + } + }; + + template + struct linear : public filterBase + { + typedef filterBase base_type; + typedef typename base_type::size_type size_type; + typedef typename base_type::extent_type extent_type; + typedef coord_linear coord_type; + + static texel_type call(texture_type const& Texture, fetch_type Fetch, normalized_type const& SampleCoordWrap, size_type Layer, size_type Face, size_type Level, texel_type const& BorderColor) + { + coord_type const& Coord = make_coord_linear(Texture.extent(Level), SampleCoordWrap); + + texel_type const& Texel00 = Fetch(Texture, extent_type(Coord.TexelFloor.s, Coord.TexelFloor.t), Layer, Face, Level); + texel_type const& Texel10 = Fetch(Texture, extent_type(Coord.TexelCeil.s, Coord.TexelFloor.t), Layer, Face, Level); + texel_type const& Texel11 = Fetch(Texture, extent_type(Coord.TexelCeil.s, Coord.TexelCeil.t), Layer, Face, Level); + texel_type const& Texel01 = Fetch(Texture, extent_type(Coord.TexelFloor.s, Coord.TexelCeil.t), Layer, Face, Level); + + texel_type const ValueA(mix(Texel00, Texel10, Coord.Blend.s)); + texel_type const ValueB(mix(Texel01, Texel11, Coord.Blend.s)); + return mix(ValueA, ValueB, Coord.Blend.t); + } + }; + + template + struct linear : public filterBase + { + typedef filterBase base_type; + typedef typename base_type::size_type size_type; + typedef typename base_type::extent_type extent_type; + typedef coord_linear_border coord_type; + + static texel_type call(texture_type const& Texture, fetch_type Fetch, normalized_type const& SampleCoordWrap, size_type Layer, size_type Face, size_type Level, texel_type const& BorderColor) + { + coord_type const& Coord = make_coord_linear_border(Texture.extent(Level), SampleCoordWrap); + + texel_type Texel000(BorderColor); + if(Coord.UseTexelFloor.s && Coord.UseTexelFloor.t && Coord.UseTexelFloor.p) + Texel000 = Fetch(Texture, extent_type(Coord.TexelFloor.s, Coord.TexelFloor.t, Coord.TexelFloor.p), Layer, Face, Level); + + texel_type Texel100(BorderColor); + if(Coord.UseTexelCeil.s && Coord.UseTexelFloor.t && Coord.UseTexelFloor.p) + Texel100 = Fetch(Texture, extent_type(Coord.TexelCeil.s, Coord.TexelFloor.t, Coord.TexelFloor.p), Layer, Face, Level); + + texel_type Texel110(BorderColor); + if(Coord.UseTexelCeil.s && Coord.UseTexelCeil.t && Coord.UseTexelFloor.p) + Texel110 = Fetch(Texture, extent_type(Coord.TexelCeil.s, Coord.TexelCeil.t, Coord.TexelFloor.p), Layer, Face, Level); + + texel_type Texel010(BorderColor); + if(Coord.UseTexelFloor.s && Coord.UseTexelCeil.t && Coord.UseTexelFloor.p) + Texel010 = Fetch(Texture, extent_type(Coord.TexelFloor.s, Coord.TexelCeil.t, Coord.TexelFloor.p), Layer, Face, Level); + + texel_type Texel001(BorderColor); + if (Coord.UseTexelFloor.s && Coord.UseTexelFloor.t && Coord.UseTexelCeil.p) + Texel001 = Fetch(Texture, extent_type(Coord.TexelFloor.s, Coord.TexelFloor.t, Coord.TexelCeil.p), Layer, Face, Level); + + texel_type Texel101(BorderColor); + if(Coord.UseTexelCeil.s && Coord.UseTexelFloor.t && Coord.UseTexelCeil.p) + Texel101 = Fetch(Texture, extent_type(Coord.TexelCeil.s, Coord.TexelFloor.t, Coord.TexelCeil.p), Layer, Face, Level); + + texel_type Texel111(BorderColor); + if(Coord.UseTexelCeil.s && Coord.UseTexelCeil.t && Coord.UseTexelCeil.p) + Texel111 = Fetch(Texture, extent_type(Coord.TexelCeil.s, Coord.TexelCeil.t, Coord.TexelCeil.p), Layer, Face, Level); + + texel_type Texel011(BorderColor); + if(Coord.UseTexelFloor.s && Coord.UseTexelCeil.t && Coord.UseTexelCeil.p) + Texel011 = Fetch(Texture, extent_type(Coord.TexelFloor.s, Coord.TexelCeil.t, Coord.TexelCeil.p), Layer, Face, Level); + + texel_type const ValueA(mix(Texel000, Texel100, Coord.Blend.s)); + texel_type const ValueB(mix(Texel010, Texel110, Coord.Blend.s)); + + texel_type const ValueC(mix(Texel001, Texel101, Coord.Blend.s)); + texel_type const ValueD(mix(Texel011, Texel111, Coord.Blend.s)); + + texel_type const ValueE(mix(ValueA, ValueB, Coord.Blend.t)); + texel_type const ValueF(mix(ValueC, ValueD, Coord.Blend.t)); + + return mix(ValueE, ValueF, Coord.Blend.p); + } + }; + + template + struct linear : public filterBase + { + typedef filterBase base_type; + typedef typename base_type::size_type size_type; + typedef typename base_type::extent_type extent_type; + typedef coord_linear coord_type; + + static texel_type call(texture_type const & Texture, fetch_type Fetch, normalized_type const & SampleCoordWrap, size_type Layer, size_type Face, size_type Level, texel_type const & BorderColor) + { + coord_type const & Coord = make_coord_linear(Texture.extent(Level), SampleCoordWrap); + + texel_type const & Texel000 = Fetch(Texture, extent_type(Coord.TexelFloor.s, Coord.TexelFloor.t, Coord.TexelFloor.p), Layer, Face, Level); + texel_type const & Texel100 = Fetch(Texture, extent_type(Coord.TexelCeil.s, Coord.TexelFloor.t, Coord.TexelFloor.p), Layer, Face, Level); + texel_type const & Texel110 = Fetch(Texture, extent_type(Coord.TexelCeil.s, Coord.TexelCeil.t, Coord.TexelFloor.p), Layer, Face, Level); + texel_type const & Texel010 = Fetch(Texture, extent_type(Coord.TexelFloor.s, Coord.TexelCeil.t, Coord.TexelFloor.p), Layer, Face, Level); + texel_type const & Texel001 = Fetch(Texture, extent_type(Coord.TexelFloor.s, Coord.TexelFloor.t, Coord.TexelCeil.p), Layer, Face, Level); + texel_type const & Texel101 = Fetch(Texture, extent_type(Coord.TexelCeil.s, Coord.TexelFloor.t, Coord.TexelCeil.p), Layer, Face, Level); + texel_type const & Texel111 = Fetch(Texture, extent_type(Coord.TexelCeil.s, Coord.TexelCeil.t, Coord.TexelCeil.p), Layer, Face, Level); + texel_type const & Texel011 = Fetch(Texture, extent_type(Coord.TexelFloor.s, Coord.TexelCeil.t, Coord.TexelCeil.p), Layer, Face, Level); + + texel_type const ValueA(mix(Texel000, Texel100, Coord.Blend.s)); + texel_type const ValueB(mix(Texel010, Texel110, Coord.Blend.s)); + + texel_type const ValueC(mix(Texel001, Texel101, Coord.Blend.s)); + texel_type const ValueD(mix(Texel011, Texel111, Coord.Blend.s)); + + texel_type const ValueE(mix(ValueA, ValueB, Coord.Blend.t)); + texel_type const ValueF(mix(ValueC, ValueD, Coord.Blend.t)); + + return mix(ValueE, ValueF, Coord.Blend.p); + } + }; + + template + struct nearest_mipmap_nearest : public filterBase + { + typedef filterBase base_type; + typedef typename base_type::size_type size_type; + typedef typename base_type::extent_type extent_type; + typedef coord_linear_border coord_type; + + static texel_type call(texture_type const & Texture, fetch_type Fetch, normalized_type const & SampleCoordWrap, size_type Layer, size_type Face, interpolate_type Level, texel_type const & BorderColor) + { + return nearest::call(Texture, Fetch, SampleCoordWrap, Layer, Face, glm::iround(Level), BorderColor); + } + }; + + template + struct nearest_mipmap_linear : public filterBase + { + typedef filterBase base_type; + typedef typename base_type::size_type size_type; + typedef typename base_type::extent_type extent_type; + typedef coord_linear_border coord_type; + + static texel_type call(texture_type const & Texture, fetch_type Fetch, normalized_type const & SampleCoordWrap, size_type Layer, size_type Face, interpolate_type Level, texel_type const & BorderColor) + { + texel_type const MinTexel = nearest::call(Texture, Fetch, SampleCoordWrap, Layer, Face, static_cast(floor(Level)), BorderColor); + texel_type const MaxTexel = nearest::call(Texture, Fetch, SampleCoordWrap, Layer, Face, static_cast(ceil(Level)), BorderColor); + return mix(MinTexel, MaxTexel, fract(Level)); + } + }; + + template + struct linear_mipmap_nearest : public filterBase + { + typedef filterBase base_type; + typedef typename base_type::size_type size_type; + typedef typename base_type::extent_type extent_type; + typedef coord_linear_border coord_type; + + static texel_type call(texture_type const & Texture, fetch_type Fetch, normalized_type const & SampleCoordWrap, size_type Layer, size_type Face, interpolate_type Level, texel_type const & BorderColor) + { + return linear::call(Texture, Fetch, SampleCoordWrap, Layer, Face, glm::iround(Level), BorderColor); + } + }; + + template + struct linear_mipmap_linear : public filterBase + { + typedef filterBase base_type; + typedef typename base_type::size_type size_type; + typedef typename base_type::extent_type extent_type; + typedef coord_linear_border coord_type; + + static texel_type call(texture_type const & Texture, fetch_type Fetch, normalized_type const & SampleCoordWrap, size_type Layer, size_type Face, interpolate_type Level, texel_type const & BorderColor) + { + size_type const FloorLevel = static_cast(floor(Level)); + size_type const CeilLevel = static_cast(ceil(Level)); + texel_type const MinTexel = linear::call(Texture, Fetch, SampleCoordWrap, Layer, Face, FloorLevel, BorderColor); + texel_type const MaxTexel = linear::call(Texture, Fetch, SampleCoordWrap, Layer, Face, CeilLevel, BorderColor); + return mix(MinTexel, MaxTexel, fract(Level)); + } + }; + + template + inline filter_type get_filter(filter Mip, filter Min, bool Border) + { + static filter_type Table[][FILTER_COUNT][2] = + { + { + { + nearest_mipmap_nearest::is_iec559, false>::call, + nearest_mipmap_nearest::is_iec559, true>::call + }, + { + linear_mipmap_nearest::is_iec559, false>::call, + linear_mipmap_nearest::is_iec559, true>::call + } + }, + { + { + nearest_mipmap_linear::is_iec559, false>::call, + nearest_mipmap_linear::is_iec559, true>::call + }, + { + linear_mipmap_linear::is_iec559, false>::call, + linear_mipmap_linear::is_iec559, true>::call + } + } + }; + static_assert(sizeof(Table) / sizeof(Table[0]) == FILTER_COUNT, "GLI ERROR: 'Table' doesn't match the number of supported filters"); + + GLI_ASSERT(Table[Mip - FILTER_FIRST][Min - FILTER_FIRST][Border ? 1 : 0]); + + return Table[Mip - FILTER_FIRST][Min - FILTER_FIRST][Border ? 1 : 0]; + } +}//namespace detail +}//namespace gli + diff --git a/external/gli/gli/core/flip.hpp b/external/gli/gli/core/flip.hpp index e6e104b1..f2885425 100644 --- a/external/gli/gli/core/flip.hpp +++ b/external/gli/gli/core/flip.hpp @@ -1,35 +1,11 @@ -/////////////////////////////////////////////////////////////////////////////////// -/// OpenGL Image (gli.g-truc.net) -/// -/// Copyright (c) 2008 - 2015 G-Truc Creation (www.g-truc.net) -/// Permission is hereby granted, free of charge, to any person obtaining a copy -/// of this software and associated documentation files (the "Software"), to deal -/// in the Software without restriction, including without limitation the rights -/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -/// copies of the Software, and to permit persons to whom the Software is -/// furnished to do so, subject to the following conditions: -/// -/// The above copyright notice and this permission notice shall be included in -/// all copies or substantial portions of the Software. -/// -/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -/// THE SOFTWARE. -/// -/// @ref core -/// @file gli/core/flip.hpp -/// @date 2014-01-17 / 2014-01-17 -/// @author Christophe Riccio -/////////////////////////////////////////////////////////////////////////////////// - #pragma once +#include + #include "../texture2d.hpp" #include "../texture2d_array.hpp" +#include "../texture_cube.hpp" +#include "../texture_cube_array.hpp" namespace gli { diff --git a/external/gli/gli/core/flip.inl b/external/gli/gli/core/flip.inl index 039aba25..d58813c7 100644 --- a/external/gli/gli/core/flip.inl +++ b/external/gli/gli/core/flip.inl @@ -1,42 +1,14 @@ -/////////////////////////////////////////////////////////////////////////////////// -/// OpenGL Image (gli.g-truc.net) -/// -/// Copyright (c) 2008 - 2015 G-Truc Creation (www.g-truc.net) -/// Permission is hereby granted, free of charge, to any person obtaining a copy -/// of this software and associated documentation files (the "Software"), to deal -/// in the Software without restriction, including without limitation the rights -/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -/// copies of the Software, and to permit persons to whom the Software is -/// furnished to do so, subject to the following conditions: -/// -/// The above copyright notice and this permission notice shall be included in -/// all copies or substantial portions of the Software. -/// -/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -/// THE SOFTWARE. -/// -/// @ref core -/// @file gli/core/flip.inl -/// @date 2014-01-17 / 2014-01-17 -/// @author Christophe Riccio -/////////////////////////////////////////////////////////////////////////////////// - namespace gli{ namespace detail { - inline void flip(image ImageDst, image ImageSrc, std::size_t BlockSize) + inline void flip(image ImageDst, image ImageSrc, size_t BlockSize) { - std::size_t const LineSize = BlockSize * ImageDst.dimensions().x; + size_t const LineSize = BlockSize * ImageDst.extent().x; - for(std::size_t y = 0; y < ImageDst.dimensions().y; ++y) + for(int y = 0; y < ImageDst.extent().y; ++y) { - std::size_t OffsetDst = LineSize * y; - std::size_t OffsetSrc = ImageSrc.size() - (LineSize * (y + 1)); + size_t OffsetDst = LineSize * y; + size_t OffsetSrc = ImageSrc.size() - (LineSize * (y + 1)); memcpy( ImageDst.data() + OffsetDst, @@ -45,6 +17,199 @@ namespace detail } } + struct dxt1_block + { + uint16_t Color0; + uint16_t Color1; + uint8_t Row0; + uint8_t Row1; + uint8_t Row2; + uint8_t Row3; + }; + + struct dxt3_block + { + uint16_t AlphaRow0; + uint16_t AlphaRow1; + uint16_t AlphaRow2; + uint16_t AlphaRow3; + uint16_t Color0; + uint16_t Color1; + uint8_t Row0; + uint8_t Row1; + uint8_t Row2; + uint8_t Row3; + }; + + struct dxt5_block + { + uint8_t Alpha0; + uint8_t Alpha1; + uint8_t AlphaR0; + uint8_t AlphaR1; + uint8_t AlphaR2; + uint8_t AlphaR3; + uint8_t AlphaR4; + uint8_t AlphaR5; + uint16_t Color0; + uint16_t Color1; + uint8_t Row0; + uint8_t Row1; + uint8_t Row2; + uint8_t Row3; + }; + + inline void flip_block_s3tc(uint8_t* BlockDst, uint8_t* BlockSrc, format Format, bool HeightTwo) + { + // There is no distinction between RGB and RGBA in DXT-compressed textures, + // it is used only to tell OpenGL how to interpret the data. + // Moreover, in DXT1 (which does not contain an alpha channel), transparency can be emulated + // using Color0 and Color1 on a per-compression-block basis. + // There is no difference in how textures with and without transparency are laid out in the file, + // so they can be flipped using the same method. + if(Format == FORMAT_RGB_DXT1_UNORM_BLOCK8 || Format == FORMAT_RGB_DXT1_SRGB_BLOCK8 + || Format == FORMAT_RGBA_DXT1_UNORM_BLOCK8 || Format == FORMAT_RGBA_DXT1_SRGB_BLOCK8) + { + dxt1_block* Src = reinterpret_cast(BlockSrc); + dxt1_block* Dst = reinterpret_cast(BlockDst); + + if(HeightTwo) + { + Dst->Color0 = Src->Color0; + Dst->Color1 = Src->Color1; + Dst->Row0 = Src->Row1; + Dst->Row1 = Src->Row0; + Dst->Row2 = Src->Row2; + Dst->Row3 = Src->Row3; + + return; + } + + Dst->Color0 = Src->Color0; + Dst->Color1 = Src->Color1; + Dst->Row0 = Src->Row3; + Dst->Row1 = Src->Row2; + Dst->Row2 = Src->Row1; + Dst->Row3 = Src->Row0; + + return; + } + + // DXT3 + if(Format == FORMAT_RGBA_DXT3_UNORM_BLOCK16 || Format == FORMAT_RGBA_DXT3_SRGB_BLOCK16) + { + dxt3_block* Src = reinterpret_cast(BlockSrc); + dxt3_block* Dst = reinterpret_cast(BlockDst); + + if(HeightTwo) + { + Dst->AlphaRow0 = Src->AlphaRow1; + Dst->AlphaRow1 = Src->AlphaRow0; + Dst->AlphaRow2 = Src->AlphaRow2; + Dst->AlphaRow3 = Src->AlphaRow3; + Dst->Color0 = Src->Color0; + Dst->Color1 = Src->Color1; + Dst->Row0 = Src->Row1; + Dst->Row1 = Src->Row0; + Dst->Row2 = Src->Row2; + Dst->Row3 = Src->Row3; + + return; + } + + Dst->AlphaRow0 = Src->AlphaRow3; + Dst->AlphaRow1 = Src->AlphaRow2; + Dst->AlphaRow2 = Src->AlphaRow1; + Dst->AlphaRow3 = Src->AlphaRow0; + Dst->Color0 = Src->Color0; + Dst->Color1 = Src->Color1; + Dst->Row0 = Src->Row3; + Dst->Row1 = Src->Row2; + Dst->Row2 = Src->Row1; + Dst->Row3 = Src->Row0; + + return; + } + + // DXT5 + if(Format == FORMAT_RGBA_DXT5_UNORM_BLOCK16 || Format == FORMAT_RGBA_DXT5_SRGB_BLOCK16) + { + dxt5_block* Src = reinterpret_cast(BlockSrc); + dxt5_block* Dst = reinterpret_cast(BlockDst); + + if(HeightTwo) + { + Dst->Alpha0 = Src->Alpha0; + Dst->Alpha1 = Src->Alpha1; + // operator+ has precedence over operator>> and operator<<, hence the parentheses. very important! + // the values below are bitmasks used to retrieve alpha values according to the DXT specification + // 0xF0 == 0b11110000 and 0xF == 0b1111 + Dst->AlphaR0 = ((Src->AlphaR1 & 0xF0) >> 4) + ((Src->AlphaR2 & 0xF) << 4); + Dst->AlphaR1 = ((Src->AlphaR2 & 0xF0) >> 4) + ((Src->AlphaR0 & 0xF) << 4); + Dst->AlphaR2 = ((Src->AlphaR0 & 0xF0) >> 4) + ((Src->AlphaR1 & 0xF) << 4); + Dst->AlphaR3 = Src->AlphaR3; + Dst->AlphaR4 = Src->AlphaR4; + Dst->AlphaR5 = Src->AlphaR5; + Dst->Color0 = Src->Color0; + Dst->Color1 = Src->Color1; + Dst->Row0 = Src->Row1; + Dst->Row1 = Src->Row0; + Dst->Row2 = Src->Row2; + Dst->Row3 = Src->Row3; + + return; + } + + Dst->Alpha0 = Src->Alpha0; + Dst->Alpha1 = Src->Alpha1; + // operator+ has precedence over operator>> and operator<<, hence the parentheses. very important! + // the values below are bitmasks used to retrieve alpha values according to the DXT specification + // 0xF0 == 0b11110000 and 0xF == 0b1111 + Dst->AlphaR0 = ((Src->AlphaR4 & 0xF0) >> 4) + ((Src->AlphaR5 & 0xF) << 4); + Dst->AlphaR1 = ((Src->AlphaR5 & 0xF0) >> 4) + ((Src->AlphaR3 & 0xF) << 4); + Dst->AlphaR2 = ((Src->AlphaR3 & 0xF0) >> 4) + ((Src->AlphaR4 & 0xF) << 4); + Dst->AlphaR3 = ((Src->AlphaR1 & 0xF0) >> 4) + ((Src->AlphaR2 & 0xF) << 4); + Dst->AlphaR4 = ((Src->AlphaR2 & 0xF0) >> 4) + ((Src->AlphaR0 & 0xF) << 4); + Dst->AlphaR5 = ((Src->AlphaR0 & 0xF0) >> 4) + ((Src->AlphaR1 & 0xF) << 4); + Dst->Color0 = Src->Color0; + Dst->Color1 = Src->Color1; + Dst->Row0 = Src->Row3; + Dst->Row1 = Src->Row2; + Dst->Row2 = Src->Row1; + Dst->Row3 = Src->Row0; + + return; + } + + // invalid format specified (unknown S3TC format?) + assert(false); + } + + inline void flip_s3tc(image ImageDst, image ImageSrc, format Format) + { + if(ImageSrc.extent().y == 1) + { + memcpy(ImageDst.data(), + ImageSrc.data(), + ImageSrc.size()); + return; + } + + std::size_t const XBlocks = ImageSrc.extent().x <= 4 ? 1 : ImageSrc.extent().x / 4; + if(ImageSrc.extent().y == 2) + { + for(std::size_t i_block = 0; i_block < XBlocks; ++i_block) + flip_block_s3tc(ImageDst.data() + i_block * block_size(Format), ImageSrc.data() + i_block * block_size(Format), Format, true); + + return; + } + + std::size_t const MaxYBlock = ImageSrc.extent().y / 4 - 1; + for(std::size_t i_row = 0; i_row <= MaxYBlock; ++i_row) + for(std::size_t i_block = 0; i_block < XBlocks; ++i_block) + flip_block_s3tc(ImageDst.data() + (MaxYBlock - i_row) * block_size(Format) * XBlocks + i_block * block_size(Format), ImageSrc.data() + i_row * block_size(Format) * XBlocks + i_block * block_size(Format), Format, false); + } + }//namespace detail /* @@ -56,34 +221,118 @@ inline image flip(image const & Image) */ template <> -inline texture2D flip(texture2D const & Texture) +inline texture2d flip(texture2d const& Texture) { - assert(!gli::is_compressed(Texture.format())); + GLI_ASSERT(!gli::is_compressed(Texture.format()) || gli::is_s3tc_compressed(Texture.format())); - texture2D Flip(Texture.format(), Texture.dimensions(), Texture.levels()); + texture2d Flip(Texture.format(), Texture.extent(), Texture.levels()); - gli::size_t const BlockSize = block_size(Texture.format()); + if(!is_compressed(Texture.format())) + { + texture2d::size_type const BlockSize = block_size(Texture.format()); - for(std::size_t Level = 0; Level < Flip.levels(); ++Level) - detail::flip(Flip[Level], Texture[Level], BlockSize); + for(texture2d::size_type Level = 0; Level < Flip.levels(); ++Level) + detail::flip(Flip[Level], Texture[Level], BlockSize); + } + else + for(texture2d::size_type Level = 0; Level < Flip.levels(); ++Level) + detail::flip_s3tc(Flip[Level], Texture[Level], Texture.format()); return Flip; } template <> -inline texture2DArray flip(texture2DArray const & Texture) +inline texture2d_array flip(texture2d_array const& Texture) { - assert(!gli::is_compressed(Texture.format())); + GLI_ASSERT(!gli::is_compressed(Texture.format()) || gli::is_s3tc_compressed(Texture.format())); - texture2DArray Flip(Texture.format(), Texture.dimensions(), Texture.layers(), Texture.levels()); + texture2d_array Flip(Texture.format(), Texture.extent(), Texture.layers(), Texture.levels()); - gli::size_t const BlockSize = block_size(Texture.format()); + if(!gli::is_compressed(Texture.format())) + { + texture2d_array::size_type const BlockSize = block_size(Texture.format()); - for(std::size_t Layer = 0; Layer < Flip.layers(); ++Layer) - for(std::size_t Level = 0; Level < Flip.levels(); ++Level) - detail::flip(Flip[Layer][Level], Texture[Layer][Level], BlockSize); + for(texture2d_array::size_type Layer = 0; Layer < Flip.layers(); ++Layer) + for(texture2d_array::size_type Level = 0; Level < Flip.levels(); ++Level) + detail::flip(Flip[Layer][Level], Texture[Layer][Level], BlockSize); + } + else + for(texture2d_array::size_type Layer = 0; Layer < Flip.layers(); ++Layer) + for(texture2d_array::size_type Level = 0; Level < Flip.levels(); ++Level) + detail::flip_s3tc(Flip[Layer][Level], Texture[Layer][Level], Texture.format()); return Flip; } +template <> +inline texture_cube flip(texture_cube const & Texture) +{ + GLI_ASSERT(!gli::is_compressed(Texture.format()) || gli::is_s3tc_compressed(Texture.format())); + + texture_cube Flip(Texture.format(), Texture.extent(), Texture.levels()); + + if(!gli::is_compressed(Texture.format())) + { + texture_cube::size_type const BlockSize = block_size(Texture.format()); + + for(texture_cube::size_type Face = 0; Face < Flip.faces(); ++Face) + for(texture_cube::size_type Level = 0; Level < Flip.levels(); ++Level) + detail::flip(Flip[Face][Level], Texture[Face][Level], BlockSize); + } + else + for(texture_cube::size_type Face = 0; Face < Flip.faces(); ++Face) + for(texture_cube::size_type Level = 0; Level < Flip.levels(); ++Level) + detail::flip_s3tc(Flip[Face][Level], Texture[Face][Level], Texture.format()); + + return Flip; +} + +template <> +inline texture_cube_array flip(texture_cube_array const & Texture) +{ + assert(!is_compressed(Texture.format()) || is_s3tc_compressed(Texture.format())); + + texture_cube_array Flip(Texture.format(), Texture.extent(), Texture.layers(), Texture.levels()); + + if(!is_compressed(Texture.format())) + { + gli::size_t const BlockSize = block_size(Texture.format()); + + for(std::size_t Layer = 0; Layer < Flip.layers(); ++Layer) + for(std::size_t Face = 0; Face < Flip.faces(); ++Face) + for(std::size_t Level = 0; Level < Flip.levels(); ++Level) + detail::flip(Flip[Layer][Face][Level], Texture[Layer][Face][Level], BlockSize); + } + else + for(std::size_t Layer = 0; Layer < Flip.layers(); ++Layer) + for(std::size_t Face = 0; Face < Flip.faces(); ++Face) + for(std::size_t Level = 0; Level < Flip.levels(); ++Level) + detail::flip_s3tc(Flip[Layer][Face][Level], Texture[Layer][Face][Level], Texture.format()); + + return Flip; +} + +template <> +inline texture flip(texture const & Texture) +{ + switch(Texture.target()) + { + case TARGET_2D: + return flip(texture2d(Texture)); + + case TARGET_2D_ARRAY: + return flip(texture2d_array(Texture)); + + case TARGET_CUBE: + return flip(texture_cube(Texture)); + + case TARGET_CUBE_ARRAY: + return flip(texture_cube_array(Texture)); + + default: + assert(false && "Texture target does not support flipping."); + return Texture; + } +} + }//namespace gli diff --git a/external/gli/gli/core/format.inl b/external/gli/gli/core/format.inl index 93743333..1a77f14d 100644 --- a/external/gli/gli/core/format.inl +++ b/external/gli/gli/core/format.inl @@ -1,38 +1,10 @@ -/////////////////////////////////////////////////////////////////////////////////// -/// OpenGL Image (gli.g-truc.net) -/// -/// Copyright (c) 2008 - 2015 G-Truc Creation (www.g-truc.net) -/// Permission is hereby granted, free of charge, to any person obtaining a copy -/// of this software and associated documentation files (the "Software"), to deal -/// in the Software without restriction, including without limitation the rights -/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -/// copies of the Software, and to permit persons to whom the Software is -/// furnished to do so, subject to the following conditions: -/// -/// The above copyright notice and this permission notice shall be included in -/// all copies or substantial portions of the Software. -/// -/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -/// THE SOFTWARE. -/// -/// @ref core -/// @file gli/core/format.inl -/// @date 2012-10-16 / 2015-06-16 -/// @author Christophe Riccio -/////////////////////////////////////////////////////////////////////////////////// - namespace gli{ namespace detail { enum { CAP_COMPRESSED_BIT = (1 << 0), - CAP_PACKED_BIT = (1 << 1), + CAP_COLORSPACE_SRGB_BIT = (1 << 1), CAP_NORMALIZED_BIT = (1 << 2), CAP_SCALED_BIT = (1 << 3), CAP_UNSIGNED_BIT = (1 << 4), @@ -41,226 +13,364 @@ namespace detail CAP_FLOAT_BIT = (1 << 7), CAP_DEPTH_BIT = (1 << 8), CAP_STENCIL_BIT = (1 << 9), - CAP_COLORSPACE_SRGB_BIT = (1 << 10), - CAP_SWIZZLE_BIT = (1 << 11), - CAP_LUMINANCE_ALPHA_BIT = (1 << 12) + CAP_SWIZZLE_BIT = (1 << 10), + CAP_LUMINANCE_ALPHA_BIT = (1 << 11), + CAP_PACKED8_BIT = (1 << 12), + CAP_PACKED16_BIT = (1 << 13), + CAP_PACKED32_BIT = (1 << 14), + CAP_DDS_GLI_EXT_BIT = (1 << 15) }; struct formatInfo { std::uint8_t BlockSize; - glm::u8vec3 BlockDimensions; + glm::u8vec3 BlockExtent; std::uint8_t Component; + swizzles Swizzles; std::uint16_t Flags; }; inline formatInfo const & get_format_info(format Format) { + GLI_ASSERT(Format >= FORMAT_FIRST && Format <= FORMAT_LAST); + static formatInfo const Table[] = { - // unorm formats - { 1, glm::u8vec3(1, 1, 1), 1, CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_R8_UNORM, - { 2, glm::u8vec3(1, 1, 1), 2, CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RG8_UNORM, - { 3, glm::u8vec3(1, 1, 1), 3, CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGB8_UNORM, - { 4, glm::u8vec3(1, 1, 1), 4, CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA8_UNORM, + { 1, glm::u8vec3(1, 1, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_PACKED8_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_R4G4_UNORM, + { 2, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_PACKED16_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA4_UNORM, + { 2, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ALPHA), CAP_PACKED16_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_BGRA4_UNORM, + { 2, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_PACKED16_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_R5G6B5_UNORM, + { 2, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ONE), CAP_PACKED16_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_B5G6R5_UNORM, + { 2, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_PACKED16_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB5A1_UNORM, + { 2, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ALPHA), CAP_PACKED16_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_BGR5A1_UNORM, + { 2, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_ALPHA, SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE), CAP_PACKED16_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_A1RGB5_UNORM, - { 2, glm::u8vec3(1, 1, 1), 1, CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_R16_UNORM, - { 4, glm::u8vec3(1, 1, 1), 2, CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RG16_UNORM, - { 6, glm::u8vec3(1, 1, 1), 3, CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGB16_UNORM, - { 8, glm::u8vec3(1, 1, 1), 4, CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA16_UNORM, + { 1, glm::u8vec3(1, 1, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_R8_UNORM, + { 1, glm::u8vec3(1, 1, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_NORMALIZED_BIT | CAP_SIGNED_BIT}, //FORMAT_R8_SNORM, + { 1, glm::u8vec3(1, 1, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_SCALED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_R8_USCALED, + { 1, glm::u8vec3(1, 1, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_SCALED_BIT | CAP_SIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_R8_SSCALED, + { 1, glm::u8vec3(1, 1, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_INTEGER_BIT | CAP_UNSIGNED_BIT}, //FORMAT_R8_UINT, + { 1, glm::u8vec3(1, 1, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_INTEGER_BIT | CAP_SIGNED_BIT}, //FORMAT_R8_SINT, + { 1, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_R8_SRGB, - // snorm formats - { 1, glm::u8vec3(1, 1, 1), 1, CAP_NORMALIZED_BIT | CAP_SIGNED_BIT}, //FORMAT_R8_SNORM, - { 2, glm::u8vec3(1, 1, 1), 2, CAP_NORMALIZED_BIT | CAP_SIGNED_BIT}, //FORMAT_RG8_SNORM, - { 3, glm::u8vec3(1, 1, 1), 3, CAP_NORMALIZED_BIT | CAP_SIGNED_BIT}, //FORMAT_RGB8_SNORM, - { 4, glm::u8vec3(1, 1, 1), 4, CAP_NORMALIZED_BIT | CAP_SIGNED_BIT}, //FORMAT_RGBA8_SNORM, + { 2, glm::u8vec3(1, 1, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RG8_UNORM, + { 2, glm::u8vec3(1, 1, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_NORMALIZED_BIT | CAP_SIGNED_BIT}, //FORMAT_RG8_SNORM, + { 2, glm::u8vec3(1, 1, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_SCALED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RG8_USCALED, + { 2, glm::u8vec3(1, 1, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_SCALED_BIT | CAP_SIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RG8_SSCALED, + { 2, glm::u8vec3(1, 1, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_INTEGER_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RG8_UINT, + { 2, glm::u8vec3(1, 1, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_INTEGER_BIT | CAP_SIGNED_BIT}, //FORMAT_RG8_SINT, + { 2, glm::u8vec3(1, 1, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_NORMALIZED_BIT | CAP_SIGNED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RG8_SRGB, - { 2, glm::u8vec3(1, 1, 1), 1, CAP_NORMALIZED_BIT | CAP_SIGNED_BIT}, //FORMAT_R16_SNORM, - { 4, glm::u8vec3(1, 1, 1), 2, CAP_NORMALIZED_BIT | CAP_SIGNED_BIT}, //FORMAT_RG16_SNORM, - { 6, glm::u8vec3(1, 1, 1), 3, CAP_NORMALIZED_BIT | CAP_SIGNED_BIT}, //FORMAT_RGB16_SNORM, - { 8, glm::u8vec3(1, 1, 1), 4, CAP_NORMALIZED_BIT | CAP_SIGNED_BIT}, //FORMAT_RGBA16_SNORM, + { 3, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB8_UNORM, + { 3, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_NORMALIZED_BIT | CAP_SIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB8_SNORM, + { 3, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_SCALED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB8_USCALED, + { 3, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_SCALED_BIT | CAP_SIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB8_SSCALED, + { 3, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_INTEGER_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB8_UINT, + { 3, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_INTEGER_BIT | CAP_SIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB8_SINT, + { 3, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB8_SRGB, - // Unsigned integer formats - { 1, glm::u8vec3(1, 1, 1), 1, CAP_INTEGER_BIT | CAP_UNSIGNED_BIT}, //FORMAT_R8_UINT, - { 2, glm::u8vec3(1, 1, 1), 2, CAP_INTEGER_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RG8_UINT, - { 3, glm::u8vec3(1, 1, 1), 3, CAP_INTEGER_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGB8_UINT, - { 4, glm::u8vec3(1, 1, 1), 4, CAP_INTEGER_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA8_UINT, + { 3, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ONE), CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_SWIZZLE_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_BGR8_UNORM, + { 3, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ONE), CAP_NORMALIZED_BIT | CAP_SIGNED_BIT | CAP_SWIZZLE_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_BGR8_SNORM, + { 3, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ONE), CAP_SCALED_BIT | CAP_UNSIGNED_BIT | CAP_SWIZZLE_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_BGR8_USCALED, + { 3, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ONE), CAP_SCALED_BIT | CAP_SIGNED_BIT | CAP_SWIZZLE_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_BGR8_SSCALED, + { 3, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ONE), CAP_INTEGER_BIT | CAP_UNSIGNED_BIT | CAP_SWIZZLE_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_BGR8_UINT, + { 3, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ONE), CAP_INTEGER_BIT | CAP_SIGNED_BIT | CAP_SWIZZLE_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_BGR8_SINT, + { 3, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ONE), CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_SWIZZLE_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_BGR8_SRGB, - { 2, glm::u8vec3(1, 1, 1), 1, CAP_INTEGER_BIT | CAP_UNSIGNED_BIT}, //FORMAT_R16_UINT, - { 4, glm::u8vec3(1, 1, 1), 2, CAP_INTEGER_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RG16_UINT, - { 6, glm::u8vec3(1, 1, 1), 3, CAP_INTEGER_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGB16_UINT, - { 8, glm::u8vec3(1, 1, 1), 4, CAP_INTEGER_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA16_UINT, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA8_UNORM, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_NORMALIZED_BIT | CAP_SIGNED_BIT}, //FORMAT_RGBA8_SNORM, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_SCALED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA8_USCALED, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_SCALED_BIT | CAP_SIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA8_SSCALED, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_INTEGER_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA8_UINT, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_INTEGER_BIT | CAP_SIGNED_BIT}, //FORMAT_RGBA8_SINT, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_COLORSPACE_SRGB_BIT}, //FORMAT_RGBA8_SRGB, - { 4, glm::u8vec3(1, 1, 1), 1, CAP_INTEGER_BIT | CAP_UNSIGNED_BIT}, //FORMAT_R32_UINT, - { 8, glm::u8vec3(1, 1, 1), 2, CAP_INTEGER_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RG32_UINT, - { 12, glm::u8vec3(1, 1, 1), 3, CAP_INTEGER_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGB32_UINT, - { 16, glm::u8vec3(1, 1, 1), 4, CAP_INTEGER_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA32_UINT, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ALPHA), CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_SWIZZLE_BIT}, //FORMAT_BGRA8_UNORM, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ALPHA), CAP_NORMALIZED_BIT | CAP_SIGNED_BIT | CAP_SWIZZLE_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_BGRA8_SNORM, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ALPHA), CAP_SCALED_BIT | CAP_UNSIGNED_BIT | CAP_SWIZZLE_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_BGRA8_USCALED, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ALPHA), CAP_SCALED_BIT | CAP_SIGNED_BIT | CAP_SWIZZLE_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_BGRA8_SSCALED, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ALPHA), CAP_INTEGER_BIT | CAP_UNSIGNED_BIT | CAP_SWIZZLE_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_BGRA8_UINT, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ALPHA), CAP_INTEGER_BIT | CAP_SIGNED_BIT | CAP_SWIZZLE_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_BGRA8_SINT, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ALPHA), CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_SWIZZLE_BIT}, //FORMAT_BGRA8_SRGB, - /// Signed integer formats - { 1, glm::u8vec3(1, 1, 1), 1, CAP_INTEGER_BIT | CAP_SIGNED_BIT}, //FORMAT_R8_SINT, - { 2, glm::u8vec3(1, 1, 1), 2, CAP_INTEGER_BIT | CAP_SIGNED_BIT}, //FORMAT_RG8_SINT, - { 3, glm::u8vec3(1, 1, 1), 3, CAP_INTEGER_BIT | CAP_SIGNED_BIT}, //FORMAT_RGB8_SINT, - { 4, glm::u8vec3(1, 1, 1), 4, CAP_INTEGER_BIT | CAP_SIGNED_BIT}, //FORMAT_RGBA8_SINT, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ALPHA), CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_SWIZZLE_BIT | CAP_PACKED32_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA8_UNORM_PACK32, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ALPHA), CAP_NORMALIZED_BIT | CAP_SIGNED_BIT | CAP_SWIZZLE_BIT | CAP_PACKED32_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA8_SNORM_PACK32, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ALPHA), CAP_SCALED_BIT | CAP_UNSIGNED_BIT | CAP_SWIZZLE_BIT | CAP_PACKED32_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA8_USCALED_PACK32, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ALPHA), CAP_SCALED_BIT | CAP_SIGNED_BIT | CAP_SWIZZLE_BIT | CAP_PACKED32_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA8_SSCALED_PACK32, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ALPHA), CAP_INTEGER_BIT | CAP_UNSIGNED_BIT | CAP_SWIZZLE_BIT | CAP_PACKED32_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA8_UINT_PACK32, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ALPHA), CAP_INTEGER_BIT | CAP_SIGNED_BIT | CAP_SWIZZLE_BIT | CAP_PACKED32_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA8_SINT_PACK32, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ALPHA), CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_SWIZZLE_BIT | CAP_PACKED32_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA8_SRGB_PACK32, - { 2, glm::u8vec3(1, 1, 1), 1, CAP_INTEGER_BIT | CAP_SIGNED_BIT}, //FORMAT_R16_SINT, - { 4, glm::u8vec3(1, 1, 1), 2, CAP_INTEGER_BIT | CAP_SIGNED_BIT}, //FORMAT_RG16_SINT, - { 6, glm::u8vec3(1, 1, 1), 3, CAP_INTEGER_BIT | CAP_SIGNED_BIT}, //FORMAT_RGB16_SINT, - { 8, glm::u8vec3(1, 1, 1), 4, CAP_INTEGER_BIT | CAP_SIGNED_BIT}, //FORMAT_RGBA16_SINT, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_PACKED32_BIT}, //FORMAT_RGB10A2_UNORM, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_NORMALIZED_BIT | CAP_SIGNED_BIT | CAP_PACKED32_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB10A2_SNORM, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_SCALED_BIT | CAP_UNSIGNED_BIT | CAP_PACKED32_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB10A2_USCALE, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_SCALED_BIT | CAP_SIGNED_BIT | CAP_PACKED32_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB10A2_SSCALE, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_INTEGER_BIT | CAP_UNSIGNED_BIT | CAP_PACKED32_BIT}, //FORMAT_RGB10A2_UINT, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_INTEGER_BIT | CAP_SIGNED_BIT | CAP_PACKED32_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB10A2_SINT, - { 4, glm::u8vec3(1, 1, 1), 1, CAP_INTEGER_BIT | CAP_SIGNED_BIT}, //FORMAT_R32_SINT, - { 8, glm::u8vec3(1, 1, 1), 2, CAP_INTEGER_BIT | CAP_SIGNED_BIT}, //FORMAT_RG32_SINT, - { 12, glm::u8vec3(1, 1, 1), 3, CAP_INTEGER_BIT | CAP_SIGNED_BIT}, //FORMAT_RGB32_SINT, - { 16, glm::u8vec3(1, 1, 1), 4, CAP_INTEGER_BIT | CAP_SIGNED_BIT}, //FORMAT_RGBA32_SINT, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ALPHA), CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_PACKED32_BIT | CAP_SWIZZLE_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_BGR10A2_UNORM, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ALPHA), CAP_NORMALIZED_BIT | CAP_SIGNED_BIT | CAP_PACKED32_BIT | CAP_SWIZZLE_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_BGR10A2_SNORM, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ALPHA), CAP_SCALED_BIT | CAP_UNSIGNED_BIT | CAP_PACKED32_BIT | CAP_SWIZZLE_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_BGR10A2_USCALE, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ALPHA), CAP_SCALED_BIT | CAP_SIGNED_BIT | CAP_PACKED32_BIT | CAP_SWIZZLE_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_BGR10A2_SSCALE, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ALPHA), CAP_INTEGER_BIT | CAP_UNSIGNED_BIT | CAP_PACKED32_BIT | CAP_SWIZZLE_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_BGR10A2_UINT, + { 4, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ALPHA), CAP_INTEGER_BIT | CAP_SIGNED_BIT | CAP_PACKED32_BIT | CAP_SWIZZLE_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_BGR10A2_SINT, - /// Floating formats - { 2, glm::u8vec3(1, 1, 1), 1, CAP_FLOAT_BIT | CAP_SIGNED_BIT}, //FORMAT_R16_SFLOAT, - { 4, glm::u8vec3(1, 1, 1), 2, CAP_FLOAT_BIT | CAP_SIGNED_BIT}, //FORMAT_RG16_SFLOAT, - { 6, glm::u8vec3(1, 1, 1), 3, CAP_FLOAT_BIT | CAP_SIGNED_BIT}, //FORMAT_RGB16_SFLOAT, - { 8, glm::u8vec3(1, 1, 1), 4, CAP_FLOAT_BIT | CAP_SIGNED_BIT}, //FORMAT_RGBA16_SFLOAT, + { 2, glm::u8vec3(1, 1, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_R16_UNORM_PACK16, + { 2, glm::u8vec3(1, 1, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_NORMALIZED_BIT | CAP_SIGNED_BIT}, //FORMAT_R16_SNORM_PACK16, + { 2, glm::u8vec3(1, 1, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_SCALED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_R16_USCALE, + { 2, glm::u8vec3(1, 1, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_SCALED_BIT | CAP_SIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_R16_SSCALE, + { 2, glm::u8vec3(1, 1, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_INTEGER_BIT | CAP_UNSIGNED_BIT}, //FORMAT_R16_UINT_PACK16, + { 2, glm::u8vec3(1, 1, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_INTEGER_BIT | CAP_SIGNED_BIT}, //FORMAT_R16_SINT_PACK16, + { 2, glm::u8vec3(1, 1, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_FLOAT_BIT | CAP_SIGNED_BIT}, //FORMAT_R16_SFLOAT_PACK16, - { 4, glm::u8vec3(1, 1, 1), 1, CAP_FLOAT_BIT | CAP_SIGNED_BIT}, //FORMAT_R32_SFLOAT, - { 8, glm::u8vec3(1, 1, 1), 2, CAP_FLOAT_BIT | CAP_SIGNED_BIT}, //FORMAT_RG32_SFLOAT, - { 12, glm::u8vec3(1, 1, 1), 3, CAP_FLOAT_BIT | CAP_SIGNED_BIT}, //FORMAT_RGB32_SFLOAT, - { 16, glm::u8vec3(1, 1, 1), 4, CAP_FLOAT_BIT | CAP_SIGNED_BIT}, //FORMAT_RGBA32_SFLOAT, + { 4, glm::u8vec3(1, 1, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RG16_UNORM_PACK16, + { 4, glm::u8vec3(1, 1, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_NORMALIZED_BIT | CAP_SIGNED_BIT}, //FORMAT_RG16_SNORM_PACK16, + { 4, glm::u8vec3(1, 1, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_SCALED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RG16_USCALE, + { 4, glm::u8vec3(1, 1, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_SCALED_BIT | CAP_SIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RG16_SSCALE, + { 4, glm::u8vec3(1, 1, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_INTEGER_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RG16_UINT_PACK16, + { 4, glm::u8vec3(1, 1, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_INTEGER_BIT | CAP_SIGNED_BIT}, //FORMAT_RG16_SINT_PACK16, + { 4, glm::u8vec3(1, 1, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_FLOAT_BIT | CAP_SIGNED_BIT}, //FORMAT_RG16_SFLOAT_PACK16, - /// sRGB formats - { 3, glm::u8vec3(1, 1, 1), 3, CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_COLORSPACE_SRGB_BIT}, //FORMAT_R8_SRGB, - { 3, glm::u8vec3(1, 1, 1), 3, CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_COLORSPACE_SRGB_BIT}, //FORMAT_RG8_SRGB, - { 3, glm::u8vec3(1, 1, 1), 3, CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_COLORSPACE_SRGB_BIT}, //FORMAT_RGB8_SRGB, - { 4, glm::u8vec3(1, 1, 1), 4, CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_COLORSPACE_SRGB_BIT}, //FORMAT_RGBA8_SRGB, + { 6, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB16_UNORM_PACK16, + { 6, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_NORMALIZED_BIT | CAP_SIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB16_SNORM_PACK16, + { 6, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_SCALED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB16_USCALE, + { 6, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_SCALED_BIT | CAP_SIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB16_SSCALE, + { 6, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_INTEGER_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB16_UINT_PACK16, + { 6, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_INTEGER_BIT | CAP_SIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB16_SINT_PACK16, + { 6, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_FLOAT_BIT | CAP_SIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB16_SFLOAT_PACK16, - /// Packed formats - { 4, glm::u8vec3(1, 1, 1), 4, CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_PACKED_BIT}, //FORMAT_RGB10A2_UNORM, - { 4, glm::u8vec3(1, 1, 1), 4, CAP_INTEGER_BIT | CAP_UNSIGNED_BIT | CAP_PACKED_BIT}, //FORMAT_RGB10A2_UINT, - { 4, glm::u8vec3(1, 1, 1), 3, CAP_PACKED_BIT | CAP_FLOAT_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGB9E5_UFLOAT, - { 4, glm::u8vec3(1, 1, 1), 3, CAP_PACKED_BIT | CAP_FLOAT_BIT | CAP_SIGNED_BIT}, //FORMAT_RG11B10_UFLOAT, - { 1, glm::u8vec3(1, 1, 1), 3, CAP_PACKED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RG3B2_UNORM, - { 2, glm::u8vec3(1, 1, 1), 3, CAP_PACKED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_R5G6B5_UNORM, - { 2, glm::u8vec3(1, 1, 1), 4, CAP_PACKED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGB5A1_UNORM, - { 2, glm::u8vec3(1, 1, 1), 4, CAP_PACKED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA4_UNORM, + { 8, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA16_UNORM_PACK16, + { 8, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_NORMALIZED_BIT | CAP_SIGNED_BIT}, //FORMAT_RGBA16_SNORM_PACK16, + { 8, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_SCALED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA16_USCALE, + { 8, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_SCALED_BIT | CAP_SIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA16_SSCALE, + { 8, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_INTEGER_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA16_UINT_PACK16, + { 8, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_INTEGER_BIT | CAP_SIGNED_BIT}, //FORMAT_RGBA16_SINT_PACK16, + { 8, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_FLOAT_BIT | CAP_SIGNED_BIT}, //FORMAT_RGBA16_SFLOAT_PACK16, - // Swizzle formats - { 4, glm::u8vec3(1, 1, 1), 3, CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_SWIZZLE_BIT}, //FORMAT_BGRX8_UNORM, - { 4, glm::u8vec3(1, 1, 1), 4, CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_SWIZZLE_BIT}, //FORMAT_BGRA8_UNORM, - { 4, glm::u8vec3(1, 1, 1), 3, CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_SWIZZLE_BIT | CAP_COLORSPACE_SRGB_BIT}, //FORMAT_BGRX8_SRGB, - { 4, glm::u8vec3(1, 1, 1), 4, CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_SWIZZLE_BIT | CAP_COLORSPACE_SRGB_BIT}, //FORMAT_BGRA8_SRGB, + { 4, glm::u8vec3(1, 1, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_INTEGER_BIT | CAP_UNSIGNED_BIT}, //FORMAT_R32_UINT_PACK32, + { 4, glm::u8vec3(1, 1, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_INTEGER_BIT | CAP_SIGNED_BIT}, //FORMAT_R32_SINT_PACK32, + { 4, glm::u8vec3(1, 1, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_FLOAT_BIT | CAP_SIGNED_BIT}, //FORMAT_R32_SFLOAT_PACK32, - // Luminance Alpha formats - { 1, glm::u8vec3(1, 1, 1), 1, CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_LUMINANCE_ALPHA_BIT}, //FORMAT_L8_UNORM, - { 1, glm::u8vec3(1, 1, 1), 1, CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_LUMINANCE_ALPHA_BIT}, //FORMAT_A8_UNORM, - { 2, glm::u8vec3(1, 1, 1), 2, CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_LUMINANCE_ALPHA_BIT}, //FORMAT_LA8_UNORM, - { 2, glm::u8vec3(1, 1, 1), 1, CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_LUMINANCE_ALPHA_BIT}, //FORMAT_L16_UNORM, - { 2, glm::u8vec3(1, 1, 1), 1, CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_LUMINANCE_ALPHA_BIT}, //FORMAT_A16_UNORM, - { 4, glm::u8vec3(1, 1, 1), 2, CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_LUMINANCE_ALPHA_BIT}, //FORMAT_LA16_UNORM, + { 8, glm::u8vec3(1, 1, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_INTEGER_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RG32_UINT_PACK32, + { 8, glm::u8vec3(1, 1, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_INTEGER_BIT | CAP_SIGNED_BIT}, //FORMAT_RG32_SINT_PACK32, + { 8, glm::u8vec3(1, 1, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_FLOAT_BIT | CAP_SIGNED_BIT}, //FORMAT_RG32_SFLOAT_PACK32, - /// Depth formats - { 2, glm::u8vec3(1, 1, 1), 1, CAP_DEPTH_BIT | CAP_INTEGER_BIT}, //FORMAT_D16_UNORM, - { 4, glm::u8vec3(1, 1, 1), 1, CAP_DEPTH_BIT | CAP_INTEGER_BIT}, //FORMAT_D24_UNORM, - { 4, glm::u8vec3(1, 1, 1), 2, CAP_DEPTH_BIT | CAP_STENCIL_BIT}, //FORMAT_D24S8_UNORM, - { 4, glm::u8vec3(1, 1, 1), 1, CAP_DEPTH_BIT | CAP_FLOAT_BIT}, //FORMAT_D32_UFLOAT, - { 8, glm::u8vec3(1, 1, 1), 2, CAP_DEPTH_BIT | CAP_STENCIL_BIT | CAP_FLOAT_BIT}, //FORMAT_D32_UFLOAT_S8_UNORM, + { 12, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_INTEGER_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGB32_UINT_PACK32, + { 12, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_INTEGER_BIT | CAP_SIGNED_BIT}, //FORMAT_RGB32_SINT_PACK32, + { 12, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_FLOAT_BIT | CAP_SIGNED_BIT}, //FORMAT_RGB32_SFLOAT_PACK32, - /// Compressed formats - { 8, glm::u8vec3(4, 4, 1), 3, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGB_DXT1_UNORM, - { 8, glm::u8vec3(4, 4, 1), 4, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_DXT1_UNORM, - { 16, glm::u8vec3(4, 4, 1), 4, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_DXT3_UNORM, - { 16, glm::u8vec3(4, 4, 1), 4, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_DXT5_UNORM, - { 8, glm::u8vec3(4, 4, 1), 1, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_R_ATI1N_UNORM, - { 8, glm::u8vec3(4, 4, 1), 1, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_SIGNED_BIT}, //FORMAT_R_ATI1N_SNORM, - { 16, glm::u8vec3(4, 4, 1), 2, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RG_ATI2N_UNORM, - { 16, glm::u8vec3(4, 4, 1), 2, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_SIGNED_BIT}, //FORMAT_RG_ATI2N_SNORM, - { 16, glm::u8vec3(4, 4, 1), 3, CAP_COMPRESSED_BIT | CAP_FLOAT_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGB_BP_UFLOAT, - { 16, glm::u8vec3(4, 4, 1), 3, CAP_COMPRESSED_BIT | CAP_FLOAT_BIT | CAP_SIGNED_BIT}, //FORMAT_RGB_BP_SFLOAT, - { 16, glm::u8vec3(4, 4, 1), 3, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGB_BP_UNORM, - { 32, glm::u8vec3(8, 8, 1), 3, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGB_PVRTC1_8X8_UNORM, - { 32, glm::u8vec3(16, 8, 1), 3, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGB_PVRTC1_16X8_UNORM, - { 32, glm::u8vec3(8, 8, 1), 4, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_PVRTC1_8X8_UNORM, - { 32, glm::u8vec3(16, 8, 1), 4, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_PVRTC1_16X8_UNORM, - { 32, glm::u8vec3(8, 8, 1), 4, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_PVRTC2_8X8_UNORM, - { 32, glm::u8vec3(16, 8, 1), 4, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_PVRTC2_16X8_UNORM, - { 8, glm::u8vec3(4, 4, 1), 3, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGB_ATC_UNORM, - { 16, glm::u8vec3(4, 4, 1), 4, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ATC_EXPLICIT_UNORM, - { 16, glm::u8vec3(4, 4, 1), 4, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ATC_INTERPOLATED_UNORM, - { 8, glm::u8vec3(4, 4, 1), 3, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGB_ETC_UNORM, - { 8, glm::u8vec3(4, 4, 1), 3, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGB_ETC2_UNORM, - { 8, glm::u8vec3(4, 4, 1), 4, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ETC2_PUNCHTHROUGH_UNORM, - { 16, glm::u8vec3(4, 4, 1), 4, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ETC2_UNORM, - { 8, glm::u8vec3(4, 4, 1), 1, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_R11_EAC_UNORM, - { 8, glm::u8vec3(4, 4, 1), 1, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_SIGNED_BIT}, //FORMAT_R11_EAC_SNORM, - { 16, glm::u8vec3(4, 4, 1), 2, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RG11_EAC_UNORM, - { 16, glm::u8vec3(4, 4, 1), 2, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_SIGNED_BIT}, //FORMAT_RG11_EAC_SNORM, - { 16, glm::u8vec3(4, 4, 1), 4, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_4X4_UNORM, - { 16, glm::u8vec3(5, 4, 1), 4, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_5X4_UNORM, - { 16, glm::u8vec3(5, 5, 1), 4, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_5X5_UNORM, - { 16, glm::u8vec3(6, 5, 1), 4, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_6X5_UNORM, - { 16, glm::u8vec3(6, 6, 1), 4, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_6X6_UNORM, - { 16, glm::u8vec3(8, 5, 1), 4, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_8X5_UNORM, - { 16, glm::u8vec3(8, 6, 1), 4, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_8X6_UNORM, - { 16, glm::u8vec3(8, 8, 1), 4, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_8X8_UNORM, - { 16, glm::u8vec3(10, 5, 1), 4, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_10X5_UNORM, - { 16, glm::u8vec3(10, 6, 1), 4, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_10X6_UNORM, - { 16, glm::u8vec3(10, 8, 1), 4, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_10X8_UNORM, - { 16, glm::u8vec3(10, 10, 1), 4, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_10X10_UNORM, - { 16, glm::u8vec3(12, 10, 1), 4, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_12X10_UNORM, - { 16, glm::u8vec3(12, 12, 1), 4, CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_12X12_UNORM, + { 16, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_INTEGER_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA32_UINT_PACK32, + { 16, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_INTEGER_BIT | CAP_SIGNED_BIT}, //FORMAT_RGBA32_SINT_PACK32, + { 16, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_FLOAT_BIT | CAP_SIGNED_BIT}, //FORMAT_RGBA32_SFLOAT_PACK32, - // Compressed sRGB formats - { 8, glm::u8vec3(4, 4, 1), 3, CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGB_DXT1_SRGB, - { 8, glm::u8vec3(4, 4, 1), 4, CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_DXT1_SRGB, - { 16, glm::u8vec3(4, 4, 1), 4, CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_DXT3_SRGB, - { 16, glm::u8vec3(4, 4, 1), 4, CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_DXT5_SRGB, - { 16, glm::u8vec3(4, 4, 1), 3, CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGB_BP_SRGB, - { 32, glm::u8vec3(8, 8, 1), 3, CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGB_PVRTC1_8X8_SRGB, - { 32, glm::u8vec3(16, 8, 1), 3, CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGB_PVRTC1_16X8_SRGB, - { 32, glm::u8vec3(8, 8, 1), 4, CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_PVRTC1_8X8_SRGB, - { 32, glm::u8vec3(16, 8, 1), 4, CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_PVRTC1_16X8_SRGB, - { 32, glm::u8vec3(8, 8, 1), 4, CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_PVRTC2_8X8_SRGB, - { 32, glm::u8vec3(16, 8, 1), 4, CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_PVRTC2_16X8_SRGB, - { 8, glm::u8vec3(4, 4, 1), 3, CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGB_ETC2_SRGB, - { 8, glm::u8vec3(4, 4, 1), 4, CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ETC2_PUNCHTHROUGH_SRGB, - { 16, glm::u8vec3(4, 4, 1), 4, CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ETC2_SRGB, - { 16, glm::u8vec3(4, 4, 1), 4, CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC4X4_SRGB, - { 16, glm::u8vec3(5, 4, 1), 4, CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC5X4_SRGB, - { 16, glm::u8vec3(5, 5, 1), 4, CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC5X5_SRGB, - { 16, glm::u8vec3(6, 5, 1), 4, CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC6X5_SRGB, - { 16, glm::u8vec3(6, 6, 1), 4, CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC6X6_SRGB, - { 16, glm::u8vec3(8, 5, 1), 4, CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC8X5_SRGB, - { 16, glm::u8vec3(8, 6, 1), 4, CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC8X6_SRGB, - { 16, glm::u8vec3(8, 8, 1), 4, CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC8X8_SRGB, - { 16, glm::u8vec3(10, 5, 1), 4, CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC10X5_SRGB, - { 16, glm::u8vec3(10, 6, 1), 4, CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC10X6_SRGB, - { 16, glm::u8vec3(10, 8, 1), 4, CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC10X8_SRGB, - { 16, glm::u8vec3(10, 10, 1), 4, CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC10X10_SRGB, - { 16, glm::u8vec3(12, 10, 1), 4, CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC12X10_SRGB, - { 16, glm::u8vec3(12, 12, 1), 4, CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC12X12_SRGB, + { 8, glm::u8vec3(1, 1, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_INTEGER_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_R64_UINT_PACK64, + { 8, glm::u8vec3(1, 1, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_INTEGER_BIT | CAP_SIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_R64_SINT_PACK64, + { 8, glm::u8vec3(1, 1, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_FLOAT_BIT | CAP_SIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_R64_SFLOAT_PACK64, + + { 16, glm::u8vec3(1, 1, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_INTEGER_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RG64_UINT_PACK64, + { 16, glm::u8vec3(1, 1, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_INTEGER_BIT | CAP_SIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RG64_SINT_PACK64, + { 16, glm::u8vec3(1, 1, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_FLOAT_BIT | CAP_SIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RG64_SFLOAT_PACK64, + + { 24, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_INTEGER_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB64_UINT_PACK64, + { 24, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_INTEGER_BIT | CAP_SIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB64_SINT_PACK64, + { 24, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_FLOAT_BIT | CAP_SIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB64_SFLOAT_PACK64, + + { 32, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_INTEGER_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA64_UINT_PACK64, + { 32, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_INTEGER_BIT | CAP_SIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA64_SINT_PACK64, + { 32, glm::u8vec3(1, 1, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_FLOAT_BIT | CAP_SIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA64_SFLOAT_PACK64, + + { 4, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_PACKED32_BIT | CAP_FLOAT_BIT | CAP_SIGNED_BIT}, //FORMAT_RG11B10_UFLOAT_PACK32, + { 4, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_PACKED32_BIT | CAP_FLOAT_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGB9E5_UFLOAT_PACK32, + + { 2, glm::u8vec3(1, 1, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_DEPTH_BIT | CAP_INTEGER_BIT}, //FORMAT_D16_UNORM_PACK16, + { 4, glm::u8vec3(1, 1, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_DEPTH_BIT | CAP_INTEGER_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_D24_UNORM_PACK32, + { 4, glm::u8vec3(1, 1, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_DEPTH_BIT | CAP_FLOAT_BIT}, //FORMAT_D32_UFLOAT_PACK32, + { 1, glm::u8vec3(1, 1, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_DEPTH_BIT | CAP_STENCIL_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_S8_UNORM_PACK8, + { 3, glm::u8vec3(1, 1, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_DEPTH_BIT | CAP_INTEGER_BIT | CAP_STENCIL_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_D16_UNORM_S8_UINT_PACK32, + { 4, glm::u8vec3(1, 1, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_DEPTH_BIT | CAP_INTEGER_BIT | CAP_STENCIL_BIT}, //FORMAT_D24_UNORM_S8_UINT_PACK32, + { 5, glm::u8vec3(1, 1, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_DEPTH_BIT | CAP_FLOAT_BIT | CAP_STENCIL_BIT}, //FORMAT_D32_SFLOAT_S8_UINT_PACK64, + + { 8, glm::u8vec3(4, 4, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB_DXT1_UNORM_BLOCK8, + { 8, glm::u8vec3(4, 4, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB_DXT1_SRGB_BLOCK8, + { 8, glm::u8vec3(4, 4, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_DXT1_UNORM_BLOCK8, + { 8, glm::u8vec3(4, 4, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_DXT1_SRGB_BLOCK8, + { 16, glm::u8vec3(4, 4, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_DXT3_UNORM_BLOCK16, + { 16, glm::u8vec3(4, 4, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_DXT3_SRGB_BLOCK16, + { 16, glm::u8vec3(4, 4, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_DXT5_UNORM_BLOCK16, + { 16, glm::u8vec3(4, 4, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_DXT5_SRGB_BLOCK16, + { 8, glm::u8vec3(4, 4, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_R_ATI1N_UNORM_BLOCK8, + { 8, glm::u8vec3(4, 4, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_SIGNED_BIT}, //FORMAT_R_ATI1N_SNORM_BLOCK8, + { 16, glm::u8vec3(4, 4, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RG_ATI2N_UNORM_BLOCK16, + { 16, glm::u8vec3(4, 4, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_SIGNED_BIT}, //FORMAT_RG_ATI2N_SNORM_BLOCK16, + { 16, glm::u8vec3(4, 4, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_COMPRESSED_BIT | CAP_FLOAT_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGB_BP_UFLOAT_BLOCK16, + { 16, glm::u8vec3(4, 4, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_COMPRESSED_BIT | CAP_FLOAT_BIT | CAP_SIGNED_BIT}, //FORMAT_RGB_BP_SFLOAT_BLOCK16, + { 16, glm::u8vec3(4, 4, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_BP_UNORM_BLOCK16, + { 16, glm::u8vec3(4, 4, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_BP_SRGB_BLOCK16, + + { 8, glm::u8vec3(4, 4, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB_ETC2_UNORM_BLOCK8, + { 8, glm::u8vec3(4, 4, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB_ETC2_SRGB_BLOCK8, + { 8, glm::u8vec3(4, 4, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA_ETC2_UNORM_BLOCK8, + { 8, glm::u8vec3(4, 4, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA_ETC2_SRGB_BLOCK8, + { 16, glm::u8vec3(4, 4, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA_ETC2_UNORM_BLOCK16, + { 16, glm::u8vec3(4, 4, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA_ETC2_SRGB_BLOCK16, + { 8, glm::u8vec3(4, 4, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_R_EAC_UNORM_BLOCK8, + { 8, glm::u8vec3(4, 4, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_SIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_R_EAC_SNORM_BLOCK8, + { 16, glm::u8vec3(4, 4, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RG_EAC_UNORM_BLOCK16, + { 16, glm::u8vec3(4, 4, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_SIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RG_EAC_SNORM_BLOCK16, + + { 16, glm::u8vec3(4, 4, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_4X4_UNORM_BLOCK16, + { 16, glm::u8vec3(4, 4, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_4X4_SRGB_BLOCK16, + { 16, glm::u8vec3(5, 4, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_5X4_UNORM_BLOCK16, + { 16, glm::u8vec3(5, 4, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_5X4_SRGB_BLOCK16, + { 16, glm::u8vec3(5, 5, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_5X5_UNORM_BLOCK16, + { 16, glm::u8vec3(5, 5, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_5X5_SRGB_BLOCK16, + { 16, glm::u8vec3(6, 5, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_6X5_UNORM_BLOCK16, + { 16, glm::u8vec3(6, 5, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_6X5_SRGB_BLOCK16, + { 16, glm::u8vec3(6, 6, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_6X6_UNORM_BLOCK16, + { 16, glm::u8vec3(6, 6, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_6X6_SRGB_BLOCK16, + { 16, glm::u8vec3(8, 5, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_8X5_UNORM_BLOCK16, + { 16, glm::u8vec3(8, 5, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_8X5_SRGB_BLOCK16, + { 16, glm::u8vec3(8, 6, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_8X6_UNORM_BLOCK16, + { 16, glm::u8vec3(8, 6, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_8X6_SRGB_BLOCK16, + { 16, glm::u8vec3(8, 8, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_8X8_UNORM_BLOCK16, + { 16, glm::u8vec3(8, 8, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_8X8_SRGB_BLOCK16, + { 16, glm::u8vec3(10, 5, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_10X5_UNORM_BLOCK16, + { 16, glm::u8vec3(10, 5, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_10X5_SRGB_BLOCK16, + { 16, glm::u8vec3(10, 6, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_10X6_UNORM_BLOCK16, + { 16, glm::u8vec3(10, 6, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_10X6_SRGB_BLOCK16, + { 16, glm::u8vec3(10, 8, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_10X8_UNORM_BLOCK16, + { 16, glm::u8vec3(10, 8, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_10X8_SRGB_BLOCK16, + { 16, glm::u8vec3(10, 10, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_10X10_UNORM_BLOCK16, + { 16, glm::u8vec3(10, 10, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_10X10_SRGB_BLOCK16, + { 16, glm::u8vec3(12, 10, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_12X10_UNORM_BLOCK16, + { 16, glm::u8vec3(12, 10, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_12X10_SRGB_BLOCK16, + { 16, glm::u8vec3(12, 12, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_12X12_UNORM_BLOCK16, + { 16, glm::u8vec3(12, 12, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT}, //FORMAT_RGBA_ASTC_12X12_SRGB_BLOCK16, + + { 32, glm::u8vec3(8, 8, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB_PVRTC1_8X8_UNORM_BLOCK32, + { 32, glm::u8vec3(8, 8, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB_PVRTC1_8X8_SRGB_BLOCK32, + { 32, glm::u8vec3(16, 8, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB_PVRTC1_16X8_UNORM_BLOCK32, + { 32, glm::u8vec3(16, 8, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB_PVRTC1_16X8_SRGB_BLOCK32, + { 32, glm::u8vec3(8, 8, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA_PVRTC1_8X8_UNORM_BLOCK32, + { 32, glm::u8vec3(8, 8, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA_PVRTC1_8X8_SRGB_BLOCK32, + { 32, glm::u8vec3(16, 8, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA_PVRTC1_16X8_UNORM_BLOCK32, + { 32, glm::u8vec3(16, 8, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA_PVRTC1_16X8_SRGB_BLOCK32, + { 8, glm::u8vec3(4, 4, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA_PVRTC2_4X4_UNORM_BLOCK8, + { 8, glm::u8vec3(4, 4, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA_PVRTC2_4X4_SRGB_BLOCK8, + { 8, glm::u8vec3(8, 4, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA_PVRTC2_8X4_UNORM_BLOCK8, + { 8, glm::u8vec3(8, 4, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_COLORSPACE_SRGB_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA_PVRTC2_8X4_SRGB_BLOCK8, + + { 8, glm::u8vec3(4, 4, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB_ETC_UNORM_BLOCK8, + { 8, glm::u8vec3(4, 4, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGB_ATC_UNORM_BLOCK8, + { 16, glm::u8vec3(4, 4, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA_ATCA_UNORM_BLOCK16, + { 16, glm::u8vec3(4, 4, 1), 4, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA), CAP_COMPRESSED_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RGBA_ATCI_UNORM_BLOCK16, + + { 1, glm::u8vec3(1, 1, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_RED, SWIZZLE_RED, SWIZZLE_ONE), CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_LUMINANCE_ALPHA_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_L8_UNORM_PACK8, + { 1, glm::u8vec3(1, 1, 1), 1, swizzles(SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_RED), CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_LUMINANCE_ALPHA_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_A8_UNORM_PACK8, + { 2, glm::u8vec3(1, 1, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_RED, SWIZZLE_RED, SWIZZLE_GREEN), CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_LUMINANCE_ALPHA_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_LA8_UNORM_PACK8, + { 2, glm::u8vec3(1, 1, 1), 1, swizzles(SWIZZLE_RED, SWIZZLE_RED, SWIZZLE_RED, SWIZZLE_ONE), CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_LUMINANCE_ALPHA_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_L16_UNORM_PACK16, + { 2, glm::u8vec3(1, 1, 1), 1, swizzles(SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_RED), CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_LUMINANCE_ALPHA_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_A16_UNORM_PACK16, + { 4, glm::u8vec3(1, 1, 1), 2, swizzles(SWIZZLE_RED, SWIZZLE_RED, SWIZZLE_RED, SWIZZLE_GREEN), CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_LUMINANCE_ALPHA_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_LA16_UNORM_PACK16, + + { 4, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ONE), CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_SWIZZLE_BIT}, //FORMAT_BGR8_UNORM_PACK32, + { 4, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_BLUE, SWIZZLE_GREEN, SWIZZLE_RED, SWIZZLE_ONE), CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_SWIZZLE_BIT | CAP_COLORSPACE_SRGB_BIT}, //FORMAT_BGR8_SRGB_PACK32, + + { 1, glm::u8vec3(1, 1, 1), 3, swizzles(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE), CAP_PACKED8_BIT | CAP_NORMALIZED_BIT | CAP_UNSIGNED_BIT | CAP_DDS_GLI_EXT_BIT}, //FORMAT_RG3B2_UNORM_PACK8, }; GLM_STATIC_ASSERT(sizeof(Table) / sizeof(Table[0]) == FORMAT_COUNT, "GLI error: format descriptor list doesn't match number of supported formats"); - assert(Format != static_cast(FORMAT_INVALID)); + GLI_ASSERT(Format != static_cast(FORMAT_INVALID)); - return Table[Format]; + return Table[Format - FORMAT_FIRST]; }; inline std::uint32_t bits_per_pixel(format Format) { detail::formatInfo const & Info = detail::get_format_info(Format); - return Info.BlockSize * 8 / (Info.BlockDimensions.x * Info.BlockDimensions.y * Info.BlockDimensions.z); + return Info.BlockSize * 8 / (Info.BlockExtent.x * Info.BlockExtent.y * Info.BlockExtent.z); } }//namespace detail - inline std::uint32_t block_size(format Format) + inline bool is_compressed(format Format) + { + return detail::get_format_info(Format).Flags & detail::CAP_COMPRESSED_BIT ? true : false; + } + + inline bool is_s3tc_compressed(format Format) + { + return Format >= FORMAT_RGB_DXT1_UNORM_BLOCK8 && Format <= FORMAT_RGBA_DXT5_SRGB_BLOCK16; + } + + inline bool is_srgb(format Format) + { + return detail::get_format_info(Format).Flags & detail::CAP_COLORSPACE_SRGB_BIT ? true : false; + } + + inline size_t block_size(format Format) { return detail::get_format_info(Format).BlockSize; } - inline gli::dim3_t block_dimensions(format Format) + inline ivec3 block_extent(format Format) { - return gli::dim3_t(detail::get_format_info(Format).BlockDimensions); + return gli::ivec3(detail::get_format_info(Format).BlockExtent); } - inline std::uint32_t component_count(format Format) + inline size_t component_count(format Format) { return detail::get_format_info(Format).Component; } + + inline bool is_unsigned(format Format) + { + return detail::get_format_info(Format).Flags & detail::CAP_UNSIGNED_BIT ? true : false; + } + + inline bool is_signed(format Format) + { + return detail::get_format_info(Format).Flags & detail::CAP_SIGNED_BIT ? true : false; + } + + inline bool is_integer(format Format) + { + return detail::get_format_info(Format).Flags & detail::CAP_INTEGER_BIT ? true : false; + } + + inline bool is_signed_integer(format Format) + { + return is_integer(Format) && is_signed(Format); + } + + inline bool is_unsigned_integer(format Format) + { + return is_integer(Format) && is_unsigned(Format); + } + + inline bool is_float(format Format) + { + return detail::get_format_info(Format).Flags & detail::CAP_FLOAT_BIT ? true : false; + } + + inline bool is_normalized(format Format) + { + return detail::get_format_info(Format).Flags & detail::CAP_NORMALIZED_BIT ? true : false; + } + + inline bool is_unorm(format Format) + { + return is_normalized(Format) && is_unsigned(Format); + } + + inline bool is_snorm(format Format) + { + return is_normalized(Format) && is_signed(Format); + } + + inline bool is_packed(format Format) + { + uint16_t flags = detail::get_format_info(Format).Flags; + + return (flags & detail::CAP_PACKED8_BIT) != 0 || (flags & detail::CAP_PACKED16_BIT) != 0 || (flags & detail::CAP_PACKED32_BIT) != 0; + } }//namespace gli diff --git a/external/gli/gli/core/generate_mipmaps.hpp b/external/gli/gli/core/generate_mipmaps.hpp deleted file mode 100644 index e83a75a7..00000000 --- a/external/gli/gli/core/generate_mipmaps.hpp +++ /dev/null @@ -1,40 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////////// -/// OpenGL Image (gli.g-truc.net) -/// -/// Copyright (c) 2008 - 2013 G-Truc Creation (www.g-truc.net) -/// Permission is hereby granted, free of charge, to any person obtaining a copy -/// of this software and associated documentation files (the "Software"), to deal -/// in the Software without restriction, including without limitation the rights -/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -/// copies of the Software, and to permit persons to whom the Software is -/// furnished to do so, subject to the following conditions: -/// -/// The above copyright notice and this permission notice shall be included in -/// all copies or substantial portions of the Software. -/// -/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -/// THE SOFTWARE. -/// -/// @ref core -/// @file gli/core/generate_mipmaps.hpp -/// @date 2010-09-27 / 2013-01-12 -/// @author Christophe Riccio -/////////////////////////////////////////////////////////////////////////////////// - -#pragma once - -#include "../texture2d.hpp" - -namespace gli -{ - template - texture generate_mipmaps(texture & Texture); - -}//namespace gli - -#include "generate_mipmaps.inl" diff --git a/external/gli/gli/core/generate_mipmaps.inl b/external/gli/gli/core/generate_mipmaps.inl index b47e32a1..e91dca22 100644 --- a/external/gli/gli/core/generate_mipmaps.inl +++ b/external/gli/gli/core/generate_mipmaps.inl @@ -1,78 +1,127 @@ -/////////////////////////////////////////////////////////////////////////////////// -/// OpenGL Image (gli.g-truc.net) -/// -/// Copyright (c) 2008 - 2013 G-Truc Creation (www.g-truc.net) -/// Permission is hereby granted, free of charge, to any person obtaining a copy -/// of this software and associated documentation files (the "Software"), to deal -/// in the Software without restriction, including without limitation the rights -/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -/// copies of the Software, and to permit persons to whom the Software is -/// furnished to do so, subject to the following conditions: -/// -/// The above copyright notice and this permission notice shall be included in -/// all copies or substantial portions of the Software. -/// -/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -/// THE SOFTWARE. -/// -/// @ref core -/// @file gli/core/generate_mipmaps.inl -/// @date 2010-09-27 / 2013-01-12 -/// @author Christophe Riccio -/////////////////////////////////////////////////////////////////////////////////// +#include "../sampler1d.hpp" +#include "../sampler1d_array.hpp" +#include "../sampler2d.hpp" +#include "../sampler2d_array.hpp" +#include "../sampler3d.hpp" +#include "../sampler_cube.hpp" +#include "../sampler_cube_array.hpp" -namespace gli{ -namespace detail +namespace gli { - -}//namespace detail - - template <> - inline texture2D generate_mipmaps(texture2D & Texture) + inline texture1d generate_mipmaps( + texture1d const& Texture, + texture1d::size_type BaseLevel, texture1d::size_type MaxLevel, + filter Minification) { - texture2D Result(Texture.format(), Texture.dimensions()); - texture2D::size_type const Components(gli::component_count(Result.format())); - - for(texture2D::size_type Level = Texture.base_level(); Level < Texture.max_level(); ++Level) - { - // Src - std::size_t BaseWidth = Result[Level].dimensions().x; - void * DataSrc = Result[Level + 0].data(); - - // Dst - texture2D::dim_type LevelDimensions = texture2D::dim_type(Result[Level].dimensions()) >> texture2D::dim_type(1); - LevelDimensions = glm::max(LevelDimensions, texture2D::dim_type(1)); - void * DataDst = Result[Level + 1].data(); - - for(std::size_t j = 0; j < LevelDimensions.y; ++j) - for(std::size_t i = 0; i < LevelDimensions.x; ++i) - for(std::size_t c = 0; c < Components; ++c) - { - std::size_t x = (i << 1); - std::size_t y = (j << 1); - - std::size_t Index00 = ((x + 0) + (y + 0) * BaseWidth) * Components + c; - std::size_t Index01 = ((x + 0) + (y + 1) * BaseWidth) * Components + c; - std::size_t Index11 = ((x + 1) + (y + 1) * BaseWidth) * Components + c; - std::size_t Index10 = ((x + 1) + (y + 0) * BaseWidth) * Components + c; - - glm::u32 Data00 = reinterpret_cast(DataSrc)[Index00]; - glm::u32 Data01 = reinterpret_cast(DataSrc)[Index01]; - glm::u32 Data11 = reinterpret_cast(DataSrc)[Index11]; - glm::u32 Data10 = reinterpret_cast(DataSrc)[Index10]; - - std::size_t IndexDst = (x + y * LevelDimensions.x) * Components + c; - - *(reinterpret_cast(DataDst) + IndexDst) = (Data00 + Data01 + Data11 + Data10) >> 2; - } - } - - return Result; + fsampler1D Sampler(Texture, WRAP_CLAMP_TO_EDGE); + Sampler.generate_mipmaps(BaseLevel, MaxLevel, Minification); + return Sampler(); } + inline texture1d_array generate_mipmaps( + texture1d_array const& Texture, + texture1d_array::size_type BaseLayer, texture1d_array::size_type MaxLayer, + texture1d_array::size_type BaseLevel, texture1d_array::size_type MaxLevel, + filter Minification) + { + fsampler1DArray Sampler(Texture, WRAP_CLAMP_TO_EDGE); + Sampler.generate_mipmaps(BaseLayer, MaxLayer, BaseLevel, MaxLevel, Minification); + return Sampler(); + } + + inline texture2d generate_mipmaps( + texture2d const& Texture, + texture2d::size_type BaseLevel, texture2d::size_type MaxLevel, + filter Minification) + { + fsampler2D Sampler(Texture, WRAP_CLAMP_TO_EDGE); + Sampler.generate_mipmaps(BaseLevel, MaxLevel, Minification); + return Sampler(); + } + + inline texture2d_array generate_mipmaps( + texture2d_array const& Texture, + texture2d_array::size_type BaseLayer, texture2d_array::size_type MaxLayer, + texture2d_array::size_type BaseLevel, texture2d_array::size_type MaxLevel, + filter Minification) + { + fsampler2DArray Sampler(Texture, WRAP_CLAMP_TO_EDGE); + Sampler.generate_mipmaps(BaseLayer, MaxLayer, BaseLevel, MaxLevel, Minification); + return Sampler(); + } + + inline texture3d generate_mipmaps( + texture3d const& Texture, + texture3d::size_type BaseLevel, texture3d::size_type MaxLevel, + filter Minification) + { + fsampler3D Sampler(Texture, WRAP_CLAMP_TO_EDGE); + Sampler.generate_mipmaps(BaseLevel, MaxLevel, Minification); + return Sampler(); + } + + inline texture_cube generate_mipmaps( + texture_cube const& Texture, + texture_cube::size_type BaseFace, texture_cube::size_type MaxFace, + texture_cube::size_type BaseLevel, texture_cube::size_type MaxLevel, + filter Minification) + { + fsamplerCube Sampler(Texture, WRAP_CLAMP_TO_EDGE); + Sampler.generate_mipmaps(BaseFace, MaxFace, BaseLevel, MaxLevel, Minification); + return Sampler(); + } + + inline texture_cube_array generate_mipmaps( + texture_cube_array const& Texture, + texture_cube_array::size_type BaseLayer, texture_cube_array::size_type MaxLayer, + texture_cube_array::size_type BaseFace, texture_cube_array::size_type MaxFace, + texture_cube_array::size_type BaseLevel, texture_cube_array::size_type MaxLevel, + filter Minification) + { + fsamplerCubeArray Sampler(Texture, WRAP_CLAMP_TO_EDGE); + Sampler.generate_mipmaps(BaseLayer, MaxLayer, BaseFace, MaxFace, BaseLevel, MaxLevel, Minification); + return Sampler(); + } + + template <> + inline texture1d generate_mipmaps(texture1d const& Texture, filter Minification) + { + return generate_mipmaps(Texture, Texture.base_level(), Texture.max_level(), Minification); + } + + template <> + inline texture1d_array generate_mipmaps(texture1d_array const& Texture, filter Minification) + { + return generate_mipmaps(Texture, Texture.base_layer(), Texture.max_layer(), Texture.base_level(), Texture.max_level(), Minification); + } + + template <> + inline texture2d generate_mipmaps(texture2d const& Texture, filter Minification) + { + return generate_mipmaps(Texture, Texture.base_level(), Texture.max_level(), Minification); + } + + template <> + inline texture2d_array generate_mipmaps(texture2d_array const& Texture, filter Minification) + { + return generate_mipmaps(Texture, Texture.base_layer(), Texture.max_layer(), Texture.base_level(), Texture.max_level(), Minification); + } + + template <> + inline texture3d generate_mipmaps(texture3d const& Texture, filter Minification) + { + return generate_mipmaps(Texture, Texture.base_level(), Texture.max_level(), Minification); + } + + template <> + inline texture_cube generate_mipmaps(texture_cube const& Texture, filter Minification) + { + return generate_mipmaps(Texture, Texture.base_face(), Texture.max_face(), Texture.base_level(), Texture.max_level(), Minification); + } + + template <> + inline texture_cube_array generate_mipmaps(texture_cube_array const& Texture, filter Minification) + { + return generate_mipmaps(Texture, Texture.base_layer(), Texture.max_layer(), Texture.base_face(), Texture.max_face(), Texture.base_level(), Texture.max_level(), Minification); + } }//namespace gli diff --git a/external/gli/gli/core/gl.inl b/external/gli/gli/core/gl.inl index 47898638..779ade57 100644 --- a/external/gli/gli/core/gl.inl +++ b/external/gli/gli/core/gl.inl @@ -1,222 +1,310 @@ -/////////////////////////////////////////////////////////////////////////////////// -/// OpenGL Image (gli.g-truc.net) -/// -/// Copyright (c) 2008 - 2015 G-Truc Creation (www.g-truc.net) -/// Permission is hereby granted, free of charge, to any person obtaining a copy -/// of this software and associated documentation files (the "Software"), to deal -/// in the Software without restriction, including without limitation the rights -/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -/// copies of the Software, and to permit persons to whom the Software is -/// furnished to do so, subject to the following conditions: -/// -/// The above copyright notice and this permission notice shall be included in -/// all copies or substantial portions of the Software. -/// -/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -/// THE SOFTWARE. -/// -/// @ref core -/// @file gli/core/gl.inl -/// @date 2013-11-09 / 2013-11-09 -/// @author Christophe Riccio -/////////////////////////////////////////////////////////////////////////////////// - #include -namespace gli +namespace gli{ +namespace detail { - inline gl::gl() + inline gl::swizzles translate(gli::swizzles const& Swizzles) { - static format const Table[] = + static gl::swizzle const Table[] = { - // unorm formats - {INTERNAL_R8_UNORM, EXTERNAL_RED, TYPE_U8, {SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE}}, //R8_UNORM, - {INTERNAL_RG8_UNORM, EXTERNAL_RG, TYPE_U8, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE}}, //RG8_UNORM, - {INTERNAL_RGB8_UNORM, EXTERNAL_RGB, TYPE_U8, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //RGB8_UNORM, - {INTERNAL_RGBA8_UNORM, EXTERNAL_RGBA, TYPE_U8, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA8_UNORM, + gl::SWIZZLE_RED, + gl::SWIZZLE_GREEN, + gl::SWIZZLE_BLUE, + gl::SWIZZLE_ALPHA, + gl::SWIZZLE_ZERO, + gl::SWIZZLE_ONE + }; + static_assert(sizeof(Table) / sizeof(Table[0]) == SWIZZLE_COUNT, "GLI error: swizzle descriptor list doesn't match number of supported swizzles"); - {INTERNAL_R16_UNORM, EXTERNAL_RED, TYPE_U16, {SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE}}, //R16_UNORM, - {INTERNAL_RG16_UNORM, EXTERNAL_RG, TYPE_U16, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE}}, //RG16_UNORM, - {INTERNAL_RGB16_UNORM, EXTERNAL_RGB, TYPE_U16, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //RGB16_UNORM, - {INTERNAL_RGBA16_UNORM, EXTERNAL_RGBA, TYPE_U16, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA16_UNORM, + return gl::swizzles(Table[Swizzles.r], Table[Swizzles.g], Table[Swizzles.b], Table[Swizzles.a]); + } - // snorm formats - {INTERNAL_R8_SNORM, EXTERNAL_RED, TYPE_I8, {SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE}}, //R8_SNORM, - {INTERNAL_RG8_SNORM, EXTERNAL_RG, TYPE_I8, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE}}, //RG8_SNORM, - {INTERNAL_RGB8_SNORM, EXTERNAL_RGB, TYPE_I8, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //RGB8_SNORM, - {INTERNAL_RGBA8_SNORM, EXTERNAL_RGBA, TYPE_I8, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA8_SNORM, + enum format_property + { + FORMAT_PROPERTY_BGRA_FORMAT_BIT = (1 << 0), + FORMAT_PROPERTY_BGRA_TYPE_BIT = (1 << 1) + }; +}//namespace detail - {INTERNAL_R16_SNORM, EXTERNAL_RED, TYPE_I16, {SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE}}, //R16_SNORM, - {INTERNAL_RG16_SNORM, EXTERNAL_RG, TYPE_I16, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE}}, //RG16_SNORM, - {INTERNAL_RGB16_SNORM, EXTERNAL_RGB, TYPE_I16, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //RGB16_SNORM, - {INTERNAL_RGBA16_SNORM, EXTERNAL_RGBA, TYPE_I16, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA16_SNORM, + inline gl::gl(profile Profile) + : Profile(Profile) + { + bool const HasSwizzle = has_swizzle(Profile); + external_format const ExternalBGR = HasSwizzle ? EXTERNAL_RGB : EXTERNAL_BGR; + external_format const ExternalBGRA = HasSwizzle ? EXTERNAL_RGBA : EXTERNAL_BGRA; + external_format const ExternalBGRInt = HasSwizzle ? EXTERNAL_RGB_INTEGER : EXTERNAL_BGR_INTEGER; + external_format const ExternalBGRAInt = HasSwizzle ? EXTERNAL_RGBA_INTEGER : EXTERNAL_BGRA_INTEGER; - // Unsigned integer formats - {INTERNAL_R8U, EXTERNAL_RED_INTEGER, TYPE_U8, {SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE}}, //R8U, - {INTERNAL_RG8U, EXTERNAL_RG_INTEGER, TYPE_U8, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE}}, //RG8U, - {INTERNAL_RGB8U, EXTERNAL_RGB_INTEGER, TYPE_U8, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //RGB8U, - {INTERNAL_RGBA8U, EXTERNAL_RGBA_INTEGER, TYPE_U8, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA8U, + external_format const ExternalSRGB8 = Profile != PROFILE_ES20 ? EXTERNAL_RGB : EXTERNAL_SRGB_EXT; + external_format const ExternalSRGB8_A8 = Profile != PROFILE_ES20 ? EXTERNAL_RGBA : EXTERNAL_SRGB_ALPHA_EXT; - {INTERNAL_R16U, EXTERNAL_RED_INTEGER, TYPE_U16, {SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE}}, //R16U, - {INTERNAL_RG16U, EXTERNAL_RG_INTEGER, TYPE_U16, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE}}, //RG16U, - {INTERNAL_RGB16U, EXTERNAL_RGB_INTEGER, TYPE_U16, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //RGB16U, - {INTERNAL_RGBA16U, EXTERNAL_RGBA_INTEGER, TYPE_U16, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA16U, + internal_format const InternalBGRA = Profile == PROFILE_ES20 ? INTERNAL_BGRA8_UNORM : INTERNAL_RGBA8_UNORM; + internal_format const InternalRGBETC = Profile == PROFILE_ES20 ? INTERNAL_RGB_ETC : INTERNAL_RGB_ETC2; - {INTERNAL_R32U, EXTERNAL_RED_INTEGER, TYPE_U32, {SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE}}, //R32U, - {INTERNAL_RG32U, EXTERNAL_RG_INTEGER, TYPE_U32, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE}}, //RG32U, - {INTERNAL_RGB32U, EXTERNAL_RGB_INTEGER, TYPE_U32, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //RGB32U, - {INTERNAL_RGBA32U, EXTERNAL_RGBA_INTEGER, TYPE_U32, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA32U, + internal_format const InternalLuminance8 = HasSwizzle ? INTERNAL_R8_UNORM : INTERNAL_LUMINANCE8; + internal_format const InternalAlpha8 = HasSwizzle ? INTERNAL_R8_UNORM : INTERNAL_ALPHA8; + internal_format const InternalLuminanceAlpha8 = HasSwizzle ? INTERNAL_RG8_UNORM : INTERNAL_LUMINANCE8_ALPHA8; - /// Signed integer formats - {INTERNAL_R8I, EXTERNAL_RED_INTEGER, TYPE_I8, {SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE}}, //R8I, - {INTERNAL_RG8I, EXTERNAL_RG_INTEGER, TYPE_I8, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE}}, //RG8I, - {INTERNAL_RGB8I, EXTERNAL_RGB_INTEGER, TYPE_I8, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //RGB8I, - {INTERNAL_RGBA8I, EXTERNAL_RGBA_INTEGER, TYPE_I8, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA8I, + internal_format const InternalLuminance16 = HasSwizzle ? INTERNAL_R16_UNORM : INTERNAL_LUMINANCE16; + internal_format const InternalAlpha16 = HasSwizzle ? INTERNAL_R16_UNORM : INTERNAL_ALPHA16; + internal_format const InternalLuminanceAlpha16 = HasSwizzle ? INTERNAL_RG16_UNORM : INTERNAL_LUMINANCE16_ALPHA16; - {INTERNAL_R16I, EXTERNAL_RED_INTEGER, TYPE_I16, {SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE}}, //R16I, - {INTERNAL_RG16I, EXTERNAL_RG_INTEGER, TYPE_I16, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE}}, //RG16I, - {INTERNAL_RGB16I, EXTERNAL_RGB_INTEGER, TYPE_I16, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //RGB16I, - {INTERNAL_RGBA16I, EXTERNAL_RGBA_INTEGER, TYPE_I16, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA16I, + external_format const ExternalLuminance = HasSwizzle ? EXTERNAL_RED : EXTERNAL_LUMINANCE; + external_format const ExternalAlpha = HasSwizzle ? EXTERNAL_RED : EXTERNAL_ALPHA; + external_format const ExternalLuminanceAlpha = HasSwizzle ? EXTERNAL_RG : EXTERNAL_LUMINANCE_ALPHA; - {INTERNAL_R32I, EXTERNAL_RED_INTEGER, TYPE_I32, {SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE}}, //R32I, - {INTERNAL_RG32I, EXTERNAL_RG_INTEGER, TYPE_I32, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE}}, //RG32I, - {INTERNAL_RGB32I, EXTERNAL_RGB_INTEGER, TYPE_I32, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //RGB32I, - {INTERNAL_RGBA32I, EXTERNAL_RGBA_INTEGER, TYPE_I32, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA32I, + type_format const TypeF16 = Profile == PROFILE_ES20 ? TYPE_F16_OES : TYPE_F16; - /// Floating formats - {INTERNAL_R16F, EXTERNAL_RED, TYPE_F16, {SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE}}, //R16F, - {INTERNAL_RG16F, EXTERNAL_RG, TYPE_F16, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE}}, //RG16F, - {INTERNAL_RGB16F, EXTERNAL_RGB, TYPE_F16, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //RGB16F, - {INTERNAL_RGBA16F, EXTERNAL_RGBA, TYPE_F16, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA16F, + format_desc const Table[] = + { + {INTERNAL_RG4_EXT, EXTERNAL_RG, TYPE_UINT8_RG4_REV_GTC, 0}, //FORMAT_R4G4_UNORM, + {INTERNAL_RGBA4, EXTERNAL_RGBA, TYPE_UINT16_RGBA4_REV, 0}, //FORMAT_RGBA4_UNORM, + {INTERNAL_RGBA4, EXTERNAL_RGBA, TYPE_UINT16_RGBA4, detail::FORMAT_PROPERTY_BGRA_TYPE_BIT}, //FORMAT_BGRA4_UNORM, + {INTERNAL_R5G6B5, EXTERNAL_RGB, TYPE_UINT16_R5G6B5_REV, 0}, //FORMAT_R5G6B5_UNORM, + {INTERNAL_R5G6B5, EXTERNAL_RGB, TYPE_UINT16_R5G6B5, detail::FORMAT_PROPERTY_BGRA_TYPE_BIT}, //FORMAT_B5G6R5_UNORM, + {INTERNAL_RGB5A1, EXTERNAL_RGBA, TYPE_UINT16_RGB5A1_REV, 0}, //FORMAT_RGB5A1_UNORM, + {INTERNAL_RGB5A1, EXTERNAL_RGBA, TYPE_UINT16_RGB5A1, detail::FORMAT_PROPERTY_BGRA_TYPE_BIT}, //FORMAT_BGR5A1_UNORM, + {INTERNAL_RGB5A1, EXTERNAL_RGBA, TYPE_UINT16_A1RGB5_GTC, 0}, //FORMAT_A1RGB5_UNORM, - {INTERNAL_R32F, EXTERNAL_RED, TYPE_F32, {SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE}}, //R32F, - {INTERNAL_RG32F, EXTERNAL_RG, TYPE_F32, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE}}, //RG32F, - {INTERNAL_RGB32F, EXTERNAL_RGB, TYPE_F32, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //RGB32F, - {INTERNAL_RGBA32F, EXTERNAL_RGBA, TYPE_F32, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA32F, + {INTERNAL_R8_UNORM, EXTERNAL_RED, TYPE_U8, 0}, //FORMAT_R8_UNORM, + {INTERNAL_R8_SNORM, EXTERNAL_RED, TYPE_I8, 0}, //FORMAT_R8_SNORM, + {INTERNAL_R8_USCALED_GTC, EXTERNAL_RED, TYPE_U8, 0}, //FORMAT_R8_USCALED, + {INTERNAL_R8_SSCALED_GTC, EXTERNAL_RED, TYPE_I8, 0}, //FORMAT_R8_SSCALED, + {INTERNAL_R8U, EXTERNAL_RED_INTEGER, TYPE_U8, 0}, //FORMAT_R8_UINT, + {INTERNAL_R8I, EXTERNAL_RED_INTEGER, TYPE_I8, 0}, //FORMAT_R8_SINT, + {INTERNAL_SR8, EXTERNAL_RED, TYPE_U8, 0}, //FORMAT_R8_SRGB, - /// sRGB formats - {INTERNAL_SR8, EXTERNAL_RED, TYPE_U8, {SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE}}, //SR8_UNORM, - {INTERNAL_SRG8, EXTERNAL_RG, TYPE_U8, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE}}, //SRG8_UNORM, - {INTERNAL_SRGB8, EXTERNAL_RGB, TYPE_U8, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //SRGB8_UNORM, - {INTERNAL_SRGB8_ALPHA8, EXTERNAL_RGBA, TYPE_U8, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //SRGB8_ALPHA8_UNORM, + {INTERNAL_RG8_UNORM, EXTERNAL_RG, TYPE_U8, 0}, //FORMAT_RG8_UNORM, + {INTERNAL_RG8_SNORM, EXTERNAL_RG, TYPE_I8, 0}, //FORMAT_RG8_SNORM, + {INTERNAL_RG8_USCALED_GTC, EXTERNAL_RG, TYPE_U8, 0}, //FORMAT_RG8_USCALED, + {INTERNAL_RG8_SSCALED_GTC, EXTERNAL_RG, TYPE_I8, 0}, //FORMAT_RG8_SSCALED, + {INTERNAL_RG8U, EXTERNAL_RG_INTEGER, TYPE_U8, 0}, //FORMAT_RG8_UINT, + {INTERNAL_RG8I, EXTERNAL_RG_INTEGER, TYPE_I8, 0}, //FORMAT_RG8_SINT, + {INTERNAL_SRG8, EXTERNAL_RG, TYPE_U8, 0}, //FORMAT_RG8_SRGB, - /// Packed formats - {INTERNAL_RGB10A2_UNORM, EXTERNAL_RGBA, TYPE_UINT32_RGB10A2, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGB10A2_UNORM, - {INTERNAL_RGB10A2U, EXTERNAL_RGBA_INTEGER, TYPE_UINT32_RGB10A2, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGB10A2U, - {INTERNAL_RGB9E5, EXTERNAL_RGB, TYPE_UINT32_RGB9_E5, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //RGB9E5, - {INTERNAL_RG11B10F, EXTERNAL_RGB, TYPE_UINT32_RG11B10F, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //RG11B10F, - {INTERNAL_RG3B2, EXTERNAL_RGB, TYPE_UINT8_RG3B2, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //RG3B2, - {INTERNAL_R5G6B5, EXTERNAL_RGB, TYPE_UINT16_R5G6B5, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //R5G6B5, - {INTERNAL_RGB5A1, EXTERNAL_RGBA, TYPE_UINT16_RGB5A1, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGB5A1, - {INTERNAL_RGBA4, EXTERNAL_RGBA, TYPE_UINT16_RGBA4, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA4, + {INTERNAL_RGB8_UNORM, EXTERNAL_RGB, TYPE_U8, 0}, //FORMAT_RGB8_UNORM, + {INTERNAL_RGB8_SNORM, EXTERNAL_RGB, TYPE_I8, 0}, //FORMAT_RGB8_SNORM, + {INTERNAL_RGB8_USCALED_GTC, EXTERNAL_RGB, TYPE_U8, 0}, //FORMAT_RGB8_USCALED, + {INTERNAL_RGB8_SSCALED_GTC, EXTERNAL_RGB, TYPE_I8, 0}, //FORMAT_RGB8_SSCALED, + {INTERNAL_RGB8U, EXTERNAL_RGB_INTEGER, TYPE_U8, 0}, //FORMAT_RGB8_UINT, + {INTERNAL_RGB8I, EXTERNAL_RGB_INTEGER, TYPE_I8, 0}, //FORMAT_RGB8_SINT, + {INTERNAL_SRGB8, ExternalSRGB8, TYPE_U8, 0}, //FORMAT_RGB8_SRGB, - // Swizzle formats - {INTERNAL_RGB8_UNORM, EXTERNAL_BGRA, TYPE_U8, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //FORMAT_BGRX8_UNORM, - {INTERNAL_RGBA8_UNORM, EXTERNAL_BGRA, TYPE_U8, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //FORMAT_BGRA8_UNORM, - {INTERNAL_SRGB8, EXTERNAL_BGRA, TYPE_U8, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //FORMAT_BGRX8_SRGB, - {INTERNAL_SRGB8_ALPHA8, EXTERNAL_BGRA, TYPE_U8, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //FORMAT_BGRA8_SRGB, + {INTERNAL_RGB8_UNORM, ExternalBGR, TYPE_U8, detail::FORMAT_PROPERTY_BGRA_FORMAT_BIT}, //FORMAT_BGR8_UNORM_PACK8, + {INTERNAL_RGB8_SNORM, ExternalBGR, TYPE_I8, detail::FORMAT_PROPERTY_BGRA_FORMAT_BIT}, //FORMAT_BGR8_SNORM_PACK8, + {INTERNAL_RGB8_USCALED_GTC, ExternalBGR, TYPE_U8, detail::FORMAT_PROPERTY_BGRA_FORMAT_BIT}, //FORMAT_BGR8_USCALED_PACK8, + {INTERNAL_RGB8_SSCALED_GTC, ExternalBGR, TYPE_I8, detail::FORMAT_PROPERTY_BGRA_FORMAT_BIT}, //FORMAT_BGR8_SSCALED_PACK8, + {INTERNAL_RGB8U, ExternalBGRInt, TYPE_U8, detail::FORMAT_PROPERTY_BGRA_FORMAT_BIT}, //FORMAT_BGR8_UINT_PACK8, + {INTERNAL_RGB8I, ExternalBGRInt, TYPE_I8, detail::FORMAT_PROPERTY_BGRA_FORMAT_BIT}, //FORMAT_BGR8_SINT_PACK8, + {INTERNAL_SRGB8, ExternalBGR, TYPE_U8, detail::FORMAT_PROPERTY_BGRA_FORMAT_BIT}, //FORMAT_BGR8_SRGB_PACK8, - // Luminance Alpha formats - {INTERNAL_RG8_UNORM, EXTERNAL_RED, TYPE_U8, {SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE}}, //L8_UNORM, - {INTERNAL_RGB8_UNORM, EXTERNAL_RED, TYPE_U8, {SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_RED}}, //A8_UNORM, - {INTERNAL_RG8_UNORM, EXTERNAL_RG, TYPE_U8, {SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_GREEN}}, //LA8_UNORM, - {INTERNAL_R16_UNORM, EXTERNAL_RED, TYPE_U16, {SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE}}, //L16_UNORM, - {INTERNAL_R16_UNORM, EXTERNAL_RED, TYPE_U16, {SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_RED}}, //A16_UNORM, - {INTERNAL_RG16_UNORM, EXTERNAL_RG, TYPE_U16, {SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_GREEN}}, //LA16_UNORM, + {INTERNAL_RGBA8_UNORM, EXTERNAL_RGBA, TYPE_U8, 0}, //FORMAT_RGBA8_UNORM_PACK8, + {INTERNAL_RGBA8_SNORM, EXTERNAL_RGBA, TYPE_I8, 0}, //FORMAT_RGBA8_SNORM_PACK8, + {INTERNAL_RGBA8_USCALED_GTC, EXTERNAL_RGBA, TYPE_U8, 0}, //FORMAT_RGBA8_USCALED_PACK8, + {INTERNAL_RGBA8_SSCALED_GTC, EXTERNAL_RGBA, TYPE_I8, 0}, //FORMAT_RGBA8_SSCALED_PACK8, + {INTERNAL_RGBA8U, EXTERNAL_RGBA_INTEGER, TYPE_U8, 0}, //FORMAT_RGBA8_UINT_PACK8, + {INTERNAL_RGBA8I, EXTERNAL_RGBA_INTEGER, TYPE_I8, 0}, //FORMAT_RGBA8_SINT_PACK8, + {INTERNAL_SRGB8_ALPHA8, ExternalSRGB8_A8, TYPE_U8, 0}, //FORMAT_RGBA8_SRGB_PACK8, - /// Depth formats - {INTERNAL_D16, EXTERNAL_DEPTH, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //D16, - {INTERNAL_D24, EXTERNAL_DEPTH, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //D24X8, - {INTERNAL_D24S8, EXTERNAL_DEPTH_STENCIL, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //D24S8, - {INTERNAL_D32F, EXTERNAL_DEPTH, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //D32F, - {INTERNAL_D32FS8X24, EXTERNAL_DEPTH_STENCIL, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //D32FS8X24, + {InternalBGRA, ExternalBGRA, TYPE_U8, detail::FORMAT_PROPERTY_BGRA_FORMAT_BIT}, //FORMAT_BGRA8_UNORM_PACK8, + {INTERNAL_RGBA8_SNORM, ExternalBGRA, TYPE_I8, detail::FORMAT_PROPERTY_BGRA_FORMAT_BIT}, //FORMAT_BGRA8_SNORM_PACK8, + {INTERNAL_RGBA8_USCALED_GTC, ExternalBGRA, TYPE_U8, detail::FORMAT_PROPERTY_BGRA_FORMAT_BIT}, //FORMAT_BGRA8_USCALED_PACK8, + {INTERNAL_RGBA8_SSCALED_GTC, ExternalBGRA, TYPE_I8, detail::FORMAT_PROPERTY_BGRA_FORMAT_BIT}, //FORMAT_BGRA8_SSCALED_PACK8, + {INTERNAL_RGBA8U, ExternalBGRAInt, TYPE_U8, detail::FORMAT_PROPERTY_BGRA_FORMAT_BIT}, //FORMAT_BGRA8_UINT_PACK8, + {INTERNAL_RGBA8I, ExternalBGRAInt, TYPE_I8, detail::FORMAT_PROPERTY_BGRA_FORMAT_BIT}, //FORMAT_BGRA8_SINT_PACK8, + {INTERNAL_SRGB8_ALPHA8, ExternalBGRA, TYPE_U8, detail::FORMAT_PROPERTY_BGRA_FORMAT_BIT}, //FORMAT_BGRA8_SRGB_PACK8, - /// Compressed formats - {INTERNAL_RGB_DXT1, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //RGB_DXT1_UNORM, - {INTERNAL_RGBA_DXT1, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA_DXT1_UNORM, - {INTERNAL_RGBA_DXT3, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA_DXT3_UNORM, - {INTERNAL_RGBA_DXT5, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA_DXT5_UNORM, - {INTERNAL_R_ATI1N_UNORM, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE}}, //R_ATI1N_UNORM, - {INTERNAL_R_ATI1N_SNORM, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE}}, //R_ATI1N_SNORM, - {INTERNAL_RG_ATI2N_UNORM, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE}}, //RG_ATI2N_UNORM, - {INTERNAL_RG_ATI2N_SNORM, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_ZERO, SWIZZLE_ONE}}, //RG_ATI2N_SNORM, - {INTERNAL_RGB_BP_UNSIGNED_FLOAT, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //RGB_BP_UF16, - {INTERNAL_RGB_BP_SIGNED_FLOAT, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //RGB_BP_SF16, - {INTERNAL_RGB_BP_UNORM, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //RGB_BP_UNORM, - {INTERNAL_RGB_PVRTC_4BPPV1, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //RGB_PVRTC_4BPP_UNORM, - {INTERNAL_RGB_PVRTC_2BPPV1, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //RGB_PVRTC_2BPP_UNORM, - {INTERNAL_RGBA_PVRTC_4BPPV1, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA_PVRTC_4BPP_UNORM, - {INTERNAL_RGBA_PVRTC_2BPPV1, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA_PVRTC_2BPP_UNORM, - {INTERNAL_RGBA_PVRTC_4BPPV2, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA_PVRTC2_4BPP_UNORM, - {INTERNAL_RGBA_PVRTC_2BPPV2, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA_PVRTC2_2BPP_UNORM, - {INTERNAL_ATC_RGB, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //ATC_RGB_UNORM, - {INTERNAL_ATC_RGBA_EXPLICIT_ALPHA, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //ATC_RGBA_EXPLICIT_ALPHA_UNORM, - {INTERNAL_ATC_RGBA_INTERPOLATED_ALPHA, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //ATC_RGBA_INTERPOLATED_ALPHA_UNORM, - {INTERNAL_RGB_ETC, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //FORMAT_RGB_ETC_UNORM, - {INTERNAL_RGB_ETC2, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //FORMAT_RGB_ETC2_UNORM, - {INTERNAL_RGBA_PUNCHTHROUGH_ETC2, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //FORMAT_RGBA_ETC2_PUNCHTHROUGH_UNORM, - {INTERNAL_RGBA_ETC2, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //FORMAT_RGBA_ETC2_UNORM, - {INTERNAL_R11_EAC, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //R11_EAC_UNORM, - {INTERNAL_SIGNED_R11_EAC, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //R11_EAC_SNORM, - {INTERNAL_RG11_EAC, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RG11_EAC_UNORM, - {INTERNAL_SIGNED_RG11_EAC, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RG11_EAC_SNORM, - {INTERNAL_RGBA_ASTC_4x4, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA_ASTC_4x4_UNORM, - {INTERNAL_RGBA_ASTC_5x4, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA_ASTC_5x4_UNORM, - {INTERNAL_RGBA_ASTC_5x5, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA_ASTC_5x5_UNORM, - {INTERNAL_RGBA_ASTC_6x5, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA_ASTC_6x5_UNORM, - {INTERNAL_RGBA_ASTC_6x6, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA_ASTC_6x6_UNORM, - {INTERNAL_RGBA_ASTC_8x5, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA_ASTC_8x5_UNORM, - {INTERNAL_RGBA_ASTC_8x6, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA_ASTC_8x6_UNORM, - {INTERNAL_RGBA_ASTC_8x8, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA_ASTC_8x8_UNORM, - {INTERNAL_RGBA_ASTC_10x5, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA_ASTC_10x5_UNORM, - {INTERNAL_RGBA_ASTC_10x6, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA_ASTC_10x6_UNORM, - {INTERNAL_RGBA_ASTC_10x8, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA_ASTC_10x8_UNORM, - {INTERNAL_RGBA_ASTC_10x10, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA_ASTC_10x10_UNORM, - {INTERNAL_RGBA_ASTC_12x10, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA_ASTC_12x10_UNORM, - {INTERNAL_RGBA_ASTC_12x12, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //RGBA_ASTC_12x12_UNORM, + {INTERNAL_RGBA8_UNORM, EXTERNAL_RGBA, TYPE_UINT32_RGBA8_REV, 0}, //FORMAT_ABGR8_UNORM_PACK32, + {INTERNAL_RGBA8_SNORM, EXTERNAL_RGBA, TYPE_UINT32_RGBA8_REV, 0}, //FORMAT_ABGR8_SNORM_PACK32, + {INTERNAL_RGBA8_USCALED_GTC, EXTERNAL_RGBA, TYPE_UINT32_RGBA8_REV, 0}, //FORMAT_ABGR8_USCALED_PACK32, + {INTERNAL_RGBA8_SSCALED_GTC, EXTERNAL_RGBA, TYPE_UINT32_RGBA8_REV, 0}, //FORMAT_ABGR8_SSCALED_PACK32, + {INTERNAL_RGBA8U, EXTERNAL_RGBA_INTEGER, TYPE_UINT32_RGBA8_REV, 0}, //FORMAT_ABGR8_UINT_PACK32, + {INTERNAL_RGBA8I, EXTERNAL_RGBA_INTEGER, TYPE_UINT32_RGBA8_REV, 0}, //FORMAT_ABGR8_SINT_PACK32, + {INTERNAL_SRGB8_ALPHA8, EXTERNAL_RGBA, TYPE_UINT32_RGBA8_REV, 0}, //FORMAT_ABGR8_SRGB_PACK32, - // sRGB compressed formats - {INTERNAL_SRGB_DXT1, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //SRGB_DXT1_UNORM, - {INTERNAL_SRGB_ALPHA_DXT1, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //SRGB_DXT1_UNORM, - {INTERNAL_SRGB_ALPHA_DXT3, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //SRGB_DXT3_UNORM, - {INTERNAL_SRGB_ALPHA_DXT5, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //SRGB_DXT5_UNORM, - {INTERNAL_SRGB_BP_UNORM, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //SRGB_BP_UNORM, - {INTERNAL_SRGB_PVRTC_2BPPV1, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //SRGB_PVRTC_4BPP_UNORM, - {INTERNAL_SRGB_PVRTC_4BPPV1, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ONE}}, //SRGB_PVRTC_2BPP_UNORM, - {INTERNAL_SRGB_ALPHA_PVRTC_2BPPV1, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //SRGB_ALPHA_PVRTC_4BPP_UNORM, - {INTERNAL_SRGB_ALPHA_PVRTC_4BPPV1, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //SRGB_ALPHA_PVRTC_2BPP_UNORM, - {INTERNAL_SRGB_ALPHA_PVRTC_2BPPV2, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //SRGB_ALPHA_PVRTC2_4BPP_UNORM, - {INTERNAL_SRGB_ALPHA_PVRTC_4BPPV2, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //SRGB_ALPHA_PVRTC2_2BPP_UNORM, - {INTERNAL_SRGB8_ETC2, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //SRGB_ETC2_UNORM, - {INTERNAL_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //SRGB_ETC2_PUNCHTHROUGH_ALPHA_UNORM, - {INTERNAL_SRGB8_ALPHA8_ETC2_EAC, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //SRGBA_ETC2_UNORM, - {INTERNAL_SRGB8_ALPHA8_ASTC_4x4, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //SRGB8_ALPHA8_ASTC_4x4_UNORM, - {INTERNAL_SRGB8_ALPHA8_ASTC_5x4, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //SRGB8_ALPHA8_ASTC_5x4_UNORM, - {INTERNAL_SRGB8_ALPHA8_ASTC_5x5, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //SRGB8_ALPHA8_ASTC_5x5_UNORM, - {INTERNAL_SRGB8_ALPHA8_ASTC_6x5, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //SRGB8_ALPHA8_ASTC_6x5_UNORM, - {INTERNAL_SRGB8_ALPHA8_ASTC_6x6, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //SRGB8_ALPHA8_ASTC_6x6_UNORM, - {INTERNAL_SRGB8_ALPHA8_ASTC_8x5, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //SRGB8_ALPHA8_ASTC_8x5_UNORM, - {INTERNAL_SRGB8_ALPHA8_ASTC_8x6, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //SRGB8_ALPHA8_ASTC_8x6_UNORM, - {INTERNAL_SRGB8_ALPHA8_ASTC_8x8, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //SRGB8_ALPHA8_ASTC_8x8_UNORM, - {INTERNAL_SRGB8_ALPHA8_ASTC_10x5, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //SRGB8_ALPHA8_ASTC_10x5_UNORM, - {INTERNAL_SRGB8_ALPHA8_ASTC_10x6, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //SRGB8_ALPHA8_ASTC_10x6_UNORM, - {INTERNAL_SRGB8_ALPHA8_ASTC_10x8, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //SRGB8_ALPHA8_ASTC_10x8_UNORM, - {INTERNAL_SRGB8_ALPHA8_ASTC_10x10, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //SRGB8_ALPHA8_ASTC_10x10_UNORM, - {INTERNAL_SRGB8_ALPHA8_ASTC_12x10, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //SRGB8_ALPHA8_ASTC_12x10_UNORM, - {INTERNAL_SRGB8_ALPHA8_ASTC_12x12, EXTERNAL_NONE, TYPE_NONE, {SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA}}, //SRGB8_ALPHA8_ASTC_12x12_UNORM, + {INTERNAL_RGB10A2_UNORM, EXTERNAL_RGBA, TYPE_UINT32_RGB10A2_REV, 0}, //FORMAT_RGB10A2_UNORM_PACK32, + {INTERNAL_RGB10A2_SNORM_EXT, EXTERNAL_RGBA, TYPE_UINT32_RGB10A2_REV, 0}, //FORMAT_RGB10A2_SNORM_PACK32, + {INTERNAL_RGB10A2_USCALED_GTC, EXTERNAL_RGBA, TYPE_UINT32_RGB10A2_REV, 0}, //FORMAT_RGB10A2_USCALE_PACK32, + {INTERNAL_RGB10A2_SSCALED_GTC, EXTERNAL_RGBA, TYPE_UINT32_RGB10A2_REV, 0}, //FORMAT_RGB10A2_SSCALE_PACK32, + {INTERNAL_RGB10A2U, EXTERNAL_RGBA_INTEGER, TYPE_UINT32_RGB10A2_REV, 0}, //FORMAT_RGB10A2_UINT_PACK32, + {INTERNAL_RGB10A2I_EXT, EXTERNAL_RGBA_INTEGER, TYPE_UINT32_RGB10A2_REV, 0}, //FORMAT_RGB10A2_SINT_PACK32, + + {INTERNAL_RGB10A2_UNORM, EXTERNAL_RGBA, TYPE_UINT32_RGB10A2, detail::FORMAT_PROPERTY_BGRA_TYPE_BIT}, //FORMAT_BGR10A2_UNORM_PACK32, + {INTERNAL_RGB10A2_SNORM_EXT, EXTERNAL_RGBA, TYPE_UINT32_RGB10A2, detail::FORMAT_PROPERTY_BGRA_TYPE_BIT}, //FORMAT_BGR10A2_SNORM_PACK32, + {INTERNAL_RGB10A2_USCALED_GTC, EXTERNAL_RGBA, TYPE_UINT32_RGB10A2, detail::FORMAT_PROPERTY_BGRA_TYPE_BIT}, //FORMAT_BGR10A2_USCALE_PACK32, + {INTERNAL_RGB10A2_SSCALED_GTC, EXTERNAL_RGBA, TYPE_UINT32_RGB10A2, detail::FORMAT_PROPERTY_BGRA_TYPE_BIT}, //FORMAT_BGR10A2_SSCALE_PACK32, + {INTERNAL_RGB10A2U, EXTERNAL_RGBA_INTEGER, TYPE_UINT32_RGB10A2, detail::FORMAT_PROPERTY_BGRA_TYPE_BIT}, //FORMAT_BGR10A2_UINT_PACK32, + {INTERNAL_RGB10A2I_EXT, EXTERNAL_RGBA_INTEGER, TYPE_UINT32_RGB10A2, detail::FORMAT_PROPERTY_BGRA_TYPE_BIT}, //FORMAT_BGR10A2_SINT_PACK32, + + {INTERNAL_R16_UNORM, EXTERNAL_RED, TYPE_U16, 0}, //FORMAT_R16_UNORM_PACK16, + {INTERNAL_R16_SNORM, EXTERNAL_RED, TYPE_I16, 0}, //FORMAT_R16_SNORM_PACK16, + {INTERNAL_R16_USCALED_GTC, EXTERNAL_RED, TYPE_U16, 0}, //FORMAT_R16_USCALED_PACK16, + {INTERNAL_R16_SSCALED_GTC, EXTERNAL_RED, TYPE_I16, 0}, //FORMAT_R16_SSCALED_PACK16, + {INTERNAL_R16U, EXTERNAL_RED_INTEGER, TYPE_U16, 0}, //FORMAT_R16_UINT_PACK16, + {INTERNAL_R16I, EXTERNAL_RED_INTEGER, TYPE_I16, 0}, //FORMAT_R16_SINT_PACK16, + {INTERNAL_R16F, EXTERNAL_RED, TypeF16, 0}, //FORMAT_R16_SFLOAT_PACK16, + + {INTERNAL_RG16_UNORM, EXTERNAL_RG, TYPE_U16, 0}, //FORMAT_RG16_UNORM_PACK16, + {INTERNAL_RG16_SNORM, EXTERNAL_RG, TYPE_I16, 0}, //FORMAT_RG16_SNORM_PACK16, + {INTERNAL_RG16_USCALED_GTC, EXTERNAL_RG, TYPE_U16, 0}, //FORMAT_RG16_USCALED_PACK16, + {INTERNAL_RG16_SSCALED_GTC, EXTERNAL_RG, TYPE_I16, 0}, //FORMAT_RG16_SSCALED_PACK16, + {INTERNAL_RG16U, EXTERNAL_RG_INTEGER, TYPE_U16, 0}, //FORMAT_RG16_UINT_PACK16, + {INTERNAL_RG16I, EXTERNAL_RG_INTEGER, TYPE_I16, 0}, //FORMAT_RG16_SINT_PACK16, + {INTERNAL_RG16F, EXTERNAL_RG, TypeF16, 0}, //FORMAT_RG16_SFLOAT_PACK16, + + {INTERNAL_RGB16_UNORM, EXTERNAL_RGB, TYPE_U16, 0}, //FORMAT_RGB16_UNORM_PACK16, + {INTERNAL_RGB16_SNORM, EXTERNAL_RGB, TYPE_I16, 0}, //FORMAT_RGB16_SNORM_PACK16, + {INTERNAL_RGB16_USCALED_GTC, EXTERNAL_RGB, TYPE_U16, 0}, //FORMAT_RGB16_USCALED_PACK16, + {INTERNAL_RGB16_SSCALED_GTC, EXTERNAL_RGB, TYPE_I16, 0}, //FORMAT_RGB16_USCALED_PACK16, + {INTERNAL_RGB16U, EXTERNAL_RGB_INTEGER, TYPE_U16, 0}, //FORMAT_RGB16_UINT_PACK16, + {INTERNAL_RGB16I, EXTERNAL_RGB_INTEGER, TYPE_I16, 0}, //FORMAT_RGB16_SINT_PACK16, + {INTERNAL_RGB16F, EXTERNAL_RGB, TypeF16, 0}, //FORMAT_RGB16_SFLOAT_PACK16, + + {INTERNAL_RGBA16_UNORM, EXTERNAL_RGBA, TYPE_U16, 0}, //FORMAT_RGBA16_UNORM_PACK16, + {INTERNAL_RGBA16_SNORM, EXTERNAL_RGBA, TYPE_I16, 0}, //FORMAT_RGBA16_SNORM_PACK16, + {INTERNAL_RGBA16_USCALED_GTC, EXTERNAL_RGBA, TYPE_U16, 0}, //FORMAT_RGBA16_USCALED_PACK16, + {INTERNAL_RGBA16_SSCALED_GTC, EXTERNAL_RGBA, TYPE_I16, 0}, //FORMAT_RGBA16_SSCALED_PACK16, + {INTERNAL_RGBA16U, EXTERNAL_RGBA_INTEGER, TYPE_U16, 0}, //FORMAT_RGBA16_UINT_PACK16, + {INTERNAL_RGBA16I, EXTERNAL_RGBA_INTEGER, TYPE_I16, 0}, //FORMAT_RGBA16_SINT_PACK16, + {INTERNAL_RGBA16F, EXTERNAL_RGBA, TypeF16, 0}, //FORMAT_RGBA16_SFLOAT_PACK16, + + {INTERNAL_R32U, EXTERNAL_RED_INTEGER, TYPE_U32, 0}, //FORMAT_R32_UINT_PACK32, + {INTERNAL_R32I, EXTERNAL_RED_INTEGER, TYPE_I32, 0}, //FORMAT_R32_SINT_PACK32, + {INTERNAL_R32F, EXTERNAL_RED, TYPE_F32, 0}, //FORMAT_R32_SFLOAT_PACK32, + + {INTERNAL_RG32U, EXTERNAL_RG_INTEGER, TYPE_U32, 0}, //FORMAT_RG32_UINT_PACK32, + {INTERNAL_RG32I, EXTERNAL_RG_INTEGER, TYPE_I32, 0}, //FORMAT_RG32_SINT_PACK32, + {INTERNAL_RG32F, EXTERNAL_RG, TYPE_F32, 0}, //FORMAT_RG32_SFLOAT_PACK32, + + {INTERNAL_RGB32U, EXTERNAL_RGB_INTEGER, TYPE_U32, 0}, //FORMAT_RGB32_UINT_PACK32, + {INTERNAL_RGB32I, EXTERNAL_RGB_INTEGER, TYPE_I32, 0}, //FORMAT_RGB32_SINT_PACK32, + {INTERNAL_RGB32F, EXTERNAL_RGB, TYPE_F32, 0}, //FORMAT_RGB32_SFLOAT_PACK32, + + {INTERNAL_RGBA32U, EXTERNAL_RGBA_INTEGER, TYPE_U32, 0}, //FORMAT_RGBA32_UINT_PACK32, + {INTERNAL_RGBA32I, EXTERNAL_RGBA_INTEGER, TYPE_I32, 0}, //FORMAT_RGBA32_SINT_PACK32, + {INTERNAL_RGBA32F, EXTERNAL_RGBA, TYPE_F32, 0}, //FORMAT_RGBA32_SFLOAT_PACK32, + + {INTERNAL_R64F_EXT, EXTERNAL_RED, TYPE_U64, 0}, //FORMAT_R64_UINT_PACK64, + {INTERNAL_R64F_EXT, EXTERNAL_RED, TYPE_I64, 0}, //FORMAT_R64_SINT_PACK64, + {INTERNAL_R64F_EXT, EXTERNAL_RED, TYPE_F64, 0}, //FORMAT_R64_SFLOAT_PACK64, + + {INTERNAL_RG64F_EXT, EXTERNAL_RG, TYPE_U64, 0}, //FORMAT_RG64_UINT_PACK64, + {INTERNAL_RG64F_EXT, EXTERNAL_RG, TYPE_I64, 0}, //FORMAT_RG64_SINT_PACK64, + {INTERNAL_RG64F_EXT, EXTERNAL_RG, TYPE_F64, 0}, //FORMAT_RG64_SFLOAT_PACK64, + + {INTERNAL_RGB64F_EXT, EXTERNAL_RGB, TYPE_U64, 0}, //FORMAT_RGB64_UINT_PACK64, + {INTERNAL_RGB64F_EXT, EXTERNAL_RGB, TYPE_I64, 0}, //FORMAT_RGB64_SINT_PACK64, + {INTERNAL_RGB64F_EXT, EXTERNAL_RGB, TYPE_F64, 0}, //FORMAT_RGB64_SFLOAT_PACK64, + + {INTERNAL_RGBA64F_EXT, EXTERNAL_RGBA, TYPE_U64, 0}, //FORMAT_RGBA64_UINT_PACK64, + {INTERNAL_RGBA64F_EXT, EXTERNAL_RGBA, TYPE_I64, 0}, //FORMAT_RGBA64_SINT_PACK64, + {INTERNAL_RGBA64F_EXT, EXTERNAL_RGBA, TYPE_F64, 0}, //FORMAT_RGBA64_SFLOAT_PACK64, + + {INTERNAL_RG11B10F, EXTERNAL_RGB, TYPE_UINT32_RG11B10F_REV, 0}, //FORMAT_RG11B10_UFLOAT_PACK32, + {INTERNAL_RGB9E5, EXTERNAL_RGB, TYPE_UINT32_RGB9_E5_REV, 0}, //FORMAT_RGB9E5_UFLOAT_PACK32, + + {INTERNAL_D16, EXTERNAL_DEPTH, TYPE_NONE, 0}, //FORMAT_D16_UNORM_PACK16, + {INTERNAL_D24, EXTERNAL_DEPTH, TYPE_NONE, 0}, //FORMAT_D24_UNORM, + {INTERNAL_D32F, EXTERNAL_DEPTH, TYPE_NONE, 0}, //FORMAT_D32_UFLOAT, + {INTERNAL_S8_EXT, EXTERNAL_STENCIL, TYPE_NONE, 0}, //FORMAT_S8_UNORM, + {INTERNAL_D16S8_EXT, EXTERNAL_DEPTH, TYPE_NONE, 0}, //FORMAT_D16_UNORM_S8_UINT_PACK32, + {INTERNAL_D24S8, EXTERNAL_DEPTH_STENCIL, TYPE_NONE, 0}, //FORMAT_D24_UNORM_S8_UINT_PACK32, + {INTERNAL_D32FS8X24, EXTERNAL_DEPTH_STENCIL, TYPE_NONE, 0}, //FORMAT_D32_SFLOAT_S8_UINT_PACK64, + + {INTERNAL_RGB_DXT1, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGB_DXT1_UNORM_BLOCK8, + {INTERNAL_SRGB_DXT1, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGB_DXT1_SRGB_BLOCK8, + {INTERNAL_RGBA_DXT1, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_DXT1_UNORM_BLOCK8, + {INTERNAL_SRGB_ALPHA_DXT1, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_DXT1_SRGB_BLOCK8, + {INTERNAL_RGBA_DXT3, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_DXT3_UNORM_BLOCK16, + {INTERNAL_SRGB_ALPHA_DXT3, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_DXT3_SRGB_BLOCK16, + {INTERNAL_RGBA_DXT5, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_DXT5_UNORM_BLOCK16, + {INTERNAL_SRGB_ALPHA_DXT5, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_DXT5_SRGB_BLOCK16, + {INTERNAL_R_ATI1N_UNORM, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_R_ATI1N_UNORM_BLOCK8, + {INTERNAL_R_ATI1N_SNORM, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_R_ATI1N_SNORM_BLOCK8, + {INTERNAL_RG_ATI2N_UNORM, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RG_ATI2N_UNORM_BLOCK16, + {INTERNAL_RG_ATI2N_SNORM, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RG_ATI2N_SNORM_BLOCK16, + {INTERNAL_RGB_BP_UNSIGNED_FLOAT, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGB_BP_UFLOAT_BLOCK16, + {INTERNAL_RGB_BP_SIGNED_FLOAT, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGB_BP_SFLOAT_BLOCK16, + {INTERNAL_RGB_BP_UNORM, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGB_BP_UNORM, + {INTERNAL_SRGB_BP_UNORM, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGB_BP_SRGB, + + {InternalRGBETC, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGB_ETC2_UNORM_BLOCK8, + {INTERNAL_SRGB8_ETC2, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGB_ETC2_SRGB_BLOCK8, + {INTERNAL_RGBA_PUNCHTHROUGH_ETC2, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ETC2_PUNCHTHROUGH_UNORM, + {INTERNAL_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ETC2_PUNCHTHROUGH_SRGB, + {INTERNAL_RGBA_ETC2, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ETC2_UNORM_BLOCK16, + {INTERNAL_SRGB8_ALPHA8_ETC2_EAC, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ETC2_SRGB_BLOCK16, + {INTERNAL_R11_EAC, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_R11_EAC_UNORM, + {INTERNAL_SIGNED_R11_EAC, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_R11_EAC_SNORM, + {INTERNAL_RG11_EAC, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RG11_EAC_UNORM, + {INTERNAL_SIGNED_RG11_EAC, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RG11_EAC_SNORM, + + {INTERNAL_RGBA_ASTC_4x4, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ASTC4X4_UNORM, + {INTERNAL_SRGB8_ALPHA8_ASTC_4x4, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ASTC4X4_SRGB, + {INTERNAL_RGBA_ASTC_5x4, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ASTC5X4_UNORM, + {INTERNAL_SRGB8_ALPHA8_ASTC_5x4, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ASTC5X4_SRGB, + {INTERNAL_RGBA_ASTC_5x5, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ASTC5X5_UNORM, + {INTERNAL_SRGB8_ALPHA8_ASTC_5x5, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ASTC5X5_SRGB, + {INTERNAL_RGBA_ASTC_6x5, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ASTC6X5_UNORM, + {INTERNAL_SRGB8_ALPHA8_ASTC_6x5, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ASTC6X5_SRGB, + {INTERNAL_RGBA_ASTC_6x6, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ASTC6X6_UNORM, + {INTERNAL_SRGB8_ALPHA8_ASTC_6x6, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ASTC6X6_SRGB, + {INTERNAL_RGBA_ASTC_8x5, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ASTC8X5_UNORM, + {INTERNAL_SRGB8_ALPHA8_ASTC_8x5, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ASTC8X5_SRGB, + {INTERNAL_RGBA_ASTC_8x6, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ASTC8X6_UNORM, + {INTERNAL_SRGB8_ALPHA8_ASTC_8x6, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ASTC8X6_SRGB, + {INTERNAL_RGBA_ASTC_8x8, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ASTC8X8_UNORM, + {INTERNAL_SRGB8_ALPHA8_ASTC_8x8, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ASTC8X8_SRGB, + {INTERNAL_RGBA_ASTC_10x5, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ASTC10X5_UNORM, + {INTERNAL_SRGB8_ALPHA8_ASTC_10x5, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ASTC10X5_SRGB, + {INTERNAL_RGBA_ASTC_10x6, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ASTC10X6_UNORM, + {INTERNAL_SRGB8_ALPHA8_ASTC_10x6, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ASTC10X6_SRGB, + {INTERNAL_RGBA_ASTC_10x8, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ASTC10X8_UNORM, + {INTERNAL_SRGB8_ALPHA8_ASTC_10x8, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ASTC10X8_SRGB, + {INTERNAL_RGBA_ASTC_10x10, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ASTC10X10_UNORM, + {INTERNAL_SRGB8_ALPHA8_ASTC_10x10, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ASTC10X10_SRGB, + {INTERNAL_RGBA_ASTC_12x10, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ASTC12X10_UNORM, + {INTERNAL_SRGB8_ALPHA8_ASTC_12x10, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ASTC12X10_SRGB, + {INTERNAL_RGBA_ASTC_12x12, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ASTC12X12_UNORM, + {INTERNAL_SRGB8_ALPHA8_ASTC_12x12, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ASTC12X12_SRGB, + + {INTERNAL_RGB_PVRTC_4BPPV1, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGB_PVRTC1_8X8_UNORM_BLOCK32, + {INTERNAL_SRGB_PVRTC_2BPPV1, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGB_PVRTC1_8X8_SRGB_BLOCK32, + {INTERNAL_RGB_PVRTC_2BPPV1, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGB_PVRTC1_16X8_UNORM_BLOCK32, + {INTERNAL_SRGB_PVRTC_4BPPV1, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGB_PVRTC1_16X8_SRGB_BLOCK32, + {INTERNAL_RGBA_PVRTC_4BPPV1, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_PVRTC1_8X8_UNORM_BLOCK32, + {INTERNAL_SRGB_ALPHA_PVRTC_2BPPV1, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_PVRTC1_8X8_SRGB_BLOCK32, + {INTERNAL_RGBA_PVRTC_2BPPV1, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_PVRTC1_16X8_UNORM_BLOCK32, + {INTERNAL_SRGB_ALPHA_PVRTC_4BPPV1, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_PVRTC1_16X8_SRGB_BLOCK32, + {INTERNAL_RGBA_PVRTC_4BPPV2, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_PVRTC2_4X4_UNORM_BLOCK8, + {INTERNAL_SRGB_ALPHA_PVRTC_4BPPV2, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_PVRTC2_4X4_SRGB_BLOCK8, + {INTERNAL_RGBA_PVRTC_2BPPV2, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_PVRTC2_8X4_UNORM_BLOCK8, + {INTERNAL_SRGB_ALPHA_PVRTC_2BPPV2, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_PVRTC2_8X4_SRGB_BLOCK8, + + {INTERNAL_RGB_ETC, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGB_ETC_UNORM_BLOCK8, + {INTERNAL_ATC_RGB, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGB_ATC_UNORM_BLOCK8, + {INTERNAL_ATC_RGBA_EXPLICIT_ALPHA, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ATCA_UNORM_BLOCK16, + {INTERNAL_ATC_RGBA_INTERPOLATED_ALPHA, EXTERNAL_NONE, TYPE_NONE, 0}, //FORMAT_RGBA_ATCI_UNORM_BLOCK16, + + {InternalLuminance8, ExternalLuminance, TYPE_U8, 0}, //FORMAT_L8_UNORM_PACK8, + {InternalAlpha8, ExternalAlpha, TYPE_U8, 0}, //FORMAT_A8_UNORM_PACK8, + {InternalLuminanceAlpha8, ExternalLuminanceAlpha, TYPE_U8, 0}, //FORMAT_LA8_UNORM_PACK8, + {InternalLuminance16, ExternalLuminance, TYPE_U16, 0}, //FORMAT_L16_UNORM_PACK16, + {InternalAlpha16, ExternalAlpha, TYPE_U16, 0}, //FORMAT_A16_UNORM_PACK16, + {InternalLuminanceAlpha16, ExternalLuminanceAlpha, TYPE_U16, 0}, //FORMAT_LA16_UNORM_PACK16, + + {INTERNAL_RGB8_UNORM, ExternalBGRA, TYPE_U8, 0}, //FORMAT_BGRX8_UNORM, + {INTERNAL_SRGB8, ExternalBGRA, TYPE_U8, 0}, //FORMAT_BGRX8_SRGB, + + {INTERNAL_RG3B2, EXTERNAL_RGB, TYPE_UINT8_RG3B2_REV, 0}, //FORMAT_RG3B2_UNORM, }; static_assert(sizeof(Table) / sizeof(Table[0]) == FORMAT_COUNT, "GLI error: format descriptor list doesn't match number of supported formats"); - std::copy(&Table[0], &Table[0] + FORMAT_COUNT, this->Translation.begin()); + std::copy(&Table[0], &Table[0] + FORMAT_COUNT, this->FormatDesc.begin()); } - inline gl::target const & gl::translate(gli::target Target) const + inline gl::target const& gl::translate(gli::target Target) const { static gl::target const Table[] = { @@ -225,33 +313,54 @@ namespace gli gl::TARGET_2D, gl::TARGET_2D_ARRAY, gl::TARGET_3D, + gl::TARGET_RECT, + gl::TARGET_RECT_ARRAY, gl::TARGET_CUBE, gl::TARGET_CUBE_ARRAY }; - - static_assert(sizeof(Table) / sizeof(Table[0]) == TARGET_COUNT, "GLI error: format descriptor list doesn't match number of supported formats"); + static_assert(sizeof(Table) / sizeof(Table[0]) == TARGET_COUNT, "GLI error: target descriptor list doesn't match number of supported targets"); return Table[Target]; } - inline gl::format const & gl::translate(gli::format Format) const + inline gl::format gl::translate(gli::format Format, gli::swizzles const& Swizzles) const { - return this->Translation[Format]; + GLI_ASSERT(Format >= FORMAT_FIRST && Format <= FORMAT_LAST); + + gl::format_desc const& FormatDesc = this->FormatDesc[Format - FORMAT_FIRST]; + + gl::format FormatGL; + FormatGL.Internal = FormatDesc.Internal; + FormatGL.External = FormatDesc.External; + FormatGL.Type = FormatDesc.Type; + FormatGL.Swizzles = this->compute_swizzle(FormatDesc, Swizzles); + return FormatGL; } - inline gli::format gl::find(gl::internalFormat InternalFormat, gl::externalFormat ExternalFormat, gl::typeFormat Type) + inline gli::format gl::find(gl::internal_format InternalFormat, gl::external_format ExternalFormat, gl::type_format Type) { - for (int FormatIndex = 0; FormatIndex < FORMAT_COUNT; ++FormatIndex) + for(int FormatIndex = FORMAT_FIRST; FormatIndex <= FORMAT_LAST; ++FormatIndex) { - if (this->Translation[FormatIndex].Internal != InternalFormat) + std::size_t const Index = FormatIndex - FORMAT_FIRST; + if (this->FormatDesc[Index].Internal != InternalFormat) continue; - if (this->Translation[FormatIndex].External != ExternalFormat) + if (this->FormatDesc[Index].External != ExternalFormat) continue; - if (this->Translation[FormatIndex].Type != Type) + if (this->FormatDesc[Index].Type != Type) continue; + return static_cast(FormatIndex); } return static_cast(FORMAT_INVALID); } + inline gl::swizzles gl::compute_swizzle(format_desc const& FormatDesc, gli::swizzles const& Swizzles) const + { + if (!this->has_swizzle(this->Profile)) + return swizzles(gl::SWIZZLE_RED, gl::SWIZZLE_GREEN, gl::SWIZZLE_BLUE, gl::SWIZZLE_ALPHA); + + bool const IsExternalBGRA = ((FormatDesc.Properties & detail::FORMAT_PROPERTY_BGRA_FORMAT_BIT) && !has_swizzle(this->Profile)) || (FormatDesc.Properties & detail::FORMAT_PROPERTY_BGRA_TYPE_BIT); + + return detail::translate(IsExternalBGRA ? gli::swizzles(Swizzles.b, Swizzles.g, Swizzles.r, Swizzles.a) : Swizzles); + } }//namespace gli diff --git a/external/gli/gli/core/image.inl b/external/gli/gli/core/image.inl index f28e9735..595a6d9b 100644 --- a/external/gli/gli/core/image.inl +++ b/external/gli/gli/core/image.inl @@ -1,108 +1,80 @@ -/////////////////////////////////////////////////////////////////////////////////// -/// OpenGL Image (gli.g-truc.net) -/// -/// Copyright (c) 2008 - 2015 G-Truc Creation (www.g-truc.net) -/// Permission is hereby granted, free of charge, to any person obtaining a copy -/// of this software and associated documentation files (the "Software"), to deal -/// in the Software without restriction, including without limitation the rights -/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -/// copies of the Software, and to permit persons to whom the Software is -/// furnished to do so, subject to the following conditions: -/// -/// The above copyright notice and this permission notice shall be included in -/// all copies or substantial portions of the Software. -/// -/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -/// THE SOFTWARE. -/// -/// @ref core -/// @file gli/core/image.inl -/// @date 2011-10-06 / 2013-01-12 -/// @author Christophe Riccio -/////////////////////////////////////////////////////////////////////////////////// - namespace gli{ namespace detail { - inline size_t texelLinearAdressing + inline size_t texel_linear_aAdressing ( - dim1_t const & Dimensions, - dim1_t const & TexelCoord + extent1d const& Extent, + extent1d const& TexelCoord ) { - assert(glm::all(glm::lessThan(TexelCoord, Dimensions))); + GLI_ASSERT(glm::all(glm::lessThan(TexelCoord, Extent))); + + return static_cast(TexelCoord.x); + } + + inline size_t texel_linear_adressing + ( + extent2d const& Extent, + extent2d const& TexelCoord + ) + { + GLI_ASSERT(TexelCoord.x < Extent.x); + GLI_ASSERT(TexelCoord.y < Extent.y); + + return static_cast(TexelCoord.x + Extent.x * TexelCoord.y); + } + + inline size_t texel_linear_adressing + ( + extent3d const& Extent, + extent3d const& TexelCoord + ) + { + GLI_ASSERT(TexelCoord.x < Extent.x); + GLI_ASSERT(TexelCoord.y < Extent.y); + GLI_ASSERT(TexelCoord.z < Extent.z); + + return static_cast(TexelCoord.x + Extent.x * (TexelCoord.y + Extent.y * TexelCoord.z)); + } + + inline size_t texel_morton_adressing + ( + extent1d const& Extent, + extent1d const& TexelCoord + ) + { + GLI_ASSERT(TexelCoord.x < Extent.x); return TexelCoord.x; } - inline size_t texelLinearAdressing + inline size_t texel_morton_adressing ( - dim2_t const & Dimensions, - dim2_t const & TexelCoord + extent2d const& Extent, + extent2d const& TexelCoord ) { - assert(TexelCoord.x < Dimensions.x); - assert(TexelCoord.y < Dimensions.y); - - return TexelCoord.x + Dimensions.x * TexelCoord.y; - } - - inline size_t texelLinearAdressing - ( - dim3_t const & Dimensions, - dim3_t const & TexelCoord - ) - { - assert(TexelCoord.x < Dimensions.x); - assert(TexelCoord.y < Dimensions.y); - assert(TexelCoord.z < Dimensions.z); - - return TexelCoord.x + Dimensions.x * (TexelCoord.y + Dimensions.y * TexelCoord.z); - } - - inline size_t texelMortonAdressing - ( - dim1_t const & Dimensions, - dim1_t const & TexelCoord - ) - { - assert(TexelCoord.x < Dimensions.x); - - return TexelCoord.x; - } - - inline size_t texelMortonAdressing - ( - dim2_t const & Dimensions, - dim2_t const & TexelCoord - ) - { - assert(TexelCoord.x < Dimensions.x && TexelCoord.x < std::numeric_limits::max()); - assert(TexelCoord.y < Dimensions.y && TexelCoord.y < std::numeric_limits::max()); + GLI_ASSERT(TexelCoord.x < Extent.x && TexelCoord.x >= 0 && TexelCoord.x < std::numeric_limits::max()); + GLI_ASSERT(TexelCoord.y < Extent.y && TexelCoord.y >= 0 && TexelCoord.y < std::numeric_limits::max()); glm::u32vec2 const Input(TexelCoord); - return glm::bitfieldInterleave(Input.x, Input.y); + return static_cast(glm::bitfieldInterleave(Input.x, Input.y)); } - inline size_t texelMortonAdressing + inline size_t texel_morton_adressing ( - dim3_t const & Dimensions, - dim3_t const & TexelCoord + extent3d const& Extent, + extent3d const& TexelCoord ) { - assert(TexelCoord.x < Dimensions.x); - assert(TexelCoord.y < Dimensions.y); - assert(TexelCoord.z < Dimensions.z); + GLI_ASSERT(TexelCoord.x < Extent.x); + GLI_ASSERT(TexelCoord.y < Extent.y); + GLI_ASSERT(TexelCoord.z < Extent.z); glm::u32vec3 const Input(TexelCoord); - return glm::bitfieldInterleave(Input.x, Input.y, Input.z); + return static_cast(glm::bitfieldInterleave(Input.x, Input.y, Input.z)); } }//namespace detail @@ -116,9 +88,9 @@ namespace detail inline image::image ( format_type Format, - dim_type const & Dimensions + extent_type const& Extent ) - : Storage(std::make_shared(Format, Dimensions, 1, 1, 1)) + : Storage(std::make_shared(Format, Extent, 1, 1, 1)) , Format(Format) , BaseLevel(0) , Data(Storage->data()) @@ -127,7 +99,7 @@ namespace detail inline image::image ( - std::shared_ptr Storage, + std::shared_ptr Storage, format_type Format, size_type BaseLayer, size_type BaseFace, @@ -151,7 +123,7 @@ namespace detail , Data(Image.Data) , Size(Image.Size) { - assert(block_size(Format) == block_size(Image.format())); + GLI_ASSERT(block_size(Format) == block_size(Image.format())); } inline bool image::empty() const @@ -164,7 +136,7 @@ namespace detail inline image::size_type image::size() const { - assert(!this->empty()); + GLI_ASSERT(!this->empty()); return this->Size; } @@ -172,7 +144,7 @@ namespace detail template inline image::size_type image::size() const { - assert(sizeof(genType) <= this->Storage->block_size()); + GLI_ASSERT(sizeof(genType) <= this->Storage->block_size()); return this->size() / sizeof(genType); } @@ -182,97 +154,98 @@ namespace detail return this->Format; } - inline image::dim_type image::dimensions() const + inline image::extent_type image::extent() const { - assert(!this->empty()); + GLI_ASSERT(!this->empty()); - return this->Storage->dimensions(this->BaseLevel); + storage_linear::extent_type const& SrcExtent = this->Storage->extent(this->BaseLevel); + storage_linear::extent_type const& DstExtent = SrcExtent * block_extent(this->format()) / this->Storage->block_extent(); - //return this->Storage->block_count(this->BaseLevel) * block_dimensions(this->format()); + return glm::max(DstExtent, storage_linear::extent_type(1)); } - inline void * image::data() + inline void* image::data() { - assert(!this->empty()); + GLI_ASSERT(!this->empty()); return this->Data; } - inline void const * image::data() const + inline void const* image::data() const { - assert(!this->empty()); + GLI_ASSERT(!this->empty()); return this->Data; } template - inline genType * image::data() + inline genType* image::data() { - assert(!this->empty()); - assert(this->Storage->block_size() >= sizeof(genType)); + GLI_ASSERT(!this->empty()); + GLI_ASSERT(this->Storage->block_size() >= sizeof(genType)); return reinterpret_cast(this->data()); } template - inline genType const * image::data() const + inline genType const* image::data() const { - assert(!this->empty()); - assert(this->Storage->block_size() >= sizeof(genType)); + GLI_ASSERT(!this->empty()); + GLI_ASSERT(this->Storage->block_size() >= sizeof(genType)); return reinterpret_cast(this->data()); } inline void image::clear() { - assert(!this->empty()); + GLI_ASSERT(!this->empty()); memset(this->data(), 0, this->size()); } template - inline void image::clear(genType const & Texel) + inline void image::clear(genType const& Texel) { - assert(!this->empty()); - assert(this->Storage->block_size() == sizeof(genType)); + GLI_ASSERT(!this->empty()); + GLI_ASSERT(this->Storage->block_size() == sizeof(genType)); for(size_type TexelIndex = 0; TexelIndex < this->size(); ++TexelIndex) *(this->data() + TexelIndex) = Texel; } - inline image::data_type * image::compute_data(size_type BaseLayer, size_type BaseFace, size_type BaseLevel) + inline image::data_type* image::compute_data(size_type BaseLayer, size_type BaseFace, size_type BaseLevel) { - size_type const Offset = this->Storage->offset(BaseLayer, BaseFace, BaseLevel); + size_type const BaseOffset = this->Storage->base_offset(BaseLayer, BaseFace, BaseLevel); - return this->Storage->data() + Offset; + return this->Storage->data() + BaseOffset; } inline image::size_type image::compute_size(size_type Level) const { - assert(!this->empty()); + GLI_ASSERT(!this->empty()); return this->Storage->level_size(Level); } template - genType image::load(dim_type const & TexelCoord) + genType image::load(extent_type const& TexelCoord) { - assert(!this->empty()); - assert(!is_compressed(this->format())); - assert(this->Storage->block_size() == sizeof(genType)); - assert(glm::all(glm::lessThan(TexelCoord, this->dimensions()))); + GLI_ASSERT(!this->empty()); + GLI_ASSERT(!is_compressed(this->format())); + GLI_ASSERT(this->Storage->block_size() == sizeof(genType)); + GLI_ASSERT(glm::all(glm::lessThan(TexelCoord, this->extent()))); - return *(this->data() + detail::texelLinearAdressing(this->dimensions(), TexelCoord)); + return *(this->data() + detail::texel_linear_adressing(this->extent(), TexelCoord)); } template - void image::store(dim_type const & TexelCoord, genType const & Data) + void image::store(extent_type const& TexelCoord, genType const& Data) { - assert(!this->empty()); - assert(!is_compressed(this->format())); - assert(this->Storage->block_size() == sizeof(genType)); - assert(glm::all(glm::lessThan(TexelCoord, this->dimensions()))); + GLI_ASSERT(!this->empty()); + GLI_ASSERT(!is_compressed(this->format())); + GLI_ASSERT(this->Storage->block_size() == sizeof(genType)); + GLI_ASSERT(glm::all(glm::lessThan(TexelCoord, this->extent()))); - *(this->data() + detail::texelLinearAdressing(this->dimensions(), TexelCoord)) = Data; + *(this->data() + detail::texel_linear_adressing(this->extent(), TexelCoord)) = Data; } }//namespace gli diff --git a/external/gli/gli/core/levels.inl b/external/gli/gli/core/levels.inl index 76cebc07..a2f49a6d 100644 --- a/external/gli/gli/core/levels.inl +++ b/external/gli/gli/core/levels.inl @@ -1,43 +1,24 @@ -/////////////////////////////////////////////////////////////////////////////////// -/// OpenGL Image (gli.g-truc.net) -/// -/// Copyright (c) 2008 - 2014 G-Truc Creation (www.g-truc.net) -/// Permission is hereby granted, free of charge, to any person obtaining a copy -/// of this software and associated documentation files (the "Software"), to deal -/// in the Software without restriction, including without limitation the rights -/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -/// copies of the Software, and to permit persons to whom the Software is -/// furnished to do so, subject to the following conditions: -/// -/// The above copyright notice and this permission notice shall be included in -/// all copies or substantial portions of the Software. -/// -/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -/// THE SOFTWARE. -/// -/// @ref core -/// @file gli/core/levels.inl -/// @date 2014-12-12 / 2014-12-12 -/// @author Christophe Riccio -/////////////////////////////////////////////////////////////////////////////////// - +#include +#define GLM_ENABLE_EXPERIMENTAL #include namespace gli { - template