Home | History | Annotate | Download | only in gm 
      1 /*
      2  * Copyright 2012 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 "SkCanvas.h"
     10 #include "SkShader.h"
     11 #include "SkBlurMaskFilter.h"
     12 
     13 namespace skiagm {
     14 
     15 /**
     16  * Stress test the GPU samplers by rendering a textured glyph with a mask and
     17  * an AA clip
     18  */
     19 class SamplerStressGM : public GM {
     20 public:
     21     SamplerStressGM()
     22     : fTextureCreated(false)
     23     , fShader(NULL)
     24     , fMaskFilter(NULL) {
     25     }
     26 
     27     virtual ~SamplerStressGM() {
     28     }
     29 
     30 protected:
     31     virtual uint32_t onGetFlags() const SK_OVERRIDE {
     32         return kSkipTiled_Flag;
     33     }
     34 
     35     virtual SkString onShortName() {
     36         return SkString("gpusamplerstress");
     37     }
     38 
     39     virtual SkISize onISize() {
     40         return SkISize::Make(640, 480);
     41     }
     42 
     43     /**
     44      * Create a red & green stripes on black texture
     45      */
     46     void createTexture() {
     47         if (fTextureCreated) {
     48             return;
     49         }
     50 
     51         static const int xSize = 16;
     52         static const int ySize = 16;
     53 
     54         fTexture.allocN32Pixels(xSize, ySize);
     55         SkPMColor* addr = fTexture.getAddr32(0, 0);
     56 
     57         for (int y = 0; y < ySize; ++y) {
     58             for (int x = 0; x < xSize; ++x) {
     59                 addr[y*xSize+x] = SkPreMultiplyColor(SK_ColorBLACK);
     60 
     61                 if ((y % 5) == 0) {
     62                     addr[y*xSize+x] = SkPreMultiplyColor(SK_ColorRED);
     63                 }
     64                 if ((x % 7) == 0) {
     65                     addr[y*xSize+x] = SkPreMultiplyColor(SK_ColorGREEN);
     66                 }
     67             }
     68         }
     69 
     70         fTextureCreated = true;
     71     }
     72 
     73     void createShader() {
     74         if (fShader.get()) {
     75             return;
     76         }
     77 
     78         createTexture();
     79 
     80         fShader.reset(SkShader::CreateBitmapShader(fTexture,
     81                                                    SkShader::kRepeat_TileMode,
     82                                                    SkShader::kRepeat_TileMode));
     83     }
     84 
     85     void createMaskFilter() {
     86         if (fMaskFilter.get()) {
     87             return;
     88         }
     89 
     90         const SkScalar sigma = 1;
     91         fMaskFilter.reset(SkBlurMaskFilter::Create(kNormal_SkBlurStyle, sigma));
     92     }
     93 
     94     virtual void onDraw(SkCanvas* canvas) {
     95 
     96         createShader();
     97         createMaskFilter();
     98 
     99         canvas->save();
    100 
    101         // draw a letter "M" with a green & red striped texture and a
    102         // stipple mask with a round rect soft clip
    103         SkPaint paint;
    104         paint.setAntiAlias(true);
    105         paint.setTextSize(72);
    106         paint.setShader(fShader.get());
    107         paint.setMaskFilter(fMaskFilter.get());
    108 
    109         SkRect temp;
    110         temp.set(SkIntToScalar(115),
    111                  SkIntToScalar(75),
    112                  SkIntToScalar(144),
    113                  SkIntToScalar(110));
    114 
    115         SkPath path;
    116         path.addRoundRect(temp, SkIntToScalar(5), SkIntToScalar(5));
    117 
    118         canvas->clipPath(path, SkRegion::kReplace_Op, true); // AA is on
    119 
    120         canvas->drawText("M", 1,
    121                          SkIntToScalar(100), SkIntToScalar(100),
    122                          paint);
    123 
    124         canvas->restore();
    125 
    126         // Now draw stroked versions of the "M" and the round rect so we can
    127         // see what is going on
    128         SkPaint paint2;
    129         paint2.setColor(SK_ColorBLACK);
    130         paint2.setAntiAlias(true);
    131         paint2.setTextSize(72);
    132         paint2.setStyle(SkPaint::kStroke_Style);
    133         paint2.setStrokeWidth(1);
    134         canvas->drawText("M", 1,
    135                          SkIntToScalar(100), SkIntToScalar(100),
    136                          paint2);
    137 
    138         paint2.setColor(SK_ColorGRAY);
    139 
    140         canvas->drawPath(path, paint2);
    141     }
    142 
    143 private:
    144     SkBitmap      fTexture;
    145     bool          fTextureCreated;
    146     SkAutoTUnref<SkShader>     fShader;
    147     SkAutoTUnref<SkMaskFilter> fMaskFilter;
    148 
    149     typedef GM INHERITED;
    150 };
    151 
    152 //////////////////////////////////////////////////////////////////////////////
    153 
    154 static GM* MyFactory(void*) { return new SamplerStressGM; }
    155 static GMRegistry reg(MyFactory);
    156 
    157 }
    158