C++字体库开发之freetype vs harfbuzz sfnt表，字体名称，可变轴八

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

freetype
sfnt表
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
FT_ULong tableCount = 0;
FT_Error error;

// When 'tag' is nullptr, returns number of tables in 'length'.
error = FT_Sfnt_Table_Info(face, 0, nullptr, &tableCount);
if (error)
    return false;

for (FT_ULong tableIndex = 0; tableIndex < tableCount; ++tableIndex) {
    FT_ULong tableTag;
    FT_ULong tableLength;
    error = FT_Sfnt_Table_Info(face, tableIndex, &tableTag, &tableLength);
    if (error)
        return false;
    FontInfo::Table table{(uint32_t)tableTag, (uint32_t)tableLength};
    m_fontInfo.tables.emplace_back(table);
}
字体名称
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
const FT_UInt numNames = FT_Get_Sfnt_Name_Count(face);
FT_SfntName   sfntName;
for (FT_UInt i = 0; i < numNames; ++i) {
    if (FT_Get_Sfnt_Name(face, i, &sfntName))
        continue;

    auto name = sfntNameTranscodeUnicode(sfntName);
    if (name.empty())
        continue;
    if (sfntName.name_id > TT_NAME_ID_VARIATIONS_PREFIX)
        continue;
    FontInfo::Encode encoding{sfntName.language_id, sfntName.platform_id, sfntName.encoding_id};
    FontInfo::Name   nameStu{name, encoding};
    m_fontInfo.nameTables.at(sfntName.name_id).emplace_back(nameStu);
}
可变轴
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

template <typename T>
T fixValue(T value)
{
    return static_cast<T>(value / 65536.f);
}

std::vector<FVariation> getFontVariations(FTLibrary library, FT_Face* face)
{
    bool            isMMType1 = false;
    FT_Multi_Master mmtype1;
    if (FT_Get_Multi_Master(face, &mmtype1) == 0) {
        isMMType1 = true;
    }

    if (!(face->face_flags & FT_FACE_FLAG_MULTIPLE_MASTERS))
        return {};

    FT_MM_Var *variations = nullptr;
    FT_Error   err        = FT_Get_MM_Var(face, &variations);
    if (err)
        printf("INFO: font %s claims to have variations, but none found.\n", face->family_name, {});

    std::vector<FVariation> axes;
    axes.reserve(variations->num_axis);

    for (FT_UInt i = 0; i < variations->num_axis; ++i) {
        FT_Var_Named_Style *namedStyle = nullptr;
        if (i < variations->num_namedstyles)
            namedStyle = &variations->namedstyle[i];
        const FT_Var_Axis &ftAxis = variations->axis[i];
        FVariation variation(ftAxis.tag);
        variation.name = ftAxis.name;
        variation.min  = fixValue(ftAxis.minimum);
        variation.def  = fixValue(ftAxis.def);
        variation.max  = fixValue(ftAxis.maximum);
        //        if (isMMType1)
        if (namedStyle) {
            variation.cur = fixValue(namedStyle->coords[i]);
            //                axes[i].def = ftAxis.minimum + (ftAxis.maximum - ftAxis.minimum) / 2;
        } else {
            variation.cur = variation.def;
        }

        // 隐藏
        FT_UInt flags;
        auto    error = FT_Get_Var_Axis_Flags(variations, i, &flags);
        if (!error && (FT_VAR_AXIS_FLAG_HIDDEN & flags))
            variation.setHidden(true);
        axes.emplace_back(variation);
    }
    FT_Done_MM_Var(library, variations);
    return axes;
}
    

FT_CharMap   *charMap = face->charmaps;
    std::set<int> encodingSet;

    for (int i = 0; i < face->num_charmaps; i++) {
        auto cur = charMap[i];
        if (encodingSet.count(cur->encoding))
            continue;
        encodingSet.insert(cur->encoding);
        FT_Select_Charmap(face, cur->encoding);
        unsigned short langID = FT_Get_CMap_Language_ID(cur);  // 0 - 表示失败，可用作默认

        auto             weight     = getWeight();
        auto             width      = getWidth();
        auto             slant      = getSlant();
        auto             variations = getFontVariations();
        FontInfo::Encode anEncode{langID, cur->platform_id, cur->encoding_id};
        FontInfo::Axes   axes{weight, width, slant, variations, anEncode};
        m_fontInfo.axes.emplace_back(axes);
    }
可变轴Instance

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202

const FT_Tag FontVarAxis::weightTag = FT_MAKE_TAG('w', 'g', 'h', 't');
const FT_Tag FontVarAxis::widthTag = FT_MAKE_TAG('w', 'd', 't', 'h');
const FT_Tag FontVarAxis::slantTag = FT_MAKE_TAG('s', 'l', 'n', 't');

std::map<uint32_t, std::string> buildNameTables()
{
    USE_FT_FACE(this, {});

    std::map<uint32_t, std::string> nameTables;
    const FT_UInt                   numNames = FT_Get_Sfnt_Name_Count(face);
    FT_SfntName                     sName;
    for (FT_UInt i = 0; i < numNames; ++i) {
        if (FT_Get_Sfnt_Name(face, i, &sName))
            continue;

        auto name = convertToUnicodeName(sName);
        if (name.empty())
            continue;
        nameTables.emplace(sName.name_id, name);
    }
    return nameTables;
}

FT_Face FontStyle::GetFace(const FontStyle::Variation& variation) const {
  FT_Face face = face_;

  FT_Multi_Master mmtype1;
  bool isMMType1 = (FT_Get_Multi_Master(face, &mmtype1) == 0);

  FT_Fixed coords[axes_->size()];
  FT_Long mmType1Coords[axes_->size()];
  for (size_t axisIndex = 0; axisIndex < axes_->size(); ++axisIndex) {
    const FontVarAxis* axis = axes_->at(axisIndex);
    double value = GetVariationValue(
        variation, axis->GetTag(), axis->GetDefaultValue());
    value = clamp(value, axis->GetMinValue(), axis->GetMaxValue());
    if (isMMType1) {
      mmType1Coords[axisIndex] = static_cast<FT_Long>(value + 0.5);
    } else {
      coords[axisIndex] = FTDoubleToFixed(value);
    }
  }
  if (isMMType1) {
    FT_Set_MM_Design_Coordinates(face, axes_->size(), mmType1Coords);
  } else {
    FT_Set_Var_Design_Coordinates(face, axes_->size(), coords);
  }

  return face;
}

const FT_Tag FontVarAxis::weightTag = FT_MAKE_TAG('w', 'g', 'h', 't');
const FT_Tag FontVarAxis::widthTag = FT_MAKE_TAG('w', 'd', 't', 'h');
const FT_Tag FontVarAxis::slantTag = FT_MAKE_TAG('s', 'l', 'n', 't');

std::vector<FontVarAxis*>* FontVarAxis::MakeAxes(FT_Face face,
                                                 const NameTable& names) {
  std::unique_ptr<std::vector<FontVarAxis*>> result(
      new std::vector<FontVarAxis*>());

  FT_MM_Var* mmvar = NULL;
  FT_Multi_Master mmtype1;
  bool isMMType1 = false;
  if (FT_HAS_MULTIPLE_MASTERS(face)) {
    if (FT_Get_MM_Var(face, &mmvar) != 0) {
      mmvar = NULL;
    }
    if (FT_Get_Multi_Master(face, &mmtype1) == 0) {
      isMMType1 = true;
    }
  }

  if (!mmvar) {
    return result.release();
  }

  result->reserve(mmvar->num_axis);
  if (isMMType1) {
    FT_UInt numAxes = mmtype1.num_axis;
    if (numAxes > 4) numAxes = 4;
    for (FT_UInt axisIndex = 0; axisIndex < numAxes; ++axisIndex) {
      const FT_MM_Axis& mmAxis = mmtype1.axis[axisIndex];
      FT_Tag axisTag = FT_MAKE_TAG('V', 'A', 'R', '0' + axisIndex);
      std::string name = std::string(mmAxis.name ? mmAxis.name : "");
      if (name.empty()) {
        continue;
      }
      const int32_t minValue = static_cast<int32_t>(mmAxis.minimum);
      const int32_t maxValue = static_cast<int32_t>(mmAxis.maximum);
      const int32_t defaultValue = minValue + (maxValue - minValue) / 2;
      FontVarAxis* axis = new FontVarAxis(axisTag, name, defaultValue,
                                          minValue, maxValue);
      result->push_back(axis);
    }
  } else {
    for (FT_UInt axisIndex = 0; axisIndex < mmvar->num_axis;
         ++axisIndex) {
      const FT_Var_Axis& ftAxis = mmvar->axis[axisIndex];
      std::string name = GetFontName(names, ftAxis.strid);
      if (name.empty() && ftAxis.name != NULL) {
        name.assign(ftAxis.name);
      }
      if (name.empty()) {
        continue;
      }
      FontVarAxis* axis = new FontVarAxis(ftAxis.tag, name,
                                          FTFixedToDouble(ftAxis.def),
                                          FTFixedToDouble(ftAxis.minimum),
                                          FTFixedToDouble(ftAxis.maximum));
      result->push_back(axis);
    }
  }

  return result.release();
}


static const FT_Tag weightTag = FT_MAKE_TAG('w', 'g', 'h', 't');
static const FT_Tag widthTag = FT_MAKE_TAG('w', 'd', 't', 'h');
static const FT_Tag slantTag = FT_MAKE_TAG('s', 'l', 'n', 't');

std::vector<FontStyle*> FontStyle::GetStyles(
    FT_Face face,
    const NameTable& names,
    const std::string& defaultSampleText) {
  std::vector<FontStyle*> result;
  const std::string& familyName = GetFontFamilyName(names);
  if (familyName.empty()) {
    return result;
  }

  FT_MM_Var* mmvar = NULL;
  FT_Multi_Master mmtype1;
  bool isMMType1 = false;
  if (FT_HAS_MULTIPLE_MASTERS(face)) {
    if (FT_Get_MM_Var(face, &mmvar) != 0) {
      mmvar = NULL;
    }
    if (FT_Get_Multi_Master(face, &mmtype1) == 0) {
      isMMType1 = true;
    }
  }

  bool hasNamedInstanceForDefault = false;
  if (mmvar && !isMMType1) {
    for (FT_UInt i = 0; i < mmvar->num_namedstyles; ++i) {
      const FT_Var_Named_Style& namedStyle = mmvar->namedstyle[i];
      const std::string& instanceName = GetFontName(names, namedStyle.strid);
      if (!instanceName.empty()) {
        FontStyle::Variation variation;
        bool isDefault = true;
        for (FT_UInt axisIndex = 0; axisIndex < mmvar->num_axis;
             ++axisIndex) {
          const FT_Var_Axis& ftAxis = mmvar->axis[axisIndex];
          variation[ftAxis.tag] =
              FTFixedToDouble(namedStyle.coords[axisIndex]);
          if (namedStyle.coords[axisIndex] != ftAxis.def) {
            isDefault = false;
          }
        }
        if (isDefault) {
          hasNamedInstanceForDefault = true;
        }
        std::vector<FontVarAxis*>* axes = FontVarAxis::MakeAxes(face, names);
        result.push_back(
            new FontStyle(face, names, instanceName, axes, variation,
                          defaultSampleText));
      }
    }
  }

  if (!hasNamedInstanceForDefault) {
    const std::string& styleName = GetFontStyleName(names);
    if (!styleName.empty()) {
      FontStyle::Variation variation;
      if (isMMType1) {
        FT_UInt numAxes = mmtype1.num_axis;
        if (numAxes > 4) numAxes = 4;
        for (FT_UInt axisIndex = 0; axisIndex < numAxes; ++axisIndex) {
          FT_Tag axisTag = FT_MAKE_TAG('V', 'A', 'R', '0' + axisIndex);
          const FT_MM_Axis& mmAxis = mmtype1.axis[axisIndex];
          const int32_t minValue = static_cast<int32_t>(mmAxis.minimum);
          const int32_t maxValue = static_cast<int32_t>(mmAxis.maximum);
          variation[axisTag] = minValue + (maxValue - minValue) / 2;
        }
      } else if (mmvar) {
        for (FT_UInt axisIndex = 0; axisIndex < mmvar->num_axis;
             ++axisIndex) {
          const FT_Var_Axis& axis = mmvar->axis[axisIndex];
          variation[axis.tag] = FTFixedToDouble(axis.def);
        }
      }
      std::vector<FontVarAxis*>* axes = FontVarAxis::MakeAxes(face, names);
      result.push_back(
         new FontStyle(face, names, styleName, axes, variation,
		       defaultSampleText));
    }
  }

  return result;
}
harfbuzz
sfnt表
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 文件中的所有表标签
unsigned int num_tags = 0;
hb_blob_t   *blob;

// 获取表标签的数量
num_tags = hb_face_get_table_tags(m_face, NULL, &num_tags, nullptr);
if (0 == num_tags)
    return false;
hb_tag_t *tags = new hb_tag_t[num_tags];
hb_face_get_table_tags(m_face, NULL, &num_tags, tags);
//    // 打印所有表标签
//    char buf[5] = {
//        0,
//    };
for (unsigned int i = 0; i < num_tags; i++) {
    blob = hb_face_reference_table(m_face, tags[i]);
    // 获取表的长度
    auto tabLen = hb_blob_get_length(blob);
    //        hb_tag_to_string(tags[i], buf);
    FontInfo::Table table{(uint32_t)tags[i], (uint32_t)tabLen};
    m_fontInfo.tables.emplace_back(table);
}
delete[] tags;
字体名称
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
const auto                             &allLanguages = FontLanguage::getAllLanguages();
std::map<unsigned short, hb_language_t> languages;
for (const auto &lang : allLanguages) {
    languages.emplace(lang.first, hb_language_from_string(lang.second.code.c_str(), lang.second.code.size()));
}

char buf[1024] = {
    0,
};
for (int i = HB_OT_NAME_ID_COPYRIGHT; i <= HB_OT_NAME_ID_VARIATIONS_PS_PREFIX; ++i) {
    for (const auto &lang : languages) {
        unsigned int size = 1024;
        if (hb_ot_name_get_utf8(m_face, i, lang.second, &size, buf) > 0) {
            FontInfo::Encode encoding{lang.first, 2, 0};
            FontInfo::Name   nameStu{buf, encoding};
            m_fontInfo.nameTables.at(i).emplace_back(nameStu);
        }
    }
}
可变轴
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
auto         font = hb_font_create(m_face);
 unsigned int length;
 const int   *coords = hb_font_get_var_coords_normalized(font, &length);
 if (!coords)
     return;
 auto denorm_coord = [](hb_ot_var_axis_info_t *axis, int coord) -> float {
     float r = coord / 16384.0;
     if (coord < 0)
         return axis->default_value + r * (axis->default_value - axis->min_value);
     else
         return axis->default_value + r * (axis->max_value - axis->default_value);
 };
 unsigned int           n_axes;
 hb_ot_var_axis_info_t *axes = new hb_ot_var_axis_info_t[length];
 FONTVIEW_CLASS(ShareData<hb_ot_var_axis_info_t>) axisInfo(axes, length);
 n_axes = length;
 hb_ot_var_get_axis_infos(m_face, 0, &n_axes, axes);

 auto weight = getWeight();
 auto width  = getWidth();
 auto slant  = getSlant();

 FontInfo::Encode anEncode{2057, 2, 0};
 for (unsigned int i = 0; i < length; ++i) {
     char         name[20];
     unsigned int namelen = 20;

     hb_ot_name_get_utf8(m_face, axes[i].name_id, hb_language_from_string("en", 2), &namelen, name);
     FontVariation fontVariation(FontVariation::toUInt32((const char *)name));
     fontVariation.cur = denorm_coord(&axes[i], coords[i]);
     fontVariation.min = axes[i].min_value;
     fontVariation.max = axes[i].max_value;
     fontVariation.def = axes[i].default_value;
     //        printf("    %s: %g (%g - %g, %g)\n",
     //               name,
     //               denorm_coord(&axes[i], coords[i]),
     //               axes[i].min_value,
     //               axes[i].max_value,
     //               axes[i].default_value);

     FontInfo::Axes axes{(size_t)weight, width, slant, {std::move(fontVariation)}, anEncode};
     m_fontInfo.axes.emplace_back(axes);
 }
 hb_font_destroy(font);
字体列表

[
    {
        “size”: “230688”,
        “sha1”: “ebb7d6f483de90805c4421f624bac1f20b4a1305”,
        “face”: [
            {
                “version”: “0.000”,
                “familys”: [
                    {
                        “familyName”: “Decovar Alpha Regular24”,
                        “language”: “en-US”,
                        “tr”: “英语(美国)”,
                        “encode”: “UTF-16BE”
                    }
                ],
                “styleNames”: [
                    {
                        “styleName”: “Regular”,
                        “language”: “en-US”,
                        “tr”: “英语(美国)”,
                        “encode”: “UTF-16BE”
                    }
                ],
                “preferredFamilyName”: {
                    “typoFamilyName”: “Decovar Alpha”,
                    “language”: “en-US”,
                    “tr”: “英语(美国)”,
                    “encode”: “UTF-16BE”
                },
                “preferredStyleName”: {
                    “typoStyleName”: “Regular24”,
                    “language”: “en-US”,
                    “tr”: “英语(美国)”,
                    “encode”: “UTF-16BE”
                },
                “fontStyles”: [
                    {
                        “width”: “100.000000”,
                        “weight”: “400”,
                        “slant”: “0.000000”,
                        “lineHeight”: “1.199707”,
                        “language”: “default”,
                        “tr”: “默认语言”,
                        “axes”: [
                            {
                                “tag”: “1112294465”,
                                “name”: “Inline”,
                                “min”: “0.000000”,
                                “max”: “1000.000000”,
                                “def”: “0.000000”,
                                “hidden”: 0
                            },
                            {
                                “tag”: “1414679876”,
                                “name”: “Shearded”,
                                “min”: “0.000000”,
                                “max”: “1000.000000”,
                                “def”: “0.000000”,
                                “hidden”: 0
                            },
                            {
                                “tag”: “1414679875”,
                                “name”: “Rounded Slab”,
                                “min”: “0.000000”,
                                “max”: “1000.000000”,
                                “def”: “0.000000”,
                                “hidden”: 0
                            },
                            {
                                “tag”: “1397443652”,
                                “name”: “Stripes”,
                                “min”: “0.000000”,
                                “max”: “1000.000000”,
                                “def”: “0.000000”,
                                “hidden”: 0
                            },
                            {
                                “tag”: “1414679884”,
                                “name”: “Worm Terminal”,
                                “min”: “0.000000”,
                                “max”: “1000.000000”,
                                “def”: “0.000000”,
                                “hidden”: 0
                            },
                            {
                                “tag”: “1397443649”,
                                “name”: “Inline Skeleton”,
                                “min”: “0.000000”,
                                “max”: “1000.000000”,
                                “def”: “0.000000”,
                                “hidden”: 0
                            },
                            {
                                “tag”: “1414679878”,
                                “name”: “Open Inline Terminal”,
                                “min”: “0.000000”,
                                “max”: “1000.000000”,
                                “def”: “0.000000”,
                                “hidden”: 0
                            },
                            {
                                “tag”: “1414679883”,
                                “name”: “Inline Terminal”,
                                “min”: “0.000000”,
                                “max”: “1000.000000”,
                                “def”: “0.000000”,
                                “hidden”: 0
                            },
                            {
                                “tag”: “1112294466”,
                                “name”: “Worm”,
                                “min”: “0.000000”,
                                “max”: “1000.000000”,
                                “def”: “0.000000”,
                                “hidden”: 0
                            },
                            {
                                “tag”: “1464686642”,
                                “name”: “Weight”,
                                “min”: “0.000000”,
                                “max”: “1000.000000”,
                                “def”: “0.000000”,
                                “hidden”: 0
                            },
                            {
                                “tag”: “1414679874”,
                                “name”: “Flared”,
                                “min”: “0.000000”,
                                “max”: “1000.000000”,
                                “def”: “0.000000”,
                                “hidden”: 0
                            },
                            {
                                “tag”: “1414679873”,
                                “name”: “Rounded”,
                                “min”: “0.000000”,
                                “max”: “1000.000000”,
                                “def”: “0.000000”,
                                “hidden”: 0
                            },
                            {
                                “tag”: “1397443650”,
                                “name”: “Worm Skeleton”,
                                “min”: “0.000000”,
                                “max”: “1000.000000”,
                                “def”: “0.000000”,
                                “hidden”: 0
                            },
                            {
                                “tag”: “1414679879”,
                                “name”: “Slab”,
                                “min”: “0.000000”,
                                “max”: “1000.000000”,
                                “def”: “0.000000”,
                                “hidden”: 0
                            },
                            {
                                “tag”: “1414679877”,
                                “name”: “Bifurcated”,
                                “min”: “0.000000”,
                                “max”: “1000.000000”,
                                “def”: “0.000000”,
                                “hidden”: 0
                            }
                        ],
                        “axesInstances”: {
                            “Bifurcated”: [
                                {
                                    “tag”: “1414679877”,
                                    “cur”: “1000.000000”
                                }
                            ],
                            “Checkered”: [
                                {
                                    “tag”: “1397443649”,
                                    “cur”: “1000.000000”
                                }
                            ],
                            “Checkered Reverse”: [
                                {
                                    “tag”: “1414679883”,
                                    “cur”: “1000.000000”
                                }
                            ],
                            “Contrast”: [
                                {
                                    “tag”: “1464686642”,
                                    “cur”: “1000.000000”
                                }
                            ],
                            “Default”: [],
                            “Fancy”: [
                                {
                                    “tag”: “1397443649”,
                                    “cur”: “1000.000000”
                                },
                                {
                                    “tag”: “1464686642”,
                                    “cur”: “1000.000000”
                                },
                                {
                                    “tag”: “1414679874”,
                                    “cur”: “1000.000000”
                                }
                            ],
                            “Flared”: [
                                {
                                    “tag”: “1414679874”,
                                    “cur”: “1000.000000”
                                }
                            ],
                            “Flared Open”: [
                                {
                                    “tag”: “1397443649”,
                                    “cur”: “1000.000000”
                                },
                                {
                                    “tag”: “1414679874”,
                                    “cur”: “1000.000000”
                                }
                            ],
                            “Inline”: [
                                {
                                    “tag”: “1397443649”,
                                    “cur”: “500.000000”
                                },
                                {
                                    “tag”: “1414679878”,
                                    “cur”: “500.000000”
                                }
                            ],
                            “Mayhem”: [
                                {
                                    “tag”: “1414679875”,
                                    “cur”: “750.000000”
                                },
                                {
                                    “tag”: “1414679884”,
                                    “cur”: “250.000000”
                                },
                                {
                                    “tag”: “1397443649”,
                                    “cur”: “1000.000000”
                                },
                                {
                                    “tag”: “1414679878”,
                                    “cur”: “250.000000”
                                },
                                {
                                    “tag”: “1414679883”,
                                    “cur”: “250.000000”
                                },
                                {
                                    “tag”: “1112294466”,
                                    “cur”: “1000.000000”
                                },
                                {
                                    “tag”: “1464686642”,
                                    “cur”: “750.000000”
                                },
                                {
                                    “tag”: “1414679874”,
                                    “cur”: “500.000000”
                                },
                                {
                                    “tag”: “1414679873”,
                                    “cur”: “500.000000”
                                },
                                {
                                    “tag”: “1397443650”,
                                    “cur”: “1000.000000”
                                },
                                {
                                    “tag”: “1414679879”,
                                    “cur”: “750.000000”
                                },
                                {
                                    “tag”: “1414679877”,
                                    “cur”: “500.000000”
                                }
                            ],
                            “Open”: [
                                {
                                    “tag”: “1112294465”,
                                    “cur”: “1000.000000”
                                }
                            ],
                            “Rounded”: [
                                {
                                    “tag”: “1414679873”,
                                    “cur”: “1000.000000”
                                }
                            ],
                            “Rounded Slab”: [
                                {
                                    “tag”: “1414679875”,
                                    “cur”: “1000.000000”
                                }
                            ],
                            “Sheared”: [
                                {
                                    “tag”: “1414679876”,
                                    “cur”: “1000.000000”
                                }
                            ],
                            “Slab”: [
                                {
                                    “tag”: “1414679879”,
                                    “cur”: “1000.000000”
                                }
                            ],
                            “Striped”: [
                                {
                                    “tag”: “1397443652”,
                                    “cur”: “500.000000”
                                }
                            ],
                            “Worm”: [
                                {
                                    “tag”: “1112294466”,
                                    “cur”: “1000.000000”
                                }
                            ]
                        }
                    }
                ],
                “fontFeatures”: [
                    “kern”
                ]
            }
        ]
    }
]

参考

C++字体库开发之字体列表设计七-CSDN博客

创作不易，小小的支持一下吧！

赏

谢谢你请我吃糖果

支付宝

扫一扫，分享到微信

微信分享二维码
× 文章目录
  1. 1. freetype
  2. 2. sfnt表
  3. 3. 字体名称
  4. 4. 可变轴
  5. 5. 可变轴Instance
  6. 6. harfbuzz
  7. 7. sfnt表
  8. 8. 字体名称
  9. 9. 可变轴
  10. 10. 字体列表
  11. 11. 参考
  • 创作不易，小小的支持一下吧！

    • tag:

      缺失模块。
      1、请确保node版本大于6.2
      2、在博客根目录（注意不是yilia根目录）执行以下命令：
      npm i hexo-generator-json-content --save

      3、在根目录_config.yml里添加配置： 

        jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

    很惭愧<br><br>只做了一点微小的工作<br>谢谢大家