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 "include/core/SkCanvas.h"
9 #include "include/effects/SkGradientShader.h"
10 #include "include/effects/SkPerlinNoiseShader.h"
11 #include "samplecode/Sample.h"
12 #include "src/utils/SkPatchUtils.h"
13 #include "tools/skui/ModifierKey.h"
14 
draw_control_points(SkCanvas * canvas,const SkPoint cubics[12])15 static void draw_control_points(SkCanvas* canvas, const SkPoint cubics[12]) {
16     //draw control points
17     SkPaint paint;
18     SkPoint bottom[SkPatchUtils::kNumPtsCubic];
19     SkPatchUtils::GetBottomCubic(cubics, bottom);
20     SkPoint top[SkPatchUtils::kNumPtsCubic];
21     SkPatchUtils::GetTopCubic(cubics, top);
22     SkPoint left[SkPatchUtils::kNumPtsCubic];
23     SkPatchUtils::GetLeftCubic(cubics, left);
24     SkPoint right[SkPatchUtils::kNumPtsCubic];
25     SkPatchUtils::GetRightCubic(cubics, right);
26 
27     paint.setColor(SK_ColorBLACK);
28     paint.setStrokeWidth(0.5f);
29     SkPoint corners[4] = { bottom[0], bottom[3], top[0], top[3] };
30     canvas->drawPoints(SkCanvas::kLines_PointMode, 4, bottom, paint);
31     canvas->drawPoints(SkCanvas::kLines_PointMode, 2, bottom + 1, paint);
32     canvas->drawPoints(SkCanvas::kLines_PointMode, 4, top, paint);
33     canvas->drawPoints(SkCanvas::kLines_PointMode, 4, left, paint);
34     canvas->drawPoints(SkCanvas::kLines_PointMode, 4, right, paint);
35 
36     canvas->drawPoints(SkCanvas::kLines_PointMode, 2, top + 1, paint);
37     canvas->drawPoints(SkCanvas::kLines_PointMode, 2, left + 1, paint);
38     canvas->drawPoints(SkCanvas::kLines_PointMode, 2, right + 1, paint);
39 
40     paint.setStrokeWidth(2);
41 
42     paint.setColor(SK_ColorRED);
43     canvas->drawPoints(SkCanvas::kPoints_PointMode, 4, corners, paint);
44 
45     paint.setColor(SK_ColorBLUE);
46     canvas->drawPoints(SkCanvas::kPoints_PointMode, 2, bottom + 1, paint);
47 
48     paint.setColor(SK_ColorCYAN);
49     canvas->drawPoints(SkCanvas::kPoints_PointMode, 2, top + 1, paint);
50 
51     paint.setColor(SK_ColorYELLOW);
52     canvas->drawPoints(SkCanvas::kPoints_PointMode, 2, left + 1, paint);
53 
54     paint.setColor(SK_ColorGREEN);
55     canvas->drawPoints(SkCanvas::kPoints_PointMode, 2, right + 1, paint);
56 }
57 
58 // These are actually half the total width and hieghts
59 const SkScalar TexWidth = 100.0f;
60 const SkScalar TexHeight = 100.0f;
61 
62 class PerlinPatchView : public Sample {
63     sk_sp<SkShader> fShader0;
64     sk_sp<SkShader> fShader1;
65     sk_sp<SkShader> fShaderCompose;
66     SkScalar fXFreq;
67     SkScalar fYFreq;
68     SkScalar fSeed;
69     SkPoint  fPts[SkPatchUtils::kNumCtrlPts];
70     SkScalar fTexX;
71     SkScalar fTexY;
72     SkScalar fTexScale;
73     SkMatrix fInvMatrix;
74     bool     fShowGrid = false;
75 
76 public:
PerlinPatchView()77     PerlinPatchView() : fXFreq(0.025f), fYFreq(0.025f), fSeed(0.0f),
78                         fTexX(100.0), fTexY(50.0), fTexScale(1.0f) {
79         const SkScalar s = 2;
80         // The order of the colors and points is clockwise starting at upper-left corner.
81         //top points
82         fPts[0].set(100 * s, 100 * s);
83         fPts[1].set(150 * s, 50 * s);
84         fPts[2].set(250 * s, 150 * s);
85         fPts[3].set(300 * s, 100 * s);
86         //right points
87         fPts[4].set(275 * s, 150 * s);
88         fPts[5].set(350 * s, 250 * s);
89         //bottom points
90         fPts[6].set(300 * s, 300 * s);
91         fPts[7].set(250 * s, 250 * s);
92         //left points
93         fPts[8].set(150 * s, 350 * s);
94         fPts[9].set(100 * s, 300 * s);
95         fPts[10].set(50 * s, 250 * s);
96         fPts[11].set(150 * s, 150 * s);
97 
98         const SkColor colors[SkPatchUtils::kNumCorners] = {
99             0xFF5555FF, 0xFF8888FF, 0xFFCCCCFF
100         };
101         const SkPoint points[2] = { SkPoint::Make(0.0f, 0.0f),
102                                     SkPoint::Make(100.0f, 100.0f) };
103         fShader0 = SkGradientShader::MakeLinear(points,
104                                                   colors,
105                                                   nullptr,
106                                                   3,
107                                                   SkTileMode::kMirror,
108                                                   0,
109                                                   nullptr);
110     }
111 
112 protected:
name()113     SkString name() override { return SkString("PerlinPatch"); }
114 
onChar(SkUnichar uni)115     bool onChar(SkUnichar uni) override {
116             switch (uni) {
117                 case 'g': fShowGrid = !fShowGrid; return true;
118                 default: break;
119             }
120             return false;
121     }
122 
onAnimate(double nanos)123     bool onAnimate(double nanos) override {
124         fSeed += 0.005f;
125         return true;
126     }
127 
onDrawContent(SkCanvas * canvas)128     void onDrawContent(SkCanvas* canvas) override {
129         if (!canvas->getTotalMatrix().invert(&fInvMatrix)) {
130             return;
131         }
132 
133         SkPaint paint;
134 
135         SkScalar texWidth = fTexScale * TexWidth;
136         SkScalar texHeight = fTexScale * TexHeight;
137         const SkPoint texCoords[SkPatchUtils::kNumCorners] = {
138             { fTexX - texWidth, fTexY - texHeight},
139             { fTexX + texWidth, fTexY - texHeight},
140             { fTexX + texWidth, fTexY + texHeight},
141             { fTexX - texWidth, fTexY + texHeight}}
142         ;
143 
144         SkScalar scaleFreq = 2.0;
145         fShader1 = SkPerlinNoiseShader::MakeImprovedNoise(fXFreq/scaleFreq, fYFreq/scaleFreq, 4,
146                                                              fSeed);
147         fShaderCompose = SkShaders::Blend(SkBlendMode::kSrcOver, fShader0, fShader1);
148 
149         paint.setShader(fShaderCompose);
150 
151         const SkPoint* tex = texCoords;
152         if (fShowGrid) {
153             tex = nullptr;
154         }
155         canvas->drawPatch(fPts, nullptr, tex, SkBlendMode::kSrc, paint);
156 
157         draw_control_points(canvas, fPts);
158     }
159 
160     class PtClick : public Click {
161     public:
162         int fIndex;
PtClick(int index)163         PtClick(int index) : fIndex(index) {}
164     };
165 
hittest(const SkPoint & pt,SkScalar x,SkScalar y)166     static bool hittest(const SkPoint& pt, SkScalar x, SkScalar y) {
167         return SkPoint::Length(pt.fX - x, pt.fY - y) < SkIntToScalar(5);
168     }
169 
onFindClickHandler(SkScalar x,SkScalar y,skui::ModifierKey modi)170     Sample::Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey modi) override {
171         modi &= ~skui::ModifierKey::kFirstPress;  // ignore this
172         if (skui::ModifierKey::kShift == modi) {
173             return new PtClick(-1);
174         }
175         if (skui::ModifierKey::kControl == modi) {
176             return new PtClick(-2);
177         }
178         SkPoint clickPoint = {x, y};
179         fInvMatrix.mapPoints(&clickPoint, 1);
180         for (size_t i = 0; i < SK_ARRAY_COUNT(fPts); i++) {
181             if (hittest(fPts[i], clickPoint.fX, clickPoint.fY)) {
182                 return new PtClick((int)i);
183             }
184         }
185         return nullptr;
186     }
187 
onClick(Click * click)188     bool onClick(Click* click) override {
189         PtClick* ptClick = (PtClick*)click;
190         if (ptClick->fIndex >= 0) {
191             fPts[ptClick->fIndex].set(click->fCurr.fX , click->fCurr.fY );
192         } else if (-1 == ptClick->fIndex) {
193             SkScalar xDiff = click->fPrev.fX - click->fCurr.fX;
194             SkScalar yDiff = click->fPrev.fY - click->fCurr.fY;
195             fTexX += xDiff * fTexScale;
196             fTexY += yDiff * fTexScale;
197         } else if (-2 == ptClick->fIndex) {
198             SkScalar yDiff = click->fCurr.fY - click->fPrev.fY;
199             fTexScale += yDiff / 10.0f;
200             fTexScale = std::max(0.1f, std::min(20.f, fTexScale));
201         }
202         return true;
203     }
204 
205 private:
206     typedef Sample INHERITED;
207 };
208 
209 DEF_SAMPLE( return new PerlinPatchView(); )
210