mono_framebuffer.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 Chris Leishman
 
#pragma once
 
#include <idfxx/error>
#include <idfxx/lcd/panel>
 
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <span>
#include <vector>
 
namespace idfxx::lcd {
 
class mono_framebuffer {
public:
    using pixel_type = bool;
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    [[nodiscard]] mono_framebuffer(size_t width, size_t height)
        : mono_framebuffer(unwrap(make(width, height))) {}
#endif
 
    [[nodiscard]] static result<mono_framebuffer> make(size_t width, size_t height) {
        if (width == 0 || height == 0 || height % 8 != 0) {
            return error(errc::invalid_arg);
        }
        return mono_framebuffer{width, height, std::vector<uint8_t>(width * height / 8)};
    }
 
    [[nodiscard]] size_t width() const noexcept { return _width; }
 
    [[nodiscard]] size_t height() const noexcept { return _height; }
 
    void set_pixel(size_t x, size_t y, bool on) noexcept {
        if (x >= _width || y >= _height) {
            return;
        }
        uint8_t& byte = _data[(y / 8) * _width + x];
        uint8_t mask = static_cast<uint8_t>(1u << (y % 8));
        if (on) {
            byte |= mask;
        } else {
            byte &= static_cast<uint8_t>(~mask);
        }
    }
 
    [[nodiscard]] bool get_pixel(size_t x, size_t y) const noexcept {
        if (x >= _width || y >= _height) {
            return false;
        }
        return (_data[(y / 8) * _width + x] & (1u << (y % 8))) != 0;
    }
 
    void fill(bool on) noexcept { std::ranges::fill(_data, on ? uint8_t{0xFF} : uint8_t{0x00}); }
 
    void clear() noexcept { fill(false); }
 
    [[nodiscard]] std::span<const uint8_t> data() const noexcept { return _data; }
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    void flush(panel& panel) const { unwrap(try_flush(panel)); }
 
    void flush_rows(panel& panel, size_t y_start, size_t y_end) const { unwrap(try_flush_rows(panel, y_start, y_end)); }
 
    void flush_region(panel& panel, size_t x_start, size_t y_start, size_t x_end, size_t y_end) const {
        unwrap(try_flush_region(panel, x_start, y_start, x_end, y_end));
    }
#endif
 
    [[nodiscard]] result<void> try_flush(panel& panel) const {
        return panel.try_draw_bitmap(0, 0, static_cast<int>(_width), static_cast<int>(_height), _data.data());
    }
 
    [[nodiscard]] result<void> try_flush_rows(panel& panel, size_t y_start, size_t y_end) const {
        return try_flush_region(panel, 0, y_start, _width, y_end);
    }
 
    [[nodiscard]] result<void>
    try_flush_region(panel& panel, size_t x_start, size_t y_start, size_t x_end, size_t y_end) const {
        if (x_start >= x_end || x_end > _width || y_start >= y_end || y_end > _height) {
            return error(errc::invalid_arg);
        }
        size_t first_page = y_start / 8;
        size_t end_page = (y_end + 7) / 8;
        if (x_start == 0 && x_end == _width) {
            // In the page-major layout a full-width band is contiguous, so a
            // single transfer covers all its pages.
            return panel.try_draw_bitmap(
                0,
                static_cast<int>(first_page * 8),
                static_cast<int>(_width),
                static_cast<int>(end_page * 8),
                _data.data() + first_page * _width
            );
        }
        for (size_t page = first_page; page < end_page; ++page) {
            auto drawn = panel.try_draw_bitmap(
                static_cast<int>(x_start),
                static_cast<int>(page * 8),
                static_cast<int>(x_end),
                static_cast<int>((page + 1) * 8),
                _data.data() + page * _width + x_start
            );
            if (!drawn) {
                return drawn;
            }
        }
        return {};
    }
 
private:
    mono_framebuffer(size_t width, size_t height, std::vector<uint8_t> data)
        : _width(width)
        , _height(height)
        , _data(std::move(data)) {}
 
    size_t _width;
    size_t _height;
    std::vector<uint8_t> _data;
};
 
} // namespace idfxx::lcd