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 "gm.h"
 #include "SkGradientShader.h"
 
 static const SkColor gColors[] = {
     SK_ColorRED, SK_ColorYELLOW
 };
 static const SkScalar gPosAll[] = {
     0, SK_Scalar1
 };
 
-static SkShader* SimpleGradient(const SkPoint pts[2]) {
+static SkShader* SimpleLinearGradient(const SkPoint pts[2]) {

[vandebo (ex-Chrome), 2013/06/11 05:15:25]

MakeLinearGradient

[ducky, 2013/06/11 19:51:01]

Done.

     return SkGradientShader::CreateLinear(pts, gColors, gPosAll,
                                           2, SkShader::kClamp_TileMode, NULL);
 }
 
+static SkShader* SimpleRadialGradient(const SkPoint pts[2], const GradData& data,

[vandebo (ex-Chrome), 2013/06/11 05:15:25]

MakeRadialGRadient

[ducky, 2013/06/11 19:51:01]

Done.

+                            SkShader::TileMode tm, SkUnitMapper* mapper) {

[vandebo (ex-Chrome), 2013/06/11 05:15:25]

line up previous line (first const).

[ducky, 2013/06/11 19:51:01]

Done.

+    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,

[reed1, 2013/06/11 13:54:16]

Another common way to pass these...

..., gColors, NULL, SK_ARRAY_COUNT(gColors), ...

If you're going to pass [ 0, 1 ] for pos, its common to pass null instead. NULL
means "evenly spread out the positions of all the colors".

SK_ARRAY_COUNT macro ensures that if you later add colors, the count will always
be correct.

[ducky, 2013/06/11 19:51:01]

Done.

+                                          gPosAll, 2, SkShader::kClamp_TileMode, NULL);

[vandebo (ex-Chrome), 2013/06/11 05:15:25]

nit: gPosAll, 2, on previous line.

[ducky, 2013/06/11 19:51:01]

Done.

+}
+
 namespace skiagm {
 
 class GradientMatrixGM : public GM {
 public:
   GradientMatrixGM() {
         this->setBGColor(0xFFDDDDDD);
     }
 
 protected:
     SkString onShortName() {
         return SkString("gradient_matrix");
     }
 
-    virtual SkISize onISize() { return make_isize(800, 400); }
+    virtual SkISize onISize() { return make_isize(800, 800); }

[reed1, 2013/06/11 13:54:16]

make_isize() is a hold-over from before we had good Make methods. Try

SkISize::Make()

[ducky, 2013/06/11 19:51:01]

Done.

 
     virtual void onDraw(SkCanvas* canvas) {

[vandebo (ex-Chrome), 2013/06/11 05:15:25]

This method is rather repetitive.  Can you pack the test values into an array
and use or a loop or something along those lines?

[ducky, 2013/06/11 19:51:01]

Done.

         const int TESTGRID_X = 200;
         const int TESTGRID_Y = 200;
 
         canvas->save();
 
-        testGrad(canvas, 0, 0, 1, 0);
+        drawLinearGradient(canvas, 0, 0, 1, 0);
         canvas->translate(TESTGRID_X, 0);
-        testGrad(canvas, 0, 0, 0, 1);
+        drawLinearGradient(canvas, 0, 0, 0, 1);
         canvas->translate(TESTGRID_X, 0);
-        testGrad(canvas, 1, 0, 0, 0);
+        drawLinearGradient(canvas, 1, 0, 0, 0);
         canvas->translate(TESTGRID_X, 0);
-        testGrad(canvas, 0, 1, 0, 0);
+        drawLinearGradient(canvas, 0, 1, 0, 0);
 
         canvas->restore();
         canvas->translate(0, TESTGRID_Y);
         canvas->save();
 
-        testGrad(canvas, 0, 0, 1, 1);
+        drawLinearGradient(canvas, 0, 0, 1, 1);
         canvas->translate(TESTGRID_X, 0);
-        testGrad(canvas, 1, 1, 0, 0);
+        drawLinearGradient(canvas, 1, 1, 0, 0);
         canvas->translate(TESTGRID_X, 0);
-        testGrad(canvas, 1, 0, 0, 1);
+        drawLinearGradient(canvas, 1, 0, 0, 1);
         canvas->translate(TESTGRID_X, 0);
-        testGrad(canvas, 0, 1, 1, 0);
+        drawLinearGradient(canvas, 0, 1, 1, 0);
+
+        canvas->restore();
+        canvas->translate(0, TESTGRID_Y);
+        canvas->save();
+
+        drawRadialGradient(canvas, 0, 0.5, 1, 0.5);
+        canvas->translate(TESTGRID_X, 0);
+        drawRadialGradient(canvas, 0.5, 0, 0.5, 1);
+        canvas->translate(TESTGRID_X, 0);
+        drawRadialGradient(canvas, 1, 0.5, 0, 0.5);
+        canvas->translate(TESTGRID_X, 0);
+        drawRadialGradient(canvas, 0.5, 1, 0.5, 0);
+
+        canvas->restore();
+        canvas->translate(0, TESTGRID_Y);
+        canvas->save();
+
+        drawRadialGradient(canvas, 0, 0, 1, 1);
+        canvas->translate(TESTGRID_X, 0);
+        drawRadialGradient(canvas, 1, 1, 0, 0);
+        canvas->translate(TESTGRID_X, 0);
+        drawRadialGradient(canvas, 1, 0, 0, 1);
+        canvas->translate(TESTGRID_X, 0);
+        drawRadialGradient(canvas, 0, 1, 1, 0);
     }
 
-    virtual void simpleGrad(SkCanvas* canvas) {
+    virtual void simpleGradient(SkCanvas* canvas) {
         SkPoint pts[2] = {
             { 100, 0 },
             { 0, 0 }
         };
         SkMatrix shaderMat = SkMatrix();
         shaderMat.setAll(1, 0, 0,
                          0, 1, 0,
                          0, 0, 1);
         SkRect rectGrad = { 0, 0, 100, 100 }; // very simple numbers
 
-        SkShader* shader = SimpleGradient(pts);
+        SkShader* shader = SimpleLinearGradient(pts);
         shader->setLocalMatrix(shaderMat);
         SkPaint paint;
         paint.setAntiAlias(true);
+        paint.setShader(shader);
+        canvas->drawRect(rectGrad, paint);
+        shader->unref();
+    }
+
+    virtual void drawRadialGradient(SkCanvas* canvas, float x1, float y1, float x2, float y2) {

[vandebo (ex-Chrome), 2013/06/11 05:15:25]

This method is basically a duplicate of the next one.  Pass in SkShader instead
of pts.

[ducky, 2013/06/11 19:51:01]

Done.

+        SkPoint pts[2] = {
+            { x1, y1 },
+            { x2, y2 }
+        };
+        SkMatrix shaderMat = SkMatrix();
+        shaderMat.setAll(138, 0, 43,
+                         0, 106, 61,
+                         0, 0, 1);
+        SkRect rectGrad = { 43, 61, 181, 167 }; // some nice prime numbers
+
+        SkShader* shader = SimpleRadialGradient(pts);
+        shader->setLocalMatrix(shaderMat);
+        SkPaint paint;
+        paint.setAntiAlias(true);
         paint.setShader(shader);
         canvas->drawRect(rectGrad, paint);
         shader->unref();
     }
 
-    virtual void testGrad(SkCanvas* canvas, int x1, int y1, int x2, int y2) {
+    virtual void drawLinearGradient(SkCanvas* canvas, float x1, float y1, float x2, float y2) {
         SkPoint pts[2] = {
             { x1, y1 },
             { x2, y2 }
         };
         SkMatrix shaderMat = SkMatrix();
         shaderMat.setAll(138, 0, 43,
                          0, 106, 61,
                          0, 0, 1);
         SkRect rectGrad = { 43, 61, 181, 167 }; // some nice prime numbers
 
-        SkShader* shader = SimpleGradient(pts);
+        SkShader* shader = SimpleLinearGradient(pts);
         shader->setLocalMatrix(shaderMat);
         SkPaint paint;
         paint.setAntiAlias(true);
         paint.setShader(shader);
         canvas->drawRect(rectGrad, paint);
         shader->unref();
     }
 
 private:
     typedef GM INHERITED;
 };
 
 static GM* MyFactory(void*) { return new GradientMatrixGM; }
 static GMRegistry reg(MyFactory);
 
 }