C++字体库开发之字体回退策略十六

2025-01-09

本文作者原创，首发在本博客；CSDN 上的同名文章已标注为转载并回链到本页：https://blog.csdn.net/qq_30220519/article/details/145042789

回退表

{
   “blocks”: [
       “UBLOCK_BASIC_LATIN”,
   ],
   “font”: {
       “family”: “Noto Sans SC”,
       “style”: [
           {
               “name”: “Thin”,
               “weight”: 250,
               “sha1”: “xxxxx”
           },
       ]
   }
}

语言块

blockTable.emplace("UBLOCK_BASIC_LATIN", UBLOCK_BASIC_LATIN);
			...
blockTable.emplace("UBLOCK_ARABIC", UBLOCK_ARABIC);
for (const auto& [key, value] : blockTable) {
	codeStrToUBlock.emplace(value, key);
}

数据定义

struct FontKey {
	std::string family;
	std::string style;
	std::string hash;
};
using FontKeys = std::vector<FontKey>;

// 回退Context
struct KnowHint {
	uint32_t codepoint;
	FontKey key;
	int weight;
	bool italic;
};

回退解析

1	std::unordered_map<std::string, FontKeys> uBlockStrToFontList;

回退策略

std::set<int> matchFontWeight(const std::string& style)
{
    static std::map<std::string, std::set<int>> fallbackStyleWeights {
        { "ExtraLight", { 100, 200, 250 } },
        { "Thin", { 100, 250 } },
        { "Light", { 300 } },
        { "Normal", { 350 } },
        { "Regular", { 400 } },
        { "Medium", { 500 } },
        { "SemiBold", { 600 } },
        { "Bold", { 700 } },
        { "ExtraBold", { 800 } },
        { "Black", { 900 } },
        { "Heavy", { 900 } },
        { "ExtraBlack", { 950 } },
    };

    for (const auto& iter : fallbackStyleWeights) {
        if (std::string::npos != style.find(iter.first))
            return iter.second;
    }
    return { 400 };
}

// 字重 和 斜体最近匹配
FontKey matchBestFontKey(const FontKeys& fontKey, const Hint& hint)
{
    FontKeys allBestKeys;
    uint32_t distance = 1000;
    for (const auto& key : fontKey) {
        auto fontWeights = matchFontWeight(key.style);
        for (const auto& weight : fontWeights) {
            auto newDistance = std::abs(weight - hint.fontWeight);
            if (0 == newDistance && !hint.isItalic)
                return key; // 字重完全吻合

            if (newDistance < distance) { // 字重越来越接近
                allBestKeys = { key };
                distance = newDistance;
            } else if (newDistance == distance) {
                allBestKeys.emplace_back(key);
            }
        }
    }

    if (allBestKeys.empty())
        return fontKey.front();	// 取最低字重
    else if (allBestKeys.size() == 1 || !hint.isItalic) // 单个 或 不是斜体
        return allBestKeys.front();
    else {
        for (const auto& bestKey : allBestKeys) { // 斜体
            if (std::string::npos != bestKey.style.find("Italic"))
                return bestKey;
        }
        return allBestKeys.front();
    }
}

// 获取回退
FontKey matchFallback(const KnowHint& hint)
{
    auto blockType = ublock_getCode(hint.codepoint);
    const auto& blockStr = codeStrToUBlock.at(blockType);
    auto findIter = uBlockStrToFontList.find(blockStr);
    if (findIter == uBlockStrToFontList.end())
        return FontKey(
            "Noto Sans", "Regular", "xxxxxxxx");

    if (!findIter->second.empty())
        return matchBestFontKey(findIter->second, hint);	// 匹配最佳

	// 打底最佳
    auto iter = m_options.find("UBLOCK_BASIC_LATIN");
    if (iter == m_options.end())
        return FontKey(
            "Noto Sans", "Regular", "xxxxx");
    return matchBestFontKey(iter->second, hint); 
}

使用示例

FontKey oldKey { "Inter", "Regular", "xxxx"};
auto weight = getFontWeight(oldKey);
auto italic = isItalic(oldKey);
Hint hint { codepoint, oldKey, weight, italic };
auto newKey = matchFallback(hint);