flood fill paint function (#2683)

* flood fill paint function

* increase max paint stack to 4000

* optional paint argument bordercolor

* replace painter stack with queue

* fix janet and wren bindings for paint function

src/api.h

@@ -632,6 +632,18 @@ enum
  tic_mem*, s32 x, s32 y, s32 a, s32 b, u8 color) \
  \
  \
+ macro(paint, \
+ "paint(x y color bordercolor=-1)", \
+ \
+ "This function fills a contiguous area with a new color.\n" \
+ "If bordercolor is given fill will extend to color boundary.", \
+ 4, \
+ 3, \
+ 0, \
+ void, \
+ tic_mem*, s32 x, s32 y, u8 color, u8 bordercolor) \
+ \
+ \
  macro(tri, \
  "tri(x1 y1 x2 y2 x3 y3 color)", \
  \

src/api/janet.c

@@ -66,6 +66,7 @@ static Janet janet_circ(int32_t argc, Janet* argv);
 static Janet janet_circb(int32_t argc, Janet* argv);
 static Janet janet_elli(int32_t argc, Janet* argv);
 static Janet janet_ellib(int32_t argc, Janet* argv);
+static Janet janet_paint(int32_t argc, Janet* argv);
 static Janet janet_tri(int32_t argc, Janet* argv);
 static Janet janet_trib(int32_t argc, Janet* argv);
 static Janet janet_ttri(int32_t argc, Janet* argv);
@@ -130,6 +131,7 @@ static const JanetReg janet_c_functions[] =
  {"circb", janet_circb, NULL},
  {"elli", janet_elli, NULL},
  {"ellib", janet_ellib, NULL},
+ {"paint", janet_paint, NULL},
  {"tri", janet_tri, NULL},
  {"trib", janet_trib, NULL},
  {"ttri", janet_ttri, NULL},
@@ -833,6 +835,20 @@ static Janet janet_ellib(int32_t argc, Janet* argv)
  return janet_wrap_nil();
 }
 
+static Janet janet_paint(int32_t argc, Janet* argv)
+{
+ janet_arity(argc, 3, 4);
+
+ s32 x = janet_getinteger(argv, 0);
+ s32 y = janet_getinteger(argv, 1);
+ u8 color = janet_getinteger(argv, 2);
+ u8 bordercolor = janet_optnumber(argv, argc, 3, 255);
+
+ tic_core* core = getJanetMachine(); tic_mem* tic = (tic_mem*)core;
+ core->api.paint(tic, x, y, color, bordercolor);
+ return janet_wrap_nil();
+}
+
 static Janet janet_tri(int32_t argc, Janet* argv)
 {
  janet_fixarity(argc, 7);

src/api/js.c

@@ -769,6 +769,20 @@ static JSValue js_ellib(JSContext *ctx, JSValueConst this_val, s32 argc, JSValue
  return JS_UNDEFINED;
 }
 
+static JSValue js_paint(JSContext *ctx, JSValueConst this_val, s32 argc, JSValueConst *argv)
+{
+ s32 x = getInteger(ctx, argv[0]);
+ s32 y = getInteger(ctx, argv[1]);
+ s32 color = getInteger(ctx, argv[2]);
+ s32 bordercolor = getInteger2(ctx, argv[3], -1);
+
+ tic_core* core = getCore(ctx); tic_mem* tic = (tic_mem*)core;
+
+ core->api.paint(tic, x, y, color, bordercolor);
+
+ return JS_UNDEFINED;
+}
+
 static JSValue js_tri(JSContext *ctx, JSValueConst this_val, s32 argc, JSValueConst *argv)
 {
  float pt[6];

src/api/luaapi.c

@@ -209,6 +209,27 @@ static s32 lua_cls(lua_State* lua)
  return 0;
 }
 
+static s32 lua_paint(lua_State* lua)
+{
+ s32 top = lua_gettop(lua);
+
+ if(top >= 3 && top <= 4)
+ {
+ s32 x = getLuaNumber(lua, 1);
+ s32 y = getLuaNumber(lua, 2);
+ s32 color = getLuaNumber(lua, 3);
+ s32 bordercolor = top >= 4 ? getLuaNumber(lua, 4) : -1;
+
+ tic_core* core = getLuaCore(lua);
+ tic_mem* tic = (tic_mem*)core;
+
+ core->api.paint(tic, x, y, color, bordercolor);
+ }
+ else luaL_error(lua, "invalid parameters, paint(x y color [bordercolor])\n");
+
+ return 0;
+}
+
 static s32 lua_pix(lua_State* lua)
 {
  s32 top = lua_gettop(lua);

src/api/mruby.c

@@ -270,6 +270,19 @@ static mrb_value mrb_ellib(mrb_state* mrb, mrb_value self)
  return mrb_nil_value();
 }
 
+static mrb_value mrb_paint(mrb_state* mrb, mrb_value self)
+{
+ mrb_int x, y, color;
+ mrb_int bordercolor = -1;
+ mrb_get_args(mrb, "iii|i", &x, &y, &color, &bordercolor);
+
+ tic_core* core = getMRubyMachine(mrb); tic_mem* tic = (tic_mem*)core;
+
+ core->api.paint(tic, x, y, color, bordercolor);
+
+ return mrb_nil_value();
+}
+
 static mrb_value mrb_tri(mrb_state* mrb, mrb_value self)
 {
  mrb_float x1, y1, x2, y2, x3, y3;

src/api/python.c

@@ -235,6 +235,25 @@ static int py_ellib(pkpy_vm* vm)
  return 0;
 }
 
+static int py_paint(pkpy_vm* vm)
+{
+ int x;
+ int y;
+ int color;
+ int bordercolor;
+
+ pkpy_to_int(vm, 0, &x);
+ pkpy_to_int(vm, 1, &y);
+ pkpy_to_int(vm, 2, &color);
+ pkpy_to_int(vm, 3, &bordercolor);
+ tic_core* core; get_core(vm, &core); tic_mem* tic = (tic_mem*)core;
+ if(pkpy_check_error(vm))
+ return 0;
+
+ core->api.paint(tic, x, y, color, bordercolor);
+ return 0;
+}
+
 static int py_clip(pkpy_vm* vm)
 {
 
@@ -1250,6 +1269,9 @@ static bool setup_c_bindings(pkpy_vm* vm) {
  pkpy_push_function(vm, "music(track=-1, frame=-1, row=-1, loop=True, sustain=False, tempo=-1, speed=-1)", py_music);
  pkpy_setglobal_2(vm, "music");
 
+ pkpy_push_function(vm, "paint(x: int, y: int, color: int, bordercolor=-1)", py_paint);
+ pkpy_setglobal_2(vm, "paint");
+
  pkpy_push_function(vm, "peek(addr: int, bits=8) -> int", py_peek);
  pkpy_setglobal_2(vm, "peek");
  pkpy_push_function(vm, "peek1(addr: int) -> int", py_peek1);

src/api/scheme.c

@@ -569,6 +569,18 @@ s7_pointer scheme_ellib(s7_scheme* sc, s7_pointer args)
  core->api.ellib(tic, x, y, a, b, color);
  return s7_nil(sc);
 }
+s7_pointer scheme_paint(s7_scheme* sc, s7_pointer args)
+{
+ // paint(x y color bordercolor=-1)
+ const int argn = s7_list_length(sc, args);
+ tic_core* core = getSchemeCore(sc); tic_mem* tic = (tic_mem*)core;
+ const s32 x = s7_integer(s7_car(args));
+ const s32 y = s7_integer(s7_cadr(args));
+ const s32 color = s7_integer(s7_caddr(args));
+ const s32 bordercolor = argn >= 4 ? s7_integer(s7_cadddr(args)) : -1;
+ core->api.paint(tic, x, y, color, bordercolor);
+ return s7_nil(sc);
+}
 s7_pointer scheme_tri(s7_scheme* sc, s7_pointer args)
 {
  // tri(x1 y1 x2 y2 x3 y3 color)

src/api/squirrel.c

@@ -423,6 +423,26 @@ static SQInteger squirrel_ellib(HSQUIRRELVM vm)
  return 0;
 }
 
+static SQInteger squirrel_paint(HSQUIRRELVM vm)
+{
+ SQInteger top = sq_gettop(vm);
+
+ if(top >= 4 && top <= 5)
+ {
+ s32 x = getSquirrelNumber(vm, 2);
+ s32 y = getSquirrelNumber(vm, 3);
+ s32 color = getSquirrelNumber(vm, 4);
+ s32 bordercolor = top >= 5 ? getSquirrelNumber(vm, 5) : -1;
+
+ tic_core* core = getSquirrelCore(vm); tic_mem* tic = (tic_mem*)core;
+
+ core->api.paint(tic, x, y, color, bordercolor);
+ }
+ else return sq_throwerror(vm, "invalid parameters, paint(x,y,color,[bordercolor=-1])\n");
+
+ return 0;
+}
+
 static SQInteger squirrel_tri(HSQUIRRELVM vm)
 {
  SQInteger top = sq_gettop(vm);

src/api/wasm.c

@@ -223,6 +223,19 @@ m3ApiRawFunction(wasmtic_ellib)
  m3ApiSuccess();
 }
 
+m3ApiRawFunction(wasmtic_paint)
+{
+ m3ApiGetArg (int32_t, x)
+ m3ApiGetArg (int32_t, y)
+ m3ApiGetArg (int8_t, color)
+ m3ApiGetArg (int8_t, bordercolor)
+
+ tic_core* core = getWasmCore(runtime); tic_mem* tic = (tic_mem*)core;
+ core->api.paint(tic, x, y, color, bordercolor);
+
+ m3ApiSuccess();
+}
+
 m3ApiRawFunction(wasmtic_rect)
 {
  m3ApiGetArg (int32_t, x)

src/api/wren.c

@@ -98,6 +98,8 @@ class TIC {\n\
  foreign static circb(x, y, radius, color)\n\
  foreign static elli(x, y, a, b, color)\n\
  foreign static ellib(x, y, a, b, color)\n\
+ foreign static paint(x, y, color)\n\
+ foreign static paint(x, y, color, bordercolor)\n\
  foreign static rect(x, y, w, h, color)\n\
  foreign static rectb(x, y, w, h, color)\n\
  foreign static tri(x1, y1, x2, y2, x3, y3, color)\n\
@@ -977,6 +979,19 @@ static void wren_ellib(WrenVM* vm)
  core->api.ellib(tic, x, y, a, b, color);
 }
 
+static void wren_paint(WrenVM* vm)
+{
+ s32 top = wrenGetSlotCount(vm);
+ s32 x = getWrenNumber(vm, 1);
+ s32 y = getWrenNumber(vm, 2);
+ s32 color = getWrenNumber(vm, 3);
+ s32 bordercolor = top > 4 ? getWrenNumber(vm, 4) : -1;
+
+ tic_core* core = getWrenCore(vm); tic_mem* tic = (tic_mem*)core;
+
+ core->api.paint(tic, x, y, color, bordercolor);
+}
+
 static void wren_rect(WrenVM* vm)
 {
  s32 x = getWrenNumber(vm, 1);
@@ -1548,6 +1563,8 @@ static WrenForeignMethodFn foreignTicMethods(const char* signature)
  if (strcmp(signature, "static TIC.circb(_,_,_,_)" ) == 0) return wren_circb;
  if (strcmp(signature, "static TIC.elli(_,_,_,_,_)" ) == 0) return wren_elli;
  if (strcmp(signature, "static TIC.ellib(_,_,_,_,_)" ) == 0) return wren_ellib;
+ if (strcmp(signature, "static TIC.paint(_,_,_)" ) == 0) return wren_paint;
+ if (strcmp(signature, "static TIC.paint(_,_,_,_)" ) == 0) return wren_paint;
  if (strcmp(signature, "static TIC.rect(_,_,_,_,_)" ) == 0) return wren_rect;
  if (strcmp(signature, "static TIC.rectb(_,_,_,_,_)" ) == 0) return wren_rectb;
  if (strcmp(signature, "static TIC.tri(_,_,_,_,_,_,_)" ) == 0) return wren_tri;

src/core/draw.c

@@ -80,7 +80,7 @@ static inline void setPixelFast(tic_core* core, s32 x, s32 y, u8 color)
  tic_api_poke4((tic_mem*)core, y * TIC80_WIDTH + x, color);
 }
 
-static u8 getPixel(tic_core* core, s32 x, s32 y)
+static inline u8 getPixel(tic_core* core, s32 x, s32 y)
 {
  return x < 0 || y < 0 || x >= TIC80_WIDTH || y >= TIC80_HEIGHT
  ? 0
@@ -613,6 +613,96 @@ static void drawLine(tic_mem* tic, float x0, float y0, float x1, float y1, u8 co
  setPixel((tic_core*)tic, x1, y1, color);
 }
 
+// Queue frame for floodFill.
+// Filled horizontal segment of scanline y for xl <= x <= xr.
+// Parent segment was on line y – dy. dy = 1 or –1.
+typedef struct
+{
+ s32 y;
+ s32 xl;
+ s32 xr;
+ s32 dy;
+} FillSegment;
+
+#define FILLQUEUESIZE 400
+static struct
+{
+ FillSegment seg[FILLQUEUESIZE];
+ size_t ini; // index of empty next in
+ size_t outi; // index of next out
+} fillQueue;
+
+static inline void fillEnqueue(tic_core* tic, s32 y, s32 xl, s32 xr, s32 dy)
+{
+ size_t nextini = (fillQueue.ini + 1) % FILLQUEUESIZE;
+ if (nextini == fillQueue.outi)
+ return; // queue full
+ if (y + dy < tic->state.clip.t || y + dy >= tic->state.clip.b)
+ return;
+ FillSegment* qseg = &fillQueue.seg[fillQueue.ini];
+ qseg->y = y;
+ qseg->xl = xl;
+ qseg->xr = xr;
+ qseg->dy = dy;
+ fillQueue.ini = nextini;
+}
+
+static inline bool fillDequeue(s32* y, s32* xl, s32* xr, s32* dy)
+{
+ if (fillQueue.ini == fillQueue.outi)
+ return false; // queue empty
+ FillSegment* qseg = &fillQueue.seg[fillQueue.outi];
+ *y = qseg->y + qseg->dy;
+ *xl = qseg->xl;
+ *xr = qseg->xr;
+ *dy = qseg->dy;
+ fillQueue.outi = (fillQueue.outi + 1) % FILLQUEUESIZE;
+ return true;
+}
+
+static inline bool floodFillInside(u8 pix, u8 paint, u8 border, u8 original)
+{
+ return border == 255 ? pix == original : pix != paint && pix != border;
+}
+
+// "A Seed Fill Algorithm", Paul S. Heckbert, Graphics Gems, Andrew Glassner
+// https://github.com/erich666/GraphicsGems/blob/master/gems/SeedFill.c
+static void floodFill(tic_core* tic, s32 x, s32 y, u8 color, u8 border)
+{
+ if (x < tic->state.clip.l || y < tic->state.clip.t || x >= tic->state.clip.r || y >= tic->state.clip.b)
+ return;
+ u8 ov = getPixel(tic, x, y);
+ if (ov == color || ov == border)
+ return;
+ fillQueue.ini = fillQueue.outi = 0;
+ fillEnqueue(tic, y, x, x, 1); // needed in some cases
+ fillEnqueue(tic, y + 1, x, x, -1); // seed segment
+ s32 l, x1, x2, dy;
+ while (fillDequeue(&y, &x1, &x2, &dy))
+ {
+ // segment of scan line y-dy for x1<=x<=x2 was previously filled,
+ // now explore adjacent pixels in scan line y
+ for (x = x1; x >= tic->state.clip.l && floodFillInside(getPixel(tic, x, y), color, border, ov); x--)
+ setPixelFast(tic, x, y, color);
+ if (x >= x1)
+ goto floodFill_skip;
+ l = x + 1;
+ if (l < x1)
+ fillEnqueue(tic, y, l, x1 - 1, -dy); // check leak left
+ x = x1 + 1;
+ do {
+ for (; x < tic->state.clip.r && floodFillInside(getPixel(tic, x, y), color, border, ov); x++)
+ setPixelFast(tic, x, y, color);
+ fillEnqueue(tic, y, l, x - 1, dy);
+ if (x > x2 + 1)
+ fillEnqueue(tic, y, x2 + 1, x - 1, -dy); // check leak right
+floodFill_skip:
+ for (x++; x <= x2 && !floodFillInside(getPixel(tic, x, y), color, border, ov); x++);
+ l = x;
+ } while (x <= x2);
+ }
+}
+
 typedef union
 {
  struct
@@ -916,6 +1006,12 @@ void tic_api_line(tic_mem* memory, float x0, float y0, float x1, float y1, u8 co
  drawLine(memory, x0, y0, x1, y1, mapColor(memory, color));
 }
 
+void tic_api_paint(tic_mem* memory, s32 x, s32 y, u8 color, u8 bordercolor)
+{
+ bordercolor = bordercolor == 255 ? 255 : mapColor(memory, bordercolor);
+ floodFill((tic_core*)memory, x, y, mapColor(memory, color), bordercolor);
+}
+
 #if defined(BUILD_DEPRECATED)
 #include "draw_dep.c"
 #endif