strokes.cpp File Reference

#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/SkPathUtils.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/utils/SkParsePath.h"
#include "src/base/SkFloatBits.h"
#include "src/base/SkRandom.h"
#include "tools/ToolUtils.h"
#include <string.h>

Go to the source code of this file.

Classes
class	StrokesGM
class	ZeroLenStrokesGM
class	TeenyStrokesGM
class	Strokes2GM
class	Strokes3GM
class	Strokes4GM
class	Strokes5GM

Macros
#define	W   400
#define	H   400
#define	N   50

Functions
static void	rnd_rect (SkRect *r, SkPaint *paint, SkRandom &rand)
	DEF_SIMPLE_GM (CubicStroke, canvas, 384, 384)
	DEF_SIMPLE_GM (zerolinestroke, canvas, 90, 120)
	DEF_SIMPLE_GM (quadcap, canvas, 200, 200)
static SkRect	inset (const SkRect &r)
	DEF_SIMPLE_GM (zerolinedash, canvas, 256, 256)
	DEF_SIMPLE_GM (inner_join_geometry, canvas, 1000, 700)
	DEF_SIMPLE_GM (skbug12244, canvas, 150, 150)
	DEF_SIMPLE_GM (b_340982297, canvas, 80, 50)

Variables
constexpr SkScalar	SW = SkIntToScalar(W)
constexpr SkScalar	SH = SkIntToScalar(H)

Macro Definition Documentation

H

#define H   400

Definition at line 34 of file strokes.cpp.

N

#define N   50

Definition at line 35 of file strokes.cpp.

W

#define W   400

Definition at line 33 of file strokes.cpp.

Function Documentation

DEF_SIMPLE_GM() [1/7]

DEF_SIMPLE_GM	(	b_340982297	,
		canvas	,
		80	,
		50
	)

Definition at line 626 of file strokes.cpp.

                                           {
    SkPaint paint;
    paint.setAntiAlias(true);
 
    SkPath path;
    path.moveTo(30.23983f, 48.5674667f);
    path.lineTo(1.30884242f, 45.5222702f);
    path.lineTo(2.97688866f, 29.6749554f);
    path.lineTo(17.4423828f, 31.1975555f);
    path.lineTo(2.94269657f, 30.0452003f);
    path.lineTo(4.38597536f, 11.8849154f);
    path.lineTo(33.3853493f, 14.1896257f);
    path.close();
 
    canvas->drawPath(path, paint);
 
    path.reset();
    path.moveTo(73.3853455f, 4.18963623f);
    path.lineTo(69.995636f, 39.1360626f);
    path.lineTo(42.83145142f, 21.056778f);
    path.lineTo(42.97689819f, 19.6749573f);
    path.lineTo(57.4423828f, 21.1975555f);
    path.lineTo(42.94268799f, 20.0451965f);
    path.lineTo(44.38595581f, 1.88491821f);
    path.close();
 
    canvas->drawPath(path, paint);
}

DEF_SIMPLE_GM() [2/7]

DEF_SIMPLE_GM	(	CubicStroke	,
		canvas	,
		384	,
		384
	)

Definition at line 208 of file strokes.cpp.

                                             {
    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() [3/7]

DEF_SIMPLE_GM	(	inner_join_geometry	,
		canvas	,
		1000	,
		700
	)

Definition at line 558 of file strokes.cpp.

                                                      {
    // 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;
        skpathutils::FillPathWithPaint(path, pathPaint, &fillPath);
        canvas->drawPath(fillPath, skeletonPaint);
 
        canvas->translate(200, 0);
        if ((i + 1) % 4 == 0) {
            canvas->translate(-800, 200);
        }
    }
}

DEF_SIMPLE_GM() [4/7]

DEF_SIMPLE_GM	(	quadcap	,
		canvas	,
		200	,
		200
	)

Definition at line 251 of file strokes.cpp.

                                         {
    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);
}

DEF_SIMPLE_GM() [5/7]

DEF_SIMPLE_GM	(	skbug12244	,
		canvas	,
		150	,
		150
	)

Definition at line 600 of file strokes.cpp.

                                            {
    // 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);
}

DEF_SIMPLE_GM() [6/7]

DEF_SIMPLE_GM	(	zerolinedash	,
		canvas	,
		256	,
		256
	)

Definition at line 513 of file strokes.cpp.

                                              {
    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);
}

DEF_SIMPLE_GM() [7/7]

DEF_SIMPLE_GM	(	zerolinestroke	,
		canvas	,
		90	,
		120
	)

Definition at line 225 of file strokes.cpp.

                                               {
    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);
}

inset()

static SkRect inset ( const SkRect &  r )

static

Definition at line 332 of file strokes.cpp.

                                     {
    SkRect rr(r);
    rr.inset(r.width()/10, r.height()/10);
    return rr;
}

rnd_rect()

static void rnd_rect ( SkRect *  r, SkPaint *  paint, SkRandom &  rand  )

static

Definition at line 40 of file strokes.cpp.

                                                                {
    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);
}

Variable Documentation

SH

constexpr SkScalar SH = SkIntToScalar(H)

constexpr

Definition at line 38 of file strokes.cpp.

SW

constexpr SkScalar SW = SkIntToScalar(W)

constexpr

Definition at line 37 of file strokes.cpp.