StatsLayer Class Reference

#include <StatsLayer.h>

Inheritance diagram for StatsLayer:

Public Types
typedef int	Timer

Public Member Functions
	StatsLayer ()
void	resetMeasurements ()
Timer	addTimer (const char *label, SkColor color, SkColor labelColor=0)
void	beginTiming (Timer)
void	endTiming (Timer)
void	onPrePaint () override
void	onPaint (SkSurface *) override
void	setDisplayScale (float scale)
Public Member Functions inherited from sk_app::Window::Layer
	Layer ()
virtual	~Layer ()=default
bool	getActive ()
void	setActive (bool active)
virtual void	onBackendCreated ()
virtual void	onAttach (Window *window)
virtual bool	onChar (SkUnichar c, skui::ModifierKey)
virtual bool	onKey (skui::Key, skui::InputState, skui::ModifierKey)
virtual bool	onMouse (int x, int y, skui::InputState, skui::ModifierKey)
virtual bool	onMouseWheel (float delta, int x, int y, skui::ModifierKey)
virtual bool	onTouch (intptr_t owner, skui::InputState, float x, float y)
virtual bool	onFling (skui::InputState state)
virtual bool	onPinch (skui::InputState state, float scale, float x, float y)
virtual void	onUIStateChanged (const SkString &stateName, const SkString &stateValue)
virtual void	onResize (int width, int height)

Detailed Description

Definition at line 18 of file StatsLayer.h.

Member Typedef Documentation

Timer

typedef int StatsLayer::Timer

Definition at line 23 of file StatsLayer.h.

Constructor & Destructor Documentation

StatsLayer()

StatsLayer::StatsLayer

(

)

Definition at line 29 of file StatsLayer.cpp.

    : fCurrentMeasurement(-1)
    , fLastTotalBegin(0)
    , fCumulativeMeasurementTime(0)
    , fCumulativeMeasurementCount(0)
    , fDisplayScale(1.0f) {
    memset(fTotalTimes, 0, sizeof(fTotalTimes));
}

Member Function Documentation

addTimer()

StatsLayer::Timer StatsLayer::addTimer	(	const char *	label,
		SkColor	color,
		SkColor	labelColor = 0
	)

Definition at line 49 of file StatsLayer.cpp.

                                                                                         {
    Timer newTimer = fTimers.size();
    TimerData& newData = fTimers.push_back();
    memset(newData.fTimes, 0, sizeof(newData.fTimes));
    newData.fLabel = label;
    newData.fColor = color;
    newData.fLabelColor = labelColor ? labelColor : color;
    return newTimer;
}

beginTiming()

void StatsLayer::beginTiming

(

Timer

timer

)

Definition at line 59 of file StatsLayer.cpp.

                                        {
    if (fCurrentMeasurement >= 0) {
        fTimers[timer].fTimes[fCurrentMeasurement] -= SkTime::GetMSecs();
    }
}

endTiming()

void StatsLayer::endTiming

(

Timer

timer

)

Definition at line 65 of file StatsLayer.cpp.

                                      {
    if (fCurrentMeasurement >= 0) {
        fTimers[timer].fTimes[fCurrentMeasurement] += SkTime::GetMSecs();
    }
}

onPaint()

void StatsLayer::onPaint ( SkSurface *  surface )

overridevirtual

Reimplemented from sk_app::Window::Layer.

Definition at line 82 of file StatsLayer.cpp.

                                           {
    int nextMeasurement = (fCurrentMeasurement + 1) & (kMeasurementCount - 1);
    for (int i = 0; i < fTimers.size(); ++i) {
        fTimers[i].fTimes[nextMeasurement] = 0;
    }
 
#ifdef SK_BUILD_FOR_ANDROID
    // Scale up the stats overlay on Android devices
    static constexpr SkScalar kScale = 1.5;
#else
    SkScalar kScale = fDisplayScale;
#endif
 
    // Now draw everything
    static const float kPixelPerMS = 2.0f;
    static const int kDisplayWidth = 192;
    static const int kGraphHeight = 100;
    static const int kTextHeight = 60;
    static const int kDisplayHeight = kGraphHeight + kTextHeight;
    static const int kDisplayPadding = 10;
    static const int kGraphPadding = 3;
    static const SkScalar kBaseMS = 1000.f / 60.f;  // ms/frame to hit 60 fps
 
    auto canvas = surface->getCanvas();
    SkISize canvasSize = canvas->getBaseLayerSize();
    SkRect rect = SkRect::MakeXYWH(SkIntToScalar(canvasSize.fWidth-kDisplayWidth-kDisplayPadding),
                                   SkIntToScalar(kDisplayPadding),
                                   SkIntToScalar(kDisplayWidth), SkIntToScalar(kDisplayHeight));
    SkPaint paint;
    canvas->save();
 
    // Scale the canvas while keeping the right edge in place.
    canvas->concat(SkMatrix::RectToRect(SkRect::Make(canvasSize),
                                        SkRect::MakeXYWH(canvasSize.width()  * (1 - kScale),
                                                         0,
                                                         canvasSize.width()  * kScale,
                                                         canvasSize.height() * kScale)));
 
    paint.setColor(SK_ColorBLACK);
    canvas->drawRect(rect, paint);
    // draw the 16ms line
    paint.setColor(SK_ColorLTGRAY);
    canvas->drawLine(rect.fLeft, rect.fBottom - kBaseMS*kPixelPerMS,
                     rect.fRight, rect.fBottom - kBaseMS*kPixelPerMS, paint);
    paint.setColor(SK_ColorRED);
    paint.setStyle(SkPaint::kStroke_Style);
    canvas->drawRect(rect, paint);
    paint.setStyle(SkPaint::kFill_Style);
 
    int x = SkScalarTruncToInt(rect.fLeft) + kGraphPadding;
    const int xStep = 3;
    int i = nextMeasurement;
    SkTDArray<double> sumTimes;
    sumTimes.resize(fTimers.size());
    memset(sumTimes.begin(), 0, sumTimes.size() * sizeof(double));
    int count = 0;
    double totalTime = 0;
    int totalCount = 0;
    do {
        int startY = SkScalarTruncToInt(rect.fBottom);
        double inc = 0;
        for (int timer = 0; timer < fTimers.size(); ++timer) {
            int height = (int)(fTimers[timer].fTimes[i] * kPixelPerMS + 0.5);
            int endY = std::max(startY - height, kDisplayPadding + kTextHeight);
            paint.setColor(fTimers[timer].fColor);
            canvas->drawLine(SkIntToScalar(x), SkIntToScalar(startY),
                             SkIntToScalar(x), SkIntToScalar(endY), paint);
            startY = endY;
            inc += fTimers[timer].fTimes[i];
            sumTimes[timer] += fTimers[timer].fTimes[i];
        }
 
        int height = (int)(fTotalTimes[i] * kPixelPerMS + 0.5);
        height = std::max(0, height - (SkScalarTruncToInt(rect.fBottom) - startY));
        int endY = std::max(startY - height, kDisplayPadding + kTextHeight);
        paint.setColor(SK_ColorWHITE);
        canvas->drawLine(SkIntToScalar(x), SkIntToScalar(startY),
                         SkIntToScalar(x), SkIntToScalar(endY), paint);
        totalTime += fTotalTimes[i];
        if (fTotalTimes[i] > 0) {
            ++totalCount;
        }
 
        if (inc > 0) {
            ++count;
        }
 
        i++;
        i &= (kMeasurementCount - 1);  // fast mod
        x += xStep;
    } while (i != nextMeasurement);
 
    SkFont font(ToolUtils::CreatePortableTypeface("sans-serif", SkFontStyle()), 16);
    paint.setColor(SK_ColorWHITE);
    double time = totalTime / std::max(1, totalCount);
    double measure = fCumulativeMeasurementTime / std::max(1, fCumulativeMeasurementCount);
    canvas->drawString(SkStringPrintf("%4.3f ms -> %4.3f ms", time, measure),
                       rect.fLeft + 3, rect.fTop + 14, font, paint);
 
    for (int timer = 0; timer < fTimers.size(); ++timer) {
        paint.setColor(fTimers[timer].fLabelColor);
        canvas->drawString(SkStringPrintf("%s: %4.3f ms", fTimers[timer].fLabel.c_str(),
                                          sumTimes[timer] / std::max(1, count)),
                           rect.fLeft + 3, rect.fTop + 28 + (14 * timer), font, paint);
    }
 
    canvas->restore();
}

onPrePaint()

void StatsLayer::onPrePaint ( )

overridevirtual

Reimplemented from sk_app::Window::Layer.

Definition at line 71 of file StatsLayer.cpp.

                            {
    if (fCurrentMeasurement >= 0) {
        fTotalTimes[fCurrentMeasurement] = SkTime::GetMSecs() - fLastTotalBegin;
        fCumulativeMeasurementTime += fTotalTimes[fCurrentMeasurement];
        fCumulativeMeasurementCount++;
    }
    fCurrentMeasurement = (fCurrentMeasurement + 1) & (kMeasurementCount - 1);
    SkASSERT(fCurrentMeasurement >= 0 && fCurrentMeasurement < kMeasurementCount);
    fLastTotalBegin = SkTime::GetMSecs();
}

resetMeasurements()

void StatsLayer::resetMeasurements

(

)

Definition at line 38 of file StatsLayer.cpp.

                                   {
    for (int i = 0; i < fTimers.size(); ++i) {
        memset(fTimers[i].fTimes, 0, sizeof(fTimers[i].fTimes));
    }
    memset(fTotalTimes, 0, sizeof(fTotalTimes));
    fCurrentMeasurement = -1;
    fLastTotalBegin = 0;
    fCumulativeMeasurementTime = 0;
    fCumulativeMeasurementCount = 0;
}

setDisplayScale()

void StatsLayer::setDisplayScale ( float  scale )

inline

Definition at line 32 of file StatsLayer.h.

{ fDisplayScale = scale; }

---

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

• third_party/skia/tools/viewer/StatsLayer.h
• third_party/skia/tools/viewer/StatsLayer.cpp