create and modify matrices in 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 609 matching lines @@
     get_ref<SkCanvas>(L, 1)->translate(tx, ty);
     return 0;
 }
 
 static int lcanvas_rotate(lua_State* L) {
     SkScalar degrees = lua2scalar_def(L, 2, 0);
     get_ref<SkCanvas>(L, 1)->rotate(degrees);
     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);
     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);
         surface->unref();
@@ skipping 21 matching lines @@
     { "getTotalMatrix", lcanvas_getTotalMatrix },
     { "getClipStack", lcanvas_getClipStack },
 #if SK_SUPPORT_GPU
     { "getReducedClipStack", SkLua::lcanvas_getReducedClipStack },
 #endif
     { "save", lcanvas_save },
     { "restore", lcanvas_restore },
     { "scale", lcanvas_scale },
     { "translate", lcanvas_translate },
     { "rotate", lcanvas_rotate },
+    { "concat", lcanvas_concat },
 
     { "newSurface", lcanvas_newSurface },
 
     { "__gc", lcanvas_gc },
     { NULL, NULL }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static int ldocument_beginPage(lua_State* L) {
@@ skipping 493 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;
 }
 

[robertphillips, 2014/10/14 16:33:14]

Can we define constants in Lua and pass an int rather then a string?

+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 {
+            const char* fName;
+            SkMatrix::ScaleToFit fScaleToFit;
+        } rec[] = {
+            { "fill",   SkMatrix::kFill_ScaleToFit },
+            { "start",  SkMatrix::kStart_ScaleToFit },
+            { "center", SkMatrix::kCenter_ScaleToFit },
+            { "end",    SkMatrix::kEnd_ScaleToFit },
+        };
+
+        for (size_t i = 0; i < SK_ARRAY_COUNT(rec); ++i) {
+            if (strcmp(rec[i].fName, scaleToFitStr) == 0) {
+                scaleToFit = rec[i].fScaleToFit;
+                break;
+            }
+        }
+    }
+
+    matrix->setRectToRect(srcR, dstR, scaleToFit);
+    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 },
     { NULL, NULL }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static int lpath_getBounds(lua_State* L) {
     SkLua(L).pushRect(get_obj<SkPath>(L, 1)->getBounds());
     return 1;
 }
 
@@ skipping 442 matching lines @@
     if (NULL == doc) {
         // do I need to push a nil on the stack and return 1?
         return 0;
     } else {
         push_ref(L, doc);
         doc->unref();
         return 1;
     }
 }
 
+static int lsk_newMatrix(lua_State* L) {
+    push_new<SkMatrix>(L)->reset();
+    return 1;
+}
+
 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();
+    push_new<SkRRect>(L)->setEmpty();
     return 1;
 }
 
 static int lsk_newTypeface(lua_State* L) {
     const char* name = NULL;
     int style = SkTypeface::kNormal;
 
     int count = lua_gettop(L);
     if (count > 0 && lua_isstring(L, 1)) {
         name = lua_tolstring(L, 1, NULL);
@@ skipping 46 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, "newMatrix", lsk_newMatrix);
     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)                             \
@@ skipping 20 matching lines @@
     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;
 }