blob: b813483334d007be6f955bfbecc9847b9c0e3ed8 [file] [log] [blame]
/*
* 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/gm.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkBlurTypes.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkMaskFilter.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPath.h"
#include "include/core/SkPathEffect.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkScalar.h"
#include "include/core/SkShader.h"
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/core/SkTileMode.h"
#include "include/core/SkTypes.h"
#include "include/effects/SkDashPathEffect.h"
#include "include/effects/SkGradientShader.h"
#include "include/private/base/SkTArray.h"
#include "tools/ToolUtils.h"
#include <initializer_list>
constexpr int kNumColumns = 6;
constexpr int kNumRows = 8;
constexpr int kRadius = 40; // radius of the snowflake
constexpr int kPad = 5; // padding on both sides of the snowflake
constexpr int kNumSpokes = 6;
constexpr SkScalar kStrokeWidth = 5.0f;
static void draw_fins(SkCanvas* canvas, const SkPoint& offset, float angle, const SkPaint& paint) {
SkScalar cos, sin;
// first fin
sin = SkScalarSin(angle + (SK_ScalarPI/4));
cos = SkScalarCos(angle + (SK_ScalarPI/4));
sin *= kRadius / 2.0f;
cos *= kRadius / 2.0f;
SkPath p;
p.moveTo(offset.fX, offset.fY);
p.lineTo(offset.fX + cos, offset.fY + sin);
canvas->drawPath(p, paint);
// second fin
sin = SkScalarSin(angle - (SK_ScalarPI/4));
cos = SkScalarCos(angle - (SK_ScalarPI/4));
sin *= kRadius / 2.0f;
cos *= kRadius / 2.0f;
p.reset();
p.moveTo(offset.fX, offset.fY);
p.lineTo(offset.fX + cos, offset.fY + sin);
canvas->drawPath(p, paint);
}
// draw a snowflake centered at the origin
static void draw_snowflake(SkCanvas* canvas, const SkPaint& paint) {
canvas->clipRect(SkRect::MakeLTRB(-kRadius-kPad, -kRadius-kPad, kRadius+kPad, kRadius+kPad));
SkScalar sin, cos, angle = 0.0f;
for (int i = 0; i < kNumSpokes/2; ++i, angle += SK_ScalarPI/(kNumSpokes/2)) {
sin = SkScalarSin(angle);
cos = SkScalarCos(angle);
sin *= kRadius;
cos *= kRadius;
// main spoke
SkPath p;
p.moveTo(-cos, -sin);
p.lineTo(cos, sin);
canvas->drawPath(p, paint);
// fins on positive side
const SkPoint posOffset = SkPoint::Make(0.5f * cos, 0.5f * sin);
draw_fins(canvas, posOffset, angle, paint);
// fins on negative side
const SkPoint negOffset = SkPoint::Make(-0.5f * cos, -0.5f * sin);
draw_fins(canvas, negOffset, angle+SK_ScalarPI, paint);
}
}
static void draw_row(SkCanvas* canvas, const SkPaint& paint, const SkMatrix& localMatrix) {
canvas->translate(kRadius+kPad, 0.0f);
for (auto cap : { SkPaint::kButt_Cap, SkPaint::kRound_Cap, SkPaint::kSquare_Cap }) {
for (auto isAA : { true, false }) {
SkPaint tmp(paint);
tmp.setStrokeWidth(kStrokeWidth);
tmp.setStyle(SkPaint::kStroke_Style);
tmp.setStrokeCap(cap);
tmp.setAntiAlias(isAA);
int saveCount = canvas->save();
canvas->concat(localMatrix);
draw_snowflake(canvas, tmp);
canvas->restoreToCount(saveCount);
canvas->translate(2*(kRadius+kPad), 0.0f);
}
}
}
namespace skiagm {
// This GM exercises the special case of a stroked lines.
// Various shaders are applied to ensure the coordinate spaces work out right.
class StrokedLinesGM : public GM {
public:
StrokedLinesGM() { this->setBGColor(ToolUtils::color_to_565(0xFF1A65D7)); }
protected:
SkString onShortName() override {
return SkString("strokedlines");
}
SkISize onISize() override {
return SkISize::Make(kNumColumns * (2*kRadius+2*kPad), kNumRows * (2*kRadius+2*kPad));
}
void onOnceBeforeDraw() override {
// paints
{
// basic white
SkPaint p;
p.setColor(SK_ColorWHITE);
fPaints.push_back(p);
}
{
// gradient
SkColor colors[] = { SK_ColorRED, SK_ColorGREEN };
SkPoint pts[] = { {-kRadius-kPad, -kRadius-kPad }, { kRadius+kPad, kRadius+kPad } };
SkPaint p;
p.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp));
fPaints.push_back(p);
}
{
// dashing
SkScalar intervals[] = { kStrokeWidth, kStrokeWidth };
int intervalCount = (int) std::size(intervals);
SkPaint p;
p.setColor(SK_ColorWHITE);
p.setPathEffect(SkDashPathEffect::Make(intervals, intervalCount, kStrokeWidth));
fPaints.push_back(p);
}
{
// Bitmap shader
SkBitmap bm;
bm.allocN32Pixels(2, 2);
*bm.getAddr32(0, 0) = *bm.getAddr32(1, 1) = 0xFFFFFFFF;
*bm.getAddr32(1, 0) = *bm.getAddr32(0, 1) = 0x0;
SkMatrix m;
m.setRotate(12.0f);
m.preScale(3.0f, 3.0f);
SkPaint p;
p.setShader(bm.makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat,
SkSamplingOptions(), m));
fPaints.push_back(p);
}
{
// blur
SkPaint p;
p.setColor(SK_ColorWHITE);
p.setMaskFilter(SkMaskFilter::MakeBlur(kOuter_SkBlurStyle, 3.0f));
fPaints.push_back(p);
}
// matrices
{
// rotation
SkMatrix m;
m.setRotate(12.0f);
fMatrices.push_back(m);
}
{
// skew
SkMatrix m;
m.setSkew(0.3f, 0.5f);
fMatrices.push_back(m);
}
{
// perspective
SkMatrix m;
m.reset();
m.setPerspX(-SK_Scalar1 / 300);
m.setPerspY(SK_Scalar1 / 300);
fMatrices.push_back(m);
}
SkASSERT(kNumRows == fPaints.size() + fMatrices.size());
}
void onDraw(SkCanvas* canvas) override {
canvas->translate(0, kRadius+kPad);
for (int i = 0; i < fPaints.size(); ++i) {
int saveCount = canvas->save();
draw_row(canvas, fPaints[i], SkMatrix::I());
canvas->restoreToCount(saveCount);
canvas->translate(0, 2*(kRadius+kPad));
}
for (int i = 0; i < fMatrices.size(); ++i) {
int saveCount = canvas->save();
draw_row(canvas, fPaints[0], fMatrices[i]);
canvas->restoreToCount(saveCount);
canvas->translate(0, 2*(kRadius+kPad));
}
}
private:
SkTArray<SkPaint> fPaints;
SkTArray<SkMatrix> fMatrices;
using INHERITED = GM;
};
//////////////////////////////////////////////////////////////////////////////
DEF_GM(return new StrokedLinesGM;)
} // namespace skiagm