add circuitpython code

10 files changed, 905 insertions, 0 deletions

diff --git a/circuitpython/shared-bindings/vectorio/Circle.c b/circuitpython/shared-bindings/vectorio/Circle.c
new file mode 100644
index 0000000..ded1861
--- /dev/null
+++ b/circuitpython/shared-bindings/vectorio/Circle.c
@@ -0,0 +1,141 @@
+#include "shared-bindings/vectorio/__init__.h"
+#include "shared-bindings/vectorio/Circle.h"
+#include "shared-bindings/vectorio/VectorShape.h"
+
+
+#include <stdint.h>
+
+#include "py/objproperty.h"
+#include "py/objtype.h"
+#include "py/runtime.h"
+#include "supervisor/shared/translate.h"
+
+//| class Circle:
+//|
+//|     def __init__(self, pixel_shader: Union[displayio.ColorConverter, displayio.Palette], radius: int, x: int, y: int) -> None:
+//|         """Circle is positioned on screen by its center point.
+//|
+//|            :param Union[~displayio.ColorConverter,~displayio.Palette] pixel_shader: The pixel shader that produces colors from values
+//|            :param int radius: The radius of the circle in pixels
+//|            :param int x: Initial x position of the axis.
+//|            :param int y: Initial y position of the axis.
+//|            :param int color_index: Initial color_index to use when selecting color from the palette."""
+//|
+static mp_obj_t vectorio_circle_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
+    enum { ARG_pixel_shader, ARG_radius, ARG_x, ARG_y, ARG_color_index };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_pixel_shader, MP_ARG_OBJ | MP_ARG_KW_ONLY | MP_ARG_REQUIRED },
+        { MP_QSTR_radius, MP_ARG_REQUIRED | MP_ARG_INT },
+        { 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_color_index, MP_ARG_INT | MP_ARG_KW_ONLY, {.u_int = 0} },
+    };
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    mp_int_t radius = args[ARG_radius].u_int;
+    if (radius < 1) {
+        mp_raise_ValueError_varg(translate("%q must be >= 1"), MP_QSTR_radius);
+    }
+
+    vectorio_circle_t *self = m_new_obj(vectorio_circle_t);
+    self->base.type = &vectorio_circle_type;
+    uint16_t color_index = args[ARG_color_index].u_int;
+    common_hal_vectorio_circle_construct(self, radius, color_index);
+
+    // VectorShape parts
+    mp_obj_t pixel_shader = args[ARG_pixel_shader].u_obj;
+    int32_t x = args[ARG_x].u_int;
+    int32_t y = args[ARG_y].u_int;
+    mp_obj_t vector_shape = vectorio_vector_shape_make_new(self, pixel_shader, x, y);
+    self->draw_protocol_instance = vector_shape;
+
+    return MP_OBJ_FROM_PTR(self);
+}
+
+STATIC const vectorio_draw_protocol_t circle_draw_protocol = {
+    MP_PROTO_IMPLEMENT(MP_QSTR_protocol_draw)
+    .draw_get_protocol_self = (draw_get_protocol_self_fun)common_hal_vectorio_circle_get_draw_protocol,
+    .draw_protocol_impl = &vectorio_vector_shape_draw_protocol_impl
+};
+
+
+//|     radius : int
+//|     """The radius of the circle in pixels."""
+//|
+STATIC mp_obj_t vectorio_circle_obj_get_radius(mp_obj_t self_in) {
+    vectorio_circle_t *self = MP_OBJ_TO_PTR(self_in);
+    return mp_obj_new_int(common_hal_vectorio_circle_get_radius(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(vectorio_circle_get_radius_obj, vectorio_circle_obj_get_radius);
+
+STATIC mp_obj_t vectorio_circle_obj_set_radius(mp_obj_t self_in, mp_obj_t radius) {
+    vectorio_circle_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_vectorio_circle_set_radius(self, mp_obj_get_int(radius));
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(vectorio_circle_set_radius_obj, vectorio_circle_obj_set_radius);
+
+MP_PROPERTY_GETSET(vectorio_circle_radius_obj,
+    (mp_obj_t)&vectorio_circle_get_radius_obj,
+    (mp_obj_t)&vectorio_circle_set_radius_obj);
+
+//|     color_index : int
+//|     """The color_index of the circle as 0 based index of the palette."""
+//|
+STATIC mp_obj_t vectorio_circle_obj_get_color_index(mp_obj_t self_in) {
+    vectorio_circle_t *self = MP_OBJ_TO_PTR(self_in);
+    return mp_obj_new_int(common_hal_vectorio_circle_get_color_index(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(vectorio_circle_get_color_index_obj, vectorio_circle_obj_get_color_index);
+
+STATIC mp_obj_t vectorio_circle_obj_set_color_index(mp_obj_t self_in, mp_obj_t color_index) {
+    vectorio_circle_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_vectorio_circle_set_color_index(self, mp_obj_get_int(color_index));
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(vectorio_circle_set_color_index_obj, vectorio_circle_obj_set_color_index);
+
+MP_PROPERTY_GETSET(vectorio_circle_color_index_obj,
+    (mp_obj_t)&vectorio_circle_get_color_index_obj,
+    (mp_obj_t)&vectorio_circle_set_color_index_obj);
+
+
+// Documentation for properties inherited from VectorShape.
+
+//|     x : int
+//|     """X position of the center point of the circle in the parent."""
+//|
+//|     y : int
+//|     """Y position of the center point of the circle in the parent."""
+//|
+//|     location : Tuple[int,int]
+//|     """(X,Y) position of the center point of the circle in the parent."""
+//|
+//|     pixel_shader : Union[displayio.ColorConverter,displayio.Palette]
+//|     """The pixel shader of the circle."""
+//|
+
+STATIC const mp_rom_map_elem_t vectorio_circle_locals_dict_table[] = {
+    // Functions
+    { MP_ROM_QSTR(MP_QSTR_contains), MP_ROM_PTR(&vectorio_vector_shape_contains_obj) },
+    // Properties
+    { MP_ROM_QSTR(MP_QSTR_radius), MP_ROM_PTR(&vectorio_circle_radius_obj) },
+    { MP_ROM_QSTR(MP_QSTR_x), MP_ROM_PTR(&vectorio_vector_shape_x_obj) },
+    { MP_ROM_QSTR(MP_QSTR_y), MP_ROM_PTR(&vectorio_vector_shape_y_obj) },
+    { MP_ROM_QSTR(MP_QSTR_color_index), MP_ROM_PTR(&vectorio_circle_color_index_obj) },
+    { MP_ROM_QSTR(MP_QSTR_location), MP_ROM_PTR(&vectorio_vector_shape_location_obj) },
+    { MP_ROM_QSTR(MP_QSTR_pixel_shader), MP_ROM_PTR(&vectorio_vector_shape_pixel_shader_obj) },
+};
+STATIC MP_DEFINE_CONST_DICT(vectorio_circle_locals_dict, vectorio_circle_locals_dict_table);
+
+const mp_obj_type_t vectorio_circle_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_Circle,
+    .flags = MP_TYPE_FLAG_EXTENDED,
+    .make_new = vectorio_circle_make_new,
+    .locals_dict = (mp_obj_dict_t *)&vectorio_circle_locals_dict,
+    MP_TYPE_EXTENDED_FIELDS(
+        .protocol = &circle_draw_protocol,
+        ),
+};
diff --git a/circuitpython/shared-bindings/vectorio/Circle.h b/circuitpython/shared-bindings/vectorio/Circle.h
new file mode 100644
index 0000000..8f16979
--- /dev/null
+++ b/circuitpython/shared-bindings/vectorio/Circle.h
@@ -0,0 +1,27 @@
+#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_VECTORIO_CIRCLE_H
+#define MICROPY_INCLUDED_SHARED_BINDINGS_VECTORIO_CIRCLE_H
+
+#include "shared-module/vectorio/__init__.h"
+#include "shared-module/vectorio/Circle.h"
+#include "shared-module/displayio/area.h"
+
+extern const mp_obj_type_t vectorio_circle_type;
+
+void common_hal_vectorio_circle_construct(vectorio_circle_t *self, uint16_t radius, uint16_t color_index);
+
+void common_hal_vectorio_circle_set_on_dirty(vectorio_circle_t *self, vectorio_event_t notification);
+
+uint32_t common_hal_vectorio_circle_get_pixel(void *circle, int16_t x, int16_t y);
+
+void common_hal_vectorio_circle_get_area(void *circle, displayio_area_t *out_area);
+
+
+int16_t common_hal_vectorio_circle_get_radius(void *circle);
+void common_hal_vectorio_circle_set_radius(void *circle, int16_t radius);
+
+uint16_t common_hal_vectorio_circle_get_color_index(void *obj);
+void common_hal_vectorio_circle_set_color_index(void *obj, uint16_t color_index);
+
+mp_obj_t common_hal_vectorio_circle_get_draw_protocol(void *circle);
+
+#endif // MICROPY_INCLUDED_SHARED_BINDINGS_VECTORIO_CIRCLE_H
diff --git a/circuitpython/shared-bindings/vectorio/Polygon.c b/circuitpython/shared-bindings/vectorio/Polygon.c
new file mode 100644
index 0000000..ae9d7a0
--- /dev/null
+++ b/circuitpython/shared-bindings/vectorio/Polygon.c
@@ -0,0 +1,147 @@
+#include "shared-bindings/vectorio/__init__.h"
+#include "shared-module/vectorio/__init__.h"
+#include "shared-bindings/vectorio/Polygon.h"
+#include "shared-bindings/vectorio/VectorShape.h"
+
+#include <stdint.h>
+
+#include "py/obj.h"
+#include "py/objproperty.h"
+#include "py/objtype.h"
+#include "py/runtime.h"
+#include "supervisor/shared/translate.h"
+
+
+#define VECTORIO_POLYGON_DEBUG(...) (void)0
+// #define VECTORIO_POLYGON_DEBUG(...) mp_printf(&mp_plat_print __VA_OPT__(,) __VA_ARGS__)
+
+
+//| class Polygon:
+//|     def __init__(self, pixel_shader: Union[displayio.ColorConverter, displayio.Palette], points: List[Tuple[int, int]], x: int, y: int) -> None:
+//|         """Represents a closed shape by ordered vertices. The path will be treated as
+//|         'closed', the last point will connect to the first point.
+//|
+//|         :param Union[~displayio.ColorConverter,~displayio.Palette] pixel_shader: The pixel
+//|             shader that produces colors from values
+//|         :param List[Tuple[int,int]] points: Vertices for the polygon
+//|         :param int x: Initial screen x position of the 0,0 origin in the points list.
+//|         :param int y: Initial screen y position of the 0,0 origin in the points list.
+//|         :param int color_index: Initial color_index to use when selecting color from the palette."""
+//|
+static mp_obj_t vectorio_polygon_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
+    enum { ARG_pixel_shader, ARG_points_list, ARG_x, ARG_y, ARG_color_index };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_pixel_shader, MP_ARG_OBJ | MP_ARG_KW_ONLY | MP_ARG_REQUIRED },
+        { MP_QSTR_points, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+        { 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_color_index, MP_ARG_INT | MP_ARG_KW_ONLY, {.u_int = 0} },
+    };
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    mp_obj_t points_list = mp_arg_validate_type(args[ARG_points_list].u_obj, &mp_type_list, MP_QSTR_points);
+
+    vectorio_polygon_t *self = m_new_obj(vectorio_polygon_t);
+    self->base.type = &vectorio_polygon_type;
+
+    uint16_t color_index = args[ARG_color_index].u_int;
+    common_hal_vectorio_polygon_construct(self, points_list, color_index);
+
+    // VectorShape parts
+    mp_obj_t pixel_shader = args[ARG_pixel_shader].u_obj;
+    int32_t x = args[ARG_x].u_int;
+    int32_t y = args[ARG_y].u_int;
+    mp_obj_t vector_shape = vectorio_vector_shape_make_new(self, pixel_shader, x, y);
+    self->draw_protocol_instance = vector_shape;
+
+    return MP_OBJ_FROM_PTR(self);
+}
+
+STATIC const vectorio_draw_protocol_t polygon_draw_protocol = {
+    MP_PROTO_IMPLEMENT(MP_QSTR_protocol_draw)
+    .draw_get_protocol_self = (draw_get_protocol_self_fun)common_hal_vectorio_polygon_get_draw_protocol,
+    .draw_protocol_impl = &vectorio_vector_shape_draw_protocol_impl
+};
+
+
+//|     points: List[Tuple[int, int]]
+//|     """Vertices for the polygon."""
+//|
+STATIC mp_obj_t vectorio_polygon_obj_get_points(mp_obj_t self_in) {
+    vectorio_polygon_t *self = MP_OBJ_TO_PTR(self_in);
+    return common_hal_vectorio_polygon_get_points(self);
+}
+MP_DEFINE_CONST_FUN_OBJ_1(vectorio_polygon_get_points_obj, vectorio_polygon_obj_get_points);
+
+STATIC mp_obj_t vectorio_polygon_obj_set_points(mp_obj_t self_in, mp_obj_t points) {
+    vectorio_polygon_t *self = MP_OBJ_TO_PTR(self_in);
+
+    common_hal_vectorio_polygon_set_points(self, points);
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(vectorio_polygon_set_points_obj, vectorio_polygon_obj_set_points);
+
+MP_PROPERTY_GETSET(vectorio_polygon_points_obj,
+    (mp_obj_t)&vectorio_polygon_get_points_obj,
+    (mp_obj_t)&vectorio_polygon_set_points_obj);
+
+//|     color_index : int
+//|     """The color_index of the polygon as 0 based index of the palette."""
+//|
+STATIC mp_obj_t vectorio_polygon_obj_get_color_index(mp_obj_t self_in) {
+    vectorio_polygon_t *self = MP_OBJ_TO_PTR(self_in);
+    return mp_obj_new_int(common_hal_vectorio_polygon_get_color_index(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(vectorio_polygon_get_color_index_obj, vectorio_polygon_obj_get_color_index);
+
+STATIC mp_obj_t vectorio_polygon_obj_set_color_index(mp_obj_t self_in, mp_obj_t color_index) {
+    vectorio_polygon_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_vectorio_polygon_set_color_index(self, mp_obj_get_int(color_index));
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(vectorio_polygon_set_color_index_obj, vectorio_polygon_obj_set_color_index);
+
+MP_PROPERTY_GETSET(vectorio_polygon_color_index_obj,
+    (mp_obj_t)&vectorio_polygon_get_color_index_obj,
+    (mp_obj_t)&vectorio_polygon_set_color_index_obj);
+
+
+// Documentation for properties inherited from VectorShape.
+
+//|     x : int
+//|     """X position of the 0,0 origin in the points list."""
+//|
+//|     y : int
+//|     """Y position of the 0,0 origin in the points list."""
+//|
+//|     location : Tuple[int,int]
+//|     """(X,Y) position of the 0,0 origin in the points list."""
+//|
+//|     pixel_shader : Union[displayio.ColorConverter,displayio.Palette]
+//|     """The pixel shader of the polygon."""
+//|
+
+STATIC const mp_rom_map_elem_t vectorio_polygon_locals_dict_table[] = {
+    // Functions
+    { MP_ROM_QSTR(MP_QSTR_contains), MP_ROM_PTR(&vectorio_vector_shape_contains_obj) },
+    // Properties
+    { MP_ROM_QSTR(MP_QSTR_points), MP_ROM_PTR(&vectorio_polygon_points_obj) },
+    { MP_ROM_QSTR(MP_QSTR_x), MP_ROM_PTR(&vectorio_vector_shape_x_obj) },
+    { MP_ROM_QSTR(MP_QSTR_y), MP_ROM_PTR(&vectorio_vector_shape_y_obj) },
+    { MP_ROM_QSTR(MP_QSTR_color_index), MP_ROM_PTR(&vectorio_polygon_color_index_obj) },
+    { MP_ROM_QSTR(MP_QSTR_location), MP_ROM_PTR(&vectorio_vector_shape_location_obj) },
+    { MP_ROM_QSTR(MP_QSTR_pixel_shader), MP_ROM_PTR(&vectorio_vector_shape_pixel_shader_obj) },
+};
+STATIC MP_DEFINE_CONST_DICT(vectorio_polygon_locals_dict, vectorio_polygon_locals_dict_table);
+
+const mp_obj_type_t vectorio_polygon_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_Polygon,
+    .flags = MP_TYPE_FLAG_EXTENDED,
+    .make_new = vectorio_polygon_make_new,
+    .locals_dict = (mp_obj_dict_t *)&vectorio_polygon_locals_dict,
+    MP_TYPE_EXTENDED_FIELDS(
+        .protocol = &polygon_draw_protocol,
+        ),
+};
diff --git a/circuitpython/shared-bindings/vectorio/Polygon.h b/circuitpython/shared-bindings/vectorio/Polygon.h
new file mode 100644
index 0000000..9d3ce2d
--- /dev/null
+++ b/circuitpython/shared-bindings/vectorio/Polygon.h
@@ -0,0 +1,29 @@
+#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_VECTORIO_POLYGON_H
+#define MICROPY_INCLUDED_SHARED_BINDINGS_VECTORIO_POLYGON_H
+
+#include "shared-module/vectorio/Polygon.h"
+#include "shared-module/displayio/area.h"
+#include "shared-module/vectorio/__init__.h"
+
+extern const mp_obj_type_t vectorio_polygon_type;
+
+void common_hal_vectorio_polygon_construct(vectorio_polygon_t *self, mp_obj_t points_list, uint16_t color_index);
+void common_hal_vectorio_polygon_set_on_dirty(vectorio_polygon_t *self, vectorio_event_t notification);
+
+
+uint32_t common_hal_vectorio_polygon_get_pixel(void *polygon, int16_t x, int16_t y);
+
+void common_hal_vectorio_polygon_get_area(void *polygon, displayio_area_t *out_area);
+
+
+
+mp_obj_t common_hal_vectorio_polygon_get_points(vectorio_polygon_t *self);
+void common_hal_vectorio_polygon_set_points(vectorio_polygon_t *self, mp_obj_t points_list);
+
+uint16_t common_hal_vectorio_polygon_get_color_index(void *obj);
+void common_hal_vectorio_polygon_set_color_index(void *obj, uint16_t color_index);
+
+mp_obj_t common_hal_vectorio_polygon_get_draw_protocol(void *polygon);
+
+
+#endif // MICROPY_INCLUDED_SHARED_BINDINGS_VECTORIO_POLYGON_H
diff --git a/circuitpython/shared-bindings/vectorio/Rectangle.c b/circuitpython/shared-bindings/vectorio/Rectangle.c
new file mode 100644
index 0000000..739a1ba
--- /dev/null
+++ b/circuitpython/shared-bindings/vectorio/Rectangle.c
@@ -0,0 +1,173 @@
+#include "shared-bindings/vectorio/__init__.h"
+#include "shared-bindings/vectorio/Rectangle.h"
+#include "shared-module/vectorio/VectorShape.h"
+#include "shared-bindings/vectorio/VectorShape.h"
+
+#include <stdint.h>
+
+#include "py/objtype.h"
+#include "py/runtime.h"
+#include "supervisor/shared/translate.h"
+
+//| class Rectangle:
+//|     def __init__(self, pixel_shader: Union[displayio.ColorConverter, displayio.Palette], width: int, height: int, x: int, y: int) -> None:
+//|         """Represents a rectangle by defining its bounds
+//|
+//|            :param Union[~displayio.ColorConverter,~displayio.Palette] pixel_shader: The pixel shader that produces colors from values
+//|            :param int width: The number of pixels wide
+//|            :param int height: The number of pixels high
+//|            :param int x: Initial x position of the top left corner.
+//|            :param int y: Initial y position of the top left corner.
+//|            :param int color_index: Initial color_index to use when selecting color from the palette."""
+//|
+static mp_obj_t vectorio_rectangle_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
+    enum { ARG_pixel_shader, ARG_width, ARG_height, ARG_x, ARG_y, ARG_color_index };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_pixel_shader, MP_ARG_OBJ | MP_ARG_KW_ONLY | MP_ARG_REQUIRED },
+        { MP_QSTR_width, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_height, MP_ARG_REQUIRED | MP_ARG_INT },
+        { 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_color_index, MP_ARG_INT | MP_ARG_KW_ONLY, {.u_int = 0} },
+    };
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    mp_int_t width = args[ARG_width].u_int;
+    if (width < 1) {
+        mp_raise_ValueError_varg(translate("%q must be >= 1"), MP_QSTR_width);
+    }
+    mp_int_t height = args[ARG_height].u_int;
+    if (height < 1) {
+        mp_raise_ValueError_varg(translate("%q must be >= 1"), MP_QSTR_height);
+    }
+
+    vectorio_rectangle_t *self = m_new_obj(vectorio_rectangle_t);
+    self->base.type = &vectorio_rectangle_type;
+    uint16_t color_index = args[ARG_color_index].u_int;
+    common_hal_vectorio_rectangle_construct(self, width, height, color_index);
+
+    // VectorShape parts
+    mp_obj_t pixel_shader = args[ARG_pixel_shader].u_obj;
+    int32_t x = args[ARG_x].u_int;
+    int32_t y = args[ARG_y].u_int;
+    mp_obj_t vector_shape = vectorio_vector_shape_make_new(self, pixel_shader, x, y);
+    self->draw_protocol_instance = vector_shape;
+
+    return MP_OBJ_FROM_PTR(self);
+}
+
+STATIC const vectorio_draw_protocol_t rectangle_draw_protocol = {
+    MP_PROTO_IMPLEMENT(MP_QSTR_protocol_draw)
+    .draw_get_protocol_self = (draw_get_protocol_self_fun)common_hal_vectorio_rectangle_get_draw_protocol,
+    .draw_protocol_impl = &vectorio_vector_shape_draw_protocol_impl
+};
+
+//|     width : int
+//|     """The width of the rectangle in pixels."""
+//|
+STATIC mp_obj_t vectorio_rectangle_obj_get_width(mp_obj_t self_in) {
+    vectorio_rectangle_t *self = MP_OBJ_TO_PTR(self_in);
+    return mp_obj_new_int(common_hal_vectorio_rectangle_get_width(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(vectorio_rectangle_get_width_obj, vectorio_rectangle_obj_get_width);
+
+STATIC mp_obj_t vectorio_rectangle_obj_set_width(mp_obj_t self_in, mp_obj_t width) {
+    vectorio_rectangle_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_vectorio_rectangle_set_width(self, mp_obj_get_int(width));
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(vectorio_rectangle_set_width_obj, vectorio_rectangle_obj_set_width);
+
+const mp_obj_property_t vectorio_rectangle_width_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {(mp_obj_t)&vectorio_rectangle_get_width_obj,
+              (mp_obj_t)&vectorio_rectangle_set_width_obj,
+              MP_ROM_NONE},
+};
+
+//|     height : int
+//|     """The height of the rectangle in pixels."""
+//|
+STATIC mp_obj_t vectorio_rectangle_obj_get_height(mp_obj_t self_in) {
+    vectorio_rectangle_t *self = MP_OBJ_TO_PTR(self_in);
+    return mp_obj_new_int(common_hal_vectorio_rectangle_get_height(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(vectorio_rectangle_get_height_obj, vectorio_rectangle_obj_get_height);
+
+STATIC mp_obj_t vectorio_rectangle_obj_set_height(mp_obj_t self_in, mp_obj_t height) {
+    vectorio_rectangle_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_vectorio_rectangle_set_height(self, mp_obj_get_int(height));
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(vectorio_rectangle_set_height_obj, vectorio_rectangle_obj_set_height);
+
+const mp_obj_property_t vectorio_rectangle_height_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {(mp_obj_t)&vectorio_rectangle_get_height_obj,
+              (mp_obj_t)&vectorio_rectangle_set_height_obj,
+              MP_ROM_NONE},
+};
+
+//|     color_index : int
+//|     """The color_index of the rectangle in 1 based index of the palette."""
+//|
+STATIC mp_obj_t vectorio_rectangle_obj_get_color_index(mp_obj_t self_in) {
+    vectorio_rectangle_t *self = MP_OBJ_TO_PTR(self_in);
+    return mp_obj_new_int(common_hal_vectorio_rectangle_get_color_index(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(vectorio_rectangle_get_color_index_obj, vectorio_rectangle_obj_get_color_index);
+
+STATIC mp_obj_t vectorio_rectangle_obj_set_color_index(mp_obj_t self_in, mp_obj_t color_index) {
+    vectorio_rectangle_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_vectorio_rectangle_set_color_index(self, mp_obj_get_int(color_index));
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(vectorio_rectangle_set_color_index_obj, vectorio_rectangle_obj_set_color_index);
+
+const mp_obj_property_t vectorio_rectangle_color_index_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {(mp_obj_t)&vectorio_rectangle_get_color_index_obj,
+              (mp_obj_t)&vectorio_rectangle_set_color_index_obj,
+              MP_ROM_NONE},
+};
+
+// Documentation for properties inherited from VectorShape.
+
+//|     x : int
+//|     """X position of the top left corner of the rectangle in the parent."""
+//|
+//|     y : int
+//|     """Y position of the top left corner of the rectangle in the parent."""
+//|
+//|     location : Tuple[int,int]
+//|     """(X,Y) position of the top left corner of the rectangle in the parent."""
+//|
+//|     pixel_shader : Union[displayio.ColorConverter,displayio.Palette]
+//|     """The pixel shader of the rectangle."""
+//|
+
+STATIC const mp_rom_map_elem_t vectorio_rectangle_locals_dict_table[] = {
+    // Functions
+    { MP_ROM_QSTR(MP_QSTR_contains), MP_ROM_PTR(&vectorio_vector_shape_contains_obj) },
+    // Properties
+    { MP_ROM_QSTR(MP_QSTR_x), MP_ROM_PTR(&vectorio_vector_shape_x_obj) },
+    { MP_ROM_QSTR(MP_QSTR_y), MP_ROM_PTR(&vectorio_vector_shape_y_obj) },
+    { MP_ROM_QSTR(MP_QSTR_color_index), MP_ROM_PTR(&vectorio_rectangle_color_index_obj) },
+    { MP_ROM_QSTR(MP_QSTR_width), MP_ROM_PTR(&vectorio_rectangle_width_obj) },
+    { MP_ROM_QSTR(MP_QSTR_height), MP_ROM_PTR(&vectorio_rectangle_height_obj) },
+    { MP_ROM_QSTR(MP_QSTR_location), MP_ROM_PTR(&vectorio_vector_shape_location_obj) },
+    { MP_ROM_QSTR(MP_QSTR_pixel_shader), MP_ROM_PTR(&vectorio_vector_shape_pixel_shader_obj) },
+};
+STATIC MP_DEFINE_CONST_DICT(vectorio_rectangle_locals_dict, vectorio_rectangle_locals_dict_table);
+
+const mp_obj_type_t vectorio_rectangle_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_Rectangle,
+    .flags = MP_TYPE_FLAG_EXTENDED,
+    .make_new = vectorio_rectangle_make_new,
+    .locals_dict = (mp_obj_dict_t *)&vectorio_rectangle_locals_dict,
+    MP_TYPE_EXTENDED_FIELDS(
+        .protocol = &rectangle_draw_protocol,
+        ),
+};
diff --git a/circuitpython/shared-bindings/vectorio/Rectangle.h b/circuitpython/shared-bindings/vectorio/Rectangle.h
new file mode 100644
index 0000000..907ae68
--- /dev/null
+++ b/circuitpython/shared-bindings/vectorio/Rectangle.h
@@ -0,0 +1,28 @@
+#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_VECTORIO_RECTANGLE_H
+#define MICROPY_INCLUDED_SHARED_BINDINGS_VECTORIO_RECTANGLE_H
+
+#include "shared-module/vectorio/Rectangle.h"
+#include "shared-module/displayio/area.h"
+#include "shared-module/vectorio/__init__.h"
+
+extern const mp_obj_type_t vectorio_rectangle_type;
+
+void common_hal_vectorio_rectangle_construct(vectorio_rectangle_t *self, uint32_t width, uint32_t height, uint16_t color_index);
+void common_hal_vectorio_rectangle_set_on_dirty(vectorio_rectangle_t *self, vectorio_event_t on_dirty);
+
+uint32_t common_hal_vectorio_rectangle_get_pixel(void *rectangle, int16_t x, int16_t y);
+
+void common_hal_vectorio_rectangle_get_area(void *rectangle, displayio_area_t *out_area);
+
+mp_obj_t common_hal_vectorio_rectangle_get_draw_protocol(void *rectangle);
+
+int16_t common_hal_vectorio_rectangle_get_width(void *obj);
+void common_hal_vectorio_rectangle_set_width(void *obj, int16_t width);
+
+uint16_t common_hal_vectorio_rectangle_get_color_index(void *obj);
+void common_hal_vectorio_rectangle_set_color_index(void *obj, uint16_t color_index);
+
+int16_t common_hal_vectorio_rectangle_get_height(void *obj);
+void common_hal_vectorio_rectangle_set_height(void *obj, int16_t height);
+
+#endif // MICROPY_INCLUDED_SHARED_BINDINGS_VECTORIO_RECTANGLE_H
diff --git a/circuitpython/shared-bindings/vectorio/VectorShape.c b/circuitpython/shared-bindings/vectorio/VectorShape.c
new file mode 100644
index 0000000..fe6be55
--- /dev/null
+++ b/circuitpython/shared-bindings/vectorio/VectorShape.c
@@ -0,0 +1,223 @@
+
+#include "shared-module/vectorio/__init__.h"
+#include "shared-bindings/vectorio/VectorShape.h"
+#include "shared-bindings/vectorio/Circle.h"
+#include "shared-bindings/vectorio/Polygon.h"
+#include "shared-bindings/vectorio/Rectangle.h"
+
+#include "shared-bindings/displayio/ColorConverter.h"
+#include "shared-bindings/displayio/Palette.h"
+
+#include <stdint.h>
+
+#include "shared/runtime/context_manager_helpers.h"
+
+#include "py/binary.h"
+#include "py/objproperty.h"
+#include "py/objtype.h"
+#include "py/runtime.h"
+#include "supervisor/shared/translate.h"
+
+
+// shape: The shape implementation to draw.
+// pixel_shader: The pixel shader that produces colors from values. The shader can be a displayio.Palette(1); it will be asked to color pixel value 0.
+// x: Initial x position of the center axis of the shape within the parent.
+// y: Initial y position of the center axis of the shape within the parent."""
+mp_obj_t vectorio_vector_shape_make_new(const mp_obj_t shape, const mp_obj_t pixel_shader, int32_t x, int32_t y) {
+    if (!mp_obj_is_type(pixel_shader, &displayio_colorconverter_type) &&
+        !mp_obj_is_type(pixel_shader, &displayio_palette_type)) {
+        mp_raise_TypeError_varg(translate("unsupported %q type"), MP_QSTR_pixel_shader);
+    }
+
+    vectorio_ishape_t ishape;
+    // Wire up shape functions
+    if (mp_obj_is_type(shape, &vectorio_polygon_type)) {
+        ishape.shape = shape;
+        ishape.get_area = &common_hal_vectorio_polygon_get_area;
+        ishape.get_pixel = &common_hal_vectorio_polygon_get_pixel;
+    } else if (mp_obj_is_type(shape, &vectorio_rectangle_type)) {
+        ishape.shape = shape;
+        ishape.get_area = &common_hal_vectorio_rectangle_get_area;
+        ishape.get_pixel = &common_hal_vectorio_rectangle_get_pixel;
+    } else if (mp_obj_is_type(shape, &vectorio_circle_type)) {
+        ishape.shape = shape;
+        ishape.get_area = &common_hal_vectorio_circle_get_area;
+        ishape.get_pixel = &common_hal_vectorio_circle_get_pixel;
+    } else {
+        mp_raise_TypeError_varg(translate("unsupported %q type"), MP_QSTR_shape);
+    }
+
+    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
+        );
+
+    // Wire up event callbacks
+    vectorio_event_t on_dirty = {
+        .obj = self,
+        .event = &common_hal_vectorio_vector_shape_set_dirty
+    };
+
+    if (mp_obj_is_type(shape, &vectorio_polygon_type)) {
+        common_hal_vectorio_polygon_set_on_dirty(self->ishape.shape, on_dirty);
+    } else if (mp_obj_is_type(shape, &vectorio_rectangle_type)) {
+        common_hal_vectorio_rectangle_set_on_dirty(self->ishape.shape, on_dirty);
+    } else if (mp_obj_is_type(shape, &vectorio_circle_type)) {
+        common_hal_vectorio_circle_set_on_dirty(self->ishape.shape, on_dirty);
+    } else {
+        mp_raise_TypeError_varg(translate("unsupported %q type"), MP_QSTR_shape);
+    }
+
+    return MP_OBJ_FROM_PTR(self);
+}
+
+vectorio_draw_protocol_impl_t vectorio_vector_shape_draw_protocol_impl = {
+    .draw_fill_area = (draw_fill_area_fun)vectorio_vector_shape_fill_area,
+    .draw_get_dirty_area = (draw_get_dirty_area_fun)vectorio_vector_shape_get_dirty_area,
+    .draw_update_transform = (draw_update_transform_fun)vectorio_vector_shape_update_transform,
+    .draw_finish_refresh = (draw_finish_refresh_fun)vectorio_vector_shape_finish_refresh,
+    .draw_get_refresh_areas = (draw_get_refresh_areas_fun)vectorio_vector_shape_get_refresh_areas,
+};
+
+// Stub checker does not approve of these shared properties.
+//     x: int
+//     y: int
+//     """true if x,y lies inside the shape."""
+//
+STATIC mp_obj_t vectorio_vector_shape_obj_contains(mp_obj_t wrapper_shape, mp_obj_t x_obj, mp_obj_t y_obj) {
+    // Relies on the fact that only vector_shape impl gets matched with a VectorShape.
+    const vectorio_draw_protocol_t *draw_protocol = mp_proto_get(MP_QSTR_protocol_draw, wrapper_shape);
+    vectorio_vector_shape_t *self = MP_OBJ_TO_PTR(draw_protocol->draw_get_protocol_self(wrapper_shape));
+
+    mp_int_t x = mp_obj_get_int(x_obj);
+    mp_int_t y = mp_obj_get_int(y_obj);
+    return mp_obj_new_bool(common_hal_vectorio_vector_shape_contains(self, x, y));
+}
+MP_DEFINE_CONST_FUN_OBJ_3(vectorio_vector_shape_contains_obj, vectorio_vector_shape_obj_contains);
+
+// Stub checker does not approve of these shared properties.
+//     x: int
+//     """X position of the center point of the shape in the parent."""
+//
+STATIC mp_obj_t vectorio_vector_shape_obj_get_x(mp_obj_t wrapper_shape) {
+    // Relies on the fact that only vector_shape impl gets matched with a VectorShape.
+    const vectorio_draw_protocol_t *draw_protocol = mp_proto_get(MP_QSTR_protocol_draw, wrapper_shape);
+    vectorio_vector_shape_t *self = MP_OBJ_TO_PTR(draw_protocol->draw_get_protocol_self(wrapper_shape));
+
+    return MP_OBJ_NEW_SMALL_INT(common_hal_vectorio_vector_shape_get_x(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(vectorio_vector_shape_get_x_obj, vectorio_vector_shape_obj_get_x);
+
+STATIC mp_obj_t vectorio_vector_shape_obj_set_x(mp_obj_t wrapper_shape, mp_obj_t x_obj) {
+    // Relies on the fact that only vector_shape impl gets matched with a VectorShape.
+    const vectorio_draw_protocol_t *draw_protocol = mp_proto_get(MP_QSTR_protocol_draw, wrapper_shape);
+    vectorio_vector_shape_t *self = MP_OBJ_TO_PTR(draw_protocol->draw_get_protocol_self(wrapper_shape));
+
+    mp_int_t x = mp_obj_get_int(x_obj);
+    common_hal_vectorio_vector_shape_set_x(self, x);
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(vectorio_vector_shape_set_x_obj, vectorio_vector_shape_obj_set_x);
+
+MP_PROPERTY_GETSET(vectorio_vector_shape_x_obj,
+    (mp_obj_t)&vectorio_vector_shape_get_x_obj,
+    (mp_obj_t)&vectorio_vector_shape_set_x_obj);
+
+
+//     y: int
+//     """Y position of the center point of the shape in the parent."""
+//
+STATIC mp_obj_t vectorio_vector_shape_obj_get_y(mp_obj_t wrapper_shape) {
+    // Relies on the fact that only vector_shape impl gets matched with a VectorShape.
+    const vectorio_draw_protocol_t *draw_protocol = mp_proto_get(MP_QSTR_protocol_draw, wrapper_shape);
+    vectorio_vector_shape_t *self = MP_OBJ_TO_PTR(draw_protocol->draw_get_protocol_self(wrapper_shape));
+
+    return MP_OBJ_NEW_SMALL_INT(common_hal_vectorio_vector_shape_get_y(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(vectorio_vector_shape_get_y_obj, vectorio_vector_shape_obj_get_y);
+
+STATIC mp_obj_t vectorio_vector_shape_obj_set_y(mp_obj_t wrapper_shape, mp_obj_t y_obj) {
+    // Relies on the fact that only vector_shape impl gets matched with a VectorShape.
+    const vectorio_draw_protocol_t *draw_protocol = mp_proto_get(MP_QSTR_protocol_draw, wrapper_shape);
+    vectorio_vector_shape_t *self = MP_OBJ_TO_PTR(draw_protocol->draw_get_protocol_self(wrapper_shape));
+
+    mp_int_t y = mp_obj_get_int(y_obj);
+    common_hal_vectorio_vector_shape_set_y(self, y);
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(vectorio_vector_shape_set_y_obj, vectorio_vector_shape_obj_set_y);
+
+MP_PROPERTY_GETSET(vectorio_vector_shape_y_obj,
+    (mp_obj_t)&vectorio_vector_shape_get_y_obj,
+    (mp_obj_t)&vectorio_vector_shape_set_y_obj);
+
+
+//     location: Tuple[int, int]
+//     """location of the center point of the shape in the parent."""
+//
+STATIC mp_obj_t vectorio_vector_shape_obj_get_location(mp_obj_t wrapper_shape) {
+    // Relies on the fact that only vector_shape impl gets matched with a VectorShape.
+    const vectorio_draw_protocol_t *draw_protocol = mp_proto_get(MP_QSTR_protocol_draw, wrapper_shape);
+    vectorio_vector_shape_t *self = MP_OBJ_TO_PTR(draw_protocol->draw_get_protocol_self(wrapper_shape));
+
+    return MP_OBJ_TO_PTR(common_hal_vectorio_vector_shape_get_location(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(vectorio_vector_shape_get_location_obj, vectorio_vector_shape_obj_get_location);
+
+STATIC mp_obj_t vectorio_vector_shape_obj_set_location(mp_obj_t wrapper_shape, mp_obj_t location_obj) {
+    // Relies on the fact that only vector_shape impl gets matched with a VectorShape.
+    const vectorio_draw_protocol_t *draw_protocol = mp_proto_get(MP_QSTR_protocol_draw, wrapper_shape);
+    vectorio_vector_shape_t *self = MP_OBJ_TO_PTR(draw_protocol->draw_get_protocol_self(wrapper_shape));
+
+    common_hal_vectorio_vector_shape_set_location(self, location_obj);
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(vectorio_vector_shape_set_location_obj, vectorio_vector_shape_obj_set_location);
+
+MP_PROPERTY_GETSET(vectorio_vector_shape_location_obj,
+    (mp_obj_t)&vectorio_vector_shape_get_location_obj,
+    (mp_obj_t)&vectorio_vector_shape_set_location_obj);
+
+
+//     pixel_shader: Union[ColorConverter, Palette]
+//     """The pixel shader of the shape."""
+//
+STATIC mp_obj_t vectorio_vector_shape_obj_get_pixel_shader(mp_obj_t wrapper_shape) {
+    // Relies on the fact that only vector_shape impl gets matched with a VectorShape.
+    const vectorio_draw_protocol_t *draw_protocol = mp_proto_get(MP_QSTR_protocol_draw, wrapper_shape);
+    vectorio_vector_shape_t *self = MP_OBJ_TO_PTR(draw_protocol->draw_get_protocol_self(wrapper_shape));
+
+    return common_hal_vectorio_vector_shape_get_pixel_shader(self);
+}
+MP_DEFINE_CONST_FUN_OBJ_1(vectorio_vector_shape_get_pixel_shader_obj, vectorio_vector_shape_obj_get_pixel_shader);
+
+STATIC mp_obj_t vectorio_vector_shape_obj_set_pixel_shader(mp_obj_t wrapper_shape, mp_obj_t pixel_shader) {
+    // Relies on the fact that only vector_shape impl gets matched with a VectorShape.
+    const vectorio_draw_protocol_t *draw_protocol = mp_proto_get(MP_QSTR_protocol_draw, wrapper_shape);
+    vectorio_vector_shape_t *self = MP_OBJ_TO_PTR(draw_protocol->draw_get_protocol_self(wrapper_shape));
+
+    if (!mp_obj_is_type(pixel_shader, &displayio_palette_type) && !mp_obj_is_type(pixel_shader, &displayio_colorconverter_type)) {
+        mp_raise_TypeError(translate("pixel_shader must be displayio.Palette or displayio.ColorConverter"));
+    }
+
+    common_hal_vectorio_vector_shape_set_pixel_shader(self, pixel_shader);
+
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(vectorio_vector_shape_set_pixel_shader_obj, vectorio_vector_shape_obj_set_pixel_shader);
+
+MP_PROPERTY_GETSET(vectorio_vector_shape_pixel_shader_obj,
+    (mp_obj_t)&vectorio_vector_shape_get_pixel_shader_obj,
+    (mp_obj_t)&vectorio_vector_shape_set_pixel_shader_obj);
+
+
+STATIC const mp_rom_map_elem_t vectorio_vector_shape_locals_dict_table[] = {
+};
+STATIC MP_DEFINE_CONST_DICT(vectorio_vector_shape_locals_dict, vectorio_vector_shape_locals_dict_table);
+
+const mp_obj_type_t vectorio_vector_shape_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_VectorShape,
+    .locals_dict = (mp_obj_dict_t *)&vectorio_vector_shape_locals_dict,
+};
diff --git a/circuitpython/shared-bindings/vectorio/VectorShape.h b/circuitpython/shared-bindings/vectorio/VectorShape.h
new file mode 100644
index 0000000..13f6292
--- /dev/null
+++ b/circuitpython/shared-bindings/vectorio/VectorShape.h
@@ -0,0 +1,47 @@
+#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_VECTORIO_SHAPE_H
+#define MICROPY_INCLUDED_SHARED_BINDINGS_VECTORIO_SHAPE_H
+
+#include "py/objproperty.h"
+#include "py/objtuple.h"
+
+#include "shared-bindings/vectorio/__init__.h"
+#include "shared-module/vectorio/VectorShape.h"
+#include "shared-module/displayio/area.h"
+
+extern const mp_obj_type_t vectorio_vector_shape_type;
+
+// Python shared bindings constructor
+mp_obj_t vectorio_vector_shape_make_new(const mp_obj_t shape, const mp_obj_t pixel_shader, int32_t x, int32_t y);
+
+// C data constructor
+void common_hal_vectorio_vector_shape_construct(vectorio_vector_shape_t *self,
+    vectorio_ishape_t ishape,
+    mp_obj_t pixel_shader, int32_t x, int32_t y);
+
+bool common_hal_vectorio_vector_shape_contains(vectorio_vector_shape_t *self, mp_int_t x, mp_int_t y);
+
+void common_hal_vectorio_vector_shape_set_dirty(void *self);
+
+mp_int_t common_hal_vectorio_vector_shape_get_x(vectorio_vector_shape_t *self);
+void common_hal_vectorio_vector_shape_set_x(vectorio_vector_shape_t *self, mp_int_t x);
+
+mp_obj_tuple_t *common_hal_vectorio_vector_shape_get_location(vectorio_vector_shape_t *self);
+void common_hal_vectorio_vector_shape_set_location(vectorio_vector_shape_t *self, mp_obj_t xy);
+
+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);
+
+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);
+
+// Composable property definition for shapes that use VectorShape
+extern vectorio_draw_protocol_impl_t vectorio_vector_shape_draw_protocol_impl;
+extern const mp_obj_property_getset_t vectorio_vector_shape_x_obj;
+extern const mp_obj_property_getset_t vectorio_vector_shape_y_obj;
+extern const mp_obj_property_getset_t vectorio_vector_shape_location_obj;
+extern const mp_obj_property_getset_t vectorio_vector_shape_pixel_shader_obj;
+extern const mp_obj_fun_builtin_fixed_t vectorio_vector_shape_contains_obj;
+
+#endif // MICROPY_INCLUDED_SHARED_BINDINGS_VECTORIO_SHAPE_H
diff --git a/circuitpython/shared-bindings/vectorio/__init__.c b/circuitpython/shared-bindings/vectorio/__init__.c
new file mode 100644
index 0000000..6e39f26
--- /dev/null
+++ b/circuitpython/shared-bindings/vectorio/__init__.c
@@ -0,0 +1,49 @@
+#include <stdint.h>
+
+#include "py/obj.h"
+#include "py/runtime.h"
+
+#include "shared-bindings/vectorio/Circle.h"
+#include "shared-bindings/vectorio/Polygon.h"
+#include "shared-bindings/vectorio/Rectangle.h"
+
+//| """Lightweight 2D shapes for displays
+//|
+//| The :py:attr:`vectorio` module provide simple filled drawing primitives for
+//| use with `displayio`.
+//|
+//| .. code-block:: python
+//|
+//|     group = displayio.Group()
+//|
+//|     palette = displayio.Palette(1)
+//|     palette[0] = 0x125690
+//|
+//|     circle = vectorio.Circle(pixel_shader=palette, radius=25, x=70, y=40)
+//|     group.append(circle)
+//|
+//|     rectangle = vectorio.Rectangle(pixel_shader=palette, width=40, height=30, x=55, y=45)
+//|     group.append(rectangle)
+//|
+//|     points=[(5, 5), (100, 20), (20, 20), (20, 100)]
+//|     polygon = vectorio.Polygon(pixel_shader=palette, points=points, x=0, y=0)
+//|     group.append(polygon)
+//|
+//| """
+//|
+
+STATIC const mp_rom_map_elem_t vectorio_module_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_vectorio) },
+    { MP_ROM_QSTR(MP_QSTR_Circle), MP_ROM_PTR(&vectorio_circle_type) },
+    { MP_ROM_QSTR(MP_QSTR_Polygon), MP_ROM_PTR(&vectorio_polygon_type) },
+    { MP_ROM_QSTR(MP_QSTR_Rectangle), MP_ROM_PTR(&vectorio_rectangle_type) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(vectorio_module_globals, vectorio_module_globals_table);
+
+const mp_obj_module_t vectorio_module = {
+    .base = { &mp_type_module },
+    .globals = (mp_obj_dict_t *)&vectorio_module_globals,
+};
+
+MP_REGISTER_MODULE(MP_QSTR_vectorio, vectorio_module, CIRCUITPY_VECTORIO);
diff --git a/circuitpython/shared-bindings/vectorio/__init__.h b/circuitpython/shared-bindings/vectorio/__init__.h
new file mode 100644
index 0000000..a34195d
--- /dev/null
+++ b/circuitpython/shared-bindings/vectorio/__init__.h
@@ -0,0 +1,41 @@
+#ifndef SHARED_MODULE_VECTORIO__INIT__H
+#define SHARED_MODULE_VECTORIO__INIT__H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "py/obj.h"
+#include "py/proto.h"
+
+#include "shared-module/displayio/area.h"
+#include "shared-module/displayio/Palette.h"
+
+// Returns the object on which the rest of the draw protocol methods are invoked.
+typedef mp_obj_t (*draw_get_protocol_self_fun)(mp_obj_t protocol_container);
+
+typedef bool (*draw_fill_area_fun)(mp_obj_t draw_protocol_self, const _displayio_colorspace_t *colorspace, const displayio_area_t *area, uint32_t *mask, uint32_t *buffer);
+typedef bool (*draw_get_dirty_area_fun)(mp_obj_t draw_protocol_self, displayio_area_t *current_dirty_area);
+typedef void (*draw_update_transform_fun)(mp_obj_t draw_protocol_self, displayio_buffer_transform_t *group_transform);
+typedef void (*draw_finish_refresh_fun)(mp_obj_t draw_protocol_self);
+typedef displayio_area_t *(*draw_get_refresh_areas_fun)(mp_obj_t draw_protocol_self, displayio_area_t *tail);
+
+typedef struct _vectorio_draw_protocol_impl_t {
+    draw_fill_area_fun draw_fill_area;
+    draw_get_dirty_area_fun draw_get_dirty_area;
+    draw_update_transform_fun draw_update_transform;
+    draw_finish_refresh_fun draw_finish_refresh;
+    draw_get_refresh_areas_fun draw_get_refresh_areas;
+} vectorio_draw_protocol_impl_t;
+
+// Draw protocol
+typedef struct _vectorio_draw_protocol_t {
+    MP_PROTOCOL_HEAD // MP_QSTR_protocol_draw
+
+    // Instance of the draw protocol
+    draw_get_protocol_self_fun draw_get_protocol_self;
+
+    // Implementation functions for the draw protocol
+    vectorio_draw_protocol_impl_t *draw_protocol_impl;
+} vectorio_draw_protocol_t;
+
+#endif