Added support for DXT1/3/5 and BC5/7 compressed textures via love.image.CompressedData. Some internals are still iffy.

- added a new CompressedData type to love.image
- added love.image.isCompressed(file or data)
- love.graphics.newImage automatically tests for compression when loading a file
- added love.graphics.isSupported strings for DXT, BC5, and BC7

Compressed textures meant to be used on the GPU offer huge performance gains when
- loading the texture from a file
- loading the texture from RAM to VRAM
- loading mipmaps
- rendering

--HG--
branch : image-CompressedData

src/modules/graphics/Graphics.cpp

@@ -163,6 +163,9 @@ StringMap<Graphics::Support, Graphics::SUPPORT_MAX_ENUM>::Entry Graphics::suppor
 	{ "npot", Graphics::SUPPORT_NPOT },
 	{ "subtractive", Graphics::SUPPORT_SUBTRACTIVE },
 	{ "mipmap", Graphics::SUPPORT_MIPMAP },
+	{ "dxt", Graphics::SUPPORT_DXT },
+	{ "bc5", Graphics::SUPPORT_BC5 },
+	{ "bc7", Graphics::SUPPORT_BC7 },
 };
 
 StringMap<Graphics::Support, Graphics::SUPPORT_MAX_ENUM> Graphics::support(Graphics::supportEntries, sizeof(Graphics::supportEntries));

src/modules/graphics/Graphics.h

@@ -92,6 +92,9 @@ public:
 		SUPPORT_NPOT,
 		SUPPORT_SUBTRACTIVE,
 		SUPPORT_MIPMAP,
+		SUPPORT_DXT,
+		SUPPORT_BC5,
+		SUPPORT_BC7,
 		SUPPORT_MAX_ENUM
 	};
 

src/modules/graphics/opengl/Graphics.cpp

@@ -373,6 +373,29 @@ Image *Graphics::newImage(love::image::ImageData *data)
 	return image;
 }
 
+Image *Graphics::newImage(love::image::CompressedData *cdata)
+{
+	// Create the image.
+	Image *image = new Image(cdata);
+	bool success;
+	try
+	{
+		success = image->load();
+	}
+	catch(love::Exception &)
+	{
+		image->release();
+		throw;
+	}
+	if (!success)
+	{
+		image->release();
+		return 0;
+	}
+
+	return image;
+}
+
 Quad *Graphics::newQuad(float x, float y, float w, float h, float sw, float sh)
 {
 	Quad::Viewport v;

src/modules/graphics/opengl/Graphics.h

@@ -251,8 +251,8 @@ public:
 	/**
 	 * Creates an Image object with padding and/or optimization.
 	 **/
-	Image *newImage(love::filesystem::File *file);
 	Image *newImage(love::image::ImageData *data);
+	Image *newImage(love::image::CompressedData *cdata);
 
 	/**
 	 * Creates a Quad object.

src/modules/graphics/opengl/Image.cpp

@@ -39,43 +39,39 @@ Image::FilterMode Image::defaultMipmapFilter = Image::FILTER_NONE;
 float Image::defaultMipmapSharpness = 0.0f;
 
 Image::Image(love::image::ImageData *data)
-	: width((float)(data->getWidth()))
+	: cdata(0)
+	, width((float)(data->getWidth()))
 	, height((float)(data->getHeight()))
 	, texture(0)
 	, mipmapSharpness(defaultMipmapSharpness)
 	, mipmapsCreated(false)
+	, isCompressed(false)
 {
 	data->retain();
 	this->data = data;
+	preload();
+}
 
-	memset(vertices, 255, sizeof(vertex)*4);
-
-	vertices[0].x = 0;
-	vertices[0].y = 0;
-	vertices[1].x = 0;
-	vertices[1].y = height;
-	vertices[2].x = width;
-	vertices[2].y = height;
-	vertices[3].x = width;
-	vertices[3].y = 0;
-
-	vertices[0].s = 0;
-	vertices[0].t = 0;
-	vertices[1].s = 0;
-	vertices[1].t = 1;
-	vertices[2].s = 1;
-	vertices[2].t = 1;
-	vertices[3].s = 1;
-	vertices[3].t = 0;
-
-	filter = getDefaultFilter();
-	filter.mipmap = defaultMipmapFilter;
+Image::Image(love::image::CompressedData *cdata)
+	: data(0)
+	, width((float)(cdata->getWidth(0)))
+	, height((float)(cdata->getHeight(0)))
+	, texture(0)
+	, mipmapSharpness(defaultMipmapSharpness)
+	, mipmapsCreated(false)
+	, isCompressed(true)
+{
+	cdata->retain();
+	this->cdata = cdata;
+	preload();
 }
 
 Image::~Image()
 {
 	if (data != 0)
 		data->release();
+	if (cdata != 0)
+		cdata->release();
 	unload();
 }
 
@@ -155,18 +151,46 @@ void Image::checkMipmapsCreated()
 	if (mipmapsCreated || (filter.mipmap != FILTER_NEAREST && filter.mipmap != FILTER_LINEAR))
 		return;
 
-	if (!hasMipmapSupport())
+	if (!(isCompressed && cdata) && !hasMipmapSupport())
 		throw love::Exception("Mipmap filtering is not supported on this system.");
 
 	// Some old drivers claim support for NPOT textures, but fail when creating mipmaps.
 	// we can't detect which systems will do this, so we fail gracefully for all NPOT images.
 	int w = int(width), h = int(height);
-	if (w != next_p2(w) || h != next_p2(h))
+	if (!isCompressed && (w != next_p2(w) || h != next_p2(h)))
 		throw love::Exception("Cannot create mipmaps: image does not have power of two dimensions.");
 
 	bind();
 
-	if (hasNpot() && (GLEE_VERSION_3_0 || GLEE_ARB_framebuffer_object))
+	if (isCompressed && cdata && hasCompressedTextureSupport(cdata->getType()))
+	{
+		int numMipmaps = cdata->getNumMipmaps();
+
+		// We have to inform OpenGL if the image doesn't have all mipmap levels.
+		if (GLEE_VERSION_1_2 || GLEE_SGIS_texture_lod)
+			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, numMipmaps - 1);
+		else if (cdata->getWidth(numMipmaps-1) > 1 || cdata->getHeight(numMipmaps-1) > 1)
+		{
+			// Telling OpenGL to ignore certain levels isn't always supported.
+			throw love::Exception("Cannot load mipmaps: "
+								  "compressed image does not have all required levels.");
+		}
+
+		GLenum format = getCompressedFormat(cdata->getType());
+
+		for (int i = 1; i < numMipmaps; i++)
+		{
+			glCompressedTexImage2DARB(GL_TEXTURE_2D,
+			                          i,
+			                          format,
+			                          cdata->getWidth(i),
+			                          cdata->getHeight(i),
+			                          0,
+			                          GLsizei(cdata->getSize(i)),
+			                          cdata->getData(i));
+		}
+	}
+	else if (data && hasNpot() && (GLEE_VERSION_3_0 || GLEE_ARB_framebuffer_object))
 	{
 		// AMD/ATI drivers have several bugs when generating mipmaps,
 		// re-uploading the entire base image seems to be required.
@@ -184,7 +208,7 @@ void Image::checkMipmapsCreated()
 		glEnable(GL_TEXTURE_2D);
 		glGenerateMipmap(GL_TEXTURE_2D);
 	}
-	else
+	else if (data)
 	{
 		glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
 		glTexSubImage2D(GL_TEXTURE_2D,
@@ -197,6 +221,8 @@ void Image::checkMipmapsCreated()
 		                GL_UNSIGNED_BYTE,
 		                data->getData());
 	}
+	else
+		return;
 
 	mipmapsCreated = true;
 }
@@ -255,6 +281,32 @@ void Image::bind() const
 	bindTexture(texture);
 }
 
+void Image::preload()
+{
+	memset(vertices, 255, sizeof(vertex)*4);
+
+	vertices[0].x = 0;
+	vertices[0].y = 0;
+	vertices[1].x = 0;
+	vertices[1].y = height;
+	vertices[2].x = width;
+	vertices[2].y = height;
+	vertices[3].x = width;
+	vertices[3].y = 0;
+
+	vertices[0].s = 0;
+	vertices[0].t = 0;
+	vertices[1].s = 0;
+	vertices[1].t = 1;
+	vertices[2].s = 1;
+	vertices[2].t = 1;
+	vertices[3].s = 1;
+	vertices[3].t = 0;
+
+	filter = getDefaultFilter();
+	filter.mipmap = defaultMipmapFilter;
+}
+
 bool Image::load()
 {
 	return loadVolatile();
@@ -267,6 +319,18 @@ void Image::unload()
 
 bool Image::loadVolatile()
 {
+	if (isCompressed && cdata && !hasCompressedTextureSupport(cdata->getType()))
+	{
+		const char *str;
+		if (image::CompressedData::getConstant(cdata->getType(), str))
+		{
+			throw love::Exception("Cannot create image: "
+								  "%s compressed images are not supported on this system.", str);
+		}
+		else
+			throw love::Exception("cannot create image: format is not supported on this system.");
+	}
+
 	if (hasMipmapSharpnessSupport() && maxMipmapSharpness == 0.0f)
 		glGetFloatv(GL_MAX_TEXTURE_LOD_BIAS, &maxMipmapSharpness);
 
@@ -296,25 +360,47 @@ bool Image::loadVolatilePOT()
 
 	while (glGetError() != GL_NO_ERROR); // clear errors
 
-	glTexImage2D(GL_TEXTURE_2D,
-	             0,
-	             GL_RGBA8,
-	             (GLsizei)p2width,
-	             (GLsizei)p2height,
-	             0,
-	             GL_RGBA,
-	             GL_UNSIGNED_BYTE,
-	             0);
+	if (isCompressed && cdata)
+	{
+		if (s != 1.0f || t != 1.0f)
+		{
+			throw love::Exception("Cannot create image: "
+								  "NPOT compressed images are not supported on this system.");
+		}
 
-	glTexSubImage2D(GL_TEXTURE_2D,
-	                0,
-	                0,
-	                0,
-	                (GLsizei)width,
-	                (GLsizei)height,
-	                GL_RGBA,
-	                GL_UNSIGNED_BYTE,
-	                data->getData());
+		GLenum format = getCompressedFormat(cdata->getType());
+
+		glCompressedTexImage2DARB(GL_TEXTURE_2D,
+		                          0,
+		                          format,
+		                          cdata->getWidth(0),
+		                          cdata->getHeight(0),
+		                          0,
+		                          GLsizei(cdata->getSize(0)),
+		                          cdata->getData(0));
+	}
+	else if (data)
+	{
+		glTexImage2D(GL_TEXTURE_2D,
+		             0,
+		             GL_RGBA8,
+		             (GLsizei)p2width,
+		             (GLsizei)p2height,
+		             0,
+		             GL_RGBA,
+		             GL_UNSIGNED_BYTE,
+		             0);
+
+		glTexSubImage2D(GL_TEXTURE_2D,
+		                0,
+		                0,
+		                0,
+		                (GLsizei)width,
+		                (GLsizei)height,
+		                GL_RGBA,
+		                GL_UNSIGNED_BYTE,
+		                data->getData());
+	}
 
 	if (glGetError() != GL_NO_ERROR)
 		throw love::Exception("Cannot create image: size may be too large for this system.");
@@ -337,15 +423,30 @@ bool Image::loadVolatileNPOT()
 
 	while (glGetError() != GL_NO_ERROR); // clear errors
 
-	glTexImage2D(GL_TEXTURE_2D,
-	             0,
-	             GL_RGBA8,
-	             (GLsizei)width,
-	             (GLsizei)height,
-	             0,
-	             GL_RGBA,
-	             GL_UNSIGNED_BYTE,
-	             data->getData());
+	if (isCompressed && cdata)
+	{
+		GLenum format = getCompressedFormat(cdata->getType());
+		glCompressedTexImage2DARB(GL_TEXTURE_2D,
+		                          0,
+		                          format,
+		                          cdata->getWidth(0),
+		                          cdata->getHeight(0),
+		                          0,
+		                          GLsizei(cdata->getSize(0)),
+		                          cdata->getData(0));
+	}
+	else if (data)
+	{
+		glTexImage2D(GL_TEXTURE_2D,
+		             0,
+		             GL_RGBA8,
+		             (GLsizei)width,
+		             (GLsizei)height,
+		             0,
+		             GL_RGBA,
+		             GL_UNSIGNED_BYTE,
+		             data->getData());
+	}
 
 	if (glGetError() != GL_NO_ERROR)
 		throw love::Exception("Cannot create image: size may be too large for this system.");
@@ -407,6 +508,29 @@ Image::FilterMode Image::getDefaultMipmapFilter()
 	return defaultMipmapFilter;
 }
 
+GLenum Image::getCompressedFormat(image::CompressedData::TextureType type) const
+{
+	switch (type)
+	{
+	case image::CompressedData::TYPE_DXT1:
+		return GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
+	case image::CompressedData::TYPE_DXT3:
+		return GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
+	case image::CompressedData::TYPE_DXT5:
+		return GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+	case image::CompressedData::TYPE_BC5s:
+		return GL_COMPRESSED_SIGNED_RG_RGTC2;
+	case image::CompressedData::TYPE_BC5u:
+		return GL_COMPRESSED_RG_RGTC2;
+	case image::CompressedData::TYPE_BC7:
+		return GL_COMPRESSED_RGBA_BPTC_UNORM_ARB;
+	case image::CompressedData::TYPE_BC7srgb:
+		return GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB;
+	default:
+		return GL_RGBA8;
+	}
+}
+
 bool Image::hasNpot()
 {
 	return GLEE_VERSION_2_0 || GLEE_ARB_texture_non_power_of_two;
@@ -427,6 +551,37 @@ bool Image::hasMipmapSharpnessSupport()
 	return GLEE_VERSION_1_4 || GLEE_EXT_texture_lod_bias;
 }
 
+bool Image::hasCompressedTextureSupport()
+{
+	return GLEE_VERSION_1_3 || GLEE_ARB_texture_compression;
+}
+
+bool Image::hasCompressedTextureSupport(image::CompressedData::TextureType type)
+{
+	if (!hasCompressedTextureSupport())
+		return false;
+
+	switch (type)
+	{
+	case image::CompressedData::TYPE_DXT1:
+	case image::CompressedData::TYPE_DXT3:
+	case image::CompressedData::TYPE_DXT5:
+		return GLEE_EXT_texture_compression_s3tc;
+
+	case image::CompressedData::TYPE_BC5s:
+	case image::CompressedData::TYPE_BC5u:
+		return (GLEE_VERSION_3_0 || GLEE_ARB_texture_compression_rgtc);
+
+	case image::CompressedData::TYPE_BC7:
+	case image::CompressedData::TYPE_BC7srgb:
+		return (GLEE_VERSION_4_2 || GLEE_ARB_texture_compression_bptc);
+
+	default:
+		return false;
+
+	}
+}
+
 } // opengl
 } // graphics
 } // love

src/modules/graphics/opengl/Image.h

@@ -26,6 +26,7 @@
 #include "common/math.h"
 #include "common/config.h"
 #include "image/ImageData.h"
+#include "image/CompressedData.h"
 #include "graphics/Image.h"
 
 // OpenGL
@@ -52,10 +53,17 @@ public:
 	 * Creates a new Image. Not that anything is ready to use
 	 * before load is called.
 	 *
-	 * @param file The file from which to load the image.
+	 * @param data The data from which to load the image.
 	 **/
 	Image(love::image::ImageData *data);
 
+	/**
+	 * Creates a new Image with compressed image data.
+	 *
+	 * @param cdata The compressed data from which to load the image.
+	 **/
+	Image(love::image::CompressedData *cdata);
+
 	/**
 	 * Destructor. Deletes the hardware texture and other resources.
 	 **/
@@ -126,6 +134,9 @@ public:
 	static bool hasMipmapSupport();
 	static bool hasMipmapSharpnessSupport();
 
+	static bool hasCompressedTextureSupport();
+	static bool hasCompressedTextureSupport(image::CompressedData::TextureType type);
+
 private:
 
 	void drawv(const Matrix &t, const vertex *v) const;
@@ -138,6 +149,9 @@ private:
 	// The ImageData from which the texture is created.
 	love::image::ImageData *data;
 
+	// Or the Compressed Image Data from which the texture is created.
+	love::image::CompressedData *cdata;
+
 	// Width and height of the hardware texture.
 	float width, height;
 
@@ -153,12 +167,16 @@ private:
 	// True if mipmaps have been created for this Image.
 	bool mipmapsCreated;
 
+	bool isCompressed;
+
 	// The image's filter mode
 	Image::Filter filter;
 
 	// The image's wrap mode
 	Image::Wrap wrap;
 
+	void preload();
+
 	bool loadVolatilePOT();
 	bool loadVolatileNPOT();
 
@@ -169,6 +187,8 @@ private:
 	static FilterMode defaultMipmapFilter;
 	static float defaultMipmapSharpness;
 
+	GLenum getCompressedFormat(image::CompressedData::TextureType type) const;
+
 }; // Image
 
 } // opengl

src/modules/graphics/opengl/OpenGL.cpp

@@ -97,6 +97,14 @@ void initializeContext()
 		glUnmapBufferARB = (GLEEPFNGLUNMAPBUFFERARBPROC) glUnmapBuffer;
 	}
 
+	// Same deal for compressed textures.
+	if (GLEE_VERSION_1_3 && !GLEE_ARB_texture_compression)
+	{
+		glCompressedTexImage2DARB = (GLEEPFNGLCOMPRESSEDTEXIMAGE2DARBPROC) glCompressedTexImage2D;
+		glCompressedTexSubImage2DARB = (GLEEPFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC) glCompressedTexSubImage2D;
+		glGetCompressedTexImageARB = (GLEEPFNGLGETCOMPRESSEDTEXIMAGEARBPROC) glGetCompressedTexImage;
+	}
+
 	if (GLEE_EXT_texture_filter_anisotropic)
 		glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &maxAnisotropy);
 	else

src/modules/graphics/opengl/wrap_Graphics.cpp

@@ -269,21 +269,45 @@ int w_setInvertedStencil(lua_State *L)
 
 int w_newImage(lua_State *L)
 {
+	love::image::ImageData *data = 0;
+	love::image::CompressedData *cdata = 0;
+
 	// Convert to File, if necessary.
 	if (lua_isstring(L, 1))
 		luax_convobj(L, 1, "filesystem", "newFile");
 
-	// Convert to ImageData, if necessary.
+	// Convert to ImageData/CompressedData, if necessary.
 	if (luax_istype(L, 1, FILESYSTEM_FILE_T))
-		luax_convobj(L, 1, "image", "newImageData");
+	{
+		// Determine whether to convert to ImageData or CompressedData.
+		luax_getfunction(L, "image", "isCompressed");
+		lua_pushvalue(L, 1);
+		lua_call(L, 1, 1);
 
-	love::image::ImageData *data = luax_checktype<love::image::ImageData>(L, 1, "ImageData", IMAGE_IMAGE_DATA_T);
+		bool compressed = luax_toboolean(L, -1);
+		lua_pop(L, 1);
+
+		if (compressed)
+			luax_convobj(L, 1, "image", "newCompressedData");
+		else
+			luax_convobj(L, 1, "image", "newImageData");
+	}
+
+	if (luax_istype(L, 1, IMAGE_COMPRESSED_DATA_T))
+		cdata = luax_checktype<love::image::CompressedData>(L, 1, "CompressedData", IMAGE_COMPRESSED_DATA_T);
+	else
+		data = luax_checktype<love::image::ImageData>(L, 1, "ImageData", IMAGE_IMAGE_DATA_T);
 
 	// Create the image.
 	Image *image = 0;
 	try
 	{
-		image = instance->newImage(data);
+		if (cdata)
+			image = instance->newImage(cdata);
+		else if (data)
+			image = instance->newImage(data);
+		else
+			throw love::Exception("Error creating image.");
 	}
 	catch(love::Exception &e)
 	{
@@ -1110,6 +1134,18 @@ int w_isSupported(lua_State *L)
 			if (!Image::hasMipmapSupport())
 				supported = false;
 			break;
+		case Graphics::SUPPORT_DXT:
+			if (!Image::hasCompressedTextureSupport(image::CompressedData::TYPE_DXT5))
+				supported = false;
+			break;
+		case Graphics::SUPPORT_BC5:
+			if (!Image::hasCompressedTextureSupport(image::CompressedData::TYPE_BC5u))
+				supported = false;
+			break;
+		case Graphics::SUPPORT_BC7:
+			if (!Image::hasCompressedTextureSupport(image::CompressedData::TYPE_BC7))
+				supported = false;
+			break;
 		default:
 			supported = false;
 		}

src/modules/image/CompressedData.cpp

@@ -0,0 +1,123 @@
+/**
+ * Copyright (c) 2006-2013 LOVE Development Team
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ **/
+
+#include "CompressedData.h"
+
+namespace love
+{
+namespace image
+{
+
+CompressedData::CompressedData()
+	: type(TYPE_MAX_ENUM)
+{
+	
+}
+
+CompressedData::~CompressedData()
+{
+	
+}
+
+int CompressedData::getSize() const
+{
+	size_t totalsize = sizeof(MipmapInfo) * dataMipmapInfo.size();
+
+	for (size_t i = 0; i < dataMipmapInfo.size(); i++)
+		totalsize += dataMipmapInfo[i].size;
+
+	return totalsize;
+}
+
+void *CompressedData::getData() const
+{
+	// ?
+	return (void *) &dataMipmapInfo[0].data[0];
+}
+
+int CompressedData::getNumMipmaps() const
+{
+	return dataMipmapInfo.size();
+}
+
+int CompressedData::getSize(int miplevel) const
+{
+	checkMipmapLevelExists(miplevel);
+
+	return dataMipmapInfo[miplevel].size;
+}
+
+void *CompressedData::getData(int miplevel) const
+{
+	checkMipmapLevelExists(miplevel);
+
+	return (void *) &dataMipmapInfo[miplevel].data[0];
+}
+
+int CompressedData::getWidth(int miplevel) const
+{
+	checkMipmapLevelExists(miplevel);
+
+	return dataMipmapInfo[miplevel].width;
+}
+
+int CompressedData::getHeight(int miplevel) const
+{
+	checkMipmapLevelExists(miplevel);
+
+	return dataMipmapInfo[miplevel].height;
+}
+
+CompressedData::TextureType CompressedData::getType() const
+{
+	return type;
+}
+
+void CompressedData::checkMipmapLevelExists(int miplevel) const
+{
+	if (miplevel < 0 || miplevel >= dataMipmapInfo.size())
+		throw love::Exception("Mipmap level %d does not exist", miplevel);
+}
+
+bool CompressedData::getConstant(const char *in, CompressedData::TextureType &out)
+{
+	return types.find(in, out);
+}
+
+bool CompressedData::getConstant(CompressedData::TextureType in, const char *&out)
+{
+	return types.find(in, out);
+}
+
+StringMap<CompressedData::TextureType, CompressedData::TYPE_MAX_ENUM>::Entry CompressedData::typeEntries[] =
+{
+	{"dxt1", CompressedData::TYPE_DXT1},
+	{"dxt3", CompressedData::TYPE_DXT3},
+	{"dxt5", CompressedData::TYPE_DXT5},
+	{"bc5s", CompressedData::TYPE_BC5s},
+	{"bc5u", CompressedData::TYPE_BC5u},
+	{"bc7", CompressedData::TYPE_BC7},
+	{"bc7srgb", CompressedData::TYPE_BC7srgb},
+};
+
+StringMap<CompressedData::TextureType, CompressedData::TYPE_MAX_ENUM> CompressedData::types(CompressedData::typeEntries, sizeof(CompressedData::typeEntries));
+
+} // image
+} // love

src/modules/image/CompressedData.h

@@ -0,0 +1,125 @@
+/**
+ * Copyright (c) 2006-2013 LOVE Development Team
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ **/
+
+#ifndef LOVE_IMAGE_COMPRESSED_DATA_H
+#define LOVE_IMAGE_COMPRESSED_DATA_H
+
+// LOVE
+#include "common/Data.h"
+#include "common/StringMap.h"
+#include "thread/threads.h"
+
+using love::thread::Mutex;
+
+// STL
+#include <vector>
+
+namespace love
+{
+namespace image
+{
+
+// 
+class CompressedData : public Data
+{
+public:
+
+	// 
+	enum TextureType
+	{
+		TYPE_DXT1,
+		TYPE_DXT3,
+		TYPE_DXT5,
+		TYPE_BC5s,
+		TYPE_BC5u,
+		TYPE_BC7,
+		TYPE_BC7srgb,
+		TYPE_MAX_ENUM
+	};
+
+	CompressedData();
+
+	virtual ~CompressedData();
+
+	// Implements Data.
+	virtual void *getData() const;
+	virtual int getSize() const;
+
+	/**
+	 * Gets the number of mipmaps in this CompressedData.
+	 * Includes the base image level.
+	 **/
+	int getNumMipmaps() const;
+
+	/**
+	 * Gets the size in bytes of the sub-image at the specified mipmap level.
+	 **/
+	int getSize(int miplevel) const;
+
+	/**
+	 * Gets the byte data of the sub-image at the specified mipmap level.
+	 **/
+	void *getData(int miplevel) const;
+
+	/**
+	 * Gets the width of the sub-image at the specified mipmap level.
+	 **/
+	int getWidth(int miplevel) const;
+
+	/**
+	 * Gets the height of the sub-image at the specified mipmap level.
+	 **/
+	int getHeight(int miplevel) const;
+
+	/**
+	 * Gets the type of the compressed data.
+	 **/
+	TextureType getType() const;
+
+	static bool getConstant(const char *in, TextureType &out);
+	static bool getConstant(TextureType in, const char *&out);
+
+protected:
+
+	struct MipmapInfo
+	{
+		size_t size;
+		int width, height;
+		std::vector<unsigned char> data;
+	};
+
+	TextureType type;
+
+	// Texture info for each mipmap level.
+	std::vector<MipmapInfo> dataMipmapInfo;
+
+	void checkMipmapLevelExists(int miplevel) const;
+
+private:
+
+	static StringMap<TextureType, TYPE_MAX_ENUM>::Entry typeEntries[];
+	static StringMap<TextureType, TYPE_MAX_ENUM> types;
+
+}; // CompressedData
+
+} // image
+} // love
+
+#endif // LOVE_IMAGE_COMPRESSED_DATA_H

src/modules/image/Image.h

@@ -26,6 +26,7 @@
 #include "common/Module.h"
 #include "filesystem/File.h"
 #include "ImageData.h"
+#include "CompressedData.h"
 
 namespace love
 {
@@ -77,6 +78,26 @@ public:
 	 **/
 	virtual ImageData *newImageData(int width, int height, void *data) = 0;
 
+	/**
+	 *
+	 **/
+	virtual CompressedData *newCompressedData(love::filesystem::File *file) = 0;
+
+	/**
+	 *
+	 **/
+	virtual CompressedData *newCompressedData(Data *data) = 0;
+
+	/**
+	 *
+	 **/
+	virtual bool isCompressed(love::filesystem::File *file) = 0;
+
+	/**
+	 *
+	 **/
+	virtual bool isCompressed(Data *data) = 0;
+
 }; // Image
 
 } // image

src/modules/image/ImageData.cpp

@@ -39,14 +39,19 @@ ImageData::~ImageData()
 	delete mutex;
 }
 
+int ImageData::getSize() const
+{
+	return getWidth()*getHeight()*sizeof(pixel);
+}
+
 void *ImageData::getData() const
 {
 	return data;
 }
 
-int ImageData::getSize() const
+bool ImageData::inside(int x, int y) const
 {
-	return getWidth()*getHeight()*sizeof(pixel);
+	return x >= 0 && x < getWidth() && y >= 0 && y < getHeight();
 }
 
 int ImageData::getWidth() const
@@ -59,11 +64,6 @@ int ImageData::getHeight() const
 	return height;
 }
 
-bool ImageData::inside(int x, int y) const
-{
-	return x >= 0 && x < getWidth() && y >= 0 && y < getHeight();
-}
-
 void ImageData::setPixel(int x, int y, pixel c)
 {
 	if (!inside(x, y))

src/modules/image/ImageData.h

@@ -45,22 +45,6 @@ struct pixel
  **/
 class ImageData : public Data
 {
-protected:
-
-	// The width of the image data.
-	int width;
-
-	// The height of the image data.
-	int height;
-
-	// The actual data.
-	unsigned char *data;
-
-	// We need to be thread-safe
-	// so we lock when we're accessing our
-	// data
-	Mutex *mutex;
-
 public:
 
 	enum Format
@@ -137,10 +121,27 @@ public:
 	virtual void encode(love::filesystem::File *f, Format format) = 0;
 
 	// Implements Data.
-	void *getData() const;
-	int getSize() const;
+	virtual void *getData() const;
+	virtual int getSize() const;
+
+protected:
+
+	// The width of the image data.
+	int width;
+
+	// The height of the image data.
+	int height;
+
+	// The actual data.
+	unsigned char *data;
+
+	// We need to be thread-safe
+	// so we lock when we're accessing our
+	// data
+	Mutex *mutex;
 
 private:
+
 	static StringMap<Format, FORMAT_MAX_ENUM>::Entry formatEntries[];
 	static StringMap<Format, FORMAT_MAX_ENUM> formats;
 

src/modules/image/devil/CompressedData.cpp

@@ -0,0 +1,133 @@
+/**
+ * Copyright (c) 2006-2013 LOVE Development Team
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ **/
+
+#include "CompressedData.h"
+
+namespace love
+{
+namespace image
+{
+namespace devil
+{
+
+CompressedData::CompressedData(Data *data)
+{
+	load(data);
+}
+
+CompressedData::CompressedData(love::filesystem::File *file)
+{
+	Data *data = file->read();
+	try
+	{
+		load(data);
+	}
+	catch (love::Exception &)
+	{
+		data->release();
+		throw;
+	}
+}
+
+CompressedData::~CompressedData()
+{
+	
+}
+
+bool CompressedData::convertFormat(dds::Format ddsformat)
+{
+	switch (ddsformat)
+	{
+	case dds::FORMAT_DXT1:
+		type = TYPE_DXT1;
+		break;
+	case dds::FORMAT_DXT3:
+		type = TYPE_DXT3;
+		break;
+	case dds::FORMAT_DXT5:
+		type = TYPE_DXT5;
+		break;
+	case dds::FORMAT_BC5s:
+		type = TYPE_BC5s;
+		break;
+	case dds::FORMAT_BC5u:
+		type = TYPE_BC5u;
+		break;
+	case dds::FORMAT_BC7:
+		type = TYPE_BC7;
+		break;
+	case dds::FORMAT_BC7srgb:
+		type = TYPE_BC7srgb;
+		break;
+	default:
+		return false;
+	}
+
+	return true;
+}
+
+void CompressedData::load(Data *data)
+{
+	if (!dds::Parser::isDDS(data->getData(), data->getSize()))
+		throw love::Exception("Could not decode compressed data (not a DDS file?)");
+
+	try
+	{
+		dds::Parser parser(data->getData(), data->getSize());
+
+		dds::Format format = parser.getFormat();
+
+		if (format == dds::FORMAT_UNKNOWN || !convertFormat(format))
+			throw love::Exception("Could not parse compressed data: Unsupported format.");
+
+		if (parser.getNumMipmaps() == 0)
+			throw love::Exception("Could not parse compressed data: No readable texture data.");
+
+		for (size_t i = 0; i < parser.getNumMipmaps(); i++)
+		{
+			const dds::Parser::Image *img = parser.getImageData(i);
+
+			MipmapInfo mip;
+
+			mip.width = img->width;
+			mip.height = img->height;
+			mip.size = img->dataSize;
+
+			mip.data.resize(mip.size);
+			memcpy(&mip.data[0], img->data, mip.size);
+
+			dataMipmapInfo.push_back(mip);
+		}
+		
+	}
+	catch (std::exception &e)
+	{
+		throw love::Exception(e.what());
+	}
+}
+
+bool CompressedData::isCompressed(const Data *data)
+{
+	return dds::Parser::isDDS(data->getData(), data->getSize());
+}
+
+} // devil
+} // image
+} // love

src/modules/image/devil/CompressedData.h

@@ -0,0 +1,60 @@
+/**
+ * Copyright (c) 2006-2013 LOVE Development Team
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ **/
+
+#ifndef LOVE_DEVIL_COMPRESSED_DATA_H
+#define LOVE_DEVIL_COMPRESSED_DATA_H
+
+// LOVE
+#include "filesystem/File.h"
+#include "image/CompressedData.h"
+
+// dds parser
+#include "ddsparse/ddsparse.h"
+
+namespace love
+{
+namespace image
+{
+namespace devil
+{
+
+class CompressedData : public love::image::CompressedData
+{
+public:
+
+	CompressedData(love::filesystem::File *file);
+	CompressedData(Data *data);
+
+	virtual ~CompressedData();
+
+	static bool isCompressed(const Data *data);
+
+private:
+
+	bool convertFormat(dds::Format ddsformat);
+	void load(Data *data);
+
+}; // CompressedData
+
+} // devil
+} // image
+} // love
+
+#endif // LOVE_DEVIL_COMPRESSED_DATA_H

src/modules/image/devil/Image.cpp

@@ -21,6 +21,7 @@
 #include "Image.h"
 
 #include "ImageData.h"
+#include "CompressedData.h"
 
 // DevIL
 #include <IL/il.h>
@@ -32,6 +33,11 @@ namespace image
 namespace devil
 {
 
+const std::string Image::compressedExts[] =
+{
+	".dds", ""
+};
+
 Image::Image()
 {
 	ilInit();
@@ -69,6 +75,47 @@ love::image::ImageData *Image::newImageData(int width, int height, void *data)
 	return new ImageData(width, height, data);
 }
 
+love::image::CompressedData *Image::newCompressedData(love::filesystem::File *file)
+{
+	return new CompressedData(file);
+}
+
+love::image::CompressedData *Image::newCompressedData(love::Data *data)
+{
+	return new CompressedData(data);
+}
+
+bool Image::isCompressed(love::filesystem::File *file)
+{
+	bool hasExt = false;
+
+	// Check whether the file has an extension known to contain compressed data.
+	const std::string &ext = file->getExtension();
+	for (int i = 0; !(compressedExts[i].empty()); i++)
+	{
+		if (compressedExts[i].compare(ext))
+		{
+			hasExt = true;
+			break;
+		}
+	}
+
+	if (!hasExt)
+		return false;
+
+	// Check whether the actual data is compressed.
+	Data *data = file->read();
+	bool compressed = CompressedData::isCompressed(data);
+	data->release();
+
+	return compressed;
+}
+
+bool Image::isCompressed(love::Data *data)
+{
+	return CompressedData::isCompressed(data);
+}
+
 } // devil
 } // image
 } // love

src/modules/image/devil/Image.h

@@ -24,6 +24,9 @@
 // LOVE
 #include "image/Image.h"
 
+// STL
+#include <string>
+
 namespace love
 {
 namespace image
@@ -46,6 +49,14 @@ public:
 	love::image::ImageData *newImageData(int width, int height);
 	love::image::ImageData *newImageData(int width, int height, void *data);
 
+	love::image::CompressedData *newCompressedData(love::filesystem::File *file);
+	love::image::CompressedData *newCompressedData(Data *data);
+
+	bool isCompressed(love::filesystem::File *file);
+	bool isCompressed(Data *data);
+
+	static const std::string compressedExts[];
+
 }; // Image
 
 } // devil

src/modules/image/wrap_CompressedData.cpp

@@ -0,0 +1,129 @@
+/**
+ * Copyright (c) 2006-2013 LOVE Development Team
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ **/
+
+#include "wrap_CompressedData.h"
+#include "common/wrap_Data.h"
+
+namespace love
+{
+namespace image
+{
+
+CompressedData *luax_checkcompresseddata(lua_State *L, int idx)
+{
+	return luax_checktype<CompressedData>(L, idx, "CompressedData", IMAGE_COMPRESSED_DATA_T);
+}
+
+int w_CompressedData_getWidth(lua_State *L)
+{
+	CompressedData *t = luax_checkcompresseddata(L, 1);
+	int miplevel = luaL_optinteger(L, 2, 1);
+	int width = 0;
+	try
+	{
+		width = t->getWidth(miplevel >= 1 ? miplevel - 1 : 0);
+	}
+	catch (love::Exception &e)
+	{
+		return luaL_error(L, "%s", e.what());
+	}
+	lua_pushinteger(L, width);
+	return 1;
+}
+
+int w_CompressedData_getHeight(lua_State *L)
+{
+	CompressedData *t = luax_checkcompresseddata(L, 1);
+	int miplevel = luaL_optinteger(L, 2, 1);
+	int height = 0;
+	try
+	{
+		height = t->getHeight(miplevel >= 1 ? miplevel - 1 : 0);
+	}
+	catch (love::Exception &e)
+	{
+		return luaL_error(L, "%s", e.what());
+	}
+	lua_pushinteger(L, height);
+	return 1;
+}
+
+int w_CompressedData_getDimensions(lua_State *L)
+{
+	CompressedData *t = luax_checkcompresseddata(L, 1);
+	int miplevel = luaL_optinteger(L, 2, 1);
+	int width = 0, height = 0;
+	try
+	{
+		width = t->getWidth(miplevel >= 1 ? miplevel - 1 : 0);
+		height = t->getHeight(miplevel >= 1 ? miplevel - 1 : 0);
+	}
+	catch (love::Exception &e)
+	{
+		return luaL_error(L, "%s", e.what());
+	}
+	lua_pushinteger(L, width);
+	lua_pushinteger(L, height);
+	return 2;
+}
+
+int w_CompressedData_getNumMipmaps(lua_State *L)
+{
+	CompressedData *t = luax_checkcompresseddata(L, 1);
+	lua_pushinteger(L, t->getNumMipmaps());
+	return 1;
+}
+
+int w_CompressedData_getType(lua_State *L)
+{
+	CompressedData *t = luax_checkcompresseddata(L, 1);
+
+	image::CompressedData::TextureType type = t->getType();
+	const char *str;
+
+	if (image::CompressedData::getConstant(type, str))
+		lua_pushstring(L, str);
+	else
+		lua_pushstring(L, "unknown");
+
+	return 1;
+}
+
+static const luaL_Reg functions[] =
+{
+	// Data
+	{ "getPointer", w_Data_getPointer },
+	{ "getSize", w_Data_getSize },
+
+	{ "getWidth", w_CompressedData_getWidth },
+	{ "getHeight", w_CompressedData_getHeight },
+	{ "getDimensions", w_CompressedData_getDimensions },
+	{ "getNumMipmaps", w_CompressedData_getNumMipmaps },
+	{ "getType", w_CompressedData_getType },
+	{ 0, 0 },
+};
+
+extern "C" int luaopen_compresseddata(lua_State *L)
+{
+	return luax_register_type(L, "CompressedData", functions);
+}
+
+} // image
+} // love

src/modules/image/wrap_CompressedData.h

@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) 2006-2013 LOVE Development Team
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ **/
+
+#ifndef LOVE_IMAGE_WRAP_COMRESSED_DATA_H
+#define LOVE_IMAGE_WRAP_COMRESSED_DATA_H
+
+// LOVE
+#include "common/runtime.h"
+#include "CompressedData.h"
+
+namespace love
+{
+namespace image
+{
+
+CompressedData *luax_checkcompresseddata(lua_State *L, int idx);
+int w_CompressedData_getWidth(lua_State *L);
+int w_CompressedData_getHeight(lua_State *L);
+int w_CompressedData_getDimensions(lua_State *L);
+int w_CompressedData_getNumMipmaps(lua_State *L);
+int w_CompressedData_getType(lua_State *L);
+extern "C" int luaopen_compresseddata(lua_State *L);
+
+} // image
+} // love
+
+#endif // LOVE_IMAGE_WRAP_COMRESSED_DATA_H

src/modules/image/wrap_Image.cpp

@@ -93,16 +93,98 @@ int w_newImageData(lua_State *L)
 	return 1;
 }
 
+int w_newCompressedData(lua_State *L)
+{
+	// Case 1: Data
+	if (luax_istype(L, 1, DATA_T))
+	{
+		Data *d = luax_checktype<Data>(L, 1, "Data", DATA_T);
+
+		CompressedData *t = 0;
+		try
+		{
+			t = instance->newCompressedData(d);
+		}
+		catch (love::Exception &e)
+		{
+			return luaL_error(L, "%s", e.what());
+		}
+		luax_newtype(L, "CompressedData", IMAGE_COMPRESSED_DATA_T, (void *) t);
+
+		return 1;
+	}
+
+	// Case 2: String/File.
+
+	// Convert to File, if necessary.
+	if (lua_isstring(L, 1))
+		luax_convobj(L, 1, "filesystem", "newFile");
+
+	love::filesystem::File *file = luax_checktype<love::filesystem::File>(L, 1, "File", FILESYSTEM_FILE_T);
+
+	CompressedData *t = 0;
+	try
+	{
+		t = instance->newCompressedData(file);
+	}
+	catch (love::Exception &e)
+	{
+		return luaL_error(L, "%s", e.what());
+	}
+	luax_newtype(L, "CompressedData", IMAGE_COMPRESSED_DATA_T, (void *) t);
+
+	return 1;
+}
+
+int w_isCompressed(lua_State *L)
+{
+	if (luax_istype(L, 1, DATA_T))
+	{
+		Data *d = luax_checktype<Data>(L, 1, "Data", DATA_T);
+		try
+		{
+			bool compressed = instance->isCompressed(d);
+			luax_pushboolean(L,	compressed);
+		}
+		catch (love::Exception &e)
+		{
+			return luaL_error(L, "%s", e.what());
+		}
+		return 1;
+	}
+
+	// Convert to File, if necessary.
+	if (lua_isstring(L, 1))
+		luax_convobj(L, 1, "filesystem", "newFile");
+
+	filesystem::File *file = luax_checktype<filesystem::File>(L, 1, "File", FILESYSTEM_FILE_T);
+
+	try
+	{
+		bool compressed = instance->isCompressed(file);
+		luax_pushboolean(L, compressed);
+	}
+	catch (love::Exception &e)
+	{
+		return luaL_error(L, "%s", e.what());
+	}
+
+	return 1;
+}
+
 // List of functions to wrap.
 static const luaL_Reg functions[] =
 {
 	{ "newImageData",  w_newImageData },
+	{ "newCompressedData", w_newCompressedData },
+	{ "isCompressed", w_isCompressed },
 	{ 0, 0 }
 };
 
 static const lua_CFunction types[] =
 {
 	luaopen_imagedata,
+	luaopen_compresseddata,
 	0
 };
 

src/modules/image/wrap_Image.h

@@ -24,14 +24,16 @@
 // LOVE
 #include "Image.h"
 #include "wrap_ImageData.h"
+#include "wrap_CompressedData.h"
 
 namespace love
 {
 namespace image
 {
 
-int w_getFormats(lua_State *L);
 int w_newImageData(lua_State *L);
+int w_newCompressedData(lua_State *L);
+int w_isCompressed(lua_State *L);
 extern "C" LOVE_EXPORT int luaopen_love_image(lua_State *L);
 
 } // image