OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2011 Google Inc. | 2 * Copyright 2011 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "gm.h" | 8 #include "gm.h" |
9 #include "SkCanvas.h" | 9 #include "SkCanvas.h" |
10 #include "SkColorFilter.h" | 10 #include "SkColorFilter.h" |
11 #include "SkColorPriv.h" | 11 #include "SkColorPriv.h" |
12 #include "SkShader.h" | 12 #include "SkShader.h" |
13 | 13 |
14 #include "SkBlurImageFilter.h" | 14 #include "SkBlurImageFilter.h" |
15 #include "SkColorFilterImageFilter.h" | 15 #include "SkColorFilterImageFilter.h" |
16 #include "SkTestImageFilters.h" | 16 #include "SkTestImageFilters.h" |
17 | 17 |
18 class FailImageFilter : public SkImageFilter { | |
19 public: | |
20 FailImageFilter() : INHERITED(0) {} | |
21 | |
22 SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(FailImageFilter) | |
23 protected: | |
24 virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&, | |
25 SkBitmap* result, SkIPoint* offset) { | |
26 return false; | |
27 } | |
28 | |
29 FailImageFilter(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {} | |
30 | |
31 private: | |
32 typedef SkImageFilter INHERITED; | |
33 }; | |
34 | |
35 // register the filter with the flattenable registry | |
36 static SkFlattenable::Registrar gFailImageFilterReg("FailImageFilter", | |
37 FailImageFilter::CreateProc)
; | |
38 | |
39 class IdentityImageFilter : public SkImageFilter { | |
40 public: | |
41 IdentityImageFilter() : INHERITED(0) {} | |
42 | |
43 SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(IdentityImageFilter) | |
44 protected: | |
45 virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&, | |
46 SkBitmap* result, SkIPoint* offset) { | |
47 *result = src; | |
48 return true; | |
49 } | |
50 | |
51 IdentityImageFilter(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {} | |
52 | |
53 private: | |
54 typedef SkImageFilter INHERITED; | |
55 }; | |
56 | |
57 // register the filter with the flattenable registry | |
58 static SkFlattenable::Registrar gIdentityImageFilterReg("IdentityImageFilter", | |
59 IdentityImageFilter::Cre
ateProc); | |
60 | |
61 | |
62 /////////////////////////////////////////////////////////////////////////////// | 18 /////////////////////////////////////////////////////////////////////////////// |
63 | 19 |
64 static void draw_paint(SkCanvas* canvas, const SkRect& r, SkImageFilter* imf) { | 20 static void draw_paint(SkCanvas* canvas, const SkRect& r, SkImageFilter* imf) { |
65 SkPaint paint; | 21 SkPaint paint; |
66 paint.setImageFilter(imf); | 22 paint.setImageFilter(imf); |
67 paint.setColor(SK_ColorGREEN); | 23 paint.setColor(SK_ColorBLACK); |
68 canvas->save(); | 24 canvas->save(); |
69 canvas->clipRect(r); | 25 canvas->clipRect(r); |
70 canvas->drawPaint(paint); | 26 canvas->drawPaint(paint); |
71 canvas->restore(); | 27 canvas->restore(); |
72 } | 28 } |
73 | 29 |
74 static void draw_line(SkCanvas* canvas, const SkRect& r, SkImageFilter* imf) { | |
75 SkPaint paint; | |
76 paint.setColor(SK_ColorBLUE); | |
77 paint.setImageFilter(imf); | |
78 paint.setStrokeWidth(r.width()/10); | |
79 canvas->drawLine(r.fLeft, r.fTop, r.fRight, r.fBottom, paint); | |
80 } | |
81 | |
82 static void draw_rect(SkCanvas* canvas, const SkRect& r, SkImageFilter* imf) { | |
83 SkPaint paint; | |
84 paint.setColor(SK_ColorYELLOW); | |
85 paint.setImageFilter(imf); | |
86 SkRect rr(r); | |
87 rr.inset(r.width()/10, r.height()/10); | |
88 canvas->drawRect(rr, paint); | |
89 } | |
90 | |
91 static void draw_path(SkCanvas* canvas, const SkRect& r, SkImageFilter* imf) { | 30 static void draw_path(SkCanvas* canvas, const SkRect& r, SkImageFilter* imf) { |
92 SkPaint paint; | 31 SkPaint paint; |
93 paint.setColor(SK_ColorMAGENTA); | 32 paint.setColor(SK_ColorMAGENTA); |
94 paint.setImageFilter(imf); | 33 paint.setImageFilter(imf); |
95 paint.setAntiAlias(true); | 34 paint.setAntiAlias(true); |
| 35 canvas->save(); |
| 36 canvas->clipRect(r); |
96 canvas->drawCircle(r.centerX(), r.centerY(), r.width()*2/5, paint); | 37 canvas->drawCircle(r.centerX(), r.centerY(), r.width()*2/5, paint); |
| 38 canvas->restore(); |
97 } | 39 } |
98 | 40 |
99 static void draw_text(SkCanvas* canvas, const SkRect& r, SkImageFilter* imf) { | 41 static void draw_text(SkCanvas* canvas, const SkRect& r, SkImageFilter* imf) { |
100 SkPaint paint; | 42 SkPaint paint; |
101 paint.setImageFilter(imf); | 43 paint.setImageFilter(imf); |
102 paint.setColor(SK_ColorCYAN); | 44 paint.setColor(SK_ColorGREEN); |
103 paint.setAntiAlias(true); | 45 paint.setAntiAlias(true); |
104 paint.setTextSize(r.height()/2); | 46 paint.setTextSize(r.height()/2); |
105 paint.setTextAlign(SkPaint::kCenter_Align); | 47 paint.setTextAlign(SkPaint::kCenter_Align); |
| 48 canvas->save(); |
| 49 canvas->clipRect(r); |
106 canvas->drawText("Text", 4, r.centerX(), r.centerY(), paint); | 50 canvas->drawText("Text", 4, r.centerX(), r.centerY(), paint); |
| 51 canvas->restore(); |
107 } | 52 } |
108 | 53 |
109 static void draw_bitmap(SkCanvas* canvas, const SkRect& r, SkImageFilter* imf) { | 54 static void draw_bitmap(SkCanvas* canvas, const SkRect& r, SkImageFilter* imf) { |
110 SkPaint paint; | 55 SkPaint paint; |
111 paint.setImageFilter(imf); | |
112 | 56 |
113 SkIRect bounds; | 57 SkIRect bounds; |
114 r.roundOut(&bounds); | 58 r.roundOut(&bounds); |
115 | 59 |
116 SkBitmap bm; | 60 SkBitmap bm; |
117 bm.setConfig(SkBitmap::kARGB_8888_Config, bounds.width(), bounds.height()); | 61 bm.setConfig(SkBitmap::kARGB_8888_Config, bounds.width(), bounds.height()); |
118 bm.allocPixels(); | 62 bm.allocPixels(); |
119 bm.eraseColor(SK_ColorTRANSPARENT); | 63 bm.eraseColor(SK_ColorTRANSPARENT); |
120 SkCanvas c(bm); | 64 SkCanvas c(bm); |
121 draw_path(&c, r, NULL); | 65 draw_path(&c, r, NULL); |
122 | 66 |
| 67 paint.setImageFilter(imf); |
| 68 canvas->save(); |
| 69 canvas->clipRect(r); |
123 canvas->drawBitmap(bm, 0, 0, &paint); | 70 canvas->drawBitmap(bm, 0, 0, &paint); |
| 71 canvas->restore(); |
124 } | 72 } |
125 | 73 |
126 static void draw_sprite(SkCanvas* canvas, const SkRect& r, SkImageFilter* imf) { | 74 static void draw_sprite(SkCanvas* canvas, const SkRect& r, SkImageFilter* imf) { |
127 SkPaint paint; | 75 SkPaint paint; |
128 paint.setImageFilter(imf); | |
129 | 76 |
130 SkIRect bounds; | 77 SkIRect bounds; |
131 r.roundOut(&bounds); | 78 r.roundOut(&bounds); |
132 | 79 |
133 SkBitmap bm; | 80 SkBitmap bm; |
134 bm.setConfig(SkBitmap::kARGB_8888_Config, bounds.width(), bounds.height()); | 81 bm.setConfig(SkBitmap::kARGB_8888_Config, bounds.width(), bounds.height()); |
135 bm.allocPixels(); | 82 bm.allocPixels(); |
136 bm.eraseColor(SK_ColorTRANSPARENT); | 83 bm.eraseColor(SK_ColorRED); |
137 SkCanvas c(bm); | 84 SkCanvas c(bm); |
138 draw_path(&c, r, NULL); | |
139 | 85 |
| 86 SkIRect cropRect = SkIRect::MakeXYWH(10, 10, 44, 44); |
| 87 paint.setColor(SK_ColorGREEN); |
| 88 c.drawRect(SkRect::Make(cropRect), paint); |
| 89 |
| 90 paint.setImageFilter(imf); |
140 SkPoint loc = { r.fLeft, r.fTop }; | 91 SkPoint loc = { r.fLeft, r.fTop }; |
141 canvas->getTotalMatrix().mapPoints(&loc, 1); | 92 canvas->getTotalMatrix().mapPoints(&loc, 1); |
142 canvas->drawSprite(bm, | 93 canvas->drawSprite(bm, |
143 SkScalarRoundToInt(loc.fX), SkScalarRoundToInt(loc.fY), | 94 SkScalarRoundToInt(loc.fX), SkScalarRoundToInt(loc.fY), |
144 &paint); | 95 &paint); |
145 } | 96 } |
146 | 97 |
147 /////////////////////////////////////////////////////////////////////////////// | 98 /////////////////////////////////////////////////////////////////////////////// |
148 | 99 |
149 class ImageFiltersBaseGM : public skiagm::GM { | 100 class ImageFiltersCroppedGM : public skiagm::GM { |
150 public: | 101 public: |
151 ImageFiltersBaseGM () {} | 102 ImageFiltersCroppedGM () {} |
152 | 103 |
153 protected: | 104 protected: |
154 | 105 |
155 virtual SkString onShortName() { | 106 virtual SkString onShortName() { |
156 return SkString("imagefiltersbase"); | 107 return SkString("imagefilterscropped"); |
157 } | 108 } |
158 | 109 |
159 virtual SkISize onISize() { return SkISize::Make(700, 460); } | 110 virtual SkISize onISize() { return SkISize::Make(700, 460); } |
160 | 111 |
161 void draw_frame(SkCanvas* canvas, const SkRect& r) { | 112 void draw_frame(SkCanvas* canvas, const SkRect& r) { |
162 SkPaint paint; | 113 SkPaint paint; |
163 paint.setStyle(SkPaint::kStroke_Style); | 114 paint.setStyle(SkPaint::kStroke_Style); |
164 paint.setColor(SK_ColorRED); | 115 paint.setColor(SK_ColorRED); |
165 canvas->drawRect(r, paint); | 116 canvas->drawRect(r, paint); |
166 } | 117 } |
167 | 118 |
168 virtual uint32_t onGetFlags() const { | 119 virtual uint32_t onGetFlags() const { |
169 // Because of the use of drawSprite, this test is excluded | 120 // Because of the use of drawSprite, this test is excluded |
170 // from scaled replay tests because drawSprite ignores the | 121 // from scaled replay tests because drawSprite ignores the |
171 // reciprocal scale that is applied at record time, which is | 122 // reciprocal scale that is applied at record time, which is |
172 // the intended behavior of drawSprite. | 123 // the intended behavior of drawSprite. |
173 return kSkipScaledReplay_Flag; | 124 return kSkipScaledReplay_Flag; |
174 } | 125 } |
175 | 126 |
176 virtual void onDraw(SkCanvas* canvas) { | 127 virtual void onDraw(SkCanvas* canvas) { |
177 void (*drawProc[])(SkCanvas*, const SkRect&, SkImageFilter*) = { | 128 void (*drawProc[])(SkCanvas*, const SkRect&, SkImageFilter*) = { |
178 draw_paint, | 129 draw_sprite, draw_bitmap, draw_path, draw_paint, draw_text |
179 draw_line, draw_rect, draw_path, draw_text, | |
180 draw_bitmap, | |
181 draw_sprite | |
182 }; | 130 }; |
183 | 131 |
184 SkColorFilter* cf = SkColorFilter::CreateModeFilter(SK_ColorRED, | 132 SkColorFilter* cf = SkColorFilter::CreateModeFilter(SK_ColorRED, |
185 SkXfermode::kSrcIn_Mode); | 133 SkXfermode::kSrcIn_Mode); |
| 134 SkIRect cropRect = SkIRect::MakeXYWH(10, 10, 44, 44); |
| 135 SkIRect bogusRect = SkIRect::MakeXYWH(-100, -100, 10, 10); |
| 136 |
186 SkImageFilter* filters[] = { | 137 SkImageFilter* filters[] = { |
187 NULL, | 138 NULL, |
188 new IdentityImageFilter, | 139 SkColorFilterImageFilter::Create(cf, NULL, &cropRect), |
189 new FailImageFilter, | 140 new SkBlurImageFilter(8.0f, 0.0f, NULL, &cropRect), |
190 SkColorFilterImageFilter::Create(cf), | 141 new SkBlurImageFilter(0.0f, 8.0f, NULL, &cropRect), |
191 new SkBlurImageFilter(12.0f, 0.0f), | 142 new SkBlurImageFilter(8.0f, 8.0f, NULL, &cropRect), |
| 143 new SkBlurImageFilter(8.0f, 8.0f, NULL, &bogusRect), |
| 144 SkColorFilterImageFilter::Create(cf, NULL, &bogusRect), |
192 }; | 145 }; |
193 cf->unref(); | 146 cf->unref(); |
194 | 147 |
195 SkRect r = SkRect::MakeWH(SkIntToScalar(64), SkIntToScalar(64)); | 148 SkRect r = SkRect::MakeWH(SkIntToScalar(64), SkIntToScalar(64)); |
196 SkScalar MARGIN = SkIntToScalar(16); | 149 SkScalar MARGIN = SkIntToScalar(16); |
197 SkScalar DX = r.width() + MARGIN; | 150 SkScalar DX = r.width() + MARGIN; |
198 SkScalar DY = r.height() + MARGIN; | 151 SkScalar DY = r.height() + MARGIN; |
199 | 152 |
200 canvas->translate(MARGIN, MARGIN); | 153 canvas->translate(MARGIN, MARGIN); |
201 for (size_t i = 0; i < SK_ARRAY_COUNT(drawProc); ++i) { | 154 for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) { |
202 canvas->save(); | 155 canvas->save(); |
203 for (size_t j = 0; j < SK_ARRAY_COUNT(filters); ++j) { | 156 for (size_t j = 0; j < SK_ARRAY_COUNT(drawProc); ++j) { |
204 drawProc[i](canvas, r, filters[j]); | 157 drawProc[j](canvas, r, filters[i]); |
205 | |
206 draw_frame(canvas, r); | |
207 canvas->translate(0, DY); | 158 canvas->translate(0, DY); |
208 } | 159 } |
209 canvas->restore(); | 160 canvas->restore(); |
210 canvas->translate(DX, 0); | 161 canvas->translate(DX, 0); |
211 } | 162 } |
212 | 163 |
213 for(size_t j = 0; j < SK_ARRAY_COUNT(filters); ++j) { | 164 for(size_t j = 0; j < SK_ARRAY_COUNT(filters); ++j) { |
214 SkSafeUnref(filters[j]); | 165 SkSafeUnref(filters[j]); |
215 } | 166 } |
216 } | 167 } |
217 | 168 |
218 private: | 169 private: |
219 typedef GM INHERITED; | 170 typedef GM INHERITED; |
220 }; | 171 }; |
221 | 172 |
222 /////////////////////////////////////////////////////////////////////////////// | 173 /////////////////////////////////////////////////////////////////////////////// |
223 | 174 |
224 static skiagm::GM* MyFactory(void*) { return new ImageFiltersBaseGM; } | 175 static skiagm::GM* MyFactory(void*) { return new ImageFiltersCroppedGM; } |
225 static skiagm::GMRegistry reg(MyFactory); | 176 static skiagm::GMRegistry reg(MyFactory); |
OLD | NEW |