blob: 5ad407572128ccc9f71f5d1ad5921c75fabb93fc [file] [log] [blame]
rileya@google.com589708b2012-07-26 20:04:23 +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
fmalitabc590c02016-02-22 09:12:33 -08008#include "Sk4fLinearGradient.h"
Matt Sarett6cc6ae752017-04-18 18:29:12 -04009#include "SkColorSpaceXformer.h"
rileya@google.com589708b2012-07-26 20:04:23 +000010#include "SkLinearGradient.h"
bungeman06ca8ec2016-06-09 08:01:03 -070011#include "SkRefCnt.h"
rileya@google.com589708b2012-07-26 20:04:23 +000012
reedf3182eb2015-11-17 08:12:19 -080013static const float kInv255Float = 1.0f / 255;
14
rileya@google.com589708b2012-07-26 20:04:23 +000015static inline int repeat_8bits(int x) {
16 return x & 0xFF;
17}
18
rileya@google.com589708b2012-07-26 20:04:23 +000019static inline int mirror_8bits(int x) {
rileya@google.com589708b2012-07-26 20:04:23 +000020 if (x & 256) {
21 x = ~x;
22 }
23 return x & 255;
rileya@google.com589708b2012-07-26 20:04:23 +000024}
25
mtkleincc695fe2014-12-10 10:29:19 -080026static SkMatrix pts_to_unit_matrix(const SkPoint pts[2]) {
rileya@google.com589708b2012-07-26 20:04:23 +000027 SkVector vec = pts[1] - pts[0];
28 SkScalar mag = vec.length();
29 SkScalar inv = mag ? SkScalarInvert(mag) : 0;
30
31 vec.scale(inv);
mtkleincc695fe2014-12-10 10:29:19 -080032 SkMatrix matrix;
33 matrix.setSinCos(-vec.fY, vec.fX, pts[0].fX, pts[0].fY);
34 matrix.postTranslate(-pts[0].fX, -pts[0].fY);
35 matrix.postScale(inv, inv);
36 return matrix;
rileya@google.com589708b2012-07-26 20:04:23 +000037}
38
39///////////////////////////////////////////////////////////////////////////////
40
reedaddf2ed2014-08-11 08:28:24 -070041SkLinearGradient::SkLinearGradient(const SkPoint pts[2], const Descriptor& desc)
mtkleincc695fe2014-12-10 10:29:19 -080042 : SkGradientShaderBase(desc, pts_to_unit_matrix(pts))
rileya@google.com589708b2012-07-26 20:04:23 +000043 , fStart(pts[0])
mtkleincc695fe2014-12-10 10:29:19 -080044 , fEnd(pts[1]) {
rileya@google.com589708b2012-07-26 20:04:23 +000045}
46
reed60c9b582016-04-03 09:11:13 -070047sk_sp<SkFlattenable> SkLinearGradient::CreateProc(SkReadBuffer& buffer) {
reed9fa60da2014-08-21 07:59:51 -070048 DescriptorScope desc;
49 if (!desc.unflatten(buffer)) {
halcanary96fcdcc2015-08-27 07:41:13 -070050 return nullptr;
reed9fa60da2014-08-21 07:59:51 -070051 }
52 SkPoint pts[2];
53 pts[0] = buffer.readPoint();
54 pts[1] = buffer.readPoint();
brianosmane25d71c2016-09-28 11:27:28 -070055 return SkGradientShader::MakeLinear(pts, desc.fColors, std::move(desc.fColorSpace), desc.fPos,
56 desc.fCount, desc.fTileMode, desc.fGradFlags,
57 desc.fLocalMatrix);
reed9fa60da2014-08-21 07:59:51 -070058}
rileya@google.com589708b2012-07-26 20:04:23 +000059
commit-bot@chromium.org8b0e8ac2014-01-30 18:58:24 +000060void SkLinearGradient::flatten(SkWriteBuffer& buffer) const {
rileya@google.com589708b2012-07-26 20:04:23 +000061 this->INHERITED::flatten(buffer);
62 buffer.writePoint(fStart);
63 buffer.writePoint(fEnd);
64}
65
Florin Malita4aed1382017-05-25 10:38:07 -040066SkShaderBase::Context* SkLinearGradient::onMakeContext(
Herb Derby83e939b2017-02-07 14:25:11 -050067 const ContextRec& rec, SkArenaAlloc* alloc) const
68{
Florin Malitaae7bb042017-06-19 15:27:47 -040069 return rec.fPreferredDstType == ContextRec::kPM4f_DstType
Herb Derby83e939b2017-02-07 14:25:11 -050070 ? CheckedMakeContext<LinearGradient4fContext>(alloc, *this, rec)
71 : CheckedMakeContext< LinearGradientContext>(alloc, *this, rec);
commit-bot@chromium.org87fcd952014-04-23 19:10:51 +000072}
73
Florin Malita47e55a52017-06-06 12:26:54 -040074SkShaderBase::Context* SkLinearGradient::onMakeBurstPipelineContext(
75 const ContextRec& rec, SkArenaAlloc* alloc) const {
76
Florin Malitaa924dd32017-06-07 14:23:55 -040077 // Raster pipeline has a 2-stop specialization faster than our burst.
78 return fColorCount > 2 ? CheckedMakeContext<LinearGradient4fContext>(alloc, *this, rec)
79 : nullptr;
Florin Malita47e55a52017-06-06 12:26:54 -040080}
81
Florin Malita5b8e2b82017-07-12 11:31:22 -040082bool SkLinearGradient::adjustMatrixAndAppendStages(SkArenaAlloc*,
Mike Kleina3771842017-05-04 19:38:48 -040083 SkMatrix* matrix,
Florin Malita5b8e2b82017-07-12 11:31:22 -040084 SkRasterPipeline*,
Florin Malita2e409002017-06-28 14:46:54 -040085 SkRasterPipeline*) const {
Florin Malita5127fcb2017-07-25 13:53:04 -040086#ifdef SK_SUPPORT_LEGACY_GRADIENT_MATRIX_MATH
Mike Kleina3771842017-05-04 19:38:48 -040087 *matrix = SkMatrix::Concat(fPtsToUnit, *matrix);
Florin Malita5127fcb2017-07-25 13:53:04 -040088#else
89 matrix->postConcat(fPtsToUnit);
90#endif
Florin Malitac86e4702017-01-20 08:41:34 -050091 return true;
92}
93
Matt Sarett6cc6ae752017-04-18 18:29:12 -040094sk_sp<SkShader> SkLinearGradient::onMakeColorSpace(SkColorSpaceXformer* xformer) const {
95 SkPoint pts[2] = { fStart, fEnd };
96 SkSTArray<8, SkColor> xformedColors(fColorCount);
97 xformer->apply(xformedColors.begin(), fOrigColors, fColorCount);
98 return SkGradientShader::MakeLinear(pts, xformedColors.begin(), fOrigPos, fColorCount,
99 fTileMode, fGradFlags, &this->getLocalMatrix());
100}
101
reedf3182eb2015-11-17 08:12:19 -0800102// This swizzles SkColor into the same component order as SkPMColor, but does not actually
103// "pre" multiply the color components.
104//
105// This allows us to map directly to Sk4f, and eventually scale down to bytes to output a
106// SkPMColor from the floats, without having to swizzle each time.
107//
108static uint32_t SkSwizzle_Color_to_PMColor(SkColor c) {
109 return SkPackARGB32NoCheck(SkColorGetA(c), SkColorGetR(c), SkColorGetG(c), SkColorGetB(c));
110}
111
commit-bot@chromium.org87fcd952014-04-23 19:10:51 +0000112SkLinearGradient::LinearGradientContext::LinearGradientContext(
reedf3182eb2015-11-17 08:12:19 -0800113 const SkLinearGradient& shader, const ContextRec& ctx)
114 : INHERITED(shader, ctx)
commit-bot@chromium.org87fcd952014-04-23 19:10:51 +0000115{
reedf3182eb2015-11-17 08:12:19 -0800116 // setup for Sk4f
fmalita748d6202016-05-11 11:39:58 -0700117 const int count = shader.fColorCount;
118 SkASSERT(count > 1);
119
reedf3182eb2015-11-17 08:12:19 -0800120 fRecs.setCount(count);
121 Rec* rec = fRecs.begin();
122 if (shader.fOrigPos) {
123 rec[0].fPos = 0;
124 SkDEBUGCODE(rec[0].fPosScale = SK_FloatNaN;) // should never get used
125 for (int i = 1; i < count; ++i) {
126 rec[i].fPos = SkTPin(shader.fOrigPos[i], rec[i - 1].fPos, 1.0f);
lsalzmanf2b86622016-01-22 14:03:02 -0800127 float diff = rec[i].fPos - rec[i - 1].fPos;
128 if (diff > 0) {
129 rec[i].fPosScale = 1.0f / diff;
130 } else {
131 rec[i].fPosScale = 0;
132 }
reedf3182eb2015-11-17 08:12:19 -0800133 }
reedf3182eb2015-11-17 08:12:19 -0800134 } else {
135 // no pos specified, so we compute evenly spaced values
136 const float scale = float(count - 1);
fmalita748d6202016-05-11 11:39:58 -0700137 const float invScale = 1.0f / scale;
reedf3182eb2015-11-17 08:12:19 -0800138 for (int i = 0; i < count; ++i) {
139 rec[i].fPos = i * invScale;
140 rec[i].fPosScale = scale;
141 }
142 }
fmalita748d6202016-05-11 11:39:58 -0700143 rec[count - 1].fPos = 1; // overwrite the last value just to be sure we end at 1.0
reedf3182eb2015-11-17 08:12:19 -0800144
145 fApplyAlphaAfterInterp = true;
146 if ((shader.getGradFlags() & SkGradientShader::kInterpolateColorsInPremul_Flag) ||
147 shader.colorsAreOpaque())
148 {
149 fApplyAlphaAfterInterp = false;
150 }
151
152 if (fApplyAlphaAfterInterp) {
153 // Our fColor values are in PMColor order, but are still unpremultiplied, allowing us to
154 // interpolate in unpremultiplied space first, and then scale by alpha right before we
155 // convert to SkPMColor bytes.
156 const float paintAlpha = ctx.fPaint->getAlpha() * kInv255Float;
157 const Sk4f scale(1, 1, 1, paintAlpha);
158 for (int i = 0; i < count; ++i) {
159 uint32_t c = SkSwizzle_Color_to_PMColor(shader.fOrigColors[i]);
mtklein507ef6d2016-01-31 08:02:47 -0800160 rec[i].fColor = SkNx_cast<float>(Sk4b::Load(&c)) * scale;
reedf3182eb2015-11-17 08:12:19 -0800161 if (i > 0) {
162 SkASSERT(rec[i - 1].fPos <= rec[i].fPos);
163 }
164 }
165 } else {
166 // Our fColor values are premultiplied, so converting to SkPMColor is just a matter
167 // of converting the floats down to bytes.
168 unsigned alphaScale = ctx.fPaint->getAlpha() + (ctx.fPaint->getAlpha() >> 7);
169 for (int i = 0; i < count; ++i) {
170 SkPMColor pmc = SkPreMultiplyColor(shader.fOrigColors[i]);
171 pmc = SkAlphaMulQ(pmc, alphaScale);
mtklein507ef6d2016-01-31 08:02:47 -0800172 rec[i].fColor = SkNx_cast<float>(Sk4b::Load(&pmc));
reedf3182eb2015-11-17 08:12:19 -0800173 if (i > 0) {
174 SkASSERT(rec[i - 1].fPos <= rec[i].fPos);
175 }
176 }
177 }
rileya@google.com589708b2012-07-26 20:04:23 +0000178}
179
180#define NO_CHECK_ITER \
181 do { \
reedcaf7e932014-12-18 12:43:08 -0800182 unsigned fi = SkGradFixedToFixed(fx) >> SkGradientShaderBase::kCache32Shift; \
rileya@google.com589708b2012-07-26 20:04:23 +0000183 SkASSERT(fi <= 0xFF); \
184 fx += dx; \
185 *dstC++ = cache[toggle + fi]; \
reed@google.com55853db2013-02-01 19:34:59 +0000186 toggle = next_dither_toggle(toggle); \
rileya@google.com589708b2012-07-26 20:04:23 +0000187 } while (0)
188
189namespace {
190
reedcaf7e932014-12-18 12:43:08 -0800191typedef void (*LinearShadeProc)(TileProc proc, SkGradFixed dx, SkGradFixed fx,
rileya@google.com589708b2012-07-26 20:04:23 +0000192 SkPMColor* dstC, const SkPMColor* cache,
193 int toggle, int count);
194
rileya@google.com589708b2012-07-26 20:04:23 +0000195// Linear interpolation (lerp) is unnecessary if there are no sharp
196// discontinuities in the gradient - which must be true if there are
197// only 2 colors - but it's cheap.
reedcaf7e932014-12-18 12:43:08 -0800198void shadeSpan_linear_vertical_lerp(TileProc proc, SkGradFixed dx, SkGradFixed fx,
rileya@google.com589708b2012-07-26 20:04:23 +0000199 SkPMColor* SK_RESTRICT dstC,
200 const SkPMColor* SK_RESTRICT cache,
201 int toggle, int count) {
202 // We're a vertical gradient, so no change in a span.
203 // If colors change sharply across the gradient, dithering is
204 // insufficient (it subsamples the color space) and we need to lerp.
reedcaf7e932014-12-18 12:43:08 -0800205 unsigned fullIndex = proc(SkGradFixedToFixed(fx));
reed@google.com3c2102c2013-02-01 12:59:40 +0000206 unsigned fi = fullIndex >> SkGradientShaderBase::kCache32Shift;
207 unsigned remainder = fullIndex & ((1 << SkGradientShaderBase::kCache32Shift) - 1);
skia.committer@gmail.com9dde0182013-02-04 12:57:42 +0000208
reed@google.com3c2102c2013-02-01 12:59:40 +0000209 int index0 = fi + toggle;
210 int index1 = index0;
211 if (fi < SkGradientShaderBase::kCache32Count - 1) {
212 index1 += 1;
213 }
214 SkPMColor lerp = SkFastFourByteInterp(cache[index1], cache[index0], remainder);
215 index0 ^= SkGradientShaderBase::kDitherStride32;
216 index1 ^= SkGradientShaderBase::kDitherStride32;
217 SkPMColor dlerp = SkFastFourByteInterp(cache[index1], cache[index0], remainder);
rileya@google.com589708b2012-07-26 20:04:23 +0000218 sk_memset32_dither(dstC, lerp, dlerp, count);
219}
220
reedcaf7e932014-12-18 12:43:08 -0800221void shadeSpan_linear_clamp(TileProc proc, SkGradFixed dx, SkGradFixed fx,
rileya@google.com589708b2012-07-26 20:04:23 +0000222 SkPMColor* SK_RESTRICT dstC,
223 const SkPMColor* SK_RESTRICT cache,
224 int toggle, int count) {
225 SkClampRange range;
reed@google.com3c2102c2013-02-01 12:59:40 +0000226 range.init(fx, dx, count, 0, SkGradientShaderBase::kCache32Count - 1);
reed9d91eb32015-01-28 11:44:48 -0800227 range.validate(count);
rileya@google.com589708b2012-07-26 20:04:23 +0000228
229 if ((count = range.fCount0) > 0) {
230 sk_memset32_dither(dstC,
231 cache[toggle + range.fV0],
reed@google.com55853db2013-02-01 19:34:59 +0000232 cache[next_dither_toggle(toggle) + range.fV0],
rileya@google.com589708b2012-07-26 20:04:23 +0000233 count);
234 dstC += count;
235 }
236 if ((count = range.fCount1) > 0) {
237 int unroll = count >> 3;
238 fx = range.fFx1;
239 for (int i = 0; i < unroll; i++) {
240 NO_CHECK_ITER; NO_CHECK_ITER;
241 NO_CHECK_ITER; NO_CHECK_ITER;
242 NO_CHECK_ITER; NO_CHECK_ITER;
243 NO_CHECK_ITER; NO_CHECK_ITER;
244 }
245 if ((count &= 7) > 0) {
246 do {
247 NO_CHECK_ITER;
248 } while (--count != 0);
249 }
250 }
251 if ((count = range.fCount2) > 0) {
252 sk_memset32_dither(dstC,
253 cache[toggle + range.fV1],
reed@google.com55853db2013-02-01 19:34:59 +0000254 cache[next_dither_toggle(toggle) + range.fV1],
rileya@google.com589708b2012-07-26 20:04:23 +0000255 count);
256 }
257}
258
reedcaf7e932014-12-18 12:43:08 -0800259void shadeSpan_linear_mirror(TileProc proc, SkGradFixed dx, SkGradFixed fx,
rileya@google.com589708b2012-07-26 20:04:23 +0000260 SkPMColor* SK_RESTRICT dstC,
261 const SkPMColor* SK_RESTRICT cache,
262 int toggle, int count) {
263 do {
reedcaf7e932014-12-18 12:43:08 -0800264 unsigned fi = mirror_8bits(SkGradFixedToFixed(fx) >> 8);
rileya@google.com589708b2012-07-26 20:04:23 +0000265 SkASSERT(fi <= 0xFF);
266 fx += dx;
267 *dstC++ = cache[toggle + fi];
reed@google.com55853db2013-02-01 19:34:59 +0000268 toggle = next_dither_toggle(toggle);
rileya@google.com589708b2012-07-26 20:04:23 +0000269 } while (--count != 0);
270}
271
reedcaf7e932014-12-18 12:43:08 -0800272void shadeSpan_linear_repeat(TileProc proc, SkGradFixed dx, SkGradFixed fx,
rileya@google.com589708b2012-07-26 20:04:23 +0000273 SkPMColor* SK_RESTRICT dstC,
274 const SkPMColor* SK_RESTRICT cache,
275 int toggle, int count) {
276 do {
reedcaf7e932014-12-18 12:43:08 -0800277 unsigned fi = repeat_8bits(SkGradFixedToFixed(fx) >> 8);
rileya@google.com589708b2012-07-26 20:04:23 +0000278 SkASSERT(fi <= 0xFF);
279 fx += dx;
280 *dstC++ = cache[toggle + fi];
reed@google.com55853db2013-02-01 19:34:59 +0000281 toggle = next_dither_toggle(toggle);
rileya@google.com589708b2012-07-26 20:04:23 +0000282 } while (--count != 0);
283}
284
285}
286
commit-bot@chromium.org87fcd952014-04-23 19:10:51 +0000287void SkLinearGradient::LinearGradientContext::shadeSpan(int x, int y, SkPMColor* SK_RESTRICT dstC,
288 int count) {
rileya@google.com589708b2012-07-26 20:04:23 +0000289 SkASSERT(count > 0);
commit-bot@chromium.org87fcd952014-04-23 19:10:51 +0000290 const SkLinearGradient& linearGradient = static_cast<const SkLinearGradient&>(fShader);
291
Florin Malita4d41b8f2017-07-12 14:35:46 -0400292 if (SkShader::kClamp_TileMode == linearGradient.fTileMode) {
reedf3182eb2015-11-17 08:12:19 -0800293 this->shade4_clamp(x, y, dstC, count);
294 return;
295 }
reedf3182eb2015-11-17 08:12:19 -0800296
rileya@google.com589708b2012-07-26 20:04:23 +0000297 SkPoint srcPt;
298 SkMatrix::MapXYProc dstProc = fDstToIndexProc;
commit-bot@chromium.org87fcd952014-04-23 19:10:51 +0000299 TileProc proc = linearGradient.fTileProc;
300 const SkPMColor* SK_RESTRICT cache = fCache->getCache32();
reed@google.com55853db2013-02-01 19:34:59 +0000301 int toggle = init_dither_toggle(x, y);
rileya@google.com589708b2012-07-26 20:04:23 +0000302
Florin Malita4d41b8f2017-07-12 14:35:46 -0400303 dstProc(fDstToIndex, SkIntToScalar(x) + SK_ScalarHalf,
304 SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
305 SkGradFixed fx = SkScalarPinToGradFixed(srcPt.fX),
306 dx = SkScalarPinToGradFixed(fDstToIndex.getScaleX());
rileya@google.com589708b2012-07-26 20:04:23 +0000307
Florin Malita4d41b8f2017-07-12 14:35:46 -0400308 LinearShadeProc shadeProc = shadeSpan_linear_repeat;
309 if (0 == dx) {
310 shadeProc = shadeSpan_linear_vertical_lerp;
311 } else if (SkShader::kClamp_TileMode == linearGradient.fTileMode) {
312 shadeProc = shadeSpan_linear_clamp;
313 } else if (SkShader::kMirror_TileMode == linearGradient.fTileMode) {
314 shadeProc = shadeSpan_linear_mirror;
rileya@google.com589708b2012-07-26 20:04:23 +0000315 } else {
Florin Malita4d41b8f2017-07-12 14:35:46 -0400316 SkASSERT(SkShader::kRepeat_TileMode == linearGradient.fTileMode);
rileya@google.com589708b2012-07-26 20:04:23 +0000317 }
Florin Malita4d41b8f2017-07-12 14:35:46 -0400318 (*shadeProc)(proc, dx, fx, dstC, cache, toggle, count);
rileya@google.com589708b2012-07-26 20:04:23 +0000319}
320
rileya@google.com589708b2012-07-26 20:04:23 +0000321SkShader::GradientType SkLinearGradient::asAGradient(GradientInfo* info) const {
322 if (info) {
323 commonAsAGradient(info);
324 info->fPoint[0] = fStart;
325 info->fPoint[1] = fEnd;
326 }
327 return kLinear_GradientType;
328}
329
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +0000330#if SK_SUPPORT_GPU
331
brianosmanb9c51372016-09-15 11:09:45 -0700332#include "GrColorSpaceXform.h"
Brian Salomon94efbf52016-11-29 13:43:05 -0500333#include "GrShaderCaps.h"
egdaniel7ea439b2015-12-03 09:20:44 -0800334#include "glsl/GrGLSLFragmentShaderBuilder.h"
dandov9de5b512014-06-10 14:38:28 -0700335#include "SkGr.h"
bsalomon@google.com2eaaefd2012-10-29 19:51:22 +0000336
rileya@google.comd7cc6512012-07-27 14:00:39 +0000337/////////////////////////////////////////////////////////////////////
338
rileya@google.com98e8b6d2012-07-31 20:38:06 +0000339class GrLinearGradient : public GrGradientEffect {
340public:
fmenozzi55d318d2016-08-09 08:05:57 -0700341 class GLSLLinearProcessor;
rileya@google.com98e8b6d2012-07-31 20:38:06 +0000342
brianosman9557c272016-09-15 06:59:15 -0700343 static sk_sp<GrFragmentProcessor> Make(const CreateArgs& args) {
Brian Salomon6af27012017-06-09 08:21:42 -0400344 auto processor = sk_sp<GrLinearGradient>(new GrLinearGradient(args));
345 return processor->isValid() ? std::move(processor) : nullptr;
bsalomon@google.com0ac6af42013-01-16 15:16:18 +0000346 }
347
mtklein36352bf2015-03-25 18:17:31 -0700348 const char* name() const override { return "Linear Gradient"; }
joshualitteb2a6762014-12-04 11:35:33 -0800349
Brian Salomonf8480b92017-07-27 15:45:59 -0400350 sk_sp<GrFragmentProcessor> clone() const override {
351 return sk_sp<GrFragmentProcessor>(new GrLinearGradient(*this));
352 }
353
rileya@google.com98e8b6d2012-07-31 20:38:06 +0000354private:
Brian Salomonf8480b92017-07-27 15:45:59 -0400355 explicit GrLinearGradient(const CreateArgs& args)
356 : INHERITED(args, args.fShader->colorsAreOpaque()) {
357 this->initClassID<GrLinearGradient>();
358 }
359
360 explicit GrLinearGradient(const GrLinearGradient& that) : INHERITED(that) {
joshualitteb2a6762014-12-04 11:35:33 -0800361 this->initClassID<GrLinearGradient>();
362 }
wangyix4b3050b2015-08-04 07:59:37 -0700363
fmenozzi55d318d2016-08-09 08:05:57 -0700364 GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
wangyixb1daa862015-08-18 11:29:31 -0700365
Brian Salomon94efbf52016-11-29 13:43:05 -0500366 virtual void onGetGLSLProcessorKey(const GrShaderCaps& caps,
fmenozzi55d318d2016-08-09 08:05:57 -0700367 GrProcessorKeyBuilder* b) const override;
wangyix4b3050b2015-08-04 07:59:37 -0700368
Brian Salomon0c26a9d2017-07-06 10:09:38 -0400369 GR_DECLARE_FRAGMENT_PROCESSOR_TEST
rileya@google.com98e8b6d2012-07-31 20:38:06 +0000370
371 typedef GrGradientEffect INHERITED;
372};
373
374/////////////////////////////////////////////////////////////////////
375
fmenozzi55d318d2016-08-09 08:05:57 -0700376class GrLinearGradient::GLSLLinearProcessor : public GrGradientEffect::GLSLProcessor {
377public:
378 GLSLLinearProcessor(const GrProcessor&) {}
379
fmenozzi55d318d2016-08-09 08:05:57 -0700380 virtual void emitCode(EmitArgs&) override;
381
Brian Salomon94efbf52016-11-29 13:43:05 -0500382 static void GenKey(const GrProcessor& processor, const GrShaderCaps&, GrProcessorKeyBuilder* b) {
fmenozzi55d318d2016-08-09 08:05:57 -0700383 b->add32(GenBaseGradientKey(processor));
384 }
385
386private:
387 typedef GrGradientEffect::GLSLProcessor INHERITED;
388};
389
390/////////////////////////////////////////////////////////////////////
391
392GrGLSLFragmentProcessor* GrLinearGradient::onCreateGLSLInstance() const {
393 return new GrLinearGradient::GLSLLinearProcessor(*this);
394}
395
Brian Salomon94efbf52016-11-29 13:43:05 -0500396void GrLinearGradient::onGetGLSLProcessorKey(const GrShaderCaps& caps,
fmenozzi55d318d2016-08-09 08:05:57 -0700397 GrProcessorKeyBuilder* b) const {
398 GrLinearGradient::GLSLLinearProcessor::GenKey(*this, caps, b);
399}
400
401/////////////////////////////////////////////////////////////////////
402
joshualittb0a8a372014-09-23 09:50:21 -0700403GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrLinearGradient);
bsalomon@google.comd4726202012-08-03 14:34:46 +0000404
Hal Canary6f6961e2017-01-31 13:50:44 -0500405#if GR_TEST_UTILS
bungeman06ca8ec2016-06-09 08:01:03 -0700406sk_sp<GrFragmentProcessor> GrLinearGradient::TestCreate(GrProcessorTestData* d) {
joshualitt0067ff52015-07-08 14:26:19 -0700407 SkPoint points[] = {{d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()},
408 {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()}};
bsalomon@google.comd4726202012-08-03 14:34:46 +0000409
Brian Osman3f748602016-10-03 18:29:03 -0400410 RandomGradientParams params(d->fRandom);
Brian Osmana2196532016-10-17 12:48:13 -0400411 auto shader = params.fUseColors4f ?
412 SkGradientShader::MakeLinear(points, params.fColors4f, params.fColorSpace, params.fStops,
413 params.fColorCount, params.fTileMode) :
414 SkGradientShader::MakeLinear(points, params.fColors, params.fStops,
415 params.fColorCount, params.fTileMode);
Brian Osman9f532a32016-10-19 11:12:09 -0400416 GrTest::TestAsFPArgs asFPArgs(d);
Florin Malita4aed1382017-05-25 10:38:07 -0400417 sk_sp<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
bsalomonc21b09e2015-08-28 18:46:56 -0700418 GrAlwaysAssert(fp);
joshualittb0a8a372014-09-23 09:50:21 -0700419 return fp;
bsalomon@google.comd4726202012-08-03 14:34:46 +0000420}
Hal Canary6f6961e2017-01-31 13:50:44 -0500421#endif
bsalomon@google.comd4726202012-08-03 14:34:46 +0000422
423/////////////////////////////////////////////////////////////////////
424
fmenozzi55d318d2016-08-09 08:05:57 -0700425void GrLinearGradient::GLSLLinearProcessor::emitCode(EmitArgs& args) {
wangyix7c157a92015-07-22 15:08:53 -0700426 const GrLinearGradient& ge = args.fFp.cast<GrLinearGradient>();
egdaniel7ea439b2015-12-03 09:20:44 -0800427 this->emitUniforms(args.fUniformHandler, ge);
bsalomon1a1aa932016-09-12 09:30:36 -0700428 SkString t = args.fFragBuilder->ensureCoords2D(args.fTransformedCoords[0]);
bsalomon@google.comd8b5fac2012-11-01 17:02:46 +0000429 t.append(".x");
egdaniel7ea439b2015-12-03 09:20:44 -0800430 this->emitColor(args.fFragBuilder,
431 args.fUniformHandler,
Brian Salomon1edc5b92016-11-29 13:43:46 -0500432 args.fShaderCaps,
fmenozzi55d318d2016-08-09 08:05:57 -0700433 ge,
434 t.c_str(),
egdaniel4ca2e602015-11-18 08:01:26 -0800435 args.fOutputColor,
436 args.fInputColor,
cdalton3f6f76f2016-04-11 12:18:09 -0700437 args.fTexSamplers);
rileya@google.comd7cc6512012-07-27 14:00:39 +0000438}
439
440/////////////////////////////////////////////////////////////////////
441
brianosman839345d2016-07-22 11:04:53 -0700442sk_sp<GrFragmentProcessor> SkLinearGradient::asFragmentProcessor(const AsFPArgs& args) const {
443 SkASSERT(args.fContext);
mtklein3f3b3d02014-12-01 11:47:08 -0800444
bsalomon@google.comdfdb7e52012-10-16 15:19:45 +0000445 SkMatrix matrix;
bsalomon@google.comf94b3a42012-10-31 18:09:01 +0000446 if (!this->getLocalMatrix().invert(&matrix)) {
bsalomonc21b09e2015-08-28 18:46:56 -0700447 return nullptr;
bsalomon@google.comdfdb7e52012-10-16 15:19:45 +0000448 }
brianosman839345d2016-07-22 11:04:53 -0700449 if (args.fLocalMatrix) {
commit-bot@chromium.org96fb7482014-05-09 20:28:11 +0000450 SkMatrix inv;
brianosman839345d2016-07-22 11:04:53 -0700451 if (!args.fLocalMatrix->invert(&inv)) {
bsalomonc21b09e2015-08-28 18:46:56 -0700452 return nullptr;
commit-bot@chromium.org96fb7482014-05-09 20:28:11 +0000453 }
454 matrix.postConcat(inv);
455 }
bsalomon@google.comf94b3a42012-10-31 18:09:01 +0000456 matrix.postConcat(fPtsToUnit);
mtklein3f3b3d02014-12-01 11:47:08 -0800457
brianosmanb9c51372016-09-15 11:09:45 -0700458 sk_sp<GrColorSpaceXform> colorSpaceXform = GrColorSpaceXform::Make(fColorSpace.get(),
459 args.fDstColorSpace);
brianosman9557c272016-09-15 06:59:15 -0700460 sk_sp<GrFragmentProcessor> inner(GrLinearGradient::Make(
brianosmanb9c51372016-09-15 11:09:45 -0700461 GrGradientEffect::CreateArgs(args.fContext, this, &matrix, fTileMode,
462 std::move(colorSpaceXform), SkToBool(args.fDstColorSpace))));
Brian Salomon6af27012017-06-09 08:21:42 -0400463 if (!inner) {
464 return nullptr;
465 }
bungeman06ca8ec2016-06-09 08:01:03 -0700466 return GrFragmentProcessor::MulOutputByInputAlpha(std::move(inner));
rileya@google.comd7cc6512012-07-27 14:00:39 +0000467}
468
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +0000469
470#endif
robertphillips@google.com76f9e932013-01-15 20:17:47 +0000471
commit-bot@chromium.org0f10f7b2014-03-13 18:02:17 +0000472#ifndef SK_IGNORE_TO_STRING
robertphillips@google.com76f9e932013-01-15 20:17:47 +0000473void SkLinearGradient::toString(SkString* str) const {
474 str->append("SkLinearGradient (");
475
476 str->appendf("start: (%f, %f)", fStart.fX, fStart.fY);
477 str->appendf(" end: (%f, %f) ", fEnd.fX, fEnd.fY);
478
479 this->INHERITED::toString(str);
480
481 str->append(")");
482}
483#endif
reedf3182eb2015-11-17 08:12:19 -0800484
485///////////////////////////////////////////////////////////////////////////////////////////////////
486
487#include "SkNx.h"
488
489static const SkLinearGradient::LinearGradientContext::Rec*
490find_forward(const SkLinearGradient::LinearGradientContext::Rec rec[], float tiledX) {
491 SkASSERT(tiledX >= 0 && tiledX <= 1);
492
493 SkASSERT(rec[0].fPos >= 0 && rec[0].fPos <= 1);
494 SkASSERT(rec[1].fPos >= 0 && rec[1].fPos <= 1);
495 SkASSERT(rec[0].fPos <= rec[1].fPos);
496 rec += 1;
lsalzmanf2b86622016-01-22 14:03:02 -0800497 while (rec->fPos < tiledX || rec->fPosScale == 0) {
reedf3182eb2015-11-17 08:12:19 -0800498 SkASSERT(rec[0].fPos >= 0 && rec[0].fPos <= 1);
499 SkASSERT(rec[1].fPos >= 0 && rec[1].fPos <= 1);
500 SkASSERT(rec[0].fPos <= rec[1].fPos);
501 rec += 1;
502 }
503 return rec - 1;
504}
505
506static const SkLinearGradient::LinearGradientContext::Rec*
507find_backward(const SkLinearGradient::LinearGradientContext::Rec rec[], float tiledX) {
508 SkASSERT(tiledX >= 0 && tiledX <= 1);
509
510 SkASSERT(rec[0].fPos >= 0 && rec[0].fPos <= 1);
511 SkASSERT(rec[1].fPos >= 0 && rec[1].fPos <= 1);
512 SkASSERT(rec[0].fPos <= rec[1].fPos);
lsalzmanf2b86622016-01-22 14:03:02 -0800513 while (tiledX < rec->fPos || rec[1].fPosScale == 0) {
reedf3182eb2015-11-17 08:12:19 -0800514 rec -= 1;
515 SkASSERT(rec[0].fPos >= 0 && rec[0].fPos <= 1);
516 SkASSERT(rec[1].fPos >= 0 && rec[1].fPos <= 1);
517 SkASSERT(rec[0].fPos <= rec[1].fPos);
518 }
519 return rec;
520}
521
fmalita0ce4f232016-12-06 08:57:47 -0800522// As an optimization, we can apply the dither bias before interpolation -- but only when
523// operating in premul space (apply_alpha == false). When apply_alpha == true, we must
524// defer the bias application until after premul.
525//
526// The following two helpers encapsulate this logic: pre_bias is called before interpolation,
527// and effects the bias when apply_alpha == false, while post_bias is called after premul and
528// effects the bias for the apply_alpha == true case.
529
530template <bool apply_alpha>
531Sk4f pre_bias(const Sk4f& x, const Sk4f& bias) {
fmalita0ce4f232016-12-06 08:57:47 -0800532 return apply_alpha ? x : x + bias;
fmalita0ce4f232016-12-06 08:57:47 -0800533}
534
535template <bool apply_alpha>
536Sk4f post_bias(const Sk4f& x, const Sk4f& bias) {
fmalita0ce4f232016-12-06 08:57:47 -0800537 return apply_alpha ? x + bias : x;
fmalita0ce4f232016-12-06 08:57:47 -0800538}
539
540template <bool apply_alpha> SkPMColor trunc_from_255(const Sk4f& x, const Sk4f& bias) {
reedf3182eb2015-11-17 08:12:19 -0800541 SkPMColor c;
fmalita0ce4f232016-12-06 08:57:47 -0800542 Sk4f c4f255 = x;
543 if (apply_alpha) {
Lee Salzmana8362672017-06-01 14:45:29 -0400544 // Due to use of multiplication by the 1/255 reciprocal instead of division by 255,
545 // non-integer alpha values very close to their ceiling can push the color values
546 // above the alpha value, which will become an invalid premultiplied color. So nudge
547 // alpha up slightly by a compensating scale to keep it above the color values.
548 // To do this, multiply alpha by a number slightly greater than 1 to compensate
549 // for error in scaling from the 1/255 approximation. Since this error is then
550 // scaled by the alpha value, we need to scale the epsilon by 255 to get a safe
551 // upper bound on the error.
552 static constexpr float alphaScale = 1 + 255*std::numeric_limits<float>::epsilon();
Florin Malita15200bd2017-06-19 15:40:45 -0400553
fmalita0ce4f232016-12-06 08:57:47 -0800554 const float scale = x[SkPM4f::A] * (1 / 255.f);
Lee Salzmana8362672017-06-01 14:45:29 -0400555 c4f255 *= Sk4f(scale, scale, scale, alphaScale);
fmalita0ce4f232016-12-06 08:57:47 -0800556 }
557 SkNx_cast<uint8_t>(post_bias<apply_alpha>(c4f255, bias)).store(&c);
Florin Malitaaaa6d772016-12-07 14:57:04 -0500558
reedf3182eb2015-11-17 08:12:19 -0800559 return c;
560}
561
562template <bool apply_alpha> void fill(SkPMColor dst[], int count,
fmalita0ce4f232016-12-06 08:57:47 -0800563 const Sk4f& c4, const Sk4f& bias0, const Sk4f& bias1) {
564 const SkPMColor c0 = trunc_from_255<apply_alpha>(pre_bias<apply_alpha>(c4, bias0), bias0);
565 const SkPMColor c1 = trunc_from_255<apply_alpha>(pre_bias<apply_alpha>(c4, bias1), bias1);
566 sk_memset32_dither(dst, c0, c1, count);
reedf3182eb2015-11-17 08:12:19 -0800567}
568
569template <bool apply_alpha> void fill(SkPMColor dst[], int count, const Sk4f& c4) {
570 // Assumes that c4 does not need to be dithered.
fmalita0ce4f232016-12-06 08:57:47 -0800571 sk_memset32(dst, trunc_from_255<apply_alpha>(c4, 0), count);
reedf3182eb2015-11-17 08:12:19 -0800572}
573
574/*
575 * TODOs
576 *
577 * - tilemodes
578 * - interp before or after premul
579 * - perspective
580 * - optimizations
581 * - use fixed (32bit or 16bit) instead of floats?
582 */
583
584static Sk4f lerp_color(float fx, const SkLinearGradient::LinearGradientContext::Rec* rec) {
reedde3aac82015-11-22 13:00:04 -0800585 SkASSERT(fx >= rec[0].fPos);
586 SkASSERT(fx <= rec[1].fPos);
587
reedf3182eb2015-11-17 08:12:19 -0800588 const float p0 = rec[0].fPos;
589 const Sk4f c0 = rec[0].fColor;
590 const Sk4f c1 = rec[1].fColor;
591 const Sk4f diffc = c1 - c0;
592 const float scale = rec[1].fPosScale;
593 const float t = (fx - p0) * scale;
594 return c0 + Sk4f(t) * diffc;
595}
596
597template <bool apply_alpha> void ramp(SkPMColor dstC[], int n, const Sk4f& c, const Sk4f& dc,
598 const Sk4f& dither0, const Sk4f& dither1) {
599 Sk4f dc2 = dc + dc;
600 Sk4f dc4 = dc2 + dc2;
fmalita0ce4f232016-12-06 08:57:47 -0800601 Sk4f cd0 = pre_bias<apply_alpha>(c , dither0);
602 Sk4f cd1 = pre_bias<apply_alpha>(c + dc, dither1);
reedf3182eb2015-11-17 08:12:19 -0800603 Sk4f cd2 = cd0 + dc2;
604 Sk4f cd3 = cd1 + dc2;
605 while (n >= 4) {
mtklein9db43ac2015-12-01 07:10:21 -0800606 if (!apply_alpha) {
mtklein6f37b4a2015-12-14 11:25:18 -0800607 Sk4f_ToBytes((uint8_t*)dstC, cd0, cd1, cd2, cd3);
mtklein9db43ac2015-12-01 07:10:21 -0800608 dstC += 4;
609 } else {
fmalita0ce4f232016-12-06 08:57:47 -0800610 *dstC++ = trunc_from_255<apply_alpha>(cd0, dither0);
611 *dstC++ = trunc_from_255<apply_alpha>(cd1, dither1);
612 *dstC++ = trunc_from_255<apply_alpha>(cd2, dither0);
613 *dstC++ = trunc_from_255<apply_alpha>(cd3, dither1);
mtklein9db43ac2015-12-01 07:10:21 -0800614 }
reedf3182eb2015-11-17 08:12:19 -0800615 cd0 = cd0 + dc4;
616 cd1 = cd1 + dc4;
617 cd2 = cd2 + dc4;
618 cd3 = cd3 + dc4;
619 n -= 4;
620 }
621 if (n & 2) {
fmalita0ce4f232016-12-06 08:57:47 -0800622 *dstC++ = trunc_from_255<apply_alpha>(cd0, dither0);
623 *dstC++ = trunc_from_255<apply_alpha>(cd1, dither1);
reedf3182eb2015-11-17 08:12:19 -0800624 cd0 = cd0 + dc2;
625 }
626 if (n & 1) {
fmalita0ce4f232016-12-06 08:57:47 -0800627 *dstC++ = trunc_from_255<apply_alpha>(cd0, dither0);
reedf3182eb2015-11-17 08:12:19 -0800628 }
629}
630
631template <bool apply_alpha, bool dx_is_pos>
632void SkLinearGradient::LinearGradientContext::shade4_dx_clamp(SkPMColor dstC[], int count,
633 float fx, float dx, float invDx,
634 const float dither[2]) {
635 Sk4f dither0(dither[0]);
636 Sk4f dither1(dither[1]);
637 const Rec* rec = fRecs.begin();
638
639 const Sk4f dx4 = Sk4f(dx);
640 SkDEBUGCODE(SkPMColor* endDstC = dstC + count;)
641
642 if (dx_is_pos) {
643 if (fx < 0) {
fmalita7b38e3c2016-05-26 11:13:52 -0700644 // count is guaranteed to be positive, but the first arg may overflow int32 after
645 // increment => casting to uint32 ensures correct clamping.
fmalita7dcb1312016-05-26 18:10:24 -0700646 int n = SkTMin<uint32_t>(static_cast<uint32_t>(SkFloatToIntFloor(-fx * invDx)) + 1,
647 count);
fmalita7b38e3c2016-05-26 11:13:52 -0700648 SkASSERT(n > 0);
reedf3182eb2015-11-17 08:12:19 -0800649 fill<apply_alpha>(dstC, n, rec[0].fColor);
650 count -= n;
651 dstC += n;
652 fx += n * dx;
653 SkASSERT(0 == count || fx >= 0);
654 if (n & 1) {
655 SkTSwap(dither0, dither1);
656 }
657 }
658 } else { // dx < 0
659 if (fx > 1) {
fmalita7b38e3c2016-05-26 11:13:52 -0700660 // count is guaranteed to be positive, but the first arg may overflow int32 after
661 // increment => casting to uint32 ensures correct clamping.
fmalita7dcb1312016-05-26 18:10:24 -0700662 int n = SkTMin<uint32_t>(static_cast<uint32_t>(SkFloatToIntFloor((1 - fx) * invDx)) + 1,
663 count);
fmalita7b38e3c2016-05-26 11:13:52 -0700664 SkASSERT(n > 0);
reedf3182eb2015-11-17 08:12:19 -0800665 fill<apply_alpha>(dstC, n, rec[fRecs.count() - 1].fColor);
666 count -= n;
667 dstC += n;
668 fx += n * dx;
669 SkASSERT(0 == count || fx <= 1);
670 if (n & 1) {
671 SkTSwap(dither0, dither1);
672 }
673 }
674 }
675 SkASSERT(count >= 0);
676
677 const Rec* r;
678 if (dx_is_pos) {
679 r = fRecs.begin(); // start at the beginning
680 } else {
681 r = fRecs.begin() + fRecs.count() - 2; // start at the end
682 }
683
684 while (count > 0) {
685 if (dx_is_pos) {
686 if (fx >= 1) {
687 fill<apply_alpha>(dstC, count, rec[fRecs.count() - 1].fColor);
688 return;
689 }
690 } else { // dx < 0
691 if (fx <= 0) {
692 fill<apply_alpha>(dstC, count, rec[0].fColor);
693 return;
694 }
695 }
696
697 if (dx_is_pos) {
698 r = find_forward(r, fx);
699 } else {
700 r = find_backward(r, fx);
701 }
702 SkASSERT(r >= fRecs.begin() && r < fRecs.begin() + fRecs.count() - 1);
703
704 const float p0 = r[0].fPos;
705 const Sk4f c0 = r[0].fColor;
706 const float p1 = r[1].fPos;
707 const Sk4f diffc = Sk4f(r[1].fColor) - c0;
708 const float scale = r[1].fPosScale;
709 const float t = (fx - p0) * scale;
710 const Sk4f c = c0 + Sk4f(t) * diffc;
711 const Sk4f dc = diffc * dx4 * Sk4f(scale);
712
713 int n;
714 if (dx_is_pos) {
715 n = SkTMin((int)((p1 - fx) * invDx) + 1, count);
716 } else {
717 n = SkTMin((int)((p0 - fx) * invDx) + 1, count);
718 }
719
720 fx += n * dx;
reedaeab8ea2016-01-05 10:01:38 -0800721 // fx should now outside of the p0..p1 interval. However, due to float precision loss,
722 // its possible that fx is slightly too small/large, so we clamp it.
reedf3182eb2015-11-17 08:12:19 -0800723 if (dx_is_pos) {
reedaeab8ea2016-01-05 10:01:38 -0800724 fx = SkTMax(fx, p1);
reedf3182eb2015-11-17 08:12:19 -0800725 } else {
reedaeab8ea2016-01-05 10:01:38 -0800726 fx = SkTMin(fx, p0);
reedf3182eb2015-11-17 08:12:19 -0800727 }
728
729 ramp<apply_alpha>(dstC, n, c, dc, dither0, dither1);
730 dstC += n;
731 SkASSERT(dstC <= endDstC);
mtklein9db43ac2015-12-01 07:10:21 -0800732
reedf3182eb2015-11-17 08:12:19 -0800733 if (n & 1) {
734 SkTSwap(dither0, dither1);
735 }
reedaeab8ea2016-01-05 10:01:38 -0800736
737 count -= n;
738 SkASSERT(count >= 0);
reedf3182eb2015-11-17 08:12:19 -0800739 }
740}
741
742void SkLinearGradient::LinearGradientContext::shade4_clamp(int x, int y, SkPMColor dstC[],
743 int count) {
744 SkASSERT(count > 0);
reedf3182eb2015-11-17 08:12:19 -0800745
746 SkPoint srcPt;
747 fDstToIndexProc(fDstToIndex, x + SK_ScalarHalf, y + SK_ScalarHalf, &srcPt);
748 float fx = srcPt.x();
749 const float dx = fDstToIndex.getScaleX();
750
751 // Default our dither bias values to 1/2, (rounding), which is no dithering
752 float dither0 = 0.5f;
753 float dither1 = 0.5f;
754 if (fDither) {
755 const float ditherCell[] = {
756 1/8.0f, 5/8.0f,
757 7/8.0f, 3/8.0f,
758 };
759 const int rowIndex = (y & 1) << 1;
760 dither0 = ditherCell[rowIndex];
761 dither1 = ditherCell[rowIndex + 1];
762 if (x & 1) {
763 SkTSwap(dither0, dither1);
764 }
765 }
766 const float dither[2] = { dither0, dither1 };
reedf3182eb2015-11-17 08:12:19 -0800767
fmalita2b469132015-11-23 08:30:23 -0800768 if (SkScalarNearlyZero(dx * count)) { // gradient is vertical
reedde3aac82015-11-22 13:00:04 -0800769 const float pinFx = SkTPin(fx, 0.0f, 1.0f);
770 Sk4f c = lerp_color(pinFx, find_forward(fRecs.begin(), pinFx));
reedf3182eb2015-11-17 08:12:19 -0800771 if (fApplyAlphaAfterInterp) {
fmalita0ce4f232016-12-06 08:57:47 -0800772 fill<true>(dstC, count, c, dither0, dither1);
reedf3182eb2015-11-17 08:12:19 -0800773 } else {
fmalita0ce4f232016-12-06 08:57:47 -0800774 fill<false>(dstC, count, c, dither0, dither1);
reedf3182eb2015-11-17 08:12:19 -0800775 }
776 return;
777 }
778
James Zern44e91c92016-11-09 19:22:46 -0800779 SkASSERT(0.f != dx);
780 const float invDx = 1 / dx;
reedf3182eb2015-11-17 08:12:19 -0800781 if (dx > 0) {
782 if (fApplyAlphaAfterInterp) {
783 this->shade4_dx_clamp<true, true>(dstC, count, fx, dx, invDx, dither);
784 } else {
785 this->shade4_dx_clamp<false, true>(dstC, count, fx, dx, invDx, dither);
786 }
787 } else {
788 if (fApplyAlphaAfterInterp) {
789 this->shade4_dx_clamp<true, false>(dstC, count, fx, dx, invDx, dither);
790 } else {
791 this->shade4_dx_clamp<false, false>(dstC, count, fx, dx, invDx, dither);
792 }
793 }
794}