Merge pull request #3374 from kmatch98/shape_update

Add dirty rectangle tracking to Shape display element

3 files changed, 78 insertions, 13 deletions

diff --git a/shared-module/displayio/Shape.c b/shared-module/displayio/Shape.c
index ab9ca735b..b94a392bc 100644
--- a/shared-module/displayio/Shape.c
+++ b/shared-module/displayio/Shape.c
@@ -29,6 +29,7 @@
 #include <string.h>
 
 #include "py/runtime.h"
+#include "py/misc.h"
 
 void common_hal_displayio_shape_construct(displayio_shape_t *self, uint32_t width,
     uint32_t height, bool mirror_x, bool mirror_y) {
@@ -37,37 +38,77 @@ void common_hal_displayio_shape_construct(displayio_shape_t *self, uint32_t widt
     self->width = width;
     if (self->mirror_x) {
         width /= 2;
-        width += self->width % 2 - 1;
+        width += self->width % 2;
     }
     self->half_width = width;
 
     self->height = height;
     if (self->mirror_y) {
         height /= 2;
-        height += self->height % 2 - 1;
+        height += self->height % 2;
     }
     self->half_height = height;
 
     self->data = m_malloc(height * sizeof(uint32_t), false);
-    for (uint16_t i = 0; i <= height; i++) {
+
+    for (uint16_t i = 0; i < height; i++) {
         self->data[2 * i] = 0;
         self->data[2 * i + 1] = width;
     }
+
+    self->dirty_area.x1=0;
+    self->dirty_area.x2=width;
+    self->dirty_area.y1=0;
+    self->dirty_area.y2=height;
 }
 
 void common_hal_displayio_shape_set_boundary(displayio_shape_t *self, uint16_t y, uint16_t start_x, uint16_t end_x) {
-    if (y < 0 || y >= self->height || (self->mirror_y && y > self->half_height)) {
+    if (y < 0 || y >= self->height || (self->mirror_y && y >= self->half_height)) {
         mp_raise_ValueError(translate("y value out of bounds"));
     }
-    if (start_x < 0 || start_x > self->width || end_x < 0 || end_x > self->width) {
+    if (start_x < 0 || start_x >= self->width || end_x < 0 || end_x >= self->width) {
         mp_raise_ValueError(translate("x value out of bounds"));
     }
-    uint16_t half_width = self->width / 2 - 1 + self->width % 2;
-    if (self->mirror_x && (start_x > half_width || end_x > half_width)) {
-        mp_raise_ValueError_varg(translate("Maximum x value when mirrored is %d"), half_width);
+    if (self->mirror_x && (start_x >= self->half_width || end_x >= self->half_width)) {
+        mp_raise_ValueError_varg(translate("Maximum x value when mirrored is %d"), self->half_width);
+    }
+
+    uint16_t lower_x, upper_x, lower_y, upper_y;
+
+    // find x-boundaries for updating based on current data and start_x, end_x, and mirror_x
+    lower_x = MIN(start_x, self->data[2 * y]);
+
+    if (self->mirror_x) {
+        upper_x = self->width - lower_x + 1; // dirty rectangles are treated with max value exclusive
+    } else {
+        upper_x = MAX(end_x, self->data[2 * y + 1]) + 1; // dirty rectangles are treated with max value exclusive
+    }
+
+    // find y-boundaries based on y and mirror_y
+    lower_y = y;
+
+    if (self->mirror_y) {
+        upper_y = self->height - lower_y + 1; // dirty rectangles are treated with max value exclusive
+    } else {
+        upper_y = y + 1; // dirty rectangles are treated with max value exclusive
     }
-    self->data[2 * y] = start_x;
+
+    self->data[2 * y] = start_x; // update the data array with the new boundaries
     self->data[2 * y + 1] = end_x;
+
+    if (self->dirty_area.x1 == self->dirty_area.x2) { // Dirty region is empty
+        self->dirty_area.x1 = lower_x;
+        self->dirty_area.x2 = upper_x;
+        self->dirty_area.y1 = lower_y;
+        self->dirty_area.y2 = upper_y;
+
+    } else { // Dirty region is not empty
+        self->dirty_area.x1 = MIN(lower_x, self->dirty_area.x1);
+        self->dirty_area.x2 = MAX(upper_x, self->dirty_area.x2);
+
+        self->dirty_area.y1 = MIN(lower_y, self->dirty_area.y1);
+        self->dirty_area.y2 = MAX(upper_y, self->dirty_area.y2);
+    }
 }
 
 uint32_t common_hal_displayio_shape_get_pixel(void *obj, int16_t x, int16_t y) {
@@ -75,10 +116,10 @@ uint32_t common_hal_displayio_shape_get_pixel(void *obj, int16_t x, int16_t y) {
     if (x >= self->width || x < 0 || y >= self->height || y < 0) {
         return 0;
     }
-    if (self->mirror_x && x > self->half_width) {
-        x = self->width - 1 - x;
+    if (self->mirror_x && x >= self->half_width) {
+        x = self->width - x - 1;
     }
-    if (self->mirror_y && y > self->half_height) {
+    if (self->mirror_y && y >= self->half_height) {
         y = self->height - y - 1;
     }
     uint16_t start_x = self->data[2 * y];
@@ -88,3 +129,16 @@ uint32_t common_hal_displayio_shape_get_pixel(void *obj, int16_t x, int16_t y) {
     }
     return 1;
 }
+
+displayio_area_t* displayio_shape_get_refresh_areas(displayio_shape_t *self, displayio_area_t* tail) {
+    if (self->dirty_area.x1 == self->dirty_area.x2) {
+        return tail;
+    }
+    self->dirty_area.next = tail;
+    return &self->dirty_area;
+}
+
+void displayio_shape_finish_refresh(displayio_shape_t *self) {
+    self->dirty_area.x1 = 0;
+    self->dirty_area.x2 = 0;
+}
diff --git a/shared-module/displayio/Shape.h b/shared-module/displayio/Shape.h
index ca054fe00..e59ad586e 100644
--- a/shared-module/displayio/Shape.h
+++ b/shared-module/displayio/Shape.h
@@ -31,6 +31,7 @@
 #include <stdint.h>
 
 #include "py/obj.h"
+#include "shared-module/displayio/area.h"
 
 typedef struct {
     mp_obj_base_t base;
@@ -41,6 +42,10 @@ typedef struct {
     uint16_t* data;
     bool mirror_x;
     bool mirror_y;
+    displayio_area_t dirty_area;
 } displayio_shape_t;
 
+void displayio_shape_finish_refresh(displayio_shape_t *self);
+displayio_area_t* displayio_shape_get_refresh_areas(displayio_shape_t *self, displayio_area_t* tail);
+
 #endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_SHAPE_H
diff --git a/shared-module/displayio/TileGrid.c b/shared-module/displayio/TileGrid.c
index 2766cbecd..e3642107f 100644
--- a/shared-module/displayio/TileGrid.c
+++ b/shared-module/displayio/TileGrid.c
@@ -499,7 +499,7 @@ void displayio_tilegrid_finish_refresh(displayio_tilegrid_t *self) {
     if (MP_OBJ_IS_TYPE(self->bitmap, &displayio_bitmap_type)) {
         displayio_bitmap_finish_refresh(self->bitmap);
     } else if (MP_OBJ_IS_TYPE(self->bitmap, &displayio_shape_type)) {
-        // TODO: Support shape changes.
+        displayio_shape_finish_refresh(self->bitmap);
     } else if (MP_OBJ_IS_TYPE(self->bitmap, &displayio_ondiskbitmap_type)) {
         // OnDiskBitmap changes will trigger a complete reload so no need to
         // track changes.
@@ -543,6 +543,12 @@ displayio_area_t* displayio_tilegrid_get_refresh_areas(displayio_tilegrid_t *sel
                 self->full_change = true;
             }
         }
+    } else if (MP_OBJ_IS_TYPE(self->bitmap, &displayio_shape_type)) {
+        displayio_area_t* refresh_area = displayio_shape_get_refresh_areas(self->bitmap, tail);
+        if (refresh_area != tail) {
+            displayio_area_copy(refresh_area, &self->dirty_area);
+            self->partial_change = true;
+        }
     }
 
     self->full_change = self->full_change ||