gfx_compat.h

Go to the documentation of this file.

/*
    MIT License

    Copyright (c) 2016-2026, Alexey Dynda

    Permission is hereby granted, free of charge, to any person obtaining a copy
    of this software and associated documentation files (the "Software"), to deal
    in the Software without restriction, including without limitation the rights
    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    copies of the Software, and to permit persons to whom the Software is
    furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be included in all
    copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
    SOFTWARE.
*/
#pragma once

#include "lcd_hal/io.h"
#include <stdint.h>
#include <stddef.h>

#ifndef _GFXFONT_H_
#define _GFXFONT_H_

typedef struct
{
    uint16_t bitmapOffset; 
    uint8_t width;         
    uint8_t height;        
    uint8_t xAdvance;      
    int8_t xOffset;        
    int8_t yOffset;        
} GFXglyph;

typedef struct
{
    uint8_t *bitmap;  
    GFXglyph *glyph;  
    uint16_t first;   
    uint16_t last;    
    uint8_t yAdvance; 
} GFXfont;
#endif // _GFXFONT_H_

template <class D> class GfxCompat
{
public:
    explicit GfxCompat(D &display)
        : m_d(display)
    {
    }

    int16_t width()
    {
        return (int16_t)m_d.width();
    }

    int16_t height()
    {
        return (int16_t)m_d.height();
    }

    void drawPixel(int16_t x, int16_t y, uint16_t color)
    {
        // On 1-bit panels putPixel always draws "on"; honor Adafruit's 0 == off
        // by clearing instead. The BITS_PER_PIXEL check folds away at compile time.
        if ( D::BITS_PER_PIXEL == 1 && color == 0 )
        {
            m_d.clearRect((lcdint_t)x, (lcdint_t)y, (lcdint_t)x, (lcdint_t)y);
            return;
        }
        m_d.setColor(mapColor(color));
        m_d.putPixel((lcdint_t)x, (lcdint_t)y);
    }

    void drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color)
    {
        if ( h <= 0 )
            return;
        m_d.setColor(mapColor(color));
        m_d.drawVLine((lcdint_t)x, (lcdint_t)y, (lcdint_t)(y + h - 1));
    }

    void drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color)
    {
        if ( w <= 0 )
            return;
        m_d.setColor(mapColor(color));
        m_d.drawHLine((lcdint_t)x, (lcdint_t)y, (lcdint_t)(x + w - 1));
    }

    void drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color)
    {
        m_d.setColor(mapColor(color));
        m_d.drawLine((lcdint_t)x0, (lcdint_t)y0, (lcdint_t)x1, (lcdint_t)y1);
    }

    void drawRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color)
    {
        if ( w <= 0 || h <= 0 )
            return;
        m_d.setColor(mapColor(color));
        m_d.drawRect((lcdint_t)x, (lcdint_t)y, (lcdint_t)(x + w - 1), (lcdint_t)(y + h - 1));
    }

    void fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color)
    {
        if ( w <= 0 || h <= 0 )
            return;
        m_d.setColor(mapColor(color));
        m_d.fillRect((lcdint_t)x, (lcdint_t)y, (lcdint_t)(x + w - 1), (lcdint_t)(y + h - 1));
    }

    void fillScreen(uint16_t color)
    {
        m_d.setColor(mapColor(color));
        m_d.fillRect(0, 0, (lcdint_t)(m_d.width() - 1), (lcdint_t)(m_d.height() - 1));
    }

    void drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color)
    {
        if ( r < 0 )
            return;
        m_d.setColor(mapColor(color));
        m_d.drawCircle((lcdint_t)x0, (lcdint_t)y0, (lcdint_t)r);
    }

    void fillCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color)
    {
        if ( r < 0 )
            return;
        drawFastVLine(x0, y0 - r, 2 * r + 1, color);
        fillCircleHelper(x0, y0, r, 3, 0, color);
    }

    void drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color)
    {
        drawLine(x0, y0, x1, y1, color);
        drawLine(x1, y1, x2, y2, color);
        drawLine(x2, y2, x0, y0, color);
    }

    void fillTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color)
    {
        int16_t minX = x0, maxX = x0;
        if ( x1 < minX )
            minX = x1;
        if ( x2 < minX )
            minX = x2;
        if ( x1 > maxX )
            maxX = x1;
        if ( x2 > maxX )
            maxX = x2;
        for ( int16_t x = minX; x <= maxX; x++ )
        {
            int16_t lo = 0, hi = 0;
            bool hit = false;
            edgeSpan(x, x0, y0, x1, y1, lo, hi, hit);
            edgeSpan(x, x1, y1, x2, y2, lo, hi, hit);
            edgeSpan(x, x2, y2, x0, y0, lo, hi, hit);
            if ( hit )
                drawFastVLine(x, lo, hi - lo + 1, color);
        }
    }

    void drawRoundRect(int16_t x, int16_t y, int16_t w, int16_t h, int16_t r, uint16_t color)
    {
        if ( w <= 0 || h <= 0 )
            return;
        int16_t maxR = ((w < h) ? w : h) / 2;
        if ( r > maxR )
            r = maxR;
        drawFastHLine(x + r, y, w - 2 * r, color);
        drawFastHLine(x + r, y + h - 1, w - 2 * r, color);
        drawFastVLine(x, y + r, h - 2 * r, color);
        drawFastVLine(x + w - 1, y + r, h - 2 * r, color);
        drawCircleHelper(x + r, y + r, r, 1, color);
        drawCircleHelper(x + w - r - 1, y + r, r, 2, color);
        drawCircleHelper(x + w - r - 1, y + h - r - 1, r, 4, color);
        drawCircleHelper(x + r, y + h - r - 1, r, 8, color);
    }

    void fillRoundRect(int16_t x, int16_t y, int16_t w, int16_t h, int16_t r, uint16_t color)
    {
        if ( w <= 0 || h <= 0 )
            return;
        int16_t maxR = ((w < h) ? w : h) / 2;
        if ( r > maxR )
            r = maxR;
        fillRect(x + r, y, w - 2 * r, h, color);
        fillCircleHelper(x + w - r - 1, y + r, r, 1, h - 2 * r - 1, color);
        fillCircleHelper(x + r, y + r, r, 2, h - 2 * r - 1, color);
    }

    void drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color)
    {
        if ( w <= 0 || h <= 0 )
            return;
        m_d.setColor(mapColor(color));
        m_d.drawBitmap1((lcdint_t)x, (lcdint_t)y, (lcduint_t)w, (lcduint_t)h, bitmap);
    }

    void setCursor(int16_t x, int16_t y)
    {
        m_cursorX = x;
        m_cursorY = y;
        m_d.setTextCursor((lcdint_t)x, (lcdint_t)y);
    }

    void setTextColor(uint16_t color)
    {
        m_textColor = color;
        m_d.setColor(mapColor(color));
    }

    void setTextColor(uint16_t color, uint16_t background)
    {
        m_textColor = color;
        m_d.setColor(mapColor(color));
        m_d.setBackground(mapColor(background));
    }

    void setFont(const GFXfont *font)
    {
        m_gfxFont = font;
    }

    void setTextSize(uint8_t size)
    {
        m_textSize = size;
    }

    void setRotation(uint8_t rotation)
    {
        m_rotation = rotation & 0x03;
    }

    uint8_t getRotation()
    {
        return m_rotation;
    }

    size_t write(uint8_t ch)
    {
        if ( m_gfxFont )
        {
            writeGfxChar(ch);
        }
        else
        {
            char s[2] = {(char)ch, '\0'};
            m_d.write(s);
        }
        return 1;
    }

    void print(const char *str)
    {
        if ( m_gfxFont )
        {
            while ( *str )
            {
                writeGfxChar((uint8_t)*str++);
            }
        }
        else
        {
            m_d.write(str);
        }
    }

    void print(char c)
    {
        write((uint8_t)c);
    }

    void print(int number)
    {
        print((long)number);
    }

    void print(long number)
    {
        char buf[12];
        numToStr(number, buf);
        print((const char *)buf);
    }

    void println(const char *str)
    {
        print(str);
        write((uint8_t)'\n');
    }

    void println(int number)
    {
        print((long)number);
        write((uint8_t)'\n');
    }

    void println()
    {
        write((uint8_t)'\n');
    }

    // ---- Adafruit_GFX transaction API (no-ops: lcdgfx has no global lock) ----

    void startWrite()
    {
    }

    void writePixel(int16_t x, int16_t y, uint16_t color)
    {
        drawPixel(x, y, color);
    }

    void endWrite()
    {
    }

    D &display()
    {
        return m_d;
    }

private:
    // Adafruit_GFX uses 0/1 for monochrome color; lcdgfx 1-bit ops expect a
    // full 0x0000/0xFFFF mask. For deeper color panels the value (RGB332/RGB565)
    // passes through untouched. The comparison is a compile-time constant.
    static uint16_t mapColor(uint16_t color)
    {
        if ( D::BITS_PER_PIXEL == 1 )
            return color ? 0xFFFF : 0x0000;
        return color;
    }

    // Accumulates the vertical extent (lo..hi) that triangle edge (xa,ya)-(xb,yb)
    // contributes at column x, for the column-based fillTriangle.
    static void edgeSpan(int16_t x, int16_t xa, int16_t ya, int16_t xb, int16_t yb, int16_t &lo, int16_t &hi, bool &hit)
    {
        int16_t xmin = xa < xb ? xa : xb;
        int16_t xmax = xa > xb ? xa : xb;
        if ( x < xmin || x > xmax )
            return;
        int16_t ey0, ey1;
        if ( xa == xb )
        { // vertical edge spans its whole segment at this column
            ey0 = ya;
            ey1 = yb;
        }
        else
        {
            ey0 = ey1 = (int16_t)((long)ya + (long)(yb - ya) * (x - xa) / (xb - xa));
        }
        if ( ey1 < ey0 )
        {
            int16_t t = ey0;
            ey0 = ey1;
            ey1 = t;
        }
        if ( !hit )
        {
            lo = ey0;
            hi = ey1;
            hit = true;
        }
        else
        {
            if ( ey0 < lo )
                lo = ey0;
            if ( ey1 > hi )
                hi = ey1;
        }
    }

    // Formats a signed value in base 10 into buf (needs room for 12 chars).
    static void numToStr(long value, char *buf)
    {
        char tmp[12];
        uint8_t i = 0;
        bool neg = value < 0;
        unsigned long v = neg ? (unsigned long)(-value) : (unsigned long)value;
        do
        {
            tmp[i++] = (char)('0' + (v % 10));
            v /= 10;
        } while ( v );
        uint8_t j = 0;
        if ( neg )
            buf[j++] = '-';
        while ( i )
            buf[j++] = tmp[--i];
        buf[j] = '\0';
    }

    // Quarter-arc outline helper for drawRoundRect (Adafruit_GFX algorithm).
    void drawCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t corner, uint16_t color)
    {
        int16_t f = 1 - r, ddF_x = 1, ddF_y = -2 * r, x = 0, y = r;
        while ( x < y )
        {
            if ( f >= 0 )
            {
                y--;
                ddF_y += 2;
                f += ddF_y;
            }
            x++;
            ddF_x += 2;
            f += ddF_x;
            if ( corner & 0x4 )
            {
                drawPixel(x0 + x, y0 + y, color);
                drawPixel(x0 + y, y0 + x, color);
            }
            if ( corner & 0x2 )
            {
                drawPixel(x0 + x, y0 - y, color);
                drawPixel(x0 + y, y0 - x, color);
            }
            if ( corner & 0x8 )
            {
                drawPixel(x0 - y, y0 + x, color);
                drawPixel(x0 - x, y0 + y, color);
            }
            if ( corner & 0x1 )
            {
                drawPixel(x0 - y, y0 - x, color);
                drawPixel(x0 - x, y0 - y, color);
            }
        }
    }

    // Filled half/quarter-circle helper for fillCircle/fillRoundRect.
    void fillCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t corner, int16_t delta, uint16_t color)
    {
        int16_t f = 1 - r, ddF_x = 1, ddF_y = -2 * r, x = 0, y = r, px = x, py = y;
        delta++;
        while ( x < y )
        {
            if ( f >= 0 )
            {
                y--;
                ddF_y += 2;
                f += ddF_y;
            }
            x++;
            ddF_x += 2;
            f += ddF_x;
            if ( x < (y + 1) )
            {
                if ( corner & 1 )
                    drawFastVLine(x0 + x, y0 - y, 2 * y + delta, color);
                if ( corner & 2 )
                    drawFastVLine(x0 - x, y0 - y, 2 * y + delta, color);
            }
            if ( y != py )
            {
                if ( corner & 1 )
                    drawFastVLine(x0 + py, y0 - px, 2 * px + delta, color);
                if ( corner & 2 )
                    drawFastVLine(x0 - py, y0 - px, 2 * px + delta, color);
                py = y;
            }
            px = x;
        }
    }

    // Byte-copies a PROGMEM-resident struct into RAM (correct on AVR and MCUs
    // with memory-mapped flash alike).
    static void readStruct(const void *src, void *dst, size_t n)
    {
        const uint8_t *s = (const uint8_t *)src;
        uint8_t *d = (uint8_t *)dst;
        for ( size_t i = 0; i < n; i++ )
        {
            d[i] = pgm_read_byte(s + i);
        }
    }

    // Largest glyph (width * ceil(height/8) bytes) the packing buffer can hold.
    // Covers e.g. 32px-tall fonts up to 32px wide; larger glyphs are skipped.
    static const uint16_t kGlyphBufSize = 128;

    // Renders one glyph of the active GFXfont at the current cursor, advancing
    // the cursor. The row-major Adafruit glyph is repacked into lcdgfx's
    // column-major/page format and drawn with a single drawBitmap1 call, so it
    // renders correctly on paged monochrome displays (no per-pixel page clobber)
    // and on color panels alike. Uses the current text color.
    void writeGfxChar(uint8_t c)
    {
        GFXfont font;
        readStruct(m_gfxFont, &font, sizeof(GFXfont));

        if ( c == '\n' )
        {
            m_cursorX = 0;
            m_cursorY += (int16_t)font.yAdvance;
            return;
        }
        if ( c == '\r' || c < font.first || c > font.last )
        {
            return;
        }

        GFXglyph glyph;
        readStruct(font.glyph + (c - font.first), &glyph, sizeof(GFXglyph));

        uint8_t w = glyph.width, h = glyph.height;
        uint8_t xa = glyph.xAdvance;
        if ( w == 0 || h == 0 ) // e.g. space: advance only
        {
            m_cursorX += (int16_t)xa;
            return;
        }

        // Draw at a page-aligned y (offset 0) and pre-shift the glyph inside the
        // buffer by the sub-page amount. This avoids drawBitmap1's short-bitmap
        // corner case (it drops data when a <1 page glyph lands at a non-zero
        // page offset) and works uniformly on paged mono and color displays.
        int16_t top = m_cursorY + glyph.yOffset;
        uint8_t shift = (uint8_t)(((top % 8) + 8) % 8);
        int16_t alignedTop = top - shift;
        uint8_t packedH = (uint8_t)(h + shift);
        uint8_t pages = (uint8_t)((packedH + 7) >> 3);
        if ( (uint16_t)w * pages > kGlyphBufSize )
        {
            m_cursorX += (int16_t)xa; // glyph too large for the packing buffer
            return;
        }

        uint8_t buf[kGlyphBufSize];
        for ( uint16_t k = 0; k < (uint16_t)w * pages; k++ )
            buf[k] = 0;

        const uint8_t *bitmap = font.bitmap;
        uint16_t bo = glyph.bitmapOffset;
        uint8_t bits = 0, bit = 0;
        for ( uint8_t row = 0; row < h; row++ )
        {
            uint8_t dst = (uint8_t)(row + shift);
            uint8_t page = (uint8_t)(dst >> 3);
            uint8_t pbit = (uint8_t)(dst & 7);
            for ( uint8_t col = 0; col < w; col++ )
            {
                if ( (bit++ & 7) == 0 )
                {
                    bits = pgm_read_byte(bitmap + bo++);
                }
                if ( bits & 0x80 )
                {
                    buf[(uint16_t)page * w + col] |= (uint8_t)(1 << pbit);
                }
                bits <<= 1;
            }
        }

        m_d.setColor(mapColor(m_textColor));
        m_d.drawBitmap1((lcdint_t)(m_cursorX + glyph.xOffset), (lcdint_t)alignedTop, (lcduint_t)w, (lcduint_t)packedH,
                        buf);
        m_cursorX += (int16_t)xa;
    }

    D &m_d;
    const GFXfont *m_gfxFont = nullptr;
    uint16_t m_textColor = 0xFFFF;
    int16_t m_cursorX = 0;
    int16_t m_cursorY = 0;
    uint8_t m_textSize = 1;
    uint8_t m_rotation = 0;
};

template <class D> GfxCompat<D> makeGfxCompat(D &display)
{
    return GfxCompat<D>(display);
}