Unify pixel format enums for ImageData, CompressedImageData, and Canvas into a single PixelFormat enum.

Replace love.graphics.getRawImageFormats and love.graphics.getCompressedImageFormats with love.graphics.getImageFormats.

--HG--
branch : minor

src/modules/image/magpie/ASTCHandler.cpp

@@ -47,41 +47,41 @@ struct ASTCHeader
 };
 #pragma pack(pop)
 
-static CompressedImageData::Format convertFormat(uint32 blockX, uint32 blockY, uint32 blockZ)
+static PixelFormat convertFormat(uint32 blockX, uint32 blockY, uint32 blockZ)
 {
 	if (blockZ > 1)
-		return CompressedImageData::FORMAT_UNKNOWN;
+		return PIXELFORMAT_UNKNOWN;
 
 	if (blockX == 4 && blockY == 4)
-		return CompressedImageData::FORMAT_ASTC_4x4;
+		return PIXELFORMAT_ASTC_4x4;
 	else if (blockX == 5 && blockY == 4)
-		return CompressedImageData::FORMAT_ASTC_5x4;
+		return PIXELFORMAT_ASTC_5x4;
 	else if (blockX == 5 && blockY == 5)
-		return CompressedImageData::FORMAT_ASTC_5x5;
+		return PIXELFORMAT_ASTC_5x5;
 	else if (blockX == 6 && blockY == 5)
-		return CompressedImageData::FORMAT_ASTC_6x5;
+		return PIXELFORMAT_ASTC_6x5;
 	else if (blockX == 6 && blockY == 6)
-		return CompressedImageData::FORMAT_ASTC_6x6;
+		return PIXELFORMAT_ASTC_6x6;
 	else if (blockX == 8 && blockY == 5)
-		return CompressedImageData::FORMAT_ASTC_8x5;
+		return PIXELFORMAT_ASTC_8x5;
 	else if (blockX == 8 && blockY == 6)
-		return CompressedImageData::FORMAT_ASTC_8x6;
+		return PIXELFORMAT_ASTC_8x6;
 	else if (blockX == 8 && blockY == 8)
-		return CompressedImageData::FORMAT_ASTC_8x8;
+		return PIXELFORMAT_ASTC_8x8;
 	else if (blockX == 10 && blockY == 5)
-		return CompressedImageData::FORMAT_ASTC_10x5;
+		return PIXELFORMAT_ASTC_10x5;
 	else if (blockX == 10 && blockY == 6)
-		return CompressedImageData::FORMAT_ASTC_10x6;
+		return PIXELFORMAT_ASTC_10x6;
 	else if (blockX == 10 && blockY == 8)
-		return CompressedImageData::FORMAT_ASTC_10x8;
+		return PIXELFORMAT_ASTC_10x8;
 	else if (blockX == 10 && blockY == 10)
-		return CompressedImageData::FORMAT_ASTC_10x10;
+		return PIXELFORMAT_ASTC_10x10;
 	else if (blockX == 12 && blockY == 10)
-		return CompressedImageData::FORMAT_ASTC_12x10;
+		return PIXELFORMAT_ASTC_12x10;
 	else if (blockX == 12 && blockY == 12)
-		return CompressedImageData::FORMAT_ASTC_12x12;
+		return PIXELFORMAT_ASTC_12x12;
 
-	return CompressedImageData::FORMAT_UNKNOWN;
+	return PIXELFORMAT_UNKNOWN;
 }
 
 } // Anonymous namespace.
@@ -104,16 +104,16 @@ bool ASTCHandler::canParse(const filesystem::FileData *data)
 	return true;
 }
 
-uint8 *ASTCHandler::parse(filesystem::FileData *filedata, std::vector<CompressedImageData::SubImage> &images, size_t &dataSize, CompressedImageData::Format &format, bool &sRGB)
+uint8 *ASTCHandler::parse(filesystem::FileData *filedata, std::vector<CompressedImageData::SubImage> &images, size_t &dataSize, PixelFormat &format, bool &sRGB)
 {
 	if (!canParse(filedata))
 		throw love::Exception("Could not decode compressed data (not an .astc file?)");
 
 	ASTCHeader header = *(const ASTCHeader *) filedata->getData();
 
-	CompressedImageData::Format cformat = convertFormat(header.blockdimX, header.blockdimY, header.blockdimZ);
+	PixelFormat cformat = convertFormat(header.blockdimX, header.blockdimY, header.blockdimZ);
 
-	if (cformat == CompressedImageData::FORMAT_UNKNOWN)
+	if (cformat == PIXELFORMAT_UNKNOWN)
 		throw love::Exception("Could not parse .astc file: unsupported ASTC format %dx%dx%d.", header.blockdimX, header.blockdimY, header.blockdimZ);
 
 	uint32 sizeX = header.sizeX[0] + (header.sizeX[1] << 8) + (header.sizeX[2] << 16);

src/modules/image/magpie/ASTCHandler.h

@@ -43,7 +43,7 @@ public:
 
 	// Implements CompressedFormatHandler.
 	virtual bool canParse(const filesystem::FileData *data);
-	virtual uint8 *parse(filesystem::FileData *filedata, std::vector<CompressedImageData::SubImage> &images, size_t &dataSize, CompressedImageData::Format &format, bool &sRGB);
+	virtual uint8 *parse(filesystem::FileData *filedata, std::vector<CompressedImageData::SubImage> &images, size_t &dataSize, PixelFormat &format, bool &sRGB);
 
 }; // ASTCHandler
 

src/modules/image/magpie/CompressedFormatHandler.h

@@ -65,7 +65,7 @@ public:
 	 * @return The single block of memory containing the parsed images.
 	 **/
 	virtual uint8 *parse(filesystem::FileData *filedata, std::vector<CompressedImageData::SubImage> &images,
-	                     size_t &dataSize, CompressedImageData::Format &format, bool &sRGB) = 0;
+	                     size_t &dataSize, PixelFormat &format, bool &sRGB) = 0;
 
 }; // CompressedFormatHandler
 

src/modules/image/magpie/CompressedImageData.cpp

@@ -48,7 +48,7 @@ CompressedImageData::CompressedImageData(std::list<CompressedFormatHandler *> fo
 	if (data == nullptr)
 		throw love::Exception("Could not parse compressed data.");
 
-	if (format == FORMAT_UNKNOWN)
+	if (format == PIXELFORMAT_UNKNOWN)
 	{
 		delete[] data;
 		throw love::Exception("Could not parse compressed data: Unknown format.");

src/modules/image/magpie/EXRHandler.cpp

@@ -41,7 +41,7 @@ bool EXRHandler::canDecode(love::filesystem::FileData *data)
 	return ParseEXRVersionFromMemory(&version, (const unsigned char *) data->getData(), data->getSize()) == TINYEXR_SUCCESS;
 }
 
-bool EXRHandler::canEncode(ImageData::Format /*rawFormat*/, ImageData::EncodedFormat /*encodedFormat*/)
+bool EXRHandler::canEncode(PixelFormat /*rawFormat*/, ImageData::EncodedFormat /*encodedFormat*/)
 {
 	return false;
 }
@@ -141,7 +141,7 @@ FormatHandler::DecodedImage EXRHandler::decode(love::filesystem::FileData *data)
 
 	if (pixelType == TINYEXR_PIXELTYPE_HALF)
 	{
-		img.format = ImageData::FORMAT_RGBA16F;
+		img.format = PIXELFORMAT_RGBA16F;
 
 		half *rgba[4] = {nullptr};
 		getEXRChannels(exrHeader, exrImage, rgba);
@@ -158,7 +158,7 @@ FormatHandler::DecodedImage EXRHandler::decode(love::filesystem::FileData *data)
 	}
 	else if (pixelType == TINYEXR_PIXELTYPE_FLOAT)
 	{
-		img.format = ImageData::FORMAT_RGBA32F;
+		img.format = PIXELFORMAT_RGBA32F;
 
 		float *rgba[4] = {nullptr};
 		getEXRChannels(exrHeader, exrImage, rgba);
@@ -179,7 +179,7 @@ FormatHandler::DecodedImage EXRHandler::decode(love::filesystem::FileData *data)
 		throw love::Exception("Could not decode EXR image: unknown pixel format.");
 	}
 
-	img.size = img.width * img.height * ImageData::getPixelSize(img.format);
+	img.size = img.width * img.height * getPixelFormatSize(img.format);
 
 	FreeEXRImage(&exrImage);
 

src/modules/image/magpie/EXRHandler.h

@@ -40,7 +40,7 @@ public:
 	// Implements FormatHandler.
 
 	virtual bool canDecode(love::filesystem::FileData *data);
-	virtual bool canEncode(ImageData::Format rawFormat, ImageData::EncodedFormat encodedFormat);
+	virtual bool canEncode(PixelFormat rawFormat, ImageData::EncodedFormat encodedFormat);
 
 	virtual DecodedImage decode(love::filesystem::FileData *data);
 	virtual EncodedImage encode(const DecodedImage &img, ImageData::EncodedFormat format);

src/modules/image/magpie/FormatHandler.cpp

@@ -42,7 +42,7 @@ bool FormatHandler::canDecode(love::filesystem::FileData* /*data*/)
 	return false;
 }
 
-bool FormatHandler::canEncode(ImageData::Format /*rawFormat*/, ImageData::EncodedFormat /*encodedFormat*/)
+bool FormatHandler::canEncode(PixelFormat /*rawFormat*/, ImageData::EncodedFormat /*encodedFormat*/)
 {
 	return false;
 }

src/modules/image/magpie/FormatHandler.h

@@ -44,7 +44,7 @@ public:
 	// Raw RGBA pixel data.
 	struct DecodedImage
 	{
-		ImageData::Format format = ImageData::FORMAT_RGBA8;
+		PixelFormat format = PIXELFORMAT_RGBA8;
 		int width   = 0;
 		int height  = 0;
 		size_t size = 0;
@@ -76,7 +76,7 @@ public:
 	/**
 	 * Whether this format handler can encode to a particular format.
 	 **/
-	virtual bool canEncode(ImageData::Format rawFormat, ImageData::EncodedFormat encodedFormat);
+	virtual bool canEncode(PixelFormat rawFormat, ImageData::EncodedFormat encodedFormat);
 
 	/**
 	 * Decodes an image from its encoded form into raw pixel data.

src/modules/image/magpie/Image.cpp

@@ -82,12 +82,12 @@ love::image::ImageData *Image::newImageData(love::filesystem::FileData *data)
 	return new ImageData(formatHandlers, data);
 }
 
-love::image::ImageData *Image::newImageData(int width, int height, ImageData::Format format)
+love::image::ImageData *Image::newImageData(int width, int height, PixelFormat format)
 {
 	return new ImageData(formatHandlers, width, height, format);
 }
 
-love::image::ImageData *Image::newImageData(int width, int height, ImageData::Format format, void *data, bool own)
+love::image::ImageData *Image::newImageData(int width, int height, PixelFormat format, void *data, bool own)
 {
 	return new ImageData(formatHandlers, width, height, format, data, own);
 }

src/modules/image/magpie/Image.h

@@ -52,8 +52,8 @@ public:
 	const char *getName() const;
 
 	love::image::ImageData *newImageData(love::filesystem::FileData *data);
-	love::image::ImageData *newImageData(int width, int height, ImageData::Format format = ImageData::FORMAT_RGBA8);
-	love::image::ImageData *newImageData(int width, int height, ImageData::Format format, void *data, bool own = false);
+	love::image::ImageData *newImageData(int width, int height, PixelFormat format = PIXELFORMAT_RGBA8);
+	love::image::ImageData *newImageData(int width, int height, PixelFormat format, void *data, bool own = false);
 
 	love::image::CompressedImageData *newCompressedData(love::filesystem::FileData *data);
 

src/modules/image/magpie/ImageData.cpp

@@ -38,12 +38,12 @@ ImageData::ImageData(std::list<FormatHandler *> formatHandlers, love::filesystem
 	decode(data);
 }
 
-ImageData::ImageData(std::list<FormatHandler *> formatHandlers, int width, int height, Format format)
+ImageData::ImageData(std::list<FormatHandler *> formatHandlers, int width, int height, PixelFormat format)
 	: formatHandlers(formatHandlers)
 	, decodeHandler(nullptr)
 {
-	for (FormatHandler *handler : formatHandlers)
-		handler->retain();
+	if (!validPixelFormat(format))
+		throw love::Exception("Unsupported pixel format for ImageData");
 
 	this->width = width;
 	this->height = height;
@@ -53,14 +53,17 @@ ImageData::ImageData(std::list<FormatHandler *> formatHandlers, int width, int h
 
 	// Set to black/transparency.
 	memset(data, 0, getSize());
+
+	for (FormatHandler *handler : formatHandlers)
+		handler->retain();
 }
 
-ImageData::ImageData(std::list<FormatHandler *> formatHandlers, int width, int height, Format format, void *data, bool own)
+ImageData::ImageData(std::list<FormatHandler *> formatHandlers, int width, int height, PixelFormat format, void *data, bool own)
 	: formatHandlers(formatHandlers)
 	, decodeHandler(nullptr)
 {
-	for (FormatHandler *handler : formatHandlers)
-		handler->retain();
+	if (!validPixelFormat(format))
+		throw love::Exception("Unsupported pixel format for ImageData");
 
 	this->width = width;
 	this->height = height;
@@ -70,6 +73,9 @@ ImageData::ImageData(std::list<FormatHandler *> formatHandlers, int width, int h
 		this->data = (unsigned char *) data;
 	else
 		create(width, height, format, data);
+
+	for (FormatHandler *handler : formatHandlers)
+		handler->retain();
 }
 
 ImageData::~ImageData()
@@ -83,9 +89,9 @@ ImageData::~ImageData()
 		handler->release();
 }
 
-void ImageData::create(int width, int height, Format format, void *data)
+void ImageData::create(int width, int height, PixelFormat format, void *data)
 {
-	size_t datasize = width * height * getPixelSize(format);
+	size_t datasize = width * height * getPixelFormatSize(format);
 
 	try
 	{
@@ -126,7 +132,7 @@ void ImageData::decode(love::filesystem::FileData *data)
 		throw love::Exception("Could not decode file '%s' to ImageData: unsupported file format", name.c_str());
 	}
 
-	if (decodedimage.size != decodedimage.width * decodedimage.height * getPixelSize(decodedimage.format))
+	if (decodedimage.size != decodedimage.width * decodedimage.height * getPixelFormatSize(decodedimage.format))
 	{
 		decoder->free(decodedimage.data);
 		throw love::Exception("Could not convert image!");
@@ -176,7 +182,7 @@ love::filesystem::FileData *ImageData::encode(EncodedFormat encodedFormat, const
 	if (encoder == nullptr || encodedimage.data == nullptr)
 	{
 		const char *fname = "unknown";
-		getConstant(format, fname);
+		love::getConstant(format, fname);
 		throw love::Exception("No suitable image encoder for %s format.", fname);
 	}
 

src/modules/image/magpie/ImageData.h

@@ -40,8 +40,8 @@ class ImageData : public love::image::ImageData
 public:
 
 	ImageData(std::list<FormatHandler *> formatHandlers, love::filesystem::FileData *data);
-	ImageData(std::list<FormatHandler *> formatHandlers, int width, int height, Format format = FORMAT_RGBA8);
-	ImageData(std::list<FormatHandler *> formatHandlers, int width, int height, Format format, void *data, bool own);
+	ImageData(std::list<FormatHandler *> formatHandlers, int width, int height, PixelFormat format = PIXELFORMAT_RGBA8);
+	ImageData(std::list<FormatHandler *> formatHandlers, int width, int height, PixelFormat format, void *data, bool own);
 	virtual ~ImageData();
 
 	// Implements image::ImageData.
@@ -50,7 +50,7 @@ public:
 private:
 
 	// Create imagedata. Initialize with data if not null.
-	void create(int width, int height, Format format, void *data = nullptr);
+	void create(int width, int height, PixelFormat format, void *data = nullptr);
 
 	// Decode and load an encoded format.
 	void decode(love::filesystem::FileData *data);

src/modules/image/magpie/KTXHandler.cpp

@@ -136,7 +136,7 @@ enum KTXGLInternalFormat
 	KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR = 0x93DD
 };
 
-CompressedImageData::Format convertFormat(uint32 glformat, bool &sRGB)
+PixelFormat convertFormat(uint32 glformat, bool &sRGB)
 {
 	sRGB = false;
 
@@ -145,136 +145,136 @@ CompressedImageData::Format convertFormat(uint32 glformat, bool &sRGB)
 	switch (glformat)
 	{
 	case KTX_GL_ETC1_RGB8_OES:
-		return CompressedImageData::FORMAT_ETC1;
+		return PIXELFORMAT_ETC1;
 
 	// EAC and ETC2.
 	case KTX_GL_COMPRESSED_R11_EAC:
-		return CompressedImageData::FORMAT_EAC_R;
+		return PIXELFORMAT_EAC_R;
 	case KTX_GL_COMPRESSED_SIGNED_R11_EAC:
-		return CompressedImageData::FORMAT_EAC_Rs;
+		return PIXELFORMAT_EAC_Rs;
 	case KTX_GL_COMPRESSED_RG11_EAC:
-		return CompressedImageData::FORMAT_EAC_RG;
+		return PIXELFORMAT_EAC_RG;
 	case KTX_GL_COMPRESSED_SIGNED_RG11_EAC:
-		return CompressedImageData::FORMAT_EAC_RGs;
+		return PIXELFORMAT_EAC_RGs;
 	case KTX_GL_COMPRESSED_RGB8_ETC2:
-		return CompressedImageData::FORMAT_ETC2_RGB;
+		return PIXELFORMAT_ETC2_RGB;
 	case KTX_GL_COMPRESSED_SRGB8_ETC2:
 		sRGB = true;
-		return CompressedImageData::FORMAT_ETC2_RGB;
+		return PIXELFORMAT_ETC2_RGB;
 	case KTX_GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
-		return CompressedImageData::FORMAT_ETC2_RGBA1;
+		return PIXELFORMAT_ETC2_RGBA1;
 	case KTX_GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
 		sRGB = true;
-		return CompressedImageData::FORMAT_ETC2_RGBA1;
+		return PIXELFORMAT_ETC2_RGBA1;
 	case KTX_GL_COMPRESSED_RGBA8_ETC2_EAC:
-		return CompressedImageData::FORMAT_ETC2_RGBA;
+		return PIXELFORMAT_ETC2_RGBA;
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
 		sRGB = true;
-		return CompressedImageData::FORMAT_ETC2_RGBA;
+		return PIXELFORMAT_ETC2_RGBA;
 
 	// PVRTC.
 	case KTX_GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG:
-		return CompressedImageData::FORMAT_PVR1_RGB4;
+		return PIXELFORMAT_PVR1_RGB4;
 	case KTX_GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG:
-		return CompressedImageData::FORMAT_PVR1_RGB2;
+		return PIXELFORMAT_PVR1_RGB2;
 	case KTX_GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG:
-		return CompressedImageData::FORMAT_PVR1_RGBA4;
+		return PIXELFORMAT_PVR1_RGBA4;
 	case KTX_GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG:
-		return CompressedImageData::FORMAT_PVR1_RGBA2;
+		return PIXELFORMAT_PVR1_RGBA2;
 
 	// DXT.
 	case KTX_GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
-		return CompressedImageData::FORMAT_DXT1;
+		return PIXELFORMAT_DXT1;
 	case KTX_GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
-		return CompressedImageData::FORMAT_DXT3;
+		return PIXELFORMAT_DXT3;
 	case KTX_GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
-		return CompressedImageData::FORMAT_DXT5;
+		return PIXELFORMAT_DXT5;
 
 	// BC4 and BC5.
 	case KTX_GL_COMPRESSED_RED_RGTC1:
-		return CompressedImageData::FORMAT_BC4;
+		return PIXELFORMAT_BC4;
 	case KTX_GL_COMPRESSED_SIGNED_RED_RGTC1:
-		return CompressedImageData::FORMAT_BC4s;
+		return PIXELFORMAT_BC4s;
 	case KTX_GL_COMPRESSED_RG_RGTC2:
-		return CompressedImageData::FORMAT_BC5;
+		return PIXELFORMAT_BC5;
 	case KTX_GL_COMPRESSED_SIGNED_RG_RGTC2:
-		return CompressedImageData::FORMAT_BC5s;
+		return PIXELFORMAT_BC5s;
 
 	// BC6 and BC7.
 	case KTX_GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_BPTC_UNORM:
-		return CompressedImageData::FORMAT_BC7;
+		return PIXELFORMAT_BC7;
 	case KTX_GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT:
-		return CompressedImageData::FORMAT_BC6Hs;
+		return PIXELFORMAT_BC6Hs;
 	case KTX_GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT:
-		return CompressedImageData::FORMAT_BC6H;
+		return PIXELFORMAT_BC6H;
 
 	// ASTC.
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_ASTC_4x4_KHR:
-		return CompressedImageData::FORMAT_ASTC_4x4;
+		return PIXELFORMAT_ASTC_4x4;
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_ASTC_5x4_KHR:
-		return CompressedImageData::FORMAT_ASTC_5x4;
+		return PIXELFORMAT_ASTC_5x4;
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_ASTC_5x5_KHR:
-		return CompressedImageData::FORMAT_ASTC_5x5;
+		return PIXELFORMAT_ASTC_5x5;
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_ASTC_6x5_KHR:
-		return CompressedImageData::FORMAT_ASTC_6x5;
+		return PIXELFORMAT_ASTC_6x5;
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_ASTC_6x6_KHR:
-		return CompressedImageData::FORMAT_ASTC_6x6;
+		return PIXELFORMAT_ASTC_6x6;
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_ASTC_8x5_KHR:
-		return CompressedImageData::FORMAT_ASTC_8x5;
+		return PIXELFORMAT_ASTC_8x5;
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_ASTC_8x6_KHR:
-		return CompressedImageData::FORMAT_ASTC_8x6;
+		return PIXELFORMAT_ASTC_8x6;
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_ASTC_8x8_KHR:
-		return CompressedImageData::FORMAT_ASTC_8x8;
+		return PIXELFORMAT_ASTC_8x8;
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_ASTC_10x5_KHR:
-		return CompressedImageData::FORMAT_ASTC_10x5;
+		return PIXELFORMAT_ASTC_10x5;
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_ASTC_10x6_KHR:
-		return CompressedImageData::FORMAT_ASTC_10x6;
+		return PIXELFORMAT_ASTC_10x6;
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_ASTC_10x8_KHR:
-		return CompressedImageData::FORMAT_ASTC_10x8;
+		return PIXELFORMAT_ASTC_10x8;
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_ASTC_10x10_KHR:
-		return CompressedImageData::FORMAT_ASTC_10x10;
+		return PIXELFORMAT_ASTC_10x10;
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_ASTC_12x10_KHR:
-		return CompressedImageData::FORMAT_ASTC_12x10;
+		return PIXELFORMAT_ASTC_12x10;
 	case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:
 		sRGB = true;
 	case KTX_GL_COMPRESSED_RGBA_ASTC_12x12_KHR:
-		return CompressedImageData::FORMAT_ASTC_12x12;
+		return PIXELFORMAT_ASTC_12x12;
 	default:
-		return CompressedImageData::FORMAT_UNKNOWN;
+		return PIXELFORMAT_UNKNOWN;
 	}
 }
 
@@ -297,7 +297,7 @@ bool KTXHandler::canParse(const filesystem::FileData *data)
 	return true;
 }
 
-uint8 *KTXHandler::parse(filesystem::FileData *filedata, std::vector<CompressedImageData::SubImage> &images, size_t &dataSize, CompressedImageData::Format &format, bool &sRGB)
+uint8 *KTXHandler::parse(filesystem::FileData *filedata, std::vector<CompressedImageData::SubImage> &images, size_t &dataSize, PixelFormat &format, bool &sRGB)
 {
 	if (!canParse(filedata))
 		throw love::Exception("Could not decode compressed data (not a KTX file?)");
@@ -314,9 +314,9 @@ uint8 *KTXHandler::parse(filesystem::FileData *filedata, std::vector<CompressedI
 	header.numberOfMipmapLevels = std::max(header.numberOfMipmapLevels, 1u);
 
 	bool isSRGB = false;
-	CompressedImageData::Format cformat = convertFormat(header.glInternalFormat, isSRGB);
+	PixelFormat cformat = convertFormat(header.glInternalFormat, isSRGB);
 
-	if (cformat == CompressedImageData::FORMAT_UNKNOWN)
+	if (cformat == PIXELFORMAT_UNKNOWN)
 		throw love::Exception("Unsupported image format in KTX file.");
 
 	if (header.numberOfArrayElements > 0)

src/modules/image/magpie/KTXHandler.h

@@ -42,7 +42,7 @@ public:
 
 	// Implements CompressedFormatHandler.
 	virtual bool canParse(const filesystem::FileData *data);
-	virtual uint8 *parse(filesystem::FileData *filedata, std::vector<CompressedImageData::SubImage> &images, size_t &dataSize, CompressedImageData::Format &format, bool &sRGB);
+	virtual uint8 *parse(filesystem::FileData *filedata, std::vector<CompressedImageData::SubImage> &images, size_t &dataSize, PixelFormat &format, bool &sRGB);
 
 }; // KTXHandler
 

src/modules/image/magpie/PKMHandler.cpp

@@ -68,29 +68,29 @@ enum PKMTextureFormat
 	ETC2PACKAGE_RG_SIGNED_NO_MIPMAPS
 };
 
-static CompressedImageData::Format convertFormat(uint16 texformat)
+static PixelFormat convertFormat(uint16 texformat)
 {
 	switch (texformat)
 	{
 	case ETC1_RGB_NO_MIPMAPS:
-		return CompressedImageData::FORMAT_ETC1;
+		return PIXELFORMAT_ETC1;
 	case ETC2PACKAGE_RGB_NO_MIPMAPS:
-		return CompressedImageData::FORMAT_ETC2_RGB;
+		return PIXELFORMAT_ETC2_RGB;
 	case ETC2PACKAGE_RGBA_NO_MIPMAPS_OLD:
 	case ETC2PACKAGE_RGBA_NO_MIPMAPS:
-		return CompressedImageData::FORMAT_ETC2_RGBA;
+		return PIXELFORMAT_ETC2_RGBA;
 	case ETC2PACKAGE_RGBA1_NO_MIPMAPS:
-		return CompressedImageData::FORMAT_ETC2_RGBA1;
+		return PIXELFORMAT_ETC2_RGBA1;
 	case ETC2PACKAGE_R_NO_MIPMAPS:
-		return CompressedImageData::FORMAT_EAC_R;
+		return PIXELFORMAT_EAC_R;
 	case ETC2PACKAGE_RG_NO_MIPMAPS:
-		return CompressedImageData::FORMAT_EAC_RG;
+		return PIXELFORMAT_EAC_RG;
 	case ETC2PACKAGE_R_SIGNED_NO_MIPMAPS:
-		return CompressedImageData::FORMAT_EAC_Rs;
+		return PIXELFORMAT_EAC_Rs;
 	case ETC2PACKAGE_RG_SIGNED_NO_MIPMAPS:
-		return CompressedImageData::FORMAT_EAC_RGs;
+		return PIXELFORMAT_EAC_RGs;
 	default:
-		return CompressedImageData::FORMAT_UNKNOWN;
+		return PIXELFORMAT_UNKNOWN;
 	}
 }
 
@@ -113,7 +113,7 @@ bool PKMHandler::canParse(const filesystem::FileData *data)
 	return true;
 }
 
-uint8 *PKMHandler::parse(filesystem::FileData *filedata, std::vector<CompressedImageData::SubImage> &images, size_t &dataSize, CompressedImageData::Format &format, bool &sRGB)
+uint8 *PKMHandler::parse(filesystem::FileData *filedata, std::vector<CompressedImageData::SubImage> &images, size_t &dataSize, PixelFormat &format, bool &sRGB)
 {
 	if (!canParse(filedata))
 		throw love::Exception("Could not decode compressed data (not a PKM file?)");
@@ -126,9 +126,9 @@ uint8 *PKMHandler::parse(filesystem::FileData *filedata, std::vector<CompressedI
 	header.widthBig = swap16big(header.widthBig);
 	header.heightBig = swap16big(header.heightBig);
 
-	CompressedImageData::Format cformat = convertFormat(header.textureFormatBig);
+	PixelFormat cformat = convertFormat(header.textureFormatBig);
 
-	if (cformat == CompressedImageData::FORMAT_UNKNOWN)
+	if (cformat == PIXELFORMAT_UNKNOWN)
 		throw love::Exception("Could not parse PKM file: unsupported texture format.");
 
 	// The rest of the file after the header is all texture data.

src/modules/image/magpie/PKMHandler.h

@@ -42,7 +42,7 @@ public:
 
 	// Implements CompressedFormatHandler.
 	virtual bool canParse(const filesystem::FileData *data);
-	virtual uint8 *parse(filesystem::FileData *filedata, std::vector<CompressedImageData::SubImage> &images, size_t &dataSize, CompressedImageData::Format &format, bool &sRGB);
+	virtual uint8 *parse(filesystem::FileData *filedata, std::vector<CompressedImageData::SubImage> &images, size_t &dataSize, PixelFormat &format, bool &sRGB);
 
 }; // PKMHandler
 

src/modules/image/magpie/PNGHandler.cpp

@@ -140,10 +140,10 @@ bool PNGHandler::canDecode(love::filesystem::FileData *data)
 	return status == 0 && width > 0 && height > 0;
 }
 
-bool PNGHandler::canEncode(ImageData::Format rawFormat, ImageData::EncodedFormat encodedFormat)
+bool PNGHandler::canEncode(PixelFormat rawFormat, ImageData::EncodedFormat encodedFormat)
 {
 	return encodedFormat == ImageData::ENCODED_PNG
-		&& (rawFormat == ImageData::FORMAT_RGBA8 || rawFormat == ImageData::FORMAT_RGBA16);
+		&& (rawFormat == PIXELFORMAT_RGBA8 || rawFormat == PIXELFORMAT_RGBA16);
 }
 
 PNGHandler::DecodedImage PNGHandler::decode(love::filesystem::FileData *fdata)
@@ -182,7 +182,7 @@ PNGHandler::DecodedImage PNGHandler::decode(love::filesystem::FileData *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 ? ImageData::FORMAT_RGBA16 : ImageData::FORMAT_RGBA8;
+	img.format = state.info_raw.bitdepth == 16 ? PIXELFORMAT_RGBA16 : PIXELFORMAT_RGBA8;
 
 	// LodePNG keeps raw 16 bit images stored as big-endian.
 #ifndef LOVE_BIG_ENDIAN
@@ -209,7 +209,7 @@ PNGHandler::EncodedImage PNGHandler::encode(const DecodedImage &img, ImageData::
 	lodepng::State state;
 
 	state.info_raw.colortype = LCT_RGBA;
-	state.info_raw.bitdepth = img.format == ImageData::FORMAT_RGBA16 ? 16 : 8;
+	state.info_raw.bitdepth = img.format == PIXELFORMAT_RGBA16 ? 16 : 8;
 
 	state.info_png.color.colortype = LCT_RGBA;
 	state.info_png.color.bitdepth = state.info_raw.bitdepth;

src/modules/image/magpie/PNGHandler.h

@@ -41,7 +41,7 @@ public:
 	// Implements FormatHandler.
 
 	virtual bool canDecode(love::filesystem::FileData *data);
-	virtual bool canEncode(ImageData::Format rawFormat, ImageData::EncodedFormat encodedFormat);
+	virtual bool canEncode(PixelFormat rawFormat, ImageData::EncodedFormat encodedFormat);
 
 	virtual DecodedImage decode(love::filesystem::FileData *data);
 	virtual EncodedImage encode(const DecodedImage &img, ImageData::EncodedFormat format);

src/modules/image/magpie/PVRHandler.cpp

@@ -203,7 +203,7 @@ void ConvertPVRHeader(PVRTexHeaderV2 header2, PVRTexHeaderV3 *header3)
 	}
 }
 
-static CompressedImageData::Format convertFormat(PVRV3PixelFormat format, PVRV3ChannelType channeltype)
+static PixelFormat convertFormat(PVRV3PixelFormat format, PVRV3ChannelType channeltype)
 {
 	bool snorm = false;
 
@@ -221,69 +221,69 @@ static CompressedImageData::Format convertFormat(PVRV3PixelFormat format, PVRV3C
 	switch (format)
 	{
 	case ePVRTPF_PVRTCI_2bpp_RGB:
-		return CompressedImageData::FORMAT_PVR1_RGB2;
+		return PIXELFORMAT_PVR1_RGB2;
 	case ePVRTPF_PVRTCI_2bpp_RGBA:
-		return CompressedImageData::FORMAT_PVR1_RGBA2;
+		return PIXELFORMAT_PVR1_RGBA2;
 	case ePVRTPF_PVRTCI_4bpp_RGB:
-		return CompressedImageData::FORMAT_PVR1_RGB4;
+		return PIXELFORMAT_PVR1_RGB4;
 	case ePVRTPF_PVRTCI_4bpp_RGBA:
-		return CompressedImageData::FORMAT_PVR1_RGBA4;
+		return PIXELFORMAT_PVR1_RGBA4;
 	case ePVRTPF_ETC1:
-		return CompressedImageData::FORMAT_ETC1;
+		return PIXELFORMAT_ETC1;
 	case ePVRTPF_DXT1:
-		return CompressedImageData::FORMAT_DXT1;
+		return PIXELFORMAT_DXT1;
 	case ePVRTPF_DXT3:
-		return CompressedImageData::FORMAT_DXT3;
+		return PIXELFORMAT_DXT3;
 	case ePVRTPF_DXT5:
-		return CompressedImageData::FORMAT_DXT5;
+		return PIXELFORMAT_DXT5;
 	case ePVRTPF_BC4:
-		return snorm ? CompressedImageData::FORMAT_BC4s : CompressedImageData::FORMAT_BC4;
+		return snorm ? PIXELFORMAT_BC4s : PIXELFORMAT_BC4;
 	case ePVRTPF_BC5:
-		return snorm ? CompressedImageData::FORMAT_BC5s : CompressedImageData::FORMAT_BC5;
+		return snorm ? PIXELFORMAT_BC5s : PIXELFORMAT_BC5;
 	case ePVRTPF_BC6:
-		return snorm ? CompressedImageData::FORMAT_BC6Hs : CompressedImageData::FORMAT_BC6H;
+		return snorm ? PIXELFORMAT_BC6Hs : PIXELFORMAT_BC6H;
 	case ePVRTPF_BC7:
-		return CompressedImageData::FORMAT_BC7;
+		return PIXELFORMAT_BC7;
 	case ePVRTPF_ETC2_RGB:
-		return CompressedImageData::FORMAT_ETC2_RGB;
+		return PIXELFORMAT_ETC2_RGB;
 	case ePVRTPF_ETC2_RGBA:
-		return CompressedImageData::FORMAT_ETC2_RGBA;
+		return PIXELFORMAT_ETC2_RGBA;
 	case ePVRTPF_ETC2_RGBA1:
-		return CompressedImageData::FORMAT_ETC2_RGBA1;
+		return PIXELFORMAT_ETC2_RGBA1;
 	case ePVRTPF_EAC_R:
-		return snorm ? CompressedImageData::FORMAT_EAC_Rs : CompressedImageData::FORMAT_EAC_R;
+		return snorm ? PIXELFORMAT_EAC_Rs : PIXELFORMAT_EAC_R;
 	case ePVRTPF_EAC_RG:
-		return snorm ? CompressedImageData::FORMAT_EAC_RGs : CompressedImageData::FORMAT_EAC_RG;
+		return snorm ? PIXELFORMAT_EAC_RGs : PIXELFORMAT_EAC_RG;
 	case ePVRTPF_ASTC_4x4:
-		return CompressedImageData::FORMAT_ASTC_4x4;
+		return PIXELFORMAT_ASTC_4x4;
 	case ePVRTPF_ASTC_5x4:
-		return CompressedImageData::FORMAT_ASTC_5x4;
+		return PIXELFORMAT_ASTC_5x4;
 	case ePVRTPF_ASTC_5x5:
-		return CompressedImageData::FORMAT_ASTC_5x5;
+		return PIXELFORMAT_ASTC_5x5;
 	case ePVRTPF_ASTC_6x5:
-		return CompressedImageData::FORMAT_ASTC_6x5;
+		return PIXELFORMAT_ASTC_6x5;
 	case ePVRTPF_ASTC_6x6:
-		return CompressedImageData::FORMAT_ASTC_6x6;
+		return PIXELFORMAT_ASTC_6x6;
 	case ePVRTPF_ASTC_8x5:
-		return CompressedImageData::FORMAT_ASTC_8x5;
+		return PIXELFORMAT_ASTC_8x5;
 	case ePVRTPF_ASTC_8x6:
-		return CompressedImageData::FORMAT_ASTC_8x6;
+		return PIXELFORMAT_ASTC_8x6;
 	case ePVRTPF_ASTC_8x8:
-		return CompressedImageData::FORMAT_ASTC_8x8;
+		return PIXELFORMAT_ASTC_8x8;
 	case ePVRTPF_ASTC_10x5:
-		return CompressedImageData::FORMAT_ASTC_10x5;
+		return PIXELFORMAT_ASTC_10x5;
 	case ePVRTPF_ASTC_10x6:
-		return CompressedImageData::FORMAT_ASTC_10x6;
+		return PIXELFORMAT_ASTC_10x6;
 	case ePVRTPF_ASTC_10x8:
-		return CompressedImageData::FORMAT_ASTC_10x8;
+		return PIXELFORMAT_ASTC_10x8;
 	case ePVRTPF_ASTC_10x10:
-		return CompressedImageData::FORMAT_ASTC_10x10;
+		return PIXELFORMAT_ASTC_10x10;
 	case ePVRTPF_ASTC_12x10:
-		return CompressedImageData::FORMAT_ASTC_12x10;
+		return PIXELFORMAT_ASTC_12x10;
 	case ePVRTPF_ASTC_12x12:
-		return CompressedImageData::FORMAT_ASTC_12x12;
+		return PIXELFORMAT_ASTC_12x12;
 	default:
-		return CompressedImageData::FORMAT_UNKNOWN;
+		return PIXELFORMAT_UNKNOWN;
 	}
 }
 
@@ -474,7 +474,7 @@ bool PVRHandler::canParse(const filesystem::FileData *data)
 	return false;
 }
 
-uint8 *PVRHandler::parse(filesystem::FileData *filedata, std::vector<CompressedImageData::SubImage> &images, size_t &dataSize, CompressedImageData::Format &format, bool &sRGB)
+uint8 *PVRHandler::parse(filesystem::FileData *filedata, std::vector<CompressedImageData::SubImage> &images, size_t &dataSize, PixelFormat &format, bool &sRGB)
 {
 	if (!canParse(filedata))
 		throw love::Exception("Could not decode compressed data (not a PVR file?)");
@@ -507,9 +507,9 @@ uint8 *PVRHandler::parse(filesystem::FileData *filedata, std::vector<CompressedI
 	PVRV3PixelFormat pixelformat = (PVRV3PixelFormat) header3.pixelFormat;
 	PVRV3ChannelType channeltype = (PVRV3ChannelType) header3.channelType;
 
-	CompressedImageData::Format cformat = convertFormat(pixelformat, channeltype);
+	PixelFormat cformat = convertFormat(pixelformat, channeltype);
 
-	if (cformat == CompressedImageData::FORMAT_UNKNOWN)
+	if (cformat == PIXELFORMAT_UNKNOWN)
 		throw love::Exception("Could not parse PVR file: unsupported image format.");
 
 	size_t totalsize = 0;

src/modules/image/magpie/PVRHandler.h

@@ -40,7 +40,7 @@ public:
 
 	// Implements CompressedFormatHandler.
 	virtual bool canParse(const filesystem::FileData *data);
-	virtual uint8 *parse(filesystem::FileData *filedata, std::vector<CompressedImageData::SubImage> &images, size_t &dataSize, CompressedImageData::Format &format, bool &sRGB);
+	virtual uint8 *parse(filesystem::FileData *filedata, std::vector<CompressedImageData::SubImage> &images, size_t &dataSize, PixelFormat &format, bool &sRGB);
 
 }; // PVRHandler
 

src/modules/image/magpie/STBHandler.cpp

@@ -60,9 +60,9 @@ bool STBHandler::canDecode(love::filesystem::FileData *data)
 	return status == 1 && w > 0 && h > 0;
 }
 
-bool STBHandler::canEncode(ImageData::Format rawFormat, ImageData::EncodedFormat encodedFormat)
+bool STBHandler::canEncode(PixelFormat rawFormat, ImageData::EncodedFormat encodedFormat)
 {
-	return encodedFormat == ImageData::ENCODED_TGA && rawFormat == ImageData::FORMAT_RGBA8;
+	return encodedFormat == ImageData::ENCODED_TGA && rawFormat == PIXELFORMAT_RGBA8;
 }
 
 FormatHandler::DecodedImage STBHandler::decode(love::filesystem::FileData *data)
@@ -77,13 +77,13 @@ FormatHandler::DecodedImage STBHandler::decode(love::filesystem::FileData *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 = ImageData::FORMAT_RGBA32F;
+		img.format = PIXELFORMAT_RGBA32F;
 	}
 	else
 	{
 		img.data = stbi_load_from_memory(buffer, bufferlen, &img.width, &img.height, &comp, 4);
 		img.size = img.width * img.height * 4;
-		img.format = ImageData::FORMAT_RGBA8;
+		img.format = PIXELFORMAT_RGBA8;
 	}
 
 	if (img.data == nullptr || img.width <= 0 || img.height <= 0)

src/modules/image/magpie/STBHandler.h

@@ -44,7 +44,7 @@ public:
 	// Implements FormatHandler.
 
 	virtual bool canDecode(love::filesystem::FileData *data);
-	virtual bool canEncode(ImageData::Format rawFormat, ImageData::EncodedFormat encodedFormat);
+	virtual bool canEncode(PixelFormat rawFormat, ImageData::EncodedFormat encodedFormat);
 
 	virtual DecodedImage decode(love::filesystem::FileData *data);
 	virtual EncodedImage encode(const DecodedImage &img, ImageData::EncodedFormat format);

src/modules/image/magpie/ddsHandler.cpp

@@ -32,12 +32,12 @@ bool DDSHandler::canParse(const filesystem::FileData *data)
 	return dds::isCompressedDDS(data->getData(), data->getSize());
 }
 
-uint8 *DDSHandler::parse(filesystem::FileData *filedata, std::vector<CompressedImageData::SubImage> &images, size_t &dataSize, CompressedImageData::Format &format, bool &sRGB)
+uint8 *DDSHandler::parse(filesystem::FileData *filedata, std::vector<CompressedImageData::SubImage> &images, size_t &dataSize, PixelFormat &format, bool &sRGB)
 {
 	if (!dds::isDDS(filedata->getData(), filedata->getSize()))
 		throw love::Exception("Could not decode compressed data (not a DDS file?)");
 
-	CompressedImageData::Format texformat = CompressedImageData::FORMAT_UNKNOWN;
+	PixelFormat texformat = PIXELFORMAT_UNKNOWN;
 	bool isSRGB = false;
 
 	uint8 *data = nullptr;
@@ -51,7 +51,7 @@ uint8 *DDSHandler::parse(filesystem::FileData *filedata, std::vector<CompressedI
 
 		texformat = convertFormat(parser.getFormat(), isSRGB);
 
-		if (texformat == CompressedImageData::FORMAT_UNKNOWN)
+		if (texformat == PIXELFORMAT_UNKNOWN)
 			throw love::Exception("Could not parse compressed data: Unsupported format.");
 
 		if (parser.getMipmapCount() == 0)
@@ -101,37 +101,37 @@ uint8 *DDSHandler::parse(filesystem::FileData *filedata, std::vector<CompressedI
 	return data;
 }
 
-CompressedImageData::Format DDSHandler::convertFormat(dds::Format ddsformat, bool &sRGB)
+PixelFormat DDSHandler::convertFormat(dds::Format ddsformat, bool &sRGB)
 {
 	sRGB = false;
 
 	switch (ddsformat)
 	{
 	case dds::FORMAT_DXT1:
-		return CompressedImageData::FORMAT_DXT1;
+		return PIXELFORMAT_DXT1;
 	case dds::FORMAT_DXT3:
-		return CompressedImageData::FORMAT_DXT3;
+		return PIXELFORMAT_DXT3;
 	case dds::FORMAT_DXT5:
-		return CompressedImageData::FORMAT_DXT5;
+		return PIXELFORMAT_DXT5;
 	case dds::FORMAT_BC4:
-		return CompressedImageData::FORMAT_BC4;
+		return PIXELFORMAT_BC4;
 	case dds::FORMAT_BC4s:
-		return CompressedImageData::FORMAT_BC4s;
+		return PIXELFORMAT_BC4s;
 	case dds::FORMAT_BC5:
-		return CompressedImageData::FORMAT_BC5;
+		return PIXELFORMAT_BC5;
 	case dds::FORMAT_BC5s:
-		return CompressedImageData::FORMAT_BC5s;
+		return PIXELFORMAT_BC5s;
 	case dds::FORMAT_BC6H:
-		return CompressedImageData::FORMAT_BC6H;
+		return PIXELFORMAT_BC6H;
 	case dds::FORMAT_BC6Hs:
-		return CompressedImageData::FORMAT_BC6Hs;
+		return PIXELFORMAT_BC6Hs;
 	case dds::FORMAT_BC7:
-		return CompressedImageData::FORMAT_BC7;
+		return PIXELFORMAT_BC7;
 	case dds::FORMAT_BC7srgb:
 		sRGB = true;
-		return CompressedImageData::FORMAT_BC7;
+		return PIXELFORMAT_BC7;
 	default:
-		return CompressedImageData::FORMAT_UNKNOWN;
+		return PIXELFORMAT_UNKNOWN;
 	}
 }
 

src/modules/image/magpie/ddsHandler.h

@@ -48,11 +48,11 @@ public:
 
 	// Implements CompressedFormatHandler.
 	virtual bool canParse(const filesystem::FileData *data);
-	virtual uint8 *parse(filesystem::FileData *filedata, std::vector<CompressedImageData::SubImage> &images, size_t &dataSize, CompressedImageData::Format &format, bool &sRGB);
+	virtual uint8 *parse(filesystem::FileData *filedata, std::vector<CompressedImageData::SubImage> &images, size_t &dataSize, PixelFormat &format, bool &sRGB);
 
 private:
 
-	static CompressedImageData::Format convertFormat(dds::Format ddsformat, bool &sRGB);
+	static PixelFormat convertFormat(dds::Format ddsformat, bool &sRGB);
 
 }; // DDSHandler