OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2006 The Android Open Source Project | 2 * Copyright 2006 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 "SkBlitRow.h" | 8 #include "SkBlitRow.h" |
9 #include "SkColorFilter.h" | 9 #include "SkColorFilter.h" |
10 #include "SkColorPriv.h" | 10 #include "SkColorPriv.h" |
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
67 #ifndef SK_IGNORE_TO_STRING | 67 #ifndef SK_IGNORE_TO_STRING |
68 virtual void toString(SkString* str) const SK_OVERRIDE { | 68 virtual void toString(SkString* str) const SK_OVERRIDE { |
69 str->append("SkModeColorFilter: color: 0x"); | 69 str->append("SkModeColorFilter: color: 0x"); |
70 str->appendHex(fColor); | 70 str->appendHex(fColor); |
71 str->append(" mode: "); | 71 str->append(" mode: "); |
72 str->append(SkXfermode::ModeName(fMode)); | 72 str->append(SkXfermode::ModeName(fMode)); |
73 } | 73 } |
74 #endif | 74 #endif |
75 | 75 |
76 #if SK_SUPPORT_GPU | 76 #if SK_SUPPORT_GPU |
77 virtual GrEffect* asNewEffect(GrContext*) const SK_OVERRIDE; | 77 virtual GrFragmentProcessor* asFragmentProcessor(GrContext*) const SK_OVERRI
DE; |
78 #endif | 78 #endif |
79 SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkModeColorFilter) | 79 SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkModeColorFilter) |
80 | 80 |
81 protected: | 81 protected: |
82 virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE { | 82 virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE { |
83 buffer.writeColor(fColor); | 83 buffer.writeColor(fColor); |
84 buffer.writeUInt(fMode); | 84 buffer.writeUInt(fMode); |
85 } | 85 } |
86 | 86 |
87 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING | 87 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING |
(...skipping 28 matching lines...) Expand all Loading... |
116 | 116 |
117 SkFlattenable* SkModeColorFilter::CreateProc(SkReadBuffer& buffer) { | 117 SkFlattenable* SkModeColorFilter::CreateProc(SkReadBuffer& buffer) { |
118 SkColor color = buffer.readColor(); | 118 SkColor color = buffer.readColor(); |
119 SkXfermode::Mode mode = (SkXfermode::Mode)buffer.readUInt(); | 119 SkXfermode::Mode mode = (SkXfermode::Mode)buffer.readUInt(); |
120 return SkColorFilter::CreateModeFilter(color, mode); | 120 return SkColorFilter::CreateModeFilter(color, mode); |
121 } | 121 } |
122 | 122 |
123 /////////////////////////////////////////////////////////////////////////////// | 123 /////////////////////////////////////////////////////////////////////////////// |
124 #if SK_SUPPORT_GPU | 124 #if SK_SUPPORT_GPU |
125 #include "GrBlend.h" | 125 #include "GrBlend.h" |
126 #include "GrEffect.h" | 126 #include "GrProcessor.h" |
127 #include "GrEffectUnitTest.h" | 127 #include "GrProcessorUnitTest.h" |
128 #include "GrTBackendEffectFactory.h" | 128 #include "GrTBackendProcessorFactory.h" |
129 #include "gl/GrGLEffect.h" | 129 #include "gl/GrGLProcessor.h" |
130 #include "gl/builders/GrGLProgramBuilder.h" | 130 #include "gl/builders/GrGLProgramBuilder.h" |
131 #include "SkGr.h" | 131 #include "SkGr.h" |
132 | 132 |
133 namespace { | 133 namespace { |
134 /** | 134 /** |
135 * A definition of blend equation for one coefficient. Generates a | 135 * A definition of blend equation for one coefficient. Generates a |
136 * blend_coeff * value "expression". | 136 * blend_coeff * value "expression". |
137 */ | 137 */ |
138 template<typename ColorExpr> | 138 template<typename ColorExpr> |
139 static inline ColorExpr blend_term(SkXfermode::Coeff coeff, | 139 static inline ColorExpr blend_term(SkXfermode::Coeff coeff, |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
175 const ColorExpr& inColor) { | 175 const ColorExpr& inColor) { |
176 SkXfermode::Coeff colorCoeff; | 176 SkXfermode::Coeff colorCoeff; |
177 SkXfermode::Coeff filterColorCoeff; | 177 SkXfermode::Coeff filterColorCoeff; |
178 SkAssertResult(SkXfermode::ModeAsCoeff(mode, &filterColorCoeff, &colorCoeff)
); | 178 SkAssertResult(SkXfermode::ModeAsCoeff(mode, &filterColorCoeff, &colorCoeff)
); |
179 return blend_term(colorCoeff, filterColor, inColor, inColor) + | 179 return blend_term(colorCoeff, filterColor, inColor, inColor) + |
180 blend_term(filterColorCoeff, filterColor, inColor, filterColor); | 180 blend_term(filterColorCoeff, filterColor, inColor, filterColor); |
181 } | 181 } |
182 | 182 |
183 } | 183 } |
184 | 184 |
185 class ModeColorFilterEffect : public GrEffect { | 185 class ModeColorFilterEffect : public GrFragmentProcessor { |
186 public: | 186 public: |
187 static GrEffect* Create(const GrColor& c, SkXfermode::Mode mode) { | 187 static GrFragmentProcessor* Create(const GrColor& c, SkXfermode::Mode mode)
{ |
188 // TODO: Make the effect take the coeffs rather than mode since we alrea
dy do the | 188 // TODO: Make the effect take the coeffs rather than mode since we alrea
dy do the |
189 // conversion here. | 189 // conversion here. |
190 SkXfermode::Coeff srcCoeff, dstCoeff; | 190 SkXfermode::Coeff srcCoeff, dstCoeff; |
191 if (!SkXfermode::ModeAsCoeff(mode, &srcCoeff, &dstCoeff)) { | 191 if (!SkXfermode::ModeAsCoeff(mode, &srcCoeff, &dstCoeff)) { |
192 SkDebugf("Failing to create color filter for mode %d\n", mode); | 192 SkDebugf("Failing to create color filter for mode %d\n", mode); |
193 return NULL; | 193 return NULL; |
194 } | 194 } |
195 return SkNEW_ARGS(ModeColorFilterEffect, (c, mode)); | 195 return SkNEW_ARGS(ModeColorFilterEffect, (c, mode)); |
196 } | 196 } |
197 | 197 |
198 virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags
) const SK_OVERRIDE; | 198 virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags
) const SK_OVERRIDE; |
199 | 199 |
200 bool willUseFilterColor() const { | 200 bool willUseFilterColor() const { |
201 SkXfermode::Coeff dstCoeff; | 201 SkXfermode::Coeff dstCoeff; |
202 SkXfermode::Coeff srcCoeff; | 202 SkXfermode::Coeff srcCoeff; |
203 SkAssertResult(SkXfermode::ModeAsCoeff(fMode, &srcCoeff, &dstCoeff)); | 203 SkAssertResult(SkXfermode::ModeAsCoeff(fMode, &srcCoeff, &dstCoeff)); |
204 if (SkXfermode::kZero_Coeff == srcCoeff) { | 204 if (SkXfermode::kZero_Coeff == srcCoeff) { |
205 return GrBlendCoeffRefsSrc(sk_blend_to_grblend(dstCoeff)); | 205 return GrBlendCoeffRefsSrc(sk_blend_to_grblend(dstCoeff)); |
206 } | 206 } |
207 return true; | 207 return true; |
208 } | 208 } |
209 | 209 |
210 virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE { | 210 virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERR
IDE { |
211 return GrTBackendEffectFactory<ModeColorFilterEffect>::getInstance(); | 211 return GrTBackendFragmentProcessorFactory<ModeColorFilterEffect>::getIns
tance(); |
212 } | 212 } |
213 | 213 |
214 static const char* Name() { return "ModeColorFilterEffect"; } | 214 static const char* Name() { return "ModeColorFilterEffect"; } |
215 | 215 |
216 SkXfermode::Mode mode() const { return fMode; } | 216 SkXfermode::Mode mode() const { return fMode; } |
217 GrColor color() const { return fColor; } | 217 GrColor color() const { return fColor; } |
218 | 218 |
219 class GLEffect : public GrGLEffect { | 219 class GLProcessor : public GrGLFragmentProcessor { |
220 public: | 220 public: |
221 GLEffect(const GrBackendEffectFactory& factory, const GrEffect&) | 221 GLProcessor(const GrBackendProcessorFactory& factory, const GrProcessor&
) |
222 : INHERITED(factory) { | 222 : INHERITED(factory) { |
223 } | 223 } |
224 | 224 |
225 virtual void emitCode(GrGLProgramBuilder* builder, | 225 virtual void emitCode(GrGLProgramBuilder* builder, |
226 const GrEffect& effect, | 226 const GrFragmentProcessor& fp, |
227 const GrEffectKey& key, | 227 const GrProcessorKey&, |
228 const char* outputColor, | 228 const char* outputColor, |
229 const char* inputColor, | 229 const char* inputColor, |
230 const TransformedCoordsArray& coords, | 230 const TransformedCoordsArray&, |
231 const TextureSamplerArray& samplers) SK_OVERRIDE { | 231 const TextureSamplerArray&) SK_OVERRIDE { |
232 SkXfermode::Mode mode = effect.cast<ModeColorFilterEffect>().mode(); | 232 SkXfermode::Mode mode = fp.cast<ModeColorFilterEffect>().mode(); |
233 | 233 |
234 SkASSERT(SkXfermode::kDst_Mode != mode); | 234 SkASSERT(SkXfermode::kDst_Mode != mode); |
235 const char* colorFilterColorUniName = NULL; | 235 const char* colorFilterColorUniName = NULL; |
236 if (effect.cast<ModeColorFilterEffect>().willUseFilterColor()) { | 236 if (fp.cast<ModeColorFilterEffect>().willUseFilterColor()) { |
237 fFilterColorUni = builder->addUniform(GrGLProgramBuilder::kFragm
ent_Visibility, | 237 fFilterColorUni = builder->addUniform(GrGLProgramBuilder::kFragm
ent_Visibility, |
238 kVec4f_GrSLType, "FilterCo
lor", | 238 kVec4f_GrSLType, "FilterCo
lor", |
239 &colorFilterColorUniName); | 239 &colorFilterColorUniName); |
240 } | 240 } |
241 | 241 |
242 GrGLSLExpr4 filter = | 242 GrGLSLExpr4 filter = |
243 color_filter_expression(mode, GrGLSLExpr4(colorFilterColorUniNam
e), | 243 color_filter_expression(mode, GrGLSLExpr4(colorFilterColorUniNam
e), |
244 GrGLSLExpr4(inputColor)); | 244 GrGLSLExpr4(inputColor)); |
245 | 245 |
246 builder->getFragmentShaderBuilder()-> | 246 builder->getFragmentShaderBuilder()-> |
247 codeAppendf("\t%s = %s;\n", outputColor, filter.c_str()); | 247 codeAppendf("\t%s = %s;\n", outputColor, filter.c_str()); |
248 } | 248 } |
249 | 249 |
250 static void GenKey(const GrEffect& effect, const GrGLCaps&, | 250 static void GenKey(const GrProcessor& fp, const GrGLCaps&, |
251 GrEffectKeyBuilder* b) { | 251 GrProcessorKeyBuilder* b) { |
252 const ModeColorFilterEffect& colorModeFilter = effect.cast<ModeColor
FilterEffect>(); | 252 const ModeColorFilterEffect& colorModeFilter = fp.cast<ModeColorFilt
erEffect>(); |
253 // The SL code does not depend on filter color at the moment, so no
need to represent it | 253 // The SL code does not depend on filter color at the moment, so no
need to represent it |
254 // in the key. | 254 // in the key. |
255 b->add32(colorModeFilter.mode()); | 255 b->add32(colorModeFilter.mode()); |
256 } | 256 } |
257 | 257 |
258 virtual void setData(const GrGLProgramDataManager& pdman, | 258 virtual void setData(const GrGLProgramDataManager& pdman, |
259 const GrEffect& effect) SK_OVERRIDE { | 259 const GrProcessor& fp) SK_OVERRIDE { |
260 if (fFilterColorUni.isValid()) { | 260 if (fFilterColorUni.isValid()) { |
261 const ModeColorFilterEffect& colorModeFilter = effect.cast<ModeC
olorFilterEffect>(); | 261 const ModeColorFilterEffect& colorModeFilter = fp.cast<ModeColor
FilterEffect>(); |
262 GrGLfloat c[4]; | 262 GrGLfloat c[4]; |
263 GrColorToRGBAFloat(colorModeFilter.color(), c); | 263 GrColorToRGBAFloat(colorModeFilter.color(), c); |
264 pdman.set4fv(fFilterColorUni, 1, c); | 264 pdman.set4fv(fFilterColorUni, 1, c); |
265 } | 265 } |
266 } | 266 } |
267 | 267 |
268 private: | 268 private: |
269 | 269 |
270 GrGLProgramDataManager::UniformHandle fFilterColorUni; | 270 GrGLProgramDataManager::UniformHandle fFilterColorUni; |
271 typedef GrGLEffect INHERITED; | 271 typedef GrGLFragmentProcessor INHERITED; |
272 }; | 272 }; |
273 | 273 |
274 GR_DECLARE_EFFECT_TEST; | 274 GR_DECLARE_FRAGMENT_PROCESSOR_TEST; |
275 | 275 |
276 private: | 276 private: |
277 ModeColorFilterEffect(GrColor color, SkXfermode::Mode mode) | 277 ModeColorFilterEffect(GrColor color, SkXfermode::Mode mode) |
278 : fMode(mode), | 278 : fMode(mode), |
279 fColor(color) { | 279 fColor(color) { |
280 | 280 |
281 SkXfermode::Coeff dstCoeff; | 281 SkXfermode::Coeff dstCoeff; |
282 SkXfermode::Coeff srcCoeff; | 282 SkXfermode::Coeff srcCoeff; |
283 SkAssertResult(SkXfermode::ModeAsCoeff(fMode, &srcCoeff, &dstCoeff)); | 283 SkAssertResult(SkXfermode::ModeAsCoeff(fMode, &srcCoeff, &dstCoeff)); |
284 // These could be calculated from the blend equation with template trick
ery.. | 284 // These could be calculated from the blend equation with template trick
ery.. |
285 if (SkXfermode::kZero_Coeff == dstCoeff && | 285 if (SkXfermode::kZero_Coeff == dstCoeff && |
286 !GrBlendCoeffRefsDst(sk_blend_to_grblend(srcCoeff))) { | 286 !GrBlendCoeffRefsDst(sk_blend_to_grblend(srcCoeff))) { |
287 this->setWillNotUseInputColor(); | 287 this->setWillNotUseInputColor(); |
288 } | 288 } |
289 } | 289 } |
290 | 290 |
291 virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE { | 291 virtual bool onIsEqual(const GrProcessor& other) const SK_OVERRIDE { |
292 const ModeColorFilterEffect& s = other.cast<ModeColorFilterEffect>(); | 292 const ModeColorFilterEffect& s = other.cast<ModeColorFilterEffect>(); |
293 return fMode == s.fMode && fColor == s.fColor; | 293 return fMode == s.fMode && fColor == s.fColor; |
294 } | 294 } |
295 | 295 |
296 SkXfermode::Mode fMode; | 296 SkXfermode::Mode fMode; |
297 GrColor fColor; | 297 GrColor fColor; |
298 | 298 |
299 typedef GrEffect INHERITED; | 299 typedef GrFragmentProcessor INHERITED; |
300 }; | 300 }; |
301 | 301 |
302 namespace { | 302 namespace { |
303 | 303 |
304 /** Function color_component_to_int tries to reproduce the GLSL rounding. The sp
ec doesn't specify | 304 /** Function color_component_to_int tries to reproduce the GLSL rounding. The sp
ec doesn't specify |
305 * to which direction the 0.5 goes. | 305 * to which direction the 0.5 goes. |
306 */ | 306 */ |
307 static inline int color_component_to_int(float value) { | 307 static inline int color_component_to_int(float value) { |
308 return sk_float_round2int(SkTMax(0.f, SkTMin(1.f, value)) * 255.f); | 308 return sk_float_round2int(SkTMax(0.f, SkTMin(1.f, value)) * 255.f); |
309 } | 309 } |
(...skipping 79 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
389 GrColorToRGBAFloat(fColor, filterColor); | 389 GrColorToRGBAFloat(fColor, filterColor); |
390 MaskedColorExpr result = | 390 MaskedColorExpr result = |
391 color_filter_expression(fMode, | 391 color_filter_expression(fMode, |
392 MaskedColorExpr(filterColor, kRGBA_GrColorCompon
entFlags), | 392 MaskedColorExpr(filterColor, kRGBA_GrColorCompon
entFlags), |
393 MaskedColorExpr(inputColor, *validFlags)); | 393 MaskedColorExpr(inputColor, *validFlags)); |
394 | 394 |
395 *color = result.getColor(); | 395 *color = result.getColor(); |
396 *validFlags = result.getValidComponents(); | 396 *validFlags = result.getValidComponents(); |
397 } | 397 } |
398 | 398 |
399 GR_DEFINE_EFFECT_TEST(ModeColorFilterEffect); | 399 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(ModeColorFilterEffect); |
400 GrEffect* ModeColorFilterEffect::TestCreate(SkRandom* rand, | 400 GrFragmentProcessor* ModeColorFilterEffect::TestCreate(SkRandom* rand, |
401 GrContext*, | 401 GrContext*, |
402 const GrDrawTargetCaps&, | 402 const GrDrawTargetCaps&, |
403 GrTexture*[]) { | 403 GrTexture*[]) { |
404 SkXfermode::Mode mode = SkXfermode::kDst_Mode; | 404 SkXfermode::Mode mode = SkXfermode::kDst_Mode; |
405 while (SkXfermode::kDst_Mode == mode) { | 405 while (SkXfermode::kDst_Mode == mode) { |
406 mode = static_cast<SkXfermode::Mode>(rand->nextRangeU(0, SkXfermode::kLa
stCoeffMode)); | 406 mode = static_cast<SkXfermode::Mode>(rand->nextRangeU(0, SkXfermode::kLa
stCoeffMode)); |
407 } | 407 } |
408 GrColor color = rand->nextU(); | 408 GrColor color = rand->nextU(); |
409 return ModeColorFilterEffect::Create(color, mode); | 409 return ModeColorFilterEffect::Create(color, mode); |
410 } | 410 } |
411 | 411 |
412 GrEffect* SkModeColorFilter::asNewEffect(GrContext*) const { | 412 GrFragmentProcessor* SkModeColorFilter::asFragmentProcessor(GrContext*) const { |
413 if (SkXfermode::kDst_Mode != fMode) { | 413 if (SkXfermode::kDst_Mode != fMode) { |
414 return ModeColorFilterEffect::Create(SkColor2GrColor(fColor), fMode); | 414 return ModeColorFilterEffect::Create(SkColor2GrColor(fColor), fMode); |
415 } | 415 } |
416 return NULL; | 416 return NULL; |
417 } | 417 } |
418 | 418 |
419 #endif | 419 #endif |
420 | 420 |
421 /////////////////////////////////////////////////////////////////////////////// | 421 /////////////////////////////////////////////////////////////////////////////// |
422 | 422 |
(...skipping 122 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
545 matrix.postTranslate(SkIntToScalar(SkColorGetR(add)), | 545 matrix.postTranslate(SkIntToScalar(SkColorGetR(add)), |
546 SkIntToScalar(SkColorGetG(add)), | 546 SkIntToScalar(SkColorGetG(add)), |
547 SkIntToScalar(SkColorGetB(add)), | 547 SkIntToScalar(SkColorGetB(add)), |
548 0); | 548 0); |
549 return SkColorMatrixFilter::Create(matrix); | 549 return SkColorMatrixFilter::Create(matrix); |
550 } | 550 } |
551 | 551 |
552 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkColorFilter) | 552 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkColorFilter) |
553 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkModeColorFilter) | 553 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkModeColorFilter) |
554 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END | 554 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END |
OLD | NEW |