Update the internal naming convention for pixel formats.

--HG--
branch : minor

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