fontana

Fontana

Toolkit pour les polices OpenType / TrueType; rendu de texte en général

---

TLDR:

• En développement, mais fonctionnel
• TTF / OTF Chargement + dessin
• Wrapper sur plusieurs backends
  • Construit sur mesure (y compris rasterizer)
  • Freetype
  • Freetype et Harfbuzz
• Destiné à être utilisé avec l'API graphique de bas niveau (Vulkan, webgpu, etc.)
• Platra plus tard dans un nouveau format de police simplifié destiné à des projets qui ont le luxe d'incorporer les polices (jeux, systèmes d'exploitation, etc.)

Portée

• Définition d'un nouveau format de police conçu principalement pour une utilisation intégrée
• Convertisseur à partir du format TTF / OTF -> Embedded
• Emballage facile à utiliser autour de Freetype / HarfBuzz pour le dessin
• Backend de chargement / rendu personnalisé

API et utilisation

Remarque : Cela ne fait référence que aux capacités de chargement / dessin TTF / OTF. Le format de police personnalisé est toujours un TODO. Voir la feuille de route pour l'état du projet

Actuellement, l'API est très simple mais offre beaucoup de flexibilité grâce à la configuration de comptime.

La première étape consiste à créer le type de police, qui prend une option de configuration de comptime. Les options sont: fontana , freetype et freetype_harfbuzz . Dans l'exemple ci-dessous, nous utilisons le backend fontana construit sur mesure:

 const font_backend: fontana.Backend = .fontana;
const Font = fontana.Font(font_backend);

var font = try Font.initFromFile(allocator, font_path);
defer font.deinit(allocator);

Le type Font a 3 fonctions publiques, initFromFile() , deinit() et createPen() . Les deux premiers fonctionnent comme prévu, passons donc sur le type Pen .

Le type Pen résume un atlas, la taille de la police et la collection de points de code. Les points de code spécifiés seront convertis en glyphes et rasterisés en texture. Si vous travaillez sur une application qui rendra le texte à différentes tailles, vous pouvez générer plus Pens à partir de la même Font .

Remarque : L'atlas de police géré par un stylo peut partager la texture de support avec d'autres parties d'une application, il ne possède que les méta-données sur les glyphes rendus rendus où.

Voici la signature de la fonction:

 pub fn createPen (
    self : * @ This ( ) ,
    comptime PixelType : type ,
    allocator : std . mem . Allocator ,
    size : Size ,
    points_per_pixel : f64 ,
    codepoints : [ ] const u8 ,
    texture_size : u32 ,
    texture_pixels : [ * ] PixelType ,
) ! Pen

Poursuivant l'exemple ci-dessus, ici un Pen est créé à partir de notre police.

 const PixelType = graphics . RGBA ( f32 ) ;
const points_per_pixel = 100 ;
const font_size = fontana . Size { . point = 24 . 0 } ;
const pen = try font . createPen (
    PixelType ,
    allocator ,
    font_size ,
    points_per_pixel ,
    atlas_codepoints ,
    texture . dimensions . width ,
    texture . pixels ,
) ;

Remarque : L'atlas ne prend en charge que les textures carrées, d'où Texture_Size par opposition à Texture_dimensions

Remarque : Le PixelType est passé par le client et ses propriétés sont détectées automatiquement pendant la raspérisation. À moins que ce soit un type très irrégulier, cela devrait simplement fonctionner.

Le type Pen a un seul objectif, pour générer des quads de texture vers un tampon de sommet qui peut être utilisé par une API graphique pour dessiner du texte sur l'écran. Il n'a qu'une seule fonction publique:

 pub fn write (
    self : * @ This ( ) ,
    codepoints : [ ] const u8 ,
    placement : geometry . Coordinates2D ( f64 ) ,
    screen_scale : geometry . Scale2D ( f64 ) ,
    writer_interface : anytype ,
) !void

Le client spécifie le texte à rendre, où le rendre sur l'écran, la mise à l'échelle de l'écran et une interface comptime utilisée pour canaliser la sortie.

screen_scale convertit les pixels en système de coordonnées de l'API graphique, dans Vulkan, il peut être calculé comme suit:

 fn scaleFromScreenDimensions ( width : f64 , height : f64 ) Scale2D ( f64 ) {
    return . {
        . vertical = 2.0 / height ,
        . horizontal = 2.0 / width ,
    } ;
}

En effet, Vulkan utilise le système de coordonnées à droite NDC, passant de -1,0 à +1,0 (longueur totale de 2,0) sur l'axe x et y.

writer_interface est d'un type évalué par comptime et doit satisfaire l'interface suivante:

 pub fn write (
    self : * @ This ( ) ,
    screen_extent : fontana . geometry . Extent2D ( f32 ) ,
    texture_extent : fontana . geometry . Extent2D ( f32 ) ,
) !void

Tout cela est de cartographier les valeurs de texture aux emplacements de l'affichage de sortie, définis dans le système de coordonnées de l'API graphique sous-jacent.

Intégration

Ajoutez simplement src/fontana.zig en tant que nouveau package dans votre build.zig.

 const fontana_path = "your_project/deps/fontana" ;
exe . addPackage ( . {
    . name = "fontana" ,
    . source = . { . path = fontana_path ++ "/src/fontana.zig" } ,
} ) ;

Fontana est maintenue en synchronisation avec la dernière version en zig. Il a été testé pour la dernière fois avec la version 0.12.0-DEV.3180 .

Exemple

Un exemple en cours d'exécution peut être trouvé dans l'exemple d'exemples de Fontana du référentiel. Les actifs non essentiels, y compris une grande quantité de code, ne sont pas vérifiés dans le référentiel principal pour le garder minimal et convivial.

Pour voir l'exemple ci-dessus sous forme complète, voir ce fichier spécifiquement

Feuille de route

TODO: Ajouter la feuille de route

Licence

Mit