OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2012 The Android Open Source Project | 2 * Copyright 2012 The Android Open Source Project |
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 "SkBitmap.h" | 8 #include "SkBitmap.h" |
9 #include "SkMagnifierImageFilter.h" | 9 #include "SkMagnifierImageFilter.h" |
10 #include "SkColorPriv.h" | 10 #include "SkColorPriv.h" |
11 #include "SkReadBuffer.h" | 11 #include "SkReadBuffer.h" |
12 #include "SkWriteBuffer.h" | 12 #include "SkWriteBuffer.h" |
13 #include "SkValidationUtils.h" | 13 #include "SkValidationUtils.h" |
14 | 14 |
15 //////////////////////////////////////////////////////////////////////////////// | 15 //////////////////////////////////////////////////////////////////////////////// |
16 #if SK_SUPPORT_GPU | 16 #if SK_SUPPORT_GPU |
17 #include "GrInvariantOutput.h" | 17 #include "GrInvariantOutput.h" |
18 #include "effects/GrSingleTextureEffect.h" | 18 #include "effects/GrSingleTextureEffect.h" |
19 #include "gl/GrGLProcessor.h" | 19 #include "gl/GrGLProcessor.h" |
20 #include "gl/GrGLSL.h" | 20 #include "gl/GrGLSL.h" |
21 #include "gl/GrGLTexture.h" | 21 #include "gl/GrGLTexture.h" |
22 #include "gl/builders/GrGLProgramBuilder.h" | 22 #include "gl/builders/GrGLProgramBuilder.h" |
23 | 23 |
24 class GrMagnifierEffect : public GrSingleTextureEffect { | 24 class GrMagnifierEffect : public GrSingleTextureEffect { |
25 | 25 |
26 public: | 26 public: |
27 static GrFragmentProcessor* Create(GrTexture* texture, | 27 static GrFragmentProcessor* Create(GrTexture* texture, |
| 28 const SkRect& bounds, |
28 float xOffset, | 29 float xOffset, |
29 float yOffset, | 30 float yOffset, |
30 float xInvZoom, | 31 float xInvZoom, |
31 float yInvZoom, | 32 float yInvZoom, |
32 float xInvInset, | 33 float xInvInset, |
33 float yInvInset) { | 34 float yInvInset) { |
34 return SkNEW_ARGS(GrMagnifierEffect, (texture, | 35 return SkNEW_ARGS(GrMagnifierEffect, (texture, |
| 36 bounds, |
35 xOffset, | 37 xOffset, |
36 yOffset, | 38 yOffset, |
37 xInvZoom, | 39 xInvZoom, |
38 yInvZoom, | 40 yInvZoom, |
39 xInvInset, | 41 xInvInset, |
40 yInvInset)); | 42 yInvInset)); |
41 } | 43 } |
42 | 44 |
43 virtual ~GrMagnifierEffect() {}; | 45 virtual ~GrMagnifierEffect() {}; |
44 | 46 |
45 const char* name() const override { return "Magnifier"; } | 47 const char* name() const override { return "Magnifier"; } |
46 | 48 |
47 void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const overri
de; | 49 void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const overri
de; |
48 | 50 |
49 GrGLFragmentProcessor* createGLInstance() const override; | 51 GrGLFragmentProcessor* createGLInstance() const override; |
50 | 52 |
| 53 const SkRect& bounds() const { return fBounds; } // Bounds of source imag
e. |
| 54 // Offset to apply to zoomed pixels, (srcRect position / texture size). |
51 float x_offset() const { return fXOffset; } | 55 float x_offset() const { return fXOffset; } |
52 float y_offset() const { return fYOffset; } | 56 float y_offset() const { return fYOffset; } |
| 57 |
| 58 // Scale to apply to zoomed pixels (srcRect size / bounds size). |
53 float x_inv_zoom() const { return fXInvZoom; } | 59 float x_inv_zoom() const { return fXInvZoom; } |
54 float y_inv_zoom() const { return fYInvZoom; } | 60 float y_inv_zoom() const { return fYInvZoom; } |
| 61 |
| 62 // 1/radius over which to transition from unzoomed to zoomed pixels (bounds
size / inset). |
55 float x_inv_inset() const { return fXInvInset; } | 63 float x_inv_inset() const { return fXInvInset; } |
56 float y_inv_inset() const { return fYInvInset; } | 64 float y_inv_inset() const { return fYInvInset; } |
57 | 65 |
58 private: | 66 private: |
59 GrMagnifierEffect(GrTexture* texture, | 67 GrMagnifierEffect(GrTexture* texture, |
| 68 const SkRect& bounds, |
60 float xOffset, | 69 float xOffset, |
61 float yOffset, | 70 float yOffset, |
62 float xInvZoom, | 71 float xInvZoom, |
63 float yInvZoom, | 72 float yInvZoom, |
64 float xInvInset, | 73 float xInvInset, |
65 float yInvInset) | 74 float yInvInset) |
66 : GrSingleTextureEffect(texture, GrCoordTransform::MakeDivByTextureWHMat
rix(texture)) | 75 : GrSingleTextureEffect(texture, GrCoordTransform::MakeDivByTextureWHMat
rix(texture)) |
| 76 , fBounds(bounds) |
67 , fXOffset(xOffset) | 77 , fXOffset(xOffset) |
68 , fYOffset(yOffset) | 78 , fYOffset(yOffset) |
69 , fXInvZoom(xInvZoom) | 79 , fXInvZoom(xInvZoom) |
70 , fYInvZoom(yInvZoom) | 80 , fYInvZoom(yInvZoom) |
71 , fXInvInset(xInvInset) | 81 , fXInvInset(xInvInset) |
72 , fYInvInset(yInvInset) { | 82 , fYInvInset(yInvInset) { |
73 this->initClassID<GrMagnifierEffect>(); | 83 this->initClassID<GrMagnifierEffect>(); |
74 } | 84 } |
75 | 85 |
76 bool onIsEqual(const GrFragmentProcessor&) const override; | 86 bool onIsEqual(const GrFragmentProcessor&) const override; |
77 | 87 |
78 void onComputeInvariantOutput(GrInvariantOutput* inout) const override; | 88 void onComputeInvariantOutput(GrInvariantOutput* inout) const override; |
79 | 89 |
80 GR_DECLARE_FRAGMENT_PROCESSOR_TEST; | 90 GR_DECLARE_FRAGMENT_PROCESSOR_TEST; |
81 | 91 |
| 92 SkRect fBounds; |
82 float fXOffset; | 93 float fXOffset; |
83 float fYOffset; | 94 float fYOffset; |
84 float fXInvZoom; | 95 float fXInvZoom; |
85 float fYInvZoom; | 96 float fYInvZoom; |
86 float fXInvInset; | 97 float fXInvInset; |
87 float fYInvInset; | 98 float fYInvInset; |
88 | 99 |
89 typedef GrSingleTextureEffect INHERITED; | 100 typedef GrSingleTextureEffect INHERITED; |
90 }; | 101 }; |
91 | 102 |
(...skipping 10 matching lines...) Expand all Loading... |
102 const char* inputColor, | 113 const char* inputColor, |
103 const TransformedCoordsArray&, | 114 const TransformedCoordsArray&, |
104 const TextureSamplerArray&) override; | 115 const TextureSamplerArray&) override; |
105 | 116 |
106 void setData(const GrGLProgramDataManager&, const GrProcessor&) override; | 117 void setData(const GrGLProgramDataManager&, const GrProcessor&) override; |
107 | 118 |
108 private: | 119 private: |
109 UniformHandle fOffsetVar; | 120 UniformHandle fOffsetVar; |
110 UniformHandle fInvZoomVar; | 121 UniformHandle fInvZoomVar; |
111 UniformHandle fInvInsetVar; | 122 UniformHandle fInvInsetVar; |
| 123 UniformHandle fBoundsVar; |
112 | 124 |
113 typedef GrGLFragmentProcessor INHERITED; | 125 typedef GrGLFragmentProcessor INHERITED; |
114 }; | 126 }; |
115 | 127 |
116 GrGLMagnifierEffect::GrGLMagnifierEffect(const GrProcessor&) { | 128 GrGLMagnifierEffect::GrGLMagnifierEffect(const GrProcessor&) { |
117 } | 129 } |
118 | 130 |
119 void GrGLMagnifierEffect::emitCode(GrGLFPBuilder* builder, | 131 void GrGLMagnifierEffect::emitCode(GrGLFPBuilder* builder, |
120 const GrFragmentProcessor&, | 132 const GrFragmentProcessor&, |
121 const char* outputColor, | 133 const char* outputColor, |
122 const char* inputColor, | 134 const char* inputColor, |
123 const TransformedCoordsArray& coords, | 135 const TransformedCoordsArray& coords, |
124 const TextureSamplerArray& samplers) { | 136 const TextureSamplerArray& samplers) { |
125 fOffsetVar = builder->addUniform( | 137 fOffsetVar = builder->addUniform( |
126 GrGLProgramBuilder::kFragment_Visibility | | 138 GrGLProgramBuilder::kFragment_Visibility | |
127 GrGLProgramBuilder::kVertex_Visibility, | 139 GrGLProgramBuilder::kVertex_Visibility, |
128 kVec2f_GrSLType, kDefault_GrSLPrecision, "Offset"); | 140 kVec2f_GrSLType, kDefault_GrSLPrecision, "Offset"); |
129 fInvZoomVar = builder->addUniform( | 141 fInvZoomVar = builder->addUniform( |
130 GrGLProgramBuilder::kFragment_Visibility | | 142 GrGLProgramBuilder::kFragment_Visibility | |
131 GrGLProgramBuilder::kVertex_Visibility, | 143 GrGLProgramBuilder::kVertex_Visibility, |
132 kVec2f_GrSLType, kDefault_GrSLPrecision, "InvZoom"); | 144 kVec2f_GrSLType, kDefault_GrSLPrecision, "InvZoom"); |
133 fInvInsetVar = builder->addUniform( | 145 fInvInsetVar = builder->addUniform( |
134 GrGLProgramBuilder::kFragment_Visibility | | 146 GrGLProgramBuilder::kFragment_Visibility | |
135 GrGLProgramBuilder::kVertex_Visibility, | 147 GrGLProgramBuilder::kVertex_Visibility, |
136 kVec2f_GrSLType, kDefault_GrSLPrecision, "InvInset"); | 148 kVec2f_GrSLType, kDefault_GrSLPrecision, "InvInset"); |
| 149 fBoundsVar = builder->addUniform( |
| 150 GrGLProgramBuilder::kFragment_Visibility | |
| 151 GrGLProgramBuilder::kVertex_Visibility, |
| 152 kVec4f_GrSLType, kDefault_GrSLPrecision, "Bounds"); |
137 | 153 |
138 GrGLFPFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder(); | 154 GrGLFPFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder(); |
139 SkString coords2D = fsBuilder->ensureFSCoords2D(coords, 0); | 155 SkString coords2D = fsBuilder->ensureFSCoords2D(coords, 0); |
140 fsBuilder->codeAppendf("\t\tvec2 coord = %s;\n", coords2D.c_str()); | 156 fsBuilder->codeAppendf("\t\tvec2 coord = %s;\n", coords2D.c_str()); |
141 fsBuilder->codeAppendf("\t\tvec2 zoom_coord = %s + %s * %s;\n", | 157 fsBuilder->codeAppendf("\t\tvec2 zoom_coord = %s + %s * %s;\n", |
142 builder->getUniformCStr(fOffsetVar), | 158 builder->getUniformCStr(fOffsetVar), |
143 coords2D.c_str(), | 159 coords2D.c_str(), |
144 builder->getUniformCStr(fInvZoomVar)); | 160 builder->getUniformCStr(fInvZoomVar)); |
145 | 161 const char* bounds = builder->getUniformCStr(fBoundsVar); |
146 fsBuilder->codeAppend("\t\tvec2 delta = min(coord, vec2(1.0, 1.0) - coord);\
n"); | 162 fsBuilder->codeAppendf("\t\tvec2 delta = (coord - %s.xy) * %s.zw;\n", bounds
, bounds); |
147 | 163 fsBuilder->codeAppendf("\t\tdelta = min(delta, vec2(1.0, 1.0) - delta);\n"); |
148 fsBuilder->codeAppendf("\t\tdelta = delta * %s;\n", builder->getUniformCStr(
fInvInsetVar)); | 164 fsBuilder->codeAppendf("\t\tdelta = delta * %s;\n", builder->getUniformCStr(
fInvInsetVar)); |
149 | 165 |
150 fsBuilder->codeAppend("\t\tfloat weight = 0.0;\n"); | 166 fsBuilder->codeAppend("\t\tfloat weight = 0.0;\n"); |
151 fsBuilder->codeAppend("\t\tif (delta.s < 2.0 && delta.t < 2.0) {\n"); | 167 fsBuilder->codeAppend("\t\tif (delta.s < 2.0 && delta.t < 2.0) {\n"); |
152 fsBuilder->codeAppend("\t\t\tdelta = vec2(2.0, 2.0) - delta;\n"); | 168 fsBuilder->codeAppend("\t\t\tdelta = vec2(2.0, 2.0) - delta;\n"); |
153 fsBuilder->codeAppend("\t\t\tfloat dist = length(delta);\n"); | 169 fsBuilder->codeAppend("\t\t\tfloat dist = length(delta);\n"); |
154 fsBuilder->codeAppend("\t\t\tdist = max(2.0 - dist, 0.0);\n"); | 170 fsBuilder->codeAppend("\t\t\tdist = max(2.0 - dist, 0.0);\n"); |
155 fsBuilder->codeAppend("\t\t\tweight = min(dist * dist, 1.0);\n"); | 171 fsBuilder->codeAppend("\t\t\tweight = min(dist * dist, 1.0);\n"); |
156 fsBuilder->codeAppend("\t\t} else {\n"); | 172 fsBuilder->codeAppend("\t\t} else {\n"); |
157 fsBuilder->codeAppend("\t\t\tvec2 delta_squared = delta * delta;\n"); | 173 fsBuilder->codeAppend("\t\t\tvec2 delta_squared = delta * delta;\n"); |
(...skipping 10 matching lines...) Expand all Loading... |
168 GrGLSLMulVarBy4f(&modulate, outputColor, inputColor); | 184 GrGLSLMulVarBy4f(&modulate, outputColor, inputColor); |
169 fsBuilder->codeAppend(modulate.c_str()); | 185 fsBuilder->codeAppend(modulate.c_str()); |
170 } | 186 } |
171 | 187 |
172 void GrGLMagnifierEffect::setData(const GrGLProgramDataManager& pdman, | 188 void GrGLMagnifierEffect::setData(const GrGLProgramDataManager& pdman, |
173 const GrProcessor& effect) { | 189 const GrProcessor& effect) { |
174 const GrMagnifierEffect& zoom = effect.cast<GrMagnifierEffect>(); | 190 const GrMagnifierEffect& zoom = effect.cast<GrMagnifierEffect>(); |
175 pdman.set2f(fOffsetVar, zoom.x_offset(), zoom.y_offset()); | 191 pdman.set2f(fOffsetVar, zoom.x_offset(), zoom.y_offset()); |
176 pdman.set2f(fInvZoomVar, zoom.x_inv_zoom(), zoom.y_inv_zoom()); | 192 pdman.set2f(fInvZoomVar, zoom.x_inv_zoom(), zoom.y_inv_zoom()); |
177 pdman.set2f(fInvInsetVar, zoom.x_inv_inset(), zoom.y_inv_inset()); | 193 pdman.set2f(fInvInsetVar, zoom.x_inv_inset(), zoom.y_inv_inset()); |
| 194 pdman.set4f(fBoundsVar, zoom.bounds().x(), zoom.bounds().y(), |
| 195 zoom.bounds().width(), zoom.bounds().height()); |
178 } | 196 } |
179 | 197 |
180 ///////////////////////////////////////////////////////////////////// | 198 ///////////////////////////////////////////////////////////////////// |
181 | 199 |
182 void GrMagnifierEffect::getGLProcessorKey(const GrGLCaps& caps, | 200 void GrMagnifierEffect::getGLProcessorKey(const GrGLCaps& caps, |
183 GrProcessorKeyBuilder* b) const { | 201 GrProcessorKeyBuilder* b) const { |
184 GrGLMagnifierEffect::GenKey(*this, caps, b); | 202 GrGLMagnifierEffect::GenKey(*this, caps, b); |
185 } | 203 } |
186 | 204 |
187 GrGLFragmentProcessor* GrMagnifierEffect::createGLInstance() const { | 205 GrGLFragmentProcessor* GrMagnifierEffect::createGLInstance() const { |
(...skipping 11 matching lines...) Expand all Loading... |
199 const int kMaxHeight = 200; | 217 const int kMaxHeight = 200; |
200 const int kMaxInset = 20; | 218 const int kMaxInset = 20; |
201 uint32_t width = random->nextULessThan(kMaxWidth); | 219 uint32_t width = random->nextULessThan(kMaxWidth); |
202 uint32_t height = random->nextULessThan(kMaxHeight); | 220 uint32_t height = random->nextULessThan(kMaxHeight); |
203 uint32_t x = random->nextULessThan(kMaxWidth - width); | 221 uint32_t x = random->nextULessThan(kMaxWidth - width); |
204 uint32_t y = random->nextULessThan(kMaxHeight - height); | 222 uint32_t y = random->nextULessThan(kMaxHeight - height); |
205 uint32_t inset = random->nextULessThan(kMaxInset); | 223 uint32_t inset = random->nextULessThan(kMaxInset); |
206 | 224 |
207 GrFragmentProcessor* effect = GrMagnifierEffect::Create( | 225 GrFragmentProcessor* effect = GrMagnifierEffect::Create( |
208 texture, | 226 texture, |
| 227 SkRect::MakeWH(SkIntToScalar(kMaxWidth), SkIntToScalar(kMaxHeight)), |
209 (float) width / texture->width(), | 228 (float) width / texture->width(), |
210 (float) height / texture->height(), | 229 (float) height / texture->height(), |
211 texture->width() / (float) x, | 230 texture->width() / (float) x, |
212 texture->height() / (float) y, | 231 texture->height() / (float) y, |
213 (float) inset / texture->width(), | 232 (float) inset / texture->width(), |
214 (float) inset / texture->height()); | 233 (float) inset / texture->height()); |
215 SkASSERT(effect); | 234 SkASSERT(effect); |
216 return effect; | 235 return effect; |
217 } | 236 } |
218 | 237 |
219 /////////////////////////////////////////////////////////////////////////////// | 238 /////////////////////////////////////////////////////////////////////////////// |
220 | 239 |
221 bool GrMagnifierEffect::onIsEqual(const GrFragmentProcessor& sBase) const { | 240 bool GrMagnifierEffect::onIsEqual(const GrFragmentProcessor& sBase) const { |
222 const GrMagnifierEffect& s = sBase.cast<GrMagnifierEffect>(); | 241 const GrMagnifierEffect& s = sBase.cast<GrMagnifierEffect>(); |
223 return (this->fXOffset == s.fXOffset && | 242 return (this->fBounds == s.fBounds && |
| 243 this->fXOffset == s.fXOffset && |
224 this->fYOffset == s.fYOffset && | 244 this->fYOffset == s.fYOffset && |
225 this->fXInvZoom == s.fXInvZoom && | 245 this->fXInvZoom == s.fXInvZoom && |
226 this->fYInvZoom == s.fYInvZoom && | 246 this->fYInvZoom == s.fYInvZoom && |
227 this->fXInvInset == s.fXInvInset && | 247 this->fXInvInset == s.fXInvInset && |
228 this->fYInvInset == s.fYInvInset); | 248 this->fYInvInset == s.fYInvInset); |
229 } | 249 } |
230 | 250 |
231 void GrMagnifierEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const
{ | 251 void GrMagnifierEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const
{ |
232 this->updateInvariantOutputForModulation(inout); | 252 this->updateInvariantOutputForModulation(inout); |
233 } | 253 } |
(...skipping 17 matching lines...) Expand all Loading... |
251 | 271 |
252 | 272 |
253 SkMagnifierImageFilter::SkMagnifierImageFilter(const SkRect& srcRect, SkScalar i
nset, | 273 SkMagnifierImageFilter::SkMagnifierImageFilter(const SkRect& srcRect, SkScalar i
nset, |
254 SkImageFilter* input) | 274 SkImageFilter* input) |
255 : INHERITED(1, &input), fSrcRect(srcRect), fInset(inset) { | 275 : INHERITED(1, &input), fSrcRect(srcRect), fInset(inset) { |
256 SkASSERT(srcRect.x() >= 0 && srcRect.y() >= 0 && inset >= 0); | 276 SkASSERT(srcRect.x() >= 0 && srcRect.y() >= 0 && inset >= 0); |
257 } | 277 } |
258 | 278 |
259 #if SK_SUPPORT_GPU | 279 #if SK_SUPPORT_GPU |
260 bool SkMagnifierImageFilter::asFragmentProcessor(GrFragmentProcessor** fp, GrTex
ture* texture, | 280 bool SkMagnifierImageFilter::asFragmentProcessor(GrFragmentProcessor** fp, GrTex
ture* texture, |
261 const SkMatrix&, const SkIRect&
) const { | 281 const SkMatrix&, const SkIRect&
bounds) const { |
262 if (fp) { | 282 if (fp) { |
263 SkScalar yOffset = (texture->origin() == kTopLeft_GrSurfaceOrigin) ? fSr
cRect.y() : | 283 SkScalar yOffset = texture->origin() == kTopLeft_GrSurfaceOrigin ? fSrcR
ect.y() : |
264 (texture->height() - (fSrcRect.y() + fSrcRect.height(
))); | 284 texture->height() - fSrcRect.height() * texture->height() / bounds.he
ight() |
| 285 - fSrcRect.y(); |
| 286 int boundsY = (texture->origin() == kTopLeft_GrSurfaceOrigin) ? bounds.y
() : |
| 287 (texture->height() - bounds.height()); |
| 288 SkRect effectBounds = SkRect::MakeXYWH( |
| 289 SkIntToScalar(bounds.x()) / texture->width(), |
| 290 SkIntToScalar(boundsY) / texture->height(), |
| 291 SkIntToScalar(texture->width()) / bounds.width(), |
| 292 SkIntToScalar(texture->height()) / bounds.height()); |
265 SkScalar invInset = fInset > 0 ? SkScalarInvert(fInset) : SK_Scalar1; | 293 SkScalar invInset = fInset > 0 ? SkScalarInvert(fInset) : SK_Scalar1; |
266 *fp = GrMagnifierEffect::Create(texture, | 294 *fp = GrMagnifierEffect::Create(texture, |
| 295 effectBounds, |
267 fSrcRect.x() / texture->width(), | 296 fSrcRect.x() / texture->width(), |
268 yOffset / texture->height(), | 297 yOffset / texture->height(), |
269 fSrcRect.width() / texture->width(), | 298 fSrcRect.width() / bounds.width(), |
270 fSrcRect.height() / texture->height(), | 299 fSrcRect.height() / bounds.height(), |
271 texture->width() * invInset, | 300 bounds.width() * invInset, |
272 texture->height() * invInset); | 301 bounds.height() * invInset); |
273 } | 302 } |
274 return true; | 303 return true; |
275 } | 304 } |
276 #endif | 305 #endif |
277 | 306 |
278 SkFlattenable* SkMagnifierImageFilter::CreateProc(SkReadBuffer& buffer) { | 307 SkFlattenable* SkMagnifierImageFilter::CreateProc(SkReadBuffer& buffer) { |
279 SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1); | 308 SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1); |
280 SkRect src; | 309 SkRect src; |
281 buffer.readRect(&src); | 310 buffer.readRect(&src); |
282 return Create(src, buffer.readScalar(), common.getInput(0)); | 311 return Create(src, buffer.readScalar(), common.getInput(0)); |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
356 | 385 |
357 #ifndef SK_IGNORE_TO_STRING | 386 #ifndef SK_IGNORE_TO_STRING |
358 void SkMagnifierImageFilter::toString(SkString* str) const { | 387 void SkMagnifierImageFilter::toString(SkString* str) const { |
359 str->appendf("SkMagnifierImageFilter: ("); | 388 str->appendf("SkMagnifierImageFilter: ("); |
360 str->appendf("src: (%f,%f,%f,%f) ", | 389 str->appendf("src: (%f,%f,%f,%f) ", |
361 fSrcRect.fLeft, fSrcRect.fTop, fSrcRect.fRight, fSrcRect.fBotto
m); | 390 fSrcRect.fLeft, fSrcRect.fTop, fSrcRect.fRight, fSrcRect.fBotto
m); |
362 str->appendf("inset: %f", fInset); | 391 str->appendf("inset: %f", fInset); |
363 str->append(")"); | 392 str->append(")"); |
364 } | 393 } |
365 #endif | 394 #endif |
OLD | NEW |