rgb565_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/color>
#include <idfxx/lcd/panel>
 
#include <algorithm>
#include <cstddef>
#include <span>
#include <vector>
 
namespace idfxx::lcd {
 
class rgb565_framebuffer {
public:
    using pixel_type = rgb565;
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    [[nodiscard]] rgb565_framebuffer(size_t width, size_t height)
        : rgb565_framebuffer(unwrap(make(width, height))) {}
#endif
 
    [[nodiscard]] static result<rgb565_framebuffer> make(size_t width, size_t height) {
        if (width == 0 || height == 0) {
            return error(errc::invalid_arg);
        }
        return rgb565_framebuffer{width, height, std::vector<rgb565>(width * height)};
    }
 
    [[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, rgb565 color) noexcept {
        if (x >= _width || y >= _height) {
            return;
        }
        _data[y * _width + x] = color;
    }
 
    [[nodiscard]] rgb565 get_pixel(size_t x, size_t y) const noexcept {
        if (x >= _width || y >= _height) {
            return {};
        }
        return _data[y * _width + x];
    }
 
    void fill(rgb565 color) noexcept { std::ranges::fill(_data, color); }
 
    void clear() noexcept { fill({}); }
 
    [[nodiscard]] std::span<const rgb565> data() const noexcept { return _data; }
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    void flush(panel& panel, size_t x = 0, size_t y = 0) const { unwrap(try_flush(panel, x, y)); }
 
    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, size_t x = 0, size_t y = 0) const {
        return panel.try_draw_bitmap(
            static_cast<int>(x),
            static_cast<int>(y),
            static_cast<int>(x + _width),
            static_cast<int>(y + _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);
        }
        if (x_start == 0 && x_end == _width) {
            // In the row-major layout a full-width band is contiguous, so a
            // single transfer covers all its rows.
            return panel.try_draw_bitmap(
                0,
                static_cast<int>(y_start),
                static_cast<int>(_width),
                static_cast<int>(y_end),
                _data.data() + y_start * _width
            );
        }
        for (size_t row = y_start; row < y_end; ++row) {
            auto drawn = panel.try_draw_bitmap(
                static_cast<int>(x_start),
                static_cast<int>(row),
                static_cast<int>(x_end),
                static_cast<int>(row + 1),
                _data.data() + row * _width + x_start
            );
            if (!drawn) {
                return drawn;
            }
        }
        return {};
    }
 
private:
    rgb565_framebuffer(size_t width, size_t height, std::vector<rgb565> data)
        : _width(width)
        , _height(height)
        , _data(std::move(data)) {}
 
    size_t _width;
    size_t _height;
    std::vector<rgb565> _data;
};
 
} // namespace idfxx::lcd