blob: 852c9d7fba93ffbcb3976865fbcdd5dd05913fea [file] [log] [blame]
commit-bot@chromium.org907fbd52013-12-09 17:03:02 +00001/*
2 * Copyright 2012 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/effects/GrTextureDomain.h"
Robert Phillips40fd7c92017-01-30 08:06:27 -05009
Mike Kleinc0bd9f92019-04-23 12:05:21 -050010#include "include/gpu/GrTexture.h"
11#include "include/private/SkFloatingPoint.h"
12#include "src/gpu/GrProxyProvider.h"
13#include "src/gpu/GrShaderCaps.h"
14#include "src/gpu/GrSurfaceProxyPriv.h"
15#include "src/gpu/effects/generated/GrSimpleTextureEffect.h"
16#include "src/gpu/glsl/GrGLSLFragmentProcessor.h"
17#include "src/gpu/glsl/GrGLSLFragmentShaderBuilder.h"
18#include "src/gpu/glsl/GrGLSLProgramDataManager.h"
19#include "src/gpu/glsl/GrGLSLShaderBuilder.h"
20#include "src/gpu/glsl/GrGLSLUniformHandler.h"
commit-bot@chromium.org907fbd52013-12-09 17:03:02 +000021
Ben Wagnerf08d1d02018-06-18 15:11:00 -040022#include <utility>
23
Michael Ludwigbe315a22018-12-17 09:50:51 -050024GrTextureDomain::GrTextureDomain(GrTextureProxy* proxy, const SkRect& domain, Mode modeX,
25 Mode modeY, int index)
26 : fModeX(modeX)
27 , fModeY(modeY)
Robert Phillips40fd7c92017-01-30 08:06:27 -050028 , fIndex(index) {
29
Michael Ludwigbe315a22018-12-17 09:50:51 -050030 if (!proxy) {
31 SkASSERT(modeX == kIgnore_Mode && modeY == kIgnore_Mode);
Robert Phillips40fd7c92017-01-30 08:06:27 -050032 return;
33 }
34
35 const SkRect kFullRect = SkRect::MakeIWH(proxy->width(), proxy->height());
36
37 // We don't currently handle domains that are empty or don't intersect the texture.
38 // It is OK if the domain rect is a line or point, but it should not be inverted. We do not
39 // handle rects that do not intersect the [0..1]x[0..1] rect.
40 SkASSERT(domain.fLeft <= domain.fRight);
41 SkASSERT(domain.fTop <= domain.fBottom);
42 fDomain.fLeft = SkScalarPin(domain.fLeft, 0.0f, kFullRect.fRight);
43 fDomain.fRight = SkScalarPin(domain.fRight, fDomain.fLeft, kFullRect.fRight);
44 fDomain.fTop = SkScalarPin(domain.fTop, 0.0f, kFullRect.fBottom);
45 fDomain.fBottom = SkScalarPin(domain.fBottom, fDomain.fTop, kFullRect.fBottom);
46 SkASSERT(fDomain.fLeft <= fDomain.fRight);
47 SkASSERT(fDomain.fTop <= fDomain.fBottom);
48}
49
commit-bot@chromium.org907fbd52013-12-09 17:03:02 +000050//////////////////////////////////////////////////////////////////////////////
51
Michael Ludwigbe315a22018-12-17 09:50:51 -050052static SkString clamp_expression(GrTextureDomain::Mode mode, const char* inCoord,
53 const char* coordSwizzle, const char* domain,
54 const char* minSwizzle, const char* maxSwizzle) {
55 SkString clampedExpr;
56 switch(mode) {
57 case GrTextureDomain::kIgnore_Mode:
58 clampedExpr.printf("%s.%s\n", inCoord, coordSwizzle);
59 break;
60 case GrTextureDomain::kDecal_Mode:
61 // The lookup coordinate to use for decal will be clamped just like kClamp_Mode,
62 // it's just that the post-processing will be different, so fall through
63 case GrTextureDomain::kClamp_Mode:
64 clampedExpr.printf("clamp(%s.%s, %s.%s, %s.%s)",
65 inCoord, coordSwizzle, domain, minSwizzle, domain, maxSwizzle);
66 break;
67 case GrTextureDomain::kRepeat_Mode:
68 clampedExpr.printf("mod(%s.%s - %s.%s, %s.%s - %s.%s) + %s.%s",
69 inCoord, coordSwizzle, domain, minSwizzle, domain, maxSwizzle,
70 domain, minSwizzle, domain, minSwizzle);
71 break;
72 default:
73 SkASSERTF(false, "Unknown texture domain mode: %u\n", (uint32_t) mode);
74 break;
75 }
76 return clampedExpr;
77}
78
egdaniel2d721d32015-11-11 13:06:05 -080079void GrTextureDomain::GLDomain::sampleTexture(GrGLSLShaderBuilder* builder,
egdaniel7ea439b2015-12-03 09:20:44 -080080 GrGLSLUniformHandler* uniformHandler,
Brian Salomon1edc5b92016-11-29 13:43:46 -050081 const GrShaderCaps* shaderCaps,
commit-bot@chromium.org907fbd52013-12-09 17:03:02 +000082 const GrTextureDomain& textureDomain,
83 const char* outColor,
84 const SkString& inCoords,
egdaniel09aa1fc2016-04-20 07:09:46 -070085 GrGLSLFragmentProcessor::SamplerHandle sampler,
Brian Osman2240be92017-10-18 13:15:13 -040086 const char* inModulateColor) {
Michael Ludwigbe315a22018-12-17 09:50:51 -050087 SkASSERT(!fHasMode || (textureDomain.modeX() == fModeX && textureDomain.modeY() == fModeY));
88 SkDEBUGCODE(fModeX = textureDomain.modeX();)
89 SkDEBUGCODE(fModeY = textureDomain.modeY();)
Hans Wennborgc63ec5c2017-12-08 18:56:23 -080090 SkDEBUGCODE(fHasMode = true;)
commit-bot@chromium.org907fbd52013-12-09 17:03:02 +000091
Michael Ludwigbe315a22018-12-17 09:50:51 -050092 if ((textureDomain.modeX() != kIgnore_Mode || textureDomain.modeY() != kIgnore_Mode) &&
93 !fDomainUni.isValid()) {
94 // Must include the domain uniform since at least one axis uses it
commit-bot@chromium.org907fbd52013-12-09 17:03:02 +000095 const char* name;
96 SkString uniName("TexDom");
97 if (textureDomain.fIndex >= 0) {
98 uniName.appendS32(textureDomain.fIndex);
99 }
Ethan Nicholasf7b88202017-09-18 14:10:39 -0400100 fDomainUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType,
egdaniel7ea439b2015-12-03 09:20:44 -0800101 uniName.c_str(), &name);
commit-bot@chromium.org907fbd52013-12-09 17:03:02 +0000102 fDomainName = name;
103 }
commit-bot@chromium.org907fbd52013-12-09 17:03:02 +0000104
Michael Ludwigbe315a22018-12-17 09:50:51 -0500105 bool decalX = textureDomain.modeX() == kDecal_Mode;
106 bool decalY = textureDomain.modeY() == kDecal_Mode;
107 if ((decalX || decalY) && !fDecalUni.isValid()) {
108 const char* name;
109 SkString uniName("DecalParams");
110 if (textureDomain.fIndex >= 0) {
111 uniName.appendS32(textureDomain.fIndex);
joshualitt5ae5fc52014-07-29 12:59:27 -0700112 }
Michael Ludwigbe315a22018-12-17 09:50:51 -0500113 // Half3 since this will hold texture width, height, and then a step function control param
114 fDecalUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf3_GrSLType,
115 uniName.c_str(), &name);
116 fDecalName = name;
117 }
commit-bot@chromium.org907fbd52013-12-09 17:03:02 +0000118
Michael Ludwigbe315a22018-12-17 09:50:51 -0500119 // Add a block so that we can declare variables
120 GrGLSLShaderBuilder::ShaderBlock block(builder);
121 // Always use a local variable for the input coordinates; often callers pass in an expression
122 // and we want to cache it across all of its references in the code below
123 builder->codeAppendf("float2 origCoord = %s;", inCoords.c_str());
124 builder->codeAppend("float2 clampedCoord = ");
125 if (textureDomain.modeX() != textureDomain.modeY()) {
126 // The wrap modes differ on the two axes, so build up a coordinate that respects each axis'
127 // domain rule independently before sampling the texture.
128 SkString tcX = clamp_expression(textureDomain.modeX(), "origCoord", "x",
129 fDomainName.c_str(), "x", "z");
130 SkString tcY = clamp_expression(textureDomain.modeY(), "origCoord", "y",
131 fDomainName.c_str(), "y", "w");
132 builder->codeAppendf("float2(%s, %s)", tcX.c_str(), tcY.c_str());
133 } else {
134 // Since the x and y axis wrap modes are the same, they can be calculated together using
135 // more efficient vector operations
136 SkString tc = clamp_expression(textureDomain.modeX(), "origCoord", "xy",
137 fDomainName.c_str(), "xy", "zw");
138 builder->codeAppend(tc.c_str());
139 }
140 builder->codeAppend(";");
141
142 // Look up the texture sample at the clamped coordinate location
143 builder->codeAppend("half4 inside = ");
144 builder->appendTextureLookupAndModulate(inModulateColor, sampler, "clampedCoord",
145 kFloat2_GrSLType);
146 builder->codeAppend(";");
147
148 // Apply decal mode's transparency interpolation if needed
149 if (decalX || decalY) {
150 // The decal err is the max absoluate value between the clamped coordinate and the original
151 // pixel coordinate. This will then be clamped to 1.f if it's greater than the control
152 // parameter, which simulates kNearest and kBilerp behavior depending on if it's 0 or 1.
153 if (decalX && decalY) {
Ethan Nicholase1f55022019-02-05 17:17:40 -0500154 builder->codeAppendf("half err = max(half(abs(clampedCoord.x - origCoord.x) * %s.x), "
155 "half(abs(clampedCoord.y - origCoord.y) * %s.y));",
Michael Ludwigbe315a22018-12-17 09:50:51 -0500156 fDecalName.c_str(), fDecalName.c_str());
157 } else if (decalX) {
Ethan Nicholase1f55022019-02-05 17:17:40 -0500158 builder->codeAppendf("half err = half(abs(clampedCoord.x - origCoord.x) * %s.x);",
Michael Ludwigbe315a22018-12-17 09:50:51 -0500159 fDecalName.c_str());
160 } else {
161 SkASSERT(decalY);
Ethan Nicholase1f55022019-02-05 17:17:40 -0500162 builder->codeAppendf("half err = half(abs(clampedCoord.y - origCoord.y) * %s.y);",
Michael Ludwigbe315a22018-12-17 09:50:51 -0500163 fDecalName.c_str());
joshualitt5ae5fc52014-07-29 12:59:27 -0700164 }
joshualitt5ae5fc52014-07-29 12:59:27 -0700165
Michael Ludwigbe315a22018-12-17 09:50:51 -0500166 // Apply a transform to the error rate, which let's us simulate nearest or bilerp filtering
167 // in the same shader. When the texture is nearest filtered, fSizeName.z is set to 1/2 so
168 // this becomes a step function centered at .5 away from the clamped coordinate (but the
169 // domain for decal is inset by .5 so the edge lines up properly). When bilerp, fSizeName.z
170 // is set to 1 and it becomes a simple linear blend between texture and transparent.
171 builder->codeAppendf("if (err > %s.z) { err = 1.0; } else if (%s.z < 1) { err = 0.0; }",
172 fDecalName.c_str(), fDecalName.c_str());
173 builder->codeAppendf("%s = mix(inside, half4(0, 0, 0, 0), err);", outColor);
174 } else {
175 // A simple look up
176 builder->codeAppendf("%s = inside;", outColor);
commit-bot@chromium.org907fbd52013-12-09 17:03:02 +0000177 }
178}
179
egdaniel018fb622015-10-28 07:26:40 -0700180void GrTextureDomain::GLDomain::setData(const GrGLSLProgramDataManager& pdman,
commit-bot@chromium.org907fbd52013-12-09 17:03:02 +0000181 const GrTextureDomain& textureDomain,
Michael Ludwigbe315a22018-12-17 09:50:51 -0500182 GrTextureProxy* proxy,
183 const GrSamplerState& sampler) {
Brian Salomonfd98c2c2018-07-31 17:25:29 -0400184 GrTexture* tex = proxy->peekTexture();
Michael Ludwigbe315a22018-12-17 09:50:51 -0500185 SkASSERT(fHasMode && textureDomain.modeX() == fModeX && textureDomain.modeY() == fModeY);
186 if (kIgnore_Mode != textureDomain.modeX() || kIgnore_Mode != textureDomain.modeY()) {
187 bool sendDecalData = textureDomain.modeX() == kDecal_Mode ||
188 textureDomain.modeY() == kDecal_Mode;
189
190 // If the texture is using nearest filtering, then the decal filter weight should step from
191 // 0 (texture) to 1 (transparent) one half pixel away from the domain. When doing any other
192 // form of filtering, the weight should be 1.0 so that it smoothly interpolates between the
193 // texture and transparent.
194 SkScalar decalFilterWeight = sampler.filter() == GrSamplerState::Filter::kNearest ?
195 SK_ScalarHalf : 1.0f;
Brian Salomon246bc3d2018-12-06 15:33:02 -0500196 SkScalar wInv, hInv, h;
197 if (proxy->textureType() == GrTextureType::kRectangle) {
198 wInv = hInv = 1.f;
199 h = tex->height();
Michael Ludwigbe315a22018-12-17 09:50:51 -0500200
201 // Don't do any scaling by texture size for decal filter rate, it's already in pixels
202 if (sendDecalData) {
203 pdman.set3f(fDecalUni, 1.f, 1.f, decalFilterWeight);
204 }
Brian Salomon246bc3d2018-12-06 15:33:02 -0500205 } else {
206 wInv = SK_Scalar1 / tex->width();
207 hInv = SK_Scalar1 / tex->height();
208 h = 1.f;
Michael Ludwigbe315a22018-12-17 09:50:51 -0500209
210 if (sendDecalData) {
211 pdman.set3f(fDecalUni, tex->width(), tex->height(), decalFilterWeight);
212 }
Brian Salomon246bc3d2018-12-06 15:33:02 -0500213 }
Robert Phillipse98234f2017-01-09 14:23:59 -0500214
egdaniel018fb622015-10-28 07:26:40 -0700215 float values[kPrevDomainCount] = {
Robert Phillipse98234f2017-01-09 14:23:59 -0500216 SkScalarToFloat(textureDomain.domain().fLeft * wInv),
217 SkScalarToFloat(textureDomain.domain().fTop * hInv),
218 SkScalarToFloat(textureDomain.domain().fRight * wInv),
219 SkScalarToFloat(textureDomain.domain().fBottom * hInv)
commit-bot@chromium.org907fbd52013-12-09 17:03:02 +0000220 };
Robert Phillipse98234f2017-01-09 14:23:59 -0500221
Brian Salomon246bc3d2018-12-06 15:33:02 -0500222 if (proxy->textureType() == GrTextureType::kRectangle) {
Khushal Sagar2cb13152019-09-11 23:17:26 +0000223 SkASSERT(values[0] >= 0.0f && values[0] <= proxy->width());
Brian Salomon246bc3d2018-12-06 15:33:02 -0500224 SkASSERT(values[1] >= 0.0f && values[1] <= proxy->height());
Khushal Sagar2cb13152019-09-11 23:17:26 +0000225 SkASSERT(values[2] >= 0.0f && values[2] <= proxy->width());
Brian Salomon246bc3d2018-12-06 15:33:02 -0500226 SkASSERT(values[3] >= 0.0f && values[3] <= proxy->height());
227 } else {
228 SkASSERT(values[0] >= 0.0f && values[0] <= 1.0f);
229 SkASSERT(values[1] >= 0.0f && values[1] <= 1.0f);
230 SkASSERT(values[2] >= 0.0f && values[2] <= 1.0f);
231 SkASSERT(values[3] >= 0.0f && values[3] <= 1.0f);
232 }
Robert Phillipse98234f2017-01-09 14:23:59 -0500233
commit-bot@chromium.org907fbd52013-12-09 17:03:02 +0000234 // vertical flip if necessary
Robert Phillipsc686ce32017-07-21 14:12:29 -0400235 if (kBottomLeft_GrSurfaceOrigin == proxy->origin()) {
Brian Salomon246bc3d2018-12-06 15:33:02 -0500236 values[1] = h - values[1];
237 values[3] = h - values[3];
238
commit-bot@chromium.org907fbd52013-12-09 17:03:02 +0000239 // The top and bottom were just flipped, so correct the ordering
240 // of elements so that values = (l, t, r, b).
Ben Wagnerf08d1d02018-06-18 15:11:00 -0400241 using std::swap;
242 swap(values[1], values[3]);
commit-bot@chromium.org907fbd52013-12-09 17:03:02 +0000243 }
egdaniel018fb622015-10-28 07:26:40 -0700244 if (0 != memcmp(values, fPrevDomain, kPrevDomainCount * sizeof(float))) {
kkinnunen7510b222014-07-30 00:04:16 -0700245 pdman.set4fv(fDomainUni, 1, values);
egdaniel018fb622015-10-28 07:26:40 -0700246 memcpy(fPrevDomain, values, kPrevDomainCount * sizeof(float));
commit-bot@chromium.org907fbd52013-12-09 17:03:02 +0000247 }
248 }
249}
250
commit-bot@chromium.org907fbd52013-12-09 17:03:02 +0000251///////////////////////////////////////////////////////////////////////////////
Brian Salomon587e08f2017-01-27 10:59:27 -0500252
Brian Salomonaff329b2017-08-11 09:40:37 -0400253std::unique_ptr<GrFragmentProcessor> GrTextureDomainEffect::Make(
254 sk_sp<GrTextureProxy> proxy,
Brian Salomonaff329b2017-08-11 09:40:37 -0400255 const SkMatrix& matrix,
256 const SkRect& domain,
257 GrTextureDomain::Mode mode,
Brian Salomon2bbdcc42017-09-07 12:36:34 -0400258 GrSamplerState::Filter filterMode) {
Michael Ludwigbe315a22018-12-17 09:50:51 -0500259 return Make(std::move(proxy), matrix, domain, mode, mode,
260 GrSamplerState(GrSamplerState::WrapMode::kClamp, filterMode));
261}
262
263std::unique_ptr<GrFragmentProcessor> GrTextureDomainEffect::Make(
264 sk_sp<GrTextureProxy> proxy,
265 const SkMatrix& matrix,
266 const SkRect& domain,
267 GrTextureDomain::Mode modeX,
268 GrTextureDomain::Mode modeY,
269 const GrSamplerState& sampler) {
270 // If both domain modes happen to be ignore, it would be faster to just drop the domain logic
271 // entirely Technically, we could also use the simple texture effect if the domain modes agree
272 // with the sampler modes and the proxy is the same size as the domain. It's a lot easier for
273 // calling code to detect these cases and handle it themselves.
274 return std::unique_ptr<GrFragmentProcessor>(new GrTextureDomainEffect(
275 std::move(proxy), matrix, domain, modeX, modeY, sampler));
Robert Phillips40fd7c92017-01-30 08:06:27 -0500276}
277
Robert Phillipsfbcef6e2017-06-15 12:07:18 -0400278GrTextureDomainEffect::GrTextureDomainEffect(sk_sp<GrTextureProxy> proxy,
Robert Phillips40fd7c92017-01-30 08:06:27 -0500279 const SkMatrix& matrix,
280 const SkRect& domain,
Michael Ludwigbe315a22018-12-17 09:50:51 -0500281 GrTextureDomain::Mode modeX,
282 GrTextureDomain::Mode modeY,
283 const GrSamplerState& sampler)
Michael Ludwig257a03d2018-12-13 14:07:07 -0500284 : INHERITED(kGrTextureDomainEffect_ClassID,
285 ModulateForSamplerOptFlags(proxy->config(),
286 GrTextureDomain::IsDecalSampled(sampler, modeX, modeY)))
Brian Salomon6cd51b52017-07-26 19:07:15 -0400287 , fCoordTransform(matrix, proxy.get())
Michael Ludwigbe315a22018-12-17 09:50:51 -0500288 , fTextureDomain(proxy.get(), domain, modeX, modeY)
289 , fTextureSampler(std::move(proxy), sampler) {
290 SkASSERT((modeX != GrTextureDomain::kRepeat_Mode && modeY != GrTextureDomain::kRepeat_Mode) ||
291 sampler.filter() == GrSamplerState::Filter::kNearest);
Brian Salomon6cd51b52017-07-26 19:07:15 -0400292 this->addCoordTransform(&fCoordTransform);
Brian Salomonf7dcd762018-07-30 14:48:15 -0400293 this->setTextureSamplerCnt(1);
Robert Phillips40fd7c92017-01-30 08:06:27 -0500294}
295
Brian Salomon3f6f9652017-07-28 07:34:05 -0400296GrTextureDomainEffect::GrTextureDomainEffect(const GrTextureDomainEffect& that)
Ethan Nicholasabff9562017-10-09 10:54:08 -0400297 : INHERITED(kGrTextureDomainEffect_ClassID, that.optimizationFlags())
Brian Salomon3f6f9652017-07-28 07:34:05 -0400298 , fCoordTransform(that.fCoordTransform)
299 , fTextureDomain(that.fTextureDomain)
Brian Osman2240be92017-10-18 13:15:13 -0400300 , fTextureSampler(that.fTextureSampler) {
Brian Salomon3f6f9652017-07-28 07:34:05 -0400301 this->addCoordTransform(&fCoordTransform);
Brian Salomonf7dcd762018-07-30 14:48:15 -0400302 this->setTextureSamplerCnt(1);
Brian Salomon3f6f9652017-07-28 07:34:05 -0400303}
304
Brian Salomon94efbf52016-11-29 13:43:05 -0500305void GrTextureDomainEffect::onGetGLSLProcessorKey(const GrShaderCaps& caps,
egdaniel57d3b032015-11-13 11:57:27 -0800306 GrProcessorKeyBuilder* b) const {
Brian Salomon2ebd0c82016-10-03 17:15:28 -0400307 b->add32(GrTextureDomain::GLDomain::DomainKey(fTextureDomain));
joshualitteb2a6762014-12-04 11:35:33 -0800308}
309
egdaniel57d3b032015-11-13 11:57:27 -0800310GrGLSLFragmentProcessor* GrTextureDomainEffect::onCreateGLSLInstance() const {
Brian Salomon2ebd0c82016-10-03 17:15:28 -0400311 class GLSLProcessor : public GrGLSLFragmentProcessor {
312 public:
313 void emitCode(EmitArgs& args) override {
314 const GrTextureDomainEffect& tde = args.fFp.cast<GrTextureDomainEffect>();
315 const GrTextureDomain& domain = tde.fTextureDomain;
316
317 GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
Ethan Nicholasd4efe682019-08-29 16:10:13 -0400318 SkString coords2D =
319 fragBuilder->ensureCoords2D(args.fTransformedCoords[0].fVaryingPoint);
Brian Osmanc4689632016-12-19 17:04:59 -0500320
Brian Salomon2ebd0c82016-10-03 17:15:28 -0400321 fGLDomain.sampleTexture(fragBuilder,
322 args.fUniformHandler,
Brian Salomon1edc5b92016-11-29 13:43:46 -0500323 args.fShaderCaps,
Brian Salomon2ebd0c82016-10-03 17:15:28 -0400324 domain,
325 args.fOutputColor,
326 coords2D,
327 args.fTexSamplers[0],
Brian Osman2240be92017-10-18 13:15:13 -0400328 args.fInputColor);
Brian Salomon2ebd0c82016-10-03 17:15:28 -0400329 }
330
331 protected:
Brian Salomonab015ef2017-04-04 10:15:51 -0400332 void onSetData(const GrGLSLProgramDataManager& pdman,
333 const GrFragmentProcessor& fp) override {
Brian Salomon2ebd0c82016-10-03 17:15:28 -0400334 const GrTextureDomainEffect& tde = fp.cast<GrTextureDomainEffect>();
335 const GrTextureDomain& domain = tde.fTextureDomain;
Brian Salomon7da2fc72018-12-10 13:40:07 -0500336 GrTextureProxy* proxy = tde.textureSampler(0).proxy();
Robert Phillips9bee2e52017-05-29 12:37:20 -0400337
Michael Ludwigbe315a22018-12-17 09:50:51 -0500338 fGLDomain.setData(pdman, domain, proxy, tde.textureSampler(0).samplerState());
Brian Salomon2ebd0c82016-10-03 17:15:28 -0400339 }
340
341 private:
342 GrTextureDomain::GLDomain fGLDomain;
Brian Salomon2ebd0c82016-10-03 17:15:28 -0400343 };
344
345 return new GLSLProcessor;
commit-bot@chromium.org907fbd52013-12-09 17:03:02 +0000346}
347
bsalomon0e08fc12014-10-15 08:19:04 -0700348bool GrTextureDomainEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
joshualitt49586be2014-09-16 08:21:41 -0700349 const GrTextureDomainEffect& s = sBase.cast<GrTextureDomainEffect>();
Brian Salomona7c4c292016-11-17 12:47:06 -0500350 return this->fTextureDomain == s.fTextureDomain;
commit-bot@chromium.org907fbd52013-12-09 17:03:02 +0000351}
352
commit-bot@chromium.org907fbd52013-12-09 17:03:02 +0000353///////////////////////////////////////////////////////////////////////////////
354
joshualittb0a8a372014-09-23 09:50:21 -0700355GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrTextureDomainEffect);
commit-bot@chromium.org907fbd52013-12-09 17:03:02 +0000356
Hal Canary6f6961e2017-01-31 13:50:44 -0500357#if GR_TEST_UTILS
Brian Salomonaff329b2017-08-11 09:40:37 -0400358std::unique_ptr<GrFragmentProcessor> GrTextureDomainEffect::TestCreate(GrProcessorTestData* d) {
Robert Phillips40fd7c92017-01-30 08:06:27 -0500359 int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx
360 : GrProcessorUnitTest::kAlphaTextureIdx;
361 sk_sp<GrTextureProxy> proxy = d->textureProxy(texIdx);
commit-bot@chromium.org907fbd52013-12-09 17:03:02 +0000362 SkRect domain;
Robert Phillips40fd7c92017-01-30 08:06:27 -0500363 domain.fLeft = d->fRandom->nextRangeScalar(0, proxy->width());
364 domain.fRight = d->fRandom->nextRangeScalar(domain.fLeft, proxy->width());
365 domain.fTop = d->fRandom->nextRangeScalar(0, proxy->height());
366 domain.fBottom = d->fRandom->nextRangeScalar(domain.fTop, proxy->height());
Michael Ludwigbe315a22018-12-17 09:50:51 -0500367 GrTextureDomain::Mode modeX =
368 (GrTextureDomain::Mode) d->fRandom->nextULessThan(GrTextureDomain::kModeCount);
369 GrTextureDomain::Mode modeY =
joshualitt0067ff52015-07-08 14:26:19 -0700370 (GrTextureDomain::Mode) d->fRandom->nextULessThan(GrTextureDomain::kModeCount);
371 const SkMatrix& matrix = GrTest::TestMatrix(d->fRandom);
Michael Ludwigbe315a22018-12-17 09:50:51 -0500372 bool bilerp = modeX != GrTextureDomain::kRepeat_Mode && modeY != GrTextureDomain::kRepeat_Mode ?
373 d->fRandom->nextBool() : false;
Brian Salomon2bbdcc42017-09-07 12:36:34 -0400374 return GrTextureDomainEffect::Make(
375 std::move(proxy),
Brian Salomon2bbdcc42017-09-07 12:36:34 -0400376 matrix,
377 domain,
Michael Ludwigbe315a22018-12-17 09:50:51 -0500378 modeX,
379 modeY,
380 GrSamplerState(GrSamplerState::WrapMode::kClamp, bilerp ?
381 GrSamplerState::Filter::kBilerp : GrSamplerState::Filter::kNearest));
Brian Salomon2ebd0c82016-10-03 17:15:28 -0400382}
Hal Canary6f6961e2017-01-31 13:50:44 -0500383#endif
Brian Salomon2ebd0c82016-10-03 17:15:28 -0400384
385///////////////////////////////////////////////////////////////////////////////
Brian Salomonaff329b2017-08-11 09:40:37 -0400386std::unique_ptr<GrFragmentProcessor> GrDeviceSpaceTextureDecalFragmentProcessor::Make(
387 sk_sp<GrTextureProxy> proxy, const SkIRect& subset, const SkIPoint& deviceSpaceOffset) {
388 return std::unique_ptr<GrFragmentProcessor>(new GrDeviceSpaceTextureDecalFragmentProcessor(
Robert Phillipsfbcef6e2017-06-15 12:07:18 -0400389 std::move(proxy), subset, deviceSpaceOffset));
Robert Phillips40fd7c92017-01-30 08:06:27 -0500390}
391
392GrDeviceSpaceTextureDecalFragmentProcessor::GrDeviceSpaceTextureDecalFragmentProcessor(
Brian Salomon2bbdcc42017-09-07 12:36:34 -0400393 sk_sp<GrTextureProxy> proxy, const SkIRect& subset, const SkIPoint& deviceSpaceOffset)
Ethan Nicholasabff9562017-10-09 10:54:08 -0400394 : INHERITED(kGrDeviceSpaceTextureDecalFragmentProcessor_ClassID,
395 kCompatibleWithCoverageAsAlpha_OptimizationFlag)
Brian Salomon2bbdcc42017-09-07 12:36:34 -0400396 , fTextureSampler(proxy, GrSamplerState::ClampNearest())
Michael Ludwigbe315a22018-12-17 09:50:51 -0500397 , fTextureDomain(proxy.get(),
398 GrTextureDomain::MakeTexelDomain(subset, GrTextureDomain::kDecal_Mode),
399 GrTextureDomain::kDecal_Mode, GrTextureDomain::kDecal_Mode) {
Brian Salomonf7dcd762018-07-30 14:48:15 -0400400 this->setTextureSamplerCnt(1);
Robert Phillips40fd7c92017-01-30 08:06:27 -0500401 fDeviceSpaceOffset.fX = deviceSpaceOffset.fX - subset.fLeft;
402 fDeviceSpaceOffset.fY = deviceSpaceOffset.fY - subset.fTop;
Robert Phillips40fd7c92017-01-30 08:06:27 -0500403}
404
Brian Salomon1a2a7ab2017-07-26 13:11:51 -0400405GrDeviceSpaceTextureDecalFragmentProcessor::GrDeviceSpaceTextureDecalFragmentProcessor(
406 const GrDeviceSpaceTextureDecalFragmentProcessor& that)
Ethan Nicholasabff9562017-10-09 10:54:08 -0400407 : INHERITED(kGrDeviceSpaceTextureDecalFragmentProcessor_ClassID,
408 kCompatibleWithCoverageAsAlpha_OptimizationFlag)
Brian Salomon1a2a7ab2017-07-26 13:11:51 -0400409 , fTextureSampler(that.fTextureSampler)
410 , fTextureDomain(that.fTextureDomain)
411 , fDeviceSpaceOffset(that.fDeviceSpaceOffset) {
Brian Salomonf7dcd762018-07-30 14:48:15 -0400412 this->setTextureSamplerCnt(1);
Brian Salomon1a2a7ab2017-07-26 13:11:51 -0400413}
414
Brian Salomonaff329b2017-08-11 09:40:37 -0400415std::unique_ptr<GrFragmentProcessor> GrDeviceSpaceTextureDecalFragmentProcessor::clone() const {
416 return std::unique_ptr<GrFragmentProcessor>(
417 new GrDeviceSpaceTextureDecalFragmentProcessor(*this));
Brian Salomon1a2a7ab2017-07-26 13:11:51 -0400418}
419
Brian Salomon2ebd0c82016-10-03 17:15:28 -0400420GrGLSLFragmentProcessor* GrDeviceSpaceTextureDecalFragmentProcessor::onCreateGLSLInstance() const {
421 class GLSLProcessor : public GrGLSLFragmentProcessor {
422 public:
423 void emitCode(EmitArgs& args) override {
424 const GrDeviceSpaceTextureDecalFragmentProcessor& dstdfp =
425 args.fFp.cast<GrDeviceSpaceTextureDecalFragmentProcessor>();
426 const char* scaleAndTranslateName;
427 fScaleAndTranslateUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag,
Ethan Nicholasf7b88202017-09-18 14:10:39 -0400428 kHalf4_GrSLType,
Brian Salomon2ebd0c82016-10-03 17:15:28 -0400429 "scaleAndTranslate",
430 &scaleAndTranslateName);
Ethan Nicholase1f55022019-02-05 17:17:40 -0500431 args.fFragBuilder->codeAppendf("half2 coords = half2(sk_FragCoord.xy * %s.xy + %s.zw);",
Brian Salomon2ebd0c82016-10-03 17:15:28 -0400432 scaleAndTranslateName, scaleAndTranslateName);
433 fGLDomain.sampleTexture(args.fFragBuilder,
434 args.fUniformHandler,
Brian Salomon1edc5b92016-11-29 13:43:46 -0500435 args.fShaderCaps,
Brian Salomon2ebd0c82016-10-03 17:15:28 -0400436 dstdfp.fTextureDomain,
437 args.fOutputColor,
438 SkString("coords"),
439 args.fTexSamplers[0],
440 args.fInputColor);
441 }
442
443 protected:
Brian Salomonab015ef2017-04-04 10:15:51 -0400444 void onSetData(const GrGLSLProgramDataManager& pdman,
445 const GrFragmentProcessor& fp) override {
Brian Salomon2ebd0c82016-10-03 17:15:28 -0400446 const GrDeviceSpaceTextureDecalFragmentProcessor& dstdfp =
447 fp.cast<GrDeviceSpaceTextureDecalFragmentProcessor>();
Brian Salomon7da2fc72018-12-10 13:40:07 -0500448 GrTextureProxy* proxy = dstdfp.textureSampler(0).proxy();
Brian Salomonfd98c2c2018-07-31 17:25:29 -0400449 GrTexture* texture = proxy->peekTexture();
Robert Phillips9bee2e52017-05-29 12:37:20 -0400450
Michael Ludwigbe315a22018-12-17 09:50:51 -0500451 fGLDomain.setData(pdman, dstdfp.fTextureDomain, proxy,
452 dstdfp.textureSampler(0).samplerState());
Brian Salomon0bbecb22016-11-17 11:38:22 -0500453 float iw = 1.f / texture->width();
454 float ih = 1.f / texture->height();
Brian Salomon2ebd0c82016-10-03 17:15:28 -0400455 float scaleAndTransData[4] = {
456 iw, ih,
457 -dstdfp.fDeviceSpaceOffset.fX * iw, -dstdfp.fDeviceSpaceOffset.fY * ih
458 };
Robert Phillipsc686ce32017-07-21 14:12:29 -0400459 if (proxy->origin() == kBottomLeft_GrSurfaceOrigin) {
Brian Salomon2ebd0c82016-10-03 17:15:28 -0400460 scaleAndTransData[1] = -scaleAndTransData[1];
461 scaleAndTransData[3] = 1 - scaleAndTransData[3];
462 }
463 pdman.set4fv(fScaleAndTranslateUni, 1, scaleAndTransData);
464 }
465
466 private:
467 GrTextureDomain::GLDomain fGLDomain;
468 UniformHandle fScaleAndTranslateUni;
469 };
470
471 return new GLSLProcessor;
472}
473
474bool GrDeviceSpaceTextureDecalFragmentProcessor::onIsEqual(const GrFragmentProcessor& fp) const {
475 const GrDeviceSpaceTextureDecalFragmentProcessor& dstdfp =
476 fp.cast<GrDeviceSpaceTextureDecalFragmentProcessor>();
Brian Salomon1a2a7ab2017-07-26 13:11:51 -0400477 return dstdfp.fTextureSampler.proxy()->underlyingUniqueID() ==
478 fTextureSampler.proxy()->underlyingUniqueID() &&
Brian Salomon2ebd0c82016-10-03 17:15:28 -0400479 dstdfp.fDeviceSpaceOffset == fDeviceSpaceOffset &&
480 dstdfp.fTextureDomain == fTextureDomain;
481}
482
Brian Salomon2ebd0c82016-10-03 17:15:28 -0400483///////////////////////////////////////////////////////////////////////////////
484
485GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrDeviceSpaceTextureDecalFragmentProcessor);
486
Hal Canary6f6961e2017-01-31 13:50:44 -0500487#if GR_TEST_UTILS
Brian Salomonaff329b2017-08-11 09:40:37 -0400488std::unique_ptr<GrFragmentProcessor> GrDeviceSpaceTextureDecalFragmentProcessor::TestCreate(
Brian Salomon2ebd0c82016-10-03 17:15:28 -0400489 GrProcessorTestData* d) {
490 int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx
491 : GrProcessorUnitTest::kAlphaTextureIdx;
Robert Phillips40fd7c92017-01-30 08:06:27 -0500492 sk_sp<GrTextureProxy> proxy = d->textureProxy(texIdx);
Brian Salomon2ebd0c82016-10-03 17:15:28 -0400493 SkIRect subset;
Robert Phillips40fd7c92017-01-30 08:06:27 -0500494 subset.fLeft = d->fRandom->nextULessThan(proxy->width() - 1);
495 subset.fRight = d->fRandom->nextRangeU(subset.fLeft, proxy->width());
496 subset.fTop = d->fRandom->nextULessThan(proxy->height() - 1);
497 subset.fBottom = d->fRandom->nextRangeU(subset.fTop, proxy->height());
Brian Salomon2ebd0c82016-10-03 17:15:28 -0400498 SkIPoint pt;
499 pt.fX = d->fRandom->nextULessThan(2048);
500 pt.fY = d->fRandom->nextULessThan(2048);
Robert Phillipsfbcef6e2017-06-15 12:07:18 -0400501 return GrDeviceSpaceTextureDecalFragmentProcessor::Make(std::move(proxy), subset, pt);
commit-bot@chromium.org907fbd52013-12-09 17:03:02 +0000502}
Hal Canary6f6961e2017-01-31 13:50:44 -0500503#endif