SkRadialGradient.cpp revision 0152cc3819291841298013d2b5515a61e974e41f 
1
2/*
3 * Copyright 2012 Google Inc.
4 *
5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file.
7 */
8
9#include "SkRadialGradient.h"
10#include "SkNx.h"
11
12namespace {
13
14// GCC doesn't like using static functions as template arguments.  So force these to be non-static.
15inline SkFixed mirror_tileproc_nonstatic(SkFixed x) {
16    return mirror_tileproc(x);
17}
18
19inline SkFixed repeat_tileproc_nonstatic(SkFixed x) {
20    return repeat_tileproc(x);
21}
22
23SkMatrix rad_to_unit_matrix(const SkPoint& center, SkScalar radius) {
24    SkScalar    inv = SkScalarInvert(radius);
25
26    SkMatrix matrix;
27    matrix.setTranslate(-center.fX, -center.fY);
28    matrix.postScale(inv, inv);
29    return matrix;
30}
31
32
33}  // namespace
34
35/////////////////////////////////////////////////////////////////////
36
37SkRadialGradient::SkRadialGradient(const SkPoint& center, SkScalar radius, const Descriptor& desc)
38    : SkGradientShaderBase(desc, rad_to_unit_matrix(center, radius))
39    , fCenter(center)
40    , fRadius(radius) {
41}
42
43size_t SkRadialGradient::contextSize() const {
44    return sizeof(RadialGradientContext);
45}
46
47SkShader::Context* SkRadialGradient::onCreateContext(const ContextRec& rec, void* storage) const {
48    return new (storage) RadialGradientContext(*this, rec);
49}
50
51SkRadialGradient::RadialGradientContext::RadialGradientContext(
52        const SkRadialGradient& shader, const ContextRec& rec)
53    : INHERITED(shader, rec) {}
54
55SkShader::GradientType SkRadialGradient::asAGradient(GradientInfo* info) const {
56    if (info) {
57        commonAsAGradient(info);
58        info->fPoint[0] = fCenter;
59        info->fRadius[0] = fRadius;
60    }
61    return kRadial_GradientType;
62}
63
64SkFlattenable* SkRadialGradient::CreateProc(SkReadBuffer& buffer) {
65    DescriptorScope desc;
66    if (!desc.unflatten(buffer)) {
67        return nullptr;
68    }
69    const SkPoint center = buffer.readPoint();
70    const SkScalar radius = buffer.readScalar();
71    return SkGradientShader::CreateRadial(center, radius, desc.fColors, desc.fPos, desc.fCount,
72                                          desc.fTileMode, desc.fGradFlags, desc.fLocalMatrix);
73}
74
75void SkRadialGradient::flatten(SkWriteBuffer& buffer) const {
76    this->INHERITED::flatten(buffer);
77    buffer.writePoint(fCenter);
78    buffer.writeScalar(fRadius);
79}
80
81namespace {
82
83inline bool radial_completely_pinned(SkScalar fx, SkScalar dx, SkScalar fy, SkScalar dy) {
84    // fast, overly-conservative test: checks unit square instead of unit circle
85    bool xClamped = (fx >= 1 && dx >= 0) || (fx <= -1 && dx <= 0);
86    bool yClamped = (fy >= 1 && dy >= 0) || (fy <= -1 && dy <= 0);
87    return xClamped || yClamped;
88}
89
90typedef void (* RadialShadeProc)(SkScalar sfx, SkScalar sdx,
91        SkScalar sfy, SkScalar sdy,
92        SkPMColor* dstC, const SkPMColor* cache,
93        int count, int toggle);
94
95static inline Sk4f fast_sqrt(const Sk4f& R) {
96    // R * R.rsqrt0() is much faster, but it's non-monotonic, which isn't so pretty for gradients.
97    return R * R.rsqrt1();
98}
99
100static inline Sk4f sum_squares(const Sk4f& a, const Sk4f& b) {
101    return a * a + b * b;
102}
103
104void shadeSpan_radial_clamp2(SkScalar sfx, SkScalar sdx, SkScalar sfy, SkScalar sdy,
105                             SkPMColor* SK_RESTRICT dstC, const SkPMColor* SK_RESTRICT cache,
106                             int count, int toggle) {
107    if (radial_completely_pinned(sfx, sdx, sfy, sdy)) {
108        unsigned fi = SkGradientShaderBase::kCache32Count - 1;
109        sk_memset32_dither(dstC,
110                           cache[toggle + fi],
111                           cache[next_dither_toggle(toggle) + fi],
112                           count);
113    } else {
114        const Sk4f max(255);
115        const float scale = 255;
116        sfx *= scale;
117        sfy *= scale;
118        sdx *= scale;
119        sdy *= scale;
120        const Sk4f fx4(sfx, sfx + sdx, sfx + 2*sdx, sfx + 3*sdx);
121        const Sk4f fy4(sfy, sfy + sdy, sfy + 2*sdy, sfy + 3*sdy);
122        const Sk4f dx4(sdx * 4);
123        const Sk4f dy4(sdy * 4);
124
125        Sk4f tmpxy = fx4 * dx4 + fy4 * dy4;
126        Sk4f tmpdxdy = sum_squares(dx4, dy4);
127        Sk4f R = sum_squares(fx4, fy4);
128        Sk4f dR = tmpxy + tmpxy + tmpdxdy;
129        const Sk4f ddR = tmpdxdy + tmpdxdy;
130
131        for (int i = 0; i < (count >> 2); ++i) {
132            Sk4f dist = Sk4f::Min(fast_sqrt(R), max);
133            R = R + dR;
134            dR = dR + ddR;
135
136            uint8_t fi[4];
137            SkNx_cast<uint8_t>(dist).store(fi);
138
139            for (int i = 0; i < 4; i++) {
140                *dstC++ = cache[toggle + fi[i]];
141                toggle = next_dither_toggle(toggle);
142            }
143        }
144        count &= 3;
145        if (count) {
146            Sk4f dist = Sk4f::Min(fast_sqrt(R), max);
147
148            uint8_t fi[4];
149            SkNx_cast<uint8_t>(dist).store(fi);
150            for (int i = 0; i < count; i++) {
151                *dstC++ = cache[toggle + fi[i]];
152                toggle = next_dither_toggle(toggle);
153            }
154        }
155    }
156}
157
158// Unrolling this loop doesn't seem to help (when float); we're stalling to
159// get the results of the sqrt (?), and don't have enough extra registers to
160// have many in flight.
161template <SkFixed (*TileProc)(SkFixed)>
162void shadeSpan_radial(SkScalar fx, SkScalar dx, SkScalar fy, SkScalar dy,
163                      SkPMColor* SK_RESTRICT dstC, const SkPMColor* SK_RESTRICT cache,
164                      int count, int toggle) {
165    do {
166        const SkFixed dist = SkFloatToFixed(sk_float_sqrt(fx*fx + fy*fy));
167        const unsigned fi = TileProc(dist);
168        SkASSERT(fi <= 0xFFFF);
169        *dstC++ = cache[toggle + (fi >> SkGradientShaderBase::kCache32Shift)];
170        toggle = next_dither_toggle(toggle);
171        fx += dx;
172        fy += dy;
173    } while (--count != 0);
174}
175
176void shadeSpan_radial_mirror(SkScalar fx, SkScalar dx, SkScalar fy, SkScalar dy,
177                             SkPMColor* SK_RESTRICT dstC, const SkPMColor* SK_RESTRICT cache,
178                             int count, int toggle) {
179    shadeSpan_radial<mirror_tileproc_nonstatic>(fx, dx, fy, dy, dstC, cache, count, toggle);
180}
181
182void shadeSpan_radial_repeat(SkScalar fx, SkScalar dx, SkScalar fy, SkScalar dy,
183                             SkPMColor* SK_RESTRICT dstC, const SkPMColor* SK_RESTRICT cache,
184                             int count, int toggle) {
185    shadeSpan_radial<repeat_tileproc_nonstatic>(fx, dx, fy, dy, dstC, cache, count, toggle);
186}
187
188}  // namespace
189
190void SkRadialGradient::RadialGradientContext::shadeSpan(int x, int y,
191                                                        SkPMColor* SK_RESTRICT dstC, int count) {
192    SkASSERT(count > 0);
193
194    const SkRadialGradient& radialGradient = static_cast<const SkRadialGradient&>(fShader);
195
196    SkPoint             srcPt;
197    SkMatrix::MapXYProc dstProc = fDstToIndexProc;
198    TileProc            proc = radialGradient.fTileProc;
199    const SkPMColor* SK_RESTRICT cache = fCache->getCache32();
200    int toggle = init_dither_toggle(x, y);
201
202    if (fDstToIndexClass != kPerspective_MatrixClass) {
203        dstProc(fDstToIndex, SkIntToScalar(x) + SK_ScalarHalf,
204                             SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
205        SkScalar sdx = fDstToIndex.getScaleX();
206        SkScalar sdy = fDstToIndex.getSkewY();
207
208        if (fDstToIndexClass == kFixedStepInX_MatrixClass) {
209            SkFixed storage[2];
210            (void)fDstToIndex.fixedStepInX(SkIntToScalar(y),
211                                           &storage[0], &storage[1]);
212            sdx = SkFixedToScalar(storage[0]);
213            sdy = SkFixedToScalar(storage[1]);
214        } else {
215            SkASSERT(fDstToIndexClass == kLinear_MatrixClass);
216        }
217
218        RadialShadeProc shadeProc = shadeSpan_radial_repeat;
219        if (SkShader::kClamp_TileMode == radialGradient.fTileMode) {
220            shadeProc = shadeSpan_radial_clamp2;
221        } else if (SkShader::kMirror_TileMode == radialGradient.fTileMode) {
222            shadeProc = shadeSpan_radial_mirror;
223        } else {
224            SkASSERT(SkShader::kRepeat_TileMode == radialGradient.fTileMode);
225        }
226        (*shadeProc)(srcPt.fX, sdx, srcPt.fY, sdy, dstC, cache, count, toggle);
227    } else {    // perspective case
228        SkScalar dstX = SkIntToScalar(x);
229        SkScalar dstY = SkIntToScalar(y);
230        do {
231            dstProc(fDstToIndex, dstX, dstY, &srcPt);
232            unsigned fi = proc(SkScalarToFixed(srcPt.length()));
233            SkASSERT(fi <= 0xFFFF);
234            *dstC++ = cache[fi >> SkGradientShaderBase::kCache32Shift];
235            dstX += SK_Scalar1;
236        } while (--count != 0);
237    }
238}
239
240/////////////////////////////////////////////////////////////////////
241
242#if SK_SUPPORT_GPU
243
244#include "SkGr.h"
245#include "glsl/GrGLSLCaps.h"
246#include "glsl/GrGLSLFragmentShaderBuilder.h"
247
248class GrGLRadialGradient : public GrGLGradientEffect {
249public:
250
251    GrGLRadialGradient(const GrProcessor&) {}
252    virtual ~GrGLRadialGradient() { }
253
254    virtual void emitCode(EmitArgs&) override;
255
256    static void GenKey(const GrProcessor& processor, const GrGLSLCaps&, GrProcessorKeyBuilder* b) {
257        b->add32(GenBaseGradientKey(processor));
258    }
259
260private:
261
262    typedef GrGLGradientEffect INHERITED;
263
264};
265
266/////////////////////////////////////////////////////////////////////
267
268class GrRadialGradient : public GrGradientEffect {
269public:
270    static GrFragmentProcessor* Create(GrContext* ctx,
271                                       const SkRadialGradient& shader,
272                                       const SkMatrix& matrix,
273                                       SkShader::TileMode tm) {
274        return new GrRadialGradient(ctx, shader, matrix, tm);
275    }
276
277    virtual ~GrRadialGradient() { }
278
279    const char* name() const override { return "Radial Gradient"; }
280
281private:
282    GrRadialGradient(GrContext* ctx,
283                     const SkRadialGradient& shader,
284                     const SkMatrix& matrix,
285                     SkShader::TileMode tm)
286        : INHERITED(ctx, shader, matrix, tm) {
287        this->initClassID<GrRadialGradient>();
288    }
289
290    GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
291        return new GrGLRadialGradient(*this);
292    }
293
294    virtual void onGetGLSLProcessorKey(const GrGLSLCaps& caps,
295                                       GrProcessorKeyBuilder* b) const override {
296        GrGLRadialGradient::GenKey(*this, caps, b);
297    }
298
299    GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
300
301    typedef GrGradientEffect INHERITED;
302};
303
304/////////////////////////////////////////////////////////////////////
305
306GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrRadialGradient);
307
308const GrFragmentProcessor* GrRadialGradient::TestCreate(GrProcessorTestData* d) {
309    SkPoint center = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
310    SkScalar radius = d->fRandom->nextUScalar1();
311
312    SkColor colors[kMaxRandomGradientColors];
313    SkScalar stopsArray[kMaxRandomGradientColors];
314    SkScalar* stops = stopsArray;
315    SkShader::TileMode tm;
316    int colorCount = RandomGradientParams(d->fRandom, colors, &stops, &tm);
317    SkAutoTUnref<SkShader> shader(SkGradientShader::CreateRadial(center, radius,
318                                                                 colors, stops, colorCount,
319                                                                 tm));
320    const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext,
321        GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality);
322    GrAlwaysAssert(fp);
323    return fp;
324}
325
326/////////////////////////////////////////////////////////////////////
327
328void GrGLRadialGradient::emitCode(EmitArgs& args) {
329    const GrRadialGradient& ge = args.fFp.cast<GrRadialGradient>();
330    this->emitUniforms(args.fUniformHandler, ge);
331    SkString t("length(");
332    t.append(args.fFragBuilder->ensureFSCoords2D(args.fCoords, 0));
333    t.append(")");
334    this->emitColor(args.fFragBuilder,
335                    args.fUniformHandler,
336                    args.fGLSLCaps,
337                    ge, t.c_str(),
338                    args.fOutputColor,
339                    args.fInputColor,
340                    args.fSamplers);
341}
342
343/////////////////////////////////////////////////////////////////////
344
345const GrFragmentProcessor* SkRadialGradient::asFragmentProcessor(
346                                                 GrContext* context,
347                                                 const SkMatrix& viewM,
348                                                 const SkMatrix* localMatrix,
349                                                 SkFilterQuality) const {
350    SkASSERT(context);
351
352    SkMatrix matrix;
353    if (!this->getLocalMatrix().invert(&matrix)) {
354        return nullptr;
355    }
356    if (localMatrix) {
357        SkMatrix inv;
358        if (!localMatrix->invert(&inv)) {
359            return nullptr;
360        }
361        matrix.postConcat(inv);
362    }
363    matrix.postConcat(fPtsToUnit);
364        SkAutoTUnref<const GrFragmentProcessor> inner(
365            GrRadialGradient::Create(context, *this, matrix, fTileMode));
366    return GrFragmentProcessor::MulOutputByInputAlpha(inner);
367}
368
369#endif
370
371#ifndef SK_IGNORE_TO_STRING
372void SkRadialGradient::toString(SkString* str) const {
373    str->append("SkRadialGradient: (");
374
375    str->append("center: (");
376    str->appendScalar(fCenter.fX);
377    str->append(", ");
378    str->appendScalar(fCenter.fY);
379    str->append(") radius: ");
380    str->appendScalar(fRadius);
381    str->append(" ");
382
383    this->INHERITED::toString(str);
384
385    str->append(")");
386}
387#endif
388