skiagm::NonClosedPathsGM Class Reference

Inheritance diagram for skiagm::NonClosedPathsGM:

Public Types
enum	ClosureType { TotallyNonClosed , FakeCloseCorner , FakeCloseMiddle , kClosureTypeCount }
Public Types inherited from skiagm::GM
enum	Mode { kGM_Mode , kSample_Mode , kBench_Mode }
using	DrawResult = skiagm::DrawResult
using	GraphiteTestContext = skiatest::graphite::GraphiteTestContext

Public Member Functions
	NonClosedPathsGM ()
Public Member Functions inherited from skiagm::GM
	GM (SkColor backgroundColor=SK_ColorWHITE)
virtual	~GM ()
void	setMode (Mode mode)
Mode	getMode () const
DrawResult	gpuSetup (SkCanvas *, SkString *errorMsg, GraphiteTestContext *=nullptr)
void	gpuTeardown ()
void	onceBeforeDraw ()
DrawResult	draw (SkCanvas *canvas)
DrawResult	draw (SkCanvas *, SkString *errorMsg)
void	drawBackground (SkCanvas *)
DrawResult	drawContent (SkCanvas *canvas)
DrawResult	drawContent (SkCanvas *, SkString *errorMsg)
virtual bool	runAsBench () const
SkScalar	width ()
SkScalar	height ()
SkColor	getBGColor () const
void	setBGColor (SkColor)
void	drawSizeBounds (SkCanvas *, SkColor)
bool	animate (double)
virtual bool	onChar (SkUnichar)
bool	getControls (SkMetaData *controls)
void	setControls (const SkMetaData &controls)
virtual void	modifyGrContextOptions (GrContextOptions *)
virtual void	modifyGraphiteContextOptions (skgpu::graphite::ContextOptions *) const
virtual bool	isBazelOnly () const
virtual std::map< std::string, std::string >	getGoldKeys () const

Protected Member Functions
SkString	getName () const override
SkISize	getISize () override
void	onDraw (SkCanvas *canvas) override
Protected Member Functions inherited from skiagm::GM
virtual DrawResult	onGpuSetup (SkCanvas *, SkString *, GraphiteTestContext *)
virtual void	onGpuTeardown ()
virtual void	onOnceBeforeDraw ()
virtual DrawResult	onDraw (SkCanvas *, SkString *errorMsg)
virtual bool	onAnimate (double)
virtual bool	onGetControls (SkMetaData *)
virtual void	onSetControls (const SkMetaData &)
GraphiteTestContext *	graphiteTestContext () const

Static Protected Member Functions
static SkPath	MakePath (ClosureType type)
static void	SetLocation (SkCanvas *canvas, int counter, int lineNum)

Additional Inherited Members
Static Public Attributes inherited from skiagm::GM
static constexpr char	kErrorMsg_DrawSkippedGpuOnly []

Detailed Description

Definition at line 22 of file nonclosedpaths.cpp.

Member Enumeration Documentation

ClosureType

enum skiagm::NonClosedPathsGM::ClosureType

Enumerator
TotallyNonClosed
FakeCloseCorner
FakeCloseMiddle
kClosureTypeCount

Definition at line 26 of file nonclosedpaths.cpp.

                     {
        TotallyNonClosed,  // The last point doesn't coincide with the first one in the contour.
                           // The path looks not closed at all.
 
        FakeCloseCorner,   // The last point coincides with the first one at a corner.
                           // The path looks closed, but final rendering has 2 ends with cap.
 
        FakeCloseMiddle,   // The last point coincides with the first one in the middle of a line.
                           // The path looks closed, and the final rendering looks closed too.
 
        kClosureTypeCount
    };

Constructor & Destructor Documentation

NonClosedPathsGM()

skiagm::NonClosedPathsGM::NonClosedPathsGM ( )

inline

Definition at line 24 of file nonclosedpaths.cpp.

{}

Member Function Documentation

getISize()

SkISize skiagm::NonClosedPathsGM::getISize ( )

inlineoverrideprotectedvirtual

Implements skiagm::GM.

Definition at line 43 of file nonclosedpaths.cpp.

{ return SkISize::Make(1220, 1920); }

getName()

SkString skiagm::NonClosedPathsGM::getName ( ) const

inlineoverrideprotectedvirtual

Implements skiagm::GM.

Definition at line 40 of file nonclosedpaths.cpp.

{ return SkString("nonclosedpaths"); }

MakePath()

static SkPath skiagm::NonClosedPathsGM::MakePath ( ClosureType  type )

inlinestaticprotected

Definition at line 47 of file nonclosedpaths.cpp.

                                             {
        SkPathBuilder path;
        if (FakeCloseMiddle == type) {
            path.moveTo(30, 50);
            path.lineTo(30, 30);
        } else {
            path.moveTo(30, 30);
        }
        path.lineTo(70, 30);
        path.lineTo(70, 70);
        path.lineTo(30, 70);
        path.lineTo(30, 50);
        if (FakeCloseCorner == type) {
            path.lineTo(30, 30);
        }
        return path.detach();
    }

onDraw()

void skiagm::NonClosedPathsGM::onDraw ( SkCanvas *  canvas )

inlineoverrideprotectedvirtual

Reimplemented from skiagm::GM.

Definition at line 72 of file nonclosedpaths.cpp.

                                           {
        // Stroke widths are:
        // 0(may use hairline rendering), 10(common case for stroke-style)
        // 40 and 50(>= geometry width/height, make the contour filled in fact)
        constexpr int kStrokeWidth[] = {0, 10, 40, 50};
        int numWidths = std::size(kStrokeWidth);
 
        constexpr SkPaint::Style kStyle[] = {
            SkPaint::kStroke_Style, SkPaint::kStrokeAndFill_Style
        };
 
        constexpr SkPaint::Cap kCap[] = {
            SkPaint::kButt_Cap, SkPaint::kRound_Cap, SkPaint::kSquare_Cap
        };
 
        constexpr SkPaint::Join kJoin[] = {
            SkPaint::kMiter_Join, SkPaint::kRound_Join, SkPaint::kBevel_Join
        };
 
        constexpr ClosureType kType[] = {
            TotallyNonClosed, FakeCloseCorner, FakeCloseMiddle
        };
 
        int counter = 0;
        SkPaint paint;
        paint.setAntiAlias(true);
 
        // For stroke style painter and fill-and-stroke style painter
        for (size_t type = 0; type < kClosureTypeCount; ++type) {
            for (size_t style = 0; style < std::size(kStyle); ++style) {
                for (size_t cap = 0; cap < std::size(kCap); ++cap) {
                    for (size_t join = 0; join < std::size(kJoin); ++join) {
                        for (int width = 0; width < numWidths; ++width) {
                            canvas->save();
                            SetLocation(canvas, counter, SkPaint::kJoinCount * numWidths);
 
                            SkPath path = MakePath(kType[type]);
 
                            paint.setStyle(kStyle[style]);
                            paint.setStrokeCap(kCap[cap]);
                            paint.setStrokeJoin(kJoin[join]);
                            paint.setStrokeWidth(SkIntToScalar(kStrokeWidth[width]));
 
                            canvas->drawPath(path, paint);
                            canvas->restore();
                            ++counter;
                        }
                    }
                }
            }
        }
 
        // For fill style painter
        paint.setStyle(SkPaint::kFill_Style);
        for (size_t type = 0; type < kClosureTypeCount; ++type) {
            canvas->save();
            SetLocation(canvas, counter, SkPaint::kJoinCount * numWidths);
 
            SkPath path = MakePath(kType[type]);
 
            canvas->drawPath(path, paint);
            canvas->restore();
            ++counter;
        }
    }

SetLocation()

static void skiagm::NonClosedPathsGM::SetLocation ( SkCanvas *  canvas, int  counter, int  lineNum  )

inlinestaticprotected

Definition at line 66 of file nonclosedpaths.cpp.

                                                                        {
        SkScalar x = SK_Scalar1 * 100 * (counter % lineNum) + 10 + SK_Scalar1 / 4;
        SkScalar y = SK_Scalar1 * 100 * (counter / lineNum) + 10 + 3 * SK_Scalar1 / 4;
        canvas->translate(x, y);
    }

---

The documentation for this class was generated from the following file:

• third_party/skia/gm/nonclosedpaths.cpp