Bilerp + mirror + perspective

gm/SkLinearBitmapPipelineGM.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 "gm.h"
 #include "SkBlitter.h"
 #include "SkCanvas.h"
@@ skipping 42 matching lines @@
     bmdst.allocN32Pixels(ir.width(), ir.height());
     bmdst.eraseColor(0xFFFFFFFF);
     SkPixmap pmdst;
     bmdst.peekPixels(&pmdst);
 
     SkImageInfo info = SkImageInfo::MakeN32Premul(ir.width(), ir.height(), kLinear_SkColorProfileType);
 
     sk_sp<SkImage> image(SkImage::MakeRasterCopy(SkPixmap(info, pmsrc.addr32(), pmsrc.rowBytes())));
     SkPaint paint;
     int32_t storage[300];
-    paint.setShader(image->makeShader(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode));
+
+    sk_sp<SkShader> shader = image->makeShader(SkShader::kRepeat_TileMode,
+                                               SkShader::kRepeat_TileMode);
+
     if (useBilerp) {
         paint.setFilterQuality(SkFilterQuality::kLow_SkFilterQuality);
     } else {
         paint.setFilterQuality(SkFilterQuality::kNone_SkFilterQuality);
     }
+    paint.setShader(std::move(shader));
     const SkShader::ContextRec rec(paint, *mat, nullptr,
                                    SkBlitter::PreferredShaderDest(pmsrc.info()));
     SkASSERT(paint.getShader()->contextSize(rec) <= sizeof(storage));
 
     SkShader::Context* ctx = paint.getShader()->createContext(rec, storage);
 
     for (int y = 0; y < ir.height(); y++) {
         ctx->shadeSpan(0, y, pmdst.writable_addr32(0, y), ir.width());
     }
 
     canvas->drawBitmap(bmdst, r.left(), r.top(), nullptr);
 
     ctx->~Context();
-
 }
 
 static void draw_rect_fp(SkCanvas* canvas, const SkRect& r, SkColor c, const SkMatrix* mat, bool useBilerp) {
     const SkIRect ir = r.round();
 
     SkBitmap bmsrc;
     fill_in_bits(bmsrc, ir, c, true);
     SkPixmap pmsrc;
     bmsrc.peekPixels(&pmsrc);
 
@@ skipping 17 matching lines @@
     }
 
     uint32_t flags = 0;
     //if (kSRGB_SkColorProfileType == profile) {
         //flags |= SkXfermode::kDstIsSRGB_PM4fFlag;
     //}
     auto procN = SkXfermode::GetD32Proc(nullptr, flags);
 
     SkLinearBitmapPipeline pipeline{
             inv, filterQuality,
-            SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, pmsrc};
+            SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, 1.0f, pmsrc};
 
     for (int y = 0; y < ir.height(); y++) {
         pipeline.shadeSpan4f(0, y, dstBits, ir.width());
         procN(nullptr, pmdst.writable_addr32(0, y), dstBits, ir.width(), nullptr);
     }
 
     delete [] dstBits;
 
     canvas->drawBitmap(bmdst, r.left(), r.top(), nullptr);
 }
@@ skipping 23 matching lines @@
     canvas->translate(20, 20);
 
     SkMatrix mi = SkMatrix::I();
     SkMatrix mlr;
     mlr.setScale(-1.0f, 1.0f, 20, 0.0f);
     SkMatrix mt;
     mt.setTranslate(8, 8);
     SkMatrix mt2;
     mt2.setTranslate(-18, -18);
     SkMatrix ms;
-    ms.setScale(2.7f, 2.7f);
+    ms.setScale(2.7f, 2.7f, -1.5f, 0);
     SkMatrix ms2;
-    ms2.setScale(-0.2f, 0.2f);
+    ms2.setScale(-0.4f, 0.4f);
     SkMatrix mr;
     mr.setRotate(10);
 
     const SkMatrix* mats[] = {nullptr, &mi, &mlr, &mt, &mt2, &ms, &ms2, &mr};
 
     const SkRect r = SkRect::MakeWH(W, H);
     bool useBilerp = false;
     while (true) {
         canvas->save();
         for (auto mat : mats) {
@@ skipping 15 matching lines @@
             }
             canvas->restore();
             canvas->translate(0, H + 20);
         }
         canvas->restore();
         canvas->translate(0, (H + 20) * SK_ARRAY_COUNT(mats));
         if (useBilerp) break;
         useBilerp = true;
     }
 }