1 /*
2 * Copyright 2017 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 "src/gpu/ccpr/GrCCClipProcessor.h"
9
10 #include "include/gpu/GrTexture.h"
11 #include "src/core/SkMakeUnique.h"
12 #include "src/gpu/GrTextureProxy.h"
13 #include "src/gpu/ccpr/GrCCClipPath.h"
14 #include "src/gpu/glsl/GrGLSLFragmentProcessor.h"
15 #include "src/gpu/glsl/GrGLSLFragmentShaderBuilder.h"
16
GrCCClipProcessor(const GrCCClipPath * clipPath,IsCoverageCount isCoverageCount,MustCheckBounds mustCheckBounds)17 GrCCClipProcessor::GrCCClipProcessor(const GrCCClipPath* clipPath, IsCoverageCount isCoverageCount,
18 MustCheckBounds mustCheckBounds)
19 : INHERITED(kGrCCClipProcessor_ClassID, kCompatibleWithCoverageAsAlpha_OptimizationFlag)
20 , fClipPath(clipPath)
21 , fIsCoverageCount(IsCoverageCount::kYes == isCoverageCount)
22 , fMustCheckBounds(MustCheckBounds::kYes == mustCheckBounds)
23 , fAtlasAccess(sk_ref_sp(fClipPath->atlasLazyProxy()), GrSamplerState::Filter::kNearest,
24 GrSamplerState::WrapMode::kClamp) {
25 SkASSERT(fAtlasAccess.proxy());
26 this->setTextureSamplerCnt(1);
27 }
28
clone() const29 std::unique_ptr<GrFragmentProcessor> GrCCClipProcessor::clone() const {
30 return skstd::make_unique<GrCCClipProcessor>(
31 fClipPath, IsCoverageCount(fIsCoverageCount), MustCheckBounds(fMustCheckBounds));
32 }
33
onGetGLSLProcessorKey(const GrShaderCaps &,GrProcessorKeyBuilder * b) const34 void GrCCClipProcessor::onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder* b) const {
35 const SkPath& clipPath = fClipPath->deviceSpacePath();
36 uint32_t key = (fIsCoverageCount) ? (uint32_t)GrFillRuleForSkPath(clipPath) : 0;
37 key = (key << 1) | ((clipPath.isInverseFillType()) ? 1 : 0);
38 key = (key << 1) | ((fMustCheckBounds) ? 1 : 0);
39 b->add32(key);
40 }
41
onIsEqual(const GrFragmentProcessor & fp) const42 bool GrCCClipProcessor::onIsEqual(const GrFragmentProcessor& fp) const {
43 const GrCCClipProcessor& that = fp.cast<GrCCClipProcessor>();
44 // Each ClipPath path has a unique atlas proxy, so hasSameSamplersAndAccesses should have
45 // already weeded out FPs with different ClipPaths.
46 SkASSERT(that.fClipPath->deviceSpacePath().getGenerationID() ==
47 fClipPath->deviceSpacePath().getGenerationID());
48 return that.fClipPath->deviceSpacePath().getFillType() ==
49 fClipPath->deviceSpacePath().getFillType() &&
50 that.fIsCoverageCount == fIsCoverageCount && that.fMustCheckBounds == fMustCheckBounds;
51 }
52
53 class GrCCClipProcessor::Impl : public GrGLSLFragmentProcessor {
54 public:
emitCode(EmitArgs & args)55 void emitCode(EmitArgs& args) override {
56 const GrCCClipProcessor& proc = args.fFp.cast<GrCCClipProcessor>();
57 GrGLSLUniformHandler* uniHandler = args.fUniformHandler;
58 GrGLSLFPFragmentBuilder* f = args.fFragBuilder;
59
60 f->codeAppend ("half coverage;");
61
62 if (proc.fMustCheckBounds) {
63 const char* pathIBounds;
64 fPathIBoundsUniform = uniHandler->addUniform(kFragment_GrShaderFlag, kFloat4_GrSLType,
65 "path_ibounds", &pathIBounds);
66 f->codeAppendf("if (all(greaterThan(float4(sk_FragCoord.xy, %s.zw), "
67 "float4(%s.xy, sk_FragCoord.xy)))) {",
68 pathIBounds, pathIBounds);
69 }
70
71 const char* atlasTransform;
72 fAtlasTransformUniform = uniHandler->addUniform(kFragment_GrShaderFlag, kFloat4_GrSLType,
73 "atlas_transform", &atlasTransform);
74 f->codeAppendf("float2 texcoord = sk_FragCoord.xy * %s.xy + %s.zw;",
75 atlasTransform, atlasTransform);
76
77 f->codeAppend ("coverage = ");
78 f->appendTextureLookup(args.fTexSamplers[0], "texcoord", kHalf2_GrSLType);
79 f->codeAppend (".a;");
80
81 if (proc.fIsCoverageCount) {
82 auto fillRule = GrFillRuleForSkPath(proc.fClipPath->deviceSpacePath());
83 if (GrFillRule::kEvenOdd == fillRule) {
84 f->codeAppend ("half t = mod(abs(coverage), 2);");
85 f->codeAppend ("coverage = 1 - abs(t - 1);");
86 } else {
87 SkASSERT(GrFillRule::kNonzero == fillRule);
88 f->codeAppend ("coverage = min(abs(coverage), 1);");
89 }
90 }
91
92 if (proc.fMustCheckBounds) {
93 f->codeAppend ("} else {");
94 f->codeAppend ( "coverage = 0;");
95 f->codeAppend ("}");
96 }
97
98 if (proc.fClipPath->deviceSpacePath().isInverseFillType()) {
99 f->codeAppend ("coverage = 1 - coverage;");
100 }
101
102 f->codeAppendf("%s = %s * coverage;", args.fOutputColor, args.fInputColor);
103 }
104
onSetData(const GrGLSLProgramDataManager & pdman,const GrFragmentProcessor & fp)105 void onSetData(const GrGLSLProgramDataManager& pdman,
106 const GrFragmentProcessor& fp) override {
107 const GrCCClipProcessor& proc = fp.cast<GrCCClipProcessor>();
108 if (proc.fMustCheckBounds) {
109 const SkRect pathIBounds = SkRect::Make(proc.fClipPath->pathDevIBounds());
110 pdman.set4f(fPathIBoundsUniform, pathIBounds.left(), pathIBounds.top(),
111 pathIBounds.right(), pathIBounds.bottom());
112 }
113 const SkVector& scale = proc.fClipPath->atlasScale();
114 const SkVector& trans = proc.fClipPath->atlasTranslate();
115 pdman.set4f(fAtlasTransformUniform, scale.x(), scale.y(), trans.x(), trans.y());
116 }
117
118 private:
119 UniformHandle fPathIBoundsUniform;
120 UniformHandle fAtlasTransformUniform;
121 };
122
onCreateGLSLInstance() const123 GrGLSLFragmentProcessor* GrCCClipProcessor::onCreateGLSLInstance() const {
124 return new Impl();
125 }
126