gm/rrects.cpp

   1 /*
   2  * Copyright 2012 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 "sk_tool_utils.h"
  10 #if SK_SUPPORT_GPU
  11 #include "GrContext.h"
  12 #include "GrRenderTargetContextPriv.h"
  13 #include "effects/GrRRectEffect.h"
  14 #include "ops/GrDrawOp.h"
  15 #include "ops/GrRectOpFactory.h"
  16 #endif
  17 #include "SkRRect.h"
  18
  19 namespace skiagm {
  20
  21 ///////////////////////////////////////////////////////////////////////////////
  22
  23 class RRectGM : public GM {
  24 public:
  25     enum Type {
  26         kBW_Draw_Type,
  27         kAA_Draw_Type,
  28         kBW_Clip_Type,
  29         kAA_Clip_Type,
  30         kEffect_Type,
  31     };
  32     RRectGM(Type type) : fType(type) { }
  33
  34 protected:
  35
  36     void onOnceBeforeDraw() override {
  37         this->setBGColor(sk_tool_utils::color_to_565(0xFFDDDDDD));
  38         this->setUpRRects();
  39     }
  40
  41     SkString onShortName() override {
  42         SkString name("rrect");
  43         switch (fType) {
  44             case kBW_Draw_Type:
  45                 name.append("_draw_bw");
  46                 break;
  47             case kAA_Draw_Type:
  48                 name.append("_draw_aa");
  49                 break;
  50             case kBW_Clip_Type:
  51                 name.append("_clip_bw");
  52                 break;
  53             case kAA_Clip_Type:
  54                 name.append("_clip_aa");
  55                 break;
  56             case kEffect_Type:
  57                 name.append("_effect");
  58                 break;
  59         }
  60         return name;
  61     }
  62
  63     SkISize onISize() override { return SkISize::Make(kImageWidth, kImageHeight); }
  64
  65     void onDraw(SkCanvas* canvas) override {
  66         GrRenderTargetContext* renderTargetContext =
  67             canvas->internal_private_accessTopLayerRenderTargetContext();
  68         if (kEffect_Type == fType && !renderTargetContext) {
  69             skiagm::GM::DrawGpuOnlyMessage(canvas);
  70             return;
  71         }
  72
  73         SkPaint paint;
  74         if (kAA_Draw_Type == fType) {
  75             paint.setAntiAlias(true);
  76         }
  77
  78         const SkRect kMaxTileBound = SkRect::MakeWH(SkIntToScalar(kTileX),
  79                                                      SkIntToScalar(kTileY));
  80 #ifdef SK_DEBUG
  81         const SkRect kMaxImageBound = SkRect::MakeWH(SkIntToScalar(kImageWidth),
  82                                                      SkIntToScalar(kImageHeight));
  83 #endif
  84
  85 #if SK_SUPPORT_GPU
  86         int lastEdgeType = (kEffect_Type == fType) ? kLast_GrProcessorEdgeType: 0;
  87 #else
  88         int lastEdgeType = 0;
  89 #endif
  90
  91         int y = 1;
  92         for (int et = 0; et <= lastEdgeType; ++et) {
  93             int x = 1;
  94             for (int curRRect = 0; curRRect < kNumRRects; ++curRRect) {
  95                 bool drew = true;
  96 #ifdef SK_DEBUG
  97                 SkASSERT(kMaxTileBound.contains(fRRects[curRRect].getBounds()));
  98                 SkRect imageSpaceBounds = fRRects[curRRect].getBounds();
  99                 imageSpaceBounds.offset(SkIntToScalar(x), SkIntToScalar(y));
 100                 SkASSERT(kMaxImageBound.contains(imageSpaceBounds));
 101 #endif
 102                 canvas->save();
 103                     canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
 104                     if (kEffect_Type == fType) {
 105 #if SK_SUPPORT_GPU
 106                         SkRRect rrect = fRRects[curRRect];
 107                         rrect.offset(SkIntToScalar(x), SkIntToScalar(y));
 108                         GrPrimitiveEdgeType edgeType = (GrPrimitiveEdgeType) et;
 109                         sk_sp<GrFragmentProcessor> fp(GrRRectEffect::Make(edgeType, rrect));
 110                         if (fp) {
 111                             GrPaint grPaint;
 112                             grPaint.setXPFactory(GrPorterDuffXPFactory::Get(SkBlendMode::kSrc));
 113                             grPaint.addCoverageFragmentProcessor(std::move(fp));
 114
 115                             SkRect bounds = rrect.getBounds();
 116                             bounds.outset(2.f, 2.f);
 117
 118                             std::unique_ptr<GrLegacyMeshDrawOp> op(GrRectOpFactory::MakeNonAAFill(
 119                                     0xff000000, SkMatrix::I(), bounds, nullptr, nullptr));
 120                             renderTargetContext->priv().testingOnly_addLegacyMeshDrawOp(
 121                                     std::move(grPaint), GrAAType::kNone, std::move(op));
 122                         } else {
 123                             drew = false;
 124                         }
 125 #endif
 126                     } else if (kBW_Clip_Type == fType || kAA_Clip_Type == fType) {
 127                         bool aaClip = (kAA_Clip_Type == fType);
 128                         canvas->clipRRect(fRRects[curRRect], aaClip);
 129                         canvas->drawRect(kMaxTileBound, paint);
 130                     } else {
 131                         canvas->drawRRect(fRRects[curRRect], paint);
 132                     }
 133                 canvas->restore();
 134                 if (drew) {
 135                     x = x + kTileX;
 136                     if (x > kImageWidth) {
 137                         x = 1;
 138                         y += kTileY;
 139                     }
 140                 }
 141             }
 142             if (x != 1) {
 143                 y += kTileY;
 144             }
 145         }
 146     }
 147
 148     void setUpRRects() {
 149         // each RRect must fit in a 0x0 -> (kTileX-2)x(kTileY-2) block. These will be tiled across
 150         // the screen in kTileX x kTileY tiles. The extra empty pixels on each side are for AA.
 151
 152         // simple cases
 153         fRRects[0].setRect(SkRect::MakeWH(kTileX-2, kTileY-2));
 154         fRRects[1].setOval(SkRect::MakeWH(kTileX-2, kTileY-2));
 155         fRRects[2].setRectXY(SkRect::MakeWH(kTileX-2, kTileY-2), 10, 10);
 156         fRRects[3].setRectXY(SkRect::MakeWH(kTileX-2, kTileY-2), 10, 5);
 157         // small circular corners are an interesting test case for gpu clipping
 158         fRRects[4].setRectXY(SkRect::MakeWH(kTileX-2, kTileY-2), 1, 1);
 159         fRRects[5].setRectXY(SkRect::MakeWH(kTileX-2, kTileY-2), 0.5f, 0.5f);
 160         fRRects[6].setRectXY(SkRect::MakeWH(kTileX-2, kTileY-2), 0.2f, 0.2f);
 161
 162         // The first complex case needs special handling since it is a square
 163         fRRects[kNumSimpleCases].setRectRadii(SkRect::MakeWH(kTileY-2, kTileY-2), gRadii[0]);
 164         for (size_t i = 1; i < SK_ARRAY_COUNT(gRadii); ++i) {
 165             fRRects[kNumSimpleCases+i].setRectRadii(SkRect::MakeWH(kTileX-2, kTileY-2), gRadii[i]);
 166         }
 167     }
 168
 169 private:
 170     Type fType;
 171
 172     static constexpr int kImageWidth = 640;
 173     static constexpr int kImageHeight = 480;
 174
 175     static constexpr int kTileX = 80;
 176     static constexpr int kTileY = 40;
 177
 178     static constexpr int kNumSimpleCases = 7;
 179     static constexpr int kNumComplexCases = 35;
 180     static const SkVector gRadii[kNumComplexCases][4];
 181
 182     static constexpr int kNumRRects = kNumSimpleCases + kNumComplexCases;
 183     SkRRect fRRects[kNumRRects];
 184
 185     typedef GM INHERITED;
 186 };
 187
 188 // Radii for the various test cases. Order is UL, UR, LR, LL
 189 const SkVector RRectGM::gRadii[kNumComplexCases][4] = {
 190     // a circle
 191     { { kTileY, kTileY }, { kTileY, kTileY }, { kTileY, kTileY }, { kTileY, kTileY } },
 192
 193     // odd ball cases
 194     { { 8, 8 }, { 32, 32 }, { 8, 8 }, { 32, 32 } },
 195     { { 16, 8 }, { 8, 16 }, { 16, 8 }, { 8, 16 } },
 196     { { 0, 0 }, { 16, 16 }, { 8, 8 }, { 32, 32 } },
 197
 198     // UL
 199     { { 30, 30 }, { 0, 0 }, { 0, 0 }, { 0, 0 } },
 200     { { 30, 15 }, { 0, 0 }, { 0, 0 }, { 0, 0 } },
 201     { { 15, 30 }, { 0, 0 }, { 0, 0 }, { 0, 0 } },
 202
 203     // UR
 204     { { 0, 0 }, { 30, 30 }, { 0, 0 }, { 0, 0 } },
 205     { { 0, 0 }, { 30, 15 }, { 0, 0 }, { 0, 0 } },
 206     { { 0, 0 }, { 15, 30 }, { 0, 0 }, { 0, 0 } },
 207
 208     // LR
 209     { { 0, 0 }, { 0, 0 }, { 30, 30 }, { 0, 0 } },
 210     { { 0, 0 }, { 0, 0 }, { 30, 15 }, { 0, 0 } },
 211     { { 0, 0 }, { 0, 0 }, { 15, 30 }, { 0, 0 } },
 212
 213     // LL
 214     { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 30, 30 } },
 215     { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 30, 15 } },
 216     { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 15, 30 } },
 217
 218     // over-sized radii
 219     { { 0, 0 }, { 100, 400 }, { 0, 0 }, { 0, 0 } },
 220     { { 0, 0 }, { 400, 400 }, { 0, 0 }, { 0, 0 } },
 221     { { 400, 400 }, { 400, 400 }, { 400, 400 }, { 400, 400 } },
 222
 223     // circular corner tabs
 224     { { 0, 0 }, { 20, 20 }, { 20, 20 }, { 0, 0 } },
 225     { { 20, 20 }, { 20, 20 }, { 0, 0 }, { 0, 0 } },
 226     { { 0, 0 }, { 0, 0 }, { 20, 20 }, { 20, 20 } },
 227     { { 20, 20 }, { 0, 0 }, { 0, 0 }, { 20, 20 } },
 228
 229     // small radius circular corner tabs
 230     { { 0, 0 }, { 0.2f, 0.2f }, { 0.2f, 0.2f }, { 0, 0 } },
 231     { { 0.3f, 0.3f }, { 0.3f, .3f }, { 0, 0 }, { 0, 0 } },
 232
 233     // single circular corner cases
 234     { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 15, 15 } },
 235     { { 0, 0 }, { 0, 0 }, { 15, 15 }, { 0, 0 } },
 236     { { 0, 0 }, { 15, 15 }, { 0, 0 }, { 0, 0 } },
 237     { { 15, 15 }, { 0, 0 }, { 0, 0 }, { 0, 0 } },
 238
 239     // nine patch elliptical
 240     { { 5, 7 }, { 8, 7 }, { 8, 12 }, { 5, 12 } },
 241     { { 0, 7 }, { 8, 7 }, { 8, 12 }, { 0, 12 } },
 242
 243     // nine patch elliptical, small radii
 244     { { 0.4f, 7 }, { 8, 7 }, { 8, 12 }, { 0.4f, 12 } },
 245     { { 0.4f, 0.4f }, { 8, 0.4f }, { 8, 12 }, { 0.4f, 12 } },
 246     { { 20, 0.4f }, { 18, 0.4f }, { 18, 0.4f }, { 20, 0.4f } },
 247     { { 0.3f, 0.4f }, { 0.3f, 0.4f }, { 0.3f, 0.4f }, { 0.3f, 0.4f } },
 248
 249 };
 250
 251 ///////////////////////////////////////////////////////////////////////////////
 252
 253 DEF_GM( return new RRectGM(RRectGM::kAA_Draw_Type); )
 254 DEF_GM( return new RRectGM(RRectGM::kBW_Draw_Type); )
 255 DEF_GM( return new RRectGM(RRectGM::kAA_Clip_Type); )
 256 DEF_GM( return new RRectGM(RRectGM::kBW_Clip_Type); )
 257 #if SK_SUPPORT_GPU
 258 DEF_GM( return new RRectGM(RRectGM::kEffect_Type); )
 259 #endif
 260
 261 }