flutter::SkStopwatchVisualizer Class Reference

#include <stopwatch_sk.h>

Inheritance diagram for flutter::SkStopwatchVisualizer:

Public Member Functions
	SkStopwatchVisualizer (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 Skia (|SkCanvas|) to draw the stopwatch.

See also

DlStopwatchVisualizer for the newer non-backend specific version.

Definition at line 17 of file stopwatch_sk.h.

Constructor & Destructor Documentation

SkStopwatchVisualizer()

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

inlineexplicit

Definition at line 19 of file stopwatch_sk.h.

      : StopwatchVisualizer(stopwatch) {}

Member Function Documentation

Visualize()

void flutter::SkStopwatchVisualizer::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 88 of file stopwatch_sk.cc.

                                                                {
  // Initialize visualize cache if it has not yet been initialized.
  InitVisualizeSurface(SkISize::Make(rect.width(), rect.height()));
 
  SkCanvas* cache_canvas = visualize_cache_surface_->getCanvas();
  SkPaint paint;
 
  // Establish the graph position.
  const SkScalar x = 0;
  const SkScalar y = 0;
  const SkScalar width = visualize_cache_surface_->width();
  const SkScalar height = visualize_cache_surface_->height();
 
  // Scale the graph to show frame times up to those that are 3 times the frame
  // time.
  const double one_frame_ms = GetFrameBudget().count();
  const double max_interval = one_frame_ms * 3.0;
  const double max_unit_interval = UnitFrameInterval(max_interval);
 
  const double sample_unit_width = (1.0 / kMaxSamples);
 
  // Draw vertical replacement bar to erase old/stale pixels.
  paint.setColor(0x99FFFFFF);
  paint.setStyle(SkPaint::Style::kFill_Style);
  paint.setBlendMode(SkBlendMode::kSrc);
  double sample_x =
      x + width * (static_cast<double>(prev_drawn_sample_index_) / kMaxSamples);
  const auto eraser_rect = SkRect::MakeLTRB(
      sample_x, y, sample_x + width * sample_unit_width, height);
  cache_canvas->drawRect(eraser_rect, paint);
 
  // Draws blue timing bar for new data.
  paint.setColor(0xAA0000FF);
  paint.setBlendMode(SkBlendMode::kSrcOver);
  const auto bar_rect = SkRect::MakeLTRB(
      sample_x,
      y + height *
              (1.0 -
               UnitHeight(stopwatch_
                              .GetLap(stopwatch_.GetCurrentSample() == 0
                                          ? kMaxSamples - 1
                                          : stopwatch_.GetCurrentSample() - 1)
                              .ToMillisecondsF(),
                          max_unit_interval)),
      sample_x + width * sample_unit_width, height);
  cache_canvas->drawRect(bar_rect, paint);
 
  // Draw horizontal frame markers.
  paint.setStrokeWidth(0);  // hairline
  paint.setStyle(SkPaint::Style::kStroke_Style);
  paint.setColor(0xCC000000);
 
  if (max_interval > one_frame_ms) {
    // Paint the horizontal markers
    size_t frame_marker_count =
        static_cast<size_t>(max_interval / one_frame_ms);
 
    // Limit the number of markers displayed. After a certain point, the graph
    // becomes crowded
    if (frame_marker_count > kMaxFrameMarkers) {
      frame_marker_count = 1;
    }
 
    for (size_t frame_index = 0; frame_index < frame_marker_count;
         frame_index++) {
      const double frame_height =
          height * (1.0 - (UnitFrameInterval((frame_index + 1) * one_frame_ms) /
                           max_unit_interval));
      cache_canvas->drawLine(x, y + frame_height, width, y + frame_height,
                             paint);
    }
  }
 
  // Paint the vertical marker for the current frame.
  // We paint it over the current frame, not after it, because when we
  // paint this we don't yet have all the times for the current frame.
  paint.setStyle(SkPaint::Style::kFill_Style);
  paint.setBlendMode(SkBlendMode::kSrcOver);
  if (UnitFrameInterval(stopwatch_.LastLap().ToMillisecondsF()) > 1.0) {
    // budget exceeded
    paint.setColor(SK_ColorRED);
  } else {
    // within budget
    paint.setColor(SK_ColorGREEN);
  }
  sample_x = x + width * (static_cast<double>(stopwatch_.GetCurrentSample()) /
                          kMaxSamples);
  const auto marker_rect = SkRect::MakeLTRB(
      sample_x, y, sample_x + width * sample_unit_width, height);
  cache_canvas->drawRect(marker_rect, paint);
  prev_drawn_sample_index_ = stopwatch_.GetCurrentSample();
 
  // Draw the cached surface onto the output canvas.
  auto image = DlImage::Make(visualize_cache_surface_->makeImageSnapshot());
  canvas->DrawImage(image, {rect.x(), rect.y()},
                    DlImageSampling::kNearestNeighbor);
}

---

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

• flow/stopwatch_sk.h
• flow/stopwatch_sk.cc