c37b386886
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>
647 lines
20 KiB
C++
647 lines
20 KiB
C++
/*
|
|
* Copyright 2011 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/SkColor.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/SkSize.h"
|
|
#include "include/core/SkString.h"
|
|
#include "include/core/SkTypes.h"
|
|
#include "include/effects/SkDashPathEffect.h"
|
|
#include "include/private/SkFloatBits.h"
|
|
#include "include/utils/SkParsePath.h"
|
|
#include "include/utils/SkRandom.h"
|
|
#include "tools/ToolUtils.h"
|
|
|
|
#include <string.h>
|
|
|
|
#define W 400
|
|
#define H 400
|
|
#define N 50
|
|
|
|
constexpr SkScalar SW = SkIntToScalar(W);
|
|
constexpr SkScalar SH = SkIntToScalar(H);
|
|
|
|
static void rnd_rect(SkRect* r, SkPaint* paint, SkRandom& rand) {
|
|
SkScalar x = rand.nextUScalar1() * W;
|
|
SkScalar y = rand.nextUScalar1() * H;
|
|
SkScalar w = rand.nextUScalar1() * (W >> 2);
|
|
SkScalar h = rand.nextUScalar1() * (H >> 2);
|
|
SkScalar hoffset = rand.nextSScalar1();
|
|
SkScalar woffset = rand.nextSScalar1();
|
|
|
|
r->setXYWH(x, y, w, h);
|
|
r->offset(-w/2 + woffset, -h/2 + hoffset);
|
|
|
|
paint->setColor(rand.nextU());
|
|
paint->setAlphaf(1.0f);
|
|
}
|
|
|
|
|
|
class StrokesGM : public skiagm::GM {
|
|
public:
|
|
StrokesGM() {}
|
|
|
|
protected:
|
|
|
|
SkString onShortName() override {
|
|
return SkString("strokes_round");
|
|
}
|
|
|
|
SkISize onISize() override {
|
|
return SkISize::Make(W, H*2);
|
|
}
|
|
|
|
void onDraw(SkCanvas* canvas) override {
|
|
SkPaint paint;
|
|
paint.setStyle(SkPaint::kStroke_Style);
|
|
paint.setStrokeWidth(SkIntToScalar(9)/2);
|
|
|
|
for (int y = 0; y < 2; y++) {
|
|
paint.setAntiAlias(!!y);
|
|
SkAutoCanvasRestore acr(canvas, true);
|
|
canvas->translate(0, SH * y);
|
|
canvas->clipRect(SkRect::MakeLTRB(
|
|
SkIntToScalar(2), SkIntToScalar(2)
|
|
, SW - SkIntToScalar(2), SH - SkIntToScalar(2)
|
|
));
|
|
|
|
SkRandom rand;
|
|
for (int i = 0; i < N; i++) {
|
|
SkRect r;
|
|
rnd_rect(&r, &paint, rand);
|
|
canvas->drawOval(r, paint);
|
|
rnd_rect(&r, &paint, rand);
|
|
canvas->drawRoundRect(r, r.width()/4, r.height()/4, paint);
|
|
rnd_rect(&r, &paint, rand);
|
|
}
|
|
}
|
|
}
|
|
|
|
private:
|
|
using INHERITED = skiagm::GM;
|
|
};
|
|
|
|
/* See
|
|
https://code.google.com/p/chromium/issues/detail?id=422974 and
|
|
http://jsfiddle.net/1xnku3sg/2/
|
|
*/
|
|
class ZeroLenStrokesGM : public skiagm::GM {
|
|
SkPath fMoveHfPath, fMoveZfPath, fDashedfPath, fRefPath[4];
|
|
SkPath fCubicPath, fQuadPath, fLinePath;
|
|
protected:
|
|
void onOnceBeforeDraw() override {
|
|
|
|
SkAssertResult(SkParsePath::FromSVGString("M0,0h0M10,0h0M20,0h0", &fMoveHfPath));
|
|
SkAssertResult(SkParsePath::FromSVGString("M0,0zM10,0zM20,0z", &fMoveZfPath));
|
|
SkAssertResult(SkParsePath::FromSVGString("M0,0h25", &fDashedfPath));
|
|
SkAssertResult(SkParsePath::FromSVGString("M 0 0 C 0 0 0 0 0 0", &fCubicPath));
|
|
SkAssertResult(SkParsePath::FromSVGString("M 0 0 Q 0 0 0 0", &fQuadPath));
|
|
SkAssertResult(SkParsePath::FromSVGString("M 0 0 L 0 0", &fLinePath));
|
|
|
|
for (int i = 0; i < 3; ++i) {
|
|
fRefPath[0].addCircle(i * 10.f, 0, 5);
|
|
fRefPath[1].addCircle(i * 10.f, 0, 10);
|
|
fRefPath[2].addRect(i * 10.f - 4, -2, i * 10.f + 4, 6);
|
|
fRefPath[3].addRect(i * 10.f - 10, -10, i * 10.f + 10, 10);
|
|
}
|
|
}
|
|
|
|
SkString onShortName() override {
|
|
return SkString("zeroPath");
|
|
}
|
|
|
|
SkISize onISize() override {
|
|
return SkISize::Make(W, H*2);
|
|
}
|
|
|
|
void onDraw(SkCanvas* canvas) override {
|
|
SkPaint fillPaint, strokePaint, dashPaint;
|
|
fillPaint.setAntiAlias(true);
|
|
strokePaint = fillPaint;
|
|
strokePaint.setStyle(SkPaint::kStroke_Style);
|
|
for (int i = 0; i < 2; ++i) {
|
|
fillPaint.setAlphaf(1.0f);
|
|
strokePaint.setAlphaf(1.0f);
|
|
strokePaint.setStrokeWidth(i ? 8.f : 10.f);
|
|
strokePaint.setStrokeCap(i ? SkPaint::kSquare_Cap : SkPaint::kRound_Cap);
|
|
canvas->save();
|
|
canvas->translate(10 + i * 100.f, 10);
|
|
canvas->drawPath(fMoveHfPath, strokePaint);
|
|
canvas->translate(0, 20);
|
|
canvas->drawPath(fMoveZfPath, strokePaint);
|
|
dashPaint = strokePaint;
|
|
const SkScalar intervals[] = { 0, 10 };
|
|
dashPaint.setPathEffect(SkDashPathEffect::Make(intervals, 2, 0));
|
|
SkPath fillPath;
|
|
dashPaint.getFillPath(fDashedfPath, &fillPath);
|
|
canvas->translate(0, 20);
|
|
canvas->drawPath(fDashedfPath, dashPaint);
|
|
canvas->translate(0, 20);
|
|
canvas->drawPath(fRefPath[i * 2], fillPaint);
|
|
strokePaint.setStrokeWidth(20);
|
|
strokePaint.setAlphaf(0.5f);
|
|
canvas->translate(0, 50);
|
|
canvas->drawPath(fMoveHfPath, strokePaint);
|
|
canvas->translate(0, 30);
|
|
canvas->drawPath(fMoveZfPath, strokePaint);
|
|
canvas->translate(0, 30);
|
|
fillPaint.setAlphaf(0.5f);
|
|
canvas->drawPath(fRefPath[1 + i * 2], fillPaint);
|
|
canvas->translate(0, 30);
|
|
canvas->drawPath(fCubicPath, strokePaint);
|
|
canvas->translate(0, 30);
|
|
canvas->drawPath(fQuadPath, strokePaint);
|
|
canvas->translate(0, 30);
|
|
canvas->drawPath(fLinePath, strokePaint);
|
|
canvas->restore();
|
|
}
|
|
}
|
|
|
|
private:
|
|
using INHERITED = skiagm::GM;
|
|
};
|
|
|
|
class TeenyStrokesGM : public skiagm::GM {
|
|
|
|
SkString onShortName() override {
|
|
return SkString("teenyStrokes");
|
|
}
|
|
|
|
SkISize onISize() override {
|
|
return SkISize::Make(W, H*2);
|
|
}
|
|
|
|
static void line(SkScalar scale, SkCanvas* canvas, SkColor color) {
|
|
SkPaint p;
|
|
p.setAntiAlias(true);
|
|
p.setStyle(SkPaint::kStroke_Style);
|
|
p.setColor(color);
|
|
canvas->translate(50, 0);
|
|
canvas->save();
|
|
p.setStrokeWidth(scale * 5);
|
|
canvas->scale(1 / scale, 1 / scale);
|
|
canvas->drawLine(20 * scale, 20 * scale, 20 * scale, 100 * scale, p);
|
|
canvas->drawLine(20 * scale, 20 * scale, 100 * scale, 100 * scale, p);
|
|
canvas->restore();
|
|
}
|
|
|
|
void onDraw(SkCanvas* canvas) override {
|
|
line(0.00005f, canvas, SK_ColorBLACK);
|
|
line(0.000045f, canvas, SK_ColorRED);
|
|
line(0.0000035f, canvas, SK_ColorGREEN);
|
|
line(0.000003f, canvas, SK_ColorBLUE);
|
|
line(0.000002f, canvas, SK_ColorBLACK);
|
|
}
|
|
private:
|
|
using INHERITED = skiagm::GM;
|
|
};
|
|
|
|
DEF_SIMPLE_GM(CubicStroke, canvas, 384, 384) {
|
|
SkPaint p;
|
|
p.setAntiAlias(true);
|
|
p.setStyle(SkPaint::kStroke_Style);
|
|
p.setStrokeWidth(1.0720f);
|
|
SkPath path;
|
|
path.moveTo(-6000,-6000);
|
|
path.cubicTo(-3500,5500,-500,5500,2500,-6500);
|
|
canvas->drawPath(path, p);
|
|
p.setStrokeWidth(1.0721f);
|
|
canvas->translate(10, 10);
|
|
canvas->drawPath(path, p);
|
|
p.setStrokeWidth(1.0722f);
|
|
canvas->translate(10, 10);
|
|
canvas->drawPath(path, p);
|
|
}
|
|
|
|
DEF_SIMPLE_GM(zerolinestroke, canvas, 90, 120) {
|
|
SkPaint paint;
|
|
paint.setStyle(SkPaint::kStroke_Style);
|
|
paint.setStrokeWidth(20);
|
|
paint.setAntiAlias(true);
|
|
paint.setStrokeCap(SkPaint::kRound_Cap);
|
|
|
|
SkPath path;
|
|
path.moveTo(30, 90);
|
|
path.lineTo(30, 90);
|
|
path.lineTo(60, 90);
|
|
path.lineTo(60, 90);
|
|
canvas->drawPath(path, paint);
|
|
|
|
path.reset();
|
|
path.moveTo(30, 30);
|
|
path.lineTo(60, 30);
|
|
canvas->drawPath(path, paint);
|
|
|
|
path.reset();
|
|
path.moveTo(30, 60);
|
|
path.lineTo(30, 60);
|
|
path.lineTo(60, 60);
|
|
canvas->drawPath(path, paint);
|
|
}
|
|
|
|
DEF_SIMPLE_GM(quadcap, canvas, 200, 200) {
|
|
SkPaint p;
|
|
p.setAntiAlias(true);
|
|
p.setStyle(SkPaint::kStroke_Style);
|
|
p.setStrokeWidth(0);
|
|
SkPath path;
|
|
SkPoint pts[] = {{105.738571f,13.126318f},
|
|
{105.738571f,13.126318f},
|
|
{123.753784f,1.f}};
|
|
SkVector tangent = pts[1] - pts[2];
|
|
tangent.normalize();
|
|
SkPoint pts2[3];
|
|
memcpy(pts2, pts, sizeof(pts));
|
|
const SkScalar capOutset = SK_ScalarPI / 8;
|
|
pts2[0].fX += tangent.fX * capOutset;
|
|
pts2[0].fY += tangent.fY * capOutset;
|
|
pts2[1].fX += tangent.fX * capOutset;
|
|
pts2[1].fY += tangent.fY * capOutset;
|
|
pts2[2].fX += -tangent.fX * capOutset;
|
|
pts2[2].fY += -tangent.fY * capOutset;
|
|
path.moveTo(pts2[0]);
|
|
path.quadTo(pts2[1], pts2[2]);
|
|
canvas->drawPath(path, p);
|
|
|
|
path.reset();
|
|
path.moveTo(pts[0]);
|
|
path.quadTo(pts[1], pts[2]);
|
|
p.setStrokeCap(SkPaint::kRound_Cap);
|
|
canvas->translate(30, 0);
|
|
canvas->drawPath(path, p);
|
|
}
|
|
|
|
class Strokes2GM : public skiagm::GM {
|
|
SkPath fPath;
|
|
protected:
|
|
void onOnceBeforeDraw() override {
|
|
SkRandom rand;
|
|
fPath.moveTo(0, 0);
|
|
for (int i = 0; i < 13; i++) {
|
|
SkScalar x = rand.nextUScalar1() * (W >> 1);
|
|
SkScalar y = rand.nextUScalar1() * (H >> 1);
|
|
fPath.lineTo(x, y);
|
|
}
|
|
}
|
|
|
|
|
|
SkString onShortName() override {
|
|
return SkString("strokes_poly");
|
|
}
|
|
|
|
SkISize onISize() override {
|
|
return SkISize::Make(W, H*2);
|
|
}
|
|
|
|
void onDraw(SkCanvas* canvas) override {
|
|
canvas->drawColor(SK_ColorWHITE);
|
|
|
|
SkPaint paint;
|
|
paint.setStyle(SkPaint::kStroke_Style);
|
|
paint.setStrokeWidth(SkIntToScalar(9)/2);
|
|
|
|
for (int y = 0; y < 2; y++) {
|
|
paint.setAntiAlias(!!y);
|
|
SkAutoCanvasRestore acr(canvas, true);
|
|
canvas->translate(0, SH * y);
|
|
canvas->clipRect(SkRect::MakeLTRB(SkIntToScalar(2),
|
|
SkIntToScalar(2),
|
|
SW - SkIntToScalar(2),
|
|
SH - SkIntToScalar(2)));
|
|
|
|
SkRandom rand;
|
|
for (int i = 0; i < N/2; i++) {
|
|
SkRect r;
|
|
rnd_rect(&r, &paint, rand);
|
|
canvas->rotate(SkIntToScalar(15), SW/2, SH/2);
|
|
canvas->drawPath(fPath, paint);
|
|
}
|
|
}
|
|
}
|
|
|
|
private:
|
|
using INHERITED = skiagm::GM;
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
static SkRect inset(const SkRect& r) {
|
|
SkRect rr(r);
|
|
rr.inset(r.width()/10, r.height()/10);
|
|
return rr;
|
|
}
|
|
|
|
class Strokes3GM : public skiagm::GM {
|
|
static void make0(SkPath* path, const SkRect& bounds, SkString* title) {
|
|
path->addRect(bounds, SkPathDirection::kCW);
|
|
path->addRect(inset(bounds), SkPathDirection::kCW);
|
|
title->set("CW CW");
|
|
}
|
|
|
|
static void make1(SkPath* path, const SkRect& bounds, SkString* title) {
|
|
path->addRect(bounds, SkPathDirection::kCW);
|
|
path->addRect(inset(bounds), SkPathDirection::kCCW);
|
|
title->set("CW CCW");
|
|
}
|
|
|
|
static void make2(SkPath* path, const SkRect& bounds, SkString* title) {
|
|
path->addOval(bounds, SkPathDirection::kCW);
|
|
path->addOval(inset(bounds), SkPathDirection::kCW);
|
|
title->set("CW CW");
|
|
}
|
|
|
|
static void make3(SkPath* path, const SkRect& bounds, SkString* title) {
|
|
path->addOval(bounds, SkPathDirection::kCW);
|
|
path->addOval(inset(bounds), SkPathDirection::kCCW);
|
|
title->set("CW CCW");
|
|
}
|
|
|
|
static void make4(SkPath* path, const SkRect& bounds, SkString* title) {
|
|
path->addRect(bounds, SkPathDirection::kCW);
|
|
SkRect r = bounds;
|
|
r.inset(bounds.width() / 10, -bounds.height() / 10);
|
|
path->addOval(r, SkPathDirection::kCW);
|
|
title->set("CW CW");
|
|
}
|
|
|
|
static void make5(SkPath* path, const SkRect& bounds, SkString* title) {
|
|
path->addRect(bounds, SkPathDirection::kCW);
|
|
SkRect r = bounds;
|
|
r.inset(bounds.width() / 10, -bounds.height() / 10);
|
|
path->addOval(r, SkPathDirection::kCCW);
|
|
title->set("CW CCW");
|
|
}
|
|
|
|
public:
|
|
Strokes3GM() {}
|
|
|
|
protected:
|
|
|
|
SkString onShortName() override {
|
|
return SkString("strokes3");
|
|
}
|
|
|
|
SkISize onISize() override {
|
|
return SkISize::Make(1500, 1500);
|
|
}
|
|
|
|
void onDraw(SkCanvas* canvas) override {
|
|
SkPaint origPaint;
|
|
origPaint.setAntiAlias(true);
|
|
origPaint.setStyle(SkPaint::kStroke_Style);
|
|
SkPaint fillPaint(origPaint);
|
|
fillPaint.setColor(SK_ColorRED);
|
|
SkPaint strokePaint(origPaint);
|
|
strokePaint.setColor(ToolUtils::color_to_565(0xFF4444FF));
|
|
|
|
void (*procs[])(SkPath*, const SkRect&, SkString*) = {
|
|
make0, make1, make2, make3, make4, make5
|
|
};
|
|
|
|
canvas->translate(SkIntToScalar(20), SkIntToScalar(80));
|
|
|
|
SkRect bounds = SkRect::MakeWH(SkIntToScalar(50), SkIntToScalar(50));
|
|
SkScalar dx = bounds.width() * 4/3;
|
|
SkScalar dy = bounds.height() * 5;
|
|
|
|
for (size_t i = 0; i < std::size(procs); ++i) {
|
|
SkPath orig;
|
|
SkString str;
|
|
procs[i](&orig, bounds, &str);
|
|
|
|
canvas->save();
|
|
for (int j = 0; j < 13; ++j) {
|
|
strokePaint.setStrokeWidth(SK_Scalar1 * j * j);
|
|
canvas->drawPath(orig, strokePaint);
|
|
canvas->drawPath(orig, origPaint);
|
|
SkPath fill;
|
|
strokePaint.getFillPath(orig, &fill);
|
|
canvas->drawPath(fill, fillPaint);
|
|
canvas->translate(dx + strokePaint.getStrokeWidth(), 0);
|
|
}
|
|
canvas->restore();
|
|
canvas->translate(0, dy);
|
|
}
|
|
}
|
|
|
|
private:
|
|
using INHERITED = skiagm::GM;
|
|
};
|
|
|
|
class Strokes4GM : public skiagm::GM {
|
|
public:
|
|
Strokes4GM() {}
|
|
|
|
protected:
|
|
|
|
SkString onShortName() override {
|
|
return SkString("strokes_zoomed");
|
|
}
|
|
|
|
SkISize onISize() override {
|
|
return SkISize::Make(W, H*2);
|
|
}
|
|
|
|
void onDraw(SkCanvas* canvas) override {
|
|
SkPaint paint;
|
|
paint.setStyle(SkPaint::kStroke_Style);
|
|
paint.setStrokeWidth(0.055f);
|
|
|
|
canvas->scale(1000, 1000);
|
|
canvas->drawCircle(0, 2, 1.97f, paint);
|
|
}
|
|
|
|
private:
|
|
using INHERITED = skiagm::GM;
|
|
};
|
|
|
|
// Test stroking for curves that produce degenerate tangents when t is 0 or 1 (see bug 4191)
|
|
class Strokes5GM : public skiagm::GM {
|
|
public:
|
|
Strokes5GM() {}
|
|
|
|
protected:
|
|
|
|
SkString onShortName() override {
|
|
return SkString("zero_control_stroke");
|
|
}
|
|
|
|
SkISize onISize() override {
|
|
return SkISize::Make(W, H*2);
|
|
}
|
|
|
|
void onDraw(SkCanvas* canvas) override {
|
|
SkPaint p;
|
|
p.setColor(SK_ColorRED);
|
|
p.setAntiAlias(true);
|
|
p.setStyle(SkPaint::kStroke_Style);
|
|
p.setStrokeWidth(40);
|
|
p.setStrokeCap(SkPaint::kButt_Cap);
|
|
|
|
SkPath path;
|
|
path.moveTo(157.474f,111.753f);
|
|
path.cubicTo(128.5f,111.5f,35.5f,29.5f,35.5f,29.5f);
|
|
canvas->drawPath(path, p);
|
|
path.reset();
|
|
path.moveTo(250, 50);
|
|
path.quadTo(280, 80, 280, 80);
|
|
canvas->drawPath(path, p);
|
|
path.reset();
|
|
path.moveTo(150, 50);
|
|
path.conicTo(180, 80, 180, 80, 0.707f);
|
|
canvas->drawPath(path, p);
|
|
|
|
path.reset();
|
|
path.moveTo(157.474f,311.753f);
|
|
path.cubicTo(157.474f,311.753f,85.5f,229.5f,35.5f,229.5f);
|
|
canvas->drawPath(path, p);
|
|
path.reset();
|
|
path.moveTo(280, 250);
|
|
path.quadTo(280, 250, 310, 280);
|
|
canvas->drawPath(path, p);
|
|
path.reset();
|
|
path.moveTo(180, 250);
|
|
path.conicTo(180, 250, 210, 280, 0.707f);
|
|
canvas->drawPath(path, p);
|
|
}
|
|
|
|
private:
|
|
using INHERITED = skiagm::GM;
|
|
};
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
DEF_GM( return new StrokesGM; )
|
|
DEF_GM( return new Strokes2GM; )
|
|
DEF_GM( return new Strokes3GM; )
|
|
DEF_GM( return new Strokes4GM; )
|
|
DEF_GM( return new Strokes5GM; )
|
|
|
|
DEF_GM( return new ZeroLenStrokesGM; )
|
|
DEF_GM( return new TeenyStrokesGM; )
|
|
|
|
DEF_SIMPLE_GM(zerolinedash, canvas, 256, 256) {
|
|
canvas->clear(SK_ColorWHITE);
|
|
|
|
SkPaint paint;
|
|
paint.setColor(SkColorSetARGB(255, 0, 0, 0));
|
|
paint.setStrokeWidth(11);
|
|
paint.setStrokeCap(SkPaint::kRound_Cap);
|
|
paint.setStrokeJoin(SkPaint::kBevel_Join);
|
|
|
|
SkScalar dash_pattern[] = {1, 5};
|
|
paint.setPathEffect(SkDashPathEffect::Make(dash_pattern, 2, 0));
|
|
|
|
canvas->drawLine(100, 100, 100, 100, paint);
|
|
}
|
|
|
|
#ifdef PDF_IS_FIXED_SO_THIS_DOESNT_BREAK_IT
|
|
DEF_SIMPLE_GM(longrect_dash, canvas, 250, 250) {
|
|
canvas->clear(SK_ColorWHITE);
|
|
|
|
SkPaint paint;
|
|
paint.setColor(SkColorSetARGB(255, 0, 0, 0));
|
|
paint.setStrokeWidth(5);
|
|
paint.setStrokeCap(SkPaint::kRound_Cap);
|
|
paint.setStrokeJoin(SkPaint::kBevel_Join);
|
|
paint.setStyle(SkPaint::kStroke_Style);
|
|
SkScalar dash_pattern[] = {1, 5};
|
|
paint.setPathEffect(SkDashPathEffect::Make(dash_pattern, 2, 0));
|
|
// try all combinations of stretching bounds
|
|
for (auto left : { 20.f, -100001.f } ) {
|
|
for (auto top : { 20.f, -100001.f } ) {
|
|
for (auto right : { 40.f, 100001.f } ) {
|
|
for (auto bottom : { 40.f, 100001.f } ) {
|
|
canvas->save();
|
|
canvas->clipRect({10, 10, 50, 50});
|
|
canvas->drawRect({left, top, right, bottom}, paint);
|
|
canvas->restore();
|
|
canvas->translate(60, 0);
|
|
}
|
|
}
|
|
canvas->translate(-60 * 4, 60);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
DEF_SIMPLE_GM(inner_join_geometry, canvas, 1000, 700) {
|
|
// These paths trigger cases where we must add inner join geometry.
|
|
// skbug.com/11964
|
|
const SkPoint pathPoints[] = {
|
|
/*moveTo*/ /*lineTo*/ /*lineTo*/
|
|
{119, 71}, {129, 151}, {230, 24},
|
|
{200, 144}, {129, 151}, {230, 24},
|
|
{192, 176}, {224, 175}, {281, 103},
|
|
{233, 205}, {224, 175}, {281, 103},
|
|
{121, 216}, {234, 189}, {195, 147},
|
|
{141, 216}, {254, 189}, {238, 250},
|
|
{159, 202}, {269, 197}, {289, 165},
|
|
{159, 202}, {269, 197}, {287, 227},
|
|
};
|
|
|
|
SkPaint pathPaint;
|
|
pathPaint.setStroke(true);
|
|
pathPaint.setAntiAlias(true);
|
|
pathPaint.setStrokeWidth(100);
|
|
|
|
SkPaint skeletonPaint;
|
|
skeletonPaint.setStroke(true);
|
|
skeletonPaint.setAntiAlias(true);
|
|
skeletonPaint.setStrokeWidth(0);
|
|
skeletonPaint.setColor(SK_ColorRED);
|
|
|
|
canvas->translate(0, 50);
|
|
for (size_t i = 0; i < std::size(pathPoints) / 3; i++) {
|
|
auto path = SkPath::Polygon(pathPoints + i * 3, 3, false);
|
|
canvas->drawPath(path, pathPaint);
|
|
|
|
SkPath fillPath;
|
|
pathPaint.getFillPath(path, &fillPath);
|
|
canvas->drawPath(fillPath, skeletonPaint);
|
|
|
|
canvas->translate(200, 0);
|
|
if ((i + 1) % 4 == 0) {
|
|
canvas->translate(-800, 200);
|
|
}
|
|
}
|
|
}
|
|
|
|
DEF_SIMPLE_GM(skbug12244, canvas, 150, 150) {
|
|
// Should look like a stroked triangle; these vertices are the results of the SkStroker
|
|
// but we draw as a filled path in order to highlight that it's the GPU triangulating path
|
|
// renderer that's the source of the problem, and not the stroking operation. The original
|
|
// path was a simple:
|
|
// m(0,0), l(100, 40), l(0, 80), l(0,0) with a stroke width of 15px
|
|
SkPath path;
|
|
path.moveTo(2.7854299545288085938, -6.9635753631591796875);
|
|
path.lineTo( 120.194366455078125, 40);
|
|
path.lineTo(-7.5000004768371582031, 91.07775115966796875);
|
|
path.lineTo(-7.5000004768371582031, -11.077748298645019531);
|
|
path.lineTo(2.7854299545288085938, -6.9635753631591796875);
|
|
path.moveTo(-2.7854299545288085938, 6.9635753631591796875);
|
|
path.lineTo( 0, 0);
|
|
path.lineTo( 7.5, 0);
|
|
path.lineTo(7.5000004768371582031, 68.92224884033203125);
|
|
path.lineTo( 79.805633544921875, 40);
|
|
path.lineTo(-2.7854299545288085938, 6.9635753631591796875);
|
|
|
|
SkPaint p;
|
|
p.setColor(SK_ColorGREEN);
|
|
|
|
canvas->translate(20.f, 20.f);
|
|
canvas->drawPath(path, p);
|
|
}
|