示例#1
0
    static void ParseText(TextAsset import)
    {
        if (!import)
        {
            throw new UnityException(import.name + "is not a valid font-xml file");
        }

        currFont          = new BitmapFontInfo();
        currFont.info     = new Dictionary <string, string>();
        currFont.common   = new Dictionary <string, string>();
        currFont.page     = new Dictionary <string, string>();
        currFont.chars    = new Dictionary <string, string>();
        currFont.chardata = new List <Dictionary <string, string> >();

        string[] txt = import.text.Split('\n');
        for (int i = 0; i < txt.Length; i++)
        {
            string str = txt[i].Trim();
            if (string.IsNullOrEmpty(str))
            {
                continue;
            }

            string[] kvStrs = ParseKeyValue(str);
            string   key    = kvStrs[0];
            switch (key)
            {
            case "info":
                ParseLine(kvStrs, ref currFont.info);
                break;

            case "common":
                ParseLine(kvStrs, ref currFont.common);
                break;

            case "page":
                ParseLine(kvStrs, ref currFont.page);
                break;

            case "chars":
                ParseLine(kvStrs, ref currFont.chars);
                break;

            case "char":
                var info = new Dictionary <string, string>();
                ParseLine(kvStrs, ref info);
                currFont.chardata.Add(info);
                break;
            }
        }
    }
示例#2
0
        public void WriteBinaryInvalidCharset()
        {
            var bitmapFontInfo = new BitmapFontInfo
            {
                Charset = "This is not a valid charset."
            };

            using (var memoryStream = new MemoryStream())
            {
                using (var binaryWriter = new BinaryWriter(memoryStream, Encoding.UTF8, true))
                {
                    bitmapFontInfo.WriteBinary(binaryWriter);
                }
            }
        }
示例#3
0
        public void ReadBinaryWrongBlockSize()
        {
            using (var memoryStream = new MemoryStream())
            {
                using (var binaryWriter = new BinaryWriter(memoryStream, Encoding.UTF8, true))
                {
                    binaryWriter.Write(8);
                    binaryWriter.Write(2);
                    binaryWriter.Write(1);
                }

                memoryStream.Seek(0, SeekOrigin.Begin);

                using (var binaryReader = new BinaryReader(memoryStream, Encoding.UTF8, true))
                {
                    BitmapFontInfo.ReadBinary(binaryReader);
                }
            }
        }
        public void updateCache()
        {
            fonts = new List<BitmapFont>();
            fontInfo = new List<BitmapFontInfo>();

            foreach (KeyValuePair<string, BitmapFont> entry in _dictionary)
            {
                fonts.Add(entry.Value);

                int index = fontInfo.FindIndex(x => x.name == entry.Value.name);
                if (index == -1)
                {
                    BitmapFontInfo info = new BitmapFontInfo();
                    info.sizes = new List<int>();

                    info.name = entry.Value.name;
                    info.displayName = entry.Value.displayName;

                    fontInfo.Add(info);
                    index = fontInfo.FindIndex(x => x.name == entry.Value.name);
                }

                fontInfo[index].sizes.Add(entry.Value.size);
            }

            for (int i = 0; i < fontInfo.Count; ++i)
            {
                fontInfo[i].sizes.Sort();
            }

            if (fonts.Count > 0 && fontInfo.Count > 0) hasFonts = true;
        }