7 files changed, 159 insertions, 8 deletions

diff --git a/drivers/painter/comms/qp_comms_spi.c b/drivers/painter/comms/qp_comms_spi.c
index 4e6067394b..8f4fc12a3c 100644
--- a/drivers/painter/comms/qp_comms_spi.c
+++ b/drivers/painter/comms/qp_comms_spi.c
@@ -36,7 +36,7 @@ uint32_t qp_comms_spi_send_data(painter_device_t device, const void *data, uint3
     const uint32_t max_msg_length  = 1024;
 
     while (bytes_remaining > 0) {
-        uint32_t bytes_this_loop = QP_MIN(bytes_remaining, max_msg_length);
+        uint32_t bytes_this_loop = MIN(bytes_remaining, max_msg_length);
         spi_transmit(p, bytes_this_loop);
         p += bytes_this_loop;
         bytes_remaining -= bytes_this_loop;
diff --git a/drivers/painter/generic/qp_surface.h b/drivers/painter/generic/qp_surface.h
index a291793649..f602a8770b 100644
--- a/drivers/painter/generic/qp_surface.h
+++ b/drivers/painter/generic/qp_surface.h
@@ -51,6 +51,16 @@ painter_device_t qp_make_rgb565_surface(uint16_t panel_width, uint16_t panel_hei
 painter_device_t qp_make_mono1bpp_surface(uint16_t panel_width, uint16_t panel_height, void *buffer);
 
 /**
+ * Factory method for an RGB888 surface (aka framebuffer).
+ *
+ * @param panel_width[in] the width of the display panel
+ * @param panel_height[in] the height of the display panel
+ * @param buffer[in] pointer to a preallocated uint8_t buffer of size `SURFACE_REQUIRED_BUFFER_BYTE_SIZE(panel_width, panel_height, 16)`
+ * @return the device handle used with all drawing routines in Quantum Painter
+ */
+painter_device_t qp_make_rgb888_surface(uint16_t panel_width, uint16_t panel_height, void *buffer);
+
+/**
  * Helper method to draw the contents of the framebuffer to the target device.
  *
  * After successful completion, the dirty area is reset.
diff --git a/drivers/painter/generic/qp_surface_internal.h b/drivers/painter/generic/qp_surface_internal.h
index 71f82e924d..e05a58594b 100644
--- a/drivers/painter/generic/qp_surface_internal.h
+++ b/drivers/painter/generic/qp_surface_internal.h
@@ -45,6 +45,7 @@ typedef struct surface_painter_device_t {
         void *    buffer;
         uint8_t * u8buffer;
         uint16_t *u16buffer;
+        rgb_t *   rgbbuffer;
     };
 
     // Manually manage the viewport for streaming pixel data to the display
diff --git a/drivers/painter/generic/qp_surface_rgb565.c b/drivers/painter/generic/qp_surface_rgb565.c
index c5b351311a..2426d53c0c 100644
--- a/drivers/painter/generic/qp_surface_rgb565.c
+++ b/drivers/painter/generic/qp_surface_rgb565.c
@@ -52,7 +52,7 @@ static bool qp_surface_pixdata_rgb565(painter_device_t device, const void *pixel
 // Pixel colour conversion
 static bool qp_surface_palette_convert_rgb565_swapped(painter_device_t device, int16_t palette_size, qp_pixel_t *palette) {
     for (int16_t i = 0; i < palette_size; ++i) {
-        rgb_t    rgb      = hsv_to_rgb_nocie((hsv_t){palette[i].hsv888.h, palette[i].hsv888.s, palette[i].hsv888.v});
+        rgb_t    rgb      = hsv_to_rgb_nocie(palette[i].hsv888);
         uint16_t rgb565   = (((uint16_t)rgb.r) >> 3) << 11 | (((uint16_t)rgb.g) >> 2) << 5 | (((uint16_t)rgb.b) >> 3);
         palette[i].rgb565 = __builtin_bswap16(rgb565);
     }
diff --git a/drivers/painter/generic/qp_surface_rgb888.c b/drivers/painter/generic/qp_surface_rgb888.c
new file mode 100644
index 0000000000..68c824b0e4
--- /dev/null
+++ b/drivers/painter/generic/qp_surface_rgb888.c
@@ -0,0 +1,143 @@
+// Copyright 2022 Nick Brassel (@tzarc)
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#ifdef QUANTUM_PAINTER_SURFACE_ENABLE
+
+#    include "color.h"
+#    include "qp_draw.h"
+#    include "qp_surface_internal.h"
+#    include "qp_comms_dummy.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Surface driver impl: rgb888
+
+static inline void setpixel_rgb888(surface_painter_device_t *surface, uint16_t x, uint16_t y, rgb_t rgb888) {
+    uint16_t w = surface->base.panel_width;
+    uint16_t h = surface->base.panel_height;
+
+    // Drop out if it's off-screen
+    if (x >= w || y >= h) {
+        return;
+    }
+
+    // Skip messing with the dirty info if the original value already matches
+    if (memcmp(&surface->rgbbuffer[y * w + x], &rgb888, sizeof(rgb_t)) != 0) {
+        // Update the dirty region
+        qp_surface_update_dirty(&surface->dirty, x, y);
+
+        // Update the pixel data in the buffer
+        surface->rgbbuffer[y * w + x] = rgb888;
+    }
+}
+
+static inline void append_pixel_rgb888(surface_painter_device_t *surface, rgb_t rgb888) {
+    setpixel_rgb888(surface, surface->viewport.pixdata_x, surface->viewport.pixdata_y, rgb888);
+    qp_surface_increment_pixdata_location(&surface->viewport);
+}
+
+static inline void stream_pixdata_rgb888(surface_painter_device_t *surface, const rgb_t *data, uint32_t native_pixel_count) {
+    for (uint32_t pixel_counter = 0; pixel_counter < native_pixel_count; ++pixel_counter) {
+        append_pixel_rgb888(surface, data[pixel_counter]);
+    }
+}
+
+// Stream pixel data to the current write position in GRAM
+static bool qp_surface_pixdata_rgb888(painter_device_t device, const void *pixel_data, uint32_t native_pixel_count) {
+    painter_driver_t *        driver  = (painter_driver_t *)device;
+    surface_painter_device_t *surface = (surface_painter_device_t *)driver;
+    stream_pixdata_rgb888(surface, (const rgb_t *)pixel_data, native_pixel_count);
+    return true;
+}
+
+// Pixel colour conversion
+static bool qp_surface_palette_convert_rgb888(painter_device_t device, int16_t palette_size, qp_pixel_t *palette) {
+    for (int16_t i = 0; i < palette_size; ++i) {
+        palette[i].rgb888 = hsv_to_rgb_nocie(palette[i].hsv888);
+    }
+    return true;
+}
+
+// Append pixels to the target location, keyed by the pixel index
+static bool qp_surface_append_pixels_rgb888(painter_device_t device, uint8_t *target_buffer, qp_pixel_t *palette, uint32_t pixel_offset, uint32_t pixel_count, uint8_t *palette_indices) {
+    rgb_t *buf = (rgb_t *)target_buffer;
+    for (uint32_t i = 0; i < pixel_count; ++i) {
+        buf[pixel_offset + i] = palette[palette_indices[i]].rgb888;
+    }
+    return true;
+}
+
+static bool rgb888_target_pixdata_transfer(painter_driver_t *surface_driver, painter_driver_t *target_driver, uint16_t x, uint16_t y, bool entire_surface) {
+    surface_painter_device_t *surface_handle = (surface_painter_device_t *)surface_driver;
+
+    uint16_t l = entire_surface ? 0 : surface_handle->dirty.l;
+    uint16_t t = entire_surface ? 0 : surface_handle->dirty.t;
+    uint16_t r = entire_surface ? (surface_handle->base.panel_width - 1) : surface_handle->dirty.r;
+    uint16_t b = entire_surface ? (surface_handle->base.panel_height - 1) : surface_handle->dirty.b;
+
+    // Set the target drawing area
+    bool ok = qp_viewport((painter_device_t)target_driver, x + l, y + t, x + r, y + b);
+    if (!ok) {
+        qp_dprintf("rgb888_target_pixdata_transfer: fail (could not set target viewport)\n");
+        return false;
+    }
+
+    // Housekeeping of the amount of pixels to transfer
+    uint32_t total_pixel_count = (8 * QUANTUM_PAINTER_PIXDATA_BUFFER_SIZE) / surface_driver->native_bits_per_pixel;
+    uint32_t pixel_counter     = 0;
+    rgb_t *  target_buffer     = (rgb_t *)qp_internal_global_pixdata_buffer;
+
+    // Fill the global pixdata area so that we can start transferring to the panel
+    for (uint16_t y = t; y <= b; ++y) {
+        for (uint16_t x = l; x <= r; ++x) {
+            // Update the target buffer
+            target_buffer[pixel_counter++] = surface_handle->rgbbuffer[y * surface_handle->base.panel_width + x];
+
+            // If we've accumulated enough data, send it
+            if (pixel_counter == total_pixel_count) {
+                ok = qp_pixdata((painter_device_t)target_driver, qp_internal_global_pixdata_buffer, pixel_counter);
+                if (!ok) {
+                    qp_dprintf("rgb888_target_pixdata_transfer: fail (could not stream pixdata to target)\n");
+                    return false;
+                }
+                // Reset the counter
+                pixel_counter = 0;
+            }
+        }
+    }
+
+    // If there's any leftover data, send it
+    if (pixel_counter > 0) {
+        ok = qp_pixdata((painter_device_t)target_driver, qp_internal_global_pixdata_buffer, pixel_counter);
+        if (!ok) {
+            qp_dprintf("rgb888_target_pixdata_transfer: fail (could not stream pixdata to target)\n");
+            return false;
+        }
+    }
+
+    return true;
+}
+
+static bool qp_surface_append_pixdata_rgb888(painter_device_t device, uint8_t *target_buffer, uint32_t pixdata_offset, uint8_t pixdata_byte) {
+    target_buffer[pixdata_offset] = pixdata_byte;
+    return true;
+}
+
+const surface_painter_driver_vtable_t rgb888_surface_driver_vtable = {
+    .base =
+        {
+            .init            = qp_surface_init,
+            .power           = qp_surface_power,
+            .clear           = qp_surface_clear,
+            .flush           = qp_surface_flush,
+            .pixdata         = qp_surface_pixdata_rgb888,
+            .viewport        = qp_surface_viewport,
+            .palette_convert = qp_surface_palette_convert_rgb888,
+            .append_pixels   = qp_surface_append_pixels_rgb888,
+            .append_pixdata  = qp_surface_append_pixdata_rgb888,
+        },
+    .target_pixdata_transfer = rgb888_target_pixdata_transfer,
+};
+
+SURFACE_FACTORY_FUNCTION_IMPL(qp_make_rgb888_surface, rgb888_surface_driver_vtable, 24);
+
+#endif // QUANTUM_PAINTER_SURFACE_ENABLE
diff --git a/drivers/painter/ili9xxx/qp_ili9486.c b/drivers/painter/ili9xxx/qp_ili9486.c
index 48db779c04..5a2e226668 100644
--- a/drivers/painter/ili9xxx/qp_ili9486.c
+++ b/drivers/painter/ili9xxx/qp_ili9486.c
@@ -90,7 +90,7 @@ static uint32_t qp_comms_spi_send_data_odd_cs_pulse(painter_device_t device, con
 
     gpio_write_pin_high(comms_config->dc_pin);
     while (bytes_remaining > 0) {
-        uint32_t bytes_this_loop = QP_MIN(bytes_remaining, max_msg_length);
+        uint32_t bytes_this_loop = MIN(bytes_remaining, max_msg_length);
         bool     odd_bytes       = bytes_this_loop & 1;
 
         // send data
diff --git a/drivers/painter/tft_panel/qp_tft_panel.c b/drivers/painter/tft_panel/qp_tft_panel.c
index c8e33343d4..a6c72b4f6f 100644
--- a/drivers/painter/tft_panel/qp_tft_panel.c
+++ b/drivers/painter/tft_panel/qp_tft_panel.c
@@ -90,7 +90,7 @@ bool qp_tft_panel_pixdata(painter_device_t device, const void *pixel_data, uint3
 
 bool qp_tft_panel_palette_convert_rgb565_swapped(painter_device_t device, int16_t palette_size, qp_pixel_t *palette) {
     for (int16_t i = 0; i < palette_size; ++i) {
-        rgb_t    rgb      = hsv_to_rgb_nocie((hsv_t){palette[i].hsv888.h, palette[i].hsv888.s, palette[i].hsv888.v});
+        rgb_t    rgb      = hsv_to_rgb_nocie(palette[i].hsv888);
         uint16_t rgb565   = (((uint16_t)rgb.r) >> 3) << 11 | (((uint16_t)rgb.g) >> 2) << 5 | (((uint16_t)rgb.b) >> 3);
         palette[i].rgb565 = __builtin_bswap16(rgb565);
     }
@@ -99,10 +99,7 @@ bool qp_tft_panel_palette_convert_rgb565_swapped(painter_device_t device, int16_
 
 bool qp_tft_panel_palette_convert_rgb888(painter_device_t device, int16_t palette_size, qp_pixel_t *palette) {
     for (int16_t i = 0; i < palette_size; ++i) {
-        rgb_t rgb           = hsv_to_rgb_nocie((hsv_t){palette[i].hsv888.h, palette[i].hsv888.s, palette[i].hsv888.v});
-        palette[i].rgb888.r = rgb.r;
-        palette[i].rgb888.g = rgb.g;
-        palette[i].rgb888.b = rgb.b;
+        palette[i].rgb888 = hsv_to_rgb_nocie(palette[i].hsv888);
     }
     return true;
 }