From 206d0e598adb66e2b23a39a7d11e2f5087513205 Mon Sep 17 00:00:00 2001
From: warriorofwire <3454741+WarriorOfWire@users.noreply.github.com>
Date: Sat, 2 May 2020 02:21:35 -0700
Subject: Add vectorio: for drawing shapes

vectorio builds on m4 express feather

Concrete shapes are composed into a VectorShape which is put into a displayio Group for display.

VectorShape provides transpose and x/y positioning for shape implementations.

Included Shapes:

* Circle
  - A radius; Circle is positioned at its axis in the VectorShape.
  - You can freely modify the radius to grow and shrink the circle in-place.

* Polygon
  - An ordered list of points.
  - Beteween each successive point an edge is inferred.  A final edge closing the shape is inferred between the last
    point and the first point.
  - You can modify the points in a Polygon.  The points' coordinate system is relative to (0, 0) so if you'd like a
      top-center justified 10x20 rectangle you can do points [(-5, 0), (5, 0), (5, 20), (0, 20)] and your VectorShape
      x and y properties will position the rectangle relative to its top center point

* Rectangle
  A width and a height.
---
 shared-module/displayio/Group.c        | 35 +++++++++++++++++++++++++++++++++-
 shared-module/displayio/display_core.c |  4 ++++
 2 files changed, 38 insertions(+), 1 deletion(-)

(limited to 'shared-module/displayio')

diff --git a/shared-module/displayio/Group.c b/shared-module/displayio/Group.c
index d69e9f585..9d50dabec 100644
--- a/shared-module/displayio/Group.c
+++ b/shared-module/displayio/Group.c
@@ -29,6 +29,11 @@
 #include "py/runtime.h"
 #include "shared-bindings/displayio/TileGrid.h"
 
+#if CIRCUITPY_VECTORIO
+#include "shared-bindings/vectorio/VectorShape.h"
+#endif
+
+
 void common_hal_displayio_group_construct(displayio_group_t* self, uint32_t max_size, uint32_t scale, mp_int_t x, mp_int_t y) {
     displayio_group_child_t* children = m_new(displayio_group_child_t, max_size);
     displayio_group_construct(self, children, max_size, scale, x, y);
@@ -200,7 +205,14 @@ void common_hal_displayio_group_set_y(displayio_group_t* self, mp_int_t y) {
 }
 
 static mp_obj_t _add_layer(displayio_group_t* self, mp_obj_t layer) {
-    mp_obj_t native_layer = mp_instance_cast_to_native_base(layer, &displayio_group_type);
+    mp_obj_t native_layer;
+#if CIRCUITPY_VECTORIO
+    native_layer = mp_instance_cast_to_native_base(layer, &vectorio_vector_shape_type);
+    if (native_layer != MP_OBJ_NULL) {
+        return native_layer;
+    }
+#endif
+    native_layer = mp_instance_cast_to_native_base(layer, &displayio_group_type);
     if (native_layer == MP_OBJ_NULL) {
         native_layer = mp_instance_cast_to_native_base(layer, &displayio_tilegrid_type);
         if (native_layer == MP_OBJ_NULL) {
@@ -317,6 +329,15 @@ bool displayio_group_fill_area(displayio_group_t *self, const _displayio_colorsp
     bool full_coverage = false;
     for (int32_t i = self->size - 1; i >= 0 ; i--) {
         mp_obj_t layer = self->children[i].native;
+#if CIRCUITPY_VECTORIO
+        if (MP_OBJ_IS_TYPE(layer, &vectorio_vector_shape_type)) {
+            if (vectorio_vector_shape_fill_area(layer, colorspace, area, mask, buffer)) {
+                full_coverage = true;
+                break;
+            }
+        }
+        else
+#endif
         if (MP_OBJ_IS_TYPE(layer, &displayio_tilegrid_type)) {
             if (displayio_tilegrid_fill_area(layer, colorspace, area, mask, buffer)) {
                 full_coverage = true;
@@ -336,6 +357,12 @@ void displayio_group_finish_refresh(displayio_group_t *self) {
     self->item_removed = false;
     for (int32_t i = self->size - 1; i >= 0 ; i--) {
         mp_obj_t layer = self->children[i].native;
+#if CIRCUITPY_VECTORIO
+        if (MP_OBJ_IS_TYPE(layer, &vectorio_vector_shape_type)) {
+            vectorio_vector_shape_finish_refresh(layer);
+        }
+        else
+#endif
         if (MP_OBJ_IS_TYPE(layer, &displayio_tilegrid_type)) {
             displayio_tilegrid_finish_refresh(layer);
         } else if (MP_OBJ_IS_TYPE(layer, &displayio_group_type)) {
@@ -352,6 +379,12 @@ displayio_area_t* displayio_group_get_refresh_areas(displayio_group_t *self, dis
 
     for (int32_t i = self->size - 1; i >= 0 ; i--) {
         mp_obj_t layer = self->children[i].native;
+#if CIRCUITPY_VECTORIO
+        if (MP_OBJ_IS_TYPE(layer, &vectorio_vector_shape_type)) {
+            tail = vectorio_vector_shape_get_refresh_areas(layer, tail);
+        }
+        else
+#endif
         if (MP_OBJ_IS_TYPE(layer, &displayio_tilegrid_type)) {
             tail = displayio_tilegrid_get_refresh_areas(layer, tail);
         } else if (MP_OBJ_IS_TYPE(layer, &displayio_group_type)) {
diff --git a/shared-module/displayio/display_core.c b/shared-module/displayio/display_core.c
index d01100f7f..43f2d1937 100644
--- a/shared-module/displayio/display_core.c
+++ b/shared-module/displayio/display_core.c
@@ -40,6 +40,9 @@
 #include <stdint.h>
 #include <string.h>
 
+#define DISPLAYIO_CORE_DEBUG(...) (void)0
+// #define DISPLAYIO_CORE_DEBUG(...) mp_printf(&mp_plat_print __VA_OPT__(,) __VA_ARGS__)
+
 void displayio_display_core_construct(displayio_display_core_t* self,
         mp_obj_t bus, uint16_t width, uint16_t height, uint16_t ram_width, uint16_t ram_height, int16_t colstart, int16_t rowstart, uint16_t rotation,
         uint16_t color_depth, bool grayscale, bool pixels_in_byte_share_row, uint8_t bytes_per_cell, bool reverse_pixels_in_byte, bool reverse_bytes_in_word) {
@@ -298,6 +301,7 @@ void displayio_display_core_start_refresh(displayio_display_core_t* self) {
 
 void displayio_display_core_finish_refresh(displayio_display_core_t* self) {
     if (self->current_group != NULL) {
+        DISPLAYIO_CORE_DEBUG("displayiocore group_finish_refresh\n");
         displayio_group_finish_refresh(self->current_group);
     }
     self->full_refresh = false;
-- 
cgit v1.2.3


From 4086600b61f14e043f02c1b8771e7780b82f313c Mon Sep 17 00:00:00 2001
From: warriorofwire <3454741+WarriorOfWire@users.noreply.github.com>
Date: Fri, 8 May 2020 23:03:15 -0700
Subject: vectorio: switch per-shape transform to Display

Rather than maintain a transform per-shape, we'll just use whatever
  settings are on the Display.  Currently only transpose is done.
---
 shared-bindings/vectorio/VectorShape.c | 22 ++--------------------
 shared-bindings/vectorio/VectorShape.h |  8 +++++---
 shared-module/displayio/Group.c        |  6 ++++++
 shared-module/vectorio/VectorShape.c   | 34 ++++++++++++++++++++++++----------
 shared-module/vectorio/VectorShape.h   |  2 +-
 5 files changed, 38 insertions(+), 34 deletions(-)

(limited to 'shared-module/displayio')

diff --git a/shared-bindings/vectorio/VectorShape.c b/shared-bindings/vectorio/VectorShape.c
index 8f99577b4..02a42536d 100644
--- a/shared-bindings/vectorio/VectorShape.c
+++ b/shared-bindings/vectorio/VectorShape.c
@@ -32,13 +32,12 @@
 //|   :param int y: Initial y position of the center axis of the shape within the parent.
 //|
 STATIC mp_obj_t vectorio_vector_shape_make_new(const mp_obj_type_t *type, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    enum { ARG_shape, ARG_pixel_shader, ARG_x, ARG_y, ARG_transpose_xy };
+    enum { ARG_shape, ARG_pixel_shader, ARG_x, ARG_y };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_shape, MP_ARG_OBJ | MP_ARG_KW_ONLY | MP_ARG_REQUIRED },
         { MP_QSTR_pixel_shader, MP_ARG_OBJ | MP_ARG_KW_ONLY | MP_ARG_REQUIRED },
         { MP_QSTR_x, MP_ARG_INT | MP_ARG_KW_ONLY, {.u_int = 0} },
         { MP_QSTR_y, MP_ARG_INT | MP_ARG_KW_ONLY, {.u_int = 0} },
-        { MP_QSTR_transpose_xy, MP_ARG_BOOL | MP_ARG_KW_ONLY, {.u_bool = false} },
     };
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
@@ -74,7 +73,7 @@ STATIC mp_obj_t vectorio_vector_shape_make_new(const mp_obj_type_t *type, size_t
     vectorio_vector_shape_t *self = m_new_obj(vectorio_vector_shape_t);
     self->base.type = &vectorio_vector_shape_type;
     common_hal_vectorio_vector_shape_construct(self,
-        ishape, pixel_shader, x, y, args[ARG_transpose_xy].u_bool
+        ishape, pixel_shader, x, y
     );
 
     // Wire up event callbacks
@@ -150,23 +149,6 @@ const mp_obj_property_t vectorio_vector_shape_y_obj = {
 };
 
 
-//|   .. attribute:: transpose_xy
-//|
-//|     true if the object is to be flipped.
-//|
-STATIC mp_obj_t vectorio_vector_shape_obj_get_transpose_xy(mp_obj_t self_in) {
-    vectorio_vector_shape_t *self = MP_OBJ_TO_PTR(self_in);
-    return mp_obj_new_bool(common_hal_vectorio_vector_shape_get_transpose_xy(self));
-}
-MP_DEFINE_CONST_FUN_OBJ_1(vectorio_vector_shape_get_transpose_xy_obj, vectorio_vector_shape_obj_get_transpose_xy);
-
-const mp_obj_property_t vectorio_vector_shape_transpose_xy_obj = {
-    .base.type = &mp_type_property,
-    .proxy = {(mp_obj_t)&vectorio_vector_shape_get_transpose_xy_obj,
-              (mp_obj_t)&mp_const_none_obj,
-              (mp_obj_t)&mp_const_none_obj},
-};
-
 //|   .. attribute:: pixel_shader
 //|
 //|     The pixel shader of the shape.
diff --git a/shared-bindings/vectorio/VectorShape.h b/shared-bindings/vectorio/VectorShape.h
index ad745b30f..d098504e9 100644
--- a/shared-bindings/vectorio/VectorShape.h
+++ b/shared-bindings/vectorio/VectorShape.h
@@ -2,12 +2,13 @@
 #define MICROPY_INCLUDED_SHARED_BINDINGS_VECTORIO_SHAPE_H
 
 #include "shared-module/vectorio/VectorShape.h"
+#include "shared-module/displayio/area.h"
 
 extern const mp_obj_type_t vectorio_vector_shape_type;
 
 void common_hal_vectorio_vector_shape_construct(vectorio_vector_shape_t *self,
         vectorio_ishape_t ishape,
-        mp_obj_t pixel_shader, uint16_t x, uint16_t y, bool transpose_xy);
+        mp_obj_t pixel_shader, uint16_t x, uint16_t y);
 
 void common_hal_vectorio_vector_shape_set_dirty(void *self);
 
@@ -17,9 +18,10 @@ void common_hal_vectorio_vector_shape_set_x(vectorio_vector_shape_t *self, mp_in
 mp_int_t common_hal_vectorio_vector_shape_get_y(vectorio_vector_shape_t *self);
 void common_hal_vectorio_vector_shape_set_y(vectorio_vector_shape_t *self, mp_int_t y);
 
-bool common_hal_vectorio_vector_shape_get_transpose_xy(vectorio_vector_shape_t *self);
-
 mp_obj_t common_hal_vectorio_vector_shape_get_pixel_shader(vectorio_vector_shape_t *self);
 void common_hal_vectorio_vector_shape_set_pixel_shader(vectorio_vector_shape_t *self, mp_obj_t pixel_shader);
 
+
+void vectorio_vector_shape_update_transform(vectorio_vector_shape_t *self, displayio_buffer_transform_t *group_transform);
+
 #endif // MICROPY_INCLUDED_SHARED_BINDINGS_VECTORIO_SHAPE_H
diff --git a/shared-module/displayio/Group.c b/shared-module/displayio/Group.c
index 9d50dabec..0c31de532 100644
--- a/shared-module/displayio/Group.c
+++ b/shared-module/displayio/Group.c
@@ -122,6 +122,12 @@ static void _update_child_transforms(displayio_group_t* self) {
     }
     for (size_t i = 0; i < self->size; i++) {
         mp_obj_t layer = self->children[i].native;
+#if CIRCUITPY_VECTORIO
+        if (MP_OBJ_IS_TYPE(layer, &vectorio_vector_shape_type)) {
+            vectorio_vector_shape_update_transform(layer, &self->absolute_transform);
+        }
+        else
+#endif
         if (MP_OBJ_IS_TYPE(layer, &displayio_tilegrid_type)) {
             displayio_tilegrid_update_transform(layer, &self->absolute_transform);
         } else if (MP_OBJ_IS_TYPE(layer, &displayio_group_type)) {
diff --git a/shared-module/vectorio/VectorShape.c b/shared-module/vectorio/VectorShape.c
index 985b77858..6030c1e3d 100644
--- a/shared-module/vectorio/VectorShape.c
+++ b/shared-module/vectorio/VectorShape.c
@@ -50,7 +50,7 @@ inline __attribute__((always_inline))
 static void _get_screen_area(vectorio_vector_shape_t *self, displayio_area_t *out_area) {
     VECTORIO_SHAPE_DEBUG("%p get_screen_area\n", self);
     self->ishape.get_area(self->ishape.shape, out_area);
-    if (self->transpose_xy) {
+    if (self->absolute_transform->transpose_xy) {
         _transpose_area(out_area);
         displayio_area_shift(out_area, self->y, self->x);
     } else {
@@ -76,18 +76,32 @@ void common_hal_vectorio_vector_shape_set_dirty(void *vector_shape) {
 }
 
 
+static displayio_buffer_transform_t null_transform = {
+    .x = 0,
+    .y = 0,
+    .dx = 0,
+    .dy = 0,
+    .scale = 1,
+    .width = 0,
+    .height = 0,
+    .mirror_x = false,
+    .mirror_y = false,
+    .transpose_xy = false
+};
+
+
 void common_hal_vectorio_vector_shape_construct(vectorio_vector_shape_t *self,
         vectorio_ishape_t ishape,
-        mp_obj_t pixel_shader, uint16_t x, uint16_t y, bool transpose_xy) {
+        mp_obj_t pixel_shader, uint16_t x, uint16_t y) {
     VECTORIO_SHAPE_DEBUG("%p vector_shape_construct x:%3d, y:%3d\n", self, x, y);
     self->x = x;
     self->y = y;
     self->pixel_shader = pixel_shader;
     self->ishape = ishape;
-    self->transpose_xy = transpose_xy;
     self->dirty = true;
     _get_screen_area(self, &self->ephemeral_dirty_area);
     self->ephemeral_dirty_area.next = NULL;
+    self->absolute_transform = &null_transform;
 }
 
 
@@ -123,12 +137,6 @@ void common_hal_vectorio_vector_shape_set_y(vectorio_vector_shape_t *self, mp_in
 }
 
 
-bool common_hal_vectorio_vector_shape_get_transpose_xy(vectorio_vector_shape_t *self) {
-    VECTORIO_SHAPE_DEBUG("%p get_transpose_xy\n", self);
-    return self->transpose_xy;
-}
-
-
 mp_obj_t common_hal_vectorio_vector_shape_get_pixel_shader(vectorio_vector_shape_t *self) {
     VECTORIO_SHAPE_DEBUG("%p get_pixel_shader\n", self);
     return self->pixel_shader;
@@ -191,7 +199,7 @@ bool vectorio_vector_shape_fill_area(vectorio_vector_shape_t *self, const _displ
             // Get the target pixel based on the shape's coordinate space
             int16_t pixel_to_get_x;
             int16_t pixel_to_get_y;
-            if (self->transpose_xy) {
+            if (self->absolute_transform->transpose_xy) {
                 pixel_to_get_x = input_pixel.y - self->x;
                 pixel_to_get_y = input_pixel.x - self->y;
             } else {
@@ -280,3 +288,9 @@ displayio_area_t* vectorio_vector_shape_get_refresh_areas(vectorio_vector_shape_
     return tail;
 }
 
+void vectorio_vector_shape_update_transform(vectorio_vector_shape_t *self, displayio_buffer_transform_t *group_transform) {
+    self->absolute_transform = group_transform;
+    common_hal_vectorio_vector_shape_set_dirty(self);
+}
+
+
diff --git a/shared-module/vectorio/VectorShape.h b/shared-module/vectorio/VectorShape.h
index ac60e5b98..8fc698dbc 100644
--- a/shared-module/vectorio/VectorShape.h
+++ b/shared-module/vectorio/VectorShape.h
@@ -30,7 +30,7 @@ typedef struct {
     mp_obj_t pixel_shader;
     int16_t x;
     int16_t y;
-    bool transpose_xy;
+    displayio_buffer_transform_t *absolute_transform;
     bool dirty;  // True if we need to draw
     // Tracks current shape footprint and expands outward as the shape dirties and changes.
     // This is suboptimal if you move your shape far.  Could add more state to only redraw
-- 
cgit v1.2.3


From 6660311a96f063e935e85a228f8b12e3a07ca95c Mon Sep 17 00:00:00 2001
From: warriorofwire <3454741+WarriorOfWire@users.noreply.github.com>
Date: Sun, 10 May 2020 14:17:57 -0700
Subject: vectorio: respect display transpose and mirror.

VectorShape now just uses the Group's and Display's absolute transforms.
---
 shared-module/displayio/Group.c      |  7 ++++
 shared-module/vectorio/Circle.c      |  4 +--
 shared-module/vectorio/VectorShape.c | 69 +++++++++++++++++++-----------------
 3 files changed, 45 insertions(+), 35 deletions(-)

(limited to 'shared-module/displayio')

diff --git a/shared-module/displayio/Group.c b/shared-module/displayio/Group.c
index 0c31de532..d6df01f3d 100644
--- a/shared-module/displayio/Group.c
+++ b/shared-module/displayio/Group.c
@@ -215,6 +215,7 @@ static mp_obj_t _add_layer(displayio_group_t* self, mp_obj_t layer) {
 #if CIRCUITPY_VECTORIO
     native_layer = mp_instance_cast_to_native_base(layer, &vectorio_vector_shape_type);
     if (native_layer != MP_OBJ_NULL) {
+        vectorio_vector_shape_update_transform(native_layer, &self->absolute_transform);
         return native_layer;
     }
 #endif
@@ -247,6 +248,12 @@ static void _remove_layer(displayio_group_t* self, size_t index) {
     mp_obj_t layer = self->children[index].native;
     displayio_area_t layer_area;
     bool rendered_last_frame = false;
+#if CIRCUITPY_VECTORIO
+    if (MP_OBJ_IS_TYPE(layer, &vectorio_vector_shape_type)) {
+        vectorio_vector_shape_update_transform(layer, NULL);
+    }
+    else
+#endif
     if (MP_OBJ_IS_TYPE(layer, &displayio_tilegrid_type)) {
         displayio_tilegrid_t* tilegrid = layer;
         rendered_last_frame = displayio_tilegrid_get_previous_area(tilegrid, &layer_area);
diff --git a/shared-module/vectorio/Circle.c b/shared-module/vectorio/Circle.c
index 6bcd6318f..e6e3268e7 100644
--- a/shared-module/vectorio/Circle.c
+++ b/shared-module/vectorio/Circle.c
@@ -34,8 +34,8 @@ uint32_t common_hal_vectorio_circle_get_pixel(void *obj, int16_t x, int16_t y) {
 
 void common_hal_vectorio_circle_get_area(void *circle, displayio_area_t *out_area) {
     vectorio_circle_t *self = circle;
-    out_area->x1 = -1 * self->radius;
-    out_area->y1 = -1 * self->radius;
+    out_area->x1 = -1 * self->radius - 1;
+    out_area->y1 = -1 * self->radius - 1;
     out_area->x2 = self->radius + 1;
     out_area->y2 = self->radius + 1;
 }
diff --git a/shared-module/vectorio/VectorShape.c b/shared-module/vectorio/VectorShape.c
index 6030c1e3d..b23baa4cf 100644
--- a/shared-module/vectorio/VectorShape.c
+++ b/shared-module/vectorio/VectorShape.c
@@ -28,34 +28,39 @@ static int32_t max(int32_t a, int32_t b) {
 }
 
 
-inline __attribute__((always_inline))
-static void _transpose_area(displayio_area_t *out_area) {
-    int16_t swap = out_area->x1;
-    out_area->x1 = out_area->y1;
-    out_area->y1 = swap;
-    swap = out_area->x2;
-    out_area->x2 = out_area->y2;
-    out_area->y2 = swap;
-}
-
-
-inline __attribute__((always_inline))
-static void _get_shape_area(vectorio_vector_shape_t *self, displayio_area_t *out_area) {
-    VECTORIO_SHAPE_DEBUG("%p get_area\n", self);
-    self->ishape.get_area(self->ishape.shape, out_area);
-}
-
-
 inline __attribute__((always_inline))
 static void _get_screen_area(vectorio_vector_shape_t *self, displayio_area_t *out_area) {
-    VECTORIO_SHAPE_DEBUG("%p get_screen_area\n", self);
+    VECTORIO_SHAPE_DEBUG("%p get_screen_area tform:{x:%d y:%d dx:%d dy:%d scl:%d w:%d h:%d mx:%d my:%d tr:%d}", self,
+        self->absolute_transform->x, self->absolute_transform->y, self->absolute_transform->dx, self->absolute_transform->dy, self->absolute_transform->scale,
+        self->absolute_transform->width, self->absolute_transform->height, self->absolute_transform->mirror_x, self->absolute_transform->mirror_y, self->absolute_transform->transpose_xy
+    );
     self->ishape.get_area(self->ishape.shape, out_area);
+    VECTORIO_SHAPE_DEBUG(" in:{(%5d,%5d), (%5d,%5d)}", out_area->x1, out_area->y1, out_area->x2, out_area->y2);
     if (self->absolute_transform->transpose_xy) {
-        _transpose_area(out_area);
-        displayio_area_shift(out_area, self->y, self->x);
+        int16_t swap = out_area->x1;
+        out_area->x1 = (out_area->y1 + self->y) * self->absolute_transform->dx + self->absolute_transform->x;
+        out_area->y1 = (swap         + self->x) * self->absolute_transform->dy + self->absolute_transform->y;
+        swap = out_area->x2;
+        out_area->x2 = (out_area->y2 + self->y) * self->absolute_transform->dx + self->absolute_transform->x;
+        out_area->y2 = (swap +         self->x) * self->absolute_transform->dy + self->absolute_transform->y;
     } else {
-        displayio_area_shift(out_area, self->x, self->y);
+        out_area->x1 = (out_area->x1 + self->x) * self->absolute_transform->dx + self->absolute_transform->x;
+        out_area->y1 = (out_area->y1 + self->y) * self->absolute_transform->dy + self->absolute_transform->y;
+        out_area->x2 = (out_area->x2 + self->x) * self->absolute_transform->dx + self->absolute_transform->x;
+        out_area->y2 = (out_area->y2 + self->y) * self->absolute_transform->dy + self->absolute_transform->y;
+    }
+    // We might have mirrored due to dx
+    if (out_area->x2 < out_area->x1) {
+        int16_t swap = out_area->x1;
+        out_area->x1 = out_area->x2;
+        out_area->x2 = swap;
+    }
+    if (out_area->y2 < out_area->y1) {
+        int16_t swap = out_area->y1;
+        out_area->y1 = out_area->y2;
+        out_area->y2 = swap;
     }
+    VECTORIO_SHAPE_DEBUG(" out:{(%5d,%5d), (%5d,%5d)}\n", out_area->x1, out_area->y1, out_area->x2, out_area->y2);
 }
 
 
@@ -79,8 +84,8 @@ void common_hal_vectorio_vector_shape_set_dirty(void *vector_shape) {
 static displayio_buffer_transform_t null_transform = {
     .x = 0,
     .y = 0,
-    .dx = 0,
-    .dy = 0,
+    .dx = 1,
+    .dy = 1,
     .scale = 1,
     .width = 0,
     .height = 0,
@@ -99,9 +104,9 @@ void common_hal_vectorio_vector_shape_construct(vectorio_vector_shape_t *self,
     self->pixel_shader = pixel_shader;
     self->ishape = ishape;
     self->dirty = true;
+    self->absolute_transform = &null_transform; // Critical to have a valid transform before getting screen area.
     _get_screen_area(self, &self->ephemeral_dirty_area);
     self->ephemeral_dirty_area.next = NULL;
-    self->absolute_transform = &null_transform;
 }
 
 
@@ -156,9 +161,7 @@ bool vectorio_vector_shape_fill_area(vectorio_vector_shape_t *self, const _displ
     // Pixels are drawn on the screen_area (shifted) coordinate space, while pixels are _determined_ from
     //   the shape_area (unshifted) space.
     displayio_area_t overlap;
-    displayio_area_t shape_area;
-    _get_shape_area(self, &shape_area);
-    VECTORIO_SHAPE_DEBUG("%p fill_area dirty:%d fill: {(%3d,%3d), (%3d,%3d)} dirty: {(%3d,%3d), (%3d,%3d)}",
+    VECTORIO_SHAPE_DEBUG("%p fill_area dirty:%d fill: {(%5d,%5d), (%5d,%5d)} dirty: {(%5d,%5d), (%5d,%5d)}",
         self, self->dirty,
         area->x1, area->y1, area->x2, area->y2,
         self->ephemeral_dirty_area.x1, self->ephemeral_dirty_area.y1, self->ephemeral_dirty_area.x2, self->ephemeral_dirty_area.y2
@@ -200,11 +203,11 @@ bool vectorio_vector_shape_fill_area(vectorio_vector_shape_t *self, const _displ
             int16_t pixel_to_get_x;
             int16_t pixel_to_get_y;
             if (self->absolute_transform->transpose_xy) {
-                pixel_to_get_x = input_pixel.y - self->x;
-                pixel_to_get_y = input_pixel.x - self->y;
+                pixel_to_get_x = (input_pixel.y - self->absolute_transform->dy * self->x - self->absolute_transform->y) / self->absolute_transform->dy;
+                pixel_to_get_y = (input_pixel.x - self->absolute_transform->dx * self->y - self->absolute_transform->x) / self->absolute_transform->dx;
             } else {
-                pixel_to_get_x = input_pixel.x - self->x;
-                pixel_to_get_y = input_pixel.y - self->y;
+                pixel_to_get_x = (input_pixel.x - self->absolute_transform->dx * self->x) / self->absolute_transform->dx;
+                pixel_to_get_y = (input_pixel.y - self->absolute_transform->dy * self->y) / self->absolute_transform->dy;
             }
             VECTORIO_SHAPE_PIXEL_DEBUG(" get_pixel %p (%3d, %3d) -> ( %3d, %3d )", self->ishape.shape, input_pixel.x, input_pixel.y, pixel_to_get_x, pixel_to_get_y);
             input_pixel.pixel = self->ishape.get_pixel(self->ishape.shape, pixel_to_get_x, pixel_to_get_y);
@@ -289,7 +292,7 @@ displayio_area_t* vectorio_vector_shape_get_refresh_areas(vectorio_vector_shape_
 }
 
 void vectorio_vector_shape_update_transform(vectorio_vector_shape_t *self, displayio_buffer_transform_t *group_transform) {
-    self->absolute_transform = group_transform;
+    self->absolute_transform = group_transform == NULL ? &null_transform : group_transform;
     common_hal_vectorio_vector_shape_set_dirty(self);
 }
 
-- 
cgit v1.2.3


From 58c8e00745064bd290fc9ec18a838960b27c1eea Mon Sep 17 00:00:00 2001
From: warriorofwire <3454741+WarriorOfWire@users.noreply.github.com>
Date: Sun, 10 May 2020 15:36:23 -0700
Subject: vectorio: clean up after group removal

VectorShape tells the Group to redraw whatever it left behind when it is removed now.
---
 shared-module/displayio/Group.c      | 2 ++
 shared-module/vectorio/VectorShape.c | 7 +++++++
 shared-module/vectorio/VectorShape.h | 4 +++-
 3 files changed, 12 insertions(+), 1 deletion(-)

(limited to 'shared-module/displayio')

diff --git a/shared-module/displayio/Group.c b/shared-module/displayio/Group.c
index d6df01f3d..15cf5b8e4 100644
--- a/shared-module/displayio/Group.c
+++ b/shared-module/displayio/Group.c
@@ -250,6 +250,8 @@ static void _remove_layer(displayio_group_t* self, size_t index) {
     bool rendered_last_frame = false;
 #if CIRCUITPY_VECTORIO
     if (MP_OBJ_IS_TYPE(layer, &vectorio_vector_shape_type)) {
+        bool has_dirty_area = vectorio_vector_shape_get_dirty_area(layer, &layer_area);
+        rendered_last_frame = has_dirty_area;
         vectorio_vector_shape_update_transform(layer, NULL);
     }
     else
diff --git a/shared-module/vectorio/VectorShape.c b/shared-module/vectorio/VectorShape.c
index b23baa4cf..f57739047 100644
--- a/shared-module/vectorio/VectorShape.c
+++ b/shared-module/vectorio/VectorShape.c
@@ -64,6 +64,13 @@ static void _get_screen_area(vectorio_vector_shape_t *self, displayio_area_t *ou
 }
 
 
+// For use by Group to know where it needs to redraw on layer removal.
+bool vectorio_vector_shape_get_dirty_area(vectorio_vector_shape_t *self, displayio_area_t *out_area) {
+    displayio_area_copy(&self->ephemeral_dirty_area, out_area);
+    return true; // For now just always redraw.
+}
+
+
 // This must be invoked each time a shape changes its position or its shape in any way.
 void common_hal_vectorio_vector_shape_set_dirty(void *vector_shape) {
     vectorio_vector_shape_t *self = vector_shape;
diff --git a/shared-module/vectorio/VectorShape.h b/shared-module/vectorio/VectorShape.h
index 8fc698dbc..56eb3d8a5 100644
--- a/shared-module/vectorio/VectorShape.h
+++ b/shared-module/vectorio/VectorShape.h
@@ -38,7 +38,9 @@ typedef struct {
     displayio_area_t ephemeral_dirty_area;
 } vectorio_vector_shape_t;
 
-displayio_area_t* vectorio_vector_shape_get_refresh_areas(vectorio_vector_shape_t *self, displayio_area_t* tail);
+displayio_area_t* vectorio_vector_shape_get_refresh_areas(vectorio_vector_shape_t *self, displayio_area_t *tail);
+
+bool vectorio_vector_shape_get_dirty_area(vectorio_vector_shape_t *self, displayio_area_t *current_dirty_area);
 
 // Area is always in absolute screen coordinates.
 bool vectorio_vector_shape_fill_area(vectorio_vector_shape_t *self, const _displayio_colorspace_t *colorspace, const displayio_area_t *area, uint32_t *mask, uint32_t *buffer);
-- 
cgit v1.2.3