Allow color mapping in drawDCI

[FeralFox]

Describe
The Poco render.drawDCI command current allows to draw a PebbleDrawCommandImage at a certain position. A good addition would be if it would be possible to map the colors of the image to be drawn.

Why do you think this feature would be useful?
I want to draw complex shapes and change their color dynamically. To draw those shapes, I create an SVG and convert them to pdc files. At the moment, I have to add each shape in each color. But it would be way easier and less resource intensive, if I could just have one shape with a specific color (e.g. #ff0000) and change this color dynamically to any other color.

Describe alternatives you've considered
I tried to create a TTF font from the SVGs to be able to dynamically colorize, however, I got another issue there which is documented here #1631

[phoddie]

Nice idea. I've never done color mapping of DCI images. It sounds like you have? Maybe you could explain how that works in C on Pebble OS.

[FeralFox]

Unfortunately this is just what I understood from a gentlemen answering my question I have originally posted in the repebble forum who said this is definitely possible with C.

There is this proposal I got from Google for an implementation in C, maybe someone with knowledge can judge if it makes sense :)

static GDrawCommandImage *s_command_image;

static void init() {
  s_command_image = gdraw_command_image_create_with_resource(RESOURCE_ID_MY_PDC_IMAGE);
}

void remap_pdc_color(GDrawCommandImage *image, GColor color_to_replace, GColor replace_with_color) {
  if (image == NULL) return;

  GDrawCommandList *cmd_list = gdraw_command_image_get_command_list(image);
  
  uint32_t num_commands = gdraw_command_list_get_num_commands(cmd_list);

  for (uint32_t i = 0; i < num_commands; i++) {
    GDrawCommand *cmd = gdraw_command_list_get_command(cmd_list, i);

    if (gcolor_equal(gdraw_command_get_stroke_color(cmd), color_to_replace)) {
      gdraw_command_set_stroke_color(cmd, replace_with_color);
    }

    if (gcolor_equal(gdraw_command_get_fill_color(cmd), color_to_replace)) {
      gdraw_command_set_fill_color(cmd, replace_with_color);
    }
  }
}

static void canvas_update_proc(Layer *layer, GContext *ctx) {
  remap_pdc_color(s_command_image, GColorRed, GColorGreen);  // better to do that in init

  GPoint origin = GPoint(10, 10);
  gdraw_command_image_draw(ctx, s_command_image, origin);
}

static void deinit() {
  gdraw_command_image_destroy(s_command_image);
}

Proposed solution in Alloy could be

render.drawDCI(dci, 0, 0, {"#ff0000": "#00ff00"});

However, given the C code above it might be better for performance reasons to have a separate function to manipulate the dci once and then re-use it

[phoddie]

Thanks for the notes. Even if they come from an LLM, they give a starting point.

Alloy already has an API to clone a DCI and APIs to modify a DCI (rotate and scale). To support color changes, I think the right answer would be to follow that structure, by adding an API to change the colors on a DCI. As I recall, some places in Pebble tint (lighten, darken, redden, etc) or invert the colors of a DCI. So, we want something more than a simple color replace.

[FeralFox]

True, I think the use-case would fit perfectly to the current interface of manipulating the DCI, so that would be definitely better than the interface proposed by me above