use Descriptor struct to encapsulate all the common paramaeters between our various gradient types.…

src/effects/gradients/SkGradientShader.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGradientShaderPriv.h"
 #include "SkLinearGradient.h"
 #include "SkRadialGradient.h"
 #include "SkTwoPointRadialGradient.h"
 #include "SkTwoPointConicalGradient.h"
 #include "SkSweepGradient.h"
 
-SkGradientShaderBase::SkGradientShaderBase(const SkColor colors[], const SkScalar pos[],
-             int colorCount, SkShader::TileMode mode, SkUnitMapper* mapper) {
-    SkASSERT(colorCount > 1);
+SkGradientShaderBase::SkGradientShaderBase(const Descriptor& desc) {
+    SkASSERT(desc.fCount > 1);
 
     fCacheAlpha = 256;  // init to a value that paint.getAlpha() can't return
 
-    fMapper = mapper;
-    SkSafeRef(mapper);
+    fMapper = desc.fMapper;
+    SkSafeRef(fMapper);
 
-    SkASSERT((unsigned)mode < SkShader::kTileModeCount);
+    SkASSERT((unsigned)desc.fTileMode < SkShader::kTileModeCount);
     SkASSERT(SkShader::kTileModeCount == SK_ARRAY_COUNT(gTileProcs));
-    fTileMode = mode;
-    fTileProc = gTileProcs[mode];
+    fTileMode = desc.fTileMode;
+    fTileProc = gTileProcs[desc.fTileMode];
 
     fCache16 = fCache16Storage = NULL;
     fCache32 = NULL;
     fCache32PixelRef = NULL;
 
     /*  Note: we let the caller skip the first and/or last position.
         i.e. pos[0] = 0.3, pos[1] = 0.7
         In these cases, we insert dummy entries to ensure that the final data
         will be bracketed by [0, 1].
         i.e. our_pos[0] = 0, our_pos[1] = 0.3, our_pos[2] = 0.7, our_pos[3] = 1
 
         Thus colorCount (the caller's value, and fColorCount (our value) may
         differ by up to 2. In the above example:
             colorCount = 2
             fColorCount = 4
      */
-    fColorCount = colorCount;
+    fColorCount = desc.fCount;
     // check if we need to add in dummy start and/or end position/colors
     bool dummyFirst = false;
     bool dummyLast = false;
-    if (pos) {
-        dummyFirst = pos[0] != 0;
-        dummyLast = pos[colorCount - 1] != SK_Scalar1;
+    if (desc.fPos) {
+        dummyFirst = desc.fPos[0] != 0;
+        dummyLast = desc.fPos[desc.fCount - 1] != SK_Scalar1;
         fColorCount += dummyFirst + dummyLast;
     }
 
     if (fColorCount > kColorStorageCount) {
         size_t size = sizeof(SkColor) + sizeof(Rec);
         fOrigColors = reinterpret_cast<SkColor*>(
                                         sk_malloc_throw(size * fColorCount));
     }
     else {
         fOrigColors = fStorage;
     }
 
     // Now copy over the colors, adding the dummies as needed
     {
         SkColor* origColors = fOrigColors;
         if (dummyFirst) {
-            *origColors++ = colors[0];
+            *origColors++ = desc.fColors[0];
         }
-        memcpy(origColors, colors, colorCount * sizeof(SkColor));
+        memcpy(origColors, desc.fColors, desc.fCount * sizeof(SkColor));
         if (dummyLast) {
-            origColors += colorCount;
-            *origColors = colors[colorCount - 1];
+            origColors += desc.fCount;
+            *origColors = desc.fColors[desc.fCount - 1];
         }
     }
 
     fRecs = (Rec*)(fOrigColors + fColorCount);
     if (fColorCount > 2) {
         Rec* recs = fRecs;
         recs->fPos = 0;
         //  recs->fScale = 0; // unused;
         recs += 1;
-        if (pos) {
+        if (desc.fPos) {
             /*  We need to convert the user's array of relative positions into
                 fixed-point positions and scale factors. We need these results
                 to be strictly monotonic (no two values equal or out of order).
                 Hence this complex loop that just jams a zero for the scale
                 value if it sees a segment out of order, and it assures that
                 we start at 0 and end at 1.0
             */
             SkFixed prev = 0;
             int startIndex = dummyFirst ? 0 : 1;
-            int count = colorCount + dummyLast;
+            int count = desc.fCount + dummyLast;
             for (int i = startIndex; i < count; i++) {
                 // force the last value to be 1.0
                 SkFixed curr;
-                if (i == colorCount) {  // we're really at the dummyLast
+                if (i == desc.fCount) {  // we're really at the dummyLast
                     curr = SK_Fixed1;
                 } else {
-                    curr = SkScalarToFixed(pos[i]);
+                    curr = SkScalarToFixed(desc.fPos[i]);
                 }
                 // pin curr withing range
                 if (curr < 0) {
                     curr = 0;
                 } else if (curr > SK_Fixed1) {
                     curr = SK_Fixed1;
                 }
                 recs->fPos = curr;
                 if (curr > prev) {
                     recs->fScale = (1 << 24) / (curr - prev);
                 } else {
                     recs->fScale = 0; // ignore this segment
                 }
                 // get ready for the next value
                 prev = curr;
                 recs += 1;
             }
         } else {    // assume even distribution
-            SkFixed dp = SK_Fixed1 / (colorCount - 1);
+            SkFixed dp = SK_Fixed1 / (desc.fCount - 1);
             SkFixed p = dp;
-            SkFixed scale = (colorCount - 1) << 8;  // (1 << 24) / dp
-            for (int i = 1; i < colorCount; i++) {
+            SkFixed scale = (desc.fCount - 1) << 8;  // (1 << 24) / dp
+            for (int i = 1; i < desc.fCount; i++) {
                 recs->fPos   = p;
                 recs->fScale = scale;
                 recs += 1;
                 p += dp;
             }
         }
     }
     this->initCommon();
 }
 
@@ skipping 501 matching lines @@
     SkColor tmp[2];                         \
     do {                                    \
         if (1 == count) {                   \
             tmp[0] = tmp[1] = colors[0];    \
             colors = tmp;                   \
             pos = NULL;                     \
             count = 2;                      \
         }                                   \
     } while (0)
 
+static void desc_init(SkGradientShaderBase::Descriptor* desc,
+                      const SkColor colors[],
+                      const SkScalar pos[], int colorCount,
+                      SkShader::TileMode mode,
+                      SkUnitMapper* mapper) {
+    desc->fColors   = colors;
+    desc->fPos      = pos;
+    desc->fCount    = colorCount;
+    desc->fTileMode = mode;
+    desc->fMapper   = mapper;
+}
+
 SkShader* SkGradientShader::CreateLinear(const SkPoint pts[2],
                                          const SkColor colors[],
                                          const SkScalar pos[], int colorCount,
                                          SkShader::TileMode mode,
                                          SkUnitMapper* mapper) {
     if (NULL == pts || NULL == colors || colorCount < 1) {
         return NULL;
     }
     EXPAND_1_COLOR(colorCount);
 
-    return SkNEW_ARGS(SkLinearGradient,
-                      (pts, colors, pos, colorCount, mode, mapper));
+    SkGradientShaderBase::Descriptor desc;
+    desc_init(&desc, colors, pos, colorCount, mode, mapper);
+    return SkNEW_ARGS(SkLinearGradient, (pts, desc));
 }
 
 SkShader* SkGradientShader::CreateRadial(const SkPoint& center, SkScalar radius,
                                          const SkColor colors[],
                                          const SkScalar pos[], int colorCount,
                                          SkShader::TileMode mode,
                                          SkUnitMapper* mapper) {
     if (radius <= 0 || NULL == colors || colorCount < 1) {
         return NULL;
     }
     EXPAND_1_COLOR(colorCount);
 
-    return SkNEW_ARGS(SkRadialGradient,
-                      (center, radius, colors, pos, colorCount, mode, mapper));
+    SkGradientShaderBase::Descriptor desc;
+    desc_init(&desc, colors, pos, colorCount, mode, mapper);
+    return SkNEW_ARGS(SkRadialGradient, (center, radius, desc));
 }
 
 SkShader* SkGradientShader::CreateTwoPointRadial(const SkPoint& start,
                                                  SkScalar startRadius,
                                                  const SkPoint& end,
                                                  SkScalar endRadius,
                                                  const SkColor colors[],
                                                  const SkScalar pos[],
                                                  int colorCount,
                                                  SkShader::TileMode mode,
                                                  SkUnitMapper* mapper) {
     if (startRadius < 0 || endRadius < 0 || NULL == colors || colorCount < 1) {
         return NULL;
     }
     EXPAND_1_COLOR(colorCount);
 
+    SkGradientShaderBase::Descriptor desc;
+    desc_init(&desc, colors, pos, colorCount, mode, mapper);
     return SkNEW_ARGS(SkTwoPointRadialGradient,
-                      (start, startRadius, end, endRadius, colors, pos,
-                       colorCount, mode, mapper));
+                      (start, startRadius, end, endRadius, desc));
 }
 
 SkShader* SkGradientShader::CreateTwoPointConical(const SkPoint& start,
                                                  SkScalar startRadius,
                                                  const SkPoint& end,
                                                  SkScalar endRadius,
                                                  const SkColor colors[],
                                                  const SkScalar pos[],
                                                  int colorCount,
                                                  SkShader::TileMode mode,
                                                  SkUnitMapper* mapper) {
     if (startRadius < 0 || endRadius < 0 || NULL == colors || colorCount < 1) {
         return NULL;
     }
     if (start == end && startRadius == endRadius) {
         return SkNEW(SkEmptyShader);
     }
     EXPAND_1_COLOR(colorCount);
 
+    SkGradientShaderBase::Descriptor desc;
+    desc_init(&desc, colors, pos, colorCount, mode, mapper);
     return SkNEW_ARGS(SkTwoPointConicalGradient,
-                      (start, startRadius, end, endRadius, colors, pos,
-                       colorCount, mode, mapper));
+                      (start, startRadius, end, endRadius, desc));
 }
 
 SkShader* SkGradientShader::CreateSweep(SkScalar cx, SkScalar cy,
                                         const SkColor colors[],
                                         const SkScalar pos[],
-                                        int count, SkUnitMapper* mapper) {
-    if (NULL == colors || count < 1) {
+                                        int colorCount, SkUnitMapper* mapper) {
+    if (NULL == colors || colorCount < 1) {
         return NULL;
     }
-    EXPAND_1_COLOR(count);
+    EXPAND_1_COLOR(colorCount);
 
-    return SkNEW_ARGS(SkSweepGradient, (cx, cy, colors, pos, count, mapper));
+    SkGradientShaderBase::Descriptor desc;
+    desc_init(&desc, colors, pos, colorCount, SkShader::kClamp_TileMode, mapper);
+    return SkNEW_ARGS(SkSweepGradient, (cx, cy, desc));
 }
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkGradientShader)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLinearGradient)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkRadialGradient)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSweepGradient)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkTwoPointRadialGradient)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkTwoPointConicalGradient)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
 
@@ skipping 159 matching lines @@
             (*stops)[i] = stop;
             stop = i < outColors - 1 ? stop + random->nextUScalar1() * (1.f - stop) : 1.f;
         }
     }
     *tm = static_cast<SkShader::TileMode>(random->nextULessThan(SkShader::kTileModeCount));
 
     return outColors;
 }
 
 #endif