AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
cdf338247b
skia2/gm/patheffects.cpp
Herb Derby c37b386886 Replace SK_ARRAY_COUNT with std::size() for skia/gm 
Note: in variedtext.cpp:66 changed static_assert to SkASSERT.

Change-Id: I853a2e5563c90c9dde5d6ba5443cc73b664b493d
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/551876
Commit-Queue: Herb Derby <herb@google.com>
Reviewed-by: John Stiles <johnstiles@google.com>
2022-06-21 18:09:30 +00:00

412 lines
12 KiB
C++
Raw Blame History

/*
* Copyright 2012 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/SkCanvas.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPathBuilder.h"
#include "include/core/SkPathEffect.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkScalar.h"
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/core/SkTypes.h"
#include "include/effects/Sk1DPathEffect.h"
#include "include/effects/Sk2DPathEffect.h"
#include "include/effects/SkCornerPathEffect.h"
#include "include/effects/SkDashPathEffect.h"
#include "include/effects/SkDiscretePathEffect.h"
#include "include/effects/SkOpPathEffect.h"
#include "include/pathops/SkPathOps.h"
#include <initializer_list>
namespace skiagm {
static void compose_pe(SkPaint* paint) {
SkPathEffect* pe = paint->getPathEffect();
sk_sp<SkPathEffect> corner = SkCornerPathEffect::Make(25);
sk_sp<SkPathEffect> compose;
if (pe) {
compose = SkPathEffect::MakeCompose(sk_ref_sp(pe), corner);
} else {
compose = corner;
}
paint->setPathEffect(compose);
}
static void hair_pe(SkPaint* paint) {
paint->setStrokeWidth(0);
}
static void hair2_pe(SkPaint* paint) {
paint->setStrokeWidth(0);
compose_pe(paint);
}
static void stroke_pe(SkPaint* paint) {
paint->setStrokeWidth(12);
compose_pe(paint);
}
static void dash_pe(SkPaint* paint) {
SkScalar inter[] = { 20, 10, 10, 10 };
paint->setStrokeWidth(12);
paint->setPathEffect(SkDashPathEffect::Make(inter, std::size(inter), 0));
compose_pe(paint);
}
constexpr int gXY[] = {
4, 0, 0, -4, 8, -4, 12, 0, 8, 4, 0, 4
};
static SkPath scale(const SkPath& path, SkScalar scale) {
SkMatrix m;
m.setScale(scale, scale);
return path.makeTransform(m);
}
static void one_d_pe(SkPaint* paint) {
SkPathBuilder b;
b.moveTo(SkIntToScalar(gXY[0]), SkIntToScalar(gXY[1]));
for (unsigned i = 2; i < std::size(gXY); i += 2) {
b.lineTo(SkIntToScalar(gXY[i]), SkIntToScalar(gXY[i+1]));
}
b.close().offset(SkIntToScalar(-6), 0);
SkPath path = scale(b.detach(), 1.5f);
paint->setPathEffect(SkPath1DPathEffect::Make(path, SkIntToScalar(21), 0,
SkPath1DPathEffect::kRotate_Style));
compose_pe(paint);
}
typedef void (*PE_Proc)(SkPaint*);
constexpr PE_Proc gPE[] = { hair_pe, hair2_pe, stroke_pe, dash_pe, one_d_pe };
static void fill_pe(SkPaint* paint) {
paint->setStyle(SkPaint::kFill_Style);
paint->setPathEffect(nullptr);
}
static void discrete_pe(SkPaint* paint) {
paint->setPathEffect(SkDiscretePathEffect::Make(10, 4));
}
static sk_sp<SkPathEffect> MakeTileEffect() {
SkMatrix m;
m.setScale(SkIntToScalar(12), SkIntToScalar(12));
return SkPath2DPathEffect::Make(m, SkPath::Circle(0,0,5));
}
static void tile_pe(SkPaint* paint) {
paint->setPathEffect(MakeTileEffect());
}
constexpr PE_Proc gPE2[] = { fill_pe, discrete_pe, tile_pe };
class PathEffectGM : public GM {
public:
PathEffectGM() {}
protected:
SkString onShortName() override {
return SkString("patheffect");
}
SkISize onISize() override { return SkISize::Make(800, 600); }
void onDraw(SkCanvas* canvas) override {
SkPaint paint;
paint.setAntiAlias(true);
paint.setStyle(SkPaint::kStroke_Style);
SkPath path = SkPath::Polygon({
{20, 20},
{70, 120},
{120, 30},
{170, 80},
{240, 50},
}, false);
canvas->save();
for (size_t i = 0; i < std::size(gPE); i++) {
gPE[i](&paint);
canvas->drawPath(path, paint);
canvas->translate(0, 75);
}
canvas->restore();
path.reset();
SkRect r = { 0, 0, 250, 120 };
path = SkPathBuilder().addOval(r, SkPathDirection::kCW)
.addRect(r.makeInset(50, 50), SkPathDirection::kCCW)
.detach();
canvas->translate(320, 20);
for (size_t i = 0; i < std::size(gPE2); i++) {
gPE2[i](&paint);
canvas->drawPath(path, paint);
canvas->translate(0, 160);
}
const SkIRect rect = SkIRect::MakeXYWH(20, 20, 60, 60);
for (size_t i = 0; i < std::size(gPE); i++) {
SkPaint p;
p.setAntiAlias(true);
p.setStyle(SkPaint::kFill_Style);
gPE[i](&p);
canvas->drawIRect(rect, p);
canvas->translate(75, 0);
}
}
private:
using INHERITED = GM;
};
DEF_GM( return new PathEffectGM; )
} // namespace skiagm
//////////////////////////////////////////////////////////////////////////////
class ComboPathEfectsGM : public skiagm::GM {
public:
ComboPathEfectsGM() {}
protected:
SkString onShortName() override {
return SkString("combo-patheffects");
}
SkISize onISize() override { return SkISize::Make(360, 630); }
void onDraw(SkCanvas* canvas) override {
SkPath path0 = SkPath::Circle(100, 100, 60),
path1 = SkPathBuilder().moveTo(20, 20)
.cubicTo(20, 180, 140, 0, 140, 140)
.detach();
sk_sp<SkPathEffect> effects[] = {
nullptr,
SkStrokePathEffect::Make(20, SkPaint::kRound_Join, SkPaint::kRound_Cap, 0),
SkMergePathEffect::Make(nullptr,
SkStrokePathEffect::Make(20, SkPaint::kRound_Join,
SkPaint::kRound_Cap, 0),
kDifference_SkPathOp),
SkMergePathEffect::Make(SkMatrixPathEffect::MakeTranslate(50, 30),
SkStrokePathEffect::Make(20, SkPaint::kRound_Join,
SkPaint::kRound_Cap, 0),
kReverseDifference_SkPathOp),
};
SkPaint wireframe;
wireframe.setStyle(SkPaint::kStroke_Style);
wireframe.setAntiAlias(true);
SkPaint paint;
paint.setColor(0xFF8888FF);
paint.setAntiAlias(true);
for (const SkPath& path : { path0, path1 }) {
canvas->save();
for (const sk_sp<SkPathEffect>& pe : effects) {
paint.setPathEffect(pe);
canvas->drawPath(path, paint);
canvas->drawPath(path, wireframe);
canvas->translate(0, 150);
}
canvas->restore();
canvas->translate(180, 0);
}
}
private:
using INHERITED = GM;
};
DEF_GM(return new ComboPathEfectsGM;)
#include "include/effects/SkStrokeAndFillPathEffect.h"
// Test that we can replicate SkPaint::kStrokeAndFill_Style
// with a patheffect. We expect the 2nd and 3rd columns to draw the same.
DEF_SIMPLE_GM(stroke_and_fill_patheffect, canvas, 900, 450) {
const float kStrokeWidth = 20;
typedef SkPath (*Maker)();
const Maker makers[] = {
[]() { return SkPath::Oval({0, 0, 100, 100}, SkPathDirection::kCW); },
[]() { return SkPath::Oval({0, 0, 100, 100}, SkPathDirection::kCCW); },
[]() {
const SkPoint pts[] = {
{0, 0}, {100, 100}, {0, 100}, {100, 0},
};
return SkPath::Polygon(pts, std::size(pts), true);
},
};
const struct {
SkPaint::Style fStyle;
float fWidth;
bool fUsePE;
bool fExpectStrokeAndFill;
} rec[] = {
{ SkPaint::kStroke_Style, 0, false, false },
{ SkPaint::kFill_Style, 0, true, false },
{ SkPaint::kStroke_Style, 0, true, false },
{ SkPaint::kStrokeAndFill_Style, kStrokeWidth, false, true },
{ SkPaint::kStroke_Style, kStrokeWidth, true, true },
{ SkPaint::kStrokeAndFill_Style, kStrokeWidth, true, true },
};
SkPaint paint;
canvas->translate(20, 20);
for (auto maker : makers) {
const SkPath path = maker();
canvas->save();
for (const auto& r : rec) {
paint.setStyle(r.fStyle);
paint.setStrokeWidth(r.fWidth);
paint.setPathEffect(r.fUsePE ? SkStrokeAndFillPathEffect::Make() : nullptr);
paint.setColor(r.fExpectStrokeAndFill ? SK_ColorGRAY : SK_ColorBLACK);
canvas->drawPath(path, paint);
canvas->translate(150, 0);
}
canvas->restore();
canvas->translate(0, 150);
}
}
//////////////////////////////////////////////////////////////////////////////
#include "include/core/SkStrokeRec.h"
#include "src/core/SkPathEffectBase.h"
namespace {
/**
* Example path effect using CTM. This "strokes" a single line segment with some stroke width,
* and then inflates the result by some number of pixels.
*/
class StrokeLineInflated : public SkPathEffectBase {
public:
StrokeLineInflated(float strokeWidth, float pxInflate)
: fRadius(strokeWidth / 2.f), fPxInflate(pxInflate) {}
bool onNeedsCTM() const final { return true; }
bool onFilterPath(SkPath* dst,
const SkPath& src,
SkStrokeRec* rec,
const SkRect* cullR,
const SkMatrix& ctm) const final {
SkASSERT(src.countPoints() == 2);
const SkPoint pts[2] = {src.getPoint(0), src.getPoint(1)};
SkMatrix invCtm;
if (!ctm.invert(&invCtm)) {
return false;
}
// For a line segment, we can just map the (scaled) normal vector to pixel-space,
// increase its length by the desired number of pixels, and then map back to canvas space.
SkPoint n = {pts[0].fY - pts[1].fY, pts[1].fX - pts[0].fX};
if (!n.setLength(fRadius)) {
return false;
}
SkPoint mappedN = ctm.mapVector(n.fX, n.fY);
if (!mappedN.setLength(mappedN.length() + fPxInflate)) {
return false;
}
n = invCtm.mapVector(mappedN.fX, mappedN.fY);
dst->moveTo(pts[0] + n);
dst->lineTo(pts[1] + n);
dst->lineTo(pts[1] - n);
dst->lineTo(pts[0] - n);
dst->close();
rec->setFillStyle();
return true;
}
protected:
void flatten(SkWriteBuffer&) const final {}
private:
SK_FLATTENABLE_HOOKS(StrokeLineInflated)
bool computeFastBounds(SkRect* bounds) const final { return false; }
const float fRadius;
const float fPxInflate;
};
sk_sp<SkFlattenable> StrokeLineInflated::CreateProc(SkReadBuffer&) { return nullptr; }
} // namespace
class CTMPathEffectGM : public skiagm::GM {
protected:
SkString onShortName() override { return SkString("ctmpatheffect"); }
SkISize onISize() override { return SkISize::Make(800, 600); }
// TODO: ctm-aware path effects are currently CPU only
DrawResult onGpuSetup(GrDirectContext* dctx, SkString*) override {
return dctx == nullptr ? DrawResult::kOk : DrawResult::kSkip;
}
void onDraw(SkCanvas* canvas) override {
const float strokeWidth = 16;
const float pxInflate = 0.5f;
sk_sp<SkPathEffect> pathEffect(new StrokeLineInflated(strokeWidth, pxInflate));
SkPath path;
path.moveTo(100, 100);
path.lineTo(200, 200);
// Draw the inflated path, and a scaled version, in blue.
SkPaint paint;
paint.setAntiAlias(true);
paint.setColor(SkColorSetA(SK_ColorBLUE, 0xff));
paint.setPathEffect(pathEffect);
canvas->drawPath(path, paint);
canvas->save();
canvas->translate(150, 0);
canvas->scale(2.5, 0.5f);
canvas->drawPath(path, paint);
canvas->restore();
// Draw the regular stroked version on top in green.
// The inflated version should be visible underneath as a blue "border".
paint.setPathEffect(nullptr);
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeWidth(strokeWidth);
paint.setColor(SkColorSetA(SK_ColorGREEN, 0xff));
canvas->drawPath(path, paint);
canvas->save();
canvas->translate(150, 0);
canvas->scale(2.5, 0.5f);
canvas->drawPath(path, paint);
canvas->restore();
}
private:
using INHERITED = GM;
};
DEF_GM(return new CTMPathEffectGM;)
Reference in New Issue View Git Blame Copy Permalink