| /* |
| * Copyright 2014 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "src/gpu/ganesh/effects/GrCoverageSetOpXP.h" |
| |
| #include "include/private/SkColorData.h" |
| #include "include/private/base/SkAssert.h" |
| #include "src/base/SkRandom.h" |
| #include "src/gpu/Blend.h" |
| #include "src/gpu/KeyBuilder.h" |
| #include "src/gpu/ganesh/GrXferProcessor.h" |
| #include "src/gpu/ganesh/glsl/GrGLSLFragmentShaderBuilder.h" |
| |
| #include <memory> |
| |
| enum class GrClampType; |
| struct GrShaderCaps; |
| |
| class CoverageSetOpXP : public GrXferProcessor { |
| public: |
| CoverageSetOpXP(SkRegion::Op regionOp, bool invertCoverage) |
| : INHERITED(kCoverageSetOpXP_ClassID) |
| , fRegionOp(regionOp) |
| , fInvertCoverage(invertCoverage) {} |
| |
| const char* name() const override { return "Coverage Set Op"; } |
| |
| std::unique_ptr<ProgramImpl> makeProgramImpl() const override; |
| |
| private: |
| void onAddToKey(const GrShaderCaps&, skgpu::KeyBuilder*) const override; |
| |
| void onGetBlendInfo(skgpu::BlendInfo* blendInfo) const override; |
| |
| bool onIsEqual(const GrXferProcessor& xpBase) const override { |
| const CoverageSetOpXP& xp = xpBase.cast<CoverageSetOpXP>(); |
| return (fRegionOp == xp.fRegionOp && |
| fInvertCoverage == xp.fInvertCoverage); |
| } |
| |
| SkRegion::Op fRegionOp; |
| bool fInvertCoverage; |
| |
| using INHERITED = GrXferProcessor; |
| }; |
| |
| void CoverageSetOpXP::onAddToKey(const GrShaderCaps& caps, skgpu::KeyBuilder* b) const { |
| b->addBool(fInvertCoverage, "invert coverage"); |
| } |
| |
| std::unique_ptr<GrXferProcessor::ProgramImpl> CoverageSetOpXP::makeProgramImpl() const { |
| class Impl : public ProgramImpl { |
| private: |
| void emitOutputsForBlendState(const EmitArgs& args) override { |
| const CoverageSetOpXP& xp = args.fXP.cast<CoverageSetOpXP>(); |
| GrGLSLXPFragmentBuilder* fb = args.fXPFragBuilder; |
| if (xp.fInvertCoverage) { |
| fb->codeAppendf("%s = 1.0 - %s;", args.fOutputPrimary, args.fInputCoverage); |
| } else { |
| fb->codeAppendf("%s = %s;", args.fOutputPrimary, args.fInputCoverage); |
| } |
| } |
| }; |
| return std::make_unique<Impl>(); |
| } |
| |
| void CoverageSetOpXP::onGetBlendInfo(skgpu::BlendInfo* blendInfo) const { |
| switch (fRegionOp) { |
| case SkRegion::kReplace_Op: |
| blendInfo->fSrcBlend = skgpu::BlendCoeff::kOne; |
| blendInfo->fDstBlend = skgpu::BlendCoeff::kZero; |
| break; |
| case SkRegion::kIntersect_Op: |
| blendInfo->fSrcBlend = skgpu::BlendCoeff::kDC; |
| blendInfo->fDstBlend = skgpu::BlendCoeff::kZero; |
| break; |
| case SkRegion::kUnion_Op: |
| blendInfo->fSrcBlend = skgpu::BlendCoeff::kOne; |
| blendInfo->fDstBlend = skgpu::BlendCoeff::kISC; |
| break; |
| case SkRegion::kXOR_Op: |
| blendInfo->fSrcBlend = skgpu::BlendCoeff::kIDC; |
| blendInfo->fDstBlend = skgpu::BlendCoeff::kISC; |
| break; |
| case SkRegion::kDifference_Op: |
| blendInfo->fSrcBlend = skgpu::BlendCoeff::kZero; |
| blendInfo->fDstBlend = skgpu::BlendCoeff::kISC; |
| break; |
| case SkRegion::kReverseDifference_Op: |
| blendInfo->fSrcBlend = skgpu::BlendCoeff::kIDC; |
| blendInfo->fDstBlend = skgpu::BlendCoeff::kZero; |
| break; |
| } |
| blendInfo->fBlendConstant = SK_PMColor4fTRANSPARENT; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| constexpr GrCoverageSetOpXPFactory::GrCoverageSetOpXPFactory(SkRegion::Op regionOp, |
| bool invertCoverage) |
| : fRegionOp(regionOp), fInvertCoverage(invertCoverage) {} |
| |
| const GrXPFactory* GrCoverageSetOpXPFactory::Get(SkRegion::Op regionOp, bool invertCoverage) { |
| switch (regionOp) { |
| case SkRegion::kReplace_Op: { |
| if (invertCoverage) { |
| static constexpr const GrCoverageSetOpXPFactory gReplaceCDXPFI( |
| SkRegion::kReplace_Op, true); |
| return &gReplaceCDXPFI; |
| } else { |
| static constexpr const GrCoverageSetOpXPFactory gReplaceCDXPF(SkRegion::kReplace_Op, |
| false); |
| return &gReplaceCDXPF; |
| } |
| } |
| case SkRegion::kIntersect_Op: { |
| if (invertCoverage) { |
| static constexpr const GrCoverageSetOpXPFactory gIntersectCDXPFI( |
| SkRegion::kIntersect_Op, true); |
| return &gIntersectCDXPFI; |
| } else { |
| static constexpr const GrCoverageSetOpXPFactory gIntersectCDXPF( |
| SkRegion::kIntersect_Op, false); |
| return &gIntersectCDXPF; |
| } |
| } |
| case SkRegion::kUnion_Op: { |
| if (invertCoverage) { |
| static constexpr const GrCoverageSetOpXPFactory gUnionCDXPFI(SkRegion::kUnion_Op, |
| true); |
| return &gUnionCDXPFI; |
| } else { |
| static constexpr const GrCoverageSetOpXPFactory gUnionCDXPF(SkRegion::kUnion_Op, |
| false); |
| return &gUnionCDXPF; |
| } |
| } |
| case SkRegion::kXOR_Op: { |
| if (invertCoverage) { |
| static constexpr const GrCoverageSetOpXPFactory gXORCDXPFI(SkRegion::kXOR_Op, true); |
| return &gXORCDXPFI; |
| } else { |
| static constexpr const GrCoverageSetOpXPFactory gXORCDXPF(SkRegion::kXOR_Op, false); |
| return &gXORCDXPF; |
| } |
| } |
| case SkRegion::kDifference_Op: { |
| if (invertCoverage) { |
| static constexpr const GrCoverageSetOpXPFactory gDifferenceCDXPFI( |
| SkRegion::kDifference_Op, true); |
| return &gDifferenceCDXPFI; |
| } else { |
| static constexpr const GrCoverageSetOpXPFactory gDifferenceCDXPF( |
| SkRegion::kDifference_Op, false); |
| return &gDifferenceCDXPF; |
| } |
| } |
| case SkRegion::kReverseDifference_Op: { |
| if (invertCoverage) { |
| static constexpr const GrCoverageSetOpXPFactory gRevDiffCDXPFI( |
| SkRegion::kReverseDifference_Op, true); |
| return &gRevDiffCDXPFI; |
| } else { |
| static constexpr const GrCoverageSetOpXPFactory gRevDiffCDXPF( |
| SkRegion::kReverseDifference_Op, false); |
| return &gRevDiffCDXPF; |
| } |
| } |
| } |
| SK_ABORT("Unknown region op."); |
| } |
| |
| sk_sp<const GrXferProcessor> GrCoverageSetOpXPFactory::makeXferProcessor( |
| const GrProcessorAnalysisColor&, |
| GrProcessorAnalysisCoverage, |
| const GrCaps& caps, |
| GrClampType) const { |
| return sk_sp<GrXferProcessor>(new CoverageSetOpXP(fRegionOp, fInvertCoverage)); |
| } |
| |
| GR_DEFINE_XP_FACTORY_TEST(GrCoverageSetOpXPFactory) |
| |
| #if defined(GR_TEST_UTILS) |
| const GrXPFactory* GrCoverageSetOpXPFactory::TestGet(GrProcessorTestData* d) { |
| SkRegion::Op regionOp = SkRegion::Op(d->fRandom->nextULessThan(SkRegion::kLastOp + 1)); |
| bool invertCoverage = d->fRandom->nextBool(); |
| return GrCoverageSetOpXPFactory::Get(regionOp, invertCoverage); |
| } |
| #endif |