Fichiers
ui/src/proj3/font/ttf.hpp
T
2026-10-11 01:55:22 +02:00

182 lignes
6.8 KiB
C++

// font/ttf.hpp — parser TTF, porte depuis Gastinel Write (src/font/ttf.h).
//
// SOUS-ENSEMBLE STRICT, inchange par rapport a l original :
// head : unitsPerEm, indexToLocFormat
// maxp : numGlyphs
// cmap : Unicode -> index de glyphe (formats 4 et 12 uniquement)
// loca : offsets dans glyf
// glyf : contours quadratiques (simples et composites)
// hmtx : advanceWidth / leftSideBearing (avec hhea)
//
// DETTE TECHNIQUE HERITEE, CONSERVEE TELLE QUELLE (cf. README) :
// pas de kern / GPOS -> aucun crenage
// pas de fpgm/prep/cvt -> aucun hinting, instructions ignorees
// pas de CFF / CFF2 -> les polices PostScript sont refusees
// pas de VORG / vmtx -> pas d ecriture verticale
// Ces choix sont volontaires et ne doivent pas etre "corriges" dans ce
// chantier.
//
// CE QUI CHANGE PAR RAPPORT A L ORIGINAL, et pourquoi :
// 1. std::vector / std::string ont disparu. Rien n alloue : l appelant
// fournit les arenes. Le garde-fou du chantier 3 tue le processus si une
// allocation cachee subsistait.
// 2. Le fichier n est plus copie. load() prend un tampon deja en memoire,
// dont l appelant garde la propriete et qui doit rester valide aussi
// longtemps que la police. L original copiait tout le fichier dans un
// vector ; ici c est l arene de l appelant qui le detient.
// 3. Les messages d erreur sont des chaines litterales, pas des std::string
// concatenees. On perd le nom du fichier dans le message ; l appelant l a.
// 4. La lecture de fichier n est plus dans cette classe (elle utilisait
// fopen). Elle est dans io/file.hpp, avec une implementation par cible.
//
// ENDIANNESS : le format TrueType est big-endian. Le parser lit octet par
// octet et reconstruit les valeurs a la main, exactement comme l original :
// il est donc insensible a l endianness de la machine. Ce point ne change pas
// entre x86 Windows et AArch64 Linux. (Ce n est PAS vrai de la composition
// vers le framebuffer : cf. render/compose.hpp.)
#pragma once
#include "proj3/base/math.hpp"
#include "proj3/base/types.hpp"
#include "proj3/mem/arena.hpp"
namespace proj3::font {
// Un point de contour, en unites de police.
// on_curve distingue les points d ancrage des points de controle quadratiques
// (TrueType n a pas de cubiques).
struct GlyphPoint {
f32 x = 0.0f;
f32 y = 0.0f;
bool on_curve = false;
};
// Bornes reprises de l original : n_points > 10000 y etait deja un refus.
// kMaxGlyphContours est nouveau — l original s appuyait sur la croissance du
// vector. 256 contours est deja bien au-dela de tout glyphe reel (le glyphe
// le plus charge d Inter en compte moins de 40).
inline constexpr u32 kMaxGlyphPoints = 10000;
inline constexpr u32 kMaxGlyphContours = 256;
inline constexpr int kMaxCompositeDepth = 5;
// Tampon de construction d un glyphe. Alloue UNE FOIS dans une arene, puis
// reutilise pour tous les glyphes. C est ce qui remplace la croissance des
// vector de l original.
struct GlyphBuilder {
GlyphPoint* points = nullptr;
u32* contour_end = nullptr; // indice de fin exclusif de chaque contour
// Tampon de drapeaux glyf. Il vit dans le builder et non sur la pile :
// 10000 octets de pile seraient deja discutables, et la pile d un
// processus sans libc n a pas de garde-page automatique.
u8* flags = nullptr;
u32 point_count = 0;
u32 contour_count = 0;
void init(mem::Arena& a) {
points = a.alloc_array<GlyphPoint>(kMaxGlyphPoints);
contour_end = a.alloc_array<u32>(kMaxGlyphContours);
flags = a.alloc_array<u8>(kMaxGlyphPoints);
reset();
}
void reset() {
point_count = 0;
contour_count = 0;
}
};
// Un glyphe decode. Les pointeurs visent le GlyphBuilder : la duree de vie
// d un Glyph est celle du prochain appel a load_glyph.
struct Glyph {
const GlyphPoint* points = nullptr;
const u32* contour_end = nullptr;
u32 point_count = 0;
u32 contour_count = 0;
f32 x_min = 0.0f, y_min = 0.0f, x_max = 0.0f, y_max = 0.0f;
f32 advance_width = 0.0f;
f32 left_side_bearing = 0.0f;
bool empty() const { return contour_count == 0; }
// Bornes du contour i dans points[].
u32 contour_begin(u32 i) const { return i == 0 ? 0u : contour_end[i - 1]; }
u32 contour_size(u32 i) const { return contour_end[i] - contour_begin(i); }
};
class TtfFont {
public:
// `data` doit rester valide tant que la police est utilisee : rien n est
// copie. `arena` sert a loca et cmap, alloues une fois pour toutes.
// En cas d echec, `error` recoit un litteral (jamais nullptr).
bool load(const u8* data, usize size, mem::Arena& arena, const char*& error);
u16 glyph_index_for_codepoint(u32 codepoint) const;
// Decode les contours d un glyphe dans `builder`. `out` pointe dedans.
bool load_glyph(u16 glyph_index, GlyphBuilder& builder, Glyph& out) const;
u16 units_per_em() const { return units_per_em_; }
i16 ascender() const { return ascender_; }
i16 descender() const { return descender_; }
i16 line_gap() const { return line_gap_; }
u16 num_glyphs() const { return num_glyphs_; }
u32 cmap_size() const { return cmap_count_; }
private:
struct TableRecord {
u32 offset = 0;
u32 length = 0;
bool present = false;
};
struct CmapEntry {
u32 codepoint;
u16 gid;
};
TableRecord find_table(const char tag[4]) const;
bool parse_head(const char*& error);
bool parse_maxp(const char*& error);
bool parse_hhea_hmtx(const char*& error);
bool parse_loca(mem::Arena& arena, const char*& error);
bool parse_cmap(mem::Arena& arena, const char*& error);
// Deux passes : compte puis remplit. `out` nul = passe de comptage.
u32 walk_cmap_format4(u32 off, CmapEntry* out, u32 cap) const;
u32 walk_cmap_format12(u32 off, CmapEntry* out, u32 cap) const;
bool append_simple_glyph(u32 start, GlyphBuilder& b) const;
bool append_composite_glyph(u32 start, u32 end, GlyphBuilder& b, int depth) const;
bool append_glyph(u16 gid, GlyphBuilder& b, int depth) const;
const u8* data_ = nullptr;
usize size_ = 0;
// Repertoire de tables : tableau fixe. 64 tables est deja plus du double
// de ce qu une police reelle expose.
static constexpr u32 kMaxTables = 64;
char table_tag_[kMaxTables][4] = {};
TableRecord table_rec_[kMaxTables] = {};
u32 table_count_ = 0;
u16 units_per_em_ = 1000;
i16 index_to_loc_format_ = 0;
u16 num_glyphs_ = 0;
u16 num_h_metrics_ = 0;
i16 ascender_ = 0;
i16 descender_ = 0;
i16 line_gap_ = 0;
u32 glyf_offset_ = 0;
u32 glyf_length_ = 0;
u32 hmtx_offset_ = 0;
u32* loca_ = nullptr; // num_glyphs + 1 offsets absolus
u32 loca_count_ = 0;
CmapEntry* cmap_ = nullptr;
u32 cmap_count_ = 0;
};
} // namespace proj3::font