Something went wrong. Try again.
A fork of https://github.com/crosspoint-reader/crosspoint-reader
Something went wrong. Try again.
46 kB · 1289 lines
C++
at master
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290#include "GfxRenderer.h"
#include <FontDecompressor.h>#include <HalGPIO.h>#include <Logging.h>#include <Utf8.h>
#include "FontCacheManager.h"
const uint8_t* GfxRenderer::getGlyphBitmap(const EpdFontData* fontData, const EpdGlyph* glyph) const { if (fontData->groups != nullptr) { auto* fd = fontCacheManager_ ? fontCacheManager_->getDecompressor() : nullptr; if (!fd) { LOG_ERR("GFX", "Compressed font but no FontDecompressor set"); return nullptr; } uint32_t glyphIndex = static_cast<uint32_t>(glyph - fontData->glyph); // For page-buffer hits the pointer is stable for the page lifetime. // For hot-group hits it is valid only until the next getBitmap() call — callers // must consume it (draw the glyph) before requesting another bitmap. return fd->getBitmap(fontData, glyph, glyphIndex); } return &fontData->bitmap[glyph->dataOffset];}
void GfxRenderer::begin() { frameBuffer = display.getFrameBuffer(); if (!frameBuffer) { LOG_ERR("GFX", "!! No framebuffer"); assert(false); } panelWidth = display.getDisplayWidth(); panelHeight = display.getDisplayHeight(); panelWidthBytes = display.getDisplayWidthBytes(); frameBufferSize = display.getBufferSize(); bwBufferChunks.assign((frameBufferSize + BW_BUFFER_CHUNK_SIZE - 1) / BW_BUFFER_CHUNK_SIZE, nullptr);}
void GfxRenderer::insertFont(const int fontId, EpdFontFamily font) { fontMap.insert({fontId, font}); }
// Translate logical (x,y) coordinates to physical panel coordinates based on current orientation// This should always be inlined for better performancestatic inline void rotateCoordinates(const GfxRenderer::Orientation orientation, const int x, const int y, int* phyX, int* phyY, const uint16_t panelWidth, const uint16_t panelHeight) { switch (orientation) { case GfxRenderer::Portrait: { // Logical portrait (480x800) → panel (800x480) // Rotation: 90 degrees clockwise *phyX = y; *phyY = panelHeight - 1 - x; break; } case GfxRenderer::LandscapeClockwise: { // Logical landscape (800x480) rotated 180 degrees (swap top/bottom and left/right) *phyX = panelWidth - 1 - x; *phyY = panelHeight - 1 - y; break; } case GfxRenderer::PortraitInverted: { // Logical portrait (480x800) → panel (800x480) // Rotation: 90 degrees counter-clockwise *phyX = panelWidth - 1 - y; *phyY = x; break; } case GfxRenderer::LandscapeCounterClockwise: { // Logical landscape (800x480) aligned with panel orientation *phyX = x; *phyY = y; break; } }}
enum class TextRotation { None, Rotated90CW };
// Shared glyph rendering logic for normal and rotated text.// Coordinate mapping and cursor advance direction are selected at compile time via the template parameter.template <TextRotation rotation>static void renderCharImpl(const GfxRenderer& renderer, GfxRenderer::RenderMode renderMode, const EpdFontFamily& fontFamily, const uint32_t cp, int cursorX, int cursorY, const bool pixelState, const EpdFontFamily::Style style) { const EpdGlyph* glyph = fontFamily.getGlyph(cp, style); if (!glyph) { LOG_ERR("GFX", "No glyph for codepoint %d", cp); return; }
const EpdFontData* fontData = fontFamily.getData(style); const bool is2Bit = fontData->is2Bit; const uint8_t width = glyph->width; const uint8_t height = glyph->height; const int left = glyph->left; const int top = glyph->top;
const uint8_t* bitmap = renderer.getGlyphBitmap(fontData, glyph);
if (bitmap != nullptr) { // For Normal: outer loop advances screenY, inner loop advances screenX // For Rotated: outer loop advances screenX, inner loop advances screenY (in reverse) int outerBase, innerBase; if constexpr (rotation == TextRotation::Rotated90CW) { outerBase = cursorX + fontData->ascender - top; // screenX = outerBase + glyphY innerBase = cursorY - left; // screenY = innerBase - glyphX } else { outerBase = cursorY - top; // screenY = outerBase + glyphY innerBase = cursorX + left; // screenX = innerBase + glyphX }
if (is2Bit) { int pixelPosition = 0; for (int glyphY = 0; glyphY < height; glyphY++) { const int outerCoord = outerBase + glyphY; for (int glyphX = 0; glyphX < width; glyphX++, pixelPosition++) { int screenX, screenY; if constexpr (rotation == TextRotation::Rotated90CW) { screenX = outerCoord; screenY = innerBase - glyphX; } else { screenX = innerBase + glyphX; screenY = outerCoord; }
const uint8_t byte = bitmap[pixelPosition >> 2]; const uint8_t bit_index = (3 - (pixelPosition & 3)) * 2; // the direct bit from the font is 0 -> white, 1 -> light gray, 2 -> dark gray, 3 -> black // we swap this to better match the way images and screen think about colors: // 0 -> black, 1 -> dark grey, 2 -> light grey, 3 -> white const uint8_t bmpVal = 3 - ((byte >> bit_index) & 0x3);
if (renderMode == GfxRenderer::BW && bmpVal < 3) { // Black (also paints over the grays in BW mode) renderer.drawPixel(screenX, screenY, pixelState); } else if (renderMode == GfxRenderer::GRAYSCALE_MSB && (bmpVal == 1 || bmpVal == 2)) { // Light gray (also mark the MSB if it's going to be a dark gray too) // Dedicated X3 gray LUTs now provide proper 4-level gray on both devices // We have to flag pixels in reverse for the gray buffers, as 0 leave alone, 1 update renderer.drawPixel(screenX, screenY, false); } else if (renderMode == GfxRenderer::GRAYSCALE_LSB && bmpVal == 1) { // Dark gray renderer.drawPixel(screenX, screenY, false); } } } } else { int pixelPosition = 0; for (int glyphY = 0; glyphY < height; glyphY++) { const int outerCoord = outerBase + glyphY; for (int glyphX = 0; glyphX < width; glyphX++, pixelPosition++) { int screenX, screenY; if constexpr (rotation == TextRotation::Rotated90CW) { screenX = outerCoord; screenY = innerBase - glyphX; } else { screenX = innerBase + glyphX; screenY = outerCoord; }
const uint8_t byte = bitmap[pixelPosition >> 3]; const uint8_t bit_index = 7 - (pixelPosition & 7);
if ((byte >> bit_index) & 1) { renderer.drawPixel(screenX, screenY, pixelState); } } } } }}
// IMPORTANT: This function is in critical rendering path and is called for every pixel. Please keep it as simple and// efficient as possible.void GfxRenderer::drawPixel(const int x, const int y, const bool state) const { int phyX = 0; int phyY = 0;
// Note: this call should be inlined for better performance rotateCoordinates(orientation, x, y, &phyX, &phyY, panelWidth, panelHeight);
// Bounds checking against runtime panel dimensions if (phyX < 0 || phyX >= panelWidth || phyY < 0 || phyY >= panelHeight) { LOG_ERR("GFX", "!! Outside range (%d, %d) -> (%d, %d)", x, y, phyX, phyY); return; }
// Calculate byte position and bit position const uint32_t byteIndex = static_cast<uint32_t>(phyY) * panelWidthBytes + (phyX / 8); const uint8_t bitPosition = 7 - (phyX % 8); // MSB first
if (state) { frameBuffer[byteIndex] &= ~(1 << bitPosition); // Clear bit } else { frameBuffer[byteIndex] |= 1 << bitPosition; // Set bit }}
int GfxRenderer::getTextWidth(const int fontId, const char* text, const EpdFontFamily::Style style) const { const auto fontIt = fontMap.find(fontId); if (fontIt == fontMap.end()) { LOG_ERR("GFX", "Font %d not found", fontId); return 0; }
int w = 0, h = 0; fontIt->second.getTextDimensions(text, &w, &h, style); return w;}
void GfxRenderer::drawCenteredText(const int fontId, const int y, const char* text, const bool black, const EpdFontFamily::Style style) const { const int x = (getScreenWidth() - getTextWidth(fontId, text, style)) / 2; drawText(fontId, x, y, text, black, style);}
void GfxRenderer::drawText(const int fontId, const int x, const int y, const char* text, const bool black, const EpdFontFamily::Style style) const { const int yPos = y + getFontAscenderSize(fontId); int lastBaseX = x; int lastBaseLeft = 0; int lastBaseWidth = 0; int lastBaseTop = 0; int32_t prevAdvanceFP = 0; // 12.4 fixed-point: prev glyph's advance + next kern for snap
// cannot draw a NULL / empty string if (text == nullptr || *text == '\0') { return; }
if (fontCacheManager_ && fontCacheManager_->isScanning()) { fontCacheManager_->recordText(text, fontId, style); return; }
const auto fontIt = fontMap.find(fontId); if (fontIt == fontMap.end()) { LOG_ERR("GFX", "Font %d not found", fontId); return; } const auto& font = fontIt->second;
uint32_t cp; uint32_t prevCp = 0; while ((cp = utf8NextCodepoint(reinterpret_cast<const uint8_t**>(&text)))) { if (utf8IsCombiningMark(cp)) { const EpdGlyph* combiningGlyph = font.getGlyph(cp, style); if (!combiningGlyph) continue; const int raiseBy = combiningMark::raiseAboveBase(combiningGlyph->top, combiningGlyph->height, lastBaseTop); const int combiningX = combiningMark::centerOver(lastBaseX, lastBaseLeft, lastBaseWidth, combiningGlyph->left, combiningGlyph->width); renderCharImpl<TextRotation::None>(*this, renderMode, font, cp, combiningX, yPos - raiseBy, black, style); continue; }
cp = font.applyLigatures(cp, text, style);
// Differential rounding: snap (previous advance + current kern) as one unit so // identical character pairs always produce the same pixel step regardless of // where they fall on the line. if (prevCp != 0) { const auto kernFP = font.getKerning(prevCp, cp, style); // 4.4 fixed-point kern lastBaseX += fp4::toPixel(prevAdvanceFP + kernFP); // snap 12.4 fixed-point to nearest pixel }
const EpdGlyph* glyph = font.getGlyph(cp, style);
lastBaseLeft = glyph ? glyph->left : 0; lastBaseWidth = glyph ? glyph->width : 0; lastBaseTop = glyph ? glyph->top : 0; prevAdvanceFP = glyph ? glyph->advanceX : 0; // 12.4 fixed-point
renderCharImpl<TextRotation::None>(*this, renderMode, font, cp, lastBaseX, yPos, black, style); prevCp = cp; }}
void GfxRenderer::drawLine(int x1, int y1, int x2, int y2, const bool state) const { if (fontCacheManager_ && fontCacheManager_->isScanning()) return; if (x1 == x2) { if (y2 < y1) { std::swap(y1, y2); } for (int y = y1; y <= y2; y++) { drawPixel(x1, y, state); } } else if (y1 == y2) { if (x2 < x1) { std::swap(x1, x2); } for (int x = x1; x <= x2; x++) { drawPixel(x, y1, state); } } else { // Bresenham's line algorithm — integer arithmetic only int dx = x2 - x1; int dy = y2 - y1; int sx = (dx > 0) ? 1 : -1; int sy = (dy > 0) ? 1 : -1; dx = sx * dx; // abs dy = sy * dy; // abs
int err = dx - dy; while (true) { drawPixel(x1, y1, state); if (x1 == x2 && y1 == y2) break; int e2 = 2 * err; if (e2 > -dy) { err -= dy; x1 += sx; } if (e2 < dx) { err += dx; y1 += sy; } } }}
void GfxRenderer::drawLine(int x1, int y1, int x2, int y2, const int lineWidth, const bool state) const { for (int i = 0; i < lineWidth; i++) { drawLine(x1, y1 + i, x2, y2 + i, state); }}
void GfxRenderer::drawRect(const int x, const int y, const int width, const int height, const bool state) const { drawLine(x, y, x + width - 1, y, state); drawLine(x + width - 1, y, x + width - 1, y + height - 1, state); drawLine(x + width - 1, y + height - 1, x, y + height - 1, state); drawLine(x, y, x, y + height - 1, state);}
// Border is inside the rectanglevoid GfxRenderer::drawRect(const int x, const int y, const int width, const int height, const int lineWidth, const bool state) const { for (int i = 0; i < lineWidth; i++) { drawLine(x + i, y + i, x + width - i, y + i, state); drawLine(x + width - i, y + i, x + width - i, y + height - i, state); drawLine(x + width - i, y + height - i, x + i, y + height - i, state); drawLine(x + i, y + height - i, x + i, y + i, state); }}
void GfxRenderer::drawArc(const int maxRadius, const int cx, const int cy, const int xDir, const int yDir, const int lineWidth, const bool state) const { const int stroke = std::min(lineWidth, maxRadius); const int innerRadius = std::max(maxRadius - stroke, 0); const int outerRadius = maxRadius;
if (outerRadius <= 0) { return; }
const int outerRadiusSq = outerRadius * outerRadius; const int innerRadiusSq = innerRadius * innerRadius;
int xOuter = outerRadius; int xInner = innerRadius;
for (int dy = 0; dy <= outerRadius; ++dy) { while (xOuter > 0 && (xOuter * xOuter + dy * dy) > outerRadiusSq) { --xOuter; } // Keep the smallest x that still lies outside/at the inner radius, // i.e. (x^2 + y^2) >= innerRadiusSq. while (xInner > 0 && ((xInner - 1) * (xInner - 1) + dy * dy) >= innerRadiusSq) { --xInner; }
if (xOuter < xInner) { continue; }
const int x0 = cx + xDir * xInner; const int x1 = cx + xDir * xOuter; const int left = std::min(x0, x1); const int width = std::abs(x1 - x0) + 1; const int py = cy + yDir * dy;
if (width > 0) { fillRect(left, py, width, 1, state); } }};
// Border is inside the rectangle, rounded cornersvoid GfxRenderer::drawRoundedRect(const int x, const int y, const int width, const int height, const int lineWidth, const int cornerRadius, bool state) const { drawRoundedRect(x, y, width, height, lineWidth, cornerRadius, true, true, true, true, state);}
// Border is inside the rectangle, rounded cornersvoid GfxRenderer::drawRoundedRect(const int x, const int y, const int width, const int height, const int lineWidth, const int cornerRadius, bool roundTopLeft, bool roundTopRight, bool roundBottomLeft, bool roundBottomRight, bool state) const { if (lineWidth <= 0 || width <= 0 || height <= 0) { return; }
const int maxRadius = std::min({cornerRadius, width / 2, height / 2}); if (maxRadius <= 0) { drawRect(x, y, width, height, lineWidth, state); return; }
const int stroke = std::min(lineWidth, maxRadius); const int right = x + width - 1; const int bottom = y + height - 1;
const int horizontalWidth = width - 2 * maxRadius; if (horizontalWidth > 0) { if (roundTopLeft || roundTopRight) { fillRect(x + maxRadius, y, horizontalWidth, stroke, state); } if (roundBottomLeft || roundBottomRight) { fillRect(x + maxRadius, bottom - stroke + 1, horizontalWidth, stroke, state); } }
const int verticalHeight = height - 2 * maxRadius; if (verticalHeight > 0) { if (roundTopLeft || roundBottomLeft) { fillRect(x, y + maxRadius, stroke, verticalHeight, state); } if (roundTopRight || roundBottomRight) { fillRect(right - stroke + 1, y + maxRadius, stroke, verticalHeight, state); } }
if (roundTopLeft) { drawArc(maxRadius, x + maxRadius, y + maxRadius, -1, -1, lineWidth, state); } if (roundTopRight) { drawArc(maxRadius, right - maxRadius, y + maxRadius, 1, -1, lineWidth, state); } if (roundBottomRight) { drawArc(maxRadius, right - maxRadius, bottom - maxRadius, 1, 1, lineWidth, state); } if (roundBottomLeft) { drawArc(maxRadius, x + maxRadius, bottom - maxRadius, -1, 1, lineWidth, state); }}
void GfxRenderer::fillRect(const int x, const int y, const int width, const int height, const bool state) const { for (int fillY = y; fillY < y + height; fillY++) { drawLine(x, fillY, x + width - 1, fillY, state); }}
// NOTE: Those are in critical path, and need to be templated to avoid runtime checks for every pixel.// Any branching must be done outside the loops to avoid performance degradation.template <>void GfxRenderer::drawPixelDither<Color::Clear>(const int x, const int y) const { // Do nothing}
template <>void GfxRenderer::drawPixelDither<Color::Black>(const int x, const int y) const { drawPixel(x, y, true);}
template <>void GfxRenderer::drawPixelDither<Color::White>(const int x, const int y) const { drawPixel(x, y, false);}
template <>void GfxRenderer::drawPixelDither<Color::LightGray>(const int x, const int y) const { drawPixel(x, y, x % 2 == 0 && y % 2 == 0);}
template <>void GfxRenderer::drawPixelDither<Color::DarkGray>(const int x, const int y) const { drawPixel(x, y, (x + y) % 2 == 0); // TODO: maybe find a better pattern?}
void GfxRenderer::fillRectDither(const int x, const int y, const int width, const int height, Color color) const { if (color == Color::Clear) { } else if (color == Color::Black) { fillRect(x, y, width, height, true); } else if (color == Color::White) { fillRect(x, y, width, height, false); } else if (color == Color::LightGray) { for (int fillY = y; fillY < y + height; fillY++) { for (int fillX = x; fillX < x + width; fillX++) { drawPixelDither<Color::LightGray>(fillX, fillY); } } } else if (color == Color::DarkGray) { for (int fillY = y; fillY < y + height; fillY++) { for (int fillX = x; fillX < x + width; fillX++) { drawPixelDither<Color::DarkGray>(fillX, fillY); } } }}
template <Color color>void GfxRenderer::fillArc(const int maxRadius, const int cx, const int cy, const int xDir, const int yDir) const { if (maxRadius <= 0) return;
if constexpr (color == Color::Clear) { return; }
const int radiusSq = maxRadius * maxRadius;
// Avoid sqrt by scanning from outer radius inward while y grows. int x = maxRadius; for (int dy = 0; dy <= maxRadius; ++dy) { while (x > 0 && (x * x + dy * dy) > radiusSq) { --x; } if (x < 0) break;
const int py = cy + yDir * dy; if (py < 0 || py >= getScreenHeight()) continue;
int x0 = cx; int x1 = cx + xDir * x; if (x0 > x1) std::swap(x0, x1); const int width = x1 - x0 + 1;
if (width <= 0) continue;
if constexpr (color == Color::Black) { fillRect(x0, py, width, 1, true); } else if constexpr (color == Color::White) { fillRect(x0, py, width, 1, false); } else { // LightGray / DarkGray: use existing dithered fill path. fillRectDither(x0, py, width, 1, color); } }}
void GfxRenderer::fillRoundedRect(const int x, const int y, const int width, const int height, const int cornerRadius, const Color color) const { fillRoundedRect(x, y, width, height, cornerRadius, true, true, true, true, color);}
void GfxRenderer::fillRoundedRect(const int x, const int y, const int width, const int height, const int cornerRadius, bool roundTopLeft, bool roundTopRight, bool roundBottomLeft, bool roundBottomRight, const Color color) const { if (width <= 0 || height <= 0) { return; }
// Assume if we're not rounding all corners then we are only rounding one side const int roundedSides = (!roundTopLeft || !roundTopRight || !roundBottomLeft || !roundBottomRight) ? 1 : 2; const int maxRadius = std::min({cornerRadius, width / roundedSides, height / roundedSides}); if (maxRadius <= 0) { fillRectDither(x, y, width, height, color); return; }
const int horizontalWidth = width - 2 * maxRadius; if (horizontalWidth > 0) { fillRectDither(x + maxRadius + 1, y, horizontalWidth - 2, height, color); }
const int leftFillTop = y + (roundTopLeft ? (maxRadius + 1) : 0); const int leftFillBottom = y + height - 1 - (roundBottomLeft ? (maxRadius + 1) : 0); if (leftFillBottom >= leftFillTop) { fillRectDither(x, leftFillTop, maxRadius + 1, leftFillBottom - leftFillTop + 1, color); }
const int rightFillTop = y + (roundTopRight ? (maxRadius + 1) : 0); const int rightFillBottom = y + height - 1 - (roundBottomRight ? (maxRadius + 1) : 0); if (rightFillBottom >= rightFillTop) { fillRectDither(x + width - maxRadius - 1, rightFillTop, maxRadius + 1, rightFillBottom - rightFillTop + 1, color); }
auto fillArcTemplated = [this](int maxRadius, int cx, int cy, int xDir, int yDir, Color color) { switch (color) { case Color::Clear: break; case Color::Black: fillArc<Color::Black>(maxRadius, cx, cy, xDir, yDir); break; case Color::White: fillArc<Color::White>(maxRadius, cx, cy, xDir, yDir); break; case Color::LightGray: fillArc<Color::LightGray>(maxRadius, cx, cy, xDir, yDir); break; case Color::DarkGray: fillArc<Color::DarkGray>(maxRadius, cx, cy, xDir, yDir); break; } };
if (roundTopLeft) { fillArcTemplated(maxRadius, x + maxRadius, y + maxRadius, -1, -1, color); }
if (roundTopRight) { fillArcTemplated(maxRadius, x + width - maxRadius - 1, y + maxRadius, 1, -1, color); }
if (roundBottomRight) { fillArcTemplated(maxRadius, x + width - maxRadius - 1, y + height - maxRadius - 1, 1, 1, color); }
if (roundBottomLeft) { fillArcTemplated(maxRadius, x + maxRadius, y + height - maxRadius - 1, -1, 1, color); }}
void GfxRenderer::drawImage(const uint8_t bitmap[], const int x, const int y, const int width, const int height) const { int rotatedX = 0; int rotatedY = 0; rotateCoordinates(orientation, x, y, &rotatedX, &rotatedY, panelWidth, panelHeight); // Rotate origin corner switch (orientation) { case Portrait: rotatedY = rotatedY - height; break; case PortraitInverted: rotatedX = rotatedX - width; break; case LandscapeClockwise: rotatedY = rotatedY - height; rotatedX = rotatedX - width; break; case LandscapeCounterClockwise: break; } // TODO: Rotate bits display.drawImage(bitmap, rotatedX, rotatedY, width, height);}
void GfxRenderer::drawIcon(const uint8_t bitmap[], const int x, const int y, const int width, const int height) const { display.drawImageTransparent(bitmap, y, getScreenWidth() - width - x, height, width);}
void GfxRenderer::drawBitmap(const Bitmap& bitmap, const int x, const int y, const int maxWidth, const int maxHeight, const float cropX, const float cropY) const { if (fontCacheManager_ && fontCacheManager_->isScanning()) return; // For 1-bit bitmaps, use optimized 1-bit rendering path (no crop support for 1-bit) if (bitmap.is1Bit() && cropX == 0.0f && cropY == 0.0f) { drawBitmap1Bit(bitmap, x, y, maxWidth, maxHeight); return; }
float scale = 1.0f; bool isScaled = false; int cropPixX = std::floor(bitmap.getWidth() * cropX / 2.0f); int cropPixY = std::floor(bitmap.getHeight() * cropY / 2.0f); LOG_DBG("GFX", "Cropping %dx%d by %dx%d pix, is %s", bitmap.getWidth(), bitmap.getHeight(), cropPixX, cropPixY, bitmap.isTopDown() ? "top-down" : "bottom-up");
const float croppedWidth = (1.0f - cropX) * static_cast<float>(bitmap.getWidth()); const float croppedHeight = (1.0f - cropY) * static_cast<float>(bitmap.getHeight()); bool hasTargetBounds = false; float fitScale = 1.0f;
if (maxWidth > 0 && croppedWidth > 0.0f) { fitScale = static_cast<float>(maxWidth) / croppedWidth; hasTargetBounds = true; }
if (maxHeight > 0 && croppedHeight > 0.0f) { const float heightScale = static_cast<float>(maxHeight) / croppedHeight; fitScale = hasTargetBounds ? std::min(fitScale, heightScale) : heightScale; hasTargetBounds = true; }
if (hasTargetBounds && fitScale < 1.0f) { scale = fitScale; isScaled = true; } LOG_DBG("GFX", "Scaling by %f - %s", scale, isScaled ? "scaled" : "not scaled");
// Calculate output row size (2 bits per pixel, packed into bytes) // IMPORTANT: Use int, not uint8_t, to avoid overflow for images > 1020 pixels wide const int outputRowSize = (bitmap.getWidth() + 3) / 4; auto* outputRow = static_cast<uint8_t*>(malloc(outputRowSize)); auto* rowBytes = static_cast<uint8_t*>(malloc(bitmap.getRowBytes()));
if (!outputRow || !rowBytes) { LOG_ERR("GFX", "!! Failed to allocate BMP row buffers"); free(outputRow); free(rowBytes); return; }
for (int bmpY = 0; bmpY < (bitmap.getHeight() - cropPixY); bmpY++) { // The BMP's (0, 0) is the bottom-left corner (if the height is positive, top-left if negative). // Screen's (0, 0) is the top-left corner. int screenY = -cropPixY + (bitmap.isTopDown() ? bmpY : bitmap.getHeight() - 1 - bmpY); if (isScaled) { screenY = std::floor(screenY * scale); } screenY += y; // the offset should not be scaled if (screenY >= getScreenHeight()) { break; }
if (bitmap.readNextRow(outputRow, rowBytes) != BmpReaderError::Ok) { LOG_ERR("GFX", "Failed to read row %d from bitmap", bmpY); free(outputRow); free(rowBytes); return; }
if (screenY < 0) { continue; }
if (bmpY < cropPixY) { // Skip the row if it's outside the crop area continue; }
for (int bmpX = cropPixX; bmpX < bitmap.getWidth() - cropPixX; bmpX++) { int screenX = bmpX - cropPixX; if (isScaled) { screenX = std::floor(screenX * scale); } screenX += x; // the offset should not be scaled if (screenX >= getScreenWidth()) { break; } if (screenX < 0) { continue; }
const uint8_t val = outputRow[bmpX / 4] >> (6 - ((bmpX * 2) % 8)) & 0x3;
if (renderMode == BW && val < 3) { drawPixel(screenX, screenY); } else if (renderMode == GRAYSCALE_MSB && (val == 1 || val == 2)) { drawPixel(screenX, screenY, false); } else if (renderMode == GRAYSCALE_LSB && val == 1) { drawPixel(screenX, screenY, false); } } }
free(outputRow); free(rowBytes);}
void GfxRenderer::drawBitmap1Bit(const Bitmap& bitmap, const int x, const int y, const int maxWidth, const int maxHeight) const { float scale = 1.0f; bool isScaled = false; if (maxWidth > 0 && bitmap.getWidth() > maxWidth) { scale = static_cast<float>(maxWidth) / static_cast<float>(bitmap.getWidth()); isScaled = true; } if (maxHeight > 0 && bitmap.getHeight() > maxHeight) { scale = std::min(scale, static_cast<float>(maxHeight) / static_cast<float>(bitmap.getHeight())); isScaled = true; }
// For 1-bit BMP, output is still 2-bit packed (for consistency with readNextRow) const int outputRowSize = (bitmap.getWidth() + 3) / 4; auto* outputRow = static_cast<uint8_t*>(malloc(outputRowSize)); auto* rowBytes = static_cast<uint8_t*>(malloc(bitmap.getRowBytes()));
if (!outputRow || !rowBytes) { LOG_ERR("GFX", "!! Failed to allocate 1-bit BMP row buffers"); free(outputRow); free(rowBytes); return; }
for (int bmpY = 0; bmpY < bitmap.getHeight(); bmpY++) { // Read rows sequentially using readNextRow if (bitmap.readNextRow(outputRow, rowBytes) != BmpReaderError::Ok) { LOG_ERR("GFX", "Failed to read row %d from 1-bit bitmap", bmpY); free(outputRow); free(rowBytes); return; }
// Calculate screen Y based on whether BMP is top-down or bottom-up const int bmpYOffset = bitmap.isTopDown() ? bmpY : bitmap.getHeight() - 1 - bmpY; int screenY = y + (isScaled ? static_cast<int>(std::floor(bmpYOffset * scale)) : bmpYOffset); if (screenY >= getScreenHeight()) { continue; // Continue reading to keep row counter in sync } if (screenY < 0) { continue; }
for (int bmpX = 0; bmpX < bitmap.getWidth(); bmpX++) { int screenX = x + (isScaled ? static_cast<int>(std::floor(bmpX * scale)) : bmpX); if (screenX >= getScreenWidth()) { break; } if (screenX < 0) { continue; }
// Get 2-bit value (result of readNextRow quantization) const uint8_t val = outputRow[bmpX / 4] >> (6 - ((bmpX * 2) % 8)) & 0x3;
// For 1-bit source: 0 or 1 -> map to black (0,1,2) or white (3) // val < 3 means black pixel (draw it) if (val < 3) { drawPixel(screenX, screenY, true); } // White pixels (val == 3) are not drawn (leave background) } }
free(outputRow); free(rowBytes);}
void GfxRenderer::fillPolygon(const int* xPoints, const int* yPoints, int numPoints, bool state) const { if (numPoints < 3) return;
// Find bounding box int minY = yPoints[0], maxY = yPoints[0]; for (int i = 1; i < numPoints; i++) { if (yPoints[i] < minY) minY = yPoints[i]; if (yPoints[i] > maxY) maxY = yPoints[i]; }
// Clip to screen if (minY < 0) minY = 0; if (maxY >= getScreenHeight()) maxY = getScreenHeight() - 1;
// Allocate node buffer for scanline algorithm auto* nodeX = static_cast<int*>(malloc(numPoints * sizeof(int))); if (!nodeX) { LOG_ERR("GFX", "!! Failed to allocate polygon node buffer"); return; }
// Scanline fill algorithm for (int scanY = minY; scanY <= maxY; scanY++) { int nodes = 0;
// Find all intersection points with edges int j = numPoints - 1; for (int i = 0; i < numPoints; i++) { if ((yPoints[i] < scanY && yPoints[j] >= scanY) || (yPoints[j] < scanY && yPoints[i] >= scanY)) { // Calculate X intersection using fixed-point to avoid float int dy = yPoints[j] - yPoints[i]; if (dy != 0) { nodeX[nodes++] = xPoints[i] + (scanY - yPoints[i]) * (xPoints[j] - xPoints[i]) / dy; } } j = i; }
// Sort nodes by X (simple bubble sort, numPoints is small) for (int i = 0; i < nodes - 1; i++) { for (int k = i + 1; k < nodes; k++) { if (nodeX[i] > nodeX[k]) { int temp = nodeX[i]; nodeX[i] = nodeX[k]; nodeX[k] = temp; } } }
// Fill between pairs of nodes for (int i = 0; i < nodes - 1; i += 2) { int startX = nodeX[i]; int endX = nodeX[i + 1];
// Clip to screen if (startX < 0) startX = 0; if (endX >= getScreenWidth()) endX = getScreenWidth() - 1;
// Draw horizontal line for (int x = startX; x <= endX; x++) { drawPixel(x, scanY, state); } } }
free(nodeX);}
// For performance measurement (using static to allow "const" methods)static unsigned long start_ms = 0;
void GfxRenderer::clearScreen(const uint8_t color) const { start_ms = millis(); display.clearScreen(color);}
void GfxRenderer::invertScreen() const { for (uint32_t i = 0; i < frameBufferSize; i++) { frameBuffer[i] = ~frameBuffer[i]; }}
void GfxRenderer::displayBuffer(const HalDisplay::RefreshMode refreshMode) const { auto elapsed = millis() - start_ms; LOG_DBG("GFX", "Time = %lu ms from clearScreen to displayBuffer", elapsed); display.displayBuffer(refreshMode, fadingFix);}
std::string GfxRenderer::truncatedText(const int fontId, const char* text, const int maxWidth, const EpdFontFamily::Style style) const { if (!text || maxWidth <= 0) return "";
std::string item = text; // U+2026 HORIZONTAL ELLIPSIS (UTF-8: 0xE2 0x80 0xA6) const char* ellipsis = "\xe2\x80\xa6"; int textWidth = getTextWidth(fontId, item.c_str(), style); if (textWidth <= maxWidth) { // Text fits, return as is return item; }
while (!item.empty() && getTextWidth(fontId, (item + ellipsis).c_str(), style) >= maxWidth) { utf8RemoveLastChar(item); }
return item.empty() ? ellipsis : item + ellipsis;}
std::vector<std::string> GfxRenderer::wrappedText(const int fontId, const char* text, const int maxWidth, const int maxLines, const EpdFontFamily::Style style) const { std::vector<std::string> lines;
if (!text || maxWidth <= 0 || maxLines <= 0) return lines;
std::string remaining = text; std::string currentLine;
while (!remaining.empty()) { if (static_cast<int>(lines.size()) == maxLines - 1) { // Last available line: combine any word already started on this line with // the rest of the text, then let truncatedText fit it with an ellipsis. std::string lastContent = currentLine.empty() ? remaining : currentLine + " " + remaining; lines.push_back(truncatedText(fontId, lastContent.c_str(), maxWidth, style)); return lines; }
// Find next word size_t spacePos = remaining.find(' '); std::string word;
if (spacePos == std::string::npos) { word = remaining; remaining.clear(); } else { word = remaining.substr(0, spacePos); remaining.erase(0, spacePos + 1); }
std::string testLine = currentLine.empty() ? word : currentLine + " " + word;
if (getTextWidth(fontId, testLine.c_str(), style) <= maxWidth) { currentLine = testLine; } else { if (!currentLine.empty()) { lines.push_back(currentLine); // If the carried-over word itself exceeds maxWidth, truncate it and // push it as a complete line immediately — storing it in currentLine // would allow a subsequent short word to be appended after the ellipsis. if (getTextWidth(fontId, word.c_str(), style) > maxWidth) { lines.push_back(truncatedText(fontId, word.c_str(), maxWidth, style)); currentLine.clear(); if (static_cast<int>(lines.size()) >= maxLines) return lines; } else { currentLine = word; } } else { // Single word wider than maxWidth: truncate and stop to avoid complicated // splitting rules (different between languages). Results in an aesthetically // pleasing end. lines.push_back(truncatedText(fontId, word.c_str(), maxWidth, style)); return lines; } } }
if (!currentLine.empty() && static_cast<int>(lines.size()) < maxLines) { lines.push_back(currentLine); }
return lines;}
// Note: Internal driver treats screen in command orientation; this library exposes a logical orientationint GfxRenderer::getScreenWidth() const { switch (orientation) { case Portrait: case PortraitInverted: // 480px wide in portrait logical coordinates return panelHeight; case LandscapeClockwise: case LandscapeCounterClockwise: // 800px wide in landscape logical coordinates return panelWidth; } return panelHeight;}
int GfxRenderer::getScreenHeight() const { switch (orientation) { case Portrait: case PortraitInverted: // 800px tall in portrait logical coordinates return panelWidth; case LandscapeClockwise: case LandscapeCounterClockwise: // 480px tall in landscape logical coordinates return panelHeight; } return panelWidth;}
int GfxRenderer::getSpaceWidth(const int fontId, const EpdFontFamily::Style style) const { const auto fontIt = fontMap.find(fontId); if (fontIt == fontMap.end()) { LOG_ERR("GFX", "Font %d not found", fontId); return 0; }
const EpdGlyph* spaceGlyph = fontIt->second.getGlyph(' ', style); return spaceGlyph ? fp4::toPixel(spaceGlyph->advanceX) : 0; // snap 12.4 fixed-point to nearest pixel}
int GfxRenderer::getSpaceAdvance(const int fontId, const uint32_t leftCp, const uint32_t rightCp, const EpdFontFamily::Style style) const { const auto fontIt = fontMap.find(fontId); if (fontIt == fontMap.end()) return 0; const auto& font = fontIt->second; const EpdGlyph* spaceGlyph = font.getGlyph(' ', style); const int32_t spaceAdvanceFP = spaceGlyph ? static_cast<int32_t>(spaceGlyph->advanceX) : 0; // Combine space advance + flanking kern into one fixed-point sum before snapping. // Snapping the combined value avoids the +/-1 px error from snapping each component separately. const int32_t kernFP = static_cast<int32_t>(font.getKerning(leftCp, ' ', style)) + static_cast<int32_t>(font.getKerning(' ', rightCp, style)); return fp4::toPixel(spaceAdvanceFP + kernFP);}
int GfxRenderer::getKerning(const int fontId, const uint32_t leftCp, const uint32_t rightCp, const EpdFontFamily::Style style) const { const auto fontIt = fontMap.find(fontId); if (fontIt == fontMap.end()) return 0; const int kernFP = fontIt->second.getKerning(leftCp, rightCp, style); // 4.4 fixed-point return fp4::toPixel(kernFP); // snap 4.4 fixed-point to nearest pixel}
int GfxRenderer::getTextAdvanceX(const int fontId, const char* text, EpdFontFamily::Style style) const { const auto fontIt = fontMap.find(fontId); if (fontIt == fontMap.end()) { LOG_ERR("GFX", "Font %d not found", fontId); return 0; }
uint32_t cp; uint32_t prevCp = 0; int widthPx = 0; int32_t prevAdvanceFP = 0; // 12.4 fixed-point: prev glyph's advance + next kern for snap const auto& font = fontIt->second; while ((cp = utf8NextCodepoint(reinterpret_cast<const uint8_t**>(&text)))) { if (utf8IsCombiningMark(cp)) { continue; } cp = font.applyLigatures(cp, text, style);
// Differential rounding: snap (previous advance + current kern) together, // matching drawText so measurement and rendering agree exactly. if (prevCp != 0) { const auto kernFP = font.getKerning(prevCp, cp, style); // 4.4 fixed-point kern widthPx += fp4::toPixel(prevAdvanceFP + kernFP); // snap 12.4 fixed-point to nearest pixel }
const EpdGlyph* glyph = font.getGlyph(cp, style); prevAdvanceFP = glyph ? glyph->advanceX : 0; prevCp = cp; } widthPx += fp4::toPixel(prevAdvanceFP); // final glyph's advance return widthPx;}
int GfxRenderer::getFontAscenderSize(const int fontId) const { const auto fontIt = fontMap.find(fontId); if (fontIt == fontMap.end()) { LOG_ERR("GFX", "Font %d not found", fontId); return 0; }
return fontIt->second.getData(EpdFontFamily::REGULAR)->ascender;}
int GfxRenderer::getLineHeight(const int fontId) const { const auto fontIt = fontMap.find(fontId); if (fontIt == fontMap.end()) { LOG_ERR("GFX", "Font %d not found", fontId); return 0; }
return fontIt->second.getData(EpdFontFamily::REGULAR)->advanceY;}
int GfxRenderer::getTextHeight(const int fontId) const { const auto fontIt = fontMap.find(fontId); if (fontIt == fontMap.end()) { LOG_ERR("GFX", "Font %d not found", fontId); return 0; } return fontIt->second.getData(EpdFontFamily::REGULAR)->ascender;}
void GfxRenderer::drawTextRotated90CW(const int fontId, const int x, const int y, const char* text, const bool black, const EpdFontFamily::Style style) const { // Cannot draw a NULL / empty string if (text == nullptr || *text == '\0') { return; }
const auto fontIt = fontMap.find(fontId); if (fontIt == fontMap.end()) { LOG_ERR("GFX", "Font %d not found", fontId); return; }
const auto& font = fontIt->second;
int lastBaseY = y; int lastBaseLeft = 0; int lastBaseWidth = 0; int lastBaseTop = 0; int32_t prevAdvanceFP = 0; // 12.4 fixed-point: prev glyph's advance + next kern for snap
uint32_t cp; uint32_t prevCp = 0; while ((cp = utf8NextCodepoint(reinterpret_cast<const uint8_t**>(&text)))) { if (utf8IsCombiningMark(cp)) { const EpdGlyph* combiningGlyph = font.getGlyph(cp, style); if (!combiningGlyph) continue; const int raiseBy = combiningMark::raiseAboveBase(combiningGlyph->top, combiningGlyph->height, lastBaseTop); const int combiningX = x - raiseBy; const int combiningY = combiningMark::centerOverRotated90CW(lastBaseY, lastBaseLeft, lastBaseWidth, combiningGlyph->left, combiningGlyph->width); renderCharImpl<TextRotation::Rotated90CW>(*this, renderMode, font, cp, combiningX, combiningY, black, style); continue; }
cp = font.applyLigatures(cp, text, style);
// Differential rounding: snap (previous advance + current kern) as one unit, // subtracting for the rotated coordinate direction. if (prevCp != 0) { const auto kernFP = font.getKerning(prevCp, cp, style); // 4.4 fixed-point kern lastBaseY -= fp4::toPixel(prevAdvanceFP + kernFP); // snap 12.4 fixed-point to nearest pixel }
const EpdGlyph* glyph = font.getGlyph(cp, style);
lastBaseLeft = glyph ? glyph->left : 0; lastBaseWidth = glyph ? glyph->width : 0; lastBaseTop = glyph ? glyph->top : 0; prevAdvanceFP = glyph ? glyph->advanceX : 0; // 12.4 fixed-point
renderCharImpl<TextRotation::Rotated90CW>(*this, renderMode, font, cp, x, lastBaseY, black, style); prevCp = cp; }}
uint8_t* GfxRenderer::getFrameBuffer() const { return frameBuffer; }
size_t GfxRenderer::getBufferSize() const { return frameBufferSize; }
// unused// void GfxRenderer::grayscaleRevert() const { display.grayscaleRevert(); }
void GfxRenderer::copyGrayscaleLsbBuffers() const { display.copyGrayscaleLsbBuffers(frameBuffer); }
void GfxRenderer::copyGrayscaleMsbBuffers() const { display.copyGrayscaleMsbBuffers(frameBuffer); }
void GfxRenderer::displayGrayBuffer() const { display.displayGrayBuffer(fadingFix); }
void GfxRenderer::freeBwBufferChunks() { for (auto& bwBufferChunk : bwBufferChunks) { if (bwBufferChunk) { free(bwBufferChunk); bwBufferChunk = nullptr; } }}
/** * This should be called before grayscale buffers are populated. * A `restoreBwBuffer` call should always follow the grayscale render if this method was called. * Uses chunked allocation to avoid needing 48KB of contiguous memory. * Returns true if buffer was stored successfully, false if allocation failed. */bool GfxRenderer::storeBwBuffer() { // Allocate and copy each chunk for (size_t i = 0; i < bwBufferChunks.size(); i++) { // Check if any chunks are already allocated if (bwBufferChunks[i]) { LOG_ERR("GFX", "!! BW buffer chunk %zu already stored - this is likely a bug, freeing chunk", i); free(bwBufferChunks[i]); bwBufferChunks[i] = nullptr; }
const size_t offset = i * BW_BUFFER_CHUNK_SIZE; const size_t chunkSize = std::min(BW_BUFFER_CHUNK_SIZE, static_cast<size_t>(frameBufferSize - offset)); bwBufferChunks[i] = static_cast<uint8_t*>(malloc(chunkSize));
if (!bwBufferChunks[i]) { LOG_ERR("GFX", "!! Failed to allocate BW buffer chunk %zu (%zu bytes)", i, chunkSize); // Free previously allocated chunks freeBwBufferChunks(); return false; }
memcpy(bwBufferChunks[i], frameBuffer + offset, chunkSize); }
LOG_DBG("GFX", "Stored BW buffer in %zu chunks (%zu bytes each)", bwBufferChunks.size(), BW_BUFFER_CHUNK_SIZE); return true;}
/** * This can only be called if `storeBwBuffer` was called prior to the grayscale render. * It should be called to restore the BW buffer state after grayscale rendering is complete. * Uses chunked restoration to match chunked storage. */void GfxRenderer::restoreBwBuffer() { // Check if all chunks are allocated bool missingChunks = false; for (const auto& bwBufferChunk : bwBufferChunks) { if (!bwBufferChunk) { missingChunks = true; break; } }
if (missingChunks) { freeBwBufferChunks(); return; }
for (size_t i = 0; i < bwBufferChunks.size(); i++) { const size_t offset = i * BW_BUFFER_CHUNK_SIZE; const size_t chunkSize = std::min(BW_BUFFER_CHUNK_SIZE, static_cast<size_t>(frameBufferSize - offset)); memcpy(frameBuffer + offset, bwBufferChunks[i], chunkSize); }
display.cleanupGrayscaleBuffers(frameBuffer);
freeBwBufferChunks(); LOG_DBG("GFX", "Restored and freed BW buffer chunks");}
/** * Cleanup grayscale buffers using the current frame buffer. * Use this when BW buffer was re-rendered instead of stored/restored. */void GfxRenderer::cleanupGrayscaleWithFrameBuffer() const { if (frameBuffer) { display.cleanupGrayscaleBuffers(frameBuffer); }}
void GfxRenderer::getOrientedViewableTRBL(int* outTop, int* outRight, int* outBottom, int* outLeft) const { switch (orientation) { case Portrait: *outTop = VIEWABLE_MARGIN_TOP; *outRight = VIEWABLE_MARGIN_RIGHT; *outBottom = VIEWABLE_MARGIN_BOTTOM; *outLeft = VIEWABLE_MARGIN_LEFT; break; case LandscapeClockwise: *outTop = VIEWABLE_MARGIN_LEFT; *outRight = VIEWABLE_MARGIN_TOP; *outBottom = VIEWABLE_MARGIN_RIGHT; *outLeft = VIEWABLE_MARGIN_BOTTOM; break; case PortraitInverted: *outTop = VIEWABLE_MARGIN_BOTTOM; *outRight = VIEWABLE_MARGIN_LEFT; *outBottom = VIEWABLE_MARGIN_TOP; *outLeft = VIEWABLE_MARGIN_RIGHT; break; case LandscapeCounterClockwise: *outTop = VIEWABLE_MARGIN_RIGHT; *outRight = VIEWABLE_MARGIN_BOTTOM; *outBottom = VIEWABLE_MARGIN_LEFT; *outLeft = VIEWABLE_MARGIN_TOP; break; }}