Commits

Alex Szpakowski committed 5fb13ad

Added love.graphics.getCanvasFormats and love.graphics.getCompressedImageFormats, and removed love.graphics.hasCanvasFormat.

The two new functions return tables containing the names of all relevant formats as keys, and boolean values indicating whether the formats are supported.

  • Participants
  • Parent commits 585b998

Comments (0)

Files changed (7)

 
   * Added Shader:getExternVariable.
   * Added several new canvas texture formats.
-  * Added love.graphics.hasCanvasFormat.
-  * Added an optional duration argument to Joystick:setVibration.
+  * Added love.graphics.getCanvasFormats.
+  * Added love.graphics.getCompressedImageFormats.
+  * Added ParticleSystem:setQuads.
+  * Added SpriteBatch:flush.
+  * Added optional duration argument to Joystick:setVibration.
   * Added love.joystick.loadGamepadMappings and love.joystick.saveGamepadMappings.
   * Added Joint:setUserData and Joint:getUserData.
   * Added Body:getWorld.
   * Added love.window.getDisplayName.
 
+  * Deprecated SpriteBatch:bind and SpriteBatch:unbind.
+  * Deprecated all uses of the name 'FSAA'.
+
   * Fixed shader:getWarnings returning unnecessary information.
   * Fixed love.filesystem.setIdentity breaking in some situations when called multiple times.
   * Fixed a potential crash when Shader objects are garbage collected.
   * Fixed Image:refresh generating mipmaps multiple times if mipmap filtering is enabled.
   * Fixed Mesh:setDrawRange when the Mesh has a vertex map set.
   * Fixed internal detection of the 'position' and 'effect' shader functions.
+  * Fixed Texture memory leak when Meshes are garbage collected.
 
   * Renamed all cases of FSAA to MSAA. The FSAA names still exist for backward-compatibility.
 

File src/modules/graphics/Graphics.cpp

 	{ "mipmap", Graphics::SUPPORT_MIPMAP },
 	{ "dxt", Graphics::SUPPORT_DXT },
 	{ "bc5", Graphics::SUPPORT_BC5 },
-	{ "instancing", Graphics::SUPPORT_INSTANCING },
 	{ "srgb", Graphics::SUPPORT_SRGB },
 };
 

File src/modules/graphics/Graphics.h

 		SUPPORT_MIPMAP,
 		SUPPORT_DXT,
 		SUPPORT_BC5,
-		SUPPORT_INSTANCING,
 		SUPPORT_SRGB,
 		SUPPORT_MAX_ENUM
 	};

File src/modules/graphics/opengl/Graphics.cpp

 	return limit;
 }
 
+bool Graphics::isSupported(Support feature) const
+{
+	switch (feature)
+	{
+	case SUPPORT_CANVAS:
+		return Canvas::isSupported();
+	case SUPPORT_HDR_CANVAS:
+		return Canvas::isFormatSupported(Canvas::FORMAT_HDR);
+	case SUPPORT_MULTI_CANVAS:
+		return Canvas::isMultiCanvasSupported();
+	case SUPPORT_SHADER:
+		return Shader::isSupported();
+	case SUPPORT_NPOT:
+		return Image::hasNpot();
+	case SUPPORT_SUBTRACTIVE:
+		return (GLEE_VERSION_1_4 || GLEE_ARB_imaging) || (GLEE_EXT_blend_minmax && GLEE_EXT_blend_subtract);
+	case SUPPORT_MIPMAP:
+		return Image::hasMipmapSupport();
+	case SUPPORT_DXT:
+		return Image::hasCompressedTextureSupport(image::CompressedData::FORMAT_DXT5);
+	case SUPPORT_BC5:
+		return Image::hasCompressedTextureSupport(image::CompressedData::FORMAT_BC5);
+	case SUPPORT_SRGB:
+		// sRGB support for the screen is guaranteed if it's supported as a
+		// Canvas format.
+		return Canvas::isFormatSupported(Canvas::FORMAT_SRGB);
+	default:
+		return false;
+	}
+}
+
 void Graphics::push()
 {
 	if (userMatrices == matrixLimit)

File src/modules/graphics/opengl/Graphics.h

 	 **/
 	double getSystemLimit(SystemLimit limittype) const;
 
+	/**
+	 * Gets whether a graphics feature is supported on this system.
+	 **/
+	bool isSupported(Support feature) const;
+
 	void push();
 	void pop();
 	void rotate(float r);

File src/modules/graphics/opengl/wrap_Graphics.cpp

 int w_isSupported(lua_State *L)
 {
 	bool supported = true;
-	size_t len = lua_gettop(L);
-	Graphics::Support support;
-	for (unsigned int i = 1; i <= len; i++)
+
+	for (int i = 1; i <= lua_gettop(L); i++)
 	{
 		const char *str = luaL_checkstring(L, i);
-		if (!Graphics::getConstant(str, support))
+		Graphics::Support feature;
+		if (!Graphics::getConstant(str, feature))
 			return luaL_error(L, "Invalid graphics feature: %s", str);
 
-		switch (support)
+		if (!instance->isSupported(feature))
 		{
-		case Graphics::SUPPORT_CANVAS:
-			if (!Canvas::isSupported())
-				supported = false;
+			supported = false;
 			break;
-		case Graphics::SUPPORT_HDR_CANVAS:
-			if (!Canvas::isFormatSupported(Canvas::FORMAT_HDR))
-				supported = false;
-			break;
-		case Graphics::SUPPORT_MULTI_CANVAS:
-			if (!Canvas::isMultiCanvasSupported())
-				supported = false;
-			break;
-		case Graphics::SUPPORT_SHADER:
-			if (!Shader::isSupported())
-				supported = false;
-			break;
-		case Graphics::SUPPORT_NPOT:
-			if (!Image::hasNpot())
-				supported = false;
-			break;
-		case Graphics::SUPPORT_SUBTRACTIVE:
-			if (!((GLEE_VERSION_1_4 || GLEE_ARB_imaging) || (GLEE_EXT_blend_minmax && GLEE_EXT_blend_subtract)))
-				supported = false;
-			break;
-		case Graphics::SUPPORT_MIPMAP:
-			if (!Image::hasMipmapSupport())
-				supported = false;
-			break;
-		case Graphics::SUPPORT_DXT:
-			if (!Image::hasCompressedTextureSupport(image::CompressedData::FORMAT_DXT5))
-				supported = false;
-			break;
-		case Graphics::SUPPORT_BC5:
-			if (!Image::hasCompressedTextureSupport(image::CompressedData::FORMAT_BC5))
-				supported = false;
-			break;
-		case Graphics::SUPPORT_INSTANCING:
-			if (!GLEE_ARB_draw_instanced)
-				supported = false;
-			break;
-		case Graphics::SUPPORT_SRGB:
-			if (!Canvas::isFormatSupported(Canvas::FORMAT_SRGB))
-				supported = false;
-			break;
-		default:
-			supported = false;
 		}
-		if (!supported)
-			break;
 	}
-	lua_pushboolean(L, supported);
+
+	luax_pushboolean(L, supported);
 	return 1;
 }
 
-int w_hasCanvasFormat(lua_State *L)
+int w_getCanvasFormats(lua_State *L)
 {
-	const char *str = luaL_checkstring(L, 1);
-	Canvas::Format format;
+	lua_createtable(L, 0, (int) Canvas::FORMAT_MAX_ENUM);
 
-	if (!Canvas::getConstant(str, format))
-		return luaL_error(L, "Invalid canvas format: %s", str);
+	for (int i = 0; i < (int) Canvas::FORMAT_MAX_ENUM; i++)
+	{
+		Canvas::Format format = (Canvas::Format) i;
+		const char *name = nullptr;
 
-	luax_pushboolean(L, Canvas::isFormatSupported(format));
+		if (!Canvas::getConstant(format, name))
+			continue;
+
+		luax_pushboolean(L, Canvas::isFormatSupported(format));
+		lua_setfield(L, -2, name);
+	}
+
+	return 1;
+}
+
+int w_getCompressedImageFormats(lua_State *L)
+{
+	lua_createtable(L, 0, (int) image::CompressedData::FORMAT_MAX_ENUM);
+
+	for (int i = 0; i < (int) image::CompressedData::FORMAT_MAX_ENUM; i++)
+	{
+		image::CompressedData::Format format = (image::CompressedData::Format) i;
+		const char *name = nullptr;
+
+		if (format == image::CompressedData::FORMAT_UNKNOWN)
+			continue;
+
+		if (!image::CompressedData::getConstant(format, name))
+			continue;
+
+		luax_pushboolean(L, Image::hasCompressedTextureSupport(format));
+		lua_setfield(L, -2, name);
+	}
+
 	return 1;
 }
 
 	{ "getShader", w_getShader },
 
 	{ "isSupported", w_isSupported },
-	{ "hasCanvasFormat", w_hasCanvasFormat },
+	{ "getCanvasFormats", w_getCanvasFormats },
+	{ "getCompressedImageFormats", w_getCompressedImageFormats },
 	{ "getRendererInfo", w_getRendererInfo },
 	{ "getSystemLimit", w_getSystemLimit },
 

File src/modules/graphics/opengl/wrap_Graphics.h

 int w_setShader(lua_State *L);
 int w_getShader(lua_State *L);
 int w_isSupported(lua_State *L);
-int w_hasCanvasFormat(lua_State *L);
+int w_getCanvasFormats(lua_State *L);
+int w_getCompressedImageFormats(lua_State *L);
 int w_getRendererInfo(lua_State *L);
 int w_getSystemLimit(lua_State *L);
 int w_draw(lua_State *L);