Mozilla diabolical clamp case added to gm/gradients.cpp

gm/gradients.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 "gm.h"
 #include "SkGradientShader.h"
 
 namespace skiagm {
 
 struct GradData {
     int             fCount;
     const SkColor*  fColors;
     const SkScalar* fPos;
 };
 
 static const SkColor gColors[] = {
     SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK
 };
 static const SkScalar gPos0[] = { 0, SK_Scalar1 };
 static const SkScalar gPos1[] = { SK_Scalar1/4, SK_Scalar1*3/4 };
 static const SkScalar gPos2[] = {
     0, SK_Scalar1/8, SK_Scalar1/2, SK_Scalar1*7/8, SK_Scalar1
 };
 
+static const SkScalar gPosClamp[]   = {0.0f, 0.0f, 1.0f, 1.0f};
+static const SkColor  gColorClamp[] = {
+    SK_ColorRED, SK_ColorGREEN, SK_ColorGREEN, SK_ColorBLUE
+};
+
 static const GradData gGradData[] = {
     { 2, gColors, NULL },
     { 2, gColors, gPos0 },
     { 2, gColors, gPos1 },
     { 5, gColors, NULL },
-    { 5, gColors, gPos2 }
+    { 5, gColors, gPos2 },
+    { 4, gColorClamp, gPosClamp }
 };
 
 static SkShader* MakeLinear(const SkPoint pts[2], const GradData& data,
                             SkShader::TileMode tm, SkUnitMapper* mapper) {
     return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos,
                                           data.fCount, tm, mapper);
 }
 
 static SkShader* MakeRadial(const SkPoint pts[2], const GradData& data,
                             SkShader::TileMode tm, SkUnitMapper* mapper) {
@@ skipping 69 matching lines @@
         SkShader::TileMode tm = SkShader::kClamp_TileMode;
         SkRect r = { 0, 0, SkIntToScalar(100), SkIntToScalar(100) };
         SkPaint paint;
         paint.setAntiAlias(true);
 
         canvas->translate(SkIntToScalar(20), SkIntToScalar(20));
         for (size_t i = 0; i < SK_ARRAY_COUNT(gGradData); i++) {
             canvas->save();
             for (size_t j = 0; j < SK_ARRAY_COUNT(gGradMakers); j++) {
                 SkShader* shader = gGradMakers[j](pts, gGradData[i], tm, NULL);
+
+                if (i == 5) { // if the clamp case
+                    SkMatrix scale;
+                    scale.setScale(0.5f, 0.5f);
+                    scale.postTranslate(25.f, 25.f);
+                    shader->setLocalMatrix(scale);
+                }
+                    
                 paint.setShader(shader);
                 canvas->drawRect(r, paint);
                 shader->unref();
                 canvas->translate(0, SkIntToScalar(120));
             }
             canvas->restore();
             canvas->translate(SkIntToScalar(120), 0);
         }
     }
 
@@ skipping 33 matching lines @@
             for (size_t j = 0; j < SK_ARRAY_COUNT(gGradMakers); j++) {
                 SkShader* shader = gGradMakers[j](pts, gGradData[i], tm, NULL);
 
                 // apply an increasing y perspective as we move to the right
                 SkMatrix perspective;
                 perspective.setIdentity();
                 perspective.setPerspY(SkScalarDiv(SkIntToScalar((unsigned) i+1),
                                       SkIntToScalar(500)));
                 perspective.setSkewX(SkScalarDiv(SkIntToScalar((unsigned) i+1),
                                      SkIntToScalar(10)));
+
                 shader->setLocalMatrix(perspective);
 
                 paint.setShader(shader);
                 canvas->drawRect(r, paint);
                 shader->unref();
                 canvas->translate(0, SkIntToScalar(120));
             }
             canvas->restore();
             canvas->translate(SkIntToScalar(120), 0);
         }
@@ skipping 174 matching lines @@
 
 static GM* MyFactory4(void*) { return new RadialGradientGM; }
 static GMRegistry reg4(MyFactory4);
 
 static GM* MyFactory5(void*) { return new GradientsLocalPerspectiveGM; }
 static GMRegistry reg5(MyFactory5);
 
 static GM* MyFactory6(void*) { return new GradientsViewPerspectiveGM; }
 static GMRegistry reg6(MyFactory6);
 }