Compressed texture formats have explicit sRGB variants

src/common/pixelformat.cpp

@@ -26,101 +26,126 @@ namespace love
 
 static PixelFormatInfo formatInfo[] =
 {
-	// components, blockW, blockH, blockSize, color, depth, stencil, compressed, dataType
-    { 0, 1, 1, 0, false, false, false, false, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_UNKNOWN
-
-	{ 0, 1, 1, 0, true, false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_NORMAL
-	{ 0, 1, 1, 0, true, false, false, false, PIXELFORMATTYPE_SFLOAT }, // PIXELFORMAT_HDR
-
-	{ 1, 1, 1, 1, true, false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_R8_UNORM
-	{ 1, 1, 1, 1, true, false, false, false, PIXELFORMATTYPE_SINT   }, // PIXELFORMAT_R8_INT
-	{ 1, 1, 1, 1, true, false, false, false, PIXELFORMATTYPE_UINT   }, // PIXELFORMAT_R8_UINT
-	{ 1, 1, 1, 2, true, false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_R16_UNORM
-	{ 1, 1, 1, 2, true, false, false, false, PIXELFORMATTYPE_SFLOAT }, // PIXELFORMAT_R16_FLOAT
-	{ 1, 1, 1, 2, true, false, false, false, PIXELFORMATTYPE_SINT   }, // PIXELFORMAT_R16_INT
-	{ 1, 1, 1, 2, true, false, false, false, PIXELFORMATTYPE_UINT   }, // PIXELFORMAT_R16_UINT
-	{ 1, 1, 1, 4, true, false, false, false, PIXELFORMATTYPE_SFLOAT }, // PIXELFORMAT_R32_FLOAT
-	{ 1, 1, 1, 4, true, false, false, false, PIXELFORMATTYPE_SINT   }, // PIXELFORMAT_R32_INT
-	{ 1, 1, 1, 4, true, false, false, false, PIXELFORMATTYPE_UINT   }, // PIXELFORMAT_R32_UINT
-
-	{ 2, 1, 1, 2, true, false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_RG8_UNORM
-	{ 2, 1, 1, 2, true, false, false, false, PIXELFORMATTYPE_SINT   }, // PIXELFORMAT_RG8_INT
-	{ 2, 1, 1, 2, true, false, false, false, PIXELFORMATTYPE_UINT   }, // PIXELFORMAT_RG8_UINT
-	{ 2, 1, 1, 2, true, false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_LA8_UNORM
-	{ 2, 1, 1, 4, true, false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_RG16_UNORM
-	{ 2, 1, 1, 4, true, false, false, false, PIXELFORMATTYPE_SFLOAT }, // PIXELFORMAT_RG16_FLOAT
-	{ 2, 1, 1, 4, true, false, false, false, PIXELFORMATTYPE_SINT   }, // PIXELFORMAT_RG16_INT
-	{ 2, 1, 1, 4, true, false, false, false, PIXELFORMATTYPE_UINT   }, // PIXELFORMAT_RG16_UINT
-	{ 2, 1, 1, 8, true, false, false, false, PIXELFORMATTYPE_SFLOAT }, // PIXELFORMAT_RG32_FLOAT
-	{ 2, 1, 1, 8, true, false, false, false, PIXELFORMATTYPE_SINT   }, // PIXELFORMAT_RG32_INT
-	{ 2, 1, 1, 8, true, false, false, false, PIXELFORMATTYPE_UINT   }, // PIXELFORMAT_RG32_UINT
-
-	{ 4, 1, 1, 4,  true, false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_RGBA8_UNORM
-	{ 4, 1, 1, 4,  true, false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_RGBA8_UNORM_sRGB
-	{ 4, 1, 1, 4,  true, false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_BGRA8_UNORM
-	{ 4, 1, 1, 4,  true, false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_BGRA8_UNORM_sRGB
-	{ 4, 1, 1, 4,  true, false, false, false, PIXELFORMATTYPE_SINT   }, // PIXELFORMAT_RGBA8_INT
-	{ 4, 1, 1, 4,  true, false, false, false, PIXELFORMATTYPE_UINT   }, // PIXELFORMAT_RGBA8_UINT
-	{ 4, 1, 1, 8,  true, false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_RGBA16_UNORM
-	{ 4, 1, 1, 8,  true, false, false, false, PIXELFORMATTYPE_SFLOAT }, // PIXELFORMAT_RGBA16_FLOAT
-	{ 4, 1, 1, 8,  true, false, false, false, PIXELFORMATTYPE_SINT   }, // PIXELFORMAT_RGBA16_INT
-	{ 4, 1, 1, 8,  true, false, false, false, PIXELFORMATTYPE_UINT   }, // PIXELFORMAT_RGBA16_UINT
-	{ 4, 1, 1, 16, true, false, false, false, PIXELFORMATTYPE_SFLOAT }, // PIXELFORMAT_RGBA32_FLOAT
-	{ 4, 1, 1, 16, true, false, false, false, PIXELFORMATTYPE_SINT   }, // PIXELFORMAT_RGBA32_INT
-	{ 4, 1, 1, 16, true, false, false, false, PIXELFORMATTYPE_UINT   }, // PIXELFORMAT_RGBA32_UINT
-
-	{ 4, 1, 1, 2, true, false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_RGBA4_UNORM
-	{ 4, 1, 1, 2, true, false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_RGB5A1_UNORM
-	{ 3, 1, 1, 2, true, false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_RGB565_UNORM
-	{ 4, 1, 1, 4, true, false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_RGB10A2_UNORM
-	{ 3, 1, 1, 4, true, false, false, false, PIXELFORMATTYPE_UFLOAT }, // PIXELFORMAT_RG11B10_FLOAT
-
-	{ 1, 1, 1, 1, false, false, true , false, PIXELFORMATTYPE_UINT   }, // PIXELFORMAT_STENCIL8
-	{ 1, 1, 1, 2, false, true,  false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_DEPTH16_UNORM
-	{ 1, 1, 1, 3, false, true,  false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_DEPTH24_UNORM
-	{ 1, 1, 1, 4, false, true,  false, false, PIXELFORMATTYPE_SFLOAT }, // PIXELFORMAT_DEPTH32_FLOAT
-	{ 2, 1, 1, 4, false, true,  true , false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_DEPTH24_UNORM_STENCIL8
-	{ 2, 1, 1, 5, false, true,  true , false, PIXELFORMATTYPE_SFLOAT }, // PIXELFORMAT_DEPTH32_FLOAT_STENCIL8
-
-	{ 3, 4, 4, 8,  true, false, false, true, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_DXT1_UNORM
-	{ 4, 4, 4, 16, true, false, false, true, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_DXT3_UNORM
-	{ 4, 4, 4, 16, true, false, false, true, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_DXT5_UNORM
-	{ 1, 4, 4, 8,  true, false, false, true, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_BC4_UNORM
-	{ 1, 4, 4, 8,  true, false, false, true, PIXELFORMATTYPE_SNORM  }, // PIXELFORMAT_BC4_SNORM
-	{ 2, 4, 4, 16, true, false, false, true, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_BC5_UNORM
-	{ 2, 4, 4, 16, true, false, false, true, PIXELFORMATTYPE_SNORM  }, // PIXELFORMAT_BC5_SNORM
-	{ 3, 4, 4, 16, true, false, false, true, PIXELFORMATTYPE_UFLOAT }, // PIXELFORMAT_BC6H_UFLOAT
-	{ 3, 4, 4, 16, true, false, false, true, PIXELFORMATTYPE_SFLOAT }, // PIXELFORMAT_BC6H_FLOAT
-	{ 4, 4, 4, 16, true, false, false, true, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_BC7_UNORM
-
-	{ 3, 16, 8, 32, true, false, false, true, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_PVR1_RGB2_UNORM
-	{ 3, 8,  8, 32, true, false, false, true, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_PVR1_RGB4_UNORM
-	{ 4, 16, 8, 32, true, false, false, true, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_PVR1_RGBA2_UNORM
-	{ 4, 8,  8, 32, true, false, false, true, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_PVR1_RGBA4_UNORM
-
-	{ 3, 4, 4, 8,  true, false, false, true, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ETC1_UNORM
-	{ 3, 4, 4, 8,  true, false, false, true, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ETC2_RGB_UNORM
-	{ 4, 4, 4, 16, true, false, false, true, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ETC2_RGBA_UNORM
-	{ 4, 4, 4, 8,  true, false, false, true, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ETC2_RGBA1_UNORM
-	{ 1, 4, 4, 8,  true, false, false, true, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_EAC_R_UNORM
-	{ 1, 4, 4, 8,  true, false, false, true, PIXELFORMATTYPE_SNORM }, // PIXELFORMAT_EAC_R_SNORM
-	{ 2, 4, 4, 16, true, false, false, true, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_EAC_RG_UNORM
-	{ 2, 4, 4, 16, true, false, false, true, PIXELFORMATTYPE_SNORM }, // PIXELFORMAT_EAC_RG_SNORM
-
-	{ 4, 4,  4,  1, true, false, false, true, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_4x4
-	{ 4, 5,  4,  1, true, false, false, true, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_5x4
-	{ 4, 5,  5,  1, true, false, false, true, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_5x5
-	{ 4, 6,  5,  1, true, false, false, true, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_6x5
-	{ 4, 6,  6,  1, true, false, false, true, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_6x6
-	{ 4, 8,  5,  1, true, false, false, true, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_8x5
-	{ 4, 8,  6,  1, true, false, false, true, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_8x6
-	{ 4, 8,  8,  1, true, false, false, true, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_8x8
-	{ 4, 8,  5,  1, true, false, false, true, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_10x5
-	{ 4, 10, 6,  1, true, false, false, true, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_10x6
-	{ 4, 10, 8,  1, true, false, false, true, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_10x8
-	{ 4, 10, 10, 1, true, false, false, true, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_10x10
-	{ 4, 12, 10, 1, true, false, false, true, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_12x10
-	{ 4, 12, 12, 1, true, false, false, true, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_12x12
+	// components, blockW, blockH, blockSize, color, depth, stencil, compressed, sRGB, dataType
+    { 0, 1, 1, 0, false, false, false, false, false, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_UNKNOWN
+
+	{ 0, 1, 1, 0, true, false, false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_NORMAL
+	{ 0, 1, 1, 0, true, false, false, false, false, PIXELFORMATTYPE_SFLOAT }, // PIXELFORMAT_HDR
+
+	{ 1, 1, 1, 1, true, false, false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_R8_UNORM
+	{ 1, 1, 1, 1, true, false, false, false, false, PIXELFORMATTYPE_SINT   }, // PIXELFORMAT_R8_INT
+	{ 1, 1, 1, 1, true, false, false, false, false, PIXELFORMATTYPE_UINT   }, // PIXELFORMAT_R8_UINT
+	{ 1, 1, 1, 2, true, false, false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_R16_UNORM
+	{ 1, 1, 1, 2, true, false, false, false, false, PIXELFORMATTYPE_SFLOAT }, // PIXELFORMAT_R16_FLOAT
+	{ 1, 1, 1, 2, true, false, false, false, false, PIXELFORMATTYPE_SINT   }, // PIXELFORMAT_R16_INT
+	{ 1, 1, 1, 2, true, false, false, false, false, PIXELFORMATTYPE_UINT   }, // PIXELFORMAT_R16_UINT
+	{ 1, 1, 1, 4, true, false, false, false, false, PIXELFORMATTYPE_SFLOAT }, // PIXELFORMAT_R32_FLOAT
+	{ 1, 1, 1, 4, true, false, false, false, false, PIXELFORMATTYPE_SINT   }, // PIXELFORMAT_R32_INT
+	{ 1, 1, 1, 4, true, false, false, false, false, PIXELFORMATTYPE_UINT   }, // PIXELFORMAT_R32_UINT
+
+	{ 2, 1, 1, 2, true, false, false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_RG8_UNORM
+	{ 2, 1, 1, 2, true, false, false, false, false, PIXELFORMATTYPE_SINT   }, // PIXELFORMAT_RG8_INT
+	{ 2, 1, 1, 2, true, false, false, false, false, PIXELFORMATTYPE_UINT   }, // PIXELFORMAT_RG8_UINT
+	{ 2, 1, 1, 2, true, false, false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_LA8_UNORM
+	{ 2, 1, 1, 4, true, false, false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_RG16_UNORM
+	{ 2, 1, 1, 4, true, false, false, false, false, PIXELFORMATTYPE_SFLOAT }, // PIXELFORMAT_RG16_FLOAT
+	{ 2, 1, 1, 4, true, false, false, false, false, PIXELFORMATTYPE_SINT   }, // PIXELFORMAT_RG16_INT
+	{ 2, 1, 1, 4, true, false, false, false, false, PIXELFORMATTYPE_UINT   }, // PIXELFORMAT_RG16_UINT
+	{ 2, 1, 1, 8, true, false, false, false, false, PIXELFORMATTYPE_SFLOAT }, // PIXELFORMAT_RG32_FLOAT
+	{ 2, 1, 1, 8, true, false, false, false, false, PIXELFORMATTYPE_SINT   }, // PIXELFORMAT_RG32_INT
+	{ 2, 1, 1, 8, true, false, false, false, false, PIXELFORMATTYPE_UINT   }, // PIXELFORMAT_RG32_UINT
+
+	{ 4, 1, 1, 4,  true, false, false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_RGBA8_UNORM
+	{ 4, 1, 1, 4,  true, false, false, false, true,  PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_RGBA8_sRGB
+	{ 4, 1, 1, 4,  true, false, false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_BGRA8_UNORM
+	{ 4, 1, 1, 4,  true, false, false, false, true,  PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_BGRA8_sRGB
+	{ 4, 1, 1, 4,  true, false, false, false, false, PIXELFORMATTYPE_SINT   }, // PIXELFORMAT_RGBA8_INT
+	{ 4, 1, 1, 4,  true, false, false, false, false, PIXELFORMATTYPE_UINT   }, // PIXELFORMAT_RGBA8_UINT
+	{ 4, 1, 1, 8,  true, false, false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_RGBA16_UNORM
+	{ 4, 1, 1, 8,  true, false, false, false, false, PIXELFORMATTYPE_SFLOAT }, // PIXELFORMAT_RGBA16_FLOAT
+	{ 4, 1, 1, 8,  true, false, false, false, false, PIXELFORMATTYPE_SINT   }, // PIXELFORMAT_RGBA16_INT
+	{ 4, 1, 1, 8,  true, false, false, false, false, PIXELFORMATTYPE_UINT   }, // PIXELFORMAT_RGBA16_UINT
+	{ 4, 1, 1, 16, true, false, false, false, false, PIXELFORMATTYPE_SFLOAT }, // PIXELFORMAT_RGBA32_FLOAT
+	{ 4, 1, 1, 16, true, false, false, false, false, PIXELFORMATTYPE_SINT   }, // PIXELFORMAT_RGBA32_INT
+	{ 4, 1, 1, 16, true, false, false, false, false, PIXELFORMATTYPE_UINT   }, // PIXELFORMAT_RGBA32_UINT
+
+	{ 4, 1, 1, 2, true, false, false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_RGBA4_UNORM
+	{ 4, 1, 1, 2, true, false, false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_RGB5A1_UNORM
+	{ 3, 1, 1, 2, true, false, false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_RGB565_UNORM
+	{ 4, 1, 1, 4, true, false, false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_RGB10A2_UNORM
+	{ 3, 1, 1, 4, true, false, false, false, false, PIXELFORMATTYPE_UFLOAT }, // PIXELFORMAT_RG11B10_FLOAT
+
+	{ 1, 1, 1, 1, false, false, true , false, false, PIXELFORMATTYPE_UINT   }, // PIXELFORMAT_STENCIL8
+	{ 1, 1, 1, 2, false, true,  false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_DEPTH16_UNORM
+	{ 1, 1, 1, 3, false, true,  false, false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_DEPTH24_UNORM
+	{ 1, 1, 1, 4, false, true,  false, false, false, PIXELFORMATTYPE_SFLOAT }, // PIXELFORMAT_DEPTH32_FLOAT
+	{ 2, 1, 1, 4, false, true,  true , false, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_DEPTH24_UNORM_STENCIL8
+	{ 2, 1, 1, 5, false, true,  true , false, false, PIXELFORMATTYPE_SFLOAT }, // PIXELFORMAT_DEPTH32_FLOAT_STENCIL8
+
+	{ 3, 4, 4, 8,  true, false, false, true, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_DXT1_UNORM
+	{ 3, 4, 4, 8,  true, false, false, true, true,  PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_DXT1_sRGB
+	{ 4, 4, 4, 16, true, false, false, true, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_DXT3_UNORM
+	{ 4, 4, 4, 16, true, false, false, true, true,  PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_DXT3_sRGB
+	{ 4, 4, 4, 16, true, false, false, true, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_DXT5_UNORM
+	{ 4, 4, 4, 16, true, false, false, true, true,  PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_DXT5_sRGB
+	{ 1, 4, 4, 8,  true, false, false, true, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_BC4_UNORM
+	{ 1, 4, 4, 8,  true, false, false, true, false, PIXELFORMATTYPE_SNORM  }, // PIXELFORMAT_BC4_SNORM
+	{ 2, 4, 4, 16, true, false, false, true, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_BC5_UNORM
+	{ 2, 4, 4, 16, true, false, false, true, false, PIXELFORMATTYPE_SNORM  }, // PIXELFORMAT_BC5_SNORM
+	{ 3, 4, 4, 16, true, false, false, true, false, PIXELFORMATTYPE_UFLOAT }, // PIXELFORMAT_BC6H_UFLOAT
+	{ 3, 4, 4, 16, true, false, false, true, false, PIXELFORMATTYPE_SFLOAT }, // PIXELFORMAT_BC6H_FLOAT
+	{ 4, 4, 4, 16, true, false, false, true, false, PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_BC7_UNORM
+	{ 4, 4, 4, 16, true, false, false, true, true,  PIXELFORMATTYPE_UNORM  }, // PIXELFORMAT_BC7_sRGB
+
+	{ 3, 16, 8, 32, true, false, false, true, false, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_PVR1_RGB2_UNORM
+	{ 3, 16, 8, 32, true, false, false, true, true,  PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_PVR1_RGB2_sRGB
+	{ 3, 8,  8, 32, true, false, false, true, false, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_PVR1_RGB4_UNORM
+	{ 3, 8,  8, 32, true, false, false, true, true,  PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_PVR1_RGB4_sRGB
+	{ 4, 16, 8, 32, true, false, false, true, false, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_PVR1_RGBA2_UNORM
+	{ 4, 16, 8, 32, true, false, false, true, true,  PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_PVR1_RGBA2_sRGB
+	{ 4, 8,  8, 32, true, false, false, true, false, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_PVR1_RGBA4_UNORM
+	{ 4, 8,  8, 32, true, false, false, true, true,  PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_PVR1_RGBA4_sRGB
+
+	{ 3, 4, 4, 8,  true, false, false, true, false, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ETC1_UNORM
+	{ 3, 4, 4, 8,  true, false, false, true, false, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ETC2_RGB_UNORM
+	{ 3, 4, 4, 8,  true, false, false, true, true,  PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ETC2_RGB_sRGB
+	{ 4, 4, 4, 16, true, false, false, true, false, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ETC2_RGBA_UNORM
+	{ 4, 4, 4, 16, true, false, false, true, true,  PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ETC2_RGBA_sRGB
+	{ 4, 4, 4, 8,  true, false, false, true, false, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ETC2_RGBA1_UNORM
+	{ 4, 4, 4, 8,  true, false, false, true, true,  PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ETC2_RGBA1_sRGB
+	{ 1, 4, 4, 8,  true, false, false, true, false, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_EAC_R_UNORM
+	{ 1, 4, 4, 8,  true, false, false, true, false, PIXELFORMATTYPE_SNORM }, // PIXELFORMAT_EAC_R_SNORM
+	{ 2, 4, 4, 16, true, false, false, true, false, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_EAC_RG_UNORM
+	{ 2, 4, 4, 16, true, false, false, true, false, PIXELFORMATTYPE_SNORM }, // PIXELFORMAT_EAC_RG_SNORM
+
+	{ 4, 4,  4,  1, true, false, false, true, false, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_4x4_UNORM
+	{ 4, 5,  4,  1, true, false, false, true, false, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_5x4_UNORM
+	{ 4, 5,  5,  1, true, false, false, true, false, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_5x5_UNORM
+	{ 4, 6,  5,  1, true, false, false, true, false, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_6x5_UNORM
+	{ 4, 6,  6,  1, true, false, false, true, false, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_6x6_UNORM
+	{ 4, 8,  5,  1, true, false, false, true, false, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_8x5_UNORM
+	{ 4, 8,  6,  1, true, false, false, true, false, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_8x6_UNORM
+	{ 4, 8,  8,  1, true, false, false, true, false, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_8x8_UNORM
+	{ 4, 8,  5,  1, true, false, false, true, false, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_10x5_UNORM
+	{ 4, 10, 6,  1, true, false, false, true, false, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_10x6_UNORM
+	{ 4, 10, 8,  1, true, false, false, true, false, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_10x8_UNORM
+	{ 4, 10, 10, 1, true, false, false, true, false, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_10x10_UNORM
+	{ 4, 12, 10, 1, true, false, false, true, false, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_12x10_UNORM
+	{ 4, 12, 12, 1, true, false, false, true, false, PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_12x12_UNORM
+	{ 4, 4,  4,  1, true, false, false, true, true,  PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_4x4_sRGB
+	{ 4, 5,  4,  1, true, false, false, true, true,  PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_5x4_sRGB
+	{ 4, 5,  5,  1, true, false, false, true, true,  PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_5x5_sRGB
+	{ 4, 6,  5,  1, true, false, false, true, true,  PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_6x5_sRGB
+	{ 4, 6,  6,  1, true, false, false, true, true,  PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_6x6_sRGB
+	{ 4, 8,  5,  1, true, false, false, true, true,  PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_8x5_sRGB
+	{ 4, 8,  6,  1, true, false, false, true, true,  PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_8x6_sRGB
+	{ 4, 8,  8,  1, true, false, false, true, true,  PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_8x8_sRGB
+	{ 4, 8,  5,  1, true, false, false, true, true,  PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_10x5_sRGB
+	{ 4, 10, 6,  1, true, false, false, true, true,  PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_10x6_sRGB
+	{ 4, 10, 8,  1, true, false, false, true, true,  PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_10x8_sRGB
+	{ 4, 10, 10, 1, true, false, false, true, true,  PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_10x10_sRGB
+	{ 4, 12, 10, 1, true, false, false, true, true,  PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_12x10_sRGB
+	{ 4, 12, 12, 1, true, false, false, true, true,  PIXELFORMATTYPE_UNORM }, // PIXELFORMAT_ASTC_12x12_sRGB
 };
 
 static_assert(sizeof(formatInfo) / sizeof(PixelFormatInfo) == PIXELFORMAT_MAX_ENUM, "Update the formatInfo array when adding or removing a PixelFormat");
@@ -155,19 +180,19 @@ static StringMap<PixelFormat, PIXELFORMAT_MAX_ENUM>::Entry formatEntries[] =
 	{ "rg32i",  PIXELFORMAT_RG32_INT   },
 	{ "rg32ui", PIXELFORMAT_RG32_UINT  },
 
-	{ "rgba8",     PIXELFORMAT_RGBA8_UNORM      },
-	{ "srgba8",    PIXELFORMAT_RGBA8_UNORM_sRGB },
-	{ "bgra8",     PIXELFORMAT_BGRA8_UNORM      },
-	{ "bgra8srgb", PIXELFORMAT_BGRA8_UNORM_sRGB },
-	{ "rgba8i",    PIXELFORMAT_RGBA8_INT        },
-	{ "rgba8ui",   PIXELFORMAT_RGBA8_UINT       },
-	{ "rgba16",    PIXELFORMAT_RGBA16_UNORM     },
-	{ "rgba16f",   PIXELFORMAT_RGBA16_FLOAT     },
-	{ "rgba16i",   PIXELFORMAT_RGBA16_INT       },
-	{ "rgba16ui",  PIXELFORMAT_RGBA16_UINT      },
-	{ "rgba32f",   PIXELFORMAT_RGBA32_FLOAT     },
-	{ "rgba32i",   PIXELFORMAT_RGBA32_INT       },
-	{ "rgba32ui",  PIXELFORMAT_RGBA32_UINT      },
+	{ "rgba8",     PIXELFORMAT_RGBA8_UNORM  },
+	{ "srgba8",    PIXELFORMAT_RGBA8_sRGB   },
+	{ "bgra8",     PIXELFORMAT_BGRA8_UNORM  },
+	{ "bgra8srgb", PIXELFORMAT_BGRA8_sRGB   },
+	{ "rgba8i",    PIXELFORMAT_RGBA8_INT    },
+	{ "rgba8ui",   PIXELFORMAT_RGBA8_UINT   },
+	{ "rgba16",    PIXELFORMAT_RGBA16_UNORM },
+	{ "rgba16f",   PIXELFORMAT_RGBA16_FLOAT },
+	{ "rgba16i",   PIXELFORMAT_RGBA16_INT   },
+	{ "rgba16ui",  PIXELFORMAT_RGBA16_UINT  },
+	{ "rgba32f",   PIXELFORMAT_RGBA32_FLOAT },
+	{ "rgba32i",   PIXELFORMAT_RGBA32_INT   },
+	{ "rgba32ui",  PIXELFORMAT_RGBA32_UINT  },
 
 	{ "rgba4",    PIXELFORMAT_RGBA4_UNORM    },
 	{ "rgb5a1",   PIXELFORMAT_RGB5A1_UNORM   },
@@ -182,43 +207,70 @@ static StringMap<PixelFormat, PIXELFORMAT_MAX_ENUM>::Entry formatEntries[] =
 	{ "depth24stencil8",  PIXELFORMAT_DEPTH24_UNORM_STENCIL8 },
 	{ "depth32fstencil8", PIXELFORMAT_DEPTH32_FLOAT_STENCIL8 },
 	
-	{ "DXT1",      PIXELFORMAT_DXT1_UNORM       },
-	{ "DXT3",      PIXELFORMAT_DXT3_UNORM       },
-	{ "DXT5",      PIXELFORMAT_DXT5_UNORM       },
-	{ "BC4",       PIXELFORMAT_BC4_UNORM        },
-	{ "BC4s",      PIXELFORMAT_BC4_SNORM        },
-	{ "BC5",       PIXELFORMAT_BC5_UNORM        },
-	{ "BC5s",      PIXELFORMAT_BC5_SNORM        },
-	{ "BC6h",      PIXELFORMAT_BC6H_UFLOAT      },
-	{ "BC6hs",     PIXELFORMAT_BC6H_FLOAT       },
-	{ "BC7",       PIXELFORMAT_BC7_UNORM        },
-	{ "PVR1rgb2",  PIXELFORMAT_PVR1_RGB2_UNORM  },
-	{ "PVR1rgb4",  PIXELFORMAT_PVR1_RGB4_UNORM  },
-	{ "PVR1rgba2", PIXELFORMAT_PVR1_RGBA2_UNORM },
-	{ "PVR1rgba4", PIXELFORMAT_PVR1_RGBA4_UNORM },
-	{ "ETC1",      PIXELFORMAT_ETC1_UNORM       },
-	{ "ETC2rgb",   PIXELFORMAT_ETC2_RGB_UNORM   },
-	{ "ETC2rgba",  PIXELFORMAT_ETC2_RGBA_UNORM  },
-	{ "ETC2rgba1", PIXELFORMAT_ETC2_RGBA1_UNORM },
-	{ "EACr",      PIXELFORMAT_EAC_R_UNORM      },
-	{ "EACrs",     PIXELFORMAT_EAC_R_SNORM      },
-	{ "EACrg",     PIXELFORMAT_EAC_RG_UNORM     },
-	{ "EACrgs",    PIXELFORMAT_EAC_RG_SNORM     },
-
-	{ "ASTC4x4",   PIXELFORMAT_ASTC_4x4   },
-	{ "ASTC5x4",   PIXELFORMAT_ASTC_5x4   },
-	{ "ASTC5x5",   PIXELFORMAT_ASTC_5x5   },
-	{ "ASTC6x5",   PIXELFORMAT_ASTC_6x5   },
-	{ "ASTC6x6",   PIXELFORMAT_ASTC_6x6   },
-	{ "ASTC8x5",   PIXELFORMAT_ASTC_8x5   },
-	{ "ASTC8x6",   PIXELFORMAT_ASTC_8x6   },
-	{ "ASTC8x8",   PIXELFORMAT_ASTC_8x8   },
-	{ "ASTC10x5",  PIXELFORMAT_ASTC_10x5  },
-	{ "ASTC10x6",  PIXELFORMAT_ASTC_10x6  },
-	{ "ASTC10x8",  PIXELFORMAT_ASTC_10x8  },
-	{ "ASTC10x10", PIXELFORMAT_ASTC_10x10 },
-	{ "ASTC12x10", PIXELFORMAT_ASTC_12x10 },
-	{ "ASTC12x12", PIXELFORMAT_ASTC_12x12 },
+	{ "DXT1",     PIXELFORMAT_DXT1_UNORM  },
+	{ "DXT1srgb", PIXELFORMAT_DXT1_sRGB   },
+	{ "DXT3",     PIXELFORMAT_DXT3_UNORM  },
+	{ "DXT3srgb", PIXELFORMAT_DXT3_sRGB   },
+	{ "DXT5",     PIXELFORMAT_DXT5_UNORM  },
+	{ "DXT5srgb", PIXELFORMAT_DXT5_sRGB   },
+	{ "BC4",      PIXELFORMAT_BC4_UNORM   },
+	{ "BC4s",     PIXELFORMAT_BC4_SNORM   },
+	{ "BC5",      PIXELFORMAT_BC5_UNORM   },
+	{ "BC5s",     PIXELFORMAT_BC5_SNORM   },
+	{ "BC6h",     PIXELFORMAT_BC6H_UFLOAT },
+	{ "BC6hs",    PIXELFORMAT_BC6H_FLOAT  },
+	{ "BC7",      PIXELFORMAT_BC7_UNORM   },
+	{ "BC7srgb",  PIXELFORMAT_BC7_sRGB    },
+
+	{ "PVR1rgb2",      PIXELFORMAT_PVR1_RGB2_UNORM  },
+	{ "PVR1rgb2srgb",  PIXELFORMAT_PVR1_RGB2_sRGB   },
+	{ "PVR1rgb4",      PIXELFORMAT_PVR1_RGB4_UNORM  },
+	{ "PVR1rgb4srgb",  PIXELFORMAT_PVR1_RGB4_sRGB   },
+	{ "PVR1rgba2",     PIXELFORMAT_PVR1_RGBA2_UNORM },
+	{ "PVR1rgba2srgb", PIXELFORMAT_PVR1_RGBA2_sRGB  },
+	{ "PVR1rgba4",     PIXELFORMAT_PVR1_RGBA4_UNORM },
+	{ "PVR1rgba4srgb", PIXELFORMAT_PVR1_RGBA4_sRGB  },
+
+	{ "ETC1",       PIXELFORMAT_ETC1_UNORM       },
+	{ "ETC2rgb",    PIXELFORMAT_ETC2_RGB_UNORM   },
+	{ "ETC2srgb",   PIXELFORMAT_ETC2_RGB_sRGB    },
+	{ "ETC2rgba",   PIXELFORMAT_ETC2_RGBA_UNORM  },
+	{ "ETC2srgba",  PIXELFORMAT_ETC2_RGBA_sRGB   },
+	{ "ETC2rgba1",  PIXELFORMAT_ETC2_RGBA1_UNORM },
+	{ "ETC2srgba1", PIXELFORMAT_ETC2_RGBA1_sRGB  },
+	{ "EACr",       PIXELFORMAT_EAC_R_UNORM      },
+	{ "EACrs",      PIXELFORMAT_EAC_R_SNORM      },
+	{ "EACrg",      PIXELFORMAT_EAC_RG_UNORM     },
+	{ "EACrgs",     PIXELFORMAT_EAC_RG_SNORM     },
+
+	{ "ASTC4x4",       PIXELFORMAT_ASTC_4x4_UNORM   },
+	{ "ASTC5x4",       PIXELFORMAT_ASTC_5x4_UNORM   },
+	{ "ASTC5x5",       PIXELFORMAT_ASTC_5x5_UNORM   },
+	{ "ASTC6x5",       PIXELFORMAT_ASTC_6x5_UNORM   },
+	{ "ASTC6x6",       PIXELFORMAT_ASTC_6x6_UNORM   },
+	{ "ASTC8x5",       PIXELFORMAT_ASTC_8x5_UNORM   },
+	{ "ASTC8x6",       PIXELFORMAT_ASTC_8x6_UNORM   },
+	{ "ASTC8x8",       PIXELFORMAT_ASTC_8x8_UNORM   },
+	{ "ASTC10x5",      PIXELFORMAT_ASTC_10x5_UNORM  },
+	{ "ASTC10x6",      PIXELFORMAT_ASTC_10x6_UNORM  },
+	{ "ASTC10x8",      PIXELFORMAT_ASTC_10x8_UNORM  },
+	{ "ASTC10x10",     PIXELFORMAT_ASTC_10x10_UNORM },
+	{ "ASTC12x10",     PIXELFORMAT_ASTC_12x10_UNORM },
+	{ "ASTC12x12",     PIXELFORMAT_ASTC_12x12_UNORM },
+	{ "ASTC4x4srgb",   PIXELFORMAT_ASTC_4x4_sRGB    },
+	{ "ASTC5x4srgb",   PIXELFORMAT_ASTC_5x4_sRGB    },
+	{ "ASTC5x5srgb",   PIXELFORMAT_ASTC_5x5_sRGB    },
+	{ "ASTC6x5srgb",   PIXELFORMAT_ASTC_6x5_sRGB    },
+	{ "ASTC6x6srgb",   PIXELFORMAT_ASTC_6x6_sRGB    },
+	{ "ASTC8x5srgb",   PIXELFORMAT_ASTC_8x5_sRGB    },
+	{ "ASTC8x6srgb",   PIXELFORMAT_ASTC_8x6_sRGB    },
+	{ "ASTC8x8srgb",   PIXELFORMAT_ASTC_8x8_sRGB    },
+	{ "ASTC10x5srgb",  PIXELFORMAT_ASTC_10x5_sRGB   },
+	{ "ASTC10x6srgb",  PIXELFORMAT_ASTC_10x6_sRGB   },
+	{ "ASTC10x8srgb",  PIXELFORMAT_ASTC_10x8_sRGB   },
+	{ "ASTC10x10srgb", PIXELFORMAT_ASTC_10x10_sRGB  },
+	{ "ASTC12x10srgb", PIXELFORMAT_ASTC_12x10_sRGB  },
+	{ "ASTC12x12srgb", PIXELFORMAT_ASTC_12x12_sRGB  },
 };
 
 static_assert(sizeof(formatEntries) / sizeof(formatEntries[0]) == (size_t) PIXELFORMAT_MAX_ENUM, "pixel format string map is missing entries!");
@@ -275,7 +327,7 @@ bool isPixelFormatStencil(PixelFormat format)
 
 bool isPixelFormatSRGB(PixelFormat format)
 {
-	return format == PIXELFORMAT_RGBA8_UNORM_sRGB || format == PIXELFORMAT_BGRA8_UNORM_sRGB;
+	return formatInfo[format].sRGB;
 }
 
 bool isPixelFormatInteger(PixelFormat format)
@@ -286,19 +338,70 @@ bool isPixelFormatInteger(PixelFormat format)
 
 PixelFormat getSRGBPixelFormat(PixelFormat format)
 {
-	if (format == PIXELFORMAT_RGBA8_UNORM)
-		return PIXELFORMAT_RGBA8_UNORM_sRGB;
-	else if (format == PIXELFORMAT_BGRA8_UNORM)
-		return PIXELFORMAT_BGRA8_UNORM_sRGB;
+	switch (format)
+	{
+	case PIXELFORMAT_RGBA8_UNORM: return PIXELFORMAT_RGBA8_sRGB;
+	case PIXELFORMAT_BGRA8_UNORM: return PIXELFORMAT_BGRA8_sRGB;
+	case PIXELFORMAT_PVR1_RGB2_UNORM: return PIXELFORMAT_PVR1_RGB2_sRGB;
+	case PIXELFORMAT_PVR1_RGB4_UNORM: return PIXELFORMAT_PVR1_RGB4_sRGB;
+	case PIXELFORMAT_PVR1_RGBA2_UNORM: return PIXELFORMAT_PVR1_RGBA2_sRGB;
+	case PIXELFORMAT_PVR1_RGBA4_UNORM: return PIXELFORMAT_PVR1_RGBA4_sRGB;
+	case PIXELFORMAT_ETC1_UNORM: return PIXELFORMAT_ETC2_RGB_sRGB; // ETC2 can load ETC1 data.
+	case PIXELFORMAT_ETC2_RGB_UNORM: return PIXELFORMAT_ETC2_RGB_sRGB;
+	case PIXELFORMAT_ETC2_RGBA_UNORM: return PIXELFORMAT_ETC2_RGBA_sRGB;
+	case PIXELFORMAT_ETC2_RGBA1_UNORM: return PIXELFORMAT_ETC2_RGBA1_sRGB;
+	case PIXELFORMAT_ASTC_4x4_UNORM: return PIXELFORMAT_ASTC_4x4_sRGB;
+	case PIXELFORMAT_ASTC_5x4_UNORM: return PIXELFORMAT_ASTC_5x4_sRGB;
+	case PIXELFORMAT_ASTC_5x5_UNORM: return PIXELFORMAT_ASTC_5x5_sRGB;
+	case PIXELFORMAT_ASTC_6x5_UNORM: return PIXELFORMAT_ASTC_6x5_sRGB;
+	case PIXELFORMAT_ASTC_6x6_UNORM: return PIXELFORMAT_ASTC_6x6_sRGB;
+	case PIXELFORMAT_ASTC_8x5_UNORM: return PIXELFORMAT_ASTC_8x5_sRGB;
+	case PIXELFORMAT_ASTC_8x6_UNORM: return PIXELFORMAT_ASTC_8x6_sRGB;
+	case PIXELFORMAT_ASTC_8x8_UNORM: return PIXELFORMAT_ASTC_8x8_sRGB;
+	case PIXELFORMAT_ASTC_10x5_UNORM: return PIXELFORMAT_ASTC_10x5_sRGB;
+	case PIXELFORMAT_ASTC_10x6_UNORM: return PIXELFORMAT_ASTC_10x6_sRGB;
+	case PIXELFORMAT_ASTC_10x8_UNORM: return PIXELFORMAT_ASTC_10x8_sRGB;
+	case PIXELFORMAT_ASTC_10x10_UNORM: return PIXELFORMAT_ASTC_10x10_sRGB;
+	case PIXELFORMAT_ASTC_12x10_UNORM: return PIXELFORMAT_ASTC_12x10_sRGB;
+	case PIXELFORMAT_ASTC_12x12_UNORM: return PIXELFORMAT_ASTC_12x12_sRGB;
+	default:
+		break;
+	}
+
 	return format;
 }
 
 PixelFormat getLinearPixelFormat(PixelFormat format)
 {
-	if (format == PIXELFORMAT_RGBA8_UNORM_sRGB)
-		return PIXELFORMAT_RGBA8_UNORM;
-	else if (format == PIXELFORMAT_BGRA8_UNORM_sRGB)
-		return PIXELFORMAT_BGRA8_UNORM;
+	switch (format)
+	{
+	case PIXELFORMAT_RGBA8_sRGB: return PIXELFORMAT_RGBA8_UNORM;
+	case PIXELFORMAT_BGRA8_sRGB: return PIXELFORMAT_BGRA8_UNORM;
+	case PIXELFORMAT_PVR1_RGB2_sRGB: return PIXELFORMAT_PVR1_RGB2_UNORM;
+	case PIXELFORMAT_PVR1_RGB4_sRGB: return PIXELFORMAT_PVR1_RGB4_UNORM;
+	case PIXELFORMAT_PVR1_RGBA2_sRGB: return PIXELFORMAT_PVR1_RGBA2_UNORM;
+	case PIXELFORMAT_PVR1_RGBA4_sRGB: return PIXELFORMAT_PVR1_RGBA4_UNORM;
+	case PIXELFORMAT_ETC2_RGB_sRGB: return PIXELFORMAT_ETC2_RGB_UNORM;
+	case PIXELFORMAT_ETC2_RGBA_sRGB: return PIXELFORMAT_ETC2_RGBA_UNORM;
+	case PIXELFORMAT_ETC2_RGBA1_sRGB: return PIXELFORMAT_ETC2_RGBA1_UNORM;
+	case PIXELFORMAT_ASTC_4x4_sRGB: return PIXELFORMAT_ASTC_4x4_UNORM;
+	case PIXELFORMAT_ASTC_5x4_sRGB: return PIXELFORMAT_ASTC_5x4_UNORM;
+	case PIXELFORMAT_ASTC_5x5_sRGB: return PIXELFORMAT_ASTC_5x5_UNORM;
+	case PIXELFORMAT_ASTC_6x5_sRGB: return PIXELFORMAT_ASTC_6x5_UNORM;
+	case PIXELFORMAT_ASTC_6x6_sRGB: return PIXELFORMAT_ASTC_6x6_UNORM;
+	case PIXELFORMAT_ASTC_8x5_sRGB: return PIXELFORMAT_ASTC_8x5_UNORM;
+	case PIXELFORMAT_ASTC_8x6_sRGB: return PIXELFORMAT_ASTC_8x6_UNORM;
+	case PIXELFORMAT_ASTC_8x8_sRGB: return PIXELFORMAT_ASTC_8x8_UNORM;
+	case PIXELFORMAT_ASTC_10x5_sRGB: return PIXELFORMAT_ASTC_10x5_UNORM;
+	case PIXELFORMAT_ASTC_10x6_sRGB: return PIXELFORMAT_ASTC_10x6_UNORM;
+	case PIXELFORMAT_ASTC_10x8_sRGB: return PIXELFORMAT_ASTC_10x8_UNORM;
+	case PIXELFORMAT_ASTC_10x10_sRGB: return PIXELFORMAT_ASTC_10x10_UNORM;
+	case PIXELFORMAT_ASTC_12x10_sRGB: return PIXELFORMAT_ASTC_12x10_UNORM;
+	case PIXELFORMAT_ASTC_12x12_sRGB: return PIXELFORMAT_ASTC_12x12_UNORM;
+	default:
+		break;
+	}
+
 	return format;
 }
 

src/common/pixelformat.h

@@ -60,9 +60,9 @@ enum PixelFormat
 
 	// 4-channel normal formats
 	PIXELFORMAT_RGBA8_UNORM,
-	PIXELFORMAT_RGBA8_UNORM_sRGB,
+	PIXELFORMAT_RGBA8_sRGB,
 	PIXELFORMAT_BGRA8_UNORM,
-	PIXELFORMAT_BGRA8_UNORM_sRGB,
+	PIXELFORMAT_BGRA8_sRGB,
 	PIXELFORMAT_RGBA8_INT,
 	PIXELFORMAT_RGBA8_UINT,
 	PIXELFORMAT_RGBA16_UNORM,
@@ -90,8 +90,11 @@ enum PixelFormat
 
 	// compressed formats
 	PIXELFORMAT_DXT1_UNORM,
+	PIXELFORMAT_DXT1_sRGB,
 	PIXELFORMAT_DXT3_UNORM,
+	PIXELFORMAT_DXT3_sRGB,
 	PIXELFORMAT_DXT5_UNORM,
+	PIXELFORMAT_DXT5_sRGB,
 	PIXELFORMAT_BC4_UNORM,
 	PIXELFORMAT_BC4_SNORM,
 	PIXELFORMAT_BC5_UNORM,
@@ -99,32 +102,57 @@ enum PixelFormat
 	PIXELFORMAT_BC6H_UFLOAT,
 	PIXELFORMAT_BC6H_FLOAT,
 	PIXELFORMAT_BC7_UNORM,
+	PIXELFORMAT_BC7_sRGB,
+
 	PIXELFORMAT_PVR1_RGB2_UNORM,
+	PIXELFORMAT_PVR1_RGB2_sRGB,
 	PIXELFORMAT_PVR1_RGB4_UNORM,
+	PIXELFORMAT_PVR1_RGB4_sRGB,
 	PIXELFORMAT_PVR1_RGBA2_UNORM,
+	PIXELFORMAT_PVR1_RGBA2_sRGB,
 	PIXELFORMAT_PVR1_RGBA4_UNORM,
+	PIXELFORMAT_PVR1_RGBA4_sRGB,
+
 	PIXELFORMAT_ETC1_UNORM,
 	PIXELFORMAT_ETC2_RGB_UNORM,
+	PIXELFORMAT_ETC2_RGB_sRGB,
 	PIXELFORMAT_ETC2_RGBA_UNORM,
+	PIXELFORMAT_ETC2_RGBA_sRGB,
 	PIXELFORMAT_ETC2_RGBA1_UNORM,
+	PIXELFORMAT_ETC2_RGBA1_sRGB,
 	PIXELFORMAT_EAC_R_UNORM,
 	PIXELFORMAT_EAC_R_SNORM,
 	PIXELFORMAT_EAC_RG_UNORM,
 	PIXELFORMAT_EAC_RG_SNORM,
-	PIXELFORMAT_ASTC_4x4,
-	PIXELFORMAT_ASTC_5x4,
-	PIXELFORMAT_ASTC_5x5,
-	PIXELFORMAT_ASTC_6x5,
-	PIXELFORMAT_ASTC_6x6,
-	PIXELFORMAT_ASTC_8x5,
-	PIXELFORMAT_ASTC_8x6,
-	PIXELFORMAT_ASTC_8x8,
-	PIXELFORMAT_ASTC_10x5,
-	PIXELFORMAT_ASTC_10x6,
-	PIXELFORMAT_ASTC_10x8,
-	PIXELFORMAT_ASTC_10x10,
-	PIXELFORMAT_ASTC_12x10,
-	PIXELFORMAT_ASTC_12x12,
+
+	PIXELFORMAT_ASTC_4x4_UNORM,
+	PIXELFORMAT_ASTC_5x4_UNORM,
+	PIXELFORMAT_ASTC_5x5_UNORM,
+	PIXELFORMAT_ASTC_6x5_UNORM,
+	PIXELFORMAT_ASTC_6x6_UNORM,
+	PIXELFORMAT_ASTC_8x5_UNORM,
+	PIXELFORMAT_ASTC_8x6_UNORM,
+	PIXELFORMAT_ASTC_8x8_UNORM,
+	PIXELFORMAT_ASTC_10x5_UNORM,
+	PIXELFORMAT_ASTC_10x6_UNORM,
+	PIXELFORMAT_ASTC_10x8_UNORM,
+	PIXELFORMAT_ASTC_10x10_UNORM,
+	PIXELFORMAT_ASTC_12x10_UNORM,
+	PIXELFORMAT_ASTC_12x12_UNORM,
+	PIXELFORMAT_ASTC_4x4_sRGB,
+	PIXELFORMAT_ASTC_5x4_sRGB,
+	PIXELFORMAT_ASTC_5x5_sRGB,
+	PIXELFORMAT_ASTC_6x5_sRGB,
+	PIXELFORMAT_ASTC_6x6_sRGB,
+	PIXELFORMAT_ASTC_8x5_sRGB,
+	PIXELFORMAT_ASTC_8x6_sRGB,
+	PIXELFORMAT_ASTC_8x8_sRGB,
+	PIXELFORMAT_ASTC_10x5_sRGB,
+	PIXELFORMAT_ASTC_10x6_sRGB,
+	PIXELFORMAT_ASTC_10x8_sRGB,
+	PIXELFORMAT_ASTC_10x10_sRGB,
+	PIXELFORMAT_ASTC_12x10_sRGB,
+	PIXELFORMAT_ASTC_12x12_sRGB,
 
 	PIXELFORMAT_MAX_ENUM
 };
@@ -149,6 +177,7 @@ struct PixelFormatInfo
 	bool depth;
 	bool stencil;
 	bool compressed;
+	bool sRGB;
 	PixelFormatType dataType;
 };
 

src/modules/graphics/Graphics.cpp

@@ -925,7 +925,7 @@ void Graphics::setRenderTargets(const RenderTargets &rts)
 		PixelFormat dsformat = PIXELFORMAT_STENCIL8;
 		if (wantsdepth && wantsstencil)
 			dsformat = PIXELFORMAT_DEPTH24_UNORM_STENCIL8;
-		else if (wantsdepth && isPixelFormatSupported(PIXELFORMAT_DEPTH24_UNORM, PIXELFORMATUSAGEFLAGS_RENDERTARGET, false))
+		else if (wantsdepth && isPixelFormatSupported(PIXELFORMAT_DEPTH24_UNORM, PIXELFORMATUSAGEFLAGS_RENDERTARGET))
 			dsformat = PIXELFORMAT_DEPTH24_UNORM;
 		else if (wantsdepth)
 			dsformat = PIXELFORMAT_DEPTH16_UNORM;
@@ -2395,7 +2395,7 @@ PixelFormat Graphics::getSizedFormat(PixelFormat format) const
 	{
 	case PIXELFORMAT_NORMAL:
 		if (isGammaCorrect())
-			return PIXELFORMAT_RGBA8_UNORM_sRGB;
+			return PIXELFORMAT_RGBA8_sRGB;
 		else
 			return PIXELFORMAT_RGBA8_UNORM;
 	case PIXELFORMAT_HDR:

src/modules/graphics/Graphics.h

@@ -824,7 +824,7 @@ public:
 	/**
 	 * Gets whether the specified pixel format usage is supported.
 	 **/
-	virtual bool isPixelFormatSupported(PixelFormat format, uint32 usage, bool sRGB = false) = 0;
+	virtual bool isPixelFormatSupported(PixelFormat format, uint32 usage) = 0;
 
 	/**
 	 * Gets the renderer used by love.graphics.

src/modules/graphics/Texture.cpp

@@ -168,7 +168,6 @@ Texture::Texture(Graphics *gfx, const Settings &settings, const Slices *slices)
 	, computeWrite(settings.computeWrite)
 	, readable(true)
 	, mipmapsMode(settings.mipmaps)
-	, sRGB(false)
 	, width(settings.width)
 	, height(settings.height)
 	, depth(settings.type == TEXTURE_VOLUME ? settings.layers : 1)
@@ -236,7 +235,8 @@ Texture::Texture(Graphics *gfx, const Settings &settings, const Slices *slices)
 		readable = !renderTarget || !isPixelFormatDepthStencil(format);
 
 	format = gfx->getSizedFormat(format);
-	sRGB = isPixelFormatSRGB(format) || (isCompressed() && isGammaCorrect() && !settings.linear);
+	if (!isGammaCorrect() || settings.linear)
+		format = getLinearPixelFormat(format);
 
 	if (mipmapsMode == MIPMAPS_AUTO && isCompressed())
 		mipmapsMode = MIPMAPS_MANUAL;
@@ -291,7 +291,7 @@ Texture::Texture(Graphics *gfx, const Settings &settings, const Slices *slices)
 	if (computeWrite)
 		usage |= PIXELFORMATUSAGEFLAGS_COMPUTEWRITE;
 
-	if (!gfx->isPixelFormatSupported(format, (PixelFormatUsageFlags) usage, sRGB))
+	if (!gfx->isPixelFormatSupported(format, (PixelFormatUsageFlags) usage))
 	{
 		const char *fstr = "unknown";
 		love::getConstant(format, fstr);
@@ -622,7 +622,7 @@ bool Texture::isCompressed() const
 
 bool Texture::isFormatLinear() const
 {
-	return isGammaCorrect() && !sRGB && !isPixelFormatSRGB(format);
+	return isGammaCorrect() && !isPixelFormatSRGB(format);
 }
 
 bool Texture::isValidSlice(int slice, int mip) const

src/modules/graphics/Texture.h

@@ -325,8 +325,6 @@ protected:
 
 	MipmapsMode mipmapsMode;
 
-	bool sRGB;
-
 	int width;
 	int height;
 

src/modules/graphics/metal/Graphics.h

@@ -110,7 +110,7 @@ public:
 
 	void setWireframe(bool enable) override;
 	
-	bool isPixelFormatSupported(PixelFormat format, uint32 usage, bool sRGB = false) override;
+	bool isPixelFormatSupported(PixelFormat format, uint32 usage) override;
 	Renderer getRenderer() const override;
 	bool usesGLSLES() const override;
 	RendererInfo getRendererInfo() const override;

src/modules/graphics/metal/Graphics.mm

@@ -503,7 +503,7 @@ void Graphics::setViewportSize(int width, int height, int pixelwidth, int pixelh
 	backbufferMSAA.set(nullptr);
 	if (settings.msaa > 1)
 	{
-		settings.format = isGammaCorrect() ? PIXELFORMAT_BGRA8_UNORM_sRGB : PIXELFORMAT_BGRA8_UNORM;
+		settings.format = isGammaCorrect() ? PIXELFORMAT_BGRA8_sRGB : PIXELFORMAT_BGRA8_UNORM;
 		backbufferMSAA.set(newTexture(settings), Acquire::NORETAIN);
 	}
 
@@ -681,7 +681,7 @@ id<MTLRenderCommandEncoder> Graphics::useRenderEncoder()
 			attachmentStoreActions.stencil = MTLStoreActionDontCare;
 
 			auto &key = lastRenderPipelineKey;
-			key.colorRenderTargetFormats = isGammaCorrect() ? PIXELFORMAT_BGRA8_UNORM_sRGB : PIXELFORMAT_BGRA8_UNORM;
+			key.colorRenderTargetFormats = isGammaCorrect() ? PIXELFORMAT_BGRA8_sRGB : PIXELFORMAT_BGRA8_UNORM;
 			key.depthStencilFormat = backbufferDepthStencil->getPixelFormat();
 			key.msaa = backbufferMSAA ? (uint8) backbufferMSAA->getMSAA() : 1;
 		}
@@ -1864,13 +1864,10 @@ void Graphics::setWireframe(bool enable)
 	}
 }
 
-bool Graphics::isPixelFormatSupported(PixelFormat format, uint32 usage, bool sRGB)
+bool Graphics::isPixelFormatSupported(PixelFormat format, uint32 usage)
 {
 	format = getSizedFormat(format);
 
-	if (sRGB)
-		format = getSRGBPixelFormat(format);
-
 	const uint32 sample = PIXELFORMATUSAGEFLAGS_SAMPLE;
 	const uint32 filter = PIXELFORMATUSAGEFLAGS_LINEAR;
 	const uint32 rt = PIXELFORMATUSAGEFLAGS_RENDERTARGET;
@@ -1958,8 +1955,8 @@ bool Graphics::isPixelFormatSupported(PixelFormat format, uint32 usage, bool sRG
 		case PIXELFORMAT_BGRA8_UNORM:
 			flags |= all;
 			break;
-		case PIXELFORMAT_RGBA8_UNORM_sRGB:
-		case PIXELFORMAT_BGRA8_UNORM_sRGB:
+		case PIXELFORMAT_RGBA8_sRGB:
+		case PIXELFORMAT_BGRA8_sRGB:
 			if (families.apple[1] || families.mac[1] || families.macCatalyst[1])
 				flags |= commonsample | commonrender;
 			if (families.apple[2])
@@ -2058,8 +2055,11 @@ bool Graphics::isPixelFormatSupported(PixelFormat format, uint32 usage, bool sRG
 			break;
 
 		case PIXELFORMAT_DXT1_UNORM:
+		case PIXELFORMAT_DXT1_sRGB:
 		case PIXELFORMAT_DXT3_UNORM:
+		case PIXELFORMAT_DXT3_sRGB:
 		case PIXELFORMAT_DXT5_UNORM:
+		case PIXELFORMAT_DXT5_sRGB:
 		case PIXELFORMAT_BC4_UNORM:
 		case PIXELFORMAT_BC4_SNORM:
 		case PIXELFORMAT_BC5_UNORM:
@@ -2067,22 +2067,30 @@ bool Graphics::isPixelFormatSupported(PixelFormat format, uint32 usage, bool sRG
 		case PIXELFORMAT_BC6H_UFLOAT:
 		case PIXELFORMAT_BC6H_FLOAT:
 		case PIXELFORMAT_BC7_UNORM:
+		case PIXELFORMAT_BC7_sRGB:
 			if (families.mac[1] || families.macCatalyst[1])
 				flags |= commonsample;
 			break;
 
 		case PIXELFORMAT_PVR1_RGB2_UNORM:
+		case PIXELFORMAT_PVR1_RGB2_sRGB:
 		case PIXELFORMAT_PVR1_RGB4_UNORM:
+		case PIXELFORMAT_PVR1_RGB4_sRGB:
 		case PIXELFORMAT_PVR1_RGBA2_UNORM:
+		case PIXELFORMAT_PVR1_RGBA2_sRGB:
 		case PIXELFORMAT_PVR1_RGBA4_UNORM:
+		case PIXELFORMAT_PVR1_RGBA4_sRGB:
 			if (families.apple[1])
 				flags |= commonsample;
 			break;
 
 		case PIXELFORMAT_ETC1_UNORM:
 		case PIXELFORMAT_ETC2_RGB_UNORM:
+		case PIXELFORMAT_ETC2_RGB_sRGB:
 		case PIXELFORMAT_ETC2_RGBA_UNORM:
+		case PIXELFORMAT_ETC2_RGBA_sRGB:
 		case PIXELFORMAT_ETC2_RGBA1_UNORM:
+		case PIXELFORMAT_ETC2_RGBA1_sRGB:
 		case PIXELFORMAT_EAC_R_UNORM:
 		case PIXELFORMAT_EAC_R_SNORM:
 		case PIXELFORMAT_EAC_RG_UNORM:
@@ -2091,20 +2099,34 @@ bool Graphics::isPixelFormatSupported(PixelFormat format, uint32 usage, bool sRG
 				flags |= commonsample;
 			break;
 
-		case PIXELFORMAT_ASTC_4x4:
-		case PIXELFORMAT_ASTC_5x4:
-		case PIXELFORMAT_ASTC_5x5:
-		case PIXELFORMAT_ASTC_6x5:
-		case PIXELFORMAT_ASTC_6x6:
-		case PIXELFORMAT_ASTC_8x5:
-		case PIXELFORMAT_ASTC_8x6:
-		case PIXELFORMAT_ASTC_8x8:
-		case PIXELFORMAT_ASTC_10x5:
-		case PIXELFORMAT_ASTC_10x6:
-		case PIXELFORMAT_ASTC_10x8:
-		case PIXELFORMAT_ASTC_10x10:
-		case PIXELFORMAT_ASTC_12x10:
-		case PIXELFORMAT_ASTC_12x12:
+		case PIXELFORMAT_ASTC_4x4_UNORM:
+		case PIXELFORMAT_ASTC_5x4_UNORM:
+		case PIXELFORMAT_ASTC_5x5_UNORM:
+		case PIXELFORMAT_ASTC_6x5_UNORM:
+		case PIXELFORMAT_ASTC_6x6_UNORM:
+		case PIXELFORMAT_ASTC_8x5_UNORM:
+		case PIXELFORMAT_ASTC_8x6_UNORM:
+		case PIXELFORMAT_ASTC_8x8_UNORM:
+		case PIXELFORMAT_ASTC_10x5_UNORM:
+		case PIXELFORMAT_ASTC_10x6_UNORM:
+		case PIXELFORMAT_ASTC_10x8_UNORM:
+		case PIXELFORMAT_ASTC_10x10_UNORM:
+		case PIXELFORMAT_ASTC_12x10_UNORM:
+		case PIXELFORMAT_ASTC_12x12_UNORM:
+		case PIXELFORMAT_ASTC_4x4_sRGB:
+		case PIXELFORMAT_ASTC_5x4_sRGB:
+		case PIXELFORMAT_ASTC_5x5_sRGB:
+		case PIXELFORMAT_ASTC_6x5_sRGB:
+		case PIXELFORMAT_ASTC_6x6_sRGB:
+		case PIXELFORMAT_ASTC_8x5_sRGB:
+		case PIXELFORMAT_ASTC_8x6_sRGB:
+		case PIXELFORMAT_ASTC_8x8_sRGB:
+		case PIXELFORMAT_ASTC_10x5_sRGB:
+		case PIXELFORMAT_ASTC_10x6_sRGB:
+		case PIXELFORMAT_ASTC_10x8_sRGB:
+		case PIXELFORMAT_ASTC_10x10_sRGB:
+		case PIXELFORMAT_ASTC_12x10_sRGB:
+		case PIXELFORMAT_ASTC_12x12_sRGB:
 			if (families.apple[2])
 				flags |= commonsample;
 			break;

src/modules/graphics/metal/Metal.h

@@ -43,7 +43,7 @@ public:
 		API_AVAILABLE(macos(10.15), ios(13.0)) MTLTextureSwizzleChannels swizzle;
 	};
 
-	static PixelFormatDesc convertPixelFormat(id<MTLDevice> device, PixelFormat format, bool &isSRGB);
+	static PixelFormatDesc convertPixelFormat(id<MTLDevice> device, PixelFormat format);
 
 }; // Metal
 

src/modules/graphics/metal/Metal.mm

@@ -28,17 +28,11 @@ namespace graphics
 namespace metal
 {
 
-Metal::PixelFormatDesc Metal::convertPixelFormat(id<MTLDevice> device, PixelFormat format, bool &isSRGB)
+Metal::PixelFormatDesc Metal::convertPixelFormat(id<MTLDevice> device, PixelFormat format)
 {
 	MTLPixelFormat mtlformat = MTLPixelFormatInvalid;
 	PixelFormatDesc desc = {};
 
-	if (isSRGB)
-		format = getSRGBPixelFormat(format);
-
-	if (!isPixelFormatCompressed(format) && !isPixelFormatSRGB(format))
-		isSRGB = false;
-
 	switch (format)
 	{
 	case PIXELFORMAT_R8_UNORM:
@@ -50,13 +44,13 @@ Metal::PixelFormatDesc Metal::convertPixelFormat(id<MTLDevice> device, PixelForm
 	case PIXELFORMAT_RGBA8_UNORM:
 		mtlformat = MTLPixelFormatRGBA8Unorm;
 		break;
-	case PIXELFORMAT_RGBA8_UNORM_sRGB:
+	case PIXELFORMAT_RGBA8_sRGB:
 		mtlformat = MTLPixelFormatRGBA8Unorm_sRGB;
 		break;
 	case PIXELFORMAT_BGRA8_UNORM:
 		mtlformat = MTLPixelFormatBGRA8Unorm;
 		break;
-	case PIXELFORMAT_BGRA8_UNORM_sRGB:
+	case PIXELFORMAT_BGRA8_sRGB:
 		mtlformat = MTLPixelFormatBGRA8Unorm_sRGB;
 		break;
 	case PIXELFORMAT_R16_UNORM:
@@ -205,177 +199,264 @@ Metal::PixelFormatDesc Metal::convertPixelFormat(id<MTLDevice> device, PixelForm
 
 	case PIXELFORMAT_DXT1_UNORM:
 #ifndef LOVE_IOS
-		mtlformat = isSRGB ? MTLPixelFormatBC1_RGBA_sRGB : MTLPixelFormatBC1_RGBA;
+		mtlformat = MTLPixelFormatBC1_RGBA;
+#endif
+		break;
+	case PIXELFORMAT_DXT1_sRGB:
+#ifndef LOVE_IOS
+		mtlformat = MTLPixelFormatBC1_RGBA_sRGB;
 #endif
 		break;
 	case PIXELFORMAT_DXT3_UNORM:
 #ifndef LOVE_IOS
-		mtlformat = isSRGB ? MTLPixelFormatBC2_RGBA_sRGB : MTLPixelFormatBC2_RGBA;
+		mtlformat = MTLPixelFormatBC2_RGBA;
+#endif
+		break;
+	case PIXELFORMAT_DXT3_sRGB:
+#ifndef LOVE_IOS
+		mtlformat = MTLPixelFormatBC2_RGBA_sRGB;
 #endif
 		break;
 	case PIXELFORMAT_DXT5_UNORM:
 #ifndef LOVE_IOS
-		mtlformat = isSRGB ? MTLPixelFormatBC3_RGBA_sRGB : MTLPixelFormatBC3_RGBA;
+		mtlformat = MTLPixelFormatBC3_RGBA;
+#endif
+		break;
+	case PIXELFORMAT_DXT5_sRGB:
+#ifndef LOVE_IOS
+		mtlformat = MTLPixelFormatBC3_RGBA_sRGB;
 #endif
 		break;
 	case PIXELFORMAT_BC4_UNORM:
 #ifndef LOVE_IOS
-		isSRGB = false;
 		mtlformat = MTLPixelFormatBC4_RUnorm;
 #endif
 		break;
 	case PIXELFORMAT_BC4_SNORM:
 #ifndef LOVE_IOS
-		isSRGB = false;
 		mtlformat = MTLPixelFormatBC4_RSnorm;
 #endif
 		break;
 	case PIXELFORMAT_BC5_UNORM:
 #ifndef LOVE_IOS
-		isSRGB = false;
 		mtlformat = MTLPixelFormatBC5_RGUnorm;
 #endif
 		break;
 	case PIXELFORMAT_BC5_SNORM:
 #ifndef LOVE_IOS
-		isSRGB = false;
 		mtlformat = MTLPixelFormatBC5_RGSnorm;
 #endif
 		break;
 	case PIXELFORMAT_BC6H_UFLOAT:
 #ifndef LOVE_IOS
-		isSRGB = false;
 		mtlformat = MTLPixelFormatBC6H_RGBUfloat;
 #endif
 		break;
 	case PIXELFORMAT_BC6H_FLOAT:
 #ifndef LOVE_IOS
-		isSRGB = false;
 		mtlformat = MTLPixelFormatBC6H_RGBFloat;
 #endif
 		break;
 	case PIXELFORMAT_BC7_UNORM:
 #ifndef LOVE_IOS
-		mtlformat = isSRGB ? MTLPixelFormatBC7_RGBAUnorm_sRGB : MTLPixelFormatBC7_RGBAUnorm;
+		mtlformat = MTLPixelFormatBC7_RGBAUnorm;
+#endif
+		break;
+	case PIXELFORMAT_BC7_sRGB:
+#ifndef LOVE_IOS
+		mtlformat = MTLPixelFormatBC7_RGBAUnorm_sRGB;
 #endif
 		break;
 
 	case PIXELFORMAT_PVR1_RGB2_UNORM:
 		if (@available(macOS 11.0, iOS 8.0, *))
-			mtlformat = isSRGB ? MTLPixelFormatPVRTC_RGB_2BPP_sRGB : MTLPixelFormatPVRTC_RGB_2BPP;
+			mtlformat = MTLPixelFormatPVRTC_RGB_2BPP;
+		break;
+	case PIXELFORMAT_PVR1_RGB2_sRGB:
+		if (@available(macOS 11.0, iOS 8.0, *))
+			mtlformat = MTLPixelFormatPVRTC_RGB_2BPP_sRGB;
 		break;
 	case PIXELFORMAT_PVR1_RGB4_UNORM:
 		if (@available(macOS 11.0, iOS 8.0, *))
-			mtlformat = isSRGB ? MTLPixelFormatPVRTC_RGB_4BPP_sRGB : MTLPixelFormatPVRTC_RGB_4BPP;
+			mtlformat = MTLPixelFormatPVRTC_RGB_4BPP;
+		break;
+	case PIXELFORMAT_PVR1_RGB4_sRGB:
+		if (@available(macOS 11.0, iOS 8.0, *))
+			mtlformat = MTLPixelFormatPVRTC_RGB_4BPP_sRGB;
 		break;
 	case PIXELFORMAT_PVR1_RGBA2_UNORM:
 		if (@available(macOS 11.0, iOS 8.0, *))
-			mtlformat = isSRGB ? MTLPixelFormatPVRTC_RGB_2BPP_sRGB : MTLPixelFormatPVRTC_RGBA_2BPP;
+			mtlformat = MTLPixelFormatPVRTC_RGBA_2BPP;
+		break;
+	case PIXELFORMAT_PVR1_RGBA2_sRGB:
+		if (@available(macOS 11.0, iOS 8.0, *))
+			mtlformat = MTLPixelFormatPVRTC_RGB_2BPP_sRGB;
 		break;
 	case PIXELFORMAT_PVR1_RGBA4_UNORM:
 		if (@available(macOS 11.0, iOS 8.0, *))
-			mtlformat = isSRGB ? MTLPixelFormatPVRTC_RGB_4BPP_sRGB : MTLPixelFormatPVRTC_RGBA_4BPP;
+			mtlformat = MTLPixelFormatPVRTC_RGBA_4BPP;
+		break;
+	case PIXELFORMAT_PVR1_RGBA4_sRGB:
+		if (@available(macOS 11.0, iOS 8.0, *))
+			mtlformat = MTLPixelFormatPVRTC_RGB_4BPP_sRGB;
 		break;
+
 	case PIXELFORMAT_ETC1_UNORM:
 		if (@available(macOS 11.0, iOS 8.0, *))
-			mtlformat = isSRGB ? MTLPixelFormatETC2_RGB8_sRGB : MTLPixelFormatETC2_RGB8;
+			mtlformat = MTLPixelFormatETC2_RGB8;
 		break;
 	case PIXELFORMAT_ETC2_RGB_UNORM:
 		if (@available(macOS 11.0, iOS 8.0, *))
-			mtlformat = isSRGB ? MTLPixelFormatETC2_RGB8_sRGB : MTLPixelFormatETC2_RGB8;
+			mtlformat = MTLPixelFormatETC2_RGB8;
+		break;
+	case PIXELFORMAT_ETC2_RGB_sRGB:
+		if (@available(macOS 11.0, iOS 8.0, *))
+			mtlformat =  MTLPixelFormatETC2_RGB8_sRGB;
 		break;
 	case PIXELFORMAT_ETC2_RGBA_UNORM:
 		if (@available(macOS 11.0, iOS 8.0, *))
-			mtlformat = isSRGB ? MTLPixelFormatEAC_RGBA8_sRGB : MTLPixelFormatEAC_RGBA8;
+			mtlformat = MTLPixelFormatEAC_RGBA8;
+		break;
+	case PIXELFORMAT_ETC2_RGBA_sRGB:
+		if (@available(macOS 11.0, iOS 8.0, *))
+			mtlformat = MTLPixelFormatEAC_RGBA8_sRGB;
 		break;
 	case PIXELFORMAT_ETC2_RGBA1_UNORM:
 		if (@available(macOS 11.0, iOS 8.0, *))
-			mtlformat = isSRGB ? MTLPixelFormatETC2_RGB8A1_sRGB : MTLPixelFormatETC2_RGB8A1;
+			mtlformat = MTLPixelFormatETC2_RGB8A1;
+		break;
+	case PIXELFORMAT_ETC2_RGBA1_sRGB:
+		if (@available(macOS 11.0, iOS 8.0, *))
+			mtlformat = MTLPixelFormatETC2_RGB8A1_sRGB;
 		break;
 	case PIXELFORMAT_EAC_R_UNORM:
 		if (@available(macOS 11.0, iOS 8.0, *))
-		{
-			isSRGB = false;
 			mtlformat = MTLPixelFormatEAC_R11Unorm;
-		}
 		break;
 	case PIXELFORMAT_EAC_R_SNORM:
 		if (@available(macOS 11.0, iOS 8.0, *))
-		{
-			isSRGB = false;
 			mtlformat = MTLPixelFormatEAC_R11Snorm;
-		}
 		break;
 	case PIXELFORMAT_EAC_RG_UNORM:
 		if (@available(macOS 11.0, iOS 8.0, *))
-		{
-			isSRGB = false;
 			mtlformat = MTLPixelFormatEAC_RG11Unorm;
-		}
 		break;
 	case PIXELFORMAT_EAC_RG_SNORM:
 		if (@available(macOS 11.0, iOS 8.0, *))
-		{
-			isSRGB = false;
 			mtlformat = MTLPixelFormatEAC_RG11Snorm;
-		}
 		break;
 
-	case PIXELFORMAT_ASTC_4x4:
+	case PIXELFORMAT_ASTC_4x4_UNORM:
+		if (@available(macOS 11.0, iOS 8.0, *))
+			mtlformat = MTLPixelFormatASTC_4x4_LDR;
+		break;
+	case PIXELFORMAT_ASTC_5x4_UNORM:
+		if (@available(macOS 11.0, iOS 8.0, *))
+			mtlformat = MTLPixelFormatASTC_5x4_LDR;
+		break;
+	case PIXELFORMAT_ASTC_5x5_UNORM:
+		if (@available(macOS 11.0, iOS 8.0, *))
+			mtlformat = MTLPixelFormatASTC_5x5_LDR;
+		break;
+	case PIXELFORMAT_ASTC_6x5_UNORM:
+		if (@available(macOS 11.0, iOS 8.0, *))
+			mtlformat = MTLPixelFormatASTC_6x5_LDR;
+		break;
+	case PIXELFORMAT_ASTC_6x6_UNORM:
+		if (@available(macOS 11.0, iOS 8.0, *))
+			mtlformat = MTLPixelFormatASTC_6x6_LDR;
+		break;
+	case PIXELFORMAT_ASTC_8x5_UNORM:
+		if (@available(macOS 11.0, iOS 8.0, *))
+			mtlformat = MTLPixelFormatASTC_8x5_LDR;
+		break;
+	case PIXELFORMAT_ASTC_8x6_UNORM:
+		if (@available(macOS 11.0, iOS 8.0, *))
+			mtlformat = MTLPixelFormatASTC_8x6_LDR;
+		break;
+	case PIXELFORMAT_ASTC_8x8_UNORM:
+		if (@available(macOS 11.0, iOS 8.0, *))
+			mtlformat = MTLPixelFormatASTC_8x8_LDR;
+		break;
+	case PIXELFORMAT_ASTC_10x5_UNORM:
+		if (@available(macOS 11.0, iOS 8.0, *))
+			mtlformat = MTLPixelFormatASTC_10x5_LDR;
+		break;
+	case PIXELFORMAT_ASTC_10x6_UNORM:
+		if (@available(macOS 11.0, iOS 8.0, *))
+			mtlformat = MTLPixelFormatASTC_10x6_LDR;
+		break;
+	case PIXELFORMAT_ASTC_10x8_UNORM:
+		if (@available(macOS 11.0, iOS 8.0, *))
+			mtlformat = MTLPixelFormatASTC_10x8_LDR;
+		break;
+	case PIXELFORMAT_ASTC_10x10_UNORM:
+		if (@available(macOS 11.0, iOS 8.0, *))
+			mtlformat = MTLPixelFormatASTC_10x10_LDR;
+		break;
+	case PIXELFORMAT_ASTC_12x10_UNORM:
+		if (@available(macOS 11.0, iOS 8.0, *))
+			mtlformat = MTLPixelFormatASTC_12x10_LDR;
+		break;
+	case PIXELFORMAT_ASTC_12x12_UNORM:
+		if (@available(macOS 11.0, iOS 8.0, *))
+			mtlformat = MTLPixelFormatASTC_12x12_LDR;
+		break;
+	case PIXELFORMAT_ASTC_4x4_sRGB:
 		if (@available(macOS 11.0, iOS 8.0, *))
-			mtlformat = isSRGB ? MTLPixelFormatASTC_4x4_sRGB : MTLPixelFormatASTC_4x4_LDR;
+			mtlformat = MTLPixelFormatASTC_4x4_sRGB;
 		break;
-	case PIXELFORMAT_ASTC_5x4:
+	case PIXELFORMAT_ASTC_5x4_sRGB:
 		if (@available(macOS 11.0, iOS 8.0, *))
-			mtlformat = isSRGB ? MTLPixelFormatASTC_5x4_sRGB : MTLPixelFormatASTC_5x4_LDR;
+			mtlformat = MTLPixelFormatASTC_5x4_sRGB;
 		break;
-	case PIXELFORMAT_ASTC_5x5:
+	case PIXELFORMAT_ASTC_5x5_sRGB:
 		if (@available(macOS 11.0, iOS 8.0, *))
-			mtlformat = isSRGB ? MTLPixelFormatASTC_5x5_sRGB : MTLPixelFormatASTC_5x5_LDR;
+			mtlformat = MTLPixelFormatASTC_5x5_sRGB;
 		break;
-	case PIXELFORMAT_ASTC_6x5:
+	case PIXELFORMAT_ASTC_6x5_sRGB:
 		if (@available(macOS 11.0, iOS 8.0, *))
-			mtlformat = isSRGB ? MTLPixelFormatASTC_6x5_sRGB : MTLPixelFormatASTC_6x5_LDR;
+			mtlformat = MTLPixelFormatASTC_6x5_sRGB;
 		break;
-	case PIXELFORMAT_ASTC_6x6:
+	case PIXELFORMAT_ASTC_6x6_sRGB:
 		if (@available(macOS 11.0, iOS 8.0, *))
-			mtlformat = isSRGB ? MTLPixelFormatASTC_6x6_sRGB : MTLPixelFormatASTC_6x6_LDR;
+			mtlformat = MTLPixelFormatASTC_6x6_sRGB;
 		break;
-	case PIXELFORMAT_ASTC_8x5:
+	case PIXELFORMAT_ASTC_8x5_sRGB:
 		if (@available(macOS 11.0, iOS 8.0, *))
-			mtlformat = isSRGB ? MTLPixelFormatASTC_8x5_sRGB : MTLPixelFormatASTC_8x5_LDR;
+			mtlformat = MTLPixelFormatASTC_8x5_sRGB;
 		break;
-	case PIXELFORMAT_ASTC_8x6:
+	case PIXELFORMAT_ASTC_8x6_sRGB:
 		if (@available(macOS 11.0, iOS 8.0, *))
-			mtlformat = isSRGB ? MTLPixelFormatASTC_8x6_sRGB : MTLPixelFormatASTC_8x6_LDR;
+			mtlformat = MTLPixelFormatASTC_8x6_sRGB;
 		break;
-	case PIXELFORMAT_ASTC_8x8:
+	case PIXELFORMAT_ASTC_8x8_sRGB:
 		if (@available(macOS 11.0, iOS 8.0, *))
-			mtlformat = isSRGB ? MTLPixelFormatASTC_8x8_sRGB : MTLPixelFormatASTC_8x8_LDR;
+			mtlformat = MTLPixelFormatASTC_8x8_sRGB;
 		break;
-	case PIXELFORMAT_ASTC_10x5:
+	case PIXELFORMAT_ASTC_10x5_sRGB:
 		if (@available(macOS 11.0, iOS 8.0, *))
-			mtlformat = isSRGB ? MTLPixelFormatASTC_10x5_sRGB : MTLPixelFormatASTC_10x5_LDR;
+			mtlformat = MTLPixelFormatASTC_10x5_sRGB;
 		break;
-	case PIXELFORMAT_ASTC_10x6:
+	case PIXELFORMAT_ASTC_10x6_sRGB:
 		if (@available(macOS 11.0, iOS 8.0, *))
-			mtlformat = isSRGB ? MTLPixelFormatASTC_10x6_sRGB : MTLPixelFormatASTC_10x6_LDR;
+			mtlformat = MTLPixelFormatASTC_10x6_sRGB;
 		break;
-	case PIXELFORMAT_ASTC_10x8:
+	case PIXELFORMAT_ASTC_10x8_sRGB:
 		if (@available(macOS 11.0, iOS 8.0, *))
-			mtlformat = isSRGB ? MTLPixelFormatASTC_10x8_sRGB : MTLPixelFormatASTC_10x8_LDR;
+			mtlformat = MTLPixelFormatASTC_10x8_sRGB;
 		break;
-	case PIXELFORMAT_ASTC_10x10:
+	case PIXELFORMAT_ASTC_10x10_sRGB:
 		if (@available(macOS 11.0, iOS 8.0, *))
-			mtlformat = isSRGB ? MTLPixelFormatASTC_10x10_sRGB : MTLPixelFormatASTC_10x10_LDR;
+			mtlformat = MTLPixelFormatASTC_10x10_sRGB;
 		break;
-	case PIXELFORMAT_ASTC_12x10:
+	case PIXELFORMAT_ASTC_12x10_sRGB:
 		if (@available(macOS 11.0, iOS 8.0, *))
-			mtlformat = isSRGB ? MTLPixelFormatASTC_12x10_sRGB : MTLPixelFormatASTC_12x10_LDR;
+			mtlformat = MTLPixelFormatASTC_12x10_sRGB;
 		break;
-	case PIXELFORMAT_ASTC_12x12:
+	case PIXELFORMAT_ASTC_12x12_sRGB:
 		if (@available(macOS 11.0, iOS 8.0, *))
-			mtlformat = isSRGB ? MTLPixelFormatASTC_12x12_sRGB : MTLPixelFormatASTC_12x12_LDR;
+			mtlformat = MTLPixelFormatASTC_12x12_sRGB;
 		break;
 
 	case PIXELFORMAT_UNKNOWN:

src/modules/graphics/metal/Texture.mm

@@ -62,7 +62,7 @@ Texture::Texture(love::graphics::Graphics *gfxbase, id<MTLDevice> device, const
 	desc.mipmapLevelCount = mipmapCount;
 	desc.textureType = getMTLTextureType(texType, 1);
 
-	auto formatdesc = Metal::convertPixelFormat(device, format, sRGB);
+	auto formatdesc = Metal::convertPixelFormat(device, format);
 	desc.pixelFormat = formatdesc.format;
 	if (formatdesc.swizzled)
 	{

src/modules/graphics/opengl/Graphics.cpp

@@ -250,7 +250,7 @@ void Graphics::updateBackbuffer(int width, int height, int /*pixelwidth*/, int p
 		settings.renderTarget = true;
 		settings.readable.set(false);
 
-		settings.format = isGammaCorrect() ? PIXELFORMAT_RGBA8_UNORM_sRGB : PIXELFORMAT_RGBA8_UNORM;
+		settings.format = isGammaCorrect() ? PIXELFORMAT_RGBA8_sRGB : PIXELFORMAT_RGBA8_UNORM;
 		internalBackbuffer.set(newTexture(settings), Acquire::NORETAIN);
 
 		settings.format = PIXELFORMAT_DEPTH24_UNORM_STENCIL8;
@@ -1189,8 +1189,7 @@ GLuint Graphics::bindCachedFBO(const RenderTargets &targets)
 		auto attachRT = [&](const RenderTarget &rt)
 		{
 			bool renderbuffer = msaa > 1 || !rt.texture->isReadable();
-			bool srgb = false;
-			OpenGL::TextureFormat fmt = OpenGL::convertPixelFormat(rt.texture->getPixelFormat(), renderbuffer, srgb);
+			OpenGL::TextureFormat fmt = OpenGL::convertPixelFormat(rt.texture->getPixelFormat(), renderbuffer);
 
 			if (fmt.framebufferAttachments[0] == GL_COLOR_ATTACHMENT0)
 			{
@@ -1754,9 +1753,8 @@ uint32 Graphics::computePixelFormatUsage(PixelFormat format, bool readable)
 	{
 		GLuint texture = 0;
 		GLuint renderbuffer = 0;
-		bool sRGB = isPixelFormatSRGB(format);
 
-		OpenGL::TextureFormat fmt = OpenGL::convertPixelFormat(format, !readable, sRGB);
+		OpenGL::TextureFormat fmt = OpenGL::convertPixelFormat(format, !readable);
 
 		GLuint current_fbo = gl.getFramebuffer(OpenGL::FRAMEBUFFER_ALL);
 
@@ -1778,7 +1776,7 @@ uint32 Graphics::computePixelFormatUsage(PixelFormat format, bool readable)
 			s.minFilter = s.magFilter = SamplerState::FILTER_NEAREST;
 			gl.setSamplerState(TEXTURE_2D, s);
 
-			gl.rawTexStorage(TEXTURE_2D, 1, format, sRGB, 1, 1);
+			gl.rawTexStorage(TEXTURE_2D, 1, format, 1, 1);
 		}
 		else
 		{
@@ -1814,11 +1812,8 @@ uint32 Graphics::computePixelFormatUsage(PixelFormat format, bool readable)
 	return usage;
 }
 
-bool Graphics::isPixelFormatSupported(PixelFormat format, uint32 usage, bool sRGB)
+bool Graphics::isPixelFormatSupported(PixelFormat format, uint32 usage)
 {
-	if (sRGB)
-		format = getSRGBPixelFormat(format);
-
 	format = getSizedFormat(format);
 
 	bool readable = (usage & PIXELFORMATUSAGEFLAGS_SAMPLE) != 0;

src/modules/graphics/opengl/Graphics.h

@@ -106,7 +106,7 @@ public:
 
 	void setWireframe(bool enable) override;
 
-	bool isPixelFormatSupported(PixelFormat format, uint32 usage, bool sRGB = false) override;
+	bool isPixelFormatSupported(PixelFormat format, uint32 usage) override;
 	Renderer getRenderer() const override;
 	bool usesGLSLES() const override;
 	RendererInfo getRendererInfo() const override;

src/modules/graphics/opengl/OpenGL.cpp

@@ -646,11 +646,9 @@ void OpenGL::createDefaultTexture()
 
 			const GLubyte *p = datatype == DATA_BASETYPE_FLOAT ? pix : intpix;
 
-			bool isSRGB = false;
-			rawTexStorage(type, 1, format, isSRGB, 1, 1);
-
-			TextureFormat fmt = convertPixelFormat(format, false, isSRGB);
+			rawTexStorage(type, 1, format, 1, 1);
 
+			TextureFormat fmt = convertPixelFormat(format, false);
 			int slices = type == TEXTURE_CUBE ? 6 : 1;
 
 			for (int slice = 0; slice < slices; slice++)
@@ -1433,10 +1431,10 @@ void OpenGL::setSamplerState(TextureType target, SamplerState &s)
 	}
 }
 
-bool OpenGL::rawTexStorage(TextureType target, int levels, PixelFormat pixelformat, bool &isSRGB, int width, int height, int depth)
+bool OpenGL::rawTexStorage(TextureType target, int levels, PixelFormat pixelformat, int width, int height, int depth)
 {
 	GLenum gltarget = getGLTextureType(target);
-	TextureFormat fmt = convertPixelFormat(pixelformat, false, isSRGB);
+	TextureFormat fmt = convertPixelFormat(pixelformat, false);
 
 	// This shouldn't be needed for glTexStorage, but some drivers don't follow
 	// the spec apparently.
@@ -1700,16 +1698,14 @@ OpenGL::Vendor OpenGL::getVendor() const
 	return vendor;
 }
 
-OpenGL::TextureFormat OpenGL::convertPixelFormat(PixelFormat pixelformat, bool renderbuffer, bool &isSRGB)
+OpenGL::TextureFormat OpenGL::convertPixelFormat(PixelFormat pixelformat, bool renderbuffer)
 {
 	TextureFormat f;
 
 	f.framebufferAttachments[0] = GL_COLOR_ATTACHMENT0;
 	f.framebufferAttachments[1] = GL_NONE;
 
-	if (isSRGB)
-		pixelformat = getSRGBPixelFormat(pixelformat);
-	else if (pixelformat == PIXELFORMAT_ETC1_UNORM)
+	if (pixelformat == PIXELFORMAT_ETC1_UNORM)
 	{
 		// The ETC2 format can load ETC1 textures.
 		if (GLAD_ES_VERSION_3_0 || GLAD_VERSION_4_3 || GLAD_ARB_ES3_compatibility)
@@ -1742,7 +1738,7 @@ OpenGL::TextureFormat OpenGL::convertPixelFormat(PixelFormat pixelformat, bool r
 		f.externalformat = GL_RGBA;
 		f.type = GL_UNSIGNED_BYTE;
 		break;
-	case PIXELFORMAT_RGBA8_UNORM_sRGB:
+	case PIXELFORMAT_RGBA8_sRGB:
 		f.internalformat = GL_SRGB8_ALPHA8;
 		f.type = GL_UNSIGNED_BYTE;
 		if (GLAD_ES_VERSION_2_0 && !GLAD_ES_VERSION_3_0)
@@ -1751,7 +1747,7 @@ OpenGL::TextureFormat OpenGL::convertPixelFormat(PixelFormat pixelformat, bool r
 			f.externalformat = GL_RGBA;
 		break;
 	case PIXELFORMAT_BGRA8_UNORM:
-	case PIXELFORMAT_BGRA8_UNORM_sRGB:
+	case PIXELFORMAT_BGRA8_sRGB:
 		// Not supported right now.
 		break;
 	case PIXELFORMAT_R16_UNORM:
@@ -2026,123 +2022,190 @@ OpenGL::TextureFormat OpenGL::convertPixelFormat(PixelFormat pixelformat, bool r
 		break;
 
 	case PIXELFORMAT_DXT1_UNORM:
-		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT : GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
+		f.internalformat = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
+		break;
+	case PIXELFORMAT_DXT1_sRGB:
+		f.internalformat = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;
 		break;
 	case PIXELFORMAT_DXT3_UNORM:
-		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT : GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
+		f.internalformat = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
+		break;
+	case PIXELFORMAT_DXT3_sRGB:
+		f.internalformat = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;
 		break;
 	case PIXELFORMAT_DXT5_UNORM:
-		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT : GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+		f.internalformat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+		break;
+	case PIXELFORMAT_DXT5_sRGB:
+		f.internalformat = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT;
 		break;
 	case PIXELFORMAT_BC4_UNORM:
-		isSRGB = false;
 		f.internalformat = GL_COMPRESSED_RED_RGTC1;
 		break;
 	case PIXELFORMAT_BC4_SNORM:
-		isSRGB = false;
 		f.internalformat = GL_COMPRESSED_SIGNED_RED_RGTC1;
 		break;
 	case PIXELFORMAT_BC5_UNORM:
-		isSRGB = false;
 		f.internalformat = GL_COMPRESSED_RG_RGTC2;
 		break;
 	case PIXELFORMAT_BC5_SNORM:
-		isSRGB = false;
 		f.internalformat = GL_COMPRESSED_SIGNED_RG_RGTC2;
 		break;
 	case PIXELFORMAT_BC6H_UFLOAT:
-		isSRGB = false;
 		f.internalformat = GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT;
 		break;
 	case PIXELFORMAT_BC6H_FLOAT:
-		isSRGB = false;
 		f.internalformat = GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT;
 		break;
 	case PIXELFORMAT_BC7_UNORM:
-		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM : GL_COMPRESSED_RGBA_BPTC_UNORM;
+		f.internalformat = GL_COMPRESSED_RGBA_BPTC_UNORM;
 		break;
+	case PIXELFORMAT_BC7_sRGB:
+		f.internalformat = GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM;
+		break;
+
 	case PIXELFORMAT_PVR1_RGB2_UNORM:
-		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT : GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG;
+		f.internalformat = GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG;
+		break;
+	case PIXELFORMAT_PVR1_RGB2_sRGB:
+		f.internalformat = GL_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT;
 		break;
 	case PIXELFORMAT_PVR1_RGB4_UNORM:
-		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT : GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG;
+		f.internalformat = GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG;
+		break;
+	case PIXELFORMAT_PVR1_RGB4_sRGB:
+		f.internalformat = GL_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT;
 		break;
 	case PIXELFORMAT_PVR1_RGBA2_UNORM:
-		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT : GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG;
+		f.internalformat = GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG;
+		break;
+	case PIXELFORMAT_PVR1_RGBA2_sRGB:
+		f.internalformat = GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT;
 		break;
 	case PIXELFORMAT_PVR1_RGBA4_UNORM:
-		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT : GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;
+		f.internalformat = GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;
+		break;
+	case PIXELFORMAT_PVR1_RGBA4_sRGB:
+		f.internalformat = GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT;
 		break;
+
 	case PIXELFORMAT_ETC1_UNORM:
-		isSRGB = false;
 		f.internalformat = GL_ETC1_RGB8_OES;
 		break;
 	case PIXELFORMAT_ETC2_RGB_UNORM:
-		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ETC2 : GL_COMPRESSED_RGB8_ETC2;
+		f.internalformat = GL_COMPRESSED_RGB8_ETC2;
+		break;
+	case PIXELFORMAT_ETC2_RGB_sRGB:
+		f.internalformat = GL_COMPRESSED_SRGB8_ETC2;
 		break;
 	case PIXELFORMAT_ETC2_RGBA_UNORM:
-		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC : GL_COMPRESSED_RGBA8_ETC2_EAC;
+		f.internalformat = GL_COMPRESSED_RGBA8_ETC2_EAC;
+		break;
+	case PIXELFORMAT_ETC2_RGBA_sRGB:
+		f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC;
 		break;
 	case PIXELFORMAT_ETC2_RGBA1_UNORM:
-		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 : GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2;
+		f.internalformat = GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2;
+		break;
+	case PIXELFORMAT_ETC2_RGBA1_sRGB:
+		f.internalformat = GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2;
 		break;
 	case PIXELFORMAT_EAC_R_UNORM:
-		isSRGB = false;
 		f.internalformat = GL_COMPRESSED_R11_EAC;
 		break;
 	case PIXELFORMAT_EAC_R_SNORM:
-		isSRGB = false;
 		f.internalformat = GL_COMPRESSED_SIGNED_R11_EAC;
 		break;
 	case PIXELFORMAT_EAC_RG_UNORM:
-		isSRGB = false;
 		f.internalformat = GL_COMPRESSED_RG11_EAC;
 		break;
 	case PIXELFORMAT_EAC_RG_SNORM:
-		isSRGB = false;
 		f.internalformat = GL_COMPRESSED_SIGNED_RG11_EAC;
 		break;
-	case PIXELFORMAT_ASTC_4x4:
-		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR : GL_COMPRESSED_RGBA_ASTC_4x4_KHR;
+
+	case PIXELFORMAT_ASTC_4x4_UNORM:
+		f.internalformat = GL_COMPRESSED_RGBA_ASTC_4x4_KHR;
+		break;
+	case PIXELFORMAT_ASTC_4x4_sRGB:
+		f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR;
 		break;
-	case PIXELFORMAT_ASTC_5x4:
-		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR : GL_COMPRESSED_RGBA_ASTC_5x4_KHR;
+	case PIXELFORMAT_ASTC_5x4_UNORM:
+		f.internalformat = GL_COMPRESSED_RGBA_ASTC_5x4_KHR;
 		break;
-	case PIXELFORMAT_ASTC_5x5:
-		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR : GL_COMPRESSED_RGBA_ASTC_5x5_KHR;
+	case PIXELFORMAT_ASTC_5x4_sRGB:
+		f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR;
 		break;
-	case PIXELFORMAT_ASTC_6x5:
-		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR : GL_COMPRESSED_RGBA_ASTC_6x5_KHR;
+	case PIXELFORMAT_ASTC_5x5_UNORM:
+		f.internalformat = GL_COMPRESSED_RGBA_ASTC_5x5_KHR;
 		break;
-	case PIXELFORMAT_ASTC_6x6:
-		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR : GL_COMPRESSED_RGBA_ASTC_6x6_KHR;
+	case PIXELFORMAT_ASTC_5x5_sRGB:
+		f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR;
 		break;
-	case PIXELFORMAT_ASTC_8x5:
-		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR : GL_COMPRESSED_RGBA_ASTC_8x5_KHR;
+	case PIXELFORMAT_ASTC_6x5_UNORM:
+		f.internalformat = GL_COMPRESSED_RGBA_ASTC_6x5_KHR;
 		break;
-	case PIXELFORMAT_ASTC_8x6:
-		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR : GL_COMPRESSED_RGBA_ASTC_8x6_KHR;
+	case PIXELFORMAT_ASTC_6x5_sRGB:
+		f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR;
 		break;
-	case PIXELFORMAT_ASTC_8x8:
-		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR : GL_COMPRESSED_RGBA_ASTC_8x8_KHR;
+	case PIXELFORMAT_ASTC_6x6_UNORM:
+		f.internalformat = GL_COMPRESSED_RGBA_ASTC_6x6_KHR;
 		break;
-	case PIXELFORMAT_ASTC_10x5:
-		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR : GL_COMPRESSED_RGBA_ASTC_10x5_KHR;
+	case PIXELFORMAT_ASTC_6x6_sRGB:
+		f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR;
 		break;
-	case PIXELFORMAT_ASTC_10x6:
-		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR : GL_COMPRESSED_RGBA_ASTC_10x6_KHR;
+	case PIXELFORMAT_ASTC_8x5_UNORM:
+		f.internalformat = GL_COMPRESSED_RGBA_ASTC_8x5_KHR;
 		break;
-	case PIXELFORMAT_ASTC_10x8:
-		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR : GL_COMPRESSED_RGBA_ASTC_10x8_KHR;
+	case PIXELFORMAT_ASTC_8x5_sRGB:
+		f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR;
 		break;
-	case PIXELFORMAT_ASTC_10x10:
-		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR : GL_COMPRESSED_RGBA_ASTC_10x10_KHR;
+	case PIXELFORMAT_ASTC_8x6_UNORM:
+		f.internalformat = GL_COMPRESSED_RGBA_ASTC_8x6_KHR;
 		break;
-	case PIXELFORMAT_ASTC_12x10:
-		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR : GL_COMPRESSED_RGBA_ASTC_12x10_KHR;
+	case PIXELFORMAT_ASTC_8x6_sRGB:
+		f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR;
 		break;
-	case PIXELFORMAT_ASTC_12x12:
-		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR : GL_COMPRESSED_RGBA_ASTC_12x12_KHR;
+	case PIXELFORMAT_ASTC_8x8_UNORM:
+		f.internalformat = GL_COMPRESSED_RGBA_ASTC_8x8_KHR;
+		break;
+	case PIXELFORMAT_ASTC_8x8_sRGB:
+		f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR;
+		break;
+	case PIXELFORMAT_ASTC_10x5_UNORM:
+		f.internalformat = GL_COMPRESSED_RGBA_ASTC_10x5_KHR;
+		break;
+	case PIXELFORMAT_ASTC_10x5_sRGB:
+		f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR;
+		break;
+	case PIXELFORMAT_ASTC_10x6_UNORM:
+		f.internalformat = GL_COMPRESSED_RGBA_ASTC_10x6_KHR;
+		break;
+	case PIXELFORMAT_ASTC_10x6_sRGB:
+		f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR;
+		break;
+	case PIXELFORMAT_ASTC_10x8_UNORM:
+		f.internalformat = GL_COMPRESSED_RGBA_ASTC_10x8_KHR;
+		break;
+	case PIXELFORMAT_ASTC_10x8_sRGB:
+		f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR;
+		break;
+	case PIXELFORMAT_ASTC_10x10_UNORM:
+		f.internalformat = GL_COMPRESSED_RGBA_ASTC_10x10_KHR;
+		break;
+	case PIXELFORMAT_ASTC_10x10_sRGB:
+		f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR;
+		break;
+	case PIXELFORMAT_ASTC_12x10_UNORM:
+		f.internalformat = GL_COMPRESSED_RGBA_ASTC_12x10_KHR;
+		break;
+	case PIXELFORMAT_ASTC_12x10_sRGB:
+		f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR;
+		break;
+	case PIXELFORMAT_ASTC_12x12_UNORM:
+		f.internalformat = GL_COMPRESSED_RGBA_ASTC_12x12_KHR;
+		break;
+	case PIXELFORMAT_ASTC_12x12_sRGB:
+		f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR;
 		break;
 
 	default:
@@ -2164,9 +2227,6 @@ OpenGL::TextureFormat OpenGL::convertPixelFormat(PixelFormat pixelformat, bool r
 		{
 			f.internalformat = f.externalformat;
 		}
-
-		if (!isPixelFormatSRGB(pixelformat))
-			isSRGB = false;
 	}
 
 	return f;
@@ -2198,7 +2258,7 @@ uint32 OpenGL::getPixelFormatUsageFlags(PixelFormat pixelformat)
 		if (GLAD_VERSION_4_3 || GLAD_ES_VERSION_3_1)
 			flags |= computewrite;
 		break;
-	case PIXELFORMAT_RGBA8_UNORM_sRGB:
+	case PIXELFORMAT_RGBA8_sRGB:
 		if (gl.bugs.brokenSRGB)
 			break;
 		if (GLAD_ES_VERSION_3_0 || GLAD_VERSION_2_1 || GLAD_EXT_texture_sRGB)
@@ -2210,7 +2270,7 @@ uint32 OpenGL::getPixelFormatUsageFlags(PixelFormat pixelformat)
 			flags |= computewrite;
 		break;
 	case PIXELFORMAT_BGRA8_UNORM:
-	case PIXELFORMAT_BGRA8_UNORM_sRGB:
+	case PIXELFORMAT_BGRA8_sRGB:
 		// Not supported right now.
 		break;
 	case PIXELFORMAT_R16_UNORM:
@@ -2278,47 +2338,47 @@ uint32 OpenGL::getPixelFormatUsageFlags(PixelFormat pixelformat)
 			flags |= computewrite;
 		break;
 
-		case PIXELFORMAT_R8_INT:
-		case PIXELFORMAT_R8_UINT:
-		case PIXELFORMAT_RG8_INT:
-		case PIXELFORMAT_RG8_UINT:
-		case PIXELFORMAT_RGBA8_INT:
-		case PIXELFORMAT_RGBA8_UINT:
-		case PIXELFORMAT_R16_INT:
-		case PIXELFORMAT_R16_UINT:
-		case PIXELFORMAT_RG16_INT:
-		case PIXELFORMAT_RG16_UINT:
-		case PIXELFORMAT_RGBA16_INT:
-		case PIXELFORMAT_RGBA16_UINT:
-		case PIXELFORMAT_R32_INT:
-		case PIXELFORMAT_R32_UINT:
-		case PIXELFORMAT_RG32_INT:
-		case PIXELFORMAT_RG32_UINT:
-		case PIXELFORMAT_RGBA32_INT:
-		case PIXELFORMAT_RGBA32_UINT:
-			if (GLAD_VERSION_3_0 || GLAD_ES_VERSION_3_0)
-				flags |= PIXELFORMATUSAGEFLAGS_SAMPLE | PIXELFORMATUSAGEFLAGS_RENDERTARGET;
-			if (GLAD_VERSION_4_3)
-				flags |= computewrite;
-			if (GLAD_ES_VERSION_3_1)
+	case PIXELFORMAT_R8_INT:
+	case PIXELFORMAT_R8_UINT:
+	case PIXELFORMAT_RG8_INT:
+	case PIXELFORMAT_RG8_UINT:
+	case PIXELFORMAT_RGBA8_INT:
+	case PIXELFORMAT_RGBA8_UINT:
+	case PIXELFORMAT_R16_INT:
+	case PIXELFORMAT_R16_UINT:
+	case PIXELFORMAT_RG16_INT:
+	case PIXELFORMAT_RG16_UINT:
+	case PIXELFORMAT_RGBA16_INT:
+	case PIXELFORMAT_RGBA16_UINT:
+	case PIXELFORMAT_R32_INT:
+	case PIXELFORMAT_R32_UINT:
+	case PIXELFORMAT_RG32_INT:
+	case PIXELFORMAT_RG32_UINT:
+	case PIXELFORMAT_RGBA32_INT:
+	case PIXELFORMAT_RGBA32_UINT:
+		if (GLAD_VERSION_3_0 || GLAD_ES_VERSION_3_0)
+			flags |= PIXELFORMATUSAGEFLAGS_SAMPLE | PIXELFORMATUSAGEFLAGS_RENDERTARGET;
+		if (GLAD_VERSION_4_3)
+			flags |= computewrite;
+		if (GLAD_ES_VERSION_3_1)
+		{
+			switch (pixelformat)
 			{
-				switch (pixelformat)
-				{
-				case PIXELFORMAT_RGBA8_INT:
-				case PIXELFORMAT_RGBA8_UINT:
-				case PIXELFORMAT_RGBA16_INT:
-				case PIXELFORMAT_RGBA16_UINT:
-				case PIXELFORMAT_R32_INT:
-				case PIXELFORMAT_R32_UINT:
-				case PIXELFORMAT_RGBA32_INT:
-				case PIXELFORMAT_RGBA32_UINT:
-					flags |= computewrite;
-					break;
-				default:
-					break;
-				}
+			case PIXELFORMAT_RGBA8_INT:
+			case PIXELFORMAT_RGBA8_UINT:
+			case PIXELFORMAT_RGBA16_INT:
+			case PIXELFORMAT_RGBA16_UINT:
+			case PIXELFORMAT_R32_INT:
+			case PIXELFORMAT_R32_UINT:
+			case PIXELFORMAT_RGBA32_INT:
+			case PIXELFORMAT_RGBA32_UINT:
+				flags |= computewrite;
+				break;
+			default:
+				break;
 			}
-			break;
+		}
+		break;
 
 	case PIXELFORMAT_LA8_UNORM:
 		flags |= commonsample;
@@ -2380,14 +2440,17 @@ uint32 OpenGL::getPixelFormatUsageFlags(PixelFormat pixelformat)
 		break;
 
 	case PIXELFORMAT_DXT1_UNORM:
+	case PIXELFORMAT_DXT1_sRGB:
 		if (GLAD_EXT_texture_compression_s3tc || GLAD_EXT_texture_compression_dxt1)
 			flags |= commonsample;
 		break;
 	case PIXELFORMAT_DXT3_UNORM:
+	case PIXELFORMAT_DXT3_sRGB:
 		if (GLAD_EXT_texture_compression_s3tc || GLAD_ANGLE_texture_compression_dxt3)
 			flags |= commonsample;
 		break;
 	case PIXELFORMAT_DXT5_UNORM:
+	case PIXELFORMAT_DXT5_sRGB:
 		if (GLAD_EXT_texture_compression_s3tc || GLAD_ANGLE_texture_compression_dxt5)
 			flags |= commonsample;
 		break;
@@ -2401,6 +2464,7 @@ uint32 OpenGL::getPixelFormatUsageFlags(PixelFormat pixelformat)
 	case PIXELFORMAT_BC6H_UFLOAT:
 	case PIXELFORMAT_BC6H_FLOAT:
 	case PIXELFORMAT_BC7_UNORM:
+	case PIXELFORMAT_BC7_sRGB:
 		if (GLAD_VERSION_4_2 || GLAD_ARB_texture_compression_bptc)
 			flags |= commonsample;
 		break;
@@ -2411,14 +2475,24 @@ uint32 OpenGL::getPixelFormatUsageFlags(PixelFormat pixelformat)
 		if (GLAD_IMG_texture_compression_pvrtc)
 			flags |= commonsample;
 		break;
+	case PIXELFORMAT_PVR1_RGB2_sRGB:
+	case PIXELFORMAT_PVR1_RGB4_sRGB:
+	case PIXELFORMAT_PVR1_RGBA2_sRGB:
+	case PIXELFORMAT_PVR1_RGBA4_sRGB:
+		if (GLAD_EXT_pvrtc_sRGB)
+			flags |= commonsample;
+		break;
 	case PIXELFORMAT_ETC1_UNORM:
 		// ETC2 support guarantees ETC1 support as well.
 		if (GLAD_ES_VERSION_3_0 || GLAD_VERSION_4_3 || GLAD_ARB_ES3_compatibility || GLAD_OES_compressed_ETC1_RGB8_texture)
 			flags |= commonsample;
 		break;
 	case PIXELFORMAT_ETC2_RGB_UNORM:
+	case PIXELFORMAT_ETC2_RGB_sRGB:
 	case PIXELFORMAT_ETC2_RGBA_UNORM:
+	case PIXELFORMAT_ETC2_RGBA_sRGB:
 	case PIXELFORMAT_ETC2_RGBA1_UNORM:
+	case PIXELFORMAT_ETC2_RGBA1_sRGB:
 	case PIXELFORMAT_EAC_R_UNORM:
 	case PIXELFORMAT_EAC_R_SNORM:
 	case PIXELFORMAT_EAC_RG_UNORM:
@@ -2426,20 +2500,34 @@ uint32 OpenGL::getPixelFormatUsageFlags(PixelFormat pixelformat)
 		if (GLAD_ES_VERSION_3_0 || GLAD_VERSION_4_3 || GLAD_ARB_ES3_compatibility)
 			flags |= commonsample;
 		break;
-	case PIXELFORMAT_ASTC_4x4:
-	case PIXELFORMAT_ASTC_5x4:
-	case PIXELFORMAT_ASTC_5x5:
-	case PIXELFORMAT_ASTC_6x5:
-	case PIXELFORMAT_ASTC_6x6:
-	case PIXELFORMAT_ASTC_8x5:
-	case PIXELFORMAT_ASTC_8x6:
-	case PIXELFORMAT_ASTC_8x8:
-	case PIXELFORMAT_ASTC_10x5:
-	case PIXELFORMAT_ASTC_10x6:
-	case PIXELFORMAT_ASTC_10x8:
-	case PIXELFORMAT_ASTC_10x10:
-	case PIXELFORMAT_ASTC_12x10:
-	case PIXELFORMAT_ASTC_12x12:
+	case PIXELFORMAT_ASTC_4x4_UNORM:
+	case PIXELFORMAT_ASTC_5x4_UNORM:
+	case PIXELFORMAT_ASTC_5x5_UNORM:
+	case PIXELFORMAT_ASTC_6x5_UNORM:
+	case PIXELFORMAT_ASTC_6x6_UNORM:
+	case PIXELFORMAT_ASTC_8x5_UNORM:
+	case PIXELFORMAT_ASTC_8x6_UNORM:
+	case PIXELFORMAT_ASTC_8x8_UNORM:
+	case PIXELFORMAT_ASTC_10x5_UNORM:
+	case PIXELFORMAT_ASTC_10x6_UNORM:
+	case PIXELFORMAT_ASTC_10x8_UNORM:
+	case PIXELFORMAT_ASTC_10x10_UNORM:
+	case PIXELFORMAT_ASTC_12x10_UNORM:
+	case PIXELFORMAT_ASTC_12x12_UNORM:
+	case PIXELFORMAT_ASTC_4x4_sRGB:
+	case PIXELFORMAT_ASTC_5x4_sRGB:
+	case PIXELFORMAT_ASTC_5x5_sRGB:
+	case PIXELFORMAT_ASTC_6x5_sRGB:
+	case PIXELFORMAT_ASTC_6x6_sRGB:
+	case PIXELFORMAT_ASTC_8x5_sRGB:
+	case PIXELFORMAT_ASTC_8x6_sRGB:
+	case PIXELFORMAT_ASTC_8x8_sRGB:
+	case PIXELFORMAT_ASTC_10x5_sRGB:
+	case PIXELFORMAT_ASTC_10x6_sRGB:
+	case PIXELFORMAT_ASTC_10x8_sRGB:
+	case PIXELFORMAT_ASTC_10x10_sRGB:
+	case PIXELFORMAT_ASTC_12x10_sRGB:
+	case PIXELFORMAT_ASTC_12x12_sRGB:
 		if (GLAD_ES_VERSION_3_2 || GLAD_KHR_texture_compression_astc_ldr)
 			flags |= commonsample;
 		break;

src/modules/graphics/opengl/OpenGL.h

@@ -381,7 +381,7 @@ public:
 	 * to glTexImage2D/3D for all levels and slices of a texture otherwise.
 	 * NOTE: this does not handle compressed texture formats.
 	 **/
-	bool rawTexStorage(TextureType target, int levels, PixelFormat pixelformat, bool &isSRGB, int width, int height, int depth = 1);
+	bool rawTexStorage(TextureType target, int levels, PixelFormat pixelformat, int width, int height, int depth = 1);
 
 	bool isTextureTypeSupported(TextureType type) const;
 	bool isBufferUsageSupported(BufferUsage usage) const;
@@ -475,7 +475,7 @@ public:
 	static GLint getGLWrapMode(SamplerState::WrapMode wmode);
 	static GLint getGLCompareMode(CompareMode mode);
 
-	static TextureFormat convertPixelFormat(PixelFormat pixelformat, bool renderbuffer, bool &isSRGB);
+	static TextureFormat convertPixelFormat(PixelFormat pixelformat, bool renderbuffer);
 	static bool isTexStorageSupported();
 	static uint32 getPixelFormatUsageFlags(PixelFormat pixelformat);
 

src/modules/graphics/opengl/Shader.cpp

@@ -175,8 +175,7 @@ void Shader::mapActiveUniforms()
 			else if ((u.access & ACCESS_READ) != 0)
 				binding.access = GL_READ_ONLY;
 
-			bool sRGB = false;
-			auto fmt = OpenGL::convertPixelFormat(u.storageTextureFormat, false, sRGB);
+			auto fmt = OpenGL::convertPixelFormat(u.storageTextureFormat, false);
 			binding.internalFormat = fmt.internalformat;
 
 			for (int i = 0; i < u.count; i++)

src/modules/graphics/opengl/Texture.cpp

@@ -56,8 +56,7 @@ static GLenum createFBO(GLuint &framebuffer, TextureType texType, PixelFormat fo
 			glReadBuffer(GL_NONE);
 		}
 
-		bool unusedSRGB = false;
-		OpenGL::TextureFormat fmt = OpenGL::convertPixelFormat(format, false, unusedSRGB);
+		OpenGL::TextureFormat fmt = OpenGL::convertPixelFormat(format, false);
 
 		int faces = texType == TEXTURE_CUBE ? 6 : 1;
 
@@ -125,8 +124,7 @@ static GLenum createFBO(GLuint &framebuffer, TextureType texType, PixelFormat fo
 
 static GLenum newRenderbuffer(int width, int height, int &samples, PixelFormat pixelformat, GLuint &buffer)
 {
-	bool unusedSRGB = false;
-	OpenGL::TextureFormat fmt = OpenGL::convertPixelFormat(pixelformat, true, unusedSRGB);
+	OpenGL::TextureFormat fmt = OpenGL::convertPixelFormat(pixelformat, true);
 
 	GLuint current_fbo = gl.getFramebuffer(OpenGL::FRAMEBUFFER_ALL);
 
@@ -282,7 +280,7 @@ void Texture::createTexture()
 	// remember some driver issues on some old Android systems, maybe...
 	// For now, the base class enforces data on init for compressed textures.
 	if (!isCompressed())
-		gl.rawTexStorage(texType, mipcount, format, sRGB, pixelWidth, pixelHeight, texType == TEXTURE_VOLUME ? depth : layers);
+		gl.rawTexStorage(texType, mipcount, format, pixelWidth, pixelHeight, texType == TEXTURE_VOLUME ? depth : layers);
 
 	// rawTexStorage handles this for uncompressed textures.
 	if (isCompressed() && (GLAD_VERSION_1_1 || GLAD_ES_VERSION_3_0))
@@ -292,7 +290,7 @@ void Texture::createTexture()
 	int h = pixelHeight;
 	int d = depth;
 
-	OpenGL::TextureFormat fmt = gl.convertPixelFormat(format, false, sRGB);
+	OpenGL::TextureFormat fmt = gl.convertPixelFormat(format, false);
 
 	for (int mip = 0; mip < mipcount; mip++)
 	{
@@ -460,7 +458,7 @@ void Texture::uploadByteData(PixelFormat pixelformat, const void *data, size_t s
 
 	gl.bindTextureToUnit(this, 0, false);
 
-	OpenGL::TextureFormat fmt = OpenGL::convertPixelFormat(pixelformat, false, sRGB);
+	OpenGL::TextureFormat fmt = OpenGL::convertPixelFormat(pixelformat, false);
 	GLenum gltarget = OpenGL::getGLTextureType(texType);
 
 	if (texType == TEXTURE_CUBE)
@@ -508,8 +506,7 @@ void Texture::readbackInternal(int slice, int mipmap, const Rect &rect, int dest
 
 	gl.bindTextureToUnit(this, 0, false);
 
-	bool isSRGB = false;
-	OpenGL::TextureFormat fmt = gl.convertPixelFormat(format, false, isSRGB);
+	OpenGL::TextureFormat fmt = gl.convertPixelFormat(format, false);
 
 	if (gl.isCopyTextureToBufferSupported())
 	{

src/modules/graphics/vulkan/Graphics.cpp

@@ -1057,11 +1057,11 @@ void Graphics::setWireframe(bool enable)
 	states.back().wireframe = enable;
 }
 
-bool Graphics::isPixelFormatSupported(PixelFormat format, uint32 usage, bool sRGB)
+bool Graphics::isPixelFormatSupported(PixelFormat format, uint32 usage)
 {
 	format = getSizedFormat(format);
 
-	auto vulkanFormat = Vulkan::getTextureFormat(format, sRGB);
+	auto vulkanFormat = Vulkan::getTextureFormat(format);
 
 	VkFormatProperties formatProperties;
 	vkGetPhysicalDeviceFormatProperties(physicalDevice, vulkanFormat.internalFormat, &formatProperties);
@@ -2444,12 +2444,12 @@ void Graphics::setRenderPass(const RenderTargets &rts, int pixelw, int pixelh, b
 	RenderPassConfiguration renderPassConfiguration{};
 	for (const auto &color : rts.colors)
 		renderPassConfiguration.colorAttachments.push_back({ 
-			Vulkan::getTextureFormat(color.texture->getPixelFormat(), isPixelFormatSRGB(color.texture->getPixelFormat())).internalFormat,
+			Vulkan::getTextureFormat(color.texture->getPixelFormat()).internalFormat,
 			VK_ATTACHMENT_LOAD_OP_LOAD,
 			dynamic_cast<Texture*>(color.texture)->getMsaaSamples() });
 	if (rts.depthStencil.texture != nullptr)
 		renderPassConfiguration.staticData.depthStencilAttachment = {
-			Vulkan::getTextureFormat(rts.depthStencil.texture->getPixelFormat(), false).internalFormat,
+			Vulkan::getTextureFormat(rts.depthStencil.texture->getPixelFormat()).internalFormat,
 			VK_ATTACHMENT_LOAD_OP_LOAD,
 			VK_ATTACHMENT_LOAD_OP_LOAD,
 			dynamic_cast<Texture*>(rts.depthStencil.texture)->getMsaaSamples() };

src/modules/graphics/vulkan/Graphics.h

@@ -297,7 +297,7 @@ public:
 	void setBlendState(const BlendState &blend) override;
 	void setPointSize(float size) override;
 	void setWireframe(bool enable) override;
-	bool isPixelFormatSupported(PixelFormat format, uint32 usage, bool sRGB) override;
+	bool isPixelFormatSupported(PixelFormat format, uint32 usage) override;
 	Renderer getRenderer() const override;
 	bool usesGLSLES() const override;
 	RendererInfo getRendererInfo() const override;

src/modules/graphics/vulkan/Texture.cpp

@@ -59,7 +59,7 @@ bool Texture::loadVolatile()
 	if (isPixelFormatColor(format))
 		imageAspect |= VK_IMAGE_ASPECT_COLOR_BIT;
 
-	auto vulkanFormat = Vulkan::getTextureFormat(format, sRGB);
+	auto vulkanFormat = Vulkan::getTextureFormat(format);
 
 	VkImageUsageFlags usageFlags =
 		VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
@@ -277,7 +277,7 @@ VkImageLayout Texture::getImageLayout() const
 
 void Texture::createTextureImageView()
 {
-	auto vulkanFormat = Vulkan::getTextureFormat(format, sRGB);
+	auto vulkanFormat = Vulkan::getTextureFormat(format);
 
 	VkImageViewCreateInfo viewInfo{};
 	viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
@@ -349,7 +349,7 @@ void Texture::clear()
 
 VkClearColorValue Texture::getClearValue()
 {
-	auto vulkanFormat = Vulkan::getTextureFormat(format, sRGB);
+	auto vulkanFormat = Vulkan::getTextureFormat(format);
 
 	VkClearColorValue clearColor{};
 	switch (vulkanFormat.internalFormatRepresentation)

src/modules/graphics/vulkan/Vulkan.cpp

@@ -130,16 +130,10 @@ VkFormat Vulkan::getVulkanVertexFormat(DataFormat format)
 	}
 }
 
-TextureFormat Vulkan::getTextureFormat(PixelFormat format, bool sRGB)
+TextureFormat Vulkan::getTextureFormat(PixelFormat format)
 {
 	TextureFormat textureFormat{};
 
-	if (sRGB)
-		format = getSRGBPixelFormat(format);
-
-	if (!isPixelFormatCompressed(format) && !isPixelFormatSRGB(format))
-		sRGB = false;
-
 	switch (format)
 	{
 	case PIXELFORMAT_UNKNOWN:
@@ -231,13 +225,13 @@ TextureFormat Vulkan::getTextureFormat(PixelFormat format, bool sRGB)
 	case PIXELFORMAT_RGBA8_UNORM:
 		textureFormat.internalFormat = VK_FORMAT_R8G8B8A8_UNORM;
 		break;
-	case PIXELFORMAT_RGBA8_UNORM_sRGB:
+	case PIXELFORMAT_RGBA8_sRGB:
 		textureFormat.internalFormat = VK_FORMAT_R8G8B8A8_SRGB;
 		break;
 	case PIXELFORMAT_BGRA8_UNORM:
 		textureFormat.internalFormat = VK_FORMAT_B8G8R8A8_UNORM;
 		break;
-	case PIXELFORMAT_BGRA8_UNORM_sRGB:
+	case PIXELFORMAT_BGRA8_sRGB:
 		textureFormat.internalFormat = VK_FORMAT_B8G8R8A8_SRGB;
 		break;
 	case PIXELFORMAT_RGBA8_INT:
@@ -308,13 +302,22 @@ TextureFormat Vulkan::getTextureFormat(PixelFormat format, bool sRGB)
 		textureFormat.internalFormat = VK_FORMAT_D32_SFLOAT_S8_UINT;
 		break;
 	case PIXELFORMAT_DXT1_UNORM:
-		textureFormat.internalFormat = sRGB ? VK_FORMAT_BC1_RGBA_SRGB_BLOCK : VK_FORMAT_BC1_RGBA_UNORM_BLOCK;
+		textureFormat.internalFormat = VK_FORMAT_BC1_RGBA_UNORM_BLOCK;
+		break;
+	case PIXELFORMAT_DXT1_sRGB:
+		textureFormat.internalFormat = VK_FORMAT_BC1_RGBA_SRGB_BLOCK;
 		break;
 	case PIXELFORMAT_DXT3_UNORM:
-		textureFormat.internalFormat = sRGB ? VK_FORMAT_BC2_SRGB_BLOCK : VK_FORMAT_BC2_UNORM_BLOCK;
+		textureFormat.internalFormat = VK_FORMAT_BC2_UNORM_BLOCK;
+		break;
+	case PIXELFORMAT_DXT3_sRGB:
+		textureFormat.internalFormat = VK_FORMAT_BC2_SRGB_BLOCK;
 		break;
 	case PIXELFORMAT_DXT5_UNORM:
-		textureFormat.internalFormat = sRGB ? VK_FORMAT_BC3_SRGB_BLOCK : VK_FORMAT_BC3_UNORM_BLOCK;
+		textureFormat.internalFormat = VK_FORMAT_BC3_UNORM_BLOCK;
+		break;
+	case PIXELFORMAT_DXT5_sRGB:
+		textureFormat.internalFormat = VK_FORMAT_BC3_SRGB_BLOCK;
 		break;
 	case PIXELFORMAT_BC4_UNORM:
 		textureFormat.internalFormat = VK_FORMAT_BC4_UNORM_BLOCK;
@@ -335,31 +338,55 @@ TextureFormat Vulkan::getTextureFormat(PixelFormat format, bool sRGB)
 		textureFormat.internalFormat = VK_FORMAT_BC6H_SFLOAT_BLOCK;
 		break;
 	case PIXELFORMAT_BC7_UNORM:
-		textureFormat.internalFormat = sRGB ? VK_FORMAT_BC7_SRGB_BLOCK : VK_FORMAT_BC7_UNORM_BLOCK;
+		textureFormat.internalFormat = VK_FORMAT_BC7_UNORM_BLOCK;
+		break;
+	case PIXELFORMAT_BC7_sRGB:
+		textureFormat.internalFormat = VK_FORMAT_BC7_SRGB_BLOCK;
 		break;
 	case PIXELFORMAT_PVR1_RGB2_UNORM:
-		textureFormat.internalFormat = sRGB ? VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG : VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG;
+		textureFormat.internalFormat = VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG;
+		break;
+	case PIXELFORMAT_PVR1_RGB2_sRGB:
+		textureFormat.internalFormat = VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG;
 		break;
 	case PIXELFORMAT_PVR1_RGB4_UNORM:
-		textureFormat.internalFormat = sRGB ? VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG : VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG;
+		textureFormat.internalFormat = VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG;
+		break;
+	case PIXELFORMAT_PVR1_RGB4_sRGB:
+		textureFormat.internalFormat = VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG;
 		break;
 	case PIXELFORMAT_PVR1_RGBA2_UNORM:
-		textureFormat.internalFormat = sRGB ? VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG : VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG;
+		textureFormat.internalFormat = VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG;
+		break;
+	case PIXELFORMAT_PVR1_RGBA2_sRGB:
+		textureFormat.internalFormat = VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG;
 		break;
 	case PIXELFORMAT_PVR1_RGBA4_UNORM:
-		textureFormat.internalFormat = sRGB ? VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG : VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG;
+		textureFormat.internalFormat = VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG;
+		break;
+	case PIXELFORMAT_PVR1_RGBA4_sRGB:
+		textureFormat.internalFormat = VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG;
 		break;
 	case PIXELFORMAT_ETC1_UNORM:
-		textureFormat.internalFormat = sRGB ? VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK : VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK;
+		textureFormat.internalFormat = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK;
 		break;
 	case PIXELFORMAT_ETC2_RGB_UNORM:
-		textureFormat.internalFormat = sRGB ? VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK : VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK;
+		textureFormat.internalFormat = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK;
+		break;
+	case PIXELFORMAT_ETC2_RGB_sRGB:
+		textureFormat.internalFormat = VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK;
 		break;
 	case PIXELFORMAT_ETC2_RGBA_UNORM:
-		textureFormat.internalFormat = sRGB ? VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK : VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK;
+		textureFormat.internalFormat = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK;
+		break;
+	case PIXELFORMAT_ETC2_RGBA_sRGB:
+		textureFormat.internalFormat = VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK;
 		break;
 	case PIXELFORMAT_ETC2_RGBA1_UNORM:
-		textureFormat.internalFormat = sRGB ? VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK : VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK;
+		textureFormat.internalFormat = VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK;
+		break;
+	case PIXELFORMAT_ETC2_RGBA1_sRGB:
+		textureFormat.internalFormat = VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK;
 		break;
 	case PIXELFORMAT_EAC_R_UNORM:
 		textureFormat.internalFormat = VK_FORMAT_EAC_R11_UNORM_BLOCK;
@@ -373,47 +400,89 @@ TextureFormat Vulkan::getTextureFormat(PixelFormat format, bool sRGB)
 	case PIXELFORMAT_EAC_RG_SNORM:
 		textureFormat.internalFormat = VK_FORMAT_EAC_R11G11_SNORM_BLOCK;
 		break;
-	case PIXELFORMAT_ASTC_4x4:
-		textureFormat.internalFormat = sRGB ? VK_FORMAT_ASTC_4x4_SRGB_BLOCK : VK_FORMAT_ASTC_4x4_UNORM_BLOCK;
+	case PIXELFORMAT_ASTC_4x4_UNORM:
+		textureFormat.internalFormat = VK_FORMAT_ASTC_4x4_UNORM_BLOCK;
+		break;
+	case PIXELFORMAT_ASTC_5x4_UNORM:
+		textureFormat.internalFormat = VK_FORMAT_ASTC_5x4_UNORM_BLOCK;
+		break;
+	case PIXELFORMAT_ASTC_5x5_UNORM:
+		textureFormat.internalFormat = VK_FORMAT_ASTC_5x5_UNORM_BLOCK;
+		break;
+	case PIXELFORMAT_ASTC_6x5_UNORM:
+		textureFormat.internalFormat = VK_FORMAT_ASTC_6x5_UNORM_BLOCK;
+		break;
+	case PIXELFORMAT_ASTC_6x6_UNORM:
+		textureFormat.internalFormat = VK_FORMAT_ASTC_6x6_UNORM_BLOCK;
+		break;
+	case PIXELFORMAT_ASTC_8x5_UNORM:
+		textureFormat.internalFormat = VK_FORMAT_ASTC_8x5_UNORM_BLOCK;
+		break;
+	case PIXELFORMAT_ASTC_8x6_UNORM:
+		textureFormat.internalFormat = VK_FORMAT_ASTC_8x6_UNORM_BLOCK;
+		break;
+	case PIXELFORMAT_ASTC_8x8_UNORM:
+		textureFormat.internalFormat = VK_FORMAT_ASTC_8x8_UNORM_BLOCK;
+		break;
+	case PIXELFORMAT_ASTC_10x5_UNORM:
+		textureFormat.internalFormat = VK_FORMAT_ASTC_10x5_UNORM_BLOCK;
+		break;
+	case PIXELFORMAT_ASTC_10x6_UNORM:
+		textureFormat.internalFormat = VK_FORMAT_ASTC_10x6_UNORM_BLOCK;
+		break;
+	case PIXELFORMAT_ASTC_10x8_UNORM:
+		textureFormat.internalFormat = VK_FORMAT_ASTC_10x8_UNORM_BLOCK;
+		break;
+	case PIXELFORMAT_ASTC_10x10_UNORM:
+		textureFormat.internalFormat = VK_FORMAT_ASTC_10x10_UNORM_BLOCK;
+		break;
+	case PIXELFORMAT_ASTC_12x10_UNORM:
+		textureFormat.internalFormat = VK_FORMAT_ASTC_12x10_UNORM_BLOCK;
+		break;
+	case PIXELFORMAT_ASTC_12x12_UNORM:
+		textureFormat.internalFormat = VK_FORMAT_ASTC_12x12_UNORM_BLOCK;
+		break;
+	case PIXELFORMAT_ASTC_4x4_sRGB:
+		textureFormat.internalFormat = VK_FORMAT_ASTC_4x4_SRGB_BLOCK;
 		break;
-	case PIXELFORMAT_ASTC_5x4:
-		textureFormat.internalFormat = sRGB ? VK_FORMAT_ASTC_5x4_SRGB_BLOCK : VK_FORMAT_ASTC_5x4_UNORM_BLOCK;
+	case PIXELFORMAT_ASTC_5x4_sRGB:
+		textureFormat.internalFormat = VK_FORMAT_ASTC_5x4_SRGB_BLOCK;
 		break;
-	case PIXELFORMAT_ASTC_5x5:
-		textureFormat.internalFormat = sRGB ? VK_FORMAT_ASTC_5x5_SRGB_BLOCK : VK_FORMAT_ASTC_5x5_UNORM_BLOCK;
+	case PIXELFORMAT_ASTC_5x5_sRGB:
+		textureFormat.internalFormat = VK_FORMAT_ASTC_5x5_SRGB_BLOCK;
 		break;
-	case PIXELFORMAT_ASTC_6x5:
-		textureFormat.internalFormat = sRGB ? VK_FORMAT_ASTC_6x5_SRGB_BLOCK : VK_FORMAT_ASTC_6x5_UNORM_BLOCK;
+	case PIXELFORMAT_ASTC_6x5_sRGB:
+		textureFormat.internalFormat = VK_FORMAT_ASTC_6x5_SRGB_BLOCK;
 		break;
-	case PIXELFORMAT_ASTC_6x6:
-		textureFormat.internalFormat = sRGB ? VK_FORMAT_ASTC_6x6_SRGB_BLOCK : VK_FORMAT_ASTC_6x6_UNORM_BLOCK;
+	case PIXELFORMAT_ASTC_6x6_sRGB:
+		textureFormat.internalFormat = VK_FORMAT_ASTC_6x6_SRGB_BLOCK;
 		break;
-	case PIXELFORMAT_ASTC_8x5:
-		textureFormat.internalFormat = sRGB ? VK_FORMAT_ASTC_8x5_SRGB_BLOCK : VK_FORMAT_ASTC_8x5_UNORM_BLOCK;
+	case PIXELFORMAT_ASTC_8x5_sRGB:
+		textureFormat.internalFormat = VK_FORMAT_ASTC_8x5_SRGB_BLOCK;
 		break;
-	case PIXELFORMAT_ASTC_8x6:
-		textureFormat.internalFormat = sRGB ? VK_FORMAT_ASTC_8x6_SRGB_BLOCK : VK_FORMAT_ASTC_8x6_UNORM_BLOCK;
+	case PIXELFORMAT_ASTC_8x6_sRGB:
+		textureFormat.internalFormat = VK_FORMAT_ASTC_8x6_SRGB_BLOCK;
 		break;
-	case PIXELFORMAT_ASTC_8x8:
-		textureFormat.internalFormat = sRGB ? VK_FORMAT_ASTC_8x8_SRGB_BLOCK : VK_FORMAT_ASTC_8x8_UNORM_BLOCK;
+	case PIXELFORMAT_ASTC_8x8_sRGB:
+		textureFormat.internalFormat = VK_FORMAT_ASTC_8x8_SRGB_BLOCK;
 		break;
-	case PIXELFORMAT_ASTC_10x5:
-		textureFormat.internalFormat = sRGB ? VK_FORMAT_ASTC_10x5_SRGB_BLOCK : VK_FORMAT_ASTC_10x5_UNORM_BLOCK;
+	case PIXELFORMAT_ASTC_10x5_sRGB:
+		textureFormat.internalFormat = VK_FORMAT_ASTC_10x5_SRGB_BLOCK;
 		break;
-	case PIXELFORMAT_ASTC_10x6:
-		textureFormat.internalFormat = sRGB ? VK_FORMAT_ASTC_10x6_SRGB_BLOCK : VK_FORMAT_ASTC_10x6_UNORM_BLOCK;
+	case PIXELFORMAT_ASTC_10x6_sRGB:
+		textureFormat.internalFormat = VK_FORMAT_ASTC_10x6_SRGB_BLOCK;
 		break;
-	case PIXELFORMAT_ASTC_10x8:
-		textureFormat.internalFormat = sRGB ? VK_FORMAT_ASTC_10x8_SRGB_BLOCK : VK_FORMAT_ASTC_10x8_UNORM_BLOCK;
+	case PIXELFORMAT_ASTC_10x8_sRGB:
+		textureFormat.internalFormat = VK_FORMAT_ASTC_10x8_SRGB_BLOCK;
 		break;
-	case PIXELFORMAT_ASTC_10x10:
-		textureFormat.internalFormat = sRGB ? VK_FORMAT_ASTC_10x10_SRGB_BLOCK : VK_FORMAT_ASTC_10x10_UNORM_BLOCK;
+	case PIXELFORMAT_ASTC_10x10_sRGB:
+		textureFormat.internalFormat = VK_FORMAT_ASTC_10x10_SRGB_BLOCK;
 		break;
-	case PIXELFORMAT_ASTC_12x10:
-		textureFormat.internalFormat = sRGB ? VK_FORMAT_ASTC_12x10_SRGB_BLOCK : VK_FORMAT_ASTC_12x10_UNORM_BLOCK;
+	case PIXELFORMAT_ASTC_12x10_sRGB:
+		textureFormat.internalFormat = VK_FORMAT_ASTC_12x10_SRGB_BLOCK;
 		break;
-	case PIXELFORMAT_ASTC_12x12:
-		textureFormat.internalFormat = sRGB ? VK_FORMAT_ASTC_12x12_SRGB_BLOCK : VK_FORMAT_ASTC_12x12_UNORM_BLOCK;
+	case PIXELFORMAT_ASTC_12x12_sRGB:
+		textureFormat.internalFormat = VK_FORMAT_ASTC_12x12_SRGB_BLOCK;
 		break;
 	default:
 		throw love::Exception("unknown pixel format");

src/modules/graphics/vulkan/Vulkan.h

@@ -59,7 +59,7 @@ public:
 	static void resetShaderSwitches();
 
 	static VkFormat getVulkanVertexFormat(DataFormat format);
-	static TextureFormat getTextureFormat(PixelFormat, bool sRGB);
+	static TextureFormat getTextureFormat(PixelFormat format);
 	static std::string getVendorName(uint32_t vendorId);
 	static std::string getVulkanApiVersion(uint32_t apiVersion);
 	static VkPrimitiveTopology getPrimitiveTypeTopology(graphics::PrimitiveType);

src/modules/graphics/wrap_Graphics.cpp

@@ -2783,7 +2783,6 @@ int w_getTextureFormats(lua_State *L)
 	luaL_checktype(L, 1, LUA_TTABLE);
 
 	bool rt = luax_checkboolflag(L, 1, Texture::getConstant(Texture::SETTING_RENDER_TARGET));
-	bool linear = luax_boolflag(L, 1, Texture::getConstant(Texture::SETTING_LINEAR), false);
 	bool computewrite = luax_boolflag(L, 1, Texture::getConstant(Texture::SETTING_COMPUTE_WRITE), false);
 
 	OptionalBool readable;
@@ -2808,8 +2807,6 @@ int w_getTextureFormats(lua_State *L)
 		if (rt && isPixelFormatDepth(format))
 			continue;
 
-		bool sRGB = isGammaCorrect() && !linear;
-
 		uint32 usage = PIXELFORMATUSAGEFLAGS_NONE;
 		if (rt)
 			usage |= PIXELFORMATUSAGEFLAGS_RENDERTARGET;
@@ -2818,7 +2815,7 @@ int w_getTextureFormats(lua_State *L)
 		if (computewrite)
 			usage |= PIXELFORMATUSAGEFLAGS_COMPUTEWRITE;
 
-		luax_pushboolean(L, instance()->isPixelFormatSupported(format, (PixelFormatUsageFlags) usage, sRGB));
+		luax_pushboolean(L, instance()->isPixelFormatSupported(format, (PixelFormatUsageFlags) usage));
 		lua_setfield(L, -2, name);
 	}
 
@@ -2862,14 +2859,14 @@ int w_getCanvasFormats(lua_State *L)
 			supported = [](PixelFormat format) -> bool
 			{
 				const uint32 usage = PIXELFORMATUSAGEFLAGS_SAMPLE | PIXELFORMATUSAGEFLAGS_RENDERTARGET;
-				return instance()->isPixelFormatSupported(format, (PixelFormatUsageFlags) usage, false);
+				return instance()->isPixelFormatSupported(format, (PixelFormatUsageFlags) usage);
 			};
 		}
 		else
 		{
 			supported = [](PixelFormat format) -> bool
 			{
-				return instance()->isPixelFormatSupported(format, PIXELFORMATUSAGEFLAGS_RENDERTARGET, false);
+				return instance()->isPixelFormatSupported(format, PIXELFORMATUSAGEFLAGS_RENDERTARGET);
 			};
 		}
 	}
@@ -2881,7 +2878,7 @@ int w_getCanvasFormats(lua_State *L)
 			uint32 usage = PIXELFORMATUSAGEFLAGS_RENDERTARGET;
 			if (readable)
 				usage |= PIXELFORMATUSAGEFLAGS_SAMPLE;
-			return instance()->isPixelFormatSupported(format, (PixelFormatUsageFlags) usage, false);
+			return instance()->isPixelFormatSupported(format, (PixelFormatUsageFlags) usage);
 		};
 	}
 
@@ -2894,7 +2891,7 @@ int w_getImageFormats(lua_State *L)
 
 	const auto supported = [](PixelFormat format) -> bool
 	{
-		return instance()->isPixelFormatSupported(format, PIXELFORMATUSAGEFLAGS_SAMPLE, false);
+		return instance()->isPixelFormatSupported(format, PIXELFORMATUSAGEFLAGS_SAMPLE);
 	};
 
 	const auto ignore = [](PixelFormat format) -> bool

src/modules/image/magpie/ASTCHandler.cpp

@@ -54,33 +54,33 @@ static PixelFormat convertFormat(uint32 blockX, uint32 blockY, uint32 blockZ)
 		return PIXELFORMAT_UNKNOWN;
 
 	if (blockX == 4 && blockY == 4)
-		return PIXELFORMAT_ASTC_4x4;
+		return PIXELFORMAT_ASTC_4x4_UNORM;
 	else if (blockX == 5 && blockY == 4)
-		return PIXELFORMAT_ASTC_5x4;
+		return PIXELFORMAT_ASTC_5x4_UNORM;
 	else if (blockX == 5 && blockY == 5)
-		return PIXELFORMAT_ASTC_5x5;
+		return PIXELFORMAT_ASTC_5x5_UNORM;
 	else if (blockX == 6 && blockY == 5)
-		return PIXELFORMAT_ASTC_6x5;
+		return PIXELFORMAT_ASTC_6x5_UNORM;
 	else if (blockX == 6 && blockY == 6)
-		return PIXELFORMAT_ASTC_6x6;
+		return PIXELFORMAT_ASTC_6x6_UNORM;
 	else if (blockX == 8 && blockY == 5)
-		return PIXELFORMAT_ASTC_8x5;
+		return PIXELFORMAT_ASTC_8x5_UNORM;
 	else if (blockX == 8 && blockY == 6)
-		return PIXELFORMAT_ASTC_8x6;
+		return PIXELFORMAT_ASTC_8x6_UNORM;
 	else if (blockX == 8 && blockY == 8)
-		return PIXELFORMAT_ASTC_8x8;
+		return PIXELFORMAT_ASTC_8x8_UNORM;
 	else if (blockX == 10 && blockY == 5)
-		return PIXELFORMAT_ASTC_10x5;
+		return PIXELFORMAT_ASTC_10x5_UNORM;
 	else if (blockX == 10 && blockY == 6)
-		return PIXELFORMAT_ASTC_10x6;
+		return PIXELFORMAT_ASTC_10x6_UNORM;
 	else if (blockX == 10 && blockY == 8)
-		return PIXELFORMAT_ASTC_10x8;
+		return PIXELFORMAT_ASTC_10x8_UNORM;
 	else if (blockX == 10 && blockY == 10)
-		return PIXELFORMAT_ASTC_10x10;
+		return PIXELFORMAT_ASTC_10x10_UNORM;
 	else if (blockX == 12 && blockY == 10)
-		return PIXELFORMAT_ASTC_12x10;
+		return PIXELFORMAT_ASTC_12x10_UNORM;
 	else if (blockX == 12 && blockY == 12)
-		return PIXELFORMAT_ASTC_12x12;
+		return PIXELFORMAT_ASTC_12x12_UNORM;
 
 	return PIXELFORMAT_UNKNOWN;
 }

src/modules/image/magpie/KTXHandler.cpp

@@ -221,59 +221,59 @@ PixelFormat convertFormat(uint32 glformat, bool &sRGB)
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_ASTC_4x4_KHR:
-		return PIXELFORMAT_ASTC_4x4;
+		return PIXELFORMAT_ASTC_4x4_UNORM;
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_ASTC_5x4_KHR:
-		return PIXELFORMAT_ASTC_5x4;
+		return PIXELFORMAT_ASTC_5x4_UNORM;
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_ASTC_5x5_KHR:
-		return PIXELFORMAT_ASTC_5x5;
+		return PIXELFORMAT_ASTC_5x5_UNORM;
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_ASTC_6x5_KHR:
-		return PIXELFORMAT_ASTC_6x5;
+		return PIXELFORMAT_ASTC_6x5_UNORM;
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_ASTC_6x6_KHR:
-		return PIXELFORMAT_ASTC_6x6;
+		return PIXELFORMAT_ASTC_6x6_UNORM;
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_ASTC_8x5_KHR:
-		return PIXELFORMAT_ASTC_8x5;
+		return PIXELFORMAT_ASTC_8x5_UNORM;
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_ASTC_8x6_KHR:
-		return PIXELFORMAT_ASTC_8x6;
+		return PIXELFORMAT_ASTC_8x6_UNORM;
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_ASTC_8x8_KHR:
-		return PIXELFORMAT_ASTC_8x8;
+		return PIXELFORMAT_ASTC_8x8_UNORM;
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_ASTC_10x5_KHR:
-		return PIXELFORMAT_ASTC_10x5;
+		return PIXELFORMAT_ASTC_10x5_UNORM;
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_ASTC_10x6_KHR:
-		return PIXELFORMAT_ASTC_10x6;
+		return PIXELFORMAT_ASTC_10x6_UNORM;
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_ASTC_10x8_KHR:
-		return PIXELFORMAT_ASTC_10x8;
+		return PIXELFORMAT_ASTC_10x8_UNORM;
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_ASTC_10x10_KHR:
-		return PIXELFORMAT_ASTC_10x10;
+		return PIXELFORMAT_ASTC_10x10_UNORM;
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_ASTC_12x10_KHR:
-		return PIXELFORMAT_ASTC_12x10;
+		return PIXELFORMAT_ASTC_12x10_UNORM;
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_ASTC_12x12_KHR:
-		return PIXELFORMAT_ASTC_12x12;
+		return PIXELFORMAT_ASTC_12x12_UNORM;
 	default:
 		return PIXELFORMAT_UNKNOWN;
 	}

src/modules/image/magpie/PVRHandler.cpp

@@ -256,33 +256,33 @@ static PixelFormat convertFormat(PVRV3PixelFormat format, PVRV3ChannelType chann
 	case ePVRTPF_EAC_RG:
 		return snorm ? PIXELFORMAT_EAC_RG_SNORM : PIXELFORMAT_EAC_RG_UNORM;
 	case ePVRTPF_ASTC_4x4:
-		return PIXELFORMAT_ASTC_4x4;
+		return PIXELFORMAT_ASTC_4x4_UNORM;
 	case ePVRTPF_ASTC_5x4:
-		return PIXELFORMAT_ASTC_5x4;
+		return PIXELFORMAT_ASTC_5x4_UNORM;
 	case ePVRTPF_ASTC_5x5:
-		return PIXELFORMAT_ASTC_5x5;
+		return PIXELFORMAT_ASTC_5x5_UNORM;
 	case ePVRTPF_ASTC_6x5:
-		return PIXELFORMAT_ASTC_6x5;
+		return PIXELFORMAT_ASTC_6x5_UNORM;
 	case ePVRTPF_ASTC_6x6:
-		return PIXELFORMAT_ASTC_6x6;
+		return PIXELFORMAT_ASTC_6x6_UNORM;
 	case ePVRTPF_ASTC_8x5:
-		return PIXELFORMAT_ASTC_8x5;
+		return PIXELFORMAT_ASTC_8x5_UNORM;
 	case ePVRTPF_ASTC_8x6:
-		return PIXELFORMAT_ASTC_8x6;
+		return PIXELFORMAT_ASTC_8x6_UNORM;
 	case ePVRTPF_ASTC_8x8:
-		return PIXELFORMAT_ASTC_8x8;
+		return PIXELFORMAT_ASTC_8x8_UNORM;
 	case ePVRTPF_ASTC_10x5:
-		return PIXELFORMAT_ASTC_10x5;
+		return PIXELFORMAT_ASTC_10x5_UNORM;
 	case ePVRTPF_ASTC_10x6:
-		return PIXELFORMAT_ASTC_10x6;
+		return PIXELFORMAT_ASTC_10x6_UNORM;
 	case ePVRTPF_ASTC_10x8:
-		return PIXELFORMAT_ASTC_10x8;
+		return PIXELFORMAT_ASTC_10x8_UNORM;
 	case ePVRTPF_ASTC_10x10:
-		return PIXELFORMAT_ASTC_10x10;
+		return PIXELFORMAT_ASTC_10x10_UNORM;
 	case ePVRTPF_ASTC_12x10:
-		return PIXELFORMAT_ASTC_12x10;
+		return PIXELFORMAT_ASTC_12x10_UNORM;
 	case ePVRTPF_ASTC_12x12:
-		return PIXELFORMAT_ASTC_12x12;
+		return PIXELFORMAT_ASTC_12x12_UNORM;
 	default:
 		return PIXELFORMAT_UNKNOWN;
 	}