Support for all BMFont output file types in FlxBitmapFont

flixel/graphics/frames/FlxBitmapFont.hx

@@ -1,18 +1,20 @@
 package flixel.graphics.frames;
 
-import openfl.display.BitmapData;
-import openfl.geom.Point;
-import openfl.geom.Rectangle;
 import flixel.FlxG;
 import flixel.graphics.FlxGraphic;
 import flixel.graphics.frames.FlxFrame.FlxFrameAngle;
 import flixel.graphics.frames.FlxFramesCollection.FlxFrameCollectionType;
+import flixel.graphics.frames.bmfontutils.BMFontFileTypeHelper;
+import flixel.graphics.frames.bmfontutils.FlxBMFontParser;
 import flixel.math.FlxPoint;
 import flixel.math.FlxRect;
 import flixel.system.FlxAssets;
 import flixel.util.FlxColor;
-import openfl.Assets;
 import haxe.xml.Access;
+import openfl.Assets;
+import openfl.display.BitmapData;
+import openfl.geom.Point;
+import openfl.geom.Rectangle;
 
 using flixel.util.FlxUnicodeUtil;
 
@@ -161,7 +163,7 @@ class FlxBitmapFont extends FlxFramesCollection
 	 * @param   data    Font data.
 	 * @return  Generated bitmap font object.
 	 */
-	public static function fromAngelCode(source:FlxBitmapFontGraphicAsset, data:FlxAngelCodeXmlAsset):FlxBitmapFont
+	public static function fromAngelCode(source:FlxBitmapFontGraphicAsset, data:FlxAngelCodeAsset):FlxBitmapFont
 	{
 		var graphic:FlxGraphic = null;
 		var frame:FlxFrame = null;
@@ -183,79 +185,57 @@ class FlxBitmapFont extends FlxFramesCollection
 
 		font = new FlxBitmapFont(frame);
 
-		final fast = new Access(data.getXml().firstElement());
+		final angelCodeDataType = BMFontFileTypeHelper.guessType(data);
+		final fontInfo = switch angelCodeDataType
+		{
+			case TEXT(text):
+				FlxBMFontParser.fromText(text);
+			case XML(xml):
+				FlxBMFontParser.fromXml(xml);
+			case BINARY(bytes):
+				FlxBMFontParser.fromBinary(bytes);
+		};
 
 		// how much to move the cursor when going to the next line.
-		font.lineHeight = Std.parseInt(fast.node.common.att.lineHeight);
-		font.size = Std.parseInt(fast.node.info.att.size);
-		font.fontName = Std.string(fast.node.info.att.face);
-		font.bold = (Std.parseInt(fast.node.info.att.bold) != 0);
-		font.italic = (Std.parseInt(fast.node.info.att.italic) != 0);
+		font.lineHeight = fontInfo.common.lineHeight;
+		font.size = fontInfo.info.fontSize;
+		font.fontName = fontInfo.info.fontName;
+		font.bold = fontInfo.info.bold;
+		font.italic = fontInfo.info.italic;
 
 		var frame:FlxRect;
 		var frameHeight:Int;
 		var offset:FlxPoint;
-		var charStr:String;
-		var charCode:Int;
 		var xOffset:Int, yOffset:Int, xAdvance:Int;
 
-		var chars = fast.node.chars;
-
-		for (char in chars.nodes.char)
+		for (char in fontInfo.chars)
 		{
 			frame = FlxRect.get();
-			frame.x = Std.parseInt(char.att.x); // X position within the bitmap image file.
-			frame.y = Std.parseInt(char.att.y); // Y position within the bitmap image file.
-			frame.width = Std.parseInt(char.att.width); // Width of the character in the image file.
-			frameHeight = Std.parseInt(char.att.height);
+			frame.x = char.x; // X position within the bitmap image file.
+			frame.y = char.y; // Y position within the bitmap image file.
+			frame.width = char.width; // Width of the character in the image file.
+			frameHeight = char.height;
 			frame.height = frameHeight; // Height of the character in the image file.
 
 			// Number of pixels to move right before drawing this character.
-			xOffset = char.has.xoffset ? Std.parseInt(char.att.xoffset) : 0;
+			xOffset = char.xoffset;
 			//  Number of pixels to move down before drawing this character.
-			yOffset = char.has.yoffset ? Std.parseInt(char.att.yoffset) : 0;
+			yOffset = char.yoffset;
 			//  Number of pixels to jump right after drawing this character.
-			xAdvance = char.has.xadvance ? Std.parseInt(char.att.xadvance) : 0;
+			xAdvance = char.xadvance;
 
 			offset = FlxPoint.get(xOffset, yOffset);
 
 			font.minOffsetX = (font.minOffsetX < -xOffset) ? -xOffset : font.minOffsetX;
 
-			charCode = -1;
-			charStr = null;
-
-			if (char.has.letter) // The ASCII value of the character this line is describing. Helpful for debugging
+			if (char.id == null)
 			{
-				charStr = char.att.letter;
-			}
-			else if (char.has.id) // The character number in the ASCII table.
-			{
-				charCode = Std.parseInt(char.att.id);
-			}
-
-			if (charCode == -1 && charStr == null)
-			{
-				throw 'Invalid font xml data!';
-			}
-
-			if (charStr != null)
-			{
-				charStr = switch (charStr)
-				{
-					case "space": ' ';
-					case "&quot;": '"';
-					case "&amp;": '&';
-					case "&gt;": '>';
-					case "&lt;": '<';
-					default: charStr;
-				}
-
-				charCode = charStr.uCharCodeAt(0);
+				throw 'Invalid font data!';
 			}
 
-			font.addCharFrame(charCode, frame, offset, xAdvance);
+			font.addCharFrame(char.id, frame, offset, xAdvance);
 
-			if (charCode == SPACE_CODE)
+			if (char.id == SPACE_CODE)
 			{
 				font.spaceWidth = xAdvance;
 			}

flixel/graphics/frames/bmfontutils/BMFont.hx

@@ -0,0 +1,110 @@
+package flixel.graphics.frames.bmfontutils;
+
+typedef BMFontInfoBlock =
+{
+	public var fontSize:Null<Int>;
+	public var smooth:Bool;
+	public var unicode:Bool;
+	public var italic:Bool;
+	public var bold:Bool;
+	public var fixedHeight:Bool;
+	public var charSet:String;
+	public var stretchH:Null<Int>;
+	public var aa:Null<Int>;
+	public var paddingUp:Null<Int>;
+	public var paddingRight:Null<Int>;
+	public var paddingDown:Null<Int>;
+	public var paddingLeft:Null<Int>;
+	public var spacingHoriz:Null<Int>;
+	public var spacingVert:Null<Int>;
+	public var outline:Null<Int>;
+	public var fontName:String;
+};
+
+typedef BMFontCommonBlock =
+{
+	public var lineHeight:Null<Int>;
+	public var base:Null<Int>;
+	public var scaleW:Null<Int>;
+	public var scaleH:Null<Int>;
+	public var pages:Null<Int>;
+	public var isPacked:Bool;
+	public var alphaChnl:Null<Int>;
+	public var redChnl:Null<Int>;
+	public var greenChnl:Null<Int>;
+	public var blueChnl:Null<Int>;
+};
+
+typedef BMFontPageInfoBlock =
+{
+	public var id:Null<Int>;
+	public var file:String;
+};
+
+typedef BMFontCharBlock =
+{
+	public var id:Null<Int>;
+	public var x:Null<Int>;
+	public var y:Null<Int>;
+	public var width:Null<Int>;
+	public var height:Null<Int>;
+	public var xoffset:Null<Int>;
+	public var yoffset:Null<Int>;
+	public var xadvance:Null<Int>;
+	public var page:Null<Int>;
+	public var chnl:Null<Int>;
+};
+
+typedef BMFontKerningPair =
+{
+	public var first:Null<Int>;
+	public var second:Null<Int>;
+	public var amount:Null<Int>;
+};
+
+class BMFont
+{
+	public var info:BMFontInfoBlock;
+	public var common:BMFontCommonBlock;
+	public var pages:Array<BMFontPageInfoBlock>;
+	public var chars:Array<BMFontCharBlock>;
+	public var kerningPairs:Array<BMFontKerningPair>;
+
+	function new()
+	{
+		info = {
+			fontSize: null,
+			smooth: false,
+			unicode: false,
+			italic: false,
+			bold: false,
+			fixedHeight: false,
+			charSet: null,
+			stretchH: null,
+			aa: null,
+			paddingUp: null,
+			paddingRight: null,
+			paddingDown: null,
+			paddingLeft: null,
+			spacingHoriz: null,
+			spacingVert: null,
+			outline: null,
+			fontName: '',
+		};
+		common = {
+			lineHeight: null,
+			base: null,
+			scaleW: null,
+			scaleH: null,
+			pages: null,
+			isPacked: false,
+			alphaChnl: null,
+			redChnl: null,
+			greenChnl: null,
+			blueChnl: null,
+		};
+		pages = [];
+		chars = [];
+		kerningPairs = [];
+	}
+}

flixel/graphics/frames/bmfontutils/BMFontFileTypeHelper.hx

@@ -0,0 +1,102 @@
+package flixel.graphics.frames.bmfontutils;
+
+import flixel.system.FlxAssets.FlxAngelCodeAsset;
+import haxe.io.Bytes;
+import openfl.Assets;
+
+enum BMFontFileType
+{
+	TEXT(text:String);
+	XML(xml:Xml);
+	BINARY(bytes:Bytes);
+}
+
+class BMFontFileTypeHelper
+{
+	/**
+	 * A helper function that helps determine the type of BMFont descriptor from either the path or content of the file
+	 * @param data The file path or the file content
+	 * @return BMFontFileType
+	 */
+	public static function guessType(data:FlxAngelCodeAsset):BMFontFileType
+	{
+		if (data is Xml)
+		{
+			return XML(cast(data, Xml).firstElement());
+		}
+		else if (data is String)
+		{
+			var dataStr: String = cast data;
+			if (Assets.exists(dataStr))
+			{
+				// dataStr is a file path
+				var bytes = Assets.getBytes(dataStr);
+				if(bytes == null)
+				{
+					return detectFromText(Assets.getText(dataStr));
+				}
+				var fileType = detectFromBytes(bytes);
+				if (fileType == null)
+				{
+					return detectFromText(bytes.toString());
+				}
+				return detectFromBytes(bytes);
+			}
+			else
+			{
+				// dataStr is the content of a file as a string (can be xml or just plain text)
+				return detectFromText(dataStr);
+			}
+		}
+		else if (data is Bytes)
+		{
+			var bytes:Bytes = cast data;
+			var fileType = detectFromBytes(bytes);
+			if (fileType == null)
+			{
+				return detectFromText(bytes.toString());
+			}
+		}
+		return null;
+	}
+	static function safeParseXML(str:String)
+	{
+		// for js, Xml.parse throws if str is not valid XML but on desktop it just returns null
+		// This function will always return null if xml is invalid
+		try
+		{
+			var xml = Xml.parse(str);
+			return xml;
+		}
+		catch (e:Dynamic)
+		{
+			return null;
+		}
+	}
+
+	static function detectFromText(text:String):BMFontFileType
+	{
+		var xml = safeParseXML(text);
+		if (xml != null && xml.firstElement() != null)
+		{
+			return XML(xml.firstElement());
+		}
+		return TEXT(text);
+	}
+	static function detectFromBytes(bytes:Bytes):Null<BMFontFileType>
+	{
+		var expected = [66, 77, 70]; // 'B', 'M', 'F'
+		var isBinary = true;
+		for (i in 0...expected.length)
+		{
+			if (bytes.get(i) != expected[i])
+			{
+				isBinary = false;
+				break;
+			}
+		}
+		if (isBinary)
+			return BINARY(bytes);
+		return null;
+	}
+}