Added a high-color (50 colors) gradient for each gradient type.

bench/GradientBench.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkBenchmark.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkColorPriv.h"
 #include "SkGradientShader.h"
 #include "SkPaint.h"
 #include "SkShader.h"
 #include "SkString.h"
 #include "SkUnitMapper.h"
 
 struct GradData {
     int             fCount;
     const SkColor*  fColors;
     const SkScalar* fPos;
 };
 
 static const SkColor gColors[] = {
     SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK,
+    SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK,
+    SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK,
+    SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK,
+    SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK,
+    SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK,
+    SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK,
+    SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK,
+    SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK,
+    SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK, // 10 lines, 50 colors
 };
 
 static const GradData gGradData[] = {
     { 2, gColors, NULL },
+    { 50, gColors, NULL }, // many color gradient
 };
 
 /// Ignores scale
 static SkShader* MakeLinear(const SkPoint pts[2], const GradData& data,
                             SkShader::TileMode tm, SkUnitMapper* mapper,
                             float scale) {
     return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos,
                                           data.fCount, tm, mapper);
 }
 
@@ skipping 70 matching lines @@
     kSweep_GradType,
     kRadial2_GradType,
     kConical_GradType
 };
 
 enum GeomType {
     kRect_GeomType,
     kOval_GeomType
 };
 
+enum ColorType {
+    kColors_2,
+    kColors_50
+};
+
 static const char* tilemodename(SkShader::TileMode tm) {
     switch (tm) {
         case SkShader::kClamp_TileMode:
             return "clamp";
         case SkShader::kRepeat_TileMode:
             return "repeat";
         case SkShader::kMirror_TileMode:
             return "mirror";
         default:
             SkASSERT(!"unknown tilemode");
@@ skipping 19 matching lines @@
     SkString fName;
     SkShader* fShader;
     int      fCount;
     enum {
         W   = 400,
         H   = 400,
         N   = 1
     };
 public:
     GradientBench(void* param, GradType gradType,
+                  ColorType colors = kColors_2,
                   SkShader::TileMode tm = SkShader::kClamp_TileMode,
                   GeomType geomType = kRect_GeomType,
-                  float scale = 1.0f)
+                  float scale = 1.0f
+        )
         : INHERITED(param) {
         fName.printf("gradient_%s_%s", gGrads[gradType].fName,
                      tilemodename(tm));
         if (geomType != kRect_GeomType) {
             fName.append("_");
             fName.append(geomtypename(geomType));
         }
 
+        if (colors == kColors_50) {
+            fName.append("_hicolor");
+        }
+
         const SkPoint pts[2] = {
             { 0, 0 },
             { SkIntToScalar(W), SkIntToScalar(H) }
         };
 
         fCount = SkBENCHLOOP(N * gGrads[gradType].fRepeat);
-        fShader = gGrads[gradType].fMaker(pts, gGradData[0], tm, NULL, scale);
+        fShader = gGrads[gradType].fMaker(pts, gGradData[colors], tm, NULL, scale);
         fGeomType = geomType;
     }
 
     virtual ~GradientBench() {
         fShader->unref();
     }
 
 protected:
     virtual const char* onGetName() {
         return fName.c_str();
@@ skipping 62 matching lines @@
             paint.setShader(s)->unref();
             canvas->drawRect(r, paint);
         }
     }
 
 private:
     typedef SkBenchmark INHERITED;
 };
 
 DEF_BENCH( return new GradientBench(p, kLinear_GradType); )
-DEF_BENCH( return new GradientBench(p, kLinear_GradType, SkShader::kMirror_TileMode); )
+DEF_BENCH( return new GradientBench(p, kLinear_GradType, kColors_50); )
+DEF_BENCH( return new GradientBench(p, kLinear_GradType, kColors_2, SkShader::kMirror_TileMode); )
 
 // Draw a radial gradient of radius 1/2 on a rectangle; half the lines should
 // be completely pinned, the other half should pe partially pinned
-DEF_BENCH( return new GradientBench(p, kRadial_GradType, SkShader::kClamp_TileMode, kRect_GeomType, 0.5f); )
+DEF_BENCH( return new GradientBench(p, kRadial_GradType, kColors_2, SkShader::kClamp_TileMode, kRect_GeomType, 0.5f); )
 
 // Draw a radial gradient on a circle of equal size; all the lines should
 // hit the unpinned fast path (so long as GradientBench.W == H)
-DEF_BENCH( return new GradientBench(p, kRadial_GradType, SkShader::kClamp_TileMode, kOval_GeomType); )
+DEF_BENCH( return new GradientBench(p, kRadial_GradType, kColors_2, SkShader::kClamp_TileMode, kOval_GeomType); )
 
-DEF_BENCH( return new GradientBench(p, kRadial_GradType, SkShader::kMirror_TileMode); )
+DEF_BENCH( return new GradientBench(p, kRadial_GradType, kColors_2, SkShader::kMirror_TileMode); )
 DEF_BENCH( return new GradientBench(p, kSweep_GradType); )
+DEF_BENCH( return new GradientBench(p, kSweep_GradType, kColors_50); )

[bsalomon, 2013/07/09 21:29:45]

Maybe just pass the GradData instance that you want to use directly and skip the
enum?

[dierk, 2013/07/10 15:01:26]

I used enums to match the style of the existing code. If I passed the GradData
directly instead what would be the best way of appending something (in this case
"_hicolor") to the name string to distinguish the new tests (in a readable
fashion)? 

On 2013/07/09 21:29:45, bsalomon wrote:

[bsalomon, 2013/07/10 15:21:21]

You could have:

struct GradData {
    int             fCount;
    const SkColor*  fColors;
    const SkScalar* fPos;
    const char*     fName;
}

and set fName to "" and "hicolor".

I don't feel very strongly about this but it seems a little easier to understand
to me.


On 2013/07/10 15:01:26, dierk wrote:

[dierk, 2013/07/10 15:41:12]

Done.

 DEF_BENCH( return new GradientBench(p, kRadial2_GradType); )
-DEF_BENCH( return new GradientBench(p, kRadial2_GradType, SkShader::kMirror_TileMode); )
+DEF_BENCH( return new GradientBench(p, kRadial2_GradType, kColors_50); )
+DEF_BENCH( return new GradientBench(p, kRadial2_GradType, kColors_2, SkShader::kMirror_TileMode); )
 DEF_BENCH( return new GradientBench(p, kConical_GradType); )
+DEF_BENCH( return new GradientBench(p, kConical_GradType, kColors_50); )
 
 DEF_BENCH( return new Gradient2Bench(p, false); )
 DEF_BENCH( return new Gradient2Bench(p, true); )