gm/textbloblooper.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
  10 #include "Sk2DPathEffect.h"
  11 #include "SkBlurMask.h"
  12 #include "SkBlurMaskFilter.h"
  13 #include "SkColorFilter.h"
  14 #include "SkCanvas.h"
  15 #include "SkGradientShader.h"
  16 #include "SkGraphics.h"
  17 #include "SkLayerDrawLooper.h"
  18 #include "SkRandom.h"
  19 #include "SkTextBlob.h"
  20
  21 namespace skiagm {
  22
  23 static const int kWidth = 1250;
  24 static const int kHeight = 700;
  25
  26 // Unlike the variant in sk_tool_utils, this version positions the glyphs on a diagonal
  27 static void add_to_text_blob(SkTextBlobBuilder* builder, const char* text, const SkPaint& origPaint,
  28                              SkScalar x, SkScalar y) {
  29     SkPaint paint(origPaint);
  30     SkTDArray<uint16_t> glyphs;
  31
  32     size_t len = strlen(text);
  33     glyphs.append(paint.textToGlyphs(text, len, NULL));
  34     paint.textToGlyphs(text, len, glyphs.begin());
  35
  36     const SkScalar advanceX = paint.getTextSize() * 0.85f;
  37     const SkScalar advanceY = paint.getTextSize() * 1.5f;
  38
  39     SkTDArray<SkScalar> pos;
  40     for (unsigned i = 0; i < len; ++i) {
  41         *pos.append() = x + i * advanceX;
  42         *pos.append() = y + i * (advanceY / len);
  43     }
  44
  45     paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
  46     const SkTextBlobBuilder::RunBuffer& run = builder->allocRunPos(paint, glyphs.count());
  47     memcpy(run.glyphs, glyphs.begin(), glyphs.count() * sizeof(uint16_t));
  48     memcpy(run.pos, pos.begin(), len * sizeof(SkScalar) * 2);
  49 }
  50
  51 typedef void (*LooperProc)(SkPaint*);
  52
  53 struct LooperSettings {
  54     SkXfermode::Mode fMode;
  55     SkColor          fColor;
  56     SkPaint::Style   fStyle;
  57     SkScalar         fWidth;
  58     SkScalar         fOffset;
  59     SkScalar         fSkewX;
  60     bool             fEffect;
  61 };
  62
  63 static void mask_filter(SkPaint* paint) {
  64     SkMaskFilter* mf = SkBlurMaskFilter::Create(kNormal_SkBlurStyle,
  65                         SkBlurMask::ConvertRadiusToSigma(3.f));
  66     paint->setMaskFilter(mf)->unref();
  67 }
  68
  69 static SkPathEffect* make_tile_effect() {
  70     SkMatrix m;
  71     m.setScale(1.f, 1.f);
  72
  73     SkPath path;
  74     path.addCircle(0, 0, SkIntToScalar(5));
  75
  76     return SkPath2DPathEffect::Create(m, path);
  77 }
  78
  79 static void path_effect(SkPaint* paint) {
  80     paint->setPathEffect(make_tile_effect())->unref();
  81 }
  82
  83 static SkShader* make_shader(const SkRect& bounds) {
  84     const SkPoint pts[] = {
  85         { bounds.left(), bounds.top() },
  86         { bounds.right(), bounds.bottom() },
  87     };
  88     const SkColor colors[] = {
  89         SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorBLACK,
  90         SK_ColorCYAN, SK_ColorMAGENTA, SK_ColorYELLOW,
  91     };
  92     return SkGradientShader::CreateLinear(pts,
  93                                           colors, NULL, SK_ARRAY_COUNT(colors),
  94                                           SkShader::kClamp_TileMode);
  95 }
  96
  97 static void color_filter(SkPaint* paint) {
  98     SkRect r;
  99     r.setWH(SkIntToScalar(kWidth), 50);
 100     paint->setShader(make_shader(r))->unref();
 101     paint->setColorFilter(SkColorFilter::CreateLightingFilter(0xF0F0F0, 0))->unref();
 102 }
 103
 104 static void kitchen_sink(SkPaint* paint) {
 105     color_filter(paint);
 106     path_effect(paint);
 107     mask_filter(paint);
 108
 109 }
 110
 111 static SkLayerDrawLooper* setupLooper(SkLayerDrawLooper::BitFlags bits,
 112                                       LooperProc proc,
 113                                       const LooperSettings settings[],
 114                                       size_t size) {
 115     SkLayerDrawLooper::Builder looperBuilder;
 116
 117     SkLayerDrawLooper::LayerInfo info;
 118     info.fPaintBits = bits;
 119
 120     info.fColorMode = SkXfermode::kSrc_Mode;
 121
 122     for (size_t i = 0; i < size; i++) {
 123         info.fOffset.set(settings[i].fOffset, settings[i].fOffset);
 124         SkPaint* paint = looperBuilder.addLayer(info);
 125         paint->setXfermodeMode(settings[i].fMode);
 126         paint->setColor(settings[i].fColor);
 127         paint->setStyle(settings[i].fStyle);
 128         paint->setStrokeWidth(settings[i].fWidth);
 129         if (settings[i].fEffect) {
 130             (*proc)(paint);
 131         }
 132     }
 133     return looperBuilder.detachLooper();
 134 }
 135
 136 class TextBlobLooperGM : public GM {
 137 public:
 138     TextBlobLooperGM() {}
 139
 140 protected:
 141     void onOnceBeforeDraw() override {
 142         SkTextBlobBuilder builder;
 143
 144         // LCD
 145         SkPaint paint;
 146         paint.setTextSize(32);
 147         const char* text = "The quick brown fox jumps over the lazy dog";
 148         paint.setSubpixelText(true);
 149         paint.setLCDRenderText(true);
 150         paint.setAntiAlias(true);
 151         add_to_text_blob(&builder, text, paint, 0, 0);
 152         fBlob.reset(builder.build());
 153
 154         // create a looper which sandwhiches an effect in two normal draws
 155         LooperSettings looperSandwhich[] = {
 156            { SkXfermode::kSrc_Mode, SK_ColorMAGENTA, SkPaint::kFill_Style, 0, 0, 0, false },
 157            { SkXfermode::kSrcOver_Mode, 0x88000000, SkPaint::kFill_Style, 0, 10.f, 0, true },
 158            { SkXfermode::kSrcOver_Mode, 0x50FF00FF, SkPaint::kFill_Style, 0, 20.f, 0, false },
 159         };
 160
 161         LooperSettings compound[] = {
 162             { SkXfermode::kSrc_Mode, SK_ColorWHITE, SkPaint::kStroke_Style, 1.f * 3/4, 0, 0, false },
 163             { SkXfermode::kSrc_Mode, SK_ColorRED, SkPaint::kStroke_Style, 4.f, 0, 0, false },
 164             { SkXfermode::kSrc_Mode, SK_ColorBLUE, SkPaint::kFill_Style, 0, 0, 0, false },
 165             { SkXfermode::kSrcOver_Mode, 0x88000000, SkPaint::kFill_Style, 0, 10.f, 0, true }
 166         };
 167
 168         LooperSettings xfermode[] = {
 169             { SkXfermode::kDifference_Mode, SK_ColorWHITE, SkPaint::kFill_Style, 0, 0, 0, false },
 170             { SkXfermode::kSrcOver_Mode, 0xFF000000, SkPaint::kFill_Style, 0, 1.f, 0, true },
 171             { SkXfermode::kSrcOver_Mode, 0x50FF00FF, SkPaint::kFill_Style, 0, 2.f, 0, false },
 172         };
 173
 174         // NOTE, this should be ignored by textblobs
 175         LooperSettings skew[] = {
 176             { SkXfermode::kSrc_Mode, SK_ColorRED, SkPaint::kFill_Style, 0, 0, -1.f, false },
 177             { SkXfermode::kSrc_Mode, SK_ColorGREEN, SkPaint::kFill_Style, 0, 10.f, -1.f, false },
 178             { SkXfermode::kSrc_Mode, SK_ColorBLUE, SkPaint::kFill_Style, 0, 20.f, -1.f, false },
 179         };
 180
 181         LooperSettings kitchenSink[] = {
 182             { SkXfermode::kSrc_Mode, SK_ColorWHITE, SkPaint::kStroke_Style, 1.f * 3/4, 0, 0, false },
 183             { SkXfermode::kSrc_Mode, SK_ColorBLACK, SkPaint::kFill_Style, 0, 0, 0, false },
 184             { SkXfermode::kDifference_Mode, SK_ColorWHITE, SkPaint::kFill_Style, 1.f, 10.f, 0, false },
 185             { SkXfermode::kSrc_Mode, SK_ColorWHITE, SkPaint::kFill_Style, 0, 10.f, 0, true },
 186             { SkXfermode::kSrcOver_Mode, 0x50FF00FF, SkPaint::kFill_Style, 0, 20.f, 0, false },
 187         };
 188
 189         fLoopers.push_back().reset(setupLooper(SkLayerDrawLooper::kMaskFilter_Bit |
 190                                                SkLayerDrawLooper::kXfermode_Bit |
 191                                                SkLayerDrawLooper::kStyle_Bit, &mask_filter,
 192                                                compound, SK_ARRAY_COUNT(compound)));
 193         fLoopers.push_back().reset(setupLooper(SkLayerDrawLooper::kPathEffect_Bit |
 194                                                SkLayerDrawLooper::kXfermode_Bit, &path_effect,
 195                                                looperSandwhich, SK_ARRAY_COUNT(looperSandwhich)));
 196         fLoopers.push_back().reset(setupLooper(SkLayerDrawLooper::kShader_Bit |
 197                                                SkLayerDrawLooper::kColorFilter_Bit |
 198                                                SkLayerDrawLooper::kXfermode_Bit, &color_filter,
 199                                                looperSandwhich, SK_ARRAY_COUNT(looperSandwhich)));
 200         fLoopers.push_back().reset(setupLooper(SkLayerDrawLooper::kShader_Bit |
 201                                                SkLayerDrawLooper::kColorFilter_Bit |
 202                                                SkLayerDrawLooper::kXfermode_Bit, &color_filter,
 203                                                xfermode, SK_ARRAY_COUNT(xfermode)));
 204         fLoopers.push_back().reset(setupLooper(0, NULL, skew, SK_ARRAY_COUNT(skew)));
 205         fLoopers.push_back().reset(setupLooper(SkLayerDrawLooper::kMaskFilter_Bit |
 206                                                SkLayerDrawLooper::kShader_Bit |
 207                                                SkLayerDrawLooper::kColorFilter_Bit |
 208                                                SkLayerDrawLooper::kPathEffect_Bit |
 209                                                SkLayerDrawLooper::kStyle_Bit |
 210                                                SkLayerDrawLooper::kXfermode_Bit, &kitchen_sink,
 211                                                kitchenSink, SK_ARRAY_COUNT(kitchenSink)));
 212
 213         // Test we respect overrides
 214         fLoopers.push_back().reset(setupLooper(0, &kitchen_sink,
 215                                                kitchenSink, SK_ARRAY_COUNT(kitchenSink)));
 216     }
 217
 218     SkString onShortName() override {
 219         return SkString("textbloblooper");
 220     }
 221
 222     SkISize onISize() override {
 223         return SkISize::Make(kWidth, kHeight);
 224     }
 225
 226     void onDraw(SkCanvas* canvas) override {
 227
 228         canvas->drawColor(SK_ColorGRAY);
 229
 230         SkPaint paint;
 231         canvas->translate(10, 40);
 232
 233         paint.setTextSize(40);
 234
 235         SkRect bounds = fBlob->bounds();
 236
 237         int y = 0;
 238         for (int looper = 0; looper < fLoopers.count(); looper++) {
 239             paint.setLooper(fLoopers[looper]);
 240             canvas->save();
 241             canvas->translate(0, SkIntToScalar(y));
 242             canvas->drawTextBlob(fBlob, 0, 0, paint);
 243             canvas->restore();
 244             y += SkScalarFloorToInt(bounds.height());
 245         }
 246     }
 247
 248 private:
 249     SkAutoTUnref<const SkTextBlob> fBlob;
 250     SkTArray<SkAutoTUnref<SkLayerDrawLooper>, true> fLoopers;
 251
 252     typedef GM INHERITED;
 253 };
 254
 255 //////////////////////////////////////////////////////////////////////////////
 256
 257 DEF_GM( return SkNEW(TextBlobLooperGM); )
 258 }