pixel_shader back to required on TileGrid. TPM init with no tilegrid or width/height, internal bind function is used to bind a TileGrid to a TilePaletteMapper when the TileGrid is init with or has pixel_shader set to a TPM

Author: FoamyGuy

shared-bindings/displayio/TileGrid.c

@@ -68,7 +68,7 @@ void displayio_tilegrid_validate_pixel_shader(mp_obj_t pixel_shader) {
 //|         tile_width and tile_height match the height of the bitmap by default.
 //|
 //|         :param Bitmap,OnDiskBitmap bitmap: The bitmap storing one or more tiles.
-//|         :param Optional[ColorConverter,Palette] pixel_shader: The pixel shader that produces colors from values
+//|         :param ColorConverter,Palette pixel_shader: The pixel shader that produces colors from values
 //|         :param int width: Width of the grid in tiles.
 //|         :param int height: Height of the grid in tiles.
 //|         :param int tile_width: Width of a single tile in pixels. Defaults to the full Bitmap and must evenly divide into the Bitmap's dimensions.
@@ -81,7 +81,7 @@ static mp_obj_t displayio_tilegrid_make_new(const mp_obj_type_t *type, size_t n_
     enum { ARG_bitmap, ARG_pixel_shader, ARG_width, ARG_height, ARG_tile_width, ARG_tile_height, ARG_default_tile, ARG_x, ARG_y };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_bitmap, MP_ARG_REQUIRED | MP_ARG_OBJ },
-        { MP_QSTR_pixel_shader, MP_ARG_OBJ | MP_ARG_KW_ONLY, {.u_obj = mp_const_none} },
+        { MP_QSTR_pixel_shader, MP_ARG_OBJ | MP_ARG_KW_ONLY | MP_ARG_REQUIRED },
         { MP_QSTR_width, MP_ARG_INT | MP_ARG_KW_ONLY, {.u_int = 1} },
         { MP_QSTR_height, MP_ARG_INT | MP_ARG_KW_ONLY, {.u_int = 1} },
         { MP_QSTR_tile_width, MP_ARG_INT | MP_ARG_KW_ONLY, {.u_int = 0} },
@@ -109,9 +109,7 @@ static mp_obj_t displayio_tilegrid_make_new(const mp_obj_type_t *type, size_t n_
         mp_raise_TypeError_varg(MP_ERROR_TEXT("unsupported %q type"), MP_QSTR_bitmap);
     }
     mp_obj_t pixel_shader = args[ARG_pixel_shader].u_obj;
-    if (pixel_shader != mp_const_none) {
-        displayio_tilegrid_validate_pixel_shader(pixel_shader);
-    }
+    displayio_tilegrid_validate_pixel_shader(pixel_shader);
     uint16_t tile_width = args[ARG_tile_width].u_int;
     if (tile_width == 0) {
         tile_width = bitmap_width;

shared-bindings/tilepalettemapper/TilePaletteMapper.c

@@ -22,22 +22,20 @@
 //|     bitmap with a wider array of colors."""
 //|
 //|     def __init__(
-//|         self, palette: displayio.Palette, input_color_count: int, tilegrid: displayio.TileGrid
+//|         self, palette: displayio.Palette, input_color_count: int
 //|     ) -> None:
 //|         """Create a TilePaletteMApper object to store a set of color mappings for tiles.
 //|
 //|         :param Union[displayio.Palette, displayio.ColorConverter] pixel_shader:
 //|           The palette or ColorConverter to get mapped colors from.
-//|         :param int input_color_count: The number of colors in in the input bitmap.
-//|         :param TileGrid tilegrid: The tilegrid to use with the TilePaletteMapper"""
+//|         :param int input_color_count: The number of colors in in the input bitmap."""
 //|
 
 static mp_obj_t tilepalettemapper_tilepalettemapper_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_input_color_count, ARG_tilegrid };
+    enum { ARG_pixel_shader, ARG_input_color_count };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_pixel_shader, MP_ARG_OBJ | MP_ARG_REQUIRED },
         { MP_QSTR_input_color_count, MP_ARG_INT | MP_ARG_REQUIRED },
-        { MP_QSTR_tilegrid, MP_ARG_OBJ | MP_ARG_REQUIRED },
 
     };
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
@@ -47,13 +45,9 @@ static mp_obj_t tilepalettemapper_tilepalettemapper_make_new(const mp_obj_type_t
         mp_raise_TypeError_varg(MP_ERROR_TEXT("unsupported %q type"), MP_QSTR_pixel_shader);
     }
 
-    mp_obj_t tilegrid = args[ARG_tilegrid].u_obj;
-    if (!mp_obj_is_type(tilegrid, &displayio_tilegrid_type)) {
-        mp_raise_TypeError_varg(MP_ERROR_TEXT("unsupported %q type"), MP_QSTR_tilegrid);
-    }
 
     tilepalettemapper_tilepalettemapper_t *self = mp_obj_malloc(tilepalettemapper_tilepalettemapper_t, &tilepalettemapper_tilepalettemapper_type);
-    common_hal_tilepalettemapper_tilepalettemapper_construct(self, pixel_shader, args[ARG_input_color_count].u_int, tilegrid);
+    common_hal_tilepalettemapper_tilepalettemapper_construct(self, pixel_shader, args[ARG_input_color_count].u_int);
 
     return MP_OBJ_FROM_PTR(self);
 }

shared-bindings/tilepalettemapper/TilePaletteMapper.h

@@ -8,7 +8,7 @@
 extern const mp_obj_type_t tilepalettemapper_tilepalettemapper_type;
 
 void common_hal_tilepalettemapper_tilepalettemapper_construct(tilepalettemapper_tilepalettemapper_t *self,
-    mp_obj_t paltte, uint16_t input_color_count, mp_obj_t tilegrid);
+    mp_obj_t paltte, uint16_t input_color_count);
 
 
 uint16_t common_hal_tilepalettemapper_tilepalettemapper_get_width(tilepalettemapper_tilepalettemapper_t *self);

shared-module/displayio/Group.c

@@ -258,9 +258,6 @@ static void _add_layer(displayio_group_t *self, mp_obj_t layer) {
     mp_obj_t native_layer = mp_obj_cast_to_native_base(layer, &displayio_tilegrid_type);
     if (native_layer != MP_OBJ_NULL) {
         displayio_tilegrid_t *tilegrid = native_layer;
-        if (tilegrid->pixel_shader == mp_const_none) {
-            mp_raise_ValueError(MP_ERROR_TEXT("TileGrid must have a pixel_shader"));
-        }
         if (tilegrid->in_group) {
             mp_raise_ValueError(MP_ERROR_TEXT("Layer already in a group"));
         } else {

shared-module/displayio/TileGrid.c

@@ -81,6 +81,11 @@ void common_hal_displayio_tilegrid_construct(displayio_tilegrid_t *self, mp_obj_
     self->flip_y = false;
     self->transpose_xy = false;
     self->absolute_transform = NULL;
+    #if CIRCUITPY_TILEPALETTEMAPPER
+    if (mp_obj_is_type(self->pixel_shader, &tilepalettemapper_tilepalettemapper_type)) {
+        tilepalettemapper_tilepalettemapper_bind(self->pixel_shader, self);
+    }
+    #endif
 }
 
 
@@ -231,6 +236,11 @@ mp_obj_t common_hal_displayio_tilegrid_get_pixel_shader(displayio_tilegrid_t *se
 void common_hal_displayio_tilegrid_set_pixel_shader(displayio_tilegrid_t *self, mp_obj_t pixel_shader) {
     self->pixel_shader = pixel_shader;
     self->full_change = true;
+    #if CIRCUITPY_TILEPALETTEMAPPER
+    if (mp_obj_is_type(self->pixel_shader, &tilepalettemapper_tilepalettemapper_type)) {
+        tilepalettemapper_tilepalettemapper_bind(self->pixel_shader, self);
+    }
+    #endif
 }
 
 mp_obj_t common_hal_displayio_tilegrid_get_bitmap(displayio_tilegrid_t *self) {

shared-module/tilepalettemapper/TilePaletteMapper.c

@@ -11,27 +11,9 @@
 #include "shared-bindings/displayio/TileGrid.h"
 
 void common_hal_tilepalettemapper_tilepalettemapper_construct(tilepalettemapper_tilepalettemapper_t *self,
-    mp_obj_t pixel_shader, uint16_t input_color_count, mp_obj_t tilegrid) {
-    self->tilegrid = tilegrid;
+    mp_obj_t pixel_shader, uint16_t input_color_count) {
     self->pixel_shader = pixel_shader;
-    self->width_in_tiles = common_hal_displayio_tilegrid_get_width(tilegrid);
-    self->height_in_tiles = common_hal_displayio_tilegrid_get_height(tilegrid);
     self->input_color_count = input_color_count;
-    int mappings_len = self->width_in_tiles * self->height_in_tiles;
-    self->tile_mappings = (uint32_t **)m_malloc(mappings_len * sizeof(uint32_t *));
-    for (int i = 0; i < mappings_len; i++) {
-        self->tile_mappings[i] = (uint32_t *)m_malloc_without_collect(input_color_count * sizeof(uint32_t));
-        if (mp_obj_is_type(self->pixel_shader, &displayio_palette_type)) {
-            for (uint16_t j = 0; j < input_color_count; j++) {
-                self->tile_mappings[i][j] = j;
-            }
-        } else if (mp_obj_is_type(self->pixel_shader, &displayio_colorconverter_type)) {
-            for (uint16_t j = 0; j < input_color_count; j++) {
-                self->tile_mappings[i][j] = 0;
-            }
-        }
-    }
-    common_hal_displayio_tilegrid_set_pixel_shader(self->tilegrid, self);
 }
 
 uint16_t common_hal_tilepalettemapper_tilepalettemapper_get_width(tilepalettemapper_tilepalettemapper_t *self) {
@@ -95,3 +77,24 @@ void tilepalettemapper_tilepalettemapper_get_color(tilepalettemapper_tilepalette
     }
 
 }
+
+void tilepalettemapper_tilepalettemapper_bind(tilepalettemapper_tilepalettemapper_t *self,  displayio_tilegrid_t *tilegrid) {
+    self->tilegrid = tilegrid;
+    self->width_in_tiles = common_hal_displayio_tilegrid_get_width(tilegrid);
+    self->height_in_tiles = common_hal_displayio_tilegrid_get_height(tilegrid);
+
+    int mappings_len = self->width_in_tiles * self->height_in_tiles;
+    self->tile_mappings = (uint32_t **)m_malloc(mappings_len * sizeof(uint32_t *));
+    for (int i = 0; i < mappings_len; i++) {
+        self->tile_mappings[i] = (uint32_t *)m_malloc_without_collect(self->input_color_count * sizeof(uint32_t));
+        if (mp_obj_is_type(self->pixel_shader, &displayio_palette_type)) {
+            for (uint16_t j = 0; j < self->input_color_count; j++) {
+                self->tile_mappings[i][j] = j;
+            }
+        } else if (mp_obj_is_type(self->pixel_shader, &displayio_colorconverter_type)) {
+            for (uint16_t j = 0; j < self->input_color_count; j++) {
+                self->tile_mappings[i][j] = 0;
+            }
+        }
+    }
+}

shared-module/tilepalettemapper/TilePaletteMapper.h

@@ -12,6 +12,7 @@
 
 #include "py/obj.h"
 #include "shared-module/displayio/Palette.h"
+#include "shared-module/displayio/TileGrid.h"
 
 typedef struct {
     mp_obj_base_t base;
@@ -24,3 +25,4 @@ typedef struct {
 } tilepalettemapper_tilepalettemapper_t;
 
 void tilepalettemapper_tilepalettemapper_get_color(tilepalettemapper_tilepalettemapper_t *self, const _displayio_colorspace_t *colorspace, displayio_input_pixel_t *input_pixel, displayio_output_pixel_t *output_color, uint16_t x_tile_index, uint16_t y_tile_index);
+void tilepalettemapper_tilepalettemapper_bind(tilepalettemapper_tilepalettemapper_t *self, displayio_tilegrid_t *tilegrid);