implement needs_refresh, run pre-commit, move get_color to shared-module

Author: FoamyGuy

shared-bindings/displayio/TileGrid.c

@@ -22,6 +22,21 @@
 #endif
 
 
+void displayio_tilegrid_validate_pixel_shader(mp_obj_t pixel_shader) {
+    bool valid_type = true;
+    if (!mp_obj_is_type(pixel_shader, &displayio_palette_type) && !mp_obj_is_type(pixel_shader, &displayio_colorconverter_type)) {
+        valid_type = false;
+    }
+    #ifdef CIRCUITPY_TILEPALETTEMAPPER
+    if (mp_obj_is_type(pixel_shader, &tilepalettemapper_tilepalettemapper_type)) {
+        valid_type = true;
+    }
+    #endif
+    if (!valid_type) {
+        mp_raise_TypeError_varg(MP_ERROR_TEXT("unsupported %q type"), MP_QSTR_pixel_shader);
+    }
+}
+
 //| class TileGrid:
 //|     """A grid of tiles sourced out of one bitmap
 //|
@@ -93,10 +108,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 (!mp_obj_is_type(pixel_shader, &displayio_colorconverter_type) &&
-        !mp_obj_is_type(pixel_shader, &displayio_palette_type)) {
-        mp_raise_TypeError_varg(MP_ERROR_TEXT("unsupported %q type"), MP_QSTR_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;
@@ -327,21 +339,7 @@ MP_DEFINE_CONST_FUN_OBJ_1(displayio_tilegrid_get_pixel_shader_obj, displayio_til
 
 static mp_obj_t displayio_tilegrid_obj_set_pixel_shader(mp_obj_t self_in, mp_obj_t pixel_shader) {
     displayio_tilegrid_t *self = native_tilegrid(self_in);
-    bool valid_type = true;
-    if (!mp_obj_is_type(pixel_shader, &displayio_palette_type) && !mp_obj_is_type(pixel_shader, &displayio_colorconverter_type)) {
-      valid_type = false;
-    }
-  mp_printf(&mp_plat_print, "checking tilepalettemapper\n");
-  #ifdef CIRCUITPY_TILEPALETTEMAPPER
-    mp_printf(&mp_plat_print, "tilepalettemapper enabled inside set pixel shader\n");
-    if (mp_obj_is_type(pixel_shader, &tilepalettemapper_tilepalettemapper_type)) {
-      valid_type = true;
-    }
-    #endif
-    if (!valid_type) {
-      mp_raise_TypeError_varg(MP_ERROR_TEXT("unsupported %q type"), MP_QSTR_pixel_shader);
-    }
-
+    displayio_tilegrid_validate_pixel_shader(pixel_shader);
     common_hal_displayio_tilegrid_set_pixel_shader(self, pixel_shader);
 
     return mp_const_none;

shared-bindings/tilepalettemapper/TilePaletteMapper.c

@@ -14,29 +14,29 @@
 #include "shared-bindings/tilepalettemapper/TilePaletteMapper.h"
 
 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_palette, ARG_width, ARG_height };
-  static const mp_arg_t allowed_args[] = {
-    { MP_QSTR_palette, MP_ARG_OBJ | MP_ARG_REQUIRED },
-    { MP_QSTR_width, MP_ARG_INT | MP_ARG_REQUIRED, {.u_int = 1} },
-    { MP_QSTR_height, MP_ARG_INT | MP_ARG_REQUIRED, {.u_int = 1} },
-};
-  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 palette = args[ARG_palette].u_obj;
-  if (!mp_obj_is_type(palette, &displayio_palette_type)) {
-    mp_raise_TypeError_varg(MP_ERROR_TEXT("unsupported %q type"), MP_QSTR_pixel_shader);
-  }
-  tilepalettemapper_tilepalettemapper_t *self = mp_obj_malloc(tilepalettemapper_tilepalettemapper_t, &tilepalettemapper_tilepalettemapper_type);
-  common_hal_tilepalettemapper_tilepalettemapper_construct(self, palette, args[ARG_width].u_int, args[ARG_height].u_int);
-
-  return MP_OBJ_FROM_PTR(self);
+    enum { ARG_palette, ARG_width, ARG_height };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_palette, MP_ARG_OBJ | MP_ARG_REQUIRED },
+        { MP_QSTR_width, MP_ARG_INT | MP_ARG_REQUIRED, {.u_int = 1} },
+        { MP_QSTR_height, MP_ARG_INT | MP_ARG_REQUIRED, {.u_int = 1} },
+    };
+    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 palette = args[ARG_palette].u_obj;
+    if (!mp_obj_is_type(palette, &displayio_palette_type)) {
+        mp_raise_TypeError_varg(MP_ERROR_TEXT("unsupported %q type"), MP_QSTR_pixel_shader);
+    }
+    tilepalettemapper_tilepalettemapper_t *self = mp_obj_malloc(tilepalettemapper_tilepalettemapper_t, &tilepalettemapper_tilepalettemapper_type);
+    common_hal_tilepalettemapper_tilepalettemapper_construct(self, palette, args[ARG_width].u_int, args[ARG_height].u_int);
+
+    return MP_OBJ_FROM_PTR(self);
 }
 
 //|     width: int
 //|     """Width of the tile palette mapper in tiles."""
 static mp_obj_t tilepalettemapper_tilepalettemapper_obj_get_width(mp_obj_t self_in) {
-  tilepalettemapper_tilepalettemapper_t *self = MP_OBJ_TO_PTR(self_in);
-  return MP_OBJ_NEW_SMALL_INT(common_hal_tilepalettemapper_tilepalettemapper_get_width(self));
+    tilepalettemapper_tilepalettemapper_t *self = MP_OBJ_TO_PTR(self_in);
+    return MP_OBJ_NEW_SMALL_INT(common_hal_tilepalettemapper_tilepalettemapper_get_width(self));
 }
 MP_DEFINE_CONST_FUN_OBJ_1(tilepalettemapper_tilepalettemapper_get_width_obj, tilepalettemapper_tilepalettemapper_obj_get_width);
 
@@ -46,8 +46,8 @@ MP_PROPERTY_GETTER(tilepalettemapper_tilepalettemapper_width_obj,
 //|     height: int
 //|     """Height of the tile palette mapper in tiles."""
 static mp_obj_t tilepalettemapper_tilepalettemapper_obj_get_height(mp_obj_t self_in) {
-  tilepalettemapper_tilepalettemapper_t *self = MP_OBJ_TO_PTR(self_in);
-  return MP_OBJ_NEW_SMALL_INT(common_hal_tilepalettemapper_tilepalettemapper_get_height(self));
+    tilepalettemapper_tilepalettemapper_t *self = MP_OBJ_TO_PTR(self_in);
+    return MP_OBJ_NEW_SMALL_INT(common_hal_tilepalettemapper_tilepalettemapper_get_height(self));
 }
 MP_DEFINE_CONST_FUN_OBJ_1(tilepalettemapper_tilepalettemapper_get_height_obj, tilepalettemapper_tilepalettemapper_obj_get_height);
 
@@ -58,8 +58,8 @@ MP_PROPERTY_GETTER(tilepalettemapper_tilepalettemapper_height_obj,
 //|     palette: displayio.Palette
 //|     """The palette that the mapper uses."""
 static mp_obj_t tilepalettemapper_tilepalettemapper_obj_get_palette(mp_obj_t self_in) {
-  tilepalettemapper_tilepalettemapper_t *self = MP_OBJ_TO_PTR(self_in);
-  return common_hal_tilepalettemapper_tilepalettemapper_get_palette(self);
+    tilepalettemapper_tilepalettemapper_t *self = MP_OBJ_TO_PTR(self_in);
+    return common_hal_tilepalettemapper_tilepalettemapper_get_palette(self);
 }
 MP_DEFINE_CONST_FUN_OBJ_1(tilepalettemapper_tilepalettemapper_get_palette_obj, tilepalettemapper_tilepalettemapper_obj_get_palette);
 
@@ -91,51 +91,51 @@ MP_PROPERTY_GETTER(tilepalettemapper_tilepalettemapper_palette_obj,
 //|
 //|
 static mp_obj_t tilepalettemapper_subscr(mp_obj_t self_in, mp_obj_t index_obj, mp_obj_t value_obj) {
-  tilepalettemapper_tilepalettemapper_t *self = MP_OBJ_TO_PTR(self_in);
-  if (mp_obj_is_type(index_obj, &mp_type_slice)) {
-    mp_raise_NotImplementedError(MP_ERROR_TEXT("Slices not supported"));
-  } else {
-    uint16_t x = 0;
-    uint16_t y = 0;
-    if (mp_obj_is_small_int(index_obj)) {
-      mp_int_t i = MP_OBJ_SMALL_INT_VALUE(index_obj);
-      uint16_t width = common_hal_tilepalettemapper_tilepalettemapper_get_width(self);
-      x = i % width;
-      y = i / width;
+    tilepalettemapper_tilepalettemapper_t *self = MP_OBJ_TO_PTR(self_in);
+    if (mp_obj_is_type(index_obj, &mp_type_slice)) {
+        mp_raise_NotImplementedError(MP_ERROR_TEXT("Slices not supported"));
     } else {
-      mp_obj_t *items;
-      mp_obj_get_array_fixed_n(index_obj, 2, &items);
-      x = mp_obj_get_int(items[0]);
-      y = mp_obj_get_int(items[1]);
-    }
-    if (x >= common_hal_tilepalettemapper_tilepalettemapper_get_width(self) ||
-        y >= common_hal_tilepalettemapper_tilepalettemapper_get_height(self)) {
-      mp_raise_IndexError(MP_ERROR_TEXT("Tile index out of bounds"));
+        uint16_t x = 0;
+        uint16_t y = 0;
+        if (mp_obj_is_small_int(index_obj)) {
+            mp_int_t i = MP_OBJ_SMALL_INT_VALUE(index_obj);
+            uint16_t width = common_hal_tilepalettemapper_tilepalettemapper_get_width(self);
+            x = i % width;
+            y = i / width;
+        } else {
+            mp_obj_t *items;
+            mp_obj_get_array_fixed_n(index_obj, 2, &items);
+            x = mp_obj_get_int(items[0]);
+            y = mp_obj_get_int(items[1]);
+        }
+        if (x >= common_hal_tilepalettemapper_tilepalettemapper_get_width(self) ||
+            y >= common_hal_tilepalettemapper_tilepalettemapper_get_height(self)) {
+            mp_raise_IndexError(MP_ERROR_TEXT("Tile index out of bounds"));
         }
 
-    if (value_obj == MP_OBJ_SENTINEL) {
-      // load
-      return common_hal_tilepalettemapper_tilepalettemapper_get_mapping(self, x, y);
-    } else if (value_obj == mp_const_none) {
-      return MP_OBJ_NULL; // op not supported
-    } else {
-        size_t len = 0;
-        mp_obj_t *items;
-        mp_obj_list_get(value_obj, &len, &items);
-        uint32_t palette_len = common_hal_displayio_palette_get_len(self->palette);
-
-        mp_arg_validate_int_range(len, 0, palette_len, MP_QSTR_mapping_length);
-        common_hal_tilepalettemapper_tilepalettemapper_set_mapping(self, x, y, len, items);
+        if (value_obj == MP_OBJ_SENTINEL) {
+            // load
+            return common_hal_tilepalettemapper_tilepalettemapper_get_mapping(self, x, y);
+        } else if (value_obj == mp_const_none) {
+            return MP_OBJ_NULL; // op not supported
+        } else {
+            size_t len = 0;
+            mp_obj_t *items;
+            mp_obj_list_get(value_obj, &len, &items);
+            uint32_t palette_len = common_hal_displayio_palette_get_len(self->palette);
+
+            mp_arg_validate_int_range(len, 0, palette_len, MP_QSTR_mapping_length);
+            common_hal_tilepalettemapper_tilepalettemapper_set_mapping(self, x, y, len, items);
+        }
     }
-  }
-  return mp_const_none;
+    return mp_const_none;
 }
 
 
 static const mp_rom_map_elem_t tilepalettemapper_tilepalettemapper_locals_dict_table[] = {
-  { MP_ROM_QSTR(MP_QSTR_width), MP_ROM_PTR(&tilepalettemapper_tilepalettemapper_width_obj) },
-  { MP_ROM_QSTR(MP_QSTR_height), MP_ROM_PTR(&tilepalettemapper_tilepalettemapper_height_obj) },
-  { MP_ROM_QSTR(MP_QSTR_palette), MP_ROM_PTR(&tilepalettemapper_tilepalettemapper_palette_obj) },
+    { MP_ROM_QSTR(MP_QSTR_width), MP_ROM_PTR(&tilepalettemapper_tilepalettemapper_width_obj) },
+    { MP_ROM_QSTR(MP_QSTR_height), MP_ROM_PTR(&tilepalettemapper_tilepalettemapper_height_obj) },
+    { MP_ROM_QSTR(MP_QSTR_palette), MP_ROM_PTR(&tilepalettemapper_tilepalettemapper_palette_obj) },
 };
 static MP_DEFINE_CONST_DICT(tilepalettemapper_tilepalettemapper_locals_dict, tilepalettemapper_tilepalettemapper_locals_dict_table);
 

shared-bindings/tilepalettemapper/TilePaletteMapper.h

@@ -14,5 +14,3 @@ uint16_t common_hal_tilepalettemapper_tilepalettemapper_get_height(tilepalettema
 mp_obj_t common_hal_tilepalettemapper_tilepalettemapper_get_palette(tilepalettemapper_tilepalettemapper_t *self);
 mp_obj_t common_hal_tilepalettemapper_tilepalettemapper_get_mapping(tilepalettemapper_tilepalettemapper_t *self, uint16_t x, uint16_t y);
 void common_hal_tilepalettemapper_tilepalettemapper_set_mapping(tilepalettemapper_tilepalettemapper_t *self, uint16_t x, uint16_t y, size_t len, mp_obj_t *items);
-
-uint32_t common_hal_tilepalettemapper_tilepalettemapper_get_color(tilepalettemapper_tilepalettemapper_t *self, uint16_t tile_index, uint32_t palette_index);

shared-module/displayio/TileGrid.c

@@ -489,8 +489,8 @@ bool displayio_tilegrid_fill_area(displayio_tilegrid_t *self,
 
             output_pixel.opaque = true;
             #ifdef CIRCUITPY_TILEPALETTEMAPPER
-            if (mp_obj_is_type(self->pixel_shader, &tilepalettemapper_tilepalettemapper_type)){
-              output_pixel.pixel = common_hal_tilepalettemapper_tilepalettemapper_get_color(self->pixel_shader, tile_location, input_pixel.pixel);
+            if (mp_obj_is_type(self->pixel_shader, &tilepalettemapper_tilepalettemapper_type)) {
+                output_pixel.pixel = tilepalettemapper_tilepalettemapper_get_color(self->pixel_shader, tile_location, input_pixel.pixel);
             }
             #endif
             if (self->pixel_shader == mp_const_none) {
@@ -558,6 +558,11 @@ void displayio_tilegrid_finish_refresh(displayio_tilegrid_t *self) {
     } else if (mp_obj_is_type(self->pixel_shader, &displayio_colorconverter_type)) {
         displayio_colorconverter_finish_refresh(self->pixel_shader);
     }
+    #ifdef CIRCUITPY_TILEPALETTEMAPPER
+    if (mp_obj_is_type(self->pixel_shader, &tilepalettemapper_tilepalettemapper_type)) {
+        tilepalettemapper_tilepalettemapper_finish_refresh(self->pixel_shader);
+    }
+    #endif
     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_ondiskbitmap_type)) {
@@ -611,6 +616,12 @@ displayio_area_t *displayio_tilegrid_get_refresh_areas(displayio_tilegrid_t *sel
             displayio_palette_needs_refresh(self->pixel_shader)) ||
         (mp_obj_is_type(self->pixel_shader, &displayio_colorconverter_type) &&
             displayio_colorconverter_needs_refresh(self->pixel_shader));
+    #ifdef CIRCUITPY_TILEPALETTEMAPPER
+    self->full_change = self->full_change ||
+        (mp_obj_is_type(self->pixel_shader, &tilepalettemapper_tilepalettemapper_type) &&
+            tilepalettemapper_tilepalettemapper_needs_refresh(self->pixel_shader));
+    #endif
+
     if (self->full_change || first_draw) {
         self->current_area.next = tail;
         return &self->current_area;

shared-module/displayio/TileGrid.h

@@ -67,3 +67,4 @@ bool displayio_tilegrid_get_previous_area(displayio_tilegrid_t *self, displayio_
 void displayio_tilegrid_finish_refresh(displayio_tilegrid_t *self);
 
 bool displayio_tilegrid_get_rendered_hidden(displayio_tilegrid_t *self);
+void displayio_tilegrid_validate_pixel_shader(mp_obj_t pixel_shader);

shared-module/tilepalettemapper/TilePaletteMapper.c

@@ -11,56 +11,65 @@
 void common_hal_tilepalettemapper_tilepalettemapper_construct(tilepalettemapper_tilepalettemapper_t *self,
     mp_obj_t palette, uint16_t width, uint16_t height) {
 
-  self->palette = palette;
-  self->width_in_tiles = width;
-  self->height_in_tiles = height;
-  int mappings_len = width * height;
-  mp_printf(&mp_plat_print, "%d", mappings_len);
-  self->tile_mappings = (uint16_t**)m_malloc(mappings_len * sizeof(uint16_t*));
-  uint32_t palette_len = common_hal_displayio_palette_get_len(self->palette);
-  for (int i = 0; i < mappings_len; i++) {
-    self->tile_mappings[i] = (uint16_t*)m_malloc(palette_len * sizeof(uint16_t));
-    for (uint16_t j = 0; j < palette_len; j++) {
-      self->tile_mappings[i][j] = j;
+    self->palette = palette;
+    self->width_in_tiles = width;
+    self->height_in_tiles = height;
+    self->needs_refresh = false;
+    int mappings_len = width * height;
+    self->tile_mappings = (uint16_t **)m_malloc(mappings_len * sizeof(uint16_t *));
+    uint32_t palette_len = common_hal_displayio_palette_get_len(self->palette);
+    for (int i = 0; i < mappings_len; i++) {
+        self->tile_mappings[i] = (uint16_t *)m_malloc(palette_len * sizeof(uint16_t));
+        for (uint16_t j = 0; j < palette_len; j++) {
+            self->tile_mappings[i][j] = j;
+        }
     }
-  }
 }
 
 uint16_t common_hal_tilepalettemapper_tilepalettemapper_get_width(tilepalettemapper_tilepalettemapper_t *self) {
-  return self->width_in_tiles;
+    return self->width_in_tiles;
 }
 
 uint16_t common_hal_tilepalettemapper_tilepalettemapper_get_height(tilepalettemapper_tilepalettemapper_t *self) {
-  return self->height_in_tiles;
+    return self->height_in_tiles;
 }
 
 mp_obj_t common_hal_tilepalettemapper_tilepalettemapper_get_palette(tilepalettemapper_tilepalettemapper_t *self) {
-  return self->palette;
+    return self->palette;
 }
 
-mp_obj_t common_hal_tilepalettemapper_tilepalettemapper_get_mapping(tilepalettemapper_tilepalettemapper_t *self, uint16_t x, uint16_t y){
-  mp_obj_list_t *list = MP_OBJ_TO_PTR(mp_obj_new_list(0, NULL));
-  uint32_t palette_len = common_hal_displayio_palette_get_len(self->palette);
-  int index = x + y * self->width_in_tiles;
-  for (uint32_t i = 0; i < palette_len; i++) {
-    mp_obj_list_append(list, mp_obj_new_int(self->tile_mappings[index][i]));
-  }
-  return MP_OBJ_FROM_PTR(list);
+mp_obj_t common_hal_tilepalettemapper_tilepalettemapper_get_mapping(tilepalettemapper_tilepalettemapper_t *self, uint16_t x, uint16_t y) {
+    mp_obj_list_t *list = MP_OBJ_TO_PTR(mp_obj_new_list(0, NULL));
+    uint32_t palette_len = common_hal_displayio_palette_get_len(self->palette);
+    int index = x + y * self->width_in_tiles;
+    for (uint32_t i = 0; i < palette_len; i++) {
+        mp_obj_list_append(list, mp_obj_new_int(self->tile_mappings[index][i]));
+    }
+    return MP_OBJ_FROM_PTR(list);
 }
 
 void common_hal_tilepalettemapper_tilepalettemapper_set_mapping(tilepalettemapper_tilepalettemapper_t *self, uint16_t x, uint16_t y, size_t len, mp_obj_t *items) {
 //  size_t len = 0;
 //  mp_obj_t *items;
 //  mp_obj_list_get(mapping, &len, &items);
-  uint32_t palette_len = common_hal_displayio_palette_get_len(self->palette);
-  for (uint16_t i = 0; i < len; i++) {
-    int mapping_val = mp_arg_validate_type_int(items[i], MP_QSTR_mapping_value);
-    mp_arg_validate_int_range(mapping_val, 0, palette_len-1, MP_QSTR_mapping_value);
-    self->tile_mappings[y * self->width_in_tiles + x][i] = mapping_val;
-  }
+    uint32_t palette_len = common_hal_displayio_palette_get_len(self->palette);
+    for (uint16_t i = 0; i < len; i++) {
+        int mapping_val = mp_arg_validate_type_int(items[i], MP_QSTR_mapping_value);
+        mp_arg_validate_int_range(mapping_val, 0, palette_len - 1, MP_QSTR_mapping_value);
+        self->tile_mappings[y * self->width_in_tiles + x][i] = mapping_val;
+    }
+    self->needs_refresh = true;
+}
+
+uint32_t tilepalettemapper_tilepalettemapper_get_color(tilepalettemapper_tilepalettemapper_t *self, uint16_t tile_index, uint32_t palette_index) {
+    uint32_t mapped_index = self->tile_mappings[tile_index][palette_index];
+    return common_hal_displayio_palette_get_color(self->palette, mapped_index);
 }
 
-uint32_t common_hal_tilepalettemapper_tilepalettemapper_get_color(tilepalettemapper_tilepalettemapper_t *self, uint16_t tile_index, uint32_t palette_index){
-  uint32_t mapped_index = self->tile_mappings[tile_index][palette_index];
-  return common_hal_displayio_palette_get_color(self->palette, mapped_index);
-}
+bool tilepalettemapper_tilepalettemapper_needs_refresh(tilepalettemapper_tilepalettemapper_t *self) {
+    return self->needs_refresh;
+}
+
+void tilepalettemapper_tilepalettemapper_finish_refresh(tilepalettemapper_tilepalettemapper_t *self) {
+    self->needs_refresh = false;
+}

shared-module/tilepalettemapper/TilePaletteMapper.h

@@ -13,9 +13,15 @@
 #include "py/obj.h"
 
 typedef struct {
-  mp_obj_base_t base;
-  mp_obj_t palette;
-  uint16_t width_in_tiles;
-  uint16_t height_in_tiles;
-  uint16_t **tile_mappings;
-} tilepalettemapper_tilepalettemapper_t;
+    mp_obj_base_t base;
+    mp_obj_t palette;
+    uint16_t width_in_tiles;
+    uint16_t height_in_tiles;
+    uint16_t **tile_mappings;
+    bool needs_refresh;
+} tilepalettemapper_tilepalettemapper_t;
+
+bool tilepalettemapper_tilepalettemapper_needs_refresh(tilepalettemapper_tilepalettemapper_t *self);
+void tilepalettemapper_tilepalettemapper_finish_refresh(tilepalettemapper_tilepalettemapper_t *self);
+
+uint32_t tilepalettemapper_tilepalettemapper_get_color(tilepalettemapper_tilepalettemapper_t *self, uint16_t tile_index, uint32_t palette_index);