Some code style refactoring #10

AnKi/Core/ConfigSet.cpp

@@ -170,7 +170,7 @@ Error ConfigSet::saveToFile(CString filename) const
 	File file;
 	ANKI_CHECK(file.open(filename, FileOpenFlag::WRITE));
 
-	ANKI_CHECK(file.writeTextf("%s\n<config>\n", XmlDocument::XML_HEADER.cstr()));
+	ANKI_CHECK(file.writeTextf("%s\n<config>\n", XmlDocument::kXmlHeader.cstr()));
 
 #define ANKI_NUMERIC_UINT(name) \
 	ANKI_CHECK(file.writeTextf("\t<!-- %s -->\n", m_##name.m_description.cstr())); \

AnKi/Gr/Format.defs.h

@@ -15,203 +15,203 @@
 // 9) Aspect
 
 // clang-format off
-//              Name                                 ID  CC  TS  BW  BH  BS  ST        ASPECT
-ANKI_FORMAT_DEF(R4G4_Unorm_Pack8,                     1,  2,  1,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R4G4B4A4_Unorm_Pack16,                2,  4,  2,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(B4G4R4A4_Unorm_Pack16,                3,  4,  2,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R5G6B5_Unorm_Pack16,                  4,  3,  2,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(B5G6R5_Unorm_Pack16,                  5,  3,  2,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R5G5B5A1_Unorm_Pack16,                6,  4,  2,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(B5G5R5A1_Unorm_Pack16,                7,  4,  2,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(A1R5G5B5_Unorm_Pack16,                8,  4,  2,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R8_Unorm,                             9,  1,  1,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R8_Snorm,                            10,  1,  1,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R8_Uscaled,                          11,  1,  1,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(R8_Sscaled,                          12,  1,  1,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(R8_Uint,                             13,  1,  1,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(R8_Sint,                             14,  1,  1,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(R8_SRGB,                             15,  1,  1,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R8G8_Unorm,                          16,  2,  2,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R8G8_Snorm,                          17,  2,  2,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R8G8_Uscaled,                        18,  2,  2,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(R8G8_Sscaled,                        19,  2,  2,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(R8G8_Uint,                           20,  2,  2,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(R8G8_Sint,                           21,  2,  2,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(R8G8_SRGB,                           22,  2,  2,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R8G8B8_Unorm,                        23,  3,  3,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R8G8B8_Snorm,                        24,  3,  3,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R8G8B8_Uscaled,                      25,  3,  3,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(R8G8B8_Sscaled,                      26,  3,  3,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(R8G8B8_Uint,                         27,  3,  3,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(R8G8B8_Sint,                         28,  3,  3,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(R8G8B8_SRGB,                         29,  3,  3,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(B8G8R8_Unorm,                        30,  3,  3,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(B8G8R8_Snorm,                        31,  3,  3,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(B8G8R8_Uscaled,                      32,  3,  3,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(B8G8R8_Sscaled,                      33,  3,  3,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(B8G8R8_Uint,                         34,  3,  3,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(B8G8R8_Sint,                         35,  3,  3,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(B8G8R8_SRGB,                         36,  3,  3,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R8G8B8A8_Unorm,                      37,  4,  4,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R8G8B8A8_Snorm,                      38,  4,  4,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R8G8B8A8_Uscaled,                    39,  4,  4,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(R8G8B8A8_Sscaled,                    40,  4,  4,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(R8G8B8A8_Uint,                       41,  4,  4,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(R8G8B8A8_Sint,                       42,  4,  4,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(R8G8B8A8_SRGB,                       43,  4,  4,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(B8G8R8A8_Unorm,                      44,  4,  4,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(B8G8R8A8_Snorm,                      45,  4,  4,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(B8G8R8A8_Uscaled,                    46,  4,  4,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(B8G8R8A8_Sscaled,                    47,  4,  4,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(B8G8R8A8_Uint,                       48,  4,  4,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(B8G8R8A8_Sint,                       49,  4,  4,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(B8G8R8A8_SRGB,                       50,  4,  4,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(A8B8G8R8_Unorm_Pack32,               51,  4,  4,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(A8B8G8R8_Snorm_Pack32,               52,  4,  4,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(A8B8G8R8_Uscaled_Pack32,             53,  4,  4,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(A8B8G8R8_Sscaled_Pack32,             54,  4,  4,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(A8B8G8R8_Uint_Pack32,                55,  4,  4,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(A8B8G8R8_Sint_Pack32,                56,  4,  4,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(A8B8G8R8_SRGB_Pack32,                57,  4,  4,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(A2R10G10B10_Unorm_Pack32,            58,  4,  4,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(A2R10G10B10_Snorm_Pack32,            59,  4,  4,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(A2R10G10B10_Uscaled_Pack32,          60,  4,  4,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(A2R10G10B10_Sscaled_Pack32,          61,  4,  4,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(A2R10G10B10_Uint_Pack32,             62,  4,  4,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(A2R10G10B10_Sint_Pack32,             63,  4,  4,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(A2B10G10R10_Unorm_Pack32,            64,  4,  4,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(A2B10G10R10_Snorm_Pack32,            65,  4,  4,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(A2B10G10R10_Uscaled_Pack32,          66,  4,  4,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(A2B10G10R10_Sscaled_Pack32,          67,  4,  4,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(A2B10G10R10_Uint_Pack32,             68,  4,  4,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(A2B10G10R10_Sint_Pack32,             69,  4,  4,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(R16_Unorm,                           70,  1,  2,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R16_Snorm,                           71,  1,  2,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R16_Uscaled,                         72,  1,  2,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(R16_Sscaled,                         73,  1,  2,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(R16_Uint,                            74,  1,  2,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(R16_Sint,                            75,  1,  2,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(R16_Sfloat,                          76,  1,  2,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R16G16_Unorm,                        77,  2,  4,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R16G16_Snorm,                        78,  2,  4,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R16G16_Uscaled,                      79,  2,  4,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(R16G16_Sscaled,                      80,  2,  4,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(R16G16_Uint,                         81,  2,  4,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(R16G16_Sint,                         82,  2,  4,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(R16G16_Sfloat,                       83,  2,  4,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R16G16B16_Unorm,                     84,  3,  6,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R16G16B16_Snorm,                     85,  3,  6,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R16G16B16_Uscaled,                   86,  3,  6,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(R16G16B16_Sscaled,                   87,  3,  6,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(R16G16B16_Uint,                      88,  3,  6,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(R16G16B16_Sint,                      89,  3,  6,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(R16G16B16_Sfloat,                    90,  3,  6,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R16G16B16A16_Unorm,                  91,  4,  8,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R16G16B16A16_Snorm,                  92,  4,  8,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R16G16B16A16_Uscaled,                93,  4,  8,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(R16G16B16A16_Sscaled,                94,  4,  8,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(R16G16B16A16_Uint,                   95,  4,  8,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(R16G16B16A16_Sint,                   96,  4,  8,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(R16G16B16A16_Sfloat,                 97,  4,  8,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R32_Uint,                            98,  1,  4,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(R32_Sint,                            99,  1,  4,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(R32_Sfloat,                         100,  1,  4,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R32G32_Uint,                        101,  2,  8,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(R32G32_Sint,                        102,  2,  8,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(R32G32_Sfloat,                      103,  2,  8,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R32G32B32_Uint,                     104,  3, 12,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(R32G32B32_Sint,                     105,  3, 12,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(R32G32B32_Sfloat,                   106,  3, 12,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R32G32B32A32_Uint,                  107,  4, 16,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(R32G32B32A32_Sint,                  108,  4, 16,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(R32G32B32A32_Sfloat,                109,  4, 16,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R64_Uint,                           110,  1,  8,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(R64_Sint,                           111,  1,  8,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(R64_Sfloat,                         112,  1,  8,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R64G64_Uint,                        113,  2, 16,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(R64G64_Sint,                        114,  2, 16,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(R64G64_Sfloat,                      115,  2, 16,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R64G64B64_Uint,                     116,  3, 24,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(R64G64B64_Sint,                     117,  3, 24,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(R64G64B64_Sfloat,                   118,  3, 24,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(R64G64B64A64_Uint,                  119,  4, 32,  0,  0,  0,  1,         None)
-ANKI_FORMAT_DEF(R64G64B64A64_Sint,                  120,  4, 32,  0,  0,  0,  2,         None)
-ANKI_FORMAT_DEF(R64G64B64A64_Sfloat,                121,  4, 32,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(B10G11R11_Ufloat_Pack32,            122,  3,  4,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(E5B9G9R9_Ufloat_Pack32,             123,  3,  4,  0,  0,  0,  0,         None)
-ANKI_FORMAT_DEF(D16_Unorm,                          124,  0,  2,  0,  0,  0,  0,        Depth)
-ANKI_FORMAT_DEF(X8_D24_Unorm_Pack32,                125,  0,  4,  0,  0,  0,  0,        Depth)
-ANKI_FORMAT_DEF(D32_Sfloat,                         126,  0,  4,  0,  0,  0,  0,        Depth)
-ANKI_FORMAT_DEF(S8_Uint,                            127,  0,  1,  0,  0,  0,  1,      Stencil)
-ANKI_FORMAT_DEF(D16_Unorm_S8_Uint,                  128,  0,  3,  0,  0,  0,  0, DepthStencil)
-ANKI_FORMAT_DEF(D24_Unorm_S8_Uint,                  129,  0,  4,  0,  0,  0,  0, DepthStencil)
-ANKI_FORMAT_DEF(D32_Sfloat_S8_Uint,                 130,  0,  0,  0,  0,  0,  0, DepthStencil)
-ANKI_FORMAT_DEF(BC1_RGB_Unorm_Block,                131,  3,  0,  4,  4,  8,  0,         None)
-ANKI_FORMAT_DEF(BC1_RGB_SRGB_Block,                 132,  3,  0,  4,  4,  8,  0,         None)
-ANKI_FORMAT_DEF(BC1_RGBA_Unorm_Block,               133,  4,  0,  4,  4,  8,  0,         None)
-ANKI_FORMAT_DEF(BC1_RGBA_SRGB_Block,                134,  4,  0,  4,  4,  8,  0,         None)
-ANKI_FORMAT_DEF(BC2_Unorm_Block,                    135,  4,  0,  4,  4, 16,  0,         None)
-ANKI_FORMAT_DEF(BC2_SRGB_Block,                     136,  4,  0,  4,  4, 16,  0,         None)
-ANKI_FORMAT_DEF(BC3_Unorm_Block,                    137,  4,  0,  4,  4, 16,  0,         None)
-ANKI_FORMAT_DEF(BC3_SRGB_Block,                     138,  4,  0,  4,  4, 16,  0,         None)
-ANKI_FORMAT_DEF(BC4_Unorm_Block,                    139,  1,  0,  4,  4,  8,  0,         None)
-ANKI_FORMAT_DEF(BC4_Snorm_Block,                    140,  1,  0,  4,  4,  8,  0,         None)
-ANKI_FORMAT_DEF(BC5_Unorm_Block,                    141,  2,  0,  4,  4, 16,  0,         None)
-ANKI_FORMAT_DEF(BC5_Snorm_Block,                    142,  2,  0,  4,  4, 16,  0,         None)
-ANKI_FORMAT_DEF(BC6H_Ufloat_Block,                  143,  3,  0,  4,  4, 16,  0,         None)
-ANKI_FORMAT_DEF(BC6H_Sfloat_Block,                  144,  3,  0,  4,  4, 16,  0,         None)
-ANKI_FORMAT_DEF(BC7_Unorm_Block,                    145,  4,  0,  4,  4, 16,  0,         None)
-ANKI_FORMAT_DEF(BC7_SRGB_Block,                     146,  4,  0,  4,  4, 16,  0,         None)
-ANKI_FORMAT_DEF(ETC2_R8G8B8_Unorm_Block,            147,  3,  0,  4,  4,  8,  0,         None)
-ANKI_FORMAT_DEF(ETC2_R8G8B8_SRGB_Block,             148,  3,  0,  4,  4,  8,  0,         None)
-ANKI_FORMAT_DEF(ETC2_R8G8B8A1_Unorm_Block,          149,  4,  0,  4,  4,  8,  0,         None)
-ANKI_FORMAT_DEF(ETC2_R8G8B8A1_SRGB_Block,           150,  4,  0,  4,  4,  8,  0,         None)
-ANKI_FORMAT_DEF(ETC2_R8G8B8A8_Unorm_Block,          151,  4,  0,  4,  4, 16,  0,         None)
-ANKI_FORMAT_DEF(ETC2_R8G8B8A8_SRGB_Block,           152,  4,  0,  4,  4, 16,  0,         None)
-ANKI_FORMAT_DEF(EAC_R11_Unorm_Block,                153,  1,  0,  4,  4,  8,  0,         None)
-ANKI_FORMAT_DEF(EAC_R11_Snorm_Block,                154,  1,  0,  4,  4,  8,  0,         None)
-ANKI_FORMAT_DEF(EAC_R11G11_Unorm_Block,             155,  2,  0,  4,  4, 16,  0,         None)
-ANKI_FORMAT_DEF(EAC_R11G11_Snorm_Block,             156,  2,  0,  4,  4, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_4x4_Unorm_Block,               157,  4,  0,  4,  4, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_4x4_SRGB_Block,                158,  4,  0,  4,  4, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_5x4_Unorm_Block,               159,  4,  0,  5,  4, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_5x4_SRGB_Block,                160,  4,  0,  5,  4, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_5x5_Unorm_Block,               161,  4,  0,  5,  5, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_5x5_SRGB_Block,                162,  4,  0,  5,  5, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_6x5_Unorm_Block,               163,  4,  0,  6,  5, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_6x5_SRGB_Block,                164,  4,  0,  6,  5, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_6x6_Unorm_Block,               165,  4,  0,  6,  6, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_6x6_SRGB_Block,                166,  4,  0,  6,  6, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_8x5_Unorm_Block,               167,  4,  0,  8,  5, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_8x5_SRGB_Block,                168,  4,  0,  8,  5, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_8x6_Unorm_Block,               169,  4,  0,  8,  6, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_8x6_SRGB_Block,                170,  4,  0,  8,  6, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_8x8_Unorm_Block,               171,  4,  0,  8,  8, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_8x8_SRGB_Block,                172,  4,  0,  8,  8, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_10x5_Unorm_Block,              173,  4,  0, 10,  5, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_10x5_SRGB_Block,               174,  4,  0, 10,  5, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_10x6_Unorm_Block,              175,  4,  0, 10,  6, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_10x6_SRGB_Block,               176,  4,  0, 10,  6, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_10x8_Unorm_Block,              177,  4,  0, 10,  8, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_10x8_SRGB_Block,               178,  4,  0, 10,  8, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_10x10_Unorm_Block,             179,  4,  0, 10, 10, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_10x10_SRGB_Block,              180,  4,  0, 10, 10, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_12x10_Unorm_Block,             181,  4,  0, 12, 10, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_12x10_SRGB_Block,              182,  4,  0, 12, 10, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_12x12_Unorm_Block,             183,  4,  0, 12, 12, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_12x12_SRGB_Block,              184,  4,  0, 12, 12, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_4x4_Sfloat_Block,       1000066000,  4,  0,  4,  4, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_5x4_Sfloat_Block,       1000066001,  4,  0,  5,  4, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_5x5_Sfloat_Block,       1000066002,  4,  0,  5,  5, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_6x5_Sfloat_Block,       1000066003,  4,  0,  6,  8, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_6x6_Sfloat_Block,       1000066004,  4,  0,  6,  6, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_8x5_Sfloat_Block,       1000066005,  4,  0,  8,  5, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_8x6_Sfloat_Block,       1000066006,  4,  0,  8,  6, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_8x8_Sfloat_Block,       1000066007,  4,  0,  8,  8, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_10x5_Sfloat_Block,      1000066008,  4,  0, 10,  5, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_10x6_Sfloat_Block,      1000066009,  4,  0, 10,  6, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_10x8_Sfloat_Block,      1000066010,  4,  0, 10,  8, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_10x10_Sfloat_Block,     1000066011,  4,  0, 10, 10, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_12x10_Sfloat_Block,     1000066012,  4,  0, 12, 10, 16,  0,         None)
-ANKI_FORMAT_DEF(ASTC_12x12_Sfloat_Block,     1000066013,  4,  0, 12, 12, 16,  0,         None)
+//              Name                                ID  CC  TS  BW  BH  BS  ST        ASPECT
+ANKI_FORMAT_DEF(R4G4UnormPack8,                      1,  2,  1,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R4G4B4A4UnormPack16,                 2,  4,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B4G4R4A4UnormPack16,                 3,  4,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R5G6B5UnormPack16,                   4,  3,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B5G6R5UnormPack16,                   5,  3,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R5G5B5A1UnormPack16,                 6,  4,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B5G5R5A1UnormPack16,                 7,  4,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(A1R5G5B5UnormPack16,                 8,  4,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8Unorm,                             9,  1,  1,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8Snorm,                            10,  1,  1,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8Uscaled,                          11,  1,  1,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R8Sscaled,                          12,  1,  1,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R8Uint,                             13,  1,  1,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R8Sint,                             14,  1,  1,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R8Srgb,                             15,  1,  1,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8G8Unorm,                          16,  2,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8G8Snorm,                          17,  2,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8G8Uscaled,                        18,  2,  2,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R8G8Sscaled,                        19,  2,  2,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R8G8Uint,                           20,  2,  2,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R8G8Sint,                           21,  2,  2,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R8G8Srgb,                           22,  2,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8G8B8Unorm,                        23,  3,  3,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8G8B8Snorm,                        24,  3,  3,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8G8B8Uscaled,                      25,  3,  3,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R8G8B8Sscaled,                      26,  3,  3,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R8G8B8Uint,                         27,  3,  3,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R8G8B8Sint,                         28,  3,  3,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R8G8B8Srgb,                         29,  3,  3,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B8G8R8Unorm,                        30,  3,  3,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B8G8R8Snorm,                        31,  3,  3,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B8G8R8Uscaled,                      32,  3,  3,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(B8G8R8Sscaled,                      33,  3,  3,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(B8G8R8Uint,                         34,  3,  3,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(B8G8R8Sint,                         35,  3,  3,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(B8G8R8Srgb,                         36,  3,  3,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8G8B8A8Unorm,                      37,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8G8B8A8Snorm,                      38,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R8G8B8A8Uscaled,                    39,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R8G8B8A8Sscaled,                    40,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R8G8B8A8Uint,                       41,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R8G8B8A8Sint,                       42,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R8G8B8A8Srgb,                       43,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B8G8R8A8Unorm,                      44,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B8G8R8A8Snorm,                      45,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B8G8R8A8Uscaled,                    46,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(B8G8R8A8Sscaled,                    47,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(B8G8R8A8Uint,                       48,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(B8G8R8A8Sint,                       49,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(B8G8R8A8Srgb,                       50,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(A8B8G8R8UnormPack32,                51,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(A8B8G8R8SnormPack32,                52,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(A8B8G8R8UscaledPack32,              53,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(A8B8G8R8SscaledPack32,              54,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(A8B8G8R8UintPack32,                 55,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(A8B8G8R8SintPack32,                 56,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(A8B8G8R8SrgbPack32,                 57,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(A2R10G10B10UnormPack32,             58,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(A2R10G10B10SnormPack32,             59,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(A2R10G10B10UscaledPack32,           60,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(A2R10G10B10SscaledPack32,           61,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(A2R10G10B10UintPack32,              62,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(A2R10G10B10SintPack32,              63,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(A2B10G10R10UnormPack32,             64,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(A2B10G10R10SnormPack32,             65,  4,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(A2B10G10R10UscaledPack32,           66,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(A2B10G10R10SscaledPack32,           67,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(A2B10G10R10UintPack32,              68,  4,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(A2B10G10R10SintPack32,              69,  4,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R16Unorm,                           70,  1,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16Snorm,                           71,  1,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16Uscaled,                         72,  1,  2,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R16Sscaled,                         73,  1,  2,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R16Uint,                            74,  1,  2,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R16Sint,                            75,  1,  2,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R16Sfloat,                          76,  1,  2,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16G16Unorm,                        77,  2,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16G16Snorm,                        78,  2,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16G16Uscaled,                      79,  2,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R16G16Sscaled,                      80,  2,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R16G16Uint,                         81,  2,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R16G16Sint,                         82,  2,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R16G16Sfloat,                       83,  2,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16G16B16Unorm,                     84,  3,  6,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16G16B16Snorm,                     85,  3,  6,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16G16B16Uscaled,                   86,  3,  6,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R16G16B16Sscaled,                   87,  3,  6,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R16G16B16Uint,                      88,  3,  6,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R16G16B16Sint,                      89,  3,  6,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R16G16B16Sfloat,                    90,  3,  6,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16G16B16A16Unorm,                  91,  4,  8,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16G16B16A16Snorm,                  92,  4,  8,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R16G16B16A16Uscaled,                93,  4,  8,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R16G16B16A16Sscaled,                94,  4,  8,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R16G16B16A16Uint,                   95,  4,  8,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R16G16B16A16Sint,                   96,  4,  8,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R16G16B16A16Sfloat,                 97,  4,  8,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R32Uint,                            98,  1,  4,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R32Sint,                            99,  1,  4,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R32Sfloat,                         100,  1,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R32G32Uint,                        101,  2,  8,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R32G32Sint,                        102,  2,  8,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R32G32Sfloat,                      103,  2,  8,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R32G32B32Uint,                     104,  3, 12,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R32G32B32Sint,                     105,  3, 12,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R32G32B32Sfloat,                   106,  3, 12,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R32G32B32A32Uint,                  107,  4, 16,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R32G32B32A32Sint,                  108,  4, 16,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R32G32B32A32Sfloat,                109,  4, 16,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R64Uint,                           110,  1,  8,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R64Sint,                           111,  1,  8,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R64Sfloat,                         112,  1,  8,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R64G64Uint,                        113,  2, 16,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R64G64Sint,                        114,  2, 16,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R64G64Sfloat,                      115,  2, 16,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R64G64B64Uint,                     116,  3, 24,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R64G64B64Sint,                     117,  3, 24,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R64G64B64Sfloat,                   118,  3, 24,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(R64G64B64A64Uint,                  119,  4, 32,  0,  0,  0,  1,         None)
+ANKI_FORMAT_DEF(R64G64B64A64Sint,                  120,  4, 32,  0,  0,  0,  2,         None)
+ANKI_FORMAT_DEF(R64G64B64A64Sfloat,                121,  4, 32,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(B10G11R11UfloatPack32,             122,  3,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(E5B9G9R9UfloatPack32,              123,  3,  4,  0,  0,  0,  0,         None)
+ANKI_FORMAT_DEF(D16Unorm,                          124,  0,  2,  0,  0,  0,  0,        Depth)
+ANKI_FORMAT_DEF(X8D24UnormPack32,                  125,  0,  4,  0,  0,  0,  0,        Depth)
+ANKI_FORMAT_DEF(D32Sfloat,                         126,  0,  4,  0,  0,  0,  0,        Depth)
+ANKI_FORMAT_DEF(S8Uint,                            127,  0,  1,  0,  0,  0,  1,      Stencil)
+ANKI_FORMAT_DEF(D16UnormS8Uint,                    128,  0,  3,  0,  0,  0,  0, DepthStencil)
+ANKI_FORMAT_DEF(D24UnormS8Uint,                    129,  0,  4,  0,  0,  0,  0, DepthStencil)
+ANKI_FORMAT_DEF(D32SfloatS8Uint,                   130,  0,  0,  0,  0,  0,  0, DepthStencil)
+ANKI_FORMAT_DEF(Bc1RgbUnormBlock,                  131,  3,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(Bc1RgbSrgbBlock,                   132,  3,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(Bc1RgbaUnormBlock,                 133,  4,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(Bc1RgbaSrgbBlock,                  134,  4,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(Bc2UnormBlock,                     135,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Bc2SrgbBlock,                      136,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Bc3UnormBlock,                     137,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Bc3SrgbBlock,                      138,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Bc4UnormBlock,                     139,  1,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(Bc4SnormBlock,                     140,  1,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(Bc5UnormBlock,                     141,  2,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Bc5SnormBlock,                     142,  2,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Bc6hUfloatBlock,                   143,  3,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Bc6hSfloatBlock,                   144,  3,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Bc7UnormBlock,                     145,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Bc7SrgbBlock,                      146,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Etc2R8G8B8UnormBlock,              147,  3,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(Etc2R8G8B8SrgbBlock,               148,  3,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(Etc2R8G8B8A1UnormBlock,            149,  4,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(Etc2R8G8B8A1SrgbBlock,             150,  4,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(Etc2R8G8B8A8UnormBlock,            151,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Etc2R8G8B8A8SrgbBlock,             152,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(EacR11UnormBlock,                  153,  1,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(EacR11SnormBlock,                  154,  1,  0,  4,  4,  8,  0,         None)
+ANKI_FORMAT_DEF(EacR11G11UnormBlock,               155,  2,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(EacR11G11SnormBlock,               156,  2,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc4x4UnormBlock,                 157,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc4x4SrgbBlock,                  158,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc5x4UnormBlock,                 159,  4,  0,  5,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc5x4SrgbBlock,                  160,  4,  0,  5,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc5x5UnormBlock,                 161,  4,  0,  5,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc5x5SrgbBlock,                  162,  4,  0,  5,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc6x5UnormBlock,                 163,  4,  0,  6,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc6x5SrgbBlock,                  164,  4,  0,  6,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc6x6UnormBlock,                 165,  4,  0,  6,  6, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc6x6SrgbBlock,                  166,  4,  0,  6,  6, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc8x5UnormBlock,                 167,  4,  0,  8,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc8x5SrgbBlock,                  168,  4,  0,  8,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc8x6UnormBlock,                 169,  4,  0,  8,  6, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc8x6SrgbBlock,                  170,  4,  0,  8,  6, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc8x8UnormBlock,                 171,  4,  0,  8,  8, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc8x8SrgbBlock,                  172,  4,  0,  8,  8, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc10x5UnormBlock,                173,  4,  0, 10,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc10x5SrgbBlock,                 174,  4,  0, 10,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc10x6UnormBlock,                175,  4,  0, 10,  6, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc10x6SrgbBlock,                 176,  4,  0, 10,  6, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc10x8UnormBlock,                177,  4,  0, 10,  8, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc10x8SrgbBlock,                 178,  4,  0, 10,  8, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc10x10UnormBlock,               179,  4,  0, 10, 10, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc10x10SrgbBlock,                180,  4,  0, 10, 10, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc12x10UnormBlock,               181,  4,  0, 12, 10, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc12x10SrgbBlock,                182,  4,  0, 12, 10, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc12x12UnormBlock,               183,  4,  0, 12, 12, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc12x12SrgbBlock,                184,  4,  0, 12, 12, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc4x4SfloatBlock,         1000066000,  4,  0,  4,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc5x4SfloatBlock,         1000066001,  4,  0,  5,  4, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc5x5SfloatBlock,         1000066002,  4,  0,  5,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc6x5SfloatBlock,         1000066003,  4,  0,  6,  8, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc6x6SfloatBlock,         1000066004,  4,  0,  6,  6, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc8x5SfloatBlock,         1000066005,  4,  0,  8,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc8x6SfloatBlock,         1000066006,  4,  0,  8,  6, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc8x8SfloatBlock,         1000066007,  4,  0,  8,  8, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc10x5SfloatBlock,        1000066008,  4,  0, 10,  5, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc10x6SfloatBlock,        1000066009,  4,  0, 10,  6, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc10x8SfloatBlock,        1000066010,  4,  0, 10,  8, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc10x10SfloatBlock,       1000066011,  4,  0, 10, 10, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc12x10SfloatBlock,       1000066012,  4,  0, 12, 10, 16,  0,         None)
+ANKI_FORMAT_DEF(Astc12x12SfloatBlock,       1000066013,  4,  0, 12, 12, 16,  0,         None)
 // clang-format on

AnKi/Gr/Gl/Common.cpp

@@ -129,17 +129,17 @@ void convertVertexFormat(Format fmt, U& compCount, GLenum& type, Bool& normalize
 {
 	switch(fmt)
 	{
-	case Format::kR32_Sfloat:
+	case Format::kR32Sfloat:
 		compCount = 1;
 		type = GL_FLOAT;
 		normalized = false;
 		break;
-	case Format::kR32G32_Sfloat:
+	case Format::kR32G32Sfloat:
 		compCount = 2;
 		type = GL_FLOAT;
 		normalized = false;
 		break;
-	case Format::kR32G32B32_Sfloat:
+	case Format::kR32G32B32Sfloat:
 		compCount = 3;
 		type = GL_FLOAT;
 		normalized = false;
@@ -179,7 +179,7 @@ void convertVertexFormat(Format fmt, U& compCount, GLenum& type, Bool& normalize
 		type = GL_INT_2_10_10_10_REV;
 		normalized = true;
 		break;
-	case Format::kR8G8B8A8_Unorm:
+	case Format::kR8G8B8A8Unorm:
 		compCount = 4;
 		type = GL_UNSIGNED_BYTE;
 		normalized = true;
@@ -336,7 +336,7 @@ void convertTextureInformation(Format pf, Bool& compressed, GLenum& format, GLen
 		internalFormat = GL_RGB8I;
 		type = GL_RGB_INTEGER;
 		break;
-	case Format::kR8G8B8A8_Unorm:
+	case Format::kR8G8B8A8Unorm:
 		format = GL_RGBA;
 		internalFormat = GL_RGBA8;
 		type = GL_UNSIGNED_BYTE;
@@ -391,7 +391,7 @@ void convertTextureInformation(Format pf, Bool& compressed, GLenum& format, GLen
 		internalFormat = GL_RGBA16UI;
 		type = GL_UNSIGNED_SHORT;
 		break;
-	case Format::kR32_Sfloat:
+	case Format::kR32Sfloat:
 		format = GL_R;
 		internalFormat = GL_R32F;
 		type = GL_FLOAT;
@@ -401,17 +401,17 @@ void convertTextureInformation(Format pf, Bool& compressed, GLenum& format, GLen
 		internalFormat = GL_R32UI;
 		type = GL_UNSIGNED_INT;
 		break;
-	case Format::kR32G32_Sfloat:
+	case Format::kR32G32Sfloat:
 		format = GL_RG;
 		internalFormat = GL_RG32F;
 		type = GL_FLOAT;
 		break;
-	case Format::kR32G32_Uint:
+	case Format::kR32G32Uint:
 		format = GL_RG_INTEGER;
 		internalFormat = GL_RG32UI;
 		type = GL_UNSIGNED_INT;
 		break;
-	case Format::kR32G32B32_Sfloat:
+	case Format::kR32G32B32Sfloat:
 		format = GL_RGB;
 		internalFormat = GL_RGB32F;
 		type = GL_FLOAT;

AnKi/Gr/Gl/GrManagerImpl.cpp

@@ -81,7 +81,7 @@ void GrManagerImpl::initFakeDefaultFb(GrManagerInitInfo& init)
 	TextureInitInfo texinit("FB Tex");
 	texinit.m_width = defaultFbWidth;
 	texinit.m_height = defaultFbHeight;
-	texinit.m_format = Format::kR8G8B8A8_Unorm;
+	texinit.m_format = Format::kR8G8B8A8Unorm;
 	texinit.m_usage =
 		TextureUsageBit::kFramebufferWrite | TextureUsageBit::kImageComputeWrite | TextureUsageBit::kPresent;
 	m_fakeFbTex = newTexture(texinit);

AnKi/Importer/GltfImporter.cpp

@@ -7,6 +7,7 @@
 #include <AnKi/Util/System.h>
 #include <AnKi/Util/ThreadHive.h>
 #include <AnKi/Util/StringList.h>
+#include <AnKi/Util/Xml.h>
 
 #if ANKI_COMPILER_GCC_COMPATIBLE
 #	pragma GCC diagnostic push
@@ -148,8 +149,6 @@ static Bool stringsExist(const HashMapAuto<CString, StringAuto>& map, const std:
 	return false;
 }
 
-const char* GltfImporter::XML_HEADER = R"(<?xml version="1.0" encoding="UTF-8" ?>)";
-
 GltfImporter::GltfImporter(GenericMemoryPoolAllocator<U8> alloc)
 	: m_alloc(alloc)
 {
@@ -920,7 +919,7 @@ Error GltfImporter::writeSkeleton(const cgltf_skin& skin)
 	File file;
 	ANKI_CHECK(file.open(fname.toCString(), FileOpenFlag::WRITE));
 
-	ANKI_CHECK(file.writeTextf("%s\n<skeleton>\n", XML_HEADER));
+	ANKI_CHECK(file.writeTextf("%s\n<skeleton>\n", XmlDocument::kXmlHeader.cstr()));
 	ANKI_CHECK(file.writeTextf("\t<bones>\n"));
 
 	for(U32 i = 0; i < skin.joints_count; ++i)

AnKi/Importer/GltfImporter.h

@@ -59,8 +59,6 @@ private:
 	};
 
 	// Data
-	static const char* XML_HEADER;
-
 	GenericMemoryPoolAllocator<U8> m_alloc;
 
 	StringAuto m_inputFname = {m_alloc};

AnKi/Importer/GltfImporterAnimation.cpp

@@ -4,6 +4,7 @@
 // http://www.anki3d.org/LICENSE
 
 #include <AnKi/Importer/GltfImporter.h>
+#include <AnKi/Util/Xml.h>
 
 namespace anki {
 
@@ -294,7 +295,7 @@ Error GltfImporter::writeAnimation(const cgltf_animation& anim)
 	File file;
 	ANKI_CHECK(file.open(fname.toCString(), FileOpenFlag::WRITE));
 
-	ANKI_CHECK(file.writeTextf("%s\n<animation>\n", XML_HEADER));
+	ANKI_CHECK(file.writeTextf("%s\n<animation>\n", XmlDocument::kXmlHeader.cstr()));
 	ANKI_CHECK(file.writeText("\t<channels>\n"));
 
 	for(const GltfAnimChannel& channel : tempChannels)

AnKi/Importer/GltfImporterMaterial.cpp

@@ -6,10 +6,11 @@
 #include <AnKi/Importer/GltfImporter.h>
 #include <AnKi/Resource/ImageLoader.h>
 #include <AnKi/Util/WeakArray.h>
+#include <AnKi/Util/Xml.h>
 
 namespace anki {
 
-const char* MATERIAL_TEMPLATE = R"(<!-- This file is auto generated by ImporterMaterial.cpp -->
+inline constexpr Char* kMaterialTemplate = R"(<!-- This file is auto generated by ImporterMaterial.cpp -->
 <material shadows="1">
 	<shaderPrograms>
 		<shaderProgram name="GBufferGeneric">
@@ -41,7 +42,7 @@ const char* MATERIAL_TEMPLATE = R"(<!-- This file is auto generated by ImporterM
 </material>
 )";
 
-const char* RT_MATERIAL_TEMPLATE = R"(
+inline constexpr Char* kRtMaterialTemplate = R"(
 		<shaderProgram name="RtShadowsHit">
 			<mutation>
 				<mutator name="ALPHA_TEXTURE" value="0"/>
@@ -62,8 +63,8 @@ static Error findConstantColorsInImage(CString fname, Vec4& constantColor, Gener
 {
 	ImageLoader iloader(alloc);
 	ANKI_CHECK(iloader.load(fname));
-	ANKI_ASSERT(iloader.getColorFormat() == ImageBinaryColorFormat::RGBA8);
-	ANKI_ASSERT(iloader.getCompression() == ImageBinaryDataCompression::RAW);
+	ANKI_ASSERT(iloader.getColorFormat() == ImageBinaryColorFormat::kRgba8);
+	ANKI_ASSERT(iloader.getCompression() == ImageBinaryDataCompression::kRaw);
 
 	const U8Vec4* data = reinterpret_cast<const U8Vec4*>(&iloader.getSurface(0, 0, 0).m_data[0]);
 	ConstWeakArray<U8Vec4> pixels(data, iloader.getWidth() * iloader.getHeight());
@@ -113,13 +114,13 @@ Error GltfImporter::writeMaterial(const cgltf_material& mtl, Bool writeRayTracin
 	ANKI_CHECK(getExtras(mtl.extras, extras));
 
 	StringAuto xml(m_alloc);
-	xml.append(XML_HEADER);
+	xml.append(XmlDocument::kXmlHeader);
 	xml.append("\n");
-	xml.append(MATERIAL_TEMPLATE);
+	xml.append(kMaterialTemplate);
 
 	if(writeRayTracing)
 	{
-		xml.replaceAll("%rayTracing%", RT_MATERIAL_TEMPLATE);
+		xml.replaceAll("%rayTracing%", kRtMaterialTemplate);
 	}
 
 	// Diffuse

AnKi/Importer/GltfImporterMesh.cpp

@@ -641,28 +641,28 @@ Error GltfImporter::writeMesh(const cgltf_mesh& mesh, U32 lod, F32 decimateFacto
 		// Positions
 		MeshBinaryVertexAttribute& posa = header.m_vertexAttributes[VertexAttributeId::POSITION];
 		posa.m_bufferBinding = 0;
-		posa.m_format = Format::kR32G32B32_Sfloat;
+		posa.m_format = Format::kR32G32B32Sfloat;
 		posa.m_relativeOffset = 0;
 		posa.m_scale = 1.0f;
 
 		// Normals
 		MeshBinaryVertexAttribute& na = header.m_vertexAttributes[VertexAttributeId::NORMAL];
 		na.m_bufferBinding = 1;
-		na.m_format = Format::kA2B10G10R10_Snorm_Pack32;
+		na.m_format = Format::kA2B10G10R10SnormPack32;
 		na.m_relativeOffset = 0;
 		na.m_scale = 1.0f;
 
 		// Tangents
 		MeshBinaryVertexAttribute& ta = header.m_vertexAttributes[VertexAttributeId::TANGENT];
 		ta.m_bufferBinding = 1;
-		ta.m_format = Format::kA2B10G10R10_Snorm_Pack32;
+		ta.m_format = Format::kA2B10G10R10SnormPack32;
 		ta.m_relativeOffset = sizeof(U32);
 		ta.m_scale = 1.0f;
 
 		// UVs
 		MeshBinaryVertexAttribute& uva = header.m_vertexAttributes[VertexAttributeId::UV0];
 		uva.m_bufferBinding = 1;
-		uva.m_format = Format::kR32G32_Sfloat;
+		uva.m_format = Format::kR32G32Sfloat;
 		uva.m_relativeOffset = sizeof(U32) * 2;
 		uva.m_scale = 1.0f;
 
@@ -671,13 +671,13 @@ Error GltfImporter::writeMesh(const cgltf_mesh& mesh, U32 lod, F32 decimateFacto
 		{
 			MeshBinaryVertexAttribute& bidxa = header.m_vertexAttributes[VertexAttributeId::BONE_INDICES];
 			bidxa.m_bufferBinding = 2;
-			bidxa.m_format = Format::kR8G8B8A8_Uint;
+			bidxa.m_format = Format::kR8G8B8A8Uint;
 			bidxa.m_relativeOffset = 0;
 			bidxa.m_scale = 1.0f;
 
 			MeshBinaryVertexAttribute& wa = header.m_vertexAttributes[VertexAttributeId::BONE_WEIGHTS];
 			wa.m_bufferBinding = 2;
-			wa.m_format = Format::kR8G8B8A8_Unorm;
+			wa.m_format = Format::kR8G8B8A8Unorm;
 			wa.m_relativeOffset = sizeof(U8Vec4);
 			wa.m_scale = 1.0f;
 		}

AnKi/Importer/ImageImporter.cpp

@@ -179,23 +179,23 @@ static Error checkConfig(const ImageImporterConfig& config)
 	}
 
 	// Type
-	ANKI_CFG_ASSERT(config.m_type != ImageBinaryType::NONE, "Wrong image type");
-	ANKI_CFG_ASSERT(config.m_inputFilenames.getSize() == 1 || config.m_type != ImageBinaryType::_2D,
+	ANKI_CFG_ASSERT(config.m_type != ImageBinaryType::kNone, "Wrong image type");
+	ANKI_CFG_ASSERT(config.m_inputFilenames.getSize() == 1 || config.m_type != ImageBinaryType::k2D,
 					"2D images require only one input image");
-	ANKI_CFG_ASSERT(config.m_inputFilenames.getSize() != 1 || config.m_type != ImageBinaryType::_2D_ARRAY,
+	ANKI_CFG_ASSERT(config.m_inputFilenames.getSize() != 1 || config.m_type != ImageBinaryType::k2DArray,
 					"2D array images require more than one input image");
-	ANKI_CFG_ASSERT(config.m_inputFilenames.getSize() != 1 || config.m_type != ImageBinaryType::_3D,
+	ANKI_CFG_ASSERT(config.m_inputFilenames.getSize() != 1 || config.m_type != ImageBinaryType::k3D,
 					"3D images require more than one input image");
-	ANKI_CFG_ASSERT(config.m_inputFilenames.getSize() != 6 || config.m_type != ImageBinaryType::CUBE,
+	ANKI_CFG_ASSERT(config.m_inputFilenames.getSize() != 6 || config.m_type != ImageBinaryType::kCube,
 					"Cube images require 6 input images");
 
 	// Compressions
-	ANKI_CFG_ASSERT(config.m_compressions != ImageBinaryDataCompression::NONE, "Missing output compressions");
-	ANKI_CFG_ASSERT(config.m_compressions == ImageBinaryDataCompression::RAW || config.m_type != ImageBinaryType::_3D,
+	ANKI_CFG_ASSERT(config.m_compressions != ImageBinaryDataCompression::kNone, "Missing output compressions");
+	ANKI_CFG_ASSERT(config.m_compressions == ImageBinaryDataCompression::kRaw || config.m_type != ImageBinaryType::k3D,
 					"Can't compress 3D textures");
 
 	// ASTC
-	if(!!(config.m_compressions & ImageBinaryDataCompression::ASTC))
+	if(!!(config.m_compressions & ImageBinaryDataCompression::kAstc))
 	{
 		ANKI_CFG_ASSERT(config.m_astcBlockSize == UVec2(4u) || config.m_astcBlockSize == UVec2(8u),
 						"Incorrect ASTC block sizes");
@@ -838,7 +838,7 @@ static Error storeAnkiImage(const ImageImporterConfig& config, const ImageImport
 
 	// Header
 	ImageBinaryHeader header = {};
-	memcpy(&header.m_magic[0], &IMAGE_MAGIC[0], sizeof(header.m_magic));
+	memcpy(&header.m_magic[0], &kImageMagic[0], sizeof(header.m_magic));
 	header.m_width = ctx.m_width;
 	header.m_height = ctx.m_height;
 	header.m_depthOrLayerCount = max(ctx.m_layerCount, ctx.m_depth);
@@ -846,11 +846,12 @@ static Error storeAnkiImage(const ImageImporterConfig& config, const ImageImport
 	if(ctx.m_hdr)
 	{
 		header.m_colorFormat =
-			(ctx.m_channelCount == 3) ? ImageBinaryColorFormat::RGBF32 : ImageBinaryColorFormat::RGBAF32;
+			(ctx.m_channelCount == 3) ? ImageBinaryColorFormat::kRgbFloat : ImageBinaryColorFormat::kRgbaFloat;
 	}
 	else
 	{
-		header.m_colorFormat = (ctx.m_channelCount == 3) ? ImageBinaryColorFormat::RGB8 : ImageBinaryColorFormat::RGBA8;
+		header.m_colorFormat =
+			(ctx.m_channelCount == 3) ? ImageBinaryColorFormat::kRgb8 : ImageBinaryColorFormat::kRgba8;
 	}
 	header.m_compressionMask = config.m_compressions;
 	header.m_isNormal = false;
@@ -860,7 +861,7 @@ static Error storeAnkiImage(const ImageImporterConfig& config, const ImageImport
 	ANKI_CHECK(outFile.write(&header, sizeof(header)));
 
 	// Write RAW
-	if(!!(config.m_compressions & ImageBinaryDataCompression::RAW))
+	if(!!(config.m_compressions & ImageBinaryDataCompression::kRaw))
 	{
 		ANKI_IMPORTER_LOGV("Storing RAW");
 
@@ -880,7 +881,7 @@ static Error storeAnkiImage(const ImageImporterConfig& config, const ImageImport
 	}
 
 	// Write S3TC
-	if(!!(config.m_compressions & ImageBinaryDataCompression::S3TC))
+	if(!!(config.m_compressions & ImageBinaryDataCompression::kS3tc))
 	{
 		ANKI_IMPORTER_LOGV("Storing S3TC");
 
@@ -900,7 +901,7 @@ static Error storeAnkiImage(const ImageImporterConfig& config, const ImageImport
 	}
 
 	// Write ASTC
-	if(!!(config.m_compressions & ImageBinaryDataCompression::ASTC))
+	if(!!(config.m_compressions & ImageBinaryDataCompression::kAstc))
 	{
 		ANKI_IMPORTER_LOGV("Storing ASTC");
 
@@ -928,7 +929,7 @@ static Error importImageInternal(const ImageImporterConfig& configOriginal)
 	ImageImporterConfig config = configOriginal;
 
 	config.m_minMipmapDimension = max(config.m_minMipmapDimension, 4u);
-	if(!!(config.m_compressions & ImageBinaryDataCompression::ASTC))
+	if(!!(config.m_compressions & ImageBinaryDataCompression::kAstc))
 	{
 		config.m_minMipmapDimension = max(config.m_minMipmapDimension, config.m_astcBlockSize.x());
 		config.m_minMipmapDimension = max(config.m_minMipmapDimension, config.m_astcBlockSize.y());
@@ -975,13 +976,13 @@ static Error importImageInternal(const ImageImporterConfig& configOriginal)
 
 	ctx.m_width = width;
 	ctx.m_height = height;
-	ctx.m_depth = (config.m_type == ImageBinaryType::_3D) ? config.m_inputFilenames.getSize() : 1;
-	ctx.m_faceCount = (config.m_type == ImageBinaryType::CUBE) ? 6 : 1;
-	ctx.m_layerCount = (config.m_type == ImageBinaryType::_2D_ARRAY) ? config.m_inputFilenames.getSize() : 1;
+	ctx.m_depth = (config.m_type == ImageBinaryType::k3D) ? config.m_inputFilenames.getSize() : 1;
+	ctx.m_faceCount = (config.m_type == ImageBinaryType::kCube) ? 6 : 1;
+	ctx.m_layerCount = (config.m_type == ImageBinaryType::k2DArray) ? config.m_inputFilenames.getSize() : 1;
 	ctx.m_hdr = isHdr;
 
 	U32 desiredChannelCount;
-	if(isHdr && !!(config.m_compressions & ImageBinaryDataCompression::S3TC))
+	if(isHdr && !!(config.m_compressions & ImageBinaryDataCompression::kS3tc))
 	{
 		// BC6H doesn't have a 4th channel
 		if(channelCount != 3)
@@ -989,7 +990,7 @@ static Error importImageInternal(const ImageImporterConfig& configOriginal)
 			ANKI_IMPORTER_LOGW("Input images have alpha but that can't be supported with BC6H");
 		}
 
-		if(!!(config.m_compressions & ImageBinaryDataCompression::RAW))
+		if(!!(config.m_compressions & ImageBinaryDataCompression::kRaw))
 		{
 			ANKI_IMPORTER_LOGE("Can't support both BC6H (which is 3 component) and RAW which requires 4 compoments");
 			return Error::kUserData;
@@ -997,7 +998,7 @@ static Error importImageInternal(const ImageImporterConfig& configOriginal)
 
 		desiredChannelCount = 3;
 	}
-	else if(!!(config.m_compressions & ImageBinaryDataCompression::RAW))
+	else if(!!(config.m_compressions & ImageBinaryDataCompression::kRaw))
 	{
 		// Always ask for 4 components because desktop GPUs don't always like 3
 		desiredChannelCount = 4;
@@ -1025,14 +1026,14 @@ static Error importImageInternal(const ImageImporterConfig& configOriginal)
 
 	// Generate mipmaps
 	const U32 mipCount =
-		min(config.m_mipmapCount, (config.m_type == ImageBinaryType::_3D)
+		min(config.m_mipmapCount, (config.m_type == ImageBinaryType::k3D)
 									  ? computeMaxMipmapCount3d(width, height, ctx.m_depth, config.m_minMipmapDimension)
 									  : computeMaxMipmapCount2d(width, height, config.m_minMipmapDimension));
 	for(U32 mip = 1; mip < mipCount; ++mip)
 	{
 		ctx.m_mipmaps.emplaceBack(alloc);
 
-		if(config.m_type != ImageBinaryType::_3D)
+		if(config.m_type != ImageBinaryType::k3D)
 		{
 			ctx.m_mipmaps[mip].m_surfacesOrVolume.create(ctx.m_faceCount * ctx.m_layerCount, alloc);
 			for(U32 l = 0; l < ctx.m_layerCount; ++l)
@@ -1086,7 +1087,7 @@ static Error importImageInternal(const ImageImporterConfig& configOriginal)
 	}
 
 	// Compress
-	if(!!(config.m_compressions & ImageBinaryDataCompression::S3TC))
+	if(!!(config.m_compressions & ImageBinaryDataCompression::kS3tc))
 	{
 		ANKI_IMPORTER_LOGV("Will compress in S3TC");
 
@@ -1115,7 +1116,7 @@ static Error importImageInternal(const ImageImporterConfig& configOriginal)
 		}
 	}
 
-	if(!!(config.m_compressions & ImageBinaryDataCompression::ASTC))
+	if(!!(config.m_compressions & ImageBinaryDataCompression::kAstc))
 	{
 		ANKI_IMPORTER_LOGV("Will compress in ASTC");
 
@@ -1145,7 +1146,7 @@ static Error importImageInternal(const ImageImporterConfig& configOriginal)
 		}
 	}
 
-	if(!!(config.m_compressions & ImageBinaryDataCompression::ETC))
+	if(!!(config.m_compressions & ImageBinaryDataCompression::kEtc))
 	{
 		ANKI_ASSERT(!"TODO");
 	}

AnKi/Importer/ImageImporter.h

@@ -21,8 +21,8 @@ public:
 	GenericMemoryPoolAllocator<U8> m_allocator;
 	ConstWeakArray<CString> m_inputFilenames;
 	CString m_outFilename;
-	ImageBinaryType m_type = ImageBinaryType::_2D;
-	ImageBinaryDataCompression m_compressions = ImageBinaryDataCompression::S3TC;
+	ImageBinaryType m_type = ImageBinaryType::k2D;
+	ImageBinaryDataCompression m_compressions = ImageBinaryDataCompression::kS3tc;
 	U32 m_minMipmapDimension = 4;
 	U32 m_mipmapCount = kMaxU32;
 	Bool m_noAlpha = true;

AnKi/Renderer/Bloom.h

@@ -41,7 +41,7 @@ public:
 	}
 
 private:
-	static constexpr Format kRtPixelFormat = Format::kA2B10G10R10_Unorm_Pack32;
+	static constexpr Format kRtPixelFormat = Format::kA2B10G10R10UnormPack32;
 
 	const Array<U32, 2> m_workgroupSize = {16, 16};
 

AnKi/Renderer/Common.h

@@ -68,7 +68,7 @@ constexpr U32 kGBufferColorRenderTargetCount = 4;
 constexpr U32 kDownscaleBurDownTo = 32;
 
 inline constexpr Array<Format, kGBufferColorRenderTargetCount> kGBufferColorRenderTargetFormats = {
-	{Format::kR8G8B8A8_Unorm, Format::kR8G8B8A8_Unorm, Format::kA2B10G10R10_Unorm_Pack32, Format::kR16G16_Snorm}};
+	{Format::kR8G8B8A8Unorm, Format::kR8G8B8A8Unorm, Format::kA2B10G10R10UnormPack32, Format::kR16G16Snorm}};
 
 /// GPU buffers and textures that the clusterer refers to.
 class ClusteredShadingContext

AnKi/Renderer/Dbg.cpp

@@ -32,7 +32,7 @@ Error Dbg::init()
 
 	// RT descr
 	m_rtDescr = m_r->create2DRenderTargetDescription(m_r->getInternalResolution().x(), m_r->getInternalResolution().y(),
-													 Format::kR8G8B8A8_Unorm, "Dbg");
+													 Format::kR8G8B8A8Unorm, "Dbg");
 	m_rtDescr.bake();
 
 	// Create FB descr

AnKi/Renderer/DepthDownscale.cpp

@@ -65,7 +65,7 @@ Error DepthDownscale::initInternal()
 			usage |= TextureUsageBit::kFramebufferWrite;
 		}
 
-		TextureInitInfo texInit = m_r->create2DRenderTargetInitInfo(width, height, Format::kR32_Sfloat, usage, "HiZ");
+		TextureInitInfo texInit = m_r->create2DRenderTargetInitInfo(width, height, Format::kR32Sfloat, usage, "HiZ");
 		texInit.m_mipmapCount = U8(m_mipCount);
 		m_hizTex = m_r->createAndClearRenderTarget(texInit, TextureUsageBit::kSampledFragment);
 	}

AnKi/Renderer/IndirectDiffuse.cpp

@@ -62,7 +62,7 @@ Error IndirectDiffuse::initInternal()
 
 		const UVec2 rez = (size + m_vrs.m_sriTexelDimension - 1) / m_vrs.m_sriTexelDimension;
 		m_vrs.m_rtHandle =
-			m_r->create2DRenderTargetDescription(rez.x(), rez.y(), Format::kR8_Uint, "IndirectDiffuseVrsSri");
+			m_r->create2DRenderTargetDescription(rez.x(), rez.y(), Format::kR8Uint, "IndirectDiffuseVrsSri");
 		m_vrs.m_rtHandle.bake();
 
 		ANKI_CHECK(getResourceManager().loadResource("ShaderBinaries/IndirectDiffuseVrsSriGeneration.ankiprogbin",

AnKi/Renderer/MainRenderer.cpp

@@ -58,8 +58,8 @@ Error MainRenderer::init(const MainRendererInitInfo& inf)
 		alignRoundDown(2, resolution.y());
 		m_tmpRtDesc = m_r->create2DRenderTargetDescription(
 			resolution.x(), resolution.y(),
-			(m_r->getGrManager().getDeviceCapabilities().m_unalignedBbpTextureFormats) ? Format::kR8G8B8_Unorm
-																					   : Format::kR8G8B8A8_Unorm,
+			(m_r->getGrManager().getDeviceCapabilities().m_unalignedBbpTextureFormats) ? Format::kR8G8B8Unorm
+																					   : Format::kR8G8B8A8Unorm,
 			"Final Composite");
 		m_tmpRtDesc.bake();
 

AnKi/Renderer/MotionVectors.cpp

@@ -42,7 +42,7 @@ Error MotionVectors::initInternal()
 
 	// RTs
 	m_motionVectorsRtDescr = m_r->create2DRenderTargetDescription(
-		m_r->getInternalResolution().x(), m_r->getInternalResolution().y(), Format::kR16G16_Sfloat, "MotionVectors");
+		m_r->getInternalResolution().x(), m_r->getInternalResolution().y(), Format::kR16G16Sfloat, "MotionVectors");
 	m_motionVectorsRtDescr.bake();
 
 	TextureUsageBit historyLengthUsage = TextureUsageBit::kAllSampled;
@@ -57,7 +57,7 @@ Error MotionVectors::initInternal()
 
 	TextureInitInfo historyLengthTexInit =
 		m_r->create2DRenderTargetInitInfo(m_r->getInternalResolution().x(), m_r->getInternalResolution().y(),
-										  Format::kR8_Unorm, historyLengthUsage, "MotionVectorsHistoryLen#1");
+										  Format::kR8Unorm, historyLengthUsage, "MotionVectorsHistoryLen#1");
 	m_historyLengthTextures[0] = m_r->createAndClearRenderTarget(historyLengthTexInit, TextureUsageBit::kAllSampled);
 	historyLengthTexInit.setName("MotionVectorsHistoryLen#2");
 	m_historyLengthTextures[1] = m_r->createAndClearRenderTarget(historyLengthTexInit, TextureUsageBit::kAllSampled);

AnKi/Renderer/Renderer.cpp

@@ -153,7 +153,7 @@ Error Renderer::initInternal(UVec2 swapchainResolution)
 		TextureInitInfo texinit("RendererDummy");
 		texinit.m_width = texinit.m_height = 4;
 		texinit.m_usage = TextureUsageBit::kAllSampled | TextureUsageBit::kImageComputeWrite;
-		texinit.m_format = Format::kR8G8B8A8_Unorm;
+		texinit.m_format = Format::kR8G8B8A8Unorm;
 		TexturePtr tex = createAndClearRenderTarget(texinit, TextureUsageBit::kAllSampled);
 
 		TextureViewInitInfo viewinit(tex);
@@ -654,15 +654,15 @@ Format Renderer::getHdrFormat() const
 	Format out;
 	if(!m_config->getRHighQualityHdr())
 	{
-		out = Format::kB10G11R11_Ufloat_Pack32;
+		out = Format::kB10G11R11UfloatPack32;
 	}
 	else if(m_gr->getDeviceCapabilities().m_unalignedBbpTextureFormats)
 	{
-		out = Format::kR16G16B16_Sfloat;
+		out = Format::kR16G16B16Sfloat;
 	}
 	else
 	{
-		out = Format::kR16G16B16A16_Sfloat;
+		out = Format::kR16G16B16A16Sfloat;
 	}
 	return out;
 }
@@ -671,11 +671,11 @@ Format Renderer::getDepthNoStencilFormat() const
 {
 	if(ANKI_PLATFORM_MOBILE)
 	{
-		return Format::kX8_D24_Unorm_Pack32;
+		return Format::kX8D24UnormPack32;
 	}
 	else
 	{
-		return Format::kD32_Sfloat;
+		return Format::kD32Sfloat;
 	}
 }
 

AnKi/Renderer/RtShadows.cpp

@@ -133,7 +133,7 @@ Error RtShadows::initInternal()
 	// Quarter rez shadow RT
 	{
 		TextureInitInfo texinit = m_r->create2DRenderTargetInitInfo(
-			m_r->getInternalResolution().x() / 2, m_r->getInternalResolution().y() / 2, Format::kR32G32_Uint,
+			m_r->getInternalResolution().x() / 2, m_r->getInternalResolution().y() / 2, Format::kR32G32Uint,
 			TextureUsageBit::kAllSampled | TextureUsageBit::kImageTraceRaysWrite | TextureUsageBit::kImageComputeWrite,
 			"RtShadows History");
 		m_historyRt = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
@@ -143,14 +143,14 @@ Error RtShadows::initInternal()
 	{
 		m_intermediateShadowsRtDescr = m_r->create2DRenderTargetDescription(m_r->getInternalResolution().x() / 2,
 																			m_r->getInternalResolution().y() / 2,
-																			Format::kR32G32_Uint, "RtShadows Tmp");
+																			Format::kR32G32Uint, "RtShadows Tmp");
 		m_intermediateShadowsRtDescr.bake();
 	}
 
 	// Moments RT
 	{
 		TextureInitInfo texinit = m_r->create2DRenderTargetInitInfo(
-			m_r->getInternalResolution().x() / 2, m_r->getInternalResolution().y() / 2, Format::kR32G32_Sfloat,
+			m_r->getInternalResolution().x() / 2, m_r->getInternalResolution().y() / 2, Format::kR32G32Sfloat,
 			TextureUsageBit::kAllSampled | TextureUsageBit::kImageTraceRaysWrite | TextureUsageBit::kImageComputeWrite,
 			"RtShadows Moments #1");
 		m_momentsRts[0] = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
@@ -164,7 +164,7 @@ Error RtShadows::initInternal()
 	{
 		m_varianceRtDescr = m_r->create2DRenderTargetDescription(m_r->getInternalResolution().x() / 2,
 																 m_r->getInternalResolution().y() / 2,
-																 Format::kR32_Sfloat, "RtShadows Variance");
+																 Format::kR32Sfloat, "RtShadows Variance");
 		m_varianceRtDescr.bake();
 	}
 
@@ -172,7 +172,7 @@ Error RtShadows::initInternal()
 	{
 		m_upscaledRtDescr =
 			m_r->create2DRenderTargetDescription(m_r->getInternalResolution().x(), m_r->getInternalResolution().y(),
-												 Format::kR32G32_Uint, "RtShadows Upscaled");
+												 Format::kR32G32Uint, "RtShadows Upscaled");
 		m_upscaledRtDescr.bake();
 	}
 

AnKi/Renderer/Scale.cpp

@@ -149,11 +149,11 @@ Error Scale::init()
 	}
 	else if(getGrManager().getDeviceCapabilities().m_unalignedBbpTextureFormats)
 	{
-		format = Format::kR8G8B8_Unorm;
+		format = Format::kR8G8B8Unorm;
 	}
 	else
 	{
-		format = Format::kR8G8B8A8_Unorm;
+		format = Format::kR8G8B8A8Unorm;
 	}
 
 	m_upscaleAndSharpenRtDescr = m_r->create2DRenderTargetDescription(
@@ -163,8 +163,8 @@ Error Scale::init()
 	if(m_neeedsTonemapping)
 	{
 		const Format fmt = (getGrManager().getDeviceCapabilities().m_unalignedBbpTextureFormats)
-							   ? Format::kR8G8B8_Unorm
-							   : Format::kR8G8B8A8_Unorm;
+							   ? Format::kR8G8B8Unorm
+							   : Format::kR8G8B8A8Unorm;
 		m_tonemapedRtDescr = m_r->create2DRenderTargetDescription(
 			m_r->getPostProcessResolution().x(), m_r->getPostProcessResolution().y(), fmt, "Tonemapped");
 		m_tonemapedRtDescr.bake();

AnKi/Renderer/ShadowMapping.cpp

@@ -102,7 +102,7 @@ Error ShadowMapping::initAtlas()
 		m_atlas.m_tileCountBothAxis = getConfig().getRShadowMappingTileCountPerRowOrColumn();
 
 		// RT
-		const Format texFormat = (ANKI_EVSM4) ? Format::kR32G32B32A32_Sfloat : Format::kR32G32_Sfloat;
+		const Format texFormat = (ANKI_EVSM4) ? Format::kR32G32B32A32Sfloat : Format::kR32G32Sfloat;
 		TextureUsageBit usage = TextureUsageBit::kSampledFragment | TextureUsageBit::kSampledCompute;
 		usage |= (preferCompute) ? TextureUsageBit::kImageComputeWrite : TextureUsageBit::kAllFramebuffer;
 		TextureInitInfo texinit = m_r->create2DRenderTargetInitInfo(

AnKi/Renderer/ShadowmapsResolve.cpp

@@ -35,7 +35,7 @@ Error ShadowmapsResolve::initInternal()
 
 	ANKI_R_LOGV("Initializing shadowmaps resolve. Resolution %ux%u", width, height);
 
-	m_rtDescr = m_r->create2DRenderTargetDescription(width, height, Format::kR8G8B8A8_Unorm, "SM resolve");
+	m_rtDescr = m_r->create2DRenderTargetDescription(width, height, Format::kR8G8B8A8Unorm, "SM resolve");
 	m_rtDescr.bake();
 
 	// Create FB descr

AnKi/Renderer/TemporalAA.cpp

@@ -75,8 +75,8 @@ Error TemporalAA::initInternal()
 
 	m_tonemappedRtDescr = m_r->create2DRenderTargetDescription(
 		m_r->getInternalResolution().x(), m_r->getInternalResolution().y(),
-		(getGrManager().getDeviceCapabilities().m_unalignedBbpTextureFormats) ? Format::kR8G8B8_Unorm
-																			  : Format::kR8G8B8A8_Unorm,
+		(getGrManager().getDeviceCapabilities().m_unalignedBbpTextureFormats) ? Format::kR8G8B8Unorm
+																			  : Format::kR8G8B8A8Unorm,
 		"TemporalAA Tonemapped");
 	m_tonemappedRtDescr.bake();
 

AnKi/Renderer/Tonemapping.cpp

@@ -43,7 +43,7 @@ Error Tonemapping::initInternal()
 	// automatic image transitions
 	const TextureUsageBit usage = TextureUsageBit::kAllImage;
 	const TextureInitInfo texinit =
-		m_r->create2DRenderTargetInitInfo(1, 1, Format::kR16G16_Sfloat, usage, "ExposureAndAvgLum1x1");
+		m_r->create2DRenderTargetInitInfo(1, 1, Format::kR16G16Sfloat, usage, "ExposureAndAvgLum1x1");
 	ClearValue clearValue;
 	clearValue.m_colorf = {0.5f, 0.5f, 0.5f, 0.5f};
 	m_exposureAndAvgLuminance1x1 = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::kAllImage, clearValue);

AnKi/Renderer/VolumetricFog.cpp

@@ -43,7 +43,7 @@ Error VolumetricFog::init()
 
 	// RT descr
 	m_rtDescr =
-		m_r->create2DRenderTargetDescription(m_volumeSize[0], m_volumeSize[1], Format::kR16G16B16A16_Sfloat, "Fog");
+		m_r->create2DRenderTargetDescription(m_volumeSize[0], m_volumeSize[1], Format::kR16G16B16A16Sfloat, "Fog");
 	m_rtDescr.m_depth = m_volumeSize[2];
 	m_rtDescr.m_type = TextureType::k3D;
 	m_rtDescr.bake();

AnKi/Renderer/VolumetricLightingAccumulation.cpp

@@ -60,7 +60,7 @@ Error VolumetricLightingAccumulation::init()
 
 	// Create RTs
 	TextureInitInfo texinit =
-		m_r->create2DRenderTargetInitInfo(m_volumeSize[0], m_volumeSize[1], Format::kR16G16B16A16_Sfloat,
+		m_r->create2DRenderTargetInitInfo(m_volumeSize[0], m_volumeSize[1], Format::kR16G16B16A16Sfloat,
 										  TextureUsageBit::kImageComputeRead | TextureUsageBit::kImageComputeWrite
 											  | TextureUsageBit::kSampledFragment | TextureUsageBit::kSampledCompute,
 										  "VolLight");

AnKi/Renderer/VrsSriGeneration.cpp

@@ -48,11 +48,11 @@ Error VrsSriGeneration::initInternal()
 	const TextureUsageBit texUsage =
 		TextureUsageBit::kFramebufferShadingRate | TextureUsageBit::kImageComputeWrite | TextureUsageBit::kAllSampled;
 	TextureInitInfo sriInitInfo =
-		m_r->create2DRenderTargetInitInfo(rez.x(), rez.y(), Format::kR8_Uint, texUsage, "VrsSri");
+		m_r->create2DRenderTargetInitInfo(rez.x(), rez.y(), Format::kR8Uint, texUsage, "VrsSri");
 	m_sriTex = m_r->createAndClearRenderTarget(sriInitInfo, TextureUsageBit::kFramebufferShadingRate);
 
 	const UVec2 rezDownscaled = (m_r->getInternalResolution() / 2 + m_sriTexelDimension - 1) / m_sriTexelDimension;
-	sriInitInfo = m_r->create2DRenderTargetInitInfo(rezDownscaled.x(), rezDownscaled.y(), Format::kR8_Uint, texUsage,
+	sriInitInfo = m_r->create2DRenderTargetInitInfo(rezDownscaled.x(), rezDownscaled.y(), Format::kR8Uint, texUsage,
 													"VrsSriDownscaled");
 	m_downscaledSriTex = m_r->createAndClearRenderTarget(sriInitInfo, TextureUsageBit::kFramebufferShadingRate);
 

AnKi/Resource/ImageBinary.h

@@ -14,40 +14,40 @@ namespace anki {
 /// @addtogroup resource
 /// @{
 
-static constexpr const char* IMAGE_MAGIC = "ANKITEX1";
+inline constexpr const Char* kImageMagic = "ANKITEX1";
 
 /// Image type.
 /// @memberof ImageBinaryHeader
 enum class ImageBinaryType : U32
 {
-	NONE,
-	_2D,
-	CUBE,
-	_3D,
-	_2D_ARRAY
+	kNone,
+	k2D,
+	kCube,
+	k3D,
+	k2DArray
 };
 
 /// The acceptable color types.
 /// @memberof ImageBinaryHeader
 enum class ImageBinaryColorFormat : U32
 {
-	NONE,
-	RGB8,
-	RGBA8,
-	SRGB8,
-	RGBF32,
-	RGBAF32
+	kNone,
+	kRgb8,
+	kRgba8,
+	kSrgb8,
+	kRgbFloat,
+	kRgbaFloat
 };
 
 /// The available data compressions.
 /// @memberof ImageBinaryHeader
 enum class ImageBinaryDataCompression : U32
 {
-	NONE,
-	RAW = 1 << 0,
-	S3TC = 1 << 1,
-	ETC = 1 << 2,
-	ASTC = 1 << 3
+	kNone,
+	kRaw = 1 << 0,
+	kS3tc = 1 << 1,
+	kEtc = 1 << 2,
+	kAstc = 1 << 3
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(ImageBinaryDataCompression)
 

AnKi/Resource/ImageBinary.xml

@@ -6,40 +6,40 @@
 	<doxygen_group name="resource"/>
 
 	<prefix_code><![CDATA[
-static constexpr const char* IMAGE_MAGIC = "ANKITEX1";
+inline constexpr const Char* kImageMagic = "ANKITEX1";
 
 /// Image type.
 /// @memberof ImageBinaryHeader
 enum class ImageBinaryType : U32
 {
-	NONE,
-	_2D,
-	CUBE,
-	_3D,
-	_2D_ARRAY
+	kNone,
+	k2D,
+	kCube,
+	k3D,
+	k2DArray
 };
 
 /// The acceptable color types.
 /// @memberof ImageBinaryHeader
 enum class ImageBinaryColorFormat : U32
 {
-	NONE,
-	RGB8,
-	RGBA8,
-	SRGB8,
-	RGBF32,
-	RGBAF32
+	kNone,
+	kRgb8,
+	kRgba8,
+	kSrgb8,
+	kRgbFloat,
+	kRgbaFloat
 };
 
 /// The available data compressions.
 /// @memberof ImageBinaryHeader
 enum class ImageBinaryDataCompression : U32
 {
-	NONE,
-	RAW = 1 << 0,
-	S3TC = 1 << 1,
-	ETC = 1 << 2,
-	ASTC = 1 << 3
+	kNone,
+	kRaw = 1 << 0,
+	kS3tc = 1 << 1,
+	kEtc = 1 << 2,
+	kAstc = 1 << 3
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(ImageBinaryDataCompression)
 ]]></prefix_code>

AnKi/Resource/ImageLoader.cpp

@@ -18,19 +18,19 @@ static PtrSize calcRawTexelSize(const ImageBinaryColorFormat cf)
 	PtrSize out;
 	switch(cf)
 	{
-	case ImageBinaryColorFormat::RGB8:
+	case ImageBinaryColorFormat::kRgb8:
 		out = 3;
 		break;
-	case ImageBinaryColorFormat::RGBA8:
+	case ImageBinaryColorFormat::kRgba8:
 		out = 4;
 		break;
-	case ImageBinaryColorFormat::SRGB8:
+	case ImageBinaryColorFormat::kSrgb8:
 		out = 3;
 		break;
-	case ImageBinaryColorFormat::RGBF32:
+	case ImageBinaryColorFormat::kRgbFloat:
 		out = 3 * sizeof(F32);
 		break;
-	case ImageBinaryColorFormat::RGBAF32:
+	case ImageBinaryColorFormat::kRgbaFloat:
 		out = 4 * sizeof(F32);
 		break;
 	default:
@@ -46,16 +46,16 @@ static PtrSize calcS3tcBlockSize(const ImageBinaryColorFormat cf)
 	PtrSize out;
 	switch(cf)
 	{
-	case ImageBinaryColorFormat::RGB8:
+	case ImageBinaryColorFormat::kRgb8:
 		out = 8;
 		break;
-	case ImageBinaryColorFormat::RGBA8:
+	case ImageBinaryColorFormat::kRgba8:
 		out = 16;
 		break;
-	case ImageBinaryColorFormat::SRGB8:
+	case ImageBinaryColorFormat::kSrgb8:
 		out = 8;
 		break;
-	case ImageBinaryColorFormat::RGBF32:
+	case ImageBinaryColorFormat::kRgbFloat:
 		out = 16;
 		break;
 	default:
@@ -78,16 +78,16 @@ static PtrSize calcSurfaceSize(const U32 width32, const U32 height32, const Imag
 
 	switch(comp)
 	{
-	case ImageBinaryDataCompression::RAW:
+	case ImageBinaryDataCompression::kRaw:
 		out = width * height * calcRawTexelSize(cf);
 		break;
-	case ImageBinaryDataCompression::S3TC:
+	case ImageBinaryDataCompression::kS3tc:
 		out = (width / 4) * (height / 4) * calcS3tcBlockSize(cf);
 		break;
-	case ImageBinaryDataCompression::ETC:
+	case ImageBinaryDataCompression::kEtc:
 		out = (width / 4) * (height / 4) * 8;
 		break;
-	case ImageBinaryDataCompression::ASTC:
+	case ImageBinaryDataCompression::kAstc:
 		out = (width / astcBlockSize.x()) * (height / astcBlockSize.y()) * 16;
 		break;
 	default:
@@ -109,7 +109,7 @@ static PtrSize calcVolumeSize(const U width, const U height, const U depth, cons
 
 	switch(comp)
 	{
-	case ImageBinaryDataCompression::RAW:
+	case ImageBinaryDataCompression::kRaw:
 		out = width * height * depth * calcRawTexelSize(cf);
 		break;
 	default:
@@ -130,19 +130,19 @@ static PtrSize calcSizeOfSegment(const ImageBinaryHeader& header, ImageBinaryDat
 	U32 mips = header.m_mipmapCount;
 	ANKI_ASSERT(mips > 0);
 
-	if(header.m_type != ImageBinaryType::_3D)
+	if(header.m_type != ImageBinaryType::k3D)
 	{
 		U32 surfCountPerMip = 0;
 
 		switch(header.m_type)
 		{
-		case ImageBinaryType::_2D:
+		case ImageBinaryType::k2D:
 			surfCountPerMip = 1;
 			break;
-		case ImageBinaryType::CUBE:
+		case ImageBinaryType::kCube:
 			surfCountPerMip = 6;
 			break;
-		case ImageBinaryType::_2D_ARRAY:
+		case ImageBinaryType::k2DArray:
 			surfCountPerMip = header.m_depthOrLayerCount;
 			break;
 		default:
@@ -401,7 +401,7 @@ Error ImageLoader::loadAnkiImage(FileInterface& file, U32 maxImageSize,
 	ImageBinaryHeader header;
 	ANKI_CHECK(file.read(&header, sizeof(ImageBinaryHeader)));
 
-	if(std::memcmp(&header.m_magic[0], IMAGE_MAGIC, sizeof(IMAGE_MAGIC) - 1) != 0)
+	if(std::memcmp(&header.m_magic[0], kImageMagic, sizeof(kImageMagic) - 1) != 0)
 	{
 		ANKI_RESOURCE_LOGE("Wrong magic word");
 		return Error::kUserData;
@@ -420,19 +420,20 @@ Error ImageLoader::loadAnkiImage(FileInterface& file, U32 maxImageSize,
 		return Error::kUserData;
 	}
 
-	if(header.m_type < ImageBinaryType::_2D || header.m_type > ImageBinaryType::_2D_ARRAY)
+	if(header.m_type < ImageBinaryType::k2D || header.m_type > ImageBinaryType::k2DArray)
 	{
 		ANKI_RESOURCE_LOGE("Incorrect header: image type");
 		return Error::kUserData;
 	}
 
-	if(header.m_colorFormat < ImageBinaryColorFormat::RGB8 || header.m_colorFormat > ImageBinaryColorFormat::RGBAF32)
+	if(header.m_colorFormat < ImageBinaryColorFormat::kRgb8
+	   || header.m_colorFormat > ImageBinaryColorFormat::kRgbaFloat)
 	{
 		ANKI_RESOURCE_LOGE("Incorrect header: color format");
 		return Error::kUserData;
 	}
 
-	if(!!(header.m_compressionMask & ImageBinaryDataCompression::ASTC))
+	if(!!(header.m_compressionMask & ImageBinaryDataCompression::kAstc))
 	{
 		if((header.m_astcBlockSizeX != 8 && header.m_astcBlockSizeX != 4)
 		   || (header.m_astcBlockSizeY != 8 && header.m_astcBlockSizeY != 4))
@@ -445,7 +446,7 @@ Error ImageLoader::loadAnkiImage(FileInterface& file, U32 maxImageSize,
 	if(!(header.m_compressionMask & preferredCompression))
 	{
 		// Fallback
-		preferredCompression = ImageBinaryDataCompression::RAW;
+		preferredCompression = ImageBinaryDataCompression::kRaw;
 
 		if(!(header.m_compressionMask & preferredCompression))
 		{
@@ -468,20 +469,20 @@ Error ImageLoader::loadAnkiImage(FileInterface& file, U32 maxImageSize,
 	U32 faceCount = 1;
 	switch(header.m_type)
 	{
-	case ImageBinaryType::_2D:
+	case ImageBinaryType::k2D:
 		depth = 1;
 		layerCount = 1;
 		break;
-	case ImageBinaryType::CUBE:
+	case ImageBinaryType::kCube:
 		depth = 1;
 		layerCount = 1;
 		faceCount = 6;
 		break;
-	case ImageBinaryType::_3D:
+	case ImageBinaryType::k3D:
 		depth = header.m_depthOrLayerCount;
 		layerCount = 1;
 		break;
-	case ImageBinaryType::_2D_ARRAY:
+	case ImageBinaryType::k2DArray:
 		depth = 1;
 		layerCount = header.m_depthOrLayerCount;
 		break;
@@ -494,50 +495,50 @@ Error ImageLoader::loadAnkiImage(FileInterface& file, U32 maxImageSize,
 	//
 	PtrSize skipSize = 0;
 
-	if(preferredCompression == ImageBinaryDataCompression::RAW)
+	if(preferredCompression == ImageBinaryDataCompression::kRaw)
 	{
 		// Do nothing
 	}
-	else if(preferredCompression == ImageBinaryDataCompression::S3TC)
+	else if(preferredCompression == ImageBinaryDataCompression::kS3tc)
 	{
-		if(!!(header.m_compressionMask & ImageBinaryDataCompression::RAW))
+		if(!!(header.m_compressionMask & ImageBinaryDataCompression::kRaw))
 		{
 			// If raw compression is present then skip it
-			skipSize += calcSizeOfSegment(header, ImageBinaryDataCompression::RAW);
+			skipSize += calcSizeOfSegment(header, ImageBinaryDataCompression::kRaw);
 		}
 	}
-	else if(preferredCompression == ImageBinaryDataCompression::ETC)
+	else if(preferredCompression == ImageBinaryDataCompression::kEtc)
 	{
-		if(!!(header.m_compressionMask & ImageBinaryDataCompression::RAW))
+		if(!!(header.m_compressionMask & ImageBinaryDataCompression::kRaw))
 		{
 			// If raw compression is present then skip it
-			skipSize += calcSizeOfSegment(header, ImageBinaryDataCompression::RAW);
+			skipSize += calcSizeOfSegment(header, ImageBinaryDataCompression::kRaw);
 		}
 
-		if(!!(header.m_compressionMask & ImageBinaryDataCompression::S3TC))
+		if(!!(header.m_compressionMask & ImageBinaryDataCompression::kS3tc))
 		{
 			// If s3tc compression is present then skip it
-			skipSize += calcSizeOfSegment(header, ImageBinaryDataCompression::S3TC);
+			skipSize += calcSizeOfSegment(header, ImageBinaryDataCompression::kS3tc);
 		}
 	}
-	else if(preferredCompression == ImageBinaryDataCompression::ASTC)
+	else if(preferredCompression == ImageBinaryDataCompression::kAstc)
 	{
-		if(!!(header.m_compressionMask & ImageBinaryDataCompression::RAW))
+		if(!!(header.m_compressionMask & ImageBinaryDataCompression::kRaw))
 		{
 			// If raw compression is present then skip it
-			skipSize += calcSizeOfSegment(header, ImageBinaryDataCompression::RAW);
+			skipSize += calcSizeOfSegment(header, ImageBinaryDataCompression::kRaw);
 		}
 
-		if(!!(header.m_compressionMask & ImageBinaryDataCompression::S3TC))
+		if(!!(header.m_compressionMask & ImageBinaryDataCompression::kS3tc))
 		{
 			// If s3tc compression is present then skip it
-			skipSize += calcSizeOfSegment(header, ImageBinaryDataCompression::S3TC);
+			skipSize += calcSizeOfSegment(header, ImageBinaryDataCompression::kS3tc);
 		}
 
-		if(!!(header.m_compressionMask & ImageBinaryDataCompression::ETC))
+		if(!!(header.m_compressionMask & ImageBinaryDataCompression::kEtc))
 		{
 			// If ETC compression is present then skip it
-			skipSize += calcSizeOfSegment(header, ImageBinaryDataCompression::ETC);
+			skipSize += calcSizeOfSegment(header, ImageBinaryDataCompression::kEtc);
 		}
 	}
 
@@ -552,7 +553,7 @@ Error ImageLoader::loadAnkiImage(FileInterface& file, U32 maxImageSize,
 
 	// Allocate the surfaces
 	mipCount = 0;
-	if(header.m_type != ImageBinaryType::_3D)
+	if(header.m_type != ImageBinaryType::k3D)
 	{
 		// Read all surfaces
 		U32 mipWidth = header.m_width;
@@ -717,8 +718,8 @@ Error ImageLoader::loadInternal(FileInterface& file, const CString& filename, U3
 	}
 
 	// load from this extension
-	m_imageType = ImageBinaryType::_2D;
-	m_compression = ImageBinaryDataCompression::RAW;
+	m_imageType = ImageBinaryType::k2D;
+	m_compression = ImageBinaryDataCompression::kRaw;
 
 	if(ext == "tga")
 	{
@@ -735,11 +736,11 @@ Error ImageLoader::loadInternal(FileInterface& file, const CString& filename, U3
 
 		if(bpp == 32)
 		{
-			m_colorFormat = ImageBinaryColorFormat::RGBA8;
+			m_colorFormat = ImageBinaryColorFormat::kRgba8;
 		}
 		else if(bpp == 24)
 		{
-			m_colorFormat = ImageBinaryColorFormat::RGB8;
+			m_colorFormat = ImageBinaryColorFormat::kRgb8;
 		}
 		else
 		{
@@ -749,9 +750,9 @@ Error ImageLoader::loadInternal(FileInterface& file, const CString& filename, U3
 	else if(ext == "ankitex")
 	{
 #if ANKI_PLATFORM_MOBILE
-		m_compression = ImageBinaryDataCompression::ASTC;
+		m_compression = ImageBinaryDataCompression::kAstc;
 #else
-		m_compression = ImageBinaryDataCompression::S3TC;
+		m_compression = ImageBinaryDataCompression::kS3tc;
 #endif
 
 		ANKI_CHECK(loadAnkiImage(file, maxImageSize, m_compression, m_surfaces, m_volumes, m_alloc, m_width, m_height,
@@ -764,7 +765,7 @@ Error ImageLoader::loadInternal(FileInterface& file, const CString& filename, U3
 		m_mipmapCount = 1;
 		m_depth = 1;
 		m_layerCount = 1;
-		m_colorFormat = ImageBinaryColorFormat::RGBA8;
+		m_colorFormat = ImageBinaryColorFormat::kRgba8;
 
 		ANKI_CHECK(loadStb(false, file, m_surfaces[0].m_width, m_surfaces[0].m_height, m_surfaces[0].m_data, m_alloc));
 
@@ -778,7 +779,7 @@ Error ImageLoader::loadInternal(FileInterface& file, const CString& filename, U3
 		m_mipmapCount = 1;
 		m_depth = 1;
 		m_layerCount = 1;
-		m_colorFormat = ImageBinaryColorFormat::RGBAF32;
+		m_colorFormat = ImageBinaryColorFormat::kRgbaFloat;
 
 		ANKI_CHECK(loadStb(true, file, m_surfaces[0].m_width, m_surfaces[0].m_height, m_surfaces[0].m_data, m_alloc));
 
@@ -802,17 +803,17 @@ const ImageLoaderSurface& ImageLoader::getSurface(U32 level, U32 face, U32 layer
 
 	switch(m_imageType)
 	{
-	case ImageBinaryType::_2D:
+	case ImageBinaryType::k2D:
 		idx = level;
 		break;
-	case ImageBinaryType::CUBE:
+	case ImageBinaryType::kCube:
 		ANKI_ASSERT(face < 6);
 		idx = level * 6 + face;
 		break;
-	case ImageBinaryType::_3D:
+	case ImageBinaryType::k3D:
 		ANKI_ASSERT(0 && "Can't use that for 3D images");
 		break;
-	case ImageBinaryType::_2D_ARRAY:
+	case ImageBinaryType::k2DArray:
 		idx = level * m_layerCount + layer;
 		break;
 	default:
@@ -824,7 +825,7 @@ const ImageLoaderSurface& ImageLoader::getSurface(U32 level, U32 face, U32 layer
 
 const ImageLoaderVolume& ImageLoader::getVolume(U32 level) const
 {
-	ANKI_ASSERT(m_imageType == ImageBinaryType::_3D);
+	ANKI_ASSERT(m_imageType == ImageBinaryType::k3D);
 	return m_volumes[level];
 }
 

AnKi/Resource/ImageLoader.h

@@ -48,13 +48,13 @@ public:
 
 	ImageBinaryColorFormat getColorFormat() const
 	{
-		ANKI_ASSERT(m_colorFormat != ImageBinaryColorFormat::NONE);
+		ANKI_ASSERT(m_colorFormat != ImageBinaryColorFormat::kNone);
 		return m_colorFormat;
 	}
 
 	ImageBinaryDataCompression getCompression() const
 	{
-		ANKI_ASSERT(m_compression != ImageBinaryDataCompression::NONE);
+		ANKI_ASSERT(m_compression != ImageBinaryDataCompression::kNone);
 		return m_compression;
 	}
 
@@ -76,25 +76,25 @@ public:
 
 	U32 getDepth() const
 	{
-		ANKI_ASSERT(m_imageType == ImageBinaryType::_3D);
+		ANKI_ASSERT(m_imageType == ImageBinaryType::k3D);
 		return m_depth;
 	}
 
 	U32 getLayerCount() const
 	{
-		ANKI_ASSERT(m_imageType == ImageBinaryType::_2D_ARRAY);
+		ANKI_ASSERT(m_imageType == ImageBinaryType::k2DArray);
 		return m_layerCount;
 	}
 
 	ImageBinaryType getImageType() const
 	{
-		ANKI_ASSERT(m_imageType != ImageBinaryType::NONE);
+		ANKI_ASSERT(m_imageType != ImageBinaryType::kNone);
 		return m_imageType;
 	}
 
 	UVec2 getAstcBlockSize() const
 	{
-		ANKI_ASSERT(!!(m_compression & ImageBinaryDataCompression::ASTC));
+		ANKI_ASSERT(!!(m_compression & ImageBinaryDataCompression::kAstc));
 		ANKI_ASSERT(m_astcBlockSize != UVec2(0u));
 		return m_astcBlockSize;
 	}
@@ -128,9 +128,9 @@ private:
 	U32 m_depth = 0;
 	U32 m_layerCount = 0;
 	UVec2 m_astcBlockSize = UVec2(0u);
-	ImageBinaryDataCompression m_compression = ImageBinaryDataCompression::NONE;
-	ImageBinaryColorFormat m_colorFormat = ImageBinaryColorFormat::NONE;
-	ImageBinaryType m_imageType = ImageBinaryType::NONE;
+	ImageBinaryDataCompression m_compression = ImageBinaryDataCompression::kNone;
+	ImageBinaryColorFormat m_colorFormat = ImageBinaryColorFormat::kNone;
+	ImageBinaryType m_imageType = ImageBinaryType::kNone;
 
 	void destroy();
 

AnKi/Resource/ImageResource.cpp

@@ -86,25 +86,25 @@ Error ImageResource::load(const ResourceFilename& filename, Bool async)
 
 	switch(loader.getImageType())
 	{
-	case ImageBinaryType::_2D:
+	case ImageBinaryType::k2D:
 		init.m_type = TextureType::k2D;
 		init.m_depth = 1;
 		faces = 1;
 		init.m_layerCount = 1;
 		break;
-	case ImageBinaryType::CUBE:
+	case ImageBinaryType::kCube:
 		init.m_type = TextureType::kCube;
 		init.m_depth = 1;
 		faces = 6;
 		init.m_layerCount = 1;
 		break;
-	case ImageBinaryType::_2D_ARRAY:
+	case ImageBinaryType::k2DArray:
 		init.m_type = TextureType::k2DArray;
 		init.m_layerCount = loader.getLayerCount();
 		init.m_depth = 1;
 		faces = 1;
 		break;
-	case ImageBinaryType::_3D:
+	case ImageBinaryType::k3D:
 		init.m_type = TextureType::k3D;
 		init.m_depth = loader.getDepth();
 		init.m_layerCount = 1;
@@ -115,81 +115,81 @@ Error ImageResource::load(const ResourceFilename& filename, Bool async)
 	}
 
 	// Internal format
-	if(loader.getColorFormat() == ImageBinaryColorFormat::RGB8)
+	if(loader.getColorFormat() == ImageBinaryColorFormat::kRgb8)
 	{
 		switch(loader.getCompression())
 		{
-		case ImageBinaryDataCompression::RAW:
-			init.m_format = Format::kR8G8B8_Unorm;
+		case ImageBinaryDataCompression::kRaw:
+			init.m_format = Format::kR8G8B8Unorm;
 			break;
-		case ImageBinaryDataCompression::S3TC:
-			init.m_format = Format::kBC1_RGB_Unorm_Block;
+		case ImageBinaryDataCompression::kS3tc:
+			init.m_format = Format::kBc1RgbUnormBlock;
 			break;
-		case ImageBinaryDataCompression::ASTC:
+		case ImageBinaryDataCompression::kAstc:
 			if(loader.getAstcBlockSize() == UVec2(4u))
 			{
-				init.m_format = Format::kASTC_4x4_Unorm_Block;
+				init.m_format = Format::kAstc4x4UnormBlock;
 			}
 			else
 			{
 				ANKI_ASSERT(loader.getAstcBlockSize() == UVec2(8u));
-				init.m_format = Format::kASTC_8x8_Unorm_Block;
+				init.m_format = Format::kAstc8x8UnormBlock;
 			}
 			break;
 		default:
 			ANKI_ASSERT(0);
 		}
 	}
-	else if(loader.getColorFormat() == ImageBinaryColorFormat::RGBA8)
+	else if(loader.getColorFormat() == ImageBinaryColorFormat::kRgba8)
 	{
 		switch(loader.getCompression())
 		{
-		case ImageBinaryDataCompression::RAW:
-			init.m_format = Format::kR8G8B8A8_Unorm;
+		case ImageBinaryDataCompression::kRaw:
+			init.m_format = Format::kR8G8B8A8Unorm;
 			break;
-		case ImageBinaryDataCompression::S3TC:
-			init.m_format = Format::kBC3_Unorm_Block;
+		case ImageBinaryDataCompression::kS3tc:
+			init.m_format = Format::kBc3UnormBlock;
 			break;
-		case ImageBinaryDataCompression::ASTC:
+		case ImageBinaryDataCompression::kAstc:
 			if(loader.getAstcBlockSize() == UVec2(4u))
 			{
-				init.m_format = Format::kASTC_4x4_Unorm_Block;
+				init.m_format = Format::kAstc4x4UnormBlock;
 			}
 			else
 			{
 				ANKI_ASSERT(loader.getAstcBlockSize() == UVec2(8u));
-				init.m_format = Format::kASTC_8x8_Unorm_Block;
+				init.m_format = Format::kAstc8x8UnormBlock;
 			}
 			break;
 		default:
 			ANKI_ASSERT(0);
 		}
 	}
-	else if(loader.getColorFormat() == ImageBinaryColorFormat::RGBF32)
+	else if(loader.getColorFormat() == ImageBinaryColorFormat::kRgbFloat)
 	{
 		switch(loader.getCompression())
 		{
-		case ImageBinaryDataCompression::S3TC:
-			init.m_format = Format::kBC6H_Ufloat_Block;
+		case ImageBinaryDataCompression::kS3tc:
+			init.m_format = Format::kBc6hUfloatBlock;
 			break;
-		case ImageBinaryDataCompression::ASTC:
+		case ImageBinaryDataCompression::kAstc:
 			ANKI_ASSERT(loader.getAstcBlockSize() == UVec2(8u));
-			init.m_format = Format::kASTC_8x8_Sfloat_Block;
+			init.m_format = Format::kAstc8x8SfloatBlock;
 			break;
 		default:
 			ANKI_ASSERT(0);
 		}
 	}
-	else if(loader.getColorFormat() == ImageBinaryColorFormat::RGBAF32)
+	else if(loader.getColorFormat() == ImageBinaryColorFormat::kRgbaFloat)
 	{
 		switch(loader.getCompression())
 		{
-		case ImageBinaryDataCompression::RAW:
-			init.m_format = Format::kR32G32B32A32_Sfloat;
+		case ImageBinaryDataCompression::kRaw:
+			init.m_format = Format::kR32G32B32A32Sfloat;
 			break;
-		case ImageBinaryDataCompression::ASTC:
+		case ImageBinaryDataCompression::kAstc:
 			ANKI_ASSERT(loader.getAstcBlockSize() == UVec2(8u));
-			init.m_format = Format::kASTC_8x8_Sfloat_Block;
+			init.m_format = Format::kAstc8x8SfloatBlock;
 			break;
 		default:
 			ANKI_ASSERT(0);

AnKi/Resource/MeshBinaryLoader.cpp

@@ -137,15 +137,15 @@ Error MeshBinaryLoader::checkHeader() const
 	}
 
 	// Attributes
-	ANKI_CHECK(checkFormat(VertexAttributeId::POSITION, Array<Format, 1>{{Format::kR32G32B32_Sfloat}}, 0, 0));
-	ANKI_CHECK(checkFormat(VertexAttributeId::NORMAL, Array<Format, 1>{{Format::kA2B10G10R10_Snorm_Pack32}}, 1, 0));
-	ANKI_CHECK(checkFormat(VertexAttributeId::TANGENT, Array<Format, 1>{{Format::kA2B10G10R10_Snorm_Pack32}}, 1, 4));
-	ANKI_CHECK(checkFormat(VertexAttributeId::UV0, Array<Format, 1>{{Format::kR32G32_Sfloat}}, 1, 8));
+	ANKI_CHECK(checkFormat(VertexAttributeId::POSITION, Array<Format, 1>{{Format::kR32G32B32Sfloat}}, 0, 0));
+	ANKI_CHECK(checkFormat(VertexAttributeId::NORMAL, Array<Format, 1>{{Format::kA2B10G10R10SnormPack32}}, 1, 0));
+	ANKI_CHECK(checkFormat(VertexAttributeId::TANGENT, Array<Format, 1>{{Format::kA2B10G10R10SnormPack32}}, 1, 4));
+	ANKI_CHECK(checkFormat(VertexAttributeId::UV0, Array<Format, 1>{{Format::kR32G32Sfloat}}, 1, 8));
 	ANKI_CHECK(checkFormat(VertexAttributeId::UV1, Array<Format, 1>{{Format::kNone}}, 1, 0));
 	ANKI_CHECK(
-		checkFormat(VertexAttributeId::BONE_INDICES, Array<Format, 2>{{Format::kNone, Format::kR8G8B8A8_Uint}}, 2, 0));
+		checkFormat(VertexAttributeId::BONE_INDICES, Array<Format, 2>{{Format::kNone, Format::kR8G8B8A8Uint}}, 2, 0));
 	ANKI_CHECK(
-		checkFormat(VertexAttributeId::BONE_WEIGHTS, Array<Format, 2>{{Format::kNone, Format::kR8G8B8A8_Unorm}}, 2, 4));
+		checkFormat(VertexAttributeId::BONE_WEIGHTS, Array<Format, 2>{{Format::kNone, Format::kR8G8B8A8Unorm}}, 2, 4));
 
 	// Vertex buffers
 	if(m_header.m_vertexBufferCount != 2 + U32(hasBoneInfo()))
@@ -277,7 +277,7 @@ Error MeshBinaryLoader::storeIndicesAndPosition(DynamicArrayAuto<U32>& indices,
 	{
 		positions.resize(m_header.m_totalVertexCount);
 		const MeshBinaryVertexAttribute& attrib = m_header.m_vertexAttributes[VertexAttributeId::POSITION];
-		ANKI_ASSERT(attrib.m_format == Format::kR32G32B32_Sfloat);
+		ANKI_ASSERT(attrib.m_format == Format::kR32G32B32Sfloat);
 		ANKI_CHECK(storeVertexBuffer(attrib.m_bufferBinding, &positions[0], positions.getSizeInBytes()));
 	}
 

AnKi/Scene/Components/ParticleEmitterComponent.cpp

@@ -402,9 +402,9 @@ void ParticleEmitterComponent::draw(RenderQueueDrawContext& ctx) const
 		cmdb->bindShaderProgram(prog);
 
 		// Vertex attribs
-		cmdb->setVertexAttribute(U32(VertexAttributeId::POSITION), 0, Format::kR32G32B32_Sfloat, 0);
-		cmdb->setVertexAttribute(U32(VertexAttributeId::SCALE), 0, Format::kR32_Sfloat, sizeof(Vec3));
-		cmdb->setVertexAttribute(U32(VertexAttributeId::ALPHA), 0, Format::kR32_Sfloat, sizeof(Vec3) + sizeof(F32));
+		cmdb->setVertexAttribute(U32(VertexAttributeId::POSITION), 0, Format::kR32G32B32Sfloat, 0);
+		cmdb->setVertexAttribute(U32(VertexAttributeId::SCALE), 0, Format::kR32Sfloat, sizeof(Vec3));
+		cmdb->setVertexAttribute(U32(VertexAttributeId::ALPHA), 0, Format::kR32Sfloat, sizeof(Vec3) + sizeof(F32));
 
 		// Vertex buff
 		cmdb->bindVertexBuffer(0, token.m_buffer, token.m_offset, VERTEX_SIZE, VertexStepRate::kInstance);

AnKi/Scene/DebugDrawer.cpp

@@ -167,7 +167,7 @@ void DebugDrawer2::drawCubes(ConstWeakArray<Mat4> mvps, const Vec4& color, F32 l
 	m_prog->getOrCreateVariant(variantInitInfo, variant);
 	cmdb->bindShaderProgram(variant->getProgram());
 
-	cmdb->setVertexAttribute(0, 0, Format::kR32G32B32_Sfloat, 0);
+	cmdb->setVertexAttribute(0, 0, Format::kR32G32B32Sfloat, 0);
 	cmdb->bindVertexBuffer(0, m_cubePositionsBuffer, 0, sizeof(Vec3));
 	cmdb->bindIndexBuffer(m_cubeIndicesBuffer, 0, IndexType::kU16);
 
@@ -209,7 +209,7 @@ void DebugDrawer2::drawLines(ConstWeakArray<Mat4> mvps, const Vec4& color, F32 l
 	m_prog->getOrCreateVariant(variantInitInfo, variant);
 	cmdb->bindShaderProgram(variant->getProgram());
 
-	cmdb->setVertexAttribute(0, 0, Format::kR32G32B32_Sfloat, 0);
+	cmdb->setVertexAttribute(0, 0, Format::kR32G32B32Sfloat, 0);
 	cmdb->bindVertexBuffer(0, vertsToken.m_buffer, vertsToken.m_offset, sizeof(Vec3));
 
 	cmdb->bindUniformBuffer(1, 0, unisToken.m_buffer, unisToken.m_offset, unisToken.m_range);
@@ -276,8 +276,8 @@ void DebugDrawer2::drawBillboardTextures(const Mat4& projMat, const Mat3x4& view
 	m_prog->getOrCreateVariant(variantInitInfo, variant);
 	cmdb->bindShaderProgram(variant->getProgram());
 
-	cmdb->setVertexAttribute(0, 0, Format::kR32G32B32_Sfloat, 0);
-	cmdb->setVertexAttribute(1, 1, Format::kR32G32_Sfloat, 0);
+	cmdb->setVertexAttribute(0, 0, Format::kR32G32B32Sfloat, 0);
+	cmdb->setVertexAttribute(1, 1, Format::kR32G32Sfloat, 0);
 	cmdb->bindVertexBuffer(0, positionsToken.m_buffer, positionsToken.m_offset, sizeof(Vec3));
 	cmdb->bindVertexBuffer(1, uvsToken.m_buffer, uvsToken.m_offset, sizeof(Vec2));
 

AnKi/Ui/Canvas.cpp

@@ -240,9 +240,9 @@ void Canvas::appendToCommandBufferInternal(CommandBufferPtr& cmdb)
 	cmdb->setViewport(0, 0, U32(fbWidth), U32(fbHeight));
 
 	cmdb->bindVertexBuffer(0, vertsToken.m_buffer, vertsToken.m_offset, sizeof(ImDrawVert));
-	cmdb->setVertexAttribute(0, 0, Format::kR32G32_Sfloat, 0);
-	cmdb->setVertexAttribute(1, 0, Format::kR8G8B8A8_Unorm, sizeof(Vec2) * 2);
-	cmdb->setVertexAttribute(2, 0, Format::kR32G32_Sfloat, sizeof(Vec2));
+	cmdb->setVertexAttribute(0, 0, Format::kR32G32Sfloat, 0);
+	cmdb->setVertexAttribute(1, 0, Format::kR8G8B8A8Unorm, sizeof(Vec2) * 2);
+	cmdb->setVertexAttribute(2, 0, Format::kR32G32Sfloat, sizeof(Vec2));
 
 	cmdb->bindIndexBuffer(indicesToken.m_buffer, indicesToken.m_offset, IndexType::kU16);
 

AnKi/Ui/Font.cpp

@@ -81,7 +81,7 @@ void Font::createTexture(const void* data, U32 width, U32 height)
 	TextureInitInfo texInit("Font");
 	texInit.m_width = width;
 	texInit.m_height = height;
-	texInit.m_format = Format::kR8G8B8A8_Unorm;
+	texInit.m_format = Format::kR8G8B8A8Unorm;
 	texInit.m_usage =
 		TextureUsageBit::kTransferDestination | TextureUsageBit::kSampledFragment | TextureUsageBit::kGenerateMipmaps;
 	texInit.m_mipmapCount = 1; // No mips because it will appear blurry with trilinear filtering

AnKi/Util/Xml.cpp

@@ -125,8 +125,6 @@ Error XmlElement::getAttributeTextOptional(CString name, CString& out, Bool& att
 	return Error::kNone;
 }
 
-CString XmlDocument::XML_HEADER = R"(<?xml version="1.0" encoding="UTF-8" ?>)";
-
 Error XmlDocument::loadFile(CString filename, GenericMemoryPoolAllocator<U8> alloc)
 {
 	File file;

AnKi/Util/Xml.h

@@ -193,7 +193,7 @@ private:
 class XmlDocument
 {
 public:
-	static CString XML_HEADER;
+	static constexpr CString kXmlHeader = R"(<?xml version="1.0" encoding="UTF-8" ?>)";
 
 	/// Parse from a file.
 	Error loadFile(CString filename, GenericMemoryPoolAllocator<U8> alloc);

Tests/Gr/Gr.cpp

@@ -325,7 +325,7 @@ static void* setStorage(PtrSize size, CommandBufferPtr& cmdb, U32 set, U32 bindi
 		cmdb_->copyBufferToTextureView(handle_.getBuffer(), handle_.getOffset(), handle_.getRange(), view); \
 	} while(0)
 
-constexpr Format DS_FORMAT = Format::kD24_Unorm_S8_Uint;
+constexpr Format kDsFormat = Format::kD24UnormS8Uint;
 
 static ShaderProgramPtr createProgram(CString vertSrc, CString fragSrc, GrManager& gr)
 {
@@ -563,7 +563,7 @@ ANKI_TEST(Gr, ViewportAndScissorOffscreen)
 	ShaderProgramPtr prog = createProgram(VERT_QUAD_STRIP_SRC, FRAG_SRC, *gr);
 	ShaderProgramPtr blitProg = createProgram(VERT_QUAD_SRC, FRAG_TEX_SRC, *gr);
 
-	const Format COL_FORMAT = Format::kR8G8B8A8_Unorm;
+	const Format COL_FORMAT = Format::kR8G8B8A8Unorm;
 	const U RT_WIDTH = 32;
 	const U RT_HEIGHT = 16;
 	TextureInitInfo init;
@@ -828,9 +828,9 @@ ANKI_TEST(Gr, DrawWithVertex)
 
 		cmdb->bindVertexBuffer(0, b, 0, sizeof(Vert));
 		cmdb->bindVertexBuffer(1, c, 0, sizeof(Vec3));
-		cmdb->setVertexAttribute(0, 0, Format::kR32G32B32_Sfloat, 0);
-		cmdb->setVertexAttribute(1, 0, Format::kR8G8B8_Unorm, sizeof(Vec3));
-		cmdb->setVertexAttribute(2, 1, Format::kR32G32B32_Sfloat, 0);
+		cmdb->setVertexAttribute(0, 0, Format::kR32G32B32Sfloat, 0);
+		cmdb->setVertexAttribute(1, 0, Format::kR8G8B8Unorm, sizeof(Vec3));
+		cmdb->setVertexAttribute(2, 1, Format::kR32G32B32Sfloat, 0);
 
 		cmdb->setViewport(0, 0, win->getWidth(), win->getHeight());
 		cmdb->setPolygonOffset(0.0, 0.0);
@@ -872,7 +872,7 @@ ANKI_TEST(Gr, Texture)
 
 	TextureInitInfo init;
 	init.m_depth = 1;
-	init.m_format = Format::kR8G8B8_Unorm;
+	init.m_format = Format::kR8G8B8Unorm;
 	init.m_usage = TextureUsageBit::kSampledFragment;
 	init.m_height = 4;
 	init.m_width = 4;
@@ -908,7 +908,7 @@ ANKI_TEST(Gr, DrawWithTexture)
 	//
 	TextureInitInfo init;
 	init.m_depth = 1;
-	init.m_format = Format::kR8G8B8_Unorm;
+	init.m_format = Format::kR8G8B8Unorm;
 	init.m_usage = TextureUsageBit::kSampledFragment | TextureUsageBit::kTransferDestination;
 	init.m_height = 2;
 	init.m_width = 2;
@@ -1104,7 +1104,7 @@ static void drawOffscreenDrawcalls([[maybe_unused]] GrManager& gr, ShaderProgram
 	*color = Vec4(0.0, 1.0, 0.0, 0.0);
 
 	cmdb->bindVertexBuffer(0, vertBuff, 0, sizeof(Vec3));
-	cmdb->setVertexAttribute(0, 0, Format::kR32G32B32_Sfloat, 0);
+	cmdb->setVertexAttribute(0, 0, Format::kR32G32B32Sfloat, 0);
 	cmdb->bindShaderProgram(prog);
 	cmdb->bindIndexBuffer(indexBuff, 0, IndexType::kU16);
 	cmdb->setViewport(0, 0, viewPortSize, viewPortSize);
@@ -1133,7 +1133,7 @@ static void drawOffscreen(GrManager& gr, Bool useSecondLevel)
 	samplerInit.m_mipmapFilter = SamplingFilter::kLinear;
 	SamplerPtr sampler = gr.newSampler(samplerInit);
 
-	const Format COL_FORMAT = Format::kR8G8B8A8_Unorm;
+	const Format COL_FORMAT = Format::kR8G8B8A8Unorm;
 	const U TEX_SIZE = 256;
 
 	TextureInitInfo init;
@@ -1149,7 +1149,7 @@ static void drawOffscreen(GrManager& gr, Bool useSecondLevel)
 	TextureViewPtr col0View = gr.newTextureView(TextureViewInitInfo(col0));
 	TextureViewPtr col1View = gr.newTextureView(TextureViewInitInfo(col1));
 
-	init.m_format = DS_FORMAT;
+	init.m_format = kDsFormat;
 	TexturePtr dp = gr.newTexture(init);
 
 	//
@@ -1293,7 +1293,7 @@ ANKI_TEST(Gr, ImageLoadStore)
 	init.m_usage =
 		TextureUsageBit::kTransferDestination | TextureUsageBit::kAllSampled | TextureUsageBit::kImageComputeWrite;
 	init.m_type = TextureType::k2D;
-	init.m_format = Format::kR8G8B8A8_Unorm;
+	init.m_format = Format::kR8G8B8A8Unorm;
 
 	TexturePtr tex = gr->newTexture(init);
 
@@ -1406,7 +1406,7 @@ ANKI_TEST(Gr, 3DTextures)
 	//
 	TextureInitInfo init;
 	init.m_depth = 1;
-	init.m_format = Format::kR8G8B8A8_Unorm;
+	init.m_format = Format::kR8G8B8A8Unorm;
 	init.m_usage = TextureUsageBit::kSampledFragment | TextureUsageBit::kTransferDestination;
 	init.m_height = 2;
 	init.m_width = 2;
@@ -1512,7 +1512,7 @@ static RenderTargetDescription newRTDescr(CString name)
 	RenderTargetDescription texInf(name);
 	texInf.m_width = texInf.m_height = 16;
 	texInf.m_usage = TextureUsageBit::kFramebufferWrite | TextureUsageBit::kSampledFragment;
-	texInf.m_format = Format::kR8G8B8A8_Unorm;
+	texInf.m_format = Format::kR8G8B8A8Unorm;
 	texInf.bake();
 	return texInf;
 }
@@ -1530,7 +1530,7 @@ ANKI_TEST(Gr, RenderGraph)
 	TextureInitInfo texI("dummy");
 	texI.m_width = texI.m_height = 16;
 	texI.m_usage = TextureUsageBit::kFramebufferWrite | TextureUsageBit::kSampledFragment;
-	texI.m_format = Format::kR8G8B8A8_Unorm;
+	texI.m_format = Format::kR8G8B8A8Unorm;
 	TexturePtr dummyTex = gr->newTexture(texI);
 
 	// SM
@@ -1762,7 +1762,7 @@ void main()
 	// Create the texture
 	TextureInitInfo texInit;
 	texInit.m_width = texInit.m_height = 8;
-	texInit.m_format = Format::kR8G8B8_Uint;
+	texInit.m_format = Format::kR8G8B8Uint;
 	texInit.m_type = TextureType::k2D;
 	texInit.m_usage = TextureUsageBit::kTransferDestination | TextureUsageBit::kAllSampled;
 	texInit.m_mipmapCount = 2;
@@ -2409,7 +2409,7 @@ ANKI_TEST(Gr, RayQuery)
 		init.m_bottomLevel.m_indexType = IndexType::kU16;
 		init.m_bottomLevel.m_positionBuffer = vertBuffer;
 		init.m_bottomLevel.m_positionCount = 3;
-		init.m_bottomLevel.m_positionsFormat = Format::kR32G32B32_Sfloat;
+		init.m_bottomLevel.m_positionsFormat = Format::kR32G32B32Sfloat;
 		init.m_bottomLevel.m_positionStride = 4 * 4;
 
 		blas = gr->newAccelerationStructure(init);
@@ -2755,7 +2755,7 @@ ANKI_TEST(Gr, RayGen)
 		TextureInitInfo inf("T_offscreen#1");
 		inf.m_width = WIDTH;
 		inf.m_height = HEIGHT;
-		inf.m_format = Format::kR8G8B8A8_Unorm;
+		inf.m_format = Format::kR8G8B8A8Unorm;
 		inf.m_usage = TextureUsageBit::kImageTraceRaysRead | TextureUsageBit::kImageTraceRaysWrite
 					  | TextureUsageBit::kImageComputeRead;
 
@@ -2862,7 +2862,7 @@ void main()
 			inf.m_bottomLevel.m_indexCount = g.m_indexCount;
 			inf.m_bottomLevel.m_positionBuffer = g.m_vertexBuffer;
 			inf.m_bottomLevel.m_positionCount = 8;
-			inf.m_bottomLevel.m_positionsFormat = Format::kR32G32B32_Sfloat;
+			inf.m_bottomLevel.m_positionsFormat = Format::kR32G32B32Sfloat;
 			inf.m_bottomLevel.m_positionStride = sizeof(Vec3);
 
 			g.m_blas = gr->newAccelerationStructure(inf);

Tests/Gr/GrTextureBuffer.cpp

@@ -59,7 +59,7 @@ void main()
 		cmdbInit.m_flags = CommandBufferFlag::kSmallBatch | CommandBufferFlag::kGeneralWork;
 		CommandBufferPtr cmdb = gr->newCommandBuffer(cmdbInit);
 
-		cmdb->bindReadOnlyTextureBuffer(0, 0, texBuff, 0, kMaxPtrSize, Format::kR8G8B8A8_Snorm);
+		cmdb->bindReadOnlyTextureBuffer(0, 0, texBuff, 0, kMaxPtrSize, Format::kR8G8B8A8Snorm);
 		cmdb->bindStorageBuffer(0, 1, storageBuff, 0, kMaxPtrSize);
 		cmdb->bindShaderProgram(prog);
 		cmdb->dispatchCompute(1, 1, 1);

Tools/Image/ImageImporterMain.cpp

@@ -40,7 +40,7 @@ Options:
 
 static Error parseCommandLineArgs(int argc, char** argv, ImageImporterConfig& config, Cleanup& cleanup)
 {
-	config.m_compressions = ImageBinaryDataCompression::S3TC | ImageBinaryDataCompression::ASTC;
+	config.m_compressions = ImageBinaryDataCompression::kS3tc | ImageBinaryDataCompression::kAstc;
 	config.m_noAlpha = false;
 	config.m_astcBlockSize = UVec2(8u);
 
@@ -76,19 +76,19 @@ static Error parseCommandLineArgs(int argc, char** argv, ImageImporterConfig& co
 
 			if(CString(argv[i]) == "2D")
 			{
-				config.m_type = ImageBinaryType::_2D;
+				config.m_type = ImageBinaryType::k2D;
 			}
 			else if(CString(argv[i]) == "3D")
 			{
-				config.m_type = ImageBinaryType::_3D;
+				config.m_type = ImageBinaryType::k3D;
 			}
 			else if(CString(argv[i]) == "Cube")
 			{
-				config.m_type = ImageBinaryType::CUBE;
+				config.m_type = ImageBinaryType::kCube;
 			}
 			else if(CString(argv[i]) == "2DArray")
 			{
-				config.m_type = ImageBinaryType::_2D_ARRAY;
+				config.m_type = ImageBinaryType::k2DArray;
 			}
 			else
 			{
@@ -109,11 +109,11 @@ static Error parseCommandLineArgs(int argc, char** argv, ImageImporterConfig& co
 
 			if(CString(argv[i]) == "1")
 			{
-				config.m_compressions |= ImageBinaryDataCompression::S3TC;
+				config.m_compressions |= ImageBinaryDataCompression::kS3tc;
 			}
 			else if(CString(argv[i]) == "0")
 			{
-				config.m_compressions = config.m_compressions & ~ImageBinaryDataCompression::S3TC;
+				config.m_compressions = config.m_compressions & ~ImageBinaryDataCompression::kS3tc;
 			}
 			else
 			{
@@ -130,11 +130,11 @@ static Error parseCommandLineArgs(int argc, char** argv, ImageImporterConfig& co
 
 			if(CString(argv[i]) == "1")
 			{
-				config.m_compressions |= ImageBinaryDataCompression::ASTC;
+				config.m_compressions |= ImageBinaryDataCompression::kAstc;
 			}
 			else if(CString(argv[i]) == "0")
 			{
-				config.m_compressions = config.m_compressions & ~ImageBinaryDataCompression::ASTC;
+				config.m_compressions = config.m_compressions & ~ImageBinaryDataCompression::kAstc;
 			}
 			else
 			{
@@ -151,11 +151,11 @@ static Error parseCommandLineArgs(int argc, char** argv, ImageImporterConfig& co
 
 			if(CString(argv[i]) == "1")
 			{
-				config.m_compressions |= ImageBinaryDataCompression::RAW;
+				config.m_compressions |= ImageBinaryDataCompression::kRaw;
 			}
 			else if(CString(argv[i]) == "0")
 			{
-				config.m_compressions = config.m_compressions & ~ImageBinaryDataCompression::RAW;
+				config.m_compressions = config.m_compressions & ~ImageBinaryDataCompression::kRaw;
 			}
 			else
 			{