mirror of
https://github.com/Nexoniarz/Fry3DX.git
synced 2026-11-03 04:24:26 +00:00
202 lines
8.2 KiB
C++
202 lines
8.2 KiB
C++
#include "text.h"
|
|
|
|
#define STBTT_STATIC
|
|
#define STB_TRUETYPE_IMPLEMENTATION
|
|
#include <stb_truetype.h>
|
|
|
|
#include <glm/gtc/matrix_transform.hpp>
|
|
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
|
|
namespace fry {
|
|
namespace {
|
|
|
|
// The next character of UTF-8 text (a bad byte: itself).
|
|
uint32_t nextChar(const std::string& s, size_t& i) {
|
|
const auto b = [&](size_t k) { return k < s.size() ? uint32_t(uint8_t(s[k])) : 0u; };
|
|
const uint32_t c = b(i);
|
|
if (c < 0x80) return ++i, c;
|
|
if ((c & 0xE0) == 0xC0) return i += 2, ((c & 0x1F) << 6) | (b(i - 1) & 0x3F);
|
|
if ((c & 0xF0) == 0xE0) return i += 3, ((c & 0x0F) << 12) | ((b(i - 2) & 0x3F) << 6) | (b(i - 1) & 0x3F);
|
|
if ((c & 0xF8) == 0xF0) return i += 4, ((c & 0x07) << 18) | ((b(i - 3) & 0x3F) << 12) | ((b(i - 2) & 0x3F) << 6) | (b(i - 1) & 0x3F);
|
|
return ++i, c;
|
|
}
|
|
|
|
using Contour = std::vector<glm::vec2>;
|
|
|
|
// A glyph's outlines (font units), its curves cut into `detail` straight pieces each.
|
|
std::vector<Contour> glyphContours(const stbtt_fontinfo& f, int glyph, int detail) {
|
|
stbtt_vertex* v = nullptr;
|
|
const int n = stbtt_GetGlyphShape(&f, glyph, &v);
|
|
std::vector<Contour> out;
|
|
glm::vec2 at(0.0f);
|
|
for (int i = 0; i < n; ++i) {
|
|
const glm::vec2 to(v[i].x, v[i].y);
|
|
switch (v[i].type) {
|
|
case STBTT_vmove:
|
|
out.emplace_back();
|
|
out.back().push_back(to);
|
|
break;
|
|
case STBTT_vline:
|
|
if (!out.empty()) out.back().push_back(to);
|
|
break;
|
|
case STBTT_vcurve: {
|
|
const glm::vec2 c(v[i].cx, v[i].cy);
|
|
for (int k = 1; k <= detail && !out.empty(); ++k) {
|
|
const float t = float(k) / float(detail);
|
|
out.back().push_back((1 - t) * (1 - t) * at + 2 * (1 - t) * t * c + t * t * to);
|
|
}
|
|
break;
|
|
}
|
|
case STBTT_vcubic: {
|
|
const glm::vec2 c1(v[i].cx, v[i].cy), c2(v[i].cx1, v[i].cy1);
|
|
for (int k = 1; k <= detail + 2 && !out.empty(); ++k) {
|
|
const float t = float(k) / float(detail + 2), u = 1 - t;
|
|
out.back().push_back(u * u * u * at + 3 * u * u * t * c1 + 3 * u * t * t * c2 + t * t * t * to);
|
|
}
|
|
break;
|
|
}
|
|
default: break;
|
|
}
|
|
at = to;
|
|
}
|
|
stbtt_FreeShape(&f, v);
|
|
for (Contour& c : out) {
|
|
while (c.size() > 1 && glm::distance(c.front(), c.back()) < 1e-3f) c.pop_back();
|
|
Contour clean; // (no point twice in a row, none in a straight line between its neighbours)
|
|
for (const glm::vec2& p : c)
|
|
if (clean.empty() || glm::distance(clean.back(), p) > 1e-3f) clean.push_back(p);
|
|
c = clean;
|
|
}
|
|
std::erase_if(out, [](const Contour& c) { return c.size() < 3; });
|
|
return out;
|
|
}
|
|
|
|
// Its area: positive when it turns counter-clockwise.
|
|
float area(const Contour& c) {
|
|
float a = 0;
|
|
for (size_t i = 0; i < c.size(); ++i) {
|
|
const glm::vec2 p = c[i], q = c[(i + 1) % c.size()];
|
|
a += p.x * q.y - q.x * p.y;
|
|
}
|
|
return a * 0.5f;
|
|
}
|
|
|
|
// A glyph made solid. Fonts tell holes by the way an outline turns: the other way from the
|
|
// letter's body. Pieces that turn the body's way are joined (a letter can be drawn as overlapping
|
|
// strokes), then the holes cut out of what they're in.
|
|
Mesh solidGlyph(const std::vector<Contour>& cs, float scale, glm::vec2 at, float depth) {
|
|
if (cs.empty()) return {};
|
|
size_t biggest = 0;
|
|
for (size_t i = 1; i < cs.size(); ++i)
|
|
if (std::abs(area(cs[i])) > std::abs(area(cs[biggest]))) biggest = i;
|
|
const bool bodyTurn = area(cs[biggest]) > 0;
|
|
auto prism = [&](const Contour& c, float thick) {
|
|
std::vector<glm::vec3> pts;
|
|
for (const glm::vec2& p : c) pts.push_back(glm::vec3(at + p * scale, 0.0f));
|
|
Mesh m = extrudeOutline(pts, glm::vec3(0, 0, 1), thick);
|
|
transform(m, glm::translate(glm::mat4(1.0f), glm::vec3(0, 0, depth * 0.5f)));
|
|
return m;
|
|
};
|
|
struct Box {
|
|
glm::vec2 lo{1e30f}, hi{-1e30f};
|
|
bool meets(const Box& o) const { return lo.x <= o.hi.x && o.lo.x <= hi.x && lo.y <= o.hi.y && o.lo.y <= hi.y; }
|
|
};
|
|
std::vector<Box> box(cs.size());
|
|
for (size_t i = 0; i < cs.size(); ++i)
|
|
for (const glm::vec2& p : cs[i]) box[i].lo = glm::min(box[i].lo, p), box[i].hi = glm::max(box[i].hi, p);
|
|
// The body's pieces in groups that touch (each group one solid).
|
|
std::vector<size_t> body, holes;
|
|
for (size_t i = 0; i < cs.size(); ++i) (area(cs[i]) > 0) == bodyTurn ? body.push_back(i) : holes.push_back(i);
|
|
std::vector<int> group(cs.size(), -1);
|
|
int groups = 0;
|
|
for (size_t i : body) {
|
|
if (group[i] >= 0) continue;
|
|
std::vector<size_t> todo{i};
|
|
group[i] = groups;
|
|
while (!todo.empty()) {
|
|
const size_t k = todo.back();
|
|
todo.pop_back();
|
|
for (size_t j : body)
|
|
if (group[j] < 0 && box[k].meets(box[j])) group[j] = groups, todo.push_back(j);
|
|
}
|
|
++groups;
|
|
}
|
|
Mesh out;
|
|
for (int g = 0; g < groups; ++g) {
|
|
Mesh solid;
|
|
Box gb;
|
|
for (size_t i : body) {
|
|
if (group[i] != g) continue;
|
|
gb.lo = glm::min(gb.lo, box[i].lo), gb.hi = glm::max(gb.hi, box[i].hi);
|
|
if (solid.faces.empty()) solid = prism(cs[i], depth);
|
|
else if (Mesh joined = solid; combine(joined, prism(cs[i], depth), Combine::Add)) solid = std::move(joined);
|
|
else append(solid, prism(cs[i], depth)); // (couldn't join: overlapping, but there)
|
|
}
|
|
for (size_t h : holes)
|
|
if (gb.meets(box[h]))
|
|
if (Mesh cut = solid; combine(cut, prism(cs[h], depth * 1.5f), Combine::Subtract)) solid = std::move(cut);
|
|
append(out, solid);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
Mesh makeText(const std::vector<uint8_t>& font, const std::string& text, const TextStyle& style, std::string* error) {
|
|
stbtt_fontinfo f;
|
|
if (font.empty() || !stbtt_InitFont(&f, font.data(), stbtt_GetFontOffsetForIndex(font.data(), 0))) {
|
|
if (error) *error = "That isn't a font that can be read (TrueType or OpenType)";
|
|
return {};
|
|
}
|
|
// The size: a capital H as tall as asked.
|
|
int x0, y0, x1, y1;
|
|
float capital = 0;
|
|
if (stbtt_GetCodepointBox(&f, 'H', &x0, &y0, &x1, &y1)) capital = float(y1);
|
|
if (capital <= 0) {
|
|
int ascent, descent, gap;
|
|
stbtt_GetFontVMetrics(&f, &ascent, &descent, &gap);
|
|
capital = float(ascent) * 0.7f;
|
|
}
|
|
const float scale = style.height / std::max(capital, 1.0f);
|
|
// The lines, each as wide as its letters.
|
|
std::vector<std::string> lines(1);
|
|
for (char c : text) c == '\n' ? (void)lines.emplace_back() : lines.back().push_back(c);
|
|
auto width = [&](const std::string& line) {
|
|
float x = 0;
|
|
int prev = 0;
|
|
for (size_t i = 0; i < line.size();) {
|
|
const int g = stbtt_FindGlyphIndex(&f, int(nextChar(line, i)));
|
|
int adv, lsb;
|
|
stbtt_GetGlyphHMetrics(&f, g, &adv, &lsb);
|
|
if (prev) x += float(stbtt_GetGlyphKernAdvance(&f, prev, g)) * scale;
|
|
x += float(adv) * scale + style.spacing * style.height;
|
|
prev = g;
|
|
}
|
|
return x;
|
|
};
|
|
float widest = 0;
|
|
for (const std::string& l : lines) widest = std::max(widest, width(l));
|
|
Mesh out;
|
|
float y = 0;
|
|
for (const std::string& line : lines) {
|
|
const float w = width(line);
|
|
float x = style.align == 1 ? (widest - w) * 0.5f : style.align == 2 ? widest - w : 0.0f;
|
|
int prev = 0;
|
|
for (size_t i = 0; i < line.size();) {
|
|
const int g = stbtt_FindGlyphIndex(&f, int(nextChar(line, i)));
|
|
if (prev) x += float(stbtt_GetGlyphKernAdvance(&f, prev, g)) * scale;
|
|
append(out, solidGlyph(glyphContours(f, g, std::max(1, style.detail)), scale, glm::vec2(x, y), style.depth));
|
|
int adv, lsb;
|
|
stbtt_GetGlyphHMetrics(&f, g, &adv, &lsb);
|
|
x += float(adv) * scale + style.spacing * style.height;
|
|
prev = g;
|
|
}
|
|
y -= style.height * (1.0f + std::max(0.0f, style.lineGap) + 0.4f); // (a capital, what hangs below, and the gap)
|
|
}
|
|
if (out.faces.empty() && error) *error = "No letters to make (only spaces?)";
|
|
return out;
|
|
}
|
|
|
|
} // namespace fry
|