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