33 Stage(
SkSize size,
int startingObjectCount,
int objectIncrement)
42 for (
size_t i = 0; i <
fObjects.size(); ++i) {
48 for (
size_t i = 0; i <
fObjects.size(); ++i) {
93 std::vector<std::unique_ptr<MMObject>>
fObjects;
102 return fStage->onChar(uni);
110 return fStage->animate(nanos);
120float time_counter_value(
double nanos,
float factor) {
121 constexpr double kMillisPerNano = 0.0000001;
122 return static_cast<float>(nanos*kMillisPerNano)/factor;
125float time_fractional_value(
double nanos,
float cycleLengthMs) {
133void canonicalize_angle(
float* startAngle,
float* endAngle) {
134 float newStartAngle =
SkScalarMod(*startAngle, 360.f);
137 *endAngle = *endAngle +
delta;
141float adjust_end_angle(
float startAngle,
float endAngle,
bool ccw) {
142 float newEndAngle = endAngle;
143 if (!ccw && endAngle - startAngle >= 360.f) {
145 }
else if (ccw && startAngle - endAngle >= 360.f) {
147 }
else if (!ccw && startAngle > endAngle) {
149 }
else if (ccw && startAngle < endAngle) {
173 static constexpr SkColor kColors[] = {
174 0xffe01040, 0xff10c030, 0xff744cba, 0xffe05010
176 fColor = kColors[circle];
177 fLineWidth = std::pow(random->
nextF(), 12) * 20 + 3;
178 fOmega = random->
nextF() * 3 + 0.2f;
180 fCosTheta = std::cos(theta);
181 fSinTheta = std::sin(theta);
183 params.fCircleRadius * fSinTheta);
184 fLength =
params.fLineMinimum;
185 fLength += std::pow(random->
nextF(), 8) *
params.fLineLengthMaximum;
186 fSegmentDirection = random->
nextF() > 0.5 ? -1 : 1;
193 paint.setAntiAlias(
true);
194 paint.setColor(fColor);
195 paint.setStrokeWidth(fLineWidth);
199 fStart.
fX + fSegmentDirection * fLength * fCosTheta,
200 fStart.
fY + fSegmentDirection * fLength * fSinTheta
206 fLength += std::sin(time_counter_value(nanos, 100) * fOmega);
217 float fSegmentDirection;
223 :
Stage(size, 5000, 1000) {
243 float dx = fTwoFifthsSizeX * std::cos(fCurrentAngle);
244 float dy = fTwoFifthsSizeX * std::sin(fCurrentAngle);
246 float colorStopStep =
SkScalarInterp(-.1f, .1f, fCurrentGradientStep);
251 (brightnessStep << 1),
254 (brightnessStep << 1),
269 0.2f + colorStopStep,
270 0.8f - colorStopStep,
277 paint.setAntiAlias(
true);
278 paint.setStrokeWidth(15);
279 for (
int i = 0; i < 4; i++) {
280 const SkColor strokeColors[] = {
281 0xffe01040, 0xff10c030, 0xff744cba, 0xffe05010
284 0xff70051d, 0xff016112, 0xff2F0C6E, 0xff702701
286 paint.setColor(strokeColors[i]);
293 paint.setColor(fillColors[i]);
296 paint.setShader(gradientShader);
298 paint.setShader(
nullptr);
305 fCurrentAngle = time_fractional_value(nanos, 3000) *
SK_ScalarPI * 2;
306 fCurrentGradientStep = 0.5f + 0.5f * std::sin(
307 time_fractional_value(nanos, 5000) *
SK_ScalarPI * 2);
314 return std::make_unique<CanvasLineSegment>(&
fRandom,fParams);
319 float fTwoFifthsSizeX;
320 float fCurrentAngle = 0;
321 float fCurrentGradientStep = 0.5f;
331 constexpr float kMaxX = 6;
332 constexpr float kMaxY = 3;
334 const SkColor baseColors[3] = {
335 0xff101010, 0xff808080, 0xffc0c0c0
337 const SkColor bonusColors[3] = {
338 0xffe01040, 0xff10c030, 0xffe05010
340 float distanceX = size.fWidth /
kMaxX;
341 float distanceY = size.fHeight / (
kMaxY + 1);
345 fPoint =
SkPoint::Make(distanceX * (randX + (randY % 2) / 2), distanceY * (randY + 0.5f));
347 fRadius = 20 + std::pow(random->
nextF(), 5) * (std::min(distanceX, distanceY) / 1.8f);
350 fOmega = (random->
nextF() - 0.5f) * 0.3f;
351 fCounterclockwise = random->
nextBool();
357 fColor = colorIndex == 3 ? bonusColor : baseColors[colorIndex];
358 fLineWidth = 1 + std::pow(random->
nextF(), 5) * 30;
366 paint.setAntiAlias(
true);
367 paint.setColor(fColor);
369 2*fRadius, 2*fRadius);
371 float startAngleDeg = fStartAngle * 180.f /
SK_ScalarPI;
372 float endAngleDeg = fEndAngle * 180.f /
SK_ScalarPI;
373 canonicalize_angle(&startAngleDeg, &endAngleDeg);
374 endAngleDeg = adjust_end_angle(startAngleDeg, endAngleDeg, fCounterclockwise);
376 float sweepAngle = startAngleDeg - endAngleDeg;
379 paint.setStrokeWidth(fLineWidth);
381 canvas->
drawArc(arcRect, startAngleDeg, sweepAngle,
false,
paint);
386 canvas->
drawArc(arcRect, startAngleDeg, sweepAngle,
true,
paint);
391 fStartAngle += fOmega;
392 fEndAngle += fOmega / 2;
403 bool fCounterclockwise;
410 :
Stage(size, 1000, 200) {
433 const SkSize kGridSize = { 80, 40 };
434 const SkPoint kGridCenter = { 40, 20 };
442 SkPoint coordinate = prevCoord ? *prevCoord : kGridCenter;
446 if (coordinate.
fX < 0 || coordinate.
fX > kGridSize.
width())
448 if (coordinate.
fY < 0 || coordinate.
fY > kGridSize.
height())
453 (coordinate.
fY + 0.5f) * size.height() / (kGridSize.
height() + 1));
454 fCoordinate = coordinate;
460 0xff101010, 0xff808080, 0xffc0c0c0, 0xff101010, 0xff808080, 0xffc0c0c0, 0xffe01040
464 fWidth = std::pow(random->
nextF(), 5) * 20 + 1;
473 path->lineTo(fPoint);
509 path->quadTo(fPoint2, this->
getPoint());
534 path->cubicTo(fPoint2, fPoint3, this->
getPoint());
547 return std::make_unique<CanvasQuadraticSegment>(random, size,
prev);
550 return std::make_unique<CanvasBezierSegment>(random, size,
prev);
555 return std::make_unique<CanvasLinePoint>(random, size,
prev);
563 :
Stage(size, 5000, 1000) {
574 paint.setAntiAlias(
true);
576 for (
size_t i = 0; i <
fObjects.size(); ++i) {
583 object->append(¤tPath);
595 object->toggleIsSplit();
std::unique_ptr< CanvasLinePoint > make_line_path(SkRandom *random, SkSize size, SkPoint *prev)
static float prev(float f)
static constexpr SkColor SkColorSetARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b)
constexpr SkColor SK_ColorWHITE
#define sk_float_ceil2int(x)
#define SkScalarMod(x, y)
#define SkScalarRoundToInt(x)
static SkScalar SkScalarInterp(SkScalar A, SkScalar B, SkScalar t)
static SkScalar SkScalarFraction(SkScalar x)
std::unique_ptr< MMObject > createObject() override
CanvasArcStage(SkSize size)
~CanvasArcStage() override=default
void draw(SkCanvas *canvas) override
void animate(double) override
CanvasArc(SkRandom *random, SkSize size)
void draw(SkCanvas *canvas) override
~CanvasArc() override=default
void load(SkScalar w, SkScalar h) override
CanvasBezierSegment(SkRandom *random, SkSize size, SkPoint *prev)
void append(SkPath *path) override
bool animate(double) override
std::unique_ptr< MMObject > createObject() override
CanvasLinePathStage(SkSize size)
~CanvasLinePathStage() override=default
void draw(SkCanvas *canvas) override
virtual void append(SkPath *path)
CanvasLinePoint(SkRandom *random, SkSize size, SkPoint *prev)
~CanvasLinePoint() override=default
void animate(double) override
void draw(SkCanvas *) override
void setEndPoint(SkRandom *random, SkSize size, SkPoint *prevCoord)
bool animate(double nanos) override
void draw(SkCanvas *canvas) override
CanvasLineSegmentStage(SkSize size)
std::unique_ptr< MMObject > createObject() override
~CanvasLineSegmentStage() override=default
~CanvasLineSegment() override=default
void draw(SkCanvas *canvas) override
void animate(double nanos) override
CanvasLineSegment(SkRandom *random, const LineSegmentParams ¶ms)
void load(SkScalar w, SkScalar h) override
void append(SkPath *path) override
CanvasQuadraticSegment(SkRandom *random, SkSize size, SkPoint *prev)
virtual void animate(double)=0
virtual void draw(SkCanvas *canvas)=0
virtual ~MMObject()=default
std::unique_ptr< Stage > fStage
bool onChar(SkUnichar uni) override
MotionMarkSlide()=default
void draw(SkCanvas *canvas) override
bool animate(double nanos) override
void load(SkScalar w, SkScalar h) override
void drawLine(SkScalar x0, SkScalar y0, SkScalar x1, SkScalar y1, const SkPaint &paint)
void clear(SkColor color)
void drawArc(const SkRect &oval, SkScalar startAngle, SkScalar sweepAngle, bool useCenter, const SkPaint &paint)
void drawPath(const SkPath &path, const SkPaint &paint)
static sk_sp< SkShader > MakeLinear(const SkPoint pts[2], const SkColor colors[], const SkScalar pos[], int count, SkTileMode mode, uint32_t flags=0, const SkMatrix *localMatrix=nullptr)
@ kStroke_Style
set to stroke geometry
@ kFill_Style
set to fill geometry
SkPath & moveTo(SkScalar x, SkScalar y)
float nextRangeF(float min, float max)
uint32_t nextRangeU(uint32_t min, uint32_t max)
virtual void draw(SkCanvas *canvas)
virtual bool animate(double nanos)
std::vector< std::unique_ptr< MMObject > > fObjects
virtual bool onChar(SkUnichar uni)
virtual std::unique_ptr< MMObject > createObject()=0
Stage(SkSize size, int startingObjectCount, int objectIncrement)
const EmbeddedViewParams * params
SkPoint fCircleCenters[4]
static constexpr SkPoint Make(float x, float y)
static constexpr SkRect MakeXYWH(float x, float y, float w, float h)
static constexpr SkSize Make(SkScalar w, SkScalar h)