FreeType est une bibliothèque open source conçue pour le rendu de polices de caractères, offrant une solution efficace et flexible pour afficher du texte dans des applications.

Avant toute utilisation, il est recommandé de consulter la documentation officielle, notamment la section dédiée aux conventions des glyphes (Glyph Conventions), essentielle pour comprendre le fonctionnement interne.

Compilation

Se rendre sur le site de téléchargement de FreeType, puis télécharger la version souhaitée. L’auteur utilise ici la version 2.13.2. Après extraction, un dossier freetype-2.13.2 est créé.

Se positionner dans le répertoire freetype-2.13.2/builds/windows/vc2010, puis ouvrir le fichier freetype.sln avec Visual Studio. La compilation produira les fichiers binaires dans objs/x64/Release : freetype.dll et freetype.lib.

Utilisation

Liaison statique avec FreeType

Créer un nouveau projet C++ dans Visual Studio. Copier freetype.lib dans le dossier du projet. Dans les propriétés du projet, accéder à VC++ Directories > Include Directories, puis ajouter le chemin freetype-2.13.2/include. Pour une compilation en Debug, s’assurer que le fichier .lib correspond à la configuration Debug.

Ajouter la directive suivante dans le fichier principal :

#pragma comment(lib, "freetype.lib")

Inclure les en-têtes nécessaires :

#include <ft2build.h>
#include FT_FREETYPE_H

Une compilation sans erreur indique que la bibliothèque est correctement intégrée.

Préparation du rendu

Avant d'afficher un caractère, initialiser une instance de FT_Library via FT_Init_FreeType. Ensuite, charger une police en utilisant FT_New_Face, qui retourne un pointeur vers un objet FT_Face représentant la police.

Définir ensuite la taille du texte en pixels via FT_Set_Pixel_Sizes. Le paramètre 0 signifie que la largeur et la hauteur sont égales.

FT_Library library;
FT_Face face;

int error = FT_Init_FreeType(&library);
error = FT_New_Face(library, "simsun.ttc", 0, &face);
error = FT_Set_Pixel_Sizes(face, 0, 24); // Taille de 24px

Rendu d’un caractère

Spécifier l’encodage du caractère à afficher. Par défaut, FreeType utilise Unicode. Le caractère « 中 » a pour code Unicode 0x4E2D.

Obtenir l’index du glyphe associé via FT_Get_Char_Index :

unsigned int char_code = 0x4E2D;
FT_UInt glyph_index = FT_Get_Char_Index(face, char_code);

Charger le glyphe avec FT_Load_Glyph, en spécifiant des drapeaux de chargement (FT_LOAD_DEFAULT) :

int load_flags = FT_LOAD_DEFAULT;
int result = FT_Load_Glyph(face, glyph_index, load_flags);

Si le format du glyphe n’est pas bitmap (FT_GLYPH_FORMAT_BITMAP), le convertir en image bitmap via FT_Render_Glyph :

FT_Render_Mode render_mode = FT_RENDER_MODE_NORMAL;
result = FT_Render_Glyph(face->glyph, render_mode);

Le résultat final est accessible via face->glyph->bitmap, une structure contenant les données brutes du bitmap.

Affichage dans la console

Implémenter une fonction pour afficher le glyphe sous forme de texte ASCII :

void DisplayGlyph(FT_GlyphSlot slot)
{
    for (int y = 0; y < slot->bitmap.rows; ++y)
    {
        for (int x = 0; x < slot->bitmap.width; ++x)
            putchar(" .:ioVM@"[slot->bitmap.buffer[y * slot->bitmap.width + x] >> 5]);
        putchar('\n');
    }
}

Code complet

#include <iostream>
#include <ft2build.h>
#include FT_FREETYPE_H

#pragma comment(lib, "freetype.lib")

FT_Library library;
FT_Face face;

void DisplayGlyph(FT_GlyphSlot slot)
{
    for (int y = 0; y < slot->bitmap.rows; ++y)
    {
        for (int x = 0; x < slot->bitmap.width; ++x)
            putchar(" .:ioVM@"[slot->bitmap.buffer[y * slot->bitmap.width + x] >> 5]);
        putchar('\n');
    }
}

int main()
{
    int status = FT_Init_FreeType(&library);

    status = FT_New_Face(library, "simsun.ttc", 0, &face);
    status = FT_Set_Pixel_Sizes(face, 0, 24);

    unsigned int unicode_code = 0x4E2D;
    FT_UInt glyph_index = FT_Get_Char_Index(face, unicode_code);

    int load_flags = FT_LOAD_DEFAULT;
    status = FT_Load_Glyph(face, glyph_index, load_flags);

    FT_Render_Mode render_mode = FT_RENDER_MODE_NORMAL;
    status = FT_Render_Glyph(face->glyph, render_mode);

    DisplayGlyph(face->glyph);

    return 0;
}

Remarques complémentaires

• FT_Face est un pointeur vers une structure FT_FaceRec contenant toutes les informations globales d’une police, comme face->num_glyphs pour connaître le nombre total de glyphes disponibles.
• Cette méthode permet de gérer des polices TrueType, OpenType ou PostScript, tant qu’elles sont compatibles avec FreeType.

Références

• Documentation officielle FreeType : Chargement simple de glyphe
• Guide d’intégration de bibliothèques DLL sous Windows
• Tutoriel FreeType : Conversion de vecteurs en bitmap