2 * Copyright 2012 Google Inc.
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
8 #include "SkLinearGradient.h"
10 static inline int repeat_bits(int x, const int bits) {
11 return x & ((1 << bits) - 1);
14 static inline int repeat_8bits(int x) {
18 // Visual Studio 2010 (MSC_VER=1600) optimizes bit-shift code incorrectly.
19 // See http://code.google.com/p/skia/issues/detail?id=472
20 #if defined(_MSC_VER) && (_MSC_VER >= 1600)
21 #pragma optimize("", off)
24 static inline int mirror_bits(int x, const int bits) {
25 if (x & (1 << bits)) {
28 return x & ((1 << bits) - 1);
31 static inline int mirror_8bits(int x) {
38 #if defined(_MSC_VER) && (_MSC_VER >= 1600)
39 #pragma optimize("", on)
42 static void pts_to_unit_matrix(const SkPoint pts[2], SkMatrix* matrix) {
43 SkVector vec = pts[1] - pts[0];
44 SkScalar mag = vec.length();
45 SkScalar inv = mag ? SkScalarInvert(mag) : 0;
48 matrix->setSinCos(-vec.fY, vec.fX, pts[0].fX, pts[0].fY);
49 matrix->postTranslate(-pts[0].fX, -pts[0].fY);
50 matrix->postScale(inv, inv);
53 ///////////////////////////////////////////////////////////////////////////////
55 SkLinearGradient::SkLinearGradient(const SkPoint pts[2], const Descriptor& desc,
56 const SkMatrix* localMatrix)
57 : SkGradientShaderBase(desc, localMatrix)
60 pts_to_unit_matrix(pts, &fPtsToUnit);
63 SkLinearGradient::SkLinearGradient(SkReadBuffer& buffer)
65 , fStart(buffer.readPoint())
66 , fEnd(buffer.readPoint()) {
69 void SkLinearGradient::flatten(SkWriteBuffer& buffer) const {
70 this->INHERITED::flatten(buffer);
71 buffer.writePoint(fStart);
72 buffer.writePoint(fEnd);
75 size_t SkLinearGradient::contextSize() const {
76 return sizeof(LinearGradientContext);
79 SkShader::Context* SkLinearGradient::onCreateContext(const ContextRec& rec, void* storage) const {
80 return SkNEW_PLACEMENT_ARGS(storage, LinearGradientContext, (*this, rec));
83 SkLinearGradient::LinearGradientContext::LinearGradientContext(
84 const SkLinearGradient& shader, const ContextRec& rec)
85 : INHERITED(shader, rec)
87 unsigned mask = SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask;
88 if ((fDstToIndex.getType() & ~mask) == 0) {
89 // when we dither, we are (usually) not const-in-Y
90 if ((fFlags & SkShader::kHasSpan16_Flag) && !rec.fPaint->isDither()) {
91 // only claim this if we do have a 16bit mode (i.e. none of our
92 // colors have alpha), and if we are not dithering (which obviously
93 // is not const in Y).
94 fFlags |= SkShader::kConstInY16_Flag;
99 #define NO_CHECK_ITER \
101 unsigned fi = fx >> SkGradientShaderBase::kCache32Shift; \
102 SkASSERT(fi <= 0xFF); \
104 *dstC++ = cache[toggle + fi]; \
105 toggle = next_dither_toggle(toggle); \
110 typedef void (*LinearShadeProc)(TileProc proc, SkFixed dx, SkFixed fx,
111 SkPMColor* dstC, const SkPMColor* cache,
112 int toggle, int count);
114 // Linear interpolation (lerp) is unnecessary if there are no sharp
115 // discontinuities in the gradient - which must be true if there are
116 // only 2 colors - but it's cheap.
117 void shadeSpan_linear_vertical_lerp(TileProc proc, SkFixed dx, SkFixed fx,
118 SkPMColor* SK_RESTRICT dstC,
119 const SkPMColor* SK_RESTRICT cache,
120 int toggle, int count) {
121 // We're a vertical gradient, so no change in a span.
122 // If colors change sharply across the gradient, dithering is
123 // insufficient (it subsamples the color space) and we need to lerp.
124 unsigned fullIndex = proc(fx);
125 unsigned fi = fullIndex >> SkGradientShaderBase::kCache32Shift;
126 unsigned remainder = fullIndex & ((1 << SkGradientShaderBase::kCache32Shift) - 1);
128 int index0 = fi + toggle;
130 if (fi < SkGradientShaderBase::kCache32Count - 1) {
133 SkPMColor lerp = SkFastFourByteInterp(cache[index1], cache[index0], remainder);
134 index0 ^= SkGradientShaderBase::kDitherStride32;
135 index1 ^= SkGradientShaderBase::kDitherStride32;
136 SkPMColor dlerp = SkFastFourByteInterp(cache[index1], cache[index0], remainder);
137 sk_memset32_dither(dstC, lerp, dlerp, count);
140 void shadeSpan_linear_clamp(TileProc proc, SkFixed dx, SkFixed fx,
141 SkPMColor* SK_RESTRICT dstC,
142 const SkPMColor* SK_RESTRICT cache,
143 int toggle, int count) {
145 range.init(fx, dx, count, 0, SkGradientShaderBase::kCache32Count - 1);
147 if ((count = range.fCount0) > 0) {
148 sk_memset32_dither(dstC,
149 cache[toggle + range.fV0],
150 cache[next_dither_toggle(toggle) + range.fV0],
154 if ((count = range.fCount1) > 0) {
155 int unroll = count >> 3;
157 for (int i = 0; i < unroll; i++) {
158 NO_CHECK_ITER; NO_CHECK_ITER;
159 NO_CHECK_ITER; NO_CHECK_ITER;
160 NO_CHECK_ITER; NO_CHECK_ITER;
161 NO_CHECK_ITER; NO_CHECK_ITER;
163 if ((count &= 7) > 0) {
166 } while (--count != 0);
169 if ((count = range.fCount2) > 0) {
170 sk_memset32_dither(dstC,
171 cache[toggle + range.fV1],
172 cache[next_dither_toggle(toggle) + range.fV1],
177 void shadeSpan_linear_mirror(TileProc proc, SkFixed dx, SkFixed fx,
178 SkPMColor* SK_RESTRICT dstC,
179 const SkPMColor* SK_RESTRICT cache,
180 int toggle, int count) {
182 unsigned fi = mirror_8bits(fx >> 8);
183 SkASSERT(fi <= 0xFF);
185 *dstC++ = cache[toggle + fi];
186 toggle = next_dither_toggle(toggle);
187 } while (--count != 0);
190 void shadeSpan_linear_repeat(TileProc proc, SkFixed dx, SkFixed fx,
191 SkPMColor* SK_RESTRICT dstC,
192 const SkPMColor* SK_RESTRICT cache,
193 int toggle, int count) {
195 unsigned fi = repeat_8bits(fx >> 8);
196 SkASSERT(fi <= 0xFF);
198 *dstC++ = cache[toggle + fi];
199 toggle = next_dither_toggle(toggle);
200 } while (--count != 0);
205 void SkLinearGradient::LinearGradientContext::shadeSpan(int x, int y, SkPMColor* SK_RESTRICT dstC,
209 const SkLinearGradient& linearGradient = static_cast<const SkLinearGradient&>(fShader);
212 SkMatrix::MapXYProc dstProc = fDstToIndexProc;
213 TileProc proc = linearGradient.fTileProc;
214 const SkPMColor* SK_RESTRICT cache = fCache->getCache32();
215 int toggle = init_dither_toggle(x, y);
217 if (fDstToIndexClass != kPerspective_MatrixClass) {
218 dstProc(fDstToIndex, SkIntToScalar(x) + SK_ScalarHalf,
219 SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
220 SkFixed dx, fx = SkScalarToFixed(srcPt.fX);
222 if (fDstToIndexClass == kFixedStepInX_MatrixClass) {
223 SkFixed dxStorage[1];
224 (void)fDstToIndex.fixedStepInX(SkIntToScalar(y), dxStorage, NULL);
227 SkASSERT(fDstToIndexClass == kLinear_MatrixClass);
228 dx = SkScalarToFixed(fDstToIndex.getScaleX());
231 LinearShadeProc shadeProc = shadeSpan_linear_repeat;
233 shadeProc = shadeSpan_linear_vertical_lerp;
234 } else if (SkShader::kClamp_TileMode == linearGradient.fTileMode) {
235 shadeProc = shadeSpan_linear_clamp;
236 } else if (SkShader::kMirror_TileMode == linearGradient.fTileMode) {
237 shadeProc = shadeSpan_linear_mirror;
239 SkASSERT(SkShader::kRepeat_TileMode == linearGradient.fTileMode);
241 (*shadeProc)(proc, dx, fx, dstC, cache, toggle, count);
243 SkScalar dstX = SkIntToScalar(x);
244 SkScalar dstY = SkIntToScalar(y);
246 dstProc(fDstToIndex, dstX, dstY, &srcPt);
247 unsigned fi = proc(SkScalarToFixed(srcPt.fX));
248 SkASSERT(fi <= 0xFFFF);
249 *dstC++ = cache[toggle + (fi >> kCache32Shift)];
250 toggle = next_dither_toggle(toggle);
252 } while (--count != 0);
256 SkShader::BitmapType SkLinearGradient::asABitmap(SkBitmap* bitmap,
258 TileMode xy[]) const {
260 this->getGradientTableBitmap(bitmap);
263 matrix->preConcat(fPtsToUnit);
267 xy[1] = kClamp_TileMode;
269 return kLinear_BitmapType;
272 SkShader::GradientType SkLinearGradient::asAGradient(GradientInfo* info) const {
274 commonAsAGradient(info);
275 info->fPoint[0] = fStart;
276 info->fPoint[1] = fEnd;
278 return kLinear_GradientType;
281 static void dither_memset16(uint16_t dst[], uint16_t value, uint16_t other,
283 if (reinterpret_cast<uintptr_t>(dst) & 2) {
286 SkTSwap(value, other);
289 sk_memset32((uint32_t*)dst, (value << 16) | other, count >> 1);
292 dst[count - 1] = value;
296 #define NO_CHECK_ITER_16 \
298 unsigned fi = fx >> SkGradientShaderBase::kCache16Shift; \
299 SkASSERT(fi < SkGradientShaderBase::kCache16Count); \
301 *dstC++ = cache[toggle + fi]; \
302 toggle = next_dither_toggle16(toggle); \
307 typedef void (*LinearShade16Proc)(TileProc proc, SkFixed dx, SkFixed fx,
308 uint16_t* dstC, const uint16_t* cache,
309 int toggle, int count);
311 void shadeSpan16_linear_vertical(TileProc proc, SkFixed dx, SkFixed fx,
312 uint16_t* SK_RESTRICT dstC,
313 const uint16_t* SK_RESTRICT cache,
314 int toggle, int count) {
315 // we're a vertical gradient, so no change in a span
316 unsigned fi = proc(fx) >> SkGradientShaderBase::kCache16Shift;
317 SkASSERT(fi < SkGradientShaderBase::kCache16Count);
318 dither_memset16(dstC, cache[toggle + fi],
319 cache[next_dither_toggle16(toggle) + fi], count);
322 void shadeSpan16_linear_clamp(TileProc proc, SkFixed dx, SkFixed fx,
323 uint16_t* SK_RESTRICT dstC,
324 const uint16_t* SK_RESTRICT cache,
325 int toggle, int count) {
327 range.init(fx, dx, count, 0, SkGradientShaderBase::kCache32Count - 1);
329 if ((count = range.fCount0) > 0) {
330 dither_memset16(dstC,
331 cache[toggle + range.fV0],
332 cache[next_dither_toggle16(toggle) + range.fV0],
336 if ((count = range.fCount1) > 0) {
337 int unroll = count >> 3;
339 for (int i = 0; i < unroll; i++) {
340 NO_CHECK_ITER_16; NO_CHECK_ITER_16;
341 NO_CHECK_ITER_16; NO_CHECK_ITER_16;
342 NO_CHECK_ITER_16; NO_CHECK_ITER_16;
343 NO_CHECK_ITER_16; NO_CHECK_ITER_16;
345 if ((count &= 7) > 0) {
348 } while (--count != 0);
351 if ((count = range.fCount2) > 0) {
352 dither_memset16(dstC,
353 cache[toggle + range.fV1],
354 cache[next_dither_toggle16(toggle) + range.fV1],
359 void shadeSpan16_linear_mirror(TileProc proc, SkFixed dx, SkFixed fx,
360 uint16_t* SK_RESTRICT dstC,
361 const uint16_t* SK_RESTRICT cache,
362 int toggle, int count) {
364 unsigned fi = mirror_bits(fx >> SkGradientShaderBase::kCache16Shift,
365 SkGradientShaderBase::kCache16Bits);
366 SkASSERT(fi < SkGradientShaderBase::kCache16Count);
368 *dstC++ = cache[toggle + fi];
369 toggle = next_dither_toggle16(toggle);
370 } while (--count != 0);
373 void shadeSpan16_linear_repeat(TileProc proc, SkFixed dx, SkFixed fx,
374 uint16_t* SK_RESTRICT dstC,
375 const uint16_t* SK_RESTRICT cache,
376 int toggle, int count) {
378 unsigned fi = repeat_bits(fx >> SkGradientShaderBase::kCache16Shift,
379 SkGradientShaderBase::kCache16Bits);
380 SkASSERT(fi < SkGradientShaderBase::kCache16Count);
382 *dstC++ = cache[toggle + fi];
383 toggle = next_dither_toggle16(toggle);
384 } while (--count != 0);
388 static bool fixed_nearly_zero(SkFixed x) {
389 return SkAbs32(x) < (SK_Fixed1 >> 12);
392 void SkLinearGradient::LinearGradientContext::shadeSpan16(int x, int y,
393 uint16_t* SK_RESTRICT dstC, int count) {
396 const SkLinearGradient& linearGradient = static_cast<const SkLinearGradient&>(fShader);
399 SkMatrix::MapXYProc dstProc = fDstToIndexProc;
400 TileProc proc = linearGradient.fTileProc;
401 const uint16_t* SK_RESTRICT cache = fCache->getCache16();
402 int toggle = init_dither_toggle16(x, y);
404 if (fDstToIndexClass != kPerspective_MatrixClass) {
405 dstProc(fDstToIndex, SkIntToScalar(x) + SK_ScalarHalf,
406 SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
407 SkFixed dx, fx = SkScalarToFixed(srcPt.fX);
409 if (fDstToIndexClass == kFixedStepInX_MatrixClass) {
410 SkFixed dxStorage[1];
411 (void)fDstToIndex.fixedStepInX(SkIntToScalar(y), dxStorage, NULL);
414 SkASSERT(fDstToIndexClass == kLinear_MatrixClass);
415 dx = SkScalarToFixed(fDstToIndex.getScaleX());
418 LinearShade16Proc shadeProc = shadeSpan16_linear_repeat;
419 if (fixed_nearly_zero(dx)) {
420 shadeProc = shadeSpan16_linear_vertical;
421 } else if (SkShader::kClamp_TileMode == linearGradient.fTileMode) {
422 shadeProc = shadeSpan16_linear_clamp;
423 } else if (SkShader::kMirror_TileMode == linearGradient.fTileMode) {
424 shadeProc = shadeSpan16_linear_mirror;
426 SkASSERT(SkShader::kRepeat_TileMode == linearGradient.fTileMode);
428 (*shadeProc)(proc, dx, fx, dstC, cache, toggle, count);
430 SkScalar dstX = SkIntToScalar(x);
431 SkScalar dstY = SkIntToScalar(y);
433 dstProc(fDstToIndex, dstX, dstY, &srcPt);
434 unsigned fi = proc(SkScalarToFixed(srcPt.fX));
435 SkASSERT(fi <= 0xFFFF);
437 int index = fi >> kCache16Shift;
438 *dstC++ = cache[toggle + index];
439 toggle = next_dither_toggle16(toggle);
442 } while (--count != 0);
448 #include "GrTBackendEffectFactory.h"
450 /////////////////////////////////////////////////////////////////////
452 class GrGLLinearGradient : public GrGLGradientEffect {
455 GrGLLinearGradient(const GrBackendEffectFactory& factory, const GrDrawEffect&)
456 : INHERITED (factory) { }
458 virtual ~GrGLLinearGradient() { }
460 virtual void emitCode(GrGLShaderBuilder*,
463 const char* outputColor,
464 const char* inputColor,
465 const TransformedCoordsArray&,
466 const TextureSamplerArray&) SK_OVERRIDE;
468 static EffectKey GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) {
469 return GenBaseGradientKey(drawEffect);
474 typedef GrGLGradientEffect INHERITED;
477 /////////////////////////////////////////////////////////////////////
479 class GrLinearGradient : public GrGradientEffect {
482 static GrEffectRef* Create(GrContext* ctx,
483 const SkLinearGradient& shader,
484 const SkMatrix& matrix,
485 SkShader::TileMode tm) {
486 AutoEffectUnref effect(SkNEW_ARGS(GrLinearGradient, (ctx, shader, matrix, tm)));
487 return CreateEffectRef(effect);
490 virtual ~GrLinearGradient() { }
492 static const char* Name() { return "Linear Gradient"; }
493 const GrBackendEffectFactory& getFactory() const SK_OVERRIDE {
494 return GrTBackendEffectFactory<GrLinearGradient>::getInstance();
497 typedef GrGLLinearGradient GLEffect;
500 GrLinearGradient(GrContext* ctx,
501 const SkLinearGradient& shader,
502 const SkMatrix& matrix,
503 SkShader::TileMode tm)
504 : INHERITED(ctx, shader, matrix, tm) { }
505 GR_DECLARE_EFFECT_TEST;
507 typedef GrGradientEffect INHERITED;
510 /////////////////////////////////////////////////////////////////////
512 GR_DEFINE_EFFECT_TEST(GrLinearGradient);
514 GrEffectRef* GrLinearGradient::TestCreate(SkRandom* random,
516 const GrDrawTargetCaps&,
518 SkPoint points[] = {{random->nextUScalar1(), random->nextUScalar1()},
519 {random->nextUScalar1(), random->nextUScalar1()}};
521 SkColor colors[kMaxRandomGradientColors];
522 SkScalar stopsArray[kMaxRandomGradientColors];
523 SkScalar* stops = stopsArray;
524 SkShader::TileMode tm;
525 int colorCount = RandomGradientParams(random, colors, &stops, &tm);
526 SkAutoTUnref<SkShader> shader(SkGradientShader::CreateLinear(points,
527 colors, stops, colorCount,
530 return shader->asNewEffect(context, paint);
533 /////////////////////////////////////////////////////////////////////
535 void GrGLLinearGradient::emitCode(GrGLShaderBuilder* builder,
538 const char* outputColor,
539 const char* inputColor,
540 const TransformedCoordsArray& coords,
541 const TextureSamplerArray& samplers) {
542 this->emitUniforms(builder, key);
543 SkString t = builder->ensureFSCoords2D(coords, 0);
545 this->emitColor(builder, t.c_str(), key, outputColor, inputColor, samplers);
548 /////////////////////////////////////////////////////////////////////
550 GrEffectRef* SkLinearGradient::asNewEffect(GrContext* context, const SkPaint&) const {
551 SkASSERT(NULL != context);
553 if (!this->getLocalMatrix().invert(&matrix)) {
556 matrix.postConcat(fPtsToUnit);
557 return GrLinearGradient::Create(context, *this, matrix, fTileMode);
562 GrEffectRef* SkLinearGradient::asNewEffect(GrContext*, const SkPaint&) const {
563 SkDEBUGFAIL("Should not call in GPU-less build");
569 #ifndef SK_IGNORE_TO_STRING
570 void SkLinearGradient::toString(SkString* str) const {
571 str->append("SkLinearGradient (");
573 str->appendf("start: (%f, %f)", fStart.fX, fStart.fY);
574 str->appendf(" end: (%f, %f) ", fEnd.fX, fEnd.fY);
576 this->INHERITED::toString(str);