gm/convexpolyclip.cpp

   1
   2 /*
   3  * Copyright 2014 Google Inc.
   4  *
   5  * Use of this source code is governed by a BSD-style license that can be
   6  * found in the LICENSE file.
   7  */
   8
   9 #include "gm.h"
  10
  11 #include "SkBitmap.h"
  12 #include "SkGradientShader.h"
  13 #include "SkTLList.h"
  14
  15 static SkBitmap make_bmp(int w, int h) {
  16     SkBitmap bmp;
  17     bmp.allocN32Pixels(w, h, true);
  18
  19     SkCanvas canvas(bmp);
  20     SkScalar wScalar = SkIntToScalar(w);
  21     SkScalar hScalar = SkIntToScalar(h);
  22
  23     SkPoint     pt = { wScalar / 2, hScalar / 2 };
  24
  25     SkScalar    radius = 3 * SkMaxScalar(wScalar, hScalar);
  26
  27     SkColor     colors[] = { SK_ColorDKGRAY, 0xFF222255,
  28                              0xFF331133, 0xFF884422,
  29                              0xFF000022, SK_ColorWHITE,
  30                              0xFFAABBCC};
  31
  32     SkScalar    pos[] = {0,
  33                          SK_Scalar1 / 6,
  34                          2 * SK_Scalar1 / 6,
  35                          3 * SK_Scalar1 / 6,
  36                          4 * SK_Scalar1 / 6,
  37                          5 * SK_Scalar1 / 6,
  38                          SK_Scalar1};
  39
  40     SkPaint paint;
  41     SkRect rect = SkRect::MakeWH(wScalar, hScalar);
  42     SkMatrix mat = SkMatrix::I();
  43     for (int i = 0; i < 4; ++i) {
  44         paint.setShader(SkGradientShader::CreateRadial(
  45                         pt, radius,
  46                         colors, pos,
  47                         SK_ARRAY_COUNT(colors),
  48                         SkShader::kRepeat_TileMode,
  49                         0, &mat))->unref();
  50         canvas.drawRect(rect, paint);
  51         rect.inset(wScalar / 8, hScalar / 8);
  52         mat.preTranslate(6 * wScalar, 6 * hScalar);
  53         mat.postScale(SK_Scalar1 / 3, SK_Scalar1 / 3);
  54     }
  55
  56     paint.setAntiAlias(true);
  57     sk_tool_utils::set_portable_typeface(&paint);
  58     paint.setTextSize(wScalar / 2.2f);
  59     paint.setShader(0);
  60     paint.setColor(SK_ColorLTGRAY);
  61     static const char kTxt[] = "Skia";
  62     SkPoint texPos = { wScalar / 17, hScalar / 2 + paint.getTextSize() / 2.5f };
  63     canvas.drawText(kTxt, SK_ARRAY_COUNT(kTxt)-1, texPos.fX, texPos.fY, paint);
  64     paint.setColor(SK_ColorBLACK);
  65     paint.setStyle(SkPaint::kStroke_Style);
  66     paint.setStrokeWidth(SK_Scalar1);
  67     canvas.drawText(kTxt, SK_ARRAY_COUNT(kTxt)-1, texPos.fX, texPos.fY, paint);
  68     return bmp;
  69 }
  70
  71 namespace skiagm {
  72 /**
  73  * This GM tests convex polygon clips.
  74  */
  75 class ConvexPolyClip : public GM {
  76 public:
  77     ConvexPolyClip() {
  78         this->setBGColor(0xFFFFFFFF);
  79     }
  80
  81 protected:
  82     SkString onShortName() override {
  83         return SkString("convex_poly_clip");
  84     }
  85
  86     SkISize onISize() override {
  87         // When benchmarking the saveLayer set of draws is skipped.
  88         int w = 435;
  89         if (kBench_Mode != this->getMode()) {
  90             w *= 2;
  91         }
  92         return SkISize::Make(w, 540);
  93     }
  94
  95     void onOnceBeforeDraw() override {
  96         SkPath tri;
  97         tri.moveTo(5.f, 5.f);
  98         tri.lineTo(100.f, 20.f);
  99         tri.lineTo(15.f, 100.f);
 100
 101         fClips.addToTail()->setPath(tri);
 102
 103         SkPath hexagon;
 104         static const SkScalar kRadius = 45.f;
 105         const SkPoint center = { kRadius, kRadius };
 106         for (int i = 0; i < 6; ++i) {
 107             SkScalar angle = 2 * SK_ScalarPI * i / 6;
 108             SkPoint point;
 109             point.fY = SkScalarSinCos(angle, &point.fX);
 110             point.scale(kRadius);
 111             point = center + point;
 112             if (0 == i) {
 113                 hexagon.moveTo(point);
 114             } else {
 115                 hexagon.lineTo(point);
 116             }
 117         }
 118         fClips.addToTail()->setPath(hexagon);
 119
 120         SkMatrix scaleM;
 121         scaleM.setScale(1.1f, 0.4f, kRadius, kRadius);
 122         hexagon.transform(scaleM);
 123         fClips.addToTail()->setPath(hexagon);
 124
 125         fClips.addToTail()->setRect(SkRect::MakeXYWH(8.3f, 11.6f, 78.2f, 72.6f));
 126
 127         SkPath rotRect;
 128         SkRect rect = SkRect::MakeLTRB(10.f, 12.f, 80.f, 86.f);
 129         rotRect.addRect(rect);
 130         SkMatrix rotM;
 131         rotM.setRotate(23.f, rect.centerX(), rect.centerY());
 132         rotRect.transform(rotM);
 133         fClips.addToTail()->setPath(rotRect);
 134
 135         fBmp = make_bmp(100, 100);
 136     }
 137
 138     void onDraw(SkCanvas* canvas) override {
 139         SkScalar y = 0;
 140         static const SkScalar kMargin = 10.f;
 141
 142         SkPaint bgPaint;
 143         bgPaint.setAlpha(0x15);
 144         SkISize size = canvas->getDeviceSize();
 145         SkRect dstRect = SkRect::MakeWH(SkIntToScalar(size.fWidth),
 146                                         SkIntToScalar(size.fHeight));
 147         canvas->drawBitmapRectToRect(fBmp, NULL, dstRect, &bgPaint);
 148
 149         static const char kTxt[] = "Clip Me!";
 150         SkPaint txtPaint;
 151         txtPaint.setTextSize(23.f);
 152         txtPaint.setAntiAlias(true);
 153         sk_tool_utils::set_portable_typeface(&txtPaint);
 154         txtPaint.setColor(SK_ColorDKGRAY);
 155         SkScalar textW = txtPaint.measureText(kTxt, SK_ARRAY_COUNT(kTxt)-1);
 156
 157         SkScalar startX = 0;
 158         int testLayers = kBench_Mode != this->getMode();
 159         for (int doLayer = 0; doLayer <= testLayers; ++doLayer) {
 160             for (SkTLList<Clip>::Iter iter(fClips, SkTLList<Clip>::Iter::kHead_IterStart);
 161                  iter.get();
 162                  iter.next()) {
 163                 const Clip* clip = iter.get();
 164                 SkScalar x = startX;
 165                 for (int aa = 0; aa < 2; ++aa) {
 166                     if (doLayer) {
 167                         SkRect bounds;
 168                         clip->getBounds(&bounds);
 169                         bounds.outset(2, 2);
 170                         bounds.offset(x, y);
 171                         canvas->saveLayer(&bounds, NULL);
 172                     } else {
 173                         canvas->save();
 174                     }
 175                     canvas->translate(x, y);
 176                     clip->setOnCanvas(canvas, SkRegion::kIntersect_Op, SkToBool(aa));
 177                     canvas->drawBitmap(fBmp, 0, 0);
 178                     canvas->restore();
 179                     x += fBmp.width() + kMargin;
 180                 }
 181                 for (int aa = 0; aa < 2; ++aa) {
 182
 183                     SkPaint clipOutlinePaint;
 184                     clipOutlinePaint.setAntiAlias(true);
 185                     clipOutlinePaint.setColor(0x50505050);
 186                     clipOutlinePaint.setStyle(SkPaint::kStroke_Style);
 187                     clipOutlinePaint.setStrokeWidth(0);
 188
 189                     if (doLayer) {
 190                         SkRect bounds;
 191                         clip->getBounds(&bounds);
 192                         bounds.outset(2, 2);
 193                         bounds.offset(x, y);
 194                         canvas->saveLayer(&bounds, NULL);
 195                     } else {
 196                         canvas->save();
 197                     }
 198                     canvas->translate(x, y);
 199                     SkPath closedClipPath;
 200                     clip->asClosedPath(&closedClipPath);
 201                     canvas->drawPath(closedClipPath, clipOutlinePaint);
 202                     clip->setOnCanvas(canvas, SkRegion::kIntersect_Op, SkToBool(aa));
 203                     canvas->scale(1.f, 1.8f);
 204                     canvas->drawText(kTxt, SK_ARRAY_COUNT(kTxt)-1,
 205                                      0, 1.5f * txtPaint.getTextSize(),
 206                                      txtPaint);
 207                     canvas->restore();
 208                     x += textW + 2 * kMargin;
 209                 }
 210                 y += fBmp.height() + kMargin;
 211             }
 212             y = 0;
 213             startX += 2 * fBmp.width() + SkScalarCeilToInt(2 * textW) + 6 * kMargin;
 214         }
 215     }
 216
 217     bool runAsBench() const override { return true; }
 218
 219 private:
 220     class Clip {
 221     public:
 222         enum ClipType {
 223             kNone_ClipType,
 224             kPath_ClipType,
 225             kRect_ClipType
 226         };
 227
 228         Clip () : fClipType(kNone_ClipType) {}
 229
 230         void setOnCanvas(SkCanvas* canvas, SkRegion::Op op, bool aa) const {
 231             switch (fClipType) {
 232                 case kPath_ClipType:
 233                     canvas->clipPath(fPath, op, aa);
 234                     break;
 235                 case kRect_ClipType:
 236                     canvas->clipRect(fRect, op, aa);
 237                     break;
 238                 case kNone_ClipType:
 239                     SkDEBUGFAIL("Uninitialized Clip.");
 240                     break;
 241             }
 242         }
 243
 244         void asClosedPath(SkPath* path) const {
 245             switch (fClipType) {
 246                 case kPath_ClipType:
 247                     *path = fPath;
 248                     path->close();
 249                     break;
 250                 case kRect_ClipType:
 251                     path->reset();
 252                     path->addRect(fRect);
 253                     break;
 254                 case kNone_ClipType:
 255                     SkDEBUGFAIL("Uninitialized Clip.");
 256                     break;
 257             }
 258         }
 259
 260         void setPath(const SkPath& path) {
 261             fClipType = kPath_ClipType;
 262             fPath = path;
 263         }
 264
 265         void setRect(const SkRect& rect) {
 266             fClipType = kRect_ClipType;
 267             fRect = rect;
 268             fPath.reset();
 269         }
 270
 271         ClipType getType() const { return fClipType; }
 272
 273         void getBounds(SkRect* bounds) const {
 274             switch (fClipType) {
 275                 case kPath_ClipType:
 276                     *bounds = fPath.getBounds();
 277                     break;
 278                 case kRect_ClipType:
 279                     *bounds = fRect;
 280                     break;
 281                 case kNone_ClipType:
 282                     SkDEBUGFAIL("Uninitialized Clip.");
 283                     break;
 284             }
 285         }
 286
 287     private:
 288         ClipType fClipType;
 289         SkPath fPath;
 290         SkRect fRect;
 291     };
 292
 293     SkTLList<Clip>   fClips;
 294     SkBitmap         fBmp;
 295
 296     typedef GM INHERITED;
 297 };
 298
 299 DEF_GM( return SkNEW(ConvexPolyClip); )
 300
 301 }