ConicPathsGM Class Reference

Inheritance diagram for ConicPathsGM:

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

Additional Inherited Members
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 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
Static Public Attributes inherited from skiagm::GM
static constexpr char	kErrorMsg_DrawSkippedGpuOnly []

Detailed Description

Definition at line 24 of file conicpaths.cpp.

Member Function Documentation

append_path()

template<typename Proc >

void ConicPathsGM::append_path ( Proc  proc )

inlineprotected

Definition at line 30 of file conicpaths.cpp.

                                                         {
        SkPathBuilder b;
        proc(&b);
        fPaths.push_back(b.detach());
    }

drawGiantCircle()

void ConicPathsGM::drawGiantCircle ( SkCanvas *  canvas )

inlineprotected

Definition at line 99 of file conicpaths.cpp.

                                           {
        SkPaint paint;
        canvas->drawPath(fGiantCircle, paint);
    }

getISize()

SkISize ConicPathsGM::getISize ( )

inlineoverrideprotectedvirtual

Implements skiagm::GM.

Definition at line 28 of file conicpaths.cpp.

{ return SkISize::Make(920, 960); }

getName()

SkString ConicPathsGM::getName ( ) const

inlineoverrideprotectedvirtual

Implements skiagm::GM.

Definition at line 26 of file conicpaths.cpp.

{ return SkString("conicpaths"); }

onDraw()

void ConicPathsGM::onDraw ( SkCanvas *  canvas )

inlineoverrideprotectedvirtual

Reimplemented from skiagm::GM.

Definition at line 104 of file conicpaths.cpp.

                                           {
        const SkAlpha kAlphaValue[] = { 0xFF, 0x40 };
 
        const SkScalar margin = 15;
        canvas->translate(margin, margin);
 
        SkPaint paint;
        for (int p = 0; p < fPaths.size(); ++p) {
            canvas->save();
            for (size_t a = 0; a < std::size(kAlphaValue); ++a) {
                paint.setARGB(kAlphaValue[a], 0, 0, 0);
                for (int aa = 0; aa < 2; ++aa) {
                    paint.setAntiAlias(SkToBool(aa));
                    for (int fh = 0; fh < 2; ++fh) {
                        paint.setStroke(fh != 0);
 
                        const SkRect& bounds = fPaths[p].getBounds();
                        canvas->save();
                        canvas->translate(-bounds.fLeft, -bounds.fTop);
                        canvas->drawPath(fPaths[p], paint);
                        canvas->restore();
 
                        canvas->translate(110, 0);
                    }
                }
            }
            canvas->restore();
            canvas->translate(0, 110);
        }
        canvas->restore();
 
        this->drawGiantCircle(canvas);
    }

onOnceBeforeDraw()

void ConicPathsGM::onOnceBeforeDraw ( )

inlineoverrideprotectedvirtual

Reimplemented from skiagm::GM.

Definition at line 36 of file conicpaths.cpp.

                                     {
        this->append_path([](SkPathBuilder* conicCircle) {
            const SkScalar w = SkScalarSqrt(2)/2;
            conicCircle->moveTo(0, 0);
            conicCircle->conicTo(0, 50, 50, 50, w);
            conicCircle->rConicTo(50, 0, 50, -50, w);
            conicCircle->rConicTo(0, -50, -50, -50, w);
            conicCircle->rConicTo(-50, 0, -50, 50, w);
        });
 
        this->append_path([](SkPathBuilder* hyperbola) {
            hyperbola->moveTo(0, 0);
            hyperbola->conicTo(0, 100, 100, 100, 2);
        });
 
        this->append_path([](SkPathBuilder* thinHyperbola) {
            thinHyperbola->moveTo(0, 0);
            thinHyperbola->conicTo(100, 100, 5, 0, 2);
        });
 
        this->append_path([](SkPathBuilder* veryThinHyperbola) {
            veryThinHyperbola->moveTo(0, 0);
            veryThinHyperbola->conicTo(100, 100, 1, 0, 2);
        });
 
        this->append_path([](SkPathBuilder* closedHyperbola) {
            closedHyperbola->moveTo(0, 0);
            closedHyperbola->conicTo(100, 100, 0, 0, 2);
        });
 
        this->append_path([](SkPathBuilder* nearParabola) {
            // using 1 as weight defaults to using quadTo
            nearParabola->moveTo(0, 0);
            nearParabola->conicTo(0, 100, 100, 100, 0.999f);
        });
 
        this->append_path([](SkPathBuilder* thinEllipse) {
            thinEllipse->moveTo(0, 0);
            thinEllipse->conicTo(100, 100, 5, 0, SK_ScalarHalf);
        });
 
        this->append_path([](SkPathBuilder* veryThinEllipse) {
            veryThinEllipse->moveTo(0, 0);
            veryThinEllipse->conicTo(100, 100, 1, 0, SK_ScalarHalf);
        });
 
        this->append_path([](SkPathBuilder* closedEllipse) {
            closedEllipse->moveTo(0,  0);
            closedEllipse->conicTo(100, 100, 0, 0, SK_ScalarHalf);
        });
 
        {
            SkPathBuilder b;
            const SkScalar w = SkScalarSqrt(2)/2;
            b.moveTo(2.1e+11f, -1.05e+11f);
            b.conicTo(2.1e+11f, 0, 1.05e+11f, 0, w);
            b.conicTo(0, 0, 0, -1.05e+11f, w);
            b.conicTo(0, -2.1e+11f, 1.05e+11f, -2.1e+11f, w);
            b.conicTo(2.1e+11f, -2.1e+11f, 2.1e+11f, -1.05e+11f, w);
            fGiantCircle = b.detach();
        }
    }

---

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

• third_party/skia/gm/conicpaths.cpp