dashing.cpp File Reference

#include "gm/gm.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkFont.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPathBuilder.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/SkTypeface.h"
#include "include/core/SkTypes.h"
#include "include/effects/SkDashPathEffect.h"
#include "tools/ToolUtils.h"
#include "tools/fonts/FontToolUtils.h"
#include <math.h>
#include <initializer_list>

Go to the source code of this file.

Classes
class	DashingGM
class	Dashing2GM
class	Dashing3GM
class	Dashing4GM
class	Dashing5GM

Functions
static void	drawline (SkCanvas *canvas, int on, int off, const SkPaint &paint, SkScalar finalX=SkIntToScalar(600), SkScalar finalY=SkIntToScalar(0), SkScalar phase=SkIntToScalar(0), SkScalar startX=SkIntToScalar(0), SkScalar startY=SkIntToScalar(0))
static void	show_giant_dash (SkCanvas *canvas)
static void	show_zero_len_dash (SkCanvas *canvas)
static SkPath	make_unit_star (int n)
static SkPath	make_path_line (const SkRect &bounds)
static SkPath	make_path_rect (const SkRect &bounds)
static SkPath	make_path_oval (const SkRect &bounds)
static SkPath	make_path_star (const SkRect &bounds)
	DEF_SIMPLE_GM (longpathdash, canvas, 612, 612)
	DEF_SIMPLE_GM (longlinedash, canvas, 512, 512)
	DEF_SIMPLE_GM (dashbigrects, canvas, 256, 256)
	DEF_SIMPLE_GM (longwavyline, canvas, 512, 512)
	DEF_SIMPLE_GM (dashtextcaps, canvas, 512, 512)
	DEF_SIMPLE_GM (dash_line_zero_off_interval, canvas, 160, 330)
	DEF_SIMPLE_GM (thin_aa_dash_lines, canvas, 330, 110)
	DEF_SIMPLE_GM (path_effect_empty_result, canvas, 100, 100)

Function Documentation

DEF_SIMPLE_GM() [1/8]

DEF_SIMPLE_GM	(	dash_line_zero_off_interval	,
		canvas	,
		160	,
		330
	)

Definition at line 585 of file dashing.cpp.

                                                             {
    static constexpr SkScalar kIntervals[] = {5.f, 0.f, 2.f, 0.f};
    SkPaint dashPaint;
    dashPaint.setPathEffect(SkDashPathEffect::Make(kIntervals, std::size(kIntervals), 0.f));
    SkASSERT(dashPaint.getPathEffect());
    dashPaint.setStroke(true);
    dashPaint.setStrokeWidth(20.f);
    static constexpr struct {
        SkPoint fA, fB;
    } kLines[] = {{{0.5f, 0.5f}, {30.5f, 0.5f}},    // horizontal
                  {{0.5f, 0.5f}, {0.5f, 30.5f}},    // vertical
                  {{0.5f, 0.5f}, {0.5f, 0.5f}},     // point
                  {{0.5f, 0.5f}, {25.5f, 25.5f}}};  // diagonal
    SkScalar pad = 5.f + dashPaint.getStrokeWidth();
    canvas->translate(pad / 2.f, pad / 2.f);
    canvas->save();
    SkScalar h = 0.f;
    for (const auto& line : kLines) {
        h = std::max(h, SkScalarAbs(line.fA.fY - line.fB.fY));
    }
    for (const auto& line : kLines) {
        SkScalar w = SkScalarAbs(line.fA.fX - line.fB.fX);
        for (auto cap : {SkPaint::kButt_Cap, SkPaint::kSquare_Cap, SkPaint::kRound_Cap}) {
            dashPaint.setStrokeCap(cap);
            for (auto aa : {false, true}) {
                dashPaint.setAntiAlias(aa);
                canvas->drawLine(line.fA, line.fB, dashPaint);
                canvas->translate(0.f, pad + h);
            }
        }
        canvas->restore();
        canvas->translate(pad + w, 0.f);
        canvas->save();
    }
}

DEF_SIMPLE_GM() [2/8]

DEF_SIMPLE_GM	(	dashbigrects	,
		canvas	,
		256	,
		256
	)

Definition at line 514 of file dashing.cpp.

                                              {
    SkRandom rand;
 
    constexpr int kHalfStrokeWidth = 8;
    constexpr int kOnOffInterval = 2*kHalfStrokeWidth;
 
    canvas->clear(SkColors::kBlack);
 
    SkPaint p;
    p.setAntiAlias(true);
    p.setStroke(true);
    p.setStrokeWidth(2*kHalfStrokeWidth);
    p.setStrokeCap(SkPaint::kButt_Cap);
 
    constexpr SkScalar intervals[] = { kOnOffInterval, kOnOffInterval };
    p.setPathEffect(SkDashPathEffect::Make(intervals, std::size(intervals), 0));
 
    constexpr float gWidthHeights[] = {
        1000000000.0f * kOnOffInterval + kOnOffInterval/2.0f,
        1000000.0f * kOnOffInterval + kOnOffInterval/2.0f,
        1000.0f * kOnOffInterval + kOnOffInterval/2.0f,
        100.0f * kOnOffInterval + kOnOffInterval/2.0f,
        10.0f * kOnOffInterval + kOnOffInterval/2.0f,
        9.0f * kOnOffInterval + kOnOffInterval/2.0f,
        8.0f * kOnOffInterval + kOnOffInterval/2.0f,
        7.0f * kOnOffInterval + kOnOffInterval/2.0f,
        6.0f * kOnOffInterval + kOnOffInterval/2.0f,
        5.0f * kOnOffInterval + kOnOffInterval/2.0f,
        4.0f * kOnOffInterval + kOnOffInterval/2.0f,
    };
 
    for (size_t i = 0; i < std::size(gWidthHeights); ++i) {
        p.setColor(ToolUtils::color_to_565(rand.nextU() | (0xFF << 24)));
 
        int offset = 2 * i * kHalfStrokeWidth + kHalfStrokeWidth;
        canvas->drawRect(SkRect::MakeXYWH(offset, offset, gWidthHeights[i], gWidthHeights[i]), p);
    }
}

DEF_SIMPLE_GM() [3/8]

DEF_SIMPLE_GM	(	dashtextcaps	,
		canvas	,
		512	,
		512
	)

Definition at line 568 of file dashing.cpp.

                                              {
    SkPaint p;
    p.setAntiAlias(true);
    p.setStroke(true);
    p.setStrokeWidth(10);
    p.setStrokeCap(SkPaint::kRound_Cap);
    p.setStrokeJoin(SkPaint::kRound_Join);
    p.setARGB(0xff, 0xbb, 0x00, 0x00);
 
    SkFont font(ToolUtils::DefaultPortableTypeface(), 100);
 
    const SkScalar intervals[] = { 12, 12 };
    p.setPathEffect(SkDashPathEffect::Make(intervals, std::size(intervals), 0));
    canvas->drawString("Sausages", 10, 90, font, p);
    canvas->drawLine(8, 120, 456, 120, p);
}

DEF_SIMPLE_GM() [4/8]

DEF_SIMPLE_GM	(	longlinedash	,
		canvas	,
		512	,
		512
	)

Definition at line 503 of file dashing.cpp.

                                              {
    SkPaint p;
    p.setAntiAlias(true);
    p.setStroke(true);
    p.setStrokeWidth(80);
 
    const SkScalar intervals[] = { 2, 2 };
    p.setPathEffect(SkDashPathEffect::Make(intervals, std::size(intervals), 0));
    canvas->drawRect(SkRect::MakeXYWH(-10000, 100, 20000, 20), p);
}

DEF_SIMPLE_GM() [5/8]

DEF_SIMPLE_GM	(	longpathdash	,
		canvas	,
		612	,
		612
	)

Definition at line 475 of file dashing.cpp.

                                              {
    SkPath lines;
    for (int x = 32; x < 256; x += 16) {
        for (SkScalar a = 0; a < 3.141592f * 2; a += 0.03141592f) {
            SkPoint pts[2] = {
                { 256 + (float) sin(a) * x,
                  256 + (float) cos(a) * x },
                { 256 + (float) sin(a + 3.141592 / 3) * (x + 64),
                  256 + (float) cos(a + 3.141592 / 3) * (x + 64) }
            };
            lines.moveTo(pts[0]);
            for (SkScalar i = 0; i < 1; i += 0.05f) {
                lines.lineTo(pts[0].fX * (1 - i) + pts[1].fX * i,
                             pts[0].fY * (1 - i) + pts[1].fY * i);
            }
        }
    }
    SkPaint p;
    p.setAntiAlias(true);
    p.setStroke(true);
    p.setStrokeWidth(1);
    const SkScalar intervals[] = { 1, 1 };
    p.setPathEffect(SkDashPathEffect::Make(intervals, std::size(intervals), 0));
 
    canvas->translate(50, 50);
    canvas->drawPath(lines, p);
}

DEF_SIMPLE_GM() [6/8]

DEF_SIMPLE_GM	(	longwavyline	,
		canvas	,
		512	,
		512
	)

Definition at line 553 of file dashing.cpp.

                                              {
    SkPaint p;
    p.setAntiAlias(true);
    p.setStroke(true);
    p.setStrokeWidth(2);
 
    SkPath wavy;
    wavy.moveTo(-10000, 100);
    for (SkScalar i = -10000; i < 10000; i += 20) {
        wavy.quadTo(i + 5, 95, i + 10, 100);
        wavy.quadTo(i + 15, 105, i + 20, 100);
    }
    canvas->drawPath(wavy, p);
}

DEF_SIMPLE_GM() [7/8]

DEF_SIMPLE_GM	(	path_effect_empty_result	,
		canvas	,
		100	,
		100
	)

Definition at line 644 of file dashing.cpp.

                                                          {
    SkPaint p;
    p.setStroke(true);
    p.setStrokeWidth(1);
 
    SkPath path;
    float r = 70;
    float l = 70;
    float t = 70;
    float b = 70;
    path.moveTo(l, t);
    path.lineTo(r, t);
    path.lineTo(r, b);
    path.lineTo(l, b);
    path.close();
 
    float dashes[] = {2.f, 2.f};
    p.setPathEffect(SkDashPathEffect::Make(dashes, 2, 0.f));
 
    canvas->drawPath(path, p);
}

DEF_SIMPLE_GM() [8/8]

DEF_SIMPLE_GM	(	thin_aa_dash_lines	,
		canvas	,
		330	,
		110
	)

Definition at line 621 of file dashing.cpp.

                                                    {
    SkPaint paint;
    static constexpr SkScalar kScale = 100.f;
    static constexpr SkScalar kIntervals[] = {10/kScale, 5/kScale};
    paint.setPathEffect(SkDashPathEffect::Make(kIntervals, std::size(kIntervals), 0.f));
    paint.setAntiAlias(true);
    paint.setStrokeWidth(0.25f/kScale);
    // substep moves the subpixel offset every iteration.
    static constexpr SkScalar kSubstep = 0.05f/kScale;
    // We will draw a grid of horiz/vertical lines that pass through each other's off intervals.
    static constexpr SkScalar kStep = kIntervals[0] + kIntervals[1];
    canvas->scale(kScale, kScale);
    canvas->translate(kIntervals[1], kIntervals[1]);
    for (auto c : {SkPaint::kButt_Cap, SkPaint::kSquare_Cap, SkPaint::kRound_Cap}) {
        paint.setStrokeCap(c);
        for (SkScalar x = -.5f*kIntervals[1]; x < 105/kScale; x += (kStep + kSubstep)) {
            canvas->drawLine({x, 0}, {x, 100/kScale}, paint);
            canvas->drawLine({0, x}, {100/kScale, x}, paint);
        }
        canvas->translate(110/kScale, 0);
    }
}

drawline()

static void drawline ( SkCanvas *  canvas, int  on, int  off, const SkPaint &  paint, SkScalar  finalX = SkIntToScalar(600), SkScalar  finalY = SkIntToScalar(0), SkScalar  phase = SkIntToScalar(0), SkScalar  startX = SkIntToScalar(0), SkScalar  startY = SkIntToScalar(0)  )

static

Definition at line 30 of file dashing.cpp.

                                                                                             {
    SkPaint p(paint);
 
    const SkScalar intervals[] = {
        SkIntToScalar(on),
        SkIntToScalar(off),
    };
 
    p.setPathEffect(SkDashPathEffect::Make(intervals, 2, phase));
    canvas->drawLine(startX, startY, finalX, finalY, p);
}

make_path_line()

static SkPath make_path_line ( const SkRect &  bounds )

static

Definition at line 122 of file dashing.cpp.

                                                   {
    return SkPathBuilder().moveTo(bounds.left(), bounds.top())
                          .lineTo(bounds.right(), bounds.bottom())
                          .detach();
}

make_path_oval()

static SkPath make_path_oval ( const SkRect &  bounds )

static

Definition at line 132 of file dashing.cpp.

                                                   {
    return SkPath::Oval(bounds);
}

make_path_rect()

static SkPath make_path_rect ( const SkRect &  bounds )

static

Definition at line 128 of file dashing.cpp.

                                                   {
    return SkPath::Rect(bounds);
}

make_path_star()

static SkPath make_path_star ( const SkRect &  bounds )

static

Definition at line 136 of file dashing.cpp.

                                                   {
    SkPath path = make_unit_star(5);
    SkMatrix matrix = SkMatrix::RectToRect(path.getBounds(), bounds, SkMatrix::kCenter_ScaleToFit);
    return path.makeTransform(matrix);
}

make_unit_star()

static SkPath make_unit_star ( int  n )

static

Definition at line 109 of file dashing.cpp.

                                    {
    SkScalar rad = -SK_ScalarPI / 2;
    const SkScalar drad = (n >> 1) * SK_ScalarPI * 2 / n;
 
    SkPathBuilder b;
    b.moveTo(0, -SK_Scalar1);
    for (int i = 1; i < n; i++) {
        rad += drad;
        b.lineTo(SkScalarCos(rad), SkScalarSin(rad));
    }
    return b.close().detach();
}

show_giant_dash()

static void show_giant_dash ( SkCanvas *  canvas )

static

Definition at line 48 of file dashing.cpp.

                                              {
    SkPaint paint;
 
    drawline(canvas, 1, 1, paint, SkIntToScalar(20 * 1000));
}

show_zero_len_dash()

static void show_zero_len_dash ( SkCanvas *  canvas )

static

Definition at line 54 of file dashing.cpp.

                                                 {
    SkPaint paint;
 
    drawline(canvas, 2, 2, paint, SkIntToScalar(0));
    paint.setStroke(true);
    paint.setStrokeWidth(SkIntToScalar(2));
    canvas->translate(0, SkIntToScalar(20));
    drawline(canvas, 4, 4, paint, SkIntToScalar(0));
}