OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2012 Google Inc. | 2 * Copyright 2012 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 | 9 |
10 #include "SkBitmapProcShader.h" | |
11 #include "SkCanvas.h" | 10 #include "SkCanvas.h" |
12 #include "SkGradientShader.h" | 11 #include "SkGradientShader.h" |
13 #include "SkGraphics.h" | 12 #include "SkGraphics.h" |
14 #include "SkShader.h" | 13 #include "SkShader.h" |
15 #include "SkString.h" | 14 #include "SkString.h" |
16 #include "SkXfermode.h" | 15 #include "SkXfermode.h" |
17 | 16 |
18 static SkShader* make_shader(SkXfermode::Mode mode) { | 17 static sk_sp<SkShader> make_shader(SkXfermode::Mode mode) { |
19 SkPoint pts[2]; | 18 SkPoint pts[2]; |
20 SkColor colors[2]; | 19 SkColor colors[2]; |
21 | 20 |
22 pts[0].set(0, 0); | 21 pts[0].set(0, 0); |
23 pts[1].set(SkIntToScalar(100), 0); | 22 pts[1].set(SkIntToScalar(100), 0); |
24 colors[0] = SK_ColorRED; | 23 colors[0] = SK_ColorRED; |
25 colors[1] = SK_ColorBLUE; | 24 colors[1] = SK_ColorBLUE; |
26 SkAutoTUnref<SkShader> shaderA(SkGradientShader::CreateLinear(pts, colors, n
ullptr, 2, | 25 auto shaderA = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShade
r::kClamp_TileMode); |
27 SkShader::kCla
mp_TileMode)); | |
28 | 26 |
29 pts[0].set(0, 0); | 27 pts[0].set(0, 0); |
30 pts[1].set(0, SkIntToScalar(100)); | 28 pts[1].set(0, SkIntToScalar(100)); |
31 colors[0] = SK_ColorBLACK; | 29 colors[0] = SK_ColorBLACK; |
32 colors[1] = SkColorSetARGB(0x80, 0, 0, 0); | 30 colors[1] = SkColorSetARGB(0x80, 0, 0, 0); |
33 SkAutoTUnref<SkShader> shaderB(SkGradientShader::CreateLinear(pts, colors, n
ullptr, 2, | 31 auto shaderB = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShade
r::kClamp_TileMode); |
34 SkShader::kCla
mp_TileMode)); | |
35 | 32 |
36 SkAutoTUnref<SkXfermode> xfer(SkXfermode::Create(mode)); | 33 SkAutoTUnref<SkXfermode> xfer(SkXfermode::Create(mode)); |
37 | 34 |
38 return SkShader::CreateComposeShader(shaderA, shaderB, xfer); | 35 return SkShader::MakeComposeShader(std::move(shaderA), std::move(shaderB), x
fer); |
39 } | 36 } |
40 | 37 |
41 class ComposeShaderGM : public skiagm::GM { | 38 class ComposeShaderGM : public skiagm::GM { |
42 public: | 39 public: |
43 ComposeShaderGM() { | 40 ComposeShaderGM() { |
44 fShader = make_shader(SkXfermode::kDstIn_Mode); | 41 fShader = make_shader(SkXfermode::kDstIn_Mode); |
45 } | 42 } |
46 | 43 |
47 virtual ~ComposeShaderGM() { | |
48 SkSafeUnref(fShader); | |
49 } | |
50 | |
51 protected: | 44 protected: |
52 SkString onShortName() override { | 45 SkString onShortName() override { |
53 return SkString("composeshader"); | 46 return SkString("composeshader"); |
54 } | 47 } |
55 | 48 |
56 SkISize onISize() override { | 49 SkISize onISize() override { |
57 return SkISize::Make(120, 120); | 50 return SkISize::Make(120, 120); |
58 } | 51 } |
59 | 52 |
60 void onDraw(SkCanvas* canvas) override { | 53 void onDraw(SkCanvas* canvas) override { |
61 | |
62 SkPaint paint; | 54 SkPaint paint; |
63 | |
64 paint.setColor(SK_ColorGREEN); | 55 paint.setColor(SK_ColorGREEN); |
65 canvas->drawRectCoords(0, 0, SkIntToScalar(100), SkIntToScalar(100), pai
nt); | 56 canvas->drawRectCoords(0, 0, SkIntToScalar(100), SkIntToScalar(100), pai
nt); |
66 paint.setShader(fShader); | 57 paint.setShader(fShader); |
67 canvas->drawRectCoords(0, 0, SkIntToScalar(100), SkIntToScalar(100), pai
nt); | 58 canvas->drawRectCoords(0, 0, SkIntToScalar(100), SkIntToScalar(100), pai
nt); |
68 } | 59 } |
69 | 60 |
70 protected: | 61 protected: |
71 SkShader* fShader; | 62 sk_sp<SkShader> fShader; |
72 | 63 |
73 private: | 64 private: |
74 typedef GM INHERITED ; | 65 typedef GM INHERITED ; |
75 }; | 66 }; |
76 | 67 |
77 class ComposeShaderAlphaGM : public skiagm::GM { | 68 class ComposeShaderAlphaGM : public skiagm::GM { |
78 public: | 69 public: |
79 ComposeShaderAlphaGM() {} | 70 ComposeShaderAlphaGM() {} |
80 | 71 |
81 protected: | 72 protected: |
82 SkString onShortName() override { | 73 SkString onShortName() override { |
83 return SkString("composeshader_alpha"); | 74 return SkString("composeshader_alpha"); |
84 } | 75 } |
85 | 76 |
86 SkISize onISize() override { | 77 SkISize onISize() override { |
87 return SkISize::Make(750, 220); | 78 return SkISize::Make(750, 220); |
88 } | 79 } |
89 | 80 |
90 void onDraw(SkCanvas* canvas) override { | 81 void onDraw(SkCanvas* canvas) override { |
91 SkAutoTUnref<SkShader> shader0(make_shader(SkXfermode::kDstIn_Mode)); | 82 sk_sp<SkShader> shaders[] = { |
92 SkAutoTUnref<SkShader> shader1(make_shader(SkXfermode::kSrcOver_Mode)); | 83 make_shader(SkXfermode::kDstIn_Mode), |
93 SkShader* shaders[] = { shader0.get(), shader1.get() }; | 84 make_shader(SkXfermode::kSrcOver_Mode), |
| 85 }; |
94 | 86 |
95 SkPaint paint; | 87 SkPaint paint; |
96 paint.setColor(SK_ColorGREEN); | 88 paint.setColor(SK_ColorGREEN); |
97 | 89 |
98 const SkRect r = SkRect::MakeXYWH(5, 5, 100, 100); | 90 const SkRect r = SkRect::MakeXYWH(5, 5, 100, 100); |
99 | 91 |
100 for (size_t y = 0; y < SK_ARRAY_COUNT(shaders); ++y) { | 92 for (size_t y = 0; y < SK_ARRAY_COUNT(shaders); ++y) { |
101 SkShader* shader = shaders[y]; | |
102 canvas->save(); | 93 canvas->save(); |
103 for (int alpha = 0xFF; alpha > 0; alpha -= 0x28) { | 94 for (int alpha = 0xFF; alpha > 0; alpha -= 0x28) { |
104 paint.setAlpha(0xFF); | 95 paint.setAlpha(0xFF); |
105 paint.setShader(nullptr); | 96 paint.setShader(nullptr); |
106 canvas->drawRect(r, paint); | 97 canvas->drawRect(r, paint); |
107 | 98 |
108 paint.setAlpha(alpha); | 99 paint.setAlpha(alpha); |
109 paint.setShader(shader); | 100 paint.setShader(shaders[y]); |
110 canvas->drawRect(r, paint); | 101 canvas->drawRect(r, paint); |
111 | 102 |
112 canvas->translate(r.width() + 5, 0); | 103 canvas->translate(r.width() + 5, 0); |
113 } | 104 } |
114 canvas->restore(); | 105 canvas->restore(); |
115 canvas->translate(0, r.height() + 5); | 106 canvas->translate(0, r.height() + 5); |
116 } | 107 } |
117 } | 108 } |
118 | 109 |
119 private: | 110 private: |
(...skipping 21 matching lines...) Expand all Loading... |
141 | 132 |
142 bm->allocPixels(SkImageInfo::MakeA8(length, length)); | 133 bm->allocPixels(SkImageInfo::MakeA8(length, length)); |
143 bm->eraseColor(SK_ColorTRANSPARENT); | 134 bm->eraseColor(SK_ColorTRANSPARENT); |
144 | 135 |
145 SkCanvas canvas(*bm); | 136 SkCanvas canvas(*bm); |
146 canvas.drawCircle(SkIntToScalar(length/2), SkIntToScalar(length/2), SkIntToS
calar(length/4), | 137 canvas.drawCircle(SkIntToScalar(length/2), SkIntToScalar(length/2), SkIntToS
calar(length/4), |
147 circlePaint); | 138 circlePaint); |
148 } | 139 } |
149 | 140 |
150 // creates a linear gradient shader | 141 // creates a linear gradient shader |
151 static SkShader* make_linear_gradient_shader(int length) { | 142 static sk_sp<SkShader> make_linear_gradient_shader(int length) { |
152 SkPoint pts[2]; | 143 SkPoint pts[2]; |
153 SkColor colors[2]; | 144 SkColor colors[2]; |
154 pts[0].set(0, 0); | 145 pts[0].set(0, 0); |
155 pts[1].set(SkIntToScalar(length), 0); | 146 pts[1].set(SkIntToScalar(length), 0); |
156 colors[0] = SK_ColorBLUE; | 147 colors[0] = SK_ColorBLUE; |
157 colors[1] = SkColorSetARGB(0, 0, 0, 0xFF); | 148 colors[1] = SkColorSetARGB(0, 0, 0, 0xFF); |
158 return SkGradientShader::CreateLinear(pts, colors, nullptr, 2, SkShader::kCl
amp_TileMode); | 149 return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClam
p_TileMode); |
159 } | 150 } |
160 | 151 |
161 | 152 |
162 class ComposeShaderBitmapGM : public skiagm::GM { | 153 class ComposeShaderBitmapGM : public skiagm::GM { |
163 public: | 154 public: |
164 ComposeShaderBitmapGM() {} | 155 ComposeShaderBitmapGM() {} |
165 ~ComposeShaderBitmapGM() { | |
166 SkSafeUnref(fColorBitmapShader); | |
167 SkSafeUnref(fAlpha8BitmapShader); | |
168 SkSafeUnref(fLinearGradientShader); | |
169 } | |
170 | 156 |
171 protected: | 157 protected: |
172 void onOnceBeforeDraw() override { | 158 void onOnceBeforeDraw() override { |
173 draw_color_bm(&fColorBitmap, squareLength); | 159 draw_color_bm(&fColorBitmap, squareLength); |
174 draw_alpha8_bm(&fAlpha8Bitmap, squareLength); | 160 draw_alpha8_bm(&fAlpha8Bitmap, squareLength); |
175 SkMatrix s; | 161 SkMatrix s; |
176 s.reset(); | 162 s.reset(); |
177 fColorBitmapShader = new SkBitmapProcShader(fColorBitmap, SkShader::kRep
eat_TileMode, | 163 fColorBitmapShader = SkShader::MakeBitmapShader(fColorBitmap, SkShader::
kRepeat_TileMode, |
178 SkShader::kRepeat_TileMode,
&s); | 164 SkShader::kRepeat_TileMo
de, &s); |
179 fAlpha8BitmapShader = new SkBitmapProcShader(fAlpha8Bitmap, SkShader::kR
epeat_TileMode, | 165 fAlpha8BitmapShader = SkShader::MakeBitmapShader(fAlpha8Bitmap, SkShader
::kRepeat_TileMode, |
180 SkShader::kRepeat_TileMode,
&s); | 166 SkShader::kRepeat_TileM
ode, &s); |
181 fLinearGradientShader = make_linear_gradient_shader(squareLength); | 167 fLinearGradientShader = make_linear_gradient_shader(squareLength); |
182 } | 168 } |
183 | 169 |
184 SkString onShortName() override { | 170 SkString onShortName() override { |
185 return SkString("composeshader_bitmap"); | 171 return SkString("composeshader_bitmap"); |
186 } | 172 } |
187 | 173 |
188 SkISize onISize() override { | 174 SkISize onISize() override { |
189 return SkISize::Make(7 * (squareLength + 5), 2 * (squareLength + 5)); | 175 return SkISize::Make(7 * (squareLength + 5), 2 * (squareLength + 5)); |
190 } | 176 } |
191 | 177 |
192 void onDraw(SkCanvas* canvas) override { | 178 void onDraw(SkCanvas* canvas) override { |
193 SkAutoTUnref<SkXfermode> xfer(SkXfermode::Create(SkXfermode::kDstOver_Mo
de)); | 179 SkAutoTUnref<SkXfermode> xfer(SkXfermode::Create(SkXfermode::kDstOver_Mo
de)); |
194 | 180 |
195 // gradient should appear over color bitmap | 181 sk_sp<SkShader> shaders[] = { |
196 SkAutoTUnref<SkShader> shader0(SkShader::CreateComposeShader(fLinearGrad
ientShader, | 182 // gradient should appear over color bitmap |
197 fColorBitmapShader, | 183 SkShader::MakeComposeShader(fLinearGradientShader, fColorBitmapShade
r, xfer), |
198 xfer)); | 184 // gradient should appear over alpha8 bitmap colorized by the paint
color |
199 // gradient should appear over alpha8 bitmap colorized by the paint colo
r | 185 SkShader::MakeComposeShader(fLinearGradientShader, fAlpha8BitmapShad
er, xfer), |
200 SkAutoTUnref<SkShader> shader1(SkShader::CreateComposeShader(fLinearGrad
ientShader, | 186 }; |
201 fAlpha8BitmapShader, | |
202 xfer)); | |
203 | |
204 SkShader* shaders[] = { shader0.get(), shader1.get() }; | |
205 | 187 |
206 SkPaint paint; | 188 SkPaint paint; |
207 paint.setColor(SK_ColorYELLOW); | 189 paint.setColor(SK_ColorYELLOW); |
208 | 190 |
209 const SkRect r = SkRect::MakeXYWH(0, 0, SkIntToScalar(squareLength), | 191 const SkRect r = SkRect::MakeXYWH(0, 0, SkIntToScalar(squareLength), |
210 SkIntToScalar(squareLength)); | 192 SkIntToScalar(squareLength)); |
211 | 193 |
212 for (size_t y = 0; y < SK_ARRAY_COUNT(shaders); ++y) { | 194 for (size_t y = 0; y < SK_ARRAY_COUNT(shaders); ++y) { |
213 SkShader* shader = shaders[y]; | |
214 canvas->save(); | 195 canvas->save(); |
215 for (int alpha = 0xFF; alpha > 0; alpha -= 0x28) { | 196 for (int alpha = 0xFF; alpha > 0; alpha -= 0x28) { |
216 paint.setAlpha(alpha); | 197 paint.setAlpha(alpha); |
217 paint.setShader(shader); | 198 paint.setShader(shaders[y]); |
218 canvas->drawRect(r, paint); | 199 canvas->drawRect(r, paint); |
219 | 200 |
220 canvas->translate(r.width() + 5, 0); | 201 canvas->translate(r.width() + 5, 0); |
221 } | 202 } |
222 canvas->restore(); | 203 canvas->restore(); |
223 canvas->translate(0, r.height() + 5); | 204 canvas->translate(0, r.height() + 5); |
224 } | 205 } |
225 } | 206 } |
226 | 207 |
227 private: | 208 private: |
228 /** This determines the length and width of the bitmaps used in the ComposeS
haders. Values | 209 /** This determines the length and width of the bitmaps used in the ComposeS
haders. Values |
229 * above 20 may cause an SkASSERT to fail in SkSmallAllocator. However, lar
ger values will | 210 * above 20 may cause an SkASSERT to fail in SkSmallAllocator. However, lar
ger values will |
230 * work in a release build. You can change this parameter and then compile
a release build | 211 * work in a release build. You can change this parameter and then compile
a release build |
231 * to have this GM draw larger bitmaps for easier visual inspection. | 212 * to have this GM draw larger bitmaps for easier visual inspection. |
232 */ | 213 */ |
233 static const int squareLength = 20; | 214 static const int squareLength = 20; |
234 | 215 |
235 SkBitmap fColorBitmap; | 216 SkBitmap fColorBitmap; |
236 SkBitmap fAlpha8Bitmap; | 217 SkBitmap fAlpha8Bitmap; |
237 SkShader* fColorBitmapShader{nullptr}; | 218 sk_sp<SkShader> fColorBitmapShader; |
238 SkShader* fAlpha8BitmapShader{nullptr}; | 219 sk_sp<SkShader> fAlpha8BitmapShader; |
239 SkShader* fLinearGradientShader{nullptr}; | 220 sk_sp<SkShader> fLinearGradientShader; |
240 | 221 |
241 typedef GM INHERITED; | 222 typedef GM INHERITED; |
242 }; | 223 }; |
243 | 224 |
244 ////////////////////////////////////////////////////////////////////////////// | 225 ////////////////////////////////////////////////////////////////////////////// |
245 | 226 |
246 DEF_GM( return new ComposeShaderGM; ) | 227 DEF_GM( return new ComposeShaderGM; ) |
247 DEF_GM( return new ComposeShaderAlphaGM; ) | 228 DEF_GM( return new ComposeShaderAlphaGM; ) |
248 DEF_GM( return new ComposeShaderBitmapGM; ) | 229 DEF_GM( return new ComposeShaderBitmapGM; ) |
OLD | NEW |