gm/pictureimagefilter.cpp

   1 /*
   2  * Copyright 2013 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 "SkPictureImageFilter.h"
  11 #include "SkPictureRecorder.h"
  12
  13 // This GM exercises the SkPictureImageFilter ImageFilter class.
  14
  15 static void fill_rect_filtered(SkCanvas* canvas,
  16                                const SkRect& clipRect,
  17                                sk_sp<SkImageFilter> filter) {
  18     SkPaint paint;
  19     paint.setImageFilter(filter);
  20     canvas->save();
  21     canvas->clipRect(clipRect);
  22     canvas->drawPaint(paint);
  23     canvas->restore();
  24 }
  25
  26 static sk_sp<SkPicture> make_picture() {
  27     SkPictureRecorder recorder;
  28     SkCanvas* canvas = recorder.beginRecording(100, 100, nullptr, 0);
  29     SkPaint paint;
  30     paint.setAntiAlias(true);
  31     sk_tool_utils::set_portable_typeface(&paint);
  32     paint.setColor(0xFFFFFFFF);
  33     paint.setTextSize(SkIntToScalar(96));
  34     const char* str = "e";
  35     canvas->drawText(str, strlen(str), SkIntToScalar(20), SkIntToScalar(70), paint);
  36     return recorder.finishRecordingAsPicture();
  37 }
  38
  39 // Create a picture that will draw LCD text
  40 static sk_sp<SkPicture> make_LCD_picture() {
  41     SkPictureRecorder recorder;
  42     SkCanvas* canvas = recorder.beginRecording(100, 100, nullptr, 0);
  43     canvas->clear(SK_ColorTRANSPARENT);
  44     SkPaint paint;
  45     paint.setLCDRenderText(true);   // want LCD
  46     paint.setAntiAlias(true);       // need AA for LCD
  47     sk_tool_utils::set_portable_typeface(&paint);
  48     paint.setColor(0xFFFFFFFF);
  49     // this has to be small enough that it doesn't become a path
  50     paint.setTextSize(SkIntToScalar(36));
  51     const char* str = "e";
  52     canvas->drawText(str, strlen(str), SkIntToScalar(20), SkIntToScalar(70), paint);
  53     return recorder.finishRecordingAsPicture();
  54 }
  55
  56 class PictureImageFilterGM : public skiagm::GM {
  57 public:
  58     PictureImageFilterGM() { }
  59
  60 protected:
  61     SkString onShortName() override {
  62         return SkString("pictureimagefilter");
  63     }
  64
  65     SkISize onISize() override { return SkISize::Make(600, 300); }
  66
  67     void onOnceBeforeDraw() override {
  68         fPicture = make_picture();
  69         fLCDPicture = make_LCD_picture();
  70     }
  71
  72     void onDraw(SkCanvas* canvas) override {
  73         canvas->clear(SK_ColorGRAY);
  74         {
  75             SkRect srcRect = SkRect::MakeXYWH(20, 20, 30, 30);
  76             SkRect emptyRect = SkRect::MakeXYWH(20, 20, 0, 0);
  77             SkRect bounds = SkRect::MakeXYWH(0, 0, 100, 100);
  78             sk_sp<SkImageFilter> pictureSource(SkPictureImageFilter::Make(fPicture));
  79             sk_sp<SkImageFilter> pictureSourceSrcRect(SkPictureImageFilter::Make(fPicture,
  80                                                                                  srcRect));
  81             sk_sp<SkImageFilter> pictureSourceEmptyRect(SkPictureImageFilter::Make(fPicture,
  82                                                                                    emptyRect));
  83             sk_sp<SkImageFilter> pictureSourceResampled(SkPictureImageFilter::MakeForLocalSpace(
  84                                                                            fPicture,
  85                                                                            fPicture->cullRect(),
  86                                                                            kLow_SkFilterQuality));
  87             sk_sp<SkImageFilter> pictureSourcePixelated(SkPictureImageFilter::MakeForLocalSpace(
  88                                                                            fPicture,
  89                                                                            fPicture->cullRect(),
  90                                                                            kNone_SkFilterQuality));
  91
  92             canvas->save();
  93             // Draw the picture unscaled.
  94             fill_rect_filtered(canvas, bounds, pictureSource);
  95             canvas->translate(SkIntToScalar(100), 0);
  96
  97             // Draw an unscaled subset of the source picture.
  98             fill_rect_filtered(canvas, bounds, pictureSourceSrcRect);
  99             canvas->translate(SkIntToScalar(100), 0);
 100
 101             // Draw the picture to an empty rect (should draw nothing).
 102             fill_rect_filtered(canvas, bounds, pictureSourceEmptyRect);
 103             canvas->translate(SkIntToScalar(100), 0);
 104
 105             // Draw the LCD picture to a layer
 106             {
 107                 SkPaint stroke;
 108                 stroke.setStyle(SkPaint::kStroke_Style);
 109
 110                 canvas->drawRect(bounds, stroke);
 111
 112                 SkPaint paint;
 113                 paint.setImageFilter(SkPictureImageFilter::MakeForLocalSpace(
 114                                                                         fLCDPicture,
 115                                                                         fPicture->cullRect(),
 116                                                                         kNone_SkFilterQuality));
 117
 118                 canvas->scale(4, 4);
 119                 canvas->translate(-0.9f*srcRect.fLeft, -2.45f*srcRect.fTop);
 120
 121                 canvas->saveLayerPreserveLCDTextRequests(&bounds, &paint);
 122                 canvas->restore();
 123             }
 124
 125             canvas->restore();
 126
 127             // Draw the picture scaled
 128             canvas->translate(0, SkIntToScalar(100));
 129             canvas->scale(200 / srcRect.width(), 200 / srcRect.height());
 130             canvas->translate(-srcRect.fLeft, -srcRect.fTop);
 131             fill_rect_filtered(canvas, srcRect, pictureSource);
 132
 133             // Draw the picture scaled, but rasterized at original resolution
 134             canvas->translate(srcRect.width(), 0);
 135             fill_rect_filtered(canvas, srcRect, pictureSourceResampled);
 136
 137             // Draw the picture scaled, pixelated
 138             canvas->translate(srcRect.width(), 0);
 139             fill_rect_filtered(canvas, srcRect, pictureSourcePixelated);
 140         }
 141     }
 142
 143 private:
 144     sk_sp<SkPicture> fPicture;
 145     sk_sp<SkPicture> fLCDPicture;
 146
 147     typedef GM INHERITED;
 148 };
 149
 150 ///////////////////////////////////////////////////////////////////////////////
 151
 152 DEF_GM( return new PictureImageFilterGM; )