182 lignes
6.8 KiB
C++
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
|