gm/drawatlas.cpp

   1 /*
   2  * Copyright 2015 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
  10 #include "SkAutoMalloc.h"
  11 #include "SkCanvas.h"
  12 #include "SkRSXform.h"
  13 #include "SkSurface.h"
  14
  15 class DrawAtlasGM : public skiagm::GM {
  16     static sk_sp<SkImage> MakeAtlas(SkCanvas* caller, const SkRect& target) {
  17         SkImageInfo info = SkImageInfo::MakeN32Premul(100, 100);
  18         auto surface(caller->makeSurface(info));
  19         if (nullptr == surface) {
  20             surface = SkSurface::MakeRaster(info);
  21         }
  22         SkCanvas* canvas = surface->getCanvas();
  23         // draw red everywhere, but we don't expect to see it in the draw, testing the notion
  24         // that drawAtlas draws a subset-region of the atlas.
  25         canvas->clear(SK_ColorRED);
  26
  27         SkPaint paint;
  28         paint.setBlendMode(SkBlendMode::kClear);
  29         SkRect r(target);
  30         r.inset(-1, -1);
  31         // zero out a place (with a 1-pixel border) to land our drawing.
  32         canvas->drawRect(r, paint);
  33         paint.setBlendMode(SkBlendMode::kSrcOver);
  34         paint.setColor(SK_ColorBLUE);
  35         paint.setAntiAlias(true);
  36         canvas->drawOval(target, paint);
  37         return surface->makeImageSnapshot();
  38     }
  39
  40 public:
  41     DrawAtlasGM() {}
  42
  43 protected:
  44
  45     SkString onShortName() override {
  46         return SkString("draw-atlas");
  47     }
  48
  49     SkISize onISize() override {
  50         return SkISize::Make(640, 480);
  51     }
  52
  53     void onDraw(SkCanvas* canvas) override {
  54         const SkRect target = { 50, 50, 80, 90 };
  55         auto atlas = MakeAtlas(canvas, target);
  56
  57         const struct {
  58             SkScalar fScale;
  59             SkScalar fDegrees;
  60             SkScalar fTx;
  61             SkScalar fTy;
  62
  63             void apply(SkRSXform* xform) const {
  64                 const SkScalar rad = SkDegreesToRadians(fDegrees);
  65                 xform->fSCos = fScale * SkScalarCos(rad);
  66                 xform->fSSin = fScale * SkScalarSin(rad);
  67                 xform->fTx   = fTx;
  68                 xform->fTy   = fTy;
  69             }
  70         } rec[] = {
  71             { 1, 0, 10, 10 },       // just translate
  72             { 2, 0, 110, 10 },      // scale + translate
  73             { 1, 30, 210, 10 },     // rotate + translate
  74             { 2, -30, 310, 30 },    // scale + rotate + translate
  75         };
  76
  77         const int N = SK_ARRAY_COUNT(rec);
  78         SkRSXform xform[N];
  79         SkRect tex[N];
  80         SkColor colors[N];
  81
  82         for (int i = 0; i < N; ++i) {
  83             rec[i].apply(&xform[i]);
  84             tex[i] = target;
  85             colors[i] = 0x80FF0000 + (i * 40 * 256);
  86         }
  87
  88         SkPaint paint;
  89         paint.setFilterQuality(kLow_SkFilterQuality);
  90         paint.setAntiAlias(true);
  91
  92         canvas->drawAtlas(atlas.get(), xform, tex, N, nullptr, &paint);
  93         canvas->translate(0, 100);
  94         canvas->drawAtlas(atlas.get(), xform, tex, colors, N, SkBlendMode::kSrcIn, nullptr, &paint);
  95     }
  96
  97 private:
  98     typedef GM INHERITED;
  99 };
 100 DEF_GM( return new DrawAtlasGM; )
 101
 102 ///////////////////////////////////////////////////////////////////////////////////////////////////
 103 #include "SkPath.h"
 104 #include "SkPathMeasure.h"
 105
 106 static void draw_text_on_path_rigid(SkCanvas* canvas, const void* text, size_t length,
 107                                     const SkPoint xy[], const SkPath& path, const SkPaint& paint) {
 108     SkPathMeasure meas(path, false);
 109
 110     int count = paint.countText(text, length);
 111     size_t size = count * (sizeof(SkRSXform) + sizeof(SkScalar));
 112     SkAutoSMalloc<512> storage(size);
 113     SkRSXform* xform = (SkRSXform*)storage.get();
 114     SkScalar* widths = (SkScalar*)(xform + count);
 115
 116     paint.getTextWidths(text, length, widths);
 117
 118     for (int i = 0; i < count; ++i) {
 119         // we want to position each character on the center of its advance
 120         const SkScalar offset = SkScalarHalf(widths[i]);
 121         SkPoint pos;
 122         SkVector tan;
 123         if (!meas.getPosTan(xy[i].x() + offset, &pos, &tan)) {
 124             pos = xy[i];
 125             tan.set(1, 0);
 126         }
 127         xform[i].fSCos = tan.x();
 128         xform[i].fSSin = tan.y();
 129         xform[i].fTx   = pos.x() - tan.y() * xy[i].y() - tan.x() * offset;
 130         xform[i].fTy   = pos.y() + tan.x() * xy[i].y() - tan.y() * offset;
 131     }
 132
 133     // Compute a conservative bounds so we can cull the draw
 134     const SkRect font = paint.getFontBounds();
 135     const SkScalar max = SkTMax(SkTMax(SkScalarAbs(font.fLeft), SkScalarAbs(font.fRight)),
 136                                 SkTMax(SkScalarAbs(font.fTop), SkScalarAbs(font.fBottom)));
 137     const SkRect bounds = path.getBounds().makeOutset(max, max);
 138
 139     canvas->drawTextRSXform(text, length, &xform[0], &bounds, paint);
 140
 141     if (true) {
 142         SkPaint p;
 143         p.setStyle(SkPaint::kStroke_Style);
 144         canvas->drawRect(bounds, p);
 145     }
 146 }
 147
 148 DEF_SIMPLE_GM(drawTextRSXform, canvas, 860, 860) {
 149     const char text0[] = "ABCDFGHJKLMNOPQRSTUVWXYZ";
 150     const int N = sizeof(text0) - 1;
 151     SkPoint pos[N];
 152
 153     SkPaint paint;
 154     paint.setAntiAlias(true);
 155     paint.setTextSize(100);
 156
 157     SkScalar x = 0;
 158     for (int i = 0; i < N; ++i) {
 159         pos[i].set(x, 0);
 160         x += paint.measureText(&text0[i], 1);
 161     }
 162
 163     SkPath path;
 164     path.addOval(SkRect::MakeXYWH(160, 160, 540, 540));
 165
 166     draw_text_on_path_rigid(canvas, text0, N, pos, path, paint);
 167
 168     paint.setStyle(SkPaint::kStroke_Style);
 169     canvas->drawPath(path, paint);
 170 }
 171
 172 #include "Resources.h"
 173 #include "SkColorFilter.h"
 174 #include "SkVertices.h"
 175
 176 static sk_sp<SkVertices> make_vertices(sk_sp<SkImage> image, const SkRect& r,
 177                                        SkColor color) {
 178     SkPoint pos[4];
 179     r.toQuad(pos);
 180     SkColor colors[4] = { color, color, color, color };
 181     return SkVertices::MakeCopy(SkVertices::kTriangleFan_VertexMode, 4,
 182                                 pos, pos, colors);
 183 }
 184
 185 /*
 186  *  drawAtlas and drawVertices have several things in common:
 187  *  - can create compound "shaders", combining texture and colors
 188  *      - these are combined via an explicit blendmode
 189  *  - like drawImage, they only respect parts of the paint
 190  *      - colorfilter, imagefilter, blendmode, alpha
 191  *
 192  *  This GM produces a series of pairs of images (atlas | vertices).
 193  *  Each pair should look the same, and each set shows a different combination
 194  *  of alpha | colorFilter | mode
 195  */
 196 DEF_SIMPLE_GM(compare_atlas_vertices, canvas, 560, 585) {
 197     const SkRect tex = SkRect::MakeWH(128, 128);
 198     const SkRSXform xform = SkRSXform::Make(1, 0, 0, 0);
 199     const SkColor color = 0x884488CC;
 200
 201     auto image = GetResourceAsImage("mandrill_128.png");
 202     auto verts = make_vertices(image, tex, color);
 203     const sk_sp<SkColorFilter> filters[] = {
 204         nullptr,
 205         SkColorFilter::MakeModeFilter(0xFF00FF88, SkBlendMode::kModulate),
 206     };
 207     const SkBlendMode modes[] = {
 208         SkBlendMode::kSrcOver,
 209         SkBlendMode::kPlus,
 210     };
 211
 212     canvas->translate(10, 10);
 213     SkPaint paint;
 214     for (SkBlendMode mode : modes) {
 215         for (int alpha : { 0xFF, 0x7F }) {
 216             paint.setAlpha(alpha);
 217             canvas->save();
 218             for (auto cf : filters) {
 219                 paint.setColorFilter(cf);
 220                 canvas->drawAtlas(image, &xform, &tex, &color, 1,
 221                                   mode, &tex, &paint);
 222                 canvas->translate(128, 0);
 223                 paint.setShader(image->makeShader());
 224                 canvas->drawVertices(verts, mode, paint);
 225                 paint.setShader(nullptr);
 226                 canvas->translate(145, 0);
 227             }
 228             canvas->restore();
 229             canvas->translate(0, 145);
 230         }
 231     }
 232 }