Add option to skip rects to drawImageLattice()

src/core/SkLiteDL.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCanvas.h"
 #include "SkData.h"
 #include "SkImageFilter.h"
@@ skipping 320 matching lines @@
         sk_sp<const SkImage> image;
         SkRect src, dst;
         SkPaint paint;
         SkCanvas::SrcRectConstraint constraint;
         void draw(SkCanvas* c, const SkMatrix&) {
             c->drawImageRect(image.get(), src, dst, &paint, constraint);
         }
     };
     struct DrawImageLattice final : Op {
         static const auto kType = Type::DrawImageLattice;
-        DrawImageLattice(sk_sp<const SkImage>&& image, int xs, int ys,
+        DrawImageLattice(sk_sp<const SkImage>&& image, int xs, int ys, int fs,
                          const SkRect& dst, const SkPaint* paint)
-            : image(std::move(image)), xs(xs), ys(ys), dst(dst) {
+            : image(std::move(image)), xs(xs), ys(ys), fs(fs), dst(dst) {
             if (paint) { this->paint = *paint; }
         }
         sk_sp<const SkImage> image;
-        int                  xs, ys;
+        int                  xs, ys, fs;
         SkRect               dst;
         SkPaint              paint;
         void draw(SkCanvas* c, const SkMatrix&) {
             auto xdivs = pod<int>(this, 0),
                  ydivs = pod<int>(this, xs*sizeof(int));
-            c->drawImageLattice(image.get(), {xdivs, xs, ydivs, ys}, dst, &paint);
+            auto flags = (0 == fs) ? nullptr :
+                                     pod<SkCanvas::Lattice::Flags>(this, (xs+ys)*sizeof(int));
+            c->drawImageLattice(image.get(), {xdivs, ydivs, flags, xs, ys}, dst, &paint);
         }
     };
 
     struct DrawText final : Op {
         static const auto kType = Type::DrawText;
         DrawText(size_t bytes, SkScalar x, SkScalar y, const SkPaint& paint)
             : bytes(bytes), x(x), y(y), paint(paint) {}
         size_t bytes;
         SkScalar x,y;
         SkPaint paint;
@@ skipping 274 matching lines @@
                               const SkRect& dst, const SkPaint* paint) {
     this->push<DrawImageNine>(0, SkImage::MakeFromBitmap(bm), center, dst, paint);
 }
 void SkLiteDL::drawBitmapRect(const SkBitmap& bm, const SkRect* src, const SkRect& dst,
                               const SkPaint* paint, SkCanvas::SrcRectConstraint constraint) {
     this->push<DrawImageRect>(0, SkImage::MakeFromBitmap(bm), src, dst, paint, constraint);
 }
 void SkLiteDL::drawBitmapLattice(const SkBitmap& bm, const SkCanvas::Lattice& lattice,
                                  const SkRect& dst, const SkPaint* paint) {
     int xs = lattice.fXCount, ys = lattice.fYCount;
-    size_t bytes = (xs + ys) * sizeof(int);
-    void* pod = this->push<DrawImageLattice>(bytes, SkImage::MakeFromBitmap(bm), xs, ys, dst,
+    int fs = lattice.fFlags ? (xs + 1) * (ys + 1) : 0;
+    size_t bytes = (xs + ys) * sizeof(int) + fs * sizeof(SkCanvas::Lattice::Flags);
+    void* pod = this->push<DrawImageLattice>(bytes, SkImage::MakeFromBitmap(bm), xs, ys, fs, dst,
                                              paint);
     copy_v(pod, lattice.fXDivs, xs,
-                lattice.fYDivs, ys);
+                lattice.fYDivs, ys,
+                lattice.fFlags, fs);
 }
 
 void SkLiteDL::drawImage(const SkImage* image, SkScalar x, SkScalar y, const SkPaint* paint) {
     this->push<DrawImage>(0, sk_ref_sp(image), x,y, paint);
 }
 void SkLiteDL::drawImageNine(const SkImage* image, const SkIRect& center,
                              const SkRect& dst, const SkPaint* paint) {
     this->push<DrawImageNine>(0, sk_ref_sp(image), center, dst, paint);
 }
 void SkLiteDL::drawImageRect(const SkImage* image, const SkRect* src, const SkRect& dst,
                              const SkPaint* paint, SkCanvas::SrcRectConstraint constraint) {
     this->push<DrawImageRect>(0, sk_ref_sp(image), src, dst, paint, constraint);
 }
 void SkLiteDL::drawImageLattice(const SkImage* image, const SkCanvas::Lattice& lattice,
                                 const SkRect& dst, const SkPaint* paint) {
     int xs = lattice.fXCount, ys = lattice.fYCount;
-    size_t bytes = (xs + ys) * sizeof(int);
-    void* pod = this->push<DrawImageLattice>(bytes, sk_ref_sp(image), xs, ys, dst, paint);
+    int fs = lattice.fFlags ? (xs + 1) * (ys + 1) : 0;
+    size_t bytes = (xs + ys) * sizeof(int) + fs * sizeof(SkCanvas::Lattice::Flags);
+    void* pod = this->push<DrawImageLattice>(bytes, sk_ref_sp(image), xs, ys, fs, dst, paint);
     copy_v(pod, lattice.fXDivs, xs,
-                lattice.fYDivs, ys);
+                lattice.fYDivs, ys,
+                lattice.fFlags, fs);
 }
 
 void SkLiteDL::drawText(const void* text, size_t bytes,
                         SkScalar x, SkScalar y, const SkPaint& paint) {
     void* pod = this->push<DrawText>(bytes, bytes, x, y, paint);
     copy_v(pod, (const char*)text,bytes);
 }
 void SkLiteDL::drawPosText(const void* text, size_t bytes,
                            const SkPoint pos[], const SkPaint& paint) {
     int n = paint.countText(text, bytes);
@@ skipping 100 matching lines @@
 }
 
 void SkLiteDL::reset(SkRect bounds) {
     SkASSERT(this->unique());
     this->map(dtor_fns);
 
     // Leave fBytes and fReserved alone.
     fUsed   = 0;
     fBounds = bounds;
 }