canvas.h

/*
 * Copyright © 2024 Synthstrom Audible Limited
 *
 * This file is part of The Synthstrom Audible Deluge Firmware.
 *
 * The Synthstrom Audible Deluge Firmware is free software: you can redistribute it and/or modify it under the
 * terms of the GNU General Public License as published by the Free Software Foundation,
 * either version 3 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with this program.
 * If not, see <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include "RZA1/cpu_specific.h"
#include "definitions.h"
#include "deluge/util/d_string.h"
#include <cstring>
#include <functional>
#include <optional>
#include <string_view>
 
namespace deluge::hid::display {
class OLED;
struct Icon;
 
namespace oled_canvas {
 
enum BorderRadius : uint8_t {
    SMALL = 0, //< 1px
    BIG = 1    //< 2px
};
 
struct Point {
    int32_t x;
    int32_t y;
    bool operator==(const Point& other) const noexcept { return x == other.x && y == other.y; }
};
 
struct DrawLineOptions {
    bool thick{false};
    std::optional<uint8_t> min_x{std::nullopt};
    std::optional<uint8_t> max_x{std::nullopt};
    std::optional<std::function<void(Point)>> point_callback{std::nullopt};
};
 
class Canvas {
public:
    Canvas() = default;
    ~Canvas() = default;
 
    Canvas(Canvas const& other) = delete;
    Canvas(Canvas&& other) = delete;
 
    Canvas& operator=(Canvas const& other) = delete;
    Canvas& operator=(Canvas&& other) = delete;


    void clear() {
        // Takes about 1 fast-timer tick (whereas entire rendering takes around 8 to 15).
        // So, not worth trying to use DMA here or anything.
        memset(image_, 0, sizeof(image_));
    };

    void clearAreaExact(int32_t minX, int32_t minY, int32_t maxX, int32_t maxY);

    void drawPixel(int32_t x, int32_t y);

    void clearPixel(int32_t x, int32_t y);

    void invertPixel(int32_t x, int32_t y);

    void drawHorizontalLine(int32_t pixelY, int32_t startX, int32_t endX);

    void drawVerticalLine(int32_t pixelX, int32_t startY, int32_t endY);

    void drawLine(int32_t x0, int32_t y0, int32_t x1, int32_t y1, const DrawLineOptions& options = {});

    void drawRectangle(int32_t minX, int32_t minY, int32_t maxX, int32_t maxY);

    void drawRectangleRounded(int32_t minX, int32_t minY, int32_t maxX, int32_t maxY, BorderRadius radius = SMALL);

    void drawCircle(int32_t centerX, int32_t centerY, int32_t radius, bool fill = false);

    void drawString(std::string_view str, int32_t pixelX, int32_t pixelY, int32_t textWidth, int32_t textHeight,
                    int32_t scrollPos = 0, int32_t endX = OLED_MAIN_WIDTH_PIXELS, bool useTextWidth = false);

    void drawStringCentred(char const* string, int32_t pixelY, int32_t textWidth, int32_t textHeight,
                           int32_t centrePos = OLED_MAIN_WIDTH_PIXELS / 2);

    void drawStringCentered(char const* string, int32_t startX, int32_t startY, int32_t textSpacingX,
                            int32_t textSpacingY, int32_t totalWidth);

    void drawStringCentered(StringBuf& stringBuf, int32_t startX, int32_t startY, int32_t textSpacingX,
                            int32_t textSpacingY, int32_t totalWidth);

    void drawStringCentredShrinkIfNecessary(char const* string, int32_t pixelY, int32_t textWidth, int32_t textHeight);

    void drawStringAlignRight(char const* string, int32_t pixelY, int32_t textWidth, int32_t textHeight,
                              int32_t rightPos = OLED_MAIN_WIDTH_PIXELS);

    void drawChar(uint8_t theChar, int32_t pixelX, int32_t pixelY, int32_t textWidth, int32_t textHeight,
                  int32_t scrollPos = 0, int32_t endX = OLED_MAIN_WIDTH_PIXELS);

    int32_t getCharIndex(uint8_t theChar);

    int32_t getCharWidthInPixels(uint8_t theChar, int32_t textHeight);

    int32_t getCharSpacingInPixels(uint8_t theChar, int32_t textHeight, bool isLastChar);

    int32_t getStringWidthInPixels(char const* string, int32_t textHeight);

    void drawGraphicMultiLine(uint8_t const* graphic, int32_t startX, int32_t startY, int32_t width, int32_t height = 8,
                              int32_t numBytesTall = 1, bool reversed = false);
    void drawIcon(const Icon& icon, int32_t x, int32_t y, bool reversed = false);

    void drawIconCentered(const Icon& icon, int32_t startX, int32_t totalWidth, int32_t y, bool reversed = false);

    void drawScreenTitle(std::string_view text, bool drawSeparator = true);

    void invertArea(int32_t xMin, int32_t width, int32_t startY, int32_t endY);

    void invertAreaRounded(int32_t xMin, int32_t width, int32_t startY, int32_t endY, BorderRadius radius = SMALL);

    void invertLeftEdgeForMenuHighlighting(int32_t xMin, int32_t width, int32_t startY, int32_t endY);


    static constexpr uint32_t kImageHeight = OLED_MAIN_HEIGHT_PIXELS >> 3;
    static constexpr uint32_t kImageWidth = OLED_MAIN_WIDTH_PIXELS;
 
    using ImageStore = uint8_t[kImageHeight][kImageWidth];

    ImageStore& hackGetImageStore() { return image_; }
 
private:
    [[gnu::aligned(CACHE_LINE_SIZE)]] uint8_t image_[kImageHeight][kImageWidth];
};
} // namespace oled_canvas
} // namespace deluge::hid::display