mirror of
https://github.com/MrLowPr/overdrive.git
synced 2026-10-17 17:01:14 +02:00
894 lines
37 KiB
C++
894 lines
37 KiB
C++
// Copyright (C) 2026 half144 and PS5 React contributors
|
|
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
// Additional attribution term: see LICENSE-ATTRIBUTION.
|
|
#include "text_shaper.hpp"
|
|
|
|
#include <SheenBidi/SheenBidi.h>
|
|
#include <hb-raster.h>
|
|
#include <hb.h>
|
|
|
|
#include "er_text_shaper.h"
|
|
#include "host_api.hpp"
|
|
|
|
#include <algorithm>
|
|
#include <climits>
|
|
#include <cstdint>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <mutex>
|
|
#include <string>
|
|
#include <sys/stat.h>
|
|
#include <unordered_map>
|
|
#include <vector>
|
|
|
|
namespace {
|
|
|
|
// Rasterized glyphs kept for reuse, least recently drawn evicted first: about 7,000 CJK glyphs at
|
|
// 24 px. Fonts are loaded whole, on first use, and kept (docs/TEXT.md lists their sizes).
|
|
constexpr std::size_t kGlyphCacheBytes = 4u << 20;
|
|
// Shaped strings kept for reuse (layout measures a node, wraps it, then the compositor draws it):
|
|
// about 1 KB each for a typical label.
|
|
constexpr std::size_t kLayoutCacheEntries = 128;
|
|
|
|
enum class Script : std::uint8_t { kOther, kHan, kKana, kDevanagari, kBengali, kArabic };
|
|
|
|
struct FaceSpec {
|
|
const char* file;
|
|
Script script;
|
|
// Line box over and under the baseline, in thousandths of an em, at most: CJK uses its em box,
|
|
// Arabic its common letters rather than the stacked marks its hhea metrics make room for.
|
|
int ascent, descent;
|
|
// Joined scripts take no letter spacing or faux-bold advance, which would break their joins.
|
|
bool joined;
|
|
};
|
|
constexpr FaceSpec kFaces[] = {
|
|
{"NotoSansJP-Regular.otf", Script::kKana, 880, 120, false},
|
|
{"NotoSansSC-Regular.otf", Script::kHan, 880, 120, false},
|
|
{"NotoSansDevanagari-Regular.ttf", Script::kDevanagari, 1000, 450, true},
|
|
{"NotoSansBengali-Regular.ttf", Script::kBengali, 1000, 450, true},
|
|
{"NotoSansArabic-Regular.ttf", Script::kArabic, 1050, 500, true},
|
|
};
|
|
constexpr int kFaceCount = sizeof kFaces / sizeof kFaces[0];
|
|
constexpr int kJapanese = 0, kChinese = 1;
|
|
|
|
struct Face {
|
|
bool present = false, failed = false;
|
|
hb_face_t* face = nullptr;
|
|
hb_font_t* probe = nullptr;
|
|
std::vector<std::pair<int, hb_font_t*>> sizes;
|
|
};
|
|
|
|
struct State {
|
|
std::string font_dir;
|
|
void (*log)(const char*) = nullptr;
|
|
Face faces[kFaceCount];
|
|
bool any_face = false;
|
|
hb_language_t language = nullptr;
|
|
bool prefer_japanese = false;
|
|
unsigned serial = 0;
|
|
hb_buffer_t* buffer = nullptr;
|
|
hb_raster_draw_t* raster = nullptr;
|
|
};
|
|
State* state = nullptr;
|
|
|
|
void log_line(const char* format, const char* a, double b = 0) {
|
|
if (!state->log) return;
|
|
char line[256];
|
|
std::snprintf(line, sizeof line, format, a, b);
|
|
state->log(line);
|
|
}
|
|
|
|
// ---- Unicode --------------------------------------------------------------------------------
|
|
|
|
std::uint32_t next_codepoint(const char* text, std::size_t length, std::size_t& at) {
|
|
const auto* p = reinterpret_cast<const unsigned char*>(text);
|
|
const unsigned char b = p[at];
|
|
int count = b < 0x80 ? 1 : (b & 0xE0) == 0xC0 ? 2 : (b & 0xF0) == 0xE0 ? 3 : (b & 0xF8) == 0xF0 ? 4 : 0;
|
|
if (!count || at + count > length) {
|
|
at++;
|
|
return 0xFFFD;
|
|
}
|
|
std::uint32_t cp = count == 1 ? b : b & (0x7F >> count);
|
|
for (int i = 1; i < count; i++) {
|
|
if ((p[at + i] & 0xC0) != 0x80) {
|
|
at += i;
|
|
return 0xFFFD;
|
|
}
|
|
cp = (cp << 6) | (p[at + i] & 0x3F);
|
|
}
|
|
at += count;
|
|
return cp;
|
|
}
|
|
|
|
Script script_of(std::uint32_t c) {
|
|
if ((c >= 0x0900 && c <= 0x0963) || (c >= 0x0966 && c <= 0x097F) || (c >= 0xA8E0 && c <= 0xA8FF) ||
|
|
(c >= 0x1CD0 && c <= 0x1CFF))
|
|
return Script::kDevanagari;
|
|
if (c >= 0x0980 && c <= 0x09FF) return Script::kBengali;
|
|
if ((c >= 0x0600 && c <= 0x06FF) || (c >= 0x0750 && c <= 0x077F) || (c >= 0x0870 && c <= 0x08FF) ||
|
|
(c >= 0xFB50 && c <= 0xFDFF) || (c >= 0xFE70 && c <= 0xFEFF))
|
|
return Script::kArabic;
|
|
if ((c >= 0x3040 && c <= 0x30FF) || (c >= 0x31F0 && c <= 0x31FF) || (c >= 0xFF66 && c <= 0xFF9F))
|
|
return Script::kKana;
|
|
if ((c >= 0x2E80 && c <= 0x2FDF) || (c >= 0x3000 && c <= 0x303F) || (c >= 0x3190 && c <= 0x33FF) ||
|
|
(c >= 0x3400 && c <= 0x4DBF) || (c >= 0x4E00 && c <= 0x9FFF) || (c >= 0xF900 && c <= 0xFAFF) ||
|
|
(c >= 0xFE30 && c <= 0xFE4F) || (c >= 0xFF00 && c <= 0xFFEF) || (c >= 0x20000 && c <= 0x3FFFF))
|
|
return Script::kHan;
|
|
return Script::kOther;
|
|
}
|
|
|
|
// Scripts that must be shaped (or reordered) even when a baked font has their characters: Hebrew to
|
|
// Myanmar, Khmer, Mongolian and the Arabic presentation forms.
|
|
bool needs_shaping(std::uint32_t c) {
|
|
return (c >= 0x0590 && c <= 0x109F) || (c >= 0x1780 && c <= 0x18AF) || (c >= 0xFB1D && c <= 0xFDFF) ||
|
|
(c >= 0xFE70 && c <= 0xFEFF);
|
|
}
|
|
|
|
// Strong right-to-left characters (Hebrew, Arabic, Syriac, Thaana, NKo and their extensions): text
|
|
// without any, and without a right-to-left direction, skips the bidi algorithm.
|
|
bool right_to_left(std::uint32_t c) {
|
|
return (c >= 0x0590 && c <= 0x08FF) || (c >= 0xFB1D && c <= 0xFDFF) || (c >= 0xFE70 && c <= 0xFEFF) ||
|
|
(c >= 0x10800 && c <= 0x10FFF) || (c >= 0x1E800 && c <= 0x1EFFF);
|
|
}
|
|
|
|
// Characters drawn as part of the one before them (combining marks, joiners, variation selectors).
|
|
bool extends(std::uint32_t c) {
|
|
if (c == 0x200C || c == 0x200D || (c >= 0xFE00 && c <= 0xFE0F) || (c >= 0xE0100 && c <= 0xE01EF)) return true;
|
|
const hb_unicode_general_category_t category = hb_unicode_general_category(hb_unicode_funcs_get_default(), c);
|
|
return category == HB_UNICODE_GENERAL_CATEGORY_NON_SPACING_MARK ||
|
|
category == HB_UNICODE_GENERAL_CATEGORY_SPACING_MARK ||
|
|
category == HB_UNICODE_GENERAL_CATEGORY_ENCLOSING_MARK;
|
|
}
|
|
|
|
// Invisible formatting characters: never a reason to leave the bitmap path.
|
|
bool ignorable(std::uint32_t c) {
|
|
return (c >= 0x200B && c <= 0x200F) || (c >= 0x2028 && c <= 0x202E) || (c >= 0x2060 && c <= 0x206F) ||
|
|
(c >= 0xFE00 && c <= 0xFE0F) || c == 0xFEFF || c == 0x00AD;
|
|
}
|
|
|
|
bool is_space(std::uint32_t c) { return c == ' ' || c == '\t' || c == 0x3000; }
|
|
|
|
// Ideographic text breaks between any two characters (UAX #14 class ID and its neighbours). Other
|
|
// scripts, Devanagari, Bengali and Arabic among them, break only after spaces.
|
|
bool breaks_around(std::uint32_t c) {
|
|
const Script script = script_of(c);
|
|
return (script == Script::kHan || script == Script::kKana) && c != 0x3000;
|
|
}
|
|
|
|
// A virama or zero-width joiner joins the next consonant into one conjunct: never a line break.
|
|
bool joins_next(std::uint32_t c) {
|
|
return c == 0x200D ||
|
|
hb_unicode_combining_class(hb_unicode_funcs_get_default(), c) == HB_UNICODE_COMBINING_CLASS_VIRAMA;
|
|
}
|
|
|
|
// Kinsoku: characters that may not start a line (closing punctuation, small kana, iteration and
|
|
// prolonged-sound marks) or end one (opening brackets).
|
|
bool no_line_start(std::uint32_t c) {
|
|
static constexpr char32_t kList[] =
|
|
U"!),.:;?]}¢°’”‰′″℃、。〃々〆〉》」』】〕〗〙〟〻ゝゞァィゥェォッャュョヮヵヶぁぃぅぇぉっゃゅょゎゕゖ"
|
|
U"ーヽヾ・‥…‐゠–〜！％），．：；？］｝｡｣､･ｧｨｩｪｫｬｭｮｯｰﾞﾟ";
|
|
for (char32_t x : kList)
|
|
if (x == c) return true;
|
|
return false;
|
|
}
|
|
bool no_line_end(std::uint32_t c) {
|
|
static constexpr char32_t kList[] = U"([{£¥‘“〈《「『【〔〖〘〝（［｛｢＄￡￥";
|
|
for (char32_t x : kList)
|
|
if (x == c) return true;
|
|
return false;
|
|
}
|
|
|
|
// ---- Fonts ----------------------------------------------------------------------------------
|
|
|
|
bool load(int index) {
|
|
Face& face = state->faces[index];
|
|
if (face.face) return true;
|
|
if (!face.present || face.failed) return false;
|
|
const std::string path = state->font_dir + "/" + kFaces[index].file;
|
|
FILE* file = std::fopen(path.c_str(), "rb");
|
|
long size = -1;
|
|
if (file && std::fseek(file, 0, SEEK_END) == 0) size = std::ftell(file);
|
|
char* data = size > 0 && std::fseek(file, 0, SEEK_SET) == 0 ? static_cast<char*>(std::malloc(size)) : nullptr;
|
|
const bool ok = data && std::fread(data, 1, size, file) == static_cast<std::size_t>(size);
|
|
if (file) std::fclose(file);
|
|
if (!ok) {
|
|
std::free(data);
|
|
face.failed = true;
|
|
log_line("text: cannot load %s", path.c_str());
|
|
return false;
|
|
}
|
|
hb_blob_t* blob = hb_blob_create(data, static_cast<unsigned>(size), HB_MEMORY_MODE_READONLY, data, std::free);
|
|
face.face = hb_face_create(blob, 0);
|
|
hb_blob_destroy(blob);
|
|
face.probe = hb_font_create(face.face);
|
|
log_line("text: loaded %s (%.1f MB)", kFaces[index].file, size / 1048576.0);
|
|
return true;
|
|
}
|
|
|
|
// The face at a pixel size: positions in 26.6 fixed point.
|
|
hb_font_t* font_at(int index, int px) {
|
|
Face& face = state->faces[index];
|
|
for (auto& [size, font] : face.sizes)
|
|
if (size == px) return font;
|
|
hb_font_t* font = hb_font_create(face.face);
|
|
hb_font_set_scale(font, px * 64, px * 64);
|
|
face.sizes.emplace_back(px, font);
|
|
return font;
|
|
}
|
|
|
|
bool face_has(int index, std::uint32_t cp) {
|
|
hb_codepoint_t glyph;
|
|
return load(index) && hb_font_get_nominal_glyph(state->faces[index].probe, cp, &glyph);
|
|
}
|
|
|
|
// The face that draws `cp`: its script's faces first, then the face of the text around it.
|
|
int face_for(std::uint32_t cp, int previous) {
|
|
int order[kFaceCount + 1];
|
|
int count = 0;
|
|
const Script script = script_of(cp);
|
|
if (script == Script::kHan || script == Script::kKana) {
|
|
const bool japanese = script == Script::kKana || state->prefer_japanese;
|
|
order[count++] = japanese ? kJapanese : kChinese;
|
|
order[count++] = japanese ? kChinese : kJapanese;
|
|
} else if (script != Script::kOther) {
|
|
for (int i = 0; i < kFaceCount; i++)
|
|
if (kFaces[i].script == script) order[count++] = i;
|
|
} else {
|
|
if (previous >= 0) order[count++] = previous;
|
|
for (int i = 0; i < kFaceCount; i++) order[count++] = i;
|
|
}
|
|
for (int i = 0; i < count; i++)
|
|
if (face_has(order[i], cp)) return order[i];
|
|
return -1;
|
|
}
|
|
|
|
bool baked_has(const BitmapFont* font, std::uint32_t cp) {
|
|
if (cp >= font->first && cp <= font->last) return true;
|
|
std::uint32_t lo = 0, hi = font->extras_count;
|
|
while (lo < hi) {
|
|
const std::uint32_t mid = (lo + hi) / 2;
|
|
if (font->extras[mid].codepoint == cp) return true;
|
|
if (font->extras[mid].codepoint < cp) lo = mid + 1;
|
|
else hi = mid;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// ---- Glyph cache ----------------------------------------------------------------------------
|
|
|
|
struct CachedGlyph {
|
|
std::uint64_t key;
|
|
CachedGlyph *newer, *older;
|
|
int left, top; // bitmap origin from the pen position and the baseline, in pixels (top is up)
|
|
int width, height;
|
|
std::uint8_t pixels[1];
|
|
};
|
|
|
|
struct GlyphCache {
|
|
std::unordered_map<std::uint64_t, CachedGlyph*> map;
|
|
CachedGlyph *newest = nullptr, *oldest = nullptr;
|
|
std::size_t bytes = 0;
|
|
|
|
void unlink(CachedGlyph* g) {
|
|
(g->newer ? g->newer->older : newest) = g->older;
|
|
(g->older ? g->older->newer : oldest) = g->newer;
|
|
}
|
|
void push(CachedGlyph* g) {
|
|
g->newer = nullptr;
|
|
g->older = newest;
|
|
(newest ? newest->newer : oldest) = g;
|
|
newest = g;
|
|
}
|
|
void clear() {
|
|
while (oldest) {
|
|
CachedGlyph* g = oldest;
|
|
unlink(g);
|
|
std::free(g);
|
|
}
|
|
map.clear();
|
|
bytes = 0;
|
|
}
|
|
};
|
|
GlyphCache* cache = nullptr;
|
|
|
|
const CachedGlyph* glyph_image(int face, int px, std::uint32_t glyph) {
|
|
const std::uint64_t key = (static_cast<std::uint64_t>(face) << 40) | (static_cast<std::uint64_t>(px) << 32) | glyph;
|
|
if (auto found = cache->map.find(key); found != cache->map.end()) {
|
|
cache->unlink(found->second);
|
|
cache->push(found->second);
|
|
return found->second;
|
|
}
|
|
hb_raster_draw_glyph(state->raster, font_at(face, px), glyph);
|
|
hb_raster_image_t* image = hb_raster_draw_render(state->raster);
|
|
if (!image) return nullptr;
|
|
hb_raster_extents_t extents;
|
|
hb_raster_image_get_extents(image, &extents);
|
|
const int width = extents.width <= 255 ? static_cast<int>(extents.width) : 0;
|
|
const int height = extents.height <= 255 ? static_cast<int>(extents.height) : 0;
|
|
const std::size_t size = sizeof(CachedGlyph) + static_cast<std::size_t>(width) * height;
|
|
auto* entry = static_cast<CachedGlyph*>(std::malloc(size));
|
|
if (!entry) {
|
|
hb_raster_draw_recycle_image(state->raster, image);
|
|
return nullptr;
|
|
}
|
|
entry->key = key;
|
|
entry->left = extents.x_origin;
|
|
entry->top = extents.y_origin + height;
|
|
entry->width = width;
|
|
entry->height = height;
|
|
// The image's first row is its bottom (y grows upward in glyph space).
|
|
const std::uint8_t* source = hb_raster_image_get_buffer(image);
|
|
for (int row = 0; row < height; row++)
|
|
std::memcpy(entry->pixels + static_cast<std::size_t>(row) * width,
|
|
source + static_cast<std::size_t>(height - 1 - row) * extents.stride, width);
|
|
hb_raster_draw_recycle_image(state->raster, image);
|
|
cache->map.emplace(key, entry);
|
|
cache->push(entry);
|
|
cache->bytes += size;
|
|
while (cache->bytes > kGlyphCacheBytes && cache->oldest != entry) {
|
|
CachedGlyph* old = cache->oldest;
|
|
cache->unlink(old);
|
|
cache->map.erase(old->key);
|
|
cache->bytes -= sizeof(CachedGlyph) + static_cast<std::size_t>(old->width) * old->height;
|
|
std::free(old);
|
|
}
|
|
return entry;
|
|
}
|
|
|
|
// ---- Shaping --------------------------------------------------------------------------------
|
|
|
|
struct Glyph {
|
|
std::uint32_t id; // glyph ID in its face, or the codepoint for a baked glyph
|
|
std::int32_t advance, dx, dy; // 26.6
|
|
std::uint32_t cluster; // byte offset of the first character it draws
|
|
std::int8_t face; // -1: baked bitmap glyph
|
|
};
|
|
|
|
struct Run {
|
|
std::uint32_t start, end;
|
|
std::int8_t face;
|
|
std::uint8_t level; // bidi embedding level: odd runs are right to left
|
|
std::uint32_t first_glyph = 0, glyph_count = 0;
|
|
};
|
|
|
|
struct Paragraph {
|
|
std::uint32_t start;
|
|
std::uint8_t level; // base level: 1 for a right-to-left paragraph
|
|
};
|
|
|
|
// kClusterStart: a HarfBuzz cluster (a base and its marks) starts here. kGraphemeStart: a cluster
|
|
// that does not continue a conjunct, the only place a word too wide for its line may be cut.
|
|
enum : std::uint8_t { kClusterStart = 1, kBreakBefore = 2, kSpace = 4, kNewline = 8, kGraphemeStart = 16 };
|
|
|
|
struct Layout {
|
|
std::string text, family;
|
|
int px = 0, letter_spacing = 0, bold = 0, direction = 0;
|
|
unsigned serial = 0;
|
|
const BitmapFont* baked = nullptr;
|
|
std::vector<Glyph> glyphs;
|
|
std::vector<Run> runs;
|
|
std::vector<Paragraph> paragraphs;
|
|
std::vector<std::uint8_t> levels; // per byte
|
|
std::vector<std::int32_t> advance; // per byte: the 26.6 advance of the cluster starting there
|
|
std::vector<std::uint8_t> flags; // per byte
|
|
int ascent = 0, descent = 0, line_height = 0; // pixels
|
|
};
|
|
|
|
struct LayoutCache {
|
|
Layout entries[kLayoutCacheEntries];
|
|
std::size_t next = 0;
|
|
};
|
|
LayoutCache* layouts = nullptr;
|
|
|
|
// Embedding levels per byte (Unicode bidirectional algorithm, one paragraph per line feed), and
|
|
// each paragraph's base level: from `direction`, else from its first strong character.
|
|
void resolve_levels(Layout& layout) {
|
|
const char* text = layout.text.c_str();
|
|
const std::size_t length = layout.text.size();
|
|
const SBLevel base = layout.direction == ER_DIRECTION_RTL ? 1 : layout.direction == ER_DIRECTION_LTR ? 0
|
|
: SBLevelDefaultLTR;
|
|
layout.levels.assign(length + 1, 0);
|
|
bool bidi = layout.direction == ER_DIRECTION_RTL;
|
|
for (std::size_t at = 0; at < length && !bidi;) bidi = right_to_left(next_codepoint(text, length, at));
|
|
if (!bidi) {
|
|
layout.paragraphs.push_back({0, 0});
|
|
return;
|
|
}
|
|
SBCodepointSequence sequence{SBStringEncodingUTF8, const_cast<char*>(text), length};
|
|
SBAlgorithmRef algorithm = SBAlgorithmCreate(&sequence);
|
|
for (SBUInteger offset = 0; algorithm && offset < length;) {
|
|
SBParagraphRef paragraph = SBAlgorithmCreateParagraph(algorithm, offset, length - offset, base);
|
|
if (!paragraph) break;
|
|
const SBUInteger size = SBParagraphGetLength(paragraph);
|
|
std::memcpy(layout.levels.data() + offset, SBParagraphGetLevelsPtr(paragraph), size);
|
|
layout.paragraphs.push_back({static_cast<std::uint32_t>(offset), SBParagraphGetBaseLevel(paragraph)});
|
|
SBParagraphRelease(paragraph);
|
|
offset += size;
|
|
}
|
|
if (algorithm) SBAlgorithmRelease(algorithm);
|
|
if (layout.paragraphs.empty()) layout.paragraphs.push_back({0, 0});
|
|
}
|
|
|
|
void itemize(Layout& layout) {
|
|
const char* text = layout.text.c_str();
|
|
const std::size_t length = layout.text.size();
|
|
std::size_t at = 0;
|
|
int previous_face = -1;
|
|
while (at < length) {
|
|
const std::size_t start = at;
|
|
const std::uint32_t cp = next_codepoint(text, length, at);
|
|
bool baked = cp == '\n' || ignorable(cp) || (baked_has(layout.baked, cp) && !needs_shaping(cp));
|
|
while (at < length) {
|
|
std::size_t peek = at;
|
|
const std::uint32_t mark = next_codepoint(text, length, peek);
|
|
if (!extends(mark)) break;
|
|
baked = baked && (ignorable(mark) || baked_has(layout.baked, mark));
|
|
at = peek;
|
|
}
|
|
const int face = baked ? -1 : face_for(cp, previous_face);
|
|
if (face >= 0) previous_face = face;
|
|
const std::uint8_t level = layout.levels[start];
|
|
if (!layout.runs.empty() && layout.runs.back().face == face && layout.runs.back().level == level)
|
|
layout.runs.back().end = static_cast<std::uint32_t>(at);
|
|
else
|
|
layout.runs.push_back({static_cast<std::uint32_t>(start), static_cast<std::uint32_t>(at),
|
|
static_cast<std::int8_t>(face), level});
|
|
}
|
|
}
|
|
|
|
void shape(Layout& layout) {
|
|
const char* text = layout.text.c_str();
|
|
const std::size_t length = layout.text.size();
|
|
for (Run& run : layout.runs) {
|
|
run.first_glyph = static_cast<std::uint32_t>(layout.glyphs.size());
|
|
if (run.face < 0) {
|
|
std::uint32_t cluster = run.start;
|
|
for (std::size_t at = run.start; at < run.end;) {
|
|
const std::uint32_t start = static_cast<std::uint32_t>(at);
|
|
const std::uint32_t cp = next_codepoint(text, length, at);
|
|
// A baked combining mark belongs to its base's cluster, so no line starts with it.
|
|
if (start == run.start || !extends(cp)) cluster = start;
|
|
if (cp == '\n' || ignorable(cp)) {
|
|
layout.glyphs.push_back({cp, 0, 0, 0, cluster, -1});
|
|
continue;
|
|
}
|
|
const int advance = font_glyph(layout.baked, cp)->advance + layout.letter_spacing + layout.bold;
|
|
layout.glyphs.push_back({cp, advance * 64, 0, 0, cluster, -1});
|
|
}
|
|
} else {
|
|
hb_buffer_t* buffer = state->buffer;
|
|
hb_buffer_clear_contents(buffer);
|
|
hb_buffer_add_utf8(buffer, text, static_cast<int>(length), run.start, static_cast<int>(run.end - run.start));
|
|
hb_buffer_set_direction(buffer, run.level & 1 ? HB_DIRECTION_RTL : HB_DIRECTION_LTR);
|
|
hb_buffer_set_language(buffer, state->language);
|
|
hb_buffer_guess_segment_properties(buffer);
|
|
hb_shape(font_at(run.face, layout.px), buffer, nullptr, 0);
|
|
unsigned count = 0;
|
|
const hb_glyph_info_t* info = hb_buffer_get_glyph_infos(buffer, &count);
|
|
const hb_glyph_position_t* position = hb_buffer_get_glyph_positions(buffer, nullptr);
|
|
const int extra = kFaces[run.face].joined ? 0 : (layout.letter_spacing + layout.bold) * 64;
|
|
for (unsigned i = 0; i < count; i++) {
|
|
const bool first_of_cluster = i == 0 || info[i].cluster != info[i - 1].cluster;
|
|
layout.glyphs.push_back({info[i].codepoint, position[i].x_advance + (first_of_cluster ? extra : 0),
|
|
position[i].x_offset, position[i].y_offset, info[i].cluster, run.face});
|
|
}
|
|
// CJK keeps the Latin line height this way (Noto CJK's hhea metrics would make its lines a
|
|
// quarter taller), and Arabic grows it by about a third rather than doubling it.
|
|
hb_font_extents_t extents{};
|
|
hb_font_get_h_extents(font_at(run.face, layout.px), &extents);
|
|
const int em = layout.px * 64;
|
|
const int ascent = std::min<int>(extents.ascender, em * kFaces[run.face].ascent / 1000);
|
|
const int descent = std::min<int>(-extents.descender, em * kFaces[run.face].descent / 1000);
|
|
layout.ascent = std::max(layout.ascent, (ascent + 63) >> 6);
|
|
layout.descent = std::max(layout.descent, (descent + 63) >> 6);
|
|
}
|
|
run.glyph_count = static_cast<std::uint32_t>(layout.glyphs.size()) - run.first_glyph;
|
|
}
|
|
layout.line_height = layout.ascent + layout.descent;
|
|
|
|
layout.advance.assign(length + 1, 0);
|
|
layout.flags.assign(length + 1, 0);
|
|
for (const Glyph& g : layout.glyphs) {
|
|
layout.advance[g.cluster] += g.advance;
|
|
layout.flags[g.cluster] |= kClusterStart;
|
|
}
|
|
// Break opportunities, before the character at each cluster start: after a space or a zero-width
|
|
// space, and around CJK characters as kinsoku allows.
|
|
std::uint32_t before = 0;
|
|
for (std::size_t at = 0; at < length;) {
|
|
const std::size_t start = at;
|
|
const std::uint32_t cp = next_codepoint(text, length, at);
|
|
if (cp == '\n') layout.flags[start] |= kNewline;
|
|
if (is_space(cp)) layout.flags[start] |= kSpace;
|
|
if ((layout.flags[start] & kClusterStart) && (start == 0 || !joins_next(before)))
|
|
layout.flags[start] |= kGraphemeStart;
|
|
if (start > 0 && (layout.flags[start] & kGraphemeStart) && !is_space(cp) &&
|
|
(is_space(before) || before == 0x200B ||
|
|
((breaks_around(before) || breaks_around(cp)) && !no_line_start(cp) && !no_line_end(before))))
|
|
layout.flags[start] |= kBreakBefore;
|
|
before = cp;
|
|
}
|
|
}
|
|
|
|
const Layout& layout_for(const char* text, const char* family, std::uint8_t font_size, int letter_spacing,
|
|
std::uint8_t font_weight, std::uint8_t direction) {
|
|
const BitmapFont* baked = er_text_font(family, font_size);
|
|
const int bold = font_weight ? 1 : 0;
|
|
const char* family_name = family ? family : "";
|
|
for (const Layout& layout : layouts->entries)
|
|
if (layout.baked == baked && layout.serial == state->serial && layout.px == font_size &&
|
|
layout.letter_spacing == letter_spacing && layout.bold == bold && layout.direction == direction &&
|
|
layout.text == text &&
|
|
layout.family == family_name)
|
|
return layout;
|
|
Layout& layout = layouts->entries[layouts->next];
|
|
layouts->next = (layouts->next + 1) % kLayoutCacheEntries;
|
|
layout = Layout{};
|
|
layout.text = text;
|
|
layout.family = family_name;
|
|
layout.px = font_size;
|
|
layout.letter_spacing = letter_spacing;
|
|
layout.bold = bold;
|
|
layout.direction = direction;
|
|
layout.serial = state->serial;
|
|
layout.baked = baked;
|
|
layout.ascent = baked->baseline;
|
|
layout.descent = baked->line_height - baked->baseline;
|
|
resolve_levels(layout);
|
|
itemize(layout);
|
|
shape(layout);
|
|
return layout;
|
|
}
|
|
|
|
// ---- Line breaking --------------------------------------------------------------------------
|
|
|
|
struct Line {
|
|
std::uint32_t start, end; // bytes, trailing spaces excluded
|
|
std::int32_t width; // 26.6
|
|
};
|
|
|
|
int to_px(std::int32_t fixed) { return (fixed + 63) >> 6; }
|
|
|
|
// Breaks like the bitmap renderer: at newlines, at break opportunities when the next cluster would
|
|
// pass `max_w` (0 = no limit), and inside a word only when nothing else fits, between grapheme
|
|
// clusters (a conjunct stays whole). `truncated` reports text left over after `max_lines`.
|
|
std::vector<Line> break_lines(const Layout& layout, int max_w, int max_lines, bool& truncated) {
|
|
std::vector<Line> lines;
|
|
truncated = false;
|
|
const std::uint32_t length = static_cast<std::uint32_t>(layout.text.size());
|
|
const std::int32_t limit = max_w > 0 ? max_w * 64 : INT32_MAX;
|
|
std::uint32_t at = 0;
|
|
auto skip_spaces = [&](std::uint32_t p) {
|
|
while (p < length && (layout.flags[p] & kSpace)) p++;
|
|
return p;
|
|
};
|
|
auto content_end = [&](std::uint32_t start, std::uint32_t end, std::int32_t& width) {
|
|
// Width without trailing spaces: recount from start, ending at the last non-space cluster.
|
|
width = 0;
|
|
std::int32_t running = 0;
|
|
std::uint32_t last = start;
|
|
for (std::uint32_t p = start; p < end; p++) {
|
|
if (!(layout.flags[p] & kClusterStart)) continue;
|
|
running += layout.advance[p];
|
|
if (!(layout.flags[p] & (kSpace | kNewline))) {
|
|
width = running;
|
|
last = p + 1;
|
|
while (last < end && !(layout.flags[last] & kClusterStart)) last++;
|
|
}
|
|
}
|
|
return last;
|
|
};
|
|
while (at < length) {
|
|
if (max_lines > 0 && static_cast<int>(lines.size()) >= max_lines) {
|
|
truncated = true;
|
|
break;
|
|
}
|
|
at = skip_spaces(at);
|
|
if (at >= length) break;
|
|
const std::uint32_t start = at;
|
|
std::uint32_t breakpoint = 0, grapheme = 0;
|
|
std::int32_t width = 0;
|
|
std::uint32_t end = length;
|
|
at = length;
|
|
for (std::uint32_t p = start; p < length; p++) {
|
|
if (layout.flags[p] & kNewline) {
|
|
end = p;
|
|
at = p + 1;
|
|
break;
|
|
}
|
|
if (!(layout.flags[p] & kClusterStart)) continue;
|
|
if (p > start && (layout.flags[p] & kBreakBefore)) breakpoint = p;
|
|
if (p > start && (layout.flags[p] & kGraphemeStart)) grapheme = p;
|
|
// A line holds at least one grapheme, even one wider than `max_w`.
|
|
if (width + layout.advance[p] > limit && p > start && !(layout.flags[p] & kSpace) && (breakpoint || grapheme)) {
|
|
end = breakpoint ? breakpoint : grapheme;
|
|
at = end;
|
|
break;
|
|
}
|
|
width += layout.advance[p];
|
|
}
|
|
Line line{start, 0, 0};
|
|
line.end = content_end(start, end, line.width);
|
|
lines.push_back(line);
|
|
}
|
|
if (lines.empty()) lines.push_back({0, 0, 0});
|
|
return lines;
|
|
}
|
|
|
|
// ---- Drawing --------------------------------------------------------------------------------
|
|
|
|
struct Style {
|
|
std::uint32_t color;
|
|
bool bold, italic;
|
|
std::uint8_t decoration;
|
|
};
|
|
|
|
Style style_at(const ERTextRenderParams* params, const std::uint8_t* span_map, std::uint32_t cluster) {
|
|
Style style{params->color, params->font_weight != 0, params->font_style != 0, params->text_decoration};
|
|
if (!span_map) return style;
|
|
const ERTextSpan& span = params->spans[span_map[cluster]];
|
|
if (span.color) style.color = span.color;
|
|
if (span.font_weight != 0xFF) style.bold = span.font_weight != 0;
|
|
if (span.font_style != 0xFF) style.italic = span.font_style != 0;
|
|
if (span.text_decoration != 0xFF) style.decoration = span.text_decoration;
|
|
return style;
|
|
}
|
|
|
|
void draw_glyph(const Layout& layout, const Glyph& g, int x, int line_top, const ERRect& clip, const Style& style) {
|
|
for (int pass = 0; pass < (style.bold ? 2 : 1); pass++) {
|
|
if (g.face < 0) {
|
|
er_text_draw_glyph(layout.baked, g.id, x + pass, line_top + layout.ascent - layout.baked->baseline, &clip,
|
|
style.color, style.italic);
|
|
continue;
|
|
}
|
|
const CachedGlyph* image = glyph_image(g.face, layout.px, g.id);
|
|
if (!image || !image->width) return;
|
|
const int left = x + pass + image->left + ((g.dx + 32) >> 6);
|
|
const int top = line_top + layout.ascent - image->top - ((g.dy + 32) >> 6);
|
|
er_text_draw_coverage(image->pixels, image->width, image->height, left, top, &clip, style.color, style.italic);
|
|
}
|
|
}
|
|
|
|
std::uint8_t paragraph_level(const Layout& layout, std::uint32_t at) {
|
|
std::uint8_t level = 0;
|
|
for (const Paragraph& paragraph : layout.paragraphs)
|
|
if (paragraph.start <= at) level = paragraph.level;
|
|
return level;
|
|
}
|
|
|
|
// The runs of a line in display order: rule L2 of the bidi algorithm, reversing every sequence of
|
|
// runs at or above each level from the highest down to the lowest odd one.
|
|
std::vector<const Run*> visual_runs(const Layout& layout, const Line& line) {
|
|
std::vector<const Run*> runs;
|
|
std::uint8_t highest = 0, lowest_odd = 255;
|
|
for (const Run& run : layout.runs) {
|
|
if (run.end <= line.start || run.start >= line.end) continue;
|
|
runs.push_back(&run);
|
|
highest = std::max(highest, run.level);
|
|
if (run.level & 1) lowest_odd = std::min(lowest_odd, run.level);
|
|
}
|
|
for (int level = highest; level >= lowest_odd && level > 0; level--) {
|
|
for (std::size_t i = 0; i < runs.size();) {
|
|
if (runs[i]->level < level) {
|
|
i++;
|
|
continue;
|
|
}
|
|
std::size_t j = i;
|
|
while (j < runs.size() && runs[j]->level >= level) j++;
|
|
std::reverse(runs.begin() + i, runs.begin() + j);
|
|
i = j;
|
|
}
|
|
}
|
|
return runs;
|
|
}
|
|
|
|
void render(const ERTextRenderParams* params, const char* text, const std::uint8_t* span_map) {
|
|
const Layout& layout = layout_for(text, params->font_family, er_text_clamp_font_size(params->font_size),
|
|
params->letter_spacing, params->font_weight, params->direction);
|
|
const ERRect& clip = params->clip;
|
|
bool truncated = false;
|
|
std::vector<Line> lines = break_lines(layout, clip.w, params->number_of_lines, truncated);
|
|
const int line_height = params->line_height > 0 ? params->line_height : layout.line_height;
|
|
const bool ellipsis = truncated && params->ellipsize_mode != ER_TEXT_ELLIPSIZE_CLIP;
|
|
const std::uint32_t ellipsis_cp = baked_has(layout.baked, 0x2026) ? 0x2026 : '.';
|
|
const int ellipsis_count = ellipsis_cp == 0x2026 ? 1 : 3;
|
|
const int ellipsis_w = ellipsis_count * (font_glyph(layout.baked, ellipsis_cp)->advance + layout.letter_spacing + layout.bold);
|
|
|
|
for (std::size_t i = 0; i < lines.size(); i++) {
|
|
const int box_top = clip.y + static_cast<int>(i) * line_height;
|
|
if (box_top >= clip.y + clip.h) break;
|
|
// Half the leading above the line, as in CSS and React Native, so a lineHeight centres the text.
|
|
const int line_top = box_top + (line_height - layout.line_height) / 2;
|
|
Line line = lines[i];
|
|
const bool cut = ellipsis && i + 1 == lines.size();
|
|
if (cut) {
|
|
// Whole grapheme clusters that fit before the ellipsis.
|
|
const std::int32_t room = (clip.w - ellipsis_w) * 64;
|
|
const std::uint32_t full = line.end;
|
|
std::int32_t width = 0;
|
|
std::uint32_t p = line.start;
|
|
for (; p < full; p++) {
|
|
if (!(layout.flags[p] & kClusterStart)) continue;
|
|
if (layout.flags[p] & kGraphemeStart) {
|
|
line.end = p;
|
|
line.width = width;
|
|
}
|
|
if (width + layout.advance[p] > room) break;
|
|
width += layout.advance[p];
|
|
}
|
|
if (p == full) {
|
|
line.end = full;
|
|
line.width = width;
|
|
}
|
|
}
|
|
const bool rtl = paragraph_level(layout, line.start) & 1;
|
|
const int width = to_px(line.width) + (cut ? ellipsis_w : 0);
|
|
// A truncated line starts where its paragraph starts; the ellipsis goes at its end.
|
|
const std::uint8_t align = cut ? ER_TEXT_ALIGN_START : er_text_physical_align(params->text_align, rtl);
|
|
int x = clip.x;
|
|
if (align == ER_TEXT_ALIGN_CENTER) x += std::max(0, (clip.w - width) / 2);
|
|
else if (align == ER_TEXT_ALIGN_RIGHT || (align == ER_TEXT_ALIGN_START && rtl)) x += std::max(0, clip.w - width);
|
|
|
|
const Style base = style_at(params, nullptr, 0);
|
|
auto draw_ellipsis = [&](std::int32_t& pen) {
|
|
for (int k = 0; k < ellipsis_count; k++) {
|
|
draw_glyph(layout, Glyph{ellipsis_cp, 0, 0, 0, 0, -1}, (pen + 32) >> 6, line_top, clip, base);
|
|
pen += (font_glyph(layout.baked, ellipsis_cp)->advance + layout.letter_spacing + layout.bold) * 64;
|
|
}
|
|
};
|
|
std::int32_t pen = x * 64;
|
|
if (cut && rtl) draw_ellipsis(pen);
|
|
for (const Run* run : visual_runs(layout, line)) {
|
|
// Shaped right-to-left runs come out of HarfBuzz in display order; baked ones are reversed
|
|
// here, with mirrored brackets.
|
|
const bool reverse = run->face < 0 && (run->level & 1);
|
|
for (std::uint32_t k = 0; k < run->glyph_count; k++) {
|
|
Glyph g = layout.glyphs[run->first_glyph + (reverse ? run->glyph_count - 1 - k : k)];
|
|
if (g.cluster < line.start || g.cluster >= line.end) continue;
|
|
if (reverse) g.id = hb_unicode_mirroring(hb_unicode_funcs_get_default(), g.id);
|
|
const Style style = style_at(params, span_map, g.cluster);
|
|
const int gx = (pen + 32) >> 6;
|
|
draw_glyph(layout, g, gx, line_top, clip, style);
|
|
pen += g.advance;
|
|
if (style.decoration != ER_TEXT_DECORATION_NONE) {
|
|
const int y = line_top + (style.decoration == ER_TEXT_DECORATION_UNDERLINE ? layout.ascent + 1 : layout.ascent * 2 / 3);
|
|
const int x0 = std::max(gx, static_cast<int>(clip.x)), x1 = std::min((pen + 32) >> 6, clip.x + clip.w);
|
|
if (x1 > x0 && y >= clip.y && y < clip.y + clip.h) er_text_fill(style.color, x0, y, x1 - x0, 1);
|
|
}
|
|
}
|
|
}
|
|
if (cut && !rtl) draw_ellipsis(pen);
|
|
}
|
|
}
|
|
|
|
// ---- Engine callbacks -----------------------------------------------------------------------
|
|
|
|
bool claims(const char* text, const char* family, std::uint8_t font_size, std::uint8_t direction) {
|
|
// Right-to-left text needs the bidi algorithm even when the baked font has every glyph.
|
|
if (direction == ER_DIRECTION_RTL) return true;
|
|
if (!state->any_face) return false;
|
|
const BitmapFont* baked = nullptr;
|
|
const std::size_t length = std::strlen(text);
|
|
for (std::size_t at = 0; at < length;) {
|
|
if (static_cast<unsigned char>(text[at]) < 0x80) {
|
|
at++;
|
|
continue;
|
|
}
|
|
const std::uint32_t cp = next_codepoint(text, length, at);
|
|
if (ignorable(cp)) continue;
|
|
if (needs_shaping(cp)) return true;
|
|
if (!baked) baked = er_text_font(family, font_size);
|
|
if (!baked_has(baked, cp)) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void measure(const char* text, std::uint8_t font_size, const char* family, std::int16_t letter_spacing,
|
|
std::uint8_t font_weight, int* out_width, int* out_height) {
|
|
const Layout& layout = layout_for(text, family, font_size, letter_spacing, font_weight, ER_DIRECTION_INHERIT);
|
|
std::int32_t width = 0;
|
|
for (std::size_t p = 0; p < layout.text.size(); p++) width += layout.advance[p];
|
|
*out_width = to_px(width);
|
|
*out_height = layout.line_height;
|
|
}
|
|
|
|
int wrap(const char* text, std::uint8_t font_size, const char* family, std::int16_t letter_spacing,
|
|
std::uint8_t font_weight, int max_w, int max_lines, int* out_width) {
|
|
const Layout& layout = layout_for(text, family, font_size, letter_spacing, font_weight, ER_DIRECTION_INHERIT);
|
|
bool truncated = false;
|
|
const std::vector<Line> lines = break_lines(layout, max_w, max_lines, truncated);
|
|
*out_width = 0;
|
|
for (const Line& line : lines) *out_width = std::max(*out_width, to_px(line.width));
|
|
return static_cast<int>(lines.size());
|
|
}
|
|
|
|
// Render workers measure and draw text concurrently. The HarfBuzz buffer and rasterizer, the glyph and
|
|
// layout caches and the lazily loaded faces are shared, and the references they hand out outlive the
|
|
// lookup, so shaped text renders one call at a time. claims() reads only the baked fonts.
|
|
std::mutex shaping;
|
|
|
|
void serial_measure(const char* text, std::uint8_t font_size, const char* family, std::int16_t letter_spacing,
|
|
std::uint8_t font_weight, int* out_width, int* out_height) {
|
|
std::lock_guard lock(shaping);
|
|
measure(text, font_size, family, letter_spacing, font_weight, out_width, out_height);
|
|
}
|
|
|
|
int serial_wrap(const char* text, std::uint8_t font_size, const char* family, std::int16_t letter_spacing,
|
|
std::uint8_t font_weight, int max_w, int max_lines, int* out_width) {
|
|
std::lock_guard lock(shaping);
|
|
return wrap(text, font_size, family, letter_spacing, font_weight, max_w, max_lines, out_width);
|
|
}
|
|
|
|
void serial_render(const ERTextRenderParams* params, const char* text, const std::uint8_t* span_map) {
|
|
std::lock_guard lock(shaping);
|
|
render(params, text, span_map);
|
|
}
|
|
|
|
const ERTextShaper kShaper = {claims, serial_measure, serial_wrap, serial_render};
|
|
|
|
} // namespace
|
|
|
|
namespace text_shaper {
|
|
|
|
void install(const char* font_dir, void (*log)(const char* line)) {
|
|
shutdown();
|
|
state = new State;
|
|
cache = new GlyphCache;
|
|
layouts = new LayoutCache;
|
|
cache->map.reserve(4096);
|
|
state->font_dir = font_dir;
|
|
state->log = log;
|
|
for (int i = 0; i < kFaceCount; i++) {
|
|
struct stat st;
|
|
const std::string path = state->font_dir + "/" + kFaces[i].file;
|
|
state->faces[i].present = stat(path.c_str(), &st) == 0 && S_ISREG(st.st_mode);
|
|
state->any_face = state->any_face || state->faces[i].present;
|
|
}
|
|
host::DeviceInfo device;
|
|
host::device_info(device);
|
|
set_language(*device.language ? device.language : "en");
|
|
state->buffer = hb_buffer_create();
|
|
state->raster = hb_raster_draw_create_or_fail();
|
|
hb_raster_draw_set_scale_factor(state->raster, 64, 64);
|
|
er_text_set_shaper(&kShaper);
|
|
}
|
|
|
|
void set_language(const char* tag) {
|
|
if (!state) return;
|
|
state->language = hb_language_from_string(tag, -1);
|
|
state->prefer_japanese = std::strncmp(tag, "ja", 2) == 0 && (tag[2] == '\0' || tag[2] == '-');
|
|
state->serial++;
|
|
}
|
|
|
|
void shutdown() {
|
|
if (!state) return;
|
|
er_text_set_shaper(nullptr);
|
|
delete layouts;
|
|
cache->clear();
|
|
delete cache;
|
|
for (Face& face : state->faces) {
|
|
for (auto& [size, font] : face.sizes) hb_font_destroy(font);
|
|
hb_font_destroy(face.probe);
|
|
hb_face_destroy(face.face);
|
|
}
|
|
hb_buffer_destroy(state->buffer);
|
|
hb_raster_draw_destroy(state->raster);
|
|
delete state;
|
|
state = nullptr;
|
|
layouts = nullptr;
|
|
cache = nullptr;
|
|
}
|
|
|
|
std::vector<std::pair<int, int>> lines(const char* text, const char* font_family, int font_size, int max_w) {
|
|
std::lock_guard lock(shaping);
|
|
const Layout& layout = layout_for(text, font_family, er_text_clamp_font_size(font_size), 0, 0, ER_DIRECTION_INHERIT);
|
|
bool truncated = false;
|
|
std::vector<std::pair<int, int>> out;
|
|
for (const Line& line : break_lines(layout, max_w, 0, truncated))
|
|
out.emplace_back(static_cast<int>(line.start), static_cast<int>(line.end));
|
|
return out;
|
|
}
|
|
|
|
} // namespace text_shaper
|