Generic 4f gradient T sampler fallback

src/effects/gradients/Sk4fGradientBase.h

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef Sk4fGradientBase_DEFINED
 #define Sk4fGradientBase_DEFINED
 
 #include "SkColor.h"
 #include "SkGradientShaderPriv.h"
 #include "SkMatrix.h"
 #include "SkNx.h"
 #include "SkPM4f.h"
 #include "SkShader.h"
 #include "SkTArray.h"
 
 class SkGradientShaderBase::
 GradientShaderBase4fContext : public SkShader::Context {
 public:
     GradientShaderBase4fContext(const SkGradientShaderBase&,
                                 const ContextRec&);
 
     uint32_t getFlags() const override { return fFlags; }
 
+    void shadeSpan(int x, int y, SkPMColor dst[], int count) override;
+    void shadeSpan4f(int x, int y, SkPM4f dst[], int count) override;
+
 protected:
     struct Interval {
         Interval(SkPMColor c0, SkScalar p0,
                  SkPMColor c1, SkScalar p1,
                  const Sk4f& componentScale);
 
         bool isZeroRamp() const { return fZeroRamp; }
 
-        // true when fx is in [p0,p1)
-        bool contains(SkScalar fx) const;
-
         SkPM4f   fC0, fDc;
         SkScalar fP0, fP1;
         bool     fZeroRamp;
     };
 
+    virtual void mapTs(int x, int y, SkScalar ts[], int count) const = 0;
+
+    void buildIntervals(const SkGradientShaderBase&, const ContextRec&, bool reverse);
+
     SkSTArray<8, Interval, true> fIntervals;
     SkMatrix                     fDstToPos;
     SkMatrix::MapXYProc          fDstToPosProc;
     uint8_t                      fDstToPosClass;
     uint8_t                      fFlags;
     bool                         fDither;
     bool                         fColorsArePremul;
 
 private:
     using INHERITED = SkShader::Context;
+
+    void addMirrorIntervals(const SkGradientShaderBase&,
+                            const Sk4f& componentScale, bool reverse);
+
+    template<typename DstType, SkShader::TileMode tileMode>
+    class TSampler;
+
+    template <typename DstType, bool premul>

[reed1, 2016/03/10 17:49:37]

does this mean you will apply alpha to the colors as part of your processing, or
that your inputs have already had that done, and you will do nothing in your
processing?

[f(malita), 2016/03/10 18:46:10]

The former: interval colors are in unpremul format, so we have to apply alpha as
part of processing.  Renamed to 'do_premul' to hopefully clarify.

+    void shadePremulSpan(int x, int y, DstType[], int count) const;
+
+    template <typename DstType, bool premul, SkShader::TileMode tileMode>
+    void shadeSpanInternal(int x, int y, DstType[], int count) const;
 };
 
 #endif // Sk4fGradientBase_DEFINED