1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
/*
* Copyright 2016 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "gm.h"
#include "sk_tool_utils.h"
#include "SkAnimTimer.h"
#include "SkBlurImageFilter.h"
#include "SkRandom.h"
#include "SkRRect.h"
static const SkScalar kBlurMax = 7.0f;
static const int kNumNodes = 30;
static const int kWidth = 512;
static const int kHeight = 512;
static const SkScalar kBlurAnimationDuration = 4.0f; // in secs
// This GM draws a lot of layers with animating BlurImageFilters
class AnimatedImageBlurs : public skiagm::GM {
public:
AnimatedImageBlurs() : fLastTime(0.0f) {
this->setBGColor(sk_tool_utils::color_to_565(0xFFCCCCCC));
}
protected:
bool runAsBench() const override { return true; }
SkString onShortName() override { return SkString("animated-image-blurs"); }
SkISize onISize() override { return SkISize::Make(kWidth, kHeight); }
void onOnceBeforeDraw() override {
for (int i = 0; i < kNumNodes; ++i) {
fNodes[i].init(&fRand);
}
}
void onDraw(SkCanvas* canvas) override {
SkPaint paint;
paint.setAntiAlias(true);
for (int i = 0; i < kNumNodes; ++i) {
SkPaint layerPaint;
layerPaint.setImageFilter(SkBlurImageFilter::Make(fNodes[i].sigma(),
fNodes[i].sigma(),
nullptr));
canvas->saveLayer(nullptr, &layerPaint);
// The rect is outset to block the circle case
SkRect rect = SkRect::MakeLTRB(fNodes[i].pos().fX - fNodes[i].size()-0.5f,
fNodes[i].pos().fY - fNodes[i].size()-0.5f,
fNodes[i].pos().fX + fNodes[i].size()+0.5f,
fNodes[i].pos().fY + fNodes[i].size()+0.5f);
SkRRect rrect = SkRRect::MakeRectXY(rect, fNodes[i].size(), fNodes[i].size());
canvas->drawRRect(rrect, paint);
canvas->restore();
}
}
bool onAnimate(const SkAnimTimer& timer) override {
if (0.0f != fLastTime) {
for (int i = 0; i < kNumNodes; ++i) {
fNodes[i].update(timer, fLastTime);
}
}
fLastTime = timer.secs();
return true;
}
private:
class Node {
public:
Node()
: fSize(0.0f)
, fPos { 0.0f, 0.0f }
, fDir { 1.0f, 0.0f }
, fBlurOffset(0.0f)
, fBlur(fBlurOffset)
, fSpeed(0.0f) {
}
void init(SkRandom* rand) {
fSize = rand->nextRangeF(10.0f, 60.f);
fPos.fX = rand->nextRangeF(fSize, kWidth - fSize);
fPos.fY = rand->nextRangeF(fSize, kHeight - fSize);
fDir.fX = rand->nextRangeF(-1.0f, 1.0f);
fDir.fY = SkScalarSqrt(1.0f - fDir.fX * fDir.fX);
if (rand->nextBool()) {
fDir.fY = -fDir.fY;
}
fBlurOffset = rand->nextRangeF(0.0f, kBlurMax);
fBlur = fBlurOffset;
fSpeed = rand->nextRangeF(20.0f, 60.0f);
}
void update(const SkAnimTimer& timer, SkScalar lastTime) {
SkScalar deltaTime = timer.secs() - lastTime;
fPos.fX += deltaTime * fSpeed * fDir.fX;
fPos.fY += deltaTime * fSpeed * fDir.fY;
if (fPos.fX >= kWidth || fPos.fX < 0.0f) {
fPos.fX = SkTPin<SkScalar>(fPos.fX, 0.0f, kWidth);
fDir.fX = -fDir.fX;
}
if (fPos.fY >= kHeight || fPos.fY < 0.0f) {
fPos.fY = SkTPin<SkScalar>(fPos.fY, 0.0f, kHeight);
fDir.fY = -fDir.fY;
}
fBlur = timer.pingPong(kBlurAnimationDuration, fBlurOffset, 0.0f, kBlurMax);
}
SkScalar sigma() const { return fBlur; }
const SkPoint& pos() const { return fPos; }
SkScalar size() const { return fSize; }
private:
SkScalar fSize;
SkPoint fPos;
SkVector fDir;
SkScalar fBlurOffset;
SkScalar fBlur;
SkScalar fSpeed;
};
Node fNodes[kNumNodes];
SkRandom fRand;
SkScalar fLastTime;
typedef GM INHERITED;
};
//////////////////////////////////////////////////////////////////////////////
DEF_GM(return new AnimatedImageBlurs;)
|
