Update the internal naming convention for pixel formats.

--HG--
branch : minor

src/common/pixelformat.cpp

@@ -31,57 +31,57 @@ static StringMap<PixelFormat, PIXELFORMAT_MAX_ENUM>::Entry formatEntries[] =
 	{ "normal",  PIXELFORMAT_NORMAL  },
 	{ "hdr",     PIXELFORMAT_HDR     },
 
-	{ "r8",      PIXELFORMAT_R8      },
-	{ "rg8",     PIXELFORMAT_RG8     },
-	{ "rgba8",   PIXELFORMAT_RGBA8   },
-	{ "srgba8",  PIXELFORMAT_sRGBA8  },
-	{ "r16",     PIXELFORMAT_R16     },
-	{ "rg16",    PIXELFORMAT_RG16    },
-	{ "rgba16",  PIXELFORMAT_RGBA16  },
-	{ "r16f",    PIXELFORMAT_R16F    },
-	{ "rg16f",   PIXELFORMAT_RG16F   },
-	{ "rgba16f", PIXELFORMAT_RGBA16F },
-	{ "r32f",    PIXELFORMAT_R32F    },
-	{ "rg32f",   PIXELFORMAT_RG32F   },
-	{ "rgba32f", PIXELFORMAT_RGBA32F },
-
-	{ "la8",     PIXELFORMAT_LA8     },
-
-	{ "rgba4",    PIXELFORMAT_RGBA4    },
-	{ "rgb5a1",   PIXELFORMAT_RGB5A1   },
-	{ "rgb565",   PIXELFORMAT_RGB565   },
-	{ "rgb10a2",  PIXELFORMAT_RGB10A2  },
-	{ "rg11b10f", PIXELFORMAT_RG11B10F },
-
-	{ "stencil8",         PIXELFORMAT_STENCIL8          },
-	{ "depth16",          PIXELFORMAT_DEPTH16           },
-	{ "depth24",          PIXELFORMAT_DEPTH24           },
-	{ "depth32f",         PIXELFORMAT_DEPTH32F          },
-	{ "depth24stencil8",  PIXELFORMAT_DEPTH24_STENCIL8  },
-	{ "depth32fstencil8", PIXELFORMAT_DEPTH32F_STENCIL8 },
+	{ "r8",      PIXELFORMAT_R8_UNORM     },
+	{ "rg8",     PIXELFORMAT_RG8_UNORM    },
+	{ "rgba8",   PIXELFORMAT_RGBA8_UNORM  },
+	{ "srgba8",  PIXELFORMAT_sRGBA8_UNORM },
+	{ "r16",     PIXELFORMAT_R16_UNORM    },
+	{ "rg16",    PIXELFORMAT_RG16_UNORM   },
+	{ "rgba16",  PIXELFORMAT_RGBA16_UNORM },
+	{ "r16f",    PIXELFORMAT_R16_FLOAT    },
+	{ "rg16f",   PIXELFORMAT_RG16_FLOAT   },
+	{ "rgba16f", PIXELFORMAT_RGBA16_FLOAT },
+	{ "r32f",    PIXELFORMAT_R32_FLOAT    },
+	{ "rg32f",   PIXELFORMAT_RG32_FLOAT   },
+	{ "rgba32f", PIXELFORMAT_RGBA32_FLOAT },
+
+	{ "la8",     PIXELFORMAT_LA8_UNORM    },
+
+	{ "rgba4",    PIXELFORMAT_RGBA4_UNORM    },
+	{ "rgb5a1",   PIXELFORMAT_RGB5A1_UNORM   },
+	{ "rgb565",   PIXELFORMAT_RGB565_UNORM   },
+	{ "rgb10a2",  PIXELFORMAT_RGB10A2_UNORM  },
+	{ "rg11b10f", PIXELFORMAT_RG11B10_FLOAT  },
+
+	{ "stencil8",         PIXELFORMAT_STENCIL8               },
+	{ "depth16",          PIXELFORMAT_DEPTH16_UNORM          },
+	{ "depth24",          PIXELFORMAT_DEPTH24_UNORM          },
+	{ "depth32f",         PIXELFORMAT_DEPTH32_FLOAT          },
+	{ "depth24stencil8",  PIXELFORMAT_DEPTH24_UNORM_STENCIL8 },
+	{ "depth32fstencil8", PIXELFORMAT_DEPTH32_FLOAT_STENCIL8 },
 	
-	{ "DXT1",      PIXELFORMAT_DXT1       },
-	{ "DXT3",      PIXELFORMAT_DXT3       },
-	{ "DXT5",      PIXELFORMAT_DXT5       },
-	{ "BC4",       PIXELFORMAT_BC4        },
-	{ "BC4s",      PIXELFORMAT_BC4s       },
-	{ "BC5",       PIXELFORMAT_BC5        },
-	{ "BC5s",      PIXELFORMAT_BC5s       },
-	{ "BC6h",      PIXELFORMAT_BC6H       },
-	{ "BC6hs",     PIXELFORMAT_BC6Hs      },
-	{ "BC7",       PIXELFORMAT_BC7        },
-	{ "PVR1rgb2",  PIXELFORMAT_PVR1_RGB2  },
-	{ "PVR1rgb4",  PIXELFORMAT_PVR1_RGB4  },
-	{ "PVR1rgba2", PIXELFORMAT_PVR1_RGBA2 },
-	{ "PVR1rgba4", PIXELFORMAT_PVR1_RGBA4 },
-	{ "ETC1",      PIXELFORMAT_ETC1       },
-	{ "ETC2rgb",   PIXELFORMAT_ETC2_RGB   },
-	{ "ETC2rgba",  PIXELFORMAT_ETC2_RGBA  },
-	{ "ETC2rgba1", PIXELFORMAT_ETC2_RGBA1 },
-	{ "EACr",      PIXELFORMAT_EAC_R      },
-	{ "EACrs",     PIXELFORMAT_EAC_Rs     },
-	{ "EACrg",     PIXELFORMAT_EAC_RG     },
-	{ "EACrgs",    PIXELFORMAT_EAC_RGs    },
+	{ "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   },
@@ -116,59 +116,59 @@ bool isPixelFormatCompressed(PixelFormat format)
 {
 	// I'm lazy
 	int iformat = (int) format;
-	return iformat >= (int) PIXELFORMAT_DXT1 && iformat < (int) PIXELFORMAT_MAX_ENUM;
+	return iformat >= (int) PIXELFORMAT_DXT1_UNORM && iformat < (int) PIXELFORMAT_MAX_ENUM;
 }
 
 bool isPixelFormatDepthStencil(PixelFormat format)
 {
 	int iformat = (int) format;
-	return iformat >= (int) PIXELFORMAT_STENCIL8 && iformat <= (int) PIXELFORMAT_DEPTH32F_STENCIL8;
+	return iformat >= (int) PIXELFORMAT_STENCIL8 && iformat <= (int) PIXELFORMAT_DEPTH32_FLOAT_STENCIL8;
 }
 
 bool isPixelFormatDepth(PixelFormat format)
 {
 	int iformat = (int) format;
-	return iformat >= (int) PIXELFORMAT_DEPTH16 && iformat <= (int) PIXELFORMAT_DEPTH32F_STENCIL8;
+	return iformat >= (int) PIXELFORMAT_DEPTH16_UNORM && iformat <= (int) PIXELFORMAT_DEPTH32_FLOAT_STENCIL8;
 }
 
 bool isPixelFormatStencil(PixelFormat format)
 {
-	return format == PIXELFORMAT_STENCIL8 || format == PIXELFORMAT_DEPTH24_STENCIL8 || format == PIXELFORMAT_DEPTH32F_STENCIL8;
+	return format == PIXELFORMAT_STENCIL8 || format == PIXELFORMAT_DEPTH24_UNORM_STENCIL8 || format == PIXELFORMAT_DEPTH32_FLOAT_STENCIL8;
 }
 
 size_t getPixelFormatSize(PixelFormat format)
 {
 	switch (format)
 	{
-	case PIXELFORMAT_R8:
+	case PIXELFORMAT_R8_UNORM:
 	case PIXELFORMAT_STENCIL8:
 		return 1;
-	case PIXELFORMAT_RG8:
-	case PIXELFORMAT_R16:
-	case PIXELFORMAT_R16F:
-	case PIXELFORMAT_LA8:
-	case PIXELFORMAT_RGBA4:
-	case PIXELFORMAT_RGB5A1:
-	case PIXELFORMAT_RGB565:
-	case PIXELFORMAT_DEPTH16:
+	case PIXELFORMAT_RG8_UNORM:
+	case PIXELFORMAT_R16_UNORM:
+	case PIXELFORMAT_R16_FLOAT:
+	case PIXELFORMAT_LA8_UNORM:
+	case PIXELFORMAT_RGBA4_UNORM:
+	case PIXELFORMAT_RGB5A1_UNORM:
+	case PIXELFORMAT_RGB565_UNORM:
+	case PIXELFORMAT_DEPTH16_UNORM:
 		return 2;
-	case PIXELFORMAT_RGBA8:
-	case PIXELFORMAT_sRGBA8:
-	case PIXELFORMAT_RG16:
-	case PIXELFORMAT_RG16F:
-	case PIXELFORMAT_R32F:
-	case PIXELFORMAT_RGB10A2:
-	case PIXELFORMAT_RG11B10F:
-	case PIXELFORMAT_DEPTH24:
-	case PIXELFORMAT_DEPTH32F:
-	case PIXELFORMAT_DEPTH24_STENCIL8:
+	case PIXELFORMAT_RGBA8_UNORM:
+	case PIXELFORMAT_sRGBA8_UNORM:
+	case PIXELFORMAT_RG16_UNORM:
+	case PIXELFORMAT_RG16_FLOAT:
+	case PIXELFORMAT_R32_FLOAT:
+	case PIXELFORMAT_RGB10A2_UNORM:
+	case PIXELFORMAT_RG11B10_FLOAT:
+	case PIXELFORMAT_DEPTH24_UNORM:
+	case PIXELFORMAT_DEPTH32_FLOAT:
+	case PIXELFORMAT_DEPTH24_UNORM_STENCIL8:
 		return 4;
-	case PIXELFORMAT_RGBA16:
-	case PIXELFORMAT_RGBA16F:
-	case PIXELFORMAT_RG32F:
-	case PIXELFORMAT_DEPTH32F_STENCIL8:
+	case PIXELFORMAT_RGBA16_UNORM:
+	case PIXELFORMAT_RGBA16_FLOAT:
+	case PIXELFORMAT_RG32_FLOAT:
+	case PIXELFORMAT_DEPTH32_FLOAT_STENCIL8:
 		return 8;
-	case PIXELFORMAT_RGBA32F:
+	case PIXELFORMAT_RGBA32_FLOAT:
 		return 16;
 	default:
 		// TODO: compressed formats
@@ -180,28 +180,28 @@ int getPixelFormatColorComponents(PixelFormat format)
 {
 	switch (format)
 	{
-	case PIXELFORMAT_R8:
-	case PIXELFORMAT_R16:
-	case PIXELFORMAT_R16F:
-	case PIXELFORMAT_R32F:
+	case PIXELFORMAT_R8_UNORM:
+	case PIXELFORMAT_R16_UNORM:
+	case PIXELFORMAT_R16_FLOAT:
+	case PIXELFORMAT_R32_FLOAT:
 		return 1;
-	case PIXELFORMAT_RG8:
-	case PIXELFORMAT_RG16:
-	case PIXELFORMAT_RG16F:
-	case PIXELFORMAT_RG32F:
-	case PIXELFORMAT_LA8:
+	case PIXELFORMAT_RG8_UNORM:
+	case PIXELFORMAT_RG16_UNORM:
+	case PIXELFORMAT_RG16_FLOAT:
+	case PIXELFORMAT_RG32_FLOAT:
+	case PIXELFORMAT_LA8_UNORM:
 		return 2;
-	case PIXELFORMAT_RGB565:
-	case PIXELFORMAT_RG11B10F:
+	case PIXELFORMAT_RGB565_UNORM:
+	case PIXELFORMAT_RG11B10_FLOAT:
 		return 3;
-	case PIXELFORMAT_RGBA8:
-	case PIXELFORMAT_sRGBA8:
-	case PIXELFORMAT_RGBA16:
-	case PIXELFORMAT_RGBA16F:
-	case PIXELFORMAT_RGBA32F:
-	case PIXELFORMAT_RGBA4:
-	case PIXELFORMAT_RGB5A1:
-	case PIXELFORMAT_RGB10A2:
+	case PIXELFORMAT_RGBA8_UNORM:
+	case PIXELFORMAT_sRGBA8_UNORM:
+	case PIXELFORMAT_RGBA16_UNORM:
+	case PIXELFORMAT_RGBA16_FLOAT:
+	case PIXELFORMAT_RGBA32_FLOAT:
+	case PIXELFORMAT_RGBA4_UNORM:
+	case PIXELFORMAT_RGB5A1_UNORM:
+	case PIXELFORMAT_RGB10A2_UNORM:
 		return 4;
 	default:
 		return 0;

src/common/pixelformat.h

@@ -34,60 +34,60 @@ enum PixelFormat
 	PIXELFORMAT_HDR,
 
 	// "regular" formats
-	PIXELFORMAT_R8,
-	PIXELFORMAT_RG8,
-	PIXELFORMAT_RGBA8,
-	PIXELFORMAT_sRGBA8,
-	PIXELFORMAT_R16,
-	PIXELFORMAT_RG16,
-	PIXELFORMAT_RGBA16,
-	PIXELFORMAT_R16F,
-	PIXELFORMAT_RG16F,
-	PIXELFORMAT_RGBA16F,
-	PIXELFORMAT_R32F,
-	PIXELFORMAT_RG32F,
-	PIXELFORMAT_RGBA32F,
-
-	PIXELFORMAT_LA8, // Same as RG8, but accessed as (L, L, L, A)
+	PIXELFORMAT_R8_UNORM,
+	PIXELFORMAT_RG8_UNORM,
+	PIXELFORMAT_RGBA8_UNORM,
+	PIXELFORMAT_sRGBA8_UNORM,
+	PIXELFORMAT_R16_UNORM,
+	PIXELFORMAT_RG16_UNORM,
+	PIXELFORMAT_RGBA16_UNORM,
+	PIXELFORMAT_R16_FLOAT,
+	PIXELFORMAT_RG16_FLOAT,
+	PIXELFORMAT_RGBA16_FLOAT,
+	PIXELFORMAT_R32_FLOAT,
+	PIXELFORMAT_RG32_FLOAT,
+	PIXELFORMAT_RGBA32_FLOAT,
+
+	PIXELFORMAT_LA8_UNORM, // Same as RG8, but accessed as (L, L, L, A)
 
 	// packed formats
-	PIXELFORMAT_RGBA4,    // LSB->MSB: [a, b, g, r]
-	PIXELFORMAT_RGB5A1,   // LSB->MSB: [a, b, g, r]
-	PIXELFORMAT_RGB565,   // LSB->MSB: [b, g, r]
-	PIXELFORMAT_RGB10A2,  // LSB->MSB: [r, g, b, a]
-	PIXELFORMAT_RG11B10F, // LSB->MSB: [r, g, b]
+	PIXELFORMAT_RGBA4_UNORM,    // LSB->MSB: [a, b, g, r]
+	PIXELFORMAT_RGB5A1_UNORM,   // LSB->MSB: [a, b, g, r]
+	PIXELFORMAT_RGB565_UNORM,   // LSB->MSB: [b, g, r]
+	PIXELFORMAT_RGB10A2_UNORM,  // LSB->MSB: [r, g, b, a]
+	PIXELFORMAT_RG11B10_FLOAT, // LSB->MSB: [r, g, b]
 
 	// depth/stencil formats
 	PIXELFORMAT_STENCIL8,
-	PIXELFORMAT_DEPTH16,
-	PIXELFORMAT_DEPTH24,
-	PIXELFORMAT_DEPTH32F,
-	PIXELFORMAT_DEPTH24_STENCIL8,
-	PIXELFORMAT_DEPTH32F_STENCIL8,
+	PIXELFORMAT_DEPTH16_UNORM,
+	PIXELFORMAT_DEPTH24_UNORM,
+	PIXELFORMAT_DEPTH32_FLOAT,
+	PIXELFORMAT_DEPTH24_UNORM_STENCIL8,
+	PIXELFORMAT_DEPTH32_FLOAT_STENCIL8,
 
 	// compressed formats
-	PIXELFORMAT_DXT1,
-	PIXELFORMAT_DXT3,
-	PIXELFORMAT_DXT5,
-	PIXELFORMAT_BC4,
-	PIXELFORMAT_BC4s,
-	PIXELFORMAT_BC5,
-	PIXELFORMAT_BC5s,
-	PIXELFORMAT_BC6H,
-	PIXELFORMAT_BC6Hs,
-	PIXELFORMAT_BC7,
-	PIXELFORMAT_PVR1_RGB2,
-	PIXELFORMAT_PVR1_RGB4,
-	PIXELFORMAT_PVR1_RGBA2,
-	PIXELFORMAT_PVR1_RGBA4,
-	PIXELFORMAT_ETC1,
-	PIXELFORMAT_ETC2_RGB,
-	PIXELFORMAT_ETC2_RGBA,
-	PIXELFORMAT_ETC2_RGBA1,
-	PIXELFORMAT_EAC_R,
-	PIXELFORMAT_EAC_Rs,
-	PIXELFORMAT_EAC_RG,
-	PIXELFORMAT_EAC_RGs,
+	PIXELFORMAT_DXT1_UNORM,
+	PIXELFORMAT_DXT3_UNORM,
+	PIXELFORMAT_DXT5_UNORM,
+	PIXELFORMAT_BC4_UNORM,
+	PIXELFORMAT_BC4_SNORM,
+	PIXELFORMAT_BC5_UNORM,
+	PIXELFORMAT_BC5_SNORM,
+	PIXELFORMAT_BC6H_UFLOAT,
+	PIXELFORMAT_BC6H_FLOAT,
+	PIXELFORMAT_BC7_UNORM,
+	PIXELFORMAT_PVR1_RGB2_UNORM,
+	PIXELFORMAT_PVR1_RGB4_UNORM,
+	PIXELFORMAT_PVR1_RGBA2_UNORM,
+	PIXELFORMAT_PVR1_RGBA4_UNORM,
+	PIXELFORMAT_ETC1_UNORM,
+	PIXELFORMAT_ETC2_RGB_UNORM,
+	PIXELFORMAT_ETC2_RGBA_UNORM,
+	PIXELFORMAT_ETC2_RGBA1_UNORM,
+	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,

src/modules/font/BMFontRasterizer.cpp

@@ -147,7 +147,7 @@ BMFontRasterizer::BMFontRasterizer(love::filesystem::FileData *fontdef, const st
 	// The parseConfig function will try to load any missing page images.
 	for (int i = 0; i < (int) imagelist.size(); i++)
 	{
-		if (imagelist[i]->getFormat() != PIXELFORMAT_RGBA8)
+		if (imagelist[i]->getFormat() != PIXELFORMAT_RGBA8_UNORM)
 			throw love::Exception("Only 32-bit RGBA images are supported in BMFonts.");
 
 		images[i] = imagelist[i];
@@ -211,7 +211,7 @@ void BMFontRasterizer::parseConfig(const std::string &configtext)
 
 				ImageData *imagedata = imagemodule->newImageData(data.get());
 
-				if (imagedata->getFormat() != PIXELFORMAT_RGBA8)
+				if (imagedata->getFormat() != PIXELFORMAT_RGBA8_UNORM)
 				{
 					imagedata->release();
 					throw love::Exception("Only 32-bit RGBA images are supported in BMFonts.");
@@ -298,16 +298,16 @@ GlyphData *BMFontRasterizer::getGlyphData(uint32 glyph) const
 
 	// Return an empty GlyphData if we don't have the glyph character.
 	if (it == characters.end())
-		return new GlyphData(glyph, GlyphMetrics(), PIXELFORMAT_RGBA8);
+		return new GlyphData(glyph, GlyphMetrics(), PIXELFORMAT_RGBA8_UNORM);
 
 	const BMFontCharacter &c = it->second;
 	const auto &imagepair = images.find(c.page);
 
 	if (imagepair == images.end())
-		return new GlyphData(glyph, GlyphMetrics(), PIXELFORMAT_RGBA8);
+		return new GlyphData(glyph, GlyphMetrics(), PIXELFORMAT_RGBA8_UNORM);
 
 	image::ImageData *imagedata = imagepair->second.get();
-	GlyphData *g = new GlyphData(glyph, c.metrics, PIXELFORMAT_RGBA8);
+	GlyphData *g = new GlyphData(glyph, c.metrics, PIXELFORMAT_RGBA8_UNORM);
 
 	size_t pixelsize = imagedata->getPixelSize();
 

src/modules/font/GlyphData.cpp

@@ -41,7 +41,7 @@ GlyphData::GlyphData(uint32 glyph, GlyphMetrics glyphMetrics, PixelFormat f)
 	, data(nullptr)
 	, format(f)
 {
-	if (f != PIXELFORMAT_LA8 && f != PIXELFORMAT_RGBA8)
+	if (f != PIXELFORMAT_LA8_UNORM && f != PIXELFORMAT_RGBA8_UNORM)
 		throw love::Exception("Invalid GlyphData pixel format.");
 
 	if (metrics.width > 0 && metrics.height > 0)

src/modules/font/ImageRasterizer.cpp

@@ -39,7 +39,7 @@ ImageRasterizer::ImageRasterizer(love::image::ImageData *data, uint32 *glyphs, i
 {
 	this->dpiScale = dpiscale;
 
-	if (data->getFormat() != PIXELFORMAT_RGBA8)
+	if (data->getFormat() != PIXELFORMAT_RGBA8_UNORM)
 		throw love::Exception("Only 32-bit RGBA images are supported in Image Fonts!");
 
 	load();
@@ -68,7 +68,7 @@ GlyphData *ImageRasterizer::getGlyphData(uint32 glyph) const
 
 	gm.height = metrics.height;
 
-	GlyphData *g = new GlyphData(glyph, gm, PIXELFORMAT_RGBA8);
+	GlyphData *g = new GlyphData(glyph, gm, PIXELFORMAT_RGBA8_UNORM);
 
 	if (gm.width == 0)
 		return g;

src/modules/font/freetype/TrueTypeRasterizer.cpp

@@ -113,7 +113,7 @@ GlyphData *TrueTypeRasterizer::getGlyphData(uint32 glyph) const
 	glyphMetrics.width = bitmap.width;
 	glyphMetrics.advance = (int) (ftglyph->advance.x >> 16);
 
-	GlyphData *glyphData = new GlyphData(glyph, glyphMetrics, PIXELFORMAT_LA8);
+	GlyphData *glyphData = new GlyphData(glyph, glyphMetrics, PIXELFORMAT_LA8_UNORM);
 
 	const uint8 *pixels = bitmap.buffer;
 	uint8 *dest = (uint8 *) glyphData->getData();

src/modules/graphics/Canvas.cpp

@@ -138,8 +138,8 @@ love::image::ImageData *Canvas::newImageData(love::image::Image *module, int sli
 		throw love::Exception("Canvas:newImageData cannot be called while that Canvas is currently active.");
 
 	PixelFormat dataformat = getPixelFormat();
-	if (dataformat == PIXELFORMAT_sRGBA8)
-		dataformat = PIXELFORMAT_RGBA8;
+	if (dataformat == PIXELFORMAT_sRGBA8_UNORM)
+		dataformat = PIXELFORMAT_RGBA8_UNORM;
 
 	if (!image::ImageData::validPixelFormat(dataformat))
 	{

src/modules/graphics/Font.cpp

@@ -161,7 +161,7 @@ void Font::createTexture()
 		// glyphs), and transparent black otherwise.
 		std::vector<uint8> emptydata(pixelcount * bpp, 0);
 
-		if (pixelFormat == PIXELFORMAT_LA8)
+		if (pixelFormat == PIXELFORMAT_LA8_UNORM)
 		{
 			for (size_t i = 0; i < pixelcount; i++)
 				emptydata[i * 2 + 0] = 255;

src/modules/graphics/Graphics.cpp

@@ -625,7 +625,7 @@ void Graphics::setCanvas(const RenderTargets &rts)
 	if (!firstcanvas->isValidSlice(firsttarget.slice))
 		throw love::Exception("Invalid slice index: %d.", firsttarget.slice + 1);
 
-	bool hasSRGBcanvas = firstcolorformat == PIXELFORMAT_sRGBA8;
+	bool hasSRGBcanvas = firstcolorformat == PIXELFORMAT_sRGBA8_UNORM;
 	int pixelw = firstcanvas->getPixelWidth(firsttarget.mipmap);
 	int pixelh = firstcanvas->getPixelHeight(firsttarget.mipmap);
 	int reqmsaa = firstcanvas->getRequestedMSAA();
@@ -655,7 +655,7 @@ void Graphics::setCanvas(const RenderTargets &rts)
 		if (isPixelFormatDepthStencil(format))
 			throw love::Exception("Depth/stencil format Canvases must be used with the 'depthstencil' field of the table passed into setCanvas.");
 
-		if (format == PIXELFORMAT_sRGBA8)
+		if (format == PIXELFORMAT_sRGBA8_UNORM)
 			hasSRGBcanvas = true;
 	}
 
@@ -693,11 +693,11 @@ void Graphics::setCanvas(const RenderTargets &rts)
 
 		PixelFormat dsformat = PIXELFORMAT_STENCIL8;
 		if (wantsdepth && wantsstencil)
-			dsformat = PIXELFORMAT_DEPTH24_STENCIL8;
-		else if (wantsdepth && isCanvasFormatSupported(PIXELFORMAT_DEPTH24, false))
-			dsformat = PIXELFORMAT_DEPTH24;
+			dsformat = PIXELFORMAT_DEPTH24_UNORM_STENCIL8;
+		else if (wantsdepth && isCanvasFormatSupported(PIXELFORMAT_DEPTH24_UNORM, false))
+			dsformat = PIXELFORMAT_DEPTH24_UNORM;
 		else if (wantsdepth)
-			dsformat = PIXELFORMAT_DEPTH16;
+			dsformat = PIXELFORMAT_DEPTH16_UNORM;
 		else if (wantsstencil)
 			dsformat = PIXELFORMAT_STENCIL8;
 

src/modules/graphics/Video.cpp

@@ -79,12 +79,12 @@ Video::Video(Graphics *gfx, love::video::VideoStream *stream, float dpiscale)
 
 	for (int i = 0; i < 3; i++)
 	{
-		Image *img = gfx->newImage(TEXTURE_2D, PIXELFORMAT_R8, widths[i], heights[i], 1, settings);
+		Image *img = gfx->newImage(TEXTURE_2D, PIXELFORMAT_R8_UNORM, widths[i], heights[i], 1, settings);
 
 		img->setFilter(filter);
 		img->setWrap(wrap);
 
-		size_t bpp = getPixelFormatSize(PIXELFORMAT_R8);
+		size_t bpp = getPixelFormatSize(PIXELFORMAT_R8_UNORM);
 		size_t size = bpp * widths[i] * heights[i];
 
 		Rect rect = {0, 0, widths[i], heights[i]};
@@ -161,7 +161,7 @@ void Video::update()
 
 		for (int i = 0; i < 3; i++)
 		{
-			size_t bpp = getPixelFormatSize(PIXELFORMAT_R8);
+			size_t bpp = getPixelFormatSize(PIXELFORMAT_R8_UNORM);
 			size_t size = bpp * widths[i] * heights[i];
 
 			Rect rect = {0, 0, widths[i], heights[i]};

src/modules/graphics/opengl/Canvas.cpp

@@ -245,7 +245,7 @@ bool Canvas::loadVolatile()
 		while (glGetError() != GL_NO_ERROR)
 			/* Clear the error buffer. */;
 
-		bool isSRGB = format == PIXELFORMAT_sRGBA8;
+		bool isSRGB = format == PIXELFORMAT_sRGBA8_UNORM;
 		if (!gl.rawTexStorage(texType, mipmapCount, format, isSRGB, pixelWidth, pixelHeight, texType == TEXTURE_VOLUME ? depth : layers))
 		{
 			status = GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
@@ -480,14 +480,14 @@ PixelFormat Canvas::getSizedFormat(PixelFormat format)
 	{
 	case PIXELFORMAT_NORMAL:
 		if (isGammaCorrect())
-			return PIXELFORMAT_sRGBA8;
-		else if (!OpenGL::isPixelFormatSupported(PIXELFORMAT_RGBA8, true, true, false))
+			return PIXELFORMAT_sRGBA8_UNORM;
+		else if (!OpenGL::isPixelFormatSupported(PIXELFORMAT_RGBA8_UNORM, true, true, false))
 			// 32-bit render targets don't have guaranteed support on GLES2.
-			return PIXELFORMAT_RGBA4;
+			return PIXELFORMAT_RGBA4_UNORM;
 		else
-			return PIXELFORMAT_RGBA8;
+			return PIXELFORMAT_RGBA8_UNORM;
 	case PIXELFORMAT_HDR:
-		return PIXELFORMAT_RGBA16F;
+		return PIXELFORMAT_RGBA16_FLOAT;
 	default:
 		return format;
 	}

src/modules/graphics/opengl/Graphics.cpp

@@ -980,7 +980,7 @@ void Graphics::present(void *screenshotCallbackData)
 
 			try
 			{
-				img = imagemodule->newImageData(w, h, PIXELFORMAT_RGBA8, screenshot);
+				img = imagemodule->newImageData(w, h, PIXELFORMAT_RGBA8_UNORM, screenshot);
 			}
 			catch (love::Exception &)
 			{

src/modules/graphics/opengl/Image.cpp

@@ -76,7 +76,7 @@ void Image::loadDefaultTexture()
 	setFilter(filter);
 
 	bool isSRGB = false;
-	gl.rawTexStorage(texType, 1, PIXELFORMAT_RGBA8, isSRGB, 2, 2, 1);
+	gl.rawTexStorage(texType, 1, PIXELFORMAT_RGBA8_UNORM, isSRGB, 2, 2, 1);
 
 	// A nice friendly checkerboard to signify invalid textures...
 	GLubyte px[] = {0xFF,0xFF,0xFF,0xFF, 0xFF,0xA0,0xA0,0xFF,
@@ -85,7 +85,7 @@ void Image::loadDefaultTexture()
 	int slices = texType == TEXTURE_CUBE ? 6 : 1;
 	Rect rect = {0, 0, 2, 2};
 	for (int slice = 0; slice < slices; slice++)
-		uploadByteData(PIXELFORMAT_RGBA8, px, sizeof(px), 0, slice, rect);
+		uploadByteData(PIXELFORMAT_RGBA8_UNORM, px, sizeof(px), 0, slice, rect);
 }
 
 void Image::loadData()

src/modules/graphics/opengl/OpenGL.cpp

@@ -525,9 +525,9 @@ void OpenGL::createDefaultTexture()
 		setTextureFilter(type, filter);
 
 		bool isSRGB = false;
-		rawTexStorage(type, 1, PIXELFORMAT_RGBA8, isSRGB, 1, 1);
+		rawTexStorage(type, 1, PIXELFORMAT_RGBA8_UNORM, isSRGB, 1, 1);
 
-		TextureFormat fmt = convertPixelFormat(PIXELFORMAT_RGBA8, false, isSRGB);
+		TextureFormat fmt = convertPixelFormat(PIXELFORMAT_RGBA8_UNORM, false, isSRGB);
 
 		int slices = type == TEXTURE_CUBE ? 6 : 1;
 
@@ -1298,18 +1298,18 @@ OpenGL::TextureFormat OpenGL::convertPixelFormat(PixelFormat pixelformat, bool r
 	f.framebufferAttachments[0] = GL_COLOR_ATTACHMENT0;
 	f.framebufferAttachments[1] = GL_NONE;
 
-	if (pixelformat == PIXELFORMAT_RGBA8 && isSRGB)
-		pixelformat = PIXELFORMAT_sRGBA8;
-	else if (pixelformat == PIXELFORMAT_ETC1)
+	if (pixelformat == PIXELFORMAT_RGBA8_UNORM && isSRGB)
+		pixelformat = PIXELFORMAT_sRGBA8_UNORM;
+	else 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)
-			pixelformat = PIXELFORMAT_ETC2_RGB;
+			pixelformat = PIXELFORMAT_ETC2_RGB_UNORM;
 	}
 
 	switch (pixelformat)
 	{
-	case PIXELFORMAT_R8:
+	case PIXELFORMAT_R8_UNORM:
 		if ((GLAD_VERSION_3_0 || GLAD_ES_VERSION_3_0 || GLAD_ARB_texture_rg || GLAD_EXT_texture_rg)
 			&& !gl.bugs.brokenR8PixelFormat)
 		{
@@ -1323,17 +1323,17 @@ OpenGL::TextureFormat OpenGL::convertPixelFormat(PixelFormat pixelformat, bool r
 		}
 		f.type = GL_UNSIGNED_BYTE;
 		break;
-	case PIXELFORMAT_RG8:
+	case PIXELFORMAT_RG8_UNORM:
 		f.internalformat = GL_RG8;
 		f.externalformat = GL_RG;
 		f.type = GL_UNSIGNED_BYTE;
 		break;
-	case PIXELFORMAT_RGBA8:
+	case PIXELFORMAT_RGBA8_UNORM:
 		f.internalformat = GL_RGBA8;
 		f.externalformat = GL_RGBA;
 		f.type = GL_UNSIGNED_BYTE;
 		break;
-	case PIXELFORMAT_sRGBA8:
+	case PIXELFORMAT_sRGBA8_UNORM:
 		f.internalformat = GL_SRGB8_ALPHA8;
 		f.type = GL_UNSIGNED_BYTE;
 		if (GLAD_ES_VERSION_2_0 && !GLAD_ES_VERSION_3_0)
@@ -1341,22 +1341,22 @@ OpenGL::TextureFormat OpenGL::convertPixelFormat(PixelFormat pixelformat, bool r
 		else
 			f.externalformat = GL_RGBA;
 		break;
-	case PIXELFORMAT_R16:
+	case PIXELFORMAT_R16_UNORM:
 		f.internalformat = GL_R16;
 		f.externalformat = GL_RED;
 		f.type = GL_UNSIGNED_SHORT;
 		break;
-	case PIXELFORMAT_RG16:
+	case PIXELFORMAT_RG16_UNORM:
 		f.internalformat = GL_RG16;
 		f.externalformat = GL_RG;
 		f.type = GL_UNSIGNED_SHORT;
 		break;
-	case PIXELFORMAT_RGBA16:
+	case PIXELFORMAT_RGBA16_UNORM:
 		f.internalformat = GL_RGBA16;
 		f.externalformat = GL_RGBA;
 		f.type = GL_UNSIGNED_SHORT;
 		break;
-	case PIXELFORMAT_R16F:
+	case PIXELFORMAT_R16_FLOAT:
 		f.internalformat = GL_R16F;
 		f.externalformat = GL_RED;
 		if (GLAD_OES_texture_half_float)
@@ -1364,7 +1364,7 @@ OpenGL::TextureFormat OpenGL::convertPixelFormat(PixelFormat pixelformat, bool r
 		else
 			f.type = GL_HALF_FLOAT;
 		break;
-	case PIXELFORMAT_RG16F:
+	case PIXELFORMAT_RG16_FLOAT:
 		f.internalformat = GL_RG16F;
 		f.externalformat = GL_RG;
 		if (GLAD_OES_texture_half_float)
@@ -1372,7 +1372,7 @@ OpenGL::TextureFormat OpenGL::convertPixelFormat(PixelFormat pixelformat, bool r
 		else
 			f.type = GL_HALF_FLOAT;
 		break;
-	case PIXELFORMAT_RGBA16F:
+	case PIXELFORMAT_RGBA16_FLOAT:
 		f.internalformat = GL_RGBA16F;
 		f.externalformat = GL_RGBA;
 		if (GLAD_OES_texture_half_float)
@@ -1380,23 +1380,23 @@ OpenGL::TextureFormat OpenGL::convertPixelFormat(PixelFormat pixelformat, bool r
 		else
 			f.type = GL_HALF_FLOAT;
 		break;
-	case PIXELFORMAT_R32F:
+	case PIXELFORMAT_R32_FLOAT:
 		f.internalformat = GL_R32F;
 		f.externalformat = GL_RED;
 		f.type = GL_FLOAT;
 		break;
-	case PIXELFORMAT_RG32F:
+	case PIXELFORMAT_RG32_FLOAT:
 		f.internalformat = GL_RG32F;
 		f.externalformat = GL_RG;
 		f.type = GL_FLOAT;
 		break;
-	case PIXELFORMAT_RGBA32F:
+	case PIXELFORMAT_RGBA32_FLOAT:
 		f.internalformat = GL_RGBA32F;
 		f.externalformat = GL_RGBA;
 		f.type = GL_FLOAT;
 		break;
 
-	case PIXELFORMAT_LA8:
+	case PIXELFORMAT_LA8_UNORM:
 		if (gl.isCoreProfile() || GLAD_ES_VERSION_3_0)
 		{
 			f.internalformat = GL_RG8;
@@ -1414,27 +1414,27 @@ OpenGL::TextureFormat OpenGL::convertPixelFormat(PixelFormat pixelformat, bool r
 		}
 		break;
 
-	case PIXELFORMAT_RGBA4:
+	case PIXELFORMAT_RGBA4_UNORM:
 		f.internalformat = GL_RGBA4;
 		f.externalformat = GL_RGBA;
 		f.type = GL_UNSIGNED_SHORT_4_4_4_4;
 		break;
-	case PIXELFORMAT_RGB5A1:
+	case PIXELFORMAT_RGB5A1_UNORM:
 		f.internalformat = GL_RGB5_A1;
 		f.externalformat = GL_RGBA;
 		f.type = GL_UNSIGNED_SHORT_5_5_5_1;
 		break;
-	case PIXELFORMAT_RGB565:
+	case PIXELFORMAT_RGB565_UNORM:
 		f.internalformat = GL_RGB565;
 		f.externalformat = GL_RGB;
 		f.type = GL_UNSIGNED_SHORT_5_6_5;
 		break;
-	case PIXELFORMAT_RGB10A2:
+	case PIXELFORMAT_RGB10A2_UNORM:
 		f.internalformat = GL_RGB10_A2;
 		f.externalformat = GL_RGBA;
 		f.type = GL_UNSIGNED_INT_2_10_10_10_REV;
 		break;
-	case PIXELFORMAT_RG11B10F:
+	case PIXELFORMAT_RG11B10_FLOAT:
 		f.internalformat = GL_R11F_G11F_B10F;
 		f.externalformat = GL_RGB;
 		f.type = GL_UNSIGNED_INT_10F_11F_11F_REV;
@@ -1466,14 +1466,14 @@ OpenGL::TextureFormat OpenGL::convertPixelFormat(PixelFormat pixelformat, bool r
 		}
 		break;
 
-	case PIXELFORMAT_DEPTH16:
+	case PIXELFORMAT_DEPTH16_UNORM:
 		f.internalformat = GL_DEPTH_COMPONENT16;
 		f.externalformat = GL_DEPTH_COMPONENT;
 		f.type = GL_UNSIGNED_SHORT;
 		f.framebufferAttachments[0] = GL_DEPTH_ATTACHMENT;
 		break;
 
-	case PIXELFORMAT_DEPTH24:
+	case PIXELFORMAT_DEPTH24_UNORM:
 		if (GLAD_ES_VERSION_2_0 && !GLAD_ES_VERSION_3_0 && !GLAD_OES_depth24 && GLAD_OES_packed_depth_stencil)
 		{
 			f.internalformat = GL_DEPTH24_STENCIL8;
@@ -1491,14 +1491,14 @@ OpenGL::TextureFormat OpenGL::convertPixelFormat(PixelFormat pixelformat, bool r
 		}
 		break;
 
-	case PIXELFORMAT_DEPTH32F:
+	case PIXELFORMAT_DEPTH32_FLOAT:
 		f.internalformat = GL_DEPTH_COMPONENT32F;
 		f.externalformat = GL_DEPTH_COMPONENT;
 		f.type = GL_FLOAT;
 		f.framebufferAttachments[0] = GL_DEPTH_ATTACHMENT;
 		break;
 
-	case PIXELFORMAT_DEPTH24_STENCIL8:
+	case PIXELFORMAT_DEPTH24_UNORM_STENCIL8:
 		f.internalformat = GL_DEPTH24_STENCIL8;
 		f.externalformat = GL_DEPTH_STENCIL;
 		f.type = GL_UNSIGNED_INT_24_8;
@@ -1513,87 +1513,87 @@ OpenGL::TextureFormat OpenGL::convertPixelFormat(PixelFormat pixelformat, bool r
 		}
 		break;
 
-	case PIXELFORMAT_DEPTH32F_STENCIL8:
+	case PIXELFORMAT_DEPTH32_FLOAT_STENCIL8:
 		f.internalformat = GL_DEPTH32F_STENCIL8;
 		f.externalformat = GL_DEPTH_STENCIL;
 		f.type = GL_FLOAT_32_UNSIGNED_INT_24_8_REV;
 		f.framebufferAttachments[0] = GL_DEPTH_STENCIL_ATTACHMENT;
 		break;
 
-	case PIXELFORMAT_DXT1:
+	case PIXELFORMAT_DXT1_UNORM:
 		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB_S3TC_DXT1_EXT : GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
 		break;
-	case PIXELFORMAT_DXT3:
+	case PIXELFORMAT_DXT3_UNORM:
 		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT : GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
 		break;
-	case PIXELFORMAT_DXT5:
+	case PIXELFORMAT_DXT5_UNORM:
 		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT : GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
 		break;
-	case PIXELFORMAT_BC4:
+	case PIXELFORMAT_BC4_UNORM:
 		isSRGB = false;
 		f.internalformat = GL_COMPRESSED_RED_RGTC1;
 		break;
-	case PIXELFORMAT_BC4s:
+	case PIXELFORMAT_BC4_SNORM:
 		isSRGB = false;
 		f.internalformat = GL_COMPRESSED_SIGNED_RED_RGTC1;
 		break;
-	case PIXELFORMAT_BC5:
+	case PIXELFORMAT_BC5_UNORM:
 		isSRGB = false;
 		f.internalformat = GL_COMPRESSED_RG_RGTC2;
 		break;
-	case PIXELFORMAT_BC5s:
+	case PIXELFORMAT_BC5_SNORM:
 		isSRGB = false;
 		f.internalformat = GL_COMPRESSED_SIGNED_RG_RGTC2;
 		break;
-	case PIXELFORMAT_BC6H:
+	case PIXELFORMAT_BC6H_UFLOAT:
 		isSRGB = false;
 		f.internalformat = GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT;
 		break;
-	case PIXELFORMAT_BC6Hs:
+	case PIXELFORMAT_BC6H_FLOAT:
 		isSRGB = false;
 		f.internalformat = GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT;
 		break;
-	case PIXELFORMAT_BC7:
+	case PIXELFORMAT_BC7_UNORM:
 		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM : GL_COMPRESSED_RGBA_BPTC_UNORM;
 		break;
-	case PIXELFORMAT_PVR1_RGB2:
+	case PIXELFORMAT_PVR1_RGB2_UNORM:
 		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT : GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG;
 		break;
-	case PIXELFORMAT_PVR1_RGB4:
+	case PIXELFORMAT_PVR1_RGB4_UNORM:
 		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT : GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG;
 		break;
-	case PIXELFORMAT_PVR1_RGBA2:
+	case PIXELFORMAT_PVR1_RGBA2_UNORM:
 		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT : GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG;
 		break;
-	case PIXELFORMAT_PVR1_RGBA4:
+	case PIXELFORMAT_PVR1_RGBA4_UNORM:
 		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT : GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;
 		break;
-	case PIXELFORMAT_ETC1:
+	case PIXELFORMAT_ETC1_UNORM:
 		isSRGB = false;
 		f.internalformat = GL_ETC1_RGB8_OES;
 		break;
-	case PIXELFORMAT_ETC2_RGB:
+	case PIXELFORMAT_ETC2_RGB_UNORM:
 		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ETC2 : GL_COMPRESSED_RGB8_ETC2;
 		break;
-	case PIXELFORMAT_ETC2_RGBA:
+	case PIXELFORMAT_ETC2_RGBA_UNORM:
 		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC : GL_COMPRESSED_RGBA8_ETC2_EAC;
 		break;
-	case PIXELFORMAT_ETC2_RGBA1:
+	case PIXELFORMAT_ETC2_RGBA1_UNORM:
 		f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 : GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2;
 		break;
-	case PIXELFORMAT_EAC_R:
+	case PIXELFORMAT_EAC_R_UNORM:
 		isSRGB = false;
 		f.internalformat = GL_COMPRESSED_R11_EAC;
 		break;
-	case PIXELFORMAT_EAC_Rs:
+	case PIXELFORMAT_EAC_R_SNORM:
 		isSRGB = false;
 		f.internalformat = GL_COMPRESSED_SIGNED_R11_EAC;
 		break;
-	case PIXELFORMAT_EAC_RG:
+	case PIXELFORMAT_EAC_RG_UNORM:
 		isSRGB = false;
 		f.internalformat = GL_COMPRESSED_RG11_EAC;
 		break;
-	case PIXELFORMAT_EAC_RGs:
+	case PIXELFORMAT_EAC_RG_SNORM:
 		isSRGB = false;
 		f.internalformat = GL_COMPRESSED_SIGNED_RG11_EAC;
 		break;
@@ -1647,13 +1647,13 @@ OpenGL::TextureFormat OpenGL::convertPixelFormat(PixelFormat pixelformat, bool r
 
 	if (!isPixelFormatCompressed(pixelformat))
 	{
-		if (GLAD_ES_VERSION_2_0 && !(GLAD_ES_VERSION_3_0 && pixelformat == PIXELFORMAT_LA8)
+		if (GLAD_ES_VERSION_2_0 && !(GLAD_ES_VERSION_3_0 && pixelformat == PIXELFORMAT_LA8_UNORM)
 			&& !renderbuffer && !isTexStorageSupported())
 		{
 			f.internalformat = f.externalformat;
 		}
 
-		if (pixelformat != PIXELFORMAT_sRGBA8)
+		if (pixelformat != PIXELFORMAT_sRGBA8_UNORM)
 			isSRGB = false;
 	}
 
@@ -1665,25 +1665,25 @@ bool OpenGL::isPixelFormatSupported(PixelFormat pixelformat, bool rendertarget,
 	if (rendertarget && isPixelFormatCompressed(pixelformat))
 		return false;
 
-	if (pixelformat == PIXELFORMAT_RGBA8 && isSRGB)
-		pixelformat = PIXELFORMAT_sRGBA8;
+	if (pixelformat == PIXELFORMAT_RGBA8_UNORM && isSRGB)
+		pixelformat = PIXELFORMAT_sRGBA8_UNORM;
 
 	switch (pixelformat)
 	{
-	case PIXELFORMAT_R8:
-	case PIXELFORMAT_RG8:
+	case PIXELFORMAT_R8_UNORM:
+	case PIXELFORMAT_RG8_UNORM:
 		if (GLAD_VERSION_3_0 || GLAD_ES_VERSION_3_0 || GLAD_ARB_texture_rg || GLAD_EXT_texture_rg)
 			return true;
-		else if (pixelformat == PIXELFORMAT_R8 && !rendertarget && (GLAD_ES_VERSION_2_0 || GLAD_VERSION_1_1))
+		else if (pixelformat == PIXELFORMAT_R8_UNORM && !rendertarget && (GLAD_ES_VERSION_2_0 || GLAD_VERSION_1_1))
 			return true; // We'll use OpenGL's luminance format internally.
 		else
 			return false;
-	case PIXELFORMAT_RGBA8:
+	case PIXELFORMAT_RGBA8_UNORM:
 		if (rendertarget)
 			return GLAD_VERSION_1_0 || GLAD_ES_VERSION_3_0 || GLAD_OES_rgb8_rgba8 || GLAD_ARM_rgba8;
 		else
 			return true;
-	case PIXELFORMAT_sRGBA8:
+	case PIXELFORMAT_sRGBA8_UNORM:
 		if (rendertarget)
 		{
 			if (GLAD_VERSION_1_0)
@@ -1696,37 +1696,37 @@ bool OpenGL::isPixelFormatSupported(PixelFormat pixelformat, bool rendertarget,
 		}
 		else
 			return GLAD_ES_VERSION_3_0 || GLAD_EXT_sRGB || GLAD_VERSION_2_1 || GLAD_EXT_texture_sRGB;
-	case PIXELFORMAT_R16:
-	case PIXELFORMAT_RG16:
+	case PIXELFORMAT_R16_UNORM:
+	case PIXELFORMAT_RG16_UNORM:
 		return GLAD_VERSION_3_0
 			|| (GLAD_VERSION_1_1 && GLAD_ARB_texture_rg)
 			|| (GLAD_EXT_texture_norm16 && (GLAD_ES_VERSION_3_0 || GLAD_EXT_texture_rg));
-	case PIXELFORMAT_RGBA16:
+	case PIXELFORMAT_RGBA16_UNORM:
 		return GLAD_VERSION_1_1 || GLAD_EXT_texture_norm16;
-	case PIXELFORMAT_R16F:
-	case PIXELFORMAT_RG16F:
+	case PIXELFORMAT_R16_FLOAT:
+	case PIXELFORMAT_RG16_FLOAT:
 		if (GLAD_VERSION_1_0)
 			return GLAD_VERSION_3_0 || (GLAD_ARB_texture_float && GLAD_ARB_half_float_pixel && GLAD_ARB_texture_rg);
 		else if (rendertarget && !GLAD_EXT_color_buffer_half_float)
 			return false;
 		else
 			return GLAD_ES_VERSION_3_0 || (GLAD_OES_texture_half_float && GLAD_EXT_texture_rg);
-	case PIXELFORMAT_RGBA16F:
+	case PIXELFORMAT_RGBA16_FLOAT:
 		if (GLAD_VERSION_1_0)
 			return GLAD_VERSION_3_0 || (GLAD_ARB_texture_float && GLAD_ARB_half_float_pixel);
 		else if (rendertarget && !GLAD_EXT_color_buffer_half_float)
 			return false;
 		else
 			return GLAD_ES_VERSION_3_0 || GLAD_OES_texture_half_float;
-	case PIXELFORMAT_R32F:
-	case PIXELFORMAT_RG32F:
+	case PIXELFORMAT_R32_FLOAT:
+	case PIXELFORMAT_RG32_FLOAT:
 		if (GLAD_VERSION_1_0)
 			return GLAD_VERSION_3_0 || (GLAD_ARB_texture_float && GLAD_ARB_texture_rg);
 		else if (!rendertarget)
 			return GLAD_ES_VERSION_3_0 || (GLAD_OES_texture_float && GLAD_EXT_texture_rg);
 		else
 			return false;
-	case PIXELFORMAT_RGBA32F:
+	case PIXELFORMAT_RGBA32_FLOAT:
 		if (GLAD_VERSION_1_0)
 			return GLAD_VERSION_3_0 || GLAD_ARB_texture_float;
 		else if (!rendertarget)
@@ -1734,17 +1734,17 @@ bool OpenGL::isPixelFormatSupported(PixelFormat pixelformat, bool rendertarget,
 		else
 			return false;
 
-	case PIXELFORMAT_LA8:
+	case PIXELFORMAT_LA8_UNORM:
 		return !rendertarget;
 
-	case PIXELFORMAT_RGBA4:
-	case PIXELFORMAT_RGB5A1:
+	case PIXELFORMAT_RGBA4_UNORM:
+	case PIXELFORMAT_RGB5A1_UNORM:
 		return true;
-	case PIXELFORMAT_RGB565:
+	case PIXELFORMAT_RGB565_UNORM:
 		return GLAD_ES_VERSION_2_0 || GLAD_VERSION_4_2 || GLAD_ARB_ES2_compatibility;
-	case PIXELFORMAT_RGB10A2:
+	case PIXELFORMAT_RGB10A2_UNORM:
 		return GLAD_ES_VERSION_3_0 || GLAD_VERSION_1_0;
-	case PIXELFORMAT_RG11B10F:
+	case PIXELFORMAT_RG11B10_FLOAT:
 		if (rendertarget)
 			return GLAD_VERSION_3_0 || GLAD_EXT_packed_float || GLAD_APPLE_color_buffer_packed_float;
 		else
@@ -1753,7 +1753,7 @@ bool OpenGL::isPixelFormatSupported(PixelFormat pixelformat, bool rendertarget,
 	case PIXELFORMAT_STENCIL8:
 		return rendertarget && !readable;
 
-	case PIXELFORMAT_DEPTH16:
+	case PIXELFORMAT_DEPTH16_UNORM:
 		if (!rendertarget)
 			return false;
 		else if (readable)
@@ -1761,7 +1761,7 @@ bool OpenGL::isPixelFormatSupported(PixelFormat pixelformat, bool rendertarget,
 		else
 			return true;
 
-	case PIXELFORMAT_DEPTH24:
+	case PIXELFORMAT_DEPTH24_UNORM:
 		if (!rendertarget)
 			return false;
 		else if (readable)
@@ -1769,7 +1769,7 @@ bool OpenGL::isPixelFormatSupported(PixelFormat pixelformat, bool rendertarget,
 		else
 			return GLAD_VERSION_2_0 || GLAD_ES_VERSION_3_0 || GLAD_OES_depth24 || GLAD_OES_depth_texture;
 
-	case PIXELFORMAT_DEPTH24_STENCIL8:
+	case PIXELFORMAT_DEPTH24_UNORM_STENCIL8:
 		if (!rendertarget)
 			return false;
 		else if (readable)
@@ -1777,40 +1777,40 @@ bool OpenGL::isPixelFormatSupported(PixelFormat pixelformat, bool rendertarget,
 		else
 			return GLAD_VERSION_3_0 || GLAD_ES_VERSION_3_0 || GLAD_EXT_packed_depth_stencil || GLAD_OES_packed_depth_stencil;
 
-	case PIXELFORMAT_DEPTH32F:
-	case PIXELFORMAT_DEPTH32F_STENCIL8:
+	case PIXELFORMAT_DEPTH32_FLOAT:
+	case PIXELFORMAT_DEPTH32_FLOAT_STENCIL8:
 		return rendertarget && (GLAD_VERSION_3_0 || GLAD_ES_VERSION_3_0 || GLAD_ARB_depth_buffer_float);
 
-	case PIXELFORMAT_DXT1:
+	case PIXELFORMAT_DXT1_UNORM:
 		return GLAD_EXT_texture_compression_s3tc || GLAD_EXT_texture_compression_dxt1;
-	case PIXELFORMAT_DXT3:
+	case PIXELFORMAT_DXT3_UNORM:
 		return GLAD_EXT_texture_compression_s3tc || GLAD_ANGLE_texture_compression_dxt3;
-	case PIXELFORMAT_DXT5:
+	case PIXELFORMAT_DXT5_UNORM:
 		return GLAD_EXT_texture_compression_s3tc || GLAD_ANGLE_texture_compression_dxt5;
-	case PIXELFORMAT_BC4:
-	case PIXELFORMAT_BC4s:
-	case PIXELFORMAT_BC5:
-	case PIXELFORMAT_BC5s:
+	case PIXELFORMAT_BC4_UNORM:
+	case PIXELFORMAT_BC4_SNORM:
+	case PIXELFORMAT_BC5_UNORM:
+	case PIXELFORMAT_BC5_SNORM:
 		return (GLAD_VERSION_3_0 || GLAD_ARB_texture_compression_rgtc || GLAD_EXT_texture_compression_rgtc);
-	case PIXELFORMAT_BC6H:
-	case PIXELFORMAT_BC6Hs:
-	case PIXELFORMAT_BC7:
+	case PIXELFORMAT_BC6H_UFLOAT:
+	case PIXELFORMAT_BC6H_FLOAT:
+	case PIXELFORMAT_BC7_UNORM:
 		return GLAD_VERSION_4_2 || GLAD_ARB_texture_compression_bptc;
-	case PIXELFORMAT_PVR1_RGB2:
-	case PIXELFORMAT_PVR1_RGB4:
-	case PIXELFORMAT_PVR1_RGBA2:
-	case PIXELFORMAT_PVR1_RGBA4:
+	case PIXELFORMAT_PVR1_RGB2_UNORM:
+	case PIXELFORMAT_PVR1_RGB4_UNORM:
+	case PIXELFORMAT_PVR1_RGBA2_UNORM:
+	case PIXELFORMAT_PVR1_RGBA4_UNORM:
 		return isSRGB ? GLAD_EXT_pvrtc_sRGB : GLAD_IMG_texture_compression_pvrtc;
-	case PIXELFORMAT_ETC1:
+	case PIXELFORMAT_ETC1_UNORM:
 		// ETC2 support guarantees ETC1 support as well.
 		return GLAD_ES_VERSION_3_0 || GLAD_VERSION_4_3 || GLAD_ARB_ES3_compatibility || GLAD_OES_compressed_ETC1_RGB8_texture;
-	case PIXELFORMAT_ETC2_RGB:
-	case PIXELFORMAT_ETC2_RGBA:
-	case PIXELFORMAT_ETC2_RGBA1:
-	case PIXELFORMAT_EAC_R:
-	case PIXELFORMAT_EAC_Rs:
-	case PIXELFORMAT_EAC_RG:
-	case PIXELFORMAT_EAC_RGs:
+	case PIXELFORMAT_ETC2_RGB_UNORM:
+	case PIXELFORMAT_ETC2_RGBA_UNORM:
+	case PIXELFORMAT_ETC2_RGBA1_UNORM:
+	case PIXELFORMAT_EAC_R_UNORM:
+	case PIXELFORMAT_EAC_R_SNORM:
+	case PIXELFORMAT_EAC_RG_UNORM:
+	case PIXELFORMAT_EAC_RG_SNORM:
 		return GLAD_ES_VERSION_3_0 || GLAD_VERSION_4_3 || GLAD_ARB_ES3_compatibility;
 	case PIXELFORMAT_ASTC_4x4:
 	case PIXELFORMAT_ASTC_5x4:
@@ -1837,13 +1837,13 @@ bool OpenGL::hasTextureFilteringSupport(PixelFormat pixelformat)
 {
 	switch (pixelformat)
 	{
-	case PIXELFORMAT_R16F:
-	case PIXELFORMAT_RG16F:
-	case PIXELFORMAT_RGBA16F:
+	case PIXELFORMAT_R16_FLOAT:
+	case PIXELFORMAT_RG16_FLOAT:
+	case PIXELFORMAT_RGBA16_FLOAT:
 		return GLAD_VERSION_1_1 || GLAD_ES_VERSION_3_0 || GLAD_OES_texture_half_float_linear;
-	case PIXELFORMAT_R32F:
-	case PIXELFORMAT_RG32F:
-	case PIXELFORMAT_RGBA32F:
+	case PIXELFORMAT_R32_FLOAT:
+	case PIXELFORMAT_RG32_FLOAT:
+	case PIXELFORMAT_RGBA32_FLOAT:
 		return GLAD_VERSION_1_1 || GLAD_OES_texture_float_linear;
 	default:
 		return true;

src/modules/image/FormatHandler.h

@@ -49,7 +49,7 @@ public:
 	// Raw RGBA pixel data.
 	struct DecodedImage
 	{
-		PixelFormat format = PIXELFORMAT_RGBA8;
+		PixelFormat format = PIXELFORMAT_RGBA8_UNORM;
 		int width   = 0;
 		int height  = 0;
 		size_t size = 0;

src/modules/image/Image.h

@@ -69,7 +69,7 @@ public:
 	 * @param height The height of the ImageData.
 	 * @return The new ImageData.
 	 **/
-	ImageData *newImageData(int width, int height, PixelFormat format = PIXELFORMAT_RGBA8);
+	ImageData *newImageData(int width, int height, PixelFormat format = PIXELFORMAT_RGBA8_UNORM);
 
 	/**
 	 * Creates empty ImageData with the given size.

src/modules/image/ImageData.cpp

@@ -731,32 +731,32 @@ void ImageData::paste(ImageData *src, int dx, int dy, int sx, int sy, int sw, in
 			if (srcformat == dstformat)
 				memcpy(rowdst.u8, rowsrc.u8, srcpixelsize * sw);
 
-			else if (srcformat == PIXELFORMAT_RGBA8 && dstformat == PIXELFORMAT_RGBA16)
+			else if (srcformat == PIXELFORMAT_RGBA8_UNORM && dstformat == PIXELFORMAT_RGBA16_UNORM)
 				pasteRGBA8toRGBA16(rowsrc, rowdst, sw);
-			else if (srcformat == PIXELFORMAT_RGBA8 && dstformat == PIXELFORMAT_RGBA16F)
+			else if (srcformat == PIXELFORMAT_RGBA8_UNORM && dstformat == PIXELFORMAT_RGBA16_FLOAT)
 				pasteRGBA8toRGBA16F(rowsrc, rowdst, sw);
-			else if (srcformat == PIXELFORMAT_RGBA8 && dstformat == PIXELFORMAT_RGBA32F)
+			else if (srcformat == PIXELFORMAT_RGBA8_UNORM && dstformat == PIXELFORMAT_RGBA32_FLOAT)
 				pasteRGBA8toRGBA32F(rowsrc, rowdst, sw);
 
-			else if (srcformat == PIXELFORMAT_RGBA16 && dstformat == PIXELFORMAT_RGBA8)
+			else if (srcformat == PIXELFORMAT_RGBA16_UNORM && dstformat == PIXELFORMAT_RGBA8_UNORM)
 				pasteRGBA16toRGBA8(rowsrc, rowdst, sw);
-			else if (srcformat == PIXELFORMAT_RGBA16 && dstformat == PIXELFORMAT_RGBA16F)
+			else if (srcformat == PIXELFORMAT_RGBA16_UNORM && dstformat == PIXELFORMAT_RGBA16_FLOAT)
 				pasteRGBA16toRGBA16F(rowsrc, rowdst, sw);
-			else if (srcformat == PIXELFORMAT_RGBA16 && dstformat == PIXELFORMAT_RGBA32F)
+			else if (srcformat == PIXELFORMAT_RGBA16_UNORM && dstformat == PIXELFORMAT_RGBA32_FLOAT)
 				pasteRGBA16toRGBA32F(rowsrc, rowdst, sw);
 
-			else if (srcformat == PIXELFORMAT_RGBA16F && dstformat == PIXELFORMAT_RGBA8)
+			else if (srcformat == PIXELFORMAT_RGBA16_FLOAT && dstformat == PIXELFORMAT_RGBA8_UNORM)
 				pasteRGBA16FtoRGBA8(rowsrc, rowdst, sw);
-			else if (srcformat == PIXELFORMAT_RGBA16F && dstformat == PIXELFORMAT_RGBA16)
+			else if (srcformat == PIXELFORMAT_RGBA16_FLOAT && dstformat == PIXELFORMAT_RGBA16_UNORM)
 				pasteRGBA16FtoRGBA16(rowsrc, rowdst, sw);
-			else if (srcformat == PIXELFORMAT_RGBA16F && dstformat == PIXELFORMAT_RGBA32F)
+			else if (srcformat == PIXELFORMAT_RGBA16_FLOAT && dstformat == PIXELFORMAT_RGBA32_FLOAT)
 				pasteRGBA16FtoRGBA32F(rowsrc, rowdst, sw);
 
-			else if (srcformat == PIXELFORMAT_RGBA32F && dstformat == PIXELFORMAT_RGBA8)
+			else if (srcformat == PIXELFORMAT_RGBA32_FLOAT && dstformat == PIXELFORMAT_RGBA8_UNORM)
 				pasteRGBA32FtoRGBA8(rowsrc, rowdst, sw);
-			else if (srcformat == PIXELFORMAT_RGBA32F && dstformat == PIXELFORMAT_RGBA16)
+			else if (srcformat == PIXELFORMAT_RGBA32_FLOAT && dstformat == PIXELFORMAT_RGBA16_UNORM)
 				pasteRGBA32FtoRGBA16(rowsrc, rowdst, sw);
-			else if (srcformat == PIXELFORMAT_RGBA32F && dstformat == PIXELFORMAT_RGBA16F)
+			else if (srcformat == PIXELFORMAT_RGBA32_FLOAT && dstformat == PIXELFORMAT_RGBA16_FLOAT)
 				pasteRGBA32FtoRGBA16F(rowsrc, rowdst, sw);
 
 			else
@@ -789,23 +789,23 @@ bool ImageData::validPixelFormat(PixelFormat format)
 {
 	switch (format)
 	{
-	case PIXELFORMAT_R8:
-	case PIXELFORMAT_RG8:
-	case PIXELFORMAT_RGBA8:
-	case PIXELFORMAT_R16:
-	case PIXELFORMAT_RG16:
-	case PIXELFORMAT_RGBA16:
-	case PIXELFORMAT_R16F:
-	case PIXELFORMAT_RG16F:
-	case PIXELFORMAT_RGBA16F:
-	case PIXELFORMAT_R32F:
-	case PIXELFORMAT_RG32F:
-	case PIXELFORMAT_RGBA32F:
-	case PIXELFORMAT_RGBA4:
-	case PIXELFORMAT_RGB5A1:
-	case PIXELFORMAT_RGB565:
-	case PIXELFORMAT_RGB10A2:
-	case PIXELFORMAT_RG11B10F:
+	case PIXELFORMAT_R8_UNORM:
+	case PIXELFORMAT_RG8_UNORM:
+	case PIXELFORMAT_RGBA8_UNORM:
+	case PIXELFORMAT_R16_UNORM:
+	case PIXELFORMAT_RG16_UNORM:
+	case PIXELFORMAT_RGBA16_UNORM:
+	case PIXELFORMAT_R16_FLOAT:
+	case PIXELFORMAT_RG16_FLOAT:
+	case PIXELFORMAT_RGBA16_FLOAT:
+	case PIXELFORMAT_R32_FLOAT:
+	case PIXELFORMAT_RG32_FLOAT:
+	case PIXELFORMAT_RGBA32_FLOAT:
+	case PIXELFORMAT_RGBA4_UNORM:
+	case PIXELFORMAT_RGB5A1_UNORM:
+	case PIXELFORMAT_RGB565_UNORM:
+	case PIXELFORMAT_RGB10A2_UNORM:
+	case PIXELFORMAT_RG11B10_FLOAT:
 		return true;
 	default:
 		return false;
@@ -817,12 +817,12 @@ bool ImageData::canPaste(PixelFormat src, PixelFormat dst)
 	if (src == dst)
 		return true;
 
-	if (!(src == PIXELFORMAT_RGBA8 || src == PIXELFORMAT_RGBA16
-		|| src == PIXELFORMAT_RGBA16F || src == PIXELFORMAT_RGBA32F))
+	if (!(src == PIXELFORMAT_RGBA8_UNORM || src == PIXELFORMAT_RGBA16_UNORM
+		|| src == PIXELFORMAT_RGBA16_FLOAT || src == PIXELFORMAT_RGBA32_FLOAT))
 		return false;
 
-	if (!(dst == PIXELFORMAT_RGBA8 || dst == PIXELFORMAT_RGBA16
-		|| dst == PIXELFORMAT_RGBA16F || dst == PIXELFORMAT_RGBA32F))
+	if (!(dst == PIXELFORMAT_RGBA8_UNORM || dst == PIXELFORMAT_RGBA16_UNORM
+		|| dst == PIXELFORMAT_RGBA16_FLOAT || dst == PIXELFORMAT_RGBA32_FLOAT))
 		return false;
 
 	return true;
@@ -832,23 +832,23 @@ ImageData::PixelSetFunction ImageData::getPixelSetFunction(PixelFormat format)
 {
 	switch (format)
 	{
-		case PIXELFORMAT_R8: return setPixelR8;
-		case PIXELFORMAT_RG8: return setPixelRG8;
-		case PIXELFORMAT_RGBA8: return setPixelRGBA8;
-		case PIXELFORMAT_R16: return setPixelR16;
-		case PIXELFORMAT_RG16: return setPixelRG16;
-		case PIXELFORMAT_RGBA16: return setPixelRGBA16;
-		case PIXELFORMAT_R16F: return setPixelR16F;
-		case PIXELFORMAT_RG16F: return setPixelRG16F;
-		case PIXELFORMAT_RGBA16F: return setPixelRGBA16F;
-		case PIXELFORMAT_R32F: return setPixelR32F;
-		case PIXELFORMAT_RG32F: return setPixelRG32F;
-		case PIXELFORMAT_RGBA32F: return setPixelRGBA32F;
-		case PIXELFORMAT_RGBA4: return setPixelRGBA4;
-		case PIXELFORMAT_RGB5A1: return setPixelRGB5A1;
-		case PIXELFORMAT_RGB565: return setPixelRGB565;
-		case PIXELFORMAT_RGB10A2: return setPixelRGB10A2;
-		case PIXELFORMAT_RG11B10F: return setPixelRG11B10F;
+		case PIXELFORMAT_R8_UNORM: return setPixelR8;
+		case PIXELFORMAT_RG8_UNORM: return setPixelRG8;
+		case PIXELFORMAT_RGBA8_UNORM: return setPixelRGBA8;
+		case PIXELFORMAT_R16_UNORM: return setPixelR16;
+		case PIXELFORMAT_RG16_UNORM: return setPixelRG16;
+		case PIXELFORMAT_RGBA16_UNORM: return setPixelRGBA16;
+		case PIXELFORMAT_R16_FLOAT: return setPixelR16F;
+		case PIXELFORMAT_RG16_FLOAT: return setPixelRG16F;
+		case PIXELFORMAT_RGBA16_FLOAT: return setPixelRGBA16F;
+		case PIXELFORMAT_R32_FLOAT: return setPixelR32F;
+		case PIXELFORMAT_RG32_FLOAT: return setPixelRG32F;
+		case PIXELFORMAT_RGBA32_FLOAT: return setPixelRGBA32F;
+		case PIXELFORMAT_RGBA4_UNORM: return setPixelRGBA4;
+		case PIXELFORMAT_RGB5A1_UNORM: return setPixelRGB5A1;
+		case PIXELFORMAT_RGB565_UNORM: return setPixelRGB565;
+		case PIXELFORMAT_RGB10A2_UNORM: return setPixelRGB10A2;
+		case PIXELFORMAT_RG11B10_FLOAT: return setPixelRG11B10F;
 		default: return nullptr;
 	}
 }
@@ -857,23 +857,23 @@ ImageData::PixelGetFunction ImageData::getPixelGetFunction(PixelFormat format)
 {
 	switch (format)
 	{
-		case PIXELFORMAT_R8: return getPixelR8;
-		case PIXELFORMAT_RG8: return getPixelRG8;
-		case PIXELFORMAT_RGBA8: return getPixelRGBA8;
-		case PIXELFORMAT_R16: return getPixelR16;
-		case PIXELFORMAT_RG16: return getPixelRG16;
-		case PIXELFORMAT_RGBA16: return getPixelRGBA16;
-		case PIXELFORMAT_R16F: return getPixelR16F;
-		case PIXELFORMAT_RG16F: return getPixelRG16F;
-		case PIXELFORMAT_RGBA16F: return getPixelRGBA16F;
-		case PIXELFORMAT_R32F: return getPixelR32F;
-		case PIXELFORMAT_RG32F: return getPixelRG32F;
-		case PIXELFORMAT_RGBA32F: return getPixelRGBA32F;
-		case PIXELFORMAT_RGBA4: return getPixelRGBA4;
-		case PIXELFORMAT_RGB5A1: return getPixelRGB5A1;
-		case PIXELFORMAT_RGB565: return getPixelRGB565;
-		case PIXELFORMAT_RGB10A2: return getPixelRGB10A2;
-		case PIXELFORMAT_RG11B10F: return getPixelRG11B10F;
+		case PIXELFORMAT_R8_UNORM: return getPixelR8;
+		case PIXELFORMAT_RG8_UNORM: return getPixelRG8;
+		case PIXELFORMAT_RGBA8_UNORM: return getPixelRGBA8;
+		case PIXELFORMAT_R16_UNORM: return getPixelR16;
+		case PIXELFORMAT_RG16_UNORM: return getPixelRG16;
+		case PIXELFORMAT_RGBA16_UNORM: return getPixelRGBA16;
+		case PIXELFORMAT_R16_FLOAT: return getPixelR16F;
+		case PIXELFORMAT_RG16_FLOAT: return getPixelRG16F;
+		case PIXELFORMAT_RGBA16_FLOAT: return getPixelRGBA16F;
+		case PIXELFORMAT_R32_FLOAT: return getPixelR32F;
+		case PIXELFORMAT_RG32_FLOAT: return getPixelRG32F;
+		case PIXELFORMAT_RGBA32_FLOAT: return getPixelRGBA32F;
+		case PIXELFORMAT_RGBA4_UNORM: return getPixelRGBA4;
+		case PIXELFORMAT_RGB5A1_UNORM: return getPixelRGB5A1;
+		case PIXELFORMAT_RGB565_UNORM: return getPixelRGB565;
+		case PIXELFORMAT_RGB10A2_UNORM: return getPixelRGB10A2;
+		case PIXELFORMAT_RG11B10_FLOAT: return getPixelRG11B10F;
 		default: return nullptr;
 	}
 }

src/modules/image/ImageData.h

@@ -62,7 +62,7 @@ public:
 	static love::Type type;
 
 	ImageData(Data *data);
-	ImageData(int width, int height, PixelFormat format = PIXELFORMAT_RGBA8);
+	ImageData(int width, int height, PixelFormat format = PIXELFORMAT_RGBA8_UNORM);
 	ImageData(int width, int height, PixelFormat format, void *data, bool own);
 	ImageData(const ImageData &c);
 	virtual ~ImageData();

src/modules/image/magpie/EXRHandler.cpp

@@ -155,7 +155,7 @@ FormatHandler::DecodedImage EXRHandler::decode(Data *data)
 
 	if (pixelType == TINYEXR_PIXELTYPE_HALF)
 	{
-		img.format = PIXELFORMAT_RGBA16F;
+		img.format = PIXELFORMAT_RGBA16_FLOAT;
 
 		float16 *rgba[4] = {nullptr};
 		getEXRChannels(exrHeader, exrImage, rgba);
@@ -172,7 +172,7 @@ FormatHandler::DecodedImage EXRHandler::decode(Data *data)
 	}
 	else if (pixelType == TINYEXR_PIXELTYPE_FLOAT)
 	{
-		img.format = PIXELFORMAT_RGBA32F;
+		img.format = PIXELFORMAT_RGBA32_FLOAT;
 
 		float *rgba[4] = {nullptr};
 		getEXRChannels(exrHeader, exrImage, rgba);

src/modules/image/magpie/KTXHandler.cpp

@@ -146,76 +146,76 @@ PixelFormat convertFormat(uint32 glformat, bool &sRGB)
 	switch (glformat)
 	{
 	case KTX_GL_ETC1_RGB8_OES:
-		return PIXELFORMAT_ETC1;
+		return PIXELFORMAT_ETC1_UNORM;
 
 	// EAC and ETC2.
 	case KTX_GL_COMPRESSED_R11_EAC:
-		return PIXELFORMAT_EAC_R;
+		return PIXELFORMAT_EAC_R_UNORM;
 	case KTX_GL_COMPRESSED_SIGNED_R11_EAC:
-		return PIXELFORMAT_EAC_Rs;
+		return PIXELFORMAT_EAC_R_SNORM;
 	case KTX_GL_COMPRESSED_RG11_EAC:
-		return PIXELFORMAT_EAC_RG;
+		return PIXELFORMAT_EAC_RG_UNORM;
 	case KTX_GL_COMPRESSED_SIGNED_RG11_EAC:
-		return PIXELFORMAT_EAC_RGs;
+		return PIXELFORMAT_EAC_RG_SNORM;
 	case KTX_GL_COMPRESSED_RGB8_ETC2:
-		return PIXELFORMAT_ETC2_RGB;
+		return PIXELFORMAT_ETC2_RGB_UNORM;
 	case KTX_GL_COMPRESSED_SRGB8_ETC2:
 		sRGB = true;
-		return PIXELFORMAT_ETC2_RGB;
+		return PIXELFORMAT_ETC2_RGB_UNORM;
 	case KTX_GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
-		return PIXELFORMAT_ETC2_RGBA1;
+		return PIXELFORMAT_ETC2_RGBA1_UNORM;
 	case KTX_GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
 		sRGB = true;
-		return PIXELFORMAT_ETC2_RGBA1;
+		return PIXELFORMAT_ETC2_RGBA1_UNORM;
 	case KTX_GL_COMPRESSED_RGBA8_ETC2_EAC:
-		return PIXELFORMAT_ETC2_RGBA;
+		return PIXELFORMAT_ETC2_RGBA_UNORM;
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
 		sRGB = true;
-		return PIXELFORMAT_ETC2_RGBA;
+		return PIXELFORMAT_ETC2_RGBA_UNORM;
 
 	// PVRTC.
 	case KTX_GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG:
-		return PIXELFORMAT_PVR1_RGB4;
+		return PIXELFORMAT_PVR1_RGB4_UNORM;
 	case KTX_GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG:
-		return PIXELFORMAT_PVR1_RGB2;
+		return PIXELFORMAT_PVR1_RGB2_UNORM;
 	case KTX_GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG:
-		return PIXELFORMAT_PVR1_RGBA4;
+		return PIXELFORMAT_PVR1_RGBA4_UNORM;
 	case KTX_GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG:
-		return PIXELFORMAT_PVR1_RGBA2;
+		return PIXELFORMAT_PVR1_RGBA2_UNORM;
 
 	// DXT.
 	case KTX_GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
-		return PIXELFORMAT_DXT1;
+		return PIXELFORMAT_DXT1_UNORM;
 	case KTX_GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
-		return PIXELFORMAT_DXT3;
+		return PIXELFORMAT_DXT3_UNORM;
 	case KTX_GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
-		return PIXELFORMAT_DXT5;
+		return PIXELFORMAT_DXT5_UNORM;
 
 	// BC4 and BC5.
 	case KTX_GL_COMPRESSED_RED_RGTC1:
-		return PIXELFORMAT_BC4;
+		return PIXELFORMAT_BC4_UNORM;
 	case KTX_GL_COMPRESSED_SIGNED_RED_RGTC1:
-		return PIXELFORMAT_BC4s;
+		return PIXELFORMAT_BC4_SNORM;
 	case KTX_GL_COMPRESSED_RG_RGTC2:
-		return PIXELFORMAT_BC5;
+		return PIXELFORMAT_BC5_UNORM;
 	case KTX_GL_COMPRESSED_SIGNED_RG_RGTC2:
-		return PIXELFORMAT_BC5s;
+		return PIXELFORMAT_BC5_SNORM;
 
 	// BC6 and BC7.
 	case KTX_GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_BPTC_UNORM:
-		return PIXELFORMAT_BC7;
+		return PIXELFORMAT_BC7_UNORM;
 	case KTX_GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT:
-		return PIXELFORMAT_BC6Hs;
+		return PIXELFORMAT_BC6H_FLOAT;
 	case KTX_GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT:
-		return PIXELFORMAT_BC6H;
+		return PIXELFORMAT_BC6H_UFLOAT;
 
 	// ASTC.
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:

src/modules/image/magpie/PKMHandler.cpp

@@ -74,22 +74,22 @@ static PixelFormat convertFormat(uint16 texformat)
 	switch (texformat)
 	{
 	case ETC1_RGB_NO_MIPMAPS:
-		return PIXELFORMAT_ETC1;
+		return PIXELFORMAT_ETC1_UNORM;
 	case ETC2PACKAGE_RGB_NO_MIPMAPS:
-		return PIXELFORMAT_ETC2_RGB;
+		return PIXELFORMAT_ETC2_RGB_UNORM;
 	case ETC2PACKAGE_RGBA_NO_MIPMAPS_OLD:
 	case ETC2PACKAGE_RGBA_NO_MIPMAPS:
-		return PIXELFORMAT_ETC2_RGBA;
+		return PIXELFORMAT_ETC2_RGBA_UNORM;
 	case ETC2PACKAGE_RGBA1_NO_MIPMAPS:
-		return PIXELFORMAT_ETC2_RGBA1;
+		return PIXELFORMAT_ETC2_RGBA1_UNORM;
 	case ETC2PACKAGE_R_NO_MIPMAPS:
-		return PIXELFORMAT_EAC_R;
+		return PIXELFORMAT_EAC_R_UNORM;
 	case ETC2PACKAGE_RG_NO_MIPMAPS:
-		return PIXELFORMAT_EAC_RG;
+		return PIXELFORMAT_EAC_RG_UNORM;
 	case ETC2PACKAGE_R_SIGNED_NO_MIPMAPS:
-		return PIXELFORMAT_EAC_Rs;
+		return PIXELFORMAT_EAC_R_SNORM;
 	case ETC2PACKAGE_RG_SIGNED_NO_MIPMAPS:
-		return PIXELFORMAT_EAC_RGs;
+		return PIXELFORMAT_EAC_RG_SNORM;
 	default:
 		return PIXELFORMAT_UNKNOWN;
 	}

src/modules/image/magpie/PNGHandler.cpp

@@ -143,7 +143,7 @@ bool PNGHandler::canDecode(Data *data)
 bool PNGHandler::canEncode(PixelFormat rawFormat, EncodedFormat encodedFormat)
 {
 	return encodedFormat == ENCODED_PNG
-		&& (rawFormat == PIXELFORMAT_RGBA8 || rawFormat == PIXELFORMAT_RGBA16);
+		&& (rawFormat == PIXELFORMAT_RGBA8_UNORM || rawFormat == PIXELFORMAT_RGBA16_UNORM);
 }
 
 PNGHandler::DecodedImage PNGHandler::decode(Data *fdata)
@@ -182,7 +182,7 @@ PNGHandler::DecodedImage PNGHandler::decode(Data *fdata)
 	img.width  = (int) width;
 	img.height = (int) height;
 	img.size   = width * height * (state.info_raw.bitdepth * 4 / 8);
-	img.format = state.info_raw.bitdepth == 16 ? PIXELFORMAT_RGBA16 : PIXELFORMAT_RGBA8;
+	img.format = state.info_raw.bitdepth == 16 ? PIXELFORMAT_RGBA16_UNORM : PIXELFORMAT_RGBA8_UNORM;
 
 	// LodePNG keeps raw 16 bit images stored as big-endian.
 #ifndef LOVE_BIG_ENDIAN
@@ -209,7 +209,7 @@ FormatHandler::EncodedImage PNGHandler::encode(const DecodedImage &img, EncodedF
 	lodepng::State state;
 
 	state.info_raw.colortype = LCT_RGBA;
-	state.info_raw.bitdepth = img.format == PIXELFORMAT_RGBA16 ? 16 : 8;
+	state.info_raw.bitdepth = img.format == PIXELFORMAT_RGBA16_UNORM ? 16 : 8;
 
 	state.info_png.color.colortype = LCT_RGBA;
 	state.info_png.color.bitdepth = state.info_raw.bitdepth;

src/modules/image/magpie/PVRHandler.cpp

@@ -222,39 +222,39 @@ static PixelFormat convertFormat(PVRV3PixelFormat format, PVRV3ChannelType chann
 	switch (format)
 	{
 	case ePVRTPF_PVRTCI_2bpp_RGB:
-		return PIXELFORMAT_PVR1_RGB2;
+		return PIXELFORMAT_PVR1_RGB2_UNORM;
 	case ePVRTPF_PVRTCI_2bpp_RGBA:
-		return PIXELFORMAT_PVR1_RGBA2;
+		return PIXELFORMAT_PVR1_RGBA2_UNORM;
 	case ePVRTPF_PVRTCI_4bpp_RGB:
-		return PIXELFORMAT_PVR1_RGB4;
+		return PIXELFORMAT_PVR1_RGB4_UNORM;
 	case ePVRTPF_PVRTCI_4bpp_RGBA:
-		return PIXELFORMAT_PVR1_RGBA4;
+		return PIXELFORMAT_PVR1_RGBA4_UNORM;
 	case ePVRTPF_ETC1:
-		return PIXELFORMAT_ETC1;
+		return PIXELFORMAT_ETC1_UNORM;
 	case ePVRTPF_DXT1:
-		return PIXELFORMAT_DXT1;
+		return PIXELFORMAT_DXT1_UNORM;
 	case ePVRTPF_DXT3:
-		return PIXELFORMAT_DXT3;
+		return PIXELFORMAT_DXT3_UNORM;
 	case ePVRTPF_DXT5:
-		return PIXELFORMAT_DXT5;
+		return PIXELFORMAT_DXT5_UNORM;
 	case ePVRTPF_BC4:
-		return snorm ? PIXELFORMAT_BC4s : PIXELFORMAT_BC4;
+		return snorm ? PIXELFORMAT_BC4_SNORM : PIXELFORMAT_BC4_UNORM;
 	case ePVRTPF_BC5:
-		return snorm ? PIXELFORMAT_BC5s : PIXELFORMAT_BC5;
+		return snorm ? PIXELFORMAT_BC5_SNORM : PIXELFORMAT_BC5_UNORM;
 	case ePVRTPF_BC6:
-		return snorm ? PIXELFORMAT_BC6Hs : PIXELFORMAT_BC6H;
+		return snorm ? PIXELFORMAT_BC6H_FLOAT : PIXELFORMAT_BC6H_UFLOAT;
 	case ePVRTPF_BC7:
-		return PIXELFORMAT_BC7;
+		return PIXELFORMAT_BC7_UNORM;
 	case ePVRTPF_ETC2_RGB:
-		return PIXELFORMAT_ETC2_RGB;
+		return PIXELFORMAT_ETC2_RGB_UNORM;
 	case ePVRTPF_ETC2_RGBA:
-		return PIXELFORMAT_ETC2_RGBA;
+		return PIXELFORMAT_ETC2_RGBA_UNORM;
 	case ePVRTPF_ETC2_RGBA1:
-		return PIXELFORMAT_ETC2_RGBA1;
+		return PIXELFORMAT_ETC2_RGBA1_UNORM;
 	case ePVRTPF_EAC_R:
-		return snorm ? PIXELFORMAT_EAC_Rs : PIXELFORMAT_EAC_R;
+		return snorm ? PIXELFORMAT_EAC_R_SNORM : PIXELFORMAT_EAC_R_UNORM;
 	case ePVRTPF_EAC_RG:
-		return snorm ? PIXELFORMAT_EAC_RGs : PIXELFORMAT_EAC_RG;
+		return snorm ? PIXELFORMAT_EAC_RG_SNORM : PIXELFORMAT_EAC_RG_UNORM;
 	case ePVRTPF_ASTC_4x4:
 		return PIXELFORMAT_ASTC_4x4;
 	case ePVRTPF_ASTC_5x4:

src/modules/image/magpie/STBHandler.cpp

@@ -66,7 +66,7 @@ bool STBHandler::canDecode(Data *data)
 
 bool STBHandler::canEncode(PixelFormat rawFormat, EncodedFormat encodedFormat)
 {
-	return encodedFormat == ENCODED_TGA && rawFormat == PIXELFORMAT_RGBA8;
+	return encodedFormat == ENCODED_TGA && rawFormat == PIXELFORMAT_RGBA8_UNORM;
 }
 
 FormatHandler::DecodedImage STBHandler::decode(Data *data)
@@ -81,13 +81,13 @@ FormatHandler::DecodedImage STBHandler::decode(Data *data)
 	{
 		img.data = (unsigned char *) stbi_loadf_from_memory(buffer, bufferlen, &img.width, &img.height, &comp, 4);
 		img.size = img.width * img.height * 4 * sizeof(float);
-		img.format = PIXELFORMAT_RGBA32F;
+		img.format = PIXELFORMAT_RGBA32_FLOAT;
 	}
 	else
 	{
 		img.data = stbi_load_from_memory(buffer, bufferlen, &img.width, &img.height, &comp, 4);
 		img.size = img.width * img.height * 4;
-		img.format = PIXELFORMAT_RGBA8;
+		img.format = PIXELFORMAT_RGBA8_UNORM;
 	}
 
 	if (img.data == nullptr || img.width <= 0 || img.height <= 0)

src/modules/image/magpie/ddsHandler.cpp

@@ -43,116 +43,116 @@ static PixelFormat convertFormat(dds::dxinfo::DXGIFormat dxformat, bool &sRGB, b
 	{
 	case DXGI_FORMAT_R32G32B32A32_TYPELESS:
 	case DXGI_FORMAT_R32G32B32A32_FLOAT:
-		return PIXELFORMAT_RGBA32F;
+		return PIXELFORMAT_RGBA32_FLOAT;
 
 	case DXGI_FORMAT_R16G16B16A16_TYPELESS:
 	case DXGI_FORMAT_R16G16B16A16_FLOAT:
-		return PIXELFORMAT_RGBA16F;
+		return PIXELFORMAT_RGBA16_FLOAT;
 
 	case DXGI_FORMAT_R16G16B16A16_UNORM:
-		return PIXELFORMAT_RGBA16;
+		return PIXELFORMAT_RGBA16_UNORM;
 
 	case DXGI_FORMAT_R32G32_TYPELESS:
 	case DXGI_FORMAT_R32G32_FLOAT:
-		return PIXELFORMAT_RG32F;
+		return PIXELFORMAT_RG32_FLOAT;
 
 	case DXGI_FORMAT_R10G10B10A2_TYPELESS:
 	case DXGI_FORMAT_R10G10B10A2_UNORM:
-		return PIXELFORMAT_RGB10A2;
+		return PIXELFORMAT_RGB10A2_UNORM;
 
 	case DXGI_FORMAT_R11G11B10_FLOAT:
-		return PIXELFORMAT_RG11B10F;
+		return PIXELFORMAT_RG11B10_FLOAT;
 
 	case DXGI_FORMAT_R8G8B8A8_TYPELESS:
 	case DXGI_FORMAT_R8G8B8A8_UNORM:
 	case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
 		sRGB = (dxformat == DXGI_FORMAT_R8G8B8A8_UNORM_SRGB);
-		return PIXELFORMAT_RGBA8;
+		return PIXELFORMAT_RGBA8_UNORM;
 
 	case DXGI_FORMAT_R16G16_TYPELESS:
 	case DXGI_FORMAT_R16G16_FLOAT:
-		return PIXELFORMAT_RG16F;
+		return PIXELFORMAT_RG16_FLOAT;
 
 	case DXGI_FORMAT_R16G16_UNORM:
-		return PIXELFORMAT_RG16;
+		return PIXELFORMAT_RG16_UNORM;
 
 	case DXGI_FORMAT_R32_TYPELESS:
 	case DXGI_FORMAT_R32_FLOAT:
-		return PIXELFORMAT_R32F;
+		return PIXELFORMAT_R32_FLOAT;
 
 	case DXGI_FORMAT_R8G8_TYPELESS:
 	case DXGI_FORMAT_R8G8_UNORM:
-		return PIXELFORMAT_RG8;
+		return PIXELFORMAT_RG8_UNORM;
 
 	case DXGI_FORMAT_R16_TYPELESS:
 	case DXGI_FORMAT_R16_FLOAT:
-		return PIXELFORMAT_R16F;
+		return PIXELFORMAT_R16_FLOAT;
 
 	case DXGI_FORMAT_R16_UNORM:
-		return PIXELFORMAT_R16;
+		return PIXELFORMAT_R16_UNORM;
 
 	case DXGI_FORMAT_R8_TYPELESS:
 	case DXGI_FORMAT_R8_UNORM:
 	case DXGI_FORMAT_A8_UNORM:
-		return PIXELFORMAT_R8;
+		return PIXELFORMAT_R8_UNORM;
 
 	case DXGI_FORMAT_BC1_TYPELESS:
 	case DXGI_FORMAT_BC1_UNORM:
 	case DXGI_FORMAT_BC1_UNORM_SRGB:
 		sRGB = (dxformat == DXGI_FORMAT_BC1_UNORM_SRGB);
-		return PIXELFORMAT_DXT1;
+		return PIXELFORMAT_DXT1_UNORM;
 
 	case DXGI_FORMAT_BC2_TYPELESS:
 	case DXGI_FORMAT_BC2_UNORM:
 	case DXGI_FORMAT_BC2_UNORM_SRGB:
 		sRGB = (dxformat == DXGI_FORMAT_BC2_UNORM_SRGB);
-		return PIXELFORMAT_DXT3;
+		return PIXELFORMAT_DXT3_UNORM;
 
 	case DXGI_FORMAT_BC3_TYPELESS:
 	case DXGI_FORMAT_BC3_UNORM:
 	case DXGI_FORMAT_BC3_UNORM_SRGB:
 		sRGB = (dxformat == DXGI_FORMAT_BC3_UNORM_SRGB);
-		return PIXELFORMAT_DXT5;
+		return PIXELFORMAT_DXT5_UNORM;
 
 	case DXGI_FORMAT_BC4_TYPELESS:
 	case DXGI_FORMAT_BC4_UNORM:
-		return PIXELFORMAT_BC4;
+		return PIXELFORMAT_BC4_UNORM;
 
 	case DXGI_FORMAT_BC4_SNORM:
-		return PIXELFORMAT_BC4s;
+		return PIXELFORMAT_BC4_SNORM;
 
 	case DXGI_FORMAT_BC5_TYPELESS:
 	case DXGI_FORMAT_BC5_UNORM:
-		return PIXELFORMAT_BC5;
+		return PIXELFORMAT_BC5_UNORM;
 
 	case DXGI_FORMAT_BC5_SNORM:
-		return PIXELFORMAT_BC5s;
+		return PIXELFORMAT_BC5_SNORM;
 
 	case DXGI_FORMAT_B5G6R5_UNORM:
-		return PIXELFORMAT_RGB565;
+		return PIXELFORMAT_RGB565_UNORM;
 
 	case DXGI_FORMAT_B5G5R5A1_UNORM:
-		return PIXELFORMAT_RGB5A1;
+		return PIXELFORMAT_RGB5A1_UNORM;
 
 	case DXGI_FORMAT_B8G8R8A8_UNORM:
 	case DXGI_FORMAT_B8G8R8A8_TYPELESS:
 	case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
 		sRGB = (dxformat == DXGI_FORMAT_B8G8R8A8_UNORM_SRGB);
 		bgra = true;
-		return PIXELFORMAT_RGBA8;
+		return PIXELFORMAT_RGBA8_UNORM;
 
 	case DXGI_FORMAT_BC6H_TYPELESS:
 	case DXGI_FORMAT_BC6H_UF16:
-		return PIXELFORMAT_BC6H;
+		return PIXELFORMAT_BC6H_UFLOAT;
 
 	case DXGI_FORMAT_BC6H_SF16:
-		return PIXELFORMAT_BC6Hs;
+		return PIXELFORMAT_BC6H_FLOAT;
 
 	case DXGI_FORMAT_BC7_TYPELESS:
 	case DXGI_FORMAT_BC7_UNORM:
 	case DXGI_FORMAT_BC7_UNORM_SRGB:
 		sRGB = (dxformat == DXGI_FORMAT_BC7_UNORM_SRGB);
-		return PIXELFORMAT_BC7;
+		return PIXELFORMAT_BC7_UNORM;
 
 	default:
 		return PIXELFORMAT_UNKNOWN;

src/modules/image/wrap_Image.cpp

@@ -44,7 +44,7 @@ int w_newImageData(lua_State *L)
 		if (w <= 0 || h <= 0)
 			return luaL_error(L, "Invalid image size.");
 
-		PixelFormat format = PIXELFORMAT_RGBA8;
+		PixelFormat format = PIXELFORMAT_RGBA8_UNORM;
 
 		if (!lua_isnoneornil(L, 3))
 		{

src/modules/window/sdl/Window.cpp

@@ -910,7 +910,7 @@ bool Window::setIcon(love::image::ImageData *imgd)
 	if (!imgd)
 		return false;
 
-	if (imgd->getFormat() != PIXELFORMAT_RGBA8)
+	if (imgd->getFormat() != PIXELFORMAT_RGBA8_UNORM)
 		throw love::Exception("setIcon only accepts 32-bit RGBA images.");
 
 	icon.set(imgd);