コード例 #1
0
    public void rebuildFontAtlas(TMPFont font)
    {
        var bakeData      = font.bakeData;
        var fullCharsPath = Path.Combine(Application.dataPath, charsPath);
        var charString    = File.ReadAllText(Path.Combine(fullCharsPath, bakeData.characterTextFile + ".txt"));

        TMPFontAssetBaker.Bake(bakeData.baseFont, false, bakeData.fontSize, bakeData.padding, fontAtlasPackingMode,
                               bakeData.atlasWidth, bakeData.atlasHeight, TMPro.EditorUtilities.FaceStyles.Normal, 2, TMPro.EditorUtilities.RenderModes.DistanceField16,
                               charString, Path.Combine(fontsPath, font.fontAsset.name + ".asset"),
                               bakeData.glyphOverrides);

        Debug.Log("Rebuilt atlas for " + font.idName);

        var missingCharData = GetMissingFontCharData(forceFont: font);

        foreach (var data in missingCharData)
        {
            Debug.LogWarning($"{data.font.fontAsset.name} is still missing {data.language.getFileName()} character(s)  " +
                             $"{data.missingChars}. Try expanding the atlas size, or maybe the characters are missing from the base font.");
        }

        if (!string.IsNullOrEmpty(bakeData.notes))
        {
            Debug.Log("Notes about " + font.idName + ":\n" + bakeData.notes);
        }
    }
コード例 #2
0
 public LanguageFontCharData(Language language, TMPFont font, string missingLetters)
 {
     this.language     = language;
     this.font         = font;
     this.missingChars = missingLetters;
 }
コード例 #3
0
    public List <LanguageFontCharData> GetMissingFontCharData(TMPFont forceFont = null, Language forceLanguage = null)
    {
        string fullLanguagesPath = Path.Combine(Application.dataPath, languagesPath);
        string fullCharsPath     = Path.Combine(Application.dataPath, charsPath);
        var    missingCharData   = new List <LanguageFontCharData>();

        foreach (var language in LanguagesData.instance.languages)
        {
            if (forceLanguage != null && forceLanguage != language)
            {
                continue;
            }

            var filePath = Path.Combine(fullLanguagesPath, language.getFileName());
            var fontDict = SerializedNestedStrings.deserialize(File.ReadAllText(filePath)).getSubData("meta.font").subData;
            foreach (var fontKVPair in fontDict)
            {
                if (LocalizationManager.parseFontCompabilityString(language, fontKVPair.Value.value))
                {
                    // Font is marked as compatible
                    var font = TMPFontsData.instance.fonts.FirstOrDefault(a => a.idName.Equals(fontKVPair.Key));

                    if (forceFont != null && forceFont != font)
                    {
                        continue;
                    }

                    if (font == null)
                    {
                        Debug.LogWarning(fontKVPair.Key + " is missing from TMP Fonts Data asset");
                        continue;
                    }
                    if (font.fontAsset == null)
                    {
                        Debug.LogWarning(fontKVPair.Key + " is missing associated TMPro font in TMP Fonts asset");
                        continue;
                    }

                    var charString = File.ReadAllText(Path.Combine(fullCharsPath, language.getFileName() + "Chars.txt"));
                    charString = string.Join("", charString.Distinct());
                    List <char> currentChars = charString.ToCharArray().ToList();
                    currentChars.Add('a');

                    // Check fonts AND fallbacks
                    var fallbackList = new List <TMP_FontAsset>();
                    fallbackList.Add(font.fontAsset);                           // Current language
                    fallbackList.AddRange(font.fontAsset.fallbackFontAssets);   // language's fallbacks
                    fallbackList.AddRange(TMP_Settings.fallbackFontAssets);     // Global fallbacks
                    fallbackList = fallbackList.Distinct().ToList();

                    foreach (var fontAsset in fallbackList)
                    {
                        var missingChars = new List <char>();
                        // NO idea why but the hasCharacters() function seems to just be true all the time, so also check for null/any

                        missingChars = currentChars.Where(a => !fontAsset.characterDictionary.ContainsKey((int)a)).ToList();

                        if (missingChars != null && missingChars.Any())
                        {
                            currentChars = missingChars;
                        }
                        else
                        {
                            currentChars = null;
                            break;
                        }
                    }
                    if (currentChars != null)
                    {
                        currentChars = currentChars.Except(ignoreChars.ToCharArray()).ToList();
                        if (currentChars.Any())
                        {
                            missingCharData.Add(new LanguageFontCharData(language, font, string.Join("", currentChars)));
                        }
                    }
                }
            }
        }
        return(missingCharData
               .OrderBy(a => a.font.fontAsset.name)
               .ThenBy(a => a.language.getLanguageID())
               .ToList());
    }