Line data    Source code

       1             : /*
       2             :  * Copyright 2013 Google Inc.
       3             :  *
       4             :  * Use of this source code is governed by a BSD-style license that can be
       5             :  * found in the LICENSE file.
       6             :  */
       7             : 
       8             : #include "GrPaint.h"
       9             : #include "GrXferProcessor.h"
      10             : #include "effects/GrCoverageSetOpXP.h"
      11             : #include "effects/GrPorterDuffXferProcessor.h"
      12             : #include "effects/GrSimpleTextureEffect.h"
      13             : 
      14           0 : void GrPaint::setPorterDuffXPFactory(SkBlendMode mode) {
      15           0 :     fXPFactory = GrPorterDuffXPFactory::Get(mode);
      16           0 : }
      17             : 
      18           0 : void GrPaint::setCoverageSetOpXPFactory(SkRegion::Op regionOp, bool invertCoverage) {
      19           0 :     fXPFactory = GrCoverageSetOpXPFactory::Get(regionOp, invertCoverage);
      20           0 : }
      21             : 
      22           0 : void GrPaint::addColorTextureProcessor(GrResourceProvider* resourceProvider,
      23             :                                        sk_sp<GrTextureProxy> proxy,
      24             :                                        sk_sp<GrColorSpaceXform> colorSpaceXform,
      25             :                                        const SkMatrix& matrix) {
      26           0 :     this->addColorFragmentProcessor(GrSimpleTextureEffect::Make(resourceProvider, std::move(proxy),
      27           0 :                                                                 std::move(colorSpaceXform),
      28           0 :                                                                 matrix));
      29           0 : }
      30             : 
      31           0 : void GrPaint::addColorTextureProcessor(GrResourceProvider* resourceProvider,
      32             :                                        sk_sp<GrTextureProxy> proxy,
      33             :                                        sk_sp<GrColorSpaceXform> colorSpaceXform,
      34             :                                        const SkMatrix& matrix,
      35             :                                        const GrSamplerParams& params) {
      36           0 :     this->addColorFragmentProcessor(GrSimpleTextureEffect::Make(resourceProvider,
      37           0 :                                                                 std::move(proxy),
      38           0 :                                                                 std::move(colorSpaceXform),
      39           0 :                                                                 matrix, params));
      40           0 : }
      41             : 
      42           0 : void GrPaint::addCoverageTextureProcessor(GrResourceProvider* resourceProvider,
      43             :                                           sk_sp<GrTextureProxy> proxy,
      44             :                                           const SkMatrix& matrix) {
      45           0 :     this->addCoverageFragmentProcessor(GrSimpleTextureEffect::Make(resourceProvider,
      46           0 :                                                                    std::move(proxy),
      47           0 :                                                                    nullptr, matrix));
      48           0 : }
      49             : 
      50           0 : void GrPaint::addCoverageTextureProcessor(GrResourceProvider* resourceProvider,
      51             :                                           sk_sp<GrTextureProxy> proxy,
      52             :                                           const SkMatrix& matrix,
      53             :                                           const GrSamplerParams& params) {
      54           0 :     this->addCoverageFragmentProcessor(GrSimpleTextureEffect::Make(resourceProvider,
      55           0 :                                                                    std::move(proxy),
      56           0 :                                                                    nullptr, matrix, params));
      57           0 : }
      58             : 
      59           0 : bool GrPaint::isConstantBlendedColor(GrColor* constantColor) const {
      60             :     // This used to do a more sophisticated analysis but now it just explicitly looks for common
      61             :     // cases.
      62           0 :     static const GrXPFactory* kSrc = GrPorterDuffXPFactory::Get(SkBlendMode::kSrc);
      63           0 :     static const GrXPFactory* kClear = GrPorterDuffXPFactory::Get(SkBlendMode::kClear);
      64           0 :     if (kClear == fXPFactory) {
      65           0 :         *constantColor = GrColor_TRANSPARENT_BLACK;
      66           0 :         return true;
      67             :     }
      68           0 :     if (this->numColorFragmentProcessors()) {
      69           0 :         return false;
      70             :     }
      71           0 :     if (kSrc == fXPFactory || (!fXPFactory && fColor.isOpaque())) {
      72           0 :         *constantColor = fColor.toGrColor();
      73           0 :         return true;
      74             :     }
      75           0 :     return false;
      76             : }