blob: 76293e214a564b0ae0e105fe9fe8b9ea0fb954c2 [file] [log] [blame]
Chris Daltona32a3c32017-12-05 10:05:21 -07001/*
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
Mike Kleinc0bd9f92019-04-23 12:05:21 -05008#include "src/gpu/ccpr/GrCCClipProcessor.h"
Chris Daltona32a3c32017-12-05 10:05:21 -07009
Mike Kleinc0bd9f92019-04-23 12:05:21 -050010#include "include/gpu/GrTexture.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050011#include "src/core/SkMakeUnique.h"
Greg Danielf91aeb22019-06-18 09:58:02 -040012#include "src/gpu/GrTextureProxy.h"
Ben Wagner729a23f2019-05-17 16:29:34 -040013#include "src/gpu/ccpr/GrCCClipPath.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050014#include "src/gpu/glsl/GrGLSLFragmentProcessor.h"
15#include "src/gpu/glsl/GrGLSLFragmentShaderBuilder.h"
Chris Daltona32a3c32017-12-05 10:05:21 -070016
Chris Daltonc3318f02019-07-19 14:20:53 -060017GrCCClipProcessor::GrCCClipProcessor(const GrCCClipPath* clipPath, IsCoverageCount isCoverageCount,
18 MustCheckBounds mustCheckBounds)
Chris Dalton383a2ef2018-01-08 17:21:41 -050019 : INHERITED(kGrCCClipProcessor_ClassID, kCompatibleWithCoverageAsAlpha_OptimizationFlag)
Chris Daltona32a3c32017-12-05 10:05:21 -070020 , fClipPath(clipPath)
Chris Daltonc3318f02019-07-19 14:20:53 -060021 , fIsCoverageCount(IsCoverageCount::kYes == isCoverageCount)
22 , fMustCheckBounds(MustCheckBounds::kYes == mustCheckBounds)
Robert Phillipsf272bea2019-10-17 08:56:16 -040023 , fAtlasAccess(sk_ref_sp(fClipPath->atlasLazyProxy())) {
Robert Phillipsbd99c0c2019-12-12 13:26:58 +000024 SkASSERT(fAtlasAccess.view().proxy());
Brian Salomonf7dcd762018-07-30 14:48:15 -040025 this->setTextureSamplerCnt(1);
Chris Daltona32a3c32017-12-05 10:05:21 -070026}
27
Chris Dalton383a2ef2018-01-08 17:21:41 -050028std::unique_ptr<GrFragmentProcessor> GrCCClipProcessor::clone() const {
Chris Daltonc3318f02019-07-19 14:20:53 -060029 return skstd::make_unique<GrCCClipProcessor>(
30 fClipPath, IsCoverageCount(fIsCoverageCount), MustCheckBounds(fMustCheckBounds));
Chris Daltona32a3c32017-12-05 10:05:21 -070031}
32
Chris Dalton383a2ef2018-01-08 17:21:41 -050033void GrCCClipProcessor::onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder* b) const {
Chris Daltonc3318f02019-07-19 14:20:53 -060034 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);
Chris Daltona32a3c32017-12-05 10:05:21 -070039}
40
Chris Dalton383a2ef2018-01-08 17:21:41 -050041bool GrCCClipProcessor::onIsEqual(const GrFragmentProcessor& fp) const {
42 const GrCCClipProcessor& that = fp.cast<GrCCClipProcessor>();
Chris Daltona32a3c32017-12-05 10:05:21 -070043 // 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());
Chris Daltonc3318f02019-07-19 14:20:53 -060047 return that.fClipPath->deviceSpacePath().getFillType() ==
48 fClipPath->deviceSpacePath().getFillType() &&
49 that.fIsCoverageCount == fIsCoverageCount && that.fMustCheckBounds == fMustCheckBounds;
Chris Daltona32a3c32017-12-05 10:05:21 -070050}
51
Chris Dalton383a2ef2018-01-08 17:21:41 -050052class GrCCClipProcessor::Impl : public GrGLSLFragmentProcessor {
Chris Daltona32a3c32017-12-05 10:05:21 -070053public:
54 void emitCode(EmitArgs& args) override {
Chris Dalton383a2ef2018-01-08 17:21:41 -050055 const GrCCClipProcessor& proc = args.fFp.cast<GrCCClipProcessor>();
Chris Daltona32a3c32017-12-05 10:05:21 -070056 GrGLSLUniformHandler* uniHandler = args.fUniformHandler;
57 GrGLSLFPFragmentBuilder* f = args.fFragBuilder;
58
59 f->codeAppend ("half coverage;");
Chris Daltonc3318f02019-07-19 14:20:53 -060060
Chris Daltona32a3c32017-12-05 10:05:21 -070061 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
Chris Daltonc3318f02019-07-19 14:20:53 -060076 f->codeAppend ("coverage = ");
Chris Daltona32a3c32017-12-05 10:05:21 -070077 f->appendTextureLookup(args.fTexSamplers[0], "texcoord", kHalf2_GrSLType);
78 f->codeAppend (".a;");
79
Chris Daltonc3318f02019-07-19 14:20:53 -060080 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 }
Chris Daltona32a3c32017-12-05 10:05:21 -070089 }
90
91 if (proc.fMustCheckBounds) {
92 f->codeAppend ("} else {");
93 f->codeAppend ( "coverage = 0;");
94 f->codeAppend ("}");
95 }
96
Chris Daltonc3318f02019-07-19 14:20:53 -060097 if (proc.fClipPath->deviceSpacePath().isInverseFillType()) {
Chris Daltona32a3c32017-12-05 10:05:21 -070098 f->codeAppend ("coverage = 1 - coverage;");
99 }
100
101 f->codeAppendf("%s = %s * coverage;", args.fOutputColor, args.fInputColor);
102 }
103
104 void onSetData(const GrGLSLProgramDataManager& pdman,
105 const GrFragmentProcessor& fp) override {
Chris Dalton383a2ef2018-01-08 17:21:41 -0500106 const GrCCClipProcessor& proc = fp.cast<GrCCClipProcessor>();
Chris Daltona32a3c32017-12-05 10:05:21 -0700107 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
117private:
118 UniformHandle fPathIBoundsUniform;
119 UniformHandle fAtlasTransformUniform;
120};
121
Chris Dalton383a2ef2018-01-08 17:21:41 -0500122GrGLSLFragmentProcessor* GrCCClipProcessor::onCreateGLSLInstance() const {
Chris Daltona32a3c32017-12-05 10:05:21 -0700123 return new Impl();
124}