Advertisement
Guest User

BmFont XML Serializer for C#

a guest
Oct 4th, 2010
12,719
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 5.12 KB | None | 0 0
  1. // ---- AngelCode BmFont XML serializer ----------------------
  2. // ---- By DeadlyDan @ deadlydan@gmail.com -------------------
  3. // ---- There's no license restrictions, use as you will. ----
  4. // ---- Credits to http://www.angelcode.com/ -----------------
  5.  
  6. using System;
  7. using System.IO;
  8. using System.Xml.Serialization;
  9.  
  10. namespace BmFont
  11. {
  12.     [Serializable]
  13.     [XmlRoot ( "font" )]
  14.     public class FontFile
  15.     {
  16.         [XmlElement ( "info" )]
  17.         public FontInfo Info
  18.         {
  19.             get;
  20.             set;
  21.         }
  22.  
  23.         [XmlElement ( "common" )]
  24.         public FontCommon Common
  25.         {
  26.             get;
  27.             set;
  28.         }
  29.  
  30.         [XmlArray ( "pages" )]
  31.         [XmlArrayItem ( "page" )]
  32.         public List<FontPage> Pages
  33.         {
  34.             get;
  35.             set;
  36.         }
  37.  
  38.         [XmlArray ( "chars" )]
  39.         [XmlArrayItem ( "char" )]
  40.         public List<FontChar> Chars
  41.         {
  42.             get;
  43.             set;
  44.         }
  45.  
  46.         [XmlArray ( "kernings" )]
  47.         [XmlArrayItem ( "kerning" )]
  48.         public List<FontKerning> Kernings
  49.         {
  50.             get;
  51.             set;
  52.         }
  53.     }
  54.  
  55.     [Serializable]
  56.     public class FontInfo
  57.     {
  58.         [XmlAttribute ( "face" )]
  59.         public String Face
  60.         {
  61.             get;
  62.             set;
  63.         }
  64.  
  65.         [XmlAttribute ( "size" )]
  66.         public Int32 Size
  67.         {
  68.             get;
  69.             set;
  70.         }
  71.  
  72.         [XmlAttribute ( "bold" )]
  73.         public Int32 Bold
  74.         {
  75.             get;
  76.             set;
  77.         }
  78.  
  79.         [XmlAttribute ( "italic" )]
  80.         public Int32 Italic
  81.         {
  82.             get;
  83.             set;
  84.         }
  85.  
  86.         [XmlAttribute ( "charset" )]
  87.         public String CharSet
  88.         {
  89.             get;
  90.             set;
  91.         }
  92.  
  93.         [XmlAttribute ( "unicode" )]
  94.         public Int32 Unicode
  95.         {
  96.             get;
  97.             set;
  98.         }
  99.  
  100.         [XmlAttribute ( "stretchH" )]
  101.         public Int32 StretchHeight
  102.         {
  103.             get;
  104.             set;
  105.         }
  106.  
  107.         [XmlAttribute ( "smooth" )]
  108.         public Int32 Smooth
  109.         {
  110.             get;
  111.             set;
  112.         }
  113.  
  114.         [XmlAttribute ( "aa" )]
  115.         public Int32 SuperSampling
  116.         {
  117.             get;
  118.             set;
  119.         }
  120.  
  121.         private Rectangle _Padding;
  122.         [XmlAttribute ( "padding" )]
  123.         public String Padding
  124.         {
  125.             get
  126.             {
  127.                 return _Padding.X + "," + _Padding.Y + "," + _Padding.Width + "," + _Padding.Height;
  128.             }
  129.             set
  130.             {
  131.                 String[] padding = value.Split ( ',' );
  132.                 _Padding = new Rectangle ( Convert.ToInt32 ( padding[0] ), Convert.ToInt32 ( padding[1] ), Convert.ToInt32 ( padding[2] ), Convert.ToInt32 ( padding[3] ) );
  133.             }
  134.         }
  135.  
  136.         private Point _Spacing;
  137.         [XmlAttribute ( "spacing" )]
  138.         public String Spacing
  139.         {
  140.             get
  141.             {
  142.                 return _Spacing.X + "," + _Spacing.Y;
  143.             }
  144.             set
  145.             {
  146.                 String[] spacing = value.Split ( ',' );
  147.                 _Spacing = new Point ( Convert.ToInt32 ( spacing[0] ), Convert.ToInt32 ( spacing[1] ) );
  148.             }
  149.         }
  150.  
  151.         [XmlAttribute ( "outline" )]
  152.         public Int32 OutLine
  153.         {
  154.             get;
  155.             set;
  156.         }
  157.     }
  158.  
  159.     [Serializable]
  160.     public class FontCommon
  161.     {
  162.         [XmlAttribute ( "lineHeight" )]
  163.         public Int32 LineHeight
  164.         {
  165.             get;
  166.             set;
  167.         }
  168.  
  169.         [XmlAttribute ( "base" )]
  170.         public Int32 Base
  171.         {
  172.             get;
  173.             set;
  174.         }
  175.  
  176.         [XmlAttribute ( "scaleW" )]
  177.         public Int32 ScaleW
  178.         {
  179.             get;
  180.             set;
  181.         }
  182.  
  183.         [XmlAttribute ( "scaleH" )]
  184.         public Int32 ScaleH
  185.         {
  186.             get;
  187.             set;
  188.         }
  189.  
  190.         [XmlAttribute ( "pages" )]
  191.         public Int32 Pages
  192.         {
  193.             get;
  194.             set;
  195.         }
  196.  
  197.         [XmlAttribute ( "packed" )]
  198.         public Int32 Packed
  199.         {
  200.             get;
  201.             set;
  202.         }
  203.  
  204.         [XmlAttribute ( "alphaChnl" )]
  205.         public Int32 AlphaChannel
  206.         {
  207.             get;
  208.             set;
  209.         }
  210.  
  211.         [XmlAttribute ( "redChnl" )]
  212.         public Int32 RedChannel
  213.         {
  214.             get;
  215.             set;
  216.         }
  217.  
  218.         [XmlAttribute ( "greenChnl" )]
  219.         public Int32 GreenChannel
  220.         {
  221.             get;
  222.             set;
  223.         }
  224.  
  225.         [XmlAttribute ( "blueChnl" )]
  226.         public Int32 BlueChannel
  227.         {
  228.             get;
  229.             set;
  230.         }
  231.     }
  232.  
  233.     [Serializable]
  234.     public class FontPage
  235.     {
  236.         [XmlAttribute ( "id" )]
  237.         public Int32 ID
  238.         {
  239.             get;
  240.             set;
  241.         }
  242.  
  243.         [XmlAttribute ( "file" )]
  244.         public String File
  245.         {
  246.             get;
  247.             set;
  248.         }
  249.     }
  250.  
  251.     [Serializable]
  252.     public class FontChar
  253.     {
  254.         [XmlAttribute ( "id" )]
  255.         public Int32 ID
  256.         {
  257.             get;
  258.             set;
  259.         }
  260.  
  261.         [XmlAttribute ( "x" )]
  262.         public Int32 X
  263.         {
  264.             get;
  265.             set;
  266.         }
  267.  
  268.         [XmlAttribute ( "y" )]
  269.         public Int32 Y
  270.         {
  271.             get;
  272.             set;
  273.         }
  274.  
  275.         [XmlAttribute ( "width" )]
  276.         public Int32 Width
  277.         {
  278.             get;
  279.             set;
  280.         }
  281.  
  282.         [XmlAttribute ( "height" )]
  283.         public Int32 Height
  284.         {
  285.             get;
  286.             set;
  287.         }
  288.  
  289.         [XmlAttribute ( "xoffset" )]
  290.         public Int32 XOffset
  291.         {
  292.             get;
  293.             set;
  294.         }
  295.  
  296.         [XmlAttribute ( "yoffset" )]
  297.         public Int32 YOffset
  298.         {
  299.             get;
  300.             set;
  301.         }
  302.  
  303.         [XmlAttribute ( "xadvance" )]
  304.         public Int32 XAdvance
  305.         {
  306.             get;
  307.             set;
  308.         }
  309.  
  310.         [XmlAttribute ( "page" )]
  311.         public Int32 Page
  312.         {
  313.             get;
  314.             set;
  315.         }
  316.  
  317.         [XmlAttribute ( "chnl" )]
  318.         public Int32 Channel
  319.         {
  320.             get;
  321.             set;
  322.         }
  323.     }
  324.  
  325.     [Serializable]
  326.     public class FontKerning
  327.     {
  328.         [XmlAttribute ( "first" )]
  329.         public Int32 First
  330.         {
  331.             get;
  332.             set;
  333.         }
  334.  
  335.         [XmlAttribute ( "second" )]
  336.         public Int32 Second
  337.         {
  338.             get;
  339.             set;
  340.         }
  341.  
  342.         [XmlAttribute ( "amount" )]
  343.         public Int32 Amount
  344.         {
  345.             get;
  346.             set;
  347.         }
  348.     }
  349.  
  350.     public class FontLoader
  351.     {
  352.         public static FontFile Load ( String filename )
  353.         {
  354.             XmlSerializer deserializer = new XmlSerializer ( typeof ( FontFile ) );
  355.             TextReader textReader = new StreamReader ( filename );
  356.             FontFile file = ( FontFile ) deserializer.Deserialize ( textReader );
  357.             textReader.Close ( );
  358.             return file;
  359.         }
  360.     }
  361. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement