diff options
Diffstat (limited to 'src/effects/gradients/Sk4fGradientBase.cpp')
| -rw-r--r-- | src/effects/gradients/Sk4fGradientBase.cpp | 451 |
1 files changed, 451 insertions, 0 deletions
diff --git a/src/effects/gradients/Sk4fGradientBase.cpp b/src/effects/gradients/Sk4fGradientBase.cpp new file mode 100644 index 0000000000..e20f5f4702 --- /dev/null +++ b/src/effects/gradients/Sk4fGradientBase.cpp @@ -0,0 +1,451 @@ +/* + * Copyright 2016 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#include "Sk4fGradientBase.h" + +#include <functional> + +namespace { + +Sk4f pack_color(SkColor c, bool premul, const Sk4f& component_scale) { + const SkColor4f c4f = SkColor4f::FromColor(c); + const Sk4f pm4f = premul + ? c4f.premul().to4f() + : Sk4f{c4f.fR, c4f.fG, c4f.fB, c4f.fA}; + + return pm4f * component_scale; +} + +class IntervalIterator { +public: + IntervalIterator(const SkColor* colors, const SkScalar* pos, int count, bool reverse) + : fColors(colors) + , fPos(pos) + , fCount(count) + , fFirstPos(reverse ? SK_Scalar1 : 0) + , fBegin(reverse ? count - 1 : 0) + , fAdvance(reverse ? -1 : 1) { + SkASSERT(colors); + SkASSERT(count > 0); + } + + void iterate(std::function<void(SkColor, SkColor, SkScalar, SkScalar)> func) const { + if (!fPos) { + this->iterateImplicitPos(func); + return; + } + + const int end = fBegin + fAdvance * (fCount - 1); + const SkScalar lastPos = 1 - fFirstPos; + int prev = fBegin; + SkScalar prevPos = fFirstPos; + + do { + const int curr = prev + fAdvance; + SkASSERT(curr >= 0 && curr < fCount); + + // TODO: this sanitization should be done in SkGradientShaderBase + const SkScalar currPos = (fAdvance > 0) + ? SkTPin(fPos[curr], prevPos, lastPos) + : SkTPin(fPos[curr], lastPos, prevPos); + + if (currPos != prevPos) { + SkASSERT((currPos - prevPos > 0) == (fAdvance > 0)); + func(fColors[prev], fColors[curr], prevPos, currPos); + } + + prev = curr; + prevPos = currPos; + } while (prev != end); + } + +private: + void iterateImplicitPos(std::function<void(SkColor, SkColor, SkScalar, SkScalar)> func) const { + // When clients don't provide explicit color stop positions (fPos == nullptr), + // the color stops are distributed evenly across the unit interval + // (implicit positioning). + const SkScalar dt = fAdvance * SK_Scalar1 / (fCount - 1); + const int end = fBegin + fAdvance * (fCount - 2); + int prev = fBegin; + SkScalar prevPos = fFirstPos; + + while (prev != end) { + const int curr = prev + fAdvance; + SkASSERT(curr >= 0 && curr < fCount); + + const SkScalar currPos = prevPos + dt; + func(fColors[prev], fColors[curr], prevPos, currPos); + prev = curr; + prevPos = currPos; + } + + // emit the last interval with a pinned end position, to avoid precision issues + func(fColors[prev], fColors[prev + fAdvance], prevPos, 1 - fFirstPos); + } + + const SkColor* fColors; + const SkScalar* fPos; + const int fCount; + const SkScalar fFirstPos; + const int fBegin; + const int fAdvance; +}; + +void addMirrorIntervals(const SkColor colors[], + const SkScalar pos[], int count, + const Sk4f& componentScale, + bool premulColors, bool reverse, + Sk4fGradientIntervalBuffer::BufferType* buffer) { + const IntervalIterator iter(colors, pos, count, reverse); + iter.iterate([&] (SkColor c0, SkColor c1, SkScalar t0, SkScalar t1) { + SkASSERT(buffer->empty() || buffer->back().fT1 == 2 - t0); + + const auto mirror_t0 = 2 - t0; + const auto mirror_t1 = 2 - t1; + // mirror_p1 & mirror_p1 may collapse for very small values - recheck to avoid + // triggering Interval asserts. + if (mirror_t0 != mirror_t1) { + buffer->emplace_back(pack_color(c0, premulColors, componentScale), mirror_t0, + pack_color(c1, premulColors, componentScale), mirror_t1); + } + }); +} + +} // anonymous namespace + +Sk4fGradientInterval::Sk4fGradientInterval(const Sk4f& c0, SkScalar t0, + const Sk4f& c1, SkScalar t1) + : fT0(t0) + , fT1(t1) { + SkASSERT(t0 != t1); + // Either p0 or p1 can be (-)inf for synthetic clamp edge intervals. + SkASSERT(SkScalarIsFinite(t0) || SkScalarIsFinite(t1)); + + const auto dt = t1 - t0; + + // Clamp edge intervals are always zero-ramp. + SkASSERT(SkScalarIsFinite(dt) || (c0 == c1).allTrue()); + SkASSERT(SkScalarIsFinite(t0) || (c0 == c1).allTrue()); + const Sk4f dc = SkScalarIsFinite(dt) ? (c1 - c0) / dt : 0; + const Sk4f bias = c0 - (SkScalarIsFinite(t0) ? t0 * dc : 0); + + bias.store(&fCb.fVec); + dc.store(&fCg.fVec); +} + +void Sk4fGradientIntervalBuffer::init(const SkColor colors[], const SkScalar pos[], int count, + SkShader::TileMode tileMode, bool premulColors, + SkScalar alpha, bool reverse) { + // The main job here is to build a specialized interval list: a different + // representation of the color stops data, optimized for efficient scan line + // access during shading. + // + // [{P0,C0} , {P1,C1}) [{P1,C2} , {P2,c3}) ... [{Pn,C2n} , {Pn+1,C2n+1}) + // + // The list may be inverted when requested (such that e.g. points are sorted + // in increasing x order when dx < 0). + // + // Note: the current representation duplicates pos data; we could refactor to + // avoid this if interval storage size becomes a concern. + // + // Aside from reordering, we also perform two more pre-processing steps at + // this stage: + // + // 1) scale the color components depending on paint alpha and the requested + // interpolation space (note: the interval color storage is SkPM4f, but + // that doesn't necessarily mean the colors are premultiplied; that + // property is tracked in fColorsArePremul) + // + // 2) inject synthetic intervals to support tiling. + // + // * for kRepeat, no extra intervals are needed - the iterator just + // wraps around at the end: + // + // ->[P0,P1)->..[Pn-1,Pn)-> + // + // * for kClamp, we add two "infinite" intervals before/after: + // + // [-/+inf , P0)->[P0 , P1)->..[Pn-1 , Pn)->[Pn , +/-inf) + // + // (the iterator should never run off the end in this mode) + // + // * for kMirror, we extend the range to [0..2] and add a flipped + // interval series - then the iterator operates just as in the + // kRepeat case: + // + // ->[P0,P1)->..[Pn-1,Pn)->[2 - Pn,2 - Pn-1)->..[2 - P1,2 - P0)-> + // + // TODO: investigate collapsing intervals << 1px. + + SkASSERT(count > 0); + SkASSERT(colors); + + fIntervals.reset(); + + const Sk4f componentScale = premulColors + ? Sk4f(alpha) + : Sk4f(1.0f, 1.0f, 1.0f, alpha); + const int first_index = reverse ? count - 1 : 0; + const int last_index = count - 1 - first_index; + const SkScalar first_pos = reverse ? SK_Scalar1 : 0; + const SkScalar last_pos = SK_Scalar1 - first_pos; + + if (tileMode == SkShader::kClamp_TileMode) { + // synthetic edge interval: -/+inf .. P0 + const Sk4f clamp_color = pack_color(colors[first_index], + premulColors, componentScale); + const SkScalar clamp_pos = reverse ? SK_ScalarInfinity : SK_ScalarNegativeInfinity; + fIntervals.emplace_back(clamp_color, clamp_pos, + clamp_color, first_pos); + } else if (tileMode == SkShader::kMirror_TileMode && reverse) { + // synthetic mirror intervals injected before main intervals: (2 .. 1] + addMirrorIntervals(colors, pos, count, componentScale, premulColors, false, &fIntervals); + } + + const IntervalIterator iter(colors, pos, count, reverse); + iter.iterate([&] (SkColor c0, SkColor c1, SkScalar t0, SkScalar t1) { + SkASSERT(fIntervals.empty() || fIntervals.back().fT1 == t0); + + fIntervals.emplace_back(pack_color(c0, premulColors, componentScale), t0, + pack_color(c1, premulColors, componentScale), t1); + }); + + if (tileMode == SkShader::kClamp_TileMode) { + // synthetic edge interval: Pn .. +/-inf + const Sk4f clamp_color = pack_color(colors[last_index], premulColors, componentScale); + const SkScalar clamp_pos = reverse ? SK_ScalarNegativeInfinity : SK_ScalarInfinity; + fIntervals.emplace_back(clamp_color, last_pos, + clamp_color, clamp_pos); + } else if (tileMode == SkShader::kMirror_TileMode && !reverse) { + // synthetic mirror intervals injected after main intervals: [1 .. 2) + addMirrorIntervals(colors, pos, count, componentScale, premulColors, true, &fIntervals); + } +} + +const Sk4fGradientInterval* Sk4fGradientIntervalBuffer::find(SkScalar t) const { + // Binary search. + const auto* i0 = fIntervals.begin(); + const auto* i1 = fIntervals.end() - 1; + + while (i0 != i1) { + SkASSERT(i0 < i1); + SkASSERT(t >= i0->fT0 && t <= i1->fT1); + + const auto* i = i0 + ((i1 - i0) >> 1); + + if (t > i->fT1) { + i0 = i + 1; + } else { + i1 = i; + } + } + + SkASSERT(i0->contains(t)); + return i0; +} + +const Sk4fGradientInterval* Sk4fGradientIntervalBuffer::findNext( + SkScalar t, const Sk4fGradientInterval* prev, bool increasing) const { + + SkASSERT(!prev->contains(t)); + SkASSERT(prev >= fIntervals.begin() && prev < fIntervals.end()); + SkASSERT(t >= fIntervals.front().fT0 && t <= fIntervals.back().fT1); + + const auto* i = prev; + + // Use the |increasing| signal to figure which direction we should search for + // the next interval, then perform a linear search. + if (increasing) { + do { + i += 1; + if (i >= fIntervals.end()) { + i = fIntervals.begin(); + } + } while (!i->contains(t)); + } else { + do { + i -= 1; + if (i < fIntervals.begin()) { + i = fIntervals.end() - 1; + } + } while (!i->contains(t)); + } + + return i; +} + +SkGradientShaderBase:: +GradientShaderBase4fContext::GradientShaderBase4fContext(const SkGradientShaderBase& shader, + const ContextRec& rec) + : INHERITED(shader, rec) + , fFlags(this->INHERITED::getFlags()) +#ifdef SK_SUPPORT_LEGACY_GRADIENT_DITHERING + , fDither(true) +#else + , fDither(rec.fPaint->isDither()) +#endif +{ + const SkMatrix& inverse = this->getTotalInverse(); + fDstToPos.setConcat(shader.fPtsToUnit, inverse); + fDstToPosProc = fDstToPos.getMapXYProc(); + fDstToPosClass = static_cast<uint8_t>(INHERITED::ComputeMatrixClass(fDstToPos)); + + if (shader.fColorsAreOpaque && this->getPaintAlpha() == SK_AlphaOPAQUE) { + fFlags |= kOpaqueAlpha_Flag; + } + + fColorsArePremul = + (shader.fGradFlags & SkGradientShader::kInterpolateColorsInPremul_Flag) + || shader.fColorsAreOpaque; +} + +bool SkGradientShaderBase:: +GradientShaderBase4fContext::isValid() const { + return fDstToPos.isFinite(); +} + +void SkGradientShaderBase:: +GradientShaderBase4fContext::shadeSpan(int x, int y, SkPMColor dst[], int count) { + if (fColorsArePremul) { + this->shadePremulSpan<DstType::L32, ApplyPremul::False>(x, y, dst, count); + } else { + this->shadePremulSpan<DstType::L32, ApplyPremul::True>(x, y, dst, count); + } +} + +void SkGradientShaderBase:: +GradientShaderBase4fContext::shadeSpan4f(int x, int y, SkPM4f dst[], int count) { + if (fColorsArePremul) { + this->shadePremulSpan<DstType::F32, ApplyPremul::False>(x, y, dst, count); + } else { + this->shadePremulSpan<DstType::F32, ApplyPremul::True>(x, y, dst, count); + } +} + +template<DstType dstType, ApplyPremul premul> +void SkGradientShaderBase:: +GradientShaderBase4fContext::shadePremulSpan(int x, int y, + typename DstTraits<dstType, premul>::Type dst[], + int count) const { + const SkGradientShaderBase& shader = + static_cast<const SkGradientShaderBase&>(fShader); + + switch (shader.fTileMode) { + case kClamp_TileMode: + this->shadeSpanInternal<dstType, + premul, + kClamp_TileMode>(x, y, dst, count); + break; + case kRepeat_TileMode: + this->shadeSpanInternal<dstType, + premul, + kRepeat_TileMode>(x, y, dst, count); + break; + case kMirror_TileMode: + this->shadeSpanInternal<dstType, + premul, + kMirror_TileMode>(x, y, dst, count); + break; + } +} + +template<DstType dstType, ApplyPremul premul, SkShader::TileMode tileMode> +void SkGradientShaderBase:: +GradientShaderBase4fContext::shadeSpanInternal(int x, int y, + typename DstTraits<dstType, premul>::Type dst[], + int count) const { + static const int kBufSize = 128; + SkScalar ts[kBufSize]; + TSampler<dstType, premul, tileMode> sampler(*this); + + SkASSERT(count > 0); + do { + const int n = SkTMin(kBufSize, count); + this->mapTs(x, y, ts, n); + for (int i = 0; i < n; ++i) { + const Sk4f c = sampler.sample(ts[i]); + DstTraits<dstType, premul>::store(c, dst++); + } + x += n; + count -= n; + } while (count > 0); +} + +template<DstType dstType, ApplyPremul premul, SkShader::TileMode tileMode> +class SkGradientShaderBase::GradientShaderBase4fContext::TSampler { +public: + TSampler(const GradientShaderBase4fContext& ctx) + : fCtx(ctx) + , fInterval(nullptr) { + switch (tileMode) { + case kClamp_TileMode: + fLargestIntervalValue = SK_ScalarInfinity; + break; + case kRepeat_TileMode: + fLargestIntervalValue = nextafterf(1, 0); + break; + case kMirror_TileMode: + fLargestIntervalValue = nextafterf(2.0f, 0); + break; + } + } + + Sk4f sample(SkScalar t) { + const auto tiled_t = tileProc(t); + + if (!fInterval) { + // Very first sample => locate the initial interval. + // TODO: maybe do this in ctor to remove a branch? + fInterval = fCtx.fIntervals.find(tiled_t); + this->loadIntervalData(fInterval); + } else if (!fInterval->contains(tiled_t)) { + fInterval = fCtx.fIntervals.findNext(tiled_t, fInterval, t >= fPrevT); + this->loadIntervalData(fInterval); + } + + fPrevT = t; + return lerp(tiled_t); + } + +private: + SkScalar tileProc(SkScalar t) const { + switch (tileMode) { + case kClamp_TileMode: + // synthetic clamp-mode edge intervals allow for a free-floating t: + // [-inf..0)[0..1)[1..+inf) + return t; + case kRepeat_TileMode: + // t % 1 (intervals range: [0..1)) + // Due to the extra arithmetic, we must clamp to ensure the value remains less than 1. + return SkTMin(t - SkScalarFloorToScalar(t), fLargestIntervalValue); + case kMirror_TileMode: + // t % 2 (synthetic mirror intervals expand the range to [0..2) + // Due to the extra arithmetic, we must clamp to ensure the value remains less than 2. + return SkTMin(t - SkScalarFloorToScalar(t / 2) * 2, fLargestIntervalValue); + } + + SK_ABORT("Unhandled tile mode."); + return 0; + } + + Sk4f lerp(SkScalar t) { + SkASSERT(fInterval->contains(t)); + return fCb + fCg * t; + } + + void loadIntervalData(const Sk4fGradientInterval* i) { + fCb = DstTraits<dstType, premul>::load(i->fCb); + fCg = DstTraits<dstType, premul>::load(i->fCg); + } + + const GradientShaderBase4fContext& fCtx; + const Sk4fGradientInterval* fInterval; + SkScalar fPrevT; + SkScalar fLargestIntervalValue; + Sk4f fCb; + Sk4f fCg; +}; |