add patch and clicktracking to lua

src/utils/SkLua.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkLua.h"
 
 #if SK_SUPPORT_GPU
@@ skipping 145 matching lines @@
 static void setfield_scalar(lua_State* L, const char key[], SkScalar value) {
     setfield_number(L, key, SkScalarToLua(value));
 }
 
 static void setfield_function(lua_State* L,
                               const char key[], lua_CFunction value) {
     lua_pushcfunction(L, value);
     lua_setfield(L, -2, key);
 }
 
+static int lua2int_def(lua_State* L, int index, int defaultValue) {
+    if (lua_isnumber(L, index)) {
+        return (int)lua_tonumber(L, index);
+    } else {
+        return defaultValue;
+    }
+}
+
+static SkScalar lua2scalar(lua_State* L, int index) {
+    SkASSERT(lua_isnumber(L, index));
+    return SkLuaToScalar(lua_tonumber(L, index));
+}
+
+static SkScalar lua2scalar_def(lua_State* L, int index, SkScalar defaultValue) {
+    if (lua_isnumber(L, index)) {
+        return SkLuaToScalar(lua_tonumber(L, index));
+    } else {
+        return defaultValue;
+    }
+}
+
+static SkScalar getarray_scalar(lua_State* L, int stackIndex, int arrayIndex) {
+    SkASSERT(lua_istable(L, stackIndex));
+    lua_rawgeti(L, stackIndex, arrayIndex);
+    
+    SkScalar value = lua2scalar(L, -1);
+    lua_pop(L, 1);
+    return value;
+}
+
+static void getarray_scalars(lua_State* L, int stackIndex, SkScalar dst[], int count) {
+    for (int i = 0; i < count; ++i) {
+        dst[i] = getarray_scalar(L, stackIndex, i + 1);
+    }
+}
+
+static void getarray_points(lua_State* L, int stackIndex, SkPoint pts[], int count) {
+    getarray_scalars(L, stackIndex, &pts[0].fX, count * 2);
+}
+
 static void setarray_number(lua_State* L, int index, double value) {
     lua_pushnumber(L, value);
     lua_rawseti(L, -2, index);
 }
 
 static void setarray_scalar(lua_State* L, int index, SkScalar value) {
     setarray_number(L, index, SkScalarToLua(value));
 }
 
 void SkLua::pushBool(bool value, const char key[]) {
@@ skipping 177 matching lines @@
     }
     this->pushString(region_op(element.getOp()), "op");
     this->pushBool(element.isAA(), "aa");
     CHECK_SETFIELD(key);
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
-static int lua2int_def(lua_State* L, int index, int defaultValue) {
-    if (lua_isnumber(L, index)) {
-        return (int)lua_tonumber(L, index);
-    } else {
-        return defaultValue;
-    }
-}
-
-static SkScalar lua2scalar(lua_State* L, int index) {
-    SkASSERT(lua_isnumber(L, index));
-    return SkLuaToScalar(lua_tonumber(L, index));
-}
-
-static SkScalar lua2scalar_def(lua_State* L, int index, SkScalar defaultValue) {
-    if (lua_isnumber(L, index)) {
-        return SkLuaToScalar(lua_tonumber(L, index));
-    } else {
-        return defaultValue;
-    }
-}
-
 static SkScalar getfield_scalar(lua_State* L, int index, const char key[]) {
     SkASSERT(lua_istable(L, index));
     lua_pushstring(L, key);
     lua_gettable(L, index);
-
+    
     SkScalar value = lua2scalar(L, -1);
     lua_pop(L, 1);
     return value;
 }
 
 static SkScalar getfield_scalar_default(lua_State* L, int index, const char key[], SkScalar def) {
     SkASSERT(lua_istable(L, index));
     lua_pushstring(L, key);
     lua_gettable(L, index);
 
@@ skipping 46 matching lines @@
     return 0;
 }
 
 static int lcanvas_drawPaint(lua_State* L) {
     get_ref<SkCanvas>(L, 1)->drawPaint(*get_obj<SkPaint>(L, 2));
     return 0;
 }
 
 static int lcanvas_drawRect(lua_State* L) {
     SkRect rect;
-    get_ref<SkCanvas>(L, 1)->drawRect(*lua2rect(L, 2, &rect),
-                                      *get_obj<SkPaint>(L, 3));
+    lua2rect(L, 2, &rect);
+    const SkPaint* paint = get_obj<SkPaint>(L, 3);
+    get_ref<SkCanvas>(L, 1)->drawRect(rect, *paint);
     return 0;
 }
 
 static int lcanvas_drawOval(lua_State* L) {
     SkRect rect;
     get_ref<SkCanvas>(L, 1)->drawOval(*lua2rect(L, 2, &rect),
                                       *get_obj<SkPaint>(L, 3));
     return 0;
 }
 
@@ skipping 44 matching lines @@
     SkRect* srcRPtr = NULL;
     if (!lua_isnil(L, 3)) {
         srcRPtr = lua2rect(L, 3, &srcR);
     }
     lua2rect(L, 4, &dstR);
     
     SkPaint paint;
     canvas->drawImageRect(image, srcRPtr, dstR, lua2OptionalPaint(L, 5, &paint));
     return 0;
 }
 

[robertphillips, 2014/11/07 18:02:54]

needed ?

[reed1, 2014/11/07 18:12:15]

Done.

+//void drawPatch(const SkPoint cubics[12], const SkColor colors[4],
+//               const SkPoint texCoords[4], SkXfermode* xmode, const SkPaint& paint);
+
+static int lcanvas_drawPatch(lua_State* L) {
+    SkPoint cubics[12];
+    SkColor colorStorage[4];
+    SkPoint texStorage[4];
+
+    const SkColor* colors = NULL;
+    const SkPoint* texs = NULL;
+
+    getarray_points(L, 2, cubics, 12);
+
+    colorStorage[0] = SK_ColorRED;
+    colorStorage[1] = SK_ColorGREEN;
+    colorStorage[2] = SK_ColorBLUE;
+    colorStorage[3] = SK_ColorGRAY;
+
+    if (lua_isnil(L, 4)) {
+        colors = colorStorage;
+    } else {
+        getarray_points(L, 4, texStorage, 4);
+        texs = texStorage;
+    }
+
+    get_ref<SkCanvas>(L, 1)->drawPatch(cubics, colors, texs, NULL, *get_obj<SkPaint>(L, 5));
+    return 0;
+}
+
 static int lcanvas_drawPath(lua_State* L) {
     get_ref<SkCanvas>(L, 1)->drawPath(*get_obj<SkPath>(L, 2),
                                       *get_obj<SkPaint>(L, 3));
     return 0;
 }
 
 // drawPicture(pic, x, y, paint)
 static int lcanvas_drawPicture(lua_State* L) {
     SkCanvas* canvas = get_ref<SkCanvas>(L, 1);
     SkPicture* picture = get_ref<SkPicture>(L, 2);
@@ skipping 123 matching lines @@
     return 0;
 }
 
 static int lcanvas_concat(lua_State* L) {
     get_ref<SkCanvas>(L, 1)->concat(*get_obj<SkMatrix>(L, 2));
     return 0;
 }
 
 static int lcanvas_newSurface(lua_State* L) {
     int width = lua2int_def(L, 2, 0);
-    int height = lua2int_def(L, 2, 0);
+    int height = lua2int_def(L, 3, 0);
     SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
     SkSurface* surface = get_ref<SkCanvas>(L, 1)->newSurface(info);
     if (NULL == surface) {
         lua_pushnil(L);
     } else {
         push_ref(L, surface)->unref();
     }
     return 1;
 }
 
 static int lcanvas_gc(lua_State* L) {
     get_ref<SkCanvas>(L, 1)->unref();
     return 0;
 }
 
 const struct luaL_Reg gSkCanvas_Methods[] = {
     { "clear", lcanvas_clear },
     { "drawColor", lcanvas_drawColor },
     { "drawPaint", lcanvas_drawPaint },
     { "drawRect", lcanvas_drawRect },
     { "drawOval", lcanvas_drawOval },
     { "drawCircle", lcanvas_drawCircle },
     { "drawImage", lcanvas_drawImage },
     { "drawImageRect", lcanvas_drawImageRect },
+    { "drawPatch", lcanvas_drawPatch },
     { "drawPath", lcanvas_drawPath },
     { "drawPicture", lcanvas_drawPicture },
     { "drawText", lcanvas_drawText },
     { "drawTextBlob", lcanvas_drawTextBlob },
     { "getSaveCount", lcanvas_getSaveCount },
     { "getTotalMatrix", lcanvas_getTotalMatrix },
     { "getClipStack", lcanvas_getClipStack },
 #if SK_SUPPORT_GPU
     { "getReducedClipStack", SkLua::lcanvas_getReducedClipStack },
 #endif
@@ skipping 174 matching lines @@
 static int lpaint_setTypeface(lua_State* L) {
     get_obj<SkPaint>(L, 1)->setTypeface(get_ref<SkTypeface>(L, 2));
     return 0;
 }
 
 static int lpaint_getHinting(lua_State* L) {
     SkLua(L).pushU32(get_obj<SkPaint>(L, 1)->getHinting());
     return 1;
 }
 
+static int lpaint_getFilterLevel(lua_State* L) {
+    SkLua(L).pushU32(get_obj<SkPaint>(L, 1)->getFilterLevel());
+    return 1;
+}
+
+static int lpaint_setFilterLevel(lua_State* L) {
+    int level = lua2int_def(L, 2, -1);
+    if (level >= 0 && level <= 3) {
+        get_obj<SkPaint>(L, 1)->setFilterLevel((SkPaint::FilterLevel)level);
+    }
+    return 0;
+}
+
 static int lpaint_getFontID(lua_State* L) {
     SkTypeface* face = get_obj<SkPaint>(L, 1)->getTypeface();
     SkLua(L).pushU32(SkTypeface::UniqueID(face));
     return 1;
 }
 
 static const struct {
     const char*     fLabel;
     SkPaint::Align  fAlign;
 } gAlignRec[] = {
@@ skipping 171 matching lines @@
 static int lpaint_gc(lua_State* L) {
     get_obj<SkPaint>(L, 1)->~SkPaint();
     return 0;
 }
 
 static const struct luaL_Reg gSkPaint_Methods[] = {
     { "isAntiAlias", lpaint_isAntiAlias },
     { "setAntiAlias", lpaint_setAntiAlias },
     { "isDither", lpaint_isDither },
     { "setDither", lpaint_setDither },
+    { "getFilterLevel", lpaint_getFilterLevel },
+    { "setFilterLevel", lpaint_setFilterLevel },
     { "isUnderlineText", lpaint_isUnderlineText },
     { "isStrikeThruText", lpaint_isStrikeThruText },
     { "isFakeBoldText", lpaint_isFakeBoldText },
     { "isLinearText", lpaint_isLinearText },
     { "isSubpixelText", lpaint_isSubpixelText },
     { "setSubpixelText", lpaint_setSubpixelText },
     { "isDevKernText", lpaint_isDevKernText },
     { "isLCDRenderText", lpaint_isLCDRenderText },
     { "setLCDRenderText", lpaint_setLCDRenderText },
     { "isEmbeddedBitmapText", lpaint_isEmbeddedBitmapText },
@@ skipping 187 matching lines @@
 static int lmatrix_getTranslateX(lua_State* L) {
     lua_pushnumber(L, get_obj<SkMatrix>(L,1)->getTranslateX());
     return 1;
 }
 
 static int lmatrix_getTranslateY(lua_State* L) {
     lua_pushnumber(L, get_obj<SkMatrix>(L,1)->getTranslateY());
     return 1;
 }
 
+static int lmatrix_invert(lua_State* L) {
+    lua_pushboolean(L, get_obj<SkMatrix>(L, 1)->invert(get_obj<SkMatrix>(L, 2)));
+    return 1;
+}
+
+static int lmatrix_mapXY(lua_State* L) {
+    SkPoint pt = { lua2scalar(L, 2), lua2scalar(L, 3) };
+    get_obj<SkMatrix>(L, 1)->mapPoints(&pt, &pt, 1);
+    lua_pushnumber(L, pt.x());
+    lua_pushnumber(L, pt.y());
+    return 2;
+}
+
 static int lmatrix_setRectToRect(lua_State* L) {
     SkMatrix* matrix = get_obj<SkMatrix>(L, 1);
     SkRect srcR, dstR;
     lua2rect(L, 2, &srcR);
     lua2rect(L, 3, &dstR);
     const char* scaleToFitStr = lua_tostring(L, 4);
     SkMatrix::ScaleToFit scaleToFit = SkMatrix::kFill_ScaleToFit;
 
     if (scaleToFitStr) {
         const struct {
@@ skipping 18 matching lines @@
     return 0;
 }
 
 static const struct luaL_Reg gSkMatrix_Methods[] = {
     { "getType", lmatrix_getType },
     { "getScaleX", lmatrix_getScaleX },
     { "getScaleY", lmatrix_getScaleY },
     { "getTranslateX", lmatrix_getTranslateX },
     { "getTranslateY", lmatrix_getTranslateY },
     { "setRectToRect", lmatrix_setRectToRect },
+    { "invert", lmatrix_invert },
+    { "mapXY", lmatrix_mapXY },
     { NULL, NULL }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static int lpath_getBounds(lua_State* L) {
     SkLua(L).pushRect(get_obj<SkPath>(L, 1)->getBounds());
     return 1;
 }
 
@@ skipping 226 matching lines @@
 static int limage_width(lua_State* L) {
     lua_pushinteger(L, get_ref<SkImage>(L, 1)->width());
     return 1;
 }
 
 static int limage_height(lua_State* L) {
     lua_pushinteger(L, get_ref<SkImage>(L, 1)->height());
     return 1;
 }
 
+static int limage_newShader(lua_State* L) {
+    SkShader::TileMode tmode = SkShader::kClamp_TileMode;
+    const SkMatrix* localM = NULL;
+    SkAutoTUnref<SkShader> shader(get_ref<SkImage>(L, 1)->newShader(tmode, tmode, localM));
+    push_ref(L, shader.get());
+    return 1;
+}
+
 static int limage_gc(lua_State* L) {
     get_ref<SkImage>(L, 1)->unref();
     return 0;
 }
 
 static const struct luaL_Reg gSkImage_Methods[] = {
     { "width", limage_width },
     { "height", limage_height },
+    { "newShader", limage_newShader },
     { "__gc", limage_gc },
     { NULL, NULL }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static int lsurface_width(lua_State* L) {
     lua_pushinteger(L, get_ref<SkSurface>(L, 1)->width());
     return 1;
 }
@@ skipping 398 matching lines @@
     REG_CLASS(L, SkSurface);
     REG_CLASS(L, SkTextBlob);
     REG_CLASS(L, SkTypeface);
 }
 
 extern "C" int luaopen_skia(lua_State* L);
 extern "C" int luaopen_skia(lua_State* L) {
     SkLua::Load(L);
     return 0;
 }