gfx.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 Chris Leishman
 
#pragma once
 
#include <idfxx/error.hpp>
#include <idfxx/font.hpp>
 
#include <algorithm>
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <string_view>
#include <utility>
 
namespace idfxx::gfx {
 
template<typename S>
concept pixel_surface = requires(S& s, const S& cs, size_t x, size_t y, typename S::pixel_type pixel) {
    typename S::pixel_type;
    { s.set_pixel(x, y, pixel) } noexcept;
    { cs.width() } -> std::convertible_to<size_t>;
    { cs.height() } -> std::convertible_to<size_t>;
};
 
template<pixel_surface Surface>
void fill_rect(
    Surface& surface,
    size_t x,
    size_t y,
    size_t width,
    size_t height,
    typename Surface::pixel_type ink
) noexcept {
    const size_t surface_width = surface.width();
    const size_t surface_height = surface.height();
    if (x >= surface_width || y >= surface_height) {
        return;
    }
    const size_t x_end = x + std::min(width, surface_width - x);
    const size_t y_end = y + std::min(height, surface_height - y);
    for (size_t py = y; py < y_end; ++py) {
        for (size_t px = x; px < x_end; ++px) {
            surface.set_pixel(px, py, ink);
        }
    }
}
 
template<pixel_surface Surface>
void draw_hline(Surface& surface, size_t x, size_t y, size_t length, typename Surface::pixel_type ink) noexcept {
    fill_rect(surface, x, y, length, 1, ink);
}
 
template<pixel_surface Surface>
void draw_vline(Surface& surface, size_t x, size_t y, size_t length, typename Surface::pixel_type ink) noexcept {
    fill_rect(surface, x, y, 1, length, ink);
}
 
template<pixel_surface Surface>
void draw_rect(
    Surface& surface,
    size_t x,
    size_t y,
    size_t width,
    size_t height,
    typename Surface::pixel_type ink
) noexcept {
    if (width == 0 || height == 0) {
        return;
    }
    if (width <= 2 || height <= 2) {
        fill_rect(surface, x, y, width, height, ink);
        return;
    }
    draw_hline(surface, x, y, width, ink);
    draw_hline(surface, x, y + height - 1, width, ink);
    draw_vline(surface, x, y + 1, height - 2, ink);
    draw_vline(surface, x + width - 1, y + 1, height - 2, ink);
}
 
template<pixel_surface Surface>
void draw_line(
    Surface& surface,
    size_t x0,
    size_t y0,
    size_t x1,
    size_t y1,
    typename Surface::pixel_type ink
) noexcept {
    if (std::min(x0, x1) >= surface.width() || std::min(y0, y1) >= surface.height()) {
        return; // the endpoints' bounding box lies entirely off the surface
    }
    // Bresenham's algorithm; the walk stays within the endpoints' bounding
    // box, so intermediate coordinates never go negative.
    ptrdiff_t px = static_cast<ptrdiff_t>(x0);
    ptrdiff_t py = static_cast<ptrdiff_t>(y0);
    const ptrdiff_t ex = static_cast<ptrdiff_t>(x1);
    const ptrdiff_t ey = static_cast<ptrdiff_t>(y1);
    const ptrdiff_t dx = std::abs(ex - px);
    const ptrdiff_t dy = -std::abs(ey - py);
    const ptrdiff_t sx = px < ex ? 1 : -1;
    const ptrdiff_t sy = py < ey ? 1 : -1;
    ptrdiff_t err = dx + dy;
    while (true) {
        surface.set_pixel(static_cast<size_t>(px), static_cast<size_t>(py), ink);
        if (px == ex && py == ey) {
            break;
        }
        const ptrdiff_t e2 = 2 * err;
        if (e2 >= dy) {
            err += dy;
            px += sx;
        }
        if (e2 <= dx) {
            err += dx;
            py += sy;
        }
    }
}
 
template<pixel_surface Surface>
void draw_text(
    Surface& surface,
    const font::mono_font& font,
    size_t x,
    size_t y,
    std::string_view text,
    typename Surface::pixel_type ink,
    unsigned scale = 1
) noexcept {
    if (scale == 0) {
        scale = 1;
    }
    if (y >= surface.height()) {
        return; // every glyph row would clip
    }
    const size_t bpr = font.bytes_per_row();
    size_t cell_x = x;
 
    for (char c : text) {
        if (cell_x >= surface.width()) {
            break; // rendering is left-to-right; nothing further can draw
        }
        if (font.contains(c)) {
            const uint8_t* glyph = font.glyph(c);
            for (size_t row = 0; row < font.height; ++row) {
                const uint8_t* row_bits = glyph + row * bpr;
                uint8_t bits = 0;
                for (size_t col = 0; col < font.width; ++col, bits <<= 1) {
                    if (col % 8 == 0) {
                        bits = row_bits[col / 8];
                    }
                    if (!(bits & 0x80u)) {
                        continue;
                    }
                    const size_t px = cell_x + col * scale;
                    const size_t py = y + row * scale;
                    for (unsigned sy = 0; sy < scale; ++sy) {
                        for (unsigned sx = 0; sx < scale; ++sx) {
                            surface.set_pixel(px + sx, py + sy, ink);
                        }
                    }
                }
            }
        }
        cell_x += font.advance(c) * scale;
    }
}
 
template<pixel_surface Surface>
    requires std::same_as<typename Surface::pixel_type, bool>
void draw_text(Surface& surface, const font::mono_font& font, size_t x, size_t y, std::string_view text) noexcept {
    draw_text(surface, font, x, y, text, true);
}
 
template<pixel_surface Surface>
class canvas {
public:
    using pixel_type = typename Surface::pixel_type;
 
    explicit canvas(Surface& surface) noexcept
        : _surface(&surface)
        , _dx(0)
        , _dy(0)
        , _width(surface.width())
        , _height(surface.height()) {}
 
    canvas(Surface& surface, size_t x, size_t y) noexcept
        : _surface(&surface)
        , _dx(static_cast<ptrdiff_t>(x))
        , _dy(static_cast<ptrdiff_t>(y))
        , _width(x + surface.width())
        , _height(y + surface.height()) {}
 
    [[nodiscard]] Surface& surface() const noexcept { return *_surface; }
 
    [[nodiscard]] size_t width() const noexcept { return _width; }
 
    [[nodiscard]] size_t height() const noexcept { return _height; }
 
    [[nodiscard]] canvas window(size_t x, size_t y, size_t width, size_t height) const noexcept {
        canvas sub(*this);
        sub._dx = _dx - static_cast<ptrdiff_t>(x);
        sub._dy = _dy - static_cast<ptrdiff_t>(y);
        sub._width = x < _width ? std::min(width, _width - x) : 0;
        sub._height = y < _height ? std::min(height, _height - y) : 0;
        return sub;
    }
 
    void set_pixel(size_t x, size_t y, pixel_type ink) noexcept {
        if (x >= _width || y >= _height) {
            return;
        }
        // Coordinates left of or above the surface wrap to huge values and
        // are ignored by the surface's own bounds check.
        _surface->set_pixel(
            static_cast<size_t>(static_cast<ptrdiff_t>(x) - _dx),
            static_cast<size_t>(static_cast<ptrdiff_t>(y) - _dy),
            ink
        );
    }
 
    void fill(pixel_type ink) noexcept {
        if constexpr (requires(Surface& s, pixel_type i) {
                          { s.fill(i) } noexcept;
                      }) {
            if (_covers_surface()) {
                _surface->fill(ink);
                return;
            }
        }
        fill_rect(0, 0, _width, _height, ink);
    }
 
    void clear() noexcept {
        if constexpr (requires(Surface& s) {
                          { s.clear() } noexcept;
                      }) {
            if (_covers_surface()) {
                _surface->clear();
                return;
            }
        }
        fill(pixel_type{});
    }
 
    template<typename... Args>
        requires requires(Surface& s) { s.flush(std::declval<Args>()...); }
    decltype(auto) flush(Args&&... args) const {
        return _surface->flush(std::forward<Args>(args)...);
    }
 
    template<typename... Args>
        requires requires(Surface& s) { s.try_flush(std::declval<Args>()...); }
    [[nodiscard]] decltype(auto) try_flush(Args&&... args) const {
        return _surface->try_flush(std::forward<Args>(args)...);
    }
 
    void fill_rect(size_t x, size_t y, size_t width, size_t height, pixel_type ink) noexcept {
        // Clamp the start to the drawable region in canvas coordinates so
        // the translated start is never left of or above the surface; the
        // surface-level fill_rect clips the far edges.
        const size_t sx = std::max(x, _dx > 0 ? static_cast<size_t>(_dx) : size_t{0});
        const size_t sy = std::max(y, _dy > 0 ? static_cast<size_t>(_dy) : size_t{0});
        if (sx >= _width || sy >= _height || sx - x >= width || sy - y >= height) {
            return;
        }
        gfx::fill_rect(
            *_surface,
            static_cast<size_t>(static_cast<ptrdiff_t>(sx) - _dx),
            static_cast<size_t>(static_cast<ptrdiff_t>(sy) - _dy),
            std::min(width - (sx - x), _width - sx),
            std::min(height - (sy - y), _height - sy),
            ink
        );
    }
 
    void draw_hline(size_t x, size_t y, size_t length, pixel_type ink) noexcept { fill_rect(x, y, length, 1, ink); }
 
    void draw_vline(size_t x, size_t y, size_t length, pixel_type ink) noexcept { fill_rect(x, y, 1, length, ink); }
 
    void draw_rect(size_t x, size_t y, size_t width, size_t height, pixel_type ink) noexcept {
        gfx::draw_rect(*this, x, y, width, height, ink);
    }
 
    void draw_line(size_t x0, size_t y0, size_t x1, size_t y1, pixel_type ink) noexcept {
        gfx::draw_line(*this, x0, y0, x1, y1, ink);
    }
 
    void draw_text(
        const font::mono_font& font,
        size_t x,
        size_t y,
        std::string_view text,
        pixel_type ink,
        unsigned scale = 1
    ) noexcept {
        gfx::draw_text(*this, font, x, y, text, ink, scale);
    }
 
    void draw_text(const font::mono_font& font, size_t x, size_t y, std::string_view text) noexcept
        requires std::same_as<pixel_type, bool>
    {
        gfx::draw_text(*this, font, x, y, text);
    }
 
private:
    // True when the drawable region spans the entire surface (the identity
    // and whole-band cases), enabling the surface's native fill/clear.
    [[nodiscard]] bool _covers_surface() const noexcept {
        return _dx >= 0 && _dy >= 0 && static_cast<size_t>(_dx) + _surface->width() <= _width &&
            static_cast<size_t>(_dy) + _surface->height() <= _height;
    }
 
    Surface* _surface;
    ptrdiff_t _dx; // canvas-coordinate position of the surface's (0, 0)
    ptrdiff_t _dy;
    size_t _width; // canvas-coordinate clip bounds
    size_t _height;
};
 
template<typename Surface, typename Dest, typename DrawFn>
concept banded_renderable = pixel_surface<Surface> && requires(canvas<Surface>& c, Dest& dest, DrawFn& draw) {
    draw(c);
    { c.try_flush(dest, size_t{}, size_t{}) } -> std::same_as<result<void>>;
};
template<pixel_surface Surface, typename Dest, typename DrawFn>
    requires banded_renderable<Surface, Dest, DrawFn>
[[nodiscard]] result<void> try_render_banded(Surface& band, Dest& dest, size_t frame_height, DrawFn&& draw);
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
template<pixel_surface Surface, typename Dest, typename DrawFn>
    requires banded_renderable<Surface, Dest, DrawFn>
void render_banded(Surface& band, Dest& dest, size_t frame_height, DrawFn&& draw) {
    unwrap(try_render_banded(band, dest, frame_height, draw));
}
#endif
 
template<pixel_surface Surface, typename Dest, typename DrawFn>
    requires banded_renderable<Surface, Dest, DrawFn>
[[nodiscard]] result<void> try_render_banded(Surface& band, Dest& dest, size_t frame_height, DrawFn&& draw) {
    const size_t band_height = band.height();
    if (band_height == 0 || frame_height == 0 || frame_height % band_height != 0) {
        return error(errc::invalid_arg);
    }
    for (size_t y = 0; y < frame_height; y += band_height) {
        canvas c(band, 0, y);
        c.clear();
        draw(c);
        if (auto flushed = c.try_flush(dest, size_t{0}, y); !flushed) {
            return flushed;
        }
    }
    return {};
}
 
 
} // namespace idfxx::gfx