Added tests for radial gradients with shader matrices

gm/gradient_matrix.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkRefCnt.h"
 
 #include "gm.h"
 #include "SkGradientShader.h"
 
 SkColor gColors[] = {
     SK_ColorRED, SK_ColorYELLOW
 };
 
 // these arrays define the gradient stop points
-// as x1, y1, x2, y2 per gradient to draw
+// as {{x1, y1}, {x2, y2}} per gradient to draw
 SkPoint linearPts[][2] = {
     {{0, 0}, {1, 0}},
     {{0, 0}, {0, 1}},
     {{1, 0}, {0, 0}},
     {{0, 1}, {0, 0}},
 
     {{0, 0}, {1, 1}},
     {{1, 1}, {0, 0}},
     {{1, 0}, {0, 1}},
     {{0, 1}, {1, 0}}
 };
 
+SkPoint radialPts[][2] = {
+    {{0,   0.5}, {1,   0.5}},
+    {{0.5, 0  }, {0.5, 1  }},
+    {{1,   0.5}, {0,   0.5}},
+    {{0.5, 1  }, {0.5, 0  }},
+
+    {{0, 0}, {1, 1}},
+    {{1, 1}, {0, 0}},
+    {{1, 0}, {0, 1}},
+    {{0, 1}, {1, 0}}
+};
+
+
 const SkScalar TESTGRID_X = 200;    // pixels allocated to each image in x dimension
 const SkScalar TESTGRID_Y = 200;    // pixels allocated to each image in y dimension
 
 const int IMAGES_X = 4;             // number of images per row
 
 static SkShader* make_linear_gradient(SkPoint pts[2]) {
     return SkGradientShader::CreateLinear(pts, gColors, NULL, SK_ARRAY_COUNT(gColors),
                                           SkShader::kClamp_TileMode, NULL);
 }
 
+static SkShader* make_radial_gradient(SkPoint pts[2]) {
+    SkPoint center;
+    center.set(SkScalarAve(pts[0].fX, pts[1].fX),
+               SkScalarAve(pts[0].fY, pts[1].fY));
+    float radius = (center - pts[0]).length();
+    return SkGradientShader::CreateRadial(center, radius, gColors, NULL, SK_ARRAY_COUNT(gColors),
+                                          SkShader::kClamp_TileMode, NULL);
+}
+
 void draw_gradients(SkCanvas* canvas, SkShader* (*makeShader)(SkPoint[2]),
                     SkPoint ptsArray[][2], int numImages) {
     // common test parameters
     SkMatrix shaderMat = SkMatrix();
     shaderMat.setAll(138, 0,   43,
                      0,   106, 61,
                      0,   0,   1);
     SkRect rectGrad = { 43, 61, 181, 167 }; // some nice prime numbers
 
-    canvas->save();

[vandebo (ex-Chrome), 2013/06/12 16:28:03]

These can stay here.

[ducky, 2013/06/12 18:24:06]

Done.

     for (int i = 0; i < numImages; i++) {
         // advance line if necessary
         if (i % IMAGES_X == 0 && i != 0) {
             canvas->restore();
             canvas->translate(0, TESTGRID_Y);
             canvas->save();
         }
 
         // unpack points, setup shader, draw
         SkAutoTUnref<SkShader> shader(makeShader(*ptsArray));
         shader->setLocalMatrix(shaderMat);
 
         SkPaint paint;
         paint.setShader(shader);
         canvas->drawRect(rectGrad, paint);
 
         // advance to next position
         canvas->translate(TESTGRID_X, 0);
         ptsArray++;
     }
-    canvas->restore();
 }
 
 namespace skiagm {
 
 class GradientMatrixGM : public GM {
 public:
     GradientMatrixGM() {
         this->setBGColor(0xFFDDDDDD);
     }
 
 protected:
     SkString onShortName() {
         return SkString("gradient_matrix");
     }
 
     virtual SkISize onISize() {
         return SkISize::Make(800, 800);
     }
 
     virtual void onDraw(SkCanvas* canvas) {
+        canvas->save();
+
         draw_gradients(canvas, &make_linear_gradient,
                       linearPts, SK_ARRAY_COUNT(linearPts));
+
+        canvas->restore();
+        canvas->translate(0, TESTGRID_Y);
+        canvas->save();
+
+        draw_gradients(canvas, &make_radial_gradient,
+                      radialPts, SK_ARRAY_COUNT(radialPts));
+
+        canvas->restore();
     }
 
 private:
     typedef GM INHERITED;
 };
 
 static GM* MyFactory(void*) { return new GradientMatrixGM; }
 static GMRegistry reg(MyFactory);
 }