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 #ifdef SK_CPU_ARM64
  77     // Skip tiled drawing on 64-bit ARM until https://skbug.com/2908 is fixed.
  78     virtual uint32_t onGetFlags() const SK_OVERRIDE {
  79         return kSkipTiled_Flag;
  80     }
  81 #endif
  82
  83     SkISize onISize() { return SkISize::Make(880, 760); }
  84
  85     virtual void onOnceBeforeDraw() SK_OVERRIDE {
  86         int size = fPowerOfTwoSize ? kPOTSize : kNPOTSize;
  87         for (size_t i = 0; i < SK_ARRAY_COUNT(gColorTypes); i++) {
  88             makebm(&fTexture[i], gColorTypes[i], size, size);
  89         }
  90     }
  91
  92     virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
  93
  94         float scale = 32.f/kPOTSize;
  95
  96         int size = fPowerOfTwoSize ? kPOTSize : kNPOTSize;
  97
  98         SkRect r = { 0, 0, SkIntToScalar(size*2), SkIntToScalar(size*2) };
  99
 100         static const char* gColorTypeNames[] = { "8888" , "565", "4444" };
 101
 102         static const SkPaint::FilterLevel           gFilterLevels[] =
 103             { SkPaint::kNone_FilterLevel,
 104               SkPaint::kLow_FilterLevel,
 105               SkPaint::kMedium_FilterLevel,
 106               SkPaint::kHigh_FilterLevel };
 107         static const char*          gFilterNames[] = { "None", "Low", "Medium", "High" };
 108
 109         static const SkShader::TileMode gModes[] = { SkShader::kClamp_TileMode, SkShader::kRepeat_TileMode, SkShader::kMirror_TileMode };
 110         static const char*          gModeNames[] = {    "C",                    "R",                   "M" };
 111
 112         SkScalar y = SkIntToScalar(24);
 113         SkScalar x = SkIntToScalar(10)/scale;
 114
 115         for (size_t kx = 0; kx < SK_ARRAY_COUNT(gModes); kx++) {
 116             for (size_t ky = 0; ky < SK_ARRAY_COUNT(gModes); ky++) {
 117                 SkPaint p;
 118                 SkString str;
 119                 p.setAntiAlias(true);
 120                 sk_tool_utils::set_portable_typeface(&p);
 121                 p.setDither(true);
 122                 p.setLooper(fLooper);
 123                 str.printf("[%s,%s]", gModeNames[kx], gModeNames[ky]);
 124
 125                 p.setTextAlign(SkPaint::kCenter_Align);
 126                 canvas->drawText(str.c_str(), str.size(), scale*(x + r.width()/2), y, p);
 127
 128                 x += r.width() * 4 / 3;
 129             }
 130         }
 131
 132         y = SkIntToScalar(40) / scale;
 133
 134         for (size_t i = 0; i < SK_ARRAY_COUNT(gColorTypes); i++) {
 135             for (size_t j = 0; j < SK_ARRAY_COUNT(gFilterLevels); j++) {
 136                 x = SkIntToScalar(10)/scale;
 137                 for (size_t kx = 0; kx < SK_ARRAY_COUNT(gModes); kx++) {
 138                     for (size_t ky = 0; ky < SK_ARRAY_COUNT(gModes); ky++) {
 139                         SkPaint paint;
 140 #if 1 // Temporary change to regen bitmap before each draw. This may help tracking down an issue
 141       // on SGX where resizing NPOT textures to POT textures exhibits a driver bug.
 142                         if (!fPowerOfTwoSize) {
 143                             makebm(&fTexture[i], gColorTypes[i], size, size);
 144                         }
 145 #endif
 146                         setup(&paint, fTexture[i], gFilterLevels[j], gModes[kx], gModes[ky]);
 147                         paint.setDither(true);
 148
 149                         canvas->save();
 150                         canvas->scale(scale,scale);
 151                         canvas->translate(x, y);
 152                         canvas->drawRect(r, paint);
 153                         canvas->restore();
 154
 155                         x += r.width() * 4 / 3;
 156                     }
 157                 }
 158                 {
 159                     SkPaint p;
 160                     SkString str;
 161                     p.setAntiAlias(true);
 162                     sk_tool_utils::set_portable_typeface(&p);
 163                     p.setLooper(fLooper);
 164                     str.printf("%s, %s", gColorTypeNames[i], gFilterNames[j]);
 165                     canvas->drawText(str.c_str(), str.size(), scale*x, scale*(y + r.height() * 2 / 3), p);
 166                 }
 167
 168                 y += r.height() * 4 / 3;
 169             }
 170         }
 171     }
 172
 173 private:
 174     bool fPowerOfTwoSize;
 175     typedef skiagm::GM INHERITED;
 176 };
 177
 178 static const int gWidth = 32;
 179 static const int gHeight = 32;
 180
 181 static SkShader* make_bm(SkShader::TileMode tx, SkShader::TileMode ty) {
 182     SkBitmap bm;
 183     makebm(&bm, kN32_SkColorType, gWidth, gHeight);
 184     return SkShader::CreateBitmapShader(bm, tx, ty);
 185 }
 186
 187 static SkShader* make_grad(SkShader::TileMode tx, SkShader::TileMode ty) {
 188     SkPoint pts[] = { { 0, 0 }, { SkIntToScalar(gWidth), SkIntToScalar(gHeight)} };
 189     SkPoint center = { SkIntToScalar(gWidth)/2, SkIntToScalar(gHeight)/2 };
 190     SkScalar rad = SkIntToScalar(gWidth)/2;
 191     SkColor colors[] = { 0xFFFF0000, 0xFF0044FF };
 192
 193     int index = (int)ty;
 194     switch (index % 3) {
 195         case 0:
 196             return SkGradientShader::CreateLinear(pts, colors, NULL, SK_ARRAY_COUNT(colors), tx);
 197         case 1:
 198             return SkGradientShader::CreateRadial(center, rad, colors, NULL, SK_ARRAY_COUNT(colors), tx);
 199         case 2:
 200             return SkGradientShader::CreateSweep(center.fX, center.fY, colors, NULL, SK_ARRAY_COUNT(colors));
 201     }
 202
 203     return NULL;
 204 }
 205
 206 typedef SkShader* (*ShaderProc)(SkShader::TileMode, SkShader::TileMode);
 207
 208 class ScaledTiling2GM : public skiagm::GM {
 209     ShaderProc fProc;
 210     SkString   fName;
 211 public:
 212     ScaledTiling2GM(ShaderProc proc, const char name[]) : fProc(proc) {
 213         fName.printf("scaled_tilemode_%s", name);
 214     }
 215
 216 protected:
 217     virtual uint32_t onGetFlags() const SK_OVERRIDE {
 218         return kSkipTiled_Flag;
 219     }
 220
 221     SkString onShortName() {
 222         return fName;
 223     }
 224
 225     SkISize onISize() { return SkISize::Make(880, 560); }
 226
 227     virtual void onDraw(SkCanvas* canvas) {
 228         canvas->scale(SkIntToScalar(3)/2, SkIntToScalar(3)/2);
 229
 230         const SkScalar w = SkIntToScalar(gWidth);
 231         const SkScalar h = SkIntToScalar(gHeight);
 232         SkRect r = { -w, -h, w*2, h*2 };
 233
 234         static const SkShader::TileMode gModes[] = {
 235             SkShader::kClamp_TileMode, SkShader::kRepeat_TileMode, SkShader::kMirror_TileMode
 236         };
 237         static const char* gModeNames[] = {
 238             "Clamp", "Repeat", "Mirror"
 239         };
 240
 241         SkScalar y = SkIntToScalar(24);
 242         SkScalar x = SkIntToScalar(66);
 243
 244         SkPaint p;
 245         p.setAntiAlias(true);
 246         sk_tool_utils::set_portable_typeface(&p);
 247         p.setTextAlign(SkPaint::kCenter_Align);
 248
 249         for (size_t kx = 0; kx < SK_ARRAY_COUNT(gModes); kx++) {
 250             SkString str(gModeNames[kx]);
 251             canvas->drawText(str.c_str(), str.size(), x + r.width()/2, y, p);
 252             x += r.width() * 4 / 3;
 253         }
 254
 255         y += SkIntToScalar(16) + h;
 256         p.setTextAlign(SkPaint::kRight_Align);
 257
 258         for (size_t ky = 0; ky < SK_ARRAY_COUNT(gModes); ky++) {
 259             x = SkIntToScalar(16) + w;
 260
 261             SkString str(gModeNames[ky]);
 262             canvas->drawText(str.c_str(), str.size(), x, y + h/2, p);
 263
 264             x += SkIntToScalar(50);
 265             for (size_t kx = 0; kx < SK_ARRAY_COUNT(gModes); kx++) {
 266                 SkPaint paint;
 267                 paint.setShader(fProc(gModes[kx], gModes[ky]))->unref();
 268
 269                 canvas->save();
 270                 canvas->translate(x, y);
 271                 canvas->drawRect(r, paint);
 272                 canvas->restore();
 273
 274                 x += r.width() * 4 / 3;
 275             }
 276             y += r.height() * 4 / 3;
 277         }
 278     }
 279
 280 private:
 281     typedef skiagm::GM INHERITED;
 282 };
 283
 284 //////////////////////////////////////////////////////////////////////////////
 285
 286 DEF_GM( return new ScaledTilingGM(true); )
 287 DEF_GM( return new ScaledTilingGM(false); )
 288 DEF_GM( return new ScaledTiling2GM(make_bm, "bitmap"); )
 289 DEF_GM( return new ScaledTiling2GM(make_grad, "gradient"); )