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 "SkAvoidXfermode.h" | 8 #include "SkAvoidXfermode.h" |
9 #include "SkColorPriv.h" | 9 #include "SkColorPriv.h" |
10 #include "SkReadBuffer.h" | 10 #include "SkReadBuffer.h" |
(...skipping 146 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
157 } | 157 } |
158 dst[i] = SkBlend3216(src[i], dst[i], d); | 158 dst[i] = SkBlend3216(src[i], dst[i], d); |
159 } | 159 } |
160 } | 160 } |
161 } | 161 } |
162 | 162 |
163 void SkAvoidXfermode::xferA8(SkAlpha dst[], const SkPMColor src[], int count, | 163 void SkAvoidXfermode::xferA8(SkAlpha dst[], const SkPMColor src[], int count, |
164 const SkAlpha aa[]) const { | 164 const SkAlpha aa[]) const { |
165 } | 165 } |
166 | 166 |
167 | |
168 #if SK_SUPPORT_GPU | |
169 | |
170 #include "GrFragmentProcessor.h" | |
171 #include "GrInvariantOutput.h" | |
172 #include "GrXferProcessor.h" | |
173 #include "glsl/GrGLSLFragmentProcessor.h" | |
174 #include "glsl/GrGLSLFragmentShaderBuilder.h" | |
175 #include "glsl/GrGLSLUniformHandler.h" | |
176 #include "glsl/GrGLSLXferProcessor.h" | |
177 | |
178 /////////////////////////////////////////////////////////////////////////////// | |
179 // Fragment Processor | |
180 /////////////////////////////////////////////////////////////////////////////// | |
181 | |
182 class GLAvoidFP; | |
183 | |
184 class AvoidFP : public GrFragmentProcessor { | |
185 public: | |
186 static const GrFragmentProcessor* Create(SkColor opColor, uint8_t tolerance, | |
187 SkAvoidXfermode::Mode mode, | |
188 const GrFragmentProcessor* dst) { | |
189 return new AvoidFP(opColor, tolerance, mode, dst); | |
190 } | |
191 | |
192 ~AvoidFP() override { } | |
193 | |
194 const char* name() const override { return "Avoid"; } | |
195 | |
196 SkString dumpInfo() const override { | |
197 SkString str; | |
198 str.appendf("Color: 0x%08x Tol: %d Mode: %s", | |
199 fOpColor, fTolerance, | |
200 fMode == SkAvoidXfermode::kAvoidColor_Mode ? "Avoid" : "Targ
et"); | |
201 return str; | |
202 } | |
203 | |
204 SkColor opColor() const { return fOpColor; } | |
205 uint8_t tol() const { return fTolerance; } | |
206 SkAvoidXfermode::Mode mode() const { return fMode; } | |
207 | |
208 private: | |
209 GrGLSLFragmentProcessor* onCreateGLSLInstance() const override; | |
210 | |
211 void onGetGLSLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const
override; | |
212 | |
213 bool onIsEqual(const GrFragmentProcessor& fpBase) const override { | |
214 const AvoidFP& fp = fpBase.cast<AvoidFP>(); | |
215 | |
216 return fOpColor == fp.fOpColor && | |
217 fTolerance == fp.fTolerance && | |
218 fMode == fp.fMode; | |
219 } | |
220 | |
221 void onComputeInvariantOutput(GrInvariantOutput* inout) const override { | |
222 inout->setToUnknown(GrInvariantOutput::kWill_ReadInput); | |
223 } | |
224 | |
225 AvoidFP(SkColor opColor, uint8_t tolerance, | |
226 SkAvoidXfermode::Mode mode, const GrFragmentProcessor* dst) | |
227 : fOpColor(opColor), fTolerance(tolerance), fMode(mode) { | |
228 this->initClassID<AvoidFP>(); | |
229 | |
230 SkASSERT(dst); | |
231 SkDEBUGCODE(int dstIndex = )this->registerChildProcessor(dst); | |
232 SkASSERT(0 == dstIndex); | |
233 } | |
234 | |
235 SkColor fOpColor; | |
236 uint8_t fTolerance; | |
237 SkAvoidXfermode::Mode fMode; | |
238 | |
239 GR_DECLARE_FRAGMENT_PROCESSOR_TEST; | |
240 typedef GrFragmentProcessor INHERITED; | |
241 }; | |
242 | |
243 /////////////////////////////////////////////////////////////////////////////// | |
244 | |
245 // Add common code for calculating avoid's distance value | |
246 static void add_avoid_code(GrGLSLFragmentBuilder* fragBuilder, | |
247 const char* dstColor, | |
248 const char* kColorAndTolUni, | |
249 const char* kDist, | |
250 SkAvoidXfermode::Mode mode) { | |
251 | |
252 fragBuilder->codeAppendf("vec3 temp = %s.rgb - %s.rgb;", dstColor, kColorAnd
TolUni); | |
253 fragBuilder->codeAppendf("float %s = max(max(abs(temp.r), abs(temp.g)), abs(
temp.b));", kDist); | |
254 | |
255 if (SkAvoidXfermode::kTargetColor_Mode == mode) { | |
256 fragBuilder->codeAppendf("%s = 1.0 - %s;", kDist, kDist); | |
257 } | |
258 | |
259 // the 'a' portion of the uniform is the scaled and inverted tolerance | |
260 fragBuilder->codeAppendf("%s = %s * %s.a - (%s.a - 1.0);", kDist, kDist, | |
261 kColorAndTolUni, kColorAndTolUni); | |
262 } | |
263 | |
264 class GLAvoidFP : public GrGLSLFragmentProcessor { | |
265 public: | |
266 void emitCode(EmitArgs& args) override { | |
267 const AvoidFP& avoid = args.fFp.cast<AvoidFP>(); | |
268 | |
269 GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder; | |
270 SkString dstColor("dstColor"); | |
271 this->emitChild(0, nullptr, &dstColor, args); | |
272 | |
273 fColorAndTolUni = args.fUniformHandler->addUniform( | |
274 GrGLSLUniformHandler::kFragment
_Visibility, | |
275 kVec4f_GrSLType, kDefault_GrSLP
recision, | |
276 "colorAndTol"); | |
277 const char* kColorAndTolUni = args.fUniformHandler->getUniformCStr(fColo
rAndTolUni); | |
278 | |
279 // add_avoid_code emits the code needed to compute the distance and put
it in this variable | |
280 const char* kDistanceVar = "dist"; | |
281 | |
282 add_avoid_code(fragBuilder, dstColor.c_str(), kColorAndTolUni, kDistance
Var, avoid.mode()); | |
283 | |
284 fragBuilder->codeAppendf("vec4 newCoverage = vec4(%s);", kDistanceVar); | |
285 fragBuilder->codeAppendf("%s = newCoverage * %s + (vec4(1.0)-newCoverage
) * %s;", | |
286 args.fOutputColor, args.fInputColor, dstColor.c
_str()); | |
287 } | |
288 | |
289 static void GenKey(const GrProcessor& proc, const GrGLSLCaps&, GrProcessorKe
yBuilder* b) { | |
290 const AvoidFP& avoid = proc.cast<AvoidFP>(); | |
291 uint32_t key = avoid.mode() == SkAvoidXfermode::kTargetColor_Mode ? 1 :
0; | |
292 b->add32(key); | |
293 } | |
294 | |
295 protected: | |
296 void onSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor& pro
c) override { | |
297 const AvoidFP& avoid = proc.cast<AvoidFP>(); | |
298 pdman.set4f(fColorAndTolUni, | |
299 SkColorGetR(avoid.opColor())/255.0f, | |
300 SkColorGetG(avoid.opColor())/255.0f, | |
301 SkColorGetB(avoid.opColor())/255.0f, | |
302 256.0f/(avoid.tol()+1.0f)); | |
303 } | |
304 | |
305 private: | |
306 GrGLSLProgramDataManager::UniformHandle fColorAndTolUni; | |
307 | |
308 typedef GrGLSLFragmentProcessor INHERITED; | |
309 }; | |
310 | |
311 /////////////////////////////////////////////////////////////////////////////// | |
312 | |
313 GrGLSLFragmentProcessor* AvoidFP::onCreateGLSLInstance() const { | |
314 return new GLAvoidFP; | |
315 } | |
316 | |
317 void AvoidFP::onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilde
r* b) const { | |
318 GLAvoidFP::GenKey(*this, caps, b); | |
319 } | |
320 | |
321 const GrFragmentProcessor* AvoidFP::TestCreate(GrProcessorTestData* d) { | |
322 SkColor opColor = d->fRandom->nextU(); | |
323 uint8_t tolerance = d->fRandom->nextBits(8); | |
324 SkAvoidXfermode::Mode mode = d->fRandom->nextBool() ? SkAvoidXfermode::kAvoi
dColor_Mode | |
325 : SkAvoidXfermode::kTarg
etColor_Mode; | |
326 | |
327 SkAutoTUnref<const GrFragmentProcessor> dst(GrProcessorUnitTest::CreateChild
FP(d)); | |
328 return new AvoidFP(opColor, tolerance, mode, dst); | |
329 } | |
330 | |
331 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(AvoidFP); | |
332 | |
333 /////////////////////////////////////////////////////////////////////////////// | |
334 // Xfer Processor | |
335 /////////////////////////////////////////////////////////////////////////////// | |
336 | |
337 class AvoidXP : public GrXferProcessor { | |
338 public: | |
339 AvoidXP(const DstTexture* dstTexture, bool hasMixedSamples, | |
340 SkColor opColor, uint8_t tolerance, SkAvoidXfermode::Mode mode) | |
341 : INHERITED(dstTexture, true, hasMixedSamples) | |
342 , fOpColor(opColor) | |
343 , fTolerance(tolerance) | |
344 , fMode(mode) { | |
345 this->initClassID<AvoidXP>(); | |
346 } | |
347 | |
348 const char* name() const override { return "Avoid"; } | |
349 | |
350 GrGLSLXferProcessor* createGLSLInstance() const override; | |
351 | |
352 SkColor opColor() const { return fOpColor; } | |
353 uint8_t tol() const { return fTolerance; } | |
354 SkAvoidXfermode::Mode mode() const { return fMode; } | |
355 | |
356 private: | |
357 GrXferProcessor::OptFlags onGetOptimizations(const GrPipelineOptimizations&
optimizations, | |
358 bool doesStencilWrite, | |
359 GrColor* overrideColor, | |
360 const GrCaps& caps) const overr
ide { | |
361 return GrXferProcessor::kNone_OptFlags; | |
362 } | |
363 | |
364 void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b)
const override; | |
365 | |
366 bool onIsEqual(const GrXferProcessor& xpBase) const override { | |
367 const AvoidXP& xp = xpBase.cast<AvoidXP>(); | |
368 | |
369 return fOpColor == xp.fOpColor && | |
370 fTolerance == xp.fTolerance && | |
371 fMode == xp.fMode; | |
372 } | |
373 | |
374 SkColor fOpColor; | |
375 uint8_t fTolerance; | |
376 SkAvoidXfermode::Mode fMode; | |
377 | |
378 typedef GrXferProcessor INHERITED; | |
379 }; | |
380 | |
381 /////////////////////////////////////////////////////////////////////////////// | |
382 | |
383 class GLAvoidXP : public GrGLSLXferProcessor { | |
384 public: | |
385 static void GenKey(const GrProcessor& processor, const GrGLSLCaps&, GrProces
sorKeyBuilder* b) { | |
386 const AvoidXP& avoid = processor.cast<AvoidXP>(); | |
387 uint32_t key = SkAvoidXfermode::kTargetColor_Mode == avoid.mode() ? 1 :
0; | |
388 b->add32(key); | |
389 } | |
390 | |
391 private: | |
392 void emitBlendCodeForDstRead(GrGLSLXPFragmentBuilder* fragBuilder, | |
393 GrGLSLUniformHandler* uniformHandler, | |
394 const char* srcColor, | |
395 const char* srcCoverage, | |
396 const char* dstColor, | |
397 const char* outColor, | |
398 const char* outColorSecondary, | |
399 const GrXferProcessor& proc) override { | |
400 const AvoidXP& avoid = proc.cast<AvoidXP>(); | |
401 | |
402 fColorAndTolUni = uniformHandler->addUniform(GrGLSLUniformHandler::kFrag
ment_Visibility, | |
403 kVec4f_GrSLType, kDefault_G
rSLPrecision, | |
404 "colorAndTol"); | |
405 const char* kColorandTolUni = uniformHandler->getUniformCStr(fColorAndTo
lUni); | |
406 | |
407 // add_avoid_code emits the code needed to compute the distance and put
it in this variable | |
408 const char* kDistanceVar = "dist"; | |
409 | |
410 add_avoid_code(fragBuilder, dstColor, kColorandTolUni, kDistanceVar, avo
id.mode()); | |
411 | |
412 fragBuilder->codeAppendf("vec4 newCoverage = vec4(%s);", kDistanceVar); | |
413 if (srcCoverage) { | |
414 fragBuilder->codeAppendf("newCoverage *= %s;", srcCoverage); | |
415 } | |
416 | |
417 // The raster implementation's quantization and behavior yield a very no
ticeable | |
418 // result near zero (0.0039 = 1/256). | |
419 fragBuilder->codeAppendf("if (%s < 0.0039) { %s = %s; } else {", | |
420 kDistanceVar, outColor, dstColor); | |
421 fragBuilder->codeAppendf("%s = %s;", outColor, srcColor); | |
422 INHERITED::DefaultCoverageModulation(fragBuilder, "newCoverage", dstColo
r, outColor, | |
423 outColorSecondary, proc); | |
424 fragBuilder->codeAppend("}"); | |
425 } | |
426 | |
427 void onSetData(const GrGLSLProgramDataManager& pdman, | |
428 const GrXferProcessor& processor) override { | |
429 const AvoidXP& avoid = processor.cast<AvoidXP>(); | |
430 pdman.set4f(fColorAndTolUni, | |
431 SkColorGetR(avoid.opColor())/255.0f, | |
432 SkColorGetG(avoid.opColor())/255.0f, | |
433 SkColorGetB(avoid.opColor())/255.0f, | |
434 256.0f/(avoid.tol()+1.0f)); | |
435 }; | |
436 | |
437 GrGLSLProgramDataManager::UniformHandle fColorAndTolUni; | |
438 | |
439 typedef GrGLSLXferProcessor INHERITED; | |
440 }; | |
441 | |
442 /////////////////////////////////////////////////////////////////////////////// | |
443 | |
444 void AvoidXP::onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilde
r* b) const { | |
445 GLAvoidXP::GenKey(*this, caps, b); | |
446 } | |
447 | |
448 GrGLSLXferProcessor* AvoidXP::createGLSLInstance() const { return new GLAvoidXP;
} | |
449 | |
450 /////////////////////////////////////////////////////////////////////////////// | |
451 class GrAvoidXPFactory : public GrXPFactory { | |
452 public: | |
453 static GrXPFactory* Create(SkColor opColor, uint8_t tolerance, | |
454 SkAvoidXfermode::Mode mode) { | |
455 return new GrAvoidXPFactory(opColor, tolerance, mode); | |
456 } | |
457 | |
458 void getInvariantBlendedColor(const GrProcOptInfo& colorPOI, | |
459 GrXPFactory::InvariantBlendedColor* blendedCol
or) const override { | |
460 blendedColor->fWillBlendWithDst = true; | |
461 blendedColor->fKnownColorFlags = kNone_GrColorComponentFlags; | |
462 } | |
463 | |
464 private: | |
465 GrAvoidXPFactory(SkColor opColor, uint8_t tolerance, SkAvoidXfermode::Mode m
ode) | |
466 : fOpColor(opColor) | |
467 , fTolerance(tolerance) | |
468 , fMode(mode) { | |
469 this->initClassID<GrAvoidXPFactory>(); | |
470 } | |
471 | |
472 GrXferProcessor* onCreateXferProcessor(const GrCaps& caps, | |
473 const GrPipelineOptimizations& optimi
zations, | |
474 bool hasMixedSamples, | |
475 const DstTexture* dstTexture) const o
verride { | |
476 return new AvoidXP(dstTexture, hasMixedSamples, fOpColor, fTolerance, fM
ode); | |
477 } | |
478 | |
479 bool onWillReadDstColor(const GrCaps& caps, | |
480 const GrPipelineOptimizations& optimizations, | |
481 bool hasMixedSamples) const override { | |
482 return true; | |
483 } | |
484 | |
485 bool onIsEqual(const GrXPFactory& xpfBase) const override { | |
486 const GrAvoidXPFactory& xpf = xpfBase.cast<GrAvoidXPFactory>(); | |
487 return fOpColor == xpf.fOpColor && | |
488 fTolerance == xpf.fTolerance && | |
489 fMode == xpf.fMode; | |
490 } | |
491 | |
492 GR_DECLARE_XP_FACTORY_TEST; | |
493 | |
494 SkColor fOpColor; | |
495 uint8_t fTolerance; | |
496 SkAvoidXfermode::Mode fMode; | |
497 | |
498 typedef GrXPFactory INHERITED; | |
499 }; | |
500 | |
501 GR_DEFINE_XP_FACTORY_TEST(GrAvoidXPFactory); | |
502 | |
503 const GrXPFactory* GrAvoidXPFactory::TestCreate(GrProcessorTestData* d) { | |
504 SkColor opColor = d->fRandom->nextU(); | |
505 uint8_t tolerance = d->fRandom->nextBits(8); | |
506 SkAvoidXfermode::Mode mode = d->fRandom->nextBool() ? SkAvoidXfermode::kAvoi
dColor_Mode | |
507 : SkAvoidXfermode::kTarg
etColor_Mode; | |
508 return GrAvoidXPFactory::Create(opColor, tolerance, mode); | |
509 } | |
510 | |
511 /////////////////////////////////////////////////////////////////////////////// | |
512 | |
513 bool SkAvoidXfermode::asFragmentProcessor(const GrFragmentProcessor** output, | |
514 const GrFragmentProcessor* dst) const
{ | |
515 if (output) { | |
516 *output = AvoidFP::Create(fOpColor, fTolerance, fMode, dst); | |
517 } | |
518 return true; | |
519 } | |
520 | |
521 bool SkAvoidXfermode::asXPFactory(GrXPFactory** xpf) const { | |
522 if (xpf) { | |
523 *xpf = GrAvoidXPFactory::Create(fOpColor, fTolerance, fMode); | |
524 } | |
525 return true; | |
526 } | |
527 #endif | |
528 | |
529 #ifndef SK_IGNORE_TO_STRING | 167 #ifndef SK_IGNORE_TO_STRING |
530 void SkAvoidXfermode::toString(SkString* str) const { | 168 void SkAvoidXfermode::toString(SkString* str) const { |
531 str->append("AvoidXfermode: opColor: "); | 169 str->append("AvoidXfermode: opColor: "); |
532 str->appendHex(fOpColor); | 170 str->appendHex(fOpColor); |
533 str->appendf("tolerance: %d ", fTolerance); | 171 str->appendf("distMul: %d ", fDistMul); |
534 | 172 |
535 static const char* gModeStrings[] = { "Avoid", "Target" }; | 173 static const char* gModeStrings[] = { "Avoid", "Target" }; |
536 | 174 |
537 str->appendf("mode: %s", gModeStrings[fMode]); | 175 str->appendf("mode: %s", gModeStrings[fMode]); |
538 } | 176 } |
539 #endif | 177 #endif |
OLD | NEW |