gm/vertices.cpp

   1 /*
   2  * Copyright 2013 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.h"
   9 #include "SkCanvas.h"
  10 #include "SkColorFilter.h"
  11 #include "SkGradientShader.h"
  12 #include "SkLocalMatrixShader.h"
  13 #include "SkRandom.h"
  14 #include "SkVertices.h"
  15
  16 static constexpr SkScalar kShaderSize = 40;
  17 static sk_sp<SkShader> make_shader1(SkScalar shaderScale) {
  18     const SkColor colors[] = {
  19         SK_ColorRED, SK_ColorCYAN, SK_ColorGREEN, SK_ColorWHITE,
  20         SK_ColorMAGENTA, SK_ColorBLUE, SK_ColorYELLOW,
  21     };
  22     const SkPoint pts[] = {{kShaderSize / 4, 0}, {3 * kShaderSize / 4, kShaderSize}};
  23     const SkMatrix localMatrix = SkMatrix::MakeScale(shaderScale, shaderScale);
  24
  25     sk_sp<SkShader> grad = SkGradientShader::MakeLinear(pts, colors, nullptr,
  26                                                         SK_ARRAY_COUNT(colors),
  27                                                         SkShader::kMirror_TileMode, 0,
  28                                                         &localMatrix);
  29     // Throw in a couple of local matrix wrappers for good measure.
  30     return shaderScale == 1
  31         ? grad
  32         : sk_make_sp<SkLocalMatrixShader>(
  33               sk_make_sp<SkLocalMatrixShader>(std::move(grad), SkMatrix::MakeTrans(-10, 0)),
  34               SkMatrix::MakeTrans(10, 0));
  35 }
  36
  37 static sk_sp<SkShader> make_shader2() {
  38     return SkShader::MakeColorShader(SK_ColorBLUE);
  39 }
  40
  41 static sk_sp<SkColorFilter> make_color_filter() {
  42     return SkColorFilter::MakeModeFilter(0xFFAABBCC, SkBlendMode::kDarken);
  43 }
  44
  45 static constexpr SkScalar kMeshSize = 30;
  46
  47 // start with the center of a 3x3 grid of vertices.
  48 static constexpr uint16_t kMeshFan[] = {
  49         4,
  50         0, 1, 2, 5, 8, 7, 6, 3, 0
  51 };
  52
  53 static const int kMeshIndexCnt = (int)SK_ARRAY_COUNT(kMeshFan);
  54 static const int kMeshVertexCnt = 9;
  55
  56 static void fill_mesh(SkPoint pts[kMeshVertexCnt], SkPoint texs[kMeshVertexCnt],
  57                       SkColor colors[kMeshVertexCnt], SkScalar shaderScale) {
  58     pts[0].set(0, 0);
  59     pts[1].set(kMeshSize / 2, 3);
  60     pts[2].set(kMeshSize, 0);
  61     pts[3].set(3, kMeshSize / 2);
  62     pts[4].set(kMeshSize / 2, kMeshSize / 2);
  63     pts[5].set(kMeshSize - 3, kMeshSize / 2);
  64     pts[6].set(0, kMeshSize);
  65     pts[7].set(kMeshSize / 2, kMeshSize - 3);
  66     pts[8].set(kMeshSize, kMeshSize);
  67
  68     const auto shaderSize = kShaderSize * shaderScale;
  69     texs[0].set(0, 0);
  70     texs[1].set(shaderSize / 2, 0);
  71     texs[2].set(shaderSize, 0);
  72     texs[3].set(0, shaderSize / 2);
  73     texs[4].set(shaderSize / 2, shaderSize / 2);
  74     texs[5].set(shaderSize, shaderSize / 2);
  75     texs[6].set(0, shaderSize);
  76     texs[7].set(shaderSize / 2, shaderSize);
  77     texs[8].set(shaderSize, shaderSize);
  78
  79     SkRandom rand;
  80     for (size_t i = 0; i < kMeshVertexCnt; ++i) {
  81         colors[i] = rand.nextU() | 0xFF000000;
  82     }
  83 }
  84
  85 class VerticesGM : public skiagm::GM {
  86     SkPoint                 fPts[kMeshVertexCnt];
  87     SkPoint                 fTexs[kMeshVertexCnt];
  88     SkColor                 fColors[kMeshVertexCnt];
  89     sk_sp<SkShader>         fShader1;
  90     sk_sp<SkShader>         fShader2;
  91     sk_sp<SkColorFilter>    fColorFilter;
  92     SkScalar                fShaderScale;
  93
  94 public:
  95     VerticesGM(SkScalar shaderScale) : fShaderScale(shaderScale) {}
  96
  97 protected:
  98
  99     void onOnceBeforeDraw() override {
 100         fill_mesh(fPts, fTexs, fColors, fShaderScale);
 101         fShader1 = make_shader1(fShaderScale);
 102         fShader2 = make_shader2();
 103         fColorFilter = make_color_filter();
 104     }
 105
 106     SkString onShortName() override {
 107         SkString name("vertices");
 108         if (fShaderScale != 1) {
 109             name.append("_scaled_shader");
 110         }
 111         return name;
 112     }
 113
 114     SkISize onISize() override {
 115         return SkISize::Make(975, 1175);
 116     }
 117
 118     void onDraw(SkCanvas* canvas) override {
 119         const SkBlendMode modes[] = {
 120             SkBlendMode::kClear,
 121             SkBlendMode::kSrc,
 122             SkBlendMode::kDst,
 123             SkBlendMode::kSrcOver,
 124             SkBlendMode::kDstOver,
 125             SkBlendMode::kSrcIn,
 126             SkBlendMode::kDstIn,
 127             SkBlendMode::kSrcOut,
 128             SkBlendMode::kDstOut,
 129             SkBlendMode::kSrcATop,
 130             SkBlendMode::kDstATop,
 131             SkBlendMode::kXor,
 132             SkBlendMode::kPlus,
 133             SkBlendMode::kModulate,
 134             SkBlendMode::kScreen,
 135             SkBlendMode::kOverlay,
 136             SkBlendMode::kDarken,
 137             SkBlendMode::kLighten,
 138             SkBlendMode::kColorDodge,
 139             SkBlendMode::kColorBurn,
 140             SkBlendMode::kHardLight,
 141             SkBlendMode::kSoftLight,
 142             SkBlendMode::kDifference,
 143             SkBlendMode::kExclusion,
 144             SkBlendMode::kMultiply,
 145             SkBlendMode::kHue,
 146             SkBlendMode::kSaturation,
 147             SkBlendMode::kColor,
 148             SkBlendMode::kLuminosity,
 149         };
 150
 151         SkPaint paint;
 152
 153         canvas->translate(4, 4);
 154         int x = 0;
 155         for (auto mode : modes) {
 156             canvas->save();
 157             for (uint8_t alpha : {0xFF, 0x80}) {
 158                 for (const auto& cf : {sk_sp<SkColorFilter>(nullptr), fColorFilter}) {
 159                     for (const auto& shader : {fShader1, fShader2}) {
 160                         static constexpr struct {
 161                             bool fHasColors;
 162                             bool fHasTexs;
 163                         } kAttrs[] = {{true, false}, {false, true}, {true, true}};
 164                         for (auto attrs : kAttrs) {
 165                             paint.setShader(shader);
 166                             paint.setColorFilter(cf);
 167                             paint.setAlpha(alpha);
 168
 169                             const SkColor* colors = attrs.fHasColors ? fColors : nullptr;
 170                             const SkPoint* texs = attrs.fHasTexs ? fTexs : nullptr;
 171                             auto v = SkVertices::MakeCopy(SkVertices::kTriangleFan_VertexMode,
 172                                                           kMeshVertexCnt, fPts, texs, colors,
 173                                                           kMeshIndexCnt, kMeshFan);
 174                             canvas->drawVertices(v, mode, paint);
 175                             canvas->translate(40, 0);
 176                             ++x;
 177                         }
 178                     }
 179                 }
 180             }
 181             canvas->restore();
 182             canvas->translate(0, 40);
 183         }
 184     }
 185
 186 private:
 187     typedef skiagm::GM INHERITED;
 188 };
 189
 190 /////////////////////////////////////////////////////////////////////////////////////
 191
 192 DEF_GM(return new VerticesGM(1);)
 193 DEF_GM(return new VerticesGM(1 / kShaderSize);)
 194
 195 static void draw_batching(SkCanvas* canvas) {
 196     // Triangle fans can't batch so we convert to regular triangles,
 197     static constexpr int kNumTris = kMeshIndexCnt - 2;
 198     SkVertices::Builder builder(SkVertices::kTriangles_VertexMode, kMeshVertexCnt, 3 * kNumTris,
 199                                 SkVertices::kHasColors_BuilderFlag |
 200                                 SkVertices::kHasTexCoords_BuilderFlag);
 201
 202     SkPoint* pts = builder.positions();
 203     SkPoint* texs = builder.texCoords();
 204     SkColor* colors = builder.colors();
 205     fill_mesh(pts, texs, colors, 1);
 206
 207     SkTDArray<SkMatrix> matrices;
 208     matrices.push()->reset();
 209     matrices.push()->setTranslate(0, 40);
 210     SkMatrix* m = matrices.push();
 211     m->setRotate(45, kMeshSize / 2, kMeshSize / 2);
 212     m->postScale(1.2f, .8f, kMeshSize / 2, kMeshSize / 2);
 213     m->postTranslate(0, 80);
 214
 215     auto shader = make_shader1(1);
 216
 217     uint16_t* indices = builder.indices();
 218     for (size_t i = 0; i < kNumTris; ++i) {
 219         indices[3 * i] = kMeshFan[0];
 220         indices[3 * i + 1] = kMeshFan[i + 1];
 221         indices[3 * i + 2] = kMeshFan[i + 2];
 222
 223     }
 224
 225     canvas->save();
 226     canvas->translate(10, 10);
 227     for (bool useShader : {false, true}) {
 228         for (bool useTex : {false, true}) {
 229             for (const auto& m : matrices) {
 230                 canvas->save();
 231                 canvas->concat(m);
 232                 SkPaint paint;
 233                 paint.setShader(useShader ? shader : nullptr);
 234
 235                 const SkPoint* t = useTex ? texs : nullptr;
 236                 auto v = SkVertices::MakeCopy(SkVertices::kTriangles_VertexMode, kMeshVertexCnt,
 237                                               pts, t, colors, kNumTris * 3, indices);
 238                 canvas->drawVertices(v, SkBlendMode::kModulate, paint);
 239                 canvas->restore();
 240             }
 241             canvas->translate(0, 120);
 242         }
 243     }
 244     canvas->restore();
 245 }
 246
 247 // This test exists to exercise batching in the gpu backend.
 248 DEF_SIMPLE_GM(vertices_batching, canvas, 100, 500) {
 249     draw_batching(canvas);
 250     canvas->translate(50, 0);
 251     draw_batching(canvas);
 252 }