add pictures 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
 #include "GrReducedClip.h"
 #endif
 
 #include "SkCanvas.h"
 #include "SkData.h"
 #include "SkDecodingImageGenerator.h"
 #include "SkDocument.h"
 #include "SkImage.h"
 #include "SkMatrix.h"
 #include "SkPaint.h"
 #include "SkPath.h"
+#include "SkPictureRecorder.h"
 #include "SkPixelRef.h"
 #include "SkRRect.h"
 #include "SkString.h"
 #include "SkSurface.h"
 #include "SkTextBlob.h"
 #include "SkTypeface.h"
 
 extern "C" {
     #include "lua.h"
     #include "lualib.h"
     #include "lauxlib.h"
 }
 
 // return the metatable name for a given class
 template <typename T> const char* get_mtname();
 #define DEF_MTNAME(T)                           \
     template <> const char* get_mtname<T>() {   \
         return #T "_LuaMetaTableName";          \
     }
 
 DEF_MTNAME(SkCanvas)
 DEF_MTNAME(SkDocument)
 DEF_MTNAME(SkImage)
 DEF_MTNAME(SkMatrix)
 DEF_MTNAME(SkRRect)
 DEF_MTNAME(SkPath)
 DEF_MTNAME(SkPaint)
 DEF_MTNAME(SkPathEffect)
+DEF_MTNAME(SkPicture)
+DEF_MTNAME(SkPictureRecorder)
 DEF_MTNAME(SkShader)
 DEF_MTNAME(SkSurface)
 DEF_MTNAME(SkTextBlob)
 DEF_MTNAME(SkTypeface)
 
 template <typename T> T* push_new(lua_State* L) {
     T* addr = (T*)lua_newuserdata(L, sizeof(T));
     new (addr) T;
     luaL_getmetatable(L, get_mtname<T>());
     lua_setmetatable(L, -2);
@@ skipping 442 matching lines @@
     canvas->drawImageRect(image, srcRPtr, dstR, lua2OptionalPaint(L, 5, &paint));
     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);
+    SkScalar x = lua2scalar_def(L, 3, 0);
+    SkScalar y = lua2scalar_def(L, 4, 0);
+    SkMatrix matrix, *matrixPtr = NULL;
+    if (x || y) {
+        matrix.setTranslate(x, y);
+        matrixPtr = &matrix;
+    }
+    SkPaint paint;
+    canvas->drawPicture(picture, matrixPtr, lua2OptionalPaint(L, 5, &paint));
+    return 0;
+}
+
 static int lcanvas_drawText(lua_State* L) {
     if (lua_gettop(L) < 5) {
         return 0;
     }
 
     if (lua_isstring(L, 2) && lua_isnumber(L, 3) && lua_isnumber(L, 4)) {
         size_t len;
         const char* text = lua_tolstring(L, 2, &len);
         get_ref<SkCanvas>(L, 1)->drawText(text, len,
                                           lua2scalar(L, 3), lua2scalar(L, 4),
@@ skipping 107 matching lines @@
 
 const struct luaL_Reg gSkCanvas_Methods[] = {
     { "clear", lcanvas_clear },
     { "drawColor", lcanvas_drawColor },
     { "drawRect", lcanvas_drawRect },
     { "drawOval", lcanvas_drawOval },
     { "drawCircle", lcanvas_drawCircle },
     { "drawImage", lcanvas_drawImage },
     { "drawImageRect", lcanvas_drawImageRect },
     { "drawPath", lcanvas_drawPath },
+    { "drawPicture", lcanvas_drawPicture },
     { "drawText", lcanvas_drawText },
     { "getSaveCount", lcanvas_getSaveCount },
     { "getTotalMatrix", lcanvas_getTotalMatrix },
     { "getClipStack", lcanvas_getClipStack },
 #if SK_SUPPORT_GPU
     { "getReducedClipStack", SkLua::lcanvas_getReducedClipStack },
 #endif
     { "save", lcanvas_save },
     { "restore", lcanvas_restore },
     { "scale", lcanvas_scale },
@@ skipping 810 matching lines @@
         lua_pushnil(L);
     } else {
         push_ref(L, image);
         image->unref();
     }
     return 1;
 }
 
 static int lsurface_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<SkSurface>(L, 1)->newSurface(info);
     if (NULL == surface) {
         lua_pushnil(L);
     } else {
         push_ref(L, surface);
         surface->unref();
     }
     return 1;
 }
 
 static int lsurface_gc(lua_State* L) {
     get_ref<SkSurface>(L, 1)->unref();
     return 0;
 }
 
 static const struct luaL_Reg gSkSurface_Methods[] = {
     { "width", lsurface_width },
     { "height", lsurface_height },
     { "getCanvas", lsurface_getCanvas },
     { "newImageSnapshot", lsurface_newImageSnapshot },
     { "newSurface", lsurface_newSurface },
     { "__gc", lsurface_gc },
     { NULL, NULL }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
+static int lpicturerecorder_beginRecording(lua_State* L) {
+    const SkScalar w = lua2scalar_def(L, 2, -1);
+    const SkScalar h = lua2scalar_def(L, 3, -1);
+    if (w <= 0 || h <= 0) {
+        lua_pushnil(L);
+        return 1;
+    }
+
+    SkCanvas* canvas = get_obj<SkPictureRecorder>(L, 1)->beginRecording(w, h);
+    if (NULL == canvas) {
+        lua_pushnil(L);
+        return 1;
+    }
+
+    push_ref(L, canvas);
+    return 1;
+}
+
+static int lpicturerecorder_getCanvas(lua_State* L) {
+    SkCanvas* canvas = get_obj<SkPictureRecorder>(L, 1)->getRecordingCanvas();
+    if (NULL == canvas) {
+        lua_pushnil(L);
+        return 1;
+    }
+    push_ref(L, canvas);
+    return 1;
+}
+
+static int lpicturerecorder_endRecording(lua_State* L) {
+    SkPicture* pic = get_obj<SkPictureRecorder>(L, 1)->endRecording();
+    if (NULL == pic) {
+        lua_pushnil(L);
+        return 1;
+    }
+    push_ref(L, pic);
+    pic->unref();   // lua is the only owner, so we unref ours
+    return 1;
+}
+
+static int lpicturerecorder_gc(lua_State* L) {
+    get_obj<SkPictureRecorder>(L, 1)->~SkPictureRecorder();
+    return 0;
+}
+
+static const struct luaL_Reg gSkPictureRecorder_Methods[] = {
+    { "beginRecording", lpicturerecorder_beginRecording },
+    { "getCanvas", lpicturerecorder_getCanvas },
+    { "endRecording", lpicturerecorder_endRecording },
+    { "__gc", lpicturerecorder_gc },
+    { NULL, NULL }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+

[robertphillips, 2014/10/13 18:31:59]

float ?

[reed1, 2014/10/13 18:34:37]

the lua function returns the number of arguments it pushed on the stack.

+static int lpicture_width(lua_State* L) {
+    lua_pushnumber(L, get_ref<SkPicture>(L, 1)->cullRect().width());
+    return 1;
+}
+

[robertphillips, 2014/10/13 18:31:59]

float ?

+static int lpicture_height(lua_State* L) {
+    lua_pushnumber(L, get_ref<SkPicture>(L, 1)->cullRect().height());
+    return 1;
+}
+
+static int lpicture_gc(lua_State* L) {
+    get_ref<SkPicture>(L, 1)->unref();
+    return 0;
+}
+
+static const struct luaL_Reg gSkPicture_Methods[] = {
+    { "width", lpicture_width },
+    { "height", lpicture_height },
+    { "__gc", lpicture_gc },
+    { NULL, NULL }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
 static int ltypeface_gc(lua_State* L) {
     SkSafeUnref(get_ref<SkTypeface>(L, 1));
     return 0;
 }
 
 static const struct luaL_Reg gSkTypeface_Methods[] = {
     { "__gc", ltypeface_gc },
     { NULL, NULL }
 };
 
@@ skipping 47 matching lines @@
 static int lsk_newPaint(lua_State* L) {
     push_new<SkPaint>(L);
     return 1;
 }
 
 static int lsk_newPath(lua_State* L) {
     push_new<SkPath>(L);
     return 1;
 }
 
+static int lsk_newPictureRecorder(lua_State* L) {
+    push_new<SkPictureRecorder>(L);
+    return 1;
+}
+
 static int lsk_newRRect(lua_State* L) {
     SkRRect* rr = push_new<SkRRect>(L);
     rr->setEmpty();
     return 1;
 }
 
 static int lsk_newTypeface(lua_State* L) {
     const char* name = NULL;
     int style = SkTypeface::kNormal;
 
@@ skipping 51 matching lines @@
 static void register_Sk(lua_State* L) {
     lua_newtable(L);
     lua_pushvalue(L, -1);
     lua_setglobal(L, "Sk");
     // the Sk table is still on top
 
     setfield_function(L, "newDocumentPDF", lsk_newDocumentPDF);
     setfield_function(L, "loadImage", lsk_loadImage);
     setfield_function(L, "newPaint", lsk_newPaint);
     setfield_function(L, "newPath", lsk_newPath);
+    setfield_function(L, "newPictureRecorder", lsk_newPictureRecorder);
     setfield_function(L, "newRRect", lsk_newRRect);
     setfield_function(L, "newRasterSurface", lsk_newRasterSurface);
     setfield_function(L, "newTypeface", lsk_newTypeface);
     lua_pop(L, 1);  // pop off the Sk table
 }
 
 #define REG_CLASS(L, C)                             \
     do {                                            \
         luaL_newmetatable(L, get_mtname<C>());      \
         lua_pushvalue(L, -1);                       \
         lua_setfield(L, -2, "__index");             \
         luaL_setfuncs(L, g##C##_Methods, 0);        \
         lua_pop(L, 1); /* pop off the meta-table */ \
     } while (0)
 
 void SkLua::Load(lua_State* L) {
     register_Sk(L);
     REG_CLASS(L, SkCanvas);
     REG_CLASS(L, SkDocument);
     REG_CLASS(L, SkImage);
     REG_CLASS(L, SkPaint);
     REG_CLASS(L, SkPath);
     REG_CLASS(L, SkPathEffect);
+    REG_CLASS(L, SkPicture);
+    REG_CLASS(L, SkPictureRecorder);
     REG_CLASS(L, SkRRect);
     REG_CLASS(L, SkShader);
     REG_CLASS(L, SkSurface);
     REG_CLASS(L, SkTypeface);
     REG_CLASS(L, SkMatrix);
 }
 
 extern "C" int luaopen_skia(lua_State* L);
 extern "C" int luaopen_skia(lua_State* L) {
     SkLua::Load(L);
     return 0;
 }