Home | History | Annotate | Download | only in gm
      1 /*
      2  * Copyright 2011 Google Inc.
      3  *
      4  * Use of this source code is governed by a BSD-style license that can be
      5  * found in the LICENSE file.
      6  */
      7 
      8 #include "gm.h"
      9 #include "SkCanvas.h"
     10 #include "SkGradientShader.h"
     11 
     12 namespace skiagm {
     13 
     14 static void makebm(SkBitmap* bm, int w, int h) {
     15     bm->allocN32Pixels(w, h);
     16     bm->eraseColor(SK_ColorTRANSPARENT);
     17 
     18     SkCanvas    canvas(*bm);
     19     SkScalar    s = SkIntToScalar(SkMin32(w, h));
     20     SkPoint     pts[] = { { 0, 0 }, { s, s } };
     21     SkColor     colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE };
     22     SkScalar    pos[] = { 0, SK_Scalar1/2, SK_Scalar1 };
     23     SkPaint     paint;
     24 
     25     paint.setDither(true);
     26     paint.setShader(SkGradientShader::CreateLinear(pts, colors, pos,
     27                 SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode))->unref();
     28     canvas.drawPaint(paint);
     29 }
     30 
     31 ///////////////////////////////////////////////////////////////////////////////
     32 
     33 struct GradData {
     34     int             fCount;
     35     const SkColor*  fColors;
     36     const SkScalar* fPos;
     37 };
     38 
     39 static const SkColor gColors[] = {
     40     SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK
     41 };
     42 
     43 static const GradData gGradData[] = {
     44     { 2, gColors, NULL },
     45     { 5, gColors, NULL },
     46 };
     47 
     48 static SkShader* MakeLinear(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
     49     return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos, data.fCount, tm);
     50 }
     51 
     52 static SkShader* MakeRadial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
     53     SkPoint center;
     54     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
     55                SkScalarAve(pts[0].fY, pts[1].fY));
     56     return SkGradientShader::CreateRadial(center, center.fX, data.fColors,
     57                                           data.fPos, data.fCount, tm);
     58 }
     59 
     60 static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data, SkShader::TileMode) {
     61     SkPoint center;
     62     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
     63                SkScalarAve(pts[0].fY, pts[1].fY));
     64     return SkGradientShader::CreateSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount);
     65 }
     66 
     67 static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
     68     SkPoint center0, center1;
     69     center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
     70                 SkScalarAve(pts[0].fY, pts[1].fY));
     71     center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
     72                 SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
     73     return SkGradientShader::CreateTwoPointRadial(
     74                             center1, (pts[1].fX - pts[0].fX) / 7,
     75                             center0, (pts[1].fX - pts[0].fX) / 2,
     76                             data.fColors, data.fPos, data.fCount, tm);
     77 }
     78 
     79 typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm);
     80 
     81 static const GradMaker gGradMakers[] = {
     82     MakeLinear, MakeRadial, MakeSweep, Make2Radial
     83 };
     84 
     85 ///////////////////////////////////////////////////////////////////////////////
     86 
     87 class ShaderTextGM : public GM {
     88 public:
     89     ShaderTextGM() {
     90         this->setBGColor(0xFFDDDDDD);
     91     }
     92 
     93 protected:
     94     virtual uint32_t onGetFlags() const SK_OVERRIDE {
     95         return kSkipTiled_Flag;
     96     }
     97 
     98     SkString onShortName() {
     99         return SkString("shadertext");
    100     }
    101 
    102     SkISize onISize() { return SkISize::Make(1450, 500); }
    103 
    104     virtual void onDraw(SkCanvas* canvas) {
    105         const char text[] = "Shaded Text";
    106         const int textLen = SK_ARRAY_COUNT(text) - 1;
    107         const int pointSize = 36;
    108 
    109         const int w = pointSize * textLen;
    110         const int h = pointSize;
    111 
    112         SkPoint pts[2] = {
    113             { 0, 0 },
    114             { SkIntToScalar(w), SkIntToScalar(h) }
    115         };
    116         SkScalar textBase = SkIntToScalar(h/2);
    117 
    118         SkShader::TileMode tileModes[] = {
    119             SkShader::kClamp_TileMode,
    120             SkShader::kRepeat_TileMode,
    121             SkShader::kMirror_TileMode
    122         };
    123 
    124         static const int gradCount = SK_ARRAY_COUNT(gGradData) *
    125                                      SK_ARRAY_COUNT(gGradMakers);
    126         static const int bmpCount = SK_ARRAY_COUNT(tileModes) *
    127                                     SK_ARRAY_COUNT(tileModes);
    128         SkShader* shaders[gradCount + bmpCount];
    129 
    130         int shdIdx = 0;
    131         for (size_t d = 0; d < SK_ARRAY_COUNT(gGradData); ++d) {
    132             for (size_t m = 0; m < SK_ARRAY_COUNT(gGradMakers); ++m) {
    133                 shaders[shdIdx++] = gGradMakers[m](pts,
    134                                                    gGradData[d],
    135                                                    SkShader::kClamp_TileMode);
    136             }
    137         }
    138 
    139         SkBitmap bm;
    140         makebm(&bm, w/16, h/4);
    141         for (size_t tx = 0; tx < SK_ARRAY_COUNT(tileModes); ++tx) {
    142             for (size_t ty = 0; ty < SK_ARRAY_COUNT(tileModes); ++ty) {
    143                 shaders[shdIdx++] = SkShader::CreateBitmapShader(bm, tileModes[tx], tileModes[ty]);
    144             }
    145         }
    146 
    147         SkPaint paint;
    148         paint.setDither(true);
    149         paint.setAntiAlias(true);
    150         sk_tool_utils::set_portable_typeface(&paint);
    151         paint.setTextSize(SkIntToScalar(pointSize));
    152 
    153         canvas->save();
    154         canvas->translate(SkIntToScalar(20), SkIntToScalar(10));
    155 
    156         SkPath path;
    157         path.arcTo(SkRect::MakeXYWH(SkIntToScalar(-40), SkIntToScalar(15),
    158                                     SkIntToScalar(300), SkIntToScalar(90)),
    159                                     SkIntToScalar(225), SkIntToScalar(90),
    160                                     false);
    161         path.close();
    162 
    163         static const int testsPerCol = 8;
    164         static const int rowHeight = 60;
    165         static const int colWidth = 300;
    166         canvas->save();
    167         for (int s = 0; s < static_cast<int>(SK_ARRAY_COUNT(shaders)); s++) {
    168             canvas->save();
    169             int i = 2*s;
    170             canvas->translate(SkIntToScalar((i / testsPerCol) * colWidth),
    171                               SkIntToScalar((i % testsPerCol) * rowHeight));
    172             paint.setShader(shaders[s])->unref();
    173             canvas->drawText(text, textLen, 0, textBase, paint);
    174             canvas->restore();
    175             canvas->save();
    176             ++i;
    177             canvas->translate(SkIntToScalar((i / testsPerCol) * colWidth),
    178                               SkIntToScalar((i % testsPerCol) * rowHeight));
    179             canvas->drawTextOnPath(text, textLen, path, NULL, paint);
    180             canvas->restore();
    181         }
    182         canvas->restore();
    183 
    184     }
    185 
    186 private:
    187     typedef GM INHERITED;
    188 };
    189 
    190 ///////////////////////////////////////////////////////////////////////////////
    191 
    192 static GM* MyFactory(void*) { return new ShaderTextGM; }
    193 static GMRegistry reg(MyFactory);
    194 }
    195