1 | /* |
2 | * Copyright 2018 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 | /************************************************************************************************** |
9 | *** This file was autogenerated from GrRRectBlurEffect.fp; do not modify. |
10 | **************************************************************************************************/ |
11 | #include "GrRRectBlurEffect.h" |
12 | |
13 | std::unique_ptr<GrFragmentProcessor> GrRRectBlurEffect::Make(GrRecordingContext* context, |
14 | float sigma, |
15 | float xformedSigma, |
16 | const SkRRect& srcRRect, |
17 | const SkRRect& devRRect) { |
18 | SkASSERT(!SkRRectPriv::IsCircle(devRRect) && |
19 | !devRRect.isRect()); // Should've been caught up-stream |
20 | |
21 | // TODO: loosen this up |
22 | if (!SkRRectPriv::IsSimpleCircular(devRRect)) { |
23 | return nullptr; |
24 | } |
25 | |
26 | // Make sure we can successfully ninepatch this rrect -- the blur sigma has to be |
27 | // sufficiently small relative to both the size of the corner radius and the |
28 | // width (and height) of the rrect. |
29 | SkRRect rrectToDraw; |
30 | SkISize dimensions; |
31 | SkScalar ignored[kSkBlurRRectMaxDivisions]; |
32 | int ignoredSize; |
33 | uint32_t ignored32; |
34 | |
35 | bool ninePatchable = SkComputeBlurredRRectParams( |
36 | srcRRect, devRRect, SkRect::MakeEmpty(), sigma, xformedSigma, &rrectToDraw, &dimensions, |
37 | ignored, ignored, ignored, ignored, &ignoredSize, &ignoredSize, &ignored32); |
38 | if (!ninePatchable) { |
39 | return nullptr; |
40 | } |
41 | |
42 | GrSurfaceProxyView mask = |
43 | find_or_create_rrect_blur_mask(context, rrectToDraw, dimensions, xformedSigma); |
44 | if (!mask) { |
45 | return nullptr; |
46 | } |
47 | |
48 | return std::unique_ptr<GrFragmentProcessor>( |
49 | new GrRRectBlurEffect(xformedSigma, devRRect.getBounds(), |
50 | SkRRectPriv::GetSimpleRadii(devRRect).fX, std::move(mask))); |
51 | } |
52 | #include "src/gpu/GrTexture.h" |
53 | #include "src/gpu/glsl/GrGLSLFragmentProcessor.h" |
54 | #include "src/gpu/glsl/GrGLSLFragmentShaderBuilder.h" |
55 | #include "src/gpu/glsl/GrGLSLProgramBuilder.h" |
56 | #include "src/sksl/SkSLCPP.h" |
57 | #include "src/sksl/SkSLUtil.h" |
58 | class GrGLSLRRectBlurEffect : public GrGLSLFragmentProcessor { |
59 | public: |
60 | GrGLSLRRectBlurEffect() {} |
61 | void emitCode(EmitArgs& args) override { |
62 | GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder; |
63 | const GrRRectBlurEffect& _outer = args.fFp.cast<GrRRectBlurEffect>(); |
64 | (void)_outer; |
65 | auto sigma = _outer.sigma; |
66 | (void)sigma; |
67 | auto rect = _outer.rect; |
68 | (void)rect; |
69 | auto cornerRadius = _outer.cornerRadius; |
70 | (void)cornerRadius; |
71 | cornerRadiusVar = args.fUniformHandler->addUniform(&_outer, kFragment_GrShaderFlag, |
72 | kHalf_GrSLType, "cornerRadius" ); |
73 | proxyRectVar = args.fUniformHandler->addUniform(&_outer, kFragment_GrShaderFlag, |
74 | kFloat4_GrSLType, "proxyRect" ); |
75 | blurRadiusVar = args.fUniformHandler->addUniform(&_outer, kFragment_GrShaderFlag, |
76 | kHalf_GrSLType, "blurRadius" ); |
77 | fragBuilder->codeAppendf( |
78 | "\nhalf2 translatedFragPos = half2(sk_FragCoord.xy - %s.xy);\nhalf threshold = %s " |
79 | "+ 2.0 * %s;\nhalf2 middle = half2((%s.zw - %s.xy) - float(2.0 * threshold));\nif " |
80 | "(translatedFragPos.x >= threshold && translatedFragPos.x < middle.x + threshold) " |
81 | "{\n translatedFragPos.x = threshold;\n} else if (translatedFragPos.x >= " |
82 | "middle.x + threshold) {\n translatedFragPos.x -= middle.x - 1.0;\n}\nif " |
83 | "(translatedFragPos.y > threshold && translatedFragPos.y < middle.y + threshold) " |
84 | "{\n translatedFragPos.y = threshold;" , |
85 | args.fUniformHandler->getUniformCStr(proxyRectVar), |
86 | args.fUniformHandler->getUniformCStr(cornerRadiusVar), |
87 | args.fUniformHandler->getUniformCStr(blurRadiusVar), |
88 | args.fUniformHandler->getUniformCStr(proxyRectVar), |
89 | args.fUniformHandler->getUniformCStr(proxyRectVar)); |
90 | fragBuilder->codeAppendf( |
91 | "\n} else if (translatedFragPos.y >= middle.y + threshold) {\n " |
92 | "translatedFragPos.y -= middle.y - 1.0;\n}\nhalf2 proxyDims = half2(2.0 * " |
93 | "threshold + 1.0);\nhalf2 texCoord = translatedFragPos / proxyDims;\n%s = %s * " |
94 | "sample(%s, float2(texCoord)).%s;\n" , |
95 | args.fOutputColor, args.fInputColor, |
96 | fragBuilder->getProgramBuilder()->samplerVariable(args.fTexSamplers[0]), |
97 | fragBuilder->getProgramBuilder() |
98 | ->samplerSwizzle(args.fTexSamplers[0]) |
99 | .asString() |
100 | .c_str()); |
101 | } |
102 | |
103 | private: |
104 | void onSetData(const GrGLSLProgramDataManager& pdman, |
105 | const GrFragmentProcessor& _proc) override { |
106 | const GrRRectBlurEffect& _outer = _proc.cast<GrRRectBlurEffect>(); |
107 | { pdman.set1f(cornerRadiusVar, (_outer.cornerRadius)); } |
108 | auto sigma = _outer.sigma; |
109 | (void)sigma; |
110 | auto rect = _outer.rect; |
111 | (void)rect; |
112 | UniformHandle& cornerRadius = cornerRadiusVar; |
113 | (void)cornerRadius; |
114 | const GrSurfaceProxyView& ninePatchSamplerView = _outer.textureSampler(0).view(); |
115 | GrTexture& ninePatchSampler = *ninePatchSamplerView.proxy()->peekTexture(); |
116 | (void)ninePatchSampler; |
117 | UniformHandle& proxyRect = proxyRectVar; |
118 | (void)proxyRect; |
119 | UniformHandle& blurRadius = blurRadiusVar; |
120 | (void)blurRadius; |
121 | |
122 | float blurRadiusValue = 3.f * SkScalarCeilToScalar(sigma - 1 / 6.0f); |
123 | pdman.set1f(blurRadius, blurRadiusValue); |
124 | |
125 | SkRect outset = rect; |
126 | outset.outset(blurRadiusValue, blurRadiusValue); |
127 | pdman.set4f(proxyRect, outset.fLeft, outset.fTop, outset.fRight, outset.fBottom); |
128 | } |
129 | UniformHandle proxyRectVar; |
130 | UniformHandle blurRadiusVar; |
131 | UniformHandle cornerRadiusVar; |
132 | }; |
133 | GrGLSLFragmentProcessor* GrRRectBlurEffect::onCreateGLSLInstance() const { |
134 | return new GrGLSLRRectBlurEffect(); |
135 | } |
136 | void GrRRectBlurEffect::onGetGLSLProcessorKey(const GrShaderCaps& caps, |
137 | GrProcessorKeyBuilder* b) const {} |
138 | bool GrRRectBlurEffect::onIsEqual(const GrFragmentProcessor& other) const { |
139 | const GrRRectBlurEffect& that = other.cast<GrRRectBlurEffect>(); |
140 | (void)that; |
141 | if (sigma != that.sigma) return false; |
142 | if (rect != that.rect) return false; |
143 | if (cornerRadius != that.cornerRadius) return false; |
144 | if (ninePatchSampler != that.ninePatchSampler) return false; |
145 | return true; |
146 | } |
147 | GrRRectBlurEffect::GrRRectBlurEffect(const GrRRectBlurEffect& src) |
148 | : INHERITED(kGrRRectBlurEffect_ClassID, src.optimizationFlags()) |
149 | , sigma(src.sigma) |
150 | , rect(src.rect) |
151 | , cornerRadius(src.cornerRadius) |
152 | , ninePatchSampler(src.ninePatchSampler) { |
153 | this->setTextureSamplerCnt(1); |
154 | } |
155 | std::unique_ptr<GrFragmentProcessor> GrRRectBlurEffect::clone() const { |
156 | return std::unique_ptr<GrFragmentProcessor>(new GrRRectBlurEffect(*this)); |
157 | } |
158 | const GrFragmentProcessor::TextureSampler& GrRRectBlurEffect::onTextureSampler(int index) const { |
159 | return IthTextureSampler(index, ninePatchSampler); |
160 | } |
161 | GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrRRectBlurEffect); |
162 | #if GR_TEST_UTILS |
163 | std::unique_ptr<GrFragmentProcessor> GrRRectBlurEffect::TestCreate(GrProcessorTestData* d) { |
164 | SkScalar w = d->fRandom->nextRangeScalar(100.f, 1000.f); |
165 | SkScalar h = d->fRandom->nextRangeScalar(100.f, 1000.f); |
166 | SkScalar r = d->fRandom->nextRangeF(1.f, 9.f); |
167 | SkScalar sigma = d->fRandom->nextRangeF(1.f, 10.f); |
168 | SkRRect rrect; |
169 | rrect.setRectXY(SkRect::MakeWH(w, h), r, r); |
170 | return GrRRectBlurEffect::Make(d->context(), sigma, sigma, rrect, rrect); |
171 | } |
172 | #endif |
173 | |