• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
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 
8 #include "SkTwoPointConicalGradient.h"
9 #include "SkTwoPointConicalGradient_gpu.h"
10 
11 struct TwoPtRadialContext {
12     const TwoPtRadial&  fRec;
13     float               fRelX, fRelY;
14     const float         fIncX, fIncY;
15     float               fB;
16     const float         fDB;
17 
18     TwoPtRadialContext(const TwoPtRadial& rec, SkScalar fx, SkScalar fy,
19                        SkScalar dfx, SkScalar dfy);
20     SkFixed nextT();
21 };
22 
valid_divide(float numer,float denom,float * ratio)23 static int valid_divide(float numer, float denom, float* ratio) {
24     SkASSERT(ratio);
25     if (0 == denom) {
26         return 0;
27     }
28     *ratio = numer / denom;
29     return 1;
30 }
31 
32 // Return the number of distinct real roots, and write them into roots[] in
33 // ascending order
find_quad_roots(float A,float B,float C,float roots[2],bool descendingOrder=false)34 static int find_quad_roots(float A, float B, float C, float roots[2], bool descendingOrder = false) {
35     SkASSERT(roots);
36 
37     if (A == 0) {
38         return valid_divide(-C, B, roots);
39     }
40 
41     float R = B*B - 4*A*C;
42     if (R < 0) {
43         return 0;
44     }
45     R = sk_float_sqrt(R);
46 
47 #if 1
48     float Q = B;
49     if (Q < 0) {
50         Q -= R;
51     } else {
52         Q += R;
53     }
54 #else
55     // on 10.6 this was much slower than the above branch :(
56     float Q = B + copysignf(R, B);
57 #endif
58     Q *= -0.5f;
59     if (0 == Q) {
60         roots[0] = 0;
61         return 1;
62     }
63 
64     float r0 = Q / A;
65     float r1 = C / Q;
66     roots[0] = r0 < r1 ? r0 : r1;
67     roots[1] = r0 > r1 ? r0 : r1;
68     if (descendingOrder) {
69         SkTSwap(roots[0], roots[1]);
70     }
71     return 2;
72 }
73 
lerp(float x,float dx,float t)74 static float lerp(float x, float dx, float t) {
75     return x + t * dx;
76 }
77 
sqr(float x)78 static float sqr(float x) { return x * x; }
79 
init(const SkPoint & center0,SkScalar rad0,const SkPoint & center1,SkScalar rad1,bool flipped)80 void TwoPtRadial::init(const SkPoint& center0, SkScalar rad0,
81                        const SkPoint& center1, SkScalar rad1,
82                        bool flipped) {
83     fCenterX = SkScalarToFloat(center0.fX);
84     fCenterY = SkScalarToFloat(center0.fY);
85     fDCenterX = SkScalarToFloat(center1.fX) - fCenterX;
86     fDCenterY = SkScalarToFloat(center1.fY) - fCenterY;
87     fRadius = SkScalarToFloat(rad0);
88     fDRadius = SkScalarToFloat(rad1) - fRadius;
89 
90     fA = sqr(fDCenterX) + sqr(fDCenterY) - sqr(fDRadius);
91     fRadius2 = sqr(fRadius);
92     fRDR = fRadius * fDRadius;
93 
94     fFlipped = flipped;
95 }
96 
TwoPtRadialContext(const TwoPtRadial & rec,SkScalar fx,SkScalar fy,SkScalar dfx,SkScalar dfy)97 TwoPtRadialContext::TwoPtRadialContext(const TwoPtRadial& rec, SkScalar fx, SkScalar fy,
98                                        SkScalar dfx, SkScalar dfy)
99     : fRec(rec)
100     , fRelX(SkScalarToFloat(fx) - rec.fCenterX)
101     , fRelY(SkScalarToFloat(fy) - rec.fCenterY)
102     , fIncX(SkScalarToFloat(dfx))
103     , fIncY(SkScalarToFloat(dfy))
104     , fB(-2 * (rec.fDCenterX * fRelX + rec.fDCenterY * fRelY + rec.fRDR))
105     , fDB(-2 * (rec.fDCenterX * fIncX + rec.fDCenterY * fIncY)) {}
106 
nextT()107 SkFixed TwoPtRadialContext::nextT() {
108     float roots[2];
109 
110     float C = sqr(fRelX) + sqr(fRelY) - fRec.fRadius2;
111     int countRoots = find_quad_roots(fRec.fA, fB, C, roots, fRec.fFlipped);
112 
113     fRelX += fIncX;
114     fRelY += fIncY;
115     fB += fDB;
116 
117     if (0 == countRoots) {
118         return TwoPtRadial::kDontDrawT;
119     }
120 
121     // Prefer the bigger t value if both give a radius(t) > 0
122     // find_quad_roots returns the values sorted, so we start with the last
123     float t = roots[countRoots - 1];
124     float r = lerp(fRec.fRadius, fRec.fDRadius, t);
125     if (r <= 0) {
126         t = roots[0];   // might be the same as roots[countRoots-1]
127         r = lerp(fRec.fRadius, fRec.fDRadius, t);
128         if (r <= 0) {
129             return TwoPtRadial::kDontDrawT;
130         }
131     }
132     return SkFloatToFixed(t);
133 }
134 
135 typedef void (*TwoPointConicalProc)(TwoPtRadialContext* rec, SkPMColor* dstC,
136                                     const SkPMColor* cache, int toggle, int count);
137 
twopoint_clamp(TwoPtRadialContext * rec,SkPMColor * SK_RESTRICT dstC,const SkPMColor * SK_RESTRICT cache,int toggle,int count)138 static void twopoint_clamp(TwoPtRadialContext* rec, SkPMColor* SK_RESTRICT dstC,
139                            const SkPMColor* SK_RESTRICT cache, int toggle,
140                            int count) {
141     for (; count > 0; --count) {
142         SkFixed t = rec->nextT();
143         if (TwoPtRadial::DontDrawT(t)) {
144             *dstC++ = 0;
145         } else {
146             SkFixed index = SkClampMax(t, 0xFFFF);
147             SkASSERT(index <= 0xFFFF);
148             *dstC++ = cache[toggle +
149                             (index >> SkGradientShaderBase::kCache32Shift)];
150         }
151         toggle = next_dither_toggle(toggle);
152     }
153 }
154 
twopoint_repeat(TwoPtRadialContext * rec,SkPMColor * SK_RESTRICT dstC,const SkPMColor * SK_RESTRICT cache,int toggle,int count)155 static void twopoint_repeat(TwoPtRadialContext* rec, SkPMColor* SK_RESTRICT dstC,
156                             const SkPMColor* SK_RESTRICT cache, int toggle,
157                             int count) {
158     for (; count > 0; --count) {
159         SkFixed t = rec->nextT();
160         if (TwoPtRadial::DontDrawT(t)) {
161             *dstC++ = 0;
162         } else {
163             SkFixed index = repeat_tileproc(t);
164             SkASSERT(index <= 0xFFFF);
165             *dstC++ = cache[toggle +
166                             (index >> SkGradientShaderBase::kCache32Shift)];
167         }
168         toggle = next_dither_toggle(toggle);
169     }
170 }
171 
twopoint_mirror(TwoPtRadialContext * rec,SkPMColor * SK_RESTRICT dstC,const SkPMColor * SK_RESTRICT cache,int toggle,int count)172 static void twopoint_mirror(TwoPtRadialContext* rec, SkPMColor* SK_RESTRICT dstC,
173                             const SkPMColor* SK_RESTRICT cache, int toggle,
174                             int count) {
175     for (; count > 0; --count) {
176         SkFixed t = rec->nextT();
177         if (TwoPtRadial::DontDrawT(t)) {
178             *dstC++ = 0;
179         } else {
180             SkFixed index = mirror_tileproc(t);
181             SkASSERT(index <= 0xFFFF);
182             *dstC++ = cache[toggle +
183                             (index >> SkGradientShaderBase::kCache32Shift)];
184         }
185         toggle = next_dither_toggle(toggle);
186     }
187 }
188 
init()189 void SkTwoPointConicalGradient::init() {
190     fRec.init(fCenter1, fRadius1, fCenter2, fRadius2, fFlippedGrad);
191     fPtsToUnit.reset();
192 }
193 
194 /////////////////////////////////////////////////////////////////////
195 
SkTwoPointConicalGradient(const SkPoint & start,SkScalar startRadius,const SkPoint & end,SkScalar endRadius,bool flippedGrad,const Descriptor & desc)196 SkTwoPointConicalGradient::SkTwoPointConicalGradient(
197         const SkPoint& start, SkScalar startRadius,
198         const SkPoint& end, SkScalar endRadius,
199         bool flippedGrad, const Descriptor& desc)
200     : SkGradientShaderBase(desc)
201     , fCenter1(start)
202     , fCenter2(end)
203     , fRadius1(startRadius)
204     , fRadius2(endRadius)
205     , fFlippedGrad(flippedGrad)
206 {
207     // this is degenerate, and should be caught by our caller
208     SkASSERT(fCenter1 != fCenter2 || fRadius1 != fRadius2);
209     this->init();
210 }
211 
isOpaque() const212 bool SkTwoPointConicalGradient::isOpaque() const {
213     // Because areas outside the cone are left untouched, we cannot treat the
214     // shader as opaque even if the gradient itself is opaque.
215     // TODO(junov): Compute whether the cone fills the plane crbug.com/222380
216     return false;
217 }
218 
contextSize() const219 size_t SkTwoPointConicalGradient::contextSize() const {
220     return sizeof(TwoPointConicalGradientContext);
221 }
222 
onCreateContext(const ContextRec & rec,void * storage) const223 SkShader::Context* SkTwoPointConicalGradient::onCreateContext(const ContextRec& rec,
224                                                               void* storage) const {
225     return SkNEW_PLACEMENT_ARGS(storage, TwoPointConicalGradientContext, (*this, rec));
226 }
227 
TwoPointConicalGradientContext(const SkTwoPointConicalGradient & shader,const ContextRec & rec)228 SkTwoPointConicalGradient::TwoPointConicalGradientContext::TwoPointConicalGradientContext(
229         const SkTwoPointConicalGradient& shader, const ContextRec& rec)
230     : INHERITED(shader, rec)
231 {
232     // we don't have a span16 proc
233     fFlags &= ~kHasSpan16_Flag;
234 
235     // in general, we might discard based on computed-radius, so clear
236     // this flag (todo: sometimes we can detect that we never discard...)
237     fFlags &= ~kOpaqueAlpha_Flag;
238 }
239 
shadeSpan(int x,int y,SkPMColor * dstCParam,int count)240 void SkTwoPointConicalGradient::TwoPointConicalGradientContext::shadeSpan(
241         int x, int y, SkPMColor* dstCParam, int count) {
242     const SkTwoPointConicalGradient& twoPointConicalGradient =
243             static_cast<const SkTwoPointConicalGradient&>(fShader);
244 
245     int toggle = init_dither_toggle(x, y);
246 
247     SkASSERT(count > 0);
248 
249     SkPMColor* SK_RESTRICT dstC = dstCParam;
250 
251     SkMatrix::MapXYProc dstProc = fDstToIndexProc;
252 
253     const SkPMColor* SK_RESTRICT cache = fCache->getCache32();
254 
255     TwoPointConicalProc shadeProc = twopoint_repeat;
256     if (SkShader::kClamp_TileMode == twoPointConicalGradient.fTileMode) {
257         shadeProc = twopoint_clamp;
258     } else if (SkShader::kMirror_TileMode == twoPointConicalGradient.fTileMode) {
259         shadeProc = twopoint_mirror;
260     } else {
261         SkASSERT(SkShader::kRepeat_TileMode == twoPointConicalGradient.fTileMode);
262     }
263 
264     if (fDstToIndexClass != kPerspective_MatrixClass) {
265         SkPoint srcPt;
266         dstProc(fDstToIndex, SkIntToScalar(x) + SK_ScalarHalf,
267                 SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
268         SkScalar dx, fx = srcPt.fX;
269         SkScalar dy, fy = srcPt.fY;
270 
271         if (fDstToIndexClass == kFixedStepInX_MatrixClass) {
272             SkFixed fixedX, fixedY;
273             (void)fDstToIndex.fixedStepInX(SkIntToScalar(y), &fixedX, &fixedY);
274             dx = SkFixedToScalar(fixedX);
275             dy = SkFixedToScalar(fixedY);
276         } else {
277             SkASSERT(fDstToIndexClass == kLinear_MatrixClass);
278             dx = fDstToIndex.getScaleX();
279             dy = fDstToIndex.getSkewY();
280         }
281 
282         TwoPtRadialContext rec(twoPointConicalGradient.fRec, fx, fy, dx, dy);
283         (*shadeProc)(&rec, dstC, cache, toggle, count);
284     } else {    // perspective case
285         SkScalar dstX = SkIntToScalar(x) + SK_ScalarHalf;
286         SkScalar dstY = SkIntToScalar(y) + SK_ScalarHalf;
287         for (; count > 0; --count) {
288             SkPoint srcPt;
289             dstProc(fDstToIndex, dstX, dstY, &srcPt);
290             TwoPtRadialContext rec(twoPointConicalGradient.fRec, srcPt.fX, srcPt.fY, 0, 0);
291             (*shadeProc)(&rec, dstC, cache, toggle, 1);
292 
293             dstX += SK_Scalar1;
294             toggle = next_dither_toggle(toggle);
295             dstC += 1;
296         }
297     }
298 }
299 
asABitmap(SkBitmap * bitmap,SkMatrix * matrix,SkShader::TileMode * xy) const300 SkShader::BitmapType SkTwoPointConicalGradient::asABitmap(
301     SkBitmap* bitmap, SkMatrix* matrix, SkShader::TileMode* xy) const {
302     SkPoint diff = fCenter2 - fCenter1;
303     SkScalar diffLen = 0;
304 
305     if (bitmap) {
306         this->getGradientTableBitmap(bitmap);
307     }
308     if (matrix) {
309         diffLen = diff.length();
310     }
311     if (matrix) {
312         if (diffLen) {
313             SkScalar invDiffLen = SkScalarInvert(diffLen);
314             // rotate to align circle centers with the x-axis
315             matrix->setSinCos(-SkScalarMul(invDiffLen, diff.fY),
316                               SkScalarMul(invDiffLen, diff.fX));
317         } else {
318             matrix->reset();
319         }
320         matrix->preTranslate(-fCenter1.fX, -fCenter1.fY);
321     }
322     if (xy) {
323         xy[0] = fTileMode;
324         xy[1] = kClamp_TileMode;
325     }
326     return kTwoPointConical_BitmapType;
327 }
328 
329 // Returns the original non-sorted version of the gradient
asAGradient(GradientInfo * info) const330 SkShader::GradientType SkTwoPointConicalGradient::asAGradient(
331     GradientInfo* info) const {
332     if (info) {
333         commonAsAGradient(info, fFlippedGrad);
334         info->fPoint[0] = fCenter1;
335         info->fPoint[1] = fCenter2;
336         info->fRadius[0] = fRadius1;
337         info->fRadius[1] = fRadius2;
338         if (fFlippedGrad) {
339             SkTSwap(info->fPoint[0], info->fPoint[1]);
340             SkTSwap(info->fRadius[0], info->fRadius[1]);
341         }
342     }
343     return kConical_GradientType;
344 }
345 
346 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
SkTwoPointConicalGradient(SkReadBuffer & buffer)347 SkTwoPointConicalGradient::SkTwoPointConicalGradient(
348     SkReadBuffer& buffer)
349     : INHERITED(buffer),
350     fCenter1(buffer.readPoint()),
351     fCenter2(buffer.readPoint()),
352     fRadius1(buffer.readScalar()),
353     fRadius2(buffer.readScalar()) {
354     if (buffer.isVersionLT(SkReadBuffer::kGradientFlippedFlag_Version)) {
355         // V23_COMPATIBILITY_CODE
356         // Sort gradient by radius size for old pictures
357         if (fRadius2 < fRadius1) {
358             SkTSwap(fCenter1, fCenter2);
359             SkTSwap(fRadius1, fRadius2);
360             this->flipGradientColors();
361             fFlippedGrad = true;
362         } else {
363             fFlippedGrad = false;
364         }
365     } else {
366         fFlippedGrad = buffer.readBool();
367     }
368     this->init();
369 };
370 #endif
371 
CreateProc(SkReadBuffer & buffer)372 SkFlattenable* SkTwoPointConicalGradient::CreateProc(SkReadBuffer& buffer) {
373     DescriptorScope desc;
374     if (!desc.unflatten(buffer)) {
375         return NULL;
376     }
377     SkPoint c1 = buffer.readPoint();
378     SkPoint c2 = buffer.readPoint();
379     SkScalar r1 = buffer.readScalar();
380     SkScalar r2 = buffer.readScalar();
381 
382     if (buffer.readBool()) {    // flipped
383         SkTSwap(c1, c2);
384         SkTSwap(r1, r2);
385 
386         SkColor* colors = desc.mutableColors();
387         SkScalar* pos = desc.mutablePos();
388         const int last = desc.fCount - 1;
389         const int half = desc.fCount >> 1;
390         for (int i = 0; i < half; ++i) {
391             SkTSwap(colors[i], colors[last - i]);
392             if (pos) {
393                 SkScalar tmp = pos[i];
394                 pos[i] = SK_Scalar1 - pos[last - i];
395                 pos[last - i] = SK_Scalar1 - tmp;
396             }
397         }
398         if (pos) {
399             if (desc.fCount & 1) {
400                 pos[half] = SK_Scalar1 - pos[half];
401             }
402         }
403     }
404 
405     return SkGradientShader::CreateTwoPointConical(c1, r1, c2, r2, desc.fColors, desc.fPos,
406                                                    desc.fCount, desc.fTileMode, desc.fGradFlags,
407                                                    desc.fLocalMatrix);
408 }
409 
flatten(SkWriteBuffer & buffer) const410 void SkTwoPointConicalGradient::flatten(SkWriteBuffer& buffer) const {
411     this->INHERITED::flatten(buffer);
412     buffer.writePoint(fCenter1);
413     buffer.writePoint(fCenter2);
414     buffer.writeScalar(fRadius1);
415     buffer.writeScalar(fRadius2);
416     buffer.writeBool(fFlippedGrad);
417 }
418 
419 #if SK_SUPPORT_GPU
420 
421 #include "SkGr.h"
422 
asFragmentProcessor(GrContext * context,const SkPaint & paint,const SkMatrix * localMatrix,GrColor * paintColor,GrFragmentProcessor ** fp) const423 bool SkTwoPointConicalGradient::asFragmentProcessor(GrContext* context,
424                                                     const SkPaint& paint,
425                                                     const SkMatrix* localMatrix,
426                                                     GrColor* paintColor,
427                                                     GrFragmentProcessor** fp)  const {
428     SkASSERT(context);
429     SkASSERT(fPtsToUnit.isIdentity());
430 
431     *fp = Gr2PtConicalGradientEffect::Create(context, *this, fTileMode, localMatrix);
432     *paintColor = SkColor2GrColorJustAlpha(paint.getColor());
433     return true;
434 }
435 
436 #else
437 
asFragmentProcessor(GrContext *,const SkPaint &,const SkMatrix *,GrColor *,GrFragmentProcessor **) const438 bool SkTwoPointConicalGradient::asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix*,
439                                                     GrColor*, GrFragmentProcessor**)  const {
440     SkDEBUGFAIL("Should not call in GPU-less build");
441     return false;
442 }
443 
444 #endif
445 
446 #ifndef SK_IGNORE_TO_STRING
toString(SkString * str) const447 void SkTwoPointConicalGradient::toString(SkString* str) const {
448     str->append("SkTwoPointConicalGradient: (");
449 
450     str->append("center1: (");
451     str->appendScalar(fCenter1.fX);
452     str->append(", ");
453     str->appendScalar(fCenter1.fY);
454     str->append(") radius1: ");
455     str->appendScalar(fRadius1);
456     str->append(" ");
457 
458     str->append("center2: (");
459     str->appendScalar(fCenter2.fX);
460     str->append(", ");
461     str->appendScalar(fCenter2.fY);
462     str->append(") radius2: ");
463     str->appendScalar(fRadius2);
464     str->append(" ");
465 
466     this->INHERITED::toString(str);
467 
468     str->append(")");
469 }
470 #endif
471