submodule/skia/gm/perspimages.cpp

   1 /*
   2  * Copyright 2018 Google Inc.
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 #include "gm/gm.h"
   9 #include "include/core/SkCanvas.h"
  10 #include "include/core/SkImage.h"
  11 #include "include/core/SkMatrix.h"
  12 #include "include/core/SkPaint.h"
  13 #include "include/core/SkRect.h"
  14 #include "include/core/SkRefCnt.h"
  15 #include "include/core/SkSize.h"
  16 #include "include/core/SkString.h"
  17 #include "include/private/SkTArray.h"
  18 #include "include/private/SkTDArray.h"
  19 #include "tools/Resources.h"
  20 #include "tools/ToolUtils.h"
  21
  22 #include <initializer_list>
  23
  24 static sk_sp<SkImage> make_image1() { return GetResourceAsImage("images/mandrill_128.png"); }
  25
  26 static sk_sp<SkImage> make_image2() {
  27     return GetResourceAsImage("images/brickwork-texture.jpg")->makeSubset({0, 0, 128, 128});
  28 }
  29
  30 namespace skiagm {
  31
  32 class PerspImages : public GM {
  33 public:
  34     PerspImages() = default;
  35
  36 protected:
  37     SkString onShortName() override { return SkString("persp_images"); }
  38
  39     SkISize onISize() override { return SkISize::Make(1150, 1280); }
  40
  41     void onOnceBeforeDraw() override {
  42         fImages.push_back(make_image1());
  43         fImages.push_back(make_image2());
  44     }
  45
  46     void onDraw(SkCanvas* canvas) override {
  47         SkTDArray<SkMatrix> matrices;
  48         matrices.push()->setAll(1.f, 0.f,    0.f,
  49                                 0.f, 1.f,    0.f,
  50                                 0.f, 0.005f, 1.f);
  51         matrices.push()->setAll(1.f,     0.f,    0.f,
  52                                 0.f,     1.f,    0.f,
  53                                 0.007f, -0.005f, 1.f);
  54         matrices[1].preSkew(0.2f, -0.1f);
  55         matrices[1].preRotate(-65.f);
  56         matrices[1].preScale(1.2f, .8f);
  57         matrices[1].postTranslate(0.f, 60.f);
  58         SkPaint paint;
  59         int n = 0;
  60         SkRect bounds = SkRect::MakeEmpty();
  61         for (const auto& img : fImages) {
  62             SkRect imgB = SkRect::MakeWH(img->width(), img->height());
  63             for (const auto& m : matrices) {
  64                 SkRect temp;
  65                 m.mapRect(&temp, imgB);
  66                 bounds.join(temp);
  67             }
  68         }
  69         canvas->translate(-bounds.fLeft + 10.f, -bounds.fTop + 10.f);
  70         canvas->save();
  71         enum class DrawType {
  72             kDrawImage,
  73             kDrawImageRectStrict,
  74             kDrawImageRectFast,
  75         };
  76         for (auto type :
  77              {DrawType::kDrawImage, DrawType::kDrawImageRectStrict, DrawType::kDrawImageRectFast}) {
  78             for (const auto& m : matrices) {
  79                 for (auto aa : {false, true}) {
  80                     paint.setAntiAlias(aa);
  81                     for (auto sampling : {
  82                         SkSamplingOptions(SkFilterMode::kNearest),
  83                         SkSamplingOptions(SkFilterMode::kLinear),
  84                         SkSamplingOptions(SkFilterMode::kLinear, SkMipmapMode::kLinear),
  85                         SkSamplingOptions(SkCubicResampler::Mitchell())}) {
  86                         for (const auto& origImage : fImages) {
  87                             sk_sp<SkImage> img = ToolUtils::MakeTextureImage(canvas, origImage);
  88                             if (img) {
  89                                 canvas->save();
  90                                 canvas->concat(m);
  91                                 SkRect src = { img->width() / 4.f, img->height() / 4.f,
  92                                                3.f * img->width() / 4.f, 3.f * img->height() / 4 };
  93                                 SkRect dst = { 0, 0,
  94                                                3.f / 4.f * img->width(), 3.f / 4.f * img->height()};
  95                                 switch (type) {
  96                                     case DrawType::kDrawImage:
  97                                         canvas->drawImage(img, 0, 0, sampling, &paint);
  98                                         break;
  99                                     case DrawType::kDrawImageRectStrict:
 100                                         canvas->drawImageRect(img, src, dst, sampling, &paint,
 101                                                               SkCanvas::kStrict_SrcRectConstraint);
 102                                         break;
 103                                     case DrawType::kDrawImageRectFast:
 104                                         canvas->drawImageRect(img, src, dst, sampling, &paint,
 105                                                               SkCanvas::kFast_SrcRectConstraint);
 106                                         break;
 107                                 }
 108                                 canvas->restore();
 109                             }
 110                             ++n;
 111                             if (n < 8) {
 112                                 canvas->translate(bounds.width() + 10.f, 0);
 113                             } else {
 114                                 canvas->restore();
 115                                 canvas->translate(0, bounds.height() + 10.f);
 116                                 canvas->save();
 117                                 n = 0;
 118                             }
 119                         }
 120                     }
 121                 }
 122             }
 123         }
 124         canvas->restore();
 125     }
 126
 127 private:
 128     inline static constexpr int kNumImages = 4;
 129     SkTArray<sk_sp<SkImage>> fImages;
 130
 131     using INHERITED = GM;
 132 };
 133
 134 //////////////////////////////////////////////////////////////////////////////
 135
 136 DEF_GM(return new PerspImages();)
 137
 138 }  // namespace skiagm