GameBench Class Reference

Inheritance diagram for GameBench:

Public Types
enum	Type { kScale_Type , kTranslate_Type , kRotate_Type }
enum	Clear { kFull_Clear , kPartial_Clear }
Public Types inherited from Benchmark
enum class	Backend {   kNonRendering , kRaster , kGanesh , kGraphite ,   kPDF , kHWUI }

Public Member Functions
	GameBench (Type type, Clear clear, bool aligned=false, bool useAtlas=false, bool useDrawVertices=false)
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

Protected Member Functions
const char *	onGetName () override
void	onDelayedSetup () override
void	onDraw (int loops, SkCanvas *canvas) override
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 *)
virtual SkISize	onGetSize ()

Detailed Description

Definition at line 21 of file GameBench.cpp.

Member Enumeration Documentation

Clear

enum GameBench::Clear

Enumerator
kFull_Clear
kPartial_Clear

Definition at line 29 of file GameBench.cpp.

               {
        kFull_Clear,
        kPartial_Clear
    };

Type

enum GameBench::Type

Enumerator
kScale_Type
kTranslate_Type
kRotate_Type

Definition at line 23 of file GameBench.cpp.

              {
        kScale_Type,
        kTranslate_Type,
        kRotate_Type
    };

Constructor & Destructor Documentation

GameBench()

GameBench::GameBench ( Type  type, Clear  clear, bool  aligned = false, bool  useAtlas = false, bool  useDrawVertices = false  )

inline

Definition at line 34 of file GameBench.cpp.

        : fType(type)
        , fClear(clear)
        , fAligned(aligned)
        , fUseAtlas(useAtlas)
        , fUseDrawVertices(useDrawVertices)
        , fName("game")
        , fNumSaved(0)
        , fInitialized(false) {
 
        switch (fType) {
        case kScale_Type:
            fName.append("_scale");
            break;
        case kTranslate_Type:
            fName.append("_trans");
            break;
        case kRotate_Type:
            fName.append("_rot");
            break;
        }
 
        if (aligned) {
            fName.append("_aligned");
        }
 
        if (kPartial_Clear == clear) {
            fName.append("_partial");
        } else {
            fName.append("_full");
        }
 
        if (useAtlas) {
            fName.append("_atlas");
        }
 
        if (useDrawVertices) {
            fName.append("_drawVerts");
        }
 
        // It's HTML 5 canvas, so always AA
        fName.append("_aa");
    }

Member Function Documentation

onDelayedSetup()

void GameBench::onDelayedSetup ( )

inlineoverrideprotectedvirtual

Reimplemented from Benchmark.

Definition at line 85 of file GameBench.cpp.

                                   {
        if (!fInitialized) {
            this->makeCheckerboard();
            this->makeAtlas();
            fInitialized = true;
        }
    }

onDraw()

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

inlineoverrideprotectedvirtual

Implements Benchmark.

Definition at line 93 of file GameBench.cpp.

                                                      {
        SkRandom scaleRand;
        SkRandom transRand;
        SkRandom rotRand;
 
        int width, height;
        if (fUseAtlas) {
            width = kAtlasCellWidth;
            height = kAtlasCellHeight;
        } else {
            width = kCheckerboardWidth;
            height = kCheckerboardHeight;
        }
 
        SkPaint clearPaint;
        clearPaint.setColor(0xFF000000);
        clearPaint.setAntiAlias(true);
 
        SkISize size = canvas->getBaseLayerSize();
 
        SkScalar maxTransX, maxTransY;
 
        if (kScale_Type == fType) {
            maxTransX = size.fWidth  - (1.5f * width);
            maxTransY = size.fHeight - (1.5f * height);
        } else if (kTranslate_Type == fType) {
            maxTransX = SkIntToScalar(size.fWidth  - width);
            maxTransY = SkIntToScalar(size.fHeight - height);
        } else {
            SkASSERT(kRotate_Type == fType);
            // Yes, some rotations will be off the top and left sides
            maxTransX = size.fWidth  - SK_ScalarSqrt2 * height;
            maxTransY = size.fHeight - SK_ScalarSqrt2 * height;
        }
 
        SkMatrix mat;
        SkRect dst = { 0, 0, SkIntToScalar(width), SkIntToScalar(height) };
        SkRect clearRect = { -1.0f, -1.0f, width+1.0f, height+1.0f };
        SkPoint verts[4] = { // for drawVertices path
            { 0, 0 },
            { 0, SkIntToScalar(height) },
            { SkIntToScalar(width), SkIntToScalar(height) },
            { SkIntToScalar(width), 0 }
        };
        uint16_t indices[6] = { 0, 1, 2, 0, 2, 3 };
 
        SkPaint p;
        p.setColor(0xFF000000);
 
        SkPaint p2;         // for drawVertices path
        p2.setColor(0xFF000000);
        p2.setShader(fAtlas->makeShader(SkSamplingOptions(SkFilterMode::kLinear)));
 
        for (int i = 0; i < loops; ++i, ++fNumSaved) {
            if (0 == i % kNumBeforeClear) {
                if (kPartial_Clear == fClear) {
                    for (int j = 0; j < fNumSaved; ++j) {
                        canvas->setMatrix(SkMatrix::I());
                        mat.setTranslate(fSaved[j][0], fSaved[j][1]);
 
                        if (kScale_Type == fType) {
                            mat.preScale(fSaved[j][2], fSaved[j][2]);
                        } else if (kRotate_Type == fType) {
                            mat.preRotate(fSaved[j][2]);
                        }
 
                        canvas->concat(mat);
                        canvas->drawRect(clearRect, clearPaint);
                    }
                } else {
                    canvas->clear(0xFF000000);
                }
 
                fNumSaved = 0;
            }
 
            SkASSERT(fNumSaved < kNumBeforeClear);
 
            canvas->setMatrix(SkMatrix::I());
 
            fSaved[fNumSaved][0] = transRand.nextRangeScalar(0.0f, maxTransX);
            fSaved[fNumSaved][1] = transRand.nextRangeScalar(0.0f, maxTransY);
            if (fAligned) {
                // make the translations integer aligned
                fSaved[fNumSaved][0] = SkScalarFloorToScalar(fSaved[fNumSaved][0]);
                fSaved[fNumSaved][1] = SkScalarFloorToScalar(fSaved[fNumSaved][1]);
            }
 
            mat.setTranslate(fSaved[fNumSaved][0], fSaved[fNumSaved][1]);
 
            if (kScale_Type == fType) {
                fSaved[fNumSaved][2] = scaleRand.nextRangeScalar(0.5f, 1.5f);
                mat.preScale(fSaved[fNumSaved][2], fSaved[fNumSaved][2]);
            } else if (kRotate_Type == fType) {
                fSaved[fNumSaved][2] = rotRand.nextRangeScalar(0.0f, 360.0f);
                mat.preRotate(fSaved[fNumSaved][2]);
            }
 
            canvas->concat(mat);
            if (fUseAtlas) {
                const int curCell = i % (kNumAtlasedX * kNumAtlasedY);
                SkRect src = SkRect::Make(
                              fAtlasRects[curCell % (kNumAtlasedX)][curCell / (kNumAtlasedX)]);
 
                if (fUseDrawVertices) {
                    SkPoint uvs[4] = {
                        { SkIntToScalar(src.fLeft),  SkIntToScalar(src.fBottom) },
                        { SkIntToScalar(src.fLeft),  SkIntToScalar(src.fTop) },
                        { SkIntToScalar(src.fRight), SkIntToScalar(src.fTop) },
                        { SkIntToScalar(src.fRight), SkIntToScalar(src.fBottom) },
                    };
                    canvas->drawVertices(SkVertices::MakeCopy(SkVertices::kTriangles_VertexMode,
                                                              4, verts, uvs, nullptr, 6, indices),
                                         SkBlendMode::kModulate, p2);
                } else {
                    canvas->drawImageRect(fAtlas, src, dst, SkSamplingOptions(), &p,
                                           SkCanvas::kFast_SrcRectConstraint);
                }
            } else {
                canvas->drawImageRect(fCheckerboard, dst, SkSamplingOptions(), &p);
            }
        }
    }

onGetName()

const char * GameBench::onGetName ( )

inlineoverrideprotectedvirtual

Implements Benchmark.

Definition at line 81 of file GameBench.cpp.

                                     {
        return fName.c_str();
    }

---

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

• third_party/skia/bench/GameBench.cpp