• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #include "SkBlurMask.h"
10 #include "SkBlurMaskFilter.h"
11 #include "SkCanvas.h"
12 #include "SkColorFilter.h"
13 #include "SkLayerDrawLooper.h"
14 
15 // This GM tests 3 different ways of drawing four shadows around a square:
16 //      just using 4 blurred rects
17 //      using 4 1-level draw loopers
18 //      using 1 4-level draw looper
19 // They all produce exactly the same pixels
20 class MegaLooperGM : public skiagm::GM {
21 public:
22     // The types define "<# of loopers> x <# of stages per looper>"
23     enum Type {
24         k0x0_Type,  // draw without loopers at all
25         k4x1_Type,  // a looper for each shadow
26         k1x4_Type,  // all four shadows in one looper
27     };
28 
MegaLooperGM(Type type)29     MegaLooperGM(Type type) : fType(type) {}
30 
31 protected:
onShortName()32     virtual SkString onShortName() {
33         switch (fType) {
34         case k0x0_Type:
35             return SkString("megalooper_0x0");
36             break;
37         case k4x1_Type:
38             return SkString("megalooper_4x1");
39             break;
40         case k1x4_Type:     // fall through
41         default:
42             return SkString("megalooper_1x4");
43             break;
44         }
45     }
46 
onISize()47     virtual SkISize onISize() {
48         return SkISize::Make(kWidth, kHeight);
49     }
50 
onDraw(SkCanvas * canvas)51     virtual void onDraw(SkCanvas* canvas) {
52         for (int y = 100; y < kHeight; y += 200) {
53             for (int x = 100; x < kWidth; x += 200) {
54                 switch (fType) {
55                     case k0x0_Type:
56                         draw0x0(canvas, SkIntToScalar(x), SkIntToScalar(y));
57                         break;
58                     case k4x1_Type:
59                         draw4x1(canvas, SkIntToScalar(x), SkIntToScalar(y));
60                         break;
61                     case k1x4_Type:     // fall through
62                     default:
63                         draw1x4(canvas, SkIntToScalar(x), SkIntToScalar(y));
64                         break;
65                 }
66             }
67         }
68     }
69 
70 private:
71     static const int kWidth = 800;
72     static const int kHeight = 800;
73     static const int kHalfOuterClipSize = 100;
74     static const int kHalfSquareSize = 50;
75     static const int kOffsetToOutsideClip = kHalfSquareSize + kHalfOuterClipSize + 1;
76 
77     static const SkPoint gBlurOffsets[4];
78     static const SkColor gColors[4];
79     Type fType;
80 
81     // Just draw a blurred rect at each of the four corners of a square (centered at x,y).
82     // Use two clips to define a rectori where we want pixels to appear.
draw0x0(SkCanvas * canvas,SkScalar x,SkScalar y)83     void draw0x0(SkCanvas* canvas, SkScalar x, SkScalar y) {
84         SkRect innerClip = { -kHalfSquareSize, -kHalfSquareSize, kHalfSquareSize, kHalfSquareSize };
85         innerClip.offset(x, y);
86 
87         SkRect outerClip = {
88             -kHalfOuterClipSize-kHalfSquareSize, -kHalfOuterClipSize-kHalfSquareSize,
89              kHalfOuterClipSize+kHalfSquareSize,  kHalfOuterClipSize+kHalfSquareSize
90         };
91         outerClip.offset(x, y);
92 
93         canvas->save();
94         canvas->clipRect(outerClip, SkRegion::kIntersect_Op);
95         canvas->clipRect(innerClip, SkRegion::kDifference_Op);
96 
97         SkPaint paint;
98         paint.setAntiAlias(true);
99         paint.setMaskFilter(createBlur())->unref();
100 
101         for (int i = 0; i < 4; ++i) {
102             paint.setColor(gColors[i]);
103 
104             SkRect rect = { -kHalfSquareSize, -kHalfSquareSize, kHalfSquareSize, kHalfSquareSize };
105             rect.offset(gBlurOffsets[i]);
106             rect.offset(x, y);
107             canvas->drawRect(rect, paint);
108         }
109 
110         canvas->restore();
111     }
112 
createBlur()113     SkMaskFilter* createBlur() {
114         static const SkScalar kBlurSigma = SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(25));
115 
116         return SkBlurMaskFilter::Create(kNormal_SkBlurStyle, kBlurSigma,
117                                         SkBlurMaskFilter::kHighQuality_BlurFlag);
118     }
119 
120     // This draws 4 blurred shadows around a single square (centered at x, y).
121     // Each blur is offset +/- half the square's side in x & y from the original
122     // (so each blurred rect is centered at one of the corners of the original).
123     // For each blur a large outer clip is centered around the blurred rect
124     // while a difference clip stays at the location of the original rect.
125     // Each blurred rect is drawn with a draw looper where the original (non-
126     // blurred rect) is offset to reside outside of the large outer clip (so
127     // it never appears) but the offset in the draw looper is used to translate
128     // the blurred version back into the clip.
draw4x1(SkCanvas * canvas,SkScalar x,SkScalar y)129     void draw4x1(SkCanvas* canvas, SkScalar x, SkScalar y) {
130 
131         for (int i = 0; i < 4; ++i) {
132             SkPaint loopPaint;
133 
134             loopPaint.setLooper(create1Looper(-kOffsetToOutsideClip, 0, gColors[i]))->unref();
135             loopPaint.setAntiAlias(true);
136 
137             SkRect outerClip = {
138                 -kHalfOuterClipSize, -kHalfOuterClipSize,
139                 kHalfOuterClipSize, kHalfOuterClipSize
140             };
141             outerClip.offset(x, y);
142             // center it on the blurred rect
143             outerClip.offset(gBlurOffsets[i]);
144 
145             SkRect rect = { -kHalfSquareSize, -kHalfSquareSize, kHalfSquareSize, kHalfSquareSize };
146             rect.offset(x, y);
147 
148             canvas->save();
149                 canvas->clipRect(outerClip, SkRegion::kIntersect_Op);
150                 canvas->clipRect(rect, SkRegion::kDifference_Op);
151 
152                 // move the rect to where we want the blur to appear
153                 rect.offset(gBlurOffsets[i]);
154                 // then move it outside the clip (the blur stage of the draw
155                 // looper will undo this translation)
156                 rect.offset(SkIntToScalar(kOffsetToOutsideClip), 0);
157 
158                 canvas->drawRect(rect, loopPaint);
159             canvas->restore();
160         }
161     }
162 
163     // Create a 1-tier drawlooper
create1Looper(SkScalar xOff,SkScalar yOff,SkColor color)164     SkLayerDrawLooper* create1Looper(SkScalar xOff, SkScalar yOff, SkColor color) {
165         SkLayerDrawLooper::Builder looperBuilder;
166         SkLayerDrawLooper::LayerInfo info;
167 
168         info.fPaintBits = SkLayerDrawLooper::kColorFilter_Bit |
169                           SkLayerDrawLooper::kMaskFilter_Bit;
170         info.fColorMode = SkXfermode::kSrc_Mode;
171         info.fOffset.set(xOff, yOff);
172         info.fPostTranslate = false;
173 
174         SkPaint* paint = looperBuilder.addLayer(info);
175 
176         paint->setMaskFilter(this->createBlur())->unref();
177 
178         SkColorFilter* cf = SkColorFilter::CreateModeFilter(color, SkXfermode::kSrcIn_Mode);
179         paint->setColorFilter(cf)->unref();
180 
181         return looperBuilder.detachLooper();
182     }
183 
draw1x4(SkCanvas * canvas,SkScalar x,SkScalar y)184     void draw1x4(SkCanvas* canvas, SkScalar x, SkScalar y) {
185         SkRect rect = { -kHalfSquareSize, -kHalfSquareSize, kHalfSquareSize, kHalfSquareSize };
186         rect.offset(x, y);
187 
188         SkRect outerClip = {
189             -kHalfOuterClipSize-kHalfSquareSize, -kHalfOuterClipSize-kHalfSquareSize,
190              kHalfOuterClipSize+kHalfSquareSize,  kHalfOuterClipSize+kHalfSquareSize
191         };
192         outerClip.offset(x, y);
193 
194         SkPaint paint;
195         paint.setAntiAlias(true);
196         paint.setLooper(create4Looper(-kOffsetToOutsideClip-kHalfSquareSize, 0))->unref();
197 
198         canvas->save();
199             canvas->clipRect(outerClip, SkRegion::kIntersect_Op);
200             canvas->clipRect(rect, SkRegion::kDifference_Op);
201 
202             rect.offset(SkIntToScalar(kOffsetToOutsideClip+kHalfSquareSize), 0);
203             canvas->drawRect(rect, paint);
204         canvas->restore();
205     }
206 
207     // Create a 4-tier draw looper
create4Looper(SkScalar xOff,SkScalar yOff)208     SkLayerDrawLooper* create4Looper(SkScalar xOff, SkScalar yOff) {
209         SkLayerDrawLooper::Builder looperBuilder;
210         SkLayerDrawLooper::LayerInfo info;
211 
212         info.fPaintBits = SkLayerDrawLooper::kColorFilter_Bit |
213                           SkLayerDrawLooper::kMaskFilter_Bit;
214         info.fColorMode = SkXfermode::kSrc_Mode;
215         info.fPostTranslate = false;
216 
217         SkPaint* paint;
218 
219         for (int i = 3; i >= 0; --i) {
220             info.fOffset.set(xOff+gBlurOffsets[i].fX, yOff+gBlurOffsets[i].fY);
221             paint = looperBuilder.addLayer(info);
222 
223             paint->setMaskFilter(this->createBlur())->unref();
224 
225             SkColorFilter* cf = SkColorFilter::CreateModeFilter(gColors[i], SkXfermode::kSrcIn_Mode);
226             paint->setColorFilter(cf)->unref();
227         }
228 
229         return looperBuilder.detachLooper();
230     }
231 
232     typedef GM INHERITED;
233 };
234 
235 const SkPoint MegaLooperGM::gBlurOffsets[4] = {
236     {  kHalfSquareSize,  kHalfSquareSize },
237     { -kHalfSquareSize,  kHalfSquareSize },
238     {  kHalfSquareSize, -kHalfSquareSize },
239     { -kHalfSquareSize, -kHalfSquareSize }
240 };
241 
242 const SkColor MegaLooperGM::gColors[4] = {
243     SK_ColorGREEN, SK_ColorYELLOW, SK_ColorBLUE, SK_ColorRED
244 };
245 
246 DEF_GM( return new MegaLooperGM(MegaLooperGM::k0x0_Type); )
247 DEF_GM( return new MegaLooperGM(MegaLooperGM::k4x1_Type); )
248 DEF_GM( return new MegaLooperGM(MegaLooperGM::k1x4_Type); )
249