ufb/framebuffer.c

//
// Created by MightyPork on 2022/11/12.
//

#include "framebuffer.h"

#define MIN(a, b) ((a)>(b)?(b):(a))
#define MAX(a, b) ((a)>(b)?(a):(b))

#include <string.h>

uint8_t fb[(FBH / 8) * FBW];

/** Fill with a vertical pattern, 1 byte */
void fb_fill(uint8_t pattern)
{
    memset(fb, pattern, sizeof(fb));
}

static void draw_mask(fbsize_t idx, uint8_t mask, uint8_t color)
{
    if (color != 0) {
        fb[idx] |= mask;
    } else {
        fb[idx] &= ~mask;
    }
}

void fb_px(fbpos_t x, fbpos_t y, uint8_t color)
{
    if (x >= FBW || y >= FBH) { return; }
    const fbpos_t row = y / 8;
    const fbpos_t rowrem = y % 8;
    const fbsize_t cell = (fbsize_t) x + (fbsize_t) row * FBW;
    draw_mask(cell, 1 << rowrem, color);
}

uint8_t fb_getpx(fbpos_t x, fbpos_t y)
{
    if (x >= FBW || y >= FBH) { return 0; }
    const fbpos_t row = y / 8;
    const fbpos_t rowrem = y % 8;
    const fbsize_t cell = (fbsize_t) x + (fbsize_t) row * FBW;
    if (fb[cell] & (1 << rowrem)) {
        return 0xFF;
    } else {
        return 0x00;
    }
}

void fb_hline(fbpos_t x, fbpos_t y, fbpos_t w, uint8_t color)
{
    if (x >= FBW || y >= FBH) { return; }
    w = MIN(FBW - x, w);
    const fbpos_t row = y / 8;
    const fbpos_t rowrem = y % 8;
    fbsize_t cell = (fbsize_t) x + (fbsize_t) row * FBW;
    for (uint8_t i = 0; i < w; i++) {
        draw_mask(cell, 1 << rowrem, color);
        cell++;
    }
}

void fb_vline(fbpos_t x, fbpos_t y, fbpos_t h, uint8_t color)
{
    if (x >= FBW || y >= FBH) { return; }
    h = MIN(FBH - y - 1, h);
    const fbpos_t row = y / 8;
    const fbpos_t rowrem = y % 8;
    uint16_t cell = (uint16_t) x + (uint16_t) row * FBW;

    if (rowrem + h < 8) {
        // all within one cell
        const uint8_t mask = (0xFF << rowrem) & (0xFF >> (8 - h - rowrem));
        draw_mask(cell, mask, color);
        return;
    } else {
        // First
        draw_mask(cell, 0xFF << rowrem, color);
        h -= (rowrem == 0 ? 8 : (8 - rowrem));

        const fbpos_t whole_cells = h / 8;
        if (whole_cells > 0) {
            h -= whole_cells * 8;
            for (fbpos_t i = 0; i < whole_cells; i++) {
                cell += FBW;
                draw_mask(cell, 0xFF, color);
            }
        }

        // last
        cell += FBW;
        draw_mask(cell, 0xFF >> (8 - h), color);
    }
}

void fb_rect(fbpos_t x, fbpos_t y, fbpos_t w, fbpos_t h, uint8_t color)
{
    if (x >= FBW || y >= FBH) { return; }
    w = MIN(FBW - x, w);
    h = MIN(FBH - y, h);
    const fbpos_t row = y / 8;
    const fbpos_t rowrem = y % 8;
    fbsize_t cell = (fbsize_t) x + (fbsize_t) row * FBW;

    if (w == 1 && h == 1) {
        fb_px(x, y, color);
    } else if (w == 1) {
        fb_vline(x, y, h, color);
    } else if (h == 1) {
        fb_hline(x, y, w, color);
    } else if (rowrem + h <= 8) {
        // all within one cell
        uint8_t mask = (0xFF << rowrem) & (0xFF >> (8 - h - rowrem));

        for (fbpos_t i = 0; i < w; i++) {
            draw_mask(cell + i, mask, color);
        }
        return;
    } else {
        // First
        uint8_t mask = (0xFF << rowrem);
        for (fbpos_t i = 0; i < w; i++) {
            draw_mask(cell + i, mask, color);
        }
        h -= 8 - rowrem;

        const fbpos_t whole_cells = h / 8;
        if (whole_cells > 0) {
            h -= whole_cells * 8;
            for (fbpos_t j = 0; j < whole_cells; j++) {
                cell += FBW;
                for (fbpos_t i = 0; i < w; i++) {
                    draw_mask(cell + i, 0xFF, color);
                }
            }
        }

        cell += FBW;

        // last
        mask = (0xFF >> (8 - h));
        for (fbpos_t i = 0; i < w; i++) {
            draw_mask(cell + i, mask, color);
        }
    }
}

void fb_frame(fbpos_t x, fbpos_t y, fbpos_t w, fbpos_t h, fbpos_t thickness, uint8_t color)
{
    if (thickness == 0) {
        return;
    } else if (thickness == 1) {
        fb_hline(x, y, w, color);
        fb_vline(x, y, h, color);
        fb_hline(x, y + h - 1, w, color);
        fb_vline(x + w - 1, y, h, color);
    } else {
        fb_rect(x, y, w, thickness, color);
        fb_rect(x, y + h - thickness, w, thickness, color);
        fb_rect(x, y + thickness, thickness, h - 2 * thickness, color);
        fb_rect(x + w - thickness, y + thickness, thickness, h - 2 * thickness, color);
    }
}

void fb_bitmap(fbpos_t x, fbpos_t y, fbpos_t w, fbpos_t h, const uint8_t *map, uint8_t color)
{
    if (x >= FBW || y >= FBH) { return; }
    const fbpos_t w0 = w;
    w = MIN(FBW - x - 1, w);
    h = MIN(FBH - y - 1, h);
    const fbpos_t row = y / 8;
    const fbpos_t rowrem = y % 8;
    fbsize_t cell = (fbsize_t) x + (fbsize_t) row * FBW;

    if (rowrem + h <= 8) {
        for (fbpos_t i = 0; i < w; i++) {
            // all within one cell
            const uint8_t mask = (map[i] & (0xFF >> (8 - h))) << rowrem;
            draw_mask(cell + i, mask, color);
        }
        return;
    } else {
        fbsize_t mapc0 = 0;

        // Draw the bitmap slice-by-slice based on how rows of the bitmap intersect with rows of the canvas.
        // This could be optimized to walk each row of the canvas only once, but the code would get bigger.
        while (h > 0) {
            for (fbpos_t i = 0; i < w; i++) {
                const uint8_t mask = (map[i + mapc0] & (0xFF >> rowrem)) << rowrem;
                draw_mask(cell + i, mask, color);
            }

            cell += FBW;

            if (rowrem != 0) {
                for (fbpos_t i = 0; i < w; i++) {
                    const uint8_t mask = (map[i + mapc0] & (0xFF << (8 - rowrem))) >> (8 - rowrem);
                    draw_mask(cell + i, mask, color);
                }
            }

            if (h > 8) {
                h -= 8;
            } else {
                break;
            }
            mapc0 += w0;
        }
    }
}


enum SevenSegBars {
  T = 1, RT = 2, RB = 4, B = 8, LB = 16, LT = 32, M = 64
};

static const uint8_t PROGMEM seven[] = {
        [0] = T | RT | RB | B | LB | LT,
        [1] = RT | RB,
        [2] = T | RT | M | LB | B,
        [3] = T | RT | M | RB | B,
        [4] = RT | RB | M | LT,
        [5] = T | LT | M | RB | B,
        [6] = T | LT | LB | B | RB | M,
        [7] = T | RT | RB,
        [8] = T | LT | RT | LB | RB | B | M,
        [9] = T | LT | RT | RB | B | M,
};

fbpos_t fb_7seg_dig(fbpos_t x, fbpos_t y, fbpos_t w, fbpos_t h, fbpos_t th, uint8_t digit, uint8_t color)
{
    const uint8_t mask = digit > 9 ? 0 : pgm_read_byte(&seven[digit]);
    const fbpos_t wi = w - th * 2;
    const fbpos_t hi = (h - th * 3) / 2;

    bool bcolor = !color; // changed for XOR

    fb_rect(x + th,
            y,
            wi,
            th, bcolor ^ (bool) (mask & T));

    fb_rect(x + th,
            y + th + hi,
            wi,
            th, bcolor ^ (bool) (mask & M));

    fb_rect(x + th,
            y + th * 2 + hi * 2,
            wi,
            th, bcolor ^ (bool) (mask & B));

    fb_rect(x,
            y + th,
            th,
            hi, bcolor ^ (bool) (mask & LT));

    fb_rect(x + th + wi,
            y + hi + th,
            th,
            hi, bcolor ^ (bool) (mask & LB));

    fb_rect(x + th + wi,
            y + th,
            th,
            hi, bcolor ^ (bool) (mask & RT));

    fb_rect(x + th + wi,
            y + th * 2 + hi,
            th,
            hi, bcolor ^ (bool) (mask & RB));

    return w;
}

fbpos_t fb_7seg_period(fbpos_t x, fbpos_t y, fbpos_t w, fbpos_t h, fbpos_t th, uint8_t color)
{
    const fbpos_t hi = (h - th * 3) / 2;
    fb_rect(x, y + hi * 2 + th * 2, th, th, color);
    return th;
}