gm/aarectmodes.cpp

   1 /*
   2  * Copyright 2011 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 "SkColorPriv.h"
  11 #include "SkPath.h"
  12 #include "SkShader.h"
  13
  14 static void test4(SkCanvas* canvas) {
  15     SkPaint paint;
  16     paint.setAntiAlias(true);
  17     SkPoint pts[] = {
  18         {10, 160}, {610, 160},
  19         {610, 160}, {10, 160},
  20
  21         {610, 160}, {610, 160},
  22         {610, 199}, {610, 199},
  23
  24         {10, 198}, {610, 198},
  25         {610, 199}, {10, 199},
  26
  27         {10, 160}, {10, 160},
  28         {10, 199}, {10, 199}
  29     };
  30     char verbs[] = {
  31         0, 1, 1, 1, 4,
  32         0, 1, 1, 1, 4,
  33         0, 1, 1, 1, 4,
  34         0, 1, 1, 1, 4
  35     };
  36     SkPath path;
  37     SkPoint* ptPtr = pts;
  38     for (size_t i = 0; i < sizeof(verbs); ++i) {
  39         switch ((SkPath::Verb) verbs[i]) {
  40             case SkPath::kMove_Verb:
  41                 path.moveTo(ptPtr->fX, ptPtr->fY);
  42                 ++ptPtr;
  43                 break;
  44             case SkPath::kLine_Verb:
  45                 path.lineTo(ptPtr->fX, ptPtr->fY);
  46                 ++ptPtr;
  47                 break;
  48             case SkPath::kClose_Verb:
  49                 path.close();
  50                 break;
  51             default:
  52                 SkASSERT(false);
  53                 break;
  54         }
  55     }
  56     SkRect clip = {0, 130, 772, 531};
  57     canvas->clipRect(clip);
  58     canvas->drawPath(path, paint);
  59 }
  60
  61 constexpr SkBlendMode gModes[] = {
  62     SkBlendMode::kClear,
  63     SkBlendMode::kSrc,
  64     SkBlendMode::kDst,
  65     SkBlendMode::kSrcOver,
  66     SkBlendMode::kDstOver,
  67     SkBlendMode::kSrcIn,
  68     SkBlendMode::kDstIn,
  69     SkBlendMode::kSrcOut,
  70     SkBlendMode::kDstOut,
  71     SkBlendMode::kSrcATop,
  72     SkBlendMode::kDstATop,
  73     SkBlendMode::kXor,
  74 };
  75
  76 const int gWidth = 64;
  77 const int gHeight = 64;
  78 const SkScalar W = SkIntToScalar(gWidth);
  79 const SkScalar H = SkIntToScalar(gHeight);
  80
  81 static SkScalar drawCell(SkCanvas* canvas, SkBlendMode mode, SkAlpha a0, SkAlpha a1) {
  82
  83     SkPaint paint;
  84     paint.setAntiAlias(true);
  85
  86     SkRect r = SkRect::MakeWH(W, H);
  87     r.inset(W/10, H/10);
  88
  89     paint.setColor(SK_ColorBLUE);
  90     paint.setAlpha(a0);
  91     canvas->drawOval(r, paint);
  92
  93     paint.setColor(SK_ColorRED);
  94     paint.setAlpha(a1);
  95     paint.setBlendMode(mode);
  96
  97     SkScalar offset = SK_Scalar1 / 3;
  98     SkRect rect = SkRect::MakeXYWH(W / 4 + offset,
  99                                    H / 4 + offset,
 100                                    W / 2, H / 2);
 101     canvas->drawRect(rect, paint);
 102
 103     return H;
 104 }
 105
 106 static sk_sp<SkShader> make_bg_shader() {
 107     SkBitmap bm;
 108     bm.allocN32Pixels(2, 2);
 109     *bm.getAddr32(0, 0) = *bm.getAddr32(1, 1) = 0xFFFFFFFF;
 110     *bm.getAddr32(1, 0) = *bm.getAddr32(0, 1) = SkPackARGB32(0xFF, 0xCE,
 111                                                              0xCF, 0xCE);
 112
 113     const SkMatrix m = SkMatrix::MakeScale(SkIntToScalar(6), SkIntToScalar(6));
 114     return SkShader::MakeBitmapShader(bm, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode,
 115                                       &m);
 116 }
 117
 118 namespace skiagm {
 119
 120     class AARectModesGM : public GM {
 121         SkPaint fBGPaint;
 122     public:
 123         AARectModesGM () {
 124             fBGPaint.setShader(make_bg_shader());
 125         }
 126
 127     protected:
 128
 129         SkString onShortName() override {
 130             return SkString("aarectmodes");
 131         }
 132
 133         SkISize onISize() override { return SkISize::Make(640, 480); }
 134
 135         void onDraw(SkCanvas* canvas) override {
 136             if (false) { // avoid bit rot, suppress warning
 137                 test4(canvas);
 138             }
 139             const SkRect bounds = SkRect::MakeWH(W, H);
 140             constexpr SkAlpha gAlphaValue[] = { 0xFF, 0x88, 0x88 };
 141
 142             canvas->translate(SkIntToScalar(4), SkIntToScalar(4));
 143
 144             for (int alpha = 0; alpha < 4; ++alpha) {
 145                 canvas->save();
 146                 canvas->save();
 147                 for (size_t i = 0; i < SK_ARRAY_COUNT(gModes); ++i) {
 148                     if (6 == i) {
 149                         canvas->restore();
 150                         canvas->translate(W * 5, 0);
 151                         canvas->save();
 152                     }
 153                     canvas->drawRect(bounds, fBGPaint);
 154                     canvas->saveLayer(&bounds, nullptr);
 155                     SkScalar dy = drawCell(canvas, gModes[i],
 156                                            gAlphaValue[alpha & 1],
 157                                            gAlphaValue[alpha & 2]);
 158                     canvas->restore();
 159
 160                     canvas->translate(0, dy * 5 / 4);
 161                 }
 162                 canvas->restore();
 163                 canvas->restore();
 164                 canvas->translate(W * 5 / 4, 0);
 165             }
 166         }
 167
 168     private:
 169         typedef GM INHERITED;
 170     };
 171
 172 //////////////////////////////////////////////////////////////////////////////
 173
 174     static GM* MyFactory(void*) { return new AARectModesGM; }
 175     static GMRegistry reg(MyFactory);
 176
 177 }