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