flutter::DlStopwatchVisualizer Class Reference

#include <stopwatch_dl.h>

Inheritance diagram for flutter::DlStopwatchVisualizer:

Public Member Functions
	DlStopwatchVisualizer (const Stopwatch &stopwatch, std::vector< DlPoint > &vertices_storage, std::vector< DlColor > &color_storage)
void	Visualize (DlCanvas *canvas, const DlRect &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, std::vector< DlPoint > &  vertices_storage, std::vector< DlColor > &  color_storage  )

inlineexplicit

Definition at line 21 of file stopwatch_dl.h.

      : StopwatchVisualizer(stopwatch),
        vertices_storage_(vertices_storage),
        color_storage_(color_storage) {}

Member Function Documentation

Visualize()

void flutter::DlStopwatchVisualizer::Visualize ( DlCanvas *  canvas, const DlRect &  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 21 of file stopwatch_dl.cc.

                                                                {
  DlVertexPainter painter(vertices_storage_, color_storage_);
  DlPaint paint;
 
  // Establish the graph position.
  const DlScalar x = rect.GetX();
  const DlScalar y = rect.GetY();
  const DlScalar width = rect.GetWidth();
  const DlScalar height = rect.GetHeight();
  const DlScalar bottom = rect.GetBottom();
 
  // Scale the graph to show time frames up to those that are 3x the frame time.
  const DlScalar one_frame_ms = GetFrameBudget().count();
  const DlScalar max_interval = one_frame_ms * 3.0;
  const DlScalar max_unit_interval = UnitFrameInterval(max_interval);
  const DlScalar sample_unit_width = width / kMaxSamples;
 
  // resize backing storage to match expected lap count.
  size_t required_storage =
      (stopwatch_.GetLapsCount() + 2 + kMaxFrameMarkers) * 6;
  if (vertices_storage_.size() < required_storage) {
    vertices_storage_.resize(required_storage);
    color_storage_.resize(required_storage);
  }
 
  // 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.
  {
    DlScalar bar_left = x;
    for (size_t i = 0u; i < stopwatch_.GetLapsCount(); i++) {
      const double time_ms = stopwatch_.GetLap(i).ToMillisecondsF();
      const DlScalar sample_unit_height = static_cast<DlScalar>(
          height * UnitHeight(time_ms, max_unit_interval));
 
      const DlScalar bar_top = bottom - sample_unit_height;
      const DlScalar bar_right = x + (i + 1) * sample_unit_width;
 
      painter.DrawRect(DlRect::MakeLTRB(/*left=*/bar_left,
                                        /*top=*/bar_top,
                                        /*right=*/bar_right,
                                        /*bottom=*/bottom),
                       DlColor(0xAA0000FF));
      bar_left = bar_right;
    }
  }
 
  // Draw horizontal frame markers.
  {
    if (max_interval > one_frame_ms) {
      // Paint the horizontal markers.
      size_t 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 (uint32_t i = 0u; i < count; i++) {
        const DlScalar frame_height =
            height * (1.0 - (UnitFrameInterval(i + 1) * one_frame_ms) /
                                max_unit_interval);
 
        // Draw a skinny rectangle (i.e. a line).
        painter.DrawRect(DlRect::MakeLTRB(/*left=*/x,
                                          /*top=*/y + frame_height,
                                          /*right=*/x + width,
                                          /*bottom=*/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();
    }
    size_t sample =
        (stopwatch_.GetCurrentSample() + 1) % stopwatch_.GetLapsCount();
    const DlScalar l = x + sample * sample_unit_width;
    const DlScalar t = y;
    const DlScalar r = l + sample_unit_width;
    const DlScalar b = rect.GetBottom();
    painter.DrawRect(DlRect::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(rect), DlBlendMode::kSrcOver,
                       paint);
}

References flutter::DlVertexPainter::DrawRect(), flutter::DlCanvas::DrawVertices(), impeller::TRect< T >::GetBottom(), flutter::Stopwatch::GetCurrentSample(), flutter::StopwatchVisualizer::GetFrameBudget(), impeller::TRect< T >::GetHeight(), flutter::Stopwatch::GetLap(), flutter::Stopwatch::GetLapsCount(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), height, i, flutter::DlVertexPainter::IntoVertices(), flutter::DlColor::kGreen(), flutter::kMaxFrameMarkers, flutter::kMaxSamples, flutter::DlColor::kRed(), flutter::Stopwatch::LastLap(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlPaint::setBlendMode(), flutter::StopwatchVisualizer::stopwatch_, fml::TimeDelta::ToMillisecondsF(), flutter::StopwatchVisualizer::UnitFrameInterval(), flutter::StopwatchVisualizer::UnitHeight(), width, x, and y.

---

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

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