ShapesBench Class Reference

Inheritance diagram for ShapesBench:

Public Types
enum	ShapesType {   kNone_ShapesType , kRect_ShapesType , kOval_ShapesType , kRRect_ShapesType ,   kMixed_ShapesType }
Public Types inherited from Benchmark
enum class	Backend {   kNonRendering , kRaster , kGanesh , kGraphite ,   kPDF , kHWUI }

Public Member Functions
	ShapesBench (ShapesType shapesType, ShapesType innerShapesType, int numShapes, const SkISize &shapesSize, bool perspective)
Public Member Functions inherited from Benchmark
	Benchmark ()
const char *	getName ()
const char *	getUniqueName ()
SkISize	getSize ()
virtual bool	isSuitableFor (Backend backend)
virtual void	modifyGrContextOptions (GrContextOptions *)
virtual bool	shouldLoop () const
void	delayedSetup ()
void	perCanvasPreDraw (SkCanvas *)
void	perCanvasPostDraw (SkCanvas *)
void	preDraw (SkCanvas *)
void	postDraw (SkCanvas *)
void	draw (int loops, SkCanvas *)
virtual void	getGpuStats (SkCanvas *, skia_private::TArray< SkString > *keys, skia_private::TArray< double > *values)
virtual bool	getDMSAAStats (GrRecordingContext *)
int	getUnits () const
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Private Member Functions
const char *	onGetName () override
SkISize	onGetSize () override
void	onDelayedSetup () override
void	onDraw (int loops, SkCanvas *canvas) override

Additional Inherited Members
Protected Member Functions inherited from Benchmark
void	setUnits (int units)
virtual void	setupPaint (SkPaint *paint)
virtual const char *	onGetUniqueName ()
virtual void	onPerCanvasPreDraw (SkCanvas *)
virtual void	onPerCanvasPostDraw (SkCanvas *)
virtual void	onPreDraw (SkCanvas *)
virtual void	onPostDraw (SkCanvas *)

Detailed Description

Definition at line 42 of file ShapesBench.cpp.

Member Enumeration Documentation

ShapesType

enum ShapesBench::ShapesType

Enumerator
kNone_ShapesType
kRect_ShapesType
kOval_ShapesType
kRRect_ShapesType
kMixed_ShapesType

Definition at line 44 of file ShapesBench.cpp.

                    {
        kNone_ShapesType,
        kRect_ShapesType,
        kOval_ShapesType,
        kRRect_ShapesType,
        kMixed_ShapesType
    };

Constructor & Destructor Documentation

ShapesBench()

ShapesBench::ShapesBench ( ShapesType  shapesType, ShapesType  innerShapesType, int  numShapes, const SkISize &  shapesSize, bool  perspective  )

inline

Definition at line 52 of file ShapesBench.cpp.

        : fShapesType(shapesType)
        , fInnerShapesType(innerShapesType)
        , fNumShapes(numShapes)
        , fShapesSize(shapesSize)
        , fPerspective(perspective) {
        clampShapeSize();
    }

Member Function Documentation

onDelayedSetup()

void ShapesBench::onDelayedSetup ( )

inlineoverrideprivatevirtual

Reimplemented from Benchmark.

Definition at line 137 of file ShapesBench.cpp.

                                   {
        SkScalar w = SkIntToScalar(fShapesSize.width());
        SkScalar h = SkIntToScalar(fShapesSize.height());
 
        fRect.setRect(SkRect::MakeXYWH(-w / 2, -h / 2, w, h));
        fOval.setOval(fRect.rect());
        fRRect.setNinePatch(fRect.rect(), w / 8, h / 13, w / 11, h / 7);
 
        if (kNone_ShapesType != fInnerShapesType) {
            fRect.inset(w / 7, h / 11, &fInnerRect);
            fInnerRect.offset(w / 28, h / 44);
            fInnerOval.setOval(fInnerRect.rect());
            fInnerRRect.setRectXY(fInnerRect.rect(), w / 13, w / 7);
        }
 
        SkRandom rand;
        fShapes.push_back_n(fNumShapes);
        for (int i = 0; i < fNumShapes; i++) {
            float pad = sqrtf(static_cast<float>(fShapesSize.width() * fShapesSize.width()) +
                              static_cast<float>(fShapesSize.height() * fShapesSize.height()));
            fShapes[i].fMatrix.setTranslate(0.5f * pad + rand.nextF() * (kBenchWidth - pad),
                                            0.5f * pad + rand.nextF() * (kBenchHeight - pad));
            fShapes[i].fMatrix.preRotate(rand.nextF() * 360.0f);
            if (fPerspective) {
                fShapes[i].fMatrix.setPerspX(0.00015f);
                fShapes[i].fMatrix.setPerspY(-0.00015f);
            }
            fShapes[i].fColor = rand.nextU() | 0xff808080;
        }
        for (int i = 0; i < fNumShapes; i++) {
            // Do this in a separate loop so mixed shapes get the same random numbers during
            // placement as non-mixed do.
            int shapeType = fShapesType;
            if (kMixed_ShapesType == shapeType) {
                shapeType = rand.nextRangeU(kRect_ShapesType, kRRect_ShapesType);
            }
            int innerShapeType = fInnerShapesType;
            if (kMixed_ShapesType == innerShapeType) {
                innerShapeType = rand.nextRangeU(kRect_ShapesType, kRRect_ShapesType);
            }
            if (kNone_ShapesType == innerShapeType) {
                switch (shapeType) {
                    using namespace std;
                    using namespace std::placeholders;
                    case kRect_ShapesType:
                        fShapes[i].fDraw = bind(&SkCanvas::drawRect, _1, cref(fRect.rect()), _2);
                        break;
                    case kOval_ShapesType:
                        fShapes[i].fDraw = bind(&SkCanvas::drawOval, _1, cref(fOval.rect()), _2);
                        break;
                    case kRRect_ShapesType:
                        fShapes[i].fDraw = bind(&SkCanvas::drawRRect, _1, cref(fRRect), _2);
                        break;
                }
            } else {
                const SkRRect* outer = nullptr;
                switch (shapeType) {
                    case kRect_ShapesType: outer = &fRect; break;
                    case kOval_ShapesType: outer = &fOval; break;
                    case kRRect_ShapesType: outer = &fRRect; break;
                }
                const SkRRect* inner = nullptr;
                switch (innerShapeType) {
                    case kRect_ShapesType: inner = &fInnerRect; break;
                    case kOval_ShapesType: inner = &fInnerOval; break;
                    case kRRect_ShapesType: inner = &fInnerRRect; break;
                }
                fShapes[i].fDraw = std::bind(&SkCanvas::drawDRRect, std::placeholders::_1,
                                             std::cref(*outer), std::cref(*inner),
                                             std::placeholders::_2);
            }
        }
    }

onDraw()

void ShapesBench::onDraw ( int  loops, SkCanvas *  canvas  )

inlineoverrideprivatevirtual

Implements Benchmark.

Definition at line 211 of file ShapesBench.cpp.

                                                      {
        SkPaint paint;
        this->setupPaint(&paint);
        for (int j = 0; j < loops; j++) {
            for (int i = 0; i < fNumShapes; i++) {
                canvas->save();
                canvas->setMatrix(fShapes[i].fMatrix);
                paint.setColor(fShapes[i].fColor);
                fShapes[i].fDraw(canvas, paint);
                canvas->restore();
            }
        }
    }

onGetName()

const char * ShapesBench::onGetName ( )

inlineoverrideprivatevirtual

Implements Benchmark.

Definition at line 116 of file ShapesBench.cpp.

                                     {
        const char* shapeTypeNames[] = {
            "none", "rect", "oval", "rrect", "mixed"
        };
 
        fName.printf("shapes_%s", shapeTypeNames[fShapesType]);
 
        if (kNone_ShapesType != fInnerShapesType) {
            fName.appendf("_inner_%s", shapeTypeNames[fInnerShapesType]);
        }
 
        fName.appendf("_%i_%ix%i", fNumShapes, fShapesSize.width(), fShapesSize.height());
 
        if (fPerspective) {
            fName.append("_persp");
        }
 
        return fName.c_str();
    }

onGetSize()

SkISize ShapesBench::onGetSize ( )

inlineoverrideprivatevirtual

Reimplemented from Benchmark.

Definition at line 135 of file ShapesBench.cpp.

{ return SkISize::Make(kBenchWidth, kBenchHeight); }

---

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

• third_party/skia/bench/ShapesBench.cpp