src/third_party/skia/gm/tilemodes_scaled.cpp

   1
   2 /*
   3  * Copyright 2011 Google Inc.
   4  *
   5  * Use of this source code is governed by a BSD-style license that can be
   6  * found in the LICENSE file.
   7  */
   8 #include "gm.h"
   9 #include "SkPath.h"
  10 #include "SkRegion.h"
  11 #include "SkShader.h"
  12 #include "SkUtils.h"
  13 #include "SkColorPriv.h"
  14 #include "SkColorFilter.h"
  15 #include "SkTypeface.h"
  16 #include "SkBlurMask.h"
  17
  18 // effects
  19 #include "SkGradientShader.h"
  20 #include "SkBlurDrawLooper.h"
  21
  22 static void makebm(SkBitmap* bm, SkColorType ct, int w, int h) {
  23     bm->allocPixels(SkImageInfo::Make(w, h, ct, kPremul_SkAlphaType));
  24     bm->eraseColor(SK_ColorTRANSPARENT);
  25
  26     SkCanvas    canvas(*bm);
  27     SkPoint     pts[] = { { 0, 0 }, { SkIntToScalar(w), SkIntToScalar(h)} };
  28     SkColor     colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE };
  29     SkScalar    pos[] = { 0, SK_Scalar1/2, SK_Scalar1 };
  30     SkPaint     paint;
  31
  32     paint.setDither(true);
  33     paint.setShader(SkGradientShader::CreateLinear(pts, colors, pos,
  34                 SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode))->unref();
  35     canvas.drawPaint(paint);
  36 }
  37
  38 static void setup(SkPaint* paint, const SkBitmap& bm, SkPaint::FilterLevel filter_level,
  39                   SkShader::TileMode tmx, SkShader::TileMode tmy) {
  40     SkShader* shader = SkShader::CreateBitmapShader(bm, tmx, tmy);
  41     paint->setShader(shader)->unref();
  42     paint->setFilterLevel(filter_level);
  43 }
  44
  45 static const SkColorType gColorTypes[] = {
  46     kN32_SkColorType,
  47     kRGB_565_SkColorType,
  48 };
  49
  50 class ScaledTilingGM : public skiagm::GM {
  51     SkAutoTUnref<SkBlurDrawLooper> fLooper;
  52 public:
  53     ScaledTilingGM(bool powerOfTwoSize)
  54             : fLooper(SkBlurDrawLooper::Create(0x88000000,
  55                                                SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(1)),
  56                                                SkIntToScalar(2), SkIntToScalar(2)))
  57             , fPowerOfTwoSize(powerOfTwoSize) {
  58     }
  59
  60     SkBitmap    fTexture[SK_ARRAY_COUNT(gColorTypes)];
  61
  62 protected:
  63     enum {
  64         kPOTSize = 4,
  65         kNPOTSize = 3,
  66     };
  67
  68     SkString onShortName() {
  69         SkString name("scaled_tilemodes");
  70         if (!fPowerOfTwoSize) {
  71             name.append("_npot");
  72         }
  73         return name;
  74     }
  75
  76     SkISize onISize() { return SkISize::Make(880, 760); }
  77
  78     virtual void onOnceBeforeDraw() SK_OVERRIDE {
  79         int size = fPowerOfTwoSize ? kPOTSize : kNPOTSize;
  80         for (size_t i = 0; i < SK_ARRAY_COUNT(gColorTypes); i++) {
  81             makebm(&fTexture[i], gColorTypes[i], size, size);
  82         }
  83     }
  84
  85     virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
  86
  87         float scale = 32.f/kPOTSize;
  88
  89         int size = fPowerOfTwoSize ? kPOTSize : kNPOTSize;
  90
  91         SkRect r = { 0, 0, SkIntToScalar(size*2), SkIntToScalar(size*2) };
  92
  93         static const char* gColorTypeNames[] = { "8888" , "565", "4444" };
  94
  95         static const SkPaint::FilterLevel           gFilterLevels[] =
  96             { SkPaint::kNone_FilterLevel,
  97               SkPaint::kLow_FilterLevel,
  98               SkPaint::kMedium_FilterLevel,
  99               SkPaint::kHigh_FilterLevel };
 100         static const char*          gFilterNames[] = { "None", "Low", "Medium", "High" };
 101
 102         static const SkShader::TileMode gModes[] = { SkShader::kClamp_TileMode, SkShader::kRepeat_TileMode, SkShader::kMirror_TileMode };
 103         static const char*          gModeNames[] = {    "C",                    "R",                   "M" };
 104
 105         SkScalar y = SkIntToScalar(24);
 106         SkScalar x = SkIntToScalar(10)/scale;
 107
 108         for (size_t kx = 0; kx < SK_ARRAY_COUNT(gModes); kx++) {
 109             for (size_t ky = 0; ky < SK_ARRAY_COUNT(gModes); ky++) {
 110                 SkPaint p;
 111                 SkString str;
 112                 p.setAntiAlias(true);
 113                 sk_tool_utils::set_portable_typeface(&p);
 114                 p.setDither(true);
 115                 p.setLooper(fLooper);
 116                 str.printf("[%s,%s]", gModeNames[kx], gModeNames[ky]);
 117
 118                 p.setTextAlign(SkPaint::kCenter_Align);
 119                 canvas->drawText(str.c_str(), str.size(), scale*(x + r.width()/2), y, p);
 120
 121                 x += r.width() * 4 / 3;
 122             }
 123         }
 124
 125         y = SkIntToScalar(40) / scale;
 126
 127         for (size_t i = 0; i < SK_ARRAY_COUNT(gColorTypes); i++) {
 128             for (size_t j = 0; j < SK_ARRAY_COUNT(gFilterLevels); j++) {
 129                 x = SkIntToScalar(10)/scale;
 130                 for (size_t kx = 0; kx < SK_ARRAY_COUNT(gModes); kx++) {
 131                     for (size_t ky = 0; ky < SK_ARRAY_COUNT(gModes); ky++) {
 132                         SkPaint paint;
 133 #if 1 // Temporary change to regen bitmap before each draw. This may help tracking down an issue
 134       // on SGX where resizing NPOT textures to POT textures exhibits a driver bug.
 135                         if (!fPowerOfTwoSize) {
 136                             makebm(&fTexture[i], gColorTypes[i], size, size);
 137                         }
 138 #endif
 139                         setup(&paint, fTexture[i], gFilterLevels[j], gModes[kx], gModes[ky]);
 140                         paint.setDither(true);
 141
 142                         canvas->save();
 143                         canvas->scale(scale,scale);
 144                         canvas->translate(x, y);
 145                         canvas->drawRect(r, paint);
 146                         canvas->restore();
 147
 148                         x += r.width() * 4 / 3;
 149                     }
 150                 }
 151                 {
 152                     SkPaint p;
 153                     SkString str;
 154                     p.setAntiAlias(true);
 155                     sk_tool_utils::set_portable_typeface(&p);
 156                     p.setLooper(fLooper);
 157                     str.printf("%s, %s", gColorTypeNames[i], gFilterNames[j]);
 158                     canvas->drawText(str.c_str(), str.size(), scale*x, scale*(y + r.height() * 2 / 3), p);
 159                 }
 160
 161                 y += r.height() * 4 / 3;
 162             }
 163         }
 164     }
 165
 166 private:
 167     bool fPowerOfTwoSize;
 168     typedef skiagm::GM INHERITED;
 169 };
 170
 171 static const int gWidth = 32;
 172 static const int gHeight = 32;
 173
 174 static SkShader* make_bm(SkShader::TileMode tx, SkShader::TileMode ty) {
 175     SkBitmap bm;
 176     makebm(&bm, kN32_SkColorType, gWidth, gHeight);
 177     return SkShader::CreateBitmapShader(bm, tx, ty);
 178 }
 179
 180 static SkShader* make_grad(SkShader::TileMode tx, SkShader::TileMode ty) {
 181     SkPoint pts[] = { { 0, 0 }, { SkIntToScalar(gWidth), SkIntToScalar(gHeight)} };
 182     SkPoint center = { SkIntToScalar(gWidth)/2, SkIntToScalar(gHeight)/2 };
 183     SkScalar rad = SkIntToScalar(gWidth)/2;
 184     SkColor colors[] = { 0xFFFF0000, 0xFF0044FF };
 185
 186     int index = (int)ty;
 187     switch (index % 3) {
 188         case 0:
 189             return SkGradientShader::CreateLinear(pts, colors, NULL, SK_ARRAY_COUNT(colors), tx);
 190         case 1:
 191             return SkGradientShader::CreateRadial(center, rad, colors, NULL, SK_ARRAY_COUNT(colors), tx);
 192         case 2:
 193             return SkGradientShader::CreateSweep(center.fX, center.fY, colors, NULL, SK_ARRAY_COUNT(colors));
 194     }
 195
 196     return NULL;
 197 }
 198
 199 typedef SkShader* (*ShaderProc)(SkShader::TileMode, SkShader::TileMode);
 200
 201 class ScaledTiling2GM : public skiagm::GM {
 202     ShaderProc fProc;
 203     SkString   fName;
 204 public:
 205     ScaledTiling2GM(ShaderProc proc, const char name[]) : fProc(proc) {
 206         fName.printf("scaled_tilemode_%s", name);
 207     }
 208
 209 protected:
 210     virtual uint32_t onGetFlags() const SK_OVERRIDE {
 211         return kSkipTiled_Flag;
 212     }
 213
 214     SkString onShortName() {
 215         return fName;
 216     }
 217
 218     SkISize onISize() { return SkISize::Make(880, 560); }
 219
 220     virtual void onDraw(SkCanvas* canvas) {
 221         canvas->scale(SkIntToScalar(3)/2, SkIntToScalar(3)/2);
 222
 223         const SkScalar w = SkIntToScalar(gWidth);
 224         const SkScalar h = SkIntToScalar(gHeight);
 225         SkRect r = { -w, -h, w*2, h*2 };
 226
 227         static const SkShader::TileMode gModes[] = {
 228             SkShader::kClamp_TileMode, SkShader::kRepeat_TileMode, SkShader::kMirror_TileMode
 229         };
 230         static const char* gModeNames[] = {
 231             "Clamp", "Repeat", "Mirror"
 232         };
 233
 234         SkScalar y = SkIntToScalar(24);
 235         SkScalar x = SkIntToScalar(66);
 236
 237         SkPaint p;
 238         p.setAntiAlias(true);
 239         sk_tool_utils::set_portable_typeface(&p);
 240         p.setTextAlign(SkPaint::kCenter_Align);
 241
 242         for (size_t kx = 0; kx < SK_ARRAY_COUNT(gModes); kx++) {
 243             SkString str(gModeNames[kx]);
 244             canvas->drawText(str.c_str(), str.size(), x + r.width()/2, y, p);
 245             x += r.width() * 4 / 3;
 246         }
 247
 248         y += SkIntToScalar(16) + h;
 249         p.setTextAlign(SkPaint::kRight_Align);
 250
 251         for (size_t ky = 0; ky < SK_ARRAY_COUNT(gModes); ky++) {
 252             x = SkIntToScalar(16) + w;
 253
 254             SkString str(gModeNames[ky]);
 255             canvas->drawText(str.c_str(), str.size(), x, y + h/2, p);
 256
 257             x += SkIntToScalar(50);
 258             for (size_t kx = 0; kx < SK_ARRAY_COUNT(gModes); kx++) {
 259                 SkPaint paint;
 260                 paint.setShader(fProc(gModes[kx], gModes[ky]))->unref();
 261
 262                 canvas->save();
 263                 canvas->translate(x, y);
 264                 canvas->drawRect(r, paint);
 265                 canvas->restore();
 266
 267                 x += r.width() * 4 / 3;
 268             }
 269             y += r.height() * 4 / 3;
 270         }
 271     }
 272
 273 private:
 274     typedef skiagm::GM INHERITED;
 275 };
 276
 277 //////////////////////////////////////////////////////////////////////////////
 278
 279 DEF_GM( return new ScaledTilingGM(true); )
 280 DEF_GM( return new ScaledTilingGM(false); )
 281 DEF_GM( return new ScaledTiling2GM(make_bm, "bitmap"); )
 282 DEF_GM( return new ScaledTiling2GM(make_grad, "gradient"); )