flutter::DlStopwatchVisualizer Class Reference

#include <stopwatch_dl.h>

Inheritance diagram for flutter::DlStopwatchVisualizer:

Public Member Functions
	DlStopwatchVisualizer (const Stopwatch &stopwatch)
void	Visualize (DlCanvas *canvas, const SkRect &rect) const override
	Renders the stopwatch as a graph.
Public Member Functions inherited from flutter::StopwatchVisualizer
	StopwatchVisualizer (const Stopwatch &stopwatch)
virtual	~StopwatchVisualizer ()=default
	FML_DISALLOW_COPY_AND_ASSIGN (StopwatchVisualizer)

Additional Inherited Members
Protected Member Functions inherited from flutter::StopwatchVisualizer
double	UnitFrameInterval (double time_ms) const
	Converts a raster time to a unit interval.
double	UnitHeight (double time_ms, double max_height) const
	Converts a raster time to a unit height.
fml::Milliseconds	GetFrameBudget () const
Protected Attributes inherited from flutter::StopwatchVisualizer
const Stopwatch &	stopwatch_
fml::Milliseconds	frame_budget_

Detailed Description

A stopwatch visualizer that uses DisplayList (|DlCanvas|) to draw.

Note

This is the newer non-backend specific version, that works in both Skia and Impeller. The older Skia-specific version is |SkStopwatchVisualizer|, which still should be used for Skia-specific optimizations.

Definition at line 19 of file stopwatch_dl.h.

Constructor & Destructor Documentation

DlStopwatchVisualizer()

flutter::DlStopwatchVisualizer::DlStopwatchVisualizer ( const Stopwatch &  stopwatch )

inlineexplicit

Definition at line 21 of file stopwatch_dl.h.

      : StopwatchVisualizer(stopwatch) {}

Member Function Documentation

Visualize()

void flutter::DlStopwatchVisualizer::Visualize ( DlCanvas *  canvas, const SkRect &  rect  ) const

overridevirtual

Renders the stopwatch as a graph.

Parameters

	canvas	The canvas to draw on.
[in]	rect	The rectangle to draw in.

Implements flutter::StopwatchVisualizer.

Definition at line 20 of file stopwatch_dl.cc.

                                                                {
  auto painter = DlVertexPainter();
  DlPaint paint;
 
  // Establish the graph position.
  auto const x = rect.x();
  auto const y = rect.y();
  auto const width = rect.width();
  auto const height = rect.height();
  auto const bottom = rect.bottom();
 
  // Scale the graph to show time frames up to those that are 3x the frame time.
  auto const one_frame_ms = GetFrameBudget().count();
  auto const max_interval = one_frame_ms * 3.0;
  auto const max_unit_interval = UnitFrameInterval(max_interval);
  auto const sample_unit_width = (1.0 / kMaxSamples);
 
  // Provide a semi-transparent background for the graph.
  painter.DrawRect(rect, DlColor(0x99FFFFFF));
 
  // Prepare a path for the data; we start at the height of the last point so
  // it looks like we wrap around.
  {
    for (auto i = size_t(0); i < stopwatch_.GetLapsCount(); i++) {
      auto const sample_unit_height =
          (1.0 - UnitHeight(stopwatch_.GetLap(i).ToMillisecondsF(),
                            max_unit_interval));
 
      auto const bar_width = width * sample_unit_width;
      auto const bar_height = height * sample_unit_height;
      auto const bar_left = x + width * sample_unit_width * i;
 
      painter.DrawRect(SkRect::MakeLTRB(/*l=*/bar_left,
                                        /*t=*/y + bar_height,
                                        /*r=*/bar_left + bar_width,
                                        /*b=*/bottom),
                       DlColor(0xAA0000FF));
    }
  }
 
  // Draw horizontal frame markers.
  {
    if (max_interval > one_frame_ms) {
      // Paint the horizontal markers.
      auto count = static_cast<size_t>(max_interval / one_frame_ms);
 
      // Limit the number of markers to a reasonable amount.
      if (count > kMaxFrameMarkers) {
        count = 1;
      }
 
      for (auto i = size_t(0); i < count; i++) {
        auto const frame_height =
            height * (1.0 - (UnitFrameInterval(i + 1) * one_frame_ms) /
                                max_unit_interval);
 
        // Draw a skinny rectangle (i.e. a line).
        painter.DrawRect(SkRect::MakeLTRB(/*l=*/x,
                                          /*t=*/y + frame_height,
                                          /*r=*/width,
                                          /*b=*/y + frame_height + 1),
                         DlColor(0xCC000000));
      }
    }
  }
 
  // Paint the vertical marker for the current frame.
  {
    DlColor color = DlColor::kGreen();
    if (UnitFrameInterval(stopwatch_.LastLap().ToMillisecondsF()) > 1.0) {
      // budget exceeded.
      color = DlColor::kRed();
    }
    auto const l =
        x + width * (static_cast<double>(stopwatch_.GetCurrentSample()) /
                     kMaxSamples);
    auto const t = y;
    auto const r = l + width * sample_unit_width;
    auto const b = rect.bottom();
    painter.DrawRect(SkRect::MakeLTRB(l, t, r, b), color);
  }
 
  // Actually draw.
  // Use kSrcOver blend mode so that elements under the performance overlay are
  // partially visible.
  paint.setBlendMode(DlBlendMode::kSrcOver);
  // The second blend mode does nothing since the paint has no additional color
  // sources like a tiled image or gradient.
  canvas->DrawVertices(painter.IntoVertices(), DlBlendMode::kSrcOver, paint);
}

---

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

• flow/stopwatch_dl.h
• flow/stopwatch_dl.cc