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