gm/surface.cpp

   1 /*
   2  * Copyright 2014 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 "SkGradientShader.h"
  10 #include "SkSurface.h"
  11 #include "SkSurfaceProps.h"
  12
  13 #define W 200
  14 #define H 100
  15
  16 static SkShader* make_shader() {
  17     int a = 0x99;
  18     int b = 0xBB;
  19     SkPoint pts[] = { { 0, 0 }, { W, H } };
  20     SkColor colors[] = { SkColorSetRGB(a, a, a), SkColorSetRGB(b, b, b) };
  21     return SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkShader::kClamp_TileMode);
  22 }
  23
  24 static SkSurface* make_surface(GrContext* ctx, const SkImageInfo& info, SkPixelGeometry geo,
  25                                int disallowAA, int disallowDither) {
  26     uint32_t flags = 0;
  27     if (disallowAA) {
  28         flags |= SkSurfaceProps::kDisallowAntiAlias_Flag;
  29     }
  30     if (disallowDither) {
  31         flags |= SkSurfaceProps::kDisallowDither_Flag;
  32     }
  33
  34     SkSurfaceProps props(flags, geo);
  35     if (ctx) {
  36         return SkSurface::NewRenderTarget(ctx, SkSurface::kNo_Budgeted, info, 0, &props);
  37     } else {
  38         return SkSurface::NewRaster(info, &props);
  39     }
  40 }
  41
  42 static void test_draw(SkCanvas* canvas, const char label[]) {
  43     SkPaint paint;
  44
  45     paint.setAntiAlias(true);
  46     paint.setLCDRenderText(true);
  47     paint.setDither(true);
  48
  49     paint.setShader(make_shader())->unref();
  50     canvas->drawRect(SkRect::MakeWH(W, H), paint);
  51     paint.setShader(NULL);
  52
  53     paint.setColor(SK_ColorWHITE);
  54     paint.setTextSize(32);
  55     paint.setTextAlign(SkPaint::kCenter_Align);
  56     canvas->drawText(label, strlen(label), W / 2, H * 3 / 4, paint);
  57 }
  58
  59 class SurfacePropsGM : public skiagm::GM {
  60 public:
  61     SurfacePropsGM() {}
  62
  63 protected:
  64     SkString onShortName() override {
  65         return SkString("surfaceprops");
  66     }
  67
  68     SkISize onISize() override {
  69         return SkISize::Make(W * 4, H * 5);
  70     }
  71
  72     void onDraw(SkCanvas* canvas) override {
  73         GrContext* ctx = canvas->getGrContext();
  74
  75         // must be opaque to have a hope of testing LCD text
  76         const SkImageInfo info = SkImageInfo::MakeN32(W, H, kOpaque_SkAlphaType);
  77
  78         const struct {
  79             SkPixelGeometry fGeo;
  80             const char*     fLabel;
  81         } rec[] = {
  82             { kUnknown_SkPixelGeometry, "Unknown" },
  83             { kRGB_H_SkPixelGeometry,   "RGB_H" },
  84             { kBGR_H_SkPixelGeometry,   "BGR_H" },
  85             { kRGB_V_SkPixelGeometry,   "RGB_V" },
  86             { kBGR_V_SkPixelGeometry,   "BGR_V" },
  87         };
  88
  89         SkScalar x = 0;
  90         for (int disallowAA = 0; disallowAA <= 1; ++disallowAA) {
  91             for (int disallowDither = 0; disallowDither <= 1; ++disallowDither) {
  92                 SkScalar y = 0;
  93                 for (size_t i = 0; i < SK_ARRAY_COUNT(rec); ++i) {
  94                     SkAutoTUnref<SkSurface> surface(make_surface(ctx, info, rec[i].fGeo,
  95                                                                  disallowAA, disallowDither));
  96                     test_draw(surface->getCanvas(), rec[i].fLabel);
  97                     surface->draw(canvas, x, y, NULL);
  98                     y += H;
  99                 }
 100                 x += W;
 101             }
 102         }
 103     }
 104
 105 private:
 106     typedef GM INHERITED;
 107 };
 108 DEF_GM( return new SurfacePropsGM )
 109
 110 #ifdef SK_DEBUG
 111 static bool equal(const SkSurfaceProps& a, const SkSurfaceProps& b) {
 112     return a.flags() == b.flags() && a.pixelGeometry() == b.pixelGeometry();
 113 }
 114 #endif
 115
 116 class NewSurfaceGM : public skiagm::GM {
 117 public:
 118     NewSurfaceGM() {}
 119
 120 protected:
 121     SkString onShortName() override {
 122         return SkString("surfacenew");
 123     }
 124
 125     SkISize onISize() override {
 126         return SkISize::Make(300, 140);
 127     }
 128
 129     static void drawInto(SkCanvas* canvas) {
 130         canvas->drawColor(SK_ColorRED);
 131     }
 132
 133     void onDraw(SkCanvas* canvas) override {
 134         SkImageInfo info = SkImageInfo::MakeN32Premul(100, 100);
 135
 136         SkAutoTUnref<SkSurface> surf(canvas->newSurface(info, NULL));
 137         if (!surf.get()) {
 138             surf.reset(SkSurface::NewRaster(info));
 139         }
 140         drawInto(surf->getCanvas());
 141
 142         SkAutoTUnref<SkImage> image(surf->newImageSnapshot());
 143         canvas->drawImage(image, 10, 10, NULL);
 144
 145         SkAutoTUnref<SkSurface> surf2(image->newSurface(info, NULL));
 146         drawInto(surf2->getCanvas());
 147
 148         // Assert that the props were communicated transitively through the first image
 149         SkASSERT(equal(surf->props(), surf2->props()));
 150
 151         SkAutoTUnref<SkImage> image2(surf2->newImageSnapshot());
 152         canvas->drawImage(image2, 10 + SkIntToScalar(image->width()) + 10, 10, NULL);
 153     }
 154
 155 private:
 156     typedef GM INHERITED;
 157 };
 158 DEF_GM( return new NewSurfaceGM )
 159