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/core/SkDrawable.h"
10 #include "include/core/SkPath.h"
11 #include "include/core/SkRSXform.h"
12 #include "include/core/SkSurface.h"
13 #include "include/utils/SkRandom.h"
14 #include "include/utils/SkTextUtils.h"
15 #include "samplecode/Sample.h"
16
17 typedef void (*DrawAtlasProc)(SkCanvas*, SkImage*, const SkRSXform[], const SkRect[],
18 const SkColor[], int, const SkRect*, const SkPaint*);
19
draw_atlas(SkCanvas * canvas,SkImage * atlas,const SkRSXform xform[],const SkRect tex[],const SkColor colors[],int count,const SkRect * cull,const SkPaint * paint)20 static void draw_atlas(SkCanvas* canvas, SkImage* atlas, const SkRSXform xform[],
21 const SkRect tex[], const SkColor colors[], int count, const SkRect* cull,
22 const SkPaint* paint) {
23 canvas->drawAtlas(atlas, xform, tex, colors, count, SkBlendMode::kModulate, cull, paint);
24 }
25
draw_atlas_sim(SkCanvas * canvas,SkImage * atlas,const SkRSXform xform[],const SkRect tex[],const SkColor colors[],int count,const SkRect * cull,const SkPaint * paint)26 static void draw_atlas_sim(SkCanvas* canvas, SkImage* atlas, const SkRSXform xform[],
27 const SkRect tex[], const SkColor colors[], int count, const SkRect* cull,
28 const SkPaint* paint) {
29 for (int i = 0; i < count; ++i) {
30 SkMatrix matrix;
31 matrix.setRSXform(xform[i]);
32
33 canvas->save();
34 canvas->concat(matrix);
35 canvas->drawImageRect(atlas, tex[i], tex[i].makeOffset(-tex[i].x(), -tex[i].y()), paint,
36 SkCanvas::kFast_SrcRectConstraint);
37 canvas->restore();
38 }
39 }
40
make_atlas(int atlasSize,int cellSize)41 static sk_sp<SkImage> make_atlas(int atlasSize, int cellSize) {
42 SkImageInfo info = SkImageInfo::MakeN32Premul(atlasSize, atlasSize);
43 auto surface(SkSurface::MakeRaster(info));
44 SkCanvas* canvas = surface->getCanvas();
45
46 SkPaint paint;
47 SkRandom rand;
48
49 const SkScalar half = cellSize * SK_ScalarHalf;
50 const char* s = "01234567890!@#$%^&*=+<>?abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
51 SkFont font(nullptr, 28);
52
53 int i = 0;
54 for (int y = 0; y < atlasSize; y += cellSize) {
55 for (int x = 0; x < atlasSize; x += cellSize) {
56 paint.setColor(rand.nextU());
57 paint.setAlpha(0xFF);
58 int index = i % strlen(s);
59 SkTextUtils::Draw(canvas, &s[index], 1, SkTextEncoding::kUTF8,
60 x + half, y + half + half/2, font, paint,
61 SkTextUtils::kCenter_Align);
62 i += 1;
63 }
64 }
65 return surface->makeImageSnapshot();
66 }
67
68 class DrawAtlasDrawable : public SkDrawable {
69 enum {
70 kMaxScale = 2,
71 kCellSize = 32,
72 kAtlasSize = 512,
73 };
74
75 struct Rec {
76 SkPoint fCenter;
77 SkVector fVelocity;
78 SkScalar fScale;
79 SkScalar fDScale;
80 SkScalar fRadian;
81 SkScalar fDRadian;
82 SkScalar fAlpha;
83 SkScalar fDAlpha;
84
advanceDrawAtlasDrawable::Rec85 void advance(const SkRect& bounds) {
86 fCenter += fVelocity;
87 if (fCenter.fX > bounds.right()) {
88 SkASSERT(fVelocity.fX > 0);
89 fVelocity.fX = -fVelocity.fX;
90 } else if (fCenter.fX < bounds.left()) {
91 SkASSERT(fVelocity.fX < 0);
92 fVelocity.fX = -fVelocity.fX;
93 }
94 if (fCenter.fY > bounds.bottom()) {
95 if (fVelocity.fY > 0) {
96 fVelocity.fY = -fVelocity.fY;
97 }
98 } else if (fCenter.fY < bounds.top()) {
99 if (fVelocity.fY < 0) {
100 fVelocity.fY = -fVelocity.fY;
101 }
102 }
103
104 fScale += fDScale;
105 if (fScale > 2 || fScale < SK_Scalar1/2) {
106 fDScale = -fDScale;
107 }
108
109 fRadian += fDRadian;
110 fRadian = SkScalarMod(fRadian, 2 * SK_ScalarPI);
111
112 fAlpha += fDAlpha;
113 if (fAlpha > 1) {
114 fAlpha = 1;
115 fDAlpha = -fDAlpha;
116 } else if (fAlpha < 0) {
117 fAlpha = 0;
118 fDAlpha = -fDAlpha;
119 }
120 }
121
asRSXformDrawAtlasDrawable::Rec122 SkRSXform asRSXform() const {
123 return SkRSXform::MakeFromRadians(fScale, fRadian, fCenter.x(), fCenter.y(),
124 SkScalarHalf(kCellSize), SkScalarHalf(kCellSize));
125 }
126 };
127
128 DrawAtlasProc fProc;
129
130 enum {
131 N = 256,
132 };
133
134 sk_sp<SkImage> fAtlas;
135 Rec fRec[N];
136 SkRect fTex[N];
137 SkRect fBounds;
138 bool fUseColors;
139
140 public:
DrawAtlasDrawable(DrawAtlasProc proc,const SkRect & r)141 DrawAtlasDrawable(DrawAtlasProc proc, const SkRect& r)
142 : fProc(proc), fBounds(r), fUseColors(false)
143 {
144 SkRandom rand;
145 fAtlas = make_atlas(kAtlasSize, kCellSize);
146 const SkScalar kMaxSpeed = 5;
147 const SkScalar cell = SkIntToScalar(kCellSize);
148 int i = 0;
149 for (int y = 0; y < kAtlasSize; y += kCellSize) {
150 for (int x = 0; x < kAtlasSize; x += kCellSize) {
151 const SkScalar sx = SkIntToScalar(x);
152 const SkScalar sy = SkIntToScalar(y);
153 fTex[i].setXYWH(sx, sy, cell, cell);
154
155 fRec[i].fCenter.set(sx + cell/2, sy + 3*cell/4);
156 fRec[i].fVelocity.fX = rand.nextSScalar1() * kMaxSpeed;
157 fRec[i].fVelocity.fY = rand.nextSScalar1() * kMaxSpeed;
158 fRec[i].fScale = 1;
159 fRec[i].fDScale = rand.nextSScalar1() / 16;
160 fRec[i].fRadian = 0;
161 fRec[i].fDRadian = rand.nextSScalar1() / 8;
162 fRec[i].fAlpha = rand.nextUScalar1();
163 fRec[i].fDAlpha = rand.nextSScalar1() / 10;
164 i += 1;
165 }
166 }
167 }
168
toggleUseColors()169 void toggleUseColors() {
170 fUseColors = !fUseColors;
171 }
172
173 protected:
onDraw(SkCanvas * canvas)174 void onDraw(SkCanvas* canvas) override {
175 SkRSXform xform[N];
176 SkColor colors[N];
177
178 for (int i = 0; i < N; ++i) {
179 fRec[i].advance(fBounds);
180 xform[i] = fRec[i].asRSXform();
181 if (fUseColors) {
182 colors[i] = SkColorSetARGB((int)(fRec[i].fAlpha * 0xFF), 0xFF, 0xFF, 0xFF);
183 }
184 }
185 SkPaint paint;
186 paint.setFilterQuality(kLow_SkFilterQuality);
187
188 const SkRect cull = this->getBounds();
189 const SkColor* colorsPtr = fUseColors ? colors : nullptr;
190 fProc(canvas, fAtlas.get(), xform, fTex, colorsPtr, N, &cull, &paint);
191 }
192
onGetBounds()193 SkRect onGetBounds() override {
194 const SkScalar border = kMaxScale * kCellSize;
195 SkRect r = fBounds;
196 r.outset(border, border);
197 return r;
198 }
199
200 private:
201 typedef SkDrawable INHERITED;
202 };
203
204 class DrawAtlasView : public Sample {
205 const char* fName;
206 DrawAtlasProc fProc;
207 sk_sp<DrawAtlasDrawable> fDrawable;
208
209 public:
DrawAtlasView(const char name[],DrawAtlasProc proc)210 DrawAtlasView(const char name[], DrawAtlasProc proc) : fName(name), fProc(proc) { }
211
212 protected:
name()213 SkString name() override { return SkString(fName); }
214
onChar(SkUnichar uni)215 bool onChar(SkUnichar uni) override {
216 switch (uni) {
217 case 'C': fDrawable->toggleUseColors(); return true;
218 default: break;
219 }
220 return false;
221 }
222
onOnceBeforeDraw()223 void onOnceBeforeDraw() override {
224 fDrawable = sk_make_sp<DrawAtlasDrawable>(fProc, SkRect::MakeWH(640, 480));
225 }
226
onDrawContent(SkCanvas * canvas)227 void onDrawContent(SkCanvas* canvas) override {
228 canvas->drawDrawable(fDrawable.get());
229 }
230
onAnimate(double)231 bool onAnimate(double /*nanos*/) override { return true; }
232 #if 0
233 // TODO: switch over to use this for our animation
234 bool onAnimate(double nanos) override {
235 SkScalar angle = SkDoubleToScalar(fmod(1e-9 * nanos * 360 / 24, 360));
236 fAnimatingDrawable->setSweep(angle);
237 return true;
238 }
239 #endif
240
241 private:
242 typedef Sample INHERITED;
243 };
244
245 //////////////////////////////////////////////////////////////////////////////
246
247 DEF_SAMPLE( return new DrawAtlasView("DrawAtlas", draw_atlas); )
248 DEF_SAMPLE( return new DrawAtlasView("DrawAtlasSim", draw_atlas_sim); )
249