GeezerVison is showing github.com — solvespace/src/ttf.cpp at python · realthunder/solvespace

Expand file tree

ttf.cpp

Copy path

More file actions

Latest commit

History

330 lines (289 loc) · 11.4 KB

ttf.cpp

Copy path

File metadata and controls

330 lines (289 loc) · 11.4 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

//-----------------------------------------------------------------------------

// Routines to read a TrueType font as vector outlines, and generate them

// as entities, since they're always representable as either lines or

// quadratic Bezier curves.

//-----------------------------------------------------------------------------

#include <ft2build.h>

#include FT_FREETYPE_H

#include FT_OUTLINE_H

#include FT_ADVANCES_H

/* Yecch. Irritatingly, you need to do this nonsense to get the error string table,

since nobody thought to put this exact function into FreeType itsself. */

#undef __FTERRORS_H__

#define FT_ERRORDEF(e, v, s) { (e), (s) },

#define FT_ERROR_START_LIST

#define FT_ERROR_END_LIST { 0, NULL }

struct ft_error {

int err;

const char *str;

};

static const struct ft_error ft_errors[] = {

#include FT_ERRORS_H

};

extern "C" const char *ft_error_string(int err) {

const struct ft_error *e;

for(e = ft_errors; e->str; e++)

if(e->err == err)

return e->str;

return "Unknown error";

}

/* Okay, we're done with that. */

#undef FT_ERRORDEF

#undef FT_ERROR_START_LIST

#undef FT_ERROR_END_LIST

#include "solvespace.h"

//-----------------------------------------------------------------------------

// Get the list of available font filenames, and load the name for each of

// them. Only that, though, not the glyphs too.

//-----------------------------------------------------------------------------

TtfFontList::TtfFontList() {

FT_Init_FreeType(&fontLibrary);

}

TtfFontList::~TtfFontList() {

FT_Done_FreeType(fontLibrary);

}

void TtfFontList::LoadAll() {

if(loaded) return;

for(const std::string &font : GetFontFiles()) {

TtfFont tf = {};

tf.fontFile = font;

if(tf.LoadFromFile(fontLibrary))

l.Add(&tf);

}

// Sort fonts according to their actual name, not filename.

std::sort(&l.elem[0], &l.elem[l.n],

[](const TtfFont &a, const TtfFont &b) { return a.name < b.name; });

// Filter out fonts with the same family and style name. This is not

// strictly necessarily the exact same font, but it will almost always be.

TtfFont *it = std::unique(&l.elem[0], &l.elem[l.n],

[](const TtfFont &a, const TtfFont &b) { return a.name == b.name; });

l.RemoveLast(&l.elem[l.n] - it);

// TODO: identify fonts by their name and not filename, which may change

// between OSes.

loaded = true;

}

void TtfFontList::PlotString(const std::string &font, const std::string &str,

SBezierList *sbl, Vector origin, Vector u, Vector v)

{

LoadAll();

TtfFont *tf = std::find_if(&l.elem[0], &l.elem[l.n],

[&](const TtfFont &tf) { return tf.FontFileBaseName() == font; });

if(!str.empty() && tf != &l.elem[l.n]) {

if(tf->fontFace == NULL) {

tf->LoadFromFile(fontLibrary, /*nameOnly=*/false);

}

tf->PlotString(str, sbl, origin, u, v);

} else {

// No text or no font; so draw a big X for an error marker.

SBezier sb;

sb = SBezier::From(origin, origin.Plus(u).Plus(v));

sbl->l.Add(&sb);

sb = SBezier::From(origin.Plus(v), origin.Plus(u));

sbl->l.Add(&sb);

}

//-----------------------------------------------------------------------------

// Return the basename of our font filename; that's how the requests and

// entities that reference us will store it.

//-----------------------------------------------------------------------------

std::string TtfFont::FontFileBaseName() const {

std::string baseName = fontFile;

size_t pos = baseName.rfind(PATH_SEP);

if(pos != std::string::npos)

return baseName.erase(0, pos + 1);

return "";

}

//-----------------------------------------------------------------------------

// Load a TrueType font into memory. We care about the curves that define

// the letter shapes, and about the mappings that determine which glyph goes

// with which character.

//-----------------------------------------------------------------------------

bool TtfFont::LoadFromFile(FT_Library fontLibrary, bool nameOnly) {

FT_Open_Args args = {};

args.flags = FT_OPEN_PATHNAME;

args.pathname = &fontFile[0]; // FT_String is char* for historical reasons

// We don't use ssfopen() here to let freetype do its own memory management.

// This is OK because on Linux/OS X we just delegate to fopen and on Windows

// we only look into C:\Windows\Fonts, which has a known short path.

if(int fterr = FT_Open_Face(fontLibrary, &args, 0, &fontFace)) {

dbp("freetype: loading font from file '%s' failed: %s",

fontFile.c_str(), ft_error_string(fterr));

return false;

}

if(int fterr = FT_Select_Charmap(fontFace, FT_ENCODING_UNICODE)) {

dbp("freetype: loading unicode CMap for file '%s' failed: %s",

fontFile.c_str(), ft_error_string(fterr));

FT_Done_Face(fontFace);

fontFace = NULL;

return false;

}

name = std::string(fontFace->family_name) +

" (" + std::string(fontFace->style_name) + ")";

if(nameOnly) {

FT_Done_Face(fontFace);

fontFace = NULL;

return true;

}

// We always ask Freetype to give us a unit size character.

// It uses fixed point; put the unit size somewhere in the middle of the dynamic

// range of its 26.6 fixed point type, and adjust the factors so that the unit

// matches cap height.

FT_Size_RequestRec sizeRequest;

sizeRequest.type = FT_SIZE_REQUEST_TYPE_REAL_DIM;

sizeRequest.width = 1 << 16;

sizeRequest.height = 1 << 16;

sizeRequest.horiResolution = 128;

sizeRequest.vertResolution = 128;

if(int fterr = FT_Request_Size(fontFace, &sizeRequest)) {

dbp("freetype: cannot set character size: %s",

ft_error_string(fterr));

FT_Done_Face(fontFace);

fontFace = NULL;

return false;

}

char chr = 'A';

uint32_t gid = FT_Get_Char_Index(fontFace, 'A');

if (gid == 0) {

dbp("freetype: CID-to-GID mapping for CID 0x%04x failed: %s; using CID as GID",

chr, ft_error_string(gid));

gid = chr;

}

if(gid) {

if(int fterr = FT_Load_Glyph(fontFace, gid, FT_LOAD_NO_BITMAP | FT_LOAD_NO_HINTING)) {

dbp("freetype: cannot load glyph for GID 0x%04x: %s",

gid, ft_error_string(fterr));

FT_Done_Face(fontFace);

fontFace = NULL;

return false;

}

FT_BBox bbox;

FT_Outline_Get_CBox(&fontFace->glyph->outline, &bbox);

capHeight = (double)bbox.yMax;

}

return true;

}

typedef struct OutlineData {

Vector origin, u, v; // input parameters

SBezierList *beziers; // output bezier list

float factor; // ratio between freetype and solvespace coordinates

FT_Pos bx; // x offset of the current glyph

FT_Pos px, py; // current point

} OutlineData;

static Vector Transform(OutlineData *data, FT_Pos x, FT_Pos y) {

Vector r = data->origin;

r = r.Plus(data->u.ScaledBy((float)(data->bx + x) * data->factor));

r = r.Plus(data->v.ScaledBy((float)y * data->factor));

return r;

}

static int MoveTo(const FT_Vector *p, void *cc)

{

OutlineData *data = (OutlineData *) cc;

data->px = p->x;

data->py = p->y;

return 0;

}

static int LineTo(const FT_Vector *p, void *cc)

{

OutlineData *data = (OutlineData *) cc;

SBezier sb = SBezier::From(

Transform(data, data->px, data->py),

Transform(data, p->x, p->y));

data->beziers->l.Add(&sb);

data->px = p->x;

data->py = p->y;

return 0;

}

static int ConicTo(const FT_Vector *c, const FT_Vector *p, void *cc)

{

OutlineData *data = (OutlineData *) cc;

SBezier sb = SBezier::From(

Transform(data, data->px, data->py),

Transform(data, c->x, c->y),

Transform(data, p->x, p->y));

data->beziers->l.Add(&sb);

data->px = p->x;

data->py = p->y;

return 0;

}

static int CubicTo(const FT_Vector *c1, const FT_Vector *c2, const FT_Vector *p, void *cc)

{

OutlineData *data = (OutlineData *) cc;

SBezier sb = SBezier::From(

Transform(data, data->px, data->py),

Transform(data, c1->x, c1->y),

Transform(data, c2->x, c2->y),

Transform(data, p->x, p->y));

data->beziers->l.Add(&sb);

data->px = p->x;

data->py = p->y;

return 0;

}

void TtfFont::PlotString(const std::string &str,

SBezierList *sbl, Vector origin, Vector u, Vector v)

{

if(fontFace == NULL) oops();

FT_Outline_Funcs outlineFuncs;

outlineFuncs.move_to = MoveTo;

outlineFuncs.line_to = LineTo;

outlineFuncs.conic_to = ConicTo;

outlineFuncs.cubic_to = CubicTo;

outlineFuncs.shift = 0;

outlineFuncs.delta = 0;

FT_Pos dx = 0;

for(char32_t cid : ReadUTF8(str)) {

uint32_t gid = FT_Get_Char_Index(fontFace, cid);

if (gid == 0) {

dbp("freetype: CID-to-GID mapping for CID 0x%04x failed: %s; using CID as GID",

cid, ft_error_string(gid));

gid = cid;

}

* Stupid hacks:

* - if we want fake-bold, use FT_Outline_Embolden(). This actually looks

* quite good.

* - if we want fake-italic, apply a shear transform [1 s s 1 0 0] here using

* FT_Set_Transform. This looks decent at small font sizes and bad at larger

* ones, antialiasing mitigates this considerably though.

if(int fterr = FT_Load_Glyph(fontFace, gid, FT_LOAD_NO_BITMAP | FT_LOAD_NO_HINTING)) {

dbp("freetype: cannot load glyph for GID 0x%04x: %s",

gid, ft_error_string(fterr));

return;

}

/* A point that has x = xMin should be plotted at (dx0 + lsb); fix up

* our x-position so that the curve-generating code will put stuff

* at the right place.

* There's no point in getting the glyph BBox here - not only can it be

* needlessly slow sometimes, but because we're about to render a single glyph,

* what we want actually *is* the CBox.

* This is notwithstanding that this makes extremely little sense, this

* looks like a workaround for either mishandling the start glyph on a line,

* or as a really hacky pseudo-track-kerning (in which case it works better than

* one would expect! especially since most fonts don't set track kerning).

FT_BBox cbox;

FT_Outline_Get_CBox(&fontFace->glyph->outline, &cbox);

FT_Pos bx = dx - cbox.xMin;

// Yes, this is what FreeType calls left-side bearing.

// Then interchangeably uses that with "left-side bearing". Sigh.

bx += fontFace->glyph->metrics.horiBearingX;

OutlineData data = {};

data.origin = origin;

data.u = u;

data.v = v;

data.beziers = sbl;

data.factor = 1.0 / capHeight;

data.bx = bx;

if(int fterr = FT_Outline_Decompose(&fontFace->glyph->outline, &outlineFuncs, &data)) {

dbp("freetype: bezier decomposition failed (gid %d): %s",

gid, ft_error_string(fterr));

}

// And we're done, so advance our position by the requested advance

// width, plus the user-requested extra advance.

dx += fontFace->glyph->advance.x;

}