blob: fc1990cca6ef73fb5bfd5dc2a9b00c54525dcc9e [file] [log] [blame]
/*
* Copyright 2022 Rive
*/
#include "viewer/viewer_content.hpp"
#include "utils/rive_utf.hpp"
#include "rive/math/raw_path.hpp"
#include "rive/factory.hpp"
#include "rive/refcnt.hpp"
#include "rive/render_text.hpp"
#include "rive/text/line_breaker.hpp"
using RenderFontTextRuns = std::vector<rive::RenderTextRun>;
using RenderFontGlyphRuns = rive::SimpleArray<rive::RenderGlyphRun>;
using RenderFontFactory = rive::rcp<rive::RenderFont> (*)(const rive::Span<const uint8_t>);
static bool ws(rive::Unichar c) { return c <= ' '; }
std::vector<int> compute_word_breaks(rive::Span<rive::Unichar> chars) {
std::vector<int> breaks;
const unsigned len = chars.size();
for (unsigned i = 0; i < len;) {
// skip ws
while (i < len && ws(chars[i])) {
++i;
}
breaks.push_back(i); // word start
// skip non-ws
while (i < len && !ws(chars[i])) {
++i;
}
breaks.push_back(i); // word end
}
assert(breaks[breaks.size() - 1] == len);
return breaks;
}
static void drawrun(rive::Factory* factory,
rive::Renderer* renderer,
const rive::RenderGlyphRun& run,
unsigned startIndex,
unsigned endIndex,
rive::Vec2D origin) {
auto font = run.font.get();
const auto scale = rive::Mat2D::fromScale(run.size, run.size);
auto paint = factory->makeRenderPaint();
paint->color(0xFFFFFFFF);
assert(startIndex >= 0 && endIndex <= run.glyphs.size());
for (size_t i = startIndex; i < endIndex; ++i) {
auto trans = rive::Mat2D::fromTranslate(origin.x + run.xpos[i], origin.y);
auto rawpath = font->getPath(run.glyphs[i]);
rawpath.transformInPlace(trans * scale);
auto path = factory->makeRenderPath(rawpath, rive::FillRule::nonZero);
renderer->drawPath(path.get(), paint.get());
}
}
static void drawpara(rive::Factory* factory,
rive::Renderer* renderer,
rive::Span<const rive::RenderGlyphLine> lines,
rive::Span<const rive::RenderGlyphRun> runs,
rive::Vec2D origin) {
for (const auto& line : lines) {
const float x0 = runs[line.startRun].xpos[line.startIndex];
int startGIndex = line.startIndex;
for (int runIndex = line.startRun; runIndex <= line.endRun; ++runIndex) {
const auto& run = runs[runIndex];
int endGIndex = runIndex == line.endRun ? line.endIndex : run.glyphs.size();
drawrun(factory,
renderer,
run,
startGIndex,
endGIndex,
{origin.x - x0, origin.y + line.baseline});
startGIndex = 0;
}
}
}
////////////////////////////////////////////////////////////////////////////////////
#ifdef RIVE_USING_HAFBUZZ_FONTS
static rive::rcp<rive::RenderFont> load_fallback_font(rive::Span<const rive::Unichar> missing) {
static rive::rcp<rive::RenderFont> gFallbackFont;
printf("missing chars:");
for (auto m : missing) {
printf(" %X", m);
}
printf("\n");
if (!gFallbackFont) {
// TODO: make this more sharable for our test apps
FILE* fp = fopen("/Users/mike/fonts/Arial Unicode.ttf", "rb");
if (!fp) {
return nullptr;
}
fseek(fp, 0, SEEK_END);
size_t size = ftell(fp);
fseek(fp, 0, SEEK_SET);
std::vector<uint8_t> bytes(size);
size_t bytesRead = fread(bytes.data(), 1, size, fp);
fclose(fp);
assert(bytesRead == size);
gFallbackFont = HBRenderFont::Decode(bytes);
}
return gFallbackFont;
}
#endif
static std::unique_ptr<rive::RenderPath> make_line(rive::Factory* factory,
rive::Vec2D a,
rive::Vec2D b) {
rive::RawPath rawPath;
rawPath.move(a);
rawPath.line(b);
return factory->makeRenderPath(rawPath, rive::FillRule::nonZero);
}
static void draw_line(rive::Factory* factory, rive::Renderer* renderer, float x) {
auto paint = factory->makeRenderPaint();
paint->style(rive::RenderPaintStyle::stroke);
paint->thickness(1);
paint->color(0xFFFFFFFF);
auto path = make_line(factory, {x, 0}, {x, 1000});
renderer->drawPath(path.get(), paint.get());
}
static rive::RenderTextRun append(std::vector<rive::Unichar>* unichars,
rive::rcp<rive::RenderFont> font,
float size,
const char text[]) {
const uint8_t* ptr = (const uint8_t*)text;
uint32_t n = 0;
while (*ptr) {
unichars->push_back(rive::UTF::NextUTF8(&ptr));
n += 1;
}
return {std::move(font), size, n};
}
class TextContent : public ViewerContent {
std::vector<rive::Unichar> m_unichars;
std::vector<int> m_breaks;
std::vector<RenderFontGlyphRuns> m_gruns;
rive::Mat2D m_xform;
float m_width = 300;
RenderFontTextRuns make_truns(RenderFontFactory fact) {
auto loader = [fact](const char filename[]) -> rive::rcp<rive::RenderFont> {
auto bytes = ViewerContent::LoadFile(filename);
if (bytes.size() == 0) {
assert(false);
return nullptr;
}
return fact(bytes);
};
const char* fontFiles[] = {
"../../../test/assets/RobotoFlex.ttf",
"../../../test/assets/LibreBodoni-Italic-VariableFont_wght.ttf",
};
auto font0 = loader(fontFiles[0]);
auto font1 = loader(fontFiles[1]);
assert(font0);
assert(font1);
rive::RenderFont::Coord c1 = {'wght', 100.f}, c2 = {'wght', 800.f};
RenderFontTextRuns truns;
truns.push_back(append(&m_unichars, font0->makeAtCoord(c2), 60, "U"));
truns.push_back(append(&m_unichars, font0->makeAtCoord(c1), 30, "ne漢字asy"));
truns.push_back(append(&m_unichars, font1, 30, " fits the crown"));
truns.push_back(append(&m_unichars, font1->makeAtCoord(c1), 30, " that often"));
truns.push_back(append(&m_unichars, font0, 30, " lies the head."));
m_breaks = compute_word_breaks(m_unichars);
return truns;
}
public:
TextContent() {
auto truns = this->make_truns(ViewerContent::DecodeFont);
m_gruns.push_back(truns[0].font->shapeText(m_unichars, truns));
m_xform = rive::Mat2D::fromTranslate(10, 0) * rive::Mat2D::fromScale(3, 3);
}
void draw(rive::Renderer* renderer, float width, const RenderFontGlyphRuns& gruns) {
renderer->save();
renderer->transform(m_xform);
auto lines = rive::RenderGlyphLine::BreakLines(gruns, m_breaks, width);
drawpara(RiveFactory(), renderer, lines, gruns, {0, 0});
draw_line(RiveFactory(), renderer, width);
renderer->restore();
}
void handleDraw(rive::Renderer* renderer, double) override {
for (auto& grun : m_gruns) {
this->draw(renderer, m_width, grun);
renderer->translate(1200, 0);
}
}
void handleResize(int width, int height) override {}
void handleImgui() override {
ImGui::Begin("text", nullptr);
ImGui::SliderFloat("Width", &m_width, 10, 400);
ImGui::End();
}
};
static bool ends_width(const char str[], const char suffix[]) {
size_t ln = strlen(str);
size_t lx = strlen(suffix);
if (lx > ln) {
return false;
}
for (size_t i = 0; i < lx; ++i) {
if (str[ln - lx + i] != suffix[i]) {
return false;
}
}
return true;
}
std::unique_ptr<ViewerContent> ViewerContent::Text(const char filename[]) {
if (ends_width(filename, ".svg")) {
return std::make_unique<TextContent>();
}
return nullptr;
}