gm/perlinnoise.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 #include "SkPerlinNoiseShader.h"
  10 #include "SkShader.h"
  11
  12 namespace {
  13
  14 enum class Type {
  15     kFractalNoise,
  16     kTurbulence,
  17 };
  18
  19 } // anonymous ns
  20
  21 class PerlinNoiseGM : public skiagm::GM {
  22 public:
  23     PerlinNoiseGM() {
  24         this->setBGColor(0xFF000000);
  25         fSize = SkISize::Make(80, 80);
  26     }
  27
  28 protected:
  29     virtual SkString onShortName() {
  30         return SkString("perlinnoise");
  31     }
  32
  33     virtual SkISize onISize() {
  34         return SkISize::Make(200, 500);
  35     }
  36
  37     void drawRect(SkCanvas* canvas, int x, int y, const SkPaint& paint, const SkISize& size) {
  38         canvas->save();
  39         canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
  40         SkRect r = SkRect::MakeWH(SkIntToScalar(size.width()),
  41                                   SkIntToScalar(size.height()));
  42         canvas->drawRect(r, paint);
  43         canvas->restore();
  44     }
  45
  46     void test(SkCanvas* canvas, int x, int y, Type type,
  47               float baseFrequencyX, float baseFrequencyY, int numOctaves, float seed,
  48               bool stitchTiles) {
  49         SkISize tileSize = SkISize::Make(fSize.width() / 2, fSize.height() / 2);
  50         sk_sp<SkShader> shader = (type == Type::kFractalNoise) ?
  51             SkPerlinNoiseShader::MakeFractalNoise(baseFrequencyX, baseFrequencyY, numOctaves,
  52                                                   seed, stitchTiles ? &tileSize : nullptr) :
  53             SkPerlinNoiseShader::MakeTurbulence(baseFrequencyX, baseFrequencyY, numOctaves,
  54                                                 seed, stitchTiles ? &tileSize : nullptr);
  55         SkPaint paint;
  56         paint.setShader(std::move(shader));
  57         if (stitchTiles) {
  58             drawRect(canvas, x, y, paint, tileSize);
  59             x += tileSize.width();
  60             drawRect(canvas, x, y, paint, tileSize);
  61             y += tileSize.width();
  62             drawRect(canvas, x, y, paint, tileSize);
  63             x -= tileSize.width();
  64             drawRect(canvas, x, y, paint, tileSize);
  65         } else {
  66             drawRect(canvas, x, y, paint, fSize);
  67         }
  68     }
  69
  70     virtual void onDraw(SkCanvas* canvas) {
  71         canvas->clear(SK_ColorBLACK);
  72         test(canvas,   0,   0, Type::kFractalNoise,
  73              0.1f, 0.1f, 0, 0, false);
  74         test(canvas, 100,   0, Type::kTurbulence,
  75              0.1f, 0.1f, 0, 0, false);
  76
  77         test(canvas,   0, 100, Type::kFractalNoise,
  78              0.1f, 0.1f, 2, 0, false);
  79         test(canvas, 100, 100, Type::kFractalNoise,
  80              0.05f, 0.1f, 1, 0, true);
  81
  82         test(canvas,   0, 200, Type::kTurbulence,
  83              0.1f, 0.1f, 1, 0, true);
  84         test(canvas, 100, 200, Type::kTurbulence,
  85              0.2f, 0.4f, 5, 0, false);
  86
  87         test(canvas,   0, 300, Type::kFractalNoise,
  88              0.1f, 0.1f, 3, 1, false);
  89         test(canvas, 100, 300, Type::kFractalNoise,
  90              0.1f, 0.1f, 3, 4, false);
  91
  92         canvas->scale(0.75f, 1.0f);
  93
  94         test(canvas,   0, 400, Type::kFractalNoise,
  95              0.1f, 0.1f, 2, 0, false);
  96         test(canvas, 100, 400, Type::kFractalNoise,
  97              0.1f, 0.05f, 1, 0, true);
  98     }
  99
 100 private:
 101     typedef GM INHERITED;
 102     SkISize fSize;
 103 };
 104
 105 class PerlinNoiseGM2 : public skiagm::GM {
 106 public:
 107     PerlinNoiseGM2() {
 108         fSize = SkISize::Make(80, 80);
 109     }
 110
 111 protected:
 112     virtual SkString onShortName() {
 113         return SkString("perlinnoise_localmatrix");
 114     }
 115
 116     virtual SkISize onISize() {
 117         return SkISize::Make(640, 480);
 118     }
 119
 120     void install(SkPaint* paint, Type type,
 121               float baseFrequencyX, float baseFrequencyY, int numOctaves, float seed,
 122               bool stitchTiles) {
 123         sk_sp<SkShader> shader = (type == Type::kFractalNoise) ?
 124             SkPerlinNoiseShader::MakeFractalNoise(baseFrequencyX, baseFrequencyY, numOctaves,
 125                                                   seed, stitchTiles ? &fSize : nullptr) :
 126             SkPerlinNoiseShader::MakeTurbulence(baseFrequencyX, baseFrequencyY, numOctaves,
 127                                                 seed, stitchTiles ? &fSize : nullptr);
 128         paint->setShader(std::move(shader));
 129     }
 130
 131     virtual void onDraw(SkCanvas* canvas) {
 132         canvas->translate(10, 10);
 133
 134         SkPaint paint;
 135         install(&paint, Type::kFractalNoise, 0.1f, 0.1f, 2, 0, false);
 136
 137         const SkScalar w = SkIntToScalar(fSize.width());
 138         const SkScalar h = SkIntToScalar(fSize.height());
 139
 140         SkRect r = SkRect::MakeWH(w, h);
 141         canvas->drawRect(r, paint);
 142
 143         canvas->save();
 144         canvas->translate(w * 5/4, 0);
 145         canvas->drawRect(r, paint);
 146         canvas->restore();
 147
 148         canvas->save();
 149         canvas->translate(0, h + 10);
 150         canvas->scale(2, 2);
 151         canvas->drawRect(r, paint);
 152         canvas->restore();
 153
 154         canvas->save();
 155         canvas->translate(w + 100, h + 10);
 156         canvas->scale(2, 2);
 157         canvas->drawRect(r, paint);
 158         canvas->restore();
 159
 160         // The next row should draw the same as the previous, even though we are using a local
 161         // matrix instead of the canvas.
 162
 163         canvas->translate(0, h * 2 + 10);
 164
 165         SkMatrix lm;
 166         lm.setScale(2, 2);
 167         paint.setShader(paint.getShader()->makeWithLocalMatrix(lm));
 168         r.fRight += r.width();
 169         r.fBottom += r.height();
 170
 171         canvas->save();
 172         canvas->translate(0, h + 10);
 173         canvas->drawRect(r, paint);
 174         canvas->restore();
 175
 176         canvas->save();
 177         canvas->translate(w + 100, h + 10);
 178         canvas->drawRect(r, paint);
 179         canvas->restore();
 180     }
 181
 182 private:
 183     typedef GM INHERITED;
 184     SkISize fSize;
 185 };
 186
 187 //////////////////////////////////////////////////////////////////////////////
 188
 189 DEF_GM( return new PerlinNoiseGM; )
 190 DEF_GM( return new PerlinNoiseGM2; )