almost there on the api

teensy/luamatrix.cpp

@@ -1,6 +1,7 @@
 #include "luamatrix.h"
 #include "matrix.h"
 #include "lua.hpp"
+#include "log.h"
 
 // CREATE ARRAY TYPE AND EXPOSE matrixpanel TO LUA.
 // metatable method for handling "array[index]"
@@ -20,39 +21,335 @@ static int matrixpanel_newindex (lua_State* L) {
    return 0; 
 } */
 
-static const struct luaL_Reg matrixpanel_metamethods[] = {
+int8_t matrixpanel_userdata = 0; // used just to have some userdata
-//    { "__index",  matrixpanel_index  },
+
-//    { "__newindex",  matrixpanel_newindex  },
+static int matrixpanel_swapbuffer(lua_State *L) {
+    matrixpanel.swapBuffers(true);
+    return 0;
+}
+
+void pushPanel (lua_State *L)
+{
+  int8_t *pi = (int8_t *)lua_newuserdata(L, sizeof(int8_t));
+  *pi = matrixpanel_userdata;
+  luaL_getmetatable(L, "matrixpanel");
+  lua_setmetatable(L, -2);
+}
+
+static int matrixpanel_new (lua_State *L) {
+  pushPanel(L);
+  return 1;
+}
+
+static int matrixpanel_gc (lua_State *L) {
+  output_log("dropped matrixpanel\n");
+  return 0;
+}
+
+static int matrixpanel_tostring (lua_State *L) {
+    lua_pushfstring(L, "matrixpanel string");
+    return 1;
+}
+
+static int matrixpanel_fillscreen (lua_State *L) {
+  int c     = luaL_checkint(L, 1);
+  matrixpanel.fillScreen(c);
+  return 0;
+}
+
+static int matrixpanel_drawpixel (lua_State *L) {
+    return 0;
+}
+
+static int matrixpanel_colorHSV (lua_State *L) {
+  float h     = luaL_checkint(L, 1);
+  float s     = luaL_checkint(L, 2);
+  float v     = luaL_checkint(L, 3);
+  bool  gflag = lua_isboolean(L, 4) ? lua_toboolean(L, 4) : false;
+  lua_pushnumber(L, matrixpanel.ColorHSV(h, s, v, gflag));
+  return 1;
+}
+
+static int matrixpanel_color888 (lua_State *L) {
+  int r     = luaL_checkint(L, 1);
+  int g     = luaL_checkint(L, 2);
+  int b     = luaL_checkint(L, 3);
+  lua_pushnumber(L, matrixpanel.Color888(r, g, b));
+  return 1;
+}
+
+static int matrixpanel_color444 (lua_State *L) {
+  int r     = luaL_checkint(L, 1);
+  int g     = luaL_checkint(L, 2);
+  int b     = luaL_checkint(L, 3);
+  lua_pushnumber(L, matrixpanel.Color444(r, g, b));
+  return 1;
+}
+
+static int matrixpanel_color333 (lua_State *L) {
+  int r     = luaL_checkint(L, 1);
+  int g     = luaL_checkint(L, 2);
+  int b     = luaL_checkint(L, 3);
+  lua_pushnumber(L, matrixpanel.Color333(r, g, b));
+  return 1;
+}
+
+// drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color),
+static int matrixpanel_drawline (lua_State *L) {
+  int x0     = luaL_checkint(L, 1);
+  int y0     = luaL_checkint(L, 2);
+  int x1     = luaL_checkint(L, 3);
+  int y1     = luaL_checkint(L, 4);
+  int c      = luaL_checkint(L, 5);
+  matrixpanel.drawLine(x0, y0, x1, y1, c);
+  return 0;
+}
+// drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color),
+static int matrixpanel_drawfastvline (lua_State *L) {
+  int x     = luaL_checkint(L, 1);
+  int y     = luaL_checkint(L, 2);
+  int h     = luaL_checkint(L, 3);
+  int c     = luaL_checkint(L, 4);
+  matrixpanel.drawFastVLine(x, y, h, c);
+  return 0;
+}
+// drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color),
+static int matrixpanel_drawfasthline (lua_State *L) {
+  int x     = luaL_checkint(L, 1);
+  int y     = luaL_checkint(L, 2);
+  int w     = luaL_checkint(L, 3);
+  int c     = luaL_checkint(L, 4);
+  matrixpanel.drawFastHLine(x, y, w, c);
+  return 0;
+}
+
+// drawRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color),
+static int matrixpanel_drawrect (lua_State *L) {
+  int x     = luaL_checkint(L, 1);
+  int y     = luaL_checkint(L, 2);
+  int w     = luaL_checkint(L, 3);
+  int h     = luaL_checkint(L, 4);
+  int c     = luaL_checkint(L, 5);
+  matrixpanel.drawRect(x, y, w, h, c);
+  return 0;
+}
+// fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color),
+static int matrixpanel_fillrect (lua_State *L) {
+  int x     = luaL_checkint(L, 1);
+  int y     = luaL_checkint(L, 2);
+  int w     = luaL_checkint(L, 3);
+  int h     = luaL_checkint(L, 4);
+  int c     = luaL_checkint(L, 5);
+  matrixpanel.fillRect(x, y, w, h, c);
+  return 0;
+}
+
+// invertDisplay(boolean i);
+static int matrixpanel_invertdisplay (lua_State *L) {
+  bool flag = lua_isboolean(L, 1) ? lua_toboolean(L, 1) : false;
+  matrixpanel.invertDisplay(flag);
+}
+
+//    drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color),
+static int matrixpanel_drawcircle (lua_State *L) {
+  int x     = luaL_checkint(L, 1);
+  int y     = luaL_checkint(L, 2);
+  int r     = luaL_checkint(L, 3);
+  int c     = luaL_checkint(L, 4);
+  matrixpanel.drawCircle(x, y, r, c);
+  return 0;
+}
+//    drawCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername, uint16_t color),
+static int matrixpanel_drawcirclehelper (lua_State *L) {
+  int x     = luaL_checkint(L, 1);
+  int y     = luaL_checkint(L, 2);
+  int r     = luaL_checkint(L, 3);
+  int corner= luaL_checkint(L, 4);
+  int c     = luaL_checkint(L, 5);
+  matrixpanel.drawCircleHelper(x, y, r, corner, c);
+  return 0;
+}
+
+//    fillCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color),
+static int matrixpanel_fillcircle (lua_State *L) {
+  int x     = luaL_checkint(L, 1);
+  int y     = luaL_checkint(L, 2);
+  int r     = luaL_checkint(L, 3);
+  int c     = luaL_checkint(L, 4);
+  matrixpanel.fillCircle(x, y, r, c);
+  return 0;
+}
+
+//    fillCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername, int16_t delta, uint16_t color),
+static int matrixpanel_fillcirclehelper (lua_State *L) {
+  int x     = luaL_checkint(L, 1);
+  int y     = luaL_checkint(L, 2);
+  int r     = luaL_checkint(L, 3);
+  int corner= luaL_checkint(L, 4);
+  int delta = luaL_checkint(L, 5);
+  int c     = luaL_checkint(L, 6);
+  matrixpanel.fillCircleHelper(x, y, r, corner, delta, c);
+  return 0;
+}
+
+//    drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color),
+static int matrixpanel_drawtriangle (lua_State *L) {
+  int x0     = luaL_checkint(L, 1);
+  int y0     = luaL_checkint(L, 2);
+  int x1     = luaL_checkint(L, 3);
+  int y1     = luaL_checkint(L, 4);
+  int x2     = luaL_checkint(L, 5);
+  int y2     = luaL_checkint(L, 6);
+  int c      = luaL_checkint(L, 7);
+  matrixpanel.drawTriangle(x0, y0, x1, y1, x2, y2, c);
+  return 0;
+}
+
+//    fillTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color),
+static int matrixpanel_filltriangle (lua_State *L) {
+  int x0     = luaL_checkint(L, 1);
+  int y0     = luaL_checkint(L, 2);
+  int x1     = luaL_checkint(L, 3);
+  int y1     = luaL_checkint(L, 4);
+  int x2     = luaL_checkint(L, 5);
+  int y2     = luaL_checkint(L, 6);
+  int c      = luaL_checkint(L, 7);
+  matrixpanel.fillTriangle(x0, y0, x1, y1, x2, y2, c);
+  return 0;
+}
+
+//    drawRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h, int16_t radius, uint16_t color),
+static int matrixpanel_drawroundrect (lua_State *L) {
+  int x     = luaL_checkint(L, 1);
+  int y     = luaL_checkint(L, 2);
+  int w     = luaL_checkint(L, 3);
+  int h     = luaL_checkint(L, 4);
+  int r     = luaL_checkint(L, 5);
+  int c     = luaL_checkint(L, 6);
+  matrixpanel.drawRoundRect(x, y, w, h, r, c);
+  return 0;  
+}
+
+//    fillRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h, int16_t radius, uint16_t color),
+static int matrixpanel_fillroundrect (lua_State *L) {
+  int x     = luaL_checkint(L, 1);
+  int y     = luaL_checkint(L, 2);
+  int w     = luaL_checkint(L, 3);
+  int h     = luaL_checkint(L, 4);
+  int r     = luaL_checkint(L, 5);
+  int c     = luaL_checkint(L, 6);
+  matrixpanel.fillRoundRect(x, y, w, h, r, c);
+  return 0;
+}
+
+//    drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color),
+//    drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg),
+//    drawBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h, uint16_t color),
+//    drawBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg),
+//    drawXBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color),
+
+//    drawChar(int16_t x, int16_t y, unsigned char c, uint16_t color, uint16_t bg, uint8_t size),
+static int matrixpanel_drawchar (lua_State *L) {
+  int x     = luaL_checkint(L, 1);
+  int y     = luaL_checkint(L, 2);
+  const char *str = luaL_checkstring(L, 3);
+  int bg    = luaL_checkint(L, 4);
+  int color = luaL_checkint(L, 5);
+  int size  = luaL_checkint(L, 6);
+  matrixpanel.drawChar(x, y, str[0], color, bg, size);
+  return 0;
+}
+
+//    setCursor(int16_t x, int16_t y),
+static int matrixpanel_setcursor (lua_State *L) {
+}
+
+//    setTextColor(uint16_t c),
+//    setTextColor(uint16_t c, uint16_t bg),
+static int matrixpanel_settextcolor (lua_State *L) {
+}
+
+//    setTextSize(uint8_t s),
+static int matrixpanel_settextsize (lua_State *L) {
+}
+
+//    setTextWrap(boolean w),
+static int matrixpanel_settextwrap (lua_State *L) {
+}
+
+//    setRotation(uint8_t r),
+static int matrixpanel_setrotation (lua_State *L) {
+}
+
+//    setFont(const GFXfont *f = NULL),
+static int matrixpanel_setfont (lua_State *L) {
+}
+
+//    getTextBounds(char *string, int16_t x, int16_t y, int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h),
+static int matrixpanel_gettextbounds (lua_State *L) {
+}
+
+static const struct luaL_Reg matrixpanel_methods[] = {
+    { "new", matrixpanel_new },
+    { "swapBuffer", matrixpanel_swapbuffer },
+    { "fillScreen", matrixpanel_fillscreen },
+    { "drawPixel", matrixpanel_drawpixel },
+    { "colorHSV", matrixpanel_colorHSV },
+    { "color888", matrixpanel_color888 },
+    { "color444", matrixpanel_color444 },
+    { "color333", matrixpanel_color333 },
+    { "drawLine", matrixpanel_drawline },
+    { "drawFastVLine", matrixpanel_drawfastvline },
+    { "drawFastHLine", matrixpanel_drawfasthline },
+    { "drawRect", matrixpanel_drawrect },
+    { "fillRect", matrixpanel_fillrect },
+    { "invertScreen", matrixpanel_invertdisplay },
+    { "drawCircle", matrixpanel_drawcircle },
+    { "drawCircleHelper", matrixpanel_drawcirclehelper },
+    { "fillCircle", matrixpanel_fillcircle },
+    { "fillCircleHelper", matrixpanel_fillcirclehelper },
+    { "drawTriangle", matrixpanel_drawtriangle },
+    { "fillTriangle", matrixpanel_filltriangle },
+    { "drawRoundRect", matrixpanel_drawroundrect },
+    { "fillRoundRect", matrixpanel_fillroundrect },
+//    drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color),
+//    drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg),
+//    drawBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h, uint16_t color),
+//    drawBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg),
+//    drawXBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color),
+    { "drawChar", matrixpanel_drawchar },
+    { "setCursor", matrixpanel_setcursor },
+    { "setTextColor", matrixpanel_settextcolor },
+    { "setTextSize", matrixpanel_settextsize },
+    { "setTextWrap", matrixpanel_settextwrap },
+    { "setRotation", matrixpanel_setrotation },
+//    setFont(const GFXfont *f = NULL),
+    { "getTextBounds", matrixpanel_gettextbounds },
     {NULL, NULL}
 };
 
-
+static const struct luaL_Reg matrixpanel_metamethods[] = {
-// create a metatable for our array type
+    { "__gc", matrixpanel_gc },
-static void create_matrixpanel_type(lua_State* L) {
+    { "__tostring", matrixpanel_tostring },
-  luaL_newmetatable(L, "matrixpanel");
+    {NULL, NULL}
-  luaL_setfuncs(L, matrixpanel_metamethods, 0);
+};
-  //lua_setglobal(L, "matrixpanel");
-}
-
-
-// expose an array to lua, by storing it in a userdata with the array metatable
-static int expose_array(lua_State* L) {
-   RGBmatrixPanel **pmatrix = (RGBmatrixPanel **) lua_newuserdata(L, sizeof(RGBmatrixPanel **));
-   *pmatrix = &matrixpanel;
-   luaL_getmetatable(L, "matrixpanel");
-   lua_setmetatable(L, -2);
-   return 1;
-}
-
-// test routine which exposes our test array to Lua 
-static int getmatrixpanel (lua_State* L) { 
-   return expose_array( L );
-}
 
 int luaopen_matrixpanel (lua_State* L) {
-   create_matrixpanel_type(L);
+  lua_newtable(L);
+  luaL_setfuncs(L, matrixpanel_methods, 0);
+  lua_setglobal(L, "matrixpanel");
+    
+  luaL_newmetatable(L, "matrixpanel");        /* create metatable for matrixpanel,
+                                         add it to the Lua registry */
+  luaL_setfuncs(L, matrixpanel_methods, 0);
 
-   // make our test routine available to Lua
+  lua_pushliteral(L, "__index");
-   lua_register(L, "matrixpanel", getmatrixpanel);
+  lua_pushvalue(L, -3);               /* dup methods table*/
-   return 0;
+  lua_rawset(L, -3);                  /* metatable.__index = methods */
+  lua_pushliteral(L, "__metatable");
+  lua_pushvalue(L, -3);               /* dup methods table*/
+  lua_rawset(L, -3);                  /* hide metatable:
+                                         metatable.__metatable = methods */
+  lua_pop(L, 1);                      /* drop metatable */  
+  return 1;
 }